controlEngine.cpp

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

#include "controlEngine.h"
#include "object3d_instance.h"
#include "systray.h"
#include <math.h>
#include "jitter.h"

extern ControlEngine ce;

ControlEngine::ControlEngine()
{
        MyRegistry reg(FALSE);
        reg="HKCU\\Software\\3d controls";
        if (reg.TestKey())
        {
                MyString version;
                reg.GetValue("version",version,"?");
                if (version!=VERSION) 
                {
                        MyString text,caption;
                        caption<<"3D Controls v"<<VERSION;
                        text<<"Your 3D Engine version is different of the last running version launched (v"<<version<<")\nWhould you want to use default configuration ?";
                        if (MessageBox(NULL,text,caption,MB_YESNO|MB_ICONINFORMATION)==IDYES)
                        {
                                reg.DeleteKey();
                        }
                }
        }
        reg="\\light";
        reg.GetValue("move0",&lightsMove[0],DEFAULT_LIGHT_MOVE0);
        reg.GetValue("move1",&lightsMove[1],DEFAULT_LIGHT_MOVE1);
        reg.GetValue("move2",&lightsMove[2],DEFAULT_LIGHT_MOVE2);
        reg.GetValue("enable0",&lights[0].isEnable,DEFAULT_LIGHT_ENABLE0);
        reg.GetValue("enable1",&lights[1].isEnable,DEFAULT_LIGHT_ENABLE1);
        reg.GetValue("enable2",&lights[2].isEnable,DEFAULT_LIGHT_ENABLE2);

        reg="..\\fog";
        reg.GetValue("enable",&fog.isEnable,DEFAULT_FOG_ENABLE);
        reg.GetValue("start",&fog.start,DEFAULT_FOG_START);
        reg.GetValue("end",&fog.end,DEFAULT_FOG_END);
        reg.GetValue("density",&fog.density,DEFAULT_FOG_DENSITY);
        reg.GetValue("mode",(int *)&fog.mode,DEFAULT_FOG_MODE);

        reg="..";
        reg.GetValue("enableAntiAliasing",&enableAntiAliasing,DEFAULT_ANTIALIASING);
        reg.GetValue("antiAliasingQuality",&antiAliasingQuality,DEFAULT_ANTIALIASING_QUALITY);
        reg.GetValue("enableRepere",&enableRepere,DEFAULT_VIEW_REPERE);
        reg.GetValue("enableLightView",&enableLightView,DEFAULT_VIEW_LIGHT);
        reg.GetValue("enablePicking",&enablePicking,DEFAULT_PICKING);
        reg.GetValue("enableDelta",&enableDelta,DEFAULT_DELTA);
        reg.GetValue("enableBackGround",&enableBackGround,DEFAULT_VIEW_BACKGROUND);
        reg.GetValue("enableFPS",&enableFPS,DEFAULT_VIEW_FPS);
        reg.GetValue("enableInertia",&enableInertia,DEFAULT_INERTIA);
        reg.GetValue("enableMonitor",&monitor.enable,DEFAULT_MONITOR);
        reg.GetValue("enableViewInertia",&enableViewInertia,DEFAULT_VIEW_INERTIA);

        reg.GetValue("enableFullScreen",&screenMain.enableFullScreen,DEFAULT_FULLSCREEN);
        reg.GetValue("enableTitle",&screenMain.enableTitle,DEFAULT_TITLED);
        reg.GetValue("enableRegion",&screenMain.region.enable,DEFAULT_VIEW_REGION);

        reg.GetValue("polygonModeFront",(int *)&polygonMode.front,DEFAULT_POLYGON_FRONT);
        reg.GetValue("polygonModeBack",(int *)&polygonMode.back,DEFAULT_POLYGON_BACK);

        int dx,dy;
        reg.GetValue("dxWin",&dx,DEFAULT_XSIZE);
        reg.GetValue("dyWin",&dy,DEFAULT_YSIZE);
        dxWin=dx;
        dyWin=dy;

        reg.GetValue("timerRefresh",&refreshTime,DEFAULT_TIMER_REFRESH);
        reg.GetValue("cpuLimit",&cpuLimit,DEFAULT_CPU_LIMIT);

        depth = 15; // distance de l'observateur

        hInst = NULL;

        aspect = 0;
        enableCursor = FALSE;
        usingInertia = 0;
        for (int i=0;i<3;i++) eventInertia[i].Init(i);

        tipFPS = 0;
        InitFont();
        fog.color.Set(0.22f,0.43f,0.64f,1);

        // init de l'infine qui contien un univers
        masterContainer = new MasterContainer;
        masterContainer->Create();

        Push(masterContainer);
                Face trashFace;
                trashFace.name="Trash";
                trash.Add(trashFace);
                // univers et taskWindow doivent etre delcarer en dynamique car sinon les contructeur sont appeler avant que tout soit initialisé
                // ex.: TaskWindow() ==> Window()==> Title() mais la fonte n'est pas encors disponible

                univers = new Univers; 
                univers->Create();

                taskWindow = new TaskWindow;
                taskWindow->Create();
        Pop();
        InitMonitor();
}

ControlEngine::~ControlEngine()
{
        MyRegistry reg(TRUE);
        reg="HKCU\\Software\\3d controls";
        reg="\\light";
        reg.SetValue("move0",lightsMove[0]);
        reg.SetValue("move1",lightsMove[1]);
        reg.SetValue("move2",lightsMove[2]);
        reg.SetValue("enable0",lights[0].isEnable);
        reg.SetValue("enable1",lights[1].isEnable);
        reg.SetValue("enable2",lights[2].isEnable);

        reg="..\\fog";
        reg.SetValue("enable",fog.isEnable);
        reg.SetValue("start",fog.start);
        reg.SetValue("end",fog.end);
        reg.SetValue("density",fog.density);
        reg.SetValue("mode",fog.mode);

        reg="..";
        reg.SetValue("version",VERSION);
        reg.SetValue("enableAntiAliasing",enableAntiAliasing);
        reg.SetValue("antiAliasingQuality",antiAliasingQuality);
        reg.SetValue("enableRepere",enableRepere);
        reg.SetValue("enableLightView",enableLightView);
        reg.SetValue("enablePicking",enablePicking);
        reg.SetValue("enableDelta",enableDelta);
        reg.SetValue("enableBackGround",enableBackGround);
        reg.SetValue("enableFPS",enableFPS);
        reg.SetValue("enableInertia",enableInertia);
        reg.SetValue("enableMonitor",monitor.enable);
        reg.SetValue("enableViewInertia",enableViewInertia);

        reg.SetValue("enableFullScreen",screenMain.enableFullScreen);
        reg.SetValue("enableTitle",screenMain.enableTitle);
        reg.SetValue("enableRegion",screenMain.region.enable);

        reg.SetValue("polygonModeFront",(int)polygonMode.front);
        reg.SetValue("polygonModeBack",(int)polygonMode.back);

        reg.SetValue("dxWin",screenMain.dxNormal);
        reg.SetValue("dyWin",screenMain.dyNormal);

        reg.SetValue("timerRefresh",refreshTime);
        reg.SetValue("cpuLimit",cpuLimit);

        EndFont();
        Stop();
        delete taskWindow;
        delete univers;

}

#include <freetype/freetype.h>
/* Memory state Var needed often*/
static FT_Library FTlib = NULL;
static int init_done = 0;
static int maxTextSize = 0;
static GLuint activeTextureID = 0;

/*
Freetype library Handling
\TODO essais correction bug de la FTGL v2.0.9
*/
int FTLibraryInit ()
{
        int err;

        if (!maxTextSize) glGetIntegerv (GL_MAX_TEXTURE_SIZE, (GLint*) &maxTextSize);
        if (!maxTextSize) //maxTextSize = 256;
        {
                glGetIntegerv( GL_MAX_TEXTURE_SIZE, (GLint*)&maxTextSize);
                if (maxTextSize > 512) maxTextSize = 512;
        }

        if (FTlib != 0 ) return TRUE;
        err = FT_Init_FreeType( &FTlib);
        if (err)
        {
                FTlib = 0;
                return FALSE;
        }
        return TRUE;
}

void FTLibraryFree ()
{
        if (init_done)
        {
                FT_Done_FreeType (FTlib);
                FTlib= 0;
        }
}

BOOL ControlEngine::InitFont()
{
        fontTexture = new FTGLTextureFont(FONT_FILE);
        fontExtrude = new FTGLExtrdFont(FONT_FILE);
        fontPixmap = new FTGLPixmapFont(FONT_FILE);
        fontOutline = new FTGLOutlineFont(FONT_FILE);
        fontPolygon = new FTGLPolygonFont(FONT_FILE);
        fontBitmap = new FTGLBitmapFont(FONT_FILE);

        if (!fontPolygon->FaceSize(16)) return FALSE; // taille max 10
        if (!fontBitmap->FaceSize(16)) return FALSE;
        if (!fontOutline->FaceSize(16)) return FALSE;
        if (!fontTexture->FaceSize(16)) return FALSE;
        if (!fontExtrude->FaceSize(16)) return FALSE;
        if (!fontPixmap->FaceSize(16)) return FALSE;

        fontPolygon->CharMap(ft_encoding_unicode);
        fontBitmap->CharMap(ft_encoding_unicode);
        fontOutline->CharMap(ft_encoding_unicode);
        fontTexture->CharMap(ft_encoding_unicode);
        fontExtrude->CharMap(ft_encoding_unicode);
        fontPixmap->CharMap(ft_encoding_unicode);

        return TRUE;
}

void ControlEngine::EndFont()
{
        if (fontPolygon)        delete fontPolygon;
        if (fontBitmap)         delete fontBitmap;
        if (fontExtrude)        delete fontExtrude;
        if (fontTexture)        delete fontTexture;
        if (fontPixmap)         delete fontPixmap;
        if (fontOutline)        delete fontOutline;
}


void ControlEngine::InitMonitor()
{
        monitor.fileName="tools/perfMon.txt";
        monitor.Begin("freeTime",TRUE);
}

void ControlEngine::Start(HINSTANCE hInstance)
{
        // pour les dialogs
        LoadLibrary("riched32.dll");
        InitCommonControls(); // ajouter "comctl32.lib" dans les settings

        hInst = hInstance;
        lights[0].id = GL_LIGHT0;
        lights[1].id = GL_LIGHT1;
        lights[2].id = GL_LIGHT2;
        lights[3].id = GL_LIGHT3;

        // class de la fenetre de base
        WNDCLASS wc ;
        memset (&wc, 0, sizeof(wc)) ;
        wc.style = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
        wc.hInstance = hInst;
        wc.hbrBackground = NULL;//si valeur: "(HBRUSH) (COLOR_BTNFACE + 1);" il faut gerer le WM_ERASEBKGND// 

        // config du systray
        wc.hCursor = LoadCursor (NULL, IDC_ARROW);
        wc.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_ICON_SYSTRAY));
        wc.lpfnWndProc = SysTrayProc;
        screenSystray.Setup(&wc,"Systray","3D Controls - Systray");
        screenSystray.Create(hInst);

        // creation de la class fenetre
        wc.hCursor = LoadCursor (NULL, IDC_ARROW);
        wc.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_DCONTROLS));
        wc.lpfnWndProc = ControlEngineProc;
        screenMain.Setup(&wc,"Render","3D Controls - Render");
        screenMain.SetStyle(WS_OVERLAPPEDWINDOW);
        screenMain.SetSize((int)dxWin,(int)dyWin,TRUE);
        screenMain.Create(hInst);
        screenMain.BindOpenGL(TRUE);//enableAntiAliasing);
        Object3D::hDC=screenMain.hDC;
        InitTextures();
        InitLights();
        ShowCursor(FALSE);
        screenMain.Show(TRUE); // pour que la fenetre soit active il faut la créer en dernier (la derniere est activé !)
        Setup((int)dxWin,(int)dyWin);
        // init de timer
        Timer::Init(screenMain.hWnd);
        SetTimerRefresh(refreshTime);

        // init de Inertia
        Control::inertia.Start();
        cursor.Create();

}

void ControlEngine::Stop()
{
        PostQuitMessage(0);
        screenMain.Destroy();
        screenSystray.Destroy();
}

void ControlEngine::Loop()
{               
        MSG msg;
        while (GetMessage(&msg, NULL, 0, 0)) 
        {
                TranslateMessage(&msg);
                DispatchMessage(&msg);
        }
}

void ControlEngine::InitViewPort(int deltaX,int deltaY)
{
        glViewport(0, 0, deltaX,deltaY);  
        glGetIntegerv(GL_VIEWPORT,viewPort);                    

        glMatrixMode(GL_PROJECTION);
        aspect = (GLdouble)deltaX/(GLdouble)deltaY;
        glLoadIdentity();
        SetPerspective(0,0);
}

void ControlEngine::Setup(int deltaX, int deltaY)
{
        InitViewPort(deltaX,deltaY);
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();                    // Reset (init) the modelview matrix
        gluLookAt(0,0,depth,0,0,0,0,1,0);

        polygonMode.Use();                                       // type de calcul polygonal
        glShadeModel(GL_SMOOTH);             // Enable smooth shading

        //glEnable(GL_CULL_FACE);                       // n'affiche que les face avant
        //glColorMaterial(GL_FRONT, GL_DIFFUSE);
        //glEnable(GL_COLOR_MATERIAL);

        glClearDepth(1);                                         // Clear depth buffer
        glEnable(GL_DEPTH_TEST);             // Enables depth test
        glDepthFunc(GL_LEQUAL);                      // Type of depth test to perform

        glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Enhances image quality   

        fog.Use();

        glClearColor(0.22f,0.43f,0.64f,0);      // Set background to blue
        glClearAccum(0.0, 0.0, 0.0, 0.0);               // tempon d'accumulation a 0

        glEnable(GL_LINE_SMOOTH);
        glEnable(GL_POLYGON_SMOOTH);
        glEnable(GL_POINT_SMOOTH);

        // pour se simplifier la vie au niveau des calcul des normal, (au detriment des performance par contre)
        glEnable(GL_NORMALIZE);
        glEnable(GL_AUTO_NORMAL); 
}

void ControlEngine::Refresh(BOOL setSize)
{
        Setup((int)dxWin,(int)dyWin);
        if (setSize) screenMain.SetSize((int)dxWin,(int)dyWin,FALSE);
        screenMain.Update(FALSE);
        screenMain.Show(TRUE);
}

void ControlEngine::SetTimerRefresh(int value)
{
        BindTimer(timerRefresh,OnRefresh,value); 
}

void ControlEngine::DrawCursors()
{
        if (!enableCursor) return;
        enableCursor = FALSE; // le message WM_SETCURSOR re-active l'affichage

        glGetDoublev (GL_PROJECTION_MATRIX,projMatrix);
        glGetDoublev (GL_MODELVIEW_MATRIX,modelMatrix);

        Color color;
        if (usingInertia) 
        {
                color.Set(0,0,1);
                DrawCursor(pickingInertia.mouse.pos,color,FALSE);
        }
        color.SetFull();
        DrawCursor(pickingCursor.mouse.pos,color,TRUE);
}

void ControlEngine::DrawCursor(Point2D<int> mousePos,Color color,BOOL isDrawInertia)
{
        Point2D<int> hotSpot;
        hotSpot = cursor.GetHotSpot(cursor.curType); 
        cursor.Rotate(univers->faceNode->elem->angle);  
        cursor.Draw(mousePos.x+hotSpot.x,mousePos.y+hotSpot.y);
}

void ControlEngine::Draw2DText(int xCenter,int yCenter,int x,int y,char *text,Color *color)
{
        Color colorFull;
        if (!color) 
        {
                color=&colorFull;
                color->SetFull();
        }
        Material material;
        material.emission=*color;
        material.Use();

        Point3D<GLdouble> pos;
        switch (xCenter)
        {
        case -1: break;
        case 0: x+=deltaXwin/2; break;
        case 1: x+=deltaXwin; break;
        }
        switch (yCenter)
        {
        case -1: y=deltaYwin-y; break;
        case 0: y=deltaYwin/2-y; break;
        case 1: break;
        }

        if (gluUnProject(x,y,0,modelMatrix,projMatrix,viewPort,&pos.x,&pos.y,&pos.z)==GL_TRUE)
        {
                glPushMatrix();
                pos.glTranslated();
                glScalef(0.001f,0.001f,1); // valeur empirique
                fontTexture->Render(text);
                glPopMatrix();
        }
}

BOOL ControlEngine::DrawOrigineRepere()
{
        if (!enableRepere) return FALSE;
        Object3D::DrawRepere();
        return TRUE;
}

BOOL ControlEngine::DrawFPS()
{       
        if (!enableFPS) 
        {
                if (tipFPS) 
                {
                        delete tipFPS;
                        tipFPS=NULL;
                }
                return FALSE;
        }
        if (!tipFPS)
        {
                tipFPS = new Tip;
                ce.Push(ce.masterContainer);
                        tipFPS->Create();
                        tipFPS->XDockLeft(2,80);
                        tipFPS->YDockTop(2,20);
                ce.Pop();
        }
        static MyString fps;
        fps.Format("%.1f fps",GiveFPS());
        tipFPS->SetText(fps);
/*
        Draw2DText(-1,-1,0,24,fps);
        Draw2DText(0,-1,0,24,"haut center ");
        Draw2DText(1,-1,-100,24,"haut droit");
        Draw2DText(-1,0,0,0,"centré gauche");
        Draw2DText(0,0,0,0,"centré centré");
        Draw2DText(1,0,-100,0,"centré droit");
        Draw2DText(-1,1,0,0,"bas gauche");
        Draw2DText(0,1,0,0,"bas centré");
        Draw2DText(1,1,-100,0,"bas droit");
*/
        return TRUE;
}

float ControlEngine::GiveFPS()
{
#define SIZE_LIST 25     // nb d'element a prendre en compt
#define TIME_TO_VIEW 250 // temp de changement de valeur min

        static MyStack<int> lstTime;
        static DWORD oldTick=0;
        static int sumTime=0;
        static DWORD lastViewTime=0;
        static float lastViewValue=0;

        DWORD tick = GetTickCount();
        if (!oldTick) { lastViewTime = oldTick = tick; return 0; }
        int delta = tick-oldTick;

        oldTick = tick;
        sumTime+=delta;
        lstTime.Push(delta);

        if (lstTime.GetNbElem()>SIZE_LIST)
        {
                sumTime-=lstTime.FrontPop();
                if ((tick-lastViewTime)> TIME_TO_VIEW) 
                {
                        lastViewValue = (SIZE_LIST*1000)/(float)sumTime;
                        lastViewTime=tick;
                }
                return lastViewValue;
        }
        else return 0;
}

void ControlEngine::ApplyScaleView()
{
        GLdouble scaling=12.4/dyWin;
        glScaled(scaling,scaling,scaling);
}

void ControlEngine::SetPerspective(float xJitter,float yJitter)
{
        //glOrtho(-dxWin/2,dxWin/2-1,-dyWin/2,dyWin/2-1,-100,100);
        double angle=45;
        if (!xJitter&&!yJitter) gluPerspective(angle, aspect, 0.01, 1000);
        else accPerspective(angle,aspect , 0.01, 1000, xJitter , yJitter, 0.0, 0.0, 1.0);
}

BOOL ControlEngine::ProjectWindowToObject(Point3D<GLdouble> &windowPos,Point3D<GLdouble> *objectPos)
{
        return gluUnProject(windowPos.x,deltaYwin-windowPos.y,windowPos.z,modelMatrix,projMatrix,viewPort,&objectPos->x,&objectPos->y,&objectPos->z)==GL_TRUE?TRUE:FALSE;
}

BOOL ControlEngine::ProjectWindowToObject(GLdouble windowPosX,GLdouble windowPosY,GLdouble windowPosZ,GLdouble *objectPosX,GLdouble *objectPosY,GLdouble *objectPosZ)
{
        GLdouble _objectPosX,_objectPosY,_objectPosZ;
        if (!objectPosX) objectPosX=&_objectPosX;
        if (!objectPosY) objectPosY=&_objectPosY;
        if (!objectPosZ) objectPosZ=&_objectPosZ;
        return gluUnProject(windowPosX,deltaYwin-windowPosY,windowPosZ,modelMatrix,projMatrix,viewPort,objectPosX,objectPosY,objectPosZ)==GL_TRUE?TRUE:FALSE;
}

BOOL ControlEngine::ProjectObjectToWindow(Point3D<GLdouble> &objectPos,Point3D<GLdouble> *windowPos)
{
        int result = gluProject(objectPos.x,objectPos.y,objectPos.z,modelMatrix,projMatrix,viewPort,&windowPos->x,&windowPos->y,&windowPos->z);
        windowPos->y=deltaYwin-windowPos->y;
        return result==GL_TRUE?TRUE:FALSE;
}

BOOL ControlEngine::ProjectObjectToWindow(GLdouble objectPosX,GLdouble objectPosY,GLdouble objectPosZ,GLdouble *windowPosX,GLdouble *windowPosY,GLdouble *windowPosZ)
{
        GLdouble _windowPosX,_windowPosY,_windowPosZ;
        if (!windowPosX) windowPosX=&_windowPosX;
        if (!windowPosY) windowPosY=&_windowPosY;
        if (!windowPosZ) windowPosZ=&_windowPosZ;
        int result = gluProject(objectPosX,objectPosY,objectPosZ,modelMatrix,projMatrix,viewPort,windowPosX,windowPosY,windowPosZ);
        *windowPosY=deltaYwin-*windowPosY;
        return result==GL_TRUE?TRUE:FALSE;
}

void ControlEngine::InitLights()
{
        Light::SetLighting(TRUE);
        glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,GL_TRUE); // sinon les face arriere ne sont pas affiché

        lights[0].material.SetDS(1,0,0);
        lights[0].position.Set(-0,0,10,TRUE);
        lights[0].cutoff = 20;
        lights[0].exponent = 50;

        BOOL isEnable;
        isEnable=lights[1].isEnable;
        lights[1]=lights[0];
        lights[1].isEnable=isEnable;
        lights[1].material.SetDS(0,1,0);

        isEnable=lights[2].isEnable;
        lights[2]=lights[1];
        lights[2].isEnable=isEnable;
        lights[2].material.SetDS(1,1,1);
        lights[2].attenuationCst.Set(4);

        lights[3].isEnable=TRUE;
        lights[3].material.SetDS(.5,.5,.5);
        lights[3].material.ambient.Set(.5,.5,.5);
        lights[3].position.Set(0,0,(GLfloat)depth,FALSE);

        MajLights();
}

void ControlEngine::InitTextures()
{
        texture.min.FromFile("min","texture/control/button minus.bmp");
        texture.max.FromFile("max","texture/control/button max.bmp");
        texture.maxAlternate.FromFile("alternate","texture/control/button max alternate.bmp");

        texture.rotateFace.FromFile("rotated face","texture/control/button rotate face.bmp");
        texture.close.FromFile("close","texture/control/button close.bmp");
        texture.iconBase.FromFile("baseIcon","texture/control/base icon.bmp");
        texture.tropique.FromFile("tropique","texture/other/virus.jpg");
        texture.arrow.FromFile("arrow","texture/control/arrow left.png");
        texture.arrowOblique.FromFile("arrow oblique","texture/control/arrow top left.png");
        texture.plus.FromFile("plus","texture/control/plus.png");
        texture.minus.FromFile("minus","texture/control/minus.png");
        texture.grip.FromFile("grip","texture/control/grip.bmp");

        texture.degradeeFocus.Begin("degradeeOn",2,2);
        texture.degradeeFocus.SetPixel(0,0,10,36,106);
        texture.degradeeFocus.SetPixel(1,0,166,202,240);
        texture.degradeeFocus.SetPixel(0,1,10,36,106);
        texture.degradeeFocus.SetPixel(1,1,10,36,106);
        texture.degradeeFocus.End();

        texture.degradeeUnFocus.Begin("degradeeOff",2,2);
        texture.degradeeUnFocus.SetPixel(0,0,128,128,128);
        texture.degradeeUnFocus.SetPixel(1,0,192,192,192);
        texture.degradeeUnFocus.SetPixel(0,1,128,128,128);
        texture.degradeeUnFocus.SetPixel(1,1,128,128,128);
        texture.degradeeUnFocus.End();

        texture.cursorArrow.FromFile("cursorArrow","texture/cursor/arrow.png");
        texture.cursorWait.FromFile("cursorWait","texture/cursor/wait.png");
        texture.cursorText.FromFile("cursorArrow","texture/cursor/text.png");
        texture.cursorMoving.FromFile("cursorWait","texture/cursor/moving.png");
        texture.cursorPush.FromFile("cursorPush","texture/cursor/push.png");

        texture.background.FromFile("background","texture/background/venus.png");

        //fonte.CreateFromBitmap("Arial","fonte/arial.bmp");
}

void ControlEngine::MajLights()
{
        for (int i=0;i<4;i++) lights[i].Use();

        boxLights[0].material.emission = lights[0].material.specular;
        boxLights[0].delta.Set(1,1,1);
        boxLights[0].coor.z = 10;

        boxLights[1]=boxLights[0];
        boxLights[1].material.emission = lights[1].material.specular;

        boxLights[2]=boxLights[0];
        boxLights[2].material.emission = lights[2].material.specular;
}

void ControlEngine::Draw()
{       
        monitor.Reset("text");
        monitor.Reset("testPicking");
        monitor.End("freeTime");
        monitor.Begin("frame",TRUE); 
        monitor.Begin("initScene",TRUE); 
        monitor.Reset("textRender");
        monitor.Reset("textRenderCenter");
        monitor.Reset("textAlign");

        //primitive.ReOrderForBlending();

        // gestion de l'antialiasing
        int jitterNum = antiAliasingQuality;
        BOOL isFirst = TRUE;
        if (!enableAntiAliasing) jitterNum=0;
        Jitter *jitter = &jitters[jitterNum];
        int jitterIndice;
        Recorder record;
        for (jitterIndice = 0; jitterIndice < jitter->nb ; jitterIndice++) 
        {
                if (enableAntiAliasing) glEnable(GL_MULTISAMPLE_ARB);
                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
                if (enableAntiAliasing) SetPerspective(jitter->tab[jitterIndice].x,jitter->tab[jitterIndice].y);
                glMatrixMode(GL_MODELVIEW);
                glLoadIdentity();
                gluLookAt(0,0,depth,0,0,0,0,1,0);

                DrawLight();
                DrawBackGround();

                // sauvegarde des projections
                glGetDoublev (GL_PROJECTION_MATRIX,projMatrix);
                glGetDoublev (GL_MODELVIEW_MATRIX,modelMatrix);

                //affichage
                DrawOrigineRepere();
                ApplyScaleView();

                monitor.End("initScene"); 
                monitor.Begin("draw",TRUE);

                if (enableAntiAliasing) 
                {
                        if (isFirst) 
                        {                               
                                record.BeginRecord(TRUE);
                                DrawScene(FALSE); 
                                DrawCursors();
                                record.EndRecord();
                                glAccum(GL_LOAD,1.0f/(float)jitter->nb); //pour eviter de faire un glClear(GL_ACCUM_BUFFER_BIT); au debut
                                isFirst=FALSE;
                        }
                        else 
                        {
                                record.Play();
                                glAccum(GL_ACCUM, 1.0f/(float)jitter->nb);
                        }
                }
                else 
                {
                        DrawScene(FALSE);
                        DrawCursors();
                }
        }
        if (enableAntiAliasing) glAccum (GL_RETURN, 1.0f);

        monitor.End("draw");
        monitor.Begin("picking",TRUE);
        monitor.Begin("drawPicking",TRUE);
        if (enablePicking) 
        {
                pickingCursor.Test();
                if (usingInertia) pickingInertia.Test();
        }
        DrawFPS();

        monitor.End("picking");
        monitor.End("frame"); 
        monitor.AddRecord();
        monitor.Begin("freeTime",TRUE);
}

BOOL ControlEngine::DrawBackGround()
{
        if (!enableBackGround) return FALSE;

        glPushMatrix();
        univers->faceNode->elem->angle.glRotated();

        /*Face fond;
        fond.material.SetDS(.5,.5,.5);
        fond.name = 7;
        fond.Draw(FALSE);*/

        glDisable(GL_BLEND);
        glDisable(GL_TEXTURE_2D);

        Material material;
        material.SetNull();

        GLUquadric *newQuadric = gluNewQuadric();
        gluQuadricNormals(newQuadric,GLU_NONE); // sinon influ de maniere misterieuse les autre normales
        material.emission.Set(1,1,1);
        material.Use();
        glEnable(GL_TEXTURE_2D);
        //glDisable(GL_DEPTH_TEST);
        glBindTexture(GL_TEXTURE_2D,texture.background.id);
        gluQuadricOrientation(newQuadric, GLU_INSIDE);
        gluQuadricTexture(newQuadric,TRUE);
        gluQuadricDrawStyle(newQuadric, GLU_FILL);

        // immage correct de 24 a 900
        gluSphere(newQuadric,univers->faceNode->elem->computePosition.z*0.1+200,50,50);
        gluDeleteQuadric(newQuadric);
        glDisable(GL_TEXTURE_2D);
        material.emission.SetNull();
        material.Use();
        glPopMatrix();
        //glEnable(GL_DEPTH_TEST); // si gestion exterieur
        //glClear(GL_DEPTH_BUFFER_BIT);
        return FALSE;
}

void ControlEngine::DrawScene(BOOL isPicking)
{
        //glCallList(1);
        primitive.Draw(isPicking);
}

void ControlEngine::DrawLight()
{
        static float count =0;
        count+=0.04f;

        // affiche une lumiere
        if (lights[0].IsEnabled())
        {
                if (lightsMove[0])
                {
                        lights[0].position.x=0;
                        lights[0].position.y=cos(count)*10.0f;
                        lights[0].position.z=sin(count)*10.0f;
                        lights[0].direction.Set(-lights[0].position.x,-lights[0].position.y,-lights[0].position.z);
                }               
                if (enableLightView) 
                {
                        boxLights[0].coor = lights[0].position;
                        boxLights[0].CenterIt();
                        boxLights[0].Draw();
                }               
        }

        if (lights[1].IsEnabled())
        {
                if (lightsMove[1])
                {
                        lights[1].position.x=sin(count)*10.0f;
                        lights[1].position.y=0;
                        lights[1].position.z=cos(count)*10.0f;
                        lights[1].direction.Set(-lights[1].position.x,-lights[1].position.y,-lights[1].position.z);
                }
                if (enableLightView) 
                {
                        boxLights[1].coor = lights[1].position;
                        boxLights[1].CenterIt();
                        boxLights[1].Draw();
                }
        }

        if (lights[2].IsEnabled())
        {
                if (lightsMove[2]) 
                {
                        lights[2].position.x=sin(count)*10.0f;
                        lights[2].position.y=cos(count)*10.0f;
                        lights[2].position.z=(GLfloat)depth;
                        lights[2].direction.Set(0,0,-1); // direction paralelle
                }
                else
                {
                        lights[2].position.x=10.0f*(-1+2.0f*((float)pickingCursor.mouse.pos.x/(float)deltaXwin));
                        lights[2].position.y=10.0f*(1-2.0f*((float)pickingCursor.mouse.pos.y/(float)deltaYwin));
                        lights[2].position.z=(GLfloat)depth;
                }
                if (enableLightView) 
                {
                        boxLights[2].coor = lights[2].position;
                        boxLights[2].CenterIt();
                        boxLights[2].Draw();
                }
        }
        MajLights();
}

double ControlEngine::ComputeRealZ(double logicZ)
{
        double y10=438.5964912;
        double y100=5434.782609;
        double alpha = (y100-y10)/90.0; // empirique je sais mais ca marche!
        double cst = y100-100.0*alpha;
        double zLineaire = 1.0/(2.0-logicZ);
        double realZdist =(zLineaire-cst)/alpha;
        double zDist = realZdist*0.001015;              // ratio en pleine ecrant
        return zDist;
}

int ControlEngine::OnRefresh(Timer *timer)
{
        /* fonctionne mais n'est pas optimisé, le mieux est de faire cela apres le swaping
        region.Reset(deltaXwin,deltaYwin);
        Draw(); 
        region.Use(hWnd);
        */
        InvalidateRect(screenMain.hWnd,NULL,FALSE); 
        return 0;
}

LRESULT CALLBACK ControlEngineProc(HWND hDlg,UINT message,WPARAM wParam,LPARAM lParam)
{   
        return ce.Proc(hDlg,message,wParam,lParam);
}

LRESULT CALLBACK ScreenShotProc(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam)
{
        switch (message)
        {
                case WM_CREATE:
                        return TRUE;

                case WM_PAINT:
                        PAINTSTRUCT ps;
                        BeginPaint(hWnd,&ps);
                        EndPaint(hWnd,&ps); 
                        return TRUE;
        }
        return DefWindowProc(hWnd,message,wParam,lParam);
}

void ControlEngine::ScreenShot(TypeScreenShot type)
{
        static BOOL isFirst = TRUE;
        if (isFirst)
        {
                isFirst=FALSE;
                WNDCLASS   wc ;
                memset (&wc, 0, sizeof(wc)) ;
                wc.style                        = CS_HREDRAW | CS_VREDRAW;
                wc.lpfnWndProc          = ScreenShotProc;
                wc.hInstance            = hInst;
                wc.hIcon                        = LoadIcon(hInst, MAKEINTRESOURCE(IDI_DCONTROLS));
                wc.hCursor                      = LoadCursor (NULL, IDC_ARROW);
                wc.hbrBackground        = NULL;//si valeur: "(HBRUSH) (COLOR_BTNFACE + 1);" il faut gerer le WM_ERASEBKGND// 
                wc.lpszClassName        = TEXT ("ScreenShot");
                if (!RegisterClass(&wc) ) MessageBox (NULL, "ScreenShot - Window","!Failed",MB_OK) ; 
        }

        MyString title("3D Control - ScreenShot - ");
        switch (type)
        {       
                case ssRGB: title<<"RGB"; break;
                case ssDepth: title<<"Depth"; break;
                case ssBlending: title<<"blending"; break;
                case ssLuminance: title<<"luminance"; break;
        }
        HWND hWndScreenShot = CreateWindow("ScreenShot",title,WS_OVERLAPPEDWINDOW,0,0,(int)dxWin,(int)dyWin,NULL,NULL,hInst,NULL);
        MoveWindow(hWndScreenShot,400,0,(int)dxWin,(int)dyWin+28,FALSE);
        ShowWindow (hWndScreenShot,SW_SHOW);

        HDC hDc = GetDC(hWndScreenShot);
        Point3D<GLfloat> pos;
        Color color;
        GLfloat value;
        for (pos.x=0;pos.x<dxWin;pos.x++)
                for (pos.y=0;pos.y<dyWin;pos.y++)
                {
                        switch (type)
                        {
                        case ssLuminance:
                                glReadPixels((GLint)pos.x,(GLint)pos.y,1,1,GL_LUMINANCE,GL_FLOAT,&value);
                                SetPixel(hDc,(int)pos.x,(int)dyWin-(int)pos.y,RGB(value*255,value*255,value*255));
                                break;
                        case ssRGB: 
                                glReadPixels((GLint)pos.x,(GLint)pos.y,1,1,GL_RGBA,GL_FLOAT,&color);
                                SetPixel(hDc,(int)pos.x,(int)dyWin-(int)pos.y,RGB(color.r*255,color.g*255,color.b*255));
                                break;
                        case ssDepth: 
                                glReadPixels((GLint)pos.x,(GLint)pos.y,1,1,GL_DEPTH_COMPONENT,GL_FLOAT,&pos.z);
                                value=(pos.z-0.999f)*1000.0f;
                                SetPixel(hDc,(int)pos.x,(int)dyWin-(int)pos.y,RGB(value*255,value*255,value*255));
                                break;
                        case ssBlending: 
                                glReadPixels((GLint)pos.x,(GLint)pos.y,1,1,GL_ALPHA,GL_FLOAT,&value);
                                SetPixel(hDc,(int)pos.x,(int)dyWin-(int)pos.y,RGB(value*255,value*255,value*255));
                                break;
                        }

                }
}

LRESULT ControlEngine::Proc(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam)
{
        LRESULT result=FALSE;
        //perf_callback->Begin();
        //MyDebug::SendEvent("Engine","Proc(%d,%d,%d,%d)",hWnd,message,wParam,lParam);
        static Timer keyDouble;
        static Control control_LMouseDown,control_RMouseDown,control_MMouseDown;

        switch(message)
        {       
        case WM_SETCURSOR: 
                ShowMouse(FALSE);
                enableCursor=TRUE; 
                result=TRUE;
                break; // message envoyer a achaque calcul d'image si souris dans la scene

        case WM_KILLFOCUS:
                ShowMouse(TRUE);
                result=TRUE;
                break;
                
        case WM_CREATE:
                pickingCursor.controlHover=univers;
                pickingCursor.controlContainer=univers;
                pickingInertia.controlHover=univers; // le picking de inertia doit exister avent les tests
                pickingInertia.controlContainer=univers; // le picking de inertia doit exister avent les tests
                univers->OverIn(univers,-1);
                result=TRUE;
                break;

        case WM_DESTROY:                        // Perform cleanup
                Stop();                                 // Clean up and close OpenGL
                PostQuitMessage(0);             // en CreatenWindows
                result=FALSE;
                break;

        case WM_TIMER:  
                result=Timer::Call((int)wParam);
                break;

        case WM_PAINT:
                PAINTSTRUCT ps;
                BeginPaint(hWnd,&ps);
                EndPaint(hWnd,&ps); // si on ne fait pas le begin / end sans les region, les perf sont netement meilleur
                if (!screenMain.region.enable) SetWindowRgn(hWnd,NULL,FALSE);
                screenMain.SwapBuffers();
                screenMain.RegionReset();
                Draw(); 
                screenMain.RegionUse();
                result=TRUE;
                break;

        case WM_SIZE:
                dxWin = LOWORD(lParam); // dx de la zone client
                dyWin = HIWORD(lParam); // dy de la zone client
                MyDebug::SendEvent("Size","%f, %f",dxWin,dyWin);
                Refresh(TRUE);
                result=FALSE;

        case WM_NCMOUSEMOVE:
                ShowMouse(TRUE);
                enableCursor=FALSE; 
                result=TRUE;
                break;

                // debut de gestion des evenement du control **********************************

        case WM_MOUSEWHEEL:
                pickingCursor.SetDeltaWheel(GET_WHEEL_DELTA_WPARAM(wParam));
                if (!pickingCursor.controlHover->OnMouseWheel(&pickingCursor.mouse,pickingCursor.faceHover))
                        if (pickingCursor.controlHover!=pickingCursor.controlContainer)
                                pickingCursor.controlContainer->OnMouseWheel(&pickingCursor.mouse,pickingCursor.faceContainer);
                result=TRUE;
                break;

        case WM_MOUSEMOVE:
                enableCursor=TRUE; 
                pickingCursor.mouse.leftBtn =   (wParam&MK_LBUTTON)==MK_LBUTTON?TRUE:FALSE;
                pickingCursor.mouse.midBtn =    (wParam&MK_MBUTTON)==MK_MBUTTON?TRUE:FALSE;
                pickingCursor.mouse.rightBtn =  (wParam&MK_RBUTTON)==MK_RBUTTON?TRUE:FALSE;
                pickingCursor.SetMousePos(GET_X_LPARAM(lParam),GET_Y_LPARAM(lParam));
                if (pickingCursor.isMoving) 
                        if (!pickingCursor.controlHover->OnMouseMove(&pickingCursor.mouse,pickingCursor.faceHover))
                                if (pickingCursor.controlHover!=pickingCursor.controlContainer)
                                        pickingCursor.controlContainer->OnMouseMove(&pickingCursor.mouse,pickingCursor.faceContainer);
                result=TRUE;
                break;

        case WM_LBUTTONDBLCLK:
                if (!pickingCursor.controlHover->OnLButtonDouble(&pickingCursor.mouse,pickingCursor.faceHover))
                        if (pickingCursor.controlHover!=pickingCursor.controlContainer)
                                pickingCursor.controlContainer->OnLButtonDouble(&pickingCursor.mouse,pickingCursor.faceContainer);
                result=TRUE;
                break;

        case WM_MBUTTONDBLCLK:
                if (!pickingCursor.controlHover->OnMButtonDouble(&pickingCursor.mouse,pickingCursor.faceHover))
                        if (pickingCursor.controlHover!=pickingCursor.controlContainer)
                                pickingCursor.controlContainer->OnMButtonDouble(&pickingCursor.mouse,pickingCursor.faceContainer);
                result=TRUE;
                break;

        case WM_RBUTTONDBLCLK:
                if (!pickingCursor.controlHover->OnRButtonDouble(&pickingCursor.mouse,pickingCursor.faceHover))
                        if (pickingCursor.controlHover!=pickingCursor.controlContainer)
                                pickingCursor.controlContainer->OnRButtonDouble(&pickingCursor.mouse,pickingCursor.faceContainer);
                result=TRUE;
                break;

        case WM_LBUTTONUP:
                ReleaseCapture(); // ca doit etre ca qui declenche onMouseMove
                pickingCursor.mouse.leftBtn=FALSE;
                if (!pickingCursor.controlHover->OnLButtonUp(&pickingCursor.mouse,pickingCursor.faceHover))
                        if (pickingCursor.controlHover!=pickingCursor.controlContainer)
                                pickingCursor.controlContainer->OnLButtonUp(&pickingCursor.mouse,pickingCursor.faceContainer);
                result=TRUE;
                break;

        case WM_MBUTTONUP:
                pickingCursor.mouse.midBtn=FALSE;
                if (!pickingCursor.controlHover->OnMButtonUp(&pickingCursor.mouse,pickingCursor.faceHover))
                        if (pickingCursor.controlHover!=pickingCursor.controlContainer)
                                pickingCursor.controlContainer->OnMButtonUp(&pickingCursor.mouse,pickingCursor.faceContainer);
                result=TRUE;
                break;

        case WM_RBUTTONUP:
                pickingCursor.mouse.rightBtn=FALSE;
                if (!pickingCursor.controlHover->OnRButtonUp(&pickingCursor.mouse,pickingCursor.faceHover))
                        if (pickingCursor.controlHover!=pickingCursor.controlContainer)
                                pickingCursor.controlContainer->OnRButtonUp(&pickingCursor.mouse,pickingCursor.faceContainer);
                result=TRUE;
                break;

        case WM_LBUTTONDOWN:
                SetCapture(hWnd); // la fenetre openGL n'a paeut etre pas le focus
                pickingCursor.mouse.leftBtn=TRUE;
                if (!pickingCursor.controlHover->OnLButtonDown(&pickingCursor.mouse,pickingCursor.faceHover))
                        if (pickingCursor.controlHover!=pickingCursor.controlContainer)
                                pickingCursor.controlContainer->OnLButtonDown(&pickingCursor.mouse,pickingCursor.faceContainer);
                result=TRUE;
                break;

        case WM_MBUTTONDOWN:
                pickingCursor.mouse.midBtn=TRUE;
                if (!pickingCursor.controlHover->OnMButtonDown(&pickingCursor.mouse,pickingCursor.faceHover))
                        if (pickingCursor.controlHover!=pickingCursor.controlContainer)
                                pickingCursor.controlContainer->OnMButtonDown(&pickingCursor.mouse,pickingCursor.faceContainer);
                result=TRUE;
                break;

        case WM_RBUTTONDOWN:
                pickingCursor.mouse.rightBtn=TRUE;
                if (!pickingCursor.controlHover->OnRButtonDown(&pickingCursor.mouse,pickingCursor.faceHover))
                        if (pickingCursor.controlHover!=pickingCursor.controlContainer)
                                pickingCursor.controlContainer->OnRButtonDown(&pickingCursor.mouse,pickingCursor.faceContainer);
                result=TRUE;
                break;

        case WM_KEYDOWN:
                {
                        short code = (short)wParam;
                        double counter = keyDouble.GetDeltaTime(TRUE);
                        BOOL isSame = code==key.code;
                        key.code= code;
                        key.letter=(char)wParam; // sinon voir l'API: MapVirtualKey
                        key.isPush=TRUE;
                        if (!pickingCursor.controlHover->OnKeyDown(&key,pickingCursor.faceHover))
                                if (pickingCursor.controlHover!=pickingCursor.controlContainer)
                                        pickingCursor.controlContainer->OnKeyDown(&key,pickingCursor.faceContainer);
                        if (isSame && counter<=DEFAULT_DOUBLE_CLICK) 
                        {
                                if (!pickingCursor.controlHover->OnKeyDouble(&key,pickingCursor.faceHover))
                                        if (pickingCursor.controlHover!=pickingCursor.controlContainer)
                                                pickingCursor.controlContainer->OnKeyDouble(&key,pickingCursor.faceContainer);
                        }
                }
                result=FALSE;
                break;

        case WM_KEYUP:
                key.code=(short)wParam;
                key.letter=(char)wParam; // sinon voir l'API: MapVirtualKey
                key.isPush=FALSE;
                if (!pickingCursor.controlHover->OnKeyUp(&key,pickingCursor.faceHover))
                        if (pickingCursor.controlHover!=pickingCursor.controlContainer)
                                pickingCursor.controlContainer->OnKeyUp(&key,pickingCursor.faceContainer);
                result=FALSE;
                break;

        // fin de gestion des evenement du control *********************************

        default: result = DefWindowProc(hWnd,message,wParam,lParam);
        }
        //perf_callback->End();
        return result;
}

BOOL ControlEngine::RegionAdd(double x,double y)
{
        GLdouble modelMatrixCur[16];
        glGetDoublev (GL_MODELVIEW_MATRIX,modelMatrixCur);
        Point2D<double> pos(x,y);
        return screenMain.region.AddElem(pos,modelMatrixCur,projMatrix,viewPort);
}

BOOL ControlEngine::RegionGet(double x,double y,Point3D<double> *pt)
{
        GLdouble modelMatrixCur[16];
        glGetDoublev (GL_MODELVIEW_MATRIX,modelMatrixCur);
        Point2D<double> pos(x,y);
        return screenMain.region.Compute(pos,modelMatrixCur,projMatrix,viewPort,pt);
}

// Gestion de la pile *********************************************************
BOOL ControlEngine::Push(Control *control)
{
        if (!control) return FALSE;
        stack.Push(control);
        primitive.Push();
        primitive.GoTo(control->faceNode);
        return TRUE;
}

Control * ControlEngine::Pop()
{
        if (!stack.GetNbElem()) return NULL;
        Control *control = stack.Pop();
        primitive.Pop();
        return control;
}

Control * ControlEngine::Peek()
{
        if (!stack.GetNbElem()) return NULL;
        return stack.Peek();
}

---