summaryrefslogtreecommitdiffstats
path: root/src/graphics/common/engine.h
diff options
context:
space:
mode:
Diffstat (limited to 'src/graphics/common/engine.h')
-rw-r--r--src/graphics/common/engine.h712
1 files changed, 712 insertions, 0 deletions
diff --git a/src/graphics/common/engine.h b/src/graphics/common/engine.h
new file mode 100644
index 0000000..724ec74
--- /dev/null
+++ b/src/graphics/common/engine.h
@@ -0,0 +1,712 @@
+// * 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 "math/point.h"
+#include "math/vector.h"
+#include "math/matrix.h"
+
+
+namespace Gfx {
+
+/*
+
+TODO
+
+class CApplication;
+class CInstanceManager;
+class CObject;
+class CLight;
+class CText;
+class CParticule;
+class CWater;
+class CCloud;
+class CBlitz;
+class CPlanet;
+class CSound;
+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 RenderState
+{
+ //! Normal opaque materials
+ RSTATE_NORMAL = 0,
+ //! The transparent texture (black = no)
+ RSTATE_TTEXTURE_BLACK = (1<<0),
+ //! The transparent texture (white = no)
+ RSTATE_TTEXTURE_WHITE = (1<<1),
+ //! The transparent diffuse color
+ RSTATE_TDIFFUSE = (1<<2),
+ //! Texture wrap
+ RSTATE_WRAP = (1<<3),
+ //! Texture borders with solid color
+ RSTATE_CLAMP = (1<<4),
+ //! Light texture (ambient max)
+ RSTATE_LIGHT = (1<<5),
+ //! Double black texturing
+ RSTATE_DUAL_BLACK = (1<<6),
+ //! Double white texturing
+ RSTATE_DUAL_WHITE = (1<<7),
+ //! Part 1 (no change in. MOD!)
+ RSTATE_PART1 = (1<<8),
+ //! Part 2
+ RSTATE_PART2 = (1<<9),
+ //! Part 3
+ RSTATE_PART3 = (1<<10),
+ //! Part 4
+ RSTATE_PART4 = (1<<11),
+ //! Double-sided face
+ RSTATE_2FACE = (1<<12),
+ //! Image using alpha channel
+ RSTATE_ALPHA = (1<<13),
+ //! Always use 2nd floor texturing
+ RSTATE_SECOND = (1<<14),
+ //! Causes the fog
+ RSTATE_FOG = (1<<15),
+ //! The transparent color (black = no)
+ RSTATE_TCOLOR_BLACK = (1<<16),
+ //! The transparent color (white = no)
+ 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;
+ Math::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 CGfxEngine
+{
+public:
+ CGfxEngine(CInstanceManager *iMan, CApplication *app);
+ ~CGfxEngine();
+
+ void SetDevice(Gfx::Device *device);
+ Gfx::Device* RetDevice();
+
+ void SetTerrain(Gfx::CTerrain* terrain);
+
+ bool WriteProfile();
+
+ void SetPause(bool bPause);
+ bool RetPause();
+
+ void SetMovieLock(bool bLock);
+ bool RetMovieLock();
+
+ void SetShowStat(bool bShow);
+ bool RetShowStat();
+
+ void SetRenderEnable(bool bEnable);
+
+ int OneTimeSceneInit();
+ int InitDeviceObjects();
+ int DeleteDeviceObjects();
+ int RestoreSurfaces();
+ int Render();
+ int FrameMove(float rTime);
+ void StepSimul(float rTime);
+ int FinalCleanup();
+ void AddStatisticTriangle(int nb);
+ int RetStatisticTriangle();
+ 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 * RetInfoText(int line);
+ //LRESULT MsgProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
+ void FirstExecuteAdapt(bool bFirst);
+ //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 RetFullScreen();
+ bool ChangeDevice(char *device, char *mode, bool bFull);
+
+ Math::Matrix* RetMatView();
+ Math::Matrix* RetMatLeftView();
+ Math::Matrix* RetMatRightView();
+
+ void TimeInit();
+ void TimeEnterGel();
+ void TimeExitGel();
+ float TimeGet();
+
+ int RetRestCreate();
+ int CreateObject();
+ void FlushObject();
+ bool DeleteObject(int objRank);
+ bool SetDrawWorld(int objRank, bool bDraw);
+ bool SetDrawFront(int objRank, bool bDraw);
+ bool AddTriangle(int objRank, Math::VertexTex2* vertex, int nb, const Gfx::Material &mat, int state, char* texName1, char* texName2, float min, float max, bool bGlobalUpdate);
+ bool AddSurface(int objRank, Math::VertexTex2* vertex, int nb, const Gfx::Material &mat, int state, char* texName1, char* texName2, float min, float max, bool bGlobalUpdate);
+ bool AddQuick(int objRank, Gfx::ObjLevel6* buffer, char* texName1, char* texName2, float min, float max, bool bGlobalUpdate);
+ 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 RetTotalTriangles(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::Maping 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::Maping 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 RetObjectType(int objRank);
+ bool SetObjectTransparency(int objRank, float value);
+
+ bool ShadowCreate(int objRank);
+ void ShadowDelete(int objRank);
+ bool SetObjectShadowHide(int objRank, bool bHide);
+ 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 RetObjectShadowRadius(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 RetLimitLOD(int rank, bool bLast=false);
+
+ void SetTerrainVision(float vision);
+
+ void SetGroundSpot(bool bMode);
+ bool RetGroundSpot();
+ void SetShadow(bool bMode);
+ bool RetShadow();
+ void SetDirty(bool bMode);
+ bool RetDirty();
+ void SetFog(bool bMode);
+ bool RetFog();
+ bool RetStateColor();
+
+ void SetSecondTexture(int texNum);
+ int RetSecondTexture();
+
+ void SetRankView(int rank);
+ int RetRankView();
+
+ void SetDrawWorld(bool bDraw);
+ void SetDrawFront(bool bDraw);
+
+ void SetAmbiantColor(const Gfx::Color &color, int rank=0);
+ Gfx::Color RetAmbiantColor(int rank=0);
+
+ void SetWaterAddColor(const Gfx::Color &color);
+ Gfx::Color RetWaterAddColor();
+
+ void SetFogColor(const Gfx::Color &color, int rank=0);
+ Gfx::Color RetFogColor(int rank=0);
+
+ void SetDeepView(float length, int rank=0, bool bRef=false);
+ float RetDeepView(int rank=0);
+
+ void SetFogStart(float start, int rank=0);
+ float RetFogStart(int rank=0);
+
+ void SetBackground(char *name, Gfx::Color up=0, Gfx::Color down=0, Gfx::Color cloudUp=0, Gfx::Color cloudDown=0, bool bFull=false, bool bQuarter=false);
+ void RetBackground(char *name, Gfx::Color &up, Gfx::Color &down, Gfx::Color &cloudUp, Gfx::Color &cloudDown, bool &bFull, bool &bQuarter);
+ void SetFrontsizeName(char *name);
+ void SetOverFront(bool bFront);
+ void SetOverColor(const Gfx::Color &color=0, int mode=RSTATE_TCOLOR_BLACK);
+
+ void SetParticuleDensity(float value);
+ float RetParticuleDensity();
+ float ParticuleAdapt(float factor);
+
+ void SetClippingDistance(float value);
+ float RetClippingDistance();
+
+ void SetObjectDetail(float value);
+ float RetObjectDetail();
+
+ void SetGadgetQuantity(float value);
+ float RetGadgetQuantity();
+
+ void SetTextureQuality(int value);
+ int RetTextureQuality();
+
+ void SetTotoMode(bool bPresent);
+ bool RetTotoMode();
+
+ void SetLensMode(bool bPresent);
+ bool RetLensMode();
+
+ void SetWaterMode(bool bPresent);
+ bool RetWaterMode();
+
+ void SetBlitzMode(bool bPresent);
+ bool RetBlitzMode();
+
+ void SetSkyMode(bool bPresent);
+ bool RetSkyMode();
+
+ void SetBackForce(bool bPresent);
+ bool RetBackForce();
+
+ void SetPlanetMode(bool bPresent);
+ bool RetPlanetMode();
+
+ void SetLightMode(bool bPresent);
+ bool RetLightMode();
+
+ void SetEditIndentMode(bool bAuto);
+ bool RetEditIndentMode();
+
+ void SetEditIndentValue(int value);
+ int RetEditIndentValue();
+
+ void SetSpeed(float speed);
+ float RetSpeed();
+
+ void SetTracePrecision(float factor);
+ float RetTracePrecision();
+
+ void SetFocus(float focus);
+ float RetFocus();
+ Math::Vector RetEyePt();
+ Math::Vector RetLookatPt();
+ float RetEyeDirH();
+ float RetEyeDirV();
+ Math::Point RetDim();
+ void UpdateMatProj();
+
+ void ApplyChange();
+
+ void FlushPressKey();
+ void ResetKey();
+ void SetKey(int keyRank, int option, int key);
+ int RetKey(int keyRank, int option);
+
+ void SetJoystick(bool bEnable);
+ bool RetJoystick();
+
+ void SetDebugMode(bool bMode);
+ bool RetDebugMode();
+ bool RetSetupMode();
+
+ bool IsVisiblePoint(const Math::Vector &pos);
+
+ int DetectObject(Math::Point mouse);
+ void SetState(int state, Gfx::Color color=0xffffffff);
+ 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 RetMousePos();
+ void SetMouseType(Gfx::MouseType type);
+ Gfx::MouseType RetMouseType();
+ void SetMouseHide(bool bHide);
+ bool RetMouseHide();
+ void SetNiceMouse(bool bNice);
+ bool RetNiceMouse();
+ bool RetNiceMouseCap();
+
+ CText* RetText();
+
+ 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 bHSV=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, Math::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::Device* m_device;
+ CText* m_text;
+ CLight* m_light;
+ CParticule* m_particule;
+ CWater* m_water;
+ CCloud* m_cloud;
+ CBlitz* m_blitz;
+ CPlanet* m_planet;
+ CSound* m_sound;
+ CTerrain* m_terrain;
+
+ 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_bPause;
+ bool m_bRender;
+ bool m_bMovieLock;
+
+ POINT m_dim;
+ POINT 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_bUpdateGeometry;
+ char m_infoText[10][200];
+ int m_alphaMode;
+ bool m_bStateColor;
+ bool m_bForceStateColor;
+ bool m_bGroundSpot;
+ bool m_bShadow;
+ bool m_bDirty;
+ bool m_bFog;
+ bool m_bFirstGroundSpot;
+ 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_bBackgroundFull;
+ bool m_bBackgroundQuarter;
+ bool m_bOverFront;
+ Gfx::Color m_overColor;
+ int m_overMode;
+ char m_frontsizeName[50];
+ bool m_bDrawWorld;
+ bool m_bDrawFront;
+ 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_bTotoMode;
+ bool m_bLensMode;
+ bool m_bWaterMode;
+ bool m_bSkyMode;
+ bool m_bBackForce;
+ bool m_bPlanetMode;
+ bool m_bLightMode;
+ bool m_bEditIndentMode;
+ int m_editIndentValue;
+ float m_tracePrecision;
+
+ int m_hiliteRank[100];
+ bool m_bHilite;
+ 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_bMouseHide;
+ bool m_bNiceMouse;
+
+ //LPDIRECTDRAWSURFACE7 m_imageSurface;
+ //DDSURFACEDESC2 m_imageDDSD;
+ //WORD* m_imageCopy;
+ //int m_imageDX;
+ //int m_imageDY;
+};*/
+
+}; // namespace Gfx
generated by cgit v1.2.3-1-g7c22 (git 2.25.1) at 2024-07-06 05:50:23 +0000