controlEngine.h

Go to the documentation of this file.

/* ***********************************************************************************
        Writer:         Sebastien Bloc
        Copyright:      2003-2004
        eMail:          sebastien.bloc@free.fr
        URL:            http://mignonsoft.free.fr

        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 2
        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.
        http://www.gnu.org/copyleft/gpl.html
*********************************************************************************** */

#ifndef INCLUDE_CONTROL_ENGINE_H
#define INCLUDE_CONTROL_ENGINE_H

#include "3d.h"

#include "texture.h"
#include "box.h"
#include "fog.h"
#include "light.h"
#include "region.h"
#include "polygonMode.h"

#include "openGL_tools.h"
#include "windowTools.h"
#include "primitive.h"

#include "control.h"
#include "univers.h"
#include "taskWindow.h"
#include "picking.h"

#include "perfMon.h"
#include "screen.h"

#include "masterContainer.h"
#include "cursor.h"
#include "tip.h"

#include "resource.h"

#define DEFAULT_DOUBLE_CLICK    0.25    // timeout du DblClk pour les touches
#define SEUIL_MIN_INERTIA               5
#define SEUIL_MAX_INERTIA               15

// config par default (sauvé dans la registry)
#define DEFAULT_LIGHT_MOVE0             FALSE
#define DEFAULT_LIGHT_MOVE1             FALSE
#define DEFAULT_LIGHT_MOVE2             FALSE
#define DEFAULT_LIGHT_ENABLE0   FALSE
#define DEFAULT_LIGHT_ENABLE1   FALSE 
#define DEFAULT_LIGHT_ENABLE2   TRUE
#define DEFAULT_FOG_ENABLE              FALSE
#define DEFAULT_FOG_START               4.5f
#define DEFAULT_FOG_END                 6.0f
#define DEFAULT_FOG_DENSITY             0.3f
#define DEFAULT_FOG_MODE                fogLinear
#define DEFAULT_ANTIALIASING    FALSE
#define DEFAULT_ANTIALIASING_QUALITY    4 // 4 points
#define DEFAULT_VIEW_REPERE             FALSE
#define DEFAULT_VIEW_LIGHT              FALSE
#define DEFAULT_PICKING                 TRUE
#define DEFAULT_DELTA                   FALSE
#define DEFAULT_VIEW_BACKGROUND TRUE
#define DEFAULT_VIEW_FPS                FALSE
#define DEFAULT_INERTIA                 FALSE
#define DEFAULT_MONITOR                 FALSE
#define DEFAULT_VIEW_INERTIA    TRUE
#define DEFAULT_FULLSCREEN              TRUE
#define DEFAULT_TITLED                  TRUE
#define DEFAULT_VIEW_REGION             FALSE
#define DEFAULT_POLYGON_BACK    fill
#define DEFAULT_POLYGON_FRONT   fill
#define DEFAULT_XSIZE                   500
#define DEFAULT_YSIZE                   400
#define DEFAULT_TIMER_REFRESH   30
#define DEFAULT_CPU_LIMIT               100

// init de la freetype
int FTLibraryInit ();
void FTLibraryFree ();

typedef enum 
{ 
        ssRGB,ssDepth,ssBlending,ssLuminance
} TypeScreenShot;

LRESULT CALLBACK ControlEngineProc(HWND hDlg,UINT message,WPARAM wParam,LPARAM lParam);

typedef struct
{
        Texture background;
        Texture plus;
        Texture minus;
        Texture min;
        Texture max;
        Texture maxAlternate;
        Texture rotateFace;
        Texture close;
        Texture tropique;
        Texture arrow;
        Texture arrowOblique;
        Texture degradeeFocus;
        Texture degradeeUnFocus;
        Texture iconBase;
        Texture cursorArrow;
        Texture cursorWait;
        Texture cursorText;
        Texture cursorMoving;
        Texture cursorPush;     
        Texture grip;
} Textures ;

class ControlEngine : public has_slots<>
{
private:
        MyStack<Control *> stack;       

public: // variable de class
        PerfMonitor monitor;            
        Primitive primitive;            
        MyTree<Face> trash;                     
        Fog fog;                                        
        Light lights[4];                        
        BOOL enableAntiAliasing;        
        int antiAliasingQuality;        
        BOOL enableCursor ;                     
        BOOL enableRepere;                      
        BOOL enableLightView;           
        BOOL enableFPS;                         
        Tip *tipFPS;                            
        Cursor cursor;                          
        BOOL enableInertia;                     
        BOOL enableViewInertia;         
        PolygonMode polygonMode;        
        Box3D boxLights[3];                     
        GLdouble aspect;                        

        // Handle       
        Screen screenMain;                      
        Screen screenSystray;           
        Screen screenConfig;            
        HINSTANCE hInst;                        
        double dxWin;                           
        double dyWin;                           
        int cpuLimit;                           

        // pour la gestion des region (cf.: CreatePolyPolygonRgn)
        GLdouble projMatrix[16];        
        GLdouble modelMatrix[16];       
        GLint viewPort[4];                      
        int     refreshTime;                    
        #define deltaXwin viewPort[2]
        #define deltaYwin viewPort[3]
        BOOL enablePicking;                     
        BOOL enableDelta;                       
        BOOL enableBackGround;          
        GLdouble depth;                         
        BOOL lightsMove[4];                     
        Timer timerRefresh;                     
        Univers *univers;                       
        TaskWindow *taskWindow;         
        MasterContainer *masterContainer; 
        StateKey key;                           
        Picking pickingCursor;          
        Picking pickingInertia;         
        int usingInertia;                       
        EventInertia eventInertia[3];

        // gestion des fonte
        FTFont *fontPixmap;                     
        FTFont *fontTexture;            
        FTFont *fontExtrude;            
        FTFont *fontOutline;            
        FTFont *fontPolygon;            
        FTFont *fontBitmap;                     

        Textures texture;                       

public:
        ControlEngine();
        ~ControlEngine();
        void Start(HINSTANCE hInstance);
        void Stop();
        void Loop();
        void InitViewPort(int deltaX,int deltaY);
        void Setup(int deltaX, int deltaY);
        void Refresh(BOOL setSize);
        void SetTimerRefresh(int value); // 10 au plus rapide 60 ==> 15Frm/s 30 ==> 30Frm/s 40 ==> 21Frm/s
        int      OnRefresh(Timer *timer);

        BOOL Push(Control *control);
        Control * Pop();
        Control * Peek();

        void InitMonitor();
        BOOL InitFont();
        void InitTextures();
        void InitLights();
        void EndFont();

        void Draw();
        BOOL DrawBackGround();
        void DrawScene(BOOL isPicking);
        void DrawLight();
        void DrawCursors();
        void DrawCursor(Point2D<int> pos,Color color,BOOL isDrawInertia);
        void Draw2DText(int xCenter,int yCenter,int x,int y,char *text,Color *color=NULL); // if !color ==> black
        BOOL DrawOrigineRepere();
        BOOL DrawFPS();

        void MajLights();

        float GiveFPS();

        void SetPerspective(float xJitter,float yJiiter);
        void ApplyScaleView();

        BOOL RegionAdd(double x,double y);
        BOOL RegionGet(double x,double y,Point3D<double> *pt);

        LRESULT Proc(HWND hDlg,UINT message,WPARAM wParam,LPARAM lParam);

        void ScreenShot(TypeScreenShot type);

        double ComputeRealZ(double logicZ);
        BOOL ProjectWindowToObject(Point3D<GLdouble> &windowPos,Point3D<GLdouble> *objectPos);
        BOOL ProjectWindowToObject(GLdouble windowPosX,GLdouble windowPosY,GLdouble windowPosZ,GLdouble *objectPosX,GLdouble *objectPosY,GLdouble *objectPosZ); 
        BOOL ProjectObjectToWindow(Point3D<GLdouble> &objectPos,Point3D<GLdouble> *windowPos);
        BOOL ProjectObjectToWindow(GLdouble objectPosX,GLdouble objectPosY,GLdouble objectPosZ,GLdouble *windowPosX,GLdouble *windowPosY,GLdouble *windowPosZ);
};

#endif

---