// 描画。
void Draw()
{
if (_flags.is(FRAME_SKIP) || _device.IsScreenOccluded())
{
// noop
}
else
{
_renderer.Clear(true, true, false, Color::BLUE);
DrawSprite();
DrawModel();
int y = 0, h = _device.GetFontHeight(_renderer.GetDefaultFont());
_renderer.DrawText(0, y, Color::WHITE, _T("Test"));
y += h;
_renderer.DrawText(0, y, Color::GREEN, _T("FPS=%.2f (%.2fms)"),
_frameRateController.GetCurrentFPS(),
_frameRateController.GetElapsedTime() * 1000.f
);
y += h;
}
_renderer.Present();
}
LRESULT CALLBACK ClientApp::OnPaint(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
Renderer* pRender = ClientApp::pRenderer;
if (pRender != NULL) {
pRender->Clear();
//設定Camera到pRender
//場景描繪(含SkyBox, 地板, 與其他動態的3D物件)
//pRender->RenderScene(ClientApp::pScene);
//UI描繪
if (pUIManager)
pUIManager->Draw(pRender);
//翻頁
pRender->Present();
}
else {
PAINTSTRUCT Ps;
HDC hDC = BeginPaint(hWnd, &Ps);
//....
EndPaint(hWnd, &Ps);
}
return S_OK;
}
void SteamVR::RenderVR(CCamera* vrCam)
{
// Run Steam client callbacks
SteamAPI_RunCallbacks();
Renderer* pRender = Renderer::getInstance();
// Must clear to black
pRender->ClearFrameBuffer(mVR_RT.GetRenderTargetView(), COLOR::BLACK);
Vector3 origCamPos = vrCam->gameObject->transform->GetGlobalPosition();
// Scene render - left / right eyes
for (int i = 0; i < EyeCount; ++i)
{
vr::Hmd_Eye eye = (vr::Hmd_Eye)i;
mCurrentEyeIndex = eye;
// Update eye pos and view matrix based on head tracker
UpdateCamFromTracker(vrCam, eye);
// Render the scene
pRender->RenderScene(vrCam);
// Set viewport to left/right eye and render
pRender->SetBlendState(CRenderer::NO_BLEND_DEPTH_LESS);
// Tone Mapping / Gamma correction
pRender->FinalImageProcessing(vrCam->GetRenderTarget(), &mVR_RT);
// Distortion render
GetViewportFromHmd(eye, mFinalVR_VP);
pRender->SetViewport(mFinalVR_VP);
pRender->PostProcess(&mVR_RT, &mDistortionRT[i], &pRender->mVRFinalRT, Shader::DISTORTION_RENDER, false);
// Set back original head position
vrCam->gameObject->transform->SetPosition(origCamPos);
// End Scene
pRender->Clear();
pRender->ClearRenderQueues();
}
// Swap buffers
if (mVsyncEnabled)
pRender->GetOculusSwapChain()->Present(1, 0);
else
pRender->GetOculusSwapChain()->Present(0, 0);
}
void ModelBrowserTool::Render()
{
Renderer* renderer = GraphicSubsystem::Instance()->GetRenderer();
GD_ASSERT(renderer);
renderer->SetViewport( 0, 0, mModelBrowserWindow->mViewerFrame->width(), mModelBrowserWindow->mViewerFrame->height() );
renderer->SetClearColor( Color4f( 0.1f, 0.2f, 0.4f, 1.0f) );
renderer->SetCulling( Renderer::CullBackFace );
// Render.
renderer->Clear( Renderer::ColorBuffer | Renderer::DepthBuffer );
renderer->SetRenderState( Renderer::DepthTest, true );
// Camera.
renderer->SetMatrixMode(Renderer::ProjectionMatrix);
renderer->LoadIdentity();
renderer->Perspective(mCamera.GetFovAngle(),
(float)mModelBrowserWindow->mViewerFrame->width() / (float)mModelBrowserWindow->mViewerFrame->height(),
mCamera.GetNearView(), mCamera.GetFarView());
renderer->SetMatrixMode(Renderer::ModelViewMatrix);
renderer->LoadIdentity();
renderer->SetView( mCamera.GetPosition(), mObjectCenter - mCamera.GetPosition(), mCamera.GetUp() );
Light light;
light.mPosition = mCamera.GetPosition();
light.mAmbient = Color4f(0.1f,0.1f, 0.1f,1.0f);
light.mDiffuse = Color4f(0.9f,0.9f, 0.9f,1.0f);
light.mType = Renderer::LightPoint;
renderer->SetRenderState( Renderer::Light_i, true, 0 );
renderer->SetLight( 0, light );
renderer->SetRenderState( Renderer::Lighting, true );
renderer->SetColor(Color4f(1.0f, 1.0f, 1.0f, 1.0f));
// Change the orientation.
static Float pAngle = 0;
pAngle += 0.05f;
mModel->SetOrientation(Quaternionf( Vector3f(0,1,0), pAngle ));
renderer->Translate(mModel->GetPosition());
renderer->Rotate(mModel->GetOrientation());
mModel->Render();
}
void Render(Renderer &rend) override
{
rend.SetColour(20, 30, 40, 255);
rend.Clear();
world.Render(rend);
if (draw_radii)
{
circle1.SetColour(244, 199, 17, 128);
// circle1.Render(rend, gx, gy, 16);
}
RenderGuy(rend);
text1.Render(rend, textx, texty);
fps_text.Render(rend, -10, 5);
gold_score_text.Render(rend, 10, -5);
}
//[-------------------------------------------------------]
//[ Public virtual PLScene::SceneNode functions ]
//[-------------------------------------------------------]
void SNLoadScreen::DrawPost(Renderer &cRenderer, const VisNode *pVisNode)
{
// Call base implementation
SNLoadScreenBase::DrawPost(cRenderer, pVisNode);
// Hide the load screen?
const float fProgress = GetLoadProgress();
if (fProgress > 1.0f || fProgress < 0.0f) {
// We do not longer need the used materials :)
FreeMaterials();
} else {
// Clear the screen
if (ClearFlags) {
uint32 nFlags = 0;
if (ClearFlags & Color)
nFlags |= Clear::Color;
if (ClearFlags & Depth)
nFlags |= Clear::ZBuffer;
if (ClearFlags & Stencil)
nFlags |= Clear::Stencil;
cRenderer.Clear(nFlags, ClearColor.Get());
}
// Screen alpha
const float fPerImage = (Images > 1) ? 1.0f/Images : 0.1f;
if (GetFlags() & NoImageBlend) {
// No image blend, please
for (uint8 i=0; i<Images; i++) {
m_fAlpha[i] = (fProgress-(static_cast<float>(i)*fPerImage))/fPerImage;
m_fAlpha[i] = (m_fAlpha[i] > 1.0f || m_fAlpha[i] < 0.0f) ? 0.0f : 1.0f;
}
} else {
if (Images > 1) {
// Image blend, please
for (uint8 i=0; i<Images; i++) {
m_fAlpha[i] = (fProgress-(static_cast<float>(i)*fPerImage))/fPerImage;
if (m_fAlpha[i] > 1.0f)
m_fAlpha[i] = 1.0f-(fProgress-(fPerImage*static_cast<float>(i+1)))/fPerImage;
}
} else {
m_fAlpha[0] = fProgress*10;
if (m_fAlpha[0] > 1.0f)
m_fAlpha[0] = 1.0f;
}
}
// Load bar alpha
m_fBarBackAlpha = fProgress/0.25f;
if (m_fBarBackAlpha > 1.0f)
m_fBarBackAlpha = 1.0f;
m_fBarAlpha[0] = (Math::Sin(fProgress)/4+0.75f)*m_fBarBackAlpha;
m_fBarAlpha[1] = (Math::Cos(fProgress)/4+0.75f)*m_fBarBackAlpha;
const float fBarRight = BarX+BarWidth*fProgress;
// Begin 2D mode
SamplerStates cSamplerStates;
DrawHelpers &cDrawHelpers = cRenderer.GetDrawHelpers();
cDrawHelpers.Begin2DMode();
// Screen
const Color4 cImageColor = ImageColor.Get();
MaterialManager &cMaterialManager = cRenderer.GetRendererContext().GetMaterialManager();
for (uint8 i=0; i<Images; i++) {
if (m_fAlpha[i] > 0.0f) {
Material *pMaterial = m_cScreenMaterial[i].GetResource();
if (!pMaterial) {
pMaterial = cMaterialManager.LoadResource(m_sScreenMaterial[i]);
if (pMaterial)
m_cScreenMaterial[i].SetResource(pMaterial);
}
if (pMaterial) {
for (uint32 nPass=0; nPass<pMaterial->GetNumOfPasses(); nPass++) {
pMaterial->SetupPass(nPass);
TextureBuffer *pTextureBuffer = cRenderer.GetTextureBuffer(0);
if (pTextureBuffer) {
cRenderer.SetRenderState(RenderState::CullMode, Cull::None);
cDrawHelpers.DrawImage(*pTextureBuffer, cSamplerStates, Vector2(ImageX, ImageY), Vector2(ImageWidth, ImageHeight),
Color4(cImageColor.r, cImageColor.g, cImageColor.b, cImageColor.a*m_fAlpha[i]));
}
}
}
// Else unload (if it's loaded :) the material because the don't need it!
} else {
m_cScreenMaterial[i].SetResource();
}
}
// Load bar background
const Color4 cBarColor = BarColor.Get();
Material *pMaterial = m_cBarBackMaterial.GetResource();
if (pMaterial) {
for (uint32 nPass=0; nPass<pMaterial->GetNumOfPasses(); nPass++) {
pMaterial->SetupPass(nPass);
TextureBuffer *pTextureBuffer = cRenderer.GetTextureBuffer(0);
if (pTextureBuffer) {
cRenderer.SetRenderState(RenderState::CullMode, Cull::None);
cDrawHelpers.DrawImage(*pTextureBuffer, cSamplerStates, Vector2(BarX, BarY), Vector2(BarWidth, BarHeight),
Color4(cBarColor.r, cBarColor.g, cBarColor.b, (GetFlags() & NoImageBlend) ? cBarColor.a : cBarColor.a*m_fBarBackAlpha));
}
}
// Try to load it
} else {
m_cBarBackMaterial.SetResource(cMaterialManager.LoadResource(m_sBarBackMaterial));
}
// Load bar
for (int i=0; i<2; i++) {
pMaterial = m_cBarMaterial[i].GetResource();
if (pMaterial) {
for (uint32 nPass=0; nPass<pMaterial->GetNumOfPasses(); nPass++) {
pMaterial->SetupPass(nPass);
TextureBuffer *pTextureBuffer = cRenderer.GetTextureBuffer(0);
if (pTextureBuffer) {
cRenderer.SetRenderState(RenderState::CullMode, Cull::None);
cDrawHelpers.DrawImage(*pTextureBuffer, cSamplerStates, Vector2(BarX, BarY), Vector2(fBarRight - BarX, BarHeight),
Color4(cBarColor.r, cBarColor.g, cBarColor.b, cBarColor.a*m_fBarAlpha[i]), 1.0f, Vector2::Zero, Vector2(fProgress, 1.0f));
}
}
// Try to load it
} else {
m_cBarMaterial[i].SetResource(cMaterialManager.LoadResource(m_sBarMaterial[i]));
}
}
// End 2D mode
cDrawHelpers.End2DMode();
}
}
/**
* @brief
* Draws the scene
*/
void SPRTTShaders::DrawScene(Renderer &cRenderer)
{
// Clear the content of the current used render target by using gray (this way, in case on an graphics error we might still see at least something)
cRenderer.Clear(Clear::Color | Clear::ZBuffer, Color4::Gray);
// Make our program to the current one
if (cRenderer.SetProgram(m_pSceneProgram)) {
// Calculate the world matrix
Matrix4x4 mWorld;
{
// Build a rotation matrix by using a given Euler angle around the y-axis
mWorld.FromEulerAngleY(static_cast<float>(m_fRotation*Math::DegToRad));
}
// Set program uniforms
ProgramUniform *pProgramUniform = m_pSceneProgram->GetUniform("ObjectSpaceToClipSpaceMatrix");
if (pProgramUniform) {
// Calculate the view matrix
Matrix4x4 mView;
{
mView.SetTranslation(0.0f, -0.1f, -0.5f);
}
// Calculate the projection matrix
Matrix4x4 mProjection;
{
const float fAspect = 1.0f;
const float fAspectRadio = cRenderer.GetViewport().GetWidth()/(cRenderer.GetViewport().GetHeight()*fAspect);
mProjection.PerspectiveFov(static_cast<float>(45.0f*Math::DegToRad), fAspectRadio, 0.001f, 1000.0f);
}
// Calculate the final composed world view projection matrix
const Matrix4x4 mWorldViewProjection = mProjection*mView*mWorld;
// Set object space to clip space matrix uniform
pProgramUniform->Set(mWorldViewProjection);
}
// Set object space to world space matrix uniform
pProgramUniform = m_pSceneProgram->GetUniform("ObjectSpaceToWorldSpaceMatrix");
if (pProgramUniform)
pProgramUniform->Set(mWorld);
// Set world space light direction
pProgramUniform = m_pSceneProgram->GetUniform("LightDirection");
if (pProgramUniform)
pProgramUniform->Set(Vector3::UnitZ);
// Get the used mesh
const Mesh *pMesh = m_pMeshHandler->GetMesh();
if (pMesh) {
// Get the mesh LOD level to use
const MeshLODLevel *pLODLevel = pMesh->GetLODLevel(0);
if (pLODLevel && pLODLevel->GetIndexBuffer()) {
// Get and use the index buffer of the mesh LOD level
cRenderer.SetIndexBuffer(pLODLevel->GetIndexBuffer());
// Get the vertex buffer of the mesh handler
VertexBuffer *pVertexBuffer = m_pMeshHandler->GetVertexBuffer();
if (pVertexBuffer) {
// Set program vertex attributes, this creates a connection between "Vertex Buffer Attribute" and "Vertex Shader Attribute"
ProgramAttribute *pProgramAttribute = m_pSceneProgram->GetAttribute("VertexPosition");
if (pProgramAttribute)
pProgramAttribute->Set(pVertexBuffer, VertexBuffer::Position);
pProgramAttribute = m_pSceneProgram->GetAttribute("VertexNormal");
if (pProgramAttribute)
pProgramAttribute->Set(pVertexBuffer, VertexBuffer::Normal);
// Loop through all geometries of the mesh
const Array<Geometry> &lstGeometries = *pLODLevel->GetGeometries();
for (uint32 nGeo=0; nGeo<lstGeometries.GetNumOfElements(); nGeo++) {
// Is this geometry active?
const Geometry &cGeometry = lstGeometries[nGeo];
if (cGeometry.IsActive()) {
// Draw the geometry
cRenderer.DrawIndexedPrimitives(
cGeometry.GetPrimitiveType(),
0,
pVertexBuffer->GetNumOfElements()-1,
cGeometry.GetStartIndex(),
cGeometry.GetIndexSize()
);
}
}
}
}
}
}
}
int __stdcall WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR cmd, int nCmd)
{
u32 r = Log2(48);
Window* window = Window::Create("BFAATW!", 480, 320, false);
if ( ! window ) return 42;
Renderer* renderer = Renderer::Create(window);
if ( ! renderer ) { delete window; return 42; }
ResourceManager* resources = new ResourceManager(renderer);
Style* style = resources->LoadStyle("basic.style");
renderer->SetStyle(style);
Mesh* plane = CreatePlane(resources, "ground");
Texture* ground = resources->LoadTexture("hill_mound_b.dds");
Matrix planeWorld(Matrix::Identity);
Matrix tmp;
MatrixScaling(tmp, Vector(10.0f, 1.0f, 10.0f));
MatrixMultiply(planeWorld, tmp);
MatrixTranslation(tmp, Vector(0.0f, -3.0f, 0.0f));
MatrixMultiply(planeWorld, tmp);
Mesh* cube = CreateCube(resources, "cube");
Texture* diffuse = resources->LoadTexture("Catwalk_03_Diffuse_512.dds");
Matrix cubeWorld(Matrix::Identity);
Matrix view, projection;
Camera::Perspective(MATH_PI_3, 480.0f/320.0f, 0.1f, 100.0f, projection);
RenderTarget* shadowMap = resources->CreateRenderTarget("shadowmap", 1024, 1024, RT_SHADOWMAP);
Vector lightPosition(3.0f, 5.0f, 2.0f);
Matrix lightView, lightProjection;
Camera::Orthographic(-3.0f, 3.0f, -3.0f, 3.0f, 0.1f, 100.0f, lightProjection);
Camera::LookAt(lightPosition, Vector::Zero, Vector::UnitY, lightView);
Timer timer(60);
timer.Start();
Texture* depth = shadowMap->GetTexture(0);
style->SetParameter("shadow", &depth);
style->SetParameter("lightPosition", &lightPosition);
while ( window->Update() && ! window->IsKeyDown(KEY_ESCAPE) )
{
while ( timer.Update() )
{
if ( window->IsMouseButtonDown(MOUSE_RIGHT) )
{
// Set camera position
u32 wx, wy;
window->GetSize(wx, wy);
s32 mx, my;
window->GetMousePosition(mx, my);
Vector eye;
float theta = -float(my) / float(wy) * MATH_2_PI;
float rho = float(mx) / float(wx) * MATH_2_PI * 2.0f;
theta = Clamp(theta, -4.5f, -2.0f);
eye.x = 5.0f * cosf(theta) * cosf(rho);
eye.y = 5.0f * sinf(theta);
eye.z = 5.0f * cosf(theta) * sinf(rho);
Camera::LookAt(eye, Vector::Zero, Vector::UnitY, view);
}
MatrixRotation(tmp, Vector::UnitY, MATH_PI / 120.0f);
MatrixMultiply(planeWorld, tmp);
//cubeWorld = Matrix::Identity * Matrix::Scaling(Vector::One * (cosf(timer.GetTime() * 13.0f)+1.2f));
}
{ // render to shadow map
renderer->SetRenderTarget(shadowMap);
renderer->SetViewport(0, 0, 1024, 1024);
renderer->Clear();
int b = false;
style->SetParameter("processShadow", &b);
Matrix viewProjection = lightView;
MatrixMultiply(viewProjection, lightProjection);
style->SetParameter("viewProjection", &viewProjection);
style->SetParameter("diffuse", (const Texture**) &diffuse);
style->SetParameter("world", &cubeWorld);
renderer->Render(cube);
style->SetParameter("diffuse", (const Texture**) &ground);
style->SetParameter("world", &planeWorld);
renderer->Render(plane);
}
{ // render to screen
renderer->SetRenderTarget(0);
renderer->SetViewport(0, 0, 480, 320);
renderer->Clear();
int b = true;
style->SetParameter("processShadow", &b);
Matrix viewProjection = view;
MatrixMultiply(viewProjection, projection);
style->SetParameter("viewProjection", &viewProjection);
style->SetParameter("diffuse", (const Texture**) &diffuse);
style->SetParameter("world", &cubeWorld);
renderer->Render(cube);
style->SetParameter("diffuse", (const Texture**) &ground);
style->SetParameter("world", &planeWorld);
renderer->Render(plane);
}
window->SwapBuffers();
}
delete resources;
delete renderer;
delete window;
return 0;
}
int main()
{
using namespace icarus::graphics;
using namespace icarus::maths;
std::cout << "Hello World!" << std::endl;
#if 0
std::cout << (1 - 0.3f) << std::endl;
Vector4 vec(10, 10, 12, 5);
Vector4 vec2(5, 5, 8, 9.3f);
std::cout << vec << std::endl;
std::cout << vec2 << std::endl;
std::cout << vec + vec2 << std::endl;
std::cout << vec * vec2 << std::endl;
std::cout << vec * 2.5f << std::endl;
std::cout << (vec == vec2) << std::endl;
std::cout << "----------------------" << std::endl;
std::cout << vec << std::endl;
vec *= 5;
std::cout << vec << std::endl;
std::cout << (vec *= 2) << std::endl;
std::cout << vec << std::endl;
std::cout << "----------------------" << std::endl;
Matrix4x4 mat = Matrix4x4::Identity();
Matrix4x4 mat2 = Matrix4x4::Identity();
std::cout << (mat * mat2) << std::endl;
std::cout << "----------------------" << std::endl;
Matrix4x4 position = Matrix4x4::Translate(2, 3, 4);
std::cout << position << std::endl;
Vector4& column = position.GetColumn(3);
std::cout << column << std::endl;
std::cout << position.elements[12] << std::endl;
column.x++;
std::cout << position.elements[12] << std::endl;
#endif
if (!glfwInit()) {
return -1;
}
Window window("Game Engine", WIDTH, HEIGHT, true);
std::cout << glGetString(GL_VERSION) << std::endl;
{
glClearColor(0.0f, 0.5f, 0.8f, 1.0f);
GLfloat vertices[] =
{
//-0.5f, -0.5f, 0,
//-0.5f, 0.5f, 0,
// 0.5f, 0.5f, 0,
// 0.5f, 0.5f, 0,
// 0.5f, -0.5f, 0,
//-0.5f, -0.5f, 0,
0, 0, 0, // 0
0, 3, 0, // 1
8, 3, 0, // 2
8, 0, 0, // 3
};
GLuint indicies[] =
{
0, 1, 2,
2, 3, 0,
};
VertexArray va;
VertexBuffer vb(vertices, 4 * 3 * sizeof(GLfloat));
VertexBufferLayout layout;
layout.Push<float>(3);
va.AddBuffer(vb, layout);
IndexBuffer ib(indicies, 6);
Shader shader("src/shaders/Basic.shader");
Matrix4x4 model(1.0f);
//model *= Matrix4x4::Rotate(45, 0, 0, 1);
//model *= Matrix4x4::Scale(1, 0.5f, 1);
//model *= Matrix4x4::Translate(4, 3, 0);
//model = Matrix4x4::Identity();
Matrix4x4 view = Matrix4x4::Identity();
Matrix4x4 proj = Matrix4x4::Orthographic(0, 16, 0, 9, -1, 1);
shader.Bind();
shader.SetUniformMat4f("u_MVP", proj * view * model);
shader.SetUniform4f("u_Color", Vector4(0.2f, 0.3f, 0.8f, 1.0f));
shader.SetUniform2f("u_LightPos", Vector2(4, 1.5f));
Renderer renderer;
ImGuiContext* imguiContext = ImGui::CreateContext();
ImGui_ImplGlfwGL3_Init(window.GetGLFWWindow(), false);
ImGui::StyleColorsDark();
float r = 0.0f;
float incrementR = 0.05f;
float lightXPos = 4.0f;
float incrementL = 0.05f;
while (!window.ShouldClose()) {
//std::cout << window.GetWidth() << std::endl;
renderer.Clear();
ImGui_ImplGlfwGL3_NewFrame();
// 1. Show a simple window.
// Tip: if we don't call ImGui::Begin()/ImGui::End() the widgets automatically appears in a window called "Debug".
{
static float f = 0.0f;
static int counter = 0;
ImGui::Text("Hello, world!"); // Display some text (you can use a format string too)
//ImGui::SliderFloat3("Translation", &translation.x, 0.0f, WIDTH);
//ImGui::SliderFloat3("Camera", &camera.x, 0.0f, WIDTH);
//ImGui::ColorEdit3("clear color", (float*)&clear_color); // Edit 3 floats representing a color
}
shader.Bind();
model = Matrix4x4::Translate(4, 3, 0);
shader.SetUniformMat4f("u_MVP", proj * view * model);
shader.SetUniformMat4f("u_modelMat", model);
shader.SetUniform4f("u_Color", Vector4(r, 0.3f, 0.8f, 1.0f));
double x, y;
window.GetMousePosition(x, y);
//shader.SetUniform2f("u_LightPos", Vector2(lightXPos, 1.5f));
shader.SetUniform2f("u_LightPos", Vector2((float)x * 16.0f / 960.0f, 9.0f - (float)y * 9.0f / 540.0f));
renderer.Draw(va, ib, shader);
model = Matrix4x4::Translate(0, 0, 0);
shader.SetUniformMat4f("u_MVP", proj * view * model);
shader.SetUniformMat4f("u_modelMat", model);
renderer.Draw(va, ib, shader);
ImGui::Render();
ImGui_ImplGlfwGL3_RenderDrawData(ImGui::GetDrawData());
if (r > 1.0f) {
incrementR = -0.05f;
} else if (r < 0.0f) {
incrementR = 0.05f;
}
r += incrementR;
//if (lightXPos > 8.0f) {
// incrementL = -0.05f;
//} else if (lightXPos < 0.0f) {
// incrementL = 0.05f;
//}
//lightXPos += incrementL;
window.Update();
}
}
ImGui_ImplGlfwGL3_Shutdown();
ImGui::DestroyContext();
glfwTerminate();
return 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();
}
