开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
NoiseGenerator.cpp
资源名称：OceanFlame.zip　[点击查看]
上传用户：henghua
上传日期：2007-11-14
资源大小：7655k
文件大小：14k
源码类别：

游戏引擎

开发平台：

Visual C++

NoiseGenerator.cpp：源码内容
  1. #include "NoiseGenerator.h"
  2. #include <xmmintrin.h>
  3. #include <math.h>
  4. #include "tools.h"
  7. CNoiseGenerator::CNoiseGenerator(int sX, int sY, CConfiguration *cfg, const LPDIRECT3DDEVICE9 dev)
  8. {
  9. // 初始化参数
  10. device = dev;
  11. sizeX = sX, sizeY = sY;
  12. config = cfg;
  13. time = 0.0;
  14. lastTime = timeGetTime();
  15. A= 0.3f;
  17. InitializeVertices(); // 初始化顶点场数组
  18. InitializeOriginalNoise(); // 生成原始的噪声场
  19. LoadEffects(); // 加载效果
  20. InitializeTextures(); // 初始化创建纹理
  21. }
  23. // 初始化顶点场数组
  24. void CNoiseGenerator::InitializeVertices()
  25. {
  26. // 先给创建的顶点场数组赋予法向量和纹理坐标
  27. noiseVertices = new SEAVERTEX[sizeX*sizeY];
  28. int v, u;
  29. for(v=0; v<sizeY; v++)
  30. for(u=0; u<sizeX; u++)
  31. {
  32. noiseVertices[v*sizeX + u].nx = 0.0f;
  33. noiseVertices[v*sizeX + u].ny = 1.0f;
  34. noiseVertices[v*sizeX + u].nz = 0.0f;
  35. noiseVertices[v*sizeX + u].tu = (float)u/(sizeX-1);
  36. noiseVertices[v*sizeX + u].tv = (float)v/(sizeY-1);
  37. }
  38. }
  40. // 生成原始的噪声场--16*16*256的三维场
  41. void CNoiseGenerator::InitializeOriginalNoise()
  42. {
  43. float tempNoise[256*256], temp;
  44. int i;
  45. for(int i=0; i<(256*256); i++)
  46. {
  47. temp = (float) rand()/RAND_MAX;
  48. tempNoise[i] = 4*(temp - 0.5f);   // 生成[-2,2]区间内的随机数
  49. }
  51. int frame, v, u;
  52. int v0, v1, v2, u0, u1, u2, f;
  53. for(frame=0; frame<256; frame++)
  54. {
  55. for(v=0; v<16; v++)
  56. {
  57. for(u=0; u<16; u++)
  58. {
  59. v0 = ((v-1)&15)*16,  v1 = v*16,  v2 = ((v+1)&15)*16,  u0 = ((u-1)&15),  u1 = u, u2 = ((u+1)&15),  f  = frame*256;
  61. temp = (1.0f/14.0f) * ( tempNoise[f + v0 + u0] + tempNoise[f + v0 + u1] + tempNoise[f + v0 + u2] + // 进行一次滤波平滑
  62. tempNoise[f + v1 + u0] + 6.0f*tempNoise[f + v1 + u1] + tempNoise[f + v1 + u2] +
  63. tempNoise[f + v2 + u0] + tempNoise[f + v2 + u1] + tempNoise[f + v2 + u2]);
  64.   
  65. OriginalNoise[frame*256 + v*16 + u] = (1<<14)*temp;
  66. }
  67. }
  68. }
  69. }
  71. // 加载效果
  72. void CNoiseGenerator::LoadEffects()
  73. {
  74. char *errortext;
  75. LPD3DXBUFFER errors;
  76. D3DXHANDLE hTechnique;
  78. D3DXCreateEffectFromFile(device, "fx\HeightShader.fx", 
  79. NULL, NULL, 0, NULL, &hMapEffect, &errors );
  81. if (errors != NULL){
  82. errortext = (char*) errors->GetBufferPointer();
  83. MessageBox(NULL, errortext, "hMapEffect", MB_OK);
  84. }
  86. hMapEffect->FindNextValidTechnique(NULL, &hTechnique);    
  87. hMapEffect->SetTechnique(hTechnique);
  89. D3DXCreateEffectFromFile(device, "fx\NormalShader.fx", 
  90. NULL, NULL, 0, NULL, &nMapEffect, &errors );
  92. if (errors != NULL){
  93. errortext = (char*) errors->GetBufferPointer();
  94. MessageBox(NULL, errortext, "nMapEffect", MB_OK);
  95. }
  97. nMapEffect->FindNextValidTechnique(NULL, &hTechnique);    
  98. nMapEffect->SetTechnique(hTechnique);
  99. }
  101. // 初始化创建纹理
  102. void CNoiseGenerator::InitializeTextures()
  103. {
  104. device->CreateTexture(128,128,0,D3DUSAGE_DYNAMIC, D3DFMT_L16, D3DPOOL_DEFAULT, &(LoadedFinalNoise[0]),NULL);
  105. device->CreateTexture(128,128,0,D3DUSAGE_DYNAMIC, D3DFMT_L16, D3DPOOL_DEFAULT, &(LoadedFinalNoise[1]),NULL);
  106. device->CreateTexture(128,128,0,D3DUSAGE_DYNAMIC, D3DFMT_L16, D3DPOOL_DEFAULT, &(trailHeightMap),NULL);
  107. device->CreateTexture(512,1024,1,D3DUSAGE_RENDERTARGET, D3DFMT_A16B16G16R16, D3DPOOL_DEFAULT, &(heightMap),NULL);
  108. device->CreateTexture(512,1024,1,D3DUSAGE_AUTOGENMIPMAP|D3DUSAGE_RENDERTARGET, D3DFMT_A16B16G16R16, D3DPOOL_DEFAULT, &(normalMap),NULL);
  110. device->CreateDepthStencilSurface( 512, 1024, D3DFMT_D24S8, D3DMULTISAMPLE_NONE, 0, true, &depthstencil, NULL );
  111. }
  113. CNoiseGenerator::~CNoiseGenerator()
  114. {
  115. delete [] noiseVertices;
  116. }
  118. bool CNoiseGenerator::UpdateNoise(const D3DXMATRIXA16 *extension, CBoatWave *pWave)
  119. {
  120. TimeGoing(); // 控制时间轴的进度
  121. UpdateTransitionalNoise(); // 更新产生过渡噪声场
  122. UpdateFinalNoise(); // 更新产生最终噪声场
  123. UpdateVerticesCoordinate(extension, pWave); // 更新产生顶点场的坐标, 填满初始化时创建的顶点数组
  124. LoadNoiseToTextures();
  125. LoadTrailToTexture(pWave);
  126. return true;
  127. }
  129. // 控制时间轴的进度
  130. void CNoiseGenerator::TimeGoing()
  131. {
  132. DWORD thisTime = timeGetTime();
  133. double interval = thisTime - lastTime;
  134. static double INTERVAL=0.0;
  135. interval *= 0.0014;
  136. INTERVAL = 0.99*INTERVAL + 0.01 * interval; // 这样控制时间进度可以有效避免因桢间时间差带来的不稳定
  138. lastTime = thisTime;
  139. time += INTERVAL;
  140. }
  142. // 更新产生过渡噪声场--16*16*8的三维场
  143. void CNoiseGenerator::UpdateTransitionalNoise()
  144. {
  145. int i, j, k;
  146. float varyScales[8];
  147. for(i=0; i<8; i++)
  148. {
  149. varyScales[i] = A*powf(0.51f,1.0f*i); // 0.3和0.51的意义，在于总体幅度控制与各幅度尺度层级的控制
  150. }
  152. unsigned int patch[3];
  153. float scope[3];
  154. for(i=0; i<8; i++)
  155. {
  156. double integer, fraction;
  157. fraction = modf(time*pow(1.31, i),&integer); // 1.31的意义，在于各时间尺度层级的控制
  158. int itg = (int)integer;
  159. scope[0] = varyScales[i]*(pow(sin((fraction+2)*D3DX_PI/3),2));
  160. scope[1] = varyScales[i]*(pow(sin((fraction+1)*D3DX_PI/3),2));
  161. scope[2] = varyScales[i]*(pow(sin((fraction)*D3DX_PI/3),2));
  162. patch[0] = (itg) & 255;
  163. patch[1] = (itg+1) & 255;
  164. patch[2] = (itg+2) & 255;
  165. for(j=0; j<256; j++)
  166. {
  167. TransitionalNoise[ j + 256 * i ] = ( ((scope[0] * OriginalNoise[j + 256 * patch[0]])) + 
  168. ((scope[1] * OriginalNoise[j + 256 * patch[1]])) + 
  169. ((scope[2] * OriginalNoise[j + 256 * patch[2]])) ) / 3;
  170. }
  171. }
  172. }
  174. // 更新产生最终噪声场--128*128*2的三维场,即2个片场,其中这两个片的幅度层级一大一小
  175. void CNoiseGenerator::UpdateFinalNoise()
  176. {
  177. int i, j, k, t;
  178. int sampleScale, scales[3]={8, 4, 2}, ik, ij, a, b, pitch;
  179. for(i=0; i<2; i++)
  180. {
  181. for(j=0; j<128; j++)
  182. for(k=0; k<128; k++)
  183. {
  184. FinalNoise[j*128+k+i*128*128] =  TransitionalNoise[(2*i+3)*256 + (j&15)*16 + (k&15)];
  185. for(t=0; t<3; t++)
  186. {
  187. sampleScale = scales[t];
  188. ik = k/sampleScale, ij = j/sampleScale, a = k&(sampleScale-1), b = j&(sampleScale-1), pitch = 2*i+t;
  190. FinalNoise[j*128+k+i*128*128] += ((sampleScale-a)*(sampleScale-b)*TransitionalNoise[pitch*256 + ((ij)&15)*16 + ((ik)&15)] +
  191. a        *(sampleScale-b)*TransitionalNoise[pitch*256 + ((ij)&15)*16 + ((ik+1)&15)] +
  192.   (sampleScale-a)*      b        *TransitionalNoise[pitch*256 + ((ij+1)&15)*16 + ((ik)&15)] +
  193. a        *      b        *TransitionalNoise[pitch*256 + ((ij+1)&15)*16 + ((ik+1)&15)]) / (sampleScale*sampleScale);
  195. };
  196. }
  197. }
  198. }
  200. // 更新产生顶点场的坐标, 填满初始化时创建的顶点数组
  201. void CNoiseGenerator::UpdateVerticesCoordinate(const D3DXMATRIXA16 *extension, CBoatWave *pWave)
  202. {
  203. // 这个四个顶角约束了绘制的范围而不使人感觉的差异, 从而大大的提高了渲染效率
  204. corner00 = CalculateWorldPosition(D3DXVECTOR2(0.0f,0.0f),extension);
  205. corner10 = CalculateWorldPosition(D3DXVECTOR2(+1.0f,0.0f),extension);
  206. corner01 = CalculateWorldPosition(D3DXVECTOR2(0.0f,+1.0f),extension);
  207. corner11 = CalculateWorldPosition(D3DXVECTOR2(+1.0f,+1.0f),extension);
  209. float magnifying = 4096 * 0.38 ; // 0.38的意义控制有显著差异的波峰谷距，即噪声场对可见海面的描述细节的尺度
  210. D3DXVECTOR4 coordinate;
  211. int i, j, k;
  212. float u, v;
  213. k = 0;
  214. for(i=0; i<sizeY; i++)
  215. {
  216. v = i / float(sizeY-1);
  217. for(j=0; j<sizeX; j++)
  218. {
  219. u = j / float(sizeX-1);
  220. // 对每个顶点需由四个顶角插值求出各个x,z坐标
  221. coordinate = (1.0f-v)*( (1.0f-u)*corner00 + u*corner10 ) + v*( (1.0f-u)*corner01 + u*corner11 );
  222. coordinate /= coordinate.w;
  223. noiseVertices[k].x = coordinate.x;
  224. noiseVertices[k].z = coordinate.z;
  225. // 由求得的x,z坐标得到相应点的高度值
  226. noiseVertices[k].y = GetHeight((int)(magnifying*coordinate.x), (int)(magnifying*coordinate.z) ) 
  227. + pWave->GetHeight(magnifying*coordinate.x, magnifying*coordinate.z) * 0.1 ;
  228. k++;
  229. }
  230. }
  232. // 再次使平滑
  233. for(i=1; i<(sizeY-1); i++)
  234. for(j=1; j<(sizeX-1); j++)
  235. {
  236. noiseVertices[i*sizeX + j].y = 0.2f * (noiseVertices[i*sizeX + j].y + noiseVertices[i*sizeX + (j+1)].y + 
  237. noiseVertices[i*sizeX + (j-1)].y +  noiseVertices[(i+1)*sizeX + j].y + noiseVertices[(i-1)*sizeX + j].y);
  238. }
  239. }
  241. // 由屏幕坐标计算得到世界坐标
  242. D3DXVECTOR4 CNoiseGenerator::CalculateWorldPosition(D3DXVECTOR2 screenPos, const D3DXMATRIXA16 *extension)
  243. {
  244. D3DXVECTOR4 origin(screenPos.x,screenPos.y,0,1);
  245. D3DXVECTOR4 direction(screenPos.x,screenPos.y,1,1);
  246. D3DXVec4Transform( &origin, &origin, extension );
  247. D3DXVec4Transform( &direction, &direction, extension );
  249. direction -= origin;    
  250. float l = - origin.y / direction.y;
  251. D3DXVECTOR4 worldPos = origin + direction * l;    
  252. return worldPos;
  253. }
  255. // 加载噪声场值到纹理
  256. void CNoiseGenerator::LoadNoiseToTextures()
  257. {
  258. D3DLOCKED_RECT locked;
  259. unsigned short *data;
  260. int tempData[128*128], offset, levels, pitch;
  261. HRESULT hr;
  262. int i, v, u, j, k;
  263. for(i=0; i<2; i++)
  264. {
  265. offset = 128*128*i;
  267. hr = LoadedFinalNoise[i]->LockRect( 0, &locked, NULL, D3DLOCK_DISCARD );
  268. data = (unsigned short*)locked.pBits;
  269. for(k=0; k<128*128; k++){
  270. tempData[k] = FinalNoise[k+offset];
  271. data[k] = 32768+tempData[k];
  272. }
  273. LoadedFinalNoise[i]->UnlockRect( 0 );
  275. // 该纹理采用MIP
  276. levels = LoadedFinalNoise[i]->GetLevelCount();
  277. LoadedFinalNoise[i]->UnlockRect( 1 );
  278. for(j=1; j<levels; j++)
  279. {
  280. hr = LoadedFinalNoise[i]->LockRect( j, &locked, NULL, 0 );
  281. data = (unsigned short*)locked.pBits;
  282. pitch = (locked.Pitch)/2;
  283. for(v=0; v<pitch; v++){
  284. for(u=0; u<pitch; u++)
  285. {
  286. tempData[v*128 + u] = (tempData[(2*v)*128 + 2*u] + tempData[(2*v)*128 + 2*u + 1] + 
  287.        tempData[(2*v+1)*128 + 2*u] + tempData[(2*v+1)*128 + 2*u + 1])/4;
  288. data[v*pitch+u] = 32768+tempData[v*128 + u];
  289. }
  290. }
  291. LoadedFinalNoise[i]->UnlockRect( j );
  292. }
  293. }
  294. }
  296. // 加载尾迹高度场值到纹理
  297. void CNoiseGenerator::LoadTrailToTexture(CBoatWave *pWave)
  298. {
  299. D3DLOCKED_RECT locked;
  300. unsigned short *data;
  301. float *pTrailHeight = &(pWave->waveHeight[0][0][0]);
  302. int tempData[128*128], offset, levels, pitch;
  303. HRESULT hr;
  304. int i, v, u, j, k;
  306. hr = trailHeightMap->LockRect( 0, &locked, NULL, D3DLOCK_DISCARD );
  307. data = (unsigned short*)locked.pBits;
  308. for(k=0; k<128*128; k++){
  309. tempData[k] = 32768*pTrailHeight[k];
  310. data[k] = 32768+tempData[k];
  311. }
  312. trailHeightMap->UnlockRect( 0 );
  314. // 该纹理采用MIP
  315. levels = trailHeightMap->GetLevelCount();
  316. trailHeightMap->UnlockRect( 1 );
  317. for(j=1; j<levels; j++)
  318. {
  319. hr = trailHeightMap->LockRect( j, &locked, NULL, 0 );
  320. data = (unsigned short*)locked.pBits;
  321. pitch = (locked.Pitch)/2;
  322. for(v=0; v<pitch; v++){
  323. for(u=0; u<pitch; u++)
  324. {
  325. tempData[v*128 + u] = (tempData[(2*v)*128 + 2*u] + tempData[(2*v)*128 + 2*u + 1] + 
  326.        tempData[(2*v+1)*128 + 2*u] + tempData[(2*v+1)*128 + 2*u + 1])/4;
  327. data[v*pitch+u] = 32768+tempData[v*128 + u];
  328. }
  329. }
  330. trailHeightMap->UnlockRect( j );
  331. }
  332. }
  334. // 从噪声场中获取相应点的高度
  335. float CNoiseGenerator::GetHeight(int x, int y)
  336. {
  337. int height=0, x0, y0, x1, y1, a0, a1;
  338. int *pNoise = FinalNoise;
  339. int i;
  340. for(i=0; i<2; i++)
  341. {
  342. x0 = (x/4096)&127, y0 = ((y/4096)&127)*128;
  343. x1 = (x/4096+1)&127, y1 = ((y/4096+1)&127)*128;
  344. a0 = x&4095, a1 = y&4095;
  345. height += ( (4096-a1)*( ((4096-a0)*pNoise[x0+y0] + a0*pNoise[x1+y0])/4096 ) + a1*( ((4096-a0)*pNoise[x0+y1] + a0*pNoise[x1+y1])/4096 ) )/4096;
  346. x = x * 8;
  347. y = y * 8;
  348. pNoise += 128*128;
  349. }
  350. return height*7.0f/(1<<14);
  351. }
  353. // 从噪声场中获取相应点的高度
  354. float CNoiseGenerator::GetHeight(float u, float v)
  355. {
  356. float magnifying = 4096 * 0.38f;
  357. return GetHeight((int)(magnifying*u), (int)(magnifying*v) );
  358. }
  360. // 更新产生法向量场纹理的数据
  361. void CNoiseGenerator::UpdateVerticesNormal(CBoatWave *pWave)
  362. {
  363. HRESULT hr;
  364. LPDIRECT3DSURFACE9 new_target,old_target,old_depthstencil;
  366. // 此处将纹理作为渲染目标,而不是通常所说的后台缓冲区
  367. hr = device->GetRenderTarget(0, &old_target );
  368. hr = device->GetDepthStencilSurface( &old_depthstencil );
  369. hr = heightMap->GetSurfaceLevel( 0,&new_target );
  370. hr = device->SetRenderTarget( 0, new_target );
  371. device->SetDepthStencilSurface( depthstencil );
  372. device->SetRenderState( D3DRS_ZENABLE, D3DZB_FALSE );
  374. // 第一步得到高度场纹理
  375. hr = device->SetFVF(D3DFVF_SEAVERTEX);
  376. hr = hMapEffect->Begin(NULL,NULL);
  377. hMapEffect->Pass(0);
  378. hMapEffect->SetFloat("scale", 0.38);
  380. hMapEffect->SetTexture("noise0",LoadedFinalNoise[0]);
  381. hMapEffect->SetTexture("noise1",LoadedFinalNoise[1]);
  382. hMapEffect->SetVector("trailCorner00", &D3DXVECTOR4(pWave->corner00.x, 0, pWave->corner00.y, 0) );
  383. hMapEffect->SetVector("trailCorner10", &D3DXVECTOR4(pWave->corner10.x, 0, pWave->corner10.y, 0) );
  384. hMapEffect->SetVector("trailCorner01", &D3DXVECTOR4(pWave->corner01.x, 0, pWave->corner01.y, 0) );
  385. hMapEffect->SetVector("trailCorner11", &D3DXVECTOR4(pWave->corner11.x, 0, pWave->corner11.y, 0) );
  386. hMapEffect->SetTexture("trailHeight",trailHeightMap);
  387. device->DrawIndexedPrimitive( D3DPT_TRIANGLELIST, 0, 0, sizeX*sizeY, 0, 2*(sizeX-1)*(sizeY-1) );
  388. hMapEffect->End();
  390. // 第二步由高度场纹理计算得到法向量场纹理
  391. hr = normalMap->GetSurfaceLevel( 0,&new_target );
  392. hr = device->SetRenderTarget( 0, new_target );
  393. hr = nMapEffect->Begin(NULL,NULL);
  394. nMapEffect->Pass(0);
  395. nMapEffect->SetFloat("dsizeX", 1.0f/512);
  396. nMapEffect->SetFloat("dsizeY", 1.0f/1024);
  397. nMapEffect->SetVector("corner00", &corner00 );
  398. nMapEffect->SetVector("corner10", &corner10 );
  399. nMapEffect->SetVector("corner01", &corner01 );
  400. nMapEffect->SetVector("corner11", &corner11 );
  401. nMapEffect->SetFloat("amplitude", 2*7.0f);
  402. nMapEffect->SetTexture("heightmap",heightMap);
  403. device->DrawIndexedPrimitive( D3DPT_TRIANGLELIST, 0, 0, sizeX*sizeY, 0, 2*(sizeX-1)*(sizeY-1) );
  404. nMapEffect->End();
  406. device->SetRenderState( D3DRS_ZENABLE, D3DZB_TRUE );
  407. device->SetRenderTarget( 0, old_target );
  408. device->SetDepthStencilSurface( old_depthstencil );
  409. }