void TouchButton::DrawButton(VideoPtr video, InputPtr input, SpriteResourceManager& spr)
{
SpritePtr sprite = spr.GetSprite(video, m_buttonSprite);
video->SetAlphaMode(GSAM_PIXEL);
if (sprite)
{
sprite->SetRect(m_buttonFrame);
sprite->SetOrigin(m_origin);
sprite->Draw(m_pos);
if (m_status == PRESSED)
{
video->SetAlphaMode(GSAM_ADD);
sprite->Draw(m_pos);
video->SetAlphaMode(GSAM_PIXEL);
}
}
}
bool GuiButton(ui_context & ui, const ui_id id, string sprite, Transform & transform,
int x, int y, int width, int height, const mouse_info & mouse)
{
bool result = false;
bool mouseover = false;
int frame = 0;
int x1 = x - width / 2;
int x2 = x + width / 2;
int y1 = y - height / 2;
int y2 = y + height / 2;
if (!result && (mouse.x > x1 && mouse.x < x2) && (mouse.y > y1 && mouse.y < y2)) {
mouseover = true;
}
if (ui.active == id) {
frame = 2;
if (mouse.LMB == false) {
if (mouseover && ui.hot == id) {
result = true;
}
ui.active.owner = NULL;
}
} else if (ui.hot == id) {
if (!mouseover) {
ui.hot == NULL;
}
else if (mouse.LMB == true) {
ui.active = id;
}
}
if (mouseover && ui.active.owner == NULL) {
ui.hot = id;
frame = 1;
}
// get dimensions of sprite
SpritePtr btnSprite = g_Sprite.GetSprite(sprite);
const ivec4 & size = btnSprite->GetSize();
double wRatio = (double) width / (double) size.x;
double hRatio = (double) height / (double) size.y;
// draw the button
MatrixStack * mv = transform.GetModelViewStack();
mv->PushMatrix();
mv->Translate((float)x, (float)y, 0);
mv->Scale((float)wRatio, (float)hRatio, 1);
btnSprite->Draw(frame, transform);
mv->PopMatrix();
return result;
}
static void DrawSplashScreen()
{
video->BeginSpriteScene(gs2d::constant::BLACK);
if (splashSprite)
{
splashSprite->SetOrigin(gs2d::Sprite::EO_CENTER);
const Vector2 screenSize(video->GetScreenSizeF());
const float scale = ComputeSplashScale(screenSize);
splashSprite->Draw(screenSize * 0.5f, gs2d::constant::WHITE, 0.0f, Vector2(scale, scale));
}
video->EndSpriteScene();
}
ETHLightmapGen::ETHLightmapGen(ETHRenderEntity* entity,
boost::shared_ptr<ETHShaderManager> shaderManager, std::list<ETHLight>::iterator iBegin, std::list<ETHLight>::iterator iEnd,
ETHBucketManager& buckets, const Vector3& oldPos, const Vector3& newPos, const float minHeight, const float maxHeight,
const ETHSceneProperties &sceneProps)
{
const SpritePtr& sprite = entity->m_pSprite;
const ETHEntityProperties& props = entity->m_properties;
if (!sprite || !props.staticEntity || !props.applyLight)
{
return;
}
const VideoPtr& video = entity->m_provider->GetVideo();
const Platform::FileLogger* logger = entity->m_provider->GetLogger();
if (video->Rendering())
{
ETH_STREAM_DECL(ss) << GS_L("Entity ID #") << entity->GetID() << GS_L(": lightmaps can't be generated during application render.");
logger->Log(ss.str(), Platform::FileLogger::ERROR);
return;
}
const Vector2 v2Size = (sprite->GetNumRects() <= 1) ? sprite->GetBitmapSizeF() : sprite->GetRect().size;
if (!(entity->m_pLightmap = video->CreateRenderTarget(static_cast<unsigned int>(v2Size.x), static_cast<unsigned int>(v2Size.y))))
{
ETH_STREAM_DECL(ss) << GS_L("ETHRenderEntity::GenerateLightmap: coudn't create the render target.");
logger->Log(ss.str(), Platform::FileLogger::ERROR);
entity->m_pLightmap.reset();
return;
}
// Paint it black
video->SetRenderTarget(entity->m_pLightmap);
if (!video->BeginTargetScene(GS_BLACK))
{
ETH_STREAM_DECL(ss) << GS_L("ETHRenderEntity::GenerateLightmap: coudn't render to target.");
logger->Log(ss.str(), Platform::FileLogger::ERROR);
entity->m_pLightmap.reset();
return;
}
video->EndTargetScene();
entity->m_controller->SetPos(newPos);
Vector2 v2CamPos = video->GetCameraPos();
video->SetCameraPos(Vector2(0,0));
for (std::list<ETHLight>::iterator iter = iBegin; iter != iEnd; iter++)
{
if (!iter->staticLight)
continue;
SpritePtr tempTarget;
if (!(tempTarget = video->CreateRenderTarget(static_cast<unsigned int>(v2Size.x), static_cast<unsigned int>(v2Size.y))))
{
ETH_STREAM_DECL(ss) << GS_L("ETHRenderEntity::GenerateLightmap: coudn't create temporary render target.");
logger->Log(ss.str(), Platform::FileLogger::ERROR);
entity->m_pLightmap.reset();
return;
}
if (!video->SetRenderTarget(tempTarget))
{
ETH_STREAM_DECL(ss) << GS_L("ETHRenderEntity::GenerateLightmap: coudn't set render target.");
logger->Log(ss.str(), Platform::FileLogger::ERROR);
entity->m_pLightmap.reset();
return;
}
if (!video->BeginTargetScene(GS_BLACK))
{
ETH_STREAM_DECL(ss) << GS_L("ETHRenderEntity::GenerateLightmap: coudn't render to temporary target.");
logger->Log(ss.str(), Platform::FileLogger::ERROR);
entity->m_pLightmap.reset();
return;
}
// draw light
if (shaderManager->BeginLightPass(entity, &(*iter), video->GetScreenSizeF().y, 0.0f, sceneProps.lightIntensity, 0, true))
{
entity->DrawLightPass(sceneProps.zAxisDirection, true);
shaderManager->EndLightPass();
}
// draw shadows
if (entity->GetType() != ETH_VERTICAL)
{
for (ETHBucketMap::iterator bucketIter = buckets.GetFirstBucket(); bucketIter != buckets.GetLastBucket(); bucketIter++)
{
for (ETHEntityList::iterator entityIter = bucketIter->second.begin();
entityIter != bucketIter->second.end(); entityIter++)
{
if (!(*entityIter)->IsStatic())
continue;
Vector3 oldPos2 = (*entityIter)->GetPosition();
Vector3 newPos2 = oldPos2-(oldPos-newPos);
(*entityIter)->SetOrphanPosition(newPos2);
if (shaderManager->BeginShadowPass((*entityIter), &(*iter), maxHeight, minHeight))
{
(*entityIter)->DrawShadow(maxHeight, minHeight, sceneProps, *iter, 0, true, true, entity->GetAngle(), entity->GetPosition());
shaderManager->EndShadowPass();
}
(*entityIter)->SetOrphanPosition(oldPos2);
}
}
}
video->EndTargetScene();
// draw the shadowed light by adding it to the final lightmap
video->SetRenderTarget(entity->m_pLightmap);
video->BeginTargetScene(GS_BLACK, false);
const GS_ALPHA_MODE oldAM = video->GetAlphaMode();
video->SetAlphaMode(GSAM_ADD);
tempTarget->Draw(Vector2(0,0));
video->SetAlphaMode(oldAM);
video->EndTargetScene();
}
entity->m_pLightmap->GenerateBackup();
video->SetRenderTarget(SpritePtr());
video->SetCameraPos(v2CamPos);
}
// TODO-TO-DO: this method is too large...
bool ETHScene::RenderList(float &minHeight, float &maxHeight, SpritePtr pOutline, SpritePtr pInvisibleEntSymbol,
std::list<ETHRenderEntity*> &outParticles, std::list<ETHRenderEntity*> &outHalos, const bool roundUp)
{
// This multimap will store all entities contained in the visible buckets
// It will automatically sort entities to draw them in an "alpha friendly" order
std::multimap<float, ETHRenderEntity*> mmEntities;
// store the max and min height to assign when everything is drawn
maxHeight = m_maxSceneHeight;
minHeight = m_minSceneHeight;
m_nRenderedEntities = 0;
// don't let bucket size be equal to 0
assert(GetBucketSize().x != 0 || GetBucketSize().y != 0);
// Gets the list of visible buckets
std::list<Vector2> bucketList;
const Vector2& v2CamPos = m_provider->GetVideo()->GetCameraPos(); //for debugging pourposes
ETHGlobal::GetIntersectingBuckets(bucketList, v2CamPos,
m_provider->GetVideo()->GetScreenSizeF(), GetBucketSize(),
IsDrawingBorderBuckets(), IsDrawingBorderBuckets());
// Loop through all visible Buckets
for (std::list<Vector2>::iterator bucketPositionIter = bucketList.begin(); bucketPositionIter != bucketList.end(); bucketPositionIter++)
{
ETHBucketMap::iterator bucketIter = m_buckets.Find(*bucketPositionIter);
if (bucketIter == m_buckets.GetLastBucket())
continue;
if (bucketIter->second.empty())
continue;
ETHEntityList::const_iterator iEnd = bucketIter->second.end();
for (ETHEntityList::iterator iter = bucketIter->second.begin(); iter != iEnd; iter++)
{
ETHSpriteEntity *pRenderEntity = (*iter);
// update scene bounding for depth buffer
maxHeight = Max(maxHeight, pRenderEntity->GetMaxHeight());
minHeight = Min(minHeight, pRenderEntity->GetMinHeight());
if (pRenderEntity->IsHidden())
continue;
// fill the light list for this frame
// const ETHEntityFile &entity = pRenderEntity->GetData()->entity;
if (pRenderEntity->HasLightSource())
{
ETHLight light = *(pRenderEntity->GetLight());
// if it has a particle system in the first slot, adjust the light
// brightness according to the number os active particles
if (pRenderEntity->GetParticleManager(0) && !pRenderEntity->IsStatic())
{
boost::shared_ptr<ETHParticleManager> paticleManager = pRenderEntity->GetParticleManager(0);
light.color *=
static_cast<float>(paticleManager->GetNumActiveParticles()) /
static_cast<float>(paticleManager->GetNumParticles());
}
AddLight(light, pRenderEntity->GetPosition());
}
// add this entity to the multimap to sort it for an alpha-friendly rendering list
const Vector3& v3Pos = pRenderEntity->GetPosition();
const ETH_ENTITY_TYPE type = pRenderEntity->GetType();
const float depth = pRenderEntity->ComputeDepth(maxHeight, minHeight);
const float drawHash = ComputeDrawHash(depth, v2CamPos, v3Pos, type);
// add the entity to the render map
mmEntities.insert(std::pair<float, ETHRenderEntity*>(drawHash, *iter));
m_nRenderedEntities++;
}
}
// Draw visible entities ordered in an alpha-friendly map
for (std::multimap<float, ETHRenderEntity*>::iterator iter = mmEntities.begin(); iter != mmEntities.end(); iter++)
{
ETHRenderEntity *pRenderEntity = (iter->second);
m_provider->GetShaderManager()->BeginAmbientPass(pRenderEntity, maxHeight, minHeight);
// draws the ambient pass and if we're at the editor, draw the collision box if it's an invisible entity
#ifdef _ETHANON_EDITOR
if (pOutline && pRenderEntity->IsInvisible() && pRenderEntity->Collidable())
{
pRenderEntity->DrawCollisionBox(true, pOutline, GS_WHITE, maxHeight, minHeight, m_sceneProps.zAxisDirection);
}
#endif
m_provider->GetVideo()->RoundUpPosition(roundUp);
pRenderEntity->DrawAmbientPass(m_maxSceneHeight, m_minSceneHeight, (m_enableLightmaps && m_showingLightmaps), m_sceneProps);
// draw "invisible entity symbol" if we're in the editor
#ifdef _ETHANON_EDITOR
if (pOutline)
{
if (pRenderEntity->IsInvisible() && pRenderEntity->Collidable())
{
pRenderEntity->DrawCollisionBox(false, pOutline, GS_WHITE, maxHeight, minHeight, m_sceneProps.zAxisDirection);
}
if (pRenderEntity->IsInvisible() && !pRenderEntity->Collidable())
{
const float depth = m_provider->GetVideo()->GetSpriteDepth();
m_provider->GetVideo()->SetSpriteDepth(1.0f);
pInvisibleEntSymbol->Draw(pRenderEntity->GetPositionXY());
m_provider->GetVideo()->SetSpriteDepth(depth);
}
}
#endif
// fill the halo list
// const ETHEntityFile &entity = pRenderEntity->GetData()->entity;
if (pRenderEntity->HasLightSource() && pRenderEntity->GetHalo())
{
outHalos.push_back(pRenderEntity);
}
// fill the particle list for this frame
if (pRenderEntity->HasParticleSystems())
{
outParticles.push_back(pRenderEntity);
}
// fill the callback list
m_tempEntities.AddCallbackWhenEligible(pRenderEntity);
m_provider->GetShaderManager()->EndAmbientPass();
//draw light pass
for (std::list<ETHLight>::iterator iter = m_lights.begin(); iter != m_lights.end(); iter++)
{
if (!pRenderEntity->IsHidden())
{
if (!(pRenderEntity->IsStatic() && iter->staticLight && m_enableLightmaps))
{
m_provider->GetVideo()->RoundUpPosition(roundUp);
if (m_provider->GetShaderManager()->BeginLightPass(pRenderEntity, &(*iter), m_maxSceneHeight, m_minSceneHeight, GetLightIntensity()))
{
pRenderEntity->DrawLightPass(GetZAxisDirection());
m_provider->GetShaderManager()->EndLightPass();
m_provider->GetVideo()->RoundUpPosition(false);
if (AreRealTimeShadowsEnabled())
{
if (m_provider->GetShaderManager()->BeginShadowPass(pRenderEntity, &(*iter), m_maxSceneHeight, m_minSceneHeight))
{
pRenderEntity->DrawShadow(m_maxSceneHeight, m_minSceneHeight, m_sceneProps, *iter, 0);
m_provider->GetShaderManager()->EndShadowPass();
}
}
m_provider->GetVideo()->RoundUpPosition(roundUp);
}
}
}
}
}
mmEntities.clear();
m_nCurrentLights = m_lights.size();
// Show the buckets outline in debug mode
#if defined _DEBUG || defined _ETHANON_EDITOR
if (m_provider->GetInput()->IsKeyDown(GSK_PAUSE))
{
DrawBucketOutlines();
}
#endif
return true;
}