void WaterPlaneCUDA::initBuffer()
{
//Start und Endkoordinaten für x-Richtung
float startX = this->uLeft.x;
float endX = this->lRight.x;
//Start und Endkoordinaten für x-Richtung
float startY = this->uLeft.z;
float endY = this->lRight.z;
cpu_newVertices = new float3[pointsX*pointsY];
cpu_oldVertices = new float3[pointsX*pointsY];
cpu_normals = new float3[pointsX*pointsY];
unsigned int count = 0;
for (float px = startX ; px< endX ; px+=stepSize){
for (float py = startY; py < endY; py+=stepSize){
cpu_newVertices[count].x = px;
cpu_newVertices[count].y = 0;
cpu_newVertices[count].z = py;
cpu_oldVertices[count].x = px;
cpu_oldVertices[count].y = 0;
cpu_oldVertices[count].z = py;
cpu_normals[count].x = 0;
cpu_normals[count].y = 1;
cpu_normals[count].z = 0;
count++;
}
}
createVBO(&newVertexBuffer, pointsX*pointsY*sizeof(float3));
cutilSafeCall(cudaGraphicsGLRegisterBuffer(&cuda_newVertex_resource, newVertexBuffer, cudaGraphicsMapFlagsNone));
createVBO(&oldVertexBuffer, pointsX*pointsY*sizeof(float3));
cutilSafeCall(cudaGraphicsGLRegisterBuffer(&cuda_oldVertex_resource, oldVertexBuffer, cudaGraphicsMapFlagsNone));
createVBO(&normalBuffer, pointsX*pointsY*sizeof(float3));
cutilSafeCall(cudaGraphicsGLRegisterBuffer(&cuda_normalsVB_resource, normalBuffer, cudaGraphicsMapFlagsNone));
createMeshIndexBuffer(&indexVertexBuffer, pointsX, pointsY);
createMeshIndexBuffer(&indexNormalBuffer, pointsX, pointsY);
glBindBuffer(GL_ARRAY_BUFFER, *&newVertexBuffer);
glBufferData( GL_ARRAY_BUFFER, pointsY*pointsX*sizeof(float3), cpu_newVertices, GL_DYNAMIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, *&oldVertexBuffer);
glBufferData( GL_ARRAY_BUFFER, pointsY*pointsX*sizeof(float3), cpu_oldVertices, GL_DYNAMIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, *&normalBuffer);
glBufferData( GL_ARRAY_BUFFER, pointsY*pointsX*sizeof(float3), cpu_normals, GL_DYNAMIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
void RenderBlock::
setSize( unsigned w, unsigned h)
{
if (w == _mesh_width && h ==_mesh_height)
return;
createMeshIndexBuffer(w, h);
createMeshPositionVBO(w, h);
}
////////////////////////////////////////////////////////////////////////////////
//! Run test
////////////////////////////////////////////////////////////////////////////////
void runGraphicsTest(int argc, char** argv)
{
printf("[%s] ", sSDKsample);
if (g_bOpenGLQA) printf("[OpenGL Readback Comparisons] ");
printf("\n");
if ( cutCheckCmdLineFlag(argc, (const char **)argv, "device") ) {
printf("[%s]\n", argv[0]);
printf(" Does not explicitly support -device=n in OpenGL mode\n");
printf(" To use -device=n, the sample must be running w/o OpenGL\n\n");
printf(" > %s -device=n -qatest\n", argv[0]);
printf("exiting...\n");
exit(0);
}
// First initialize OpenGL context, so we can properly set the GL for CUDA.
// This is necessary in order to achieve optimal performance with OpenGL/CUDA interop.
if(CUTFalse == initGL( &argc, argv )) {
cudaThreadExit();
return;
}
cudaGLSetGLDevice( cutGetMaxGflopsDeviceId() );
// create FFT plan
CUFFT_SAFE_CALL(cufftPlan2d(&fftPlan, meshW, meshH, CUFFT_C2R) );
// allocate memory
fftInputW = (meshW / 2)+1;
fftInputH = meshH;
fftInputSize = (fftInputW*fftInputH)*sizeof(float2);
cutilSafeCall(cudaMalloc((void **)&d_h0, fftInputSize) );
cutilSafeCall(cudaMalloc((void **)&d_ht, fftInputSize) );
h_h0 = (float2 *) malloc(fftInputSize);
generate_h0();
cutilSafeCall(cudaMemcpy(d_h0, h_h0, fftInputSize, cudaMemcpyHostToDevice) );
cutilSafeCall(cudaMalloc((void **)&d_slope, meshW*meshH*sizeof(float2)) );
cutCreateTimer(&timer);
cutStartTimer(timer);
prevTime = cutGetTimerValue(timer);
// create vertex buffers and register with CUDA
createVBO(&heightVertexBuffer, meshW*meshH*sizeof(float));
// DEPRECATED: cutilSafeCall(cudaGLRegisterBufferObject(heightVertexBuffer));
cutilSafeCall(cudaGraphicsGLRegisterBuffer(&cuda_heightVB_resource, heightVertexBuffer, cudaGraphicsMapFlagsWriteDiscard));
createVBO(&slopeVertexBuffer, meshW*meshH*sizeof(float2));
// DEPRECATED: cutilSafeCall(cudaGLRegisterBufferObject(slopeVertexBuffer));
cutilSafeCall(cudaGraphicsGLRegisterBuffer(&cuda_slopeVB_resource, slopeVertexBuffer, cudaGraphicsMapFlagsWriteDiscard));
// create vertex and index buffer for mesh
createMeshPositionVBO(&posVertexBuffer, meshW, meshH);
createMeshIndexBuffer(&indexBuffer, meshW, meshH);
// Creating the Auto-Validation Code
if (g_bOpenGLQA) {
g_CheckRender = new CheckBackBuffer(windowH, windowH, 4);
g_CheckRender->setPixelFormat(GL_RGBA);
g_CheckRender->setExecPath(argv[0]);
g_CheckRender->EnableQAReadback(true);
}
runCuda();
// register callbacks
glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutReshapeFunc(reshape);
glutIdleFunc(idle);
// start rendering mainloop
glutMainLoop();
cudaThreadExit();
}