ActorComponent::ptr ActorFactory::createLightComponent()
{
LightComponent* comp = new LightComponent;
comp->setId(++m_LastLightComponentId);
return ActorComponent::ptr(comp);
}
void OnMouseDown(UINT button, int x, int y)
{
XOrientation camOrient;
cameraEntity->GetOrientation(&camOrient);
if (button == 0)
cameraControl = true;
//shoot a cube
else if (button == 1)
{
Entity* pCube = g_pScene->CreateEntity();
g_pSelectedEntity = pCube;
pCube->SetPosition(cameraEntity->GetPosition() + camOrient.z);
pCube->SetVelocity(0.1f * camOrient.z);
//pCube->SetMaxLifeTime(5.0f);
MeshComponent* pMesh = new MeshComponent(pCube);
pMesh->SetMeshResource("cube.nfm");
BodyComponent* pBody = new BodyComponent(pCube);
pBody->SetMass(10.0f);
pBody->EnablePhysics((CollisionShape*)EngineGetResource(ResourceType::COLLISION_SHAPE,
"shape_box"));
OmniLightDesc lightDesc;
lightDesc.radius = 4.0f;
lightDesc.shadowFadeStart = 20.0;
lightDesc.shadowFadeEnd = 30.0;
Entity* pLightEntity = g_pScene->CreateEntity();
pCube->Attach(pLightEntity);
//pLightEntity->SetLocalPosition(Vector(0.0f, 1.0f, 0.0f));
LightComponent* pLight = new LightComponent(pLightEntity);
pLight->SetOmniLight(&lightDesc);
pLight->SetColor(Float3(1.0f, 1.0f, 10.0f));
pLight->SetShadowMap(0);
}
else
{
Entity* pBarrel = g_pScene->CreateEntity();
g_pSelectedEntity = pBarrel;
pBarrel->SetPosition(cameraEntity->GetPosition() + camOrient.z);
pBarrel->SetVelocity(30.0f * camOrient.z);
MeshComponent* pMesh = new MeshComponent(pBarrel);
pMesh->SetMeshResource("barrel.nfm");
BodyComponent* pBody = new BodyComponent(pBarrel);
pBody->SetMass(20.0f);
pBody->EnablePhysics((CollisionShape*)EngineGetResource(ResourceType::COLLISION_SHAPE,
"shape_barrel"));
}
}
Light * GetLight( Entity * fromEntity )
{
if(NULL != fromEntity)
{
LightComponent * component = static_cast<LightComponent*>(fromEntity->GetComponent(Component::LIGHT_COMPONENT));
if(component)
{
return component->GetLightObject();
}
}
return NULL;
}
void OnKeyPress(int key)
{
if (key == VK_F1)
{
BOOL fullscreen = getFullscreenMode();
setFullscreenMode(!fullscreen);
}
XOrientation orient;
//place spot light
if (key == 'T')
{
Entity* pLightEntity = g_pScene->CreateEntity();
cameraEntity->GetOrientation(&orient);
pLightEntity->SetOrientation(&orient);
pLightEntity->SetPosition(cameraEntity->GetPosition());
LightComponent* pLight = new LightComponent(pLightEntity);
SpotLightDesc lightDesc;
lightDesc.nearDist = 0.1f;
lightDesc.farDist = 500.0f;
lightDesc.cutoff = NFE_MATH_PI / 4.0f;
lightDesc.maxShadowDistance = 60.0;
pLight->SetSpotLight(&lightDesc);
pLight->SetColor(Float3(600, 200, 50));
pLight->SetLightMap("flashlight.jpg");
pLight->SetShadowMap(1024);
g_pSelectedEntity = pLightEntity;
}
//place omni light
if (key == 'O')
{
OmniLightDesc lightDesc;
lightDesc.radius = 10.0f;
lightDesc.shadowFadeStart = 20.0;
lightDesc.shadowFadeEnd = 30.0;
Entity* pLightEntity = g_pScene->CreateEntity();
pLightEntity->SetPosition(cameraEntity->GetPosition());
LightComponent* pLight = new LightComponent(pLightEntity);
pLight->SetOmniLight(&lightDesc);
pLight->SetColor(Float3(600, 600, 600));
pLight->SetShadowMap(512);
g_pSelectedEntity = pLightEntity;
}
}
Actor* addSun(Scene *scene)
{
Actor* actor = new Actor;
TransformComponent* trans = new TransformComponent();
trans->setPos(vec3(0, 20, 0));
Rotation rot;
actor->addComponent(trans);
LightComponent* l = new DirectionalLightComponent();
l->setDirectional(1);
l->dir = normalize(vec3(0.5, 1, 0.2));
actor->addComponent(l);
scene->systemManager->getSystem(StringHash("GenericSystem").getHash())->addComponent(l);
scene->addActor(actor);
return actor;
}
void VisualRaymarchComponent::DrawWithShadows(D3D& d3d)
{
SetShader(G_ShaderManager().GetShader("Raymarch"));
// CAMERA BUFFER
ConstantBuffers::RayMarchCameraBuffer cameraBuffer;
cameraBuffer.eyePos = GetParent().GetParent().GetActiveCamera()->GetParent().GetPos();
cameraBuffer.nearPlane = 1.0f;
cameraBuffer.farPlane = 1000.0f;
glm::mat4 inverse = GetParent().GetParent().GetActiveCamera()->GetViewMatrix();
cameraBuffer.viewInverse =/* glm::transpose( */
inverse ;
cameraBuffer.viewportH = d3d.GetScreenHeight();
cameraBuffer.viewportW = d3d.GetScreenWidth();
cameraBuffer.raymarchId = m_raymarchId;
GetShader().PSSetConstBufferData(d3d, std::string("RaymarchCameraBuffer"), (void*)&cameraBuffer,
sizeof(cameraBuffer), 0);
// LIGHT BUFFER
const std::vector<Component*>& lights = GetParent().GetParent().GetLights();
LightComponent* light = static_cast<LightComponent*>(lights[0]);
ConstantBuffers::RayMarchLightBuffer lightBuffer;
lightBuffer.lightColor = light->GetDiffuse();
lightBuffer.lightPosition = light->GetParent().GetPos();
GetShader().PSSetConstBufferData(d3d, std::string("RaymarchLightBuffer"), (void*)&lightBuffer,
sizeof(lightBuffer), 1);
// BACKGROUND BUFFER
ConstantBuffers::RayMarchBackgroundColorBuffer backgroundBuffer;
backgroundBuffer.backgroundColor = glm::vec4(0.1f, 0.1f, 0.1f, 1.0f);
GetShader().PSSetConstBufferData(d3d, std::string("RaymarchBackgroundColorBuffer"),
(void*)&backgroundBuffer, sizeof(backgroundBuffer), 2);
// Render with shader.
GetShader().RenderShader(d3d, m_mesh.GetIndexCount());
}
int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
SetUpCurrentDirectory();
//create window
CustomWindow* pWindow = new CustomWindow;
pWindow->setSize(800, 600);
pWindow->setTitle(L"NFEngine Demo - Initializing engine...");
pWindow->open();
//initialize engine
if (EngineInit() != Result::OK)
return 1;
Demo_InitEditorBar();
//create scene and camera
g_pScene = EngineCreateScene();
// --------------------------------
// Build scene
// --------------------------------
#ifdef DEMO_SEC_CAMERA_ON
InitSecondaryCamera();
#endif
//set ambient & background color
EnviromentDesc envDesc;
envDesc.ambientLight = Vector(0.02f, 0.03f, 0.04f, 0.0f);
//envDesc.m_BackgroundColor = Vector(0.04f, 0.05f, 0.07f, 0.03f);
envDesc.backgroundColor = Vector(0.02f, 0.03f, 0.04f, 0.01f);
g_pScene->SetEnvironment(&envDesc);
CollisionShape* pFloorShape = ENGINE_GET_COLLISION_SHAPE("shape_floor");
pFloorShape->SetCallbacks(OnLoadCustomShapeResource, NULL);
pFloorShape->Load();
pFloorShape->AddRef();
CollisionShape* pFrameShape = ENGINE_GET_COLLISION_SHAPE("shape_frame");
pFrameShape->SetCallbacks(OnLoadCustomShapeResource, NULL);
pFrameShape->Load();
pFrameShape->AddRef();
CollisionShape* pBoxShape = ENGINE_GET_COLLISION_SHAPE("shape_box");
pBoxShape->SetCallbacks(OnLoadCustomShapeResource, NULL);
pBoxShape->Load();
pBoxShape->AddRef();
CollisionShape* pBarrelShape = ENGINE_GET_COLLISION_SHAPE("shape_barrel");
pBarrelShape->SetCallbacks(OnLoadCustomShapeResource, NULL);
pBarrelShape->Load();
pBarrelShape->AddRef();
CollisionShape* pChamberShape = ENGINE_GET_COLLISION_SHAPE("chamber_collision_shape.nfcs");
pChamberShape->Load();
pChamberShape->AddRef();
pWindow->InitCamera();
pWindow->setTitle(L"NFEngine Demo");
#ifdef SCENE_MINECRAFT
// SUNLIGHT
Entity* pDirLightEnt = g_pScene->CreateEntity();
XOrientation orient;
orient.x = Vector(0.0f, -0.0f, -0.0f, 0.0f);
orient.z = Vector(-1.5f, -1.0f, 0.5f, 0.0f);
orient.y = Vector(0.0f, 1.0f, 0.0f, 0.0f);
pDirLightEnt->SetOrientation(&orient);
DirLightDesc dirLight;
dirLight.m_Far = 100.0f;
dirLight.m_Splits = 4;
dirLight.m_LightDist = 1000.0f;
LightComponent* pDirLight = new LightComponent(pDirLightEnt);
pDirLight->SetDirLight(&dirLight);
pDirLight->SetColor(Float3(2.2, 2, 1.8));
pDirLight->SetShadowMap(1024);
// MINECRAFT
Entity* pEnt = g_pScene->CreateEntity();
pEnt->SetPosition(Vector(0, -70.0f, 0));
MeshComponent* pMesh = new MeshComponent(pEnt);
pMesh->SetMeshResource("minecraft.nfm");
#endif
#ifdef SCENE_SPONZA
// SPONZA
Entity* pEnt = g_pScene->CreateEntity();
pEnt->SetPosition(Vector(0, 0, 0));
MeshComponent* pMesh = new MeshComponent(pEnt);
pMesh->SetMeshResource("sponza.nfm");
CollisionShape* pSponzaShape = ENGINE_GET_COLLISION_SHAPE("sponza_collision_shape.nfcs");
//pSponzaShape->Load();
BodyComponent* pFloorBody = new BodyComponent(pEnt);
pFloorBody->EnablePhysics(pSponzaShape);
pFloorBody->SetMass(0.0);
pEnt = g_pScene->CreateEntity();
pEnt->SetPosition(Vector(0.0f, 3.5f, 0.0f));
LightComponent* pLight = new LightComponent(pEnt);
OmniLightDesc omni;
omni.m_ShadowFadeStart = 12.0f;
omni.m_ShadowFadeEnd = 120.0f;
omni.m_Radius = 90.0f;
pLight->SetOmniLight(&omni);
pLight->SetColor(Float3(50, 50, 50));
pLight->SetShadowMap(512);
/*
// SUNLIGHT
Entity* pDirLightEnt = g_pScene->CreateEntity();
XOrientation orient;
orient.x = Vector(0.0f, -0.0f, -0.0f, 0.0f);
orient.z = Vector(0.1, -2.3f, 1.05, 0.0f);
orient.y = Vector(0.0f, 1.0f, 0.0f, 0.0f);
pDirLightEnt->SetOrientation(&orient);
DirLightDesc dirLight;
dirLight.m_Far = 100.0f;
dirLight.m_Splits = 4;
dirLight.m_LightDist = 1000.0;
LightComponent* pDirLight = new LightComponent(pDirLightEnt);
pDirLight->SetDirLight(&dirLight);
pDirLight->SetColor(Float3(2.2, 1.3, 0.8));
pDirLight->SetShadowMap(2048);
*/
#endif
//performance test (many objects and shadowmaps)
#ifdef SCENE_SEGMENTS_PERF_TEST
for (int x = -4; x < 5; x++)
{
for (int z = -4; z < 5; z++)
{
Entity* pEntity = g_pScene->CreateEntity();
pEntity->SetPosition(12.0f * Vector((float)x, 0, (float)z));
MeshComponent* pMesh = new MeshComponent(pEntity);
pMesh->SetMeshResource("chamber.nfm");
BodyComponent* pBody = new BodyComponent(pEntity);
pBody->EnablePhysics(pChamberShape);
LightComponent* pLight;
OmniLightDesc omni;
pEntity = g_pScene->CreateEntity();
pEntity->SetPosition(12.0f * Vector(x, 0, z) + Vector(0.0f, 3.5f, 0.0f));
pLight = new LightComponent(pEntity);
omni.shadowFadeStart = 80.0f;
omni.shadowFadeEnd = 120.0f;
omni.radius = 8.0f;
pLight->SetOmniLight(&omni);
pLight->SetColor(Float3(50, 50, 50));
pLight->SetShadowMap(32);
pEntity = g_pScene->CreateEntity();
pEntity->SetPosition(12.0f * Vector(x, 0, z) + Vector(6.0f, 1.8f, 0.0f));
pLight = new LightComponent(pEntity);
omni.radius = 3.0f;
pLight->SetOmniLight(&omni);
pLight->SetColor(Float3(5.0f, 0.5f, 0.25f));
pEntity = g_pScene->CreateEntity();
pEntity->SetPosition(12.0f * Vector(x, 0, z) + Vector(0.0f, 1.8f, 6.0f));
pLight = new LightComponent(pEntity);
omni.radius = 3.0f;
pLight->SetOmniLight(&omni);
pLight->SetColor(Float3(5.0f, 0.5f, 0.25f));
/*
for (int i = -3; i<=3; i++)
{
for (int j = 0; j<4; j++)
{
for (int k = -3; k<=3; k++)
{
Entity* pCube = g_pScene->CreateEntity();
pCube->SetPosition(12.0f * Vector(x,0,z) + 0.6f * Vector(i,j,k) + Vector(0.0f, 0.25f, 0.0f));
MeshComponent* pMesh = new MeshComponent(pCube);
pMesh->SetMeshResource("cube.nfm");
BodyComponent* pBody = new BodyComponent(pCube);
pBody->SetMass(0.0f);
pBody->EnablePhysics((CollisionShape*)Engine_GetResource(Mesh::COLLISION_SHAPE, "shape_box"));
}
}
}*/
}
}
#endif
// infinite looped scene
#ifdef SCENE_SEGMENTS
BufferOutputStream segmentDesc;
Matrix mat = MatrixRotationNormal(Vector(0, 1, 0), NFE_MATH_PI / 4.0f);
// create segments description buffer
{
OmniLightDesc omni;
LightComponent* pLight;
Entity entity;
entity.SetPosition(Vector());
//pEntity->SetMatrix(mat);
MeshComponent* pMesh = new MeshComponent(&entity);
pMesh->SetMeshResource("chamber.nfm");
BodyComponent* pBody = new BodyComponent(&entity);
pBody->EnablePhysics(pChamberShape);
entity.Serialize(&segmentDesc, Vector());
entity.RemoveAllComponents();
entity.SetPosition(Vector(0.0f, 3.5f, 0.0f));
/*
pLight = new LightComponent(&entity);
omni.m_ShadowFadeEnd = 12.0f;
omni.m_ShadowFadeStart = 8.0f;
omni.m_Radius = 9.0f;
pLight->SetOmniLight(&omni);
pLight->SetColor(Float3(50, 50, 50));
pLight->SetShadowMap(512);
entity.Serialize(&segmentDesc, Vector());
*/
entity.RemoveAllComponents();
entity.SetPosition(Vector(6.0f, 1.8f, 0.0f));
pLight = new LightComponent(&entity);
omni.m_Radius = 3.0f;
pLight->SetOmniLight(&omni);
pLight->SetColor(Float3(5.0f, 0.5f, 0.25f));
entity.Serialize(&segmentDesc, Vector());
entity.RemoveAllComponents();
entity.SetPosition(Vector(0.0f, 1.8f, 6.0f));
pLight = new LightComponent(&entity);
omni.m_Radius = 3.0f;
pLight->SetOmniLight(&omni);
pLight->SetColor(Float3(5.0f, 0.5f, 0.25f));
entity.Serialize(&segmentDesc, Vector());
}
#define SEG_AXIS_NUM 12
Segment* pSegments[SEG_AXIS_NUM][SEG_AXIS_NUM];
// create segments array
for (int i = 0; i < SEG_AXIS_NUM; i++)
{
for (int j = 0; j < SEG_AXIS_NUM; j++)
{
char segName[32];
sprintf_s(segName, "seg_%i_%i", i, j);
pSegments[i][j] = g_pScene->CreateSegment(segName, Vector(5.99f, 1000.0f, 5.99f));
pSegments[i][j]->AddEntityFromRawBuffer(segmentDesc.GetData(), segmentDesc.GetSize());
}
}
// create links
for (int x = 0; x < SEG_AXIS_NUM; x++)
{
for (int z = 0; z < SEG_AXIS_NUM; z++)
{
//make inifinite loop
for (int depth = 1; depth <= 5; depth++)
{
g_pScene->CreateLink(pSegments[x][z], pSegments[(x + depth) % SEG_AXIS_NUM][z],
Vector(depth * 12.0f, 0.0f, 0.0f));
g_pScene->CreateLink(pSegments[x][z], pSegments[x][(z + depth) % SEG_AXIS_NUM], Vector(0.0, 0.0f,
depth * 12.0f));
}
}
}
// Set focus
g_pScene->SetFocusSegment(pSegments[0][0]);
#endif
/*
for (int i = -4; i<4; i++)
{
for (int j = -10; j<10; j++)
{
for (int k = -4; k<4; k++)
{
Entity* pCube = g_pScene->CreateEntity();
pCube->SetPosition(0.75f * Vector(i,j,k));
MeshComponent* pMesh = new MeshComponent(pCube);
pMesh->SetMeshResource("cube.nfm");
BodyComponent* pBody = new BodyComponent(pCube);
pBody->SetMass(1.0f);
pBody->EnablePhysics((CollisionShape*)Engine_GetResource(Mesh::COLLISION_SHAPE, "shape_box"));
}
}
}
//set ambient & background color
envDesc.m_AmbientLight = Vector(0.001f, 0.001f, 0.001f, 0.0f);
envDesc.m_BackgroundColor = Vector(0.0f, 0.0f, 0.0f, 0.0f);
g_pScene->SetEnvironment(&envDesc);
// SUNLIGHT
Entity* pDirLightEnt = g_pScene->CreateEntity();
XOrientation orient;
orient.x = Vector(0.0f, -0.0f, -0.0f, 0.0f);
orient.z = Vector(-0.5f, -1.1f, 1.2f, 0.0f);
orient.y = Vector(0.0f, 1.0f, 0.0f, 0.0f);
pDirLightEnt->SetOrientation(&orient);
DirLightDesc dirLight;
dirLight.m_Far = 100.0f;
dirLight.m_Splits = 4;
dirLight.m_LightDist = 1000.0f;
LightComponent* pDirLight = new LightComponent(pDirLightEnt);
pDirLight->SetDirLight(&dirLight);
pDirLight->SetColor(Float3(2.2, 2, 1.8));
pDirLight->SetShadowMap(1024);
pFirstWindow->cameraEntity->SetPosition(Vector(0.0f, 1.6f, -20.0f, 0.0f));
*/
// message loop
DrawRequest drawRequests[2];
Common::Timer timer;
timer.Start();
while (!pWindow->isClosed())
{
//measure delta time
g_DeltaTime = (float)timer.Stop();
timer.Start();
UpdateRequest updateReq;
updateReq.pScene = g_pScene;
updateReq.deltaTime = g_DeltaTime;
pWindow->processMessages();
pWindow->UpdateCamera();
drawRequests[0].deltaTime = g_DeltaTime;
drawRequests[0].pView = pWindow->view;
drawRequests[1].deltaTime = g_DeltaTime;
drawRequests[1].pView = g_pSecondaryCameraView;
EngineAdvance(drawRequests, 2, &updateReq, 1);
ProcessSceneEvents();
// print focus segment name
wchar_t str[128];
Segment* pFocus = g_pScene->GetFocusSegment();
swprintf(str, L"NFEngine Demo (%S) - focus: %S", PLATFORM_STR,
(pFocus != 0) ? pFocus->GetName() : "NONE");
pWindow->setTitle(str);
}
// for testing purposes
Common::FileOutputStream test_stream("test.xml");
g_pScene->Serialize(&test_stream, SerializationFormat::Xml, false);
EngineDeleteScene(g_pScene);
delete pWindow;
EngineRelease();
//detect memory leaks
#ifdef _DEBUG
_CrtDumpMemoryLeaks();
#endif
return 0;
}
// the program starts here
void AppMain() {
// initialise GLFW
glfwSetErrorCallback(OnError);
if(!glfwInit())
throw std::runtime_error("glfwInit failed");
// open a window with GLFW
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
gWindow = glfwCreateWindow((int)SCREEN_SIZE.x, (int)SCREEN_SIZE.y, "Mek", NULL /*glfwGetPrimaryMonitor()*/, NULL);
if (!gWindow)
throw std::runtime_error("glfwCreateWindow failed. Can your hardware handle OpenGL 3.3?");
// GLFW settings
glfwSetInputMode(gWindow, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
glfwSetCursorPos(gWindow, 0, 0);
glfwSetScrollCallback(gWindow, OnScroll);
glfwMakeContextCurrent(gWindow);
// required or we crash on VAO creation
glewExperimental = GL_TRUE;
// initialise GLEW
if (glewInit() != GLEW_OK)
{
throw std::runtime_error("glewInit failed");
}
// GLEW throws some errors so discard all the errors so far
while(glGetError() != GL_NO_ERROR) {}
// Init DevIL
ilInit();
// enable vsync using windows only code
#ifdef _WIN32
// Turn on vertical screen sync under Windows.
typedef BOOL(WINAPI *PFNWGLSWAPINTERVALEXTPROC)(int interval);
PFNWGLSWAPINTERVALEXTPROC wglSwapIntervalEXT = NULL;
wglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC)wglGetProcAddress("wglSwapIntervalEXT");
if (wglSwapIntervalEXT)
wglSwapIntervalEXT(1);
#endif
// print out some info about the graphics drivers
std::cout << "OpenGL version: " << glGetString(GL_VERSION) << std::endl;
std::cout << "GLSL version: " << glGetString(GL_SHADING_LANGUAGE_VERSION) << std::endl;
std::cout << "Vendor: " << glGetString(GL_VENDOR) << std::endl;
std::cout << "Renderer: " << glGetString(GL_RENDERER) << std::endl;
// make sure OpenGL version 3.2 API is available
if(!GLEW_VERSION_3_3)
throw std::runtime_error("OpenGL 3.3 API is not available.");
// OpenGL settings
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// initialise the gWoodenCrate asset
LoadWoodenCrateAsset();
// create all the instances in the 3D scene based on the gWoodenCrate asset
CreateInstances();
// setup Camera::getInstance()
Camera::getInstance().setPosition(glm::vec3(1100, 75, 0));
Camera::getInstance().setViewportAspectRatio(SCREEN_SIZE.x / SCREEN_SIZE.y);
Camera::getInstance().setNearAndFarPlanes(1.f, 500.0f);
Camera::getInstance().setFieldOfView(179);
crosshair = new twodOverlay("crosshair.png", 0, 0, 1);
skull = new twodOverlayAnim("killSkull.png", 5, 0.5);
startscreen = new twodOverlay("pressStart.png", 0, 0, 10);
skull->updatePos(-0.85f, -0.75f, 4);
skull ->cycle = true;
//MODEL INITS
prepProjectiles();
model = new GameObject(0);
model->SetName("Moving");
gModel = new ComponentGraphics();
gModel->setOwner(model);
gModel->loadModel("models/TallCube.dae");
Component* gp = gModel;
model->AddComponent(GRAPHICS, gp);
gCol = new ComponentCollision();
gCol->setCollisionMask(gModel->getScene());
gCol->setOwner(model);
model->pos = glm::vec3(7.5, 0.5, -11);
model->vel = 0.01;
model->dir = glm::vec3(1, 0, 0);
model->scale = glm::vec3(5, 5, 5);
gCol->type = MOVING;
gCol->createHitboxRender();
gp = gCol;
model->AddComponent(PHYSICS, gp);
ComponentInput* ci = new ComponentInput(0.05,0.05);
gp = ci;
model->AddComponent(CONTROLLER, gp);
//PROPER INIT
for (int i = 0; i < 22; i++)
{
if (i != 3 && i != 0 && i != 4 && i != 8 && i != 18 && i != 19 && i != 20 && i !=21)
{
GameObject *gObject = new GameObject(goVec.size());
ComponentGraphics *cModel = new ComponentGraphics();
ComponentCollision *cCollision = new ComponentCollision();
Component *c;
if (i == 0)
{
gObject->SetName("Spawn Container 1");
cModel->loadModel("models/Container.dae");
gObject->scale = glm::vec3(0.7, 0.7, 0.7);
gObject->pos = glm::vec3(60, 0, -110);
}
else if (i == 1)
{
gObject->SetName("Water Tower");
cModel->loadModel("models/Watertower.dae");
gObject->scale = glm::vec3(3, 3, 3);
gObject->pos = glm::vec3(-65, 0, -90);
}
else if (i == 2)
{
gObject->SetName("MenuScene");
cModel->loadModel("models/Warehouse_One_mesh_No_roof.dae");
gObject->scale = glm::vec3(1, 1, 1);// glm::vec3(1.6, 1.6, 1.6);
gObject->pos = glm::vec3(10000, 0, 0);
}
else if (i == 3)
{
gObject->SetName("Spawn Container 2");
cModel->loadModel("models/Container90.dae");
gObject->scale = glm::vec3(0.7, 0.7, 0.7);
gObject->pos = glm::vec3(85, 0, -75);
}
else if (i == 4)
{
gObject->SetName("Middle Plus");
cModel->loadModel("models/Container.dae");
gObject->scale = glm::vec3(0.7, 0.7, 0.7);
gObject->pos = glm::vec3(15, 0, -20);
}
else if (i == 5)
{
gObject->SetName("North Wall");
cModel->loadModel("models/Container_Wal_LPl.dae");
gObject->scale = glm::vec3(0.7, 0.70, 0.70);
gObject->pos = glm::vec3(100, 0, 165);
}
else if (i == 6)
{
gObject->SetName("Dumbster");//Crane
cModel->loadModel("models/Dumspter2.dae");
gObject->pos = glm::vec3(0, 0, -140);
gObject->scale = glm::vec3(0.4, 0.4, 0.4);
}
else if (i == 7)
{
gObject->SetName("Shack");
cModel->loadModel("models/Shack.dae");
gObject->scale = glm::vec3(0.75, 0.75, 0.75);
gObject->pos = glm::vec3(0, 0, 120);
}
else if (i == 8)
{
gObject->SetName("Middle Plus");
cModel->loadModel("models/Container.dae");
gObject->scale = glm::vec3(0.7, 0.7, 0.7);
gObject->pos = glm::vec3(-5, 0, -20);
}
else if (i == 9)
{
gObject->SetName("Container 2");
cModel->loadModel("models/Container.dae");
gObject->scale = glm::vec3(0.70, 0.70, 0.70);
gObject->pos = glm::vec3(80, 0, 100);
}
else if (i == 10)
{
gObject->SetName("South Wall");
cModel->loadModel("models/Container_Wal_LPl.dae");
gObject->scale = glm::vec3(0.7, 0.70, 0.70);
gObject->pos = glm::vec3(-100, 0, 165);
}
else if (i == 11)
{
gObject->SetName("East Wall");
cModel->loadModel("models/Container_Wal_LP90.dae");
gObject->scale = glm::vec3(0.7, 0.70, 0.70);
gObject->pos = glm::vec3(50, 0, 145);
}
else if (i == 12)
{
gObject->SetName("West Wall");
cModel->loadModel("models/Container_Wal_LP90.dae");
gObject->scale = glm::vec3(0.7, 0.70, 0.70);
gObject->pos = glm::vec3(50, 0, -125);
}
else if (i == 13)
{
gObject->SetName("Container 2");
cModel->loadModel("models/Container.dae");
gObject->scale = glm::vec3(0.70, 0.70, 0.70);
gObject->pos = glm::vec3(60, 0, 100);
}
else if (i == 14)
{
gObject->SetName("Container 90");
cModel->loadModel("models/Container90.dae");
gObject->scale = glm::vec3(0.70, 0.70, 0.70);
gObject->pos = glm::vec3(70, 0, 70);
}
else if (i == 15)
{
gObject->SetName("Shack");
cModel->loadModel("models/Shack.dae");
gObject->scale = glm::vec3(0.75, 0.75, 0.75);
gObject->pos = glm::vec3(-30, 0, 120);
}
else if (i == 16)
{
gObject->SetName("Shack");
cModel->loadModel("models/Shack.dae");
gObject->scale = glm::vec3(0.75, 0.75, 0.75);
gObject->pos = glm::vec3(30, 0, 120);
}
else if (i == 17)
{
gObject->SetName("Shack");
cModel->loadModel("models/Shack.dae");
gObject->scale = glm::vec3(0.75, 0.75, 0.75);
gObject->pos = glm::vec3(-60, 0, 120);
}
else if (i == 18)
{
gObject->SetName("Middle Plus North");
cModel->loadModel("models/Container90.dae");
gObject->scale = glm::vec3(0.7, 0.7, 0.7);
gObject->pos = glm::vec3(27, 0, -5);
}
else if (i == 19)
{
gObject->SetName("Middle Plus North");
cModel->loadModel("models/Container90.dae");
gObject->scale = glm::vec3(0.7, 0.7, 0.7);
gObject->pos = glm::vec3(27, 0, 15);
}
else if (i == 20)
{
gObject->SetName("Middle Plus North");
cModel->loadModel("models/Container90.dae");
gObject->scale = glm::vec3(0.7, 0.7, 0.7);
gObject->pos = glm::vec3(-20, 0, 15);
}
else if (i == 21)
{
gObject->SetName("Middle Plus North");
cModel->loadModel("models/Container90.dae");
gObject->scale = glm::vec3(0.7, 0.7, 0.7);
gObject->pos = glm::vec3(-20, 0, -5);
}
gObject->pos /= 10.f;
cModel->setOwner(gObject);
c = cModel;
gObject->AddComponent(GRAPHICS, c);
cCollision->setOwner(gObject);
cCollision->setCollisionMask(cModel->getScene());
cCollision->type = STATIC;
cCollision->setCollisionElip(glm::vec3(1, 1, 1));
cCollision->createHitboxRender();
gObject->AddComponent(PHYSICS, cCollision);
goVec.push_back(gObject);
}
}
LoadTargets();
spotLightColour = glm::normalize(spotLightColour);
for (int i = 0; i < 6; i++)
{
LightComponent* light;
if (i == 0)
{
light = new LightComponent(lSPOT);
SpotLight* lc = new SpotLight;
lc->Base.Base.Color = spotLightColour;
lc->Base.Base.AmbientIntensity = 0.1f;
lc->Base.Base.DiffuseIntensity = 0.1f;
lc->Base.Atten.Constant = 0.1f;
lc->Base.Atten.Exp = 0.1f;
lc->Base.Atten.Linear = 0.1f;
lc->Cutoff = 0.75f;
lc->Base.Position = glm::vec3(-6, 1, 11);
lc->Direction = glm::vec3(0, 0, -1);
light->SetVars(lSPOT, lc);
}
if (i == 1)
{
light = new LightComponent(lSPOT);
SpotLight* lc = new SpotLight;
lc->Base.Base.Color = spotLightColour;
lc->Base.Base.AmbientIntensity = 0.5f;
lc->Base.Base.DiffuseIntensity = 0.5f;
lc->Base.Atten.Constant = 0.5f;
lc->Base.Atten.Exp = 0.5f;
lc->Base.Atten.Linear = 0.5f;
lc->Cutoff = 0.75f;
lc->Base.Position = glm::vec3(3, 1, 11);
lc->Direction = (glm::vec3(0, 0, 10));
light->SetVars(lSPOT, lc);
}
if (i == 2)
{
//light = new LightComponent(lSPOT);
//SpotLight* lc = new SpotLight;
//lc->Base.Base.Color = glm::vec3(0,0.1,0);
//lc->Base.Base.AmbientIntensity = 0.5f;
//lc->Base.Base.DiffuseIntensity = 0.5f;
//
//lc->Base.Atten.Constant = 0.5f;
//lc->Base.Atten.Exp = 0.5f;
//lc->Base.Atten.Linear = 0.5f;
//
//lc->Cutoff = 0.75f;
//lc->Base.Position = glm::vec3(-3, 1, 11);
//lc->Direction = (glm::vec3(-3, 0, 12));
//
//light->SetVars(lSPOT, lc);
}
if (i == 3)
{
//light = new LightComponent(lSPOT);
//SpotLight* lc = new SpotLight;
//lc->Base.Base.Color = spotLightColour;
//lc->Base.Base.AmbientIntensity = 0.5f;
//lc->Base.Base.DiffuseIntensity = 0.5f;
//
//lc->Base.Atten.Constant = 0.5f;
//lc->Base.Atten.Exp = 0.5f;
//lc->Base.Atten.Linear = 0.5f;
//
//lc->Cutoff = 0.75f;
//lc->Base.Position = glm::vec3(-6, 1, 11);
//lc->Direction = (glm::vec3(-6, 1, 12));
//
//light->SetVars(lSPOT, lc);
}
if (i == 4)
{
//light = new LightComponent(lSPOT);
//SpotLight* lc = new SpotLight;
//lc->Base.Base.Color = spotLightColour;
//lc->Base.Base.AmbientIntensity = 0.1f;
//lc->Base.Base.DiffuseIntensity = 0.1f;
//
//lc->Base.Atten.Constant = 0.1f;
//lc->Base.Atten.Exp = 0.1f;
//lc->Base.Atten.Linear = 0.1f;
//
//lc->Cutoff = 0.75f;
//lc->Base.Position = glm::vec3(0, 1, 0);
//lc->Direction = glm::vec3(0, -1, 0);
//
//light->SetVars(lSPOT, lc);
}
if (i == 5)
{
light = new LightComponent(lSPOT);
SpotLight* lc = new SpotLight;
lc->Base.Base.Color = spotLightColour;
lc->Base.Base.AmbientIntensity = 0.5f;
lc->Base.Base.DiffuseIntensity = 0.5f;
lc->Base.Atten.Constant = 0.5f;
lc->Base.Atten.Exp = 0.5f;
lc->Base.Atten.Linear = 0.5f;
lc->Cutoff = 0.5f;
lc->Base.Position = glm::vec3(1000, 1, 0);//4 1 0
lc->Direction = glm::vec3(0, -1, 0);// 5 0 0
light->SetVars(lSPOT, lc);
}
}
animatedMech = new GameObject(100);
animatedMechGC = new ComponentGraphics();
animatedMechGC->loadModel("models/Test_Animation_DAE.dae");
Component* c = animatedMechGC;
animatedMech->AddComponent(GRAPHICS, c);
animatedMech->pos = glm::vec3(0, 0, 0);
animatedMech->scale = glm::vec3(1, 1, 1);
//END MODEL INITS
camInterp.points.push_back(glm::vec3(1025, 1, 0));
camInterp.points.push_back(glm::vec3(1000, 1, 25));
camInterp.points.push_back(glm::vec3(975, 1, 0));
camInterp.points.push_back(glm::vec3(1000, 1, -25));
camInterp.points.push_back(glm::vec3(1025, 1, 0));
camInterp.state = SLERP;
camInterp.buildCurve();
TextRendering::getInstance().initText2D("MekFont.bmp");
fontColour = glm::normalize(fontColour);
wglSwapIntervalEXT(1);
// run while the window is open
double lastTime = glfwGetTime();
while(!glfwWindowShouldClose(gWindow)){
// process pending events
glfwPollEvents();
// update the scene based on the time elapsed since last update
double thisTime = glfwGetTime();
Update((float)(thisTime - lastTime));
lastTime = thisTime;
// draw one frame
Render();
// check for errors
GLenum error = glGetError();
if (error != GL_NO_ERROR)
{
std::cerr << "OpenGL Error " << error << " - " << glewGetErrorString(error) << std::endl;
}
//exit program if escape key is pressed
if(glfwGetKey(gWindow, GLFW_KEY_ESCAPE))
glfwSetWindowShouldClose(gWindow, GL_TRUE);
}
// clean up and exit
glfwTerminate();
}
void ShadowComponent::Finished()
{
using namespace dtEntity;
BaseClass::Finished();
assert(mEntity != NULL);
osgShadow::MinimalShadowMap* msm = NULL;
osgShadow::ParallelSplitShadowMap* pssm = NULL;
PropertyGroup props = mShadowType.GroupValue();
StringId selected = props[__SELECTED__Id]->StringIdValue();
if(mEnabled.Get() == false)
{
mTechnique = NULL;
}
else if(selected == LISPId)
{
msm = new osgShadow::LightSpacePerspectiveShadowMapDB();
mTechnique = msm;
}/*
else if(mShadowTechnique.Get() == "LISPSM_ViewBounds")
{
msm = new osgShadow::LightSpacePerspectiveShadowMapVB();
mTechnique = msm;
}
else if(mShadowTechnique.Get() == "LISPSM_CullBounds")
{
msm = new osgShadow::LightSpacePerspectiveShadowMapCB();
mTechnique = msm;
}*/
else if(selected == PSSMId)
{
PropertyGroup pssmgrp = props[PSSMId]->GroupValue();
pssm = new osgShadow::ParallelSplitShadowMap(0, pssmgrp[MapCountId]->UIntValue());
pssm->setTextureResolution(pssmgrp[MapResId]->UIntValue());
if(pssmgrp[MinNearSplitId]->UIntValue() != 0)
{
pssm->setMinNearDistanceForSplits(pssmgrp[MinNearSplitId]->UIntValue());
}
if(pssmgrp[MaxFarDistId]->UIntValue() != 0)
{
pssm->setMaxFarDistance(pssmgrp[MaxFarDistId]->UIntValue());
pssm->setMoveVCamBehindRCamFactor(pssmgrp[MoveVCamFactorId]->FloatValue());
}
if(pssmgrp[DebugColorOnId]->BoolValue())
{
pssm->setDebugColorOn();
}
pssm->setPolygonOffset(osg::Vec2(
pssmgrp[PolyOffsetFactorId]->FloatValue(),
pssmgrp[PolyOffsetUnitId]->FloatValue()));
mTechnique = pssm;
}
else
{
return;
}
osgShadow::ShadowedScene* shadowedScene = static_cast<osgShadow::ShadowedScene*>(GetNode());
shadowedScene->setShadowTechnique(mTechnique);
OSGSystemInterface* iface = static_cast<OSGSystemInterface*>(GetSystemInterface());
osg::ref_ptr<osg::Light> light = iface->GetPrimaryView()->getLight();
if(msm)
{
PropertyGroup lispgrp = props[LISPId]->GroupValue();
msm->setTextureSize(osg::Vec2s(lispgrp[TexSizeId]->UIntValue(), lispgrp[TexSizeId]->UIntValue()) );
msm->setMinLightMargin(lispgrp[MinLightMarginId]->FloatValue());
msm->setMaxFarPlane(lispgrp[MaxFarPlaneId]->FloatValue());
msm->setBaseTextureCoordIndex(lispgrp[BaseTexCoordIndexId]->UIntValue());
msm->setShadowTextureCoordIndex(lispgrp[ShadowTexCoordIndexId]->UIntValue());
msm->setShadowTextureUnit(lispgrp[ShadowTexUnitId]->UIntValue());
msm->setBaseTextureUnit(lispgrp[BaseTexUnitId]->UIntValue());
msm->setLight(light);
// setting these for PSSM breaks shadows, so only do it here ...
shadowedScene->setReceivesShadowTraversalMask(NodeMasks::RECEIVES_SHADOWS);
shadowedScene->setCastsShadowTraversalMask(NodeMasks::CASTS_SHADOWS);
}
if(pssm)
{
LightSystem* ls;
if(mEntity->GetEntityManager().GetEntitySystem(LightComponent::TYPE, ls) && ls->GetNumComponents() != 0)
{
for(LightSystem::ComponentStore::iterator i = ls->begin(); i != ls->end(); ++i)
{
LightComponent* lcomp = i->second;
osg::ref_ptr<osg::Group> lightsource = lcomp->GetNode()->asGroup();
lightsource->getParent(0)->removeChild(lightsource);
GetGroup()->addChild(lightsource);
}
}
}
}
void DebugRenderSystem::Process()
{
uint32 size = entities.size();
for(uint32 i = 0; i < size; ++i)
{
Entity * entity = entities[i];
DebugRenderComponent * debugRenderComponent = cast_if_equal<DebugRenderComponent*>(entity->GetComponent(Component::DEBUG_RENDER_COMPONENT));
TransformComponent * transformComponent = cast_if_equal<TransformComponent*>(entity->GetComponent(Component::TRANSFORM_COMPONENT));
//RenderComponent * renderComponent = cast_if_equal<RenderComponent*>(entity->GetComponent(Component::RENDER_COMPONENT));
Matrix4 worldTransform = /*(*transformComponent->GetWorldTransform()) * */camera->GetMatrix();
RenderManager::Instance()->SetMatrix(RenderManager::MATRIX_MODELVIEW, camera->GetMatrix());
AABBox3 debugBoundigBox = entity->GetWTMaximumBoundingBoxSlow();
uint32 debugFlags = debugRenderComponent->GetDebugFlags();
// Camera debug draw
if(debugFlags & DebugRenderComponent::DEBUG_DRAW_CAMERA)
{
CameraComponent * entityCameraComp = (CameraComponent *) entity->GetComponent(Component::CAMERA_COMPONENT);
if(NULL != entityCameraComp)
{
Camera* entityCamera = entityCameraComp->GetCamera();
if(NULL != entityCamera && camera != entityCamera)
{
Color camColor(0.0f, 1.0f, 0.0f, 1.0f);
Vector3 camPos = entityCamera->GetPosition();
//Vector3 camDirect = entityCamera->GetDirection();
AABBox3 camBox(camPos, 2.5f);
// If this is clip camera - show it as red camera
if (entityCamera == entity->GetScene()->GetClipCamera()) camColor = Color(1.0f, 0.0f, 0.0f, 1.0f);
RenderManager::Instance()->SetRenderEffect(RenderManager::FLAT_COLOR);
RenderManager::Instance()->SetState(RenderState::STATE_COLORMASK_ALL | RenderState::STATE_DEPTH_WRITE);
RenderManager::Instance()->SetColor(camColor);
RenderHelper::Instance()->DrawBox(camBox, 2.5f);
RenderManager::Instance()->SetState(RenderState::DEFAULT_3D_STATE);
RenderManager::Instance()->ResetColor();
debugBoundigBox = camBox;
}
}
}
// UserNode debug draw
if(debugFlags & DebugRenderComponent::DEBUG_DRAW_USERNODE)
{
if(NULL != entity->GetComponent(Component::USER_COMPONENT))
{
Color dcColor(0.0f, 0.0f, 1.0f, 1.0f);
AABBox3 dcBox(Vector3(), 1.0f);
Matrix4 prevMatrix = RenderManager::Instance()->GetMatrix(RenderManager::MATRIX_MODELVIEW);
Matrix4 finalMatrix = transformComponent->GetWorldTransform() * prevMatrix;
RenderManager::Instance()->SetMatrix(RenderManager::MATRIX_MODELVIEW, finalMatrix);
RenderManager::Instance()->SetRenderEffect(RenderManager::FLAT_COLOR);
RenderManager::Instance()->SetState(RenderState::STATE_COLORMASK_ALL | RenderState::STATE_DEPTH_WRITE | RenderState::STATE_DEPTH_TEST);
RenderManager::Instance()->SetColor(1.f, 1.f, 0, 1.0f);
RenderHelper::Instance()->DrawLine(Vector3(0, 0, 0), Vector3(1.f, 0, 0));
RenderManager::Instance()->SetColor(1.f, 0, 1.f, 1.0f);
RenderHelper::Instance()->DrawLine(Vector3(0, 0, 0), Vector3(0, 1.f, 0));
RenderManager::Instance()->SetColor(0, 1.f, 1.f, 1.0f);
RenderHelper::Instance()->DrawLine(Vector3(0, 0, 0), Vector3(0, 0, 1.f));
RenderManager::Instance()->SetColor(dcColor);
RenderHelper::Instance()->DrawBox(dcBox);
RenderManager::Instance()->SetState(RenderState::DEFAULT_3D_STATE);
RenderManager::Instance()->ResetColor();
RenderManager::Instance()->SetMatrix(RenderManager::MATRIX_MODELVIEW, prevMatrix);
dcBox.GetTransformedBox(transformComponent->GetWorldTransform(), debugBoundigBox);
}
}
// LightNode debug draw
if (debugFlags & DebugRenderComponent::DEBUG_DRAW_LIGHT_NODE)
{
LightComponent *lightComp = (LightComponent *) entity->GetComponent(Component::LIGHT_COMPONENT);
if(NULL != lightComp)
{
Light* light = lightComp->GetLightObject();
if(NULL != light)
{
Vector3 lPosition = light->GetPosition();
RenderManager::Instance()->SetRenderEffect(RenderManager::FLAT_COLOR);
RenderManager::Instance()->SetState(RenderState::STATE_COLORMASK_ALL | RenderState::STATE_DEPTH_WRITE);
RenderManager::Instance()->SetColor(1.0f, 1.0f, 0.0f, 1.0f);
switch (light->GetType())
{
case Light::TYPE_DIRECTIONAL:
{
Vector3 lDirection = light->GetDirection();
RenderHelper::Instance()->DrawArrow(lPosition, lPosition + lDirection * 10, 2.5f);
RenderHelper::Instance()->DrawBox(AABBox3(lPosition, 0.5f), 1.5f);
debugBoundigBox = AABBox3(lPosition, 2.5f);
}
break;
default:
{
AABBox3 lightBox(lPosition, 2.5f);
RenderHelper::Instance()->DrawBox(lightBox, 2.5f);
debugBoundigBox = lightBox;
}
break;
}
RenderManager::Instance()->SetState(RenderState::DEFAULT_3D_STATE);
RenderManager::Instance()->ResetColor();
}
}
}
if ((debugFlags & DebugRenderComponent::DEBUG_DRAW_AABOX_CORNERS))
{
RenderManager::Instance()->SetRenderEffect(RenderManager::FLAT_COLOR);
RenderManager::Instance()->SetState(RenderState::STATE_COLORMASK_ALL | RenderState::STATE_DEPTH_WRITE | RenderState::STATE_DEPTH_TEST);
RenderManager::Instance()->SetColor(1.0f, 1.0f, 1.0f, 1.0f);
RenderHelper::Instance()->DrawCornerBox(debugBoundigBox, 1.5f);
RenderManager::Instance()->SetState(RenderState::DEFAULT_3D_STATE);
RenderManager::Instance()->SetColor(1.0f, 1.0f, 1.0f, 1.0f);
// RenderManager::Instance()->SetMatrix(RenderManager::MATRIX_MODELVIEW, prevMatrix);
}
if (debugFlags & DebugRenderComponent::DEBUG_DRAW_RED_AABBOX)
{
RenderManager::Instance()->SetRenderEffect(RenderManager::FLAT_COLOR);
RenderManager::Instance()->SetState(RenderState::STATE_COLORMASK_ALL | RenderState::STATE_DEPTH_WRITE);
RenderManager::Instance()->SetColor(1.0f, 0.0f, 0.0f, 1.0f);
RenderHelper::Instance()->DrawBox(debugBoundigBox, 1.5f);
RenderManager::Instance()->SetState(RenderState::DEFAULT_3D_STATE);
RenderManager::Instance()->SetColor(1.0f, 1.0f, 1.0f, 1.0f);
}
// UserNode Draw
#if 0
if (debugFlags & DEBUG_DRAW_USERNODE)
{
Matrix4 prevMatrix = RenderManager::Instance()->GetMatrix(RenderManager::MATRIX_MODELVIEW);
Matrix4 finalMatrix = worldTransform * prevMatrix;
RenderManager::Instance()->SetMatrix(RenderManager::MATRIX_MODELVIEW, finalMatrix);
RenderManager::Instance()->SetRenderEffect(RenderManager::FLAT_COLOR);
RenderManager::Instance()->SetState(RenderStateBlock::STATE_COLORMASK_ALL | RenderStateBlock::STATE_DEPTH_WRITE | RenderStateBlock::STATE_DEPTH_TEST);
RenderManager::Instance()->SetColor(0, 0, 1.0f, 1.0f);
RenderHelper::Instance()->DrawBox(drawBox);
RenderManager::Instance()->SetColor(1.f, 1.f, 0, 1.0f);
RenderHelper::Instance()->DrawLine(Vector3(0, 0, 0), Vector3(1.f, 0, 0));
RenderManager::Instance()->SetColor(1.f, 0, 1.f, 1.0f);
RenderHelper::Instance()->DrawLine(Vector3(0, 0, 0), Vector3(0, 1.f, 0));
RenderManager::Instance()->SetColor(0, 1.f, 1.f, 1.0f);
RenderHelper::Instance()->DrawLine(Vector3(0, 0, 0), Vector3(0, 0, 1.f));
RenderManager::Instance()->SetState(RenderStateBlock::DEFAULT_3D_STATE);
RenderManager::Instance()->SetColor(1.0f, 1.0f, 1.0f, 1.0f);
RenderManager::Instance()->SetMatrix(RenderManager::MATRIX_MODELVIEW, prevMatrix);
}
#endif
#if 0
// ParticleEffectNode
if (debugFlags != DEBUG_DRAW_NONE)
{
if (!(flags & SceneNode::NODE_VISIBLE))return;
RenderManager::Instance()->SetRenderEffect(RenderManager::FLAT_COLOR);
RenderManager::Instance()->SetState(RenderStateBlock::STATE_COLORMASK_ALL | RenderStateBlock::STATE_DEPTH_WRITE);
Vector3 position = Vector3(0.0f, 0.0f, 0.0f) * GetWorldTransform();
Matrix3 rotationPart(GetWorldTransform());
Vector3 direction = Vector3(0.0f, 0.0f, 1.0f) * rotationPart;
direction.Normalize();
RenderManager::Instance()->SetColor(0.0f, 0.0f, 1.0f, 1.0f);
RenderHelper::Instance()->DrawLine(position, position + direction * 10, 2.f);
RenderManager::Instance()->SetState(RenderStateBlock::DEFAULT_3D_STATE);
RenderManager::Instance()->SetColor(1.0f, 1.0f, 1.0f, 1.0f);
}
#endif
}
}
