Vector3 RenderTargetD3D9::project(const Vector3 & v)
{
//world matrix
D3DXMATRIX matWorldD3D ( MappingsD3D9::getMatrix( m_RenderState.m_mtxWorld ) );
//view matrix
xs::Matrix4 matView( m_RenderState.m_mtxView );
matView[2][0] = -matView[2][0];
matView[2][1] = -matView[2][1];
matView[2][2] = -matView[2][2];
matView[2][3] = -matView[2][3];
D3DXMATRIX matViewD3D( MappingsD3D9::getMatrix( matView ) );
//projection matrix
xs::Matrix4 matProj;
convertProjectionMatrix(m_RenderState.m_mtxProjection, matProj, false);
D3DXMATRIX matProjD3D( MappingsD3D9::getMatrix( matProj) );
D3DXVECTOR3 vin(v.x, v.y, v.z);
D3DXVECTOR3 vout;
D3DXVec3Project(&vout, &vin, &m_viewport, &matProjD3D, &matViewD3D, &matWorldD3D);
return Vector3(vout.x, vout.y, vout.z);
}
void App::GetRay(D3DXVECTOR3& vPickRayDir, D3DXVECTOR3& vPickRayOrig)
{
if (!ActiveCam_) return;
D3DXMATRIX pmatProj(ActiveCam_->getProjectionMatrix());
POINT pos;
//GetCursorPos(&pos);
//ScreenToClient(getWindow(), &pos);
pos = mMousePos;
//pos.x = getWidth() / 2;
//pos.y = getHeight() / 2;
noVec3 orig, dir;
ActiveCam_->WindowPointToRay(pos.x, pos.y, orig, dir, width, height);
vPickRayOrig.x =orig.x;
vPickRayOrig.y =orig.y;
vPickRayOrig.z =orig.z;
vPickRayDir.x = dir.x;
vPickRayDir.y = dir.y;
vPickRayDir.z = dir.z;
#if 0
// Compute the vector of the pick ray in screen space
D3DXVECTOR3 v;
v.x = ( ( ( 2.0f * pos.x ) / getWidth() ) - 1 ) / pmatProj._11;
v.y = -( ( ( 2.0f * pos.y ) / getHeight() ) - 1 ) / pmatProj._22;
v.z = 1.0f;
// Get the inverse view matrix
D3DXMATRIX matView(ActiveCam_->getViewMatrix());
D3DXMATRIX mWorldView = matView;
D3DXMATRIX m;
D3DXMatrixInverse( &m, NULL, &mWorldView );
// Transform the screen space pick ray into 3D space
vPickRayDir.x = v.x * m._11 + v.y * m._21 + v.z * m._31;
vPickRayDir.y = v.x * m._12 + v.y * m._22 + v.z * m._32;
vPickRayDir.z = v.x * m._13 + v.y * m._23 + v.z * m._33;
vPickRayOrig.x = m._41;
vPickRayOrig.y = m._42;
vPickRayOrig.z = m._43;
#endif
#if 1
//float screenX = (float)pos.x / getWidth();
//float screenY = (float)pos.y / getHeight();
//float nx = (2.0f * screenX) - 1.0f;
//float ny = 1.0f - (2.0f * screenY);
//noVec3 nearPoint(nx, ny, -1.f);
//// Use midPoint rather than far point to avoid issues with infinite projection
//noVec3 midPoint (nx, ny, 0.0f);
//noMat4 matView(pcamera_->getViewMatrix());
//noMat4 matProj(pcamera_->getProjectionMatrix());
//noMat4 mViewProj = matProj * matView;
//noMat4 m;
//m = mViewProj.Inverse();
//
noVec3 rayOrigin, rayTarget;
//rayOrigin = m * nearPoint;
//rayTarget = m * midPoint;
ActiveCam_->unProject( pos.x, pos.y, 0.0f, getWidth(), getHeight(), rayOrigin);
ActiveCam_->unProject( pos.x, pos.y, 1.0f, getWidth(), getHeight(), rayTarget);
noVec3 rayDirection = rayTarget - rayOrigin;
rayDirection.Normalize();
rayOrig_ = rayOrigin;
rayTarget_ = rayTarget;
// Transform the screen space pick ray into 3D space
vPickRayDir.x = rayDirection.x;
vPickRayDir.y = rayDirection.y;
vPickRayDir.z = rayDirection.z;
vPickRayOrig.x = rayOrigin.x;
vPickRayOrig.y = rayOrigin.y;
vPickRayOrig.z = rayOrigin.z;
#endif
}
void CubeReflector::updateFace( const ReflectParams ¶ms, U32 faceidx )
{
GFXDEBUGEVENT_SCOPE( CubeReflector_UpdateFace, ColorI::WHITE );
// store current matrices
GFXTransformSaver saver;
// set projection to 90 degrees vertical and horizontal
F32 left, right, top, bottom;
MathUtils::makeFrustum( &left, &right, &top, &bottom, M_HALFPI_F, 1.0f, mDesc->nearDist );
GFX->setFrustum( left, right, bottom, top, mDesc->nearDist, mDesc->farDist );
// We don't use a special clipping projection, but still need to initialize
// this for objects like SkyBox which will use it during a reflect pass.
gClientSceneGraph->setNonClipProjection( GFX->getProjectionMatrix() );
// Standard view that will be overridden below.
VectorF vLookatPt(0.0f, 0.0f, 0.0f), vUpVec(0.0f, 0.0f, 0.0f), vRight(0.0f, 0.0f, 0.0f);
switch( faceidx )
{
case 0 : // D3DCUBEMAP_FACE_POSITIVE_X:
vLookatPt = VectorF( 1.0f, 0.0f, 0.0f );
vUpVec = VectorF( 0.0f, 1.0f, 0.0f );
break;
case 1 : // D3DCUBEMAP_FACE_NEGATIVE_X:
vLookatPt = VectorF( -1.0f, 0.0f, 0.0f );
vUpVec = VectorF( 0.0f, 1.0f, 0.0f );
break;
case 2 : // D3DCUBEMAP_FACE_POSITIVE_Y:
vLookatPt = VectorF( 0.0f, 1.0f, 0.0f );
vUpVec = VectorF( 0.0f, 0.0f,-1.0f );
break;
case 3 : // D3DCUBEMAP_FACE_NEGATIVE_Y:
vLookatPt = VectorF( 0.0f, -1.0f, 0.0f );
vUpVec = VectorF( 0.0f, 0.0f, 1.0f );
break;
case 4 : // D3DCUBEMAP_FACE_POSITIVE_Z:
vLookatPt = VectorF( 0.0f, 0.0f, 1.0f );
vUpVec = VectorF( 0.0f, 1.0f, 0.0f );
break;
case 5: // D3DCUBEMAP_FACE_NEGATIVE_Z:
vLookatPt = VectorF( 0.0f, 0.0f, -1.0f );
vUpVec = VectorF( 0.0f, 1.0f, 0.0f );
break;
}
// create camera matrix
VectorF cross = mCross( vUpVec, vLookatPt );
cross.normalizeSafe();
MatrixF matView(true);
matView.setColumn( 0, cross );
matView.setColumn( 1, vLookatPt );
matView.setColumn( 2, vUpVec );
matView.setPosition( mObject->getPosition() );
matView.inverse();
GFX->setWorldMatrix(matView);
renderTarget->attachTexture( GFXTextureTarget::Color0, cubemap, faceidx );
GFX->setActiveRenderTarget( renderTarget );
GFX->clear( GFXClearStencil | GFXClearTarget | GFXClearZBuffer, gCanvasClearColor, 1.0f, 0 );
SceneRenderState reflectRenderState
(
gClientSceneGraph,
SPT_Reflect,
SceneCameraState::fromGFX()
);
reflectRenderState.getMaterialDelegate().bind( REFLECTMGR, &ReflectionManager::getReflectionMaterial );
reflectRenderState.setDiffuseCameraTransform( params.query->cameraMatrix );
reflectRenderState.disableAdvancedLightingBins(true);
// render scene
LIGHTMGR->registerGlobalLights( &reflectRenderState.getCullingFrustum(), false );
gClientSceneGraph->renderSceneNoLights( &reflectRenderState, mDesc->objectTypeMask );
LIGHTMGR->unregisterAllLights();
// Clean up.
renderTarget->resolve();
}
//-----------------------------------------------------------------------------
// Name: Render()
// Desc: Called once per frame, the call is the entry point for 3d
// rendering. This function sets up render states, clears the
// viewport, and renders the scene.
//-----------------------------------------------------------------------------
HRESULT CMyD3DApplication::Render()
{
// Begin the scene
if( SUCCEEDED( m_pd3dDevice->BeginScene() ) )
{
// Render the Skybox
{
D3DXMATRIX matWorld;
D3DXMatrixScaling( &matWorld, 10.0f, 10.0f, 10.0f );
D3DXMATRIX matView(m_matView);
matView._41 = matView._42 = matView._43 = 0.0f;
m_pd3dDevice->SetTransform( D3DTS_WORLD, &matWorld );
m_pd3dDevice->SetTransform( D3DTS_VIEW, &matView );
m_pd3dDevice->SetTransform( D3DTS_PROJECTION, &m_matProject );
m_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
m_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
m_pd3dDevice->SetTextureStageState( 0, D3DTSS_MINFILTER, D3DTEXF_LINEAR );
m_pd3dDevice->SetTextureStageState( 0, D3DTSS_MAGFILTER, D3DTEXF_LINEAR );
m_pd3dDevice->SetTextureStageState( 0, D3DTSS_ADDRESSU, D3DTADDRESS_MIRROR );
m_pd3dDevice->SetTextureStageState( 0, D3DTSS_ADDRESSV, D3DTADDRESS_MIRROR );
// Always pass Z-test, so we can avoid clearing color and depth buffers
m_pd3dDevice->SetRenderState( D3DRS_ZFUNC, D3DCMP_ALWAYS );
m_pSkyBox->Render( m_pd3dDevice );
m_pd3dDevice->SetRenderState( D3DRS_ZFUNC, D3DCMP_LESSEQUAL );
}
// Render the environment-mapped ShinyTeapot
{
// Set transform state
D3DXMATRIX matViewProject;
D3DXMatrixMultiply( &matViewProject, &m_matView, &m_matProject );
D3DXMATRIX matViewInv;
D3DXMatrixInverse( &matViewInv, NULL, &m_matView );
D3DXVECTOR4 vecPosition( matViewInv._41, matViewInv._42, matViewInv._43, 1.0f );
m_pEffect->SetMatrix( "matWorld", &m_matWorld );
m_pEffect->SetMatrix( "matViewProject", &matViewProject );
m_pEffect->SetVector( "vecPosition", &vecPosition );
// Draw teapot
LPDIRECT3DVERTEXBUFFER8 pVB;
LPDIRECT3DINDEXBUFFER8 pIB;
m_pShinyTeapot->m_pLocalMesh->GetVertexBuffer( &pVB );
m_pShinyTeapot->m_pLocalMesh->GetIndexBuffer( &pIB );
m_pd3dDevice->SetStreamSource( 0, pVB, sizeof(ENVMAPPEDVERTEX) );
m_pd3dDevice->SetIndices( pIB, 0 );
UINT uPasses;
m_pEffect->Begin( &uPasses, 0 );
for( UINT iPass = 0; iPass < uPasses; iPass++ )
{
m_pEffect->Pass( iPass );
m_pd3dDevice->DrawIndexedPrimitive( D3DPT_TRIANGLELIST,
0, m_pShinyTeapot->m_pLocalMesh->GetNumVertices(),
0, m_pShinyTeapot->m_pLocalMesh->GetNumFaces() );
}
m_pEffect->End();
SAFE_RELEASE( pVB );
SAFE_RELEASE( pIB );
}
// Output statistics
m_pFont->DrawText( 2, 0, D3DCOLOR_ARGB(255,255,255,0), m_strFrameStats );
m_pFont->DrawText( 2, 20, D3DCOLOR_ARGB(255,255,255,0), m_strDeviceStats );
// End the scene.
m_pd3dDevice->EndScene();
}
return S_OK;
}
void glutDisplay_callback(void)
{
::g_FrameCount++;
clock_t Now = clock();
if ( ::g_LastTime == 0 ) // if (LastTime == 0)
{
::g_LastTime = Now; // LastTime = Now;
}
// ___ _ _ _
//| _ \ ___ _ _ __| | ___ _ _ ___| |_ __ _ __| | ___ __ __ __ _ __ __ _ _ __
//| // -_)| ' \ / _` |/ -_)| '_| (_-<| ' \ / _` |/ _` |/ _ \\ V V / | ' \ / _` || '_ \
//|_|_\\___||_||_|\__,_|\___||_| /__/|_||_|\__,_|\__,_|\___/ \_/\_/ |_|_|_|\__,_|| .__/
// |_|
// Draw depth buffer from light perspective
glm::mat4 matViewFromLight(1.0f);
glm::mat4 light_proj_matrix = glm::frustum( -1.0f, 1.0f, -1.0f, 1.0f, 1.0f, 10000.0f );
std::vector< IGameObjectRender* > vec_pRenderedObjects;
g_pFactoryMediator->getRenderedObjects( vec_pRenderedObjects, IFactory::ONLY_REGULAR_MESH_OBJECTS );
SortGameObjects(vec_pRenderedObjects);
for ( unsigned int lightID = 0; lightID != g_p_LightManager->getMaxLights(); lightID++ )
{
CLight light_props;
::g_p_LightManager->GetLightInformation(lightID, light_props);
if ( light_props.bIsEnabled && light_props.get_bHasShadow() )
{
// AKA The "view or camera" matrix, but from the lights perspective
glm::mat4 light_view_matrix = glm::lookAt( glm::vec3(light_props.position.x, light_props.position.y, light_props.position.z ),
glm::vec3( 0.0f, 0.0f, 0.0f ),
glm::vec3( 0.0f, 1.0f, 0.0f ) );
for (std::vector< IGameObjectRender* >::iterator itGO = vec_pRenderedObjects.begin();
itGO != vec_pRenderedObjects.end(); itGO++)
{
std::vector<CMeshDesc> vecMeshes;
(*itGO)->getMeshDescriptions( vecMeshes );
for ( std::vector<CMeshDesc>::iterator itCurMesh = vecMeshes.begin(); itCurMesh != vecMeshes.end(); itCurMesh++ )
{
DrawMeshForShadow( *itCurMesh, matViewFromLight, lightID );
}
}
}
}// for ( unsigned int lightID...
// ___ _ __ _ _ __
//| _ \ ___ _ _ __| | ___ _ _ ___ __ ___ _ _ ___ / /_ _ ___ _ _ _ __ __ _ | || | _ _\ \
//| // -_)| ' \ / _` |/ -_)| '_| (_-</ _|/ -_)| ' \ / -_) | || ' \ / _ \| '_|| ' \ / _` || || || || || |
//|_|_\\___||_||_|\__,_|\___||_| /__/\__|\___||_||_|\___| | ||_||_|\___/|_| |_|_|_|\__,_||_||_| \_, || |
// \_\ |__//_/
// *********************************
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glm::mat4 matView(1.0f);
if (::g_pCamera->getCameraState() == CCamera::INDEPENDENT_FREE_LOOK)
{
if (g_pCamera->deltaAngleYaw != 0.0f){
g_pCamera->cameraAngleYaw += g_pCamera->deltaAngleYaw;
g_pCamera->deltaAngleYaw = 0.0f;
}
if (g_pCamera->deltaAnglePitch != 0.0f){
g_pCamera->cameraAnglePitch += ::g_pCamera->deltaAnglePitch;
g_pCamera->deltaAnglePitch = 0.0f;
}
if (g_pCamera->deltaMove != 0.0f){
g_pCamera->eye.x += g_pCamera->deltaMove*sin(g_pCamera->cameraAngleYaw + g_pCamera->cameraMove);
g_pCamera->eye.y += g_pCamera->deltaMove*tan(g_pCamera->cameraAnglePitch);
g_pCamera->eye.z += g_pCamera->deltaMove*(-cos(g_pCamera->cameraAngleYaw + g_pCamera->cameraMove));
g_pCamera->deltaMove = 0.0f;
g_pCamera->cameraMove = 0.0f;
}
g_pCamera->target.x = g_pCamera->eye.x + sin(g_pCamera->cameraAngleYaw + g_pCamera->cameraMove);
g_pCamera->target.y = g_pCamera->eye.y + tan(g_pCamera->cameraAnglePitch);
g_pCamera->target.z = g_pCamera->eye.z + (-cos(g_pCamera->cameraAngleYaw + g_pCamera->cameraMove));
}
matView = glm::lookAt( glm::vec3(g_pCamera->eye.x, g_pCamera->eye.y, g_pCamera->eye.z), // Camera (aka "Eye")
glm::vec3(g_pCamera->target.x, g_pCamera->target.y, g_pCamera->target.z), // At (aka "target")
glm::vec3(g_pCamera->up.x, g_pCamera->up.y, g_pCamera->up.z) ); // Up
ExitOnGLError("Unknown error");
// ___ ___ _ _ __ __
//| \ _ _ __ _ __ __ __ / __|| |__ _ _ | |__ ___ __ __ / /___ ___\ \
//| |) || '_|/ _` |\ V V / \__ \| / /| || || '_ \/ _ \\ \ /| |/ -_)(_-< | |
//|___/ |_| \__,_| \_/\_/ |___/|_\_\ \_, ||_.__/\___//_\_\| |\___|/__/ | |
// |__/ \_\ /_/
// Get the objects we are to render from the factory
g_pFactoryMediator->getRenderedObjects( vec_pRenderedObjects, IFactory::ONLY_SKYBOXES );
SortGameObjects(vec_pRenderedObjects);
glDisable(GL_DEPTH_TEST);
for (std::vector< IGameObjectRender* >::iterator itGO = vec_pRenderedObjects.begin();
itGO != vec_pRenderedObjects.end(); itGO++)
{
DrawObject( *itGO, matView );
}
glEnable(GL_DEPTH_TEST);
// __ __ _ ___ _
//| \/ | __ _ (_) _ _ | \ _ _ __ _ __ __ __ | | ___ ___ _ __
//| |\/| |/ _` || || ' \ | |) || '_|/ _` |\ V V / | |__ / _ \/ _ \| '_ \
//|_| |_|\__,_||_||_||_| |___/ |_| \__,_| \_/\_/ |____|\___/\___/| .__/
// |_|
g_pFactoryMediator->getRenderedObjects(vec_pRenderedObjects, IFactory::ONLY_REGULAR_MESH_OBJECTS);
SortGameObjects(vec_pRenderedObjects);
for (std::vector< IGameObjectRender* >::iterator itGO = vec_pRenderedObjects.begin();
itGO != vec_pRenderedObjects.end(); itGO++)
{
DrawObject( *itGO, matView );
}
for (std::vector< CGameObject* >::iterator itGO = g_vecPhysDebugObjects.begin();
itGO != g_vecPhysDebugObjects.end(); itGO++)
{
DrawObject(*itGO, matView);
}
// Debug object draw loop
// Get the debug objects...
std::vector< CMeshDesc > vecDebugMeshes;
for (std::vector< IGameObjectRender* >::iterator itGO = vec_pRenderedObjects.begin();
itGO != vec_pRenderedObjects.end(); itGO++)
{
vecDebugMeshes.clear();
(*itGO)->getDebugMeshObjects( vecDebugMeshes, IGameObjectRender::AABB_CENTRED );
// Then draw them
for ( std::vector< CMeshDesc >::iterator itDO = vecDebugMeshes.begin();
itDO != vecDebugMeshes.end(); itDO++ )
{
DrawMesh( *itDO, matView );
}
}
// for ( std::vector< IGameObjectRender* >::iterator itGO ...
// vecDebugMeshes is stack based, so debug objects get deleted
if (g_SavingData == true)
{
std::ofstream myFile;
myFile.open("assets/Scene2.txt");
for (unsigned index = 0; index < vecModelsInfo.size(); index++)
{
myFile << "<Model> " << std::endl;
myFile << "\t<Type> " << vecModelsInfo[index].type << " </Type>" << std::endl;
myFile << "\t<PlyFile> " << vecModelsInfo[index].file << " </PlyFile>" << std::endl;
if (vecModelsInfo[index].isSkybox)
{
myFile << "\t<SkyboxTexture>" << std::endl;
myFile << "\t\t<Name> " << vecModelsInfo[index].tex[0][0] << " </Name>" << std::endl;
for (unsigned j = 1; j <= 6; j++)
myFile << "\t\t<Texture> " << vecModelsInfo[index].tex[0][j] << " <Texture>" << std::endl;
myFile << "\t</SkyboxTexture> " << std::endl;
myFile << "\t<IsSkybox> True </IsSkybox> " << std::endl;
}
else
{
for (unsigned j = 0; j < vecModelsInfo[index].tex[0].size(); j++)
myFile << "\t<Texture> " << vecModelsInfo[index].tex[0][j] << " </Texture>" << std::endl;
}
static CPhysicalProp physProps;
::g_pFactoryMediator->getPhysicalPropertiesByID(vecModelsInfo[index].ID, physProps);
myFile << "\t<Position> " << physProps.position.x << " " << physProps.position.y << " " << physProps.position.z << " </Position>" << std::endl;
myFile << "\t<Colour> " << vecModelsInfo[index].col.x << " " << vecModelsInfo[index].col.y << " " << vecModelsInfo[index].col.z << " </Colour>" << std::endl;
myFile << "\t<Rotation> " << physProps.rotStep.x << " " << physProps.rotStep.y << " " << physProps.rotStep.z << " </Rotation>" << std::endl;
myFile << "\t<Blend> " << vecModelsInfo[index].blend << " </Blend>" << std::endl;
if (vecModelsInfo[index].isTransparent)
myFile << "\t<Transparency> " << vecModelsInfo[index].transparency << " </Transparency>" << std::endl;
if (vecModelsInfo[index].isPlayer)
myFile << "\t<IsPlayer> True </IsPlayer>" << std::endl;
if (vecModelsInfo[index].isLightBall)
myFile << "\t<IsLightBall> True </IsLightBall>" << std::endl;
if (vecModelsInfo[index].isEnvironment)
myFile << "\t<IsEnviro> True </IsEnviro>" << std::endl;
else
myFile << "\t<Scale> " << vecModelsInfo[index].scale << " </Scale>" << std::endl;
myFile << "</Model> " << std::endl;
}
g_SavingData = false;
}
// Detatch from the vertex buffer (0 is reserved in OpenGL, so setting to "0" means "set to nothing", sort of)
glBindVertexArray(0);
// Detatch from the current shader program
//glUseProgram(0);
// Now that everything is drawn, show the back buffer
// (i.e. switch the 'back' framebuffer with the 'front'
glutSwapBuffers();
return;
}
