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; }