void GameLightsUpdate::UpdateGameObjectLight(GameObject* gameObject)
{
AEAssert(gameObject != nullptr);
if (gameObject == nullptr)
{
return;
}
if (gameObject->HasLightGOC())
{
Light* light = gameObject->GetLightGOC()->GetLight();
if (light != nullptr && light->IsEnabled())
{
light->SetPosition(gameObject->GetWorldPosition());
if (light->GetLightType() == LightType::Spot || light->GetLightType() == LightType::Directional)
{
glm::vec3 direction = gameObject->GetDirection();
light->SetDirection(direction);
}
}
}
for (auto goIt : *gameObject)
{
UpdateGameObjectLight(goIt.second);
}
}
void GameObjectLightComponentWidget::InitFields()
{
Light* light = nullptr;
////////////////////////////////////////
// Set Ready to false, so Light cannot change
// properties while been initialized
m_IsReady = false;
////////////////////////////////////////
// Check Engine Viewer
AEAssert(m_EngineViewer != nullptr);
if (m_EngineViewer == nullptr)
{
return;
}
////////////////////////////////////////
// Verify LOC and Get Light Object
light = GetLight();
if(light == nullptr)
{
AETODO("Add log");
return;
}
////////////////////////////////////////
// Set Light Type
SetLightTypeComboBoxIndex(light->GetLightType());
////////////////////////////////////////
// Set Enabled
m_GameObjectLightComponentWidgetQtUI.m_Enabled->setChecked(light->IsEnabled());
////////////////////////////////////////
// Set Intensity
m_GameObjectLightComponentWidgetQtUI.m_IntensitySB->setValue(static_cast<double>(light->GetIntensity()));
////////////////////////////////////////
// Set Color
QColor qColor = AEQTHelpers::GetQColorFromColor(light->GetColor());
SetColorToColorWidget(qColor);
////////////////////////////////////////
// Set Near and Far Attenuation
m_GameObjectLightComponentWidgetQtUI.m_NearAttSB->setValue(static_cast<double>(light->GetNearAttenuation()));
m_GameObjectLightComponentWidgetQtUI.m_FarAttSB->setValue(static_cast<double>(light->GetFarAttenuation()));
////////////////////////////////////////
// Set Shadow Enabled
m_GameObjectLightComponentWidgetQtUI.m_ShadowEnabled->setChecked(light->IsShadowEnabled());
m_GameObjectLightComponentWidgetQtUI.m_DrawFrustum->setEnabled(light->IsShadowEnabled());
////////////////////////////////////////
// Enable/Visibility of Angle options
if(light->GetLightType() == LightType::Spot)
{
m_GameObjectLightComponentWidgetQtUI.m_LabelAngle->setVisible(true);
m_GameObjectLightComponentWidgetQtUI.m_LabelFalloffAngle->setVisible(true);
m_GameObjectLightComponentWidgetQtUI.m_AngleSB->setVisible(true);
m_GameObjectLightComponentWidgetQtUI.m_FalloffAngleSB->setVisible(true);
////////////////////////////////////////
// Get Spot Light
SpotLight* spotLight = reinterpret_cast<SpotLight*>(light);
////////////////////////////////////////
// Set Angle and Fall out Angle
m_GameObjectLightComponentWidgetQtUI.m_AngleSB->setValue(static_cast<double>(spotLight->GetAngle()));
m_GameObjectLightComponentWidgetQtUI.m_FalloffAngleSB->setValue(static_cast<double>(spotLight->GetFallOffAngle()));
}
else
{
m_GameObjectLightComponentWidgetQtUI.m_LabelAngle->setVisible(false);
m_GameObjectLightComponentWidgetQtUI.m_LabelFalloffAngle->setVisible(false);
m_GameObjectLightComponentWidgetQtUI.m_AngleSB->setVisible(false);
m_GameObjectLightComponentWidgetQtUI.m_FalloffAngleSB->setVisible(false);
}
////////////////////////////////////////
// Enable/Visibility of Draw Frustum Cascades
if (light->GetLightType() == LightType::Directional)
{
m_GameObjectLightComponentWidgetQtUI.m_DrawCascadeFrustums->setVisible(true);
}
else
{
m_GameObjectLightComponentWidgetQtUI.m_DrawCascadeFrustums->setVisible(false);
}
////////////////////////////////////////
// Light is Ready to change properties
m_IsReady = true;
}
void DataViewer_GameObject::_ApplyChanges()
{
if ( _changeList["GameObject"] )
{
_selectedObject->SetSavable( _ReadWidget_Bool( _dataGameObject.savable ) );
_selectedObject->SetEnabled( _ReadWidget_Bool( _dataGameObject.enable ) );
_selectedObject->SetName( _ReadWidget_String( _dataGameObject.name ) );
_Colorize_GameObject( _selectedObject->IsEnabled() );
_Colorize_Transform( _selectedObject->IsEnabled() );
I_Component* comp;
comp = _selectedObject->GetComponent<Camera>();
if ( comp != NULL )
{
_Colorize_Camera( _selectedObject->IsEnabled() && comp->IsEnabled() );
}
comp = _selectedObject->GetComponent<Light>();
if ( comp != NULL )
{
_Colorize_Light( _selectedObject->IsEnabled() && comp->IsEnabled() );
}
comp = _selectedObject->GetComponent<MeshDrawing>();
if ( comp != NULL )
{
_Colorize_MeshDrawing( _selectedObject->IsEnabled() && comp->IsEnabled() );
}
for (auto& dataScript : _dataScripts)
{
Script* script = _selectedObject->GetComponent<Script>( dataScript.scriptName );
_Colorize_Script( _selectedObject->IsEnabled() && script->IsEnabled(), dataScript );
}
_changeList["GameObject"] = false;
return;
}
if ( _changeList["Transform_Local"] )
{
Transform* transform = _selectedObject->GetComponent<Transform>();
transform->SetPositionLocal( _ReadWidget_Vector3( _dataTransform.posLocal ) );
transform->SetEulerRotationLocal( _ReadWidget_Vector3( _dataTransform.rotLocal ) );
transform->SetScaleLocal( _ReadWidget_Vector3( _dataTransform.scaleLocal ) );
_changeList["Transform_Local"] = false;
return;
}
if ( _changeList["Transform_World"] )
{
Transform* transform = _selectedObject->GetComponent<Transform>();
transform->SetPositionWorld( _ReadWidget_Vector3( _dataTransform.posWorld ) );
transform->SetEulerRotationWorld( _ReadWidget_Vector3( _dataTransform.rotWorld ) );
transform->SetScaleWorld( _ReadWidget_Vector3( _dataTransform.scaleWorld ) );
_changeList["Transform_World"] = false;
return;
}
if ( _changeList["Light"] )
{
Light* light = _selectedObject->GetComponent<Light>();
light->SetEnabled( _ReadWidget_Bool( _dataLight.enable ) );
light->SetType( EnumConvertor::s2e_LightType[ _ReadWidget_Choice( _dataLight.type ) ] );
light->SetColor( _ReadWidget_Vector3( _dataLight.color ) );
light->SetIntensity( _ReadWidget_Float( _dataLight.intensity ) );
light->SetRange( _ReadWidget_Float( _dataLight.range ) );
light->SetSpotAngle( _ReadWidget_Float( _dataLight.spotAngle ) );
light->SetCastShadows( _ReadWidget_Bool( _dataLight.castShadows ) );
_Colorize_Light( light->IsEnabled() && _selectedObject->IsEnabled() );
_changeList["Light"] = false;
return;
}
if ( _changeList["Camera"] )
{
Camera* camera = _selectedObject->GetComponent<Camera>();
camera->SetEnabled( _ReadWidget_Bool( _dataCamera.enable ) );
camera->SetType( EnumConvertor::s2e_CameraType[ _ReadWidget_Choice( _dataCamera.type ) ] );
camera->SetOrthoSize( _ReadWidget_Vector2( _dataCamera.orthoSize ) );
camera->SetFovYAngle( _ReadWidget_Float( _dataCamera.fovYAngle ) );
camera->SetAspectRatio( _ReadWidget_Float( _dataCamera.aspectRatio ) );
camera->SetNearClipping( _ReadWidget_Float( _dataCamera.nearClipping ) );
camera->SetFarClipping( _ReadWidget_Float( _dataCamera.farClipping ) );
_Colorize_Camera( camera->IsEnabled() && _selectedObject->IsEnabled() );
_changeList["Camera"] = false;
return;
}
if ( _changeList["MeshDrawing"] )
{
MeshDrawing* meshDrawing = _selectedObject->GetComponent<MeshDrawing>();
meshDrawing->SetEnabled( _ReadWidget_Bool( _dataMeshDrawing.enable ) );
String materialName = _ReadWidget_Picking( _dataMeshDrawing.material );
meshDrawing->SetMaterial( Systems::Resource()->GetMaterial( materialName ) );
String meshName = _ReadWidget_Picking( _dataMeshDrawing.mesh );
meshDrawing->SetMesh( Systems::Resource()->GetMesh( meshName ) );
meshDrawing->SetCastShadows( _ReadWidget_Bool( _dataMeshDrawing.castShadows ) );
meshDrawing->SetReceiveShadows( _ReadWidget_Bool( _dataMeshDrawing.receiveShadows ) );
_Colorize_MeshDrawing( meshDrawing->IsEnabled() && _selectedObject->IsEnabled() );
_changeList["MeshDrawing"] = false;
return;
}
if ( _changeList["Script"] )
{
for (auto& dataScript : _dataScripts)
{
Script* script = _selectedObject->GetComponent<Script>( dataScript.scriptName );
script->SetEnabled( _ReadWidget_Bool( dataScript.enable ) );
_Colorize_Script( script->IsEnabled() && _selectedObject->IsEnabled(), dataScript );
}
_changeList["Script"] = false;
return;
}
}
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);
}
