bool ETHRenderEntity::IsSpriteVisible(const ETHSceneProperties& sceneProps, const ETHBackBufferTargetManagerPtr& backBuffer) const
{
if (!m_pSprite || IsHidden())
return false;
const float angle = GetAngle();
if (GetType() == ETHEntityProperties::ET_VERTICAL || angle == 0.0f)
{
const Vector2& bufferSize = backBuffer->GetBufferSize();
const ETHEntityProperties::VIEW_RECT& rect = GetScreenRect(sceneProps);
const Vector2& min = rect.min;
const Vector2& max = rect.max;
if (min.x > bufferSize.x || min.y > bufferSize.y)
{
return false;
}
else if (max.x < 0.0f || max.y < 0.0f)
{
return false;
}
else
{
return true;
}
}
else
{
// TODO/TO-DO perform this in the OrientedBoundingBox class
const Vector2& size = GetCurrentSize();
const float radianAngle = -DegreeToRadian(angle);
const OrientedBoundingBox entityObb(ComputeInScreenSpriteCenter(sceneProps), size, radianAngle);
return entityObb.Overlaps(*(backBuffer->GetOBB().get()));
}
}
// Set the current font size
bool Font::SetCurrentSize( unsigned int size )
{
unsigned int currentSize = GetCurrentSize();
// Only change the size if necessary
if ( currentSize != size )
{
FT_Error error = FT_Set_Pixel_Sizes( _myFontFace, 0, size );
#if defined( _DEBUG ) || defined( DEBUG )
// If the given size was invalid, print out valid sizes
if ( error == FT_Err_Invalid_Pixel_Size && !FT_IS_SCALABLE( _myFontFace ) )
{
std::cout << "Failed to set " << GetFontName() << " font size to " << size << std::endl;
std::cout << "Valid sizes for " << GetFontName() << ":" << std::endl;
for ( int i = 0; i < _myFontFace->num_fixed_sizes; ++i )
{
std::cout << " " << _myFontFace->available_sizes[ i ].height << std::endl;
}
}
#endif
return error == FT_Err_Ok;
}
return true;
}
void vParticle::Render()
{
Assert( pRenderer != NULL );
if ( GetCurrentAlpha() <= 0.0f ||
GetCurrentColor().LengthSqr() <= 0.0f ||
GetCurrentSize() < 1 )
return;
pRenderer->Render( this );
}
bool ETHRenderEntity::DrawAmbientPass(const float maxHeight, const float minHeight,
const bool enableLightmaps, const ETHSceneProperties& sceneProps,
const float parallaxIntensity)
{
if (!m_pSprite || IsHidden())
return false;
Vector4 v4FinalAmbient = Vector4(sceneProps.ambient, 1.0f);
v4FinalAmbient.x = Min(1.0f, v4FinalAmbient.x + m_properties.emissiveColor.x);
v4FinalAmbient.y = Min(1.0f, v4FinalAmbient.y + m_properties.emissiveColor.y);
v4FinalAmbient.z = Min(1.0f, v4FinalAmbient.z + m_properties.emissiveColor.z);
v4FinalAmbient = v4FinalAmbient * m_v4Color;
SetDepth(maxHeight, minHeight);
const VideoPtr& video = m_provider->GetVideo();
const bool applyLightmap = (m_pLightmap && enableLightmaps && IsStatic());
if (applyLightmap)
{
m_pLightmap->SetAsTexture(1);
}
// sets the alpha mode according to the entity's property
const Video::ALPHA_MODE& am = GetBlendMode();
if (am != video->GetAlphaMode())
video->SetAlphaMode(am);
ValidateSpriteCut(m_pSprite);
m_pSprite->SetRect(m_spriteFrame);
SetOrigin();
const bool shouldUseFourTriangles = ShouldUseFourTriangles(parallaxIntensity);
const float angle = (m_properties.type == ETHEntityProperties::ET_VERTICAL) ? 0.0f : GetAngle();
const Vector2 pos = ETHGlobal::ToScreenPos(GetPosition(), sceneProps.zAxisDirection);
if (shouldUseFourTriangles)
m_pSprite->SetRectMode(Sprite::RM_FOUR_TRIANGLES);
m_pSprite->DrawOptimal(pos, ConvertToDW(v4FinalAmbient), angle, GetCurrentSize());
if (shouldUseFourTriangles)
m_pSprite->SetRectMode(Sprite::RM_TWO_TRIANGLES);
if (applyLightmap)
{
video->UnsetTexture(1);
}
return true;
}
Vector2 ImageActor::GetCurrentImageSize() const
{
Vector3 size;
Vector3 currentSize;
// get the texture size / pixel area if only a subset of it is displayed
if( IsPixelAreaSet() )
{
PixelArea area(GetPixelArea());
return Vector2(area.width, area.height );
}
else
{
return Vector2( GetCurrentSize() );
}
}
Peer_Info* PeerList::operator[](int nIndex)
{
if (nIndex < 0 || nIndex >= GetCurrentSize())
{
return NULL;
}
else
{
PeerInfoListIter Iter1;
int i;
for (i = 0, Iter1 = m_PeerInfoList.begin();
i < nIndex;
++Iter1, ++i)
{
;
}
return &(*Iter1);
}
}
bool ETHRenderEntity::DrawProjShadow(const float maxHeight, const float minHeight, const ETHSceneProperties& sceneProps, const ETHLight& light, ETHSpriteEntity *pParent,
const bool maxOpacity, const bool drawToTarget, const float targetAngle, const Vector3& v3TargetPos)
{
if (!m_pSprite || IsHidden())
return false;
VideoPtr video = m_provider->GetVideo();
ETHShaderManagerPtr shaderManager = m_provider->GetShaderManager();
SpritePtr pShadow = shaderManager->GetProjShadow();
Vector3 v3LightPos;
Vector3 v3ParentPos(0,0,0);
const Vector3 v3EntityPos = GetPosition();
if (pParent)
{
v3ParentPos = pParent->GetPosition();
v3LightPos = Vector3(v3ParentPos.x, v3ParentPos.y, 0) + light.pos;
}
else
{
v3LightPos = light.pos;
}
// if the object is higher than the light, then the shadow shouldn't be cast on the floor
if (v3LightPos.z < v3EntityPos.z)
{
return true;
}
const float scale = (m_properties.shadowScale <= 0.0f) ? 1.0f : m_properties.shadowScale;
const float opacity = (m_properties.shadowOpacity <= 0.0f) ? 1.0f : m_properties.shadowOpacity;
const Vector2 v2Size = GetCurrentSize();
Vector2 v2ShadowSize(v2Size.x, v2Size.y);
Vector2 v2ShadowPos(v3EntityPos.x, v3EntityPos.y);
// if we are drawing to a target of a rotated entity
if (drawToTarget && targetAngle != 0)
{
// rotate the shadow position according to entity angle
Matrix4x4 matRot = RotateZ(-DegreeToRadian(targetAngle));
Vector3 newShadowPos(v2ShadowPos, 0);
newShadowPos = newShadowPos - v3TargetPos;
newShadowPos = Multiply(newShadowPos, matRot);
newShadowPos = newShadowPos + v3TargetPos;
v2ShadowPos.x = newShadowPos.x;
v2ShadowPos.y = newShadowPos.y;
// rotate the light source to cast it correctly
Vector3 newPos = v3LightPos - v3TargetPos;
newPos = Multiply(newPos, matRot);
v3LightPos = newPos + v3TargetPos;
}
Vector3 diff = v3EntityPos - v3LightPos;
const float squaredDist = DP3(diff, diff);
float squaredRange = light.range * light.range;
if (squaredDist > squaredRange)
{
return true;
}
v2ShadowSize.x *= _ETH_SHADOW_SCALEX * scale;
// calculate the correct shadow length according to the light height
if ((GetPosition().z+v2Size.y) < light.pos.z) // if the light is over the entity
{
const float planarDist = Distance(GetPositionXY(), ETHGlobal::ToVector2(v3LightPos));
const float verticalDist = Abs((v3EntityPos.z+v2Size.y)-v3LightPos.z);
const float totalDist = (planarDist/verticalDist)*Abs(v3LightPos.z);
v2ShadowSize.y = totalDist-planarDist;
// clamp shadow length to the object's height. This is not realistic
// but it looks better for the real-time shadows.
v2ShadowSize.y = Min(v2Size.y*_ETH_SHADOW_FAKE_STRETCH, v2ShadowSize.y);
}
else
{
v2ShadowSize.y *= ((drawToTarget) ? _ETH_SHADOW_SCALEY : _ETH_SHADOW_SCALEY/4);
}
// specify a minimum length for the shadow
v2ShadowSize.y = Max(v2ShadowSize.y, v2Size.y);
ShaderPtr pVS = video->GetVertexShader();
pVS->SetConstant(GS_L("shadowLength"), v2ShadowSize.y * m_properties.shadowLengthScale);
pVS->SetConstant(GS_L("entityZ"), Max(m_shadowZ, v3EntityPos.z));
pVS->SetConstant(GS_L("shadowZ"), m_shadowZ);
pVS->SetConstant(GS_L("lightPos"), v3LightPos);
video->SetSpriteDepth(
(GetType() == ETHEntityProperties::ET_VERTICAL) ?
ETHEntity::ComputeDepth(m_shadowZ, maxHeight, minHeight)
: Max(0.0f, ComputeDepth(maxHeight, minHeight) - m_layrableMinimumDepth));
v2ShadowSize.y = 1.0f;
Vector2 lightPos2(v3LightPos.x, v3LightPos.y);
const float shadowAngle = ::GetAngle((lightPos2 - Vector2(v3EntityPos.x, v3EntityPos.y))) + DegreeToRadian(targetAngle);
squaredRange = Max(squaredDist, squaredRange);
float attenBias = 1;
// adjust brightness according to ambient light
if (!maxOpacity)
{
attenBias = (1-(squaredDist/squaredRange));
//fade the color according to the light brightness
const float colorLen = Max(Max(light.color.x, light.color.y), light.color.z);
attenBias *= Min(colorLen, 1.0f);
//fade the color according to the ambient light brightness
const Vector3 &ambientColor = sceneProps.ambient;
const float ambientColorLen = 1.0f-((ambientColor.x + ambientColor.y + ambientColor.z)/3.0f);
attenBias = Min(attenBias*ambientColorLen, 1.0f);
attenBias *= Max(Min((1-(GetPosition().z/Max(GetCurrentSize().y, 1.0f))), 1.0f), 0.0f);
}
GS_BYTE alpha = static_cast<GS_BYTE>(attenBias*255.0f*opacity);
if (alpha < 8)
return true;
Color dwShadowColor(alpha,255,255,255);
pShadow->SetOrigin(Vector2(0.5f, 0.79f));
pShadow->SetRectMode(Sprite::RM_THREE_TRIANGLES);
pShadow->DrawShaped(v2ShadowPos, v2ShadowSize,
dwShadowColor, dwShadowColor, dwShadowColor, dwShadowColor,
RadianToDegree(shadowAngle));
return true;
}