2 files changed, 284 insertions, 2 deletions
diff --git a/src/graphics/opengl/gldevice.cpp b/src/graphics/opengl/gldevice.cpp
index 7938e62..9ef376f 100644
--- a/src/graphics/opengl/gldevice.cpp
+++ b/src/graphics/opengl/gldevice.cpp
@@ -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
+}
diff --git a/src/graphics/opengl/gldevice.h b/src/graphics/opengl/gldevice.h
index a2fb4a0..0b4702a 100644
--- a/src/graphics/opengl/gldevice.h
+++ b/src/graphics/opengl/gldevice.h
@@ -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