Rampoina
/
MegaGlest
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
MegaGlest/source/glest_game/graphics/renderer.cpp

10117 lines
319 KiB
C++
Raw Permalink Blame History

// This file is part of Glest (www.glest.org)
//
// Copyright (C) 2001-2008 Martiño Figueroa
//
// You can redistribute this code and/or modify it under
// the terms of the GNU General Public License as published
// by the Free Software Foundation; either version 2 of the
// License, or (at your option) any later version
// ==============================================================
#define NOMINMAX
#include "renderer.h"
#include "texture_gl.h"
#include "main_menu.h"
#include "config.h"
#include "components.h"
#include "time_flow.h"
#include "graphics_interface.h"
#include "object.h"
#include "core_data.h"
#include "game.h"
#include "metrics.h"
#include "opengl.h"
#include "faction.h"
#include "factory_repository.h"
#include <cstdlib>
#include "cache_manager.h"
#include "network_manager.h"
#include <algorithm>
#include <iterator>
#include "leak_dumper.h"
using namespace Shared::Graphics;
using namespace Shared::Graphics::Gl;
using namespace Shared::Util;
using namespace Shared::Graphics;
namespace Glest { namespace Game{
uint32 Renderer::SurfaceData::nextUniqueId = 1;
bool Renderer::renderText3DEnabled = true;
//const float SKIP_INTERPOLATION_DISTANCE = 20.0f;
const string DEFAULT_CHAR_FOR_WIDTH_CALC = "V";
enum PROJECTION_TO_INFINITY {
pti_D_IS_ZERO,
pti_N_OVER_D_IS_OUTSIDE
};
// =====================================================
// class MeshCallbackTeamColor
// =====================================================
bool MeshCallbackTeamColor::noTeamColors = false;
void MeshCallbackTeamColor::execute(const Mesh *mesh) {
//team color
if( mesh->getCustomTexture() && teamTexture != NULL &&
MeshCallbackTeamColor::noTeamColors == false) {
//texture 0
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
//set color to interpolation
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_INTERPOLATE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_TEXTURE1);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB, GL_SRC_ALPHA);
//set alpha to 1
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
//texture 1
glActiveTexture(GL_TEXTURE1);
glMultiTexCoord2f(GL_TEXTURE1, 0.f, 0.f);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, static_cast<const Texture2DGl*>(teamTexture)->getHandle());
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_MODULATE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_PRIMARY_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_PREVIOUS);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
//set alpha to 1
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_PRIMARY_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
glActiveTexture(GL_TEXTURE0);
}
else {
glActiveTexture(GL_TEXTURE1);
glDisable(GL_TEXTURE_2D);
glActiveTexture(GL_TEXTURE0);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
}
}
// ===========================================================
// class Renderer
// ===========================================================
// ===================== PUBLIC ========================
const int Renderer::maxProgressBar= 100;
const Vec4f Renderer::progressBarBack1= Vec4f(0.7f, 0.7f, 0.7f, 0.7f);
const Vec4f Renderer::progressBarBack2= Vec4f(0.7f, 0.7f, 0.7f, 1.f);
const Vec4f Renderer::progressBarFront1= Vec4f(0.f, 0.5f, 0.f, 1.f);
const Vec4f Renderer::progressBarFront2= Vec4f(0.f, 0.1f, 0.f, 1.f);
const float Renderer::sunDist= 10e6;
const float Renderer::moonDist= 10e6;
const float Renderer::lightAmbFactor= 0.4f;
const int Renderer::maxMouse2dAnim= 100;
const GLenum Renderer::baseTexUnit= GL_TEXTURE0;
const GLenum Renderer::fowTexUnit= GL_TEXTURE1;
const GLenum Renderer::shadowTexUnit= GL_TEXTURE2;
const float Renderer::selectionCircleRadius= 0.7f;
const float Renderer::magicCircleRadius= 1.f;
//perspective values
const float Renderer::perspFov= 60.f;
const float Renderer::perspNearPlane= 1.f;
//const float Renderer::perspFarPlane= 50.f;
float Renderer::perspFarPlane= 1000000.f;
const float Renderer::ambFactor= 0.7f;
const Vec4f Renderer::fowColor= Vec4f(0.0f, 0.0f, 0.0f, 1.0f);
const Vec4f Renderer::defSpecularColor= Vec4f(0.8f, 0.8f, 0.8f, 1.f);
const Vec4f Renderer::defDiffuseColor= Vec4f(1.f, 1.f, 1.f, 1.f);
const Vec4f Renderer::defAmbientColor= Vec4f(1.f * ambFactor, 1.f * ambFactor, 1.f * ambFactor, 1.f);
const Vec4f Renderer::defColor= Vec4f(1.f, 1.f, 1.f, 1.f);
//const float Renderer::maxLightDist= 100.f;
const float Renderer::maxLightDist= 100.f;
bool Renderer::rendererEnded = true;
const int MIN_FPS_NORMAL_RENDERING = 15;
const int MIN_FPS_NORMAL_RENDERING_TOP_THRESHOLD = 25;
const int OBJECT_SELECT_OFFSET=100000000;
bool VisibleQuadContainerCache::enableFrustumCalcs = true;
// ==================== constructor and destructor ====================
Renderer::Renderer() : BaseRenderer(), saveScreenShotThreadAccessor(new Mutex(CODE_AT_LINE)) {
//this->masterserverMode = masterserverMode;
//printf("this->masterserverMode = %d\n",this->masterserverMode);
//assert(0==1);
Renderer::rendererEnded = false;
shadowIntensity = 0;
shadowFrameSkip = 0;
triangleCount = 0;
smoothedRenderFps = 0;
shadowTextureSize = 0;
shadows = sDisabled;
shadowMapFrame = 0;
textures3D = false;
photoMode = false;
focusArrows = false;
pointCount = 0;
maxLights = 0;
waterAnim = 0;
this->allowRenderUnitTitles = false;
this->menu = NULL;
this->game = NULL;
this->gameCamera = NULL;
showDebugUI = false;
showDebugUILevel = debugui_fps;
modelRenderer = NULL;
textRenderer = NULL;
textRenderer3D = NULL;
particleRenderer = NULL;
saveScreenShotThread = NULL;
mapSurfaceData.clear();
visibleFrameUnitList.clear();
visibleFrameUnitListCameraKey = "";
quadCache = VisibleQuadContainerCache();
quadCache.clearFrustumData();
lastRenderFps=MIN_FPS_NORMAL_RENDERING;
shadowsOffDueToMinRender=false;
shadowMapHandle=0;
shadowMapHandleValid=false;
//list3d=0;
//list3dValid=false;
//list2d=0;
//list2dValid=false;
//list3dMenu=0;
//list3dMenuValid=false;
//customlist3dMenu=NULL;
//this->mm3d = NULL;
this->custom_mm3d = NULL;
this->program = NULL;
//resources
for(int i=0; i < rsCount; ++i) {
modelManager[i] = NULL;
textureManager[i] = NULL;
particleManager[i] = NULL;
fontManager[i] = NULL;
}
Config &config= Config::getInstance();
Renderer::perspFarPlane = config.getFloat("PerspectiveFarPlane",floatToStr(Renderer::perspFarPlane).c_str());
this->no2DMouseRendering = config.getBool("No2DMouseRendering","false");
this->maxConsoleLines= config.getInt("ConsoleMaxLines");
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s Line: %d] Renderer::perspFarPlane [%f] this->no2DMouseRendering [%d] this->maxConsoleLines [%d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,Renderer::perspFarPlane,this->no2DMouseRendering,this->maxConsoleLines);
GraphicsInterface &gi= GraphicsInterface::getInstance();
FactoryRepository &fr= FactoryRepository::getInstance();
gi.setFactory(fr.getGraphicsFactory(config.getString("FactoryGraphics")));
GraphicsFactory *graphicsFactory= GraphicsInterface::getInstance().getFactory();
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == false) {
modelRenderer= graphicsFactory->newModelRenderer();
textRenderer= graphicsFactory->newTextRenderer2D();
textRenderer3D = graphicsFactory->newTextRenderer3D();
particleRenderer= graphicsFactory->newParticleRenderer();
}
//resources
for(int i=0; i< rsCount; ++i) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == false) {
modelManager[i]= graphicsFactory->newModelManager();
textureManager[i]= graphicsFactory->newTextureManager();
modelManager[i]->setTextureManager(textureManager[i]);
fontManager[i]= graphicsFactory->newFontManager();
}
particleManager[i]= graphicsFactory->newParticleManager();
}
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == false) {
static string mutexOwnerId = string(extractFileFromDirectoryPath(__FILE__).c_str()) + string("_") + intToStr(__LINE__);
saveScreenShotThread = new SimpleTaskThread(this,0,25);
saveScreenShotThread->setUniqueID(mutexOwnerId);
saveScreenShotThread->start();
}
}
void Renderer::cleanupScreenshotThread() {
if(saveScreenShotThread) {
saveScreenShotThread->signalQuit();
// for(time_t elapsed = time(NULL);
// getSaveScreenQueueSize() > 0 && difftime((long int)time(NULL),elapsed) <= 7;) {
// sleep(0);
// }
// if(saveScreenShotThread->canShutdown(true) == true &&
// saveScreenShotThread->shutdownAndWait() == true) {
// //printf("IN MenuStateCustomGame cleanup - C\n");
// delete saveScreenShotThread;
// }
// saveScreenShotThread = NULL;
if(saveScreenShotThread->shutdownAndWait() == true) {
delete saveScreenShotThread;
}
saveScreenShotThread = NULL;
if(getSaveScreenQueueSize() > 0) {
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line %d] FORCING MEMORY CLEANUP and NOT SAVING screenshots, saveScreenQueue.size() = %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,saveScreenQueue.size());
static string mutexOwnerId = string(extractFileFromDirectoryPath(__FILE__).c_str()) + string("_") + intToStr(__LINE__);
MutexSafeWrapper safeMutex(saveScreenShotThreadAccessor,mutexOwnerId);
for(std::list<std::pair<string,Pixmap2D *> >::iterator iter = saveScreenQueue.begin();
iter != saveScreenQueue.end(); ++iter) {
delete iter->second;
}
saveScreenQueue.clear();
}
}
}
Renderer::~Renderer() {
try{
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
delete modelRenderer;
modelRenderer = NULL;
delete textRenderer;
textRenderer = NULL;
delete textRenderer3D;
textRenderer3D = NULL;
delete particleRenderer;
particleRenderer = NULL;
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
//resources
for(int i=0; i<rsCount; ++i){
delete modelManager[i];
modelManager[i] = NULL;
delete textureManager[i];
textureManager[i] = NULL;
delete particleManager[i];
particleManager[i] = NULL;
delete fontManager[i];
fontManager[i] = NULL;
}
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
// Wait for the queue to become empty or timeout the thread at 7 seconds
cleanupScreenshotThread();
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
mapSurfaceData.clear();
quadCache = VisibleQuadContainerCache();
quadCache.clearFrustumData();
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
this->menu = NULL;
this->game = NULL;
this->gameCamera = NULL;
delete saveScreenShotThreadAccessor;
saveScreenShotThreadAccessor = NULL;
}
catch(const exception &e) {
char szBuf[8096]="";
snprintf(szBuf,8096,"In [%s::%s Line: %d]\nError [%s]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,e.what());
SystemFlags::OutputDebug(SystemFlags::debugError,szBuf);
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,szBuf);
throw megaglest_runtime_error(szBuf);
}
}
void Renderer::simpleTask(BaseThread *callingThread,void *userdata) {
// This code reads pixmaps from a queue and saves them to disk
Pixmap2D *savePixMapBuffer=NULL;
string path="";
static string mutexOwnerId = string(extractFileFromDirectoryPath(__FILE__).c_str()) + string("_") + intToStr(__LINE__);
MutexSafeWrapper safeMutex(saveScreenShotThreadAccessor,mutexOwnerId);
if(saveScreenQueue.empty() == false) {
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line %d] saveScreenQueue.size() = %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,saveScreenQueue.size());
savePixMapBuffer = saveScreenQueue.front().second;
path = saveScreenQueue.front().first;
saveScreenQueue.pop_front();
}
safeMutex.ReleaseLock();
if(savePixMapBuffer != NULL) {
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line %d] about to save [%s]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,path.c_str());
savePixMapBuffer->save(path);
delete savePixMapBuffer;
}
}
bool Renderer::isEnded() {
return Renderer::rendererEnded;
}
Renderer &Renderer::getInstance() {
static Renderer renderer;
return renderer;
}
void Renderer::reinitAll() {
//resources
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
for(int i=0; i<rsCount; ++i){
//modelManager[i]->init();
textureManager[i]->init(true);
//particleManager[i]->init();
//fontManager[i]->init();
}
}
// ==================== init ====================
void Renderer::init() {
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
Config &config= Config::getInstance();
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
loadConfig();
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
if(config.getBool("CheckGlCaps")){
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
checkGlCaps();
}
if(glActiveTexture == NULL) {
char szBuf[8096]="";
snprintf(szBuf,8096,"Error: glActiveTexture == NULL\nglActiveTexture is only supported if the GL version is 1.3 or greater,\nor if the ARB_multitexture extension is supported!");
throw megaglest_runtime_error(szBuf);
}
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
if(config.getBool("FirstTime")){
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
config.setBool("FirstTime", false);
autoConfig();
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
config.save();
}
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
modelManager[rsGlobal]->init();
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
textureManager[rsGlobal]->init();
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
fontManager[rsGlobal]->init();
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
init2dList();
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
glHint(GL_FOG_HINT, GL_FASTEST);
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
//glHint(GL_GENERATE_MIPMAP_HINT, GL_FASTEST);
glHint(GL_LINE_SMOOTH_HINT, GL_FASTEST);
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
//glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
//glHint(GL_POINT_SMOOTH_HINT, GL_FASTEST);
//glHint(GL_POLYGON_SMOOTH_HINT, GL_FASTEST);
glHint(GL_TEXTURE_COMPRESSION_HINT, GL_FASTEST);
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
}
void Renderer::initGame(const Game *game, GameCamera *gameCamera) {
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
this->gameCamera = gameCamera;
VisibleQuadContainerCache::enableFrustumCalcs = Config::getInstance().getBool("EnableFrustrumCalcs","true");
quadCache = VisibleQuadContainerCache();
quadCache.clearFrustumData();
SurfaceData::nextUniqueId = 1;
mapSurfaceData.clear();
this->game= game;
worldToScreenPosCache.clear();
//vars
shadowMapFrame= 0;
waterAnim= 0;
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
//check gl caps
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
checkGlOptionalCaps();
//shadows
if(shadows == sProjected || shadows == sShadowMapping) {
static_cast<ModelRendererGl*>(modelRenderer)->setSecondaryTexCoordUnit(2);
Config &config= Config::getInstance();
glGenTextures(1, &shadowMapHandle);
shadowMapHandleValid=true;
shadowIntensity= config.getFloat("ShadowIntensity","1.0");
if(game!=NULL){
shadowIntensity=shadowIntensity*game->getWorld()->getTileset()->getShadowIntense();
if(shadowIntensity > 1.0f){
shadowIntensity=1.0f;
}
}
glBindTexture(GL_TEXTURE_2D, shadowMapHandle);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
if(shadows == sShadowMapping) {
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
//shadow mapping
glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE, GL_LUMINANCE);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE_ARB, GL_COMPARE_R_TO_TEXTURE_ARB);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE_ARB, GL_NONE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC_ARB, GL_LEQUAL);
//glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FAIL_VALUE_ARB, 1.0f-shadowAlpha);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT32,
shadowTextureSize, shadowTextureSize,
0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, NULL);
}
else {
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
//projected
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8,
shadowTextureSize, shadowTextureSize,
0, GL_LUMINANCE, GL_UNSIGNED_BYTE, NULL);
}
shadowMapFrame= -1;
}
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
IF_DEBUG_EDITION( getDebugRenderer().init(); )
//texture init
modelManager[rsGame]->init();
textureManager[rsGame]->init();
fontManager[rsGame]->init();
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
init3dList();
}
void Renderer::manageDeferredParticleSystems() {
// if(deferredParticleSystems.empty() == false) {
// printf("deferredParticleSystems.size() = %d\n",(int)deferredParticleSystems.size());
// }
for(unsigned int i = 0; i < deferredParticleSystems.size(); ++i) {
std::pair<ParticleSystem *, ResourceScope> &deferredParticleSystem = deferredParticleSystems[i];
ParticleSystem *ps = deferredParticleSystem.first;
ResourceScope rs = deferredParticleSystem.second;
if(ps->getTextureFileLoadDeferred() != "" && ps->getTexture() == NULL) {
CoreData::TextureSystemType textureSystemId =
static_cast<CoreData::TextureSystemType>(
ps->getTextureFileLoadDeferredSystemId());
//printf("Load DEFERRED particle i = %d textureSystemId = %d\n",i,textureSystemId);
if(textureSystemId != CoreData::tsyst_NONE) {
Texture2D *texture= CoreData::getInstance().getTextureBySystemId(textureSystemId);
//printf("Loading texture from system [%d] [%p]\n",textureSystemId,texture);
ps->setTexture(texture);
//printf("#2 Load DEFERRED particle i = %d textureSystemId = %d, texture = %p\n",i,textureSystemId,texture);
}
else {
Texture2D *texture= newTexture2D(rs);
if(texture) {
texture->setFormat(ps->getTextureFileLoadDeferredFormat());
texture->getPixmap()->init(ps->getTextureFileLoadDeferredComponents());
}
if(texture) {
string textureFile = ps->getTextureFileLoadDeferred();
if(fileExists(textureFile) == false) {
textureFile = Config::findValidLocalFileFromPath(textureFile);
}
texture->load(textureFile);
ps->setTexture(texture);
}
//printf("#3 Load DEFERRED particle i = %d textureSystemId = %d, texture = %p\n",i,textureSystemId,texture);
}
}
if(dynamic_cast<GameParticleSystem *>(ps) != NULL) {
GameParticleSystem *gps = dynamic_cast<GameParticleSystem *>(ps);
if(gps != NULL && gps->getModelFileLoadDeferred() != "" && gps->getModel() == NULL) {
std::map<string,vector<pair<string, string> > > loadedFileList;
Model *model= newModel(rsGame, gps->getModelFileLoadDeferred(), false, &loadedFileList, NULL);
if(model)
gps->setModel(model);
}
}
manageParticleSystem(ps, rs);
//printf("Managing ps [%p]\n",ps);
}
deferredParticleSystems.clear();
//printf("After deferredParticleSystems.size() = %d\n",deferredParticleSystems.size());
}
void Renderer::initMenu(const MainMenu *mm) {
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
this->menu = mm;
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
modelManager[rsMenu]->init();
textureManager[rsMenu]->init();
fontManager[rsMenu]->init();
//modelRenderer->setCustomTexture(CoreData::getInstance().getCustomTexture());
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
//init3dListMenu(mm);
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
}
void Renderer::reset3d() {
assertGl();
glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
//glCallList(list3d);
render3dSetup();
pointCount= 0;
triangleCount= 0;
assertGl();
}
void Renderer::reset2d() {
assertGl();
glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SINGLE_COLOR);
//glCallList(list2d);
render2dMenuSetup();
assertGl();
}
void Renderer::reset3dMenu() {
assertGl();
glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SINGLE_COLOR);
//printf("In [%s::%s Line: %d] this->custom_mm3d [%p] this->mm3d [%p]\n",__FILE__,__FUNCTION__,__LINE__,this->custom_mm3d,this->mm3d);
if(this->custom_mm3d != NULL) {
render3dMenuSetup(this->custom_mm3d);
//glCallList(*this->customlist3dMenu);
}
else {
render3dMenuSetup(this->menu);
//render3dMenuSetup(this->mm3d);
//glCallList(list3dMenu);
}
assertGl();
}
// ==================== end ====================
void Renderer::end() {
quadCache = VisibleQuadContainerCache();
quadCache.clearFrustumData();
if(Renderer::rendererEnded == true) {
return;
}
std::map<string,Texture2D *> &crcFactionPreviewTextureCache = CacheManager::getCachedItem< std::map<string,Texture2D *> >(GameConstants::factionPreviewTextureCacheLookupKey);
crcFactionPreviewTextureCache.clear();
// Wait for the queue to become empty or timeout the thread at 7 seconds
cleanupScreenshotThread();
mapSurfaceData.clear();
//delete resources
if(modelManager[rsGlobal]) {
modelManager[rsGlobal]->end();
}
if(textureManager[rsGlobal]) {
textureManager[rsGlobal]->end();
}
if(fontManager[rsGlobal]) {
fontManager[rsGlobal]->end();
}
if(particleManager[rsGlobal]) {
particleManager[rsGlobal]->end();
}
//delete 2d list
//if(list2dValid == true) {
// glDeleteLists(list2d, 1);
// list2dValid=false;
//}
Renderer::rendererEnded = true;
}
void Renderer::endScenario() {
this->game= NULL;
this->gameCamera = NULL;
quadCache = VisibleQuadContainerCache();
quadCache.clearFrustumData();
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
//delete resources
//modelManager[rsGame]->end();
//textureManager[rsGame]->end();
//fontManager[rsGame]->end();
//particleManager[rsGame]->end();
if(shadowMapHandleValid == true &&
(shadows == sProjected || shadows == sShadowMapping)) {
glDeleteTextures(1, &shadowMapHandle);
shadowMapHandleValid=false;
}
//if(list3dValid == true) {
// glDeleteLists(list3d, 1);
// list3dValid=false;
//}
worldToScreenPosCache.clear();
ReleaseSurfaceVBOs();
mapSurfaceData.clear();
}
void Renderer::endGame(bool isFinalEnd) {
this->game= NULL;
this->gameCamera = NULL;
Config &config= Config::getInstance();
try {
quadCache = VisibleQuadContainerCache();
quadCache.clearFrustumData();
}
catch(const exception &e) {
char szBuf[8096]="";
snprintf(szBuf,8096,"In [%s::%s Line: %d]\nError [%s]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,e.what());
SystemFlags::OutputDebug(SystemFlags::debugError,szBuf);
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,szBuf);
abort();
}
if(isFinalEnd) {
//delete resources
if(modelManager[rsGame] != NULL) {
modelManager[rsGame]->end();
}
if(textureManager[rsGame] != NULL) {
textureManager[rsGame]->end();
}
if(fontManager[rsGame] != NULL) {
fontManager[rsGame]->end();
}
if(particleManager[rsGame] != NULL) {
particleManager[rsGame]->end();
}
}
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
if(shadowMapHandleValid == true &&
(shadows == sProjected || shadows == sShadowMapping)) {
glDeleteTextures(1, &shadowMapHandle);
shadowMapHandleValid=false;
}
shadowIntensity= config.getFloat("ShadowIntensity","1.0");
//if(list3dValid == true) {
// glDeleteLists(list3d, 1);
// list3dValid=false;
//}
worldToScreenPosCache.clear();
ReleaseSurfaceVBOs();
mapSurfaceData.clear();
}
void Renderer::endMenu() {
this->menu = NULL;
//delete resources
if(modelManager[rsMenu]) {
modelManager[rsMenu]->end();
}
if(textureManager[rsMenu]) {
textureManager[rsMenu]->end();
}
if(fontManager[rsMenu]) {
fontManager[rsMenu]->end();
}
if(particleManager[rsMenu]) {
particleManager[rsMenu]->end();
}
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
//if(this->customlist3dMenu != NULL) {
// glDeleteLists(*this->customlist3dMenu,1);
//}
//else {
// glDeleteLists(list3dMenu, 1);
//}
}
//void Renderer::reloadResources() {
// if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
// return;
// }
//
// for(int i=0; i<rsCount; ++i) {
// modelManager[i]->end();
// textureManager[i]->end();
// fontManager[i]->end();
// }
//
// for(int i=0; i<rsCount; ++i) {
// modelManager[i]->init();
// textureManager[i]->init();
// fontManager[i]->init();
// }
//}
// ==================== engine interface ====================
void Renderer::initTexture(ResourceScope rs, Texture *texture) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
textureManager[rs]->initTexture(texture);
}
void Renderer::endTexture(ResourceScope rs, Texture *texture, bool mustExistInList) {
string textureFilename = texture->getPath();
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s Line: %d] free texture from manager [%s]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,textureFilename.c_str());
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
textureManager[rs]->endTexture(texture,mustExistInList);
if(rs == rsGlobal) {
std::map<string,Texture2D *> &crcFactionPreviewTextureCache = CacheManager::getCachedItem< std::map<string,Texture2D *> >(GameConstants::factionPreviewTextureCacheLookupKey);
if(crcFactionPreviewTextureCache.find(textureFilename) != crcFactionPreviewTextureCache.end()) {
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d] textureFilename [%s]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,textureFilename.c_str());
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s Line: %d] free texture from cache [%s]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,textureFilename.c_str());
crcFactionPreviewTextureCache.erase(textureFilename);
}
}
}
void Renderer::endLastTexture(ResourceScope rs, bool mustExistInList) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
textureManager[rs]->endLastTexture(mustExistInList);
}
Model *Renderer::newModel(ResourceScope rs,const string &path,bool deletePixMapAfterLoad,std::map<string,vector<pair<string, string> > > *loadedFileList, string *sourceLoader){
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return NULL;
}
return modelManager[rs]->newModel(path,deletePixMapAfterLoad,loadedFileList,sourceLoader);
}
void Renderer::endModel(ResourceScope rs, Model *model,bool mustExistInList) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
modelManager[rs]->endModel(model,mustExistInList);
}
void Renderer::endLastModel(ResourceScope rs, bool mustExistInList) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
modelManager[rs]->endLastModel(mustExistInList);
}
Texture2D *Renderer::newTexture2D(ResourceScope rs){
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return NULL;
}
return textureManager[rs]->newTexture2D();
}
Texture3D *Renderer::newTexture3D(ResourceScope rs){
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return NULL;
}
return textureManager[rs]->newTexture3D();
}
Font2D *Renderer::newFont(ResourceScope rs){
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return NULL;
}
return fontManager[rs]->newFont2D();
}
Font3D *Renderer::newFont3D(ResourceScope rs){
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return NULL;
}
return fontManager[rs]->newFont3D();
}
void Renderer::endFont(::Shared::Graphics::Font *font, ResourceScope rs, bool mustExistInList) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
fontManager[rs]->endFont(font,mustExistInList);
}
//void Renderer::resetFontManager(ResourceScope rs) {
// if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
// return;
// }
// fontManager[rs]->end();
// fontManager[rsGlobal]->init();
//}
void Renderer::addToDeferredParticleSystemList(std::pair<ParticleSystem *, ResourceScope> deferredParticleSystem) {
deferredParticleSystems.push_back(deferredParticleSystem);
}
void Renderer::manageParticleSystem(ParticleSystem *particleSystem, ResourceScope rs){
particleManager[rs]->manage(particleSystem);
}
bool Renderer::validateParticleSystemStillExists(ParticleSystem * particleSystem,ResourceScope rs) const {
return particleManager[rs]->validateParticleSystemStillExists(particleSystem);
}
void Renderer::removeParticleSystemsForParticleOwner(ParticleOwner * particleOwner,ResourceScope rs) {
particleManager[rs]->removeParticleSystemsForParticleOwner(particleOwner);
}
void Renderer::cleanupParticleSystems(vector<ParticleSystem *> &particleSystems, ResourceScope rs) {
particleManager[rs]->cleanupParticleSystems(particleSystems);
}
void Renderer::cleanupUnitParticleSystems(vector<UnitParticleSystem *> &particleSystems, ResourceScope rs) {
particleManager[rs]->cleanupUnitParticleSystems(particleSystems);
}
void Renderer::updateParticleManager(ResourceScope rs, int renderFps) {
particleManager[rs]->update(renderFps);
}
void Renderer::renderParticleManager(ResourceScope rs){
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
glPushAttrib(GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
glDepthFunc(GL_LESS);
particleRenderer->renderManager(particleManager[rs], modelRenderer);
glPopAttrib();
}
void Renderer::swapBuffers() {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
//glFlush(); // should not be required - http://www.opengl.org/wiki/Common_Mistakes
//glFlush();
GraphicsInterface::getInstance().getCurrentContext()->swapBuffers();
}
// ==================== lighting ====================
//places all the opengl lights
void Renderer::setupLighting() {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
int lightCount= 0;
const World *world= game->getWorld();
const GameCamera *gameCamera= game->getGameCamera();
const TimeFlow *timeFlow= world->getTimeFlow();
float time= timeFlow->getTime();
assertGl();
//sun/moon light
Vec3f lightColor= timeFlow->computeLightColor();
Vec3f fogColor= world->getTileset()->getFogColor();
Vec4f lightPos= timeFlow->isDay()? computeSunPos(time): computeMoonPos(time);
nearestLightPos= lightPos;
glLightfv(GL_LIGHT0, GL_POSITION, lightPos.ptr());
glLightfv(GL_LIGHT0, GL_AMBIENT, Vec4f(lightColor*lightAmbFactor, 1.f).ptr());
glLightfv(GL_LIGHT0, GL_DIFFUSE, Vec4f(lightColor, 1.f).ptr());
glLightfv(GL_LIGHT0, GL_SPECULAR, Vec4f(0.0f, 0.0f, 0.f, 1.f).ptr());
glFogfv(GL_FOG_COLOR, Vec4f(fogColor*lightColor, 1.f).ptr());
lightCount++;
//disable all secondary lights
for(int i= 1; i < maxLights; ++i) {
glDisable(GL_LIGHT0 + i);
}
//unit lights (not projectiles)
if(timeFlow->isTotalNight()) {
VisibleQuadContainerCache &qCache = getQuadCache();
if(qCache.visibleQuadUnitList.empty() == false) {
//bool modelRenderStarted = false;
for(int visibleUnitIndex = 0;
visibleUnitIndex < (int)qCache.visibleQuadUnitList.size() && lightCount < maxLights;
++visibleUnitIndex) {
Unit *unit = qCache.visibleQuadUnitList[visibleUnitIndex];
if(world->toRenderUnit(unit) &&
unit->getCurrMidHeightVector().dist(gameCamera->getPos()) < maxLightDist &&
unit->getType()->getLight() && unit->isOperative()) {
//printf("$$$ Show light for faction: %s # %d / %d for Unit [%d - %s]\n",world->getFaction(i)->getType()->getName().c_str(),lightCount,maxLights,unit->getId(),unit->getFullName().c_str());
Vec4f pos= Vec4f(unit->getCurrMidHeightVector());
pos.y+=4.f;
GLenum lightEnum= GL_LIGHT0 + lightCount;
glEnable(lightEnum);
glLightfv(lightEnum, GL_POSITION, pos.ptr());
glLightfv(lightEnum, GL_AMBIENT, Vec4f(unit->getType()->getLightColor()).ptr());
glLightfv(lightEnum, GL_DIFFUSE, Vec4f(unit->getType()->getLightColor()).ptr());
glLightfv(lightEnum, GL_SPECULAR, Vec4f(unit->getType()->getLightColor()*0.3f).ptr());
glLightf(lightEnum, GL_QUADRATIC_ATTENUATION, 0.05f);
++lightCount;
const GameCamera *gameCamera= game->getGameCamera();
if(Vec3f(pos).dist(gameCamera->getPos())<Vec3f(nearestLightPos).dist(gameCamera->getPos())){
nearestLightPos= pos;
}
}
}
}
}
assertGl();
}
//void Renderer::setupLightingForRotatedModel() {
// if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
// return;
// }
//
// const World *world= game->getWorld();
// //const GameCamera *gameCamera= game->getGameCamera();
// const TimeFlow *timeFlow= world->getTimeFlow();
// float time= timeFlow->getTime();
//
// assertGl();
//
// //sun/moon light
// Vec3f lightColor= timeFlow->computeLightColor();
// Vec3f fogColor= world->getTileset()->getFogColor();
// Vec4f lightPos= timeFlow->isDay()? computeSunPos(time): computeMoonPos(time);
// //nearestLightPos= lightPos;
//
// glLightfv(GL_LIGHT0, GL_POSITION, lightPos.ptr());
// glLightfv(GL_LIGHT0, GL_AMBIENT, Vec4f(lightColor*lightAmbFactor, 1.f).ptr());
// glLightfv(GL_LIGHT0, GL_DIFFUSE, Vec4f(lightColor, 1.f).ptr());
// glLightfv(GL_LIGHT0, GL_SPECULAR, Vec4f(0.0f, 0.0f, 0.f, 1.f).ptr());
//
// glFogfv(GL_FOG_COLOR, Vec4f(fogColor*lightColor, 1.f).ptr());
//
// assertGl();
//}
void Renderer::loadGameCameraMatrix() {
const GameCamera *gameCamera= game->getGameCamera();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
if(gameCamera != NULL) {
glRotatef(gameCamera->getVAng(), -1, 0, 0);
glRotatef(gameCamera->getHAng(), 0, 1, 0);
glTranslatef(-(gameCamera->getPos().x + gameCamera->getShakeOffset().x),
-gameCamera->getPos().y,
-(gameCamera->getPos().z + gameCamera->getShakeOffset().y));
}
}
void Renderer::loadCameraMatrix(const Camera *camera) {
const Vec3f &position= camera->getConstPosition();
Quaternion orientation= camera->getOrientation().conjugate();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glMultMatrixf(orientation.toMatrix4().ptr());
glTranslatef(-position.x, -position.y, -position.z);
}
static Vec2i _unprojectMap(const Vec2i& pt,const GLdouble* model,const GLdouble* projection,const GLint* viewport,const char* label=NULL) {
Vec3d a,b;
/* note viewport[3] is height of window in pixels */
GLint realy = viewport[3] - (GLint) pt.y;
gluUnProject(pt.x,realy,0,model,projection,viewport,&a.x,&a.y,&a.z);
gluUnProject(pt.x,realy,1,model,projection,viewport,&b.x,&b.y,&b.z);
// junk values if you were looking parallel to the XZ plane; this shouldn't happen as the camera can't do this?
const Vec3f
start(a.x,a.y,a.z),
stop(b.x,b.y,b.z),
plane(0,0,0),
norm(0,1,0),
u = stop-start,
w = start-plane;
const float d = norm.x*u.x + norm.y*u.y + norm.z*u.z;
if(std::fabs(d) < 0.00001)
throw pti_D_IS_ZERO;
const float nd = -(norm.x*w.x + norm.y*w.y + norm.z*w.z) / d;
if(nd < 0.0 || nd >= 1.0)
throw pti_N_OVER_D_IS_OUTSIDE;
const Vec3f i = start + u*nd;
//const Vec2i pos(i.x,i.z);
Vec2i pos;
if(strcmp(label,"tl") == 0) {
pos = Vec2i(std::floor(i.x),std::floor(i.z));
}
else if(strcmp(label,"tr") == 0) {
pos = Vec2i(std::ceil(i.x),std::floor(i.z));
}
else if(strcmp(label,"bl") == 0) {
pos = Vec2i(std::floor(i.x),std::ceil(i.z));
}
else if(strcmp(label,"br") == 0) {
pos = Vec2i(std::ceil(i.x),std::ceil(i.z));
}
if(false) { // print debug info
if(label) printf("%s ",label);
printf("%d,%d -> %f,%f,%f -> %f,%f,%f -> %f,%f,%f -> %d,%d\n",
pt.x,pt.y,
start.x,start.y,start.z,
stop.x,stop.y,stop.z,
i.x,i.y,i.z,
pos.x,pos.y);
}
return pos;
}
bool Renderer::ExtractFrustum(VisibleQuadContainerCache &quadCacheItem) {
bool frustumChanged = false;
vector<float> proj(16,0);
vector<float> modl(16,0);
/* Get the current PROJECTION matrix from OpenGL */
glGetFloatv( GL_PROJECTION_MATRIX, &proj[0] );
/* Get the current MODELVIEW matrix from OpenGL */
glGetFloatv( GL_MODELVIEW_MATRIX, &modl[0] );
// for(unsigned int i = 0; i < proj.size(); ++i) {
// //printf("\ni = %d proj [%f][%f] modl [%f][%f]\n",i,proj[i],quadCacheItem.proj[i],modl[i],quadCacheItem.modl[i]);
// if(proj[i] != quadCacheItem.proj[i]) {
// frustumChanged = true;
// break;
// }
// if(modl[i] != quadCacheItem.modl[i]) {
// frustumChanged = true;
// break;
// }
// }
// Check the frustum cache
const bool useFrustumCache = Config::getInstance().getBool("EnableFrustrumCache","false");
pair<vector<float>,vector<float> > lookupKey;
if(useFrustumCache == true) {
lookupKey = make_pair(proj,modl);
map<pair<vector<float>,vector<float> >, vector<vector<float> > >::iterator iterFind = quadCacheItem.frustumDataCache.find(lookupKey);
if(iterFind != quadCacheItem.frustumDataCache.end()) {
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("\nCalc Frustum found in cache\n");
quadCacheItem.frustumData = iterFind->second;
frustumChanged = (quadCacheItem.proj != proj || quadCacheItem.modl != modl);
if(frustumChanged == true) {
quadCacheItem.proj = proj;
quadCacheItem.modl = modl;
}
return frustumChanged;
}
}
if(quadCacheItem.proj != proj || quadCacheItem.modl != modl) {
//if(frustumChanged == true) {
frustumChanged = true;
vector<vector<float> > &frustum = quadCacheItem.frustumData;
//assert(frustum.size() == 6);
//assert(frustum[0].size() == 4);
quadCacheItem.proj = proj;
quadCacheItem.modl = modl;
float clip[16];
float t=0;
/* Combine the two matrices (multiply projection by modelview) */
clip[ 0] = modl[ 0] * proj[ 0] + modl[ 1] * proj[ 4] + modl[ 2] * proj[ 8] + modl[ 3] * proj[12];
clip[ 1] = modl[ 0] * proj[ 1] + modl[ 1] * proj[ 5] + modl[ 2] * proj[ 9] + modl[ 3] * proj[13];
clip[ 2] = modl[ 0] * proj[ 2] + modl[ 1] * proj[ 6] + modl[ 2] * proj[10] + modl[ 3] * proj[14];
clip[ 3] = modl[ 0] * proj[ 3] + modl[ 1] * proj[ 7] + modl[ 2] * proj[11] + modl[ 3] * proj[15];
clip[ 4] = modl[ 4] * proj[ 0] + modl[ 5] * proj[ 4] + modl[ 6] * proj[ 8] + modl[ 7] * proj[12];
clip[ 5] = modl[ 4] * proj[ 1] + modl[ 5] * proj[ 5] + modl[ 6] * proj[ 9] + modl[ 7] * proj[13];
clip[ 6] = modl[ 4] * proj[ 2] + modl[ 5] * proj[ 6] + modl[ 6] * proj[10] + modl[ 7] * proj[14];
clip[ 7] = modl[ 4] * proj[ 3] + modl[ 5] * proj[ 7] + modl[ 6] * proj[11] + modl[ 7] * proj[15];
clip[ 8] = modl[ 8] * proj[ 0] + modl[ 9] * proj[ 4] + modl[10] * proj[ 8] + modl[11] * proj[12];
clip[ 9] = modl[ 8] * proj[ 1] + modl[ 9] * proj[ 5] + modl[10] * proj[ 9] + modl[11] * proj[13];
clip[10] = modl[ 8] * proj[ 2] + modl[ 9] * proj[ 6] + modl[10] * proj[10] + modl[11] * proj[14];
clip[11] = modl[ 8] * proj[ 3] + modl[ 9] * proj[ 7] + modl[10] * proj[11] + modl[11] * proj[15];
clip[12] = modl[12] * proj[ 0] + modl[13] * proj[ 4] + modl[14] * proj[ 8] + modl[15] * proj[12];
clip[13] = modl[12] * proj[ 1] + modl[13] * proj[ 5] + modl[14] * proj[ 9] + modl[15] * proj[13];
clip[14] = modl[12] * proj[ 2] + modl[13] * proj[ 6] + modl[14] * proj[10] + modl[15] * proj[14];
clip[15] = modl[12] * proj[ 3] + modl[13] * proj[ 7] + modl[14] * proj[11] + modl[15] * proj[15];
/* Extract the numbers for the RIGHT plane */
frustum[0][0] = clip[ 3] - clip[ 0];
frustum[0][1] = clip[ 7] - clip[ 4];
frustum[0][2] = clip[11] - clip[ 8];
frustum[0][3] = clip[15] - clip[12];
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("\nCalc Frustum #%da: [%f][%f][%f][%f]\n",0,frustum[0][0],frustum[0][1],frustum[0][2],frustum[0][3]);
/* Normalize the result */
t = std::sqrt( frustum[0][0] * frustum[0][0] + frustum[0][1] * frustum[0][1] + frustum[0][2] * frustum[0][2] );
if(t != 0.0) {
frustum[0][0] /= t;
frustum[0][1] /= t;
frustum[0][2] /= t;
frustum[0][3] /= t;
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("\nCalc Frustum #%db: [%f][%f][%f][%f] t = %f\n",0,frustum[0][0],frustum[0][1],frustum[0][2],frustum[0][3],t);
}
/* Extract the numbers for the LEFT plane */
frustum[1][0] = clip[ 3] + clip[ 0];
frustum[1][1] = clip[ 7] + clip[ 4];
frustum[1][2] = clip[11] + clip[ 8];
frustum[1][3] = clip[15] + clip[12];
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("\nCalc Frustum #%da: [%f][%f][%f][%f]\n",1,frustum[1][0],frustum[1][1],frustum[1][2],frustum[1][3]);
/* Normalize the result */
t = std::sqrt( frustum[1][0] * frustum[1][0] + frustum[1][1] * frustum[1][1] + frustum[1][2] * frustum[1][2] );
if(t != 0.0) {
frustum[1][0] /= t;
frustum[1][1] /= t;
frustum[1][2] /= t;
frustum[1][3] /= t;
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("\nCalc Frustum #%db: [%f][%f][%f][%f] t = %f\n",1,frustum[1][0],frustum[1][1],frustum[1][2],frustum[1][3],t);
}
/* Extract the BOTTOM plane */
frustum[2][0] = clip[ 3] + clip[ 1];
frustum[2][1] = clip[ 7] + clip[ 5];
frustum[2][2] = clip[11] + clip[ 9];
frustum[2][3] = clip[15] + clip[13];
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("\nCalc Frustum #%da: [%f][%f][%f][%f]\n",2,frustum[2][0],frustum[2][1],frustum[2][2],frustum[2][3]);
/* Normalize the result */
t = std::sqrt( frustum[2][0] * frustum[2][0] + frustum[2][1] * frustum[2][1] + frustum[2][2] * frustum[2][2] );
if(t != 0.0) {
frustum[2][0] /= t;
frustum[2][1] /= t;
frustum[2][2] /= t;
frustum[2][3] /= t;
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("\nCalc Frustum #%db: [%f][%f][%f][%f] t = %f\n",2,frustum[2][0],frustum[2][1],frustum[2][2],frustum[2][3],t);
}
/* Extract the TOP plane */
frustum[3][0] = clip[ 3] - clip[ 1];
frustum[3][1] = clip[ 7] - clip[ 5];
frustum[3][2] = clip[11] - clip[ 9];
frustum[3][3] = clip[15] - clip[13];
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("\nCalc Frustum #%da: [%f][%f][%f][%f]\n",3,frustum[3][0],frustum[3][1],frustum[3][2],frustum[3][3]);
/* Normalize the result */
t = std::sqrt( frustum[3][0] * frustum[3][0] + frustum[3][1] * frustum[3][1] + frustum[3][2] * frustum[3][2] );
if(t != 0.0) {
frustum[3][0] /= t;
frustum[3][1] /= t;
frustum[3][2] /= t;
frustum[3][3] /= t;
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("\nCalc Frustum #%db: [%f][%f][%f][%f] t = %f\n",3,frustum[3][0],frustum[3][1],frustum[3][2],frustum[3][3],t);
}
/* Extract the FAR plane */
frustum[4][0] = clip[ 3] - clip[ 2];
frustum[4][1] = clip[ 7] - clip[ 6];
frustum[4][2] = clip[11] - clip[10];
frustum[4][3] = clip[15] - clip[14];
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("\nCalc Frustum #%da: [%f][%f][%f][%f]\n",4,frustum[4][0],frustum[4][1],frustum[4][2],frustum[4][3]);
/* Normalize the result */
t = std::sqrt( frustum[4][0] * frustum[4][0] + frustum[4][1] * frustum[4][1] + frustum[4][2] * frustum[4][2] );
if(t != 0.0) {
frustum[4][0] /= t;
frustum[4][1] /= t;
frustum[4][2] /= t;
frustum[4][3] /= t;
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("\nCalc Frustum #%db: [%f][%f][%f][%f] t = %f\n",4,frustum[4][0],frustum[4][1],frustum[4][2],frustum[4][3],t);
}
/* Extract the NEAR plane */
frustum[5][0] = clip[ 3] + clip[ 2];
frustum[5][1] = clip[ 7] + clip[ 6];
frustum[5][2] = clip[11] + clip[10];
frustum[5][3] = clip[15] + clip[14];
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("\nCalc Frustum #%da: [%f][%f][%f][%f]\n",5,frustum[5][0],frustum[5][1],frustum[5][2],frustum[5][3]);
/* Normalize the result */
t = std::sqrt( frustum[5][0] * frustum[5][0] + frustum[5][1] * frustum[5][1] + frustum[5][2] * frustum[5][2] );
if(t != 0.0) {
frustum[5][0] /= t;
frustum[5][1] /= t;
frustum[5][2] /= t;
frustum[5][3] /= t;
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("\nCalc Frustum #%db: [%f][%f][%f][%f] t = %f\n",5,frustum[5][0],frustum[5][1],frustum[5][2],frustum[5][3],t);
}
if(useFrustumCache == true) {
quadCacheItem.frustumDataCache[lookupKey] = frustum;
}
}
return frustumChanged;
}
//bool Renderer::PointInFrustum(vector<vector<float> > &frustum, float x, float y, float z ) {
// unsigned int p=0;
//
// for( p = 0; p < frustum.size(); p++ ) {
// if( frustum[p][0] * x + frustum[p][1] * y + frustum[p][2] * z + frustum[p][3] <= 0 ) {
// return false;
// }
// }
// return true;
//}
//
//bool Renderer::SphereInFrustum(vector<vector<float> > &frustum, float x, float y, float z, float radius) {
// // Go through all the sides of the frustum
// for(int i = 0; i < (int)frustum.size(); i++ ) {
// // If the center of the sphere is farther away from the plane than the radius
// if(frustum[i][0] * x + frustum[i][1] * y + frustum[i][2] * z + frustum[i][3] <= -radius ) {
// // The distance was greater than the radius so the sphere is outside of the frustum
// return false;
// }
// }
//
// // The sphere was inside of the frustum!
// return true;
//}
bool Renderer::CubeInFrustum(vector<vector<float> > &frustum, float x, float y, float z, float size ) {
unsigned int p=0;
for( p = 0; p < frustum.size(); p++ ) {
if( frustum[p][0] * (x - size) + frustum[p][1] * (y - size) + frustum[p][2] * (z - size) + frustum[p][3] > 0 )
continue;
if( frustum[p][0] * (x + size) + frustum[p][1] * (y - size) + frustum[p][2] * (z - size) + frustum[p][3] > 0 )
continue;
if( frustum[p][0] * (x - size) + frustum[p][1] * (y + size) + frustum[p][2] * (z - size) + frustum[p][3] > 0 )
continue;
if( frustum[p][0] * (x + size) + frustum[p][1] * (y + size) + frustum[p][2] * (z - size) + frustum[p][3] > 0 )
continue;
if( frustum[p][0] * (x - size) + frustum[p][1] * (y - size) + frustum[p][2] * (z + size) + frustum[p][3] > 0 )
continue;
if( frustum[p][0] * (x + size) + frustum[p][1] * (y - size) + frustum[p][2] * (z + size) + frustum[p][3] > 0 )
continue;
if( frustum[p][0] * (x - size) + frustum[p][1] * (y + size) + frustum[p][2] * (z + size) + frustum[p][3] > 0 )
continue;
if( frustum[p][0] * (x + size) + frustum[p][1] * (y + size) + frustum[p][2] * (z + size) + frustum[p][3] > 0 )
continue;
return false;
}
return true;
}
void Renderer::computeVisibleQuad() {
visibleQuad = this->gameCamera->computeVisibleQuad();
bool frustumChanged = false;
if(VisibleQuadContainerCache::enableFrustumCalcs == true) {
frustumChanged = ExtractFrustum(quadCache);
}
if(frustumChanged && SystemFlags::VERBOSE_MODE_ENABLED) {
printf("\nCamera: %d,%d %d,%d %d,%d %d,%d\n",
visibleQuad.p[0].x,visibleQuad.p[0].y,
visibleQuad.p[1].x,visibleQuad.p[1].y,
visibleQuad.p[2].x,visibleQuad.p[2].y,
visibleQuad.p[3].x,visibleQuad.p[3].y);
for(unsigned int i = 0; i < quadCache.frustumData.size(); ++i) {
printf("\nFrustum #%u [" MG_SIZE_T_SPECIFIER "]: ",i,quadCache.frustumData.size());
vector<float> &frustumDataInner = quadCache.frustumData[i];
for(unsigned int j = 0; j < frustumDataInner.size(); ++j) {
printf("[%f]",quadCache.frustumData[i][j]);
}
}
printf("\nEND\n");
}
const bool newVisibleQuadCalc = false;
if(newVisibleQuadCalc) {
const bool debug = false;
try {
if(debug) {
visibleQuad = gameCamera->computeVisibleQuad();
printf("Camera: %d,%d %d,%d %d,%d %d,%d\n",
visibleQuad.p[0].x,visibleQuad.p[0].y,
visibleQuad.p[1].x,visibleQuad.p[1].y,
visibleQuad.p[2].x,visibleQuad.p[2].y,
visibleQuad.p[3].x,visibleQuad.p[3].y);
}
// compute the four corners using OpenGL
GLdouble model[16], projection[16];
GLint viewport[4];
glGetDoublev(GL_MODELVIEW_MATRIX,model);
glGetDoublev(GL_PROJECTION_MATRIX,projection);
glGetIntegerv(GL_VIEWPORT,viewport);
Vec2i
tl = _unprojectMap(Vec2i(0,0),model,projection,viewport,"tl"),
tr = _unprojectMap(Vec2i(viewport[2],0),model,projection,viewport,"tr"),
br = _unprojectMap(Vec2i(viewport[2],viewport[3]),model,projection,viewport,"br"),
bl = _unprojectMap(Vec2i(0,viewport[3]),model,projection,viewport,"bl");
// orientate it for map iterator
//bool swapRequiredX = false;
bool swapRequiredY = false;
int const cellBuffer = 4;
if((tl.x > tr.x) || (bl.x > br.x)) {
if(debug) printf("Swap X???\n");
//std::swap(tl,bl);
//std::swap(tr,br);
if(tl.x > tr.x) {
if(debug) printf("Swap X1???\n");
tr.x += cellBuffer;
tl.x -= cellBuffer;
std::swap(tl.x,tr.x);
//swapRequiredX = true;
}
else {
tl.x += cellBuffer;
tr.x -= cellBuffer;
}
if(bl.x > br.x) {
if(debug) printf("Swap X2???\n");
bl.x += cellBuffer;
br.x -= cellBuffer;
std::swap(bl.x,br.x);
//swapRequiredX = true;
}
else {
br.x += cellBuffer;
bl.x -= cellBuffer;
}
}
if((tl.y > bl.y) || (tr.y > br.y)) {
visibleQuad = this->gameCamera->computeVisibleQuad();
if(debug) printf("Swap Y???\n");
if(tl.y > bl.y) {
if(debug) printf("Swap Y1???\n");
tl.y += cellBuffer;
bl.y -= cellBuffer;
std::swap(tl.y,bl.y);
swapRequiredY = true;
}
else {
bl.y += cellBuffer;
tl.y -= cellBuffer;
}
if(tr.y > br.y) {
if(debug) printf("Swap Y2???\n");
tr.y += cellBuffer;
br.y -= cellBuffer;
std::swap(tr.y,br.y);
swapRequiredY = true;
}
else {
br.y += cellBuffer;
tr.y -= cellBuffer;
}
//std::swap(tl,tr);
//std::swap(bl,br);
}
if(swapRequiredY == false) {
tl.y -= cellBuffer;
tr.y -= cellBuffer;
bl.y += cellBuffer;
br.y += cellBuffer;
}
// set it as the frustum
visibleQuad = Quad2i(tl,bl,tr,br); // strange order
if(debug) {
printf("Will: %d,%d %d,%d %d,%d %d,%d\n",
visibleQuad.p[0].x,visibleQuad.p[0].y,
visibleQuad.p[1].x,visibleQuad.p[1].y,
visibleQuad.p[2].x,visibleQuad.p[2].y,
visibleQuad.p[3].x,visibleQuad.p[3].y);
}
}
catch(PROJECTION_TO_INFINITY &e) {
if(debug) printf("hmm staring at the horizon %d\n",(int)e);
// use historic code solution
visibleQuad = this->gameCamera->computeVisibleQuad();
}
}
}
// =======================================
// basic rendering
// =======================================
void Renderer::renderMouse2d(int x, int y, int anim, float fade) {
if(no2DMouseRendering == true) {
return;
}
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
// float blue=0.0f;
// float green=0.4f;
if(game != NULL && game->getGui() != NULL) {
const Gui *gui=game->getGui();
const Display *display=gui->getDisplay();
int downPos= display->getDownSelectedPos();
if(downPos != Display::invalidPos){
// in state of doing something
const Texture2D *texture= display->getDownImage(downPos);
renderTextureQuad(x+18,y-50,32,32,texture,0.8f);
}
// else {
// // Display current commandtype
// const Unit *unit=NULL;
// if(gui->getSelection()->isEmpty()){
// blue=0.0f;
// green=0.1f;
// }
// else{
// unit=gui->getSelection()->getFrontUnit();
// if(unit->getCurrCommand()!=NULL && unit->getCurrCommand()->getCommandType()->getImage()!=NULL){
// const Texture2D *texture = unit->getCurrCommand()->getCommandType()->getImage();
// renderTextureQuad(x+18,y-50,32,32,texture,0.2f);
// }
// }
// }
if(game->isMarkCellMode() == true) {
const Texture2D *texture= game->getMarkCellTexture();
renderTextureQuad(x,y,texture->getTextureWidth(),texture->getTextureHeight(),texture,0.8f);
}
if(game->isUnMarkCellMode() == true) {
const Texture2D *texture= game->getUnMarkCellTexture();
renderTextureQuad(x,y,texture->getTextureWidth(),texture->getTextureHeight(),texture,0.8f);
}
}
float fadeFactor = fade + 1.f;
anim= anim * 2 - maxMouse2dAnim;
float color2= (abs(anim*(int)fadeFactor)/static_cast<float>(maxMouse2dAnim))/2.f+0.4f;
float color1= (abs(anim*(int)fadeFactor)/static_cast<float>(maxMouse2dAnim))/2.f+0.8f;
glPushAttrib(GL_CURRENT_BIT | GL_COLOR_BUFFER_BIT | GL_LINE_BIT);
glEnable(GL_BLEND);
//inside
glColor4f(0.4f*fadeFactor, 0.2f*fadeFactor, 0.2f*fadeFactor, 0.5f*fadeFactor);
glBegin(GL_TRIANGLES);
glVertex2i(x, y);
glVertex2i(x+20, y-10);
glVertex2i(x+10, y-20);
glEnd();
//border
glLineWidth(2);
glBegin(GL_LINE_LOOP);
glColor4f(1.f, 0.2f, 0, color1);
glVertex2i(x, y);
glColor4f(1.f, 0.4f, 0, color2);
glVertex2i(x+20, y-10);
glColor4f(1.f, 0.4f, 0, color2);
glVertex2i(x+10, y-20);
glEnd();
glPopAttrib();
/*
if(no2DMouseRendering == true) {
return;
}
float color1 = 0.0, color2 = 0.0;
float fadeFactor = fade + 1.f;
anim= anim * 2 - maxMouse2dAnim;
color2= (abs(anim*(int)fadeFactor)/static_cast<float>(maxMouse2dAnim))/2.f+0.4f;
color1= (abs(anim*(int)fadeFactor)/static_cast<float>(maxMouse2dAnim))/2.f+0.8f;
glPushAttrib(GL_CURRENT_BIT | GL_COLOR_BUFFER_BIT | GL_LINE_BIT);
glEnable(GL_BLEND);
//inside
Vec2i vertices[3];
vertices[0] = Vec2i(x, y);
vertices[1] = Vec2i(x+20, y-10);
vertices[2] = Vec2i(x+10, y-20);
glColor4f(0.4f*fadeFactor, 0.2f*fadeFactor, 0.2f*fadeFactor, 0.5f*fadeFactor);
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(2, GL_INT, 0, &vertices[0]);
glDrawArrays(GL_TRIANGLES, 0, 3);
glDisableClientState(GL_VERTEX_ARRAY);
//border
vertices[0] = Vec2i(x, y);
vertices[1] = Vec2i(x+20, y-10);
vertices[2] = Vec2i(x+10, y-20);
Vec4f colors[4];
colors[0] = Vec4f(1.f, 0.2f, 0, color1);
colors[1] = Vec4f(1.f, 0.4f, 0, color2);
colors[2] = Vec4f(1.f, 0.4f, 0, color2);
glLineWidth(2);
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(2, GL_INT, 0, &vertices[0]);
glEnableClientState(GL_COLOR_ARRAY);
glColorPointer(4, GL_FLOAT, 0, &colors[0]);
glDrawArrays(GL_LINE_LOOP, 0, 3);
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
glPopAttrib();
*/
}
void Renderer::renderMouse3d() {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
Config &config= Config::getInstance();
if(config.getBool("RecordMode","false") == true) {
return;
}
if(game == NULL) {
char szBuf[8096]="";
snprintf(szBuf,8096,"In [%s::%s] Line: %d game == NULL",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
throw megaglest_runtime_error(szBuf);
}
else if(game->getGui() == NULL) {
char szBuf[8096]="";
snprintf(szBuf,8096,"In [%s::%s] Line: %d game->getGui() == NULL",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
throw megaglest_runtime_error(szBuf);
}
else if(game->getGui()->getMouse3d() == NULL) {
char szBuf[8096]="";
snprintf(szBuf,8096,"In [%s::%s] Line: %d game->getGui()->getMouse3d() == NULL",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
throw megaglest_runtime_error(szBuf);
}
const Gui *gui= game->getGui();
const Mouse3d *mouse3d= gui->getMouse3d();
const Map *map= game->getWorld()->getMap();
if(map == NULL) {
char szBuf[8096]="";
snprintf(szBuf,8096,"In [%s::%s] Line: %d map == NULL",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
throw megaglest_runtime_error(szBuf);
}
assertGl();
if((mouse3d->isEnabled() || gui->isPlacingBuilding()) && gui->isValidPosObjWorld()) {
const Vec2i &pos= gui->getPosObjWorld();
glMatrixMode(GL_MODELVIEW);
glPushAttrib(GL_CURRENT_BIT | GL_LIGHTING_BIT | GL_ENABLE_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_BLEND);
glDisable(GL_STENCIL_TEST);
glDepthFunc(GL_LESS);
glEnable(GL_COLOR_MATERIAL);
glDepthMask(GL_FALSE);
if(gui->isPlacingBuilding()) {
modelRenderer->begin(true, true, false, false);
const UnitType *building= gui->getBuilding();
const Gui *gui= game->getGui();
renderGhostModel(building, pos, gui->getSelectedFacing());
modelRenderer->end();
glDisable(GL_COLOR_MATERIAL);
glPopAttrib();
}
else {
glPushMatrix();
Vec3f pos3f= Vec3f(pos.x, map->getCell(pos)->getHeight(), pos.y);
Vec4f color;
GLUquadricObj *cilQuadric;
//standard mouse
glDisable(GL_TEXTURE_2D);
glDisable(GL_CULL_FACE);
color= Vec4f(1.f, 0.f, 0.f, 1.f-mouse3d->getFade());
glColor4fv(color.ptr());
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, color.ptr());
glTranslatef(pos3f.x, pos3f.y+2.f, pos3f.z);
glRotatef(90.f, 1.f, 0.f, 0.f);
glRotatef(static_cast<float>(mouse3d->getRot()), 0.f, 0.f, 1.f);
cilQuadric= gluNewQuadric();
gluQuadricDrawStyle(cilQuadric, GLU_FILL);
gluCylinder(cilQuadric, 0.5f, 0.f, 2.f, 4, 1);
gluCylinder(cilQuadric, 0.5f, 0.f, 0.f, 4, 1);
glTranslatef(0.f, 0.f, 1.f);
gluCylinder(cilQuadric, 0.7f, 0.f, 1.f, 4, 1);
gluCylinder(cilQuadric, 0.7f, 0.f, 0.f, 4, 1);
gluDeleteQuadric(cilQuadric);
glPopAttrib();
glPopMatrix();
}
}
}
void Renderer::renderBackground(const Texture2D *texture) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
const Metrics &metrics= Metrics::getInstance();
assertGl();
glPushAttrib(GL_ENABLE_BIT);
glDisable(GL_LIGHTING);
glEnable(GL_TEXTURE_2D);
renderQuad(0, 0, metrics.getVirtualW(), metrics.getVirtualH(), texture);
glPopAttrib();
assertGl();
}
void Renderer::renderTextureQuad(int x, int y, int w, int h, const Texture2D *texture, float alpha,const Vec3f *color) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
assertGl();
glPushAttrib(GL_ENABLE_BIT);
glDisable(GL_LIGHTING);
glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
if(color != NULL) {
Vec4f newColor(*color);
newColor.w = alpha;
glColor4fv(newColor.ptr());
}
else {
glColor4f(1.f, 1.f, 1.f, alpha);
}
renderQuad(x, y, w, h, texture);
glPopAttrib();
assertGl();
}
void Renderer::renderConsoleLine3D(int lineIndex, int xPosition, int yPosition, int lineHeight,
Font3D* font, string stringToHightlight, const ConsoleLineInfo *lineInfo) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
Vec4f fontColor;
Lang &lang= Lang::getInstance();
//const Metrics &metrics= Metrics::getInstance();
FontMetrics *fontMetrics= font->getMetrics();
if(game != NULL) {
fontColor = game->getGui()->getDisplay()->getColor();
}
else {
// white shadowed is default ( in the menu for example )
//fontColor=Vec4f(1.f, 1.f, 1.f, 0.0f);
fontColor=Vec4f(lineInfo->color.x,lineInfo->color.y,lineInfo->color.z, 0.0f);
}
Vec4f defaultFontColor = fontColor;
if(lineInfo->PlayerIndex >= 0) {
std::map<int,Texture2D *> &crcPlayerTextureCache = CacheManager::getCachedItem< std::map<int,Texture2D *> >(GameConstants::playerTextureCacheLookupKey);
Vec3f playerColor = crcPlayerTextureCache[lineInfo->PlayerIndex]->getPixmap()->getPixel3f(0, 0);
fontColor.x = playerColor.x;
fontColor.y = playerColor.y;
fontColor.z = playerColor.z;
GameNetworkInterface *gameNetInterface = NetworkManager::getInstance().getGameNetworkInterface();
if(gameNetInterface != NULL && gameNetInterface->getGameSettings() != NULL) {
const GameSettings *gameSettings = gameNetInterface->getGameSettings();
string playerName = gameSettings->getNetworkPlayerNameByPlayerIndex(lineInfo->PlayerIndex);
if(playerName != lineInfo->originalPlayerName && lineInfo->originalPlayerName != "") {
playerName = lineInfo->originalPlayerName;
}
if(playerName == GameConstants::NETWORK_SLOT_UNCONNECTED_SLOTNAME) {
playerName = lang.getString("SystemUser");
}
//printf("playerName [%s], line [%s]\n",playerName.c_str(),line.c_str());
//string headerLine = "*" + playerName + ":";
//string headerLine = playerName + ": ";
string headerLine = playerName;
if(lineInfo->teamMode == true) {
headerLine += " (" + lang.getString("Team") + ")";
}
headerLine += ": ";
if(fontMetrics == NULL) {
throw megaglest_runtime_error("fontMetrics == NULL");
}
renderTextShadow3D(
headerLine,
font,
fontColor,
xPosition, lineIndex * lineHeight + yPosition);
fontColor = defaultFontColor;
//xPosition += (8 * (playerName.length() + 2));
// Proper font spacing after username portion of chat text rendering
//xPosition += (metrics.toVirtualX(fontMetrics->getTextWidth(headerLine)));
xPosition += fontMetrics->getTextWidth(headerLine);
}
}
else if(lineInfo->originalPlayerName != "") {
string playerName = lineInfo->originalPlayerName;
//string headerLine = playerName + ": ";
string headerLine = playerName;
if(lineInfo->teamMode == true) {
headerLine += " (" + lang.getString("Team") + ")";
}
headerLine += ": ";
if(fontMetrics == NULL) {
throw megaglest_runtime_error("fontMetrics == NULL");
}
renderTextShadow3D(
headerLine,
font,
fontColor,
xPosition, lineIndex * lineHeight + yPosition);
fontColor = defaultFontColor;
//xPosition += (8 * (playerName.length() + 2));
// Proper font spacing after username portion of chat text rendering
//xPosition += (metrics.toVirtualX(fontMetrics->getTextWidth(headerLine)));
xPosition += fontMetrics->getTextWidth(headerLine);
}
else {
fontColor = defaultFontColor;
}
if(stringToHightlight!="" && lineInfo->text.find(stringToHightlight)!=string::npos){
fontColor=Vec4f(1.f, 0.5f, 0.5f, 0.0f);
}
renderTextShadow3D(
lineInfo->text,
font,
fontColor,
xPosition, (lineIndex * lineHeight) + yPosition);
}
void Renderer::renderConsoleLine(int lineIndex, int xPosition, int yPosition, int lineHeight,
Font2D* font, string stringToHightlight, const ConsoleLineInfo *lineInfo) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
Vec4f fontColor;
Lang &lang= Lang::getInstance();
const Metrics &metrics= Metrics::getInstance();
FontMetrics *fontMetrics= font->getMetrics();
if(game != NULL) {
fontColor = game->getGui()->getDisplay()->getColor();
}
else {
// white shadowed is default ( in the menu for example )
//fontColor=Vec4f(1.f, 1.f, 1.f, 0.0f);
fontColor=Vec4f(lineInfo->color.x,lineInfo->color.y,lineInfo->color.z, 0.0f);
}
Vec4f defaultFontColor = fontColor;
if(lineInfo->PlayerIndex >= 0) {
std::map<int,Texture2D *> &crcPlayerTextureCache = CacheManager::getCachedItem< std::map<int,Texture2D *> >(GameConstants::playerTextureCacheLookupKey);
Vec3f playerColor = crcPlayerTextureCache[lineInfo->PlayerIndex]->getPixmap()->getPixel3f(0, 0);
fontColor.x = playerColor.x;
fontColor.y = playerColor.y;
fontColor.z = playerColor.z;
GameNetworkInterface *gameNetInterface = NetworkManager::getInstance().getGameNetworkInterface();
if(gameNetInterface != NULL && gameNetInterface->getGameSettings() != NULL) {
const GameSettings *gameSettings = gameNetInterface->getGameSettings();
string playerName = gameSettings->getNetworkPlayerNameByPlayerIndex(lineInfo->PlayerIndex);
if(playerName != lineInfo->originalPlayerName && lineInfo->originalPlayerName != "") {
playerName = lineInfo->originalPlayerName;
}
//printf("playerName [%s], line [%s]\n",playerName.c_str(),line.c_str());
//string headerLine = "*" + playerName + ":";
//string headerLine = playerName + ": ";
string headerLine = playerName;
if(lineInfo->teamMode == true) {
headerLine += " (" + lang.getString("Team") + ")";
}
headerLine += ": ";
if(fontMetrics == NULL) {
throw megaglest_runtime_error("fontMetrics == NULL");
}
renderTextShadow(
headerLine,
font,
fontColor,
xPosition, lineIndex * lineHeight + yPosition);
fontColor = defaultFontColor;
//xPosition += (8 * (playerName.length() + 2));
// Proper font spacing after username portion of chat text rendering
xPosition += (metrics.toVirtualX(fontMetrics->getTextWidth(headerLine)));
}
}
else if(lineInfo->originalPlayerName != "") {
string playerName = lineInfo->originalPlayerName;
//string headerLine = playerName + ": ";
string headerLine = playerName;
if(lineInfo->teamMode == true) {
headerLine += " (" + lang.getString("Team") + ")";
}
headerLine += ": ";
if(fontMetrics == NULL) {
throw megaglest_runtime_error("fontMetrics == NULL");
}
renderTextShadow(
headerLine,
font,
fontColor,
xPosition, lineIndex * lineHeight + yPosition);
fontColor = defaultFontColor;
//xPosition += (8 * (playerName.length() + 2));
// Proper font spacing after username portion of chat text rendering
xPosition += (metrics.toVirtualX(fontMetrics->getTextWidth(headerLine)));
}
else {
fontColor = defaultFontColor;
}
if(stringToHightlight!="" && lineInfo->text.find(stringToHightlight)!=string::npos){
fontColor=Vec4f(1.f, 0.5f, 0.5f, 0.0f);
}
renderTextShadow(
lineInfo->text,
font,
fontColor,
xPosition, (lineIndex * lineHeight) + yPosition);
}
void Renderer::renderConsole(const Console *console, ConsoleMode mode , int overrideMaxConsoleLines){
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
if(console == NULL) {
throw megaglest_runtime_error("console == NULL");
}
glPushAttrib(GL_ENABLE_BIT);
glEnable(GL_BLEND);
if(mode==consoleFull) {
int x= console->getXPos()-5;
int y= console->getYPos()-5;
int h= console->getLineHeight()*console->getStoredLineCount();
if(h > 0) {
int w= 1000;
//background
glPushAttrib(GL_ENABLE_BIT | GL_CURRENT_BIT);
glEnable(GL_BLEND);
glColor4f(0.0f, 0.0f, 0.0f, 0.8f) ;
glBegin(GL_TRIANGLE_STRIP);
glVertex2i(x, y);
glVertex2i(x, y+h);
glVertex2i(x+w, y);
glVertex2i(x+w, y+h);
glEnd();
glPopAttrib();
}
for(int i = 0; i < console->getStoredLineCount(); ++i) {
const ConsoleLineInfo &lineInfo = console->getStoredLineItem(i);
if(renderText3DEnabled == true) {
renderConsoleLine3D(i, console->getXPos(), console->getYPos(),
console->getLineHeight(), console->getFont3D(),
console->getStringToHighlight(), &lineInfo);
}
else {
renderConsoleLine(i, console->getXPos(), console->getYPos(),
console->getLineHeight(), console->getFont(),
console->getStringToHighlight(), &lineInfo);
}
}
}
else if(mode==consoleStoredOnly) {
int allowedMaxLines = (overrideMaxConsoleLines >= 0 ? overrideMaxConsoleLines : maxConsoleLines);
for(int i = 0; i < console->getStoredLineCount() && i < allowedMaxLines; ++i) {
const ConsoleLineInfo &lineInfo = console->getStoredLineItem(i);
if(renderText3DEnabled == true) {
renderConsoleLine3D(i, console->getXPos(), console->getYPos(),
console->getLineHeight(), console->getFont3D(), console->getStringToHighlight(), &lineInfo);
}
else {
renderConsoleLine(i, console->getXPos(), console->getYPos(),
console->getLineHeight(), console->getFont(), console->getStringToHighlight(), &lineInfo);
}
}
}
else if(mode==consoleStoredAndNormal) {
int allowedMaxLines = (overrideMaxConsoleLines >= 0 ? overrideMaxConsoleLines : maxConsoleLines);
float starttimestamp=-1;
int consoleIndex=0;
for(int i = 0; i < console->getLineCount() && i < allowedMaxLines; ++i) {
const ConsoleLineInfo &lineInfo = console->getLineItem(i);
if(starttimestamp>lineInfo.timeStamp || starttimestamp==-1) starttimestamp=lineInfo.timeStamp;
if(renderText3DEnabled == true) {
renderConsoleLine3D(i, console->getXPos(), console->getYPos(),
console->getLineHeight(), console->getFont3D(), console->getStringToHighlight(), &lineInfo);
}
else {
renderConsoleLine(i, console->getXPos(), console->getYPos(),
console->getLineHeight(), console->getFont(), console->getStringToHighlight(), &lineInfo);
}
consoleIndex++;
}
for(int i = 0; i < console->getStoredLineCount() && consoleIndex < allowedMaxLines; ++i) {
const ConsoleLineInfo &lineInfo = console->getStoredLineItem(i);
if( lineInfo.timeStamp<starttimestamp || starttimestamp==-1){
if(renderText3DEnabled == true) {
renderConsoleLine3D(consoleIndex, console->getXPos(), console->getYPos(),
console->getLineHeight(), console->getFont3D(), console->getStringToHighlight(), &lineInfo);
}
else {
renderConsoleLine(consoleIndex, console->getXPos(), console->getYPos(),
console->getLineHeight(), console->getFont(), console->getStringToHighlight(), &lineInfo);
}
consoleIndex++;
}
}
}
else if(mode==consoleNormal) {
for(int i = 0; i < console->getLineCount(); ++i) {
const ConsoleLineInfo &lineInfo = console->getLineItem(i);
if(renderText3DEnabled == true) {
renderConsoleLine3D(i, console->getXPos(), console->getYPos(),
console->getLineHeight(), console->getFont3D(), console->getStringToHighlight(), &lineInfo);
}
else {
renderConsoleLine(i, console->getXPos(), console->getYPos(),
console->getLineHeight(), console->getFont(), console->getStringToHighlight(), &lineInfo);
}
}
}
glPopAttrib();
}
void Renderer::renderChatManager(const ChatManager *chatManager) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
Vec4f fontColor;
Lang &lang= Lang::getInstance();
if(chatManager->getEditEnabled()) {
Vec4f color=Vec4f(0.0f,0.0f,0.0f,0.6f);
string text="";
if(chatManager->isInCustomInputMode() == true) {
text += lang.getString("CellHint");
}
else if(chatManager->getInMenu()) {
text += lang.getString("Chat");
}
else if(chatManager->getTeamMode()) {
text += lang.getString("Team");
}
else {
text += lang.getString("All");
}
text += ": " + chatManager->getText() + "_";
if(game != NULL) {
fontColor = game->getGui()->getDisplay()->getColor();
}
else {
// white shadowed is default ( in the menu for example )
fontColor=Vec4f(1.f, 1.f, 1.f, 0.0f);
}
// render Background
int x=chatManager->getXPos();
int y=chatManager->getYPos()-6;
int h=22;
int w=830;
glPushAttrib(GL_ENABLE_BIT | GL_CURRENT_BIT);
glEnable(GL_BLEND);
glColor4f(color.x, color.y, color.z, color.w) ;
glBegin(GL_TRIANGLE_STRIP);
glVertex2i(x, y);
glVertex2i(x, y+h);
glVertex2i(x+w, y);
glVertex2i(x+w, y+h);
glEnd();
glPopAttrib();
if(renderText3DEnabled == true) {
renderTextShadow3D(
text,
chatManager->getFont3D(),
fontColor,
chatManager->getXPos(), chatManager->getYPos());
}
else {
renderTextShadow(
text,
chatManager->getFont(),
fontColor,
chatManager->getXPos(), chatManager->getYPos());
}
}
else
{
if (chatManager->getInMenu()) {
string text = "\t\t\t\t\t>> "+lang.getString("PressEnterToChat")+" <<";
fontColor = Vec4f(0.5f, 0.5f, 0.5f, 0.5f);
if(renderText3DEnabled == true) {
renderTextShadow3D(text, chatManager->getFont3D(), fontColor,
chatManager->getXPos(), chatManager->getYPos());
}
else {
renderTextShadow(text, chatManager->getFont(), fontColor,
chatManager->getXPos(), chatManager->getYPos());
}
}
}
}
void Renderer::renderPerformanceStats() {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
const Metrics &metrics = Metrics::getInstance();
const Vec4f fontColor = game->getGui()->getDisplay()->getColor();
char szBuf[200]="";
snprintf(szBuf,200,"Frame: %d",game->getWorld()->getFrameCount() / 20);
string str = string(szBuf) + string("\n");
static time_t lastGamePerfCheck = time(NULL);
static string gamePerfStats = "";
if(difftime((long int)time(NULL),lastGamePerfCheck) > 3) {
lastGamePerfCheck = time(NULL);
gamePerfStats = game->getGamePerformanceCounts(true);
}
if(gamePerfStats != "") {
str += gamePerfStats + "\n";
}
if(renderText3DEnabled == true) {
renderTextShadow3D(
str, CoreData::getInstance().getDisplayFontSmall3D(),
fontColor,
10, metrics.getVirtualH()-180, false);
}
else {
renderTextShadow(
str, CoreData::getInstance().getDisplayFontSmall(),
fontColor,
10, metrics.getVirtualH()-180, false);
}
}
void Renderer::renderClock() {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
Config &config= Config::getInstance();
if(config.getBool("InGameClock","true") == false &&
config.getBool("InGameLocalClock","true") == false &&
config.getBool("InGameFrameCounter","false") == false) {
return;
}
string str = "";
const Metrics &metrics = Metrics::getInstance();
const World *world = game->getWorld();
const Vec4f fontColor = game->getGui()->getDisplay()->getColor();
if(config.getBool("InGameClock","true") == true) {
Lang &lang= Lang::getInstance();
char szBuf[501]="";
//int hours = world->getTimeFlow()->getTime();
//int minutes = (world->getTimeFlow()->getTime() - hours) * 100 * 0.6; // scale 100 to 60
//snprintf(szBuf,200,"%s %.2d:%.2d",lang.getString("GameTime","",true).c_str(),hours,minutes);
// string header2 = lang.getString("GameDurationTime","",true) + ": " + getTimeString(stats.getFramesToCalculatePlaytime());
snprintf(szBuf,500,"%s %s",lang.getString("GameDurationTime","",true).c_str(),getTimeDuationString(world->getFrameCount(),GameConstants::updateFps).c_str());
if(str != "") {
str += " ";
}
str += szBuf;
}
if(config.getBool("InGameLocalClock","true") == true) {
//time_t nowTime = time(NULL);
//struct tm *loctime = localtime(&nowTime);
struct tm loctime = threadsafe_localtime(systemtime_now());
char szBuf2[100]="";
strftime(szBuf2,100,"%H:%M",&loctime);
Lang &lang= Lang::getInstance();
char szBuf[200]="";
snprintf(szBuf,200,"%s %s",lang.getString("LocalTime","",true).c_str(),szBuf2);
if(str != "") {
str += " ";
}
str += szBuf;
}
if(config.getBool("InGameFrameCounter","false") == true) {
char szBuf[200]="";
snprintf(szBuf,200,"Frame: %d",game->getWorld()->getFrameCount() / 20);
if(str != "") {
str += " ";
}
str += szBuf;
}
//string str = szBuf;
if(renderText3DEnabled == true) {
renderTextShadow3D(
str, CoreData::getInstance().getDisplayFontSmall3D(),
fontColor,
10, metrics.getVirtualH()-160, false);
}
else {
renderTextShadow(
str, CoreData::getInstance().getDisplayFontSmall(),
fontColor,
10, metrics.getVirtualH()-160, false);
}
}
void Renderer::renderResourceStatus() {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
const World *world = game->getWorld();
Config &config= Config::getInstance();
if(world->getThisFactionIndex() < 0 ||
world->getThisFactionIndex() >= world->getFactionCount()) {
return;
}
const Faction *thisFaction = world->getFaction(world->getThisFactionIndex());
if(thisFaction->getPersonalityType() == fpt_Observer){
// render resources of selected units faction
const Gui *gui = game->getGui();
if(gui != NULL) {
const Selection *selection = gui->getSelection();
if(selection != NULL && selection->getCount() > 0 && selection->getFrontUnit() != NULL) {
const Unit *selectedUnit = selection->getFrontUnit();
thisFaction=selectedUnit->getFaction();
}
}
}
assertGl();
glPushAttrib(GL_ENABLE_BIT);
int rowsRendered = 0;
int resourceCountRendered = 0;
bool twoRessourceLines=false;
bool sharedTeamUnits = game != NULL && game->getGui() != NULL
&& game->isFlagType1BitEnabled(ft1_allow_shared_team_units)
== true;
bool sharedTeamResources = game != NULL && game->getGui() != NULL
&& game->isFlagType1BitEnabled(
ft1_allow_shared_team_resources) == true;
bool renderSharedTeamResources=false;
bool renderSharedTeamUnits=false;
bool renderLocalFactionResources=false;
if(config.getBool("TwoLineTeamResourceRendering","false") == true) {
if( sharedTeamResources == true || sharedTeamUnits == true){
twoRessourceLines=true;
}
if(sharedTeamResources == true){
renderSharedTeamResources=true;
renderSharedTeamUnits=true;
}
else if(sharedTeamUnits == true){
renderSharedTeamUnits=true;
renderLocalFactionResources=true;
}
else{
renderLocalFactionResources=true;
}
}
else {
if(sharedTeamResources == true)
renderSharedTeamResources=true;
else if(sharedTeamUnits == true)
renderSharedTeamUnits=true;
else
renderLocalFactionResources=true;
}
if(renderSharedTeamResources == true) {
resourceCountRendered = 0;
for(int techTreeResourceTypeIndex = 0;
techTreeResourceTypeIndex < world->getTechTree()->getResourceTypeCount();
++techTreeResourceTypeIndex) {
const ResourceType *rt = world->getTechTree()->getResourceType(techTreeResourceTypeIndex);
if ( rt->getDisplayInHud() == false ) {
continue;
}
bool showResource = world->showResourceTypeForTeam(rt, thisFaction->getTeam());
if(showResource == true) {
rowsRendered = renderResource(thisFaction,
false, twoRessourceLines, rt, 0,
resourceCountRendered);
}
}
if(resourceCountRendered > 0) {
rowsRendered++;
}
}
if(renderLocalFactionResources == true){
resourceCountRendered = 0;
const Faction *factionForResourceView = thisFaction;
bool localFactionResourcesOnly = true;
for(int techTreeResourceTypeIndex = 0;
techTreeResourceTypeIndex < world->getTechTree()->getResourceTypeCount();
++techTreeResourceTypeIndex) {
const ResourceType *rt = world->getTechTree()->getResourceType(techTreeResourceTypeIndex);
if ( rt->getDisplayInHud() == false ) {
continue;
}
//if any unit produces the resource
bool showResource;
if (twoRessourceLines)
showResource = world->showResourceTypeForTeam(rt,
factionForResourceView->getTeam());
else
showResource = world->showResourceTypeForFaction(rt,
factionForResourceView);
if(showResource == true) {
renderResource(factionForResourceView, localFactionResourcesOnly,
twoRessourceLines, rt, rowsRendered, resourceCountRendered);
}
}
if(resourceCountRendered > 0) {
rowsRendered++;
}
}
if(renderSharedTeamUnits == true){
resourceCountRendered = 0;
const Faction *factionForResourceView = thisFaction;
bool localFactionResourcesOnly = true;
const Gui *gui = game->getGui();
if(gui != NULL) {
const Selection *selection = gui->getSelection();
if(selection != NULL && selection->getCount() > 0 && selection->getFrontUnit() != NULL) {
const Unit *selectedUnit = selection->getFrontUnit();
if(selectedUnit != NULL && selectedUnit->getFaction()->isAlly(thisFaction) == true) {
factionForResourceView = selectedUnit->getFaction();
}
}
}
for(int techTreeResourceTypeIndex = 0;
techTreeResourceTypeIndex < world->getTechTree()->getResourceTypeCount();
++techTreeResourceTypeIndex) {
const ResourceType *rt = world->getTechTree()->getResourceType(techTreeResourceTypeIndex);
if ( rt->getDisplayInHud() == false ) {
continue;
}
//if any unit produces the resource
bool showResource;
if (twoRessourceLines)
showResource = world->showResourceTypeForTeam(rt,
factionForResourceView->getTeam());
else
showResource = world->showResourceTypeForFaction(rt,
factionForResourceView);
if(showResource == true) {
renderResource(factionForResourceView, localFactionResourcesOnly,
twoRessourceLines, rt, rowsRendered, resourceCountRendered);
}
}
//if(resourceCountRendered > 0) {
// rowsRendered++;
//}
}
glPopAttrib();
assertGl();
}
int Renderer::renderResource(const Faction *factionForResourceView,bool localFactionResourcesOnly,
bool twoResourceLines, const ResourceType *rt, int startRow, int &resourceCountRendered) {
const Metrics &metrics = Metrics::getInstance();
const int MAX_RESOURCES_PER_ROW = 6;
int resourceRowHeigth=30;
int resourceYStart=metrics.getVirtualH()-30;
if(twoResourceLines){
// we need to save some space
resourceYStart=metrics.getVirtualH()-22;
resourceRowHeigth=16;
}
//draw resource status
if(localFactionResourcesOnly == true) {
Vec4f resourceFontColor = Vec4f(factionForResourceView->getTexture()->getPixmapConst()->getPixel3f(0,0));
int resourceCol = 0;
int resourceRow = startRow;
int x=resourceCol * 100 + 190;
int y=resourceYStart - (resourceRowHeigth * resourceRow);
int h=16;
int w=8;
glColor3f(resourceFontColor.x,resourceFontColor.y,resourceFontColor.z);
glBegin(GL_TRIANGLE_STRIP);
glVertex2i(x, y+h);
glVertex2i(x, y);
glVertex2i(x+w, y+h/2);
glEnd();
}
const Resource *r = factionForResourceView->getResource(rt,localFactionResourcesOnly);
string str = intToStr(r->getAmount());
glEnable(GL_TEXTURE_2D);
const Vec4f fontColor = game->getGui()->getDisplay()->getColor();
Vec4f resourceFontColor = fontColor;
bool isNegativeConsumableDisplayCycle = false;
if(rt->getClass() == rcConsumable) {
// Show in yellow/orange/red font if negative
if(r->getBalance() * 5 + r->getAmount() < 0) {
if(time(NULL) % 2 == 0) {
isNegativeConsumableDisplayCycle = true;
if(r->getBalance() * 1 + r->getAmount() < 0) {
glColor3f(RED.x,RED.y,RED.z);
resourceFontColor = RED;
}
else if(r->getBalance() * 3 + r->getAmount() < 0) {
glColor3f(ORANGE.x,ORANGE.y,ORANGE.z);
resourceFontColor = ORANGE;
}
else if(r->getBalance() * 5 + r->getAmount() < 0) {
glColor3f(YELLOW.x,YELLOW.y,YELLOW.z);
resourceFontColor = YELLOW;
}
}
}
}
if(isNegativeConsumableDisplayCycle == false) {
glColor3f(1.f, 1.f, 1.f);
}
int resourceRow = startRow + (resourceCountRendered > 0 ? resourceCountRendered / MAX_RESOURCES_PER_ROW : 0);
int resourceCol = resourceCountRendered % MAX_RESOURCES_PER_ROW;
renderQuad(resourceCol * 100 + 200, resourceYStart - (resourceRowHeigth * resourceRow), 16, 16, rt->getImage());
if(rt->getClass() != rcStatic) {
str+= "/" + intToStr(factionForResourceView->getStoreAmount(rt,localFactionResourcesOnly));
}
if(rt->getClass() == rcConsumable) {
str+= "(";
if(r->getBalance() > 0) {
str+= "+";
}
str+= intToStr(r->getBalance()) + ")";
}
glDisable(GL_TEXTURE_2D);
if(renderText3DEnabled == true) {
renderTextShadow3D(
str, CoreData::getInstance().getDisplayFontSmall3D(),
resourceFontColor,
resourceCol * 100 + 220, resourceYStart - (resourceRowHeigth * resourceRow), false);
}
else {
renderTextShadow(
str, CoreData::getInstance().getDisplayFontSmall(),
resourceFontColor,
resourceCol * 100 + 220, resourceYStart - (resourceRowHeigth * resourceRow), false);
}
++resourceCountRendered;
return resourceRow;
}
void Renderer::renderSelectionQuad() {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
Config &config= Config::getInstance();
if(config.getBool("RecordMode","false") == true) {
return;
}
const Gui *gui= game->getGui();
const SelectionQuad *sq= gui->getSelectionQuad();
Vec2i down= sq->getPosDown();
Vec2i up= sq->getPosUp();
if(gui->isSelecting()) {
glPushAttrib(GL_CURRENT_BIT | GL_LINE_BIT);
Vec2i vertices[4];
vertices[0] = Vec2i(down.x, down.y);
vertices[1] = Vec2i(up.x, down.y);
vertices[2] = Vec2i(up.x, up.y);
vertices[3] = Vec2i(down.x, up.y);
glColor3f(0,1,0);
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(2, GL_INT, 0, &vertices[0]);
glDrawArrays(GL_LINE_LOOP, 0, 4);
glDisableClientState(GL_VERTEX_ARRAY);
/*
glColor3f(0,1,0);
glBegin(GL_LINE_LOOP);
glVertex2i(down.x, down.y);
glVertex2i(up.x, down.y);
glVertex2i(up.x, up.y);
glVertex2i(down.x, up.y);
glEnd();
*/
glPopAttrib();
}
}
Vec2i computeCenteredPos(const string &text, Font2D *font, int x, int y) {
if(font == NULL) {
//abort();
throw megaglest_runtime_error("font == NULL (1) text = " + text);
}
const Metrics &metrics= Metrics::getInstance();
FontMetrics *fontMetrics= font->getMetrics();
if(fontMetrics == NULL) {
throw megaglest_runtime_error("fontMetrics == NULL (1) text = " + text);
}
int virtualX = (fontMetrics->getTextWidth(text) > 0 ? static_cast<int>(fontMetrics->getTextWidth(text)/2.f) : 5);
int virtualY = (fontMetrics->getHeight(text) > 0 ? static_cast<int>(fontMetrics->getHeight(text)/2.f) : 5);
Vec2i textPos(
x-metrics.toVirtualX(virtualX),
y-metrics.toVirtualY(virtualY));
//printf("text [%s] x = %d y = %d virtualX = %d virtualY = %d fontMetrics->getHeight() = %f\n",text.c_str(),x,y,virtualX,virtualY,fontMetrics->getHeight());
return textPos;
}
Vec2i computeCenteredPos(const string &text, Font3D *font, int x, int y) {
if(font == NULL) {
throw megaglest_runtime_error("font == NULL (2) text = " + text);
}
const Metrics &metrics= Metrics::getInstance();
FontMetrics *fontMetrics= font->getMetrics();
if(fontMetrics == NULL) {
throw megaglest_runtime_error("fontMetrics == NULL (2) text = " + text);
}
int virtualX = (fontMetrics->getTextWidth(text) > 0 ? static_cast<int>(fontMetrics->getTextWidth(text) / 2.f) : 5);
int virtualY = (fontMetrics->getHeight(text) > 0 ? static_cast<int>(fontMetrics->getHeight(text) / 2.f) : 5);
Vec2i textPos(
x-metrics.toVirtualX(virtualX),
y-metrics.toVirtualY(virtualY));
return textPos;
}
void Renderer::renderTextSurroundingBox(int x, int y, int w, int h,
int maxEditWidth, int maxEditRenderWidth) {
//glColor4fv(color.ptr());
//glBegin(GL_QUADS); // Start drawing a quad primitive
//printf("A w = %d maxEditWidth = %d maxEditRenderWidth = %d\n",w,maxEditWidth,maxEditRenderWidth);
if(maxEditWidth >= 0 || maxEditRenderWidth >= 0) {
//printf("B w = %d maxEditWidth = %d maxEditRenderWidth = %d\n",w,maxEditWidth,maxEditRenderWidth);
if(maxEditRenderWidth >= 0) {
w = maxEditRenderWidth;
}
else {
w = maxEditWidth;
}
}
//printf("HI!!!\n");
glPointSize(20.0f);
int margin = 4;
//glBegin(GL_POINTS); // Start drawing a point primitive
glBegin(GL_LINE_LOOP); // Start drawing a line primitive
glVertex3f(x, y+h, 0.0f); // The bottom left corner
glVertex3f(x, y-margin, 0.0f); // The top left corner
glVertex3f(x+w, y-margin, 0.0f); // The top right corner
glVertex3f(x+w, y+h, 0.0f); // The bottom right corner
glEnd();
}
//
// renderTextBoundingBox3D
//
void Renderer::renderTextBoundingBox3D(const string &text, Font3D *font, float alpha, int x, int y, int w, int h, bool centeredW, bool centeredH,
bool editModeEnabled, int maxEditWidth, int maxEditRenderWidth) {
renderTextBoundingBox3D(text, font, Vec4f(1.f, 1.f, 1.f, alpha), x, y, w, h, centeredW, centeredH, editModeEnabled, maxEditRenderWidth, maxEditRenderWidth);
}
void Renderer::renderTextBoundingBox3D(const string &text, Font3D *font, const Vec3f &color, int x, int y, int w, int h, bool centeredW, bool centeredH,
bool editModeEnabled, int maxEditWidth, int maxEditRenderWidth) {
renderTextBoundingBox3D(text, font, Vec4f(color.x, color.y, color.z, 1.f), x, y, w, h, centeredW, centeredH, editModeEnabled, maxEditRenderWidth,
maxEditRenderWidth);
}
void Renderer::renderTextBoundingBox3D(const string &text, Font3D *font, const Vec4f &color, int x, int y, int w, int h, bool centeredW, bool centeredH,
bool editModeEnabled, int maxEditWidth, int maxEditRenderWidth) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
glPushAttrib(GL_ENABLE_BIT | GL_CURRENT_BIT);
glEnable(GL_BLEND);
glColor4fv(color.ptr());
Vec2f pos= Vec2f(x, y);
//Vec2i pos= centered? computeCenteredPos(text, font, x, y): Vec2i(x, y);
if(centeredW == true || centeredH == true) {
getCentered3DPos(text, font, pos, w, h,centeredW,centeredH);
}
if(editModeEnabled) {
if(maxEditWidth >= 0 || maxEditRenderWidth >= 0) {
int useWidth = maxEditWidth;
string temp = "";
for(int i = 0; i < useWidth; ++i) {
temp += DEFAULT_CHAR_FOR_WIDTH_CALC;
}
float lineWidth = (font->getTextHandler()->Advance(temp.c_str()) * ::Shared::Graphics::Font::scaleFontValue);
useWidth = (int)lineWidth;
maxEditWidth = useWidth;
}
renderTextSurroundingBox(pos.x, pos.y, w, h,maxEditWidth,maxEditRenderWidth);
}
glColor4fv(color.ptr());
TextRendererSafeWrapper safeTextRender(textRenderer3D,font);
textRenderer3D->render(text, pos.x, pos.y);
safeTextRender.end();
glDisable(GL_BLEND);
glPopAttrib();
}
//
// renderText3D
//
void Renderer::renderText3D(const string &text, Font3D *font, float alpha, int x, int y, bool centered) {
renderText3D(text,font,Vec4f(1.f, 1.f, 1.f, alpha),x,y,centered);
}
void Renderer::renderText3D(const string &text, Font3D *font, const Vec3f &color, int x, int y, bool centered) {
renderText3D(text,font,Vec4f(color.x, color.y, color.z, 1.f),x,y,centered);
}
void Renderer::renderText3D(const string &text, Font3D *font, const Vec4f &color, int x, int y, bool centered) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
glPushAttrib(GL_ENABLE_BIT | GL_CURRENT_BIT);
glEnable(GL_BLEND);
glColor4fv(color.ptr());
Vec2i pos= Vec2i(x, y);
//Vec2i pos= centered? computeCenteredPos(text, font, x, y): Vec2i(x, y);
TextRendererSafeWrapper safeTextRender(textRenderer3D,font);
textRenderer3D->render(text, pos.x, pos.y, centered);
safeTextRender.end();
glDisable(GL_BLEND);
glPopAttrib();
}
//
// renderText
//
void Renderer::renderText(const string &text, Font2D *font, float alpha, int x, int y, bool centered) {
renderText(text,font,Vec4f(1.f, 1.f, 1.f, alpha),x,y,centered);
}
void Renderer::renderText(const string &text, Font2D *font, const Vec3f &color, int x, int y, bool centered){
renderText(text,font,Vec4f(color.x, color.y, color.z, 1.f),x,y,centered);
}
void Renderer::renderText(const string &text, Font2D *font, const Vec4f &color, int x, int y, bool centered){
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
glPushAttrib(GL_ENABLE_BIT | GL_CURRENT_BIT);
glEnable(GL_BLEND);
glColor4fv(color.ptr());
Vec2i pos= centered? computeCenteredPos(text, font, x, y): Vec2i(x, y);
TextRendererSafeWrapper safeTextRender(textRenderer,font);
textRenderer->render(text, pos.x, pos.y);
safeTextRender.end();
glPopAttrib();
}
Vec2f Renderer::getCentered3DPos(const string &text, Font3D *font, Vec2f &pos, int w, int h,bool centeredW, bool centeredH) {
if(centeredW == true) {
if(font == NULL) {
//abort();
throw megaglest_runtime_error("font == NULL (5) text = " + text);
}
else if(font->getTextHandler() == NULL) {
char szBuf[8096] = "";
snprintf(szBuf, 8096, "font->getTextHandler() == NULL(5) text = [%s] FontPtr = [%p]\n", text.c_str(),font);
throw megaglest_runtime_error(szBuf);
}
float lineWidth = (font->getTextHandler()->Advance(text.c_str()) * ::Shared::Graphics::Font::scaleFontValue);
if(lineWidth < w) {
pos.x += ((w / 2.f) - (lineWidth / 2.f));
}
}
if(centeredH) {
if(font == NULL) {
throw megaglest_runtime_error("font == NULL (6) text = " + text);
}
else if(font->getTextHandler() == NULL) {
throw megaglest_runtime_error("font->getTextHandler() == NULL (6) text = " + text);
}
//const Metrics &metrics= Metrics::getInstance();
//float lineHeight = (font->getTextHandler()->LineHeight(text.c_str()) * Font::scaleFontValue);
float lineHeight = (font->getTextHandler()->LineHeight(text.c_str()) * ::Shared::Graphics::Font::scaleFontValue);
//lineHeight=metrics.toVirtualY(lineHeight);
//lineHeight= lineHeight / (2.f + 0.2f * FontMetrics::DEFAULT_Y_OFFSET_FACTOR);
//pos.y += (h / 2.f) - (lineHeight / 2.f);
//pos.y += (h / 2.f) - (lineHeight);
//pos.y += (lineHeight / 2.f); // y starts at the middle of the render position, so only move up 1/2 the font height
if(lineHeight < h) {
//printf("line %d, lineHeight [%f] h [%d] text [%s]\n",__LINE__,lineHeight,h,text.c_str());
//if(Font::forceFTGLFonts == true) {
// First go to top of bounding box
pos.y += (h - lineHeight);
pos.y -= ((h - lineHeight) / ::Shared::Graphics::Font::scaleFontValueCenterHFactor);
// }
// else {
// pos.y += (float)(((float)h) / 2.0);
// float heightGap = (float)(((float)h - lineHeight) / 2.0);
// pos.y -= heightGap;
//
// //printf("h = %d lineHeight = %f heightGap = %f\n",h,lineHeight,heightGap);
//
// // Now calculate till we get text to middle
// //pos.y -= (realHeight / 2);
// //pos.y += (lineHeight / 2);
// }
}
else if(lineHeight > h) {
//printf("line %d, lineHeight [%f] h [%d] text [%s]\n",__LINE__,lineHeight,h,text.c_str());
pos.y += (std::ceil(lineHeight - h));
}
}
return pos;
}
void Renderer::renderTextShadow3D(const string &text, Font3D *font,const Vec4f &color, int x, int y, bool centered) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
if(font == NULL) {
throw megaglest_runtime_error("font == NULL (3) text = " + text);
}
glPushAttrib(GL_CURRENT_BIT);
Vec2i pos= centered? computeCenteredPos(text, font, x, y): Vec2i(x, y);
TextRendererSafeWrapper safeTextRender(textRenderer3D,font);
if(color.w < 0.5) {
glColor3f(0.0f, 0.0f, 0.0f);
textRenderer3D->render(text, pos.x-1.0f, pos.y-1.0f);
}
glColor3f(color.x,color.y,color.z);
textRenderer3D->render(text, pos.x, pos.y);
//textRenderer3D->end();
safeTextRender.end();
glPopAttrib();
}
void Renderer::renderTextShadow(const string &text, Font2D *font,const Vec4f &color, int x, int y, bool centered){
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
if(font == NULL) {
throw megaglest_runtime_error("font == NULL (4) text = " + text);
}
glPushAttrib(GL_CURRENT_BIT);
Vec2i pos= centered? computeCenteredPos(text, font, x, y): Vec2i(x, y);
TextRendererSafeWrapper safeTextRender(textRenderer,font);
if(color.w < 0.5) {
glColor3f(0.0f, 0.0f, 0.0f);
textRenderer->render(text, pos.x-1.0f, pos.y-1.0f);
}
glColor3f(color.x,color.y,color.z);
textRenderer->render(text, pos.x, pos.y);
//textRenderer->end();
safeTextRender.end();
glPopAttrib();
}
// ============= COMPONENTS =============================
void Renderer::renderLabel(GraphicLabel *label) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
if( label->getVisible()==false){
return;
}
if(label->getEditable() && label->getMaxEditRenderWidth()>0)
{
int x= label->getX();
int y= label->getY();
int h= label->getH();
int w= label->getMaxEditRenderWidth();
if(h>0){
//background
glPushAttrib(GL_ENABLE_BIT | GL_CURRENT_BIT);
glEnable(GL_BLEND);
glColor4f(0.2f, 0.2f, 0.2f, 0.6f*label->getFade()) ;
glBegin(GL_TRIANGLE_STRIP);
glVertex2i(x, y);
glVertex2i(x, y+h);
glVertex2i(x+w, y);
glVertex2i(x+w, y+h);
glEnd();
glPopAttrib();
}
}
if(label->getRenderBackground())
{
int x= label->getX();
int y= label->getY();
int h= label->getH();
int w= label->getW();
if(label->getMaxEditRenderWidth()>0){
w= label->getMaxEditRenderWidth();
}
Vec4f color=label->getBackgroundColor();
if(h>0){
//background
glPushAttrib(GL_ENABLE_BIT | GL_CURRENT_BIT);
glEnable(GL_BLEND);
glColor4f(color.x, color.y, color.z, color.w*label->getFade()) ;
glBegin(GL_TRIANGLE_STRIP);
glVertex2i(x, y);
glVertex2i(x, y+h);
glVertex2i(x+w, y);
glVertex2i(x+w, y+h);
glEnd();
glPopAttrib();
}
}
if(label->getTexture()!=NULL )
{
int x= label->getX();
int y= label->getY();
int h= label->getH();
int w= label->getW();
if(h>0){
//background
glPushAttrib(GL_ENABLE_BIT | GL_CURRENT_BIT);
glEnable(GL_BLEND);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, static_cast<Texture2DGl*>( label->getTexture())->getHandle());
glColor4f(1.0f, 1.0f, 1.0f, 1.0f*label->getFade()) ;
glBegin(GL_TRIANGLE_STRIP);
glTexCoord2f(0.f, 0.f);
glVertex2f(x, y);
glTexCoord2f(0.f, 1.f);
glVertex2f(x, y+h);
glTexCoord2f(1.f, 0.f);
glVertex2f(x+w, y);
glTexCoord2f(1.f, 1.f);
glVertex2f(x+w, y+h);
glEnd();
glDisable(GL_TEXTURE_2D);
glPopAttrib();
}
}
Vec3f labelColor=label->getTextColor();
Vec4f colorWithAlpha = Vec4f(labelColor.x,labelColor.y,labelColor.z,GraphicComponent::getFade());
renderLabel(label,&colorWithAlpha);
}
void Renderer::renderLabel(GraphicLabel *label,const Vec3f *color) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
if(color != NULL) {
Vec4f colorWithAlpha = Vec4f(*color);
colorWithAlpha.w = GraphicComponent::getFade();
renderLabel(label,&colorWithAlpha);
}
else {
Vec4f *colorWithAlpha = NULL;
renderLabel(label,colorWithAlpha);
}
}
void Renderer::renderLabel(GraphicLabel *label,const Vec4f *color) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
if(label->getVisible() == false) {
return;
}
try {
glPushAttrib(GL_ENABLE_BIT);
glEnable(GL_BLEND);
vector<string> lines;
string renderTextString = (label->getTextNativeTranslation() != "" ? label->getTextNativeTranslation() : label->getText());
if(label->getWordWrap() == true) {
Tokenize(renderTextString,lines,"\n");
}
else {
lines.push_back(renderTextString);
}
for(unsigned int i = 0; i < lines.size(); ++i) {
Vec2i textPos;
int x= label->getX();
int y= label->getY() - (i * label->getH());
int h= label->getH();
int w= label->getW();
//if(label->getInstanceName() == "modDescrLabel") printf("~~~ lines.size() [%u] i = %d lines[i] [%s] y = %d\n",lines.size(),i,lines[i].c_str(),y);
if(label->getCentered()) {
textPos= Vec2i(x+w/2, y+h/2);
}
else {
textPos= Vec2i(x, y+h/4);
}
string renderTextStr = lines[i];
if(label->getIsPassword() == true) {
if(renderTextStr != "") {
renderTextStr = "*****";
}
}
if(color != NULL) {
if(renderText3DEnabled == true) {
//renderText3D(lines[i], label->getFont3D(), (*color), textPos.x, textPos.y, label->getCentered());
//printf("Text Render3D [%s] font3d [%p]\n",lines[i].c_str(),label->getFont3D());
//printf("Label render C\n");
renderTextBoundingBox3D(renderTextStr, label->getFont3D(), (*color),
x, y, w, h, label->getCenteredW(),label->getCenteredH(),
label->getEditModeEnabled(),label->getMaxEditWidth(),
label->getMaxEditRenderWidth());
}
else {
//printf("Label render D\n");
renderText(renderTextStr, label->getFont(), (*color), textPos.x, textPos.y, label->getCentered());
}
}
else {
if(renderText3DEnabled == true) {
//renderText3D(lines[i], label->getFont3D(), GraphicComponent::getFade(), textPos.x, textPos.y, label->getCentered());
//printf("Text Render3D [%s] font3d [%p]\n",lines[i].c_str(),label->getFont3D());
//printf("Label render E\n");
renderTextBoundingBox3D(renderTextStr, label->getFont3D(),
GraphicComponent::getFade(), x, y, w, h,
label->getCenteredW(),label->getCenteredH(),
label->getEditModeEnabled(),label->getMaxEditWidth(),
label->getMaxEditRenderWidth());
}
else {
//printf("Label render F\n");
renderText(renderTextStr, label->getFont(), GraphicComponent::getFade(), textPos.x, textPos.y, label->getCentered());
}
}
}
glPopAttrib();
}
catch(const exception &e) {
char szBuf[8096]="";
snprintf(szBuf,8096,"In [%s::%s Line: %d]\nError [%s] For Control [%s]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,e.what(),label->getInstanceName().c_str());
SystemFlags::OutputDebug(SystemFlags::debugError,szBuf);
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,szBuf);
throw megaglest_runtime_error(szBuf);
}
}
void Renderer::renderButton(GraphicButton *button, const Vec4f *fontColorOverride, bool *lightedOverride) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
if(button->getVisible() == false) {
return;
}
try {
//char szBuf[8096]="";
//snprintf(szBuf,8096,"In [%s::%s Line: %d]\n For Control container [%s] name [%s]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,button->getContainerName().c_str(), button->getInstanceName().c_str());
//printf(szBuf);
int x= button->getX();
int y= button->getY();
int h= button->getH();
int w= button->getW();
const Vec3f disabledTextColor= Vec3f(0.25f,0.25f,0.25f);
glPushAttrib(GL_CURRENT_BIT | GL_ENABLE_BIT);
//background
CoreData &coreData= CoreData::getInstance();
Texture2D *backTexture = NULL;
if(button->getUseCustomTexture() == true) {
backTexture = dynamic_cast<Texture2D *>(button->getCustomTexture());
}
else {
backTexture = w > 3 * h / 2 ? coreData.getButtonBigTexture(): coreData.getButtonSmallTexture();
}
glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
if(backTexture != NULL) {
glBindTexture(GL_TEXTURE_2D, static_cast<Texture2DGl*>(backTexture)->getHandle());
}
else {
glBindTexture(GL_TEXTURE_2D, 0);
}
//button
Vec4f fontColor(GraphicComponent::getCustomTextColor());
if(fontColorOverride != NULL) {
fontColor= *fontColorOverride;
}
else {
// white shadowed is default ( in the menu for example )
fontColor.w = GraphicComponent::getFade();
}
//Vec4f color= Vec4f(1.f, 1.f, 1.f, GraphicComponent::getFade());
Vec4f color= fontColor;
glColor4fv(color.ptr());
glBegin(GL_TRIANGLE_STRIP);
glTexCoord2f(0.f, 0.f);
glVertex2f(x, y);
glTexCoord2f(0.f, 1.f);
glVertex2f(x, y+h);
glTexCoord2f(1.f, 0.f);
glVertex2f(x+w, y);
glTexCoord2f(1.f, 1.f);
glVertex2f(x+w, y+h);
glEnd();
glDisable(GL_TEXTURE_2D);
//lighting
float anim= GraphicComponent::getAnim();
if(anim>0.5f) anim= 1.f-anim;
bool renderLighted = (button->getLighted() && button->getEditable());
if(lightedOverride != NULL) {
renderLighted = *lightedOverride;
}
if(renderLighted) {
const int lightSize= 0;
const Vec4f color1= Vec4f(color.x, color.y, color.z, 0.1f+anim*0.5f);
const Vec4f color2= Vec4f(color.x, color.y, color.z, 0.3f+anim);
glBegin(GL_TRIANGLE_FAN);
glColor4fv(color2.ptr());
glVertex2f(x+w/2, y+h/2);
glColor4fv(color1.ptr());
glVertex2f(x-lightSize, y-lightSize);
glColor4fv(color1.ptr());
glVertex2f(x+w+lightSize, y-lightSize);
glColor4fv(color1.ptr());
glVertex2f(x+w+lightSize, y+h+lightSize);
glColor4fv(color1.ptr());
glVertex2f(x+w+lightSize, y+h+lightSize);
glColor4fv(color1.ptr());
glVertex2f(x-lightSize, y+h+lightSize);
glColor4fv(color1.ptr());
glVertex2f(x-lightSize, y-lightSize);
glEnd();
}
//Vec2i textPos= Vec2i(x + w / 2, y + h / 2);
if(button->getEditable()) {
if(renderText3DEnabled == true) {
//renderText3D(button->getText(), button->getFont3D(), color,x + (w / 2), y + (h / 2), true);
renderTextBoundingBox3D(button->getText(), button->getFont3D(),
color, x, y, w, h, true, true,false,-1,-1);
}
else {
renderText(button->getText(), button->getFont(), color,x + (w / 2), y + (h / 2), true);
}
}
else {
if(renderText3DEnabled == true) {
//renderText3D(button->getText(), button->getFont3D(),disabledTextColor,
// x + (w / 2), y + (h / 2), true);
renderTextBoundingBox3D(button->getText(), button->getFont3D(),disabledTextColor,
x, y, w, h, true, true,false,-1,-1);
}
else {
renderText(button->getText(), button->getFont(),disabledTextColor,
x + (w / 2), y + (h / 2), true);
}
}
glPopAttrib();
}
catch(const exception &e) {
char szBuf[8096]="";
snprintf(szBuf,8096,"In [%s::%s Line: %d]\nError [%s] For Control container [%s] name [%s]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,e.what(),button->getContainerName().c_str(), button->getInstanceName().c_str());
SystemFlags::OutputDebug(SystemFlags::debugError,szBuf);
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,szBuf);
throw megaglest_runtime_error(szBuf);
}
}
void Renderer::renderCheckBox(const GraphicCheckBox *box) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
if(box->getVisible() == false) {
return;
}
int x= box->getX();
int y= box->getY();
int h= box->getH();
int w= box->getW();
//const Vec3f disabledTextColor= Vec3f(0.25f,0.25f,0.25f);
glPushAttrib(GL_CURRENT_BIT | GL_ENABLE_BIT);
//background
CoreData &coreData= CoreData::getInstance();
Texture2D *backTexture= box->getValue()? coreData.getCheckedCheckBoxTexture(): coreData.getCheckBoxTexture();
glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glBindTexture(GL_TEXTURE_2D, static_cast<Texture2DGl*>(backTexture)->getHandle());
//box
Vec4f fontColor;
//if(game!=NULL){
// fontColor=game->getGui()->getDisplay()->getColor();
// fontColor.w = GraphicComponent::getFade();
//}
//else {
// white shadowed is default ( in the menu for example )
fontColor=Vec4f(1.f, 1.f, 1.f, GraphicComponent::getFade());
//}
//Vec4f color= Vec4f(1.f, 1.f, 1.f, GraphicComponent::getFade());
Vec4f color= fontColor;
glColor4fv(color.ptr());
glBegin(GL_TRIANGLE_STRIP);
glTexCoord2f(0.f, 0.f);
glVertex2f(x, y);
glTexCoord2f(0.f, 1.f);
glVertex2f(x, y+h);
glTexCoord2f(1.f, 0.f);
glVertex2f(x+w, y);
glTexCoord2f(1.f, 1.f);
glVertex2f(x+w, y+h);
glEnd();
glDisable(GL_TEXTURE_2D);
//lighting
float anim= GraphicComponent::getAnim();
if(anim > 0.5f) {
anim = 1.f - anim;
}
if(box->getLighted() && box->getEditable()) {
const int lightSize= 0;
const Vec4f color1= Vec4f(color.x, color.y, color.z, 0.1f+anim*0.5f);
const Vec4f color2= Vec4f(color.x, color.y, color.z, 0.3f+anim);
glBegin(GL_TRIANGLE_FAN);
glColor4fv(color2.ptr());
glVertex2f(x+w/2, y+h/2);
glColor4fv(color1.ptr());
glVertex2f(x-lightSize, y-lightSize);
glColor4fv(color1.ptr());
glVertex2f(x+w+lightSize, y-lightSize);
glColor4fv(color1.ptr());
glVertex2f(x+w+lightSize, y+h+lightSize);
glColor4fv(color1.ptr());
glVertex2f(x+w+lightSize, y+h+lightSize);
glColor4fv(color1.ptr());
glVertex2f(x-lightSize, y+h+lightSize);
glColor4fv(color1.ptr());
glVertex2f(x-lightSize, y-lightSize);
glEnd();
}
glPopAttrib();
}
void Renderer::renderLine(const GraphicLine *line) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
if(line->getVisible() == false) {
return;
}
int x= line->getX();
int y= line->getY();
int h= line->getH();
int w= line->getW();
//const Vec3f disabledTextColor= Vec3f(0.25f,0.25f,0.25f);
glPushAttrib(GL_CURRENT_BIT | GL_ENABLE_BIT);
//background
CoreData &coreData= CoreData::getInstance();
Texture2D *backTexture= line->getHorizontal()? coreData.getHorizontalLineTexture(): coreData.getVerticalLineTexture();
glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glBindTexture(GL_TEXTURE_2D, static_cast<Texture2DGl*>(backTexture)->getHandle());
glBegin(GL_TRIANGLE_STRIP);
glTexCoord2f(0.f, 0.f);
glVertex2f(x, y);
glTexCoord2f(0.f, 1.f);
glVertex2f(x, y+h);
glTexCoord2f(1.f, 0.f);
glVertex2f(x+w, y);
glTexCoord2f(1.f, 1.f);
glVertex2f(x+w, y+h);
glEnd();
glDisable(GL_TEXTURE_2D);
glPopAttrib();
}
void Renderer::renderScrollBar(const GraphicScrollBar *sb) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
if(sb->getVisible() == false) {
return;
}
int x= sb->getX();
int y= sb->getY();
int h= sb->getH();
int w= sb->getW();
// calc real length
if(sb->getElementCount()<sb->getVisibleSize()){
int realLength=sb->getElementCount()*sb->getLength()/ sb->getVisibleSize();
if (sb->getHorizontal()) {
x=x-(w-realLength);
}
else {
y=y+(h-realLength);
h=realLength;
};
}
glPushAttrib(GL_CURRENT_BIT | GL_ENABLE_BIT);
/////////////////////
//background
////////////////////
CoreData &coreData= CoreData::getInstance();
Texture2D *backTexture= coreData.getHorizontalLineTexture();
glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
Vec4f fontColor;
fontColor=Vec4f(1.f, 1.f, 1.f, GraphicComponent::getFade());
Vec4f color= fontColor;
glColor4fv(color.ptr());
glBindTexture(GL_TEXTURE_2D, static_cast<Texture2DGl*>(backTexture)->getHandle());
glBegin(GL_TRIANGLE_STRIP);
glTexCoord2f(0.f, 0.f);
glVertex2f(x, y);
glTexCoord2f(0.f, 1.f);
glVertex2f(x, y+h);
glTexCoord2f(1.f, 0.f);
glVertex2f(x+w, y);
glTexCoord2f(1.f, 1.f);
glVertex2f(x+w, y+h);
glEnd();
////////////////////
// selectBlock
////////////////////
if (sb->getElementCount() >= sb->getVisibleSize()) {
if (sb->getHorizontal()) {
x = x + sb->getVisibleCompPosStart();
w = sb->getVisibleCompPosEnd() - sb->getVisibleCompPosStart();
} else {
y = y + sb->getVisibleCompPosStart();
h = sb->getVisibleCompPosEnd() - sb->getVisibleCompPosStart();
}
}
Texture2D *selectTexture= coreData.getButtonBigTexture();
assert(selectTexture != NULL);
glBindTexture(GL_TEXTURE_2D, static_cast<Texture2DGl*>(selectTexture)->getHandle());
glBegin(GL_TRIANGLE_STRIP);
glTexCoord2f(0.f, 0.f);
glVertex2f(x, y);
glTexCoord2f(0.f, 1.f);
glVertex2f(x, y+h);
glTexCoord2f(1.f, 0.f);
glVertex2f(x+w, y);
glTexCoord2f(1.f, 1.f);
glVertex2f(x+w, y+h);
glEnd();
glDisable(GL_TEXTURE_2D);
//lighting
float anim= GraphicComponent::getAnim();
if(anim>0.5f) anim= 1.f-anim;
if(sb->getLighted() && sb->getEditable()){
const int lightSize= 0;
const Vec4f color1= Vec4f(color.x, color.y, color.z, 0.1f+anim*0.5f);
const Vec4f color2= Vec4f(color.x, color.y, color.z, 0.3f+anim);
glBegin(GL_TRIANGLE_FAN);
glColor4fv(color2.ptr());
glVertex2f(x+w/2, y+h/2);
glColor4fv(color1.ptr());
glVertex2f(x-lightSize, y-lightSize);
glColor4fv(color1.ptr());
glVertex2f(x+w+lightSize, y-lightSize);
glColor4fv(color1.ptr());
glVertex2f(x+w+lightSize, y+h+lightSize);
glColor4fv(color1.ptr());
glVertex2f(x+w+lightSize, y+h+lightSize);
glColor4fv(color1.ptr());
glVertex2f(x-lightSize, y+h+lightSize);
glColor4fv(color1.ptr());
glVertex2f(x-lightSize, y-lightSize);
glEnd();
}
glPopAttrib();
}
void Renderer::renderListBox(GraphicListBox *listBox) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
if(listBox->getVisible() == false) {
return;
}
//if(listBox->getLeftControlled()==true)
{
int x= listBox->getX();
int y= listBox->getY();
int h= listBox->getH();
int w= listBox->getW();
if(h>0){
//background
glPushAttrib(GL_ENABLE_BIT | GL_CURRENT_BIT);
glEnable(GL_BLEND);
glColor4f(0.0f, 0.0f, 0.0f, 0.6f*listBox->getFade()) ;
glBegin(GL_TRIANGLE_STRIP);
glVertex2i(x, y);
glVertex2i(x, y+h);
glVertex2i(x+w, y);
glVertex2i(x+w, y+h);
glEnd();
glPopAttrib();
}
}
renderButton(listBox->getButton1());
renderButton(listBox->getButton2());
glPushAttrib(GL_ENABLE_BIT);
glEnable(GL_BLEND);
GraphicLabel label("ListBox_render_label","label",false);
//label.setInstanceName("ListBox_render_label");
if(listBox->getLeftControlled()==true){
label.init(listBox->getX()+listBox->getButton1()->getW()+listBox->getButton2()->getW()+2, listBox->getY(), listBox->getW(), listBox->getH(), false,listBox->getTextColor());
}
else {
label.init(listBox->getX(), listBox->getY(), listBox->getW(), listBox->getH(), true,listBox->getTextColor());
}
label.setText(listBox->getText());
label.setTextNativeTranslation(listBox->getTextNativeTranslation());
label.setFont(listBox->getFont());
label.setFont3D(listBox->getFont3D());
renderLabel(&label);
//lighting
bool renderLighted= (listBox->getLighted());
if(renderLighted) {
float anim= GraphicComponent::getAnim();
if(anim>0.5f) anim= 1.f-anim;
Vec3f color=listBox->getTextColor();
int x= listBox->getX()+listBox->getButton1()->getW();
int y= listBox->getY();
int h= listBox->getH();
int w= listBox->getW()-listBox->getButton1()->getW()-listBox->getButton2()->getW();
const int lightSize= 0;
const Vec4f color1= Vec4f(color.x, color.y, color.z, 0.1f+anim*0.5f);
const Vec4f color2= Vec4f(color.x, color.y, color.z, 0.3f+anim);
glBegin(GL_TRIANGLE_FAN);
glColor4fv(color2.ptr());
glVertex2f(x+w/2, y+h/2);
glColor4fv(color1.ptr());
glVertex2f(x-lightSize, y-lightSize);
glColor4fv(color1.ptr());
glVertex2f(x+w+lightSize, y-lightSize);
glColor4fv(color1.ptr());
glVertex2f(x+w+lightSize, y+h+lightSize);
glColor4fv(color1.ptr());
glVertex2f(x+w+lightSize, y+h+lightSize);
glColor4fv(color1.ptr());
glVertex2f(x-lightSize, y+h+lightSize);
glColor4fv(color1.ptr());
glVertex2f(x-lightSize, y-lightSize);
glEnd();
}
glPopAttrib();
}
void Renderer::renderComboBox(GraphicComboBox *comboBox) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
if(comboBox->getVisible() == false) {
return;
}
int x= comboBox->getX();
int y= comboBox->getY();
int h= comboBox->getH();
int w= comboBox->getW();
if(h>0){
//background
glPushAttrib(GL_ENABLE_BIT | GL_CURRENT_BIT);
glEnable(GL_BLEND);
glColor4f(0.0f, 0.0f, 0.0f, 0.6f*comboBox->getFade()) ;
glBegin(GL_TRIANGLE_STRIP);
glVertex2i(x, y);
glVertex2i(x, y+h);
glVertex2i(x+w, y);
glVertex2i(x+w, y+h);
glEnd();
glPopAttrib();
}
renderButton(comboBox->getButton());
if( comboBox->isDropDownShowing()){
renderScrollBar(comboBox->getScrollbar());
if(comboBox->getPopupButtons()->size() != 0) {
for(int i = comboBox->getScrollbar()->getVisibleStart();
i <= comboBox->getScrollbar()->getVisibleEnd(); ++i) {
renderButton((* comboBox->getPopupButtons())[i]);
}
}
}
glPushAttrib(GL_ENABLE_BIT);
glEnable(GL_BLEND);
GraphicLabel label("ComboBox_render_label","label",false);
//label.setInstanceName("ComboBox_render_label");
label.init(comboBox->getX(), comboBox->getY(), comboBox->getW(), comboBox->getH(), true,comboBox->getTextColor());
label.setText(comboBox->getText());
label.setTextNativeTranslation(comboBox->getTextNativeTranslation());
label.setFont(comboBox->getFont());
label.setFont3D(comboBox->getFont3D());
renderLabel(&label);
//lighting
bool renderLighted= (comboBox->getLighted());
if(renderLighted) {
float anim= GraphicComponent::getAnim();
if(anim>0.5f) anim= 1.f-anim;
Vec3f color=comboBox->getTextColor();
int x= comboBox->getX()+comboBox->getButton()->getW();
int y= comboBox->getY();
int h= comboBox->getH();
int w= comboBox->getW()-comboBox->getButton()->getW();
const int lightSize= 0;
const Vec4f color1= Vec4f(color.x, color.y, color.z, 0.1f+anim*0.5f);
const Vec4f color2= Vec4f(color.x, color.y, color.z, 0.3f+anim);
glBegin(GL_TRIANGLE_FAN);
glColor4fv(color2.ptr());
glVertex2f(x+w/2, y+h/2);
glColor4fv(color1.ptr());
glVertex2f(x-lightSize, y-lightSize);
glColor4fv(color1.ptr());
glVertex2f(x+w+lightSize, y-lightSize);
glColor4fv(color1.ptr());
glVertex2f(x+w+lightSize, y+h+lightSize);
glColor4fv(color1.ptr());
glVertex2f(x+w+lightSize, y+h+lightSize);
glColor4fv(color1.ptr());
glVertex2f(x-lightSize, y+h+lightSize);
glColor4fv(color1.ptr());
glVertex2f(x-lightSize, y-lightSize);
glEnd();
}
glPopAttrib();
}
void Renderer::renderMessageBox(GraphicMessageBox *messageBox) {
const int headerHeight=25;
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
try {
if(messageBox->getVisible() == false) {
return;
}
if((renderText3DEnabled == false && messageBox->getFont() == NULL) ||
(renderText3DEnabled == true && messageBox->getFont3D() == NULL)) {
messageBox->setFont(CoreData::getInstance().getMenuFontNormal());
messageBox->setFont3D(CoreData::getInstance().getMenuFontNormal3D());
}
string wrappedText = messageBox->getText();
if(messageBox->getAutoWordWrap() == true) {
if(renderText3DEnabled == false) {
wrappedText = messageBox->getFont()->getMetrics()->wordWrapText(wrappedText,messageBox->getW() * 0.90);
}
else {
wrappedText = messageBox->getFont3D()->getMetrics()->wordWrapText(wrappedText,messageBox->getW() * 0.90);
}
}
//background
glPushAttrib(GL_ENABLE_BIT | GL_CURRENT_BIT);
glEnable(GL_BLEND);
glColor4f(0.0f, 0.0f, 0.0f, 0.8f) ;
glBegin(GL_TRIANGLE_STRIP);
glVertex2i(messageBox->getX(), messageBox->getY()+messageBox->getH()-headerHeight);
glVertex2i(messageBox->getX(), messageBox->getY());
glVertex2i(messageBox->getX() + messageBox->getW(), messageBox->getY() + messageBox->getH()-headerHeight);
glVertex2i(messageBox->getX() + messageBox->getW(), messageBox->getY());
glEnd();
glColor4f(0.0f, 0.0f, 0.0f, 0.8f) ;
glBegin(GL_TRIANGLE_STRIP);
glVertex2i(messageBox->getX(), messageBox->getY()+messageBox->getH());
glVertex2i(messageBox->getX(), messageBox->getY()+messageBox->getH()-headerHeight);
glVertex2i(messageBox->getX() + messageBox->getW(), messageBox->getY() + messageBox->getH());
glVertex2i(messageBox->getX() + messageBox->getW(), messageBox->getY()+messageBox->getH()-headerHeight);
glEnd();
glBegin(GL_LINE_LOOP);
glColor4f(0.5f, 0.5f, 0.5f, 0.25f) ;
glVertex2i(messageBox->getX(), messageBox->getY());
glColor4f(0.0f, 0.0f, 0.0f, 0.25f) ;
glVertex2i(messageBox->getX()+ messageBox->getW(), messageBox->getY());
glColor4f(0.5f, 0.5f, 0.5f, 0.25f) ;
glVertex2i(messageBox->getX()+ messageBox->getW(), messageBox->getY() + messageBox->getH());
glColor4f(0.25f, 0.25f, 0.25f, 0.25f) ;
glVertex2i(messageBox->getX(), messageBox->getY() + messageBox->getH());
glEnd();
glBegin(GL_LINE_STRIP);
glColor4f(1.0f, 1.0f, 1.0f, 0.25f) ;
glVertex2i(messageBox->getX(), messageBox->getY() + messageBox->getH()-headerHeight);
glColor4f(0.5f, 0.5f, 0.5f, 0.25f) ;
glVertex2i(messageBox->getX()+ messageBox->getW(), messageBox->getY() + messageBox->getH()-headerHeight);
glEnd();
glPopAttrib();
//buttons
for(int i=0; i<messageBox->getButtonCount();i++){
if((renderText3DEnabled == false && messageBox->getButton(i)->getFont() == NULL) ||
(renderText3DEnabled == true && messageBox->getButton(i)->getFont3D() == NULL)) {
messageBox->getButton(i)->setFont(CoreData::getInstance().getMenuFontNormal());
messageBox->getButton(i)->setFont3D(CoreData::getInstance().getMenuFontNormal3D());
}
renderButton(messageBox->getButton(i));
}
Vec4f fontColor;
//if(game!=NULL){
// fontColor=game->getGui()->getDisplay()->getColor();
//}
//else {
// white shadowed is default ( in the menu for example )
fontColor=Vec4f(1.f, 1.f, 1.f, 1.0f);
//}
if(renderText3DEnabled == true) {
//text
renderTextShadow3D(
wrappedText, messageBox->getFont3D(), fontColor,
messageBox->getX()+15, messageBox->getY()+messageBox->getH()-headerHeight*2,
false );
renderTextShadow3D(
messageBox->getHeader(), messageBox->getFont3D(),fontColor,
messageBox->getX()+15, messageBox->getY()+messageBox->getH()-headerHeight+8,
false );
}
else {
//text
renderTextShadow(
wrappedText, messageBox->getFont(), fontColor,
messageBox->getX()+15, messageBox->getY()+messageBox->getH()-headerHeight*2,
false );
renderTextShadow(
messageBox->getHeader(), messageBox->getFont(),fontColor,
messageBox->getX()+15, messageBox->getY()+messageBox->getH()-headerHeight+8,
false );
}
}
catch(const exception &e) {
char szBuf[8096]="";
snprintf(szBuf,8096,"In [%s::%s Line: %d]\nError [%s]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,e.what());
SystemFlags::OutputDebug(SystemFlags::debugError,szBuf);
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,szBuf);
throw megaglest_runtime_error(szBuf);
}
}
// ==================== complex rendering ====================
//VisibleQuadContainerVBOCache * Renderer::GetSurfaceVBOs(SurfaceData *cellData) {
// std::map<uint32,VisibleQuadContainerVBOCache >::iterator iterFind = mapSurfaceVBOCache.find(cellData->uniqueId);
// if(iterFind == mapSurfaceVBOCache.end()) {
// Vec2f *texCoords = &cellData->texCoords[0];
// Vec2f *texCoordsSurface = &cellData->texCoordsSurface[0];
// Vec3f *vertices = &cellData->vertices[0];
// Vec3f *normals = &cellData->normals[0];
//
// VisibleQuadContainerVBOCache vboCache;
//
// // Generate And Bind The Vertex Buffer
// glGenBuffersARB( 1, (GLuint*)&vboCache.m_nVBOVertices ); // Get A Valid Name
// glBindBufferARB( GL_ARRAY_BUFFER_ARB, vboCache.m_nVBOVertices ); // Bind The Buffer
// // Load The Data
// glBufferDataARB( GL_ARRAY_BUFFER_ARB, sizeof(Vec3f) * cellData->bufferCount, vertices, GL_STATIC_DRAW_ARB );
// glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
//
// assertGl();
// // Generate And Bind The Texture Coordinate Buffer
// glGenBuffersARB( 1, (GLuint*)&vboCache.m_nVBOFowTexCoords ); // Get A Valid Name
// glBindBufferARB( GL_ARRAY_BUFFER_ARB, vboCache.m_nVBOFowTexCoords ); // Bind The Buffer
// // Load The Data
// glBufferDataARB( GL_ARRAY_BUFFER_ARB, sizeof(Vec2f) * cellData->bufferCount, texCoords, GL_STATIC_DRAW_ARB );
// glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
//
// assertGl();
// // Generate And Bind The Texture Coordinate Buffer
// glGenBuffersARB( 1, (GLuint*)&vboCache.m_nVBOSurfaceTexCoords ); // Get A Valid Name
// glBindBufferARB( GL_ARRAY_BUFFER_ARB, vboCache.m_nVBOSurfaceTexCoords ); // Bind The Buffer
// // Load The Data
// glBufferDataARB( GL_ARRAY_BUFFER_ARB, sizeof(Vec2f) * cellData->bufferCount, texCoordsSurface, GL_STATIC_DRAW_ARB );
// glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
//
// assertGl();
// // Generate And Bind The Normal Buffer
// glGenBuffersARB( 1, (GLuint*)&vboCache.m_nVBONormals ); // Get A Valid Name
// glBindBufferARB( GL_ARRAY_BUFFER_ARB, vboCache.m_nVBONormals ); // Bind The Buffer
// // Load The Data
// glBufferDataARB( GL_ARRAY_BUFFER_ARB, sizeof(Vec3f) * cellData->bufferCount, normals, GL_STATIC_DRAW_ARB );
// glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
//
// vboCache.hasBuiltVBOs = true;
//
// mapSurfaceVBOCache[cellData->uniqueId] = vboCache;
//
// // don't need the data in computer RAM anymore its in the GPU now
// cellData->texCoords.clear();
// cellData->texCoordsSurface.clear();
// cellData->vertices.clear();
// cellData->normals.clear();
// }
//
// return &mapSurfaceVBOCache[cellData->uniqueId];
//}
void Renderer::ReleaseSurfaceVBOs() {
for(std::map<uint32,VisibleQuadContainerVBOCache>::iterator iterFind = mapSurfaceVBOCache.begin();
iterFind != mapSurfaceVBOCache.end(); ++iterFind) {
VisibleQuadContainerVBOCache &item = iterFind->second;
if(item.hasBuiltVBOs == true) {
glDeleteBuffersARB( 1, (GLuint*)&item.m_nVBOVertices ); // Get A Valid Name
glDeleteBuffersARB( 1, (GLuint*)&item.m_nVBOFowTexCoords ); // Get A Valid Name
glDeleteBuffersARB( 1, (GLuint*)&item.m_nVBOSurfaceTexCoords ); // Get A Valid Name
glDeleteBuffersARB( 1, (GLuint*)&item.m_nVBONormals ); // Get A Valid Name
//glDeleteBuffersARB( 1, &item.m_nVBOIndexes ); // Get A Valid Name
}
}
mapSurfaceVBOCache.clear();
}
Renderer::MapRenderer::Layer::~Layer() {
if(vbo_vertices) glDeleteBuffersARB(1,&vbo_vertices);
if(vbo_normals) glDeleteBuffersARB(1,&vbo_normals);
if(vbo_fowTexCoords) glDeleteBuffersARB(1,&vbo_fowTexCoords);
if(vbo_surfTexCoords) glDeleteBuffersARB(1,&vbo_surfTexCoords);
if(vbo_indices) glDeleteBuffersARB(1,&vbo_indices);
}
template<typename T> void _loadVBO(GLuint &vbo,std::vector<T> buf,int target=GL_ARRAY_BUFFER_ARB) {
assert(buf.size());
if(true /* vbo enabled? */) {
glGenBuffersARB(1,&vbo);
assert(vbo);
glBindBufferARB(target,vbo);
glBufferDataARB(target,sizeof(T)*buf.size(),&buf[0],GL_STATIC_DRAW_ARB);
glBindBufferARB(target,0);
assertGl();
buf.clear();
}
}
void Renderer::MapRenderer::Layer::load_vbos(bool vboEnabled) {
indexCount = (int)indices.size();
if(vboEnabled) {
_loadVBO(vbo_vertices,vertices);
_loadVBO(vbo_normals,normals);
_loadVBO(vbo_fowTexCoords,fowTexCoords);
_loadVBO(vbo_surfTexCoords,surfTexCoords);
_loadVBO(vbo_indices,indices,GL_ELEMENT_ARRAY_BUFFER_ARB);
}
else {
vbo_vertices = 0;
vbo_normals = 0;
vbo_fowTexCoords = 0;
vbo_surfTexCoords = 0;
vbo_indices = 0;
}
}
void Renderer::MapRenderer::loadVisibleLayers(float coordStep,VisibleQuadContainerCache &qCache) {
int totalCellCount = 0;
// we create a layer for each visible texture in the map
for(int visibleIndex = 0;
visibleIndex < (int)qCache.visibleScaledCellList.size(); ++visibleIndex) {
Vec2i &pos = qCache.visibleScaledCellList[visibleIndex];
totalCellCount++;
SurfaceCell *tc00= map->getSurfaceCell(pos.x, pos.y);
SurfaceCell *tc10= map->getSurfaceCell(pos.x+1, pos.y);
SurfaceCell *tc01= map->getSurfaceCell(pos.x, pos.y+1);
SurfaceCell *tc11= map->getSurfaceCell(pos.x+1, pos.y+1);
const Vec2f &surfCoord= tc00->getSurfTexCoord();
SurfaceCell *tc[4] = {
tc00,
tc10,
tc01,
tc11
};
int textureHandle = static_cast<const Texture2DGl*>(tc[0]->getSurfaceTexture())->getHandle();
string texturePath = static_cast<const Texture2DGl*>(tc[0]->getSurfaceTexture())->getPath();
//int32 textureCRC = CalculatePixelsCRC(static_cast<const Texture2DGl*>(tc[0]->getSurfaceTexture()));
Layer* layer = NULL;
for(Layers::iterator it= layers.begin(); it!= layers.end(); ++it) {
if((*it)->textureHandle == textureHandle) {
//if((*it)->texturePath == texturePath) {
//if((*it)->textureCRC == textureCRC) {
layer = *it;
break;
}
}
if(!layer) {
layer = new Layer(textureHandle);
layer->texturePath = texturePath;
//layer->textureCRC = textureCRC;
layers.push_back(layer);
//printf("Ading new unique texture [%s]\n",texturePath.c_str());
}
// we'll be super-lazy and re-emit all four corners just because its easier
int index[4];
int loopIndexes[4] = { 2,0,3,1 };
for(int i=0; i < 4; i++) {
index[i] = (int)layer->vertices.size();
SurfaceCell *corner = tc[loopIndexes[i]];
layer->vertices.push_back(corner->getVertex());
layer->normals.push_back(corner->getNormal());
layer->fowTexCoords.push_back(corner->getFowTexCoord());
}
layer->surfTexCoords.push_back(Vec2f(surfCoord.x, surfCoord.y + coordStep));
layer->surfTexCoords.push_back(Vec2f(surfCoord.x, surfCoord.y));
layer->surfTexCoords.push_back(Vec2f(surfCoord.x+coordStep, surfCoord.y+coordStep));
layer->surfTexCoords.push_back(Vec2f(surfCoord.x+coordStep, surfCoord.y));
// and make two triangles (no strip, we may be disjoint)
layer->indices.push_back(index[0]);
layer->indices.push_back(index[1]);
layer->indices.push_back(index[2]);
layer->indices.push_back(index[1]);
layer->indices.push_back(index[3]);
layer->indices.push_back(index[2]);
}
// turn them into vbos (actually this method will just calc the index count)
for(Layers::iterator layer= layers.begin(); layer!= layers.end(); ++layer){
(*layer)->load_vbos(false);
}
//printf("Total # of layers for this map = %d totalCellCount = %d overall render reduction ratio = %d times\n",layers.size(),totalCellCount,(totalCellCount / layers.size()));
}
void Renderer::MapRenderer::load(float coordStep) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
int totalCellCount = 0;
// we create a layer for each texture in the map
for(int y=0; y<map->getSurfaceH()-1; y++) {
for(int x=0; x<map->getSurfaceW()-1; x++) {
totalCellCount++;
SurfaceCell *tc[4] = {
map->getSurfaceCell(x,y),
map->getSurfaceCell(x+1,y),
map->getSurfaceCell(x,y+1),
map->getSurfaceCell(x+1,y+1)
};
int textureHandle = static_cast<const Texture2DGl*>(tc[0]->getSurfaceTexture())->getHandle();
string texturePath = static_cast<const Texture2DGl*>(tc[0]->getSurfaceTexture())->getPath();
//int32 textureCRC = CalculatePixelsCRC(static_cast<const Texture2DGl*>(tc[0]->getSurfaceTexture()));
Layer* layer = NULL;
for(Layers::iterator it= layers.begin(); it!= layers.end(); ++it) {
if((*it)->textureHandle == textureHandle) {
//if((*it)->texturePath == texturePath) {
//if((*it)->textureCRC == textureCRC) {
layer = *it;
break;
}
}
if(!layer) {
layer = new Layer(textureHandle);
layer->texturePath = texturePath;
//layer->textureCRC = textureCRC;
layers.push_back(layer);
//printf("Ading new unique texture [%s]\n",texturePath.c_str());
}
// we'll be super-lazy and re-emit all four corners just because its easier
int index[4];
int loopIndexes[4] = { 2,0,3,1 };
for(int i=0; i < 4; i++) {
index[i] = (int)layer->vertices.size();
SurfaceCell *corner = tc[loopIndexes[i]];
layer->vertices.push_back(corner->getVertex());
layer->normals.push_back(corner->getNormal());
}
// the texture coords are all on the current texture obviously
layer->fowTexCoords.push_back(tc[loopIndexes[0]]->getFowTexCoord());
layer->fowTexCoords.push_back(tc[loopIndexes[1]]->getFowTexCoord());
layer->fowTexCoords.push_back(tc[loopIndexes[2]]->getFowTexCoord());
layer->fowTexCoords.push_back(tc[loopIndexes[3]]->getFowTexCoord());
layer->surfTexCoords.push_back(tc[0]->getSurfTexCoord()+Vec2f(0,coordStep));
layer->surfTexCoords.push_back(tc[0]->getSurfTexCoord()+Vec2f(0,0));
layer->surfTexCoords.push_back(tc[0]->getSurfTexCoord()+Vec2f(coordStep,coordStep));
layer->surfTexCoords.push_back(tc[0]->getSurfTexCoord()+Vec2f(coordStep,0));
layer->cellToIndicesMap[Vec2i(x,y)] = (int)layer->indices.size();
// and make two triangles (no strip, we may be disjoint)
layer->indices.push_back(index[0]);
layer->indices.push_back(index[1]);
layer->indices.push_back(index[2]);
layer->indices.push_back(index[1]);
layer->indices.push_back(index[3]);
layer->indices.push_back(index[2]);
}
}
// turn them into vbos
for(Layers::iterator layer= layers.begin(); layer!= layers.end(); ++layer){
(*layer)->load_vbos(true);
}
//printf("Total # of layers for this map = %d totalCellCount = %d overall render reduction ratio = %d times\n",layers.size(),totalCellCount,(totalCellCount / layers.size()));
}
template<typename T> void* _bindVBO(GLuint vbo,std::vector<T> &buf,int target=GL_ARRAY_BUFFER_ARB) {
void* result = NULL;
if(vbo) {
glBindBuffer(target,vbo);
}
else {
result = &buf[0];
}
return result;
}
void Renderer::MapRenderer::Layer::renderVisibleLayer() {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
//glBindTexture(GL_TEXTURE_2D, static_cast<const Texture2DGl*>(fowTex)->getHandle());
glClientActiveTexture(Renderer::fowTexUnit);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, 0,&fowTexCoords[0]);
glBindTexture(GL_TEXTURE_2D, textureHandle);
glClientActiveTexture(Renderer::baseTexUnit);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, 0, &surfTexCoords[0]);
glVertexPointer(3, GL_FLOAT, 0, &vertices[0]);
glNormalPointer(GL_FLOAT, 0, &normals[0]);
//glDrawArrays(GL_TRIANGLE_STRIP, 0, vertices.size());
//unsigned short faceIndices[4] = {0, 1, 2, 3};
//glDrawElements(GL_TRIANGLE_STRIP, 4, GL_UNSIGNED_SHORT, &faceIndices[0]);
glDrawElements(GL_TRIANGLES,indexCount,GL_UNSIGNED_INT,&indices[0]);
glClientActiveTexture(Renderer::fowTexUnit);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glClientActiveTexture(Renderer::baseTexUnit);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
void Renderer::MapRenderer::Layer::render(VisibleQuadContainerCache &qCache) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
// const bool renderOnlyVisibleQuad = true;
//
// if(renderOnlyVisibleQuad == true) {
vector<pair<int,int> > rowsToRender;
if(rowsToRenderCache.find(qCache.lastVisibleQuad) != rowsToRenderCache.end()) {
rowsToRender = rowsToRenderCache[qCache.lastVisibleQuad];
}
else {
int startIndex = -1;
int lastValidIndex = -1;
for(int visibleIndex = 0;
visibleIndex < (int)qCache.visibleScaledCellList.size(); ++visibleIndex) {
Vec2i &pos = qCache.visibleScaledCellList[visibleIndex];
if(cellToIndicesMap.find(pos) != cellToIndicesMap.end()) {
//printf("Layer Render, visibleindex = %d pos [%s] cellToIndicesMap[pos] = %d lastValidIndex = %d\n",visibleIndex,pos.getString().c_str(),cellToIndicesMap[pos],lastValidIndex);
if(startIndex < 0 || cellToIndicesMap[pos] == lastValidIndex + 6) {
lastValidIndex = cellToIndicesMap[pos];
if(startIndex < 0) {
startIndex = lastValidIndex;
}
}
else if(startIndex >= 0) {
rowsToRender.push_back(make_pair(startIndex,lastValidIndex));
lastValidIndex = cellToIndicesMap[pos];
startIndex = lastValidIndex;
}
}
}
if(startIndex >= 0) {
rowsToRender.push_back(make_pair(startIndex,lastValidIndex));
}
rowsToRenderCache[qCache.lastVisibleQuad] = rowsToRender;
}
if(rowsToRender.empty() == false) {
//printf("Layer has %d rows in visible quad, visible quad has %d cells\n",rowsToRender.size(),qCache.visibleScaledCellList.size());
glVertexPointer(3,GL_FLOAT,0,_bindVBO(vbo_vertices,vertices));
glNormalPointer(GL_FLOAT,0,_bindVBO(vbo_normals,normals));
glClientActiveTexture(Renderer::fowTexUnit);
glTexCoordPointer(2,GL_FLOAT,0,_bindVBO(vbo_fowTexCoords,fowTexCoords));
glClientActiveTexture(Renderer::baseTexUnit);
glBindTexture(GL_TEXTURE_2D,textureHandle);
glTexCoordPointer(2,GL_FLOAT,0,_bindVBO(vbo_surfTexCoords,surfTexCoords));
for(unsigned int i = 0; i < rowsToRender.size(); ++i) {
//glDrawElements(GL_TRIANGLES,indexCount,GL_UNSIGNED_INT,_bindVBO(vbo_indices,indices,GL_ELEMENT_ARRAY_BUFFER_ARB));
glDrawRangeElements(GL_TRIANGLES,rowsToRender[i].first,rowsToRender[i].second,indexCount,GL_UNSIGNED_INT,_bindVBO(vbo_indices,indices,GL_ELEMENT_ARRAY_BUFFER_ARB));
}
}
// }
// else {
// glVertexPointer(3,GL_FLOAT,0,_bindVBO(vbo_vertices,vertices));
// glNormalPointer(GL_FLOAT,0,_bindVBO(vbo_normals,normals));
//
// glClientActiveTexture(Renderer::fowTexUnit);
// glTexCoordPointer(2,GL_FLOAT,0,_bindVBO(vbo_fowTexCoords,fowTexCoords));
//
// glClientActiveTexture(Renderer::baseTexUnit);
// glBindTexture(GL_TEXTURE_2D,textureHandle);
// glTexCoordPointer(2,GL_FLOAT,0,_bindVBO(vbo_surfTexCoords,surfTexCoords));
//
// glDrawElements(GL_TRIANGLES,indexCount,GL_UNSIGNED_INT,_bindVBO(vbo_indices,indices,GL_ELEMENT_ARRAY_BUFFER_ARB));
// }
}
void Renderer::MapRenderer::renderVisibleLayers(const Map* map,float coordStep,VisibleQuadContainerCache &qCache) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
if(map != this->map) {
//printf("New Map loading\n");
destroy(); // clear any previous map data
this->map = map;
loadVisibleLayers(coordStep,qCache);
}
else if(lastVisibleQuad != qCache.lastVisibleQuad) {
//printf("New Visible Quad loading\n");
destroy(); // clear any previous map data
this->map = map;
loadVisibleLayers(coordStep,qCache);
}
lastVisibleQuad = qCache.lastVisibleQuad;
//printf("About to render %d layers\n",layers.size());
glClientActiveTexture(fowTexUnit);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glClientActiveTexture(baseTexUnit);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
for(Layers::iterator layer= layers.begin(); layer!= layers.end(); ++layer)
(*layer)->renderVisibleLayer();
glDisableClientState(GL_VERTEX_ARRAY);
glBindBuffer(GL_ARRAY_BUFFER_ARB,0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB,0);
glDisableClientState(GL_NORMAL_ARRAY);
glClientActiveTexture(fowTexUnit);
glBindTexture(GL_TEXTURE_2D,0);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glClientActiveTexture(baseTexUnit);
glBindTexture(GL_TEXTURE_2D,0);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
assertGl();
}
void Renderer::MapRenderer::render(const Map* map,float coordStep,VisibleQuadContainerCache &qCache) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
if(map != this->map) {
destroy(); // clear any previous map data
this->map = map;
load(coordStep);
}
//printf("About to render %d layers\n",layers.size());
glClientActiveTexture(fowTexUnit);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glClientActiveTexture(baseTexUnit);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
for(Layers::iterator layer= layers.begin(); layer!= layers.end(); ++layer)
(*layer)->render(qCache);
glDisableClientState(GL_VERTEX_ARRAY);
glBindBuffer(GL_ARRAY_BUFFER_ARB,0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB,0);
glDisableClientState(GL_NORMAL_ARRAY);
glClientActiveTexture(fowTexUnit);
glBindTexture(GL_TEXTURE_2D,0);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glClientActiveTexture(baseTexUnit);
glBindTexture(GL_TEXTURE_2D,0);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
assertGl();
}
void Renderer::MapRenderer::destroy() {
while(layers.empty() == false) {
delete layers.back();
layers.pop_back();
}
map = NULL;
}
void Renderer::renderSurface(const int renderFps) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
IF_DEBUG_EDITION(
if (getDebugRenderer().willRenderSurface()) {
getDebugRenderer().renderSurface(visibleQuad / Map::cellScale);
} else {
)
assertGl();
const World *world= game->getWorld();
const Map *map= world->getMap();
float coordStep= world->getTileset()->getSurfaceAtlas()->getCoordStep();
const Texture2D *fowTex= world->getMinimap()->getFowTexture();
if(fowTex == NULL) {
return;
}
glPushAttrib(GL_LIGHTING_BIT | GL_ENABLE_BIT | GL_FOG_BIT | GL_TEXTURE_BIT);
glEnable(GL_BLEND);
glEnable(GL_COLOR_MATERIAL);
glDisable(GL_ALPHA_TEST);
glEnable(GL_CULL_FACE);
//fog of war tex unit
glActiveTexture(fowTexUnit);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, static_cast<const Texture2DGl*>(fowTex)->getHandle());
glTexSubImage2D(
GL_TEXTURE_2D, 0, 0, 0,
fowTex->getPixmapConst()->getW(), fowTex->getPixmapConst()->getH(),
GL_ALPHA, GL_UNSIGNED_BYTE, fowTex->getPixmapConst()->getPixels());
if(shadowsOffDueToMinRender == false) {
//shadow texture
if(shadows == sProjected || shadows == sShadowMapping) {
glActiveTexture(shadowTexUnit);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, shadowMapHandle);
static_cast<ModelRendererGl*>(modelRenderer)->setDuplicateTexCoords(true);
enableProjectiveTexturing();
}
}
const Rect2i mapBounds(0, 0, map->getSurfaceW()-1, map->getSurfaceH()-1);
glActiveTexture(baseTexUnit);
VisibleQuadContainerCache &qCache = getQuadCache();
bool useVBORendering = getVBOSupported();
if(useVBORendering == true) {
VisibleQuadContainerCache &qCache = getQuadCache();
//mapRenderer.render(map,coordStep,qCache);
mapRenderer.renderVisibleLayers(map,coordStep,qCache);
}
else if(qCache.visibleScaledCellList.empty() == false) {
int lastTex=-1;
//int currTex=-1;
//Quad2i snapshotOfvisibleQuad = visibleQuad;
//bool useVertexArrayRendering = getVBOSupported();
//bool useVertexArrayRendering = false;
//if(useVertexArrayRendering == false) {
//printf("\LEGACY qCache.visibleScaledCellList.size() = %d \n",qCache.visibleScaledCellList.size());
Vec2f texCoords[4];
Vec2f texCoordsSurface[4];
Vec3f vertices[4];
Vec3f normals[4];
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
std::map<int,int> uniqueVisibleTextures;
for(int visibleIndex = 0;
visibleIndex < (int)qCache.visibleScaledCellList.size(); ++visibleIndex) {
Vec2i &pos = qCache.visibleScaledCellList[visibleIndex];
SurfaceCell *tc00= map->getSurfaceCell(pos.x, pos.y);
int cellTex= static_cast<const Texture2DGl*>(tc00->getSurfaceTexture())->getHandle();
uniqueVisibleTextures[cellTex]++;
}
//printf("Current renders = %d possible = %d\n",qCache.visibleScaledCellList.size(),uniqueVisibleTextures.size());
for(int visibleIndex = 0;
visibleIndex < (int)qCache.visibleScaledCellList.size(); ++visibleIndex) {
Vec2i &pos = qCache.visibleScaledCellList[visibleIndex];
SurfaceCell *tc00= map->getSurfaceCell(pos.x, pos.y);
SurfaceCell *tc10= map->getSurfaceCell(pos.x+1, pos.y);
SurfaceCell *tc01= map->getSurfaceCell(pos.x, pos.y+1);
SurfaceCell *tc11= map->getSurfaceCell(pos.x+1, pos.y+1);
if(tc00 == NULL) {
throw megaglest_runtime_error("tc00 == NULL");
}
if(tc10 == NULL) {
throw megaglest_runtime_error("tc10 == NULL");
}
if(tc01 == NULL) {
throw megaglest_runtime_error("tc01 == NULL");
}
if(tc11 == NULL) {
throw megaglest_runtime_error("tc11 == NULL");
}
triangleCount+= 2;
pointCount+= 4;
//set texture
if(tc00->getSurfaceTexture() == NULL) {
throw megaglest_runtime_error("tc00->getSurfaceTexture() == NULL");
}
int currTex= static_cast<const Texture2DGl*>(tc00->getSurfaceTexture())->getHandle();
if(currTex != lastTex) {
lastTex = currTex;
//glBindTexture(GL_TEXTURE_2D, lastTex);
}
const Vec2f &surfCoord= tc00->getSurfTexCoord();
texCoords[0] = tc01->getFowTexCoord();
texCoordsSurface[0] = Vec2f(surfCoord.x, surfCoord.y + coordStep);
vertices[0] = tc01->getVertex();
normals[0] = tc01->getNormal();;
texCoords[1] = tc00->getFowTexCoord();
texCoordsSurface[1] = Vec2f(surfCoord.x, surfCoord.y);
vertices[1] = tc00->getVertex();
normals[1] = tc00->getNormal();
texCoords[2] = tc11->getFowTexCoord();
texCoordsSurface[2] = Vec2f(surfCoord.x+coordStep, surfCoord.y+coordStep);
vertices[2] = tc11->getVertex();
normals[2] = tc11->getNormal();
texCoords[3] = tc10->getFowTexCoord();
texCoordsSurface[3] = Vec2f(surfCoord.x+coordStep, surfCoord.y);
vertices[3] = tc10->getVertex();
normals[3] = tc10->getNormal();
//glBindTexture(GL_TEXTURE_2D, static_cast<const Texture2DGl*>(fowTex)->getHandle());
glClientActiveTexture(fowTexUnit);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, 0,&texCoords[0]);
glBindTexture(GL_TEXTURE_2D, lastTex);
glClientActiveTexture(baseTexUnit);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, 0, &texCoordsSurface[0]);
glVertexPointer(3, GL_FLOAT, 0, &vertices[0]);
glNormalPointer(GL_FLOAT, 0, &normals[0]);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
//unsigned short faceIndices[4] = {0, 1, 2, 3};
//glDrawElements(GL_TRIANGLE_STRIP, 4, GL_UNSIGNED_SHORT, &faceIndices[0]);
glClientActiveTexture(fowTexUnit);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glClientActiveTexture(baseTexUnit);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
/*
glBegin(GL_TRIANGLE_STRIP);
//draw quad using immediate mode
glMultiTexCoord2fv(fowTexUnit, tc01->getFowTexCoord().ptr());
glMultiTexCoord2f(baseTexUnit, surfCoord.x, surfCoord.y + coordStep);
glNormal3fv(tc01->getNormal().ptr());
glVertex3fv(tc01->getVertex().ptr());
glMultiTexCoord2fv(fowTexUnit, tc00->getFowTexCoord().ptr());
glMultiTexCoord2f(baseTexUnit, surfCoord.x, surfCoord.y);
glNormal3fv(tc00->getNormal().ptr());
glVertex3fv(tc00->getVertex().ptr());
glMultiTexCoord2fv(fowTexUnit, tc11->getFowTexCoord().ptr());
glMultiTexCoord2f(baseTexUnit, surfCoord.x+coordStep, surfCoord.y+coordStep);
glNormal3fv(tc11->getNormal().ptr());
glVertex3fv(tc11->getVertex().ptr());
glMultiTexCoord2fv(fowTexUnit, tc10->getFowTexCoord().ptr());
glMultiTexCoord2f(baseTexUnit, surfCoord.x + coordStep, surfCoord.y);
glNormal3fv(tc10->getNormal().ptr());
glVertex3fv(tc10->getVertex().ptr());
glEnd();
*/
}
glDisableClientState(GL_NORMAL_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
// }
// else {
// const bool useVBOs = false;
// const bool useSurfaceCache = false;
//
// std::vector<SurfaceData> surfaceData;
// bool recalcSurface = false;
//
// if(useSurfaceCache == true) {
// std::map<string,std::pair<Chrono, std::vector<SurfaceData> > >::iterator iterFind = mapSurfaceData.find(snapshotOfvisibleQuad.getString());
// if(iterFind == mapSurfaceData.end()) {
// recalcSurface = true;
// //printf("#1 Calculating surface for Rendering using VA's [%s]\n",snapshotOfvisibleQuad.getString().c_str());
// }
///*
// else if(iterFind->second.first.getMillis() >= 250) {
// recalcSurface = true;
// mapSurfaceData.erase(snapshotOfvisibleQuad.getString());
// //printf("#2 RE-Calculating surface for Rendering using VA's [%s]\n",snapshotOfvisibleQuad.getString().c_str());
// }
//*/
// }
// else {
// recalcSurface = true;
// }
//
// if(recalcSurface == true) {
// //printf("Calculating surface for Rendering using VA's [%s]\n",snapshotOfvisibleQuad.getString().c_str());
//
// std::vector<SurfaceData> *surface = &surfaceData;
// if(useSurfaceCache == true) {
// std::pair<Chrono, std::vector<SurfaceData> > &surfaceCacheEntity = mapSurfaceData[snapshotOfvisibleQuad.getString()];
// surface = &surfaceCacheEntity.second;
// //surface.reserve(qCache.visibleScaledCellList.size());
// }
// surface->reserve(qCache.visibleScaledCellList.size());
//
// int lastSurfaceDataIndex = -1;
// for(int visibleIndex = 0;
// visibleIndex < (int)qCache.visibleScaledCellList.size(); ++visibleIndex) {
// Vec2i &pos = qCache.visibleScaledCellList[visibleIndex];
//
// SurfaceCell *tc00= map->getSurfaceCell(pos.x, pos.y);
// SurfaceCell *tc10= map->getSurfaceCell(pos.x+1, pos.y);
// SurfaceCell *tc01= map->getSurfaceCell(pos.x, pos.y+1);
// SurfaceCell *tc11= map->getSurfaceCell(pos.x+1, pos.y+1);
//
// if(tc00 == NULL) {
// throw megaglest_runtime_error("tc00 == NULL");
// }
// if(tc10 == NULL) {
// throw megaglest_runtime_error("tc10 == NULL");
// }
// if(tc01 == NULL) {
// throw megaglest_runtime_error("tc01 == NULL");
// }
// if(tc11 == NULL) {
// throw megaglest_runtime_error("tc11 == NULL");
// }
//
// triangleCount+= 2;
// pointCount+= 4;
//
// //set texture
// if(tc00->getSurfaceTexture() == NULL) {
// throw megaglest_runtime_error("tc00->getSurfaceTexture() == NULL");
// }
//
// int surfaceDataIndex = -1;
// currTex= static_cast<const Texture2DGl*>(tc00->getSurfaceTexture())->getHandle();
// if(currTex != lastTex) {
// lastTex = currTex;
// }
// else {
// surfaceDataIndex = lastSurfaceDataIndex;
// }
//
// if(surfaceDataIndex < 0) {
// SurfaceData newData;
// newData.uniqueId = SurfaceData::nextUniqueId;
// SurfaceData::nextUniqueId++;
// newData.bufferCount=0;
// newData.textureHandle = currTex;
// surface->push_back(newData);
//
// surfaceDataIndex = (int)surface->size() - 1;
// }
//
// lastSurfaceDataIndex = surfaceDataIndex;
//
// SurfaceData *cellData = &(*surface)[surfaceDataIndex];
//
// const Vec2f &surfCoord= tc00->getSurfTexCoord();
//
// cellData->texCoords.push_back(tc01->getFowTexCoord());
// cellData->texCoordsSurface.push_back(Vec2f(surfCoord.x, surfCoord.y + coordStep));
// cellData->vertices.push_back(tc01->getVertex());
// cellData->normals.push_back(tc01->getNormal());
// cellData->bufferCount++;
//
// cellData->texCoords.push_back(tc00->getFowTexCoord());
// cellData->texCoordsSurface.push_back(Vec2f(surfCoord.x, surfCoord.y));
// cellData->vertices.push_back(tc00->getVertex());
// cellData->normals.push_back(tc00->getNormal());
// cellData->bufferCount++;
//
// cellData->texCoords.push_back(tc11->getFowTexCoord());
// cellData->texCoordsSurface.push_back(Vec2f(surfCoord.x+coordStep, surfCoord.y+coordStep));
// cellData->vertices.push_back(tc11->getVertex());
// cellData->normals.push_back(tc11->getNormal());
// cellData->bufferCount++;
//
// cellData->texCoords.push_back(tc10->getFowTexCoord());
// cellData->texCoordsSurface.push_back(Vec2f(surfCoord.x+coordStep, surfCoord.y));
// cellData->vertices.push_back(tc10->getVertex());
// cellData->normals.push_back(tc10->getNormal());
// cellData->bufferCount++;
// }
// }
//
// std::vector<SurfaceData> *surface = &surfaceData;
// if(useSurfaceCache == true) {
// std::pair<Chrono, std::vector<SurfaceData> > &surfaceCacheEntity = mapSurfaceData[snapshotOfvisibleQuad.getString()];
// surface = &surfaceCacheEntity.second;
// }
//
// glEnableClientState(GL_VERTEX_ARRAY);
// glEnableClientState(GL_NORMAL_ARRAY);
//
// for(int i = 0; i < (int)surface->size(); ++i) {
// SurfaceData &data = (*surface)[i];
//
// if(useVBOs == true) {
// VisibleQuadContainerVBOCache *vboCache = GetSurfaceVBOs(&data);
//
// //glBindTexture(GL_TEXTURE_2D, static_cast<const Texture2DGl*>(fowTex)->getHandle());
// glClientActiveTexture(fowTexUnit);
// glEnableClientState(GL_TEXTURE_COORD_ARRAY);
//
// glBindBufferARB( GL_ARRAY_BUFFER_ARB, vboCache->m_nVBOFowTexCoords);
// glTexCoordPointer(2, GL_FLOAT, 0,(char *) NULL);
//
// glBindTexture(GL_TEXTURE_2D, data.textureHandle);
// glClientActiveTexture(baseTexUnit);
// glEnableClientState(GL_TEXTURE_COORD_ARRAY);
//
// glBindBufferARB( GL_ARRAY_BUFFER_ARB, vboCache->m_nVBOSurfaceTexCoords);
// glTexCoordPointer(2, GL_FLOAT, 0, (char *) NULL);
//
// glBindBufferARB( GL_ARRAY_BUFFER_ARB, vboCache->m_nVBOVertices);
// glVertexPointer(3, GL_FLOAT, 0, (char *) NULL);
//
// glBindBufferARB( GL_ARRAY_BUFFER_ARB, vboCache->m_nVBONormals);
// glNormalPointer(GL_FLOAT, 0, (char *) NULL);
//
// glDrawArrays(GL_TRIANGLE_STRIP, 0, data.bufferCount);
//
// glBindBufferARB( GL_ARRAY_BUFFER_ARB, 0 );
//
// glClientActiveTexture(fowTexUnit);
// glDisableClientState(GL_TEXTURE_COORD_ARRAY);
// glClientActiveTexture(baseTexUnit);
// glDisableClientState(GL_TEXTURE_COORD_ARRAY);
//
// }
// else {
// Vec2f *texCoords = &data.texCoords[0];
// Vec2f *texCoordsSurface = &data.texCoordsSurface[0];
// Vec3f *vertices = &data.vertices[0];
// Vec3f *normals = &data.normals[0];
//
// //glBindTexture(GL_TEXTURE_2D, static_cast<const Texture2DGl*>(fowTex)->getHandle());
// glClientActiveTexture(fowTexUnit);
// glEnableClientState(GL_TEXTURE_COORD_ARRAY);
// glTexCoordPointer(2, GL_FLOAT, 0,texCoords);
//
// glBindTexture(GL_TEXTURE_2D, data.textureHandle);
// glClientActiveTexture(baseTexUnit);
// glEnableClientState(GL_TEXTURE_COORD_ARRAY);
// glTexCoordPointer(2, GL_FLOAT, 0, texCoordsSurface);
//
// glVertexPointer(3, GL_FLOAT, 0, vertices);
// glNormalPointer(GL_FLOAT, 0, normals);
//
// glDrawArrays(GL_TRIANGLE_STRIP, 0, data.bufferCount);
//
// glClientActiveTexture(fowTexUnit);
// glDisableClientState(GL_TEXTURE_COORD_ARRAY);
// glClientActiveTexture(baseTexUnit);
// glDisableClientState(GL_TEXTURE_COORD_ARRAY);
// }
// }
//
// glDisableClientState(GL_NORMAL_ARRAY);
// glDisableClientState(GL_VERTEX_ARRAY);
//
// //printf("Surface Render before [%d] after [%d]\n",qCache.visibleScaledCellList.size(),surface.size());
// }
}
//Restore
static_cast<ModelRendererGl*>(modelRenderer)->setDuplicateTexCoords(false);
glDisable(GL_TEXTURE_2D);
glPopAttrib();
//assert
GLenum glresult = glGetError(); //remove when first mtex problem solved
if(glresult) {
assertGl();
}
assertGl();
IF_DEBUG_EDITION(
} // end else, if not renderering debug textures instead of regular terrain
getDebugRenderer().renderEffects(visibleQuad / Map::cellScale);
)
}
void Renderer::renderObjects(const int renderFps) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
const World *world= game->getWorld();
//const Map *map= world->getMap();
Config &config= Config::getInstance();
int tilesetObjectsToAnimate=config.getInt("AnimatedTilesetObjects","-1");
assertGl();
const Texture2D *fowTex = world->getMinimap()->getFowTexture();
const Pixmap2D *fowTexPixmap = fowTex->getPixmapConst();
Vec3f baseFogColor = world->getTileset()->getFogColor() * world->getTimeFlow()->computeLightColor();
bool modelRenderStarted = false;
VisibleQuadContainerCache &qCache = getQuadCache();
// for(int visibleIndex = 0;
// visibleIndex < qCache.visibleObjectList.size(); ++visibleIndex) {
// render from last to first object so animated objects which are on bottom of screen are
// rendered first which looks better for limited number of animated tileset objects
for(int visibleIndex = (int)qCache.visibleObjectList.size()-1;
visibleIndex >= 0 ; --visibleIndex) {
Object *o = qCache.visibleObjectList[visibleIndex];
Model *objModel= o->getModelPtr();
//objModel->updateInterpolationData(o->getAnimProgress(), true);
const Vec3f v= o->getConstPos();
if(modelRenderStarted == false) {
modelRenderStarted = true;
glPushAttrib(GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT | GL_FOG_BIT | GL_LIGHTING_BIT | GL_TEXTURE_BIT);
if(shadowsOffDueToMinRender == false &&
shadows == sShadowMapping) {
glActiveTexture(shadowTexUnit);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, shadowMapHandle);
static_cast<ModelRendererGl*>(modelRenderer)->setDuplicateTexCoords(true);
enableProjectiveTexturing();
}
glActiveTexture(baseTexUnit);
glEnable(GL_COLOR_MATERIAL);
glAlphaFunc(GL_GREATER, 0.5f);
modelRenderer->begin(true, true, false, false);
}
//ambient and diffuse color is taken from cell color
float fowFactor= fowTexPixmap->getPixelf(o->getMapPos().x / Map::cellScale, o->getMapPos().y / Map::cellScale);
Vec4f color= Vec4f(Vec3f(fowFactor), 1.f);
glColor4fv(color.ptr());
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, (color * ambFactor).ptr());
glFogfv(GL_FOG_COLOR, (baseFogColor * fowFactor).ptr());
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glTranslatef(v.x, v.y, v.z);
glRotatef(o->getRotation(), 0.f, 1.f, 0.f);
//We use OpenGL Lights so no manual action is needed here. In fact this call did bad things on lighting big rocks for example
// if(o->getRotation() != 0.0) {
// setupLightingForRotatedModel();
// }
//objModel->updateInterpolationData(0.f, true);
//if(this->gameCamera->getPos().dist(o->getPos()) <= SKIP_INTERPOLATION_DISTANCE) {
if (tilesetObjectsToAnimate == -1) {
objModel->updateInterpolationData(o->getAnimProgress(), true);
} else if (tilesetObjectsToAnimate > 0 && o->isAnimated()) {
tilesetObjectsToAnimate--;
objModel->updateInterpolationData(o->getAnimProgress(), true);
} else {
objModel->updateInterpolationData(0, true);
}
// objModel->updateInterpolationData(o->getAnimProgress(), true);
//}
modelRenderer->render(objModel);
triangleCount+= objModel->getTriangleCount();
pointCount+= objModel->getVertexCount();
glPopMatrix();
}
if(modelRenderStarted == true) {
modelRenderer->end();
glPopAttrib();
}
//restore
static_cast<ModelRendererGl*>(modelRenderer)->setDuplicateTexCoords(true);
assertGl();
}
void Renderer::renderWater() {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
const World *world= game->getWorld();
const Map *map= world->getMap();
const Texture2D *fowTex= world->getMinimap()->getFowTexture();
if(fowTex == NULL) {
return;
}
float waterAnim= world->getWaterEffects()->getAmin();
//assert
assertGl();
glPushAttrib(GL_TEXTURE_BIT | GL_ENABLE_BIT | GL_CURRENT_BIT);
//water texture nit
glDisable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
if(textures3D) {
Texture3D *waterTex= world->getTileset()->getWaterTex();
if(waterTex == NULL) {
throw megaglest_runtime_error("waterTex == NULL");
}
glEnable(GL_TEXTURE_3D);
glBindTexture(GL_TEXTURE_3D, static_cast<Texture3DGl*>(waterTex)->getHandle());
}
else{
glEnable(GL_COLOR_MATERIAL);
glColor4f(0.5f, 0.5f, 1.0f, 0.5f);
glBindTexture(GL_TEXTURE_3D, 0);
}
assertGl();
//fog of War texture Unit
//const Texture2D *fowTex= world->getMinimap()->getFowTexture();
glActiveTexture(fowTexUnit);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, static_cast<const Texture2DGl*>(fowTex)->getHandle());
glActiveTexture(baseTexUnit);
assertGl();
int thisTeamIndex= world->getThisTeamIndex();
bool cellExplored = world->showWorldForPlayer(world->getThisFactionIndex());
bool closed= false;
Rect2i boundingRect= visibleQuad.computeBoundingRect();
Rect2i scaledRect= boundingRect/Map::cellScale;
scaledRect.clamp(0, 0, map->getSurfaceW()-1, map->getSurfaceH()-1);
float waterLevel= world->getMap()->getWaterLevel();
for(int j=scaledRect.p[0].y; j<scaledRect.p[1].y; ++j){
glBegin(GL_TRIANGLE_STRIP);
for(int i=scaledRect.p[0].x; i<=scaledRect.p[1].x; ++i){
SurfaceCell *tc0= map->getSurfaceCell(i, j);
SurfaceCell *tc1= map->getSurfaceCell(i, j+1);
if(tc0 == NULL) {
throw megaglest_runtime_error("tc0 == NULL");
}
if(tc1 == NULL) {
throw megaglest_runtime_error("tc1 == NULL");
}
if(cellExplored == false) {
cellExplored = (tc0->isExplored(thisTeamIndex) || tc1->isExplored(thisTeamIndex));
}
if(cellExplored == true && tc0->getNearSubmerged()) {
glNormal3f(0.f, 1.f, 0.f);
closed= false;
triangleCount+= 2;
pointCount+= 2;
//vertex 1
glMaterialfv(
GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE,
computeWaterColor(waterLevel, tc1->getHeight()).ptr());
glMultiTexCoord2fv(GL_TEXTURE1, tc1->getFowTexCoord().ptr());
glTexCoord3f(i, 1.f, waterAnim);
glVertex3f(
static_cast<float>(i)*Map::mapScale,
waterLevel,
static_cast<float>(j+1)*Map::mapScale);
//vertex 2
glMaterialfv(
GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE,
computeWaterColor(waterLevel, tc0->getHeight()).ptr());
glMultiTexCoord2fv(GL_TEXTURE1, tc0->getFowTexCoord().ptr());
glTexCoord3f(i, 0.f, waterAnim);
glVertex3f(
static_cast<float>(i)*Map::mapScale,
waterLevel,
static_cast<float>(j)*Map::mapScale);
}
else{
if(closed == false) {
pointCount+= 2;
//vertex 1
glMaterialfv(
GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE,
computeWaterColor(waterLevel, tc1->getHeight()).ptr());
glMultiTexCoord2fv(GL_TEXTURE1, tc1->getFowTexCoord().ptr());
glTexCoord3f(i, 1.f, waterAnim);
glVertex3f(
static_cast<float>(i)*Map::mapScale,
waterLevel,
static_cast<float>(j+1)*Map::mapScale);
//vertex 2
glMaterialfv(
GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE,
computeWaterColor(waterLevel, tc0->getHeight()).ptr());
glMultiTexCoord2fv(GL_TEXTURE1, tc0->getFowTexCoord().ptr());
glTexCoord3f(i, 0.f, waterAnim);
glVertex3f(
static_cast<float>(i)*Map::mapScale,
waterLevel,
static_cast<float>(j)*Map::mapScale);
glEnd();
glBegin(GL_TRIANGLE_STRIP);
closed= true;
}
}
}
glEnd();
}
//restore
glPopAttrib();
assertGl();
}
void Renderer::renderTeamColorCircle(){
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
VisibleQuadContainerCache &qCache = getQuadCache();
if(qCache.visibleQuadUnitList.empty() == false) {
glPushAttrib(GL_ENABLE_BIT | GL_CURRENT_BIT | GL_DEPTH_BUFFER_BIT);
glDisable(GL_LIGHTING);
glDisable(GL_TEXTURE_2D);
glDepthFunc(GL_ALWAYS);
glDisable(GL_STENCIL_TEST);
glDisable(GL_CULL_FACE);
glEnable(GL_BLEND);
glLineWidth(2.f);
for(int visibleUnitIndex = 0;
visibleUnitIndex < (int)qCache.visibleQuadUnitList.size(); ++visibleUnitIndex) {
Unit *unit = qCache.visibleQuadUnitList[visibleUnitIndex];
Vec3f currVec= unit->getCurrVectorFlat();
Vec3f color=unit->getFaction()->getTexture()->getPixmapConst()->getPixel3f(0,0);
glColor4f(color.x, color.y, color.z, 0.7f);
renderSelectionCircle(currVec, unit->getType()->getSize(), 0.8f, 0.05f);
}
glPopAttrib();
}
}
void Renderer::renderSpecialHighlightUnits(std::map<int,HighlightSpecialUnitInfo> unitHighlightList) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true || unitHighlightList.empty() == true) {
return;
}
VisibleQuadContainerCache &qCache = getQuadCache();
if(qCache.visibleQuadUnitList.empty() == false) {
glPushAttrib(GL_ENABLE_BIT | GL_CURRENT_BIT | GL_DEPTH_BUFFER_BIT);
glDisable(GL_LIGHTING);
glDisable(GL_TEXTURE_2D);
glDepthFunc(GL_ALWAYS);
glDisable(GL_STENCIL_TEST);
glDisable(GL_CULL_FACE);
glEnable(GL_BLEND);
glLineWidth(2.f);
for(int visibleUnitIndex = 0;
visibleUnitIndex < (int)qCache.visibleQuadUnitList.size(); ++visibleUnitIndex) {
Unit *unit = qCache.visibleQuadUnitList[visibleUnitIndex];
std::map<int,HighlightSpecialUnitInfo>::iterator iterFindSpecialUnit = unitHighlightList.find(unit->getId());
if(iterFindSpecialUnit != unitHighlightList.end()) {
Vec3f color=unit->getFaction()->getTexture()->getPixmapConst()->getPixel3f(0,0);
float radius = 1.0f;
float thickness = 0.1f;
float alpha = 0.65f;
HighlightSpecialUnitInfo &specialInfo = iterFindSpecialUnit->second;
if(specialInfo.color.x >= 0) {
color.x = specialInfo.color.x;
color.y = specialInfo.color.y;
color.z = specialInfo.color.z;
}
if(specialInfo.color.w >= 0) {
alpha = specialInfo.color.w;
}
if(specialInfo.radius > 0) {
radius = specialInfo.radius;
}
if(specialInfo.thickness > 0) {
thickness = specialInfo.thickness;
}
glColor4f(color.x, color.y, color.z, alpha);
Vec3f currVec= unit->getCurrVectorFlat();
renderSelectionCircle(currVec, unit->getType()->getSize(), radius, thickness);
}
}
glPopAttrib();
}
}
void Renderer::renderTeamColorPlane(){
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
VisibleQuadContainerCache &qCache = getQuadCache();
if(qCache.visibleQuadUnitList.empty() == false){
glPushAttrib(GL_ENABLE_BIT);
glDisable(GL_LIGHTING);
glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glEnable(GL_COLOR_MATERIAL);
const Texture2D *texture=CoreData::getInstance().getTeamColorTexture();
for(int visibleUnitIndex = 0;
visibleUnitIndex < (int)qCache.visibleQuadUnitList.size(); ++visibleUnitIndex){
Unit *unit = qCache.visibleQuadUnitList[visibleUnitIndex];
if( unit->isAlive()){
Vec3f currVec= unit->getCurrVectorFlat();
renderTeamColorEffect(currVec,visibleUnitIndex,unit->getType()->getSize(),
unit->getFaction()->getTexture()->getPixmapConst()->getPixel3f(0,0),texture);
}
}
glDisable(GL_COLOR_MATERIAL);
glPopAttrib();
}
}
void Renderer::renderGhostModel(const UnitType *building, const Vec2i pos,CardinalDir facing, Vec4f *forceColor) {
//const UnitType *building= gui->getBuilding();
//const Vec2i &pos= gui->getPosObjWorld();
//const Gui *gui= game->getGui();
//const Mouse3d *mouse3d= gui->getMouse3d();
const Map *map= game->getWorld()->getMap();
if(map == NULL) {
char szBuf[8096]="";
snprintf(szBuf,8096,"In [%s::%s] Line: %d map == NULL",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
throw megaglest_runtime_error(szBuf);
}
glPushMatrix();
Vec3f pos3f= Vec3f(pos.x, map->getCell(pos)->getHeight(), pos.y);
//selection building placement
float offset= building->getSize()/2.f-0.5f;
glTranslatef(pos3f.x+offset, pos3f.y, pos3f.z+offset);
//choose color
Vec4f color;
if(forceColor != NULL) {
color = *forceColor;
}
else {
if(map->isFreeCells(pos, building->getSize(), fLand)) {
color= Vec4f(1.f, 1.f, 1.f, 0.5f);
}
else {
// Uint64 tc=game->getTickCount();
// float red=0.49f+((tc%4*1.0f)/2);
color= Vec4f(1.0f, 0.f, 0.f, 0.5f);
}
}
glColor4fv(color.ptr());
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, color.ptr());
Model *buildingModel= building->getFirstStOfClass(scStop)->getAnimation();
if(facing != CardinalDir::NORTH) {
float rotateAmount = facing * 90.f;
if(rotateAmount > 0) {
glRotatef(rotateAmount, 0.f, 1.f, 0.f);
}
}
buildingModel->updateInterpolationData(0.f, false);
modelRenderer->render(buildingModel);
glPopMatrix();
}
void Renderer::renderUnits(bool airUnits, const int renderFps) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
//Unit *unit=NULL;
//const World *world= game->getWorld();
MeshCallbackTeamColor meshCallbackTeamColor;
//assert
assertGl();
if(visibleFrameUnitList.empty() == false) {
visibleFrameUnitList.clear();
//visibleFrameUnitListCameraKey = "";
//if(visibleFrameUnitListCameraKey != game->getGameCamera()->getCameraMovementKey()) {
// worldToScreenPosCache.clear();
//}
}
VisibleQuadContainerCache &qCache = getQuadCache();
if(qCache.visibleQuadUnitList.empty() == false) {
bool modelRenderStarted = false;
for(int visibleUnitIndex = 0;
visibleUnitIndex < (int)qCache.visibleQuadUnitList.size(); ++visibleUnitIndex) {
Unit *unit = qCache.visibleQuadUnitList[visibleUnitIndex];
if(( airUnits==false && unit->getType()->getField()==fAir) || ( airUnits==true && unit->getType()->getField()!=fAir)){
continue;
}
meshCallbackTeamColor.setTeamTexture(unit->getFaction()->getTexture());
if(modelRenderStarted == false) {
modelRenderStarted = true;
glPushAttrib(GL_ENABLE_BIT | GL_FOG_BIT | GL_LIGHTING_BIT | GL_TEXTURE_BIT);
glEnable(GL_COLOR_MATERIAL);
if(!shadowsOffDueToMinRender) {
if(shadows == sShadowMapping) {
glActiveTexture(shadowTexUnit);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, shadowMapHandle);
static_cast<ModelRendererGl*>(modelRenderer)->setDuplicateTexCoords(true);
enableProjectiveTexturing();
}
}
glActiveTexture(baseTexUnit);
modelRenderer->begin(true, true, true, false, &meshCallbackTeamColor);
}
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
//translate
Vec3f currVec= unit->getCurrVectorFlat();
glTranslatef(currVec.x, currVec.y, currVec.z);
//rotate
float zrot=unit->getRotationZ();
float xrot=unit->getRotationX();
if(zrot!=.0f){
glRotatef(zrot, 0.f, 0.f, 1.f);
}
if(xrot!=.0f){
glRotatef(xrot, 1.f, 0.f, 0.f);
}
glRotatef(unit->getRotation(), 0.f, 1.f, 0.f);
//dead alpha
const SkillType *st= unit->getCurrSkill();
if(st->getClass() == scDie && static_cast<const DieSkillType*>(st)->getFade()) {
float alpha= 1.0f - unit->getAnimProgressAsFloat();
glDisable(GL_COLOR_MATERIAL);
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, Vec4f(1.0f, 1.0f, 1.0f, alpha).ptr());
}
else {
glEnable(GL_COLOR_MATERIAL);
// we cut off a tiny bit here to avoid problems with fully transparent texture parts cutting units in background rendered later.
glAlphaFunc(GL_GREATER, 0.02f);
}
//render
Model *model= unit->getCurrentModelPtr();
//printf("Rendering model [%d - %s]\n[%s]\nCamera [%s]\nDistance: %f\n",unit->getId(),unit->getType()->getName().c_str(),unit->getCurrVector().getString().c_str(),this->gameCamera->getPos().getString().c_str(),this->gameCamera->getPos().dist(unit->getCurrVector()));
//if(this->gameCamera->getPos().dist(unit->getCurrVector()) <= SKIP_INTERPOLATION_DISTANCE) {
model->updateInterpolationData(unit->getAnimProgressAsFloat(), unit->isAlive() && !unit->isAnimProgressBound());
//}
modelRenderer->render(model);
triangleCount+= model->getTriangleCount();
pointCount+= model->getVertexCount();
glPopMatrix();
unit->setVisible(true);
if( showDebugUI == true &&
(showDebugUILevel & debugui_unit_titles) == debugui_unit_titles) {
unit->setScreenPos(computeScreenPosition(currVec));
visibleFrameUnitList.push_back(unit);
visibleFrameUnitListCameraKey = game->getGameCamera()->getCameraMovementKey();
}
}
if(modelRenderStarted == true) {
modelRenderer->end();
glPopAttrib();
}
}
//restore
static_cast<ModelRendererGl*>(modelRenderer)->setDuplicateTexCoords(true);
// reset alpha
glAlphaFunc(GL_GREATER, 0.0f);
//assert
assertGl();
}
void Renderer::renderUnitsToBuild(const int renderFps) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
//assert
assertGl();
VisibleQuadContainerCache &qCache = getQuadCache();
if(qCache.visibleQuadUnitBuildList.empty() == false) {
glMatrixMode(GL_MODELVIEW);
glPushAttrib(GL_CURRENT_BIT | GL_LIGHTING_BIT | GL_ENABLE_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_BLEND);
glDisable(GL_STENCIL_TEST);
glDepthFunc(GL_LESS);
glEnable(GL_COLOR_MATERIAL);
glDepthMask(GL_FALSE);
modelRenderer->begin(true, true, false, false);
for(int visibleUnitIndex = 0;
visibleUnitIndex < (int)qCache.visibleQuadUnitBuildList.size(); ++visibleUnitIndex) {
const UnitBuildInfo &buildUnit = qCache.visibleQuadUnitBuildList[visibleUnitIndex];
//Vec4f modelColor= Vec4f(0.f, 1.f, 0.f, 0.5f);
const Vec3f teamColor = buildUnit.unit->getFaction()->getTexture()->getPixmapConst()->getPixel3f(0,0);
Vec4f modelColor= Vec4f(teamColor.x,teamColor.y,teamColor.z,0.4f);
renderGhostModel(buildUnit.buildUnit, buildUnit.pos, buildUnit.facing, &modelColor);
//printf("Rendering to build unit index = %d\n",visibleUnitIndex);
}
modelRenderer->end();
glDisable(GL_COLOR_MATERIAL);
glPopAttrib();
}
//assert
assertGl();
}
void Renderer::renderTeamColorEffect(Vec3f &v, int heigth, int size, Vec3f color, const Texture2D *texture) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
//GLUquadricObj *disc;
float halfSize=size;
//halfSize=halfSize;
float heigthoffset=0.5+heigth%25*0.004;
glPushMatrix();
glBindTexture(GL_TEXTURE_2D, static_cast<const Texture2DGl*>(texture)->getHandle());
glColor4f(color.x, color.y, color.z, 1.0f);
glBegin(GL_TRIANGLE_STRIP);
glTexCoord2i(0, 1);
glVertex3f(v.x-halfSize,v.y+heigthoffset,v.z+halfSize);
glTexCoord2i(0, 0);
glVertex3f(v.x-halfSize,v.y+heigthoffset, v.z-halfSize);
glTexCoord2i(1, 1);
glVertex3f(v.x+halfSize,v.y+heigthoffset, v.z+halfSize);
glTexCoord2i(1, 0);
glVertex3f(v.x+halfSize,v.y+heigthoffset, v.z-halfSize);
glEnd();
glPopMatrix();
}
void Renderer::renderMorphEffects(){
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
VisibleQuadContainerCache &qCache = getQuadCache();
if(qCache.visibleQuadUnitList.empty() == false) {
bool initialized=false;
int frameCycle=0;
for(int visibleUnitIndex = 0;
visibleUnitIndex < (int)qCache.visibleQuadUnitList.size(); ++visibleUnitIndex) {
Unit *unit = qCache.visibleQuadUnitList[visibleUnitIndex];
if(unit->getCurrSkill() != NULL && unit->getCurrSkill()->getClass() == scMorph) {
Command *command= unit->getCurrCommand();
if(command != NULL && command->getCommandType()->commandTypeClass == ccMorph){
const MorphCommandType *mct= static_cast<const MorphCommandType*>(command->getCommandType());
const UnitType* mType=mct->getMorphUnit();
if(mType->getSize()>unit->getType()->getSize() ||
mType->getField()!=unit->getType()->getField()){
if(!initialized){
const World *world= game->getWorld();
frameCycle=world->getFrameCount() % 40;
glPushAttrib(GL_ENABLE_BIT | GL_CURRENT_BIT | GL_DEPTH_BUFFER_BIT);
glDisable(GL_LIGHTING);
glDisable(GL_TEXTURE_2D);
glDepthFunc(GL_ALWAYS);
glDisable(GL_STENCIL_TEST);
glDisable(GL_CULL_FACE);
glEnable(GL_BLEND);
glLineWidth(2.f);
initialized=true;
}
Vec3f currVec= unit->getCurrVectorFlat();
currVec=Vec3f(currVec.x,currVec.y+0.3f,currVec.z);
if(mType->getField() == fAir && unit->getType()->getField()== fLand) {
currVec=Vec3f(currVec.x,currVec.y+game->getWorld()->getTileset()->getAirHeight(),currVec.z);
}
if(mType->getField() == fLand && unit->getType()->getField()== fAir) {
currVec=Vec3f(currVec.x,currVec.y-game->getWorld()->getTileset()->getAirHeight(),currVec.z);
}
float color=frameCycle*0.4f/40;
glColor4f(color,color, 0.4f, 0.4f);
renderSelectionCircle(currVec, mType->getSize(), frameCycle*0.85f/40, 0.2f);
}
}
}
}
if(initialized) {
glPopAttrib();
}
}
}
void Renderer::renderSelectionEffects(int healthbarMode) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
Config &config= Config::getInstance();
if(config.getBool("RecordMode","false") == true) {
return;
}
const World *world= game->getWorld();
const Map *map= world->getMap();
const Selection *selection= game->getGui()->getSelection();
const Object *selectedResourceObject= game->getGui()->getSelectedResourceObject();
glPushAttrib(GL_ENABLE_BIT | GL_CURRENT_BIT | GL_DEPTH_BUFFER_BIT);
glDisable(GL_LIGHTING);
glDisable(GL_TEXTURE_2D);
glDepthFunc(GL_ALWAYS);
glDisable(GL_STENCIL_TEST);
glDisable(GL_CULL_FACE);
glEnable(GL_BLEND);
glLineWidth(2.f);
//units
for(int i=0; i<selection->getCount(); ++i){
const Unit *unit= selection->getUnit(i);
if(unit != NULL) {
//translate
Vec3f currVec= unit->getCurrVectorFlat();
currVec.y+= 0.3f;
//selection circle
int finalHealthbarMode = hbvUndefined;
if(healthbarMode == hbvUndefined) {
finalHealthbarMode = unit->getFaction()->getType()->getHealthbarVisible();
}
else {
finalHealthbarMode = healthbarMode;
}
bool healthbarsVisible =((finalHealthbarMode & hbvAlways) ||
(finalHealthbarMode & hbvSelected) ||
(finalHealthbarMode & hbvIfNeeded));
float selectionCircleThickness = 0.2f;
float hpRatio = unit->getHpRatio();
if(healthbarsVisible) {
selectionCircleThickness = 0.05f;
hpRatio = 1.0f;
}
if(world->getThisFactionIndex() == unit->getFactionIndex()) {
if( showDebugUI == true &&
((showDebugUILevel & debugui_unit_titles) == debugui_unit_titles) &&
unit->getCommandSize() > 0 &&
dynamic_cast<const BuildCommandType *>(unit->getCurrCommand()->getCommandType()) != NULL) {
glColor4f(hpRatio, hpRatio, hpRatio, 0.3f);
}
else {
glColor4f(0, hpRatio, 0, 0.3f);
}
}
else if ( world->getThisTeamIndex() == unit->getTeam()) {
glColor4f(hpRatio, hpRatio, 0, 0.3f);
}
else {
glColor4f(hpRatio, 0, 0, 0.3f);
}
renderSelectionCircle(currVec, unit->getType()->getSize(), selectionCircleRadius,selectionCircleThickness);
if( showDebugUI == true &&
(showDebugUILevel & debugui_unit_titles) == debugui_unit_titles) {
const UnitPathInterface *path= unit->getPath();
const UnitPathBasic *pathfinder = (path == NULL ? NULL : dynamic_cast<const UnitPathBasic *>(path));
if(pathfinder != NULL) {
vector<Vec2i> pathList = pathfinder->getQueue();
Vec2i lastPosValue;
for(int i = 0; i < (int)pathList.size(); ++i) {
Vec2i curPosValue = pathList[i];
if(i == 0) {
lastPosValue = curPosValue;
}
Vec3f currVec2 = unit->getVectorFlat(lastPosValue,curPosValue);
currVec2.y+= 0.3f;
renderSelectionCircle(currVec2, 1, selectionCircleRadius);
}
}
}
//magic circle
if(!healthbarsVisible && world->getThisFactionIndex() == unit->getFactionIndex() && unit->getType()->getMaxEp() > 0) {
glColor4f(unit->getEpRatio()/2.f, unit->getEpRatio(), unit->getEpRatio(), 0.5f);
renderSelectionCircle(currVec, unit->getType()->getSize(), magicCircleRadius);
}
// Render Attack-boost circles
if(showDebugUI == true) {
//const std::pair<const SkillType *,std::vector<Unit *> > &currentAttackBoostUnits = unit->getCurrentAttackBoostUnits();
const UnitAttackBoostEffectOriginator &effect = unit->getAttackBoostOriginatorEffect();
if(effect.skillType->isAttackBoostEnabled() == true) {
glColor4f(MAGENTA.x,MAGENTA.y,MAGENTA.z,MAGENTA.w);
renderSelectionCircle(currVec, 1, effect.skillType->getAttackBoost()->radius, .25f/effect.skillType->getAttackBoost()->radius);
for(unsigned int i = 0; i < effect.currentAttackBoostUnits.size(); ++i) {
// Remove attack boost upgrades from unit
int findUnitId = effect.currentAttackBoostUnits[i];
Unit *affectedUnit = game->getWorld()->findUnitById(findUnitId);
if(affectedUnit != NULL) {
Vec3f currVecBoost = affectedUnit->getCurrVectorFlat();
currVecBoost.y += 0.3f;
renderSelectionCircle(currVecBoost, affectedUnit->getType()->getSize(), 1.f);
}
}
}
}
//meeting point arrow
if(unit->getType()->getMeetingPoint()) {
Vec2i pos= unit->getMeetingPos();
map->clampPos(pos);
Vec3f arrowTarget= Vec3f(pos.x, map->getCell(pos)->getHeight(), pos.y);
renderArrow(unit->getCurrVectorFlat(), arrowTarget, Vec3f(0.f, 0.f, 1.f), 0.3f);
}
}
}
if(selectedResourceObject != NULL && selectedResourceObject->getResource() != NULL && selection->getCount() < 1) {
Resource *r= selectedResourceObject->getResource();
int defaultValue= r->getType()->getDefResPerPatch();
float colorValue=static_cast<float>(r->getAmount())/static_cast<float>(defaultValue);
glColor4f(0.1f, 0.1f , colorValue, 0.4f);
renderSelectionCircle(selectedResourceObject->getPos(),2, selectionCircleRadius);
}
//target arrow
if(selection->getCount() == 1) {
const Unit *unit= selection->getUnit(0);
if(unit != NULL) {
//comand arrow
if(focusArrows && unit->anyCommand()) {
const CommandType *ct= unit->getCurrCommand()->getCommandType();
if(ct->getClicks() != cOne){
//arrow color
Vec3f arrowColor;
switch(ct->getClass()) {
case ccMove:
arrowColor= Vec3f(0.f, 1.f, 0.f);
break;
case ccAttack:
case ccAttackStopped:
arrowColor= Vec3f(1.f, 0.f, 0.f);
break;
default:
arrowColor= Vec3f(1.f, 1.f, 0.f);
break;
}
//arrow target
Vec3f arrowTarget;
Command *c= unit->getCurrCommand();
if(c->getUnit() != NULL) {
arrowTarget= c->getUnit()->getCurrVectorFlat();
}
else {
Vec2i pos= c->getPos();
map->clampPos(pos);
arrowTarget= Vec3f(pos.x, map->getCell(pos)->getHeight(), pos.y);
}
renderArrow(unit->getCurrVectorFlat(), arrowTarget, arrowColor, 0.3f);
}
}
}
}
//render selection hightlights
if(game->getGui()->getHighlightedUnit() != NULL) {
const Unit *unit=game->getGui()->getHighlightedUnit() ;
if(unit->isHighlighted()) {
float highlight= unit->getHightlight();
if(game->getWorld()->getThisFactionIndex() == unit->getFactionIndex()) {
glColor4f(0.f, 1.f, 0.f, highlight);
}
else{
glColor4f(1.f, 0.f, 0.f, highlight);
}
Vec3f v= unit->getCurrVectorFlat();
v.y+= 0.3f;
renderSelectionCircle(v, unit->getType()->getSize(), 0.5f+0.4f*highlight );
}
}
// old inefficient way to render highlights
// for(int i=0; i < world->getFactionCount(); ++i) {
// for(int j=0; j < world->getFaction(i)->getUnitCount(); ++j) {
// const Unit *unit= world->getFaction(i)->getUnit(j);
//
// if(unit->isHighlighted()) {
// float highlight= unit->getHightlight();
// if(game->getWorld()->getThisFactionIndex() == unit->getFactionIndex()) {
// glColor4f(0.f, 1.f, 0.f, highlight);
// }
// else{
// glColor4f(1.f, 0.f, 0.f, highlight);
// }
//
// Vec3f v= unit->getCurrVectorFlat();
// v.y+= 0.3f;
// renderSelectionCircle(v, unit->getType()->getSize(), 0.5f+0.4f*highlight );
// }
// }
// }
//render resource selection highlight
if(game->getGui()->getHighlightedResourceObject() != NULL) {
const Object* object=game->getGui()->getHighlightedResourceObject();
if(object->isHighlighted()) {
float highlight= object->getHightlight();
glColor4f(0.1f, 0.1f , 1.0f, highlight);
Vec3f v= object->getPos();
v.y+= 0.3f;
renderSelectionCircle(v, 2, 0.4f+0.4f*highlight );
}
}
glPopAttrib();
}
void Renderer::renderHealthBars(int healthbarMode){
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
Config &config= Config::getInstance();
if(config.getBool("RecordMode","false") == true) {
return;
}
if(config.getBool("PhotoMode")) {
return;
}
glPushAttrib(GL_ENABLE_BIT | GL_CURRENT_BIT | GL_DEPTH_BUFFER_BIT);
glDisable(GL_LIGHTING);
glDisable(GL_TEXTURE_2D);
glDepthFunc(GL_ALWAYS);
glDisable(GL_STENCIL_TEST);
glDisable(GL_CULL_FACE);
glEnable(GL_BLEND);
glLineWidth(2.f);
VisibleQuadContainerCache &qCache = getQuadCache();
if(qCache.visibleQuadUnitList.empty() == false) {
for(int visibleUnitIndex = 0;
visibleUnitIndex < (int)qCache.visibleQuadUnitList.size(); ++visibleUnitIndex) {
Unit *unit = qCache.visibleQuadUnitList[visibleUnitIndex];
if(isHealthBarVisible(unit,healthbarMode)) {
float healthbarheight;
float healthbarthickness;
const Texture2D *healthbarTexture;
const Texture2D *healthbarBackgroundTexture;
bool healthbarLineBorder;
//get settings of the faction
healthbarheight=unit->getFaction()->getType()->getHealthbarHeight();
healthbarthickness=unit->getFaction()->getType()->getHealthbarThickness();
healthbarLineBorder=unit->getFaction()->getType()->isHealthbarLineBorder();
CoreData &coreData= CoreData::getInstance();
//First try faction texture then use core Texture
if(unit->getFaction()->getType()->isHealthbarBorderTextureEnabled()) {
healthbarTexture=unit->getFaction()->getType()->getHealthbarTexture();
if(healthbarTexture==NULL) {
healthbarTexture=coreData.getHealthbarTexture();
}
} else {
healthbarTexture=NULL;
}
if(unit->getFaction()->getType()->isHealthbarBackgroundTextureEnabled()) {
healthbarBackgroundTexture=unit->getFaction()->getType()->getHealthbarBackgroundTexture();
if(healthbarBackgroundTexture==NULL) {
healthbarBackgroundTexture=coreData.getHealthbarBackgroundTexture();
}
} else {
healthbarBackgroundTexture=NULL;
}
//replace them by the ones from the unit if existent
if(unit->getType()->getHealthbarVisible()!=hbvOff && unit->getType()->getHealthbarVisible()!=hbvUndefined) {
if(unit->getType()->getHealthbarHeight()!=-100.0f) {
healthbarheight=unit->getType()->getHealthbarHeight();
}
if(unit->getType()->getHealthbarThickness()!=-1.0f) {
healthbarthickness=unit->getType()->getHealthbarThickness();
}
}
Vec3f currVec= unit->getCurrVectorFlat();
if(healthbarheight==-100.0f) {
currVec.y+=unit->getType()->getHeight();
} else {
currVec.y+=healthbarheight;
}
renderHealthBar(currVec,unit,healthbarthickness,healthbarLineBorder,healthbarTexture,healthbarBackgroundTexture);
}
}
}
glPopAttrib();
}
bool Renderer::isHealthBarVisible(const Unit *unit,int healthbarMode){
int healthbarVisible=hbvUndefined;
//check options (hotkey)
if(healthbarMode==hbvUndefined) {
healthbarVisible=unit->getFaction()->getType()->getHealthbarVisible();
} else {
healthbarVisible=healthbarMode;
}
//replace them by the ones from the unit if existent
if(unit->getType()->getHealthbarVisible()!=hbvOff && unit->getType()->getHealthbarVisible()!=hbvUndefined) {
if(healthbarMode==hbvUndefined) { //don't override the visible setting when hotkey is not hbvUndefined
healthbarVisible=unit->getType()->getHealthbarVisible();
}
}
bool settingsWantToRenderThem=!(healthbarVisible==hbvUndefined || (healthbarVisible&hbvOff))
&& ((healthbarVisible&hbvAlways)
|| ((healthbarVisible&hbvIfNeeded) && unit->getHp()<unit->getType()->getMaxHp()+unit->getTotalUpgrade()->getMaxHp())
|| ((healthbarVisible&hbvIfNeeded) && unit->getType()->getMaxEp() > 0 && unit->getEp()<unit->getType()->getMaxEp()+unit->getTotalUpgrade()->getMaxEp())
|| ((healthbarVisible&hbvIfNeeded) && unit->getProductionPercent() > 0)
|| ((healthbarVisible&hbvSelected) && game->getGui()->isSelected(unit)));
if(unit->isAlive() && (settingsWantToRenderThem)) {
return true;
}
return false;
}
void Renderer::renderWaterEffects(){
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
const World *world= game->getWorld();
const WaterEffects *we= world->getWaterEffects();
const Map *map= world->getMap();
CoreData &coreData= CoreData::getInstance();
float height= map->getWaterLevel()+0.001f;
assertGl();
glPushAttrib(GL_CURRENT_BIT | GL_ENABLE_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_BLEND);
glDisable(GL_ALPHA_TEST);
glDepthMask(GL_FALSE);
glDepthFunc(GL_LEQUAL);
glEnable(GL_COLOR_MATERIAL);
//glNormal3f(0.f, 1.f, 0.f);
//splashes
glBindTexture(GL_TEXTURE_2D, static_cast<Texture2DGl*>(coreData.getWaterSplashTexture())->getHandle());
//!!!
Vec2f texCoords[4];
Vec3f vertices[4];
Vec3f normals[4];
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
for(int i=0; i<we->getWaterSplashCount(); ++i){
const WaterSplash *ws= we->getWaterSplash(i);
//render only if enabled
if(ws->getEnabled()){
//render only if visible
Vec2i intPos= Vec2i(static_cast<int>(ws->getPos().x), static_cast<int>(ws->getPos().y));
const Vec2i &mapPos = Map::toSurfCoords(intPos);
bool visible = map->getSurfaceCell(mapPos)->isVisible(world->getThisTeamIndex());
if(visible == false && world->showWorldForPlayer(world->getThisFactionIndex()) == true) {
visible = true;
}
if(visible == true) {
float scale= ws->getAnim()*ws->getSize();
texCoords[0] = Vec2f(0.f, 1.f);
vertices[0] = Vec3f(ws->getPos().x-scale, height, ws->getPos().y+scale);
normals[0] = Vec3f(0.f, 1.f, 0.f);
texCoords[1] = Vec2f(0.f, 0.f);
vertices[1] = Vec3f(ws->getPos().x-scale, height, ws->getPos().y-scale);
normals[1] = Vec3f(0.f, 1.f, 0.f);
texCoords[2] = Vec2f(1.f, 1.f);
vertices[2] = Vec3f(ws->getPos().x+scale, height, ws->getPos().y+scale);
normals[2] = Vec3f(0.f, 1.f, 0.f);
texCoords[3] = Vec2f(1.f, 0.f);
vertices[3] = Vec3f(ws->getPos().x+scale, height, ws->getPos().y-scale);
normals[3] = Vec3f(0.f, 1.f, 0.f);
glColor4f(1.f, 1.f, 1.f, 1.f - ws->getAnim());
glTexCoordPointer(2, GL_FLOAT, 0,&texCoords[0]);
glVertexPointer(3, GL_FLOAT, 0, &vertices[0]);
glNormalPointer(GL_FLOAT, 0, &normals[0]);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
/*
glBegin(GL_TRIANGLE_STRIP);
glTexCoord2f(0.f, 1.f);
glVertex3f(ws->getPos().x-scale, height, ws->getPos().y+scale);
glTexCoord2f(0.f, 0.f);
glVertex3f(ws->getPos().x-scale, height, ws->getPos().y-scale);
glTexCoord2f(1.f, 1.f);
glVertex3f(ws->getPos().x+scale, height, ws->getPos().y+scale);
glTexCoord2f(1.f, 0.f);
glVertex3f(ws->getPos().x+scale, height, ws->getPos().y-scale);
glEnd();
*/
}
}
}
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
glPopAttrib();
assertGl();
}
void Renderer::renderHud(){
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
Texture2D *hudTexture=game->getGui()->getHudTexture();
if(hudTexture!=NULL){
const Metrics &metrics= Metrics::getInstance();
renderTextureQuad(0, 0, metrics.getVirtualW(), metrics.getVirtualH(),hudTexture,1.0f);
}
}
void Renderer::renderMinimap(){
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
const World *world= game->getWorld();
const Minimap *minimap= world->getMinimap();
if(minimap == NULL || minimap->getTexture() == NULL) {
return;
}
const GameCamera *gameCamera= game->getGameCamera();
const Pixmap2D *pixmap= minimap->getTexture()->getPixmapConst();
const Metrics &metrics= Metrics::getInstance();
const WaterEffects *attackEffects= world->getAttackEffects();
int mx= metrics.getMinimapX();
int my= metrics.getMinimapY();
int mw= metrics.getMinimapW();
int mh= metrics.getMinimapH();
Vec2f zoom= Vec2f(
static_cast<float>(mw)/ pixmap->getW(),
static_cast<float>(mh)/ pixmap->getH());
assertGl();
// render minimap border
Vec4f col= game->getGui()->getDisplay()->getColor();
glColor4f(col.x*0.5f,col.y*0.5f,col.z*0.5f,1.0 );
int borderWidth=2;
glBegin(GL_QUADS);
glVertex2i(mx-borderWidth, my-borderWidth);
glVertex2i(mx-borderWidth, my);
glVertex2i(mx+mw+borderWidth, my);
glVertex2i(mx+mw+borderWidth, my-borderWidth);
glEnd();
glBegin(GL_QUADS);
glVertex2i(mx-borderWidth, my+mh+borderWidth);
glVertex2i(mx-borderWidth, my+mh);
glVertex2i(mx+mw+borderWidth, my+mh);
glVertex2i(mx+mw+borderWidth, my+mh+borderWidth);
glEnd();
glBegin(GL_QUADS);
glVertex2i(mx-borderWidth, my);
glVertex2i(mx-borderWidth, my+mh);
glVertex2i(mx, my+mh);
glVertex2i(mx, my);
glEnd();
glBegin(GL_QUADS);
glVertex2i(mx+mw, my);
glVertex2i(mx+mw, my+mh);
glVertex2i(mx+mw+borderWidth, my+mh);
glVertex2i(mx+mw+borderWidth, my);
glEnd();
assertGl();
glPushAttrib(GL_CURRENT_BIT | GL_ENABLE_BIT | GL_LINE_BIT | GL_TEXTURE_BIT);
//draw map
glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glActiveTexture(fowTexUnit);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, static_cast<const Texture2DGl*>(minimap->getFowTexture())->getHandle());
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_INTERPOLATE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_PREVIOUS);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_PRIMARY_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_ADD);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_PRIMARY_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA, GL_TEXTURE);
glActiveTexture(baseTexUnit);
glBindTexture(GL_TEXTURE_2D, static_cast<const Texture2DGl*>(minimap->getTexture())->getHandle());
glColor4f(0.5f, 0.5f, 0.5f, 0.2f);
glBegin(GL_TRIANGLE_STRIP);
glTexCoord2f(0.0f, 1.0f);
glMultiTexCoord2f(fowTexUnit, 0.0f, 1.0f);
glVertex2i(mx, my);
glTexCoord2f(0.0f, 0.0f);
glMultiTexCoord2f(fowTexUnit, 0.0f, 0.0f);
glVertex2i(mx, my+mh);
glTexCoord2f(1.0f, 1.0f);
glMultiTexCoord2f(fowTexUnit, 1.0f, 1.0f);
glVertex2i(mx+mw, my);
glTexCoord2f(1.0f, 0.0f);
glMultiTexCoord2f(fowTexUnit, 1.0f, 0.0f);
glVertex2i(mx+mw, my+mh);
glEnd();
glDisable(GL_BLEND);
glActiveTexture(fowTexUnit);
glDisable(GL_TEXTURE_2D);
glActiveTexture(baseTexUnit);
glDisable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
const int itemCount = attackEffects->getWaterSplashCount() * 12;
if(itemCount > 0) {
vector<Vec2f> vertices;
vertices.resize(itemCount);
vector<Vec4f> colors;
colors.resize(itemCount);
// draw attack alarm
int vertexIndex = 0;
for(int i = 0; i < attackEffects->getWaterSplashCount(); ++i) {
const WaterSplash *ws = attackEffects->getWaterSplash(i);
float scale= (1/ws->getAnim()*ws->getSize())*5;
//glColor4f(1.f, 1.f, 0.f, 1.f-ws->getAnim());
float alpha=(1.f-ws->getAnim())*0.01f;
Vec2f pos= ws->getPos()/Map::cellScale;
float attackX=mx +pos.x*zoom.x;
float attackY=my +mh -pos.y*zoom.y;
if(ws->getEnabled()){
// glBegin(GL_QUADS);
// glVertex2f(attackX-scale, attackY-scale);
// glVertex2f(attackX-scale, attackY+scale);
// glVertex2f(attackX+scale, attackY+scale);
// glVertex2f(attackX+scale, attackY-scale);
// glEnd();
colors[vertexIndex] = Vec4f(1.f, 1.f, 0.f, alpha);
vertices[vertexIndex] = Vec2f(attackX-scale, attackY-scale);
vertexIndex++;
colors[vertexIndex] = Vec4f(1.f, 1.f, 0.f, alpha);
vertices[vertexIndex] = Vec2f(attackX-scale, attackY+scale);
vertexIndex++;
colors[vertexIndex] = Vec4f(1.f, 1.f, 0.f, 0.8f);
vertices[vertexIndex] = Vec2f(attackX, attackY);
vertexIndex++;
colors[vertexIndex] = Vec4f(1.f, 1.f, 0.f, alpha);
vertices[vertexIndex] = Vec2f(attackX+scale, attackY+scale);
vertexIndex++;
colors[vertexIndex] = Vec4f(1.f, 1.f, 0.f, alpha);
vertices[vertexIndex] = Vec2f(attackX-scale, attackY+scale);
vertexIndex++;
colors[vertexIndex] = Vec4f(1.f, 1.f, 0.f, 0.8f);
vertices[vertexIndex] = Vec2f(attackX, attackY);
vertexIndex++;
colors[vertexIndex] = Vec4f(1.f, 1.f, 0.f, alpha);
vertices[vertexIndex] = Vec2f(attackX+scale, attackY+scale);
vertexIndex++;
colors[vertexIndex] = Vec4f(1.f, 1.f, 0.f, alpha);
vertices[vertexIndex] = Vec2f(attackX+scale, attackY-scale);
vertexIndex++;
colors[vertexIndex] = Vec4f(1.f, 1.f, 0.f, 0.8f);
vertices[vertexIndex] = Vec2f(attackX, attackY);
vertexIndex++;
colors[vertexIndex] = Vec4f(1.f, 1.f, 0.f, alpha);
vertices[vertexIndex] = Vec2f(attackX+scale, attackY-scale);
vertexIndex++;
colors[vertexIndex] = Vec4f(1.f, 1.f, 0.f, alpha);
vertices[vertexIndex] = Vec2f(attackX-scale, attackY-scale);
vertexIndex++;
colors[vertexIndex] = Vec4f(1.f, 1.f, 0.f, 0.8f);
vertices[vertexIndex] = Vec2f(attackX, attackY);
vertexIndex++;
/*
glBegin(GL_TRIANGLES);
glColor4f(1.f, 1.f, 0.f, alpha);
glVertex2f(attackX-scale, attackY-scale);
glVertex2f(attackX-scale, attackY+scale);
glColor4f(1.f, 1.f, 0.f, 0.8f);
glVertex2f(attackX, attackY);
glEnd();
glBegin(GL_TRIANGLES);
glColor4f(1.f, 1.f, 0.f, alpha);
glVertex2f(attackX-scale, attackY+scale);
glVertex2f(attackX+scale, attackY+scale);
glColor4f(1.f, 1.f, 0.f, 0.8f);
glVertex2f(attackX, attackY);
glEnd();
glBegin(GL_TRIANGLES);
glColor4f(1.f, 1.f, 0.f, alpha);
glVertex2f(attackX+scale, attackY+scale);
glVertex2f(attackX+scale, attackY-scale);
glColor4f(1.f, 1.f, 0.f, 0.8f);
glVertex2f(attackX, attackY);
glEnd();
glBegin(GL_TRIANGLES);
glColor4f(1.f, 1.f, 0.f, alpha);
glVertex2f(attackX+scale, attackY-scale);
glVertex2f(attackX-scale, attackY-scale);
glColor4f(1.f, 1.f, 0.f, 0.8f);
glVertex2f(attackX, attackY);
glEnd();
*/
}
}
if(vertexIndex > 0) {
glEnableClientState(GL_COLOR_ARRAY);
glEnableClientState(GL_VERTEX_ARRAY);
glColorPointer(4,GL_FLOAT, 0, &colors[0]);
glVertexPointer(2, GL_FLOAT, 0, &vertices[0]);
glDrawArrays(GL_TRIANGLE_STRIP, 0, vertexIndex);
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
}
}
glDisable(GL_BLEND);
//draw units
VisibleQuadContainerCache &qCache = getQuadCache();
std::vector<Unit *> visibleUnitList = qCache.visibleUnitList;
const bool showAllUnitsInMinimap = Config::getInstance().getBool("DebugGameSynchUI","false");
if(showAllUnitsInMinimap == true) {
visibleUnitList.clear();
const World *world= game->getWorld();
for(unsigned int i = 0; i < (unsigned int)world->getFactionCount(); ++i) {
const Faction *faction = world->getFaction(i);
for(unsigned int j = 0; j < (unsigned int)faction->getUnitCount(); ++j) {
Unit *unit = faction->getUnit(j);
visibleUnitList.push_back(unit);
}
}
}
if(visibleUnitList.empty() == false) {
uint32 unitIdx=0;
vector<Vec2f> unit_vertices;
unit_vertices.resize(visibleUnitList.size()*4);
vector<Vec3f> unit_colors;
unit_colors.resize(visibleUnitList.size()*4);
for(int visibleIndex = 0;
visibleIndex < (int)visibleUnitList.size(); ++visibleIndex) {
Unit *unit = visibleUnitList[visibleIndex];
if (unit->isAlive() == false) {
continue;
}
Vec2i pos= unit->getPos() / Map::cellScale;
int size= unit->getType()->getSize();
Vec3f color= unit->getFaction()->getTexture()->getPixmapConst()->getPixel3f(0, 0);
unit_colors[unitIdx] = color;
unit_vertices[unitIdx] = Vec2f(mx + pos.x*zoom.x, my + mh - (pos.y*zoom.y));
unitIdx++;
unit_colors[unitIdx] = color;
unit_vertices[unitIdx] = Vec2f(mx + (pos.x+1)*zoom.x+size, my + mh - (pos.y*zoom.y));
unitIdx++;
unit_colors[unitIdx] = color;
unit_vertices[unitIdx] = Vec2f(mx + (pos.x+1)*zoom.x+size, my + mh - ((pos.y+size)*zoom.y));
unitIdx++;
unit_colors[unitIdx] = color;
unit_vertices[unitIdx] = Vec2f(mx + pos.x*zoom.x, my + mh - ((pos.y+size)*zoom.y));
unitIdx++;
}
if(unitIdx > 0) {
glEnableClientState(GL_COLOR_ARRAY);
glEnableClientState(GL_VERTEX_ARRAY);
glColorPointer(3,GL_FLOAT, 0, &unit_colors[0]);
glVertexPointer(2, GL_FLOAT, 0, &unit_vertices[0]);
glDrawArrays(GL_QUADS, 0, unitIdx);
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
}
}
renderMarkedCellsOnMinimap();
//draw camera
float wRatio= static_cast<float>(metrics.getMinimapW()) / world->getMap()->getW();
float hRatio= static_cast<float>(metrics.getMinimapH()) / world->getMap()->getH();
int x= static_cast<int>(gameCamera->getPos().x * wRatio);
int y= static_cast<int>(gameCamera->getPos().z * hRatio);
float ang= degToRad(gameCamera->getHAng());
glEnable(GL_BLEND);
int x1;
int y1;
x1 = mx + x + static_cast<int>(20*std::sin(ang-pi/5));
y1 = my + mh - (y-static_cast<int>(20*std::cos(ang-pi/5)));
int x2;
int y2;
x2 = mx + x + static_cast<int>(20*std::sin(ang+pi/5));
y2 = my + mh - (y-static_cast<int>(20*std::cos(ang+pi/5)));
glColor4f(1.f, 1.f, 1.f, 1.f);
glBegin(GL_TRIANGLES);
glVertex2i(mx+x, my+mh-y);
glColor4f(1.f, 1.f, 1.f, 0.0f);
glVertex2i(x1,y1);
glColor4f(1.f, 1.f, 1.f, 0.0f);
glVertex2i(x2,y2);
glEnd();
glPopAttrib();
assertGl();
}
void Renderer::renderHighlightedCellsOnMinimap() {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
// Draw marked cells
const std::vector<MarkedCell> *highlightedCells = game->getHighlightedCells();
if(highlightedCells->empty() == false) {
//const Map *map= game->getWorld()->getMap();
const World *world= game->getWorld();
const Minimap *minimap= world->getMinimap();
int pointersize=10;
if(minimap == NULL || minimap->getTexture() == NULL) {
return;
}
//const GameCamera *gameCamera= game->getGameCamera();
const Pixmap2D *pixmap= minimap->getTexture()->getPixmapConst();
const Metrics &metrics= Metrics::getInstance();
//int mx= metrics.getMinimapX();
int my= metrics.getMinimapY();
int mw= metrics.getMinimapW();
int mh= metrics.getMinimapH();
Vec2f zoom= Vec2f(
static_cast<float>(mw)/ pixmap->getW()/2,
static_cast<float>(mh)/ pixmap->getH()/2);
for(int i = 0;i < (int)highlightedCells->size(); i++) {
const MarkedCell *mc=&highlightedCells->at(i);
if(mc->getFaction() == NULL || (mc->getFaction()->getTeam() == game->getWorld()->getThisFaction()->getTeam())) {
const Texture2D *texture= game->getHighlightCellTexture();
Vec3f color(MarkedCell::static_system_marker_color);
if(mc->getFaction() != NULL) {
color= mc->getFaction()->getTexture()->getPixmapConst()->getPixel3f(0, 0);
}
int lighting=(mc->getAliveCount()%15);
Vec3f myColor=Vec3f(color.x/2+.5f/lighting,color.y/2+.5f/lighting,color.z/2+.5f/lighting);
Vec2i pos=mc->getTargetPos();
if(texture != NULL) {
//float alpha = 0.49f+0.5f/(mc->getAliveCount()%15);
float alpha=1.0f;
renderTextureQuad((int)(pos.x*zoom.x)+pointersize, my + mh-(int)(pos.y*zoom.y), pointersize, pointersize, texture, alpha,&myColor);
}
}
}
}
}
void Renderer::renderMarkedCellsOnMinimap() {
// Draw marked cells
std::map<Vec2i, MarkedCell> markedCells = game->getMapMarkedCellList();
if(markedCells.empty() == false) {
//const Map *map= game->getWorld()->getMap();
const World *world= game->getWorld();
const Minimap *minimap= world->getMinimap();
if(minimap == NULL || minimap->getTexture() == NULL) {
return;
}
//const GameCamera *gameCamera= game->getGameCamera();
const Pixmap2D *pixmap= minimap->getTexture()->getPixmapConst();
const Metrics &metrics= Metrics::getInstance();
//const WaterEffects *attackEffects= world->getAttackEffects();
int mx= metrics.getMinimapX();
int my= metrics.getMinimapY();
int mw= metrics.getMinimapW();
int mh= metrics.getMinimapH();
Vec2f zoom= Vec2f(
static_cast<float>(mw)/ pixmap->getW(),
static_cast<float>(mh)/ pixmap->getH());
uint32 unitIdx=0;
vector<Vec2f> unit_vertices;
unit_vertices.resize(markedCells.size()*4);
vector<Vec4f> unit_colors;
unit_colors.resize(markedCells.size()*4);
for(std::map<Vec2i, MarkedCell>::iterator iterMap =markedCells.begin();
iterMap != markedCells.end(); ++iterMap) {
MarkedCell &bm = iterMap->second;
if(bm.getPlayerIndex() < 0 ||
(bm.getFaction() != NULL &&
bm.getFaction()->getTeam() == game->getWorld()->getThisFaction()->getTeam())) {
Vec2i pos= bm.getTargetPos() / Map::cellScale;
float size= 0.5f;
Vec3f color(MarkedCell::static_system_marker_color);
if(bm.getFaction() != NULL) {
color= bm.getFaction()->getTexture()->getPixmapConst()->getPixel3f(0, 0);
}
float alpha = 0.65f;
unit_colors[unitIdx] = Vec4f(color.x,color.y,color.z,alpha);
unit_vertices[unitIdx] = Vec2f(mx + pos.x*zoom.x, my + mh - (pos.y*zoom.y));
unitIdx++;
unit_colors[unitIdx] = Vec4f(color.x,color.y,color.z,alpha);
unit_vertices[unitIdx] = Vec2f(mx + (pos.x+1)*zoom.x+size, my + mh - (pos.y*zoom.y));
unitIdx++;
unit_colors[unitIdx] = Vec4f(color.x,color.y,color.z,alpha);
unit_vertices[unitIdx] = Vec2f(mx + (pos.x+1)*zoom.x+size, my + mh - ((pos.y+size)*zoom.y));
unitIdx++;
unit_colors[unitIdx] = Vec4f(color.x,color.y,color.z,alpha);
unit_vertices[unitIdx] = Vec2f(mx + pos.x*zoom.x, my + mh - ((pos.y+size)*zoom.y));
unitIdx++;
}
}
if(unitIdx > 0) {
glEnable(GL_BLEND);
glEnableClientState(GL_COLOR_ARRAY);
glEnableClientState(GL_VERTEX_ARRAY);
glColorPointer(4,GL_FLOAT, 0, &unit_colors[0]);
glVertexPointer(2, GL_FLOAT, 0, &unit_vertices[0]);
glDrawArrays(GL_QUADS, 0, unitIdx);
//glDrawArrays(GL_TRIANGLE_STRIP, 0, unitIdx);
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
glDisable(GL_BLEND);
}
}
}
void Renderer::renderVisibleMarkedCells(bool renderTextHint,int x, int y) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
// Draw marked cells
std::map<Vec2i, MarkedCell> markedCells = game->getMapMarkedCellList();
if(markedCells.empty() == false) {
const Texture2D *texture= game->getMarkCellTexture();
const int yOffset = -40;
for(std::map<Vec2i, MarkedCell>::iterator iterMap =markedCells.begin();
iterMap != markedCells.end(); ++iterMap) {
MarkedCell &bm = iterMap->second;
if(bm.getPlayerIndex() < 0 ||
(bm.getFaction() != NULL &&
bm.getFaction()->getTeam() == game->getWorld()->getThisFaction()->getTeam())) {
const Map *map= game->getWorld()->getMap();
std::pair<bool,Vec3f> bmVisible = posInCellQuadCache(
map->toSurfCoords(bm.getTargetPos()));
if(bmVisible.first == true) {
if(renderTextHint == true) {
if(bm.getNote() != "") {
bool validPosObjWorld= x > bmVisible.second.x &&
y > bmVisible.second.y + yOffset &&
x < bmVisible.second.x + texture->getTextureWidth() &&
y < bmVisible.second.y + yOffset + texture->getTextureHeight();
if(validPosObjWorld) {
//printf("Checking for hint text render mouse [%d,%d] marker pos [%d,%d] validPosObjWorld = %d, hint [%s]\n",x,y,bm.getTargetPos().x,bm.getTargetPos().y,validPosObjWorld,bm.getNote().c_str());
//Lang &lang= Lang::getInstance();
Vec4f fontColor = Vec4f(1.0f, 1.0f, 1.0f, 0.25f);
if(renderText3DEnabled == true) {
renderTextShadow3D(bm.getNote(), CoreData::getInstance().getConsoleFont3D(), fontColor,
bmVisible.second.x, bmVisible.second.y);
}
else {
renderTextShadow(bm.getNote(), CoreData::getInstance().getConsoleFont(), fontColor,
bmVisible.second.x, bmVisible.second.y);
}
}
}
}
else {
/*
//texture 0
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
//set color to interpolation
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_INTERPOLATE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_TEXTURE1);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB, GL_SRC_ALPHA);
//set alpha to 1
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
//texture 1
glActiveTexture(GL_TEXTURE1);
glMultiTexCoord2f(GL_TEXTURE1, 0.f, 0.f);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, static_cast<const Texture2DGl*>(bm.getFaction()->getTexture())->getHandle());
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_MODULATE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_PRIMARY_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_PREVIOUS);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
//set alpha to 1
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_PRIMARY_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
glActiveTexture(GL_TEXTURE0);
*/
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
Vec3f color(MarkedCell::static_system_marker_color);
if(bm.getFaction() != NULL) {
color = bm.getFaction()->getTexture()->getPixmapConst()->getPixel3f(0,0);
}
renderTextureQuad(
bmVisible.second.x,bmVisible.second.y + yOffset,
texture->getTextureWidth(),texture->getTextureHeight(),texture,0.8f,&color);
/*
glActiveTexture(GL_TEXTURE1);
glDisable(GL_TEXTURE_2D);
glActiveTexture(GL_TEXTURE0);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
*/
}
}
}
}
}
}
void Renderer::renderDisplay() {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
CoreData &coreData= CoreData::getInstance();
const Metrics &metrics= Metrics::getInstance();
const Display *display= game->getGui()->getDisplay();
glPushAttrib(GL_ENABLE_BIT);
if(renderText3DEnabled == true) {
//infoString
renderTextShadow3D(
display->getInfoText().c_str(),
coreData.getDisplayFont3D(),
display->getColor(),
metrics.getDisplayX(),
metrics.getDisplayY()+Display::infoStringY);
//title
renderTextShadow3D(
display->getTitle().c_str(),
coreData.getDisplayFont3D(),
display->getColor(),
metrics.getDisplayX()+40,
metrics.getDisplayY() + metrics.getDisplayH() - 20);
glColor3f(0.0f, 0.0f, 0.0f);
//text
renderTextShadow3D(
display->getText().c_str(),
coreData.getDisplayFont3D(),
display->getColor(),
metrics.getDisplayX() -1,
metrics.getDisplayY() + metrics.getDisplayH() - 56);
//progress Bar
if(display->getProgressBar() != -1) {
renderProgressBar3D(
display->getProgressBar(),
metrics.getDisplayX(),
metrics.getDisplayY() + metrics.getDisplayH()-50,
coreData.getDisplayFontSmall3D(), 175);
}
}
else {
//infoString
renderTextShadow(
display->getInfoText().c_str(),
coreData.getDisplayFont(),
display->getColor(),
metrics.getDisplayX(),
metrics.getDisplayY()+Display::infoStringY);
//title
renderTextShadow(
display->getTitle().c_str(),
coreData.getDisplayFont(),
display->getColor(),
metrics.getDisplayX()+40,
metrics.getDisplayY() + metrics.getDisplayH() - 20);
glColor3f(0.0f, 0.0f, 0.0f);
//text
renderTextShadow(
display->getText().c_str(),
coreData.getDisplayFont(),
display->getColor(),
metrics.getDisplayX() -1,
metrics.getDisplayY() + metrics.getDisplayH() - 56);
//progress Bar
if(display->getProgressBar()!=-1){
renderProgressBar(
display->getProgressBar(),
metrics.getDisplayX(),
metrics.getDisplayY() + metrics.getDisplayH()-50,
coreData.getDisplayFontSmall());
}
}
//up images
glEnable(GL_TEXTURE_2D);
glColor3f(1.f, 1.f, 1.f);
for(int i=0; i<Display::upCellCount; ++i){
if(display->getUpImage(i)!=NULL){
renderQuad(
metrics.getDisplayX()+display->computeUpX(i),
metrics.getDisplayY()+display->computeUpY(i),
display->getUpImageSize(), display->getUpImageSize(), display->getUpImage(i));
}
}
//down images
for(int i=0; i<Display::downCellCount; ++i){
if(display->getDownImage(i)!=NULL){
Vec3f c=display->getDownImageColor(i);
glColor3f(c.x,c.y,c.z );
int x= metrics.getDisplayX()+display->computeDownX(i);
int y= metrics.getDisplayY()+display->computeDownY(i);
int size= Display::imageSize;
if(display->getDownSelectedPos()==i){
x-= 3;
y-= 3;
size+= 6;
}
renderQuad(x, y, size, size, display->getDownImage(i));
}
}
//selection
int downPos= display->getDownSelectedPos();
if(downPos!=Display::invalidPos){
const Texture2D *texture= display->getDownImage(downPos);
if(texture!=NULL){
int x= metrics.getDisplayX()+display->computeDownX(downPos)-3;
int y= metrics.getDisplayY()+display->computeDownY(downPos)-3;
int size= Display::imageSize+6;
renderQuad(x, y, size, size, display->getDownImage(downPos));
}
}
glPopAttrib();
}
void Renderer::renderMenuBackground(const MenuBackground *menuBackground) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
assertGl();
const Vec3f &cameraPosition= menuBackground->getCamera()->getConstPosition();
glPushAttrib(GL_LIGHTING_BIT | GL_ENABLE_BIT | GL_CURRENT_BIT | GL_DEPTH_BUFFER_BIT);
//clear
Vec4f fogColor= Vec4f(0.4f, 0.4f, 0.4f, 1.f) * menuBackground->getFade();
glClearColor(fogColor.x, fogColor.y, fogColor.z, 1.f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glFogfv(GL_FOG_COLOR, fogColor.ptr());
//light
Vec4f lightPos= Vec4f(10.f, 10.f, 10.f, 1.f)* menuBackground->getFade();
Vec4f diffLight= Vec4f(0.9f, 0.9f, 0.9f, 1.f)* menuBackground->getFade();
Vec4f ambLight= Vec4f(0.3f, 0.3f, 0.3f, 1.f)* menuBackground->getFade();
Vec4f specLight= Vec4f(0.1f, 0.1f, 0.1f, 1.f)* menuBackground->getFade();
glEnable(GL_LIGHT0);
glLightfv(GL_LIGHT0, GL_POSITION, lightPos.ptr());
glLightfv(GL_LIGHT0, GL_DIFFUSE, diffLight.ptr());
glLightfv(GL_LIGHT0, GL_AMBIENT, ambLight.ptr());
glLightfv(GL_LIGHT0, GL_SPECULAR, specLight.ptr());
//main model
glEnable(GL_ALPHA_TEST);
glAlphaFunc(GL_GREATER, 0.5f);
modelRenderer->begin(true, true, true, false);
menuBackground->getMainModelPtr()->updateInterpolationData(menuBackground->getAnim(), true);
modelRenderer->render(menuBackground->getMainModelPtr());
modelRenderer->end();
glDisable(GL_ALPHA_TEST);
//characters
float dist= menuBackground->getAboutPosition().dist(cameraPosition);
float minDist= 3.f;
if(dist < minDist) {
glAlphaFunc(GL_GREATER, 0.0f);
float alpha= clamp((minDist-dist) / minDist, 0.f, 1.f);
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, Vec4f(1.0f, 1.0f, 1.0f, alpha).ptr());
std::vector<Vec3f> &characterMenuScreenPositionListCache =
CacheManager::getCachedItem< std::vector<Vec3f> >(GameConstants::characterMenuScreenPositionListCacheLookupKey);
characterMenuScreenPositionListCache.clear();
modelRenderer->begin(true, true, false, false);
for(int i=0; i < MenuBackground::characterCount; ++i) {
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
Vec3f worldPos(i*2.f-4.f, -1.4f, -7.5f);
glTranslatef(worldPos.x,worldPos.y,worldPos.z);
//
// Get the screen coordinates for each character model - START
//std::vector<GLdouble> projection(16);
//std::vector<GLdouble> modelview(16);
//std::vector<GLdouble> screen_coords(3);
//glGetDoublev(GL_PROJECTION_MATRIX, projection.data());
//glGetDoublev(GL_MODELVIEW_MATRIX, modelview.data());
const Metrics &metrics= Metrics::getInstance();
GLint viewport[]= {0, 0, metrics.getVirtualW(), metrics.getVirtualH()};
//get matrices
GLdouble projection[16];
glGetDoublev(GL_PROJECTION_MATRIX, projection);
GLdouble modelview[16];
glGetDoublev(GL_MODELVIEW_MATRIX, modelview);
//get the screen coordinates
GLdouble screen_coords[3];
gluProject(worldPos.x, worldPos.y, worldPos.z,
modelview, projection, viewport,
&screen_coords[0], &screen_coords[1], &screen_coords[2]);
characterMenuScreenPositionListCache.push_back(Vec3f(screen_coords[0],screen_coords[1],screen_coords[2]));
// Get the screen coordinates for each character model - END
//
menuBackground->getCharacterModelPtr(i)->updateInterpolationData(menuBackground->getAnim(), true);
modelRenderer->render(menuBackground->getCharacterModelPtr(i));
glPopMatrix();
}
modelRenderer->end();
}
//water
if(menuBackground->getWater()) {
//water surface
const int waterTesselation= 10;
const int waterSize= 250;
const int waterQuadSize= 2*waterSize/waterTesselation;
const float waterHeight= menuBackground->getWaterHeight();
glEnable(GL_BLEND);
glNormal3f(0.f, 1.f, 0.f);
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, Vec4f(1.f, 1.f, 1.f, 1.f).ptr());
GLuint waterHandle= static_cast<Texture2DGl*>(menuBackground->getWaterTexture())->getHandle();
glBindTexture(GL_TEXTURE_2D, waterHandle);
for(int i=1; i < waterTesselation; ++i) {
glBegin(GL_TRIANGLE_STRIP);
for(int j=1; j < waterTesselation; ++j) {
glTexCoord2i(1, 2 % j);
glVertex3f(-waterSize+i*waterQuadSize, waterHeight, -waterSize+j*waterQuadSize);
glTexCoord2i(0, 2 % j);
glVertex3f(-waterSize+(i+1)*waterQuadSize, waterHeight, -waterSize+j*waterQuadSize);
}
glEnd();
}
glDisable(GL_BLEND);
//raindrops
if(menuBackground->getRain()) {
const float maxRaindropAlpha= 0.5f;
glEnable(GL_BLEND);
glDisable(GL_LIGHTING);
glDisable(GL_ALPHA_TEST);
glDepthMask(GL_FALSE);
//splashes
CoreData &coreData= CoreData::getInstance();
glBindTexture(GL_TEXTURE_2D, static_cast<Texture2DGl*>(coreData.getWaterSplashTexture())->getHandle());
for(int i=0; i< MenuBackground::raindropCount; ++i) {
Vec2f pos= menuBackground->getRaindropPos(i);
float scale= menuBackground->getRaindropState(i);
float alpha= maxRaindropAlpha-scale*maxRaindropAlpha;
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glColor4f(1.f, 1.f, 1.f, alpha);
glTranslatef(pos.x, waterHeight+0.01f, pos.y);
glBegin(GL_TRIANGLE_STRIP);
glTexCoord2f(0.f, 1.f);
glVertex3f(-scale, 0, scale);
glTexCoord2f(0.f, 0.f);
glVertex3f(-scale, 0, -scale);
glTexCoord2f(1.f, 1.f);
glVertex3f(scale, 0, scale);
glTexCoord2f(1.f, 0.f);
glVertex3f(scale, 0, -scale);
glEnd();
glPopMatrix();
}
}
}
glPopAttrib();
assertGl();
}
void Renderer::renderMenuBackground(Camera *camera, float fade, Model *mainModel, vector<Model *> characterModels,const Vec3f characterPosition, float anim) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
assertGl();
const Vec3f &cameraPosition= camera->getConstPosition();
glPushAttrib(GL_LIGHTING_BIT | GL_ENABLE_BIT | GL_CURRENT_BIT | GL_DEPTH_BUFFER_BIT);
//clear
//Vec4f fogColor= Vec4f(0.4f, 0.4f, 0.4f, 1.f) * fade;
// Show black bacground
Vec4f fogColor= Vec4f(0.f, 0.f, 0.f, 1.f);
glClearColor(fogColor.x, fogColor.y, fogColor.z, 1.f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glFogfv(GL_FOG_COLOR, fogColor.ptr());
//light
Vec4f lightPos= Vec4f(10.f, 10.f, 10.f, 1.f) * fade;
Vec4f diffLight= Vec4f(0.9f, 0.9f, 0.9f, 1.f) * fade;
Vec4f ambLight= Vec4f(0.3f, 0.3f, 0.3f, 1.f) * fade;
Vec4f specLight= Vec4f(0.1f, 0.1f, 0.1f, 1.f) * fade;
glEnable(GL_LIGHT0);
glLightfv(GL_LIGHT0, GL_POSITION, lightPos.ptr());
glLightfv(GL_LIGHT0, GL_DIFFUSE, diffLight.ptr());
glLightfv(GL_LIGHT0, GL_AMBIENT, ambLight.ptr());
glLightfv(GL_LIGHT0, GL_SPECULAR, specLight.ptr());
//main model
if(mainModel) {
glEnable(GL_ALPHA_TEST);
glAlphaFunc(GL_GREATER, 0.5f);
modelRenderer->begin(true, true, true, false);
mainModel->updateInterpolationData(anim, true);
modelRenderer->render(mainModel);
modelRenderer->end();
glDisable(GL_ALPHA_TEST);
}
//characters
if(characterModels.empty() == false) {
float dist= characterPosition.dist(cameraPosition);
float minDist= 3.f;
if(dist < minDist) {
glAlphaFunc(GL_GREATER, 0.0f);
float alpha= clamp((minDist-dist) / minDist, 0.f, 1.f);
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, Vec4f(1.0f, 1.0f, 1.0f, alpha).ptr());
modelRenderer->begin(true, true, false, false);
for(unsigned int i = 0; i < characterModels.size(); ++i) {
if(characterModels[i]) {
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glTranslatef(i*2.f-4.f, -1.4f, -7.5f);
characterModels[i]->updateInterpolationData(anim, true);
modelRenderer->render(characterModels[i]);
glPopMatrix();
}
}
modelRenderer->end();
}
}
glPopAttrib();
assertGl();
}
// ==================== computing ====================
bool Renderer::ccomputePosition(const Vec2i &screenPos, Vec2i &worldPos, bool exactCoords) {
assertGl();
const Map* map= game->getWorld()->getMap();
const Metrics &metrics= Metrics::getInstance();
float depth= 0.0f;
GLdouble modelviewMatrix[16];
GLdouble projectionMatrix[16];
GLint viewport[4]= {0, 0, metrics.getScreenW(), metrics.getScreenH()};
GLdouble worldX;
GLdouble worldY;
GLdouble worldZ;
GLint screenX= (screenPos.x * metrics.getScreenW() / metrics.getVirtualW());
GLint screenY= (screenPos.y * metrics.getScreenH() / metrics.getVirtualH());
//get the depth in the cursor pixel
glReadPixels(screenX, screenY, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &depth);
//load matrices
loadProjectionMatrix();
loadGameCameraMatrix();
//get matrices
glGetDoublev(GL_MODELVIEW_MATRIX, modelviewMatrix);
glGetDoublev(GL_PROJECTION_MATRIX, projectionMatrix);
//get the world coordinates
gluUnProject(
screenX, screenY, depth,
modelviewMatrix, projectionMatrix, viewport,
&worldX, &worldY, &worldZ);
//conver coords to int
if(exactCoords == true) {
worldPos= Vec2i(static_cast<int>(worldX), static_cast<int>(worldZ));
}
else {
worldPos= Vec2i(static_cast<int>(worldX+0.5f), static_cast<int>(worldZ+0.5f));
}
//clamp coords to map size
return map->isInside(worldPos);
}
// This method takes world co-ordinates and translates them to screen co-ords
Vec3f Renderer::computeScreenPosition(const Vec3f &worldPos) {
if(worldToScreenPosCache.find(worldPos) != worldToScreenPosCache.end()) {
return worldToScreenPosCache[worldPos];
}
assertGl();
const Metrics &metrics= Metrics::getInstance();
GLint viewport[]= {0, 0, metrics.getVirtualW(), metrics.getVirtualH()};
GLdouble worldX = worldPos.x;
GLdouble worldY = worldPos.y;
GLdouble worldZ = worldPos.z;
//load matrices
loadProjectionMatrix();
loadGameCameraMatrix();
//get matrices
GLdouble modelviewMatrix[16];
glGetDoublev(GL_MODELVIEW_MATRIX, modelviewMatrix);
GLdouble projectionMatrix[16];
glGetDoublev(GL_PROJECTION_MATRIX, projectionMatrix);
//get the screen coordinates
GLdouble screenX;
GLdouble screenY;
GLdouble screenZ;
gluProject(worldX, worldY, worldZ,
modelviewMatrix, projectionMatrix, viewport,
&screenX, &screenY, &screenZ);
Vec3f screenPos(screenX,screenY,screenZ);
worldToScreenPosCache[worldPos]=screenPos;
return screenPos;
}
void Renderer::computeSelected( Selection::UnitContainer &units, const Object *&obj,
const bool withObjectSelection,
const Vec2i &posDown, const Vec2i &posUp) {
const string selectionType=toLower(Config::getInstance().getString("SelectionType",Config::colorPicking));
if(selectionType==Config::colorPicking) {
selectUsingColorPicking(units,obj, withObjectSelection,posDown, posUp);
}
/// Frustum approach --> Currently not accurate enough
else if(selectionType==Config::frustumPicking) {
selectUsingFrustumSelection(units,obj, withObjectSelection,posDown, posUp);
}
else {
selectUsingSelectionBuffer(units,obj, withObjectSelection,posDown, posUp);
}
}
void Renderer::selectUsingFrustumSelection(Selection::UnitContainer &units,
const Object *&obj, const bool withObjectSelection,
const Vec2i &posDown, const Vec2i &posUp) {
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
const Metrics &metrics= Metrics::getInstance();
GLint view[]= {0, 0, metrics.getVirtualW(), metrics.getVirtualH()};
//compute center and dimensions of selection rectangle
int x = (posDown.x+posUp.x) / 2;
int y = (posDown.y+posUp.y) / 2;
int w = abs(posDown.x-posUp.x);
int h = abs(posDown.y-posUp.y);
if(w < 2) {
w = 2;
}
if(h < 2) {
h = 2;
}
gluPickMatrix(x, y, w, h, view);
gluPerspective(perspFov, metrics.getAspectRatio(), perspNearPlane, perspFarPlane);
loadGameCameraMatrix();
VisibleQuadContainerCache quadSelectionCacheItem;
ExtractFrustum(quadSelectionCacheItem);
//pop matrices
glMatrixMode(GL_PROJECTION);
glPopMatrix();
VisibleQuadContainerCache &qCache = getQuadCache();
if(qCache.visibleQuadUnitList.empty() == false) {
for(int visibleUnitIndex = 0;
visibleUnitIndex < (int)qCache.visibleQuadUnitList.size(); ++visibleUnitIndex) {
Unit *unit = qCache.visibleQuadUnitList[visibleUnitIndex];
if(unit != NULL && unit->isAlive()) {
Vec3f unitPos = unit->getCurrMidHeightVector();
bool insideQuad = CubeInFrustum(quadSelectionCacheItem.frustumData,
unitPos.x, unitPos.y, unitPos.z, unit->getType()->getRenderSize());
if(insideQuad == true) {
units.push_back(unit);
}
}
}
}
if(withObjectSelection == true) {
if(qCache.visibleObjectList.empty() == false) {
for(int visibleIndex = 0;
visibleIndex < (int)qCache.visibleObjectList.size(); ++visibleIndex) {
Object *object = qCache.visibleObjectList[visibleIndex];
if(object != NULL) {
bool insideQuad = CubeInFrustum(quadSelectionCacheItem.frustumData,
object->getPos().x, object->getPos().y, object->getPos().z, 1);
if(insideQuad == true) {
obj = object;
//if(withObjectSelection == true) {
break;
//}
}
}
}
}
}
}
void Renderer::selectUsingSelectionBuffer(Selection::UnitContainer &units,
const Object *&obj, const bool withObjectSelection,
const Vec2i &posDown, const Vec2i &posUp) {
//compute center and dimensions of selection rectangle
int x = (posDown.x+posUp.x) / 2;
int y = (posDown.y+posUp.y) / 2;
int w = abs(posDown.x-posUp.x);
int h = abs(posDown.y-posUp.y);
if(w < 2) {
w = 2;
}
if(h < 2) {
h = 2;
}
//declarations
GLuint selectBuffer[Gui::maxSelBuff];
//setup matrices
glSelectBuffer(Gui::maxSelBuff, selectBuffer);
//glMatrixMode(GL_PROJECTION);
//glPushMatrix();
GLint renderModeResult = glRenderMode(GL_SELECT);
if(renderModeResult < 0) {
const char *errorString= reinterpret_cast<const char*>(gluErrorString(renderModeResult));
char szBuf[8096]="";
snprintf(szBuf,8096,"OpenGL error #%d [0x%X] : [%s] at file: [%s], line: %d",renderModeResult,renderModeResult,errorString,extractFileFromDirectoryPath(__FILE__).c_str(),__LINE__);
printf("%s\n",szBuf);
}
glPushMatrix();
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
const Metrics &metrics= Metrics::getInstance();
GLint view[]= {0, 0, metrics.getVirtualW(), metrics.getVirtualH()};
//GLint view[4];
//glGetIntegerv(GL_VIEWPORT, view);
gluPickMatrix(x, y, w, h, view);
gluPerspective(perspFov, metrics.getAspectRatio(), perspNearPlane, perspFarPlane);
//gluPerspective(perspFov, metrics.getAspectRatio(), 0.0001, 1000.0);
//gluPerspective(perspFov, (float)view[2]/(float)view[3], perspNearPlane, perspFarPlane);
loadGameCameraMatrix();
//render units to find which ones should be selected
renderUnitsFast();
if(withObjectSelection == true) {
renderObjectsFast(false,true);
}
//pop matrices
glPopMatrix();
// Added this to ensure all the selection calls are done now
// (see http://www.unknownroad.com/rtfm/graphics/glselection.html section: [0x4])
//glFlush();
//select units by checking the selected buffer
int selCount= glRenderMode(GL_RENDER);
if(selCount > 0) {
VisibleQuadContainerCache &qCache = getQuadCache();
for(int i = 1; i <= selCount; ++i) {
int index = selectBuffer[i*4-1];
if(index >= OBJECT_SELECT_OFFSET) {
Object *object = qCache.visibleObjectList[index - OBJECT_SELECT_OFFSET];
if(object != NULL) {
obj = object;
if(withObjectSelection == true) {
break;
}
}
}
else {
Unit *unit = qCache.visibleQuadUnitList[index];
if(unit != NULL && unit->isAlive()) {
units.push_back(unit);
}
}
}
}
else if(selCount < 0) {
const char *errorString= reinterpret_cast<const char*>(gluErrorString(selCount));
char szBuf[8096]="";
snprintf(szBuf,8096,"OpenGL error #%d [0x%X] : [%s] at file: [%s], line: %d",selCount,selCount,errorString,extractFileFromDirectoryPath(__FILE__).c_str(),__LINE__);
printf("%s\n",szBuf);
}
}
void Renderer::selectUsingColorPicking(Selection::UnitContainer &units,
const Object *&obj, const bool withObjectSelection,
const Vec2i &posDown, const Vec2i &posUp) {
int x1 = posDown.x;
int y1 = posDown.y;
int x2 = posUp.x;
int y2 = posUp.y;
int x = min(x1,x2);
int y = min(y1,y2);
int w = max(x1,x2) - min(x1,x2);
int h = max(y1,y2) - min(y1,y2);
if(w < 2) {
w = 2;
}
if(h < 2) {
h = 2;
}
const Metrics &metrics= Metrics::getInstance();
x= (x * metrics.getScreenW() / metrics.getVirtualW());
y= (y * metrics.getScreenH() / metrics.getVirtualH());
w= (w * metrics.getScreenW() / metrics.getVirtualW());
h= (h * metrics.getScreenH() / metrics.getVirtualH());
PixelBufferWrapper::begin();
glPushMatrix();
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
//GLint view[]= {0, 0, metrics.getVirtualW(), metrics.getVirtualH()};
//gluPickMatrix(x, y, w, h, view);
gluPerspective(perspFov, metrics.getAspectRatio(), perspNearPlane, perspFarPlane);
loadGameCameraMatrix();
//render units to find which ones should be selected
//printf("In [%s::%s] Line: %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
vector<Unit *> rendererUnits = renderUnitsFast(false, true);
//printf("In [%s::%s] Line: %d rendererUnits = %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,rendererUnits.size());
// Added this to ensure all the selection calls are done now
// (see http://www.unknownroad.com/rtfm/graphics/glselection.html section: [0x4])
//glFlush();
//GraphicsInterface::getInstance().getCurrentContext()->swapBuffers();
PixelBufferWrapper::end();
vector<BaseColorPickEntity *> unitsVector;
bool unitFound=false;
if(rendererUnits.empty() == false) {
copy(rendererUnits.begin(), rendererUnits.end(), std::inserter(unitsVector, unitsVector.begin()));
}
if(unitsVector.empty() == false) {
vector<int> pickedList = BaseColorPickEntity::getPickedList(x,y,w,h, unitsVector);
//printf("In [%s::%s] Line: %d pickedList = %d models rendered = %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,pickedList.size(),rendererModels.size());
if(pickedList.empty() == false) {
units.reserve(pickedList.size());
for(unsigned int i = 0; i < pickedList.size(); ++i) {
int index = pickedList[i];
//printf("In [%s::%s] Line: %d searching for selected object i = %d index = %d units = %d objects = %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,i,index,rendererUnits.size(),rendererObjects.size());
if(rendererUnits.empty() == false && index < (int)rendererUnits.size()) {
Unit *unit = rendererUnits[index];
if(unit != NULL && unit->isAlive()) {
unitFound=true;
units.push_back(unit);
}
}
}
}
}
if(withObjectSelection == true && unitFound==false) {
vector<Object *> rendererObjects;
vector<BaseColorPickEntity *> objectsVector;
rendererObjects = renderObjectsFast(false,true,true);
if(rendererObjects.empty() == false) {
copy(rendererObjects.begin(), rendererObjects.end(), std::inserter(objectsVector, objectsVector.begin()));
}
if(objectsVector.empty() == false) {
vector<int> pickedList = BaseColorPickEntity::getPickedList(x,y,w,h, objectsVector);
//printf("In [%s::%s] Line: %d pickedList = %d models rendered = %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,pickedList.size(),rendererModels.size());
if(pickedList.empty() == false) {
for(unsigned int i = 0; i < pickedList.size(); ++i) {
int index = pickedList[i];
//printf("In [%s::%s] Line: %d searching for selected object i = %d index = %d units = %d objects = %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,i,index,rendererUnits.size(),rendererObjects.size());
if(rendererObjects.empty() == false && index < (int)rendererObjects.size()) {
Object *object = rendererObjects[index];
//printf("In [%s::%s] Line: %d searching for selected object i = %d index = %d [%p]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,i,index,object);
if(object != NULL) {
obj = object;
break;
}
}
}
}
}
}
//pop matrices
glPopMatrix();
}
// ==================== shadows ====================
void Renderer::renderShadowsToTexture(const int renderFps){
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
if(shadowsOffDueToMinRender == false &&
(shadows == sProjected || shadows == sShadowMapping)) {
shadowMapFrame= (shadowMapFrame + 1) % (shadowFrameSkip + 1);
if(shadowMapFrame == 0){
assertGl();
glPushAttrib(GL_ENABLE_BIT | GL_CURRENT_BIT | GL_COLOR_BUFFER_BIT | GL_VIEWPORT_BIT | GL_POLYGON_BIT);
if(shadows == sShadowMapping) {
glClear(GL_DEPTH_BUFFER_BIT);
}
else {
float color= 1.0f-shadowIntensity;
glColor3f(color, color, color);
glClearColor(1.f, 1.f, 1.f, 1.f);
glDisable(GL_DEPTH_TEST);
glClear(GL_COLOR_BUFFER_BIT);
}
//assertGl();
//clear color buffer
//
//set viewport, we leave one texel always in white to avoid problems
glViewport(1, 1, shadowTextureSize-2, shadowTextureSize-2);
//assertGl();
if(nearestLightPos.w == 0.f) {
//directional light
//light pos
assert(game != NULL);
assert(game->getWorld() != NULL);
const TimeFlow *tf= game->getWorld()->getTimeFlow();
assert(tf != NULL);
float ang= tf->isDay()? computeSunAngle(tf->getTime()): computeMoonAngle(tf->getTime());
ang= radToDeg(ang);
//push and set projection
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
//assertGl();
if(game->getGameCamera()->getState()==GameCamera::sGame){
//glOrtho(-35, 5, -15, 15, -1000, 1000);
//glOrtho(-30, 30, -20, 20, -1000, 1000);
glOrtho(-30, 5, -20, 20, -1000, 1000);
}
else{
glOrtho(-30, 30, -20, 20, -1000, 1000);
}
//assertGl();
//push and set modelview
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glRotatef(15, 0, 1, 0);
glRotatef(ang, 1, 0, 0);
glRotatef(90, 0, 1, 0);
const Vec3f &pos= game->getGameCamera()->getPos();
glTranslatef(static_cast<int>(-pos.x), 0, static_cast<int>(-pos.z));
//assertGl();
}
else {
//non directional light
//push projection
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
//assertGl();
gluPerspective(perspFov, 1.f, perspNearPlane, perspFarPlane);
//const Metrics &metrics= Metrics::getInstance();
//gluPerspective(perspFov, metrics.getAspectRatio(), perspNearPlane, perspFarPlane);
assertGl();
//push modelview
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glRotatef(-90, -1, 0, 0);
glTranslatef(-nearestLightPos.x, -nearestLightPos.y-2, -nearestLightPos.z);
//assertGl();
}
if(shadows == sShadowMapping) {
glEnable(GL_POLYGON_OFFSET_FILL);
glPolygonOffset(1.0f, 16.0f);
//assertGl();
}
//render 3d
renderUnitsFast(true);
renderObjectsFast(true,false);
//assertGl();
//read color buffer
glBindTexture(GL_TEXTURE_2D, shadowMapHandle);
assertGl();
glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, shadowTextureSize, shadowTextureSize);
GLenum error = glGetError();
// This error can happen when a Linux user switches from an X session
// back to a running game, and 'seems' to be safe to ignore it
if(error != GL_INVALID_OPERATION) {
assertGlWithErrorNumber(error);
}
//get elemental matrices
static Matrix4f matrix1;
static bool matrix1Populate = true;
if(matrix1Populate == true) {
matrix1Populate = false;
matrix1[0]= 0.5f; matrix1[4]= 0.f; matrix1[8]= 0.f; matrix1[12]= 0.5f;
matrix1[1]= 0.f; matrix1[5]= 0.5f; matrix1[9]= 0.f; matrix1[13]= 0.5f;
matrix1[2]= 0.f; matrix1[6]= 0.f; matrix1[10]= 0.5f; matrix1[14]= 0.5f;
matrix1[3]= 0.f; matrix1[7]= 0.f; matrix1[11]= 0.f; matrix1[15]= 1.f;
}
Matrix4f matrix2;
glGetFloatv(GL_PROJECTION_MATRIX, matrix2.ptr());
//assertGl();
Matrix4f matrix3;
glGetFloatv(GL_MODELVIEW_MATRIX, matrix3.ptr());
//pop both matrices
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPushMatrix();
//assertGl();
//compute texture matrix
glLoadMatrixf(matrix1.ptr());
glMultMatrixf(matrix2.ptr());
glMultMatrixf(matrix3.ptr());
glGetFloatv(GL_TRANSPOSE_PROJECTION_MATRIX_ARB, shadowMapMatrix.ptr());
//assertGl();
//if(shadows == sShadowMapping) {
// glDisable(GL_POLYGON_OFFSET_FILL);
// glPolygonOffset(0.0f, 0.0f);
//}
//pop
glPopMatrix();
//assertGl();
glPopAttrib();
assertGl();
}
}
}
// ==================== gl wrap ====================
string Renderer::getGlInfo(){
string infoStr="";
Lang &lang= Lang::getInstance();
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == false) {
infoStr+= lang.getString("OpenGlInfo")+":\n";
infoStr+= " "+lang.getString("OpenGlVersion")+": ";
infoStr+= string((getGlVersion() != NULL ? getGlVersion() : "?"))+"\n";
infoStr+= " "+lang.getString("OpenGlRenderer")+": ";
infoStr+= string((getGlVersion() != NULL ? getGlVersion() : "?"))+"\n";
infoStr+= " "+lang.getString("OpenGlVendor")+": ";
infoStr+= string((getGlVendor() != NULL ? getGlVendor() : "?"))+"\n";
infoStr+= " "+lang.getString("OpenGlMaxLights")+": ";
infoStr+= intToStr(getGlMaxLights())+"\n";
infoStr+= " "+lang.getString("OpenGlMaxTextureSize")+": ";
infoStr+= intToStr(getGlMaxTextureSize())+"\n";
infoStr+= " "+lang.getString("OpenGlMaxTextureUnits")+": ";
infoStr+= intToStr(getGlMaxTextureUnits())+"\n";
infoStr+= " "+lang.getString("OpenGlModelviewStack")+": ";
infoStr+= intToStr(getGlModelviewMatrixStackDepth())+"\n";
infoStr+= " "+lang.getString("OpenGlProjectionStack")+": ";
infoStr+= intToStr(getGlProjectionMatrixStackDepth())+"\n";
}
return infoStr;
}
string Renderer::getGlMoreInfo(){
string infoStr="";
Lang &lang= Lang::getInstance();
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == false) {
//gl extensions
infoStr+= lang.getString("OpenGlExtensions")+":\n ";
string extensions= getGlExtensions();
int charCount= 0;
for(int i = 0; i < (int)extensions.size(); ++i) {
infoStr+= extensions[i];
if(charCount>120 && extensions[i]==' '){
infoStr+= "\n ";
charCount= 0;
}
++charCount;
}
//platform extensions
infoStr+= "\n\n";
infoStr+= lang.getString("OpenGlPlatformExtensions")+":\n ";
charCount= 0;
string platformExtensions= getGlPlatformExtensions();
for(int i = 0; i < (int)platformExtensions.size(); ++i) {
infoStr+= platformExtensions[i];
if(charCount>120 && platformExtensions[i]==' '){
infoStr+= "\n ";
charCount= 0;
}
++charCount;
}
}
return infoStr;
}
void Renderer::autoConfig() {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == false) {
Config &config= Config::getInstance();
bool nvidiaCard= toLower(getGlVendor()).find("nvidia")!=string::npos;
bool atiCard= toLower(getGlVendor()).find("ati")!=string::npos;
//bool shadowExtensions = isGlExtensionSupported("GL_ARB_shadow") && isGlExtensionSupported("GL_ARB_shadow_ambient");
bool shadowExtensions = isGlExtensionSupported("GL_ARB_shadow");
//3D textures
config.setBool("Textures3D", isGlExtensionSupported("GL_EXT_texture3D"));
//shadows
string shadows="";
if(getGlMaxTextureUnits()>=3){
if(nvidiaCard && shadowExtensions){
shadows= shadowsToStr(sShadowMapping);
}
else{
shadows= shadowsToStr(sProjected);
}
}
else{
shadows=shadowsToStr(sDisabled);
}
config.setString("Shadows", shadows);
//lights
config.setInt("MaxLights", atiCard? 1: 4);
//filter
config.setString("Filter", "Bilinear");
}
}
void Renderer::clearBuffers() {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
void Renderer::clearZBuffer() {
glClear(GL_DEPTH_BUFFER_BIT);
}
void Renderer::loadConfig() {
Config &config= Config::getInstance();
//cache most used config params
maxLights= config.getInt("MaxLights");
photoMode= config.getBool("PhotoMode");
focusArrows= config.getBool("FocusArrows");
textures3D= config.getBool("Textures3D");
float gammaValue=config.getFloat("GammaValue","0.0");
if(this->program == NULL) {
throw megaglest_runtime_error("this->program == NULL");
}
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == false) {
//if(this->program != NULL) {
if(gammaValue != 0.0) {
this->program->getWindow()->setGamma(gammaValue);
}
//}
}
//load shadows
shadows= strToShadows(config.getString("Shadows"));
if(shadows==sProjected || shadows==sShadowMapping){
shadowTextureSize= config.getInt("ShadowTextureSize");
shadowFrameSkip= config.getInt("ShadowFrameSkip");
shadowIntensity= config.getFloat("ShadowIntensity","1.0");
}
//load filter settings
Texture2D::Filter textureFilter= strToTextureFilter(config.getString("Filter"));
int maxAnisotropy= config.getInt("FilterMaxAnisotropy");
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == false) {
for(int i=0; i<rsCount; ++i){
textureManager[i]->setFilter(textureFilter);
textureManager[i]->setMaxAnisotropy(maxAnisotropy);
}
}
}
//Texture2D *Renderer::saveScreenToTexture(int x, int y, int width, int height) {
// if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
//
// Config &config= Config::getInstance();
// Texture2D::Filter textureFilter = strToTextureFilter(config.getString("Filter"));
// int maxAnisotropy = config.getInt("FilterMaxAnisotropy");
//
// Texture2D *texture = GraphicsInterface::getInstance().getFactory()->newTexture2D();
// texture->setForceCompressionDisabled(true);
// texture->setMipmap(false);
// Pixmap2D *pixmapScreenShot = texture->getPixmap();
// pixmapScreenShot->init(width, height, 3);
// texture->init(textureFilter,maxAnisotropy);
//
// if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
// //glFinish();
//
// if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
// glReadPixels(x, y, pixmapScreenShot->getW(), pixmapScreenShot->getH(),
// GL_RGB, GL_UNSIGNED_BYTE, pixmapScreenShot->getPixels());
//
// if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
//
// return texture;
//}
void Renderer::saveScreen(const string &path,int w, int h) {
const Metrics &sm= Metrics::getInstance();
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
Pixmap2D *pixmapScreenShot = new Pixmap2D(sm.getScreenW(),sm.getScreenH(), 3);
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
//glFinish();
glPixelStorei(GL_PACK_ALIGNMENT, 1);
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
glReadPixels(0, 0, pixmapScreenShot->getW(), pixmapScreenShot->getH(),
GL_RGB, GL_UNSIGNED_BYTE, pixmapScreenShot->getPixels());
if(w==0 || h==0){
h=sm.getScreenH();
w=sm.getScreenW();
}
else{
pixmapScreenShot->Scale(GL_RGB,w,h);
}
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
// Signal the threads queue to add a screenshot save request
MutexSafeWrapper safeMutex(saveScreenShotThreadAccessor,string(extractFileFromDirectoryPath(__FILE__).c_str()) + "_" + intToStr(__LINE__));
saveScreenQueue.push_back(make_pair(path,pixmapScreenShot));
safeMutex.ReleaseLock();
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
}
unsigned int Renderer::getSaveScreenQueueSize() {
MutexSafeWrapper safeMutex(saveScreenShotThreadAccessor,string(extractFileFromDirectoryPath(__FILE__).c_str()) + "_" + intToStr(__LINE__));
int queueSize = (int)saveScreenQueue.size();
safeMutex.ReleaseLock();
return queueSize;
}
// ==================== PRIVATE ====================
float Renderer::computeSunAngle(float time) {
float dayTime= TimeFlow::dusk-TimeFlow::dawn;
float fTime= (time-TimeFlow::dawn)/dayTime;
return clamp(fTime*pi, pi/8.f, 7.f*pi/8.f);
}
float Renderer::computeMoonAngle(float time) {
float nightTime= 24-(TimeFlow::dusk-TimeFlow::dawn);
if(time<TimeFlow::dawn){
time+= 24.f;
}
float fTime= (time-TimeFlow::dusk)/nightTime;
return clamp((1.0f-fTime)*pi, pi/8.f, 7.f*pi/8.f);
}
Vec4f Renderer::computeSunPos(float time) {
float ang= computeSunAngle(time);
return Vec4f(-std::cos(ang)*sunDist, std::sin(ang)*sunDist, 0.f, 0.f);
}
Vec4f Renderer::computeMoonPos(float time) {
float ang= computeMoonAngle(time);
return Vec4f(-std::cos(ang)*moonDist, std::sin(ang)*moonDist, 0.f, 0.f);
}
// ==================== fast render ====================
//render units for selection purposes
vector<Unit *> Renderer::renderUnitsFast(bool renderingShadows, bool colorPickingSelection) {
vector<Unit *> unitsList;
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return unitsList;
}
assert(game != NULL);
//const World *world= game->getWorld();
//assert(world != NULL);
VisibleQuadContainerCache &qCache = getQuadCache();
if(qCache.visibleQuadUnitList.empty() == false) {
if(colorPickingSelection == true) {
unitsList.reserve(qCache.visibleQuadUnitList.size());
}
bool modelRenderStarted = false;
bool renderOnlyBuildings=true;
for(int k=0; k<2 ;k++) {
if(k==0){
//glDisable(GL_DEPTH_TEST);
renderOnlyBuildings=true;
}
else {
if(colorPickingSelection == true){
// clear depth buffer to get units behind buildings rendered in front of them
glClear(GL_DEPTH_BUFFER_BIT);
}
//glEnable(GL_DEPTH_TEST);
renderOnlyBuildings=false;
}
for(int visibleUnitIndex = 0;
visibleUnitIndex < (int)qCache.visibleQuadUnitList.size(); ++visibleUnitIndex) {
Unit *unit = qCache.visibleQuadUnitList[visibleUnitIndex];
if(renderingShadows==false && unit->isAlive()==false){
// no need to render dead units for selection
continue;
}
if(renderOnlyBuildings==true && unit->getType()->hasSkillClass(scMove)){
continue;
}
if(renderOnlyBuildings==false && !unit->getType()->hasSkillClass(scMove)){
continue;
}
if(modelRenderStarted == false) {
modelRenderStarted = true;
if(colorPickingSelection == false) {
//glPushAttrib(GL_ENABLE_BIT| GL_TEXTURE_BIT);
glDisable(GL_LIGHTING);
if (renderingShadows == false) {
glPushAttrib(GL_ENABLE_BIT);
glDisable(GL_TEXTURE_2D);
}
else {
glPushAttrib(GL_ENABLE_BIT| GL_TEXTURE_BIT);
glEnable(GL_TEXTURE_2D);
glAlphaFunc(GL_GREATER, 0.4f);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
//set color to the texture alpha
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_PRIMARY_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
//set alpha to the texture alpha
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
}
}
modelRenderer->begin(false, renderingShadows, false, colorPickingSelection);
if(colorPickingSelection == false) {
glInitNames();
}
}
if(colorPickingSelection == false) {
glPushName(visibleUnitIndex);
}
//assertGl();
glMatrixMode(GL_MODELVIEW);
//debuxar modelo
glPushMatrix();
//translate
Vec3f currVec= unit->getCurrVectorFlat();
glTranslatef(currVec.x, currVec.y, currVec.z);
//rotate
glRotatef(unit->getRotation(), 0.f, 1.f, 0.f);
//render
Model *model= unit->getCurrentModelPtr();
//if(this->gameCamera->getPos().dist(unit->getCurrVector()) <= SKIP_INTERPOLATION_DISTANCE) {
// ***MV don't think this is needed below 2013/01/11
model->updateInterpolationVertices(unit->getAnimProgressAsFloat(), unit->isAlive() && !unit->isAnimProgressBound());
//}
if(colorPickingSelection == true) {
unit->setUniquePickingColor();
unitsList.push_back(unit);
}
modelRenderer->render(model,renderingShadows?rmShadows:rmSelection);
glPopMatrix();
if(colorPickingSelection == false) {
glPopName();
}
}
}
if(modelRenderStarted == true) {
modelRenderer->end();
if(colorPickingSelection == false) {
glPopAttrib();
}
}
}
//glDisable(GL_DEPTH_TEST);
return unitsList;
}
//render objects for selection purposes
vector<Object *> Renderer::renderObjectsFast(bool renderingShadows, bool resourceOnly,
bool colorPickingSelection) {
vector<Object *> objectList;
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return objectList;
}
VisibleQuadContainerCache &qCache = getQuadCache();
if(qCache.visibleObjectList.empty() == false) {
if(colorPickingSelection == true) {
objectList.reserve(qCache.visibleObjectList.size());
}
bool modelRenderStarted = false;
for(int visibleIndex = 0;
visibleIndex < (int)qCache.visibleObjectList.size(); ++visibleIndex) {
Object *o = qCache.visibleObjectList[visibleIndex];
if(modelRenderStarted == false) {
modelRenderStarted = true;
if(colorPickingSelection == false) {
glDisable(GL_LIGHTING);
if (renderingShadows == false){
glPushAttrib(GL_ENABLE_BIT);
glDisable(GL_TEXTURE_2D);
}
else {
glPushAttrib(GL_ENABLE_BIT| GL_TEXTURE_BIT);
glAlphaFunc(GL_GREATER, 0.5f);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
//set color to the texture alpha
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_PRIMARY_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
//set alpha to the texture alpha
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
}
}
modelRenderer->begin(false, renderingShadows, false, colorPickingSelection);
if(colorPickingSelection == false) {
glInitNames();
}
}
if(resourceOnly == false || o->getResource()!= NULL) {
Model *objModel= o->getModelPtr();
//if(this->gameCamera->getPos().dist(o->getPos()) <= SKIP_INTERPOLATION_DISTANCE) {
// ***MV don't think this is needed below 2013/01/11
//objModel->updateInterpolationData(o->getAnimProgress(), true);
//}
const Vec3f v= o->getConstPos();
if(colorPickingSelection == false) {
glPushName(OBJECT_SELECT_OFFSET+visibleIndex);
}
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glTranslatef(v.x, v.y, v.z);
glRotatef(o->getRotation(), 0.f, 1.f, 0.f);
if(colorPickingSelection == true) {
o->setUniquePickingColor();
objectList.push_back(o);
}
modelRenderer->render(objModel,resourceOnly?rmSelection:rmNormal);
glPopMatrix();
if(colorPickingSelection == false) {
glPopName();
}
}
}
if(modelRenderStarted == true) {
modelRenderer->end();
if(colorPickingSelection == false) {
glPopAttrib();
}
}
}
return objectList;
}
// ==================== gl caps ====================
void Renderer::checkGlCaps() {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
if(glActiveTexture == NULL) {
string message;
message += "Your system supports OpenGL version [";
message += getGlVersion() + string("]\n");
message += "MegaGlest needs a version that supports\n";
message += "glActiveTexture (OpenGL 1.3) or the ARB_multitexture extension.";
throw megaglest_runtime_error(message.c_str(),true);
}
//opengl 2.1
if(glewIsSupported("GL_VERSION_2_1") == false) {
string message;
message += "Your system supports OpenGL version [";
message += getGlVersion() + string("]\n");
message += "MegaGlest needs at least version 2.1 to work\n";
message += "You may solve this problem by installing your latest video card drivers";
throw megaglest_runtime_error(message.c_str(),true);
}
//opengl 1.4 or extension
//if(!isGlVersionSupported(1, 4, 0)){
if(glewIsSupported("GL_VERSION_1_4") == false) {
checkExtension("GL_ARB_texture_env_crossbar", "MegaGlest");
}
}
void Renderer::checkGlOptionalCaps() {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
//shadows
if(shadows == sProjected || shadows == sShadowMapping) {
if(getGlMaxTextureUnits() < 3) {
throw megaglest_runtime_error("Your system doesn't support 3 texture units, required for shadows");
}
}
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
//shadow mapping
if(shadows == sShadowMapping) {
checkExtension("GL_ARB_shadow", "Shadow Mapping");
//checkExtension("GL_ARB_shadow_ambient", "Shadow Mapping");
//checkExtension("GL_ARB_depth_texture", "Shadow Mapping");
}
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
}
void Renderer::checkExtension(const string &extension, const string &msg) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
if(!isGlExtensionSupported(extension.c_str())) {
string str= "OpenGL extension not supported: " + extension + ", required for " + msg;
throw megaglest_runtime_error(str);
}
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
}
// ==================== init 3d lists ====================
void Renderer::init3dList() {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
render3dSetup();
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
//const Metrics &metrics= Metrics::getInstance();
//assertGl();
//if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
//list3d= glGenLists(1);
//assertGl();
//list3dValid=true;
//if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
//glNewList(list3d, GL_COMPILE_AND_EXECUTE);
//need to execute, because if not gluPerspective takes no effect and gluLoadMatrix is wrong
//render3dSetup();
//glEndList();
//if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
//assert
//assertGl();
}
void Renderer::render3dSetup() {
//if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
const Metrics &metrics= Metrics::getInstance();
//if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
//misc
glViewport(0, 0, metrics.getScreenW(), metrics.getScreenH());
glClearColor(fowColor.x, fowColor.y, fowColor.z, fowColor.w);
glFrontFace(GL_CW);
glEnable(GL_CULL_FACE);
loadProjectionMatrix();
//if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
//if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
//texture state
glActiveTexture(shadowTexUnit);
glDisable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glActiveTexture(fowTexUnit);
glDisable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glActiveTexture(baseTexUnit);
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
//if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
//if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
//material state
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, defSpecularColor.ptr());
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, defAmbientColor.ptr());
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, defDiffuseColor.ptr());
glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
glColor4fv(defColor.ptr());
//blend state
glDisable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
//if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
//alpha test state
glEnable(GL_ALPHA_TEST);
glAlphaFunc(GL_GREATER, 0.f);
//depth test state
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_TRUE);
glDepthFunc(GL_LESS);
//if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
//lighting state
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
//matrix mode
glMatrixMode(GL_MODELVIEW);
//stencil test
glDisable(GL_STENCIL_TEST);
//if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
//if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
//fog
const Tileset *tileset= NULL;
if(game != NULL && game->getWorld() != NULL) {
//if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
tileset = game->getWorld()->getTileset();
}
//if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
if(tileset != NULL && tileset->getFog()) {
//if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
glEnable(GL_FOG);
if(tileset->getFogMode()==fmExp) {
glFogi(GL_FOG_MODE, GL_EXP);
}
else {
glFogi(GL_FOG_MODE, GL_EXP2);
}
glFogf(GL_FOG_DENSITY, tileset->getFogDensity());
glFogfv(GL_FOG_COLOR, tileset->getFogColor().ptr());
}
//if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
}
void Renderer::init2dList() {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
// //this list sets the state for the 2d rendering
// list2d= glGenLists(1);
// assertGl();
// list2dValid=true;
//
// glNewList(list2d, GL_COMPILE);
// render2dMenuSetup();
// glEndList();
//
// assertGl();
}
void Renderer::render2dMenuSetup() {
//if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
const Metrics &metrics= Metrics::getInstance();
//projection
glViewport(0, 0, metrics.getScreenW(), metrics.getScreenH());
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0, metrics.getVirtualW(), 0, metrics.getVirtualH(), 0, 1);
//if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
//modelview
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
//if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
//disable everything
glDisable(GL_BLEND);
glDisable(GL_LIGHTING);
glDisable(GL_ALPHA_TEST);
glDisable(GL_DEPTH_TEST);
glDisable(GL_STENCIL_TEST);
glDisable(GL_FOG);
glDisable(GL_CULL_FACE);
glFrontFace(GL_CCW);
//if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
if(glActiveTexture != NULL) {
glActiveTexture(baseTexUnit);
}
else {
char szBuf[8096]="";
snprintf(szBuf,8096,"In [%s::%s] Line: %d\nglActiveTexture == NULL\nglActiveTexture is only supported if the GL version is 1.3 or greater,\nor if the ARB_multitexture extension is supported!",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
throw megaglest_runtime_error(szBuf);
}
//if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glDisable(GL_TEXTURE_2D);
//if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
//blend func
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
//color
glColor4f(1.f, 1.f, 1.f, 1.f);
//if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
}
//void Renderer::init3dListMenu(const MainMenu *mm) {
// if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
// return;
// }
//
// //this->mm3d = mm;
// //printf("In [%s::%s Line: %d] this->custom_mm3d [%p] this->mm3d [%p]\n",__FILE__,__FUNCTION__,__LINE__,this->custom_mm3d,this->mm3d);
//
///*
// assertGl();
//
// if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
//
// const Metrics &metrics= Metrics::getInstance();
// //const MenuBackground *mb= mm->getConstMenuBackground();
// const MenuBackground *mb = NULL;
// if(mm != NULL) {
// mb = mm->getConstMenuBackground();
// }
//
// if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
//
// if(this->customlist3dMenu != NULL) {
// *this->customlist3dMenu = glGenLists(1);
// assertGl();
// }
// else {
// list3dMenu= glGenLists(1);
// assertGl();
// list3dMenuValid=true;
// }
//
// if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
//
// if(this->customlist3dMenu != NULL) {
// glNewList(*this->customlist3dMenu, GL_COMPILE);
// }
// else {
// glNewList(list3dMenu, GL_COMPILE);
// }
//
// if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
// //misc
// glViewport(0, 0, metrics.getScreenW(), metrics.getScreenH());
// glClearColor(0.4f, 0.4f, 0.4f, 1.f);
// glFrontFace(GL_CW);
// glEnable(GL_CULL_FACE);
// glMatrixMode(GL_PROJECTION);
// glLoadIdentity();
// gluPerspective(perspFov, metrics.getAspectRatio(), perspNearPlane, 1000000);
//
// //texture state
// glEnable(GL_TEXTURE_2D);
// glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
//
// //material state
// glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, defSpecularColor.ptr());
// glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, defAmbientColor.ptr());
// glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, defDiffuseColor.ptr());
// glColor4fv(defColor.ptr());
// glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
//
// //blend state
// glDisable(GL_BLEND);
// glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
//
// //alpha test state
// glEnable(GL_ALPHA_TEST);
// glAlphaFunc(GL_GREATER, 0.f);
//
// //depth test state
// glEnable(GL_DEPTH_TEST);
// glDepthMask(GL_TRUE);
// glDepthFunc(GL_LESS);
//
// //lighting state
// glEnable(GL_LIGHTING);
//
// //matrix mode
// glMatrixMode(GL_MODELVIEW);
//
// //stencil test
// glDisable(GL_STENCIL_TEST);
//
// if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
//
// //fog
// if(mb != NULL && mb->getFog()){
// if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
//
// glEnable(GL_FOG);
// glFogi(GL_FOG_MODE, GL_EXP2);
// glFogf(GL_FOG_DENSITY, mb->getFogDensity());
// }
//
// if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
//
// glEndList();
//
// if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
//
// //assert
// assertGl();
//*/
//}
void Renderer::render3dMenuSetup(const MainMenu *mm) {
//if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
const Metrics &metrics= Metrics::getInstance();
const MenuBackground *mb = NULL;
if(mm != NULL) {
mb = mm->getConstMenuBackground();
}
//if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
//misc
glViewport(0, 0, metrics.getScreenW(), metrics.getScreenH());
glClearColor(0.4f, 0.4f, 0.4f, 1.f);
glFrontFace(GL_CW);
glEnable(GL_CULL_FACE);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(perspFov, metrics.getAspectRatio(), perspNearPlane, 1000000);
//texture state
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
//material state
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, defSpecularColor.ptr());
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, defAmbientColor.ptr());
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, defDiffuseColor.ptr());
glColor4fv(defColor.ptr());
glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
//blend state
glDisable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
//alpha test state
glEnable(GL_ALPHA_TEST);
glAlphaFunc(GL_GREATER, 0.f);
//depth test state
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_TRUE);
glDepthFunc(GL_LESS);
//lighting state
glEnable(GL_LIGHTING);
//matrix mode
glMatrixMode(GL_MODELVIEW);
//stencil test
glDisable(GL_STENCIL_TEST);
//if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
//fog
if(mb != NULL && mb->getFog()) {
//if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
glEnable(GL_FOG);
glFogi(GL_FOG_MODE, GL_EXP2);
glFogf(GL_FOG_DENSITY, mb->getFogDensity());
}
//assert
assertGl();
//if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
}
// ==================== misc ====================
void Renderer::loadProjectionMatrix() {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
GLdouble clipping;
const Metrics &metrics= Metrics::getInstance();
assertGl();
clipping= photoMode ? perspFarPlane*100 : perspFarPlane;
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(perspFov, metrics.getAspectRatio(), perspNearPlane, clipping);
assertGl();
}
void Renderer::enableProjectiveTexturing() {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
glTexGenfv(GL_S, GL_EYE_PLANE, &shadowMapMatrix[0]);
glTexGenfv(GL_T, GL_EYE_PLANE, &shadowMapMatrix[4]);
glTexGenfv(GL_R, GL_EYE_PLANE, &shadowMapMatrix[8]);
glTexGenfv(GL_Q, GL_EYE_PLANE, &shadowMapMatrix[12]);
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
glEnable(GL_TEXTURE_GEN_R);
glEnable(GL_TEXTURE_GEN_Q);
}
// ==================== private aux drawing ====================
void Renderer::renderHealthBar(Vec3f v, Unit *unit, float height, bool lineBorder, const Texture2D *texture, const Texture2D *backgroundTexture) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
int numberOfBars=1;
int barCount=0;
float hp=unit->getHpRatio();
float ep=-1.f;
if(unit->getType()->getTotalMaxEp(unit->getTotalUpgrade()) !=0 ) {
ep=unit->getEpRatio();
numberOfBars++;
}
int productionPercent=unit->getProductionPercent();
if(productionPercent!=-1) {
numberOfBars++;
}
int size=unit->getType()->getSize();
Vec3f rightVector;
Vec3f upVector;
Vec3f rightVectorTexture;
Vec3f upVectorTexture;
v.y+=1;
float modelview[16];
float width=(float)size/6+0.25f;
float red;
float green;
float brightness=0.8f;
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
// get the current modelview state
glGetFloatv(GL_MODELVIEW_MATRIX , modelview);
rightVector= Vec3f(modelview[0], modelview[4], modelview[8]);
upVector= Vec3f(modelview[1], modelview[5], modelview[9]);
rightVectorTexture=rightVector*2;
upVectorTexture=upVector*4;
//from green to yellow to red
if(hp >= 0.75f) {
green=1;
red=1-((2*hp-1)-0.5f);
} else {
red=1;
green=0.5f+(2*hp-1);
}
if(red>1.0f) red=1.0f;
if(green>1.0f) green=1.0f;
float yOffset=(float)numberOfBars/2.f;
if(backgroundTexture!=NULL) {
//backgroundTexture
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, static_cast<const Texture2DGl*>(backgroundTexture)->getHandle());
glColor4f(1.f,1.f,1.f,1.f);
//glColor4f(red+0.1f,green+0.1f,0.1f,0.5f);
glBegin(GL_QUADS);
glTexCoord2i(0,1);
glVertex3fv((v - (rightVectorTexture*width - upVectorTexture*height*yOffset)).ptr());
glTexCoord2i(0,0);
glVertex3fv((v - (rightVectorTexture*width + upVectorTexture*height*yOffset)).ptr());
glTexCoord2i(1,0);
glVertex3fv((v + (rightVectorTexture*width - upVectorTexture*height*yOffset)).ptr());
glTexCoord2i(1,1);
glVertex3fv((v + (rightVectorTexture*width + upVectorTexture*height*yOffset)).ptr());
glEnd();
glDisable(GL_TEXTURE_2D);
}
//healthbar
glColor4f(red*brightness,green*brightness,0.0f,0.4f);
//hpbar
barCount++;
internalRenderHp(numberOfBars,barCount,hp,v,width,height,rightVector,upVector);
if(ep > -1.0f) {
//epbar
barCount++;
//glColor4f(brightness,0,brightness,0.5f);
glColor4f(.15f*brightness,0.3f*brightness,0.8f*brightness,0.7f);
internalRenderHp(numberOfBars,barCount,ep,v,width,height,rightVector,upVector);
}
if(productionPercent!=-1) {
barCount++;
glColor4f(brightness,0,brightness,0.6f);
//glColor4f(0.0f*brightness,0.4f*brightness,0.2f*brightness,0.8f);
internalRenderHp(numberOfBars,barCount,(float)productionPercent/100,v,width,height,rightVector,upVector);
}
// glBegin(GL_QUADS);
// if(ep < -2.0f) {
// //hpbar
// glVertex3fv((v - (rightVector*width - upVector*height)).ptr());
// glVertex3fv((v - (rightVector*width + upVector*height)).ptr());
// glVertex3fv((v + (rightVector*hp*width - upVector*height)).ptr());
// glVertex3fv((v + (rightVector*hp*width + upVector*height)).ptr());
//
// } else {
// //hpbar
// glVertex3fv((v - (rightVector*width - upVector*height)).ptr());
// glVertex3fv((v - (rightVector*width + upVector*height*0.0f)).ptr());
// glVertex3fv((v + (rightVector*hp*width - upVector*height*0.0f)).ptr());
// glVertex3fv((v + (rightVector*hp*width + upVector*height)).ptr());
// //epbar
// glColor4f(brightness,0,brightness,0.4f);
// glVertex3fv((v - (rightVector*width + upVector*height*0.0f)).ptr());
// glVertex3fv((v - (rightVector*width + upVector*height)).ptr());
// glVertex3fv((v + (rightVector*ep*width - upVector*height)).ptr());
// glVertex3fv((v + (rightVector*ep*width - upVector*height*0.0f)).ptr());
// }
// glEnd();
if(lineBorder) {
//border
glColor4f(red*brightness,green*brightness,0.1f*brightness,0.5f);
glBegin(GL_LINE_LOOP);
glVertex3fv((v - (rightVector*width - upVector*height*yOffset)).ptr());
glVertex3fv((v - (rightVector*width + upVector*height*yOffset)).ptr());
glVertex3fv((v + (rightVector*width - upVector*height*yOffset)).ptr());
glVertex3fv((v + (rightVector*width + upVector*height*yOffset)).ptr());
glEnd();
}
if(texture!=NULL) {
//BorderTexture
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, static_cast<const Texture2DGl*>(texture)->getHandle());
glColor4f(1.f,1.f,1.f,1.f);
//glColor4f(red+0.1f,green+0.1f,0.1f,0.5f);
glBegin(GL_QUADS);
glTexCoord2i(0,1);
glVertex3fv((v - (rightVectorTexture*width - upVectorTexture*height*yOffset)).ptr());
glTexCoord2i(0,0);
glVertex3fv((v - (rightVectorTexture*width + upVectorTexture*height*yOffset)).ptr());
glTexCoord2i(1,0);
glVertex3fv((v + (rightVectorTexture*width - upVectorTexture*height*yOffset)).ptr());
glTexCoord2i(1,1);
glVertex3fv((v + (rightVectorTexture*width + upVectorTexture*height*yOffset)).ptr());
glEnd();
glDisable(GL_TEXTURE_2D);
}
glPopMatrix();
}
void Renderer::internalRenderHp(int numberOfBars, int barNumber, float hp,
Vec3f posVector, float width, float singleHPheight, Vec3f rightVector, Vec3f upVector) {
float yOffset=(float)numberOfBars*singleHPheight/2;
float offsetTop=yOffset-singleHPheight*(barNumber-1);
float offsetBottom=yOffset-singleHPheight*barNumber;
offsetBottom=offsetBottom*-1;
hp=hp*2-1;
glBegin(GL_QUADS);
glVertex3fv((posVector - (rightVector*width - upVector*offsetTop)).ptr());
glVertex3fv((posVector - (rightVector*width + upVector*offsetBottom)).ptr());
glVertex3fv((posVector + (rightVector*hp*width - upVector*offsetBottom)).ptr());
glVertex3fv((posVector + (rightVector*hp*width + upVector*offsetTop)).ptr());
glEnd();
}
void Renderer::renderSelectionCircle(Vec3f v, int size, float radius, float thickness) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
GLUquadricObj *disc;
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glTranslatef(v.x, v.y, v.z);
glRotatef(90.f, 1.f, 0.f, 0.f);
disc= gluNewQuadric();
gluQuadricDrawStyle(disc, GLU_FILL);
gluCylinder(disc, radius*(size-thickness), radius*size, thickness, 30, 1);
gluDeleteQuadric(disc);
glPopMatrix();
// glBegin (GL_QUAD_STRIP);
// for (float k = 0; k <= 180; k=k+1) {
// float j=degToRad(k);
// glVertex3f(v.x+std::cos(j)*.9*radius*size, v.y+thickness, v.z+std::sin(j)*.9*radius*size);
// glVertex3f(v.x+std::cos(j)*radius*size, v.y, v.z+std::sin(j)*radius*size);
// }
// glEnd();
}
void Renderer::renderArrow(const Vec3f &pos1, const Vec3f &pos2,
const Vec3f &color, float width) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
Config &config= Config::getInstance();
if(config.getBool("RecordMode","false") == true) {
return;
}
const int tesselation= 3;
const float arrowEndSize= 0.4f;
const float maxlen= 25;
const float blendDelay= 5.f;
Vec3f dir= Vec3f(pos2-pos1);
float len= dir.length();
if(len>maxlen) {
return;
}
float alphaFactor= clamp((maxlen-len)/blendDelay, 0.f, 1.f);
dir.normalize();
Vec3f normal= dir.cross(Vec3f(0, 1, 0));
Vec3f pos2Left= pos2 + normal*(width-0.05f) - dir*arrowEndSize*width;
Vec3f pos2Right= pos2 - normal*(width-0.05f) - dir*arrowEndSize*width;
Vec3f pos1Left= pos1 + normal*(width+0.05f);
Vec3f pos1Right= pos1 - normal*(width+0.05f);
//arrow body
glBegin(GL_TRIANGLE_STRIP);
for(int i=0; i<=tesselation; ++i) {
float t= static_cast<float>(i)/tesselation;
Vec3f a= pos1Left.lerp(t, pos2Left);
Vec3f b= pos1Right.lerp(t, pos2Right);
Vec4f c= Vec4f(color, t*0.25f*alphaFactor);
glColor4fv(c.ptr());
glVertex3fv(a.ptr());
glVertex3fv(b.ptr());
}
glEnd();
//arrow end
glBegin(GL_TRIANGLES);
glVertex3fv((pos2Left + normal*(arrowEndSize-0.1f)).ptr());
glVertex3fv((pos2Right - normal*(arrowEndSize-0.1f)).ptr());
glVertex3fv((pos2 + dir*(arrowEndSize-0.1f)).ptr());
glEnd();
}
void Renderer::renderProgressBar3D(int size, int x, int y, Font3D *font, int customWidth,
string prefixLabel,bool centeredText,int customHeight) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
// Makiong this smaller than 14 is a bad idea (since the font size is never smaller than that)
int progressbarHeight = (customHeight > 0 ? customHeight : 14);
int currentSize = size;
int maxSize = maxProgressBar;
string renderText = intToStr(static_cast<int>(size)) + "%";
if(customWidth > 0) {
if(size > 0) {
currentSize = (int)((double)customWidth * ((double)size / 100.0));
}
maxSize = customWidth;
//if(maxSize <= 0) {
// maxSize = maxProgressBar;
//}
}
if(prefixLabel != "") {
renderText = prefixLabel + renderText;
}
//bar
glBegin(GL_QUADS);
glColor4fv(progressBarFront2.ptr());
glVertex2i(x, y);
glVertex2i(x, y + progressbarHeight);
glColor4fv(progressBarFront1.ptr());
glVertex2i(x + currentSize, y + progressbarHeight);
glVertex2i(x + currentSize, y);
glEnd();
//transp bar
glEnable(GL_BLEND);
glBegin(GL_QUADS);
glColor4fv(progressBarBack2.ptr());
glVertex2i(x + currentSize, y);
glVertex2i(x + currentSize, y + progressbarHeight);
glColor4fv(progressBarBack1.ptr());
glVertex2i(x + maxSize, y + progressbarHeight);
glVertex2i(x + maxSize, y);
glEnd();
glDisable(GL_BLEND);
//text
//glColor3fv(defColor.ptr());
//printf("Render progress bar3d renderText [%s] y = %d, centeredText = %d\n",renderText.c_str(),y, centeredText);
renderTextBoundingBox3D(renderText, font, defColor, x, y, maxSize,
progressbarHeight, true, true, false,-1,-1);
}
void Renderer::renderProgressBar(int size, int x, int y, Font2D *font, int customWidth,
string prefixLabel,bool centeredText) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
int currentSize = size;
int maxSize = maxProgressBar;
string renderText = intToStr(static_cast<int>(size)) + "%";
if(customWidth > 0) {
if(size > 0) {
currentSize = (int)((double)customWidth * ((double)size / 100.0));
}
maxSize = customWidth;
//if(maxSize <= 0) {
// maxSize = maxProgressBar;
//}
}
if(prefixLabel != "") {
renderText = prefixLabel + renderText;
}
//bar
glBegin(GL_QUADS);
glColor4fv(progressBarFront2.ptr());
glVertex2i(x, y);
glVertex2i(x, y+10);
glColor4fv(progressBarFront1.ptr());
glVertex2i(x + currentSize, y+10);
glVertex2i(x + currentSize, y);
glEnd();
//transp bar
glEnable(GL_BLEND);
glBegin(GL_QUADS);
glColor4fv(progressBarBack2.ptr());
glVertex2i(x + currentSize, y);
glVertex2i(x + currentSize, y+10);
glColor4fv(progressBarBack1.ptr());
glVertex2i(x + maxSize, y+10);
glVertex2i(x + maxSize, y);
glEnd();
glDisable(GL_BLEND);
//text
glColor3fv(defColor.ptr());
//textRenderer->begin(font);
TextRendererSafeWrapper safeTextRender(textRenderer,font);
if(centeredText == true) {
textRenderer->render(renderText.c_str(), x + maxSize / 2, y, centeredText);
}
else {
textRenderer->render(renderText.c_str(), x, y, centeredText);
}
//textRenderer->end();
safeTextRender.end();
}
//void Renderer::renderTile(const Vec2i &pos) {
// if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
// return;
// }
//
// const Map *map= game->getWorld()->getMap();
// Vec2i scaledPos= pos * Map::cellScale;
//
// glMatrixMode(GL_MODELVIEW);
// glPushMatrix();
// glTranslatef(-0.5f, 0.f, -0.5f);
//
// glInitNames();
// for(int i=0; i < Map::cellScale; ++i) {
// for(int j=0; j < Map::cellScale; ++j) {
//
// Vec2i renderPos= scaledPos + Vec2i(i, j);
//
// glPushName(renderPos.y);
// glPushName(renderPos.x);
//
// glDisable(GL_CULL_FACE);
//
// float h1 = map->getCell(renderPos.x, renderPos.y)->getHeight();
// float h2 = map->getCell(renderPos.x, renderPos.y+1)->getHeight();
// float h3 = map->getCell(renderPos.x+1, renderPos.y)->getHeight();
// float h4 = map->getCell(renderPos.x+1, renderPos.y+1)->getHeight();
//
// glBegin(GL_TRIANGLE_STRIP);
// glVertex3f(
// static_cast<float>(renderPos.x),
// h1,
// static_cast<float>(renderPos.y));
// glVertex3f(
// static_cast<float>(renderPos.x),
// h2,
// static_cast<float>(renderPos.y+1));
// glVertex3f(
// static_cast<float>(renderPos.x+1),
// h3,
// static_cast<float>(renderPos.y));
// glVertex3f(
// static_cast<float>(renderPos.x+1),
// h4,
// static_cast<float>(renderPos.y+1));
// glEnd();
//
// glPopName();
// glPopName();
// }
// }
//
// glPopMatrix();
//}
void Renderer::renderQuad(int x, int y, int w, int h, const Texture2D *texture) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
if(texture == NULL) {
printf("\n**WARNING** detected a null texture to render in renderQuad!\n");
return;
}
if(w < 0) {
w = texture->getPixmapConst()->getW();
}
if(h < 0) {
h = texture->getPixmapConst()->getH();
}
glBindTexture(GL_TEXTURE_2D, static_cast<const Texture2DGl*>(texture)->getHandle());
glBegin(GL_TRIANGLE_STRIP);
glTexCoord2i(0, 1);
glVertex2i(x, y+h);
glTexCoord2i(0, 0);
glVertex2i(x, y);
glTexCoord2i(1, 1);
glVertex2i(x+w, y+h);
glTexCoord2i(1, 0);
glVertex2i(x+w, y);
glEnd();
}
Renderer::Shadows Renderer::strToShadows(const string &s){
if(s=="Projected"){
return sProjected;
}
else if(s=="ShadowMapping"){
return sShadowMapping;
}
return sDisabled;
}
string Renderer::shadowsToStr(Shadows shadows){
switch(shadows){
case sDisabled:
return "Disabled2";
case sProjected:
return "Projected";
case sShadowMapping:
return "ShadowMapping";
default:
assert(false);
return "";
}
}
Texture2D::Filter Renderer::strToTextureFilter(const string &s){
if(s=="Bilinear"){
return Texture2D::fBilinear;
}
else if(s=="Trilinear"){
return Texture2D::fTrilinear;
}
throw megaglest_runtime_error("Error converting from string to FilterType, found: "+s);
}
void Renderer::setAllowRenderUnitTitles(bool value) {
allowRenderUnitTitles = value;
}
// This method renders titles for units
void Renderer::renderUnitTitles3D(Font3D *font, Vec3f color) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
//std::map<int,bool> unitRenderedList;
if(visibleFrameUnitList.empty() == false) {
//printf("Render Unit titles ON\n");
for(int idx = 0; idx < (int)visibleFrameUnitList.size(); idx++) {
const Unit *unit = visibleFrameUnitList[idx];
if(unit != NULL) {
if(unit->getVisible() == true) {
if(unit->getCurrentUnitTitle() != "") {
//get the screen coordinates
Vec3f screenPos = unit->getScreenPos();
renderText3D(unit->getCurrentUnitTitle(), font, color, std::fabs(screenPos.x) + 5, std::fabs(screenPos.y) + 5, false);
//unitRenderedList[unit->getId()] = true;
}
else {
string str = unit->getFullName(unit->showTranslatedTechTree()) + " - " + intToStr(unit->getId()) + " [" + unit->getPosNotThreadSafe().getString() + "]";
Vec3f screenPos = unit->getScreenPos();
renderText3D(str, font, color, std::fabs(screenPos.x) + 5, std::fabs(screenPos.y) + 5, false);
}
}
}
}
visibleFrameUnitList.clear();
}
/*
if(renderUnitTitleList.empty() == false) {
for(int idx = 0; idx < renderUnitTitleList.size(); idx++) {
std::pair<Unit *,Vec3f> &unitInfo = renderUnitTitleList[idx];
Unit *unit = unitInfo.first;
const World *world= game->getWorld();
Unit *validUnit = world->findUnitById(unit->getId());
if(validUnit != NULL && unitRenderedList.find(validUnit->getId()) == unitRenderedList.end()) {
string str = validUnit->getFullName() + " - " + intToStr(validUnit->getId());
//get the screen coordinates
Vec3f &screenPos = unitInfo.second;
renderText(str, font, color, fabs(screenPos.x) + 5, fabs(screenPos.y) + 5, false);
//SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d] screenPos.x = %f, screenPos.y = %f, screenPos.z = %f\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,screenPos.x,screenPos.y,screenPos.z);
}
}
renderUnitTitleList.clear();
}
*/
}
// This method renders titles for units
void Renderer::renderUnitTitles(Font2D *font, Vec3f color) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
//std::map<int,bool> unitRenderedList;
if(visibleFrameUnitList.empty() == false) {
//printf("Render Unit titles ON\n");
for(int idx = 0; idx < (int)visibleFrameUnitList.size(); idx++) {
const Unit *unit = visibleFrameUnitList[idx];
if(unit != NULL) {
if(unit->getCurrentUnitTitle() != "") {
//get the screen coordinates
Vec3f screenPos = unit->getScreenPos();
renderText(unit->getCurrentUnitTitle(), font, color, std::fabs(screenPos.x) + 5, std::fabs(screenPos.y) + 5, false);
//unitRenderedList[unit->getId()] = true;
}
else {
string str = unit->getFullName(unit->showTranslatedTechTree()) + " - " + intToStr(unit->getId()) + " [" + unit->getPosNotThreadSafe().getString() + "]";
Vec3f screenPos = unit->getScreenPos();
renderText(str, font, color, std::fabs(screenPos.x) + 5, std::fabs(screenPos.y) + 5, false);
}
}
}
visibleFrameUnitList.clear();
}
/*
if(renderUnitTitleList.empty() == false) {
for(int idx = 0; idx < renderUnitTitleList.size(); idx++) {
std::pair<Unit *,Vec3f> &unitInfo = renderUnitTitleList[idx];
Unit *unit = unitInfo.first;
const World *world= game->getWorld();
Unit *validUnit = world->findUnitById(unit->getId());
if(validUnit != NULL && unitRenderedList.find(validUnit->getId()) == unitRenderedList.end()) {
string str = validUnit->getFullName() + " - " + intToStr(validUnit->getId());
//get the screen coordinates
Vec3f &screenPos = unitInfo.second;
renderText(str, font, color, fabs(screenPos.x) + 5, fabs(screenPos.y) + 5, false);
//SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d] screenPos.x = %f, screenPos.y = %f, screenPos.z = %f\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,screenPos.x,screenPos.y,screenPos.z);
}
}
renderUnitTitleList.clear();
}
*/
}
void Renderer::removeObjectFromQuadCache(const Object *o) {
VisibleQuadContainerCache &qCache = getQuadCache();
for(int visibleIndex = 0;
visibleIndex < (int)qCache.visibleObjectList.size(); ++visibleIndex) {
Object *currentObj = qCache.visibleObjectList[visibleIndex];
if(currentObj == o) {
qCache.visibleObjectList.erase(qCache.visibleObjectList.begin() + visibleIndex);
break;
}
}
}
void Renderer::removeUnitFromQuadCache(const Unit *unit) {
VisibleQuadContainerCache &qCache = getQuadCache();
for(int visibleIndex = 0;
visibleIndex < (int)qCache.visibleQuadUnitList.size(); ++visibleIndex) {
Unit *currentUnit = qCache.visibleQuadUnitList[visibleIndex];
if(currentUnit == unit) {
qCache.visibleQuadUnitList.erase(qCache.visibleQuadUnitList.begin() + visibleIndex);
break;
}
}
for(int visibleIndex = 0;
visibleIndex < (int)qCache.visibleUnitList.size(); ++visibleIndex) {
Unit *currentUnit = qCache.visibleUnitList[visibleIndex];
if(currentUnit == unit) {
qCache.visibleUnitList.erase(qCache.visibleUnitList.begin() + visibleIndex);
break;
}
}
}
VisibleQuadContainerCache & Renderer::getQuadCache( bool updateOnDirtyFrame,
bool forceNew) {
//forceNew = true;
if(game != NULL && game->getWorld() != NULL) {
const World *world= game->getWorld();
if(forceNew == true ||
(updateOnDirtyFrame == true &&
(world->getFrameCount() != quadCache.cacheFrame ||
visibleQuad != quadCache.lastVisibleQuad))) {
// Dump cached info
//if(forceNew == true || visibleQuad != quadCache.lastVisibleQuad) {
//quadCache.clearCacheData();
//}
//else {
quadCache.clearVolatileCacheData();
worldToScreenPosCache.clear();
//}
// Unit calculations
for(int i = 0; i < world->getFactionCount(); ++i) {
const Faction *faction = world->getFaction(i);
for(int j = 0; j < faction->getUnitCount(); ++j) {
Unit *unit= faction->getUnit(j);
bool unitCheckedForRender = false;
if(VisibleQuadContainerCache::enableFrustumCalcs == true) {
//bool insideQuad = PointInFrustum(quadCache.frustumData, unit->getCurrVector().x, unit->getCurrVector().y, unit->getCurrVector().z );
bool insideQuad = CubeInFrustum(quadCache.frustumData, unit->getCurrMidHeightVector().x, unit->getCurrMidHeightVector().y, unit->getCurrMidHeightVector().z, unit->getType()->getRenderSize());
bool renderInMap = world->toRenderUnit(unit);
if(insideQuad == false || renderInMap == false) {
unit->setVisible(false);
if(renderInMap == true) {
quadCache.visibleUnitList.push_back(unit);
}
unitCheckedForRender = true; // no more need to check any further;
// Currently don't need this list
//quadCache.inVisibleUnitList.push_back(unit);
}
}
if(unitCheckedForRender == false) {
bool insideQuad = visibleQuad.isInside(unit->getPos());
bool renderInMap = world->toRenderUnit(unit);
if(insideQuad == true && renderInMap == true) {
quadCache.visibleQuadUnitList.push_back(unit);
}
else {
unit->setVisible(false);
// Currently don't need this list
//quadCache.inVisibleUnitList.push_back(unit);
}
if(renderInMap == true) {
quadCache.visibleUnitList.push_back(unit);
}
}
bool unitBuildPending = unit->isBuildCommandPending();
if(unitBuildPending == true) {
const UnitBuildInfo &pendingUnit = unit->getBuildCommandPendingInfo();
const Vec2i &pos = pendingUnit.pos;
const Map *map= world->getMap();
bool unitBuildCheckedForRender = false;
//printf("#1 Unit is about to build another unit\n");
if(VisibleQuadContainerCache::enableFrustumCalcs == true) {
Vec3f pos3f= Vec3f(pos.x, map->getCell(pos)->getHeight(), pos.y);
//bool insideQuad = PointInFrustum(quadCache.frustumData, unit->getCurrVector().x, unit->getCurrVector().y, unit->getCurrVector().z );
bool insideQuad = CubeInFrustum(quadCache.frustumData, pos3f.x, pos3f.y, pos3f.z, pendingUnit.buildUnit->getRenderSize());
bool renderInMap = world->toRenderUnit(pendingUnit);
if(insideQuad == false || renderInMap == false) {
if(renderInMap == true) {
quadCache.visibleQuadUnitBuildList.push_back(pendingUnit);
}
unitBuildCheckedForRender = true; // no more need to check any further;
// Currently don't need this list
//quadCache.inVisibleUnitList.push_back(unit);
}
//printf("#2 Unit build added? insideQuad = %d, renderInMap = %d\n",insideQuad,renderInMap);
}
if(unitBuildCheckedForRender == false) {
bool insideQuad = visibleQuad.isInside(pos);
bool renderInMap = world->toRenderUnit(pendingUnit);
if(insideQuad == true && renderInMap == true) {
quadCache.visibleQuadUnitBuildList.push_back(pendingUnit);
}
else {
//unit->setVisible(false);
// Currently don't need this list
//quadCache.inVisibleUnitList.push_back(unit);
}
//printf("#3 Unit build added? insideQuad = %d, renderInMap = %d\n",insideQuad,renderInMap);
}
//printf("#4 quadCache.visibleQuadUnitBuildList.size() = %d\n",quadCache.visibleQuadUnitBuildList.size());
}
}
}
if(forceNew == true || visibleQuad != quadCache.lastVisibleQuad) {
// Object calculations
const Map *map= world->getMap();
// clear visibility of old objects
for(int visibleIndex = 0;
visibleIndex < (int)quadCache.visibleObjectList.size(); ++visibleIndex){
quadCache.visibleObjectList[visibleIndex]->setVisible(false);
}
quadCache.clearNonVolatileCacheData();
//int loops1=0;
PosQuadIterator pqi(map,visibleQuad, Map::cellScale);
while(pqi.next()) {
const Vec2i &pos= pqi.getPos();
if(map->isInside(pos)) {
//loops1++;
const Vec2i &mapPos = Map::toSurfCoords(pos);
//quadCache.visibleCellList.push_back(mapPos);
SurfaceCell *sc = map->getSurfaceCell(mapPos);
Object *o = sc->getObject();
if(VisibleQuadContainerCache::enableFrustumCalcs == true) {
if(o != NULL) {
//bool insideQuad = PointInFrustum(quadCache.frustumData, o->getPos().x, o->getPos().y, o->getPos().z );
bool insideQuad = CubeInFrustum(quadCache.frustumData, o->getPos().x, o->getPos().y, o->getPos().z, 1);
if(insideQuad == false) {
o->setVisible(false);
continue;
}
}
}
bool cellExplored = world->showWorldForPlayer(world->getThisFactionIndex());
if(cellExplored == false) {
cellExplored = sc->isExplored(world->getThisTeamIndex());
}
bool isExplored = (cellExplored == true && o != NULL);
//bool isVisible = (sc->isVisible(world->getThisTeamIndex()) && o != NULL);
bool isVisible = true;
if(isExplored == true && isVisible == true) {
quadCache.visibleObjectList.push_back(o);
o->setVisible(true);
}
}
}
//printf("Frame # = %d loops1 = %d\n",world->getFrameCount(),loops1);
//int loops2=0;
std::map<Vec2i, MarkedCell> markedCells = game->getMapMarkedCellList();
const Rect2i mapBounds(0, 0, map->getSurfaceW()-1, map->getSurfaceH()-1);
Quad2i scaledQuad = visibleQuad / Map::cellScale;
PosQuadIterator pqis(map,scaledQuad);
while(pqis.next()) {
const Vec2i &pos= pqis.getPos();
if(mapBounds.isInside(pos)) {
//loops2++;
if(VisibleQuadContainerCache::enableFrustumCalcs == false) {
quadCache.visibleScaledCellList.push_back(pos);
if(markedCells.empty() == false) {
if(markedCells.find(pos) != markedCells.end()) {
//printf("#1 ******** VISIBLE SCALED CELL FOUND in marked list pos [%s] markedCells.size() = " MG_SIZE_T_SPECIFIER "\n",pos.getString().c_str(),markedCells.size());
//if(markedCells.empty() == false) {
//SurfaceCell *sc = map->getSurfaceCell(pos);
//quadCache.visibleScaledCellToScreenPosList[pos]=computeScreenPosition(sc->getVertex());
updateMarkedCellScreenPosQuadCache(pos);
}
else {
//printf("#1 VISIBLE SCALED CELL NOT FOUND in marked list pos [%s] markedCells.size() = " MG_SIZE_T_SPECIFIER "\n",pos.getString().c_str(),markedCells.size());
}
}
}
else {
//bool insideQuad = false;
//if( !insideQuad) {
SurfaceCell *sc = map->getSurfaceCell(pos.x, pos.y);
bool insideQuad = CubeInFrustum(quadCache.frustumData, sc->getVertex().x, sc->getVertex().y, sc->getVertex().z, 0);
//}
if( !insideQuad) {
SurfaceCell *sc = map->getSurfaceCell(pos.x+1, pos.y);
insideQuad = CubeInFrustum(quadCache.frustumData, sc->getVertex().x, sc->getVertex().y, sc->getVertex().z, 0);
}
if( !insideQuad) {
SurfaceCell *sc = map->getSurfaceCell(pos.x, pos.y+1);
insideQuad = CubeInFrustum(quadCache.frustumData, sc->getVertex().x, sc->getVertex().y, sc->getVertex().z, 0);
}
if( !insideQuad) {
SurfaceCell *sc = map->getSurfaceCell(pos.x+1, pos.y+1);
insideQuad = CubeInFrustum(quadCache.frustumData, sc->getVertex().x, sc->getVertex().y, sc->getVertex().z, 0);
}
if(insideQuad == true) {
quadCache.visibleScaledCellList.push_back(pos);
if(markedCells.empty() == false) {
if(markedCells.find(pos) != markedCells.end()) {
//printf("#2 ******** VISIBLE SCALED CELL FOUND in marked list pos [%s] markedCells.size() = " MG_SIZE_T_SPECIFIER "\n",pos.getString().c_str(),markedCells.size());
//if(markedCells.empty() == false) {
//quadCache.visibleScaledCellToScreenPosList[pos]=computeScreenPosition(sc->getVertex());
updateMarkedCellScreenPosQuadCache(pos);
}
else {
//printf("#2 VISIBLE SCALED CELL NOT FOUND in marked list pos [%s] markedCells.size() = " MG_SIZE_T_SPECIFIER "\n",pos.getString().c_str(),markedCells.size());
}
}
}
}
}
}
//printf("Frame # = %d loops2 = %d\n",world->getFrameCount(),loops2);
}
quadCache.cacheFrame = world->getFrameCount();
quadCache.lastVisibleQuad = visibleQuad;
}
}
return quadCache;
}
void Renderer::updateMarkedCellScreenPosQuadCache(Vec2i pos) {
const World *world= game->getWorld();
const Map *map= world->getMap();
SurfaceCell *sc = map->getSurfaceCell(pos);
quadCache.visibleScaledCellToScreenPosList[pos]=computeScreenPosition(sc->getVertex());
}
void Renderer::forceQuadCacheUpdate() {
quadCache.cacheFrame = -1;
Vec2i clearPos(-1,-1);
quadCache.lastVisibleQuad.p[0] = clearPos;
quadCache.lastVisibleQuad.p[1] = clearPos;
quadCache.lastVisibleQuad.p[2] = clearPos;
quadCache.lastVisibleQuad.p[3] = clearPos;
}
std::pair<bool,Vec3f> Renderer::posInCellQuadCache(Vec2i pos) {
std::pair<bool,Vec3f> result = make_pair(false,Vec3f());
if(std::find(
quadCache.visibleScaledCellList.begin(),
quadCache.visibleScaledCellList.end(),
pos) != quadCache.visibleScaledCellList.end()) {
result.first = true;
result.second = quadCache.visibleScaledCellToScreenPosList[pos];
}
return result;
}
//Vec3f Renderer::getMarkedCellScreenPosQuadCache(Vec2i pos) {
// Vec3f result(-1,-1,-1);
// if(std::find(
// quadCache.visibleScaledCellList.begin(),
// quadCache.visibleScaledCellList.end(),
// pos) != quadCache.visibleScaledCellList.end()) {
// result = quadCache.visibleScaledCellToScreenPosList[pos];
// }
// return result;
//}
void Renderer::beginRenderToTexture(Texture2D **renderToTexture) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
static bool supportFBOs = Texture2DGl().supports_FBO_RBO();
if(supportFBOs == true && renderToTexture != NULL) {
Config &config= Config::getInstance();
Texture2D::Filter textureFilter = strToTextureFilter(config.getString("Filter"));
int maxAnisotropy = config.getInt("FilterMaxAnisotropy");
const Metrics &metrics = Metrics::getInstance();
*renderToTexture = GraphicsInterface::getInstance().getFactory()->newTexture2D();
Texture2DGl *texture = static_cast<Texture2DGl *>(*renderToTexture);
texture->setMipmap(false);
Pixmap2D *pixmapScreenShot = texture->getPixmap();
pixmapScreenShot->init(metrics.getScreenW(), metrics.getScreenH(), 4);
texture->setForceCompressionDisabled(true);
texture->init(textureFilter,maxAnisotropy);
texture->setup_FBO_RBO();
assertGl();
if(texture->checkFrameBufferStatus() == false) {
//printf("******************** WARNING CANNOT Attach to FBO!\n");
texture->end();
delete texture;
*renderToTexture=NULL;
}
}
}
void Renderer::endRenderToTexture(Texture2D **renderToTexture) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
static bool supportFBOs = Texture2DGl().supports_FBO_RBO();
if(supportFBOs == true && renderToTexture != NULL && *renderToTexture != NULL) {
Texture2DGl *texture = static_cast<Texture2DGl *>(*renderToTexture);
if(texture != NULL) {
texture->dettachFrameBufferFromTexture();
}
assertGl();
}
}
void Renderer::renderMapPreview( const MapPreview *map, bool renderAll,
int screenPosX, int screenPosY,
Texture2D **renderToTexture) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
static bool supportFBOs = Texture2DGl().supports_FBO_RBO();
if(Config::getInstance().getBool("LegacyMapPreviewRendering","false") == true) {
supportFBOs = false;
}
//static bool supportFBOs = false;
const Metrics &metrics= Metrics::getInstance();
float alt = 0;
float showWater = 0;
int renderMapHeight = 64;
int renderMapWidth = 64;
float cellSize = 2;
float playerCrossSize = 2;
float clientW = renderMapWidth * cellSize;
float clientH = renderMapHeight * cellSize;;
float minDimension = std::min(metrics.getVirtualW(), metrics.getVirtualH());
// stretch small maps to 128x128
if(map->getW() < map->getH()) {
cellSize = cellSize * renderMapHeight / map->getH();
}
else {
cellSize = cellSize * renderMapWidth / map->getW();
}
assertGl();
if(supportFBOs == true && renderToTexture != NULL) {
Config &config= Config::getInstance();
Texture2D::Filter textureFilter = strToTextureFilter(config.getString("Filter"));
int maxAnisotropy = config.getInt("FilterMaxAnisotropy");
*renderToTexture = GraphicsInterface::getInstance().getFactory()->newTexture2D();
Texture2DGl *texture = static_cast<Texture2DGl *>(*renderToTexture);
texture->setMipmap(false);
Pixmap2D *pixmapScreenShot = texture->getPixmap();
pixmapScreenShot->init(minDimension, minDimension, 4);
texture->setForceCompressionDisabled(true);
texture->init(textureFilter,maxAnisotropy);
texture->setup_FBO_RBO();
assertGl();
if(texture->checkFrameBufferStatus() == false) {
//printf("******************** WARNING CANNOT Attach to FBO!\n");
texture->end();
delete texture;
*renderToTexture=NULL;
}
}
if(supportFBOs == true && renderToTexture != NULL && *renderToTexture != NULL) {
cellSize =1;
clientW = minDimension;
clientH = minDimension;
int mapMaxDimensionSize = std::max(map->getW(),map->getH());
switch(mapMaxDimensionSize) {
case 8:
cellSize = 96;
break;
case 16:
cellSize = 48;
break;
case 32:
cellSize = 24;
break;
case 64:
cellSize = 12;
break;
case 128:
cellSize = 6;
break;
case 256:
cellSize = 3;
break;
case 512:
cellSize = 2;
break;
}
}
glFrontFace(GL_CW);
glEnable(GL_CULL_FACE);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
assertGl();
GLint viewport[4]; // Where The original Viewport Values Will Be Stored
if(supportFBOs == true && renderToTexture != NULL && *renderToTexture != NULL) {
glGetIntegerv(GL_VIEWPORT, viewport);
glOrtho(0, clientW, 0, clientH, 0, 1);
glViewport(0, 0, clientW, clientH);
}
else {
glOrtho(0, metrics.getVirtualW(), 0, metrics.getVirtualH(), 0, 1);
}
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
if(supportFBOs == false || renderToTexture == NULL || *renderToTexture == NULL) {
glTranslatef(static_cast<float>(screenPosX),static_cast<float>(screenPosY)-clientH,0.0f);
}
assertGl();
glPushAttrib(GL_CURRENT_BIT);
glLineWidth(1);
glColor3f(0, 0, 0);
for (int j = 0; j < map->getH(); j++) {
for (int i = 0; i < map->getW(); i++) {
//surface
alt = map->getHeight(i, j) / 20.f;
showWater = map->getWaterLevel()/ 20.f - alt;
showWater = (showWater > 0)? showWater:0;
Vec3f surfColor;
switch (map->getSurface(i, j)) {
case st_Grass:
surfColor = Vec3f(0.0, 0.8f * alt, 0.f + showWater);
break;
case st_Secondary_Grass:
surfColor = Vec3f(0.4f * alt, 0.6f * alt, 0.f + showWater);
break;
case st_Road:
surfColor = Vec3f(0.6f * alt, 0.3f * alt, 0.f + showWater);
break;
case st_Stone:
surfColor = Vec3f(0.7f * alt, 0.7f * alt, 0.7f * alt + showWater);
break;
case st_Ground:
surfColor = Vec3f(0.7f * alt, 0.5f * alt, 0.3f * alt + showWater);
break;
}
glColor3fv(surfColor.ptr());
glBegin(GL_TRIANGLE_STRIP);
glVertex2f(i * cellSize, clientH - j * cellSize - cellSize);
glVertex2f(i * cellSize, clientH - j * cellSize);
glVertex2f(i * cellSize + cellSize, clientH - j * cellSize - cellSize);
glVertex2f(i * cellSize + cellSize, clientH - j * cellSize);
glEnd();
//objects
if(renderAll == true) {
switch (map->getObject(i, j)) {
case 0:
glColor3f(0.f, 0.f, 0.f);
break;
case 1:
glColor3f(1.f, 0.f, 0.f);
break;
case 2:
glColor3f(1.f, 1.f, 1.f);
break;
case 3:
glColor3f(0.5f, 0.5f, 1.f);
break;
case 4:
glColor3f(0.f, 0.f, 1.f);
break;
case 5:
glColor3f(0.5f, 0.5f, 0.5f);
break;
case 6:
glColor3f(1.f, 0.8f, 0.5f);
break;
case 7:
glColor3f(0.f, 1.f, 1.f);
break;
case 8:
glColor3f(0.7f, 0.1f, 0.3f);
break;
case 9:
glColor3f(0.5f, 1.f, 0.1f);
break;
case 10:
glColor3f(1.f, 0.2f, 0.8f);
break;// we don't render unvisible blocking objects
}
if ( renderAll && (map->getObject(i, j) != 0) && (map->getObject(i, j) != 10) ) {
glPointSize(cellSize / 2.f);
glBegin(GL_POINTS);
glVertex2f(i * cellSize + cellSize / 2.f, clientH - j * cellSize - cellSize / 2.f);
glEnd();
}
}
// bool found = false;
//height lines
// if (!found) {
//left
if (i > 0 && map->getHeight(i - 1, j) > map->getHeight(i, j)) {
glColor3fv((surfColor*0.5f).ptr());
glBegin(GL_LINES);
glVertex2f(i * cellSize, clientH - (j + 1) * cellSize);
glVertex2f(i * cellSize, clientH - j * cellSize);
glEnd();
}
//down
if (j > 0 && map->getHeight(i, j - 1) > map->getHeight(i, j)) {
glColor3fv((surfColor*0.5f).ptr());
glBegin(GL_LINES);
glVertex2f(i * cellSize, clientH - j * cellSize);
glVertex2f((i + 1) * cellSize, clientH - j * cellSize);
glEnd();
}
//left
if (i > 0 && map->getHeight(i - 1, j) < map->getHeight(i, j)) {
glColor3fv((surfColor*2.f).ptr());
glBegin(GL_LINES);
glVertex2f(i * cellSize, clientH - (j + 1) * cellSize);
glVertex2f(i * cellSize, clientH - j * cellSize);
glEnd();
}
if (j > 0 && map->getHeight(i, j - 1) < map->getHeight(i, j)) {
glColor3fv((surfColor*2.f).ptr());
glBegin(GL_LINES);
glVertex2f(i * cellSize, clientH - j * cellSize);
glVertex2f((i + 1) * cellSize, clientH - j * cellSize);
glEnd();
}
// }
//resources
if(renderAll == true) {
switch (map->getResource(i, j)) {
case 1: glColor3f(1.f, 1.f, 0.f); break;
case 2: glColor3f(0.5f, 0.5f, 0.5f); break;
case 3: glColor3f(1.f, 0.f, 0.f); break;
case 4: glColor3f(0.f, 0.f, 1.f); break;
case 5: glColor3f(0.5f, 0.5f, 1.f); break;
}
if (renderAll && map->getResource(i, j) != 0) {
glBegin(GL_LINES);
glVertex2f(i * cellSize, clientH - j * cellSize - cellSize);
glVertex2f(i * cellSize + cellSize, clientH - j * cellSize);
glVertex2f(i * cellSize, clientH - j * cellSize);
glVertex2f(i * cellSize + cellSize, clientH - j * cellSize - cellSize);
glEnd();
}
}
}
}
//start locations
glLineWidth(3);
assertGl();
if(supportFBOs == true && renderToTexture != NULL && *renderToTexture != NULL) {
glLineWidth(14);
playerCrossSize = 24;
}
else {
// force playerCrossSize to be at least of size 4
if(cellSize < 4) {
playerCrossSize = 4;
}
else {
playerCrossSize = cellSize;
}
}
assertGl();
Vec2f *vertices = new Vec2f[map->getMaxFactions() * 4];
Vec3f *colors = new Vec3f[map->getMaxFactions() * 4];
for (int i = 0; i < map->getMaxFactions(); i++) {
Vec3f color;
switch (i) {
case 0:
color = Vec3f(1.f, 0.f, 0.f);
break;
case 1:
color = Vec3f(0.f, 0.f, 1.f);
break;
case 2:
color = Vec3f(0.f, 1.f, 0.f);
break;
case 3:
color = Vec3f(1.f, 1.f, 0.f);
break;
case 4:
color = Vec3f(1.f, 1.f, 1.f);
break;
case 5:
color = Vec3f(0.f, 1.f, 0.8f);
break;
case 6:
color = Vec3f(1.f, 0.5f, 0.f);
break;
case 7:
color = Vec3f(1.f, 0.5f, 1.f);
break;
}
colors[i*4] = color;
colors[(i*4)+1] = color;
colors[(i*4)+2] = color;
colors[(i*4)+3] = color;
vertices[i*4] = Vec2f((map->getStartLocationX(i) - 1) * cellSize, clientH - (map->getStartLocationY(i) - 1) * cellSize);
vertices[(i*4)+1] = Vec2f((map->getStartLocationX(i) + 1) * cellSize + playerCrossSize, clientH - (map->getStartLocationY(i) + 1) * cellSize - playerCrossSize);
vertices[(i*4)+2] = Vec2f((map->getStartLocationX(i) - 1) * cellSize, clientH - (map->getStartLocationY(i) + 1) * cellSize - playerCrossSize);
vertices[(i*4)+3] = Vec2f((map->getStartLocationX(i) + 1) * cellSize + playerCrossSize, clientH - (map->getStartLocationY(i) - 1) * cellSize);
}
glEnableClientState(GL_COLOR_ARRAY);
glColorPointer(3, GL_FLOAT, 0, &colors[0]);
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(2, GL_FLOAT, 0, &vertices[0]);
glDrawArrays(GL_LINES, 0, 4 * map->getMaxFactions());
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
assertGl();
glLineWidth(1);
glPopMatrix();
glPopAttrib();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
if(supportFBOs == true && renderToTexture != NULL && *renderToTexture != NULL) {
Texture2DGl *texture = static_cast<Texture2DGl *>(*renderToTexture);
if(texture != NULL) {
texture->dettachFrameBufferFromTexture();
}
glViewport(viewport[0], viewport[1], viewport[2], viewport[3]);
assertGl();
}
delete [] vertices;
delete [] colors;
assertGl();
}
// setLastRenderFps and calculate shadowsOffDueToMinRender
void Renderer::setLastRenderFps(int value) {
lastRenderFps = value;
smoothedRenderFps=(MIN_FPS_NORMAL_RENDERING*smoothedRenderFps+lastRenderFps)/(MIN_FPS_NORMAL_RENDERING+1.0f);
if(smoothedRenderFps>=MIN_FPS_NORMAL_RENDERING_TOP_THRESHOLD){
shadowsOffDueToMinRender=false;
}
if(smoothedRenderFps<=MIN_FPS_NORMAL_RENDERING){
shadowsOffDueToMinRender=true;
}
}
std::size_t Renderer::getCurrentPixelByteCount(ResourceScope rs) const {
std::size_t result = 0;
for(int i = (rs == rsCount ? 0 : rs); i < rsCount; ++i) {
if(textureManager[i] != NULL) {
const ::Shared::Graphics::TextureContainer &textures = textureManager[i]->getTextures();
for(int j = 0; j < (int)textures.size(); ++j) {
const Texture *texture = textures[j];
result += texture->getPixelByteCount();
}
if(rs != rsCount) {
break;
}
}
}
return result;
}
Texture2D * Renderer::preloadTexture(string logoFilename) {
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d] logoFilename [%s]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,logoFilename.c_str());
Texture2D *result = NULL;
if(logoFilename != "") {
// Cache faction preview textures
string data_path = getGameReadWritePath(GameConstants::path_data_CacheLookupKey);
std::map<string,Texture2D *> &crcFactionPreviewTextureCache = CacheManager::getCachedItem< std::map<string,Texture2D *> >(GameConstants::factionPreviewTextureCacheLookupKey);
if(crcFactionPreviewTextureCache.find(logoFilename) != crcFactionPreviewTextureCache.end()) {
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d] logoFilename [%s]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,logoFilename.c_str());
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s Line: %d] load texture from cache [%s]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,logoFilename.c_str());
result = crcFactionPreviewTextureCache[logoFilename];
}
else {
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d] logoFilename [%s]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,logoFilename.c_str());
Renderer &renderer= Renderer::getInstance();
result = renderer.newTexture2D(rsGlobal);
if(result) {
result->setMipmap(true);
result->load(logoFilename);
//renderer.initTexture(rsGlobal,result);
}
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s Line: %d] add texture to manager and cache [%s]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,logoFilename.c_str());
crcFactionPreviewTextureCache[logoFilename] = result;
}
}
return result;
}
Texture2D * Renderer::findTexture(string logoFilename) {
if(SystemFlags::getSystemSettingType(SystemFlags::debugSystem).enabled) SystemFlags::OutputDebug(SystemFlags::debugSystem,"In [%s::%s Line: %d] logoFilename [%s]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,logoFilename.c_str());
Texture2D *result = preloadTexture(logoFilename);
if(result != NULL && result->getInited() == false) {
Renderer &renderer= Renderer::getInstance();
renderer.initTexture(rsGlobal,result);
}
return result;
}
void Renderer::cycleShowDebugUILevel() {
//printf("#1 showDebugUILevel = %d, debugui_fps = %d, debugui_unit_titles = %d\n",showDebugUILevel,debugui_fps,debugui_unit_titles);
//if(showDebugUI == false) {
// showDebugUI = true;
//}
if((showDebugUILevel & debugui_fps) != debugui_fps ||
(showDebugUILevel & debugui_unit_titles) != debugui_unit_titles) {
showDebugUILevel |= debugui_fps;
showDebugUILevel |= debugui_unit_titles;
}
else {
showDebugUILevel = debugui_fps;
}
//printf("#2 showDebugUILevel = %d, debugui_fps = %d, debugui_unit_titles = %d\n",showDebugUILevel,debugui_fps,debugui_unit_titles);
}
void Renderer::renderFPSWhenEnabled(int lastFps) {
if(getShowDebugUI() == true) {
CoreData &coreData= CoreData::getInstance();
if(Renderer::renderText3DEnabled) {
renderText3D(
"FPS: " + intToStr(lastFps),
coreData.getMenuFontNormal3D(), Vec3f(1.f), 10, 10, false);
}
else {
renderText(
"FPS: " + intToStr(lastFps),
coreData.getMenuFontNormal(), Vec3f(1.f), 10, 10, false);
}
}
}
void Renderer::renderPopupMenu(PopupMenu *menu) {
if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
return;
}
if(menu->getVisible() == false || menu->getEnabled() == false) {
return;
}
//background
glPushAttrib(GL_ENABLE_BIT | GL_CURRENT_BIT);
glEnable(GL_BLEND);
glColor4f(0.0f, 0.0f, 0.0f, 0.8f) ;
glBegin(GL_TRIANGLE_STRIP);
glVertex2i(menu->getX(), menu->getY() + 9 * menu->getH() / 10);
glVertex2i(menu->getX(), menu->getY());
glVertex2i(menu->getX() + menu->getW(), menu->getY() + 9 * menu->getH() / 10);
glVertex2i(menu->getX() + menu->getW(), menu->getY());
glEnd();
glColor4f(0.0f, 0.0f, 0.0f, 0.8f) ;
glBegin(GL_TRIANGLE_STRIP);
glVertex2i(menu->getX(), menu->getY() + menu->getH());
glVertex2i(menu->getX(), menu->getY() + 9 * menu->getH() / 10);
glVertex2i(menu->getX() + menu->getW(), menu->getY() + menu->getH());
glVertex2i(menu->getX() + menu->getW(), menu->getY() + 9 * menu->getH() / 10);
glEnd();
glBegin(GL_LINE_LOOP);
glColor4f(0.5f, 0.5f, 0.5f, 0.25f) ;
glVertex2i(menu->getX(), menu->getY());
glColor4f(0.0f, 0.0f, 0.0f, 0.25f) ;
glVertex2i(menu->getX() + menu->getW(), menu->getY());
glColor4f(0.5f, 0.5f, 0.5f, 0.25f) ;
glVertex2i(menu->getX() + menu->getW(), menu->getY() + menu->getH());
glColor4f(0.25f, 0.25f, 0.25f, 0.25f) ;
glVertex2i(menu->getX(), menu->getY() + menu->getH());
glEnd();
glBegin(GL_LINE_STRIP);
glColor4f(1.0f, 1.0f, 1.0f, 0.25f) ;
glVertex2i(menu->getX(), menu->getY() + 90*menu->getH()/100);
glColor4f(0.5f, 0.5f, 0.5f, 0.25f) ;
glVertex2i(menu->getX()+ menu->getW(), menu->getY() + 90*menu->getH()/100);
glEnd();
glPopAttrib();
Vec4f fontColor;
//if(game!=NULL){
// fontColor=game->getGui()->getDisplay()->getColor();
//}
//else {
// white shadowed is default ( in the menu for example )
fontColor=Vec4f(1.f, 1.f, 1.f, 1.0f);
//}
if(renderText3DEnabled == true) {
//text
renderTextBoundingBox3D(
menu->getHeader(), menu->getFont3D(),fontColor,
menu->getX(), menu->getY()+93*menu->getH()/100,menu->getW(),0,
true,false, false,-1,-1);
}
else {
//text
int renderX = (menu->getX() + (menu->getW() / 2));
//int renderY = (menu->getY() + (menu->getH() / 2));
FontMetrics *fontMetrics= menu->getFont()->getMetrics();
int renderY = menu->getY() + menu->getH() - fontMetrics->getHeight(menu->getHeader());
renderTextShadow(
menu->getHeader(), menu->getFont(),fontColor,
renderX, renderY,
true);
//renderText(button->getText(), button->getFont(), color,x + (w / 2), y + (h / 2), true);
}
//buttons
// int maxButtonWidth = -1;
std::vector<GraphicButton> &menuItems = menu->getMenuItems();
// for(unsigned int i = 0; i < menuItems.size(); ++i) {
// GraphicButton *button = &menuItems[i];
// int currentButtonWidth = -1;
// if(renderText3DEnabled == true) {
// FontMetrics *fontMetrics= menu->getFont3D()->getMetrics();
// currentButtonWidth = fontMetrics->getTextWidth(button->getText());
// }
// else {
// FontMetrics *fontMetrics= menu->getFont()->getMetrics();
// currentButtonWidth = fontMetrics->getTextWidth(button->getText());
// }
//
// if(maxButtonWidth < 0 || currentButtonWidth > maxButtonWidth) {
// maxButtonWidth = currentButtonWidth + 5;
// }
// }
for(unsigned int i = 0; i < menuItems.size(); ++i) {
GraphicButton *button = &menuItems[i];
//button->setW(maxButtonWidth);
renderButton(button);
}
}
void Renderer::setupRenderForVideo() {
clearBuffers();
//3d
reset3dMenu();
clearZBuffer();
//2d
reset2d();
glClearColor(0.f, 0.f, 0.f, 1.f);
}
void Renderer::renderVideoLoading(int progressPercent) {
//printf("Rendering progress progressPercent = %d\n",progressPercent);
setupRenderForVideo();
Lang &lang= Lang::getInstance();
string textToRender = lang.getString("PleaseWait");
const Metrics &metrics= Metrics::getInstance();
static Chrono cycle(true);
static float anim = 0.0f;
if(CoreData::getInstance().getMenuFontBig3D() != NULL) {
int w= metrics.getVirtualW();
int renderX = (w / 2) - (CoreData::getInstance().getMenuFontBig3D()->getMetrics()->getTextWidth(textToRender) / 2);
int h= metrics.getVirtualH();
int renderY = (h / 2) + (CoreData::getInstance().getMenuFontBig3D()->getMetrics()->getHeight(textToRender) / 2);
renderText3D(
textToRender,
CoreData::getInstance().getMenuFontBig3D(),
Vec4f(1.f, 1.f, 0.f,anim),
renderX, renderY, false);
}
else {
renderText(
textToRender,
CoreData::getInstance().getMenuFontBig(),
Vec4f(1.f, 1.f, 0.f,anim), (metrics.getScreenW() / 2),
(metrics.getScreenH() / 2), true);
}
swapBuffers();
if(cycle.getCurMillis() % 50 == 0) {
static bool animCycleUp = true;
if(animCycleUp == true) {
anim += 0.1f;
if(anim > 1.f) {
anim= 1.f;
cycle.reset();
animCycleUp = false;
}
}
else {
anim -= 0.1f;
if(anim < 0.f) {
anim= 0.f;
cycle.reset();
animCycleUp = true;
}
}
}
}
}}//end namespace
Reference in New Issue View Git Blame Copy Permalink