?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge from development branch heightmap to main.
[scorched3d.git] / src / client / water / Water2Renderer.cpp
blobb830d5e84c653bff2b2d0343479a7fee1a6f0d6f
1 ////////////////////////////////////////////////////////////////////////////////
2 // Scorched3D (c) 2000-2004
3 //
4 // This file is part of Scorched3D.
5 //
6 // Scorched3D is free software; you can redistribute it and/or modify
7 // it under the terms of the GNU General Public License as published by
8 // the Free Software Foundation; either version 2 of the License, or
9 // (at your option) any later version.
10 //
11 // Scorched3D is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
15 //
16 // You should have received a copy of the GNU General Public License
17 // along with Scorched3D; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 ////////////////////////////////////////////////////////////////////////////////
20
21 #include <water/Water2Renderer.h>
22 #include <water/Water2.h>
23 #include <water/WaterMapPoints.h>
24 #include <water/WaterWaves.h>
25 #include <common/Vector4.h>
26 #include <image/ImageFactory.h>
27 #include <image/ImageFactory.h>
28 #include <GLEXT/GLStateExtension.h>
29 #include <GLEXT/GLCamera.h>
30 #include <GLEXT/GLTextureCubeMap.h>
31 #include <client/ScorchedClient.h>
32 #include <sky/Sky.h>
33 #include <land/VisibilityPatchGrid.h>
34 #include <landscapemap/LandscapeMaps.h>
35 #include <landscapedef/LandscapeTex.h>
36 #include <landscapedef/LandscapeDefn.h>
37 #include <landscape/Landscape.h>
38 #include <graph/MainCamera.h>
39 #include <graph/OptionsDisplay.h>
40
41 #include <water/Water2Constants.h>
42
43 Water2Renderer::Water2Renderer() :
44 waterShader_(0),
45 currentPatch_(0), totalTime_(0.0f),
46 noShaderWaterTexture_(0)
47 {
48 }
49
50 Water2Renderer::~Water2Renderer()
51 {
52 }
53
54 void Water2Renderer::simulate(float frameTime)
55 {
56 totalTime_ += frameTime * 24.0f;
57 }
58
59 void Water2Renderer::draw(Water2 &water2, WaterMapPoints &points, WaterWaves &waves)
60 {
61 GAMESTATE_PERF_COUNTER_START(ScorchedClient::instance()->getGameState(), "WATER_PATCHSETUP");
62 // Choose correct water frame
63 Water2Patches &currentPatch = water2.getPatch(totalTime_);
64 if (&currentPatch != currentPatch_)
65 {
66 currentPatch_ = &currentPatch;
67
68 // Set the normal map for the current water frame
69 if (GLStateExtension::hasShaders() &&
70 !OptionsDisplay::instance()->getNoWaterMovement() &&
71 !OptionsDisplay::instance()->getSimpleWaterShaders())
72 {
73 normalTexture_.replace(currentPatch_->getNormalMap(),
74 GLStateExtension::hasHardwareMipmaps());
75 }
76 }
77 GAMESTATE_PERF_COUNTER_END(ScorchedClient::instance()->getGameState(), "WATER_PATCHSETUP");
78
79 // Draw waves
80 GAMESTATE_PERF_COUNTER_START(ScorchedClient::instance()->getGameState(), "WATER_WAVES");
81 waves.draw(*currentPatch_);
82 GAMESTATE_PERF_COUNTER_END(ScorchedClient::instance()->getGameState(), "WATER_WAVES");
83
84 // Draw Water
85 if (GLStateExtension::hasShaders() &&
86 OptionsDisplay::instance()->getUseWaterTexture())
87 {
88 drawWaterShaders(water2);
89 }
90 else
91 {
92 drawWaterNoShaders(water2);
93 }
94
95 GAMESTATE_PERF_COUNTER_START(ScorchedClient::instance()->getGameState(), "WATER_DRAWPOINTS");
96 drawPoints(points);
97 GAMESTATE_PERF_COUNTER_END(ScorchedClient::instance()->getGameState(), "WATER_DRAWPOINTS");
98 }
99
100 void Water2Renderer::drawPoints(WaterMapPoints &points)
101 {
102 if (!currentPatch_) return;
103
104 // Draw Points
105 points.draw(*currentPatch_);
106 }
107
108 void Water2Renderer::drawWaterShaders(Water2 &water2)
109 {
110 GLState state(GLState::LIGHTING_OFF | GLState::TEXTURE_ON | GLState::BLEND_ON);
111
112 glPushAttrib(GL_ALL_ATTRIB_BITS);
113
114 Vector cameraPos = GLCamera::getCurrentCamera()->getCurrentPos();
115 cameraPos[2] = -waterHeight_;
116 waterShader_->use();
117 waterShader_->set_uniform("viewpos", cameraPos);
118
119 // Tex 3
120 if (!OptionsDisplay::instance()->getSimpleWaterShaders())
121 {
122 waterShader_->set_gl_texture(currentPatch_->getAOF(), "tex_foamamount", 3);
123 }
124
125 // Tex 2
126 if (Landscape::instance()->getShadowFrameBuffer().bufferValid())
127 {
128 glActiveTextureARB(GL_TEXTURE2_ARB);
129 glEnable(GL_TEXTURE_2D);
130 waterShader_->set_gl_texture(Landscape::instance()->getShadowFrameBuffer(),
131 "tex_shadow", 2);
132 glMatrixMode(GL_TEXTURE);
133 glLoadMatrixf(Landscape::instance()->getShadowTextureMatrix());
134 glMatrixMode(GL_MODELVIEW);
135 }
136
137 // texture units / coordinates:
138 // tex0: noise map (color normals) / matching texcoords
139 // tex1: reflection map / matching texcoords
140 // tex2: foam
141 // tex3: amount of foam
142
143 // set up scale/translation of foam and noise maps
144 // we do not use the texture matrix here, as this would be overkill
145 // and would be clumsy
146
147 // need to divide by noise tile size here too (tex coordinates are in [0...1], not meters)
148 Vector D_0 = windDir1_ * (windSpeed1_ / (-64.0f * 6.0f)); // noise tile is 256/8=32m long
149 Vector D_1 = windDir2_ * (windSpeed2_ / (-16.0f * 6.0f)); // noise tile is 256/32=8m long
150
151 float mytime = totalTime_ / 24.0f;
152 Vector noise_0_pos = D_0 * mytime;
153 Vector noise_1_pos = D_1 * mytime;
154 noise_0_pos[2] = wavetile_length_rcp * 8.0f;
155 noise_1_pos[2] = wavetile_length_rcp * 32.0f;
156
157 //fixme: do we have to treat the viewer offset here, like with tex matrix
158 // setup below?!
159
160 // Tex 0
161 glActiveTextureARB(GL_TEXTURE0);
162 if (!OptionsDisplay::instance()->getSimpleWaterShaders())
163 {
164 waterShader_->set_uniform("noise_xform_0", noise_0_pos);
165 waterShader_->set_uniform("noise_xform_1", noise_1_pos);
166 waterShader_->set_gl_texture(normalTexture_, "tex_normal", 0);
167 }
168
169 const float noisetilescale = 1.0f/32.0f;//meters (128/16=8, 8tex/m).
170 glMatrixMode(GL_TEXTURE);
171 glLoadIdentity();
172 glScalef(noisetilescale, noisetilescale, 1.0f); // fixme adjust scale
173 glMatrixMode(GL_MODELVIEW);
174
175 // Tex 1
176 glActiveTextureARB(GL_TEXTURE1);
177 glEnable(GL_TEXTURE_2D);
178 waterShader_->set_gl_texture(reflectionTexture_, "tex_reflection", 1);
179
180 // Draw Water
181 glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
182 drawWater(water2, waterShader_);
183
184 // Cleanup
185 waterShader_->use_fixed();
186
187 glActiveTextureARB(GL_TEXTURE2);
188 glMatrixMode(GL_TEXTURE);
189 glLoadIdentity();
190 glMatrixMode(GL_MODELVIEW);
191 glDisable(GL_TEXTURE_2D);
192
193 glActiveTextureARB(GL_TEXTURE1);
194 glMatrixMode(GL_TEXTURE);
195 glLoadIdentity();
196 glMatrixMode(GL_MODELVIEW);
197 glDisable(GL_TEXTURE_2D);
198
199 glActiveTextureARB(GL_TEXTURE0);
200 glMatrixMode(GL_TEXTURE);
201 glLoadIdentity();
202 glMatrixMode(GL_MODELVIEW);
203
204 glPopAttrib();
205 }
206
207 void Water2Renderer::drawWaterNoShaders(Water2 &water2)
208 {
209 glPushAttrib(GL_TEXTURE_BIT);
210
211 // Set up texture coordinate generation for reflections
212 static float PlaneS[] = { 0.0f, 1.0f / 20.0f, 0.0f, 0.0f };
213 static float PlaneT[] = { 1.0f / 20.0f, 0.0f, 0.0f, 0.0f };
214
215 if (GLStateExtension::hasMultiTex() &&
216 OptionsDisplay::instance()->getUseWaterTexture())
217 {
218 // Set up texture coordinate generation for base texture
219 glActiveTextureARB(GL_TEXTURE1);
220 glEnable(GL_TEXTURE_2D);
221 glEnable(GL_TEXTURE_GEN_S);
222 glEnable(GL_TEXTURE_GEN_T);
223 glTexGenf(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
224 glTexGenf(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
225 glTexGenfv(GL_S, GL_OBJECT_PLANE, PlaneS);
226 glTexGenfv(GL_T, GL_OBJECT_PLANE, PlaneT);
227 reflectionTexture_.draw(true);
228
229 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
230 glTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE_ARB, 2);
231
232 glActiveTextureARB(GL_TEXTURE0);
233
234
235 glColor4f(0.3f, 0.3f, 0.3f, 0.8f);
236 }
237 else
238 {
239 glColor4f(0.7f, 0.7f, 0.7f, 0.8f);
240 }
241
242 // Turn lighting on (if enabled)
243 unsigned int state = 0;
244 if (!OptionsDisplay::instance()->getNoModelLighting())
245 {
246 state =
247 GLState::LIGHTING_ON |
248 GLState::LIGHT1_ON;
249
250 Vector4 ambientColor(0.2f, 0.2f, 0.2f, 0.8f);
251 Vector4 diffuseColor(0.8f, 0.8f, 0.8f, 0.8f);
252 Vector4 specularColor(1.0f, 1.0f, 1.0f, 0.8f);
253 Vector4 emissiveColor(0.0f, 0.0f, 0.0f, 0.8f);
254 float shininess = 100.0f;
255 glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, ambientColor);
256 glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, diffuseColor);
257 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specularColor);
258 glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, emissiveColor);
259 glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, shininess);
260
261 Landscape::instance()->getSky().getSun().setLightPosition();
262 }
263
264 if (!OptionsDisplay::instance()->getUseWaterTexture())
265 {
266 GLState currentState(GLState::LIGHTING_OFF | GLState::TEXTURE_OFF);
267 glColor3f(0.0f, 0.3f, 1.0f);
268 drawWater(water2, 0);
269 }
270 else if (GLStateExtension::hasCubeMap())
271 {
272 GLState currentState(state | GLState::TEXTURE_OFF | GLState::BLEND_ON | GLState::CUBEMAP_ON);
273
274 // Set up texture coordinate generation for cubemap reflections
275 glEnable(GL_TEXTURE_GEN_S);
276 glEnable(GL_TEXTURE_GEN_T);
277 glEnable(GL_TEXTURE_GEN_R);
278 glTexGenf(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_EXT);
279 glTexGenf(GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_EXT);
280 glTexGenf(GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_EXT);
281
282 drawWater(water2, 0);
283 }
284 else if (GLStateExtension::hasSphereMap())
285 {
286 GLState currentState(state | GLState::TEXTURE_ON | GLState::BLEND_ON);
287 noShaderWaterTexture_->draw();
288
289 // Set up texture coordinate generation for spheremap reflections
290 glEnable(GL_TEXTURE_GEN_S);
291 glEnable(GL_TEXTURE_GEN_T);
292 glEnable(GL_TEXTURE_GEN_R);
293 glTexGenf(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
294 glTexGenf(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
295 glTexGenf(GL_R, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
296
297 drawWater(water2, 0);
298 }
299 else
300 {
301 GLState currentState(state | GLState::TEXTURE_ON | GLState::BLEND_ON);
302 noShaderWaterTexture_->draw();
303
304 // Set up texture coordinate generation for linear reflections
305 glEnable(GL_TEXTURE_GEN_S);
306 glEnable(GL_TEXTURE_GEN_T);
307 glTexGenf(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
308 glTexGenf(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
309 glTexGenfv(GL_S, GL_OBJECT_PLANE, PlaneS);
310 glTexGenfv(GL_T, GL_OBJECT_PLANE, PlaneT);
311
312 drawWater(water2, 0);
313 }
314
315 if (GLStateExtension::hasMultiTex())
316 {
317 glActiveTextureARB(GL_TEXTURE1);
318 glDisable(GL_TEXTURE_GEN_S);
319 glDisable(GL_TEXTURE_GEN_T);
320 glDisable(GL_TEXTURE_GEN_R);
321 glDisable(GL_TEXTURE_2D);
322
323 glActiveTextureARB(GL_TEXTURE0);
324 glDisable(GL_TEXTURE_GEN_S);
325 glDisable(GL_TEXTURE_GEN_T);
326 glDisable(GL_TEXTURE_GEN_R);
327 }
328
329 glPopAttrib();
330 }
331
332 void Water2Renderer::drawWater(Water2 &water2, GLSLShaderSetup *waterShader)
333 {
334 // Draw Water
335 Vector &cameraPos = GLCamera::getCurrentCamera()->getCurrentPos();
336 VisibilityPatchGrid::instance()->drawWater(
337 *currentPatch_, water2.getIndexs(), cameraPos, landscapeSize_, waterShader);
338 }
339
340 void Water2Renderer::generate(LandscapeTexBorderWater *water, ProgressCounter *counter)
341 {
342 currentPatch_ = 0;
343 if (GLStateExtension::hasShaders())
344 {
345 // Load shaders
346 if (!waterShader_)
347 {
348 GLSLShader::defines_list dl;
349 if (Landscape::instance()->getShadowFrameBuffer().bufferValid())
350 {
351 dl.push_back("USE_SHADOWS");
352 }
353
354 if (OptionsDisplay::instance()->getSimpleWaterShaders())
355 {
356 waterShader_ = new GLSLShaderSetup(
357 S3D::getDataFile("data/shaders/watersimple.vshader"),
358 S3D::getDataFile("data/shaders/watersimple.fshader"),
359 dl);
360 }
361 else
362 {
363 waterShader_ = new GLSLShaderSetup(
364 S3D::getDataFile("data/shaders/water.vshader"),
365 S3D::getDataFile("data/shaders/water.fshader"),
366 dl);
367 }
368 }
369 }
370
371 // Set the water height
372 waterHeight_ = water->height.asFloat();
373
374 // fixme: color depends also on weather. bad weather -> light is less bright
375 // so this will be computed implicitly. Environment can also change water color
376 // (light blue in tropic waters), water depth also important etc.
377 // this depends on sky color...
378 // good weather
379 // color wavetop = color(color(10, 10, 10), color(18, 93, 77), light_brightness);
380 // color wavebottom = color(color(10, 10, 20), color(18, 73, 107), light_brightness);
381 // rather bad weather
382 //fixme: multiply with light color here, not only light brightness.
383 //dim yellow light should result in dim yellow-green upwelling color, not dim green.
384 Vector4 light_color(water->wavelight, 1.0f);
385 Vector4 wavetopA(water->wavetopa, 0.0f);
386 Vector4 wavetopB(water->wavetopb, 0.0f);
387 Vector4 wavebottomA(water->wavebottoma, 0.0f);
388 Vector4 wavebottomB(water->wavebottomb, 0.0f);
389 Vector4 wavetop = light_color.lerp(wavetopA, wavetopB);
390 Vector4 wavebottom = light_color.lerp(wavebottomA, wavebottomB);
391
392 // Create textures
393 if (GLStateExtension::hasFBO() &&
394 GLStateExtension::hasShaders() &&
395 !OptionsDisplay::instance()->getNoWaterReflections())
396 {
397 reflectionTexture_.createBufferTexture(512, 512, false);
398 reflectionBuffer_.create(reflectionTexture_, true);
399 }
400 else
401 {
402 ImageHandle loadedBitmapWater =
403 ImageFactory::loadImageHandle(S3D::getDataFile(water->texture.c_str()));
404 ImageHandle bitmapWater2 = loadedBitmapWater.createResize(128, 128);
405 reflectionTexture_.create(bitmapWater2, true); // Not the reflection in this case
406 }
407
408 ImageHandle map = ImageFactory::createBlank(128, 128, false, 0);
409 normalTexture_.create(map, GLStateExtension::hasHardwareMipmaps());
410
411 LandscapeDefn &defn = *ScorchedClient::instance()->getLandscapeMaps().
412 getDefinitions().getDefn();
413 landscapeSize_ = Vector(defn.getLandscapeWidth(), defn.getLandscapeHeight());
414
415 if (GLStateExtension::hasShaders())
416 {
417 Vector upwelltop(wavetop[0], wavetop[1], wavetop[2]);
418 Vector upwellbot(wavebottom[0], wavebottom[1], wavebottom[2]);
419 Vector upwelltopbot = upwelltop - upwellbot;
420
421 waterShader_->use();
422 waterShader_->set_uniform("upwelltop", upwelltop);
423 waterShader_->set_uniform("upwellbot", upwellbot);
424 waterShader_->set_uniform("upwelltopbot", upwelltopbot);
425 if (!OptionsDisplay::instance()->getSimpleWaterShaders())
426 {
427 Vector landfoam;
428 waterShader_->set_uniform("landfoam", landfoam);
429 waterShader_->set_uniform("landscape_size", landscapeSize_);
430 }
431 waterShader_->use_fixed();
432 }
433 else
434 {
435 // Load the water reflection bitmap
436 // Create water cubemap texture
437 ImageHandle loadedBitmapWater =
438 ImageFactory::loadImageHandle(S3D::getDataFile(water->reflection.c_str()));
439 ImageHandle bitmapWater2 = loadedBitmapWater.createResize(256, 256);
440 delete noShaderWaterTexture_;
441 if (GLStateExtension::hasCubeMap())
442 {
443 GLTextureCubeMap *waterCubeMap = new GLTextureCubeMap();
444 waterCubeMap->create(bitmapWater2, false);
445 noShaderWaterTexture_ = waterCubeMap;
446 }
447 else
448 {
449 GLTexture *waterNormalMap = new GLTexture();
450 waterNormalMap->create(bitmapWater2, false);
451 noShaderWaterTexture_ = waterNormalMap;
452 }
453 }
454
455 // Setup wind dir/speed
456 windSpeed1_ = ScorchedClient::instance()->
457 getOptionsTransient().getWindSpeed().asFloat() * 2.0f + 3.0f;
458 windDir1_ = ScorchedClient::instance()->
459 getOptionsTransient().getWindDirection().asVector();
460 windDir1_[2] = 0.0f;
461 windSpeed2_ = MAX(0.0f, RAND * 2.0f - 1.0f + windSpeed1_);
462 windDir2_ = Vector(windDir1_[0] + RAND * 0.4f - 0.2f,
463 windDir1_[1] + RAND * 0.4f - 0.2f);
464 windDir1_.StoreNormalize();
465 windDir2_.StoreNormalize();
466 }
Scorched3D git-svn mirror ("/trunk/scorched" only)