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 GLSLProgram<real>::SetupLights()
{
const std::vector<Light<real>*>* lights = RenderState<real>::Get()->GetLights();
// Setup enabled lights
for ( uint i=0 ; i<lights->size() && i<mLightLocations.size() ; ++i )
{
Light<real>* light = (*lights)[i];
glUniform1i( mLightLocations[i].enabled, true );
glUniform1i( mLightLocations[i].type, light->GetLightType() );
Vector3<float> position = light->GetLocalToGlobal() * Vector3<real>( 0, 0, 0 );
glUniform3fv( mLightLocations[i].position, 1, (float*)&position );
Color<float> intensity = light->GetIntensity();
glUniform4fv( mLightLocations[i].intensity, 1, (float*)&intensity );
Color<float> ambient = light->GetAmbient();
glUniform4fv( mLightLocations[i].ambient, 1, (float*)&ambient );
// Setup sub-parameters
switch( light->GetLightType() )
{
case Light<real>::TypeDirectional: SetupDirectionalLight( i, light ); break;
case Light<real>::TypePoint: SetupPointLight( i, light ); break;
case Light<real>::TypeSpot: SetupSpotLight( i, light ); break;
}
}
// Disabled lights
for ( uint i=lights->size() ; i<mLightLocations.size() ; ++i )
glUniform1i( mLightLocations[i].enabled, false );
// Nb of lights
glUniform1i( mNbLightsLocation, lights->size() );
}
AEResult GameLightsUpdate::ShadowDirLightRenderGameObject()
{
LightManager* lightManager = m_GameApp->GetLightManager();
GameObjectManager* gameObjectManager = m_GameApp->GetGameObjectManager();
if (lightManager->GetNumDirLightsWithShadows() == 0)
{
return AEResult::Ok;
}
Texture2DArray* shadowTextureArray = lightManager->GetDirLightShadowTextureArray();
AETODO("Check return");
RenderTarget* rtsDS[1] = { nullptr };
m_GraphicDevice->SetRenderTargetsAndDepthStencil(1, rtsDS, m_DirLightShadowTexturesDS);
for (auto lightIt : *lightManager)
{
Light* light = lightIt.second;
if (light->GetLightType() == LightType::Directional && light->IsShadowEnabled())
{
DirectionalLight* dirLight = reinterpret_cast<DirectionalLight*>(light);
uint32_t idxs[1] = { light->GetShadowTextureIndex() };
AETODO("Check return");
m_GraphicDevice->SetRenderTargets(1, idxs, shadowTextureArray);
m_GraphicDevice->Clear(true, 0, true, true, AEColors::Transparent);
for (uint32_t i = 0; i < AE_LIGHT_NUM_CASCADE_MAPS; i++)
{
AETODO("Check return");
m_GraphicDevice->SetViewport(m_DirLightShadowViewports[i]);
const LightCascadeInfo& lightCascadeInfo = dirLight->GetLightCascadeInfo();
for (auto goIt : *gameObjectManager)
{
AETODO("Check return");
ShadowLightRenderGameObject(goIt.second, lightCascadeInfo.m_CascadeViewMatrix[i], lightCascadeInfo.m_CascadeProjectionMatrix[i]);
}
}
}
}
AETODO("Check return");
m_GraphicDevice->ResetViewport();
AETODO("Check return");
m_GraphicDevice->ResetRenderTargetAndSetDepthStencil();
return AEResult::Ok;
}
Color<real> BlinnPhongShader<real>::GetDiffuseAndSpecular( const Light<real>& light )
{
Color<real> finalColor( 0, 0, 0, 1 );
////////////////////////////////////////////
//////////////////IFT 3355//////////////////
////////////////////////////////////////////
//Ici, vous calculerez les composantes
//diffuse et spéculaire en vous servant des
//propriétés du matériau.
////////////////////////////////////////////
//////////////////IFT 3355//////////////////
////////////////////////////////////////////
Vector3<real> lightPos = light.GetGlobalPosition();
Vector3<real> lightDir = (lightPos - mIntersection.GetPosition()).Normalized();
real r2 = (mIntersection.GetPosition() - lightPos).SquaredLength();
Vector3<real> intersectionShifted = mIntersection.GetPosition() + EPS*mIntersection.GetNormal();
// Shadow+Diffuse
bool lightVisible = mRayTracer.IsLightVisible(intersectionShifted, &light);
if (!lightVisible)
return finalColor;
switch (light.GetLightType()) {
case Light<real>::TypeDirectional:
case Light<real>::TypeSpot:
case Light<real>::TypePoint:
finalColor += mMaterial.GetDiffuse() *
std::max<real>(0, lightDir * mIntersection.GetNormal()) *
GetMaterialSurfaceColor();
break;
}
// Specular
const Camera<real> *cam = mScene.GetActiveCamera();
Vector3<real> camDir = cam->GetFrontDirection();
Vector3<real> H = lightDir + camDir;
H.Normalize();
Vector3<real> N = mIntersection.GetNormal();
real n = mMaterial.GetShininess();
real cs = (n+2)/2;
Color<real> ks = mMaterial.GetSpecular();
Color<real> m = mMaterial.GetMetallic();
finalColor += cs * ks *
(m*GetMaterialSurfaceColor() + (Color<real>(1, 1, 1, 1) - m)) *
pow(N * H, n);
return finalColor * light.GetIntensity() / (r2 * PI);
}
void LightWidget::InitComponent(Component* pComponent)
{
BaseComponentEditor::InitComponent(pComponent);
BeginInit();
Light* pLight = (Light*)pComponent;
if(pLight != NULL)
{
selColor->setColor(pLight->GetColor());
lblSpeInden->SetText(QString::number(pLight->GetSpecularIntensity()).toStdString().c_str());
cboLightType->setCurrentIndex((int)pLight->GetLightType());
}
EndInit();
}
AEResult GameLightsUpdate::ShadowSpotLightRenderGameObject()
{
LightManager* lightManager = m_GameApp->GetLightManager();
GameObjectManager* gameObjectManager = m_GameApp->GetGameObjectManager();
if (lightManager->GetNumSpotLightsWithShadows() == 0)
{
return AEResult::Ok;
}
Texture2DArray* shadowTextureArray = lightManager->GetSpotLightShadowTextureArray();
AETODO("Check return");
RenderTarget* rtsDS[1] = { nullptr };
m_GraphicDevice->SetRenderTargetsAndDepthStencil(1, rtsDS, m_SpotLightShadowTexturesDS);
AETODO("Check return");
m_GraphicDevice->SetViewport(m_SpotLightShadowViewport);
for (auto lightIt : *lightManager)
{
Light* light = lightIt.second;
if (light->GetLightType() == LightType::Spot && light->IsShadowEnabled())
{
uint32_t idxs[1] = { light->GetShadowTextureIndex() };
AETODO("Check return");
m_GraphicDevice->SetRenderTargets(1, idxs, shadowTextureArray);
m_GraphicDevice->Clear(true, 0, true, true, AEColors::Transparent);
for (auto goIt : *gameObjectManager)
{
AETODO("Check return");
ShadowLightRenderGameObject(goIt.second, light->GetViewMatrix(), light->GetProjectionMatrix());
}
}
}
AETODO("Check return");
m_GraphicDevice->ResetViewport();
AETODO("Check return");
m_GraphicDevice->ResetRenderTargetAndSetDepthStencil();
return AEResult::Ok;
}
void GameObjectLightComponentWidget::on_m_FalloffAngleSB_editingFinished()
{
if (!m_IsReady)
{
return;
}
Light* light = nullptr;
////////////////////////////////////////
// Verify LOC and Get Light Object
light = GetLight();
if(light == nullptr)
{
AETODO("Add log");
return;
}
////////////////////////////////////////
// Verify that it is Spot Light
if(light->GetLightType() != LightType::Spot)
{
return;
}
////////////////////////////////////////
// Get Spot Light
SpotLight* spotLight = reinterpret_cast<SpotLight*>(light);
float newFalloffAngle = static_cast<float>(m_GameObjectLightComponentWidgetQtUI.m_FalloffAngleSB->value());
float angle = spotLight->GetFallOffAngle();
if (newFalloffAngle < angle)
{
spotLight->SetAngle(newFalloffAngle);
m_GameObjectLightComponentWidgetQtUI.m_AngleSB->setValue(newFalloffAngle);
}
spotLight->SetFallOffAngle(newFalloffAngle);
}
void Batch::Prepare(View* view, bool setModelTransform) const
{
if (!vertexShader_ || !pixelShader_)
return;
Graphics* graphics = view->GetGraphics();
Renderer* renderer = view->GetRenderer();
Node* cameraNode = camera_ ? camera_->GetNode() : 0;
Light* light = lightQueue_ ? lightQueue_->light_ : 0;
Texture2D* shadowMap = lightQueue_ ? lightQueue_->shadowMap_ : 0;
// Set pass / material-specific renderstates
if (pass_ && material_)
{
bool isShadowPass = pass_->GetType() == PASS_SHADOW;
BlendMode blend = pass_->GetBlendMode();
// Turn additive blending into subtract if the light is negative
if (light && light->IsNegative())
{
if (blend == BLEND_ADD)
blend = BLEND_SUBTRACT;
else if (blend == BLEND_ADDALPHA)
blend = BLEND_SUBTRACTALPHA;
}
graphics->SetBlendMode(blend);
renderer->SetCullMode(isShadowPass ? material_->GetShadowCullMode() : material_->GetCullMode(), camera_);
if (!isShadowPass)
{
const BiasParameters& depthBias = material_->GetDepthBias();
graphics->SetDepthBias(depthBias.constantBias_, depthBias.slopeScaledBias_);
}
graphics->SetDepthTest(pass_->GetDepthTestMode());
graphics->SetDepthWrite(pass_->GetDepthWrite());
}
// Set shaders first. The available shader parameters and their register/uniform positions depend on the currently set shaders
graphics->SetShaders(vertexShader_, pixelShader_);
// Set global (per-frame) shader parameters
if (graphics->NeedParameterUpdate(SP_FRAME, (void*)0))
view->SetGlobalShaderParameters();
// Set camera shader parameters
unsigned cameraHash = overrideView_ ? (unsigned)(size_t)camera_ + 4 : (unsigned)(size_t)camera_;
if (graphics->NeedParameterUpdate(SP_CAMERA, reinterpret_cast<void*>(cameraHash)))
view->SetCameraShaderParameters(camera_, true, overrideView_);
// Set viewport shader parameters
IntVector2 rtSize = graphics->GetRenderTargetDimensions();
IntRect viewport = graphics->GetViewport();
unsigned viewportHash = (viewport.left_) | (viewport.top_ << 8) | (viewport.right_ << 16) | (viewport.bottom_ << 24);
if (graphics->NeedParameterUpdate(SP_VIEWPORT, reinterpret_cast<void*>(viewportHash)))
{
float rtWidth = (float)rtSize.x_;
float rtHeight = (float)rtSize.y_;
float widthRange = 0.5f * viewport.Width() / rtWidth;
float heightRange = 0.5f * viewport.Height() / rtHeight;
#ifdef URHO3D_OPENGL
Vector4 bufferUVOffset(((float)viewport.left_) / rtWidth + widthRange,
1.0f - (((float)viewport.top_) / rtHeight + heightRange), widthRange, heightRange);
#else
Vector4 bufferUVOffset((0.5f + (float)viewport.left_) / rtWidth + widthRange,
(0.5f + (float)viewport.top_) / rtHeight + heightRange, widthRange, heightRange);
#endif
graphics->SetShaderParameter(VSP_GBUFFEROFFSETS, bufferUVOffset);
float sizeX = 1.0f / rtWidth;
float sizeY = 1.0f / rtHeight;
graphics->SetShaderParameter(PSP_GBUFFERINVSIZE, Vector4(sizeX, sizeY, 0.0f, 0.0f));
}
// Set model or skinning transforms
if (setModelTransform && graphics->NeedParameterUpdate(SP_OBJECTTRANSFORM, worldTransform_))
{
if (geometryType_ == GEOM_SKINNED)
{
graphics->SetShaderParameter(VSP_SKINMATRICES, reinterpret_cast<const float*>(worldTransform_),
12 * numWorldTransforms_);
}
else
graphics->SetShaderParameter(VSP_MODEL, *worldTransform_);
// Set the orientation for billboards, either from the object itself or from the camera
if (geometryType_ == GEOM_BILLBOARD)
{
if (numWorldTransforms_ > 1)
graphics->SetShaderParameter(VSP_BILLBOARDROT, worldTransform_[1].RotationMatrix());
else
graphics->SetShaderParameter(VSP_BILLBOARDROT, cameraNode->GetWorldRotation().RotationMatrix());
}
}
// Set zone-related shader parameters
BlendMode blend = graphics->GetBlendMode();
// If the pass is additive, override fog color to black so that shaders do not need a separate additive path
bool overrideFogColorToBlack = blend == BLEND_ADD || blend == BLEND_ADDALPHA;
unsigned zoneHash = (unsigned)(size_t)zone_;
if (overrideFogColorToBlack)
zoneHash += 0x80000000;
if (zone_ && graphics->NeedParameterUpdate(SP_ZONE, reinterpret_cast<void*>(zoneHash)))
{
graphics->SetShaderParameter(VSP_AMBIENTSTARTCOLOR, zone_->GetAmbientStartColor());
graphics->SetShaderParameter(VSP_AMBIENTENDCOLOR, zone_->GetAmbientEndColor().ToVector4() - zone_->GetAmbientStartColor().ToVector4());
const BoundingBox& box = zone_->GetBoundingBox();
Vector3 boxSize = box.Size();
Matrix3x4 adjust(Matrix3x4::IDENTITY);
adjust.SetScale(Vector3(1.0f / boxSize.x_, 1.0f / boxSize.y_, 1.0f / boxSize.z_));
adjust.SetTranslation(Vector3(0.5f, 0.5f, 0.5f));
Matrix3x4 zoneTransform = adjust * zone_->GetInverseWorldTransform();
graphics->SetShaderParameter(VSP_ZONE, zoneTransform);
graphics->SetShaderParameter(PSP_AMBIENTCOLOR, zone_->GetAmbientColor());
graphics->SetShaderParameter(PSP_FOGCOLOR, overrideFogColorToBlack ? Color::BLACK : zone_->GetFogColor());
float farClip = camera_->GetFarClip();
float fogStart = Min(zone_->GetFogStart(), farClip);
float fogEnd = Min(zone_->GetFogEnd(), farClip);
if (fogStart >= fogEnd * (1.0f - M_LARGE_EPSILON))
fogStart = fogEnd * (1.0f - M_LARGE_EPSILON);
float fogRange = Max(fogEnd - fogStart, M_EPSILON);
Vector4 fogParams(fogEnd / farClip, farClip / fogRange, 0.0f, 0.0f);
Node* zoneNode = zone_->GetNode();
if (zone_->GetHeightFog() && zoneNode)
{
Vector3 worldFogHeightVec = zoneNode->GetWorldTransform() * Vector3(0.0f, zone_->GetFogHeight(), 0.0f);
fogParams.z_ = worldFogHeightVec.y_;
fogParams.w_ = zone_->GetFogHeightScale() / Max(zoneNode->GetWorldScale().y_, M_EPSILON);
}
graphics->SetShaderParameter(PSP_FOGPARAMS, fogParams);
}
// Set light-related shader parameters
if (lightQueue_)
{
if (graphics->NeedParameterUpdate(SP_VERTEXLIGHTS, lightQueue_) && graphics->HasShaderParameter(VS, VSP_VERTEXLIGHTS))
{
Vector4 vertexLights[MAX_VERTEX_LIGHTS * 3];
const PODVector<Light*>& lights = lightQueue_->vertexLights_;
for (unsigned i = 0; i < lights.Size(); ++i)
{
Light* vertexLight = lights[i];
Node* vertexLightNode = vertexLight->GetNode();
LightType type = vertexLight->GetLightType();
// Attenuation
float invRange, cutoff, invCutoff;
if (type == LIGHT_DIRECTIONAL)
invRange = 0.0f;
else
invRange = 1.0f / Max(vertexLight->GetRange(), M_EPSILON);
if (type == LIGHT_SPOT)
{
cutoff = Cos(vertexLight->GetFov() * 0.5f);
invCutoff = 1.0f / (1.0f - cutoff);
}
else
{
cutoff = -1.0f;
invCutoff = 1.0f;
}
// Color
float fade = 1.0f;
float fadeEnd = vertexLight->GetDrawDistance();
float fadeStart = vertexLight->GetFadeDistance();
// Do fade calculation for light if both fade & draw distance defined
if (vertexLight->GetLightType() != LIGHT_DIRECTIONAL && fadeEnd > 0.0f && fadeStart > 0.0f && fadeStart < fadeEnd)
fade = Min(1.0f - (vertexLight->GetDistance() - fadeStart) / (fadeEnd - fadeStart), 1.0f);
Color color = vertexLight->GetEffectiveColor() * fade;
vertexLights[i * 3] = Vector4(color.r_, color.g_, color.b_, invRange);
// Direction
vertexLights[i * 3 + 1] = Vector4(-(vertexLightNode->GetWorldDirection()), cutoff);
// Position
vertexLights[i * 3 + 2] = Vector4(vertexLightNode->GetWorldPosition(), invCutoff);
}
if (lights.Size())
graphics->SetShaderParameter(VSP_VERTEXLIGHTS, vertexLights[0].Data(), lights.Size() * 3 * 4);
}
}
if (light && graphics->NeedParameterUpdate(SP_LIGHT, light))
{
// Deferred light volume batches operate in a camera-centered space. Detect from material, zone & pass all being null
bool isLightVolume = !material_ && !pass_ && !zone_;
Matrix3x4 cameraEffectiveTransform = camera_->GetEffectiveWorldTransform();
Vector3 cameraEffectivePos = cameraEffectiveTransform.Translation();
Node* lightNode = light->GetNode();
Matrix3 lightWorldRotation = lightNode->GetWorldRotation().RotationMatrix();
graphics->SetShaderParameter(VSP_LIGHTDIR, lightWorldRotation * Vector3::BACK);
float atten = 1.0f / Max(light->GetRange(), M_EPSILON);
graphics->SetShaderParameter(VSP_LIGHTPOS, Vector4(lightNode->GetWorldPosition(), atten));
if (graphics->HasShaderParameter(VS, VSP_LIGHTMATRICES))
{
switch (light->GetLightType())
{
case LIGHT_DIRECTIONAL:
{
Matrix4 shadowMatrices[MAX_CASCADE_SPLITS];
unsigned numSplits = lightQueue_->shadowSplits_.Size();
for (unsigned i = 0; i < numSplits; ++i)
CalculateShadowMatrix(shadowMatrices[i], lightQueue_, i, renderer, Vector3::ZERO);
graphics->SetShaderParameter(VSP_LIGHTMATRICES, shadowMatrices[0].Data(), 16 * numSplits);
}
break;
case LIGHT_SPOT:
{
Matrix4 shadowMatrices[2];
CalculateSpotMatrix(shadowMatrices[0], light, Vector3::ZERO);
bool isShadowed = shadowMap && graphics->HasTextureUnit(TU_SHADOWMAP);
if (isShadowed)
CalculateShadowMatrix(shadowMatrices[1], lightQueue_, 0, renderer, Vector3::ZERO);
graphics->SetShaderParameter(VSP_LIGHTMATRICES, shadowMatrices[0].Data(), isShadowed ? 32 : 16);
}
break;
case LIGHT_POINT:
{
Matrix4 lightVecRot(lightNode->GetWorldRotation().RotationMatrix());
// HLSL compiler will pack the parameters as if the matrix is only 3x4, so must be careful to not overwrite
// the next parameter
#ifdef URHO3D_OPENGL
graphics->SetShaderParameter(VSP_LIGHTMATRICES, lightVecRot.Data(), 16);
#else
graphics->SetShaderParameter(VSP_LIGHTMATRICES, lightVecRot.Data(), 12);
#endif
}
break;
}
}
float fade = 1.0f;
float fadeEnd = light->GetDrawDistance();
float fadeStart = light->GetFadeDistance();
// Do fade calculation for light if both fade & draw distance defined
if (light->GetLightType() != LIGHT_DIRECTIONAL && fadeEnd > 0.0f && fadeStart > 0.0f && fadeStart < fadeEnd)
fade = Min(1.0f - (light->GetDistance() - fadeStart) / (fadeEnd - fadeStart), 1.0f);
// Negative lights will use subtract blending, so write absolute RGB values to the shader parameter
graphics->SetShaderParameter(PSP_LIGHTCOLOR, Color(light->GetEffectiveColor().Abs(),
light->GetEffectiveSpecularIntensity()) * fade);
graphics->SetShaderParameter(PSP_LIGHTDIR, lightWorldRotation * Vector3::BACK);
graphics->SetShaderParameter(PSP_LIGHTPOS, Vector4((isLightVolume ? (lightNode->GetWorldPosition() -
cameraEffectivePos) : lightNode->GetWorldPosition()), atten));
if (graphics->HasShaderParameter(PS, PSP_LIGHTMATRICES))
{
switch (light->GetLightType())
{
case LIGHT_DIRECTIONAL:
{
Matrix4 shadowMatrices[MAX_CASCADE_SPLITS];
unsigned numSplits = lightQueue_->shadowSplits_.Size();
for (unsigned i = 0; i < numSplits; ++i)
{
CalculateShadowMatrix(shadowMatrices[i], lightQueue_, i, renderer, isLightVolume ? cameraEffectivePos :
Vector3::ZERO);
}
graphics->SetShaderParameter(PSP_LIGHTMATRICES, shadowMatrices[0].Data(), 16 * numSplits);
}
break;
case LIGHT_SPOT:
{
Matrix4 shadowMatrices[2];
CalculateSpotMatrix(shadowMatrices[0], light, cameraEffectivePos);
bool isShadowed = lightQueue_->shadowMap_ != 0;
if (isShadowed)
{
CalculateShadowMatrix(shadowMatrices[1], lightQueue_, 0, renderer, isLightVolume ? cameraEffectivePos :
Vector3::ZERO);
}
graphics->SetShaderParameter(PSP_LIGHTMATRICES, shadowMatrices[0].Data(), isShadowed ? 32 : 16);
}
break;
case LIGHT_POINT:
{
Matrix4 lightVecRot(lightNode->GetWorldRotation().RotationMatrix());
// HLSL compiler will pack the parameters as if the matrix is only 3x4, so must be careful to not overwrite
// the next parameter
#ifdef URHO3D_OPENGL
graphics->SetShaderParameter(PSP_LIGHTMATRICES, lightVecRot.Data(), 16);
#else
graphics->SetShaderParameter(PSP_LIGHTMATRICES, lightVecRot.Data(), 12);
#endif
}
break;
}
}
// Set shadow mapping shader parameters
if (shadowMap)
{
{
// Calculate point light shadow sampling offsets (unrolled cube map)
unsigned faceWidth = shadowMap->GetWidth() / 2;
unsigned faceHeight = shadowMap->GetHeight() / 3;
float width = (float)shadowMap->GetWidth();
float height = (float)shadowMap->GetHeight();
#ifdef URHO3D_OPENGL
float mulX = (float)(faceWidth - 3) / width;
float mulY = (float)(faceHeight - 3) / height;
float addX = 1.5f / width;
float addY = 1.5f / height;
#else
float mulX = (float)(faceWidth - 4) / width;
float mulY = (float)(faceHeight - 4) / height;
float addX = 2.5f / width;
float addY = 2.5f / height;
#endif
// If using 4 shadow samples, offset the position diagonally by half pixel
if (renderer->GetShadowQuality() & SHADOWQUALITY_HIGH_16BIT)
{
addX -= 0.5f / width;
addY -= 0.5f / height;
}
graphics->SetShaderParameter(PSP_SHADOWCUBEADJUST, Vector4(mulX, mulY, addX, addY));
}
{
// Calculate shadow camera depth parameters for point light shadows and shadow fade parameters for
// directional light shadows, stored in the same uniform
Camera* shadowCamera = lightQueue_->shadowSplits_[0].shadowCamera_;
float nearClip = shadowCamera->GetNearClip();
float farClip = shadowCamera->GetFarClip();
float q = farClip / (farClip - nearClip);
float r = -q * nearClip;
const CascadeParameters& parameters = light->GetShadowCascade();
float viewFarClip = camera_->GetFarClip();
float shadowRange = parameters.GetShadowRange();
float fadeStart = parameters.fadeStart_ * shadowRange / viewFarClip;
float fadeEnd = shadowRange / viewFarClip;
float fadeRange = fadeEnd - fadeStart;
graphics->SetShaderParameter(PSP_SHADOWDEPTHFADE, Vector4(q, r, fadeStart, 1.0f / fadeRange));
}
{
float intensity = light->GetShadowIntensity();
float fadeStart = light->GetShadowFadeDistance();
float fadeEnd = light->GetShadowDistance();
if (fadeStart > 0.0f && fadeEnd > 0.0f && fadeEnd > fadeStart)
intensity = Lerp(intensity, 1.0f, Clamp((light->GetDistance() - fadeStart) / (fadeEnd - fadeStart), 0.0f, 1.0f));
float pcfValues = (1.0f - intensity);
float samples = renderer->GetShadowQuality() >= SHADOWQUALITY_HIGH_16BIT ? 4.0f : 1.0f;
graphics->SetShaderParameter(PSP_SHADOWINTENSITY, Vector4(pcfValues / samples, intensity, 0.0f, 0.0f));
}
float sizeX = 1.0f / (float)shadowMap->GetWidth();
float sizeY = 1.0f / (float)shadowMap->GetHeight();
graphics->SetShaderParameter(PSP_SHADOWMAPINVSIZE, Vector4(sizeX, sizeY, 0.0f, 0.0f));
Vector4 lightSplits(M_LARGE_VALUE, M_LARGE_VALUE, M_LARGE_VALUE, M_LARGE_VALUE);
if (lightQueue_->shadowSplits_.Size() > 1)
lightSplits.x_ = lightQueue_->shadowSplits_[0].farSplit_ / camera_->GetFarClip();
if (lightQueue_->shadowSplits_.Size() > 2)
lightSplits.y_ = lightQueue_->shadowSplits_[1].farSplit_ / camera_->GetFarClip();
if (lightQueue_->shadowSplits_.Size() > 3)
lightSplits.z_ = lightQueue_->shadowSplits_[2].farSplit_ / camera_->GetFarClip();
graphics->SetShaderParameter(PSP_SHADOWSPLITS, lightSplits);
}
}
// Set material-specific shader parameters and textures
if (material_)
{
if (graphics->NeedParameterUpdate(SP_MATERIAL, material_))
{
// Update shader parameter animations
material_->UpdateShaderParameterAnimations();
const HashMap<StringHash, MaterialShaderParameter>& parameters = material_->GetShaderParameters();
for (HashMap<StringHash, MaterialShaderParameter>::ConstIterator i = parameters.Begin(); i != parameters.End(); ++i)
graphics->SetShaderParameter(i->first_, i->second_.value_);
}
const SharedPtr<Texture>* textures = material_->GetTextures();
for (unsigned i = 0; i < MAX_MATERIAL_TEXTURE_UNITS; ++i)
{
TextureUnit unit = (TextureUnit)i;
if (textures[i] && graphics->HasTextureUnit(unit))
graphics->SetTexture(i, textures[i]);
}
}
// Set light-related textures
if (light)
{
if (shadowMap && graphics->HasTextureUnit(TU_SHADOWMAP))
graphics->SetTexture(TU_SHADOWMAP, shadowMap);
if (graphics->HasTextureUnit(TU_LIGHTRAMP))
{
Texture* rampTexture = light->GetRampTexture();
if (!rampTexture)
rampTexture = renderer->GetDefaultLightRamp();
graphics->SetTexture(TU_LIGHTRAMP, rampTexture);
}
if (graphics->HasTextureUnit(TU_LIGHTSHAPE))
{
Texture* shapeTexture = light->GetShapeTexture();
if (!shapeTexture && light->GetLightType() == LIGHT_SPOT)
shapeTexture = renderer->GetDefaultLightSpot();
graphics->SetTexture(TU_LIGHTSHAPE, shapeTexture);
}
}
}
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 Batch::Prepare(View* view, Camera* camera, bool setModelTransform, bool allowDepthWrite) const
{
if (!vertexShader_ || !pixelShader_)
return;
Graphics* graphics = view->GetGraphics();
Renderer* renderer = view->GetRenderer();
Node* cameraNode = camera ? camera->GetNode() : 0;
Light* light = lightQueue_ ? lightQueue_->light_ : 0;
Texture2D* shadowMap = lightQueue_ ? lightQueue_->shadowMap_ : 0;
// Set shaders first. The available shader parameters and their register/uniform positions depend on the currently set shaders
graphics->SetShaders(vertexShader_, pixelShader_);
// Set pass / material-specific renderstates
if (pass_ && material_)
{
BlendMode blend = pass_->GetBlendMode();
// Turn additive blending into subtract if the light is negative
if (light && light->IsNegative())
{
if (blend == BLEND_ADD)
blend = BLEND_SUBTRACT;
else if (blend == BLEND_ADDALPHA)
blend = BLEND_SUBTRACTALPHA;
}
graphics->SetBlendMode(blend);
bool isShadowPass = pass_->GetIndex() == Technique::shadowPassIndex;
CullMode effectiveCullMode = pass_->GetCullMode();
// Get cull mode from material if pass doesn't override it
if (effectiveCullMode == MAX_CULLMODES)
effectiveCullMode = isShadowPass ? material_->GetShadowCullMode() : material_->GetCullMode();
renderer->SetCullMode(effectiveCullMode, camera);
if (!isShadowPass)
{
const BiasParameters& depthBias = material_->GetDepthBias();
graphics->SetDepthBias(depthBias.constantBias_, depthBias.slopeScaledBias_);
}
// Use the "least filled" fill mode combined from camera & material
graphics->SetFillMode((FillMode)(Max(camera->GetFillMode(), material_->GetFillMode())));
graphics->SetDepthTest(pass_->GetDepthTestMode());
graphics->SetDepthWrite(pass_->GetDepthWrite() && allowDepthWrite);
}
// Set global (per-frame) shader parameters
if (graphics->NeedParameterUpdate(SP_FRAME, (void*)0))
view->SetGlobalShaderParameters();
// Set camera & viewport shader parameters
unsigned cameraHash = (unsigned)(size_t)camera;
IntRect viewport = graphics->GetViewport();
IntVector2 viewSize = IntVector2(viewport.Width(), viewport.Height());
unsigned viewportHash = (unsigned)(viewSize.x_ | (viewSize.y_ << 16));
if (graphics->NeedParameterUpdate(SP_CAMERA, reinterpret_cast<const void*>(cameraHash + viewportHash)))
{
view->SetCameraShaderParameters(camera);
// During renderpath commands the G-Buffer or viewport texture is assumed to always be viewport-sized
view->SetGBufferShaderParameters(viewSize, IntRect(0, 0, viewSize.x_, viewSize.y_));
}
// Set model or skinning transforms
if (setModelTransform && graphics->NeedParameterUpdate(SP_OBJECT, worldTransform_))
{
if (geometryType_ == GEOM_SKINNED)
{
graphics->SetShaderParameter(VSP_SKINMATRICES, reinterpret_cast<const float*>(worldTransform_),
12 * numWorldTransforms_);
}
else
graphics->SetShaderParameter(VSP_MODEL, *worldTransform_);
// Set the orientation for billboards, either from the object itself or from the camera
if (geometryType_ == GEOM_BILLBOARD)
{
if (numWorldTransforms_ > 1)
graphics->SetShaderParameter(VSP_BILLBOARDROT, worldTransform_[1].RotationMatrix());
else
graphics->SetShaderParameter(VSP_BILLBOARDROT, cameraNode->GetWorldRotation().RotationMatrix());
}
}
// Set zone-related shader parameters
BlendMode blend = graphics->GetBlendMode();
// If the pass is additive, override fog color to black so that shaders do not need a separate additive path
bool overrideFogColorToBlack = blend == BLEND_ADD || blend == BLEND_ADDALPHA;
unsigned zoneHash = (unsigned)(size_t)zone_;
if (overrideFogColorToBlack)
zoneHash += 0x80000000;
if (zone_ && graphics->NeedParameterUpdate(SP_ZONE, reinterpret_cast<const void*>(zoneHash)))
{
graphics->SetShaderParameter(VSP_AMBIENTSTARTCOLOR, zone_->GetAmbientStartColor());
graphics->SetShaderParameter(VSP_AMBIENTENDCOLOR,
zone_->GetAmbientEndColor().ToVector4() - zone_->GetAmbientStartColor().ToVector4());
const BoundingBox& box = zone_->GetBoundingBox();
Vector3 boxSize = box.Size();
Matrix3x4 adjust(Matrix3x4::IDENTITY);
adjust.SetScale(Vector3(1.0f / boxSize.x_, 1.0f / boxSize.y_, 1.0f / boxSize.z_));
adjust.SetTranslation(Vector3(0.5f, 0.5f, 0.5f));
Matrix3x4 zoneTransform = adjust * zone_->GetInverseWorldTransform();
graphics->SetShaderParameter(VSP_ZONE, zoneTransform);
graphics->SetShaderParameter(PSP_AMBIENTCOLOR, zone_->GetAmbientColor());
graphics->SetShaderParameter(PSP_FOGCOLOR, overrideFogColorToBlack ? Color::BLACK : zone_->GetFogColor());
float farClip = camera->GetFarClip();
float fogStart = Min(zone_->GetFogStart(), farClip);
float fogEnd = Min(zone_->GetFogEnd(), farClip);
if (fogStart >= fogEnd * (1.0f - M_LARGE_EPSILON))
fogStart = fogEnd * (1.0f - M_LARGE_EPSILON);
float fogRange = Max(fogEnd - fogStart, M_EPSILON);
Vector4 fogParams(fogEnd / farClip, farClip / fogRange, 0.0f, 0.0f);
Node* zoneNode = zone_->GetNode();
if (zone_->GetHeightFog() && zoneNode)
{
Vector3 worldFogHeightVec = zoneNode->GetWorldTransform() * Vector3(0.0f, zone_->GetFogHeight(), 0.0f);
fogParams.z_ = worldFogHeightVec.y_;
fogParams.w_ = zone_->GetFogHeightScale() / Max(zoneNode->GetWorldScale().y_, M_EPSILON);
}
graphics->SetShaderParameter(PSP_FOGPARAMS, fogParams);
}
// Set light-related shader parameters
if (lightQueue_)
{
if (light && graphics->NeedParameterUpdate(SP_LIGHT, lightQueue_))
{
Node* lightNode = light->GetNode();
float atten = 1.0f / Max(light->GetRange(), M_EPSILON);
Vector3 lightDir(lightNode->GetWorldRotation() * Vector3::BACK);
Vector4 lightPos(lightNode->GetWorldPosition(), atten);
graphics->SetShaderParameter(VSP_LIGHTDIR, lightDir);
graphics->SetShaderParameter(VSP_LIGHTPOS, lightPos);
if (graphics->HasShaderParameter(VSP_LIGHTMATRICES))
{
switch (light->GetLightType())
{
case LIGHT_DIRECTIONAL:
{
Matrix4 shadowMatrices[MAX_CASCADE_SPLITS];
unsigned numSplits = Min(MAX_CASCADE_SPLITS, lightQueue_->shadowSplits_.Size());
for (unsigned i = 0; i < numSplits; ++i)
CalculateShadowMatrix(shadowMatrices[i], lightQueue_, i, renderer);
graphics->SetShaderParameter(VSP_LIGHTMATRICES, shadowMatrices[0].Data(), 16 * numSplits);
}
break;
case LIGHT_SPOT:
{
Matrix4 shadowMatrices[2];
CalculateSpotMatrix(shadowMatrices[0], light);
bool isShadowed = shadowMap && graphics->HasTextureUnit(TU_SHADOWMAP);
if (isShadowed)
CalculateShadowMatrix(shadowMatrices[1], lightQueue_, 0, renderer);
graphics->SetShaderParameter(VSP_LIGHTMATRICES, shadowMatrices[0].Data(), isShadowed ? 32 : 16);
}
break;
case LIGHT_POINT:
{
Matrix4 lightVecRot(lightNode->GetWorldRotation().RotationMatrix());
// HLSL compiler will pack the parameters as if the matrix is only 3x4, so must be careful to not overwrite
// the next parameter
#ifdef ATOMIC_OPENGL
graphics->SetShaderParameter(VSP_LIGHTMATRICES, lightVecRot.Data(), 16);
#else
graphics->SetShaderParameter(VSP_LIGHTMATRICES, lightVecRot.Data(), 12);
#endif
}
break;
}
}
float fade = 1.0f;
float fadeEnd = light->GetDrawDistance();
float fadeStart = light->GetFadeDistance();
// Do fade calculation for light if both fade & draw distance defined
if (light->GetLightType() != LIGHT_DIRECTIONAL && fadeEnd > 0.0f && fadeStart > 0.0f && fadeStart < fadeEnd)
fade = Min(1.0f - (light->GetDistance() - fadeStart) / (fadeEnd - fadeStart), 1.0f);
// Negative lights will use subtract blending, so write absolute RGB values to the shader parameter
graphics->SetShaderParameter(PSP_LIGHTCOLOR, Color(light->GetEffectiveColor().Abs(),
light->GetEffectiveSpecularIntensity()) * fade);
graphics->SetShaderParameter(PSP_LIGHTDIR, lightDir);
graphics->SetShaderParameter(PSP_LIGHTPOS, lightPos);
if (graphics->HasShaderParameter(PSP_LIGHTMATRICES))
{
switch (light->GetLightType())
{
case LIGHT_DIRECTIONAL:
{
Matrix4 shadowMatrices[MAX_CASCADE_SPLITS];
unsigned numSplits = Min(MAX_CASCADE_SPLITS, lightQueue_->shadowSplits_.Size());
for (unsigned i = 0; i < numSplits; ++i)
CalculateShadowMatrix(shadowMatrices[i], lightQueue_, i, renderer);
graphics->SetShaderParameter(PSP_LIGHTMATRICES, shadowMatrices[0].Data(), 16 * numSplits);
}
break;
case LIGHT_SPOT:
{
Matrix4 shadowMatrices[2];
CalculateSpotMatrix(shadowMatrices[0], light);
bool isShadowed = lightQueue_->shadowMap_ != 0;
if (isShadowed)
CalculateShadowMatrix(shadowMatrices[1], lightQueue_, 0, renderer);
graphics->SetShaderParameter(PSP_LIGHTMATRICES, shadowMatrices[0].Data(), isShadowed ? 32 : 16);
}
break;
case LIGHT_POINT:
{
Matrix4 lightVecRot(lightNode->GetWorldRotation().RotationMatrix());
// HLSL compiler will pack the parameters as if the matrix is only 3x4, so must be careful to not overwrite
// the next parameter
#ifdef ATOMIC_OPENGL
graphics->SetShaderParameter(PSP_LIGHTMATRICES, lightVecRot.Data(), 16);
#else
graphics->SetShaderParameter(PSP_LIGHTMATRICES, lightVecRot.Data(), 12);
#endif
}
break;
}
}
// Set shadow mapping shader parameters
if (shadowMap)
{
{
// Calculate point light shadow sampling offsets (unrolled cube map)
unsigned faceWidth = (unsigned)(shadowMap->GetWidth() / 2);
unsigned faceHeight = (unsigned)(shadowMap->GetHeight() / 3);
float width = (float)shadowMap->GetWidth();
float height = (float)shadowMap->GetHeight();
#ifdef ATOMIC_OPENGL
float mulX = (float)(faceWidth - 3) / width;
float mulY = (float)(faceHeight - 3) / height;
float addX = 1.5f / width;
float addY = 1.5f / height;
#else
float mulX = (float)(faceWidth - 4) / width;
float mulY = (float)(faceHeight - 4) / height;
float addX = 2.5f / width;
float addY = 2.5f / height;
#endif
// If using 4 shadow samples, offset the position diagonally by half pixel
if (renderer->GetShadowQuality() == SHADOWQUALITY_PCF_16BIT || renderer->GetShadowQuality() == SHADOWQUALITY_PCF_24BIT)
{
addX -= 0.5f / width;
addY -= 0.5f / height;
}
graphics->SetShaderParameter(PSP_SHADOWCUBEADJUST, Vector4(mulX, mulY, addX, addY));
}
{
// Calculate shadow camera depth parameters for point light shadows and shadow fade parameters for
// directional light shadows, stored in the same uniform
Camera* shadowCamera = lightQueue_->shadowSplits_[0].shadowCamera_;
float nearClip = shadowCamera->GetNearClip();
float farClip = shadowCamera->GetFarClip();
float q = farClip / (farClip - nearClip);
float r = -q * nearClip;
const CascadeParameters& parameters = light->GetShadowCascade();
float viewFarClip = camera->GetFarClip();
float shadowRange = parameters.GetShadowRange();
float fadeStart = parameters.fadeStart_ * shadowRange / viewFarClip;
float fadeEnd = shadowRange / viewFarClip;
float fadeRange = fadeEnd - fadeStart;
graphics->SetShaderParameter(PSP_SHADOWDEPTHFADE, Vector4(q, r, fadeStart, 1.0f / fadeRange));
}
{
float intensity = light->GetShadowIntensity();
float fadeStart = light->GetShadowFadeDistance();
float fadeEnd = light->GetShadowDistance();
if (fadeStart > 0.0f && fadeEnd > 0.0f && fadeEnd > fadeStart)
intensity =
Lerp(intensity, 1.0f, Clamp((light->GetDistance() - fadeStart) / (fadeEnd - fadeStart), 0.0f, 1.0f));
float pcfValues = (1.0f - intensity);
float samples = 1.0f;
if (renderer->GetShadowQuality() == SHADOWQUALITY_PCF_16BIT || renderer->GetShadowQuality() == SHADOWQUALITY_PCF_24BIT)
samples = 4.0f;
graphics->SetShaderParameter(PSP_SHADOWINTENSITY, Vector4(pcfValues / samples, intensity, 0.0f, 0.0f));
}
float sizeX = 1.0f / (float)shadowMap->GetWidth();
float sizeY = 1.0f / (float)shadowMap->GetHeight();
graphics->SetShaderParameter(PSP_SHADOWMAPINVSIZE, Vector2(sizeX, sizeY));
Vector4 lightSplits(M_LARGE_VALUE, M_LARGE_VALUE, M_LARGE_VALUE, M_LARGE_VALUE);
if (lightQueue_->shadowSplits_.Size() > 1)
lightSplits.x_ = lightQueue_->shadowSplits_[0].farSplit_ / camera->GetFarClip();
if (lightQueue_->shadowSplits_.Size() > 2)
lightSplits.y_ = lightQueue_->shadowSplits_[1].farSplit_ / camera->GetFarClip();
if (lightQueue_->shadowSplits_.Size() > 3)
lightSplits.z_ = lightQueue_->shadowSplits_[2].farSplit_ / camera->GetFarClip();
graphics->SetShaderParameter(PSP_SHADOWSPLITS, lightSplits);
if (graphics->HasShaderParameter(PSP_VSMSHADOWPARAMS))
graphics->SetShaderParameter(PSP_VSMSHADOWPARAMS, renderer->GetVSMShadowParameters());
if (light->GetShadowBias().normalOffset_ > 0.0f)
{
Vector4 normalOffsetScale(Vector4::ZERO);
// Scale normal offset strength with the width of the shadow camera view
if (light->GetLightType() != LIGHT_DIRECTIONAL)
{
Camera* shadowCamera = lightQueue_->shadowSplits_[0].shadowCamera_;
normalOffsetScale.x_ = 2.0f * tanf(shadowCamera->GetFov() * M_DEGTORAD * 0.5f) * shadowCamera->GetFarClip();
}
else
{
normalOffsetScale.x_ = lightQueue_->shadowSplits_[0].shadowCamera_->GetOrthoSize();
if (lightQueue_->shadowSplits_.Size() > 1)
normalOffsetScale.y_ = lightQueue_->shadowSplits_[1].shadowCamera_->GetOrthoSize();
if (lightQueue_->shadowSplits_.Size() > 2)
normalOffsetScale.z_ = lightQueue_->shadowSplits_[2].shadowCamera_->GetOrthoSize();
if (lightQueue_->shadowSplits_.Size() > 3)
normalOffsetScale.w_ = lightQueue_->shadowSplits_[3].shadowCamera_->GetOrthoSize();
}
normalOffsetScale *= light->GetShadowBias().normalOffset_;
#ifdef GL_ES_VERSION_2_0
normalOffsetScale *= renderer->GetMobileNormalOffsetMul();
#endif
graphics->SetShaderParameter(VSP_NORMALOFFSETSCALE, normalOffsetScale);
graphics->SetShaderParameter(PSP_NORMALOFFSETSCALE, normalOffsetScale);
}
}
}
else if (lightQueue_->vertexLights_.Size() && graphics->HasShaderParameter(VSP_VERTEXLIGHTS) &&
graphics->NeedParameterUpdate(SP_LIGHT, lightQueue_))
{
Vector4 vertexLights[MAX_VERTEX_LIGHTS * 3];
const PODVector<Light*>& lights = lightQueue_->vertexLights_;
for (unsigned i = 0; i < lights.Size(); ++i)
{
Light* vertexLight = lights[i];
Node* vertexLightNode = vertexLight->GetNode();
LightType type = vertexLight->GetLightType();
// Attenuation
float invRange, cutoff, invCutoff;
if (type == LIGHT_DIRECTIONAL)
invRange = 0.0f;
else
invRange = 1.0f / Max(vertexLight->GetRange(), M_EPSILON);
if (type == LIGHT_SPOT)
{
cutoff = Cos(vertexLight->GetFov() * 0.5f);
invCutoff = 1.0f / (1.0f - cutoff);
}
else
{
cutoff = -1.0f;
invCutoff = 1.0f;
}
// Color
float fade = 1.0f;
float fadeEnd = vertexLight->GetDrawDistance();
float fadeStart = vertexLight->GetFadeDistance();
// Do fade calculation for light if both fade & draw distance defined
if (vertexLight->GetLightType() != LIGHT_DIRECTIONAL && fadeEnd > 0.0f && fadeStart > 0.0f && fadeStart < fadeEnd)
fade = Min(1.0f - (vertexLight->GetDistance() - fadeStart) / (fadeEnd - fadeStart), 1.0f);
Color color = vertexLight->GetEffectiveColor() * fade;
vertexLights[i * 3] = Vector4(color.r_, color.g_, color.b_, invRange);
// Direction
vertexLights[i * 3 + 1] = Vector4(-(vertexLightNode->GetWorldDirection()), cutoff);
// Position
vertexLights[i * 3 + 2] = Vector4(vertexLightNode->GetWorldPosition(), invCutoff);
}
graphics->SetShaderParameter(VSP_VERTEXLIGHTS, vertexLights[0].Data(), lights.Size() * 3 * 4);
}
}
// Set zone texture if necessary
#ifndef GL_ES_VERSION_2_0
if (zone_ && graphics->HasTextureUnit(TU_ZONE))
graphics->SetTexture(TU_ZONE, zone_->GetZoneTexture());
#else
// On OpenGL ES set the zone texture to the environment unit instead
if (zone_ && zone_->GetZoneTexture() && graphics->HasTextureUnit(TU_ENVIRONMENT))
graphics->SetTexture(TU_ENVIRONMENT, zone_->GetZoneTexture());
#endif
// Set material-specific shader parameters and textures
if (material_)
{
if (graphics->NeedParameterUpdate(SP_MATERIAL, reinterpret_cast<const void*>(material_->GetShaderParameterHash())))
{
const HashMap<StringHash, MaterialShaderParameter>& parameters = material_->GetShaderParameters();
for (HashMap<StringHash, MaterialShaderParameter>::ConstIterator i = parameters.Begin(); i != parameters.End(); ++i)
graphics->SetShaderParameter(i->first_, i->second_.value_);
}
const HashMap<TextureUnit, SharedPtr<Texture> >& textures = material_->GetTextures();
for (HashMap<TextureUnit, SharedPtr<Texture> >::ConstIterator i = textures.Begin(); i != textures.End(); ++i)
{
if (graphics->HasTextureUnit(i->first_))
graphics->SetTexture(i->first_, i->second_.Get());
}
}
// Set light-related textures
if (light)
{
if (shadowMap && graphics->HasTextureUnit(TU_SHADOWMAP))
graphics->SetTexture(TU_SHADOWMAP, shadowMap);
if (graphics->HasTextureUnit(TU_LIGHTRAMP))
{
Texture* rampTexture = light->GetRampTexture();
if (!rampTexture)
rampTexture = renderer->GetDefaultLightRamp();
graphics->SetTexture(TU_LIGHTRAMP, rampTexture);
}
if (graphics->HasTextureUnit(TU_LIGHTSHAPE))
{
Texture* shapeTexture = light->GetShapeTexture();
if (!shapeTexture && light->GetLightType() == LIGHT_SPOT)
shapeTexture = renderer->GetDefaultLightSpot();
graphics->SetTexture(TU_LIGHTSHAPE, shapeTexture);
}
}
}