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

CDevice interface and stub of implementation 

- added CDevice abstract interface
- began implementation of CGLDevice
- added stub for Texture struct
- created CGLDeviceConfig
- changed particule -> particle & other minor changes
dev-ui
Piotr Dziwinski 2012-07-01 01:37:30 +02:00
parent 5bbf897fb1
commit 9bd4ec03b2
13 changed files with 608 additions and 119 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@ -9,6 +9,8 @@ find_package(OpenGL REQUIRED)
find_package(SDL REQUIRED)
find_package(SDL_image REQUIRED)
# TODO: check for SDL version. Should be >= 1.2.10
# Build with debugging symbols
set(CMAKE_BUILD_TYPE debug)

44
src/app/app.cpp
View File

@ -21,6 +21,7 @@
#include "app/system.h"
#include "common/iman.h"
#include "graphics/opengl/gldevice.h"
#include <SDL/SDL.h>
@ -54,6 +55,8 @@ struct ApplicationPrivate
int joystickIndex;
//! Id of joystick timer
SDL_TimerID joystickTimer;
//! Current configuration of OpenGL display device
Gfx::GLDeviceConfig deviceConfig;
ApplicationPrivate()
{
@ -137,18 +140,18 @@ Error CApplication::ParseArguments(int argc, char *argv[])
bool CApplication::Create()
{
// Temporarily -- only in windowed mode
m_deviceConfig.fullScreen = false;
m_private->deviceConfig.fullScreen = false;
// Create the 3D engine.
m_engine = new Gfx::CEngine(m_iMan, this);
/* TODO
// Initialize the app's custom scene stuff
if (! m_engine->OneTimeSceneInit())
{
SystemDialog(SDT_ERROR, "COLOBOT - Error", m_engine->RetError());
return false;
}*/
}
/* // Create the sound instance.
m_sound = new CSound(m_iMan);
@ -178,7 +181,7 @@ bool CApplication::Create()
Uint32 videoFlags = SDL_OPENGL | SDL_GL_DOUBLEBUFFER | SDL_HWPALETTE;
if (m_deviceConfig.resizeable)
if (m_private->deviceConfig.resizeable)
videoFlags |= SDL_RESIZABLE;
// Use hardware surface if available
@ -191,16 +194,25 @@ bool CApplication::Create()
if (videoInfo->blit_hw)
videoFlags |= SDL_HWACCEL;
if (m_deviceConfig.fullScreen)
if (m_private->deviceConfig.fullScreen)
videoFlags |= SDL_FULLSCREEN;
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
// Set OpenGL attributes
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, m_private->deviceConfig.redSize);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, m_private->deviceConfig.greenSize);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, m_private->deviceConfig.blueSize);
SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, m_private->deviceConfig.alphaSize);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, m_private->deviceConfig.depthSize);
if (m_private->deviceConfig.doubleBuf)
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
/* If hardware acceleration specifically requested, this will force the hw accel
and fail with error if not available */
if (m_private->deviceConfig.hardwareAccel)
SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL, 1);
if ((IMG_Init(IMG_INIT_PNG) & IMG_INIT_PNG) == 0)
{
@ -209,8 +221,8 @@ bool CApplication::Create()
return false;
}
m_private->surface = SDL_SetVideoMode(m_deviceConfig.width, m_deviceConfig.height,
m_deviceConfig.bpp, videoFlags);
m_private->surface = SDL_SetVideoMode(m_private->deviceConfig.width, m_private->deviceConfig.height,
m_private->deviceConfig.bpp, videoFlags);
if (m_private->surface == NULL)
{
@ -426,8 +438,8 @@ y: 0=down, 1=up
*/
Math::Point CApplication::WindowToInterfaceCoords(int x, int y)
{
return Math::Point((float)x / (float)m_deviceConfig.width,
1.0f - (float)y / (float)m_deviceConfig.height);
return Math::Point((float)x / (float)m_private->deviceConfig.width,
1.0f - (float)y / (float)m_private->deviceConfig.height);
}
@ -546,7 +558,7 @@ bool CApplication::Render()
if (! result)
return false;
if (m_deviceConfig.doubleBuf)
if (m_private->deviceConfig.doubleBuf)
SDL_GL_SwapBuffers();
return true;

3
src/app/app.h
View File

@ -21,7 +21,6 @@
#include "common/misc.h"
#include "graphics/common/device.h"
#include "graphics/common/engine.h"
#include <string>
@ -162,8 +161,6 @@ protected:
ApplicationPrivate* m_private;
//! Global event queue
CEventQueue* m_eventQueue;
//! Current configuration of display device
Gfx::DeviceConfig m_deviceConfig;
//! Graphics engine
Gfx::CEngine* m_engine;
//! Sound subsystem

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

@ -1,14 +1,33 @@
// * 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"
//! Sets the default values
Gfx::DeviceConfig::DeviceConfig()
void Gfx::DeviceConfig::LoadDefault()
{
width = 800;
height = 600;
bpp = 16;
bpp = 32;
fullScreen = false;
resizeable = false;
hardwareAccel = true;
doubleBuf = true;
noFrame = false;
}
}

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

@ -20,8 +20,22 @@
#pragma once
#include "graphics/common/color.h"
#include "graphics/common/light.h"
#include "graphics/common/material.h"
#include "graphics/common/texture.h"
#include "graphics/common/vertex.h"
#include "math/matrix.h"
namespace Gfx {
/**
\struct DeviceConfig
\brief General config for graphics device
These settings are common window options set by SDL.
*/
struct DeviceConfig
{
//! Screen width
@ -34,19 +48,131 @@ struct DeviceConfig
bool fullScreen;
//! Resizeable window
bool resizeable;
//! Hardware acceleration
bool hardwareAccel;
//! Double buffering
bool doubleBuf;
//! No window frame (also set with full screen)
bool noFrame;
DeviceConfig();
//! Constructor calls LoadDefault()
DeviceConfig() { LoadDefault(); }
//! Loads the default values
void LoadDefault();
};
/**
\enum TransformType
\brief Type of transformation in rendering pipeline
Corresponds directly to DirectX's transformation types. Listed are only the used types. */
enum TransformType
{
TRANSFORM_WORLD,
TRANSFORM_VIEW,
TRANSFORM_PROJECTION
};
/**
\enum RenderState
\brief Render states that can be enabled/disabled
Corresponds to DirectX's render states. Listed are only the used modes.
TODO: replace with functions in CDevice */
enum RenderState
{
RENDER_STATE_ALPHABLENDENABLE,
RENDER_STATE_ALPHAFUNC,
RENDER_STATE_ALPHAREF,
RENDER_STATE_ALPHATESTENABLE,
RENDER_STATE_AMBIENT,
RENDER_STATE_CULLMODE,
RENDER_STATE_DESTBLEND,
RENDER_STATE_DITHERENABLE,
RENDER_STATE_FILLMODE,
RENDER_STATE_FOGCOLOR,
RENDER_STATE_FOGENABLE,
RENDER_STATE_FOGEND,
RENDER_STATE_FOGSTART,
RENDER_STATE_FOGVERTEXMODE,
RENDER_STATE_LIGHTING,
RENDER_STATE_SHADEMODE,
RENDER_STATE_SPECULARENABLE,
RENDER_STATE_SRCBLEND,
RENDER_STATE_TEXTUREFACTOR,
RENDER_STATE_WRAP,
RENDER_STATE_ZBIAS,
RENDER_STATE_ZENABLE,
RENDER_STATE_ZFUNC,
RENDER_STATE_ZWRITEENABLE
};
/**
\enum PrimitiveType
\brief Type of primitive to render
Only these two types are used. */
enum PrimitiveType
{
PRIMITIVE_TRIANGLES,
PRIMITIVE_TRIANGLE_STRIP
};
/**
\class CDevice
\brief Abstract interface of graphics device
It is based on DIRECT3DDEVICE class from DirectX to make it easier to port existing code.
It encapsulates the general graphics device state and provides a common interface
to graphics-specific functions which will be used throughout the program,
both in CEngine class and in UI classes. Note that it doesn't contain all functions from DirectX,
only those that were used in old code.
*/
class CDevice
{
// TODO
public:
//! Initializes the device, setting the initial state
virtual void Initialize() = 0;
//! Destroys the device, releasing every acquired resource
virtual void Destroy() = 0;
// TODO: documentation
virtual void BeginScene() = 0;
virtual void EndScene() = 0;
virtual void Clear() = 0;
virtual void SetTransform(TransformType type, const Math::Matrix &matrix) = 0;
virtual const Math::Matrix& GetTransform(TransformType type) = 0;
virtual void MultiplyTransform(TransformType type, const Math::Matrix &matrix) = 0;
virtual void SetMaterial(const Gfx::Material &material) = 0;
virtual const Gfx::Material& GetMaterial() = 0;
virtual int GetMaxLightCount() = 0;
virtual void SetLight(int index, const Gfx::Light &light) = 0;
virtual const Gfx::Light& GetLight(int index) = 0;
virtual void SetLightEnabled(int index, bool enabled) = 0;
virtual bool GetLightEnabled(int index) = 0;
virtual int GetMaxTextureCount() = 0;
virtual const Gfx::Texture& GetTexture(int index) = 0;
virtual void SetTexture(int index, const Gfx::Texture &texture) = 0;
// TODO:
// virtual void GetTextureStageState() = 0;
// virtual void SetTextureStageState() = 0;
virtual void SetRenderState(Gfx::RenderState state, bool enabled) = 0;
virtual bool GetRenderState(Gfx::RenderState state) = 0;
// TODO:
// virtual void ComputeSphereVisibility() = 0;
virtual void DrawPrimitive(PrimitiveType, Vertex *vertices, int vertexCount) = 0;
virtual void DrawPrimitive(PrimitiveType, VertexTex2 *vertices, int vertexCount) = 0;
};
}; // namespace Gfx

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

@ -35,6 +35,17 @@ Gfx::CEngine::~CEngine()
// TODO
}
std::string Gfx::CEngine::RetError()
{
return m_error;
}
int Gfx::CEngine::OneTimeSceneInit()
{
// TODO
return 1;
}
int Gfx::CEngine::Render()
{
/* Just a hello world for now */
@ -71,3 +82,5 @@ int Gfx::CEngine::Render()
return 1;
}

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

@ -29,10 +29,16 @@
#include "math/vector.h"
#include <string>
class CApplication;
class CInstanceManager;
class CObject;
namespace Snd {
class CSound;
};
namespace Gfx {
@ -117,46 +123,46 @@ enum ShadowType
SHADOW_WORM = 1
};
enum RenderState
enum EngineRenderState
{
//! Normal opaque materials
RSTATE_NORMAL = 0,
ENG_RSTATE_NORMAL = 0,
//! The transparent texture (black = no)
RSTATE_TTEXTURE_BLACK = (1<<0),
ENG_RSTATE_TTEXTURE_BLACK = (1<<0),
//! The transparent texture (white = no)
RSTATE_TTEXTURE_WHITE = (1<<1),
ENG_RSTATE_TTEXTURE_WHITE = (1<<1),
//! The transparent diffuse color
RSTATE_TDIFFUSE = (1<<2),
ENG_RSTATE_TDIFFUSE = (1<<2),
//! Texture wrap
RSTATE_WRAP = (1<<3),
ENG_RSTATE_WRAP = (1<<3),
//! Texture borders with solid color
RSTATE_CLAMP = (1<<4),
ENG_RSTATE_CLAMP = (1<<4),
//! Light texture (ambient max)
RSTATE_LIGHT = (1<<5),
ENG_RSTATE_LIGHT = (1<<5),
//! Double black texturing
RSTATE_DUAL_BLACK = (1<<6),
ENG_RSTATE_DUAL_BLACK = (1<<6),
//! Double white texturing
RSTATE_DUAL_WHITE = (1<<7),
ENG_RSTATE_DUAL_WHITE = (1<<7),
//! Part 1 (no change in. MOD!)
RSTATE_PART1 = (1<<8),
ENG_RSTATE_PART1 = (1<<8),
//! Part 2
RSTATE_PART2 = (1<<9),
ENG_RSTATE_PART2 = (1<<9),
//! Part 3
RSTATE_PART3 = (1<<10),
ENG_RSTATE_PART3 = (1<<10),
//! Part 4
RSTATE_PART4 = (1<<11),
ENG_RSTATE_PART4 = (1<<11),
//! Double-sided face
RSTATE_2FACE = (1<<12),
ENG_RSTATE_2FACE = (1<<12),
//! Image using alpha channel
RSTATE_ALPHA = (1<<13),
ENG_RSTATE_ALPHA = (1<<13),
//! Always use 2nd floor texturing
RSTATE_SECOND = (1<<14),
ENG_RSTATE_SECOND = (1<<14),
//! Causes the fog
RSTATE_FOG = (1<<15),
ENG_RSTATE_FOG = (1<<15),
//! The transparent color (black = no)
RSTATE_TCOLOR_BLACK = (1<<16),
ENG_RSTATE_TCOLOR_BLACK = (1<<16),
//! The transparent color (white = no)
RSTATE_TCOLOR_WHITE = (1<<17)
ENG_RSTATE_TCOLOR_WHITE = (1<<17)
};
@ -289,6 +295,8 @@ public:
CEngine(CInstanceManager *iMan, CApplication *app);
~CEngine();
std::string RetError();
void SetDevice(Gfx::CDevice *device);
Gfx::CDevice* RetDevice();
@ -439,7 +447,7 @@ public:
void RetBackground(char *name, Gfx::Color &up, Gfx::Color &down, Gfx::Color &cloudUp, Gfx::Color &cloudDown, bool &full, bool &quarter);
void SetFrontsizeName(char *name);
void SetOverFront(bool front);
void SetOverColor(const Gfx::Color &color=Gfx::Color(), int mode=RSTATE_TCOLOR_BLACK);
void SetOverColor(const Gfx::Color &color=Gfx::Color(), int mode=ENG_RSTATE_TCOLOR_BLACK);
void SetParticuleDensity(float value);
float RetParticuleDensity();
@ -584,18 +592,20 @@ protected:
void DrawSprite(Math::Point pos, Math::Point dim, int icon);
protected:
CInstanceManager* m_iMan;
CApplication* m_app;
Gfx::CDevice* m_device;
Gfx::CText* m_text;
Gfx::CLight* m_light;
Gfx::CParticle* m_particule;
Gfx::CWater* m_water;
Gfx::CCloud* m_cloud;
Gfx::CLightning* m_blitz;
Gfx::CPlanet* m_planet;
Gfx::CTerrain* m_terrain;
CSound* m_sound;
CInstanceManager* m_iMan;
CApplication* m_app;
Gfx::CDevice* m_device;
Gfx::CText* m_text;
Gfx::CLight* m_light;
Gfx::CParticle* m_particle;
Gfx::CWater* m_water;
Gfx::CCloud* m_cloud;
Gfx::CLightning* m_lightning;
Gfx::CPlanet* m_planet;
Gfx::CTerrain* m_terrain;
Snd::CSound* m_sound;
std::string m_error;
int m_blackSrcBlend[2];
int m_blackDestBlend[2];

104
src/graphics/common/particle.h
View File

@ -50,7 +50,7 @@ const short SH_MAX = 3;
// type == 4 -> text (white background)
enum ParticuleType
enum ParticleType
{
PARTIEXPLOT = 1, // technology explosion
PARTIEXPLOO = 2, // organic explosion
@ -193,20 +193,20 @@ enum ParticuleType
PARTITRACE19 = 159, // trace
};
enum ParticulePhase
enum ParticlePhase
{
PARPHSTART = 0,
PARPHEND = 1,
};
struct Particule
struct Particle
{
char bUsed; // TRUE -> particle used
char bRay; // TRUE -> ray with goal
unsigned short uniqueStamp; // unique mark
short sheet; // sheet (0..n)
ParticuleType type; // type PARTI*
ParticulePhase phase; // phase PARPH*
ParticleType type; // type PARTI*
ParticlePhase phase; // phase PARPH*
float mass; // mass of the particle (in rebounding)
float weight; // weight of the particle (for noise)
float duration; // length of life
@ -233,7 +233,7 @@ struct Particule
struct Track
{
char bUsed; // TRUE -> drag used
char bDrawParticule;
char bDrawParticle;
float step; // duration of not
float last; // increase last not memorized
float intensity; // intensity at starting (0..1)
@ -246,7 +246,7 @@ struct Track
struct WheelTrace
{
ParticuleType type; // type PARTI*
ParticleType type; // type PARTI*
Math::Vector pos[4]; // rectangle positions
float startTime; // beginning of life
};
@ -261,16 +261,16 @@ public:
void SetGLDevice(CDevice device);
void FlushParticule();
void FlushParticule(int sheet);
int CreateParticule(Math::Vector pos, Math::Vector speed, Math::Point dim, ParticuleType type, float duration=1.0f, float mass=0.0f, float windSensitivity=1.0f, int sheet=0);
int CreateFrag(Math::Vector pos, Math::Vector speed, Triangle *triangle, ParticuleType type, float duration=1.0f, float mass=0.0f, float windSensitivity=1.0f, int sheet=0);
int CreatePart(Math::Vector pos, Math::Vector speed, ParticuleType type, float duration=1.0f, float mass=0.0f, float weight=0.0f, float windSensitivity=1.0f, int sheet=0);
int CreateRay(Math::Vector pos, Math::Vector goal, ParticuleType type, Math::Point dim, float duration=1.0f, int sheet=0);
int CreateTrack(Math::Vector pos, Math::Vector speed, Math::Point dim, ParticuleType type, float duration=1.0f, float mass=0.0f, float length=10.0f, float width=1.0f);
void CreateWheelTrace(const Math::Vector &p1, const Math::Vector &p2, const Math::Vector &p3, const Math::Vector &p4, ParticuleType type);
void DeleteParticule(ParticuleType type);
void DeleteParticule(int channel);
void FlushParticle();
void FlushParticle(int sheet);
int CreateParticle(Math::Vector pos, Math::Vector speed, Math::Point dim, ParticleType type, float duration=1.0f, float mass=0.0f, float windSensitivity=1.0f, int sheet=0);
int CreateFrag(Math::Vector pos, Math::Vector speed, Triangle *triangle, ParticleType type, float duration=1.0f, float mass=0.0f, float windSensitivity=1.0f, int sheet=0);
int CreatePart(Math::Vector pos, Math::Vector speed, ParticleType type, float duration=1.0f, float mass=0.0f, float weight=0.0f, float windSensitivity=1.0f, int sheet=0);
int CreateRay(Math::Vector pos, Math::Vector goal, ParticleType type, Math::Point dim, float duration=1.0f, int sheet=0);
int CreateTrack(Math::Vector pos, Math::Vector speed, Math::Point dim, ParticleType type, float duration=1.0f, float mass=0.0f, float length=10.0f, float width=1.0f);
void CreateWheelTrace(const Math::Vector &p1, const Math::Vector &p2, const Math::Vector &p3, const Math::Vector &p4, ParticleType type);
void DeleteParticle(ParticleType type);
void DeleteParticle(int channel);
void SetObjectLink(int channel, CObject *object);
void SetObjectFather(int channel, CObject *object);
void SetPosition(int channel, Math::Vector pos);
@ -279,57 +279,57 @@ public:
void SetAngle(int channel, float angle);
void SetIntensity(int channel, float intensity);
void SetParam(int channel, Math::Vector pos, Math::Point dim, float zoom, float angle, float intensity);
void SetPhase(int channel, ParticulePhase phase, float duration);
void SetPhase(int channel, ParticlePhase phase, float duration);
bool GetPosition(int channel, Math::Vector &pos);
Gfx::Color RetFogColor(Math::Vector pos);
void SetFrameUpdate(int sheet, bool bUpdate);
void FrameParticule(float rTime);
void DrawParticule(int sheet);
void FrameParticle(float rTime);
void DrawParticle(int sheet);
bool WriteWheelTrace(char *filename, int width, int height, Math::Vector dl, Math::Vector ur);
protected:
void DeleteRank(int rank);
bool CheckChannel(int &channel);
void DrawParticuleTriangle(int i);
void DrawParticuleNorm(int i);
void DrawParticuleFlat(int i);
void DrawParticuleFog(int i);
void DrawParticuleRay(int i);
void DrawParticuleSphere(int i);
void DrawParticuleCylinder(int i);
void DrawParticuleWheel(int i);
CObject* SearchObjectGun(Math::Vector old, Math::Vector pos, ParticuleType type, CObject *father);
CObject* SearchObjectRay(Math::Vector pos, Math::Vector goal, ParticuleType type, CObject *father);
void DrawParticleTriangle(int i);
void DrawParticleNorm(int i);
void DrawParticleFlat(int i);
void DrawParticleFog(int i);
void DrawParticleRay(int i);
void DrawParticleSphere(int i);
void DrawParticleCylinder(int i);
void DrawParticleWheel(int i);
CObject* SearchObjectGun(Math::Vector old, Math::Vector pos, ParticleType type, CObject *father);
CObject* SearchObjectRay(Math::Vector pos, Math::Vector goal, ParticleType type, CObject *father);
void Play(Snd::Sound sound, Math::Vector pos, float amplitude);
bool TrackMove(int i, Math::Vector pos, float progress);
void TrackDraw(int i, ParticuleType type);
void TrackDraw(int i, ParticleType type);
protected:
CInstanceManager* m_iMan;
CEngine* m_engine;
CDevice* m_pDevice;
CRobotMain* m_main;
CTerrain* m_terrain;
CWater* m_water;
CSound* m_sound;
CInstanceManager* m_iMan;
CEngine* m_engine;
CDevice* m_pDevice;
CRobotMain* m_main;
CTerrain* m_terrain;
CWater* m_water;
Snd::CSound* m_sound;
Particule m_particule[MAXPARTICULE*MAXPARTITYPE];
Gfx::Triangle m_triangle[MAXPARTICULE]; // triangle if PartiType == 0
Track m_track[MAXTRACK];
int m_wheelTraceTotal;
int m_wheelTraceIndex;
WheelTrace m_wheelTrace[MAXWHEELTRACE];
int m_totalInterface[MAXPARTITYPE][SH_MAX];
bool m_bFrameUpdate[SH_MAX];
int m_fogTotal;
int m_fog[MAXPARTIFOG];
int m_uniqueStamp;
int m_exploGunCounter;
float m_lastTimeGunDel;
float m_absTime;
Gfx::Particle m_particule[MAXPARTICULE*MAXPARTITYPE];
Gfx::Triangle m_triangle[MAXPARTICULE]; // triangle if PartiType == 0
Track m_track[MAXTRACK];
int m_wheelTraceTotal;
int m_wheelTraceIndex;
WheelTrace m_wheelTrace[MAXWHEELTRACE];
int m_totalInterface[MAXPARTITYPE][SH_MAX];
bool m_bFrameUpdate[SH_MAX];
int m_fogTotal;
int m_fog[MAXPARTIFOG];
int m_uniqueStamp;
int m_exploGunCounter;
float m_lastTimeGunDel;
float m_absTime;
};

4
src/graphics/common/text.h
View File

@ -73,7 +73,7 @@ public:
CText(CInstanceManager *iMan, Gfx::CEngine* engine);
~CText();
void SetGLDevice(Gfx::CDevice device);
void SetDevice(Gfx::CDevice *device);
void DrawText(char *string, char *format, int len, Math::Point pos, float width, int justif, float size, float stretch, int eol);
void DrawText(char *string, char *format, Math::Point pos, float width, int justif, float size, float stretch, int eol);
@ -106,7 +106,7 @@ protected:
protected:
CInstanceManager* m_iMan;
Gfx::CEngine* m_engine;
Gfx::CDevice m_pDevice;
Gfx::CDevice* m_device;
};

28
src/graphics/common/texture.h Normal file
View File

@ -0,0 +1,28 @@
// * This file is part of the COLOBOT source code
// * 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/.
// texture.h
#pragma once
namespace Gfx {
struct Texture
{
// TODO
};
}; // namespace Gfx

4
src/graphics/common/water.h
View File

@ -48,7 +48,7 @@ const short MAXWATVAPOR = 10;
struct WaterVapor
{
bool bUsed;
ParticuleType type;
ParticleType type;
Math::Vector pos;
float delay;
float time;
@ -96,7 +96,7 @@ protected:
bool CreateLine(int x, int y, int len);
void VaporFlush();
bool VaporCreate(ParticuleType type, Math::Vector pos, float delay);
bool VaporCreate(ParticleType type, Math::Vector pos, float delay);
void VaporFrame(int i, float rTime);
protected:

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

@ -18,4 +18,194 @@
#include "graphics/opengl/gldevice.h"
// TODO
#include <GL/gl.h>
#include <GL/glu.h>
void Gfx::GLDeviceConfig::LoadDefault()
{
Gfx::DeviceConfig::LoadDefault();
hardwareAccel = true;
redSize = 8;
blueSize = 8;
greenSize = 8;
alphaSize = 8;
depthSize = 24;
}
Gfx::CGLDevice::CGLDevice()
{
m_renderState = 0;
}
Gfx::CGLDevice::~CGLDevice()
{
}
void Gfx::CGLDevice::Initialize()
{
// TODO
}
void Gfx::CGLDevice::Destroy()
{
// TODO
}
void Gfx::CGLDevice::BeginScene()
{
// TODO
}
void Gfx::CGLDevice::EndScene()
{
// TODO
}
void Gfx::CGLDevice::Clear()
{
// TODO
}
void Gfx::CGLDevice::SetTransform(Gfx::TransformType type, const Math::Matrix &matrix)
{
switch (type)
{
case Gfx::TRANSFORM_WORLD:
m_worldMat = matrix;
// TODO
break;
case Gfx::TRANSFORM_VIEW:
m_viewMat = matrix;
// TODO
break;
case Gfx::TRANSFORM_PROJECTION:
m_projectionMat = matrix;
// TODO
break;
default:
assert(false);
}
}
const Math::Matrix& Gfx::CGLDevice::GetTransform(Gfx::TransformType type)
{
switch (type)
{
case Gfx::TRANSFORM_WORLD:
return m_worldMat;
case Gfx::TRANSFORM_VIEW:
return m_viewMat;
case Gfx::TRANSFORM_PROJECTION:
return m_projectionMat;
default:
assert(false);
}
return m_worldMat; // to avoid warning
}
void Gfx::CGLDevice::MultiplyTransform(Gfx::TransformType type, const Math::Matrix &matrix)
{
// TODO
}
void Gfx::CGLDevice::SetMaterial(const Gfx::Material &material)
{
m_material = material;
// TODO
}
const Gfx::Material& Gfx::CGLDevice::GetMaterial()
{
return m_material;
}
int Gfx::CGLDevice::GetMaxLightCount()
{
return m_lights.size();
}
void Gfx::CGLDevice::SetLight(int index, const Gfx::Light &light)
{
assert(index >= 0);
assert(index < (int)m_lights.size());
m_lights[index] = light;
// TODO
}
const Gfx::Light& Gfx::CGLDevice::GetLight(int index)
{
assert(index >= 0);
assert(index < (int)m_lights.size());
return m_lights[index];
}
void Gfx::CGLDevice::SetLightEnabled(int index, bool enabled)
{
assert(index >= 0);
assert(index < (int)m_lightsEnabled.size());
m_lightsEnabled[index] = enabled;
// TODO
}
bool Gfx::CGLDevice::GetLightEnabled(int index)
{
assert(index >= 0);
assert(index < (int)m_lights.size());
return m_lightsEnabled[index];
}
int Gfx::CGLDevice::GetMaxTextureCount()
{
return m_textures.size();
}
const Gfx::Texture& Gfx::CGLDevice::GetTexture(int index)
{
assert(index >= 0);
assert(index < (int)m_textures.size());
return m_textures[index];
}
void Gfx::CGLDevice::SetTexture(int index, const Gfx::Texture &texture)
{
assert(index >= 0);
assert(index < (int)m_textures.size());
m_textures[index] = texture;
// TODO
}
void Gfx::CGLDevice::SetRenderState(Gfx::RenderState state, bool enabled)
{
// TODO
}
bool Gfx::CGLDevice::GetRenderState(Gfx::RenderState state)
{
// TODO
return false;
}
void Gfx::CGLDevice::DrawPrimitive(Gfx::PrimitiveType, Vertex *vertices, int vertexCount)
{
// TODO
}
void Gfx::CGLDevice::DrawPrimitive(Gfx::PrimitiveType, VertexTex2 *vertices, int vertexCount)
{
// TODO
}

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

@ -21,11 +21,103 @@
#include "graphics/common/device.h"
#include <vector>
namespace Gfx {
/**
\struct GLDeviceConfig
\brief Additional config with OpenGL-specific settings */
struct GLDeviceConfig : public DeviceConfig
{
//! Size of red channel in bits
int redSize;
//! Size of green channel in bits
int greenSize;
//! Size of blue channel in bits
int blueSize;
//! Size of alpha channel in bits
int alphaSize;
//! Color depth in bits
int depthSize;
//! Force hardware acceleration (video mode set will fail on lack of hw accel)
bool hardwareAccel;
//! Constructor calls LoadDefaults()
GLDeviceConfig() { LoadDefault(); }
//! Loads the default values
void LoadDefault();
};
/**
\class CGLDevice
\brief Implementation of CDevice interface in OpenGL
Provides the concrete implementation of 3D device in OpenGL.
This class should be initialized (by calling Initialize() ) only after
setting the video mode by CApplication, once the OpenGL context is defined.
Because of that, CGLDeviceConfig is outside the CDevice class and must be set
in CApplication.
*/
class CGLDevice : public Gfx::CDevice
{
// TODO
public:
CGLDevice();
virtual ~CGLDevice();
virtual void Initialize();
virtual void Destroy();
virtual void BeginScene();
virtual void EndScene();
virtual void Clear();
virtual void SetTransform(Gfx::TransformType type, const Math::Matrix &matrix);
virtual const Math::Matrix& GetTransform(Gfx::TransformType type);
virtual void MultiplyTransform(Gfx::TransformType type, const Math::Matrix &matrix);
virtual void SetMaterial(const Gfx::Material &material);
virtual const Gfx::Material& GetMaterial();
virtual int GetMaxLightCount();
virtual void SetLight(int index, const Gfx::Light &light);
virtual const Gfx::Light& GetLight(int index);
virtual void SetLightEnabled(int index, bool enabled);
virtual bool GetLightEnabled(int index);
virtual int GetMaxTextureCount();
virtual const Gfx::Texture& GetTexture(int index);
virtual void SetTexture(int index, const Gfx::Texture &texture);
virtual void SetRenderState(Gfx::RenderState state, bool enabled);
virtual bool GetRenderState(Gfx::RenderState state);
virtual void DrawPrimitive(Gfx::PrimitiveType, Vertex *vertices, int vertexCount);
virtual void DrawPrimitive(Gfx::PrimitiveType, VertexTex2 *vertices, int vertexCount);
private:
//! Current world matrix
Math::Matrix m_worldMat;
//! Current view matrix
Math::Matrix m_viewMat;
//! Current projection matrix
Math::Matrix m_projectionMat;
//! The current material
Gfx::Material m_material;
//! Current lights
std::vector<Gfx::Light> m_lights;
//! Current lights enable status
std::vector<bool> m_lightsEnabled;
//! Current textures
std::vector<Gfx::Texture> m_textures;
//! Current render state
unsigned long m_renderState;
};
}; // namespace Gfx