//----------------------------------------------------------------------------
void ObjLoadingTestApp::Initialize(GPUDevice* device)
{
float color = 0.0f;
glClearColor(color, color, color, 0.0f);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
// Create scene camera.
mMainCamera->SetPerspectiveFrustum(45.0f, (float)Width / (float)Height, 0.01f, 150.0f);
mMainCamera->SetLookAt(vec3(0.0f, 10.0f, 35.0f), vec3(0.0f, 10.0f, 0.0f),
vec3(0.0f, 1.0f, 0.0f));
// Create material templates.
Material* material = 0;
ShaderProgramInfo objMeshProgramInfo;
objMeshProgramInfo.VShaderFileName = "ObjLoadingTest/vObjMesh.glsl";
objMeshProgramInfo.FShaderFileName = "ObjLoadingTest/fObjMesh.glsl";
objMeshProgramInfo.ShaderStageFlag = ShaderType::ST_Vertex |
ShaderType::ST_Fragment;
Pass* passObjMesh = new Pass(objMeshProgramInfo);
Technique* techObjMesh = new Technique();
techObjMesh->AddPass(passObjMesh);
MaterialTemplate* mtObjMesh = new MaterialTemplate();
mtObjMesh->AddTechnique(techObjMesh);
// Create scene.
mat4 rotM;
material = new Material(mtObjMesh);
mModel = new ObjMesh(material, mMainCamera);
mModel->LoadFromOBJFile("elephant-gallop/elephant-gallop-1.obj");
mModel->GenerateNormals();
mModel->CreateDeviceResource(mDevice);
rotM = rotate(mat4(), radians(-60.0f), vec3(0, 1, 0));
mModel->SetWorldTransform(rotM);
mModel->SetWorldTranslation(vec3(3.2f, 3.6f, 2.4f));
mModel->SetWorldScale(vec3(9.0f));
}
//----------------------------------------------------------------------------
void SIIApp::Initialize(GPUDevice* device)
{
float color = 0.0f;
glClearColor(color, color, color, 0.0f);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
// Create scene camera.
mMainCamera->SetPerspectiveFrustum(45.0f, (float)Width/(float)Height, 0.01f, 50.0f);
mMainCamera->SetLookAt(vec3(0.0f, 10.0f, 35.0f), vec3(0.0f, 10.0f, 0.0f),
vec3(0.0f, 1.0f, 0.0f));
// Create light projector.
mLightProjector = new Camera();
mLightProjector->SetPerspectiveFrustum(85.0f, 1.0f, 0.01f, 50.0f);
mLightProjector->SetLookAt(vec3(0.0f, 10.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f),
vec3(1.0f, 0.0f, 0.0f));
// Create material templates.
Material* material = 0;
ShaderProgramInfo programInfo;
programInfo.VShaderFileName = "SplattingIndirectIllumination/vVPLShadow.glsl";
programInfo.FShaderFileName = "SplattingIndirectIllumination/fVPLShadow.glsl";
programInfo.TCShaderFileName = "SplattingIndirectIllumination/tcVPLShadow.glsl";
programInfo.TEShaderFileName = "SplattingIndirectIllumination/teVPLShadow.glsl";
programInfo.ShaderStageFlag = ShaderType::ST_Vertex |
ShaderType::ST_Fragment |
ShaderType::ST_TessellationControl |
ShaderType::ST_TessellationEvaluation;
Pass* passShadow = new Pass(programInfo);
programInfo.VShaderFileName = "SplattingIndirectIllumination/vScene.glsl";
programInfo.FShaderFileName = "SplattingIndirectIllumination/fScene.glsl";
programInfo.TCShaderFileName = "";
programInfo.TEShaderFileName = "";
programInfo.ShaderStageFlag = ShaderType::ST_Vertex |
ShaderType::ST_Fragment;
Pass* passScene = new Pass(programInfo);
programInfo.VShaderFileName = "SplattingIndirectIllumination/vRSMBuffer.glsl";
programInfo.FShaderFileName = "SplattingIndirectIllumination/fRSMBuffer.glsl";
programInfo.TCShaderFileName = "";
programInfo.TEShaderFileName = "";
programInfo.ShaderStageFlag = ShaderType::ST_Vertex |
ShaderType::ST_Fragment;
Pass* passRSMBuffer = new Pass(programInfo);
Technique* techSII = new Technique();
techSII->AddPass(passShadow);
techSII->AddPass(passRSMBuffer);
techSII->AddPass(passScene);
MaterialTemplate* mtSII = new MaterialTemplate();
mtSII->AddTechnique(techSII);
programInfo.VShaderFileName = "SplattingIndirectIllumination/vSampleRSMBuffer.glsl";
programInfo.FShaderFileName = "SplattingIndirectIllumination/fSampleRSMBuffer.glsl";
programInfo.TCShaderFileName = "";
programInfo.TEShaderFileName = "";
programInfo.ShaderStageFlag = ShaderType::ST_Vertex |
ShaderType::ST_Fragment;
Pass* passVPLQuad = new Pass(programInfo);
Technique* techVPLQuad = new Technique();
techVPLQuad->AddPass(passVPLQuad);
MaterialTemplate* mtVPLQuad = new MaterialTemplate();
mtVPLQuad->AddTechnique(techVPLQuad);
programInfo.VShaderFileName = "SplattingIndirectIllumination/vSIITemp.glsl";
programInfo.FShaderFileName = "SplattingIndirectIllumination/fSIITemp.glsl";
programInfo.TCShaderFileName = "";
programInfo.TEShaderFileName = "";
programInfo.ShaderStageFlag = ShaderType::ST_Vertex |
ShaderType::ST_Fragment;
Pass* passScreenQuad = new Pass(programInfo);
Technique* techScreenQuad = new Technique();
techScreenQuad->AddPass(passScreenQuad);
MaterialTemplate* mtScreenQuad = new MaterialTemplate();
mtScreenQuad->AddTechnique(techScreenQuad);
// Create shadow map render target.
int shadowMapWidth, shadowMapHeight;
shadowMapWidth = 1024;
shadowMapHeight = 1024;
mShadowMapTexture = new Texture2D();
mShadowMapTexture->CreateRenderTarget(mDevice, shadowMapWidth,
shadowMapHeight, BF_RGBF);
mShadowMapDepthTexture = new Texture2D();
mShadowMapDepthTexture->CreateRenderTarget(mDevice, shadowMapWidth,
shadowMapHeight, BF_Depth);
// Create shadow map frame buffer.
Texture* renderTargets[] = { mShadowMapTexture };
mShadowMapFB = new FrameBuffer(mDevice);
mShadowMapFB->SetRenderTargets(1, renderTargets, mShadowMapDepthTexture);
// Create RSM-buffer MRT textures.
int RSMWidth = 1024;
int RSMHeight = 1024;
mRSMPositionTexturePX = new Texture2D();
mRSMPositionTexturePX->CreateRenderTarget(mDevice, RSMWidth, RSMHeight,
BF_RGBF);
mRSMNormalTexturePX = new Texture2D();
mRSMNormalTexturePX->CreateRenderTarget(mDevice, RSMWidth, RSMHeight,
BF_RGBF);
mRSMFluxTexturePX = new Texture2D();
mRSMFluxTexturePX->CreateRenderTarget(mDevice, RSMWidth, RSMHeight,
BF_RGBF);
mRSMDepthTexturePX = new Texture2D();
mRSMDepthTexturePX->CreateRenderTarget(mDevice, RSMWidth, RSMHeight,
BF_Depth);
// Create RSM-buffer.
Texture* rsmTextures[3] = { mRSMPositionTexturePX, mRSMNormalTexturePX, mRSMFluxTexturePX };
mRSMBufferPX = new FrameBuffer(mDevice);
mRSMBufferPX->SetRenderTargets(3, rsmTextures, mRSMDepthTexturePX);
// Create RSM sample texture.
mRSMSampleTexture = new Texture1D();
mRSMSampleTexture->CreateUniformRandomTexture(mDevice, 128, 2);
// Create VPL quad.
material = new Material(mtVPLQuad);
mVPLQuad = new SIIVPLQuad(material, mMainCamera);
mVPLQuad->LoadFromPLYFile("screenquad.ply");
mVPLQuad->CreateDeviceResource(mDevice);
mVPLQuad->IsQuad = true;
mVPLQuad->RSMPositionTexture = mRSMPositionTexturePX;
mVPLQuad->RSMNormalTexture = mRSMNormalTexturePX;
mVPLQuad->RSMFluxTexture = mRSMFluxTexturePX;
mVPLQuad->RSMSampleTexture = mRSMSampleTexture;
// Create scene.
mat4 rotM;
material = new Material(mtSII);
mModel = new SIITriMesh(material, mMainCamera);
mModel->LoadFromPLYFile("cow.ply");
mat4 scale = glm::scale(mat4(), vec3(2.0f));
mModel->UpdateModelSpaceVertices(scale);
mModel->GenerateNormals();
mModel->CreateDeviceResource(mDevice);
mModel->SetWorldTranslation(vec3(-2.0f, 3.0f, 3.0f));
mModel->MaterialColor = vec3(0.65f, 0.65f, 0.65f);
mModel->LightProjector = mLightProjector;
mModel->ShadowMap = mShadowMapTexture;
material = new Material(mtSII);
mGround = new SIITriMesh(material, mMainCamera);
mGround->LoadFromPLYFile("square.ply");
mGround->GenerateNormals();
mGround->CreateDeviceResource(mDevice);
mGround->MaterialColor = vec3(0.5f, 0.0f, 0.0f);
mGround->LightProjector = mLightProjector;
mGround->ShadowMap = mShadowMapTexture;
material = new Material(mtSII);
mCeiling = new SIITriMesh(material, mMainCamera);
mCeiling->LoadFromPLYFile("square.ply");
mCeiling->GenerateNormals();
mCeiling->CreateDeviceResource(mDevice);
rotM = rotate(mat4(), radians(180.0f), vec3(1, 0, 0));
mCeiling->SetWorldTransform(rotM);
mCeiling->SetWorldTranslation(vec3(0.0f, 20.0f, 0.0f));
mCeiling->MaterialColor = vec3(0.0f, 0.0f, 0.75f);
mCeiling->LightProjector = mLightProjector;
mCeiling->ShadowMap = mShadowMapTexture;
material = new Material(mtSII);
mBackWall = new SIITriMesh(material, mMainCamera);
mBackWall->LoadFromPLYFile("square.ply");
mBackWall->GenerateNormals();
mBackWall->CreateDeviceResource(mDevice);
rotM = rotate(mat4(), radians(90.0f), vec3(1, 0, 0));
mBackWall->SetWorldTransform(rotM);
mBackWall->SetWorldTranslation(vec3(0.0f, 10.0f, -10.0f));
mBackWall->MaterialColor = vec3(0.75f, 0.75f, 0.75f);
mBackWall->LightProjector = mLightProjector;
mBackWall->ShadowMap = mShadowMapTexture;
material = new Material(mtSII);
mLeftWall = new SIITriMesh(material, mMainCamera);
mLeftWall->LoadFromPLYFile("square.ply");
mLeftWall->GenerateNormals();
mLeftWall->CreateDeviceResource(mDevice);
rotM = rotate(mat4(), radians(-90.0f), vec3(0, 0, 1));
mLeftWall->SetWorldTransform(rotM);
mLeftWall->SetWorldTranslation(vec3(-10.0f, 10.0f, 0.0f));
mLeftWall->MaterialColor = vec3(1.0f, 0.0f, 0.0f);
mLeftWall->LightProjector = mLightProjector;
mLeftWall->ShadowMap = mShadowMapTexture;
material = new Material(mtSII);
mRightWall = new SIITriMesh(material, mMainCamera);
mRightWall->LoadFromPLYFile("square.ply");
mRightWall->GenerateNormals();
mRightWall->CreateDeviceResource(mDevice);
rotM = rotate(mat4(), radians(90.0f), vec3(0, 0, 1));
mRightWall->SetWorldTransform(rotM);
mRightWall->SetWorldTranslation(vec3(10.0f, 10.0f, 0.0f));
mRightWall->MaterialColor = vec3(0.0f, 1.0f, 0.0f);
mRightWall->LightProjector = mLightProjector;
mRightWall->ShadowMap = mShadowMapTexture;
material = new Material(mtScreenQuad);
mShadowMapScreenQuad = new SIITempScreenQuad(material);
mShadowMapScreenQuad->LoadFromPLYFile("screenquad.ply");
mShadowMapScreenQuad->SetTCoord(0, vec2(0.0f, 0.0f));
mShadowMapScreenQuad->SetTCoord(1, vec2(1.0f, 0.0f));
mShadowMapScreenQuad->SetTCoord(2, vec2(1.0f, 1.0f));
mShadowMapScreenQuad->SetTCoord(3, vec2(0.0f, 1.0f));
mShadowMapScreenQuad->CreateDeviceResource(mDevice);
mShadowMapScreenQuad->TempTexture = mShadowMapTexture;
}
//----------------------------------------------------------------------------
void SSSviaPSMApp::Initialize(GPUDevice* device)
{
float color = 1.0f;
glClearColor(color, color, color, 0.0f);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
// Create scene camera.
mMainCamera->SetPerspectiveFrustum(45.0f, (float)Width/(float)Height, 0.01f, 50.0f);
mMainCamera->SetLookAt(vec3(0.0f, 10.0f, 35.0f), vec3(0.0f, 10.0f, 0.0f),
vec3(0.0f, 1.0f, 0.0f));
// Create light projector.
mLightProjector = new Camera();
mLightProjector->SetPerspectiveFrustum(45.0f, (float)Width / (float)Height, 0.01f, 50.0f);
mLightProjector->SetLookAt(vec3(0.0f, 5.0f, -9.5f), vec3(0.0f, 5.0f, 0.0f),
vec3(0.0f, 1.0f, 0.0f));
// Create material templates.
Material* material = 0;
ShaderProgramInfo programInfo;
programInfo.VShaderFileName = "SSSviaPSM/vShadow.glsl";
programInfo.FShaderFileName = "SSSviaPSM/fShadow.glsl";
programInfo.TCShaderFileName = "SSSviaPSM/tcShadow.glsl";
programInfo.TEShaderFileName = "SSSviaPSM/teShadow.glsl";
programInfo.ShaderStageFlag = ShaderType::ST_Vertex |
ShaderType::ST_Fragment |
ShaderType::ST_TessellationControl |
ShaderType::ST_TessellationEvaluation;
Pass* passShadow = new Pass(programInfo);
programInfo.VShaderFileName = "SSSviaPSM/vScene.glsl";
programInfo.FShaderFileName = "SSSviaPSM/fScene.glsl";
programInfo.TCShaderFileName = "";
programInfo.TEShaderFileName = "";
programInfo.ShaderStageFlag = ShaderType::ST_Vertex |
ShaderType::ST_Fragment;
Pass* passScene = new Pass(programInfo);
Technique* techISM = new Technique();
techISM->AddPass(passShadow);
techISM->AddPass(passScene);
MaterialTemplate* mtISM = new MaterialTemplate();
mtISM->AddTechnique(techISM);
programInfo.VShaderFileName = "SSSviaPSM/vSSSviaPSMTemp.glsl";
programInfo.FShaderFileName = "SSSviaPSM/fSSSviaPSMTemp.glsl";
programInfo.TCShaderFileName = "";
programInfo.TEShaderFileName = "";
programInfo.ShaderStageFlag = ShaderType::ST_Vertex |
ShaderType::ST_Fragment;
Pass* passScreenQuad = new Pass(programInfo);
Technique* techScreenQuad = new Technique();
techScreenQuad->AddPass(passScreenQuad);
MaterialTemplate* mtScreenQuad = new MaterialTemplate();
mtScreenQuad->AddTechnique(techScreenQuad);
// Create shadow map render target.
int shadowMapWidth, shadowMapHeight;
shadowMapWidth = 1024;
shadowMapHeight = 1024;
mShadowMapTexture = new Texture2D();
mShadowMapTexture->CreateRenderTarget(mDevice, shadowMapWidth,
shadowMapHeight, BF_RGBF);
mShadowMapDepthTexture = new Texture2D();
mShadowMapDepthTexture->CreateRenderTarget(mDevice, shadowMapWidth,
shadowMapHeight, BF_Depth);
// Create shadow map frame buffer.
Texture* renderTargets[] = { mShadowMapTexture };
mShadowMapFB = new FrameBuffer(mDevice);
mShadowMapFB->SetRenderTargets(1, renderTargets, mShadowMapDepthTexture);
// Create scene.
mat4 rotM;
material = new Material(mtISM);
mModel = new SSSviaPSMTriMesh(material, mMainCamera);
mModel->LoadFromPLYFile("dragon_s.ply");
mat4 scale = glm::scale(mat4(), vec3(60.0f));
//mat4 scale = Scale(vec3(1.0f));
mModel->UpdateModelSpaceVertices(scale);
mModel->GenerateNormals();
mModel->CreateDeviceResource(mDevice);
mModel->SetWorldTranslation(vec3(0.0f, 4.0f, 0.0f));
//mModel->SetWorldTranslation(vec3(0.0f, 6.0f, 0.0f));
mModel->MaterialColor = vec3(0.15f, 0.55f, 0.35f);
mModel->LightProjector = mLightProjector;
mModel->ShadowMap = mShadowMapTexture;
mModel->IsSSS = true;
material = new Material(mtISM);
mGround = new SSSviaPSMTriMesh(material, mMainCamera);
mGround->LoadFromPLYFile("square.ply");
mGround->GenerateNormals();
mGround->CreateDeviceResource(mDevice);
mGround->MaterialColor = vec3(0.8f, 0.8f, 0.8f);
mGround->LightProjector = mLightProjector;
mGround->ShadowMap = mShadowMapTexture;
material = new Material(mtISM);
mCeiling = new SSSviaPSMTriMesh(material, mMainCamera);
mCeiling->LoadFromPLYFile("square.ply");
mCeiling->GenerateNormals();
mCeiling->CreateDeviceResource(mDevice);
rotM = rotate(mat4(), radians(180.0f), vec3(1, 0, 0));
mCeiling->SetWorldTransform(rotM);
mCeiling->SetWorldTranslation(vec3(0.0f, 20.0f, 0.0f));
mCeiling->MaterialColor = vec3(0.0f, 0.0f, 0.75f);
mCeiling->LightProjector = mLightProjector;
mCeiling->ShadowMap = mShadowMapTexture;
material = new Material(mtISM);
mBackWall = new SSSviaPSMTriMesh(material, mMainCamera);
mBackWall->LoadFromPLYFile("square.ply");
mBackWall->GenerateNormals();
mBackWall->CreateDeviceResource(mDevice);
rotM = rotate(mat4(), radians(90.0f), vec3(1, 0, 0));
mBackWall->SetWorldTransform(rotM);
mBackWall->SetWorldTranslation(vec3(0.0f, 10.0f, -10.0f));
mBackWall->MaterialColor = vec3(0.75f, 0.75f, 0.75f);
mBackWall->LightProjector = mLightProjector;
mBackWall->ShadowMap = mShadowMapTexture;
material = new Material(mtISM);
mLeftWall = new SSSviaPSMTriMesh(material, mMainCamera);
mLeftWall->LoadFromPLYFile("square.ply");
mLeftWall->GenerateNormals();
mLeftWall->CreateDeviceResource(mDevice);
rotM = rotate(mat4(), radians(-90.0f), vec3(0, 0, 1));
mLeftWall->SetWorldTransform(rotM);
mLeftWall->SetWorldTranslation(vec3(-10.0f, 10.0f, 0.0f));
mLeftWall->MaterialColor = vec3(1.0f, 0.0f, 0.0f);
mLeftWall->LightProjector = mLightProjector;
mLeftWall->ShadowMap = mShadowMapTexture;
material = new Material(mtISM);
mRightWall = new SSSviaPSMTriMesh(material, mMainCamera);
mRightWall->LoadFromPLYFile("square.ply");
mRightWall->GenerateNormals();
mRightWall->CreateDeviceResource(mDevice);
rotM = rotate(mat4(), radians(90.0f), vec3(0, 0, 1));
mRightWall->SetWorldTransform(rotM);
mRightWall->SetWorldTranslation(vec3(10.0f, 10.0f, 0.0f));
mRightWall->MaterialColor = vec3(0.0f, 1.0f, 0.0f);
mRightWall->LightProjector = mLightProjector;
mRightWall->ShadowMap = mShadowMapTexture;
material = new Material(mtScreenQuad);
mShadowMapScreenQuad = new SSSviaPSMTempScreenQuad(material);
mShadowMapScreenQuad->LoadFromPLYFile("screenquad.ply");
mShadowMapScreenQuad->SetTCoord(0, vec2(0.0f, 0.0f));
mShadowMapScreenQuad->SetTCoord(1, vec2(1.0f, 0.0f));
mShadowMapScreenQuad->SetTCoord(2, vec2(1.0f, 1.0f));
mShadowMapScreenQuad->SetTCoord(3, vec2(0.0f, 1.0f));
mShadowMapScreenQuad->CreateDeviceResource(mDevice);
mShadowMapScreenQuad->TempTexture = mShadowMapTexture;
}
//----------------------------------------------------------------------------
void VPLviaSVOGI::Initialize(GPUDevice* device)
{
float color = 0.0f;
glClearColor(color, color, color, 0.0f);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
// Create scene camera.
mMainCamera->SetPerspectiveFrustum(45.0f, (float)Width/(float)Height, 0.01f, 150.0f);
mMainCamera->SetLookAt(vec3(0.0f, 10.0f, 35.0f), vec3(0.0f, 10.0f, 0.0f),
vec3(0.0f, 1.0f, 0.0f));
// Create light manager.
mLightManager = new LightManager(device);
// Create scene lights.
//LightProjectorDesc pointLight1ProjDesc;
//pointLight1ProjDesc.UpFovDegrees = 90.0f;
//pointLight1ProjDesc.AspectRatio = 1.0f;
//pointLight1ProjDesc.NearPlane = 0.01f;
//pointLight1ProjDesc.FarPlane = 50.0f;
//pointLight1ProjDesc.Location = vec3(2.0f, 12.0f, 2.0f);
//pointLight1ProjDesc.LookAt = vec3(0.0f, 0.0f, 0.0f);
//pointLight1ProjDesc.Up = vec3(1.0f, 0.0f, 0.0f);
//PointLightDesc light1Desc;
//light1Desc.Intensity = vec3(50.0f, 50.0f, 50.0f);
//mLightManager->CreatePointLight(&pointLight1ProjDesc, mMainCamera, &light1Desc);
//LightProjectorDesc pointLight2ProjDesc;
//pointLight2ProjDesc.UpFovDegrees = 90.0f;
//pointLight2ProjDesc.AspectRatio = 1.0f;
//pointLight2ProjDesc.NearPlane = 0.01f;
//pointLight2ProjDesc.FarPlane = 50.0f;
//pointLight2ProjDesc.Location = vec3(-2.0f, 12.0f, 2.0f);
//pointLight2ProjDesc.LookAt = vec3(0.0f, 0.0f, 0.0f);
//pointLight2ProjDesc.Up = vec3(1.0f, 0.0f, 0.0f);
//PointLightDesc light2Desc;
//light2Desc.Intensity = vec3(50.0f, 20.0f, 10.0f);
//mLightManager->CreatePointLight(&pointLight2ProjDesc, mMainCamera, &light2Desc);
LightProjectorDesc spotLight1ProjDesc;
spotLight1ProjDesc.UpFovDegrees = 90.0f;
spotLight1ProjDesc.AspectRatio = 1.0f;
spotLight1ProjDesc.NearPlane = 0.01f;
spotLight1ProjDesc.FarPlane = 50.0f;
spotLight1ProjDesc.Location = vec3(-0.5f, 10.0f, 0.0f);
spotLight1ProjDesc.LookAt = vec3(-10.0f, 1.0f, 0.0f);
spotLight1ProjDesc.Up = vec3(0.0f, 1.0f, 0.0f);
SpotLightDesc spotLight1Desc;
spotLight1Desc.Intensity = vec3(50.0f, 50.0f, 50.0f);
spotLight1Desc.ConstantAttenuation = 0.0f;
spotLight1Desc.QuadraticAttenuation = 0.2f;
spotLight1Desc.CosCutoff = cos(40.0f / 180.0f * PI_SP);
spotLight1Desc.InnerCosCutoff = cos(40.0f * 0.95f / 180.0f * PI_SP);
spotLight1Desc.SpotExponent = 0.0f;
mLightManager->CreateSpotLight(&spotLight1ProjDesc, mMainCamera, &spotLight1Desc);
LightProjectorDesc spotLight2ProjDesc;
spotLight2ProjDesc.UpFovDegrees = 90.0f;
spotLight2ProjDesc.AspectRatio = 1.0f;
spotLight2ProjDesc.NearPlane = 0.01f;
spotLight2ProjDesc.FarPlane = 50.0f;
spotLight2ProjDesc.Location = vec3(0.5f, 10.0f, 0.0f);
spotLight2ProjDesc.LookAt = vec3(10.0f, 15.0f, -5.0f);
spotLight2ProjDesc.Up = vec3(0.0f, 1.0f, 0.0f);
SpotLightDesc spotLight2Desc;
spotLight2Desc.Intensity = vec3(50.0f, 50.0f, 50.0f);
spotLight2Desc.ConstantAttenuation = 0.0f;
spotLight2Desc.QuadraticAttenuation = 0.2f;
spotLight2Desc.CosCutoff = cos(40.0f / 180.0f * PI_SP);
spotLight2Desc.InnerCosCutoff = cos(40.0f * 0.95f / 180.0f * PI_SP);
spotLight2Desc.SpotExponent = 0.0f;
mLightManager->CreateSpotLight(&spotLight2ProjDesc, mMainCamera, &spotLight2Desc);
mLightManager->CreateLightBuffer(mDevice);
// Create material templates.
Material* material = 0;
ShaderProgramInfo voxelizationProgramInfo;
voxelizationProgramInfo.VShaderFileName = "VPLviaSVOGI/vVoxelization.glsl";
voxelizationProgramInfo.GShaderFileName = "VPLviaSVOGI/gVoxelization.glsl";
if( mVoxelizerType == Voxelizer::VT_Grid )
{
voxelizationProgramInfo.FShaderFileName = "VPLviaSVOGI/fVoxelization.glsl";
}
else if( mVoxelizerType == Voxelizer::VT_SVO )
{
voxelizationProgramInfo.FShaderFileName = "VPLviaSVOGI/fSVOVoxelization.glsl";
}
else
{
assert(false);
}
voxelizationProgramInfo.ShaderStageFlag = ShaderType::ST_Vertex |
ShaderType::ST_Geometry |
ShaderType::ST_Fragment;
Pass* passVoxelization = new Pass(voxelizationProgramInfo);
ShaderProgramInfo pointLightShadowProgramInfo;
pointLightShadowProgramInfo.VShaderFileName = "VPLviaSVOGI/vPointLightShadow.glsl";
pointLightShadowProgramInfo.FShaderFileName = "VPLviaSVOGI/fPointLightShadow.glsl";
pointLightShadowProgramInfo.TCShaderFileName = "VPLviaSVOGI/tcPointLightShadow.glsl";
pointLightShadowProgramInfo.TEShaderFileName = "VPLviaSVOGI/tePointLightShadow.glsl";
pointLightShadowProgramInfo.GShaderFileName = "VPLviaSVOGI/gPointLightShadow.glsl";
pointLightShadowProgramInfo.ShaderStageFlag = ShaderType::ST_Vertex |
ShaderType::ST_Fragment |
ShaderType::ST_TessellationControl |
ShaderType::ST_TessellationEvaluation |
ShaderType::ST_Geometry;
Pass* passPointLightShadow = new Pass(pointLightShadowProgramInfo);
ShaderProgramInfo spotLightShadowProgramInfo;
spotLightShadowProgramInfo.VShaderFileName = "VPLviaSVOGI/vSpotLightShadow.glsl";
spotLightShadowProgramInfo.GShaderFileName = "VPLviaSVOGI/gSpotLightShadow.glsl";
spotLightShadowProgramInfo.FShaderFileName = "VPLviaSVOGI/fSpotLightShadow.glsl";
spotLightShadowProgramInfo.ShaderStageFlag = ShaderType::ST_Vertex |
ShaderType::ST_Geometry |
ShaderType::ST_Fragment;
Pass* passSpotLightShadow = new Pass(spotLightShadowProgramInfo);
ShaderProgramInfo gbufferProgramInfo;
if( mUseTC )
{
gbufferProgramInfo.VShaderFileName = "VPLviaSVOGI/vGBufferRPC.glsl";
gbufferProgramInfo.FShaderFileName = "VPLviaSVOGI/fGBufferRPC.glsl";
}
else
{
gbufferProgramInfo.VShaderFileName = "VPLviaSVOGI/vGBuffer.glsl";
gbufferProgramInfo.FShaderFileName = "VPLviaSVOGI/fGBuffer.glsl";
}
gbufferProgramInfo.ShaderStageFlag = ShaderType::ST_Vertex |
ShaderType::ST_Fragment;
Pass* passGBuffer = new Pass(gbufferProgramInfo);
ShaderProgramInfo pointLightRSMProgramInfo;
pointLightRSMProgramInfo.VShaderFileName = "VPLviaSVOGI/vPointLightRSM.glsl";
pointLightRSMProgramInfo.GShaderFileName = "VPLviaSVOGI/gPointLightRSM.glsl";
pointLightRSMProgramInfo.FShaderFileName = "VPLviaSVOGI/fPointLightRSM.glsl";
pointLightRSMProgramInfo.ShaderStageFlag = ShaderType::ST_Vertex |
ShaderType::ST_Geometry |
ShaderType::ST_Fragment;
pointLightRSMProgramInfo.Parameters.push_back(
ShaderProgramParameterValue(SPP_Geometry_Vertices_Out,
RSM_FACE_COUNT * 3));
Pass* passPointLightRSM = new Pass(pointLightRSMProgramInfo);
ShaderProgramInfo spotLightRSMProgramInfo;
spotLightRSMProgramInfo.VShaderFileName = "VPLviaSVOGI/vSpotLightRSM.glsl";
spotLightRSMProgramInfo.GShaderFileName = "VPLviaSVOGI/gSpotLightRSM.glsl";
spotLightRSMProgramInfo.FShaderFileName = "VPLviaSVOGI/fSpotLightRSM.glsl";
spotLightRSMProgramInfo.ShaderStageFlag = ShaderType::ST_Vertex |
ShaderType::ST_Geometry |
ShaderType::ST_Fragment;
Pass* passSpotLightRSM = new Pass(spotLightRSMProgramInfo);
Technique* techSceneModel = new Technique();
techSceneModel->AddPass(passVoxelization);
techSceneModel->AddPass(passPointLightShadow);
techSceneModel->AddPass(passSpotLightShadow);
techSceneModel->AddPass(passGBuffer);
techSceneModel->AddPass(passPointLightRSM);
techSceneModel->AddPass(passSpotLightRSM);
MaterialTemplate* mtSceneModel = new MaterialTemplate();
mtSceneModel->AddTechnique(techSceneModel);
// Create scene.
mat4 rotM;
material = new Material(mtSceneModel);
mModel = new SceneMesh(material, mMainCamera);
mModel->LoadFromPLYFile("cube.ply");
mModel->GenerateNormals();
mModel->CreateDeviceResource(mDevice);
rotM = rotate(mat4(), radians(-60.0f), vec3(0, 1, 0));
mModel->SetWorldTransform(rotM);
mModel->SetWorldTranslation(vec3(-6.0f, 2.5f, -1.5f));
mModel->SetWorldScale(vec3(2.5f));
mModel->MaterialColor = vec3(0.1f, 0.9f, 0.9f);
mModel->SceneBB = &mSceneBB;
mSceneBB.Merge(mModel->GetWorldSpaceBB());
mModel2Sequence = new RenderSequence(0);
for( int i = 1; i <= 12; ++i )
{
material = new Material(mtSceneModel);
SceneMesh* model2 = new SceneMesh(material, mMainCamera);
char objFileName[64];
sprintf(objFileName, "elephant-gallop/elephant-gallop-%d.obj", i);
model2->LoadFromOBJFile(objFileName);
model2->GenerateNormals();
model2->CreateDeviceResource(mDevice);
rotM = rotate(mat4(), radians(-60.0f), vec3(0, 1, 0));
model2->SetWorldTransform(rotM);
model2->SetWorldTranslation(vec3(3.2f, 3.6f, 2.4f));
model2->SetWorldScale(vec3(9.0f));
model2->MaterialColor = vec3(0.2f, 0.2f, 0.9f);
model2->SceneBB = &mSceneBB;
model2->TessLevel = 1.0f;
mSceneBB.Merge(model2->GetWorldSpaceBB());
mModel2Sequence->AddRenderObject(model2);
}
mModel2Sequence->SetActiveRenderObject(0);
mModel2Sequence->SetFrequence(0.4f);
material = new Material(mtSceneModel);
mGround = new SceneMesh(material, mMainCamera);
mGround->LoadFromPLYFile("square.ply");
mGround->GenerateNormals();
mGround->CreateDeviceResource(mDevice);
mGround->MaterialColor = vec3(1.0f, 1.0f, 1.0f);
mGround->SceneBB = &mSceneBB;
mSceneBB.Merge(mGround->GetWorldSpaceBB());
material = new Material(mtSceneModel);
mCeiling = new SceneMesh(material, mMainCamera);
mCeiling->LoadFromPLYFile("square.ply");
mCeiling->GenerateNormals();
mCeiling->CreateDeviceResource(mDevice);
rotM = rotate(mat4(), radians(180.0f), vec3(1, 0, 0));
mCeiling->SetWorldTransform(rotM);
mCeiling->SetWorldTranslation(vec3(0.0f, 20.0f, 0.0f));
mCeiling->MaterialColor = vec3(1.0f, 1.0f, 1.0f);
mCeiling->SceneBB = &mSceneBB;
mSceneBB.Merge(mCeiling->GetWorldSpaceBB());
material = new Material(mtSceneModel);
mBackWall = new SceneMesh(material, mMainCamera);
mBackWall->LoadFromPLYFile("square.ply");
mBackWall->GenerateNormals();
mBackWall->CreateDeviceResource(mDevice);
rotM = rotate(mat4(), radians(90.0f), vec3(1, 0, 0));
mBackWall->SetWorldTransform(rotM);
mBackWall->SetWorldTranslation(vec3(0.0f, 10.0f, -10.0f));
mBackWall->MaterialColor = vec3(1.0f, 1.0f, 1.0f);
mBackWall->SceneBB = &mSceneBB;
mSceneBB.Merge(mBackWall->GetWorldSpaceBB());
material = new Material(mtSceneModel);
mLeftWall = new SceneMesh(material, mMainCamera);
mLeftWall->LoadFromPLYFile("square.ply");
mLeftWall->GenerateNormals();
mLeftWall->CreateDeviceResource(mDevice);
rotM = rotate(mat4(), radians(-90.0f), vec3(0, 0, 1));
mLeftWall->SetWorldTransform(rotM);
mLeftWall->SetWorldTranslation(vec3(-10.0f, 10.0f, 0.0f));
mLeftWall->MaterialColor = vec3(0.95f, 0.2f, 0.2f);
mLeftWall->SceneBB = &mSceneBB;
mSceneBB.Merge(mLeftWall->GetWorldSpaceBB());
material = new Material(mtSceneModel);
mRightWall = new SceneMesh(material, mMainCamera);
mRightWall->LoadFromPLYFile("square.ply");
mRightWall->GenerateNormals();
mRightWall->CreateDeviceResource(mDevice);
rotM = rotate(mat4(), radians(90.0f), vec3(0, 0, 1));
mRightWall->SetWorldTransform(rotM);
mRightWall->SetWorldTranslation(vec3(10.0f, 10.0f, 0.0f));
mRightWall->MaterialColor = vec3(0.2f, 0.95f, 0.2f);
mRightWall->SceneBB = &mSceneBB;
mSceneBB.Merge(mRightWall->GetWorldSpaceBB());
// Create scene renderset.
mSceneObjects = new RenderSet();
mSceneObjects->AddRenderObject(mModel);
mSceneObjects->AddRenderObject(mModel2Sequence);
mSceneObjects->AddRenderObject(mGround);
mSceneObjects->AddRenderObject(mCeiling);
mSceneObjects->AddRenderObject(mBackWall);
mSceneObjects->AddRenderObject(mLeftWall);
mSceneObjects->AddRenderObject(mRightWall);
mSceneObjects->UpdateRenderCache();
// Create shadow casters.
mShadowCasters = new RenderSet();
mShadowCasters->AddRenderObject(mModel);
mShadowCasters->AddRenderObject(mModel2Sequence);
mShadowCasters->AddRenderObject(mGround);
mShadowCasters->AddRenderObject(mCeiling);
mShadowCasters->AddRenderObject(mBackWall);
mShadowCasters->AddRenderObject(mLeftWall);
mShadowCasters->AddRenderObject(mRightWall);
// Create voxelizer renderset.
mVoxelizedObjects = new RenderSet();
if( mVoxelizerType == Voxelizer::VT_Grid )
{
mVoxelizedObjects->AddRenderObject(mModel);
mVoxelizedObjects->AddRenderObject(mModel2Sequence);
mVoxelizedObjects->AddRenderObject(mGround);
mVoxelizedObjects->AddRenderObject(mCeiling);
mVoxelizedObjects->AddRenderObject(mBackWall);
mVoxelizedObjects->AddRenderObject(mLeftWall);
mVoxelizedObjects->AddRenderObject(mRightWall);
}
else if( mVoxelizerType == Voxelizer::VT_SVO )
{
mVoxelizedObjects->AddRenderObject(mModel);
mVoxelizedObjects->AddRenderObject(mModel2Sequence);
}
else
{
assert(false);
}
// Create scene voxelizer.
if( mVoxelizerType == Voxelizer::VT_Grid )
{
mVoxelizer = new GridVoxelizer(mDevice);
((GridVoxelizer*)(Voxelizer*)mVoxelizer)->Initialize(mDevice,
VOXEL_DIMENSION, VOXEL_LOCAL_GROUP_DIM, &mSceneBB);
}
else if( mVoxelizerType == Voxelizer::VT_SVO )
{
mVoxelizer = new SVOVoxelizer(mDevice);
((SVOVoxelizer*)(Voxelizer*)mVoxelizer)->Initialize(mDevice,
VOXEL_DIMENSION, &mSceneBB);
}
else
{
assert(false);
}
mVoxelizer->RasterizerDimBias = -1;
mVoxelizer->SetRenderSet(mVoxelizedObjects);
// Create G-buffer renderer.
GBufferDesc gbufferDesc;
gbufferDesc.Width = Width;
gbufferDesc.Height = Height;
gbufferDesc.PositionFormat = BF_RGBAF;
gbufferDesc.NormalFormat = BF_RGBAF;
gbufferDesc.AlbedoFormat = BF_RGBAF;
gbufferDesc.RPCFormat = BF_RGBAF;
mGBufferRenderer = new GBufferRenderer(mDevice);
mGBufferRenderer->CreateGBuffer(&gbufferDesc);
mGBufferRenderer->SetRenderSet(mSceneObjects);
// Create shadow map renderer.
mShadowMapRenderer = new ShadowMapsGenerator(mDevice);
mShadowMapRenderer->Initialize(1024, 1024, BF_R32F, mLightManager);
mShadowMapRenderer->SetRenderSet(mShadowCasters);
// Create RSM renderer.
mRSMRenderer = new RSMRenderer(mDevice);
mRSMRenderer->Initialize(256, 256, BF_RGBAF, mLightManager);
mRSMRenderer->SetRenderSet(mSceneObjects);
// Create VPL generator.
mVPLGenerator = new VPLGenerator(mDevice);
mVPLGenerator->SetRSMRenderer(mRSMRenderer);
mVPLGenerator->Initialize(mDevice, VPL_SAMPLE_COUNT);
// Create direct lighting renderer.
mDirectLightingRenderer = new DirectLightingRenderer(mDevice);
mDirectLightingRenderer->Initialize(mDevice, Width, Height, BF_RGBAF,
mGBufferRenderer, mShadowMapRenderer);
// Create indirect lighting renderer.
mIndirectLightingRenderer = new IndirectLightingRenderer(mDevice);
mIndirectLightingRenderer->Initialize(mDevice, Width, Height, BF_RGBAF,
VPL_SAMPLE_COUNT, INTERLEAVED_PATTERN_SIZE, &mSceneBB, VOXEL_DIMENSION,
mGBufferRenderer, mVPLGenerator, mVoxelizer, mUseTC);
// Create visualizer.
mVisualizer = new Visualizer(mDevice);
mVisualizer->Initialize(mDevice, mVoxelizer, mVPLGenerator,
mShadowMapRenderer, mGBufferRenderer, mRSMRenderer,
mDirectLightingRenderer, mIndirectLightingRenderer, &mSceneBB,
VOXEL_DIMENSION, VOXEL_LOCAL_GROUP_DIM, mMainCamera,
INTERLEAVED_PATTERN_SIZE, VPL_SAMPLE_COUNT);
// Create GPU timer.
mTimer = new GPUTimer();
mTimer->CreateDeviceResource();
mVoxelizer->SetTimer(mTimer);
mShadowMapRenderer->SetTimer(mTimer);
mGBufferRenderer->SetTimer(mTimer);
mRSMRenderer->SetTimer(mTimer);
mVPLGenerator->SetTimer(mTimer);
mDirectLightingRenderer->SetTimer(mTimer);
mIndirectLightingRenderer->SetTimer(mTimer);
mVisualizer->SetTimer(mTimer);
// Create information panel.
int screenX, screenY;
glfwGetWindowPos(Window, &screenX, &screenY);
InformationPanel^ infoPanel = gcnew InformationPanel();
infoPanel->Show();
infoPanel->SetDesktopLocation(screenX + Width + 12, screenY - 30);
// Create GUI elements.
InformationPanel::GetInstance()->AddListener(this);
int infoStartY = 20;
int infoIncY = 20;
#ifdef SHOW_TIMING
InformationPanel::GetInstance()->AddTimingLabel("Scene Voxelization Pass", 16, infoStartY);
infoStartY += infoIncY;
InformationPanel::GetInstance()->AddTimingLabel("Scene Shadow Pass", 16, infoStartY);
infoStartY += infoIncY;
InformationPanel::GetInstance()->AddTimingLabel("Scene G-buffer Pass", 16, infoStartY);
infoStartY += infoIncY;
InformationPanel::GetInstance()->AddTimingLabel("RSM Pass", 16, infoStartY);
infoStartY += infoIncY;
InformationPanel::GetInstance()->AddTimingLabel("VPL Creation Pass", 16, infoStartY);
infoStartY += infoIncY;
InformationPanel::GetInstance()->AddTimingLabel("Direct Lighting Pass", 16, infoStartY);
infoStartY += infoIncY;
InformationPanel::GetInstance()->AddTimingLabel("Indirect Lighting Pass", 16, infoStartY);
infoStartY += infoIncY;
InformationPanel::GetInstance()->AddTimingLabel("Visualizer Pass", 16, infoStartY);
infoStartY += infoIncY;
InformationPanel::GetInstance()->AddTimingLabel("Total", 16, infoStartY);
infoStartY += infoIncY;
InformationPanel::GetInstance()->AddTimingLabel("Frame Counter", 16, infoStartY);
#endif
infoStartY = 20;
InformationPanel::GetInstance()->AddRadioButton("Voxel Buffer", 16, infoStartY, 60, 20, false);
infoStartY += infoIncY;
if( mVoxelizerType == Voxelizer::VT_Grid )
{
InformationPanel::GetInstance()->AddRadioButton("Voxel Grid", 16, infoStartY, 60, 20, false);
}
else if( mVoxelizerType == Voxelizer::VT_SVO )
{
InformationPanel::GetInstance()->AddRadioButton("SVO Grid", 16, infoStartY, 60, 20, false);
}
else
{
assert(false);
}
infoStartY += infoIncY;
InformationPanel::GetInstance()->AddRadioButton("Scene Shadow Map", 16, infoStartY, 60, 20, false);
infoStartY += infoIncY;
InformationPanel::GetInstance()->AddButton("Prev Shadow Map", 30, infoStartY, 110, 24);
InformationPanel::GetInstance()->AddButton("Next Shadow Map", 145, infoStartY, 110, 24);
infoStartY += infoIncY + 5;
InformationPanel::GetInstance()->AddRadioButton("G-Buffer Position", 16, infoStartY, 60, 20, false);
infoStartY += infoIncY;
InformationPanel::GetInstance()->AddRadioButton("G-Buffer Normal", 16, infoStartY, 60, 20, false);
infoStartY += infoIncY;
InformationPanel::GetInstance()->AddRadioButton("G-Buffer Albedo", 16, infoStartY, 60, 20, false);
if( mUseTC )
{
infoStartY += infoIncY;
InformationPanel::GetInstance()->AddRadioButton("G-Buffer RPC", 16, infoStartY, 60, 20, false);
}
infoStartY += infoIncY;
InformationPanel::GetInstance()->AddRadioButton("RSM Position", 16, infoStartY, 60, 20, false);
infoStartY += infoIncY;
InformationPanel::GetInstance()->AddRadioButton("RSM Normal", 16, infoStartY, 60, 20, false);
infoStartY += infoIncY;
InformationPanel::GetInstance()->AddRadioButton("RSM Flux", 16, infoStartY, 60, 20, false);
infoStartY += infoIncY;
InformationPanel::GetInstance()->AddRadioButton("Direct Lighting", 16, infoStartY, 60, 20, false);
infoStartY += infoIncY;
InformationPanel::GetInstance()->AddRadioButton("Indirect Lighting", 16, infoStartY, 60, 20, false);
infoStartY += infoIncY;
InformationPanel::GetInstance()->AddRadioButton("Filtered Indirect Lighting", 16, infoStartY, 60, 20, false);
infoStartY += infoIncY;
InformationPanel::GetInstance()->AddRadioButton("Final Result", 16, infoStartY, 60, 20, true);
infoStartY += infoIncY;
InformationPanel::GetInstance()->AddCheckBox("Enable Rotation", 16, infoStartY, 60, 20, false);
infoStartY += infoIncY;
InformationPanel::GetInstance()->AddCheckBox("Show Direct Shadow", 16, infoStartY, 60, 20, true);
infoStartY += infoIncY;
InformationPanel::GetInstance()->AddCheckBox("VPL Visibility Test", 16, infoStartY, 60, 20, true);
infoStartY += infoIncY;
InformationPanel::GetInstance()->AddCheckBox("Show VPL", 16, infoStartY, 60, 20, false);
infoStartY += infoIncY;
InformationPanel::GetInstance()->AddCheckBox("Show VPL Interleaved Sampling Subset", 16, infoStartY, 60, 20, false);
infoStartY += infoIncY;
InformationPanel::GetInstance()->AddCheckBox("Show VPL Flux Contrast", 16, infoStartY, 60, 20, false);
infoStartY += 24;
InformationPanel::GetInstance()->AddButton("Prev VPL Subset", 16, infoStartY, 100, 24);
InformationPanel::GetInstance()->AddButton("Next VPL Subset", 120, infoStartY, 100, 24);
}
//----------------------------------------------------------------------------
void RayBundleApp::Initialize(GPUDevice* device)
{
GLboolean supportNVAtomicFloatOp = QueryExtension("GL_NV_shader_atomic_float");
assert( supportNVAtomicFloatOp );
float color = 0.0f;
glClearColor(color, color, color, 0.0f);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
//glEnable(GL_DEPTH_TEST);
glDisable(GL_DEPTH_TEST);
//glEnable(GL_CULL_FACE);
glDisable(GL_CULL_FACE);
// Create ray-bundle projector.
mRayBundleProjector = new Camera(false);
mRayBundleProjector->SetOrthogonalFrustum(11.0f,
(float)mRayBundleRTWidth/(float)mRayBundleRTHeight, 1.0f, 100.0f);
mRayBundleProjector->SetLookAt(vec3(0.0f, -4.15f, 0.0f), sphereCenter,
vec3(0.0f, 0.0f, 1.0f));
// Create scene camera.
mMainCamera->SetPerspectiveFrustum(45.0f, (float)Width/(float)Height, 1.0f, 50.0f);
mMainCamera->SetLookAt(vec3(0.0f, 10.0f, 35.0f), vec3(0.0f, 10.0f, 0.0f),
vec3(0.0f, 1.0f, 0.0f));
// Create material templates.
Material* material = 0;
ShaderProgramInfo sceneProgramInfo;
sceneProgramInfo.VShaderFileName = "RayBundle/vScene.glsl";
sceneProgramInfo.FShaderFileName = "RayBundle/fScene.glsl";
sceneProgramInfo.ShaderStageFlag = ShaderType::ST_Vertex | ShaderType::ST_Fragment;
Pass* passScene = new Pass(sceneProgramInfo);
ShaderProgramInfo rayBundleProgramInfo;
rayBundleProgramInfo.VShaderFileName = "RayBundle/vRayBundle.glsl";
rayBundleProgramInfo.FShaderFileName = "RayBundle/fRayBundle.glsl";
rayBundleProgramInfo.ShaderStageFlag = ShaderType::ST_Vertex | ShaderType::ST_Fragment;
Pass* passRayBundle = new Pass(rayBundleProgramInfo);
Technique* techRayBundle = new Technique();
techRayBundle->AddPass(passScene);
techRayBundle->AddPass(passRayBundle);
MaterialTemplate* mtRayBundle = new MaterialTemplate();
mtRayBundle->AddTechnique(techRayBundle);
ShaderProgramInfo updateAccumulationProgramInfo;
updateAccumulationProgramInfo.VShaderFileName = "RayBundle/vUpdateAccumulation.glsl";
updateAccumulationProgramInfo.FShaderFileName = "RayBundle/fUpdateAccumulation.glsl";
updateAccumulationProgramInfo.ShaderStageFlag = ShaderType::ST_Vertex | ShaderType::ST_Fragment;
Pass* passUpdateAccumulation = new Pass(updateAccumulationProgramInfo);
Technique* techUpdateAccumulation = new Technique();
techUpdateAccumulation->AddPass(passUpdateAccumulation);
MaterialTemplate* mtUpdateAccumulation = new MaterialTemplate();
mtUpdateAccumulation->AddTechnique(techUpdateAccumulation);
// Create scene.
mat4 rotM;
material = new Material(mtRayBundle);
mModel = new RayBundleTriMesh(material, mMainCamera);
mModel->LoadFromPLYFile("beethoven.ply");
mModel->GenerateNormals();
mModel->CreateDeviceResource(mDevice);
mModel->SetWorldTranslation(vec3(-2.0f, 5.8f, -1.0f));
mModel->MaterialColor = vec3(0.65f, 0.65f, 0.65f);
mSceneBB.Merge(mModel->GetWorldSpaceBB());
material = new Material(mtRayBundle);
mGround = new RayBundleTriMesh(material, mMainCamera);
mGround->LoadFromPLYFile("square.ply");
mGround->GenerateNormals();
mGround->CreateDeviceResource(mDevice);
mGround->MaterialColor = vec3(0.5f, 0.0f, 0.0f);
mSceneBB.Merge(mGround->GetWorldSpaceBB());
material = new Material(mtRayBundle);
mCeiling = new RayBundleTriMesh(material, mMainCamera);
mCeiling->LoadFromPLYFile("square.ply");
mCeiling->GenerateNormals();
mCeiling->CreateDeviceResource(mDevice);
rotM = rotate(mat4(), radians(180.0f), vec3(1, 0, 0));
mCeiling->SetWorldTransform(rotM);
mCeiling->SetWorldTranslation(vec3(0.0f, 20.0f, 0.0f));
mCeiling->MaterialColor = vec3(0.0f, 0.0f, 0.75f);
mSceneBB.Merge(mCeiling->GetWorldSpaceBB());
material = new Material(mtRayBundle);
mLight = new RayBundleTriMesh(material, mMainCamera);
mLight->LoadFromPLYFile("square.ply");
mLight->GenerateNormals();
mLight->CreateDeviceResource(mDevice);
rotM = rotate(mat4(), radians(180.0f), vec3(1, 0, 0));
mLight->SetWorldTransform(rotM);
mLight->SetWorldScale(vec3(0.5f));
mLight->SetWorldTranslation(vec3(0.0f, 19.0f, 3.0f));
mLight->EmissionColor = vec3(1000.0f, 1000.0f, 1000.0f);
mLight->MaterialColor = vec3(0.0f, 0.0f, 0.0f);
mLight->IsLight = true;
mSceneBB.Merge(mLight->GetWorldSpaceBB());
material = new Material(mtRayBundle);
mBackWall = new RayBundleTriMesh(material, mMainCamera);
mBackWall->LoadFromPLYFile("square.ply");
mBackWall->GenerateNormals();
mBackWall->CreateDeviceResource(mDevice);
rotM = rotate(mat4(), radians(90.0f), vec3(1, 0, 0));
mBackWall->SetWorldTransform(rotM);
mBackWall->SetWorldTranslation(vec3(0.0f, 10.0f, -10.0f));
mBackWall->MaterialColor = vec3(0.75f, 0.75f, 0.75f);
mSceneBB.Merge(mBackWall->GetWorldSpaceBB());
material = new Material(mtRayBundle);
mLeftWall = new RayBundleTriMesh(material, mMainCamera);
mLeftWall->LoadFromPLYFile("square.ply");
mLeftWall->GenerateNormals();
mLeftWall->CreateDeviceResource(mDevice);
rotM = rotate(mat4(), radians(-90.0f), vec3(0, 0, 1));
mLeftWall->SetWorldTransform(rotM);
mLeftWall->SetWorldTranslation(vec3(-10.0f, 10.0f, 0.0f));
mLeftWall->MaterialColor = vec3(1.0f, 0.0f, 0.0f);
mSceneBB.Merge(mLeftWall->GetWorldSpaceBB());
material = new Material(mtRayBundle);
mRightWall = new RayBundleTriMesh(material, mMainCamera);
mRightWall->LoadFromPLYFile("square.ply");
mRightWall->GenerateNormals();
mRightWall->CreateDeviceResource(mDevice);
rotM = rotate(mat4(), radians(90.0f), vec3(0, 0, 1));
mRightWall->SetWorldTransform(rotM);
mRightWall->SetWorldTranslation(vec3(10.0f, 10.0f, 0.0f));
mRightWall->MaterialColor = vec3(0.0f, 1.0f, 0.0f);
mSceneBB.Merge(mRightWall->GetWorldSpaceBB());
mVoxelGridCenter = mSceneBB.GetBoxCenter();
int pixelCount = 0;
void* pixelBufferData = 0;
size_t gpuMemPoolSize = 0;
// Create ray head pointer texture.
mRayHeadPointerTexture = new Texture2D();
mRayHeadPointerTexture->CreateRenderTarget(mDevice, mRayBundleRTWidth,
mRayBundleRTHeight, BF_R32UI);
// Create ray head pointer texture init data.
pixelCount = mRayBundleRTWidth * mRayBundleRTHeight;
mRayHeadPointerTextureInitData = new PixelBuffer();
mRayHeadPointerTextureInitData->ReserveMutableDeviceResource(mDevice,
pixelCount*sizeof(GLuint), BU_Static_Draw);
mRayHeadPointerTextureInitData->Bind();
pixelBufferData = mRayHeadPointerTextureInitData->Map(BA_Write_Only);
assert( pixelBufferData );
memset(pixelBufferData, 0x00, pixelCount*sizeof(GLuint));
mRayHeadPointerTextureInitData->Unmap();
// Create per-voxel mutex texture.
int voxelMutexCount = mVoxelCount;
mPerVoxelMutexTexture = new Texture1D();
mPerVoxelMutexTexture->LoadFromSystemMemory(mDevice, BIF_R32UI, voxelMutexCount,
BF_R32UI, BCT_Unsigned_Byte, 0);
// Create per-voxel mutex texture init data.
mPerVoxelMutexTextureInitData = new PixelBuffer();
mPerVoxelMutexTextureInitData->ReserveMutableDeviceResource(mDevice,
voxelMutexCount*sizeof(GLuint), BU_Static_Draw);
mPerVoxelMutexTextureInitData->Bind();
pixelBufferData = mPerVoxelMutexTextureInitData->Map(BA_Write_Only);
assert( pixelBufferData );
memset(pixelBufferData, 0x00, voxelMutexCount*sizeof(GLuint));
mPerVoxelMutexTextureInitData->Unmap();
// Create ray GPU memory allocator counter.
mRayAllocCounter = new AtomicCounterBuffer();
mRayAllocCounter->ReserveMutableDeviceResource(mDevice, sizeof(GLuint),
BU_Dynamic_Copy);
// Create ray GPU memory pool for concurrent linked lists.
gpuMemPoolSize = 8 * pixelCount * (4*sizeof(vec4) + sizeof(GLuint) +
sizeof(GLfloat) + sizeof(GLboolean));
mRayBundleNodeBuffer = new StructuredBuffer();
mRayBundleNodeBuffer->ReserveMutableDeviceResource(mDevice, gpuMemPoolSize, BU_Dynamic_Copy);
// Create accumulation buffer.
size_t bufferSize = mVoxelCount * sizeof(vec4);
mAccumulationBuffer = new StructuredBuffer();
mAccumulationBuffer->ReserveMutableDeviceResource(mDevice, bufferSize, BU_Dynamic_Copy);
// Create ray-bundle render target.
mRayBundleRT = new Texture2D();
mRayBundleRT->CreateRenderTarget(mDevice, mRayBundleRTWidth, mRayBundleRTHeight, BF_RGBF);
mRayBundleDepth = new Texture2D();
mRayBundleDepth->CreateRenderTarget(mDevice, mRayBundleRTWidth, mRayBundleRTHeight, BF_Depth);
Texture* rayBundleRT[1] = {mRayBundleRT};
mRayBundleFB = new FrameBuffer(mDevice);
mRayBundleFB->SetRenderTargets(1, rayBundleRT, mRayBundleDepth);
// Create update accumulation screen quad.
material = new Material(mtUpdateAccumulation);
mUpdateAccuScreenQuad = new UpdateAccumulationScreenQuad(material);
mUpdateAccuScreenQuad->LoadFromPLYFile("screenquad.ply");
mUpdateAccuScreenQuad->SetTCoord(0, vec2(0.0f, 0.0f));
mUpdateAccuScreenQuad->SetTCoord(1, vec2(1.0f, 0.0f));
mUpdateAccuScreenQuad->SetTCoord(2, vec2(1.0f, 1.0f));
mUpdateAccuScreenQuad->SetTCoord(3, vec2(0.0f, 1.0f));
mUpdateAccuScreenQuad->CreateDeviceResource(mDevice);
for( int i = 0; i < RAYBUNDLE_SAMPLE_COUNT; ++i )
{
float u1 = (float)UniformRandom();
float u2 = (float)UniformRandom();
mRandmoDirections[i] = UniformSampleSphere(u1, u2);
}
}
