path: root/src/graphics/common/engine.h

// * 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/.

// engine.h

#pragma once


#include "graphics/common/color.h"
#include "graphics/common/material.h"
#include "graphics/common/vertex.h"
#include "math/intpoint.h"
#include "math/matrix.h"
#include "math/point.h"
#include "math/vector.h"


#include <string>


class CApplication;
class CInstanceManager;
class CObject;
class CSound;


namespace Gfx {

class CDevice;
class CLight;
class CText;
class CParticle;
class CWater;
class CCloud;
class CLightning;
class CPlanet;
class CTerrain;


//const int MAXOBJECT       = 1200;
//const int MAXSHADOW       = 500;
//const int MAXGROUNDSPOT   = 100;


enum ObjectType
{
    //! Object doesn't exist
    OBJTYPE_NULL        = 0,
    //! Terrain
    OBJTYPE_TERRAIN     = 1,
    //! Fixed object
    OBJTYPE_FIX         = 2,
    //! Moving object
    OBJTYPE_VEHICULE    = 3,
    //! Part of a moving object
    OBJTYPE_DESCENDANT  = 4,
    //! Fixed object type quartz
    OBJTYPE_QUARTZ      = 5,
    //! Fixed object type metal
    OBJTYPE_METAL       = 6
};

enum TriangleType
{
    //! triangles
    TRIANGLE_TYPE_6T        = 1,
    //! surfaces
    TRIANGLE_TYPE_6S        = 2
};

enum Mapping
{
    MAPPING_X       = 1,
    MAPPING_Y       = 2,
    MAPPING_Z       = 3,
    MAPPING_1X      = 4,
    MAPPING_1Y      = 5,
    MAPPING_1Z      = 6
};

enum MouseType
{
    MOUSE_HIDE      = 0,        // no mouse
    MOUSE_NORM      = 1,
    MOUSE_WAIT      = 2,
    MOUSE_EDIT      = 3,
    MOUSE_HAND      = 4,
    MOUSE_CROSS     = 5,
    MOUSE_SHOW      = 6,
    MOUSE_NO        = 7,
    MOUSE_MOVE      = 8,        // +
    MOUSE_MOVEH     = 9,        // -
    MOUSE_MOVEV     = 10,       // |
    MOUSE_MOVED     = 11,       // /
    MOUSE_MOVEI     = 12,       // \ //
    MOUSE_SCROLLL   = 13,       // <<
    MOUSE_SCROLLR   = 14,       // >>
    MOUSE_SCROLLU   = 15,       // ^
    MOUSE_SCROLLD   = 16,       // v
    MOUSE_TARGET    = 17
};

enum ShadowType
{
    SHADOW_NORM = 0,
    SHADOW_WORM = 1
};

enum EngineRenderState
{
    //! Normal opaque materials
    ENG_RSTATE_NORMAL           = 0,
    //! The transparent texture (black = no)
    ENG_RSTATE_TTEXTURE_BLACK   = (1<<0),
    //! The transparent texture (white = no)
    ENG_RSTATE_TTEXTURE_WHITE   = (1<<1),
    //! The transparent diffuse color
    ENG_RSTATE_TDIFFUSE         = (1<<2),
    //! Texture wrap
    ENG_RSTATE_WRAP             = (1<<3),
    //! Texture borders with solid color
    ENG_RSTATE_CLAMP            = (1<<4),
    //! Light texture (ambient max)
    ENG_RSTATE_LIGHT            = (1<<5),
    //! Double black texturing
    ENG_RSTATE_DUAL_BLACK       = (1<<6),
    //! Double white texturing
    ENG_RSTATE_DUAL_WHITE       = (1<<7),
    //! Part 1 (no change in. MOD!)
    ENG_RSTATE_PART1            = (1<<8),
    //! Part 2
    ENG_RSTATE_PART2            = (1<<9),
    //! Part 3
    ENG_RSTATE_PART3            = (1<<10),
    //! Part 4
    ENG_RSTATE_PART4            = (1<<11),
    //! Double-sided face
    ENG_RSTATE_2FACE            = (1<<12),
    //! Image using alpha channel
    ENG_RSTATE_ALPHA            = (1<<13),
    //! Always use 2nd floor texturing
    ENG_RSTATE_SECOND           = (1<<14),
    //! Causes the fog
    ENG_RSTATE_FOG              = (1<<15),
    //! The transparent color (black = no)
    ENG_RSTATE_TCOLOR_BLACK     = (1<<16),
    //! The transparent color (white = no)
    ENG_RSTATE_TCOLOR_WHITE     = (1<<17)
};


struct Triangle
{
    Gfx::VertexTex2     triangle[3];
    Gfx::Material       material;
    int                 state;
    char                texName1[20];
    char                texName2[20];
};


struct ObjLevel6
{
    int                 totalPossible;
    int                 totalUsed;
    Gfx::Material       material;
    int                 state;
    Gfx::TriangleType   type;
    Gfx::VertexTex2 vertex[1];
};

struct ObjLevel5
{
    int             totalPossible;
    int             totalUsed;
    int             reserve;
    Gfx::ObjLevel6* table[1];
};

struct ObjLevel4
{
    int             totalPossible;
    int             totalUsed;
    float           min, max;
    Gfx::ObjLevel5* table[1];
};

struct ObjLevel3
{
    int             totalPossible;
    int             totalUsed;
    int             objRank;
    Gfx::ObjLevel4* table[1];
};

struct ObjLevel2
{
    int             totalPossible;
    int             totalUsed;
    char            texName1[20];
    char            texName2[20];
    Gfx::ObjLevel3* table[1];
};

struct ObjLevel1
{
    int             totalPossible;
    int             totalUsed;
    Gfx::ObjLevel2* table[1];
};


struct Object
{
    bool                used;           // true -> object exists
    bool                visible;        // true -> visible object
    bool                drawWorld;      // true -> shape behind the interface
    bool                drawFront;      // true -> shape before the interface
    int                 totalTriangle;      // number of triangles used
    Gfx::ObjectType     type;           // type of the object (TYPE*)
    Math::Matrix        transform;      // transformation matrix
    float               distance;       // distance point of view - original
    Math::Vector        bboxMin;        // bounding box of the object
    Math::Vector        bboxMax;        // (the origin 0, 0, 0 is always included)
    float               radius;         // radius of the sphere at the origin
    int                 shadowRank;     // rank of the associated shadow
    float               transparency;       // transparency of the object (0 .. 1)
};

struct Shadow
{
    bool                used;           // true -> object exists
    bool                hide;           // true -> invisible shadow (object carried by ex.)
    int                 objRank;        // rank of the object
    Gfx::ShadowType     type;           // type of shadow
    Math::Vector        pos;            // position for the shadow
    Math::Vector        normal;         // normal terrain
    float               angle;          // angle of the shadow
    float               radius;         // radius of the shadow
    float               intensity;      // intensity of the shadow
    float               height;         // height from the ground
};

struct GroundSpot
{
    bool            used;           // true -> object exists
    Gfx::Color      color;          // color of the shadow
    float           min, max;       // altitudes min / max
    float           smooth;         // transition area
    Math::Vector    pos;            // position for the shadow
    float           radius;         // radius of the shadow
    Math::Vector    drawPos;        // drawn to position the shade
    float           drawRadius;     // radius of the shadow drawn
};

struct GroundMark
{
    bool            used;           // true -> object exists
    bool            draw;           // true -> drawn mark
    int             phase;          // 1 = increase, 2 = fixed, 3 = decrease
    float           delay[3];       // time for 3 phases
    float           fix;            // fixed time
    Math::Vector    pos;            // position for marks
    float           radius;         // radius of marks
    float           intensity;      // color intensity
    Math::Vector    drawPos;        // drawn in position marks
    float           drawRadius;     // radius marks drawn
    float           drawIntensity;      // current drawn
    int             dx, dy;         // dimensions table
    char*           table;          // pointer to the table
};



class CEngine
{
public:
    CEngine(CInstanceManager *iMan, CApplication *app);
    ~CEngine();

    bool            GetWasInit();
    std::string     GetError();

    bool            BeforeCreateInit();
    bool            Create();
    void            Destroy();

    void            SetDevice(Gfx::CDevice *device);
    Gfx::CDevice*   GetDevice();

    bool            AfterDeviceSetInit();


    bool            Render();



    void            SetTerrain(Gfx::CTerrain* terrain);

    bool            WriteProfile();

    void            SetPause(bool pause);
    bool            GetPause();

    void            SetMovieLock(bool lock);
    bool            GetMovieLock();

    void            SetShowStat(bool show);
    bool            GetShowStat();

    void            SetRenderEnable(bool enable);

    int             OneTimeSceneInit();
    int             InitDeviceObjects();
    int             DeleteDeviceObjects();
    int             RestoreSurfaces();
    int             FrameMove(float rTime);
    void            StepSimul(float rTime);
    int             FinalCleanup();
    void            AddStatisticTriangle(int nb);
    int             GetStatisticTriangle();
    void            SetHiliteRank(int *rankList);
    bool            GetHilite(Math::Point &p1, Math::Point &p2);
    bool            GetSpriteCoord(int &x, int &y);
    void            SetInfoText(int line, char* text);
    char    *       GetInfoText(int line);
    //LRESULT       MsgProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
    void            FirstExecuteAdapt(bool first);
    //int               GetVidMemTotal();
    //bool          IsVideo8MB();
    //bool          IsVideo32MB();

    bool            EnumDevices(char *bufDevices, int lenDevices, char *bufModes, int lenModes, int &totalDevices, int &selectDevices, int &totalModes, int &selectModes);
    bool            GetFullScreen();
    bool            ChangeDevice(char *device, char *mode, bool full);

    Math::Matrix*   GetMatView();
    Math::Matrix*   GetMatLeftView();
    Math::Matrix*   GetMatRightView();

    void            TimeInit();
    void            TimeEnterGel();
    void            TimeExitGel();
    float           TimeGet();

    int             GetRestCreate();
    int             CreateObject();
    void            FlushObject();
    bool            DeleteObject(int objRank);
    bool            SetDrawWorld(int objRank, bool draw);
    bool            SetDrawFront(int objRank, bool draw);
    bool            AddTriangle(int objRank, Gfx::VertexTex2* vertex, int nb, const Gfx::Material &mat, int state, char* texName1, char* texName2, float min, float max, bool globalUpdate);
    bool            AddSurface(int objRank, Gfx::VertexTex2* vertex, int nb, const Gfx::Material &mat, int state, char* texName1, char* texName2, float min, float max, bool globalUpdate);
    bool            AddQuick(int objRank, Gfx::ObjLevel6* buffer, char* texName1, char* texName2, float min, float max, bool globalUpdate);
    Gfx::ObjLevel6* SearchTriangle(int objRank, const Gfx::Material &mat, int state, char* texName1, char* texName2, float min, float max);
    void            ChangeLOD();
    bool            ChangeSecondTexture(int objRank, char* texName2);
    int             GetTotalTriangles(int objRank);
    int             GetTriangles(int objRank, float min, float max, Gfx::Triangle* buffer, int size, float percent);
    bool            GetBBox(int objRank, Math::Vector &min, Math::Vector &max);
    bool            ChangeTextureMapping(int objRank, const Gfx::Material &mat, int state, char* texName1, char* texName2, float min, float max, Gfx::Mapping mode, float au, float bu, float av, float bv);
    bool            TrackTextureMapping(int objRank, const Gfx::Material &mat, int state, char* texName1, char* texName2, float min, float max, Gfx::Mapping mode, float pos, float factor, float tl, float ts, float tt);
    bool            SetObjectTransform(int objRank, const Math::Matrix &transform);
    bool            GetObjectTransform(int objRank, Math::Matrix &transform);
    bool            SetObjectType(int objRank, Gfx::ObjectType type);
    Gfx::ObjectType GetObjectType(int objRank);
    bool            SetObjectTransparency(int objRank, float value);

    bool            ShadowCreate(int objRank);
    void            ShadowDelete(int objRank);
    bool            SetObjectShadowHide(int objRank, bool hide);
    bool            SetObjectShadowType(int objRank, Gfx::ShadowType type);
    bool            SetObjectShadowPos(int objRank, const Math::Vector &pos);
    bool            SetObjectShadowNormal(int objRank, const Math::Vector &n);
    bool            SetObjectShadowAngle(int objRank, float angle);
    bool            SetObjectShadowRadius(int objRank, float radius);
    bool            SetObjectShadowIntensity(int objRank, float intensity);
    bool            SetObjectShadowHeight(int objRank, float h);
    float           GetObjectShadowRadius(int objRank);

    void            GroundSpotFlush();
    int             GroundSpotCreate();
    void            GroundSpotDelete(int rank);
    bool            SetObjectGroundSpotPos(int rank, const Math::Vector &pos);
    bool            SetObjectGroundSpotRadius(int rank, float radius);
    bool            SetObjectGroundSpotColor(int rank, const Gfx::Color &color);
    bool            SetObjectGroundSpotMinMax(int rank, float min, float max);
    bool            SetObjectGroundSpotSmooth(int rank, float smooth);

    int             GroundMarkCreate(Math::Vector pos, float radius, float delay1, float delay2, float delay3, int dx, int dy, char* table);
    bool            GroundMarkDelete(int rank);

    void            Update();

    void            SetViewParams(const Math::Vector &vEyePt, const Math::Vector &vLookatPt, const Math::Vector &vUpVec, float fEyeDistance);

    bool            FreeTexture(char* name);
    bool            LoadTexture(char* name, int stage=0);
    bool            LoadAllTexture();

    void            SetLimitLOD(int rank, float limit);
    float           GetLimitLOD(int rank, bool last=false);

    void            SetTerrainVision(float vision);

    void            SetGroundSpot(bool mode);
    bool            GetGroundSpot();
    void            SetShadow(bool mode);
    bool            GetShadow();
    void            SetDirty(bool mode);
    bool            GetDirty();
    void            SetFog(bool mode);
    bool            GetFog();
    bool            GetStateColor();

    void            SetSecondTexture(int texNum);
    int             GetSecondTexture();

    void            SetRankView(int rank);
    int             GetRankView();

    void            SetDrawWorld(bool draw);
    void            SetDrawFront(bool draw);

    void            SetAmbiantColor(const Gfx::Color &color, int rank=0);
    Gfx::Color      GetAmbiantColor(int rank=0);

    void            SetWaterAddColor(const Gfx::Color &color);
    Gfx::Color      GetWaterAddColor();

    void            SetFogColor(const Gfx::Color &color, int rank=0);
    Gfx::Color      GetFogColor(int rank=0);

    void            SetDeepView(float length, int rank=0, bool ref=false);
    float           GetDeepView(int rank=0);

    void            SetFogStart(float start, int rank=0);
    float           GetFogStart(int rank=0);

    void            SetBackground(char *name, Gfx::Color up=Gfx::Color(), Gfx::Color down=Gfx::Color(), Gfx::Color cloudUp=Gfx::Color(), Gfx::Color cloudDown=Gfx::Color(), bool full=false, bool quarter=false);
    void            GetBackground(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=ENG_RSTATE_TCOLOR_BLACK);

    void            SetParticuleDensity(float value);
    float           GetParticuleDensity();
    float           ParticuleAdapt(float factor);

    void            SetClippingDistance(float value);
    float           GetClippingDistance();

    void            SetObjectDetail(float value);
    float           GetObjectDetail();

    void            SetGadgetQuantity(float value);
    float           GetGadgetQuantity();

    void            SetTextureQuality(int value);
    int             GetTextureQuality();

    void            SetTotoMode(bool present);
    bool            GetTotoMode();

    void            SetLensMode(bool present);
    bool            GetLensMode();

    void            SetWaterMode(bool present);
    bool            GetWaterMode();

    void            SetBlitzMode(bool present);
    bool            GetBlitzMode();

    void            SetSkyMode(bool present);
    bool            GetSkyMode();

    void            SetBackForce(bool present);
    bool            GetBackForce();

    void            SetPlanetMode(bool present);
    bool            GetPlanetMode();

    void            SetLightMode(bool present);
    bool            GetLightMode();

    void            SetEditIndentMode(bool autoIndent);
    bool            GetEditIndentMode();

    void            SetEditIndentValue(int value);
    int             GetEditIndentValue();

    void            SetSpeed(float speed);
    float           GetSpeed();

    void            SetTracePrecision(float factor);
    float           GetTracePrecision();

    void            SetFocus(float focus);
    float           GetFocus();
    Math::Vector    GetEyePt();
    Math::Vector    GetLookatPt();
    float           GetEyeDirH();
    float           GetEyeDirV();
    Math::Point     GetDim();
    void            UpdateMatProj();

    void            ApplyChange();

    void            FlushPressKey();
    void            ResetKey();
    void            SetKey(int keyRank, int option, int key);
    int             GetKey(int keyRank, int option);

    void            SetJoystick(bool enable);
    bool            GetJoystick();

    void            SetDebugMode(bool mode);
    bool            GetDebugMode();
    bool            GetSetupMode();

    bool            IsVisiblePoint(const Math::Vector &pos);

    int             DetectObject(Math::Point mouse);
    void            SetState(int state, Gfx::Color color=Gfx::Color(1.0f, 1.0f, 1.0f, 1.0f));
    void            SetTexture(char *name, int stage=0);
    void            SetMaterial(const Gfx::Material &mat);

    void            MoveMousePos(Math::Point pos);
    void            SetMousePos(Math::Point pos);
    Math::Point     GetMousePos();
    void            SetMouseType(Gfx::MouseType type);
    Gfx::MouseType  GetMouseType();
    void            SetMouseHide(bool hide);
    bool            GetMouseHide();
    void            SetNiceMouse(bool nice);
    bool            GetNiceMouse();
    bool            GetNiceMouseCap();

    CText*          GetText();

    bool            ChangeColor(char *name, Gfx::Color colorRef1, Gfx::Color colorNew1, Gfx::Color colorRef2, Gfx::Color colorNew2, float tolerance1, float tolerance2, Math::Point ts, Math::Point ti, Math::Point *pExclu=0, float shift=0.0f, bool hSV=false);
    bool            OpenImage(char *name);
    bool            CopyImage();
    bool            LoadImage();
    bool            ScrollImage(int dx, int dy);
    bool            SetDot(int x, int y, Gfx::Color color);
    bool            CloseImage();
    bool            WriteScreenShot(char *filename, int width, int height);
    //bool      GetRenderDC(HDC &hDC);
    //bool      ReleaseRenderDC(HDC &hDC);
    //PBITMAPINFO   CreateBitmapInfoStruct(HBITMAP hBmp);
    //bool      CreateBMPFile(LPTSTR pszFile, PBITMAPINFO pbi, HBITMAP hBMP, HDC hDC);

protected:
    void        MemSpace1(Gfx::ObjLevel1 *&p, int nb);
    void        MemSpace2(Gfx::ObjLevel2 *&p, int nb);
    void        MemSpace3(Gfx::ObjLevel3 *&p, int nb);
    void        MemSpace4(Gfx::ObjLevel4 *&p, int nb);
    void        MemSpace5(Gfx::ObjLevel5 *&p, int nb);
    void        MemSpace6(Gfx::ObjLevel6 *&p, int nb);

    Gfx::ObjLevel2* AddLevel1(Gfx::ObjLevel1 *&p1, char* texName1, char* texName2);
    Gfx::ObjLevel3* AddLevel2(Gfx::ObjLevel2 *&p2, int objRank);
    Gfx::ObjLevel4* AddLevel3(Gfx::ObjLevel3 *&p3, float min, float max);
    Gfx::ObjLevel5* AddLevel4(Gfx::ObjLevel4 *&p4, int reserve);
    Gfx::ObjLevel6* AddLevel5(Gfx::ObjLevel5 *&p5, Gfx::TriangleType type, const Gfx::Material &mat, int state, int nb);

    bool        IsVisible(int objRank);
    bool        DetectBBox(int objRank, Math::Point mouse);
    bool        DetectTriangle(Math::Point mouse, Gfx::VertexTex2 *triangle, int objRank, float &dist);
    bool        TransformPoint(Math::Vector &p2D, int objRank, Math::Vector p3D);
    void        ComputeDistance();
    void        UpdateGeometry();
    void        RenderGroundSpot();
    void        DrawShadow();
    void        DrawBackground();
    void        DrawBackgroundGradient(Gfx::Color up, Gfx::Color down);
    void        DrawBackgroundImageQuarter(Math::Point p1, Math::Point p2, char *name);
    void        DrawBackgroundImage();
    void        DrawPlanet();
    void        DrawFrontsize();
    void        DrawOverColor();
    bool        GetBBox2D(int objRank, Math::Point &min, Math::Point &max);
    void        DrawHilite();
    void        DrawMouse();
    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_particle;
    Gfx::CWater*     m_water;
    Gfx::CCloud*     m_cloud;
    Gfx::CLightning* m_lightning;
    Gfx::CPlanet*    m_planet;
    Gfx::CTerrain*   m_terrain;
    CSound*          m_sound;

    bool            m_wasInit;
    std::string     m_error;

    int             m_blackSrcBlend[2];
    int             m_blackDestBlend[2];
    int             m_whiteSrcBlend[2];
    int             m_whiteDestBlend[2];
    int             m_diffuseSrcBlend[2];
    int             m_diffuseDestBlend[2];
    int             m_alphaSrcBlend[2];
    int             m_alphaDestBlend[2];

    Math::Matrix    m_matProj;
    Math::Matrix    m_matLeftView;
    Math::Matrix    m_matRightView;
    Math::Matrix    m_matView;
    float           m_focus;

    Math::Matrix    m_matWorldInterface;
    Math::Matrix    m_matProjInterface;
    Math::Matrix    m_matViewInterface;

    long            m_baseTime;
    long            m_stopTime;
    float           m_absTime;
    float           m_lastTime;
    float           m_speed;
    bool            m_pause;
    bool            m_render;
    bool            m_movieLock;

    Math::IntPoint      m_dim;
    Math::IntPoint      m_lastDim;
    Gfx::ObjLevel1*     m_objectPointer;
    int                 m_objectParamTotal;
    Gfx::Object*        m_objectParam;
    int                 m_shadowTotal;
    Gfx::Shadow*        m_shadow;
    Gfx::GroundSpot*    m_groundSpot;
    Gfx::GroundMark     m_groundMark;
    Math::Vector        m_eyePt;
    Math::Vector        m_lookatPt;
    float           m_eyeDirH;
    float           m_eyeDirV;
    int             m_rankView;
    Gfx::Color      m_ambiantColor[2];
    Gfx::Color      m_backColor[2];
    Gfx::Color      m_fogColor[2];
    float           m_deepView[2];
    float           m_fogStart[2];
    Gfx::Color      m_waterAddColor;
    int             m_statisticTriangle;
    bool            m_updateGeometry;
    char            m_infoText[10][200];
    int             m_alphaMode;
    bool            m_stateColor;
    bool            m_forceStateColor;
    bool            m_groundSpotVisible;
    bool            m_shadowVisible;
    bool            m_dirty;
    bool            m_fog;
    bool            m_firstGroundSpot;
    int             m_secondTexNum;
    char            m_backgroundName[50];
    Gfx::Color      m_backgroundColorUp;
    Gfx::Color      m_backgroundColorDown;
    Gfx::Color      m_backgroundCloudUp;
    Gfx::Color      m_backgroundCloudDown;
    bool            m_backgroundFull;
    bool            m_backgroundQuarter;
    bool            m_overFront;
    Gfx::Color      m_overColor;
    int             m_overMode;
    char            m_frontsizeName[50];
    bool            m_drawWorld;
    bool            m_drawFront;
    float           m_limitLOD[2];
    float           m_particuleDensity;
    float           m_clippingDistance;
    float           m_lastClippingDistance;
    float           m_objectDetail;
    float           m_lastObjectDetail;
    float           m_terrainVision;
    float           m_gadgetQuantity;
    int             m_textureQuality;
    bool            m_totoMode;
    bool            m_lensMode;
    bool            m_waterMode;
    bool            m_skyMode;
    bool            m_backForce;
    bool            m_planetMode;
    bool            m_lightMode;
    bool            m_editIndentMode;
    int             m_editIndentValue;
    float           m_tracePrecision;

    int             m_hiliteRank[100];
    bool            m_hilite;
    Math::Point     m_hiliteP1;
    Math::Point     m_hiliteP2;

    int             m_lastState;
    Gfx::Color      m_lastColor;
    char            m_lastTexture[2][50];
    Gfx::Material   m_lastMaterial;

    Math::Point     m_mousePos;
    Gfx::MouseType  m_mouseType;
    bool            m_mouseHide;
    bool            m_niceMouse;

    //LPDIRECTDRAWSURFACE7 m_imageSurface;
    //DDSURFACEDESC2        m_imageDDSD;
    //WORD*             m_imageCopy;
    //int                   m_imageDX;
    //int                   m_imageDY;
};

}; // namespace Gfx