//----------------------------------------------------------------------------
bool PlanarShadowEffect::GetProjectionMatrix (int i, HMatrix& projection)
{
// Compute the equation for the shadow plane in world coordinates.
APoint vertex[3];
mPlanes[i]->GetWorldTriangle(0, vertex);
HPlane worldPlane(vertex[0], vertex[1], vertex[2]);
// This is a conservative test to see whether a shadow should be cast.
// This can cause incorrect results if the caster is large and intersects
// the plane, but ordinarily we are not trying to cast shadows in such
// situations.
if (mShadowCaster->WorldBound.WhichSide(worldPlane) < 0)
{
// The shadow caster is on the far side of plane, so it cannot cast
// a shadow.
return false;
}
// Compute the projection matrix for the light source.
Light* projector = mProjectors[i];
AVector normal = worldPlane.GetNormal();
if (projector->GetType() == Light::LT_DIRECTIONAL)
{
float NdD = normal.Dot(projector->DVector);
if (NdD >= 0.0f)
{
// The projection must be onto the "positive side" of the plane.
return false;
}
projection.MakeObliqueProjection(vertex[0], normal,
projector->DVector);
}
else if (projector->GetType() == Light::LT_POINT
|| projector->GetType() == Light::LT_SPOT)
{
float NdE = projector->Position.Dot(normal);
if (NdE <= 0.0f)
{
// The projection must be onto the "positive side" of the plane.
return false;
}
projection.MakePerspectiveProjection(vertex[0], normal,
projector->Position);
}
else
{
assertion(false, "Light type not supported.\n");
return false;
}
return true;
}
void EditorLightNode::Update(float32 timeElapsed)
{
Light * parent = (Light*)GetParent();
if(type != parent->GetType())
{
RemoveAllChildren();
type = parent->GetType();
SceneNode * lightDrawNode = scene->GetRootNode(GetSceneFile())->Clone();
AddNode(lightDrawNode);
SafeRelease(lightDrawNode);
}
}
void renderer::setLight(u32 index, Light & light)
{
switch (light.GetType()) {
case Light::POSITION: {
if (light.m_position.w == 0.0f)
light.m_position.w = 1.0f;
}
break;
case Light::SPOT: {
}
break;
case Light::DIRECTIONAL: {
if (light.m_position.w != 0.0f)
light.m_position.w = 0.0f;
}
break;
}
//
ew_glLightfv(GL_LIGHT0 + index, GL_POSITION, (const GLfloat *) light.m_position.GetDataPtr());
ew_glLightfv(GL_LIGHT0 + index, GL_AMBIENT, (const GLfloat *) light.m_ambient.GetDataPtr());
ew_glLightfv(GL_LIGHT0 + index, GL_DIFFUSE, (const GLfloat *) light.m_diffuse.GetDataPtr());
ew_glLightfv(GL_LIGHT0 + index, GL_SPECULAR, (const GLfloat *) light.m_specular.GetDataPtr());
// This part is untested
ew_glLightfv(GL_LIGHT0 + index, GL_SPOT_DIRECTION, (const GLfloat *) light.m_direction.GetDataPtr());
// ew_glLightf(GL_LIGHT0 + index, GL_SPOT_CUTOFF, light.m_spot_cutoff);
// ew_glLightf(GL_LIGHT0 + index, GL_SPOT_EXPONENT, light.m_spot_exponent);
//
ew_glLightf(GL_LIGHT0 + index, GL_CONSTANT_ATTENUATION, light.m_constant_attenuation);
ew_glLightf(GL_LIGHT0 + index, GL_LINEAR_ATTENUATION, light.m_linear_attenuation);
ew_glLightf(GL_LIGHT0 + index, GL_QUADRATIC_ATTENUATION, light.m_quadratic_attenuation);
}
//----------------------------------------------------------------------------
void RawTerrainPage::UpdateWorldData (double applicationTime)
{
TriMesh::UpdateWorldData(applicationTime);
PX2::Light *light = 0;
for (int i=0; i<(int)mInfulencedLights.size(); i++)
{
Light *lit = mInfulencedLights[i];
if (lit->GetType() == Light::LT_DIRECTIONAL)
{
light = lit;
break;
}
}
if (light!=0 && light!=mDirLight)
{
mDirLight = light;
mMaterialInstance->SetPixelConstant(0, "gLightModelDirection",
new0 LightModelDVectorConstant(mDirLight));
mMaterialInstance->SetPixelConstant(0, "gLightColour",
new0 LightDiffuseConstant(mDirLight));
}
}
void World::CullLights(VisibleCullResult & result, Camera * cam)
{
List<Light*>::Iterator whr = mLights.Begin();
List<Light*>::Iterator end = mLights.End();
while (whr != end)
{
// current it's false
Light * light = *whr;
if (!light->IsVisible())
continue;
switch (light->GetType())
{
case LT_DIRECTIONAL:
result.lights.PushBack(light);
break;
case LT_POINT:
case LT_SPOT:
{
Sphere sph = Sphere(light->GetPosition(), light->GetRange());
if (cam->IsVisible(sph))
result.lights.PushBack(light);
}
break;
}
++whr;
}
}
//----------------------------------------------------------------------------
void RawTerrainPage::CreateEditMtlInstPerVertex (EditTerrainMaterial *material,
Shine *shine)
{
PX2::Light *light = 0;
for (int i=0; i<(int)mInfulencedLights.size(); i++)
{
Light *lit = mInfulencedLights[i];
if (lit->GetType() == Light::LT_DIRECTIONAL)
{
light = lit;
break;
}
}
if (light == 0)
{
light = new0 Light(Light::LT_DIRECTIONAL);
light->Ambient = Float4(1.0f, 0.8f, 0.8f, 1.0f);
light->Diffuse = Float4(1.0f, 0.8f, 0.6f, 1.0f);
light->Intensity = 1.0f;
light->SetDirection(AVector(-1.0f, -1.0f, -1.0f));
}
mMtlInst = new0 MaterialInstance(material, 0);
mMtlInst->SetVertexConstant(0, "gPVWMatrix", new0 PVWMatrixConstant());
mMtlInst->SetVertexConstant(0, "gShineEmissive",
new0 ShineEmissiveConstant(shine));
mMtlInst->SetVertexConstant(0, "gShineAmbient",
new0 ShineAmbientConstant(shine));
mMtlInst->SetVertexConstant(0, "gShineDiffuse",
new0 ShineDiffuseConstant(shine));
mMtlInst->SetVertexConstant(0, "gLightModelDirection",
new0 LightModelDVectorConstant(light));
mMtlInst->SetVertexConstant(0, "gLightColour",
new0 LightDiffuseConstant(light));
mMtlInst->SetVertexConstant(0, "gLightAttenuation",
new0 LightAttenuationConstant(light));
mMtlInst->SetPixelConstant(0, "UVScale01", mUV01Float);
mMtlInst->SetPixelConstant(0, "UVScale23", mUV23Float);
mMtlInst->SetPixelConstant(0, "UVScale4", mUV4Float);
SetTexture0(mTextureDefaultFilename);
SetTextureAlpha(mTextureAlpha);
SetTexture1(mTextureDefaultFilename);
SetTexture2(mTextureDefaultFilename);
SetTexture3(mTextureDefaultFilename);
SetTexture4(mTextureDefaultFilename);
SetMaterialInstance(mMtlInst);
}
void LightPropertyControl::OnIntPropertyChanged(PropertyList *forList, const String &forKey, int newValue)
{
Light *light = GetLight(currentSceneNode);
if("Shadow samples" == forKey)
{
if(Light::TYPE_DIRECTIONAL == light->GetType())
{
currentSceneNode->GetCustomProperties()->SetInt32("editor.staticlight.shadowsamples", newValue);
}
}
NodesPropertyControl::OnIntPropertyChanged(forList, forKey, newValue);
}
void LightPropertyControl::OnFloatPropertyChanged(PropertyList *forList, const String &forKey, float newValue)
{
Light *light = GetLight(currentSceneNode);
if("Intensity" == forKey)
{
currentSceneNode->GetCustomProperties()->SetFloat("editor.intensity", newValue);
}
else if("Shadow angle" == forKey)
{
if(Light::TYPE_DIRECTIONAL == light->GetType())
{
currentSceneNode->GetCustomProperties()->SetFloat("editor.staticlight.shadowangle", newValue);
}
}
else if("Shadow radius" == forKey)
{
if(Light::TYPE_POINT == light->GetType())
{
currentSceneNode->GetCustomProperties()->SetFloat("editor.staticlight.shadowradius", newValue);
}
}
else if("Falloff cutoff" == forKey)
{
currentSceneNode->GetCustomProperties()->SetFloat("editor.staticlight.falloffcutoff", newValue);
}
else if("Falloff exponent" == forKey)
{
currentSceneNode->GetCustomProperties()->SetFloat("editor.staticlight.falloffexponent", newValue);
}
else if("property.lightnode.intensity" == forKey)
{
light->SetIntensity(newValue);
}
NodesPropertyControl::OnFloatPropertyChanged(forList, forKey, newValue);
}
//----------------------------------------------------------------------------
void RawTerrainPage::UpdateWorldData (double applicationTime)
{
TriMesh::UpdateWorldData(applicationTime);
PX2::Light *light = 0;
for (int i=0; i<(int)mInfulencedLights.size(); i++)
{
Light *lit = mInfulencedLights[i];
if (lit->GetType() == Light::LT_DIRECTIONAL)
{
light = lit;
break;
}
}
if (light!=0 && light!=mDirLight)
{
mDirLight = light;
mMtlInst->SetVertexConstant(0, "gLightColour",
new0 LightDiffuseConstant(mDirLight));
mMtlInst->SetVertexConstant(0, "gLightAttenuation",
new0 LightAttenuationConstant(mDirLight));
mMtlInst->SetVertexConstant(0, "gLightModelDirection",
new0 LightModelDVectorConstant(mDirLight));
for (int i=0; i<(int)mJunglers.size(); i++)
{
Jungler *jungler = mJunglers[i];
MaterialInstance *inst = jungler->GetMtlInst();
if (inst)
{
inst->SetVertexConstant(0, "gLightColour",
new0 LightDiffuseConstant(mDirLight));
inst->SetVertexConstant(0, "gLightAttenuation",
new0 LightAttenuationConstant(mDirLight));
inst->SetVertexConstant(0, "gLightModelDirection",
new0 LightModelDVectorConstant(mDirLight));
}
}
}
}
void LightPropertyControl::OnComboIndexChanged(PropertyList *forList, const String &forKey, int32 newItemIndex, const String &newItemKey)
{
if("property.lightnode.type" == forKey)
{
Light *light = GetLight(currentSceneNode);
light->SetType((Light::eType)newItemIndex);
if(Light::TYPE_DIRECTIONAL == light->GetType())
{
if(propertyList->IsPropertyAvaliable("Shadow angle"))
{
currentSceneNode->GetCustomProperties()->SetFloat("editor.staticlight.shadowangle", propertyList->GetFloatPropertyValue("Shadow angle"));
}
if(propertyList->IsPropertyAvaliable("Shadow samples"))
{
currentSceneNode->GetCustomProperties()->SetInt32("editor.staticlight.shadowsamples", propertyList->GetIntPropertyValue("Shadow samples"));
}
}
}
NodesPropertyControl::OnComboIndexChanged(forList, forKey, newItemIndex, newItemKey);
}
void LightPropertyControl::ReadFrom(Entity * sceneNode)
{
NodesPropertyControl::ReadFrom(sceneNode);
Light *light = GetLight(sceneNode);
DVASSERT(light);
propertyList->AddSection("property.lightnode.light", GetHeaderState("property.lightnode.light", true));
propertyList->AddComboProperty("property.lightnode.type", types);
propertyList->SetComboPropertyIndex("property.lightnode.type", light->GetType());
propertyList->AddColorProperty("property.lightnode.ambient.color");
propertyList->SetColorPropertyValue("property.lightnode.ambient.color", light->GetAmbientColor());
propertyList->AddColorProperty("property.lightnode.diffuse.color");
propertyList->SetColorPropertyValue("property.lightnode.diffuse.color", light->GetDiffuseColor());
propertyList->AddColorProperty("property.lightnode.specular.color");
propertyList->SetColorPropertyValue("property.lightnode.specular.color", light->GetSpecularColor());
propertyList->AddFloatProperty("property.lightnode.intensity");
propertyList->SetFloatPropertyValue("property.lightnode.intensity", light->GetIntensity());
//propertyList->AddFloatProperty("property.lightnode.material.shininess", light->GetShininess())
propertyList->AddSection("property.lightnode.staticlight", GetHeaderState("property.lightnode.staticlight", true));
propertyList->AddBoolProperty("property.staticlight.enable");
propertyList->SetBoolPropertyValue("property.staticlight.enable", sceneNode->GetCustomProperties()->GetBool("editor.staticlight.enable", true));
propertyList->AddBoolProperty("Cast shadows");
propertyList->SetBoolPropertyValue("Cast shadows", sceneNode->GetCustomProperties()->GetBool("editor.staticlight.castshadows", true));
propertyList->AddFloatProperty("Intensity");
propertyList->SetFloatPropertyValue("Intensity", sceneNode->GetCustomProperties()->GetFloat("editor.intensity", 1.f));
propertyList->AddFloatProperty("Falloff cutoff");
propertyList->SetFloatPropertyValue("Falloff cutoff", sceneNode->GetCustomProperties()->GetFloat("editor.staticlight.falloffcutoff", 1000.f));
propertyList->AddFloatProperty("Falloff exponent");
propertyList->SetFloatPropertyValue("Falloff exponent", sceneNode->GetCustomProperties()->GetFloat("editor.staticlight.falloffexponent", 1.f));
if(Light::TYPE_DIRECTIONAL == light->GetType())
{
propertyList->AddFloatProperty("Shadow angle");
propertyList->SetFloatPropertyValue("Shadow angle", sceneNode->GetCustomProperties()->GetFloat("editor.staticlight.shadowangle", 0.f));
propertyList->AddIntProperty("Shadow samples");
propertyList->SetIntPropertyValue("Shadow samples", sceneNode->GetCustomProperties()->GetInt32("editor.staticlight.shadowsamples", 1));
}
else if(Light::TYPE_POINT == light->GetType())
{
propertyList->AddFloatProperty("Shadow radius");
propertyList->SetFloatPropertyValue("Shadow radius", sceneNode->GetCustomProperties()->GetFloat("editor.staticlight.shadowradius", 0.f));
}
propertyList->AddSection("property.lightnode.dynamiclight", GetHeaderState("property.lightnode.dynamiclight", true));
propertyList->AddBoolProperty("property.dynamiclight.enable");
propertyList->SetBoolPropertyValue("property.dynamiclight.enable", sceneNode->GetCustomProperties()->GetBool("editor.dynamiclight.enable", true));
}
void SceneManager::LoadFromText(const char *text)
{
TextParser parser;
parser.Parse(text);
TextParser::NODE *node = NULL;
if ((node = parser.GetNode("FILETYPE")) && node->values[0] == "SCENE")
{
TextParser::NODE *node_data = parser.GetNode("DATA");
if (node_data)
{
// Models
TextParser::NODE *node_models = node_data->FindChild("MODELS");
if (node_models)
{
for(size_t i=0;i<node_models->children.size();i++)
{
TextParser::NODE *child = node_models->children[i];
TextParser::NODE *node_filename = NULL;
if ( child->name == "MODEL" &&
(node_filename = child->FindChild("FILENAME")))
{ // MODEL
Model *model = new Model(node_filename->values[0].GetCharPtr());
TextParser::NODE *node_position = child->FindChild("POSITION");
if (node_position) model->SetPosition(node_position->ToFVector3());
TextParser::NODE *node_scale = child->FindChild("SCALE");
if (node_scale) model->SetScale(node_scale->ToFVector3());
TextParser::NODE *node_rotation = child->FindChild("ROTATION");
if (node_rotation) model->SetRotation(node_rotation->ToFVector3());
mModels.push_back(model);
}
}
}
// Lights
TextParser::NODE *node_lights = node_data->FindChild("LIGHTS");
if (node_lights)
{
for(size_t i=0;i<node_lights->children.size();i++)
{
Light *light = NULL;
TextParser::NODE *child = node_lights->children[i];
TextParser::NODE *node_type = child->FindChild("TYPE");
if (node_type->values[0] == "Point")
{
light = new PointLight();
}
else if (node_type->values[0] == "Directional")
{
light = new DirectionalLight();
}
else if (node_type->values[0] == "Ambient")
{
light = new AmbientLight();
}
if (!light) continue;
TextParser::NODE *node_color = child->FindChild("COLOR");
if (node_color)
{
light->SetColor(node_color->ToFVector3());
}
TextParser::NODE *node_intensity = child->FindChild("INTENSITY");
if (node_intensity)
{
light->SetIntensity(node_intensity->values[0].ToFloat());
}
TextParser::NODE *node_pos = child->FindChild("POSITION");
if (node_pos && light->GetType() == Light::TYPE_POINT)
{
((PointLight*)light)->SetPosition(node_pos->ToFVector3());
}
TextParser::NODE *node_scl = child->FindChild("SCALE");
if (node_scl && light->GetType() == Light::TYPE_POINT)
{
((PointLight*)light)->SetScale(node_scl->ToFVector3());
}
switch(light->GetType())
{
case Light::TYPE_POINT:
{
TextParser::NODE *node_range = child->FindChild("RANGE");
if (node_range)
{
((PointLight*)light)->SetRange(node_range->values[0].ToFloat());
}
TextParser::NODE *node_exp = child->FindChild("EXPONENT");
if (node_exp)
{
((PointLight*)light)->SetExponent(node_exp->values[0].ToFloat());
}
} break;
}
AddLight(light);
}
}
}
}
}
void World::GetVisibleLights(Node * node, List<Light*> & lights)
{
profile_code();
lights.Clear();
List<Light*>::Iterator iter;
List<Light*>::Iterator end;
iter = mLights.Begin();
end = mLights.End();
Light * light;
while (iter != end)
{
light = *iter;
if (light->IsVisible())
{
LIGHT_TYPE type = light->GetType();
if (type == LT_DIRECTIONAL)
{
lights.PushBack(light);
}
else if (type == LT_POINT)
{
const Sphere & sph = node->GetWorldBoundingSphere();
float len = Math::VecLength(light->GetPosition() - sph.center);
if (len - sph.radius < light->GetRange())
lights.PushBack(light);
}
else if (type == LT_SPOT)
{
Aabb aabb;
Vec3 ltf, lbf, rtf, rbf;
Vec3 ltb, lbb, rtb, rbb;
Vec3 lp;
float sq1, sq2, sq3, sq4;
float sq5, sq6, sq7, sq8;
float rsq;
Vec3 d1, d2, d3, d4;
Vec3 d5, d6, d7, d8;
Vec3 ld;
float dt1, dt2, dt3, dt4;
float dt5, dt6, dt7, dt8;
float mdt;
aabb = node->GetWorldAabb();
ltf = aabb.GetLeftTopFrontPoint();
lbf = aabb.GetLeftBottomFrontPoint();
rtf = aabb.GetRightTopFrontPoint();
rbf = aabb.GetRightBottomFrontPoint();
ltb = aabb.GetLeftTopBackPoint();
lbb = aabb.GetLeftBottomBackPoint();
rtb = aabb.GetRightTopBackPoint();
rbb = aabb.GetRightBottomBackPoint();
lp = light->GetPosition();
rsq = light->GetRange() * light->GetRange();
sq1 = Math::VecDistanceSq(lp, ltf);
sq2 = Math::VecDistanceSq(lp, lbf);
sq3 = Math::VecDistanceSq(lp, rtf);
sq4 = Math::VecDistanceSq(lp, rbf);
sq5 = Math::VecDistanceSq(lp, ltb);
sq6 = Math::VecDistanceSq(lp, lbb);
sq7 = Math::VecDistanceSq(lp, rtb);
sq8 = Math::VecDistanceSq(lp, rbb);
if (sq1 < rsq || sq2 < rsq || sq3 < rsq || sq4 < rsq ||
sq5 < rsq || sq6 < rsq || sq7 < rsq || sq8 < rsq)
{
ld = light->GetDirection();
mdt = light->GetOuter();
d1 = ltf - lp;
d2 = lbf - lp;
d3 = rtf - lp;
d4 = rbf - lp;
d5 = ltb - lp;
d6 = lbb - lp;
d7 = rtb - lp;
d8 = rbb - lp;
Math::VecNormalize(d1, d1);
Math::VecNormalize(d2, d2);
Math::VecNormalize(d3, d3);
Math::VecNormalize(d4, d4);
Math::VecNormalize(d5, d5);
Math::VecNormalize(d6, d6);
Math::VecNormalize(d7, d7);
Math::VecNormalize(d8, d8);
dt1 = Math::VecDot(ld, d1);
dt2 = Math::VecDot(ld, d2);
dt3 = Math::VecDot(ld, d3);
dt4 = Math::VecDot(ld, d4);
dt5 = Math::VecDot(ld, d5);
dt6 = Math::VecDot(ld, d6);
dt7 = Math::VecDot(ld, d7);
dt8 = Math::VecDot(ld, d8);
if (dt1 > mdt || dt2 > mdt || dt3 > mdt || dt4 > mdt ||
dt5 > mdt || dt6 > mdt || dt7 > mdt || dt7 > mdt)
{
lights.PushBack(light);
}
}
}
}
++iter;
}
}
void Scene::Render( RenderPass renderPass, Viewport* viewport )
{
static Mesh* skyboxMesh = ResourceManager::GetGenMesh(GenMeshes::Cube);
std::string viewportName = viewport != NULL ? viewport->GetName() : "";
bool ignoreShadowCast = true;
if (renderPass == RenderPass::ShadowPass)
{
ignoreShadowCast = false;
}
for (uint rank = 0; rank < m_layers.size(); rank++)
{
if ( !m_layers[rank]->IsEnabled() ) continue;
RenderManager::UseNewLayer(renderPass);
if (rank == 0)
{
if ( m_skyboxMaterial != NULL && renderPass != RenderPass::PickingPass )
{
Transform transform(NULL);
transform.SetPositionWorld( RenderManager::GetRenderCamera()->GetComponent<Transform>()->GetPositionWorld() );
transform.SetScaleWorld( Vector3(m_skyboxSize) );
MeshRenderer renderer;
renderer.SetMaterial(m_skyboxMaterial);
renderer.SetMesh(skyboxMesh);
renderer.SetFaceCulling( FaceCulling::CULL_FRONT );
RenderManager::ObjectToRender objectToRender;
objectToRender.transform = &transform;
objectToRender.meshRenderer = &renderer;
objectToRender.renderPass = renderPass;
RenderManager::RenderObject( objectToRender );
}
GizmoManager::RenderGrid( renderPass );
}
#if (ME3D_SHADING_MODE == ME3D_CLASSIC_SHADING)
if (viewport != NULL && viewport->HasEnableLights() && renderPass != RenderPass::PickingPass)
{
for (uint j = 0; j < m_layers[rank]->GetObjectsCount(); j++)
{
GameObject* obj = m_layers[rank]->GetObjectAt(j);
if (obj->IsFullyActive())
{
Light* lightComp = obj->GetComponent<Light>();
if (lightComp != NULL && lightComp->IsEnabled())
{
RenderManager::ActiveLight activeLight;
activeLight.light = lightComp;
activeLight.transform = obj->GetComponent<Transform>();
RenderManager::AddActiveLight( activeLight );
}
}
}
}
#endif
for (uint j = 0; j < m_layers[rank]->GetObjectsCount(); j++)
{
GameObject* obj = m_layers[rank]->GetObjectAt(j);
if ( !obj->IsIgnoringViewport(viewportName)
&& obj->IsFullyActive() )
{
GizmoManager::RenderFollower( obj, renderPass );
MeshRenderer* renderer = obj->GetComponent<MeshRenderer>();
GuiTexture* guiTexture = obj->GetComponent<GuiTexture>();
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_TRUE);
glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
if (renderer != NULL &&
renderer->GetMaterial() != NULL &&
renderer->GetMesh() != NULL &&
(ignoreShadowCast || renderer->IsCastingShadows()) )
{
RenderManager::ObjectToRender objectToRender;
objectToRender.uniqueIndex = obj->GetUniqueIndex();
objectToRender.transform = obj->GetComponent<Transform>();
objectToRender.meshRenderer = renderer;
objectToRender.renderPass = renderPass;
RenderManager::RenderObject( objectToRender );
}
if (guiTexture != NULL)
{
RenderManager::ObjectToRender objectToRender;
objectToRender.uniqueIndex = obj->GetUniqueIndex();
objectToRender.guiTexture = guiTexture;
RenderManager::RenderObject( objectToRender );
}
}
}
#if (ME3D_SHADING_MODE == ME3D_DEFERRED_SHADING)
if (viewport != NULL && viewport->HasEnableLights() && renderPass != RenderPass::PickingPass)
{
for (uint j = 0; j < m_layers[rank]->GetObjectsCount(); j++)
{
GameObject* obj = m_layers[rank]->GetObjectAt(j);
if (obj->IsFullyActive())
{
Light* lightComp = obj->GetComponent<Light>();
if (lightComp != NULL && lightComp->IsEnabled())
{
RenderManager::ActiveLight activeLight;
activeLight.light = lightComp;
activeLight.transform = obj->GetComponent<Transform>();
switch (lightComp->GetType())
{
case LightType::Directional:
RenderManager::DeferredDirectional(activeLight);
break;
case LightType::Point:
case LightType::Spot:
RenderManager::DeferredPointAndSpot(activeLight);
break;
}
}
}
}
}
#endif
#if (ME3D_SHADING_MODE == ME3D_DEFERRED_SHADING)
if (renderPass != RenderPass::PickingPass)
{
RenderManager::DeferredUnlit();
}
#endif
RenderManager::CollapseLayer(renderPass);
} // end for
// layer for gizmo
RenderManager::UseNewLayer(renderPass);
GizmoManager::RenderTools(renderPass);
#if (ME3D_SHADING_MODE == ME3D_DEFERRED_SHADING)
if (renderPass != RenderPass::PickingPass)
{
RenderManager::DeferredUnlit();
}
#endif
RenderManager::CollapseLayer(renderPass);
// layer for menu
RenderManager::UseNewLayer(renderPass);
MenuManager::Render(renderPass, viewportName);
#if (ME3D_SHADING_MODE == ME3D_DEFERRED_SHADING)
if (renderPass != RenderPass::PickingPass)
{
RenderManager::DeferredUnlit();
}
#endif
RenderManager::CollapseLayer(renderPass);
}
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
}
}
