stuff
[carveJwlIkooP6JGAAIwe30JlM.git] / water.h
1 #include "common.h"
2 #include "model.h"
3
4 static void water_register(void);
5 static void water_init(void);
6 static void water_fb_resize(void);
7 static void water_compute_depth( boxf bounds );
8 static void water_set_surface( glmesh *surf, float height );
9 static float water_height(void);
10
11 #ifndef WATER_H
12 #define WATER_H
13
14 #include "world.h"
15 #include "render.h"
16 #include "shaders/water.h"
17 #include "scene.h"
18
19 vg_tex2d tex_water_surf = { .path = "textures/water_surf.qoi" };
20
21 static struct
22 {
23 struct framebuffer fbreflect, fbdepth;
24 glmesh mdl;
25
26 GLuint depthmap;
27 boxf depthbounds;
28 int depth_computed;
29
30 float height;
31 int enabled;
32 }
33 wrender =
34 {
35 .fbreflect = { .format = GL_RGB, .div = 2 },
36 .fbdepth = { .format = GL_RGBA, .div = 2 }
37 };
38
39 static float water_height(void)
40 {
41 return wrender.height;
42 }
43
44 static void water_register(void)
45 {
46 shader_water_register();
47 }
48
49 static void water_init(void)
50 {
51 /* TODO: probably dont do this every time */
52 wrender.enabled = 1;
53
54 fb_init( &wrender.fbreflect );
55 fb_init( &wrender.fbdepth );
56 }
57
58 static void water_fb_resize(void)
59 {
60 if( !wrender.enabled )
61 return;
62
63 fb_resize( &wrender.fbreflect );
64 fb_resize( &wrender.fbdepth );
65 }
66
67 static void water_compute_depth( boxf bounds )
68 {
69 if( !wrender.enabled )
70 return;
71
72 #ifdef VG_RELEASE
73 int const kres = 512;
74 #else
75 int const kres = 64;
76 #endif
77
78 vg_info( "Computing depth map\n" );
79 u8 *img = malloc( kres*kres );
80
81 v3f volume;
82 v3_sub( bounds[1], bounds[0], volume );
83 box_copy( bounds, wrender.depthbounds );
84
85 for( int y=0; y<kres; y++ )
86 {
87 for( int x=0; x<kres; x++ )
88 {
89 v3f pos = { x, 0, y };
90 v3_divs( pos, kres, pos );
91 v3_muladd( bounds[0], pos, volume, pos );
92 pos[1] = wrender.height;
93
94 ray_hit hit;
95 hit.dist = INFINITY;
96 u8 *dst = &img[ y*kres+x ];
97
98 if( ray_world( pos, (v3f){0.0f,-1.0f,0.0f}, &hit ))
99 {
100 float h = wrender.height - hit.pos[1];
101 h *= 1.0f/15.0f;
102 h = vg_clampf( h, 0.0f, 1.0f );
103 *dst = (u8)(h*255.0f);
104 }
105 else
106 *dst = 0;
107 }
108 }
109
110 if( wrender.depth_computed )
111 glDeleteTextures( 1, &wrender.depthmap );
112
113 glGenTextures( 1, &wrender.depthmap );
114 glBindTexture( GL_TEXTURE_2D, wrender.depthmap );
115 glTexImage2D( GL_TEXTURE_2D, 0, GL_RED, kres, kres, 0,
116 GL_RED, GL_UNSIGNED_BYTE, img );
117
118 vg_tex2d_mipmap();
119 vg_tex2d_linear_mipmap();
120 vg_tex2d_clamp();
121
122 wrender.depth_computed = 1;
123 free( img );
124 vg_success( "Done.\n" );
125 }
126
127 static void water_set_surface( glmesh *surf, float height )
128 {
129 wrender.mdl = *surf;
130 wrender.height = height;
131 }
132
133 static void render_water_texture( m4x3f camera )
134 {
135 if( !wrender.enabled )
136 return;
137
138 /* Draw reflection buffa */
139 fb_use( &wrender.fbreflect );
140 glClear( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT );
141
142 m4x3f new_cam, inverse;
143 v3_copy( camera[3], new_cam[3] );
144 new_cam[3][1] -= 2.0f * (camera[3][1] - wrender.height);
145
146 m3x3f flip;
147 m3x3_identity( flip );
148 flip[1][1] = -1.0f;
149 m3x3_mul( flip, camera, new_cam );
150
151
152 v3f p0;
153 m3x3_mulv( new_cam, (v3f){0.0f,0.0f,-1.0f}, p0 );
154 v3_add( new_cam[3], p0, p0 );
155 vg_line( new_cam[3], p0, 0xffffffff );
156
157 m4x4f view;
158 vg_line_pt3( new_cam[3], 0.3f, 0xff00ffff );
159
160 m4x3_invert_affine( new_cam, inverse );
161 m4x3_expand( inverse, view );
162
163 v4f clippa = { 0.0f, 1.0f, 0.0f, wrender.height-0.1f };
164 m4x3_mulp( inverse, clippa, clippa );
165 clippa[3] *= -1.0f;
166
167 m4x4f projection;
168 m4x4_projection( projection,
169 gpipeline.fov,
170 (float)vg_window_x / (float)vg_window_y,
171 0.1f, 900.0f );
172 plane_clip_projection( projection, clippa );
173 m4x4_mul( projection, view, projection );
174
175 glCullFace( GL_FRONT );
176 render_world( projection, new_cam );
177 glCullFace( GL_BACK );
178
179
180 /* Draw beneath texture */
181 fb_use( &wrender.fbdepth );
182 glClear( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT );
183
184 m4x3_invert_affine( camera, inverse );
185 m4x3_expand( inverse, view );
186
187 v4f clippb = { 0.0f, -1.0f, 0.0f, -(wrender.height) };
188 m4x3_mulp( inverse, clippb, clippb );
189 clippb[3] *= -1.0f;
190
191 float depth_loss = camera[3][1]-wrender.height;
192
193 m4x4_projection( projection,
194 gpipeline.fov,
195 (float)vg_window_x / (float)vg_window_y,
196 0.1f, 900.0f );
197
198 plane_clip_projection( projection, clippb );
199 m4x4_mul( projection, view, projection );
200 render_world( projection, camera );
201
202 glViewport( 0, 0, vg_window_x, vg_window_y );
203 }
204
205 static void render_water_surface( m4x4f pv, m4x3f camera )
206 {
207 if( !wrender.enabled )
208 return;
209
210 /* Draw surface */
211 shader_water_use();
212
213 fb_bindtex( &wrender.fbreflect, 0 );
214 shader_water_uTexMain( 0 );
215
216 vg_tex2d_bind( &tex_water_surf, 1 );
217 shader_water_uTexDudv( 1 );
218 shader_water_uInvRes( (v2f){
219 1.0f / (float)vg_window_x,
220 1.0f / (float)vg_window_y });
221
222 glActiveTexture( GL_TEXTURE2 );
223 glBindTexture( GL_TEXTURE_2D, wrender.depthmap );
224 shader_water_uTexDepth( 2 );
225 shader_water_uDepthBounds( (v4f){
226 wrender.depthbounds[0][0],
227 wrender.depthbounds[0][2],
228 1.0f/ (wrender.depthbounds[1][0]-wrender.depthbounds[0][0]),
229 1.0f/ (wrender.depthbounds[1][2]-wrender.depthbounds[0][2])} );
230
231 fb_bindtex( &wrender.fbdepth, 3 );
232 shader_water_uTexBack( 3 );
233
234 shader_water_uTime( vg_time );
235 shader_water_uCamera( camera[3] );
236 shader_water_uSurfaceY( wrender.height );
237
238 shader_water_uPv( pv );
239
240 m4x3f full;
241 m4x3_identity( full );
242 full[3][1] = wrender.height;
243
244 shader_water_uMdl( full );
245
246 glEnable(GL_BLEND);
247 glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
248 glBlendEquation(GL_FUNC_ADD);
249
250 mesh_bind( &wrender.mdl );
251 mesh_draw( &wrender.mdl );
252
253 glDisable(GL_BLEND);
254 }
255
256 #endif /* WATER_H */