immibis
/
colobot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Refactoring of texture code 

- refactored texture structs & functions
- added note about OpenGL extensions
- removed device.cpp as unnecessary
- minor changes in CEngine
dev-ui
Piotr Dziwinski 2012-07-25 00:27:01 +02:00
parent 9d59204531
commit 42963b341f
10 changed files with 282 additions and 298 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/app/app.cpp
View File

@ -170,14 +170,6 @@ bool CApplication::Create()
// Create the 3D engine // Create the 3D engine
m_engine = new Gfx::CEngine(m_iMan, this); m_engine = new Gfx::CEngine(m_iMan, this);
// Initialize the app's custom scene stuff, but before initializing the graphics device
if (! m_engine->BeforeCreateInit())
{
SystemDialog(SDT_ERROR, "COLOBOT - Error", std::string("Error in CEngine::BeforeCreateInit() :\n") +
std::string(m_engine->GetError()) );
m_exitCode = 1;
return false;
}
/* // Create the sound instance. /* // Create the sound instance.
m_sound = new CSound(m_iMan); m_sound = new CSound(m_iMan);

33
src/graphics/common/device.cpp
View File

@ -1,33 +0,0 @@
// * This file is part of the COLOBOT source code
// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
// *
// * This program is free software: you can redistribute it and/or modify
// * it under the terms of the GNU General Public License as published by
// * the Free Software Foundation, either version 3 of the License, or
// * (at your option) any later version.
// *
// * This program is distributed in the hope that it will be useful,
// * but WITHOUT ANY WARRANTY; without even the implied warranty of
// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// * GNU General Public License for more details.
// *
// * You should have received a copy of the GNU General Public License
// * along with this program. If not, see http://www.gnu.org/licenses/.
// device.cpp
#include "graphics/common/device.h"
void Gfx::DeviceConfig::LoadDefault()
{
width = 800;
height = 600;
bpp = 32;
fullScreen = false;
resizeable = false;
doubleBuf = true;
noFrame = false;
}

19
src/graphics/common/device.h
View File

@ -62,7 +62,16 @@ struct DeviceConfig
DeviceConfig() { LoadDefault(); } DeviceConfig() { LoadDefault(); }
//! Loads the default values //! Loads the default values
void LoadDefault(); inline void LoadDefault()
{
width = 800;
height = 600;
bpp = 32;
fullScreen = false;
resizeable = false;
doubleBuf = true;
noFrame = false;
}
}; };
@ -326,10 +335,10 @@ public:
//! Returns the current enable state of given texture stage //! Returns the current enable state of given texture stage
virtual bool GetTextureEnabled(int index) = 0; virtual bool GetTextureEnabled(int index) = 0;
//! Sets the current params of texture with given index //! Sets the params for texture stage with given index
virtual void SetTextureParams(int index, const Gfx::TextureParams &params) = 0; virtual void SetTextureStageParams(int index, const Gfx::TextureStageParams &params) = 0;
//! Returns the current params of texture with given index //! Returns the current params of texture stage with given index
virtual Gfx::TextureParams GetTextureParams(int index) = 0; virtual Gfx::TextureStageParams GetTextureStageParams(int index) = 0;
//! Sets the texture factor to the given color value //! Sets the texture factor to the given color value
virtual void SetTextureFactor(const Gfx::Color &color) = 0; virtual void SetTextureFactor(const Gfx::Color &color) = 0;

106
src/graphics/common/engine.cpp
View File

@ -52,13 +52,13 @@ Gfx::CEngine::CEngine(CInstanceManager *iMan, CApplication *app)
m_iMan->AddInstance(CLASS_ENGINE, this); m_iMan->AddInstance(CLASS_ENGINE, this);
m_app = app; m_app = app;
/*m_light = new Gfx::CLight(m_iMan, this); m_light = NULL;
m_text = new Gfx::CText(m_iMan, this); m_text = NULL;
m_particle = new Gfx::CParticle(m_iMan, this); m_particle = NULL;
m_water = new Gfx::CWater(m_iMan, this); m_water = NULL;
m_cloud = new Gfx::CCloud(m_iMan, this); m_cloud = NULL;
m_lightning = new Gfx::CLightning(m_iMan, this); m_lightning = NULL;
m_planet = new Gfx::CPlanet(m_iMan, this);*/ m_planet = NULL;
m_sound = NULL; m_sound = NULL;
m_terrain = NULL; m_terrain = NULL;
@ -185,6 +185,43 @@ Gfx::CEngine::~CEngine()
m_app = NULL; m_app = NULL;
m_device = NULL; m_device = NULL;
m_sound = NULL;
m_terrain = NULL;
}
bool Gfx::CEngine::GetWasInit()
{
return m_wasInit;
}
std::string Gfx::CEngine::GetError()
{
return m_error;
}
bool Gfx::CEngine::Create()
{
m_wasInit = true;
/*m_light = new Gfx::CLight(m_iMan, this);
m_text = new Gfx::CText(m_iMan, this);
m_particle = new Gfx::CParticle(m_iMan, this);
m_water = new Gfx::CWater(m_iMan, this);
m_cloud = new Gfx::CCloud(m_iMan, this);
m_lightning = new Gfx::CLightning(m_iMan, this);
m_planet = new Gfx::CPlanet(m_iMan, this);*/
m_matWorldInterface.LoadIdentity();
m_matViewInterface.LoadIdentity();
Math::LoadOrthoProjectionMatrix(m_matProjInterface, 0.0f, 1.0f, 0.0f, 1.0f, -1.0f, 1.0f);
return true;
}
void Gfx::CEngine::Destroy()
{
// TODO
/*delete m_light; /*delete m_light;
m_light = NULL; m_light = NULL;
@ -206,41 +243,6 @@ Gfx::CEngine::~CEngine()
delete m_planet; delete m_planet;
m_planet = NULL;*/ m_planet = NULL;*/
m_sound = NULL;
m_terrain = NULL;
}
bool Gfx::CEngine::GetWasInit()
{
return m_wasInit;
}
std::string Gfx::CEngine::GetError()
{
return m_error;
}
bool Gfx::CEngine::BeforeCreateInit()
{
// TODO
return true;
}
bool Gfx::CEngine::Create()
{
m_wasInit = true;
m_matWorldInterface.LoadIdentity();
m_matViewInterface.LoadIdentity();
Math::LoadOrthoProjectionMatrix(m_matProjInterface, 0.0f, 1.0f, 0.0f, 1.0f, -1.0f, 1.0f);
return true;
}
void Gfx::CEngine::Destroy()
{
// TODO
m_wasInit = false; m_wasInit = false;
} }
@ -265,7 +267,7 @@ bool Gfx::CEngine::AfterDeviceSetInit()
params.minFilter = Gfx::TEX_MIN_FILTER_NEAREST; params.minFilter = Gfx::TEX_MIN_FILTER_NEAREST;
params.magFilter = Gfx::TEX_MAG_FILTER_NEAREST; params.magFilter = Gfx::TEX_MAG_FILTER_NEAREST;
params.mipmap = false; params.mipmap = false;
CreateTexture("mouse.png", params); m_miceTexture = CreateTexture("mouse.png", params);
return true; return true;
} }
@ -360,12 +362,12 @@ void Gfx::CEngine::SetState(int state, Gfx::Color color)
m_device->SetTextureEnabled(0, true); m_device->SetTextureEnabled(0, true);
m_device->SetTextureFactor(color); m_device->SetTextureFactor(color);
Gfx::TextureParams params; Gfx::TextureStageParams params;
params.colorOperation = Gfx::TEX_MIX_OPER_MODULATE; params.colorOperation = Gfx::TEX_MIX_OPER_MODULATE;
params.colorArg1 = Gfx::TEX_MIX_ARG_TEXTURE; params.colorArg1 = Gfx::TEX_MIX_ARG_TEXTURE;
params.colorArg2 = Gfx::TEX_MIX_ARG_FACTOR; params.colorArg2 = Gfx::TEX_MIX_ARG_FACTOR;
params.alphaOperation = Gfx::TEX_MIX_OPER_MODULATE; params.alphaOperation = Gfx::TEX_MIX_OPER_MODULATE;
m_device->SetTextureParams(0, params); m_device->SetTextureStageParams(0, params);
} }
else if (state & Gfx::ENG_RSTATE_TTEXTURE_WHITE) // The transparent white texture? else if (state & Gfx::ENG_RSTATE_TTEXTURE_WHITE) // The transparent white texture?
{ {
@ -379,12 +381,12 @@ void Gfx::CEngine::SetState(int state, Gfx::Color color)
m_device->SetTextureEnabled(0, true); m_device->SetTextureEnabled(0, true);
m_device->SetTextureFactor(color.Inverse()); m_device->SetTextureFactor(color.Inverse());
Gfx::TextureParams params; Gfx::TextureStageParams params;
params.colorOperation = Gfx::TEX_MIX_OPER_ADD; params.colorOperation = Gfx::TEX_MIX_OPER_ADD;
params.colorArg1 = Gfx::TEX_MIX_ARG_TEXTURE; params.colorArg1 = Gfx::TEX_MIX_ARG_TEXTURE;
params.colorArg2 = Gfx::TEX_MIX_ARG_FACTOR; params.colorArg2 = Gfx::TEX_MIX_ARG_FACTOR;
params.alphaOperation = Gfx::TEX_MIX_OPER_MODULATE; params.alphaOperation = Gfx::TEX_MIX_OPER_MODULATE;
m_device->SetTextureParams(0, params); m_device->SetTextureStageParams(0, params);
} }
else if (state & Gfx::ENG_RSTATE_TCOLOR_BLACK) // The transparent black color? else if (state & Gfx::ENG_RSTATE_TCOLOR_BLACK) // The transparent black color?
{ {
@ -398,7 +400,7 @@ void Gfx::CEngine::SetState(int state, Gfx::Color color)
m_device->SetTextureFactor(color); m_device->SetTextureFactor(color);
m_device->SetTextureEnabled(0, true); m_device->SetTextureEnabled(0, true);
m_device->SetTextureParams(0, Gfx::TextureParams()); m_device->SetTextureStageParams(0, Gfx::TextureStageParams());
} }
else if (state & Gfx::ENG_RSTATE_TCOLOR_WHITE) // The transparent white color? else if (state & Gfx::ENG_RSTATE_TCOLOR_WHITE) // The transparent white color?
{ {
@ -412,7 +414,7 @@ void Gfx::CEngine::SetState(int state, Gfx::Color color)
m_device->SetTextureFactor(color.Inverse()); m_device->SetTextureFactor(color.Inverse());
m_device->SetTextureEnabled(0, true); m_device->SetTextureEnabled(0, true);
m_device->SetTextureParams(0, Gfx::TextureParams()); m_device->SetTextureStageParams(0, Gfx::TextureStageParams());
} }
else if (state & Gfx::ENG_RSTATE_TDIFFUSE) // diffuse color as transparent? else if (state & Gfx::ENG_RSTATE_TDIFFUSE) // diffuse color as transparent?
{ {
@ -454,7 +456,7 @@ void Gfx::CEngine::SetState(int state, Gfx::Color color)
m_device->SetRenderState(Gfx::RENDER_STATE_TEXTURING, true); m_device->SetRenderState(Gfx::RENDER_STATE_TEXTURING, true);
m_device->SetTextureEnabled(0, true); m_device->SetTextureEnabled(0, true);
m_device->SetTextureParams(0, Gfx::TextureParams()); m_device->SetTextureStageParams(0, Gfx::TextureStageParams());
/*m_device->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE); /*m_device->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE);
m_device->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE); m_device->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
@ -620,8 +622,8 @@ void Gfx::CEngine::DrawMouse()
material.diffuse = Gfx::Color(1.0f, 1.0f, 1.0f); material.diffuse = Gfx::Color(1.0f, 1.0f, 1.0f);
material.ambient = Gfx::Color(0.5f, 0.5f, 0.5f); material.ambient = Gfx::Color(0.5f, 0.5f, 0.5f);
SetMaterial(material); m_device->SetMaterial(material);
SetTexture("mouse.png"); m_device->SetTexture(0, m_miceTexture);
int index = static_cast<int>(m_mouseType); int index = static_cast<int>(m_mouseType);

2
src/graphics/common/engine.h
View File

@ -516,7 +516,6 @@ public:
bool GetWasInit(); bool GetWasInit();
std::string GetError(); std::string GetError();
bool BeforeCreateInit();
bool Create(); bool Create();
void Destroy(); void Destroy();
@ -970,6 +969,7 @@ protected:
std::map<Gfx::Texture, std::string> m_revTexNameMap; std::map<Gfx::Texture, std::string> m_revTexNameMap;
Gfx::EngineMouse m_mice[Gfx::ENG_MOUSE_COUNT]; Gfx::EngineMouse m_mice[Gfx::ENG_MOUSE_COUNT];
Gfx::Texture m_miceTexture;
Math::Point m_mouseSize; Math::Point m_mouseSize;
Gfx::EngineMouseType m_mouseType; Gfx::EngineMouseType m_mouseType;
Math::Point m_mousePos; Math::Point m_mousePos;

82
src/graphics/common/texture.h
View File

@ -25,15 +25,21 @@ namespace Gfx {
\brief Format of image data */ \brief Format of image data */
enum TexImgFormat enum TexImgFormat
{ {
//! Try to determine automatically (may not work)
TEX_IMG_AUTO,
//! RGB triplet, 3 bytes
TEX_IMG_RGB, TEX_IMG_RGB,
//! BGR triplet, 3 bytes
TEX_IMG_BGR, TEX_IMG_BGR,
//! RGBA triplet, 4 bytes
TEX_IMG_RGBA, TEX_IMG_RGBA,
//! BGRA triplet, 4 bytes
TEX_IMG_BGRA TEX_IMG_BGRA
}; };
/** /**
\enum TexMinFilter \enum TexMinFilter
\brief Minification texture filter \brief Texture minification filter
Corresponds to OpenGL modes but should translate to DirectX too. */ Corresponds to OpenGL modes but should translate to DirectX too. */
enum TexMinFilter enum TexMinFilter
@ -48,7 +54,7 @@ enum TexMinFilter
/** /**
\enum TexMagFilter \enum TexMagFilter
\brief Magnification texture filter */ \brief Texture magnification filter */
enum TexMagFilter enum TexMagFilter
{ {
TEX_MAG_FILTER_NEAREST, TEX_MAG_FILTER_NEAREST,
@ -66,30 +72,42 @@ enum TexWrapMode
/** /**
\enum TexMixOperation \enum TexMixOperation
\brief Multitexture mixing operation \brief Multitexture mixing operation */
*/
enum TexMixOperation enum TexMixOperation
{ {
//! Default operation on default params (modulate on computed & texture)
TEX_MIX_OPER_DEFAULT,
//! = Arg1
TEX_MIX_OPER_REPLACE,
//! = Arg1 * Arg2
TEX_MIX_OPER_MODULATE, TEX_MIX_OPER_MODULATE,
TEX_MIX_OPER_ADD //! = Arg1 + Arg2
TEX_MIX_OPER_ADD,
//! = Arg1 - Arg2
TEX_MIX_OPER_SUBTRACT
}; };
/** /**
\enum TexMixArgument \enum TexMixArgument
\brief Multitexture mixing argument \brief Multitexture mixing argument */
*/
enum TexMixArgument enum TexMixArgument
{ {
TEX_MIX_ARG_CURRENT, //! Color from current texture
TEX_MIX_ARG_TEXTURE, TEX_MIX_ARG_TEXTURE,
TEX_MIX_ARG_DIFFUSE, //! Color computed by previous texture unit (current in DirectX; previous in OpenGL)
TEX_MIX_ARG_COMPUTED_COLOR,
//! (Source) color of textured fragment (diffuse in DirectX; primary color in OpenGL)
TEX_MIX_ARG_SRC_COLOR,
//! Constant color (texture factor in DirectX; texture env color in OpenGL)
TEX_MIX_ARG_FACTOR TEX_MIX_ARG_FACTOR
}; };
/** /**
\struct TextureCreateParams \struct TextureCreateParams
\brief Parameters for texture creation \brief Parameters for texture creation
*/
These params define how particular texture is created and later displayed.
They must be specified at texture creation time and cannot be changed later. */
struct TextureCreateParams struct TextureCreateParams
{ {
//! Whether to generate mipmaps //! Whether to generate mipmaps
@ -100,10 +118,6 @@ struct TextureCreateParams
Gfx::TexMinFilter minFilter; Gfx::TexMinFilter minFilter;
//! Magnification filter //! Magnification filter
Gfx::TexMagFilter magFilter; Gfx::TexMagFilter magFilter;
//! Wrap S coord mode
Gfx::TexWrapMode wrapS;
//! Wrap T coord mode
Gfx::TexWrapMode wrapT;
//! Constructor; calls LoadDefault() //! Constructor; calls LoadDefault()
TextureCreateParams() TextureCreateParams()
@ -117,17 +131,16 @@ struct TextureCreateParams
minFilter = Gfx::TEX_MIN_FILTER_NEAREST; minFilter = Gfx::TEX_MIN_FILTER_NEAREST;
magFilter = Gfx::TEX_MAG_FILTER_NEAREST; magFilter = Gfx::TEX_MAG_FILTER_NEAREST;
wrapS = Gfx::TEX_WRAP_REPEAT;
wrapT = Gfx::TEX_WRAP_REPEAT;
} }
}; };
/** /**
\struct TextureParams \struct TextureStageParams
\brief Parameters for texture creation \brief Parameters for a texture unit
*/
struct TextureParams These params define the behavior of texturing units (stages).
They can be changed freely and are feature of graphics engine, not any particular texture. */
struct TextureStageParams
{ {
//! Mixing operation done on color values //! Mixing operation done on color values
Gfx::TexMixOperation colorOperation; Gfx::TexMixOperation colorOperation;
@ -141,30 +154,41 @@ struct TextureParams
Gfx::TexMixArgument alphaArg1; Gfx::TexMixArgument alphaArg1;
//! 2nd argument of alpha operations //! 2nd argument of alpha operations
Gfx::TexMixArgument alphaArg2; Gfx::TexMixArgument alphaArg2;
//! Wrap mode for 1st tex coord
Gfx::TexWrapMode wrapS;
//! Wrap mode for 2nd tex coord
Gfx::TexWrapMode wrapT;
//! Constructor; calls LoadDefault() //! Constructor; calls LoadDefault()
TextureParams() TextureStageParams()
{ LoadDefault(); } { LoadDefault(); }
//! Loads the default values //! Loads the default values
inline void LoadDefault() inline void LoadDefault()
{ {
colorOperation = Gfx::TEX_MIX_OPER_MODULATE; colorOperation = Gfx::TEX_MIX_OPER_DEFAULT;
colorArg1 = Gfx::TEX_MIX_ARG_CURRENT; colorArg1 = Gfx::TEX_MIX_ARG_COMPUTED_COLOR;
colorArg2 = Gfx::TEX_MIX_ARG_TEXTURE; colorArg2 = Gfx::TEX_MIX_ARG_TEXTURE;
alphaOperation = Gfx::TEX_MIX_OPER_MODULATE; alphaOperation = Gfx::TEX_MIX_OPER_DEFAULT;
alphaArg1 = Gfx::TEX_MIX_ARG_CURRENT; alphaArg1 = Gfx::TEX_MIX_ARG_COMPUTED_COLOR;
alphaArg2 = Gfx::TEX_MIX_ARG_TEXTURE; alphaArg2 = Gfx::TEX_MIX_ARG_TEXTURE;
wrapS = wrapT = Gfx::TEX_WRAP_REPEAT;
} }
}; };
/** \struct Texture*/ /**
\struct Texture
\brief Info about a texture
Identifies (through id) a texture created in graphics engine.
Also contains some additional data. */
struct Texture struct Texture
{ {
//! Whether the texture was loaded //! Whether the texture (ID) is valid
bool valid; bool valid;
//! Id of the texture in graphics engine //! ID of the texture in graphics engine
unsigned int id; unsigned int id;
//! Width of texture //! Width of texture
int width; int width;

273
src/graphics/opengl/gldevice.cpp
View File

@ -20,6 +20,7 @@
#include "graphics/opengl/gldevice.h" #include "graphics/opengl/gldevice.h"
#include "math/geometry.h" #include "math/geometry.h"
// Should define prototypes of used extensions as OpenGL functions
#define GL_GLEXT_PROTOTYPES #define GL_GLEXT_PROTOTYPES
#include <GL/gl.h> #include <GL/gl.h>
@ -71,24 +72,9 @@ std::string Gfx::CGLDevice::GetError()
bool Gfx::CGLDevice::Create() bool Gfx::CGLDevice::Create()
{ {
/* First check for extensions /* NOTE: extension testing is not done here as the assumed version of OpenGL to be used (1.4+)
These should be available in standard OpenGL 1.3 must already have the required extensions. The used extensions are listed here for reference:
But every distribution is different GL_ARB_multitexture, GL_EXT_texture_env_combine, GL_EXT_secondary_color */
So we're loading them dynamically through SDL_GL_GetProcAddress() */
std::string extensions = std::string( (char*) glGetString(GL_EXTENSIONS));
if (extensions.find("GL_ARB_multitexture") == std::string::npos)
{
m_error = "Required extension GL_ARB_multitexture not supported";
return false;
}
if (extensions.find("GL_EXT_texture_env_combine") == std::string::npos)
{
m_error = "Required extension GL_EXT_texture_env_combine not supported";
return false;
}
m_wasInit = true; m_wasInit = true;
@ -112,11 +98,11 @@ bool Gfx::CGLDevice::Create()
m_lightsEnabled = std::vector<bool> (GL_MAX_LIGHTS, false); m_lightsEnabled = std::vector<bool> (GL_MAX_LIGHTS, false);
int maxTextures = 0; int maxTextures = 0;
glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &maxTextures); glGetIntegerv(GL_MAX_TEXTURE_UNITS, &maxTextures);
m_textures = std::vector<Gfx::Texture> (maxTextures, Gfx::Texture()); m_currentTextures = std::vector<Gfx::Texture> (maxTextures, Gfx::Texture());
m_texturesEnabled = std::vector<bool> (maxTextures, false); m_texturesEnabled = std::vector<bool> (maxTextures, false);
m_texturesParams = std::vector<Gfx::TextureParams>(maxTextures, Gfx::TextureParams()); m_textureStageParams = std::vector<Gfx::TextureStageParams>(maxTextures, Gfx::TextureStageParams());
return true; return true;
} }
@ -130,9 +116,9 @@ void Gfx::CGLDevice::Destroy()
m_lights.clear(); m_lights.clear();
m_lightsEnabled.clear(); m_lightsEnabled.clear();
m_textures.clear(); m_currentTextures.clear();
m_texturesEnabled.clear(); m_texturesEnabled.clear();
m_texturesParams.clear(); m_textureStageParams.clear();
m_wasInit = false; m_wasInit = false;
} }
@ -324,7 +310,7 @@ Gfx::Texture Gfx::CGLDevice::CreateTexture(CImage *image, const Gfx::TextureCrea
result.height = data->surface->h; result.height = data->surface->h;
// Use & enable 1st texture stage // Use & enable 1st texture stage
glActiveTextureARB(GL_TEXTURE0_ARB); glActiveTexture(GL_TEXTURE0);
glEnable(GL_TEXTURE_2D); glEnable(GL_TEXTURE_2D);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
@ -352,19 +338,6 @@ Gfx::Texture Gfx::CGLDevice::CreateTexture(CImage *image, const Gfx::TextureCrea
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, magF); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, magF);
if (params.wrapS == Gfx::TEX_WRAP_CLAMP)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
else if (params.wrapS == Gfx::TEX_WRAP_REPEAT)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
else assert(false);
if (params.wrapT == Gfx::TEX_WRAP_CLAMP)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
else if (params.wrapT == Gfx::TEX_WRAP_REPEAT)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
else assert(false);
if (params.mipmap) if (params.mipmap)
glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE); glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
else else
@ -399,8 +372,8 @@ Gfx::Texture Gfx::CGLDevice::CreateTexture(CImage *image, const Gfx::TextureCrea
// Restore the previous state of 1st stage // Restore the previous state of 1st stage
if (m_textures[0].valid) if (m_currentTextures[0].valid)
glBindTexture(GL_TEXTURE_2D, m_textures[0].id); glBindTexture(GL_TEXTURE_2D, m_currentTextures[0].id);
else else
glBindTexture(GL_TEXTURE_2D, 0); glBindTexture(GL_TEXTURE_2D, 0);
@ -417,9 +390,9 @@ void Gfx::CGLDevice::DestroyTexture(const Gfx::Texture &texture)
m_allTextures.erase(it); m_allTextures.erase(it);
// Unbind the texture if in use anywhere // Unbind the texture if in use anywhere
for (int index = 0; index < (int)m_textures.size(); ++index) for (int index = 0; index < (int)m_currentTextures.size(); ++index)
{ {
if (m_textures[index] == texture) if (m_currentTextures[index] == texture)
SetTexture(index, Gfx::Texture()); // set to invalid texture SetTexture(index, Gfx::Texture()); // set to invalid texture
} }
@ -436,7 +409,7 @@ void Gfx::CGLDevice::DestroyAllTextures()
int Gfx::CGLDevice::GetMaxTextureCount() int Gfx::CGLDevice::GetMaxTextureCount()
{ {
return m_textures.size(); return m_currentTextures.size();
} }
/** /**
@ -446,13 +419,13 @@ int Gfx::CGLDevice::GetMaxTextureCount()
void Gfx::CGLDevice::SetTexture(int index, const Gfx::Texture &texture) void Gfx::CGLDevice::SetTexture(int index, const Gfx::Texture &texture)
{ {
assert(index >= 0); assert(index >= 0);
assert(index < (int)m_textures.size()); assert(index < (int)m_currentTextures.size());
// Enable the given texture stage // Enable the given texture stage
glActiveTextureARB(GL_TEXTURE0_ARB + index); glActiveTexture(GL_TEXTURE0 + index);
glEnable(GL_TEXTURE_2D); glEnable(GL_TEXTURE_2D);
m_textures[index] = texture; // remember the change m_currentTextures[index] = texture; // remember the change
if (! texture.valid) if (! texture.valid)
{ {
@ -460,8 +433,8 @@ void Gfx::CGLDevice::SetTexture(int index, const Gfx::Texture &texture)
} }
else else
{ {
glBindTexture(GL_TEXTURE_2D, texture.id); // bind the texture glBindTexture(GL_TEXTURE_2D, texture.id); // bind the texture
SetTextureParams(index, m_texturesParams[index]); // texture params need to be re-set for the new texture SetTextureStageParams(index, m_textureStageParams[index]); // texture stage params need to be re-set for the new texture
} }
// Disable the stage if it is set so // Disable the stage if it is set so
@ -474,19 +447,19 @@ void Gfx::CGLDevice::SetTexture(int index, const Gfx::Texture &texture)
Gfx::Texture Gfx::CGLDevice::GetTexture(int index) Gfx::Texture Gfx::CGLDevice::GetTexture(int index)
{ {
assert(index >= 0); assert(index >= 0);
assert(index < (int)m_textures.size()); assert(index < (int)m_currentTextures.size());
return m_textures[index]; return m_currentTextures[index];
} }
void Gfx::CGLDevice::SetTextureEnabled(int index, bool enabled) void Gfx::CGLDevice::SetTextureEnabled(int index, bool enabled)
{ {
assert(index >= 0); assert(index >= 0);
assert(index < (int)m_textures.size()); assert(index < (int)m_currentTextures.size());
m_texturesEnabled[index] = enabled; m_texturesEnabled[index] = enabled;
glActiveTextureARB(GL_TEXTURE0_ARB + index); glActiveTexture(GL_TEXTURE0 + index);
if (enabled) if (enabled)
glEnable(GL_TEXTURE_2D); glEnable(GL_TEXTURE_2D);
else else
@ -496,7 +469,7 @@ void Gfx::CGLDevice::SetTextureEnabled(int index, bool enabled)
bool Gfx::CGLDevice::GetTextureEnabled(int index) bool Gfx::CGLDevice::GetTextureEnabled(int index)
{ {
assert(index >= 0); assert(index >= 0);
assert(index < (int)m_textures.size()); assert(index < (int)m_currentTextures.size());
return m_texturesEnabled[index]; return m_texturesEnabled[index];
} }
@ -505,111 +478,137 @@ bool Gfx::CGLDevice::GetTextureEnabled(int index)
Sets the texture parameters for the given texture stage. Sets the texture parameters for the given texture stage.
If the given texture was not set (bound) yet, nothing happens. If the given texture was not set (bound) yet, nothing happens.
The settings are remembered, even if texturing is disabled at the moment. */ The settings are remembered, even if texturing is disabled at the moment. */
void Gfx::CGLDevice::SetTextureParams(int index, const Gfx::TextureParams &params) void Gfx::CGLDevice::SetTextureStageParams(int index, const Gfx::TextureStageParams &params)
{ {
assert(index >= 0); assert(index >= 0);
assert(index < (int)m_textures.size()); assert(index < (int)m_currentTextures.size());
// Remember the settings // Remember the settings
m_texturesParams[index] = params; m_textureStageParams[index] = params;
// Don't actually do anything if texture not set // Don't actually do anything if texture not set
if (! m_textures[index].valid) if (! m_currentTextures[index].valid)
return; return;
// Enable the given stage // Enable the given stage
glActiveTextureARB(GL_TEXTURE0_ARB + index); glActiveTexture(GL_TEXTURE0 + index);
glEnable(GL_TEXTURE_2D); glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, m_textures[index].id); glBindTexture(GL_TEXTURE_2D, m_currentTextures[index].id);
// To save some trouble
if ( (params.colorOperation == Gfx::TEX_MIX_OPER_DEFAULT) &&
(params.alphaOperation == Gfx::TEX_MIX_OPER_DEFAULT) )
{
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
goto after_tex_operations;
}
// Selection of operation and arguments
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
// Only these modes of getting color & alpha are used
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA);
// Color operation // Color operation
if (params.colorOperation == Gfx::TEX_MIX_OPER_MODULATE)
glTexEnvi(GL_TEXTURE_2D, GL_COMBINE_RGB_ARB, GL_MODULATE); if (params.colorOperation == Gfx::TEX_MIX_OPER_DEFAULT)
{
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_PREVIOUS);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_2D, GL_COMBINE_RGB, GL_MODULATE);
goto after_tex_color;
}
else if (params.colorOperation == Gfx::TEX_MIX_OPER_REPLACE)
glTexEnvi(GL_TEXTURE_2D, GL_COMBINE_RGB, GL_REPLACE);
else if (params.colorOperation == Gfx::TEX_MIX_OPER_MODULATE)
glTexEnvi(GL_TEXTURE_2D, GL_COMBINE_RGB, GL_MODULATE);
else if (params.colorOperation == Gfx::TEX_MIX_OPER_ADD) else if (params.colorOperation == Gfx::TEX_MIX_OPER_ADD)
glTexEnvi(GL_TEXTURE_2D, GL_COMBINE_RGB_ARB, GL_ADD); glTexEnvi(GL_TEXTURE_2D, GL_COMBINE_RGB, GL_ADD);
else if (params.colorOperation == Gfx::TEX_MIX_OPER_SUBTRACT)
glTexEnvi(GL_TEXTURE_2D, GL_COMBINE_RGB, GL_SUBTRACT);
else assert(false); else assert(false);
// Color arg1 // Color arg1
if (params.colorArg1 == Gfx::TEX_MIX_ARG_CURRENT) if (params.colorArg1 == Gfx::TEX_MIX_ARG_TEXTURE)
{ glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS); // that's right - stupid D3D enum values else if (params.colorArg1 == Gfx::TEX_MIX_ARG_COMPUTED_COLOR)
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_PREVIOUS);
} else if (params.colorArg1 == Gfx::TEX_MIX_ARG_SRC_COLOR)
else if (params.colorArg1 == Gfx::TEX_MIX_ARG_TEXTURE) glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_PRIMARY_COLOR);
{ else if (params.colorArg1 == Gfx::TEX_MIX_ARG_FACTOR)
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_CONSTANT);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
}
else if (params.colorArg1 == Gfx::TEX_MIX_ARG_DIFFUSE)
{
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PRIMARY_COLOR); // here as well
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
}
else assert(false); else assert(false);
// Color arg2 // Color arg2
if (params.colorArg2 == Gfx::TEX_MIX_ARG_CURRENT) if (params.colorArg2 == Gfx::TEX_MIX_ARG_TEXTURE)
{ glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS); else if (params.colorArg2 == Gfx::TEX_MIX_ARG_COMPUTED_COLOR)
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_PREVIOUS);
} else if (params.colorArg2 == Gfx::TEX_MIX_ARG_SRC_COLOR)
else if (params.colorArg2 == Gfx::TEX_MIX_ARG_TEXTURE) glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_PRIMARY_COLOR);
{ else if (params.colorArg2 == Gfx::TEX_MIX_ARG_FACTOR)
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_TEXTURE); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_CONSTANT);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR);
}
else if (params.colorArg2 == Gfx::TEX_MIX_ARG_DIFFUSE)
{
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PRIMARY_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR);
}
else assert(false); else assert(false);
after_tex_color:
// Alpha operation // Alpha operation
if (params.alphaOperation == Gfx::TEX_MIX_OPER_MODULATE) if (params.alphaOperation == Gfx::TEX_MIX_OPER_DEFAULT)
glTexEnvi(GL_TEXTURE_2D, GL_COMBINE_ALPHA_ARB, GL_MODULATE); {
glTexEnvi(GL_TEXTURE_2D, GL_COMBINE_ALPHA, GL_MODULATE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_PREVIOUS);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA, GL_TEXTURE);
goto after_tex_operations;
}
else if (params.colorOperation == Gfx::TEX_MIX_OPER_REPLACE)
glTexEnvi(GL_TEXTURE_2D, GL_COMBINE_ALPHA, GL_REPLACE);
else if (params.alphaOperation == Gfx::TEX_MIX_OPER_MODULATE)
glTexEnvi(GL_TEXTURE_2D, GL_COMBINE_ALPHA, GL_MODULATE);
else if (params.alphaOperation == Gfx::TEX_MIX_OPER_ADD) else if (params.alphaOperation == Gfx::TEX_MIX_OPER_ADD)
glTexEnvi(GL_TEXTURE_2D, GL_COMBINE_ALPHA_ARB, GL_ADD); glTexEnvi(GL_TEXTURE_2D, GL_COMBINE_ALPHA, GL_ADD);
else if (params.alphaOperation == Gfx::TEX_MIX_OPER_SUBTRACT)
glTexEnvi(GL_TEXTURE_2D, GL_COMBINE_ALPHA, GL_SUBTRACT);
else assert(false); else assert(false);
// Alpha arg1 // Alpha arg1
if (params.alphaArg1 == Gfx::TEX_MIX_ARG_CURRENT) if (params.alphaArg1 == Gfx::TEX_MIX_ARG_TEXTURE)
{ glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_PREVIOUS); else if (params.alphaArg1 == Gfx::TEX_MIX_ARG_COMPUTED_COLOR)
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_PREVIOUS);
} else if (params.alphaArg1 == Gfx::TEX_MIX_ARG_SRC_COLOR)
else if (params.alphaArg1 == Gfx::TEX_MIX_ARG_TEXTURE) glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_PRIMARY_COLOR);
{ else if (params.alphaArg1 == Gfx::TEX_MIX_ARG_FACTOR)
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_TEXTURE); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_CONSTANT);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA);
}
else if (params.alphaArg1 == Gfx::TEX_MIX_ARG_DIFFUSE)
{
glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_ALPHA, GL_PRIMARY_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
}
else assert(false); else assert(false);
// Alpha arg2 // Alpha arg2
if (params.alphaArg2 == Gfx::TEX_MIX_ARG_CURRENT) if (params.alphaArg2 == Gfx::TEX_MIX_ARG_TEXTURE)
{ glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_ARB, GL_PREVIOUS); else if (params.alphaArg2 == Gfx::TEX_MIX_ARG_COMPUTED_COLOR)
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_ARB, GL_SRC_ALPHA); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA, GL_PREVIOUS);
} else if (params.alphaArg2 == Gfx::TEX_MIX_ARG_SRC_COLOR)
else if (params.alphaArg2 == Gfx::TEX_MIX_ARG_TEXTURE) glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA, GL_PRIMARY_COLOR);
{ else if (params.alphaArg2 == Gfx::TEX_MIX_ARG_FACTOR)
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_ARB, GL_TEXTURE); glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA, GL_CONSTANT);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_ARB, GL_SRC_ALPHA); else assert(false);
}
else if (params.alphaArg2 == Gfx::TEX_MIX_ARG_DIFFUSE)
{ after_tex_operations:
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_ARB, GL_PRIMARY_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_ARB, GL_SRC_ALPHA); if (params.wrapS == Gfx::TEX_WRAP_CLAMP)
} glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
else if (params.wrapS == Gfx::TEX_WRAP_REPEAT)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
else assert(false);
if (params.wrapT == Gfx::TEX_WRAP_CLAMP)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
else if (params.wrapT == Gfx::TEX_WRAP_REPEAT)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
else assert(false); else assert(false);
// Disable the stage if it is set so // Disable the stage if it is set so
@ -617,21 +616,21 @@ void Gfx::CGLDevice::SetTextureParams(int index, const Gfx::TextureParams &param
glDisable(GL_TEXTURE_2D); glDisable(GL_TEXTURE_2D);
} }
Gfx::TextureParams Gfx::CGLDevice::GetTextureParams(int index) Gfx::TextureStageParams Gfx::CGLDevice::GetTextureStageParams(int index)
{ {
assert(index >= 0); assert(index >= 0);
assert(index < (int)m_textures.size()); assert(index < (int)m_currentTextures.size());
return m_texturesParams[index]; return m_textureStageParams[index];
} }
void Gfx::CGLDevice::SetTextureFactor(const Gfx::Color &color) void Gfx::CGLDevice::SetTextureFactor(const Gfx::Color &color)
{ {
// Needs to be set for all texture stages // Needs to be set for all texture stages
for (int index = 0; index < (int)m_textures.size(); ++index) for (int index = 0; index < (int)m_currentTextures.size(); ++index)
{ {
// Activate stage // Activate stage
glActiveTextureARB(GL_TEXTURE0_ARB + index); glActiveTexture(GL_TEXTURE0 + index);
glEnable(GL_TEXTURE_2D); glEnable(GL_TEXTURE_2D);
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color.Array()); glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color.Array());
@ -645,7 +644,7 @@ void Gfx::CGLDevice::SetTextureFactor(const Gfx::Color &color)
Gfx::Color Gfx::CGLDevice::GetTextureFactor() Gfx::Color Gfx::CGLDevice::GetTextureFactor()
{ {
// Get from 1st stage (should be the same for all stages) // Get from 1st stage (should be the same for all stages)
glActiveTextureARB(GL_TEXTURE0_ARB); glActiveTexture(GL_TEXTURE0);
glEnable(GL_TEXTURE_2D); glEnable(GL_TEXTURE_2D);
GLfloat color[4] = { 0.0f }; GLfloat color[4] = { 0.0f };
@ -672,7 +671,7 @@ void Gfx::CGLDevice::DrawPrimitive(Gfx::PrimitiveType type, const Vertex *vertic
for (int i = 0; i < vertexCount; ++i) for (int i = 0; i < vertexCount; ++i)
{ {
glNormal3fv(const_cast<GLfloat*>(vertices[i].normal.Array())); glNormal3fv(const_cast<GLfloat*>(vertices[i].normal.Array()));
glMultiTexCoord2fvARB(GL_TEXTURE0_ARB, const_cast<GLfloat*>(vertices[i].texCoord.Array())); glMultiTexCoord2fv(GL_TEXTURE0, const_cast<GLfloat*>(vertices[i].texCoord.Array()));
glVertex3fv(const_cast<GLfloat*>(vertices[i].coord.Array())); glVertex3fv(const_cast<GLfloat*>(vertices[i].coord.Array()));
} }
@ -692,7 +691,7 @@ void Gfx::CGLDevice::DrawPrimitive(Gfx::PrimitiveType type, const Gfx::VertexCol
{ {
glColor4fv(const_cast<GLfloat*>(vertices[i].color.Array())); glColor4fv(const_cast<GLfloat*>(vertices[i].color.Array()));
glSecondaryColor3fv(const_cast<GLfloat*>(vertices[i].specular.Array())); glSecondaryColor3fv(const_cast<GLfloat*>(vertices[i].specular.Array()));
glMultiTexCoord2fvARB(GL_TEXTURE0_ARB, const_cast<GLfloat*>(vertices[i].texCoord.Array())); glMultiTexCoord2fv(GL_TEXTURE0, const_cast<GLfloat*>(vertices[i].texCoord.Array()));
glVertex3fv(const_cast<GLfloat*>(vertices[i].coord.Array())); glVertex3fv(const_cast<GLfloat*>(vertices[i].coord.Array()));
} }
@ -713,8 +712,8 @@ void Gfx::CGLDevice::DrawPrimitive(Gfx::PrimitiveType type, const VertexTex2 *ve
for (int i = 0; i < vertexCount; ++i) for (int i = 0; i < vertexCount; ++i)
{ {
glNormal3fv(const_cast<GLfloat*>(vertices[i].normal.Array())); glNormal3fv(const_cast<GLfloat*>(vertices[i].normal.Array()));
glMultiTexCoord2fvARB(GL_TEXTURE0_ARB, const_cast<GLfloat*>(vertices[i].texCoord.Array())); glMultiTexCoord2fv(GL_TEXTURE0, const_cast<GLfloat*>(vertices[i].texCoord.Array()));
glMultiTexCoord2fvARB(GL_TEXTURE1_ARB, const_cast<GLfloat*>(vertices[i].texCoord.Array())); glMultiTexCoord2fv(GL_TEXTURE1, const_cast<GLfloat*>(vertices[i].texCoord.Array()));
glVertex3fv(const_cast<GLfloat*>(vertices[i].coord.Array())); glVertex3fv(const_cast<GLfloat*>(vertices[i].coord.Array()));
} }
@ -814,9 +813,9 @@ void Gfx::CGLDevice::SetRenderState(Gfx::RenderState state, bool enabled)
m_texturing = enabled; m_texturing = enabled;
// Enable/disable stages with new setting // Enable/disable stages with new setting
for (int index = 0; index < (int)m_textures.size(); ++index) for (int index = 0; index < (int)m_currentTextures.size(); ++index)
{ {
glActiveTextureARB(GL_TEXTURE0_ARB + index); glActiveTexture(GL_TEXTURE0 + index);
if (m_texturing && m_texturesEnabled[index]) if (m_texturing && m_texturesEnabled[index])
glEnable(GL_TEXTURE_2D); glEnable(GL_TEXTURE_2D);
else else

9
src/graphics/opengl/gldevice.h
View File

@ -107,8 +107,8 @@ public:
virtual void SetTextureEnabled(int index, bool enabled); virtual void SetTextureEnabled(int index, bool enabled);
virtual bool GetTextureEnabled(int index); virtual bool GetTextureEnabled(int index);
virtual void SetTextureParams(int index, const Gfx::TextureParams &params); virtual void SetTextureStageParams(int index, const Gfx::TextureStageParams &params);
virtual Gfx::TextureParams GetTextureParams(int index); virtual Gfx::TextureStageParams GetTextureStageParams(int index);
virtual void SetTextureFactor(const Gfx::Color &color); virtual void SetTextureFactor(const Gfx::Color &color);
virtual Gfx::Color GetTextureFactor(); virtual Gfx::Color GetTextureFactor();
@ -153,6 +153,7 @@ public:
virtual Gfx::FillMode GetFillMode(); virtual Gfx::FillMode GetFillMode();
private: private:
//! Updates internal modelview matrix
void UpdateModelviewMatrix(); void UpdateModelviewMatrix();
private: private:
@ -181,11 +182,11 @@ private:
//! Whether texturing is enabled in general //! Whether texturing is enabled in general
bool m_texturing; bool m_texturing;
//! Current textures; \c NULL value means unassigned //! Current textures; \c NULL value means unassigned
std::vector<Gfx::Texture> m_textures; std::vector<Gfx::Texture> m_currentTextures;
//! Current texture stages enable status //! Current texture stages enable status
std::vector<bool> m_texturesEnabled; std::vector<bool> m_texturesEnabled;
//! Current texture params //! Current texture params
std::vector<Gfx::TextureParams> m_texturesParams; std::vector<Gfx::TextureStageParams> m_textureStageParams;
//! Set of all created textures //! Set of all created textures
std::set<Gfx::Texture> m_allTextures; std::set<Gfx::Texture> m_allTextures;

11
src/graphics/opengl/test/model_test.cpp
View File

@ -73,7 +73,6 @@ void LoadTexture(Gfx::CGLDevice *device, const std::string &name)
texCreateParams.format = Gfx::TEX_IMG_BGRA; texCreateParams.format = Gfx::TEX_IMG_BGRA;
texCreateParams.minFilter = Gfx::TEX_MIN_FILTER_LINEAR_MIPMAP_LINEAR; texCreateParams.minFilter = Gfx::TEX_MIN_FILTER_LINEAR_MIPMAP_LINEAR;
texCreateParams.magFilter = Gfx::TEX_MAG_FILTER_LINEAR; texCreateParams.magFilter = Gfx::TEX_MAG_FILTER_LINEAR;
texCreateParams.wrapT = Gfx::TEX_WRAP_CLAMP;
tex = device->CreateTexture(&img, texCreateParams); tex = device->CreateTexture(&img, texCreateParams);
} }
@ -139,16 +138,6 @@ void Render(Gfx::CGLDevice *device, Gfx::CModelFile *modelFile)
device->SetTextureEnabled(0, true); device->SetTextureEnabled(0, true);
device->SetTextureEnabled(1, true); device->SetTextureEnabled(1, true);
Gfx::TextureParams tex1Params;
tex1Params.alphaOperation = Gfx::TEX_MIX_OPER_MODULATE;
tex1Params.colorOperation = Gfx::TEX_MIX_OPER_MODULATE;
device->SetTextureParams(0, tex1Params);
Gfx::TextureParams tex2Params;
tex2Params.alphaOperation = Gfx::TEX_MIX_OPER_MODULATE;
tex2Params.colorOperation = Gfx::TEX_MIX_OPER_MODULATE;
device->SetTextureParams(1, tex2Params);
device->SetMaterial(triangles[i].material); device->SetMaterial(triangles[i].material);
tri[0] = triangles[i].p1; tri[0] = triangles[i].p1;

37
src/graphics/opengl/test/texture_test.cpp
View File

@ -10,9 +10,14 @@
void Init(Gfx::CGLDevice *device) void Init(Gfx::CGLDevice *device)
{ {
device->SetRenderState(Gfx::RENDER_STATE_DEPTH_TEST, false);
device->SetShadeModel(Gfx::SHADE_SMOOTH); device->SetShadeModel(Gfx::SHADE_SMOOTH);
device->SetRenderState(Gfx::RENDER_STATE_DEPTH_TEST, false);
device->SetRenderState(Gfx::RENDER_STATE_TEXTURING, true);
device->SetTextureEnabled(0, true);
device->SetTextureEnabled(1, true);
CImage img1; CImage img1;
if (! img1.Load("tex1.png")) if (! img1.Load("tex1.png"))
{ {
@ -31,32 +36,18 @@ void Init(Gfx::CGLDevice *device)
tex1CreateParams.format = Gfx::TEX_IMG_RGBA; tex1CreateParams.format = Gfx::TEX_IMG_RGBA;
tex1CreateParams.minFilter = Gfx::TEX_MIN_FILTER_LINEAR_MIPMAP_LINEAR; tex1CreateParams.minFilter = Gfx::TEX_MIN_FILTER_LINEAR_MIPMAP_LINEAR;
tex1CreateParams.magFilter = Gfx::TEX_MAG_FILTER_LINEAR; tex1CreateParams.magFilter = Gfx::TEX_MAG_FILTER_LINEAR;
tex1CreateParams.wrapT = Gfx::TEX_WRAP_CLAMP;
Gfx::TextureCreateParams tex2CreateParams; Gfx::TextureCreateParams tex2CreateParams;
tex2CreateParams.mipmap = true; tex2CreateParams.mipmap = true;
tex2CreateParams.format = Gfx::TEX_IMG_RGBA; tex2CreateParams.format = Gfx::TEX_IMG_RGBA;
tex2CreateParams.minFilter = Gfx::TEX_MIN_FILTER_NEAREST_MIPMAP_NEAREST; tex2CreateParams.minFilter = Gfx::TEX_MIN_FILTER_NEAREST_MIPMAP_NEAREST;
tex2CreateParams.magFilter = Gfx::TEX_MAG_FILTER_NEAREST; tex2CreateParams.magFilter = Gfx::TEX_MAG_FILTER_NEAREST;
tex2CreateParams.wrapS = Gfx::TEX_WRAP_CLAMP;
Gfx::Texture tex1 = device->CreateTexture(&img1, tex1CreateParams); Gfx::Texture tex1 = device->CreateTexture(&img1, tex1CreateParams);
Gfx::Texture tex2 = device->CreateTexture(&img2, tex2CreateParams); Gfx::Texture tex2 = device->CreateTexture(&img2, tex2CreateParams);
device->SetTexture(0, tex1); device->SetTexture(0, tex1);
device->SetTexture(1, tex2); device->SetTexture(1, tex2);
Gfx::TextureParams tex1Params;
tex1Params.alphaOperation = Gfx::TEX_MIX_OPER_MODULATE;
tex1Params.colorOperation = Gfx::TEX_MIX_OPER_MODULATE;
device->SetTextureParams(0, tex1Params);
Gfx::TextureParams tex2Params;
tex2Params.alphaOperation = Gfx::TEX_MIX_OPER_MODULATE;
tex2Params.colorOperation = Gfx::TEX_MIX_OPER_MODULATE;
device->SetTextureParams(1, tex2Params);
device->SetRenderState(Gfx::RENDER_STATE_TEXTURING, true);
} }
void Render(Gfx::CGLDevice *device) void Render(Gfx::CGLDevice *device)
@ -84,6 +75,16 @@ void Render(Gfx::CGLDevice *device)
Gfx::VertexTex2(Math::Vector(-2.0f, 2.0f, 0.0f), Math::Vector(), Math::Point(0.0f, 0.0f), Math::Point(0.0f, 0.0f)), Gfx::VertexTex2(Math::Vector(-2.0f, 2.0f, 0.0f), Math::Vector(), Math::Point(0.0f, 0.0f), Math::Point(0.0f, 0.0f)),
}; };
Gfx::TextureStageParams tex1StageParams;
tex1StageParams.colorOperation = Gfx::TEX_MIX_OPER_DEFAULT;
tex1StageParams.alphaOperation = Gfx::TEX_MIX_OPER_DEFAULT;
device->SetTextureStageParams(0, tex1StageParams);
Gfx::TextureStageParams tex2StageParams;
tex2StageParams.colorOperation = Gfx::TEX_MIX_OPER_DEFAULT;
tex2StageParams.alphaOperation = Gfx::TEX_MIX_OPER_DEFAULT;
device->SetTextureStageParams(1, tex2StageParams);
Math::Matrix t; Math::Matrix t;
Math::LoadTranslationMatrix(t, Math::Vector(-4.0f, 4.0f, 0.0f)); Math::LoadTranslationMatrix(t, Math::Vector(-4.0f, 4.0f, 0.0f));
device->SetTransform(Gfx::TRANSFORM_VIEW, t); device->SetTransform(Gfx::TRANSFORM_VIEW, t);
@ -101,12 +102,12 @@ void Render(Gfx::CGLDevice *device)
device->DrawPrimitive(Gfx::PRIMITIVE_TRIANGLES, quad, 6); device->DrawPrimitive(Gfx::PRIMITIVE_TRIANGLES, quad, 6);
device->SetTextureEnabled(0, true);
device->SetTextureEnabled(1, true);
Math::LoadTranslationMatrix(t, Math::Vector( 0.0f, -4.0f, 0.0f)); Math::LoadTranslationMatrix(t, Math::Vector( 0.0f, -4.0f, 0.0f));
device->SetTransform(Gfx::TRANSFORM_VIEW, t); device->SetTransform(Gfx::TRANSFORM_VIEW, t);
device->SetTextureEnabled(0, true);
device->SetTextureEnabled(1, true);
device->DrawPrimitive(Gfx::PRIMITIVE_TRIANGLES, quad, 6); device->DrawPrimitive(Gfx::PRIMITIVE_TRIANGLES, quad, 6);
device->EndScene(); device->EndScene();