void ModelBrowserTool::SetCameraFocus()
{
	BoundingBox boundingBox = mModel->GetBoundingBox();
    Vector3f boxCenter = boundingBox.GetCenter();
	
	// Cubify the bounding box.
	BoundingBox boundingCube = boundingBox;
	Float maxValue = Maths::Max(boundingCube.Max().x, Maths::Max(boundingCube.Max().y, boundingCube.Max().z));
	Float minValue = Maths::Min(boundingCube.Min().x, Maths::Min(boundingCube.Min().y, boundingCube.Min().z));
	boundingCube.SetMax( Vector3f(maxValue, maxValue, maxValue) );
    boundingCube.SetMin( Vector3f(minValue, minValue, minValue) );
	
	// Recenter
	Vector3f cubeCenter = boundingCube.GetCenter();
	Vector3f offset = cubeCenter - boxCenter;
	cubeCenter -= offset;
	boundingCube(0) -= offset;
	boundingCube(1) -= offset;

	Float fovAngle = Maths::ToRadians(mCamera.GetFovAngle());
	Float halfFov = fovAngle / 2.0f;
	Float sin = Maths::Sin(halfFov);
	Float cos = Maths::Cos(halfFov);

	// Compute the camera position and viewing position.
	Float halfPos = cubeCenter.y - boundingCube.Min().y;
	Float zPos = boundingBox.Max().z + (cos * halfPos / sin);

	mCamera.SetPosition(Vector3f(boxCenter.x, boxCenter.y, zPos));
	mObjectCenter = Vector3f(boxCenter.x, boxCenter.y, boxCenter.z);
}
예제 #2
0
void World::Render()
{
    if( !mWorldInitialized )
        return;

    Renderer* renderer = GraphicSubsystem::Instance()->GetRenderer();
    GD_ASSERT(renderer);

    UInt32 viewWidth = renderer->GetRenderTarget()->GetWidth();
    UInt32 viewHeight = renderer->GetRenderTarget()->GetHeight();

    // Init.
    //renderer->BeginScene( Renderer::PointList );

    renderer->SetViewport( 0, 0, viewWidth, viewHeight );
    renderer->SetClearColor(Color4f(0.0f, 0.0f, 0.0f, 1.0f));
    renderer->SetRenderState( Renderer::Texture2D, false );
    renderer->SetRenderState( Renderer::DepthTest, true );
    //renderer->SetRenderState( Renderer::Lighting, true );
    //renderer->SetCulling( Renderer::CullBackFace );

    // Render.
    renderer->Clear( Renderer::ColorBuffer | Renderer::DepthBuffer );

    renderer->SetMatrixMode(Renderer::ProjectionMatrix);
    renderer->LoadIdentity();

    Camera* currentCamera = GetCurrentCamera();
    renderer->Perspective(currentCamera->GetFovAngle(),
                          viewWidth / static_cast<Float>(viewHeight),
                          currentCamera->GetNearView(), currentCamera->GetFarView());

    renderer->SetMatrixMode(Renderer::ModelViewMatrix);
    renderer->LoadIdentity();
    currentCamera->ApplyViewMatrix();
    /*
    Light light;
    light.mPosition = Vector3f( 4.32f, -3.0f, -3.4f ).Normalize();
    light.mAmbient  = Color4f(1.0f,1.0f, 1.0f,1.0f);
    light.mDiffuse  = Color4f(1.0f,1.0f, 1.0f,1.0f);
    light.mSpecular = Color4f(1.0f,1.0f, 1.0f,1.0f);
    light.mType = Renderer::LightDirectional;
    renderer->SetRenderState( Renderer::Light_i, true, 0 );
    renderer->SetLight( 0, light );*/

#if 0
    Matrix4d modelView;
    renderer->GetModelViewMatrix( modelView );

    Vector3f vRight( modelView[0], modelView[4], modelView[8] );
    Vector3f vUp( modelView[1], modelView[5], modelView[9] );

    Vector3f vBottomLeft  = light.mPosition + (-vRight - vUp).Normalize() * 2;
    Vector3f vBottomRight = light.mPosition + ( vRight - vUp).Normalize() * 2;
    Vector3f vTopRight    = light.mPosition + ( vRight + vUp).Normalize() * 2;
    Vector3f vTopLeft     = light.mPosition + (-vRight + vUp).Normalize() * 2;

    /*renderer->SetRenderState( Renderer::DepthMask, false );
    renderer->SetRenderState( Renderer::Lighting, false );
    renderer->SetRenderState( Renderer::Blend, true );
    renderer->SetBlendFunc( Renderer::BlendSrcAlpha, Renderer::BlendOne );*/
    renderer->SetRenderState( Renderer::Lighting, false );
    renderer->DrawQuad( vBottomLeft, vBottomRight, vTopRight, vTopLeft, false );
    renderer->SetRenderState( Renderer::Lighting, true );
#endif


    renderer->SetAmbiantColor( Color4f(1.0f, 1.0f, 1.0f, 1.0f) );

      /*Light lightPoint;
    lightPoint.mPosition = currentCamera->GetPosition();
    lightPoint.mAmbient  = Color4f(0.00f,0.00f, 0.00f,1.0f);
    lightPoint.mDiffuse  = Color4f(1.0f,1.0f, 1.0f,1.0f);
    lightPoint.mSpecular = Color4f(1.0f,1.0f, 1.0f,1.0f);
    lightPoint.mType = Renderer::LightPoint;
    lightPoint.mAttenuationConstant  = 0;
    lightPoint.mAttenuationLinear    = 0;
    lightPoint.mAttenuationQuadratic = 0.01f;
    renderer->SetRenderState( Renderer::Light_i, true, 0 );
    renderer->SetLight( 0, lightPoint );*/

	// Get the frustum.
	Matrix4f modelViewMatrix;
    Matrix4f projectionMatrix;
    Frustum  frustum;

	renderer->GetModelViewMatrix(modelViewMatrix);
	renderer->GetProjectionMatrix(projectionMatrix);
	frustum.CalculateFrustum(projectionMatrix, modelViewMatrix);

	mNbRenderedEntities = 0;

    // Render the objects in the world.
    /*
    List<Entity*> visibleEntities;
	mSpacePartition->Query(frustum, visibleEntities);
    */
    List<Entity*>::const_iterator itEntity;
    for( itEntity = mEntities.begin(); itEntity != mEntities.end(); ++itEntity )
    {
        if( *itEntity != currentCamera )
        {
			// Do frustum culling.
			if((*itEntity)->GetClass() != Terrain::StaticClass() &&
               (*itEntity)->GetClass() != SkyDome::StaticClass())
			{
				BoundingBox boundingBox = (*itEntity)->GetBoundingBox();

                if( (*itEntity)->GetClass() != ParticleEmitter::StaticClass() )
                {
                    Matrix4f translation = Matrix4f::Translation((*itEntity)->GetPosition());
				    Matrix4f rotation;
				    (*itEntity)->GetOrientation().ToMatrix(rotation);

				    Matrix4f trsMatrix = rotation * translation;
				    boundingBox.SetMin( boundingBox.Min() * trsMatrix );
				    boundingBox.SetMax( boundingBox.Max() * trsMatrix );
                }

				if( frustum.BoxInFrustum(boundingBox) )
				{
					mNbRenderedEntities++;
				}
				else
				{
					continue;
				}
			}

            renderer->PushMatrix();

            if( String((*itEntity)->GetClass()->GetName()) == "SkyDome" )
                renderer->Translate(currentCamera->GetPosition()-Vector3f(0,100,0) );
            else
                renderer->Translate((*itEntity)->GetPosition());

            renderer->Rotate((*itEntity)->GetOrientation());

            if( (*itEntity)->IsSelected() )
                (*itEntity)->RenderSelected();

            (*itEntity)->Render();

            renderer->PopMatrix();
        }
    }

    renderer->SetMatrixMode(Renderer::ModelViewMatrix);
    renderer->LoadIdentity();
    currentCamera->ApplyViewMatrix();

    //renderer->EndScene();
}