picking.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 "3d.h"
#include "control.h"
#include "face.h"
#include "controlEngine.h"
#include "picking.h"
#include "resource.h"

extern ControlEngine ce;

Picking::Picking()
{
        ResetLast();
        ResetCurrent();
        isMoving=FALSE;
        zDist=0;
}

void Picking::ResetLast()
{
        lastFaceHover=-1;
        lastFaceContainer=-1;
        lastControlHover=NULL;
        lastControlContainer=NULL;
}

void Picking::ResetCurrent()
{
        faceHover=-1;
        faceContainer=-1;
        controlHover=NULL;
        controlContainer=NULL;
}

void Picking::UpdateLast()
{
        lastFaceHover=faceHover;
        lastFaceContainer=faceContainer;
        lastControlHover=controlHover;
        lastControlContainer=controlContainer;
}

void Picking::operator=(Picking &src)
{
        mouse=src.mouse;
        oldMouse=src.oldMouse;
        controlHover=src.controlHover;                  
        controlContainer=src.controlContainer;
        faceHover=src.faceHover;
        faceContainer=src.faceContainer;
        zDist=src.zDist;
        isMoving=src.isMoving;
}

void Picking::SetMousePos(int x,int y)
{
        oldMouse = mouse;               
        mouse.pos.Set(x,y);
        isMoving = oldMouse.pos!=mouse.pos;
}

void Picking::SetDeltaWheel(int delta)
{
        mouse.wheelDelta=delta;
        mouse.wheelVal+=delta;
}


void Picking::OnMouseMove(int x,int y)
{
        SetMousePos(x,y);
        controlHover->OnMouseMove(&mouse,faceHover);
}

void Picking::OnMouseWheel(int delta)
{
        SetDeltaWheel(delta);
        controlHover->OnMouseWheel(&mouse,faceHover);
}

void Picking::OnLButtonUp()
{
        mouse.leftBtn=FALSE;
        controlHover->onControl.mouse.left.up(&mouse,faceHover);
}

void Picking::OnMButtonUp()
{
        mouse.midBtn=FALSE;
        controlHover->onControl.mouse.mid.up(&mouse,faceHover);
}

void Picking::OnRButtonUp()
{
        mouse.rightBtn=FALSE;
        controlHover->onControl.mouse.right.up(&mouse,faceHover);
}


GLuint bufferSelect[MAX_BUFFER_SELECT]; // buffer du picking

void Picking::TestOvers()
{
        TestOver(lastControlHover,lastFaceHover,controlHover,faceHover);
        if (lastControlHover!=lastControlContainer)
                TestOver(lastControlContainer,lastFaceContainer,controlContainer,faceContainer);
}


void Picking::TestOver(Control *lastControl,int lastFace,Control *control,int face)
{       
        if(!lastControl) lastControl=ce.univers;
        if (control!=lastControl)
        {
                if (lastFace!=-1)
                {
                        lastControl->OverOut(control,face);
                        lastControl->FaceOverOut(face); 
                }
                control->OverIn(lastControl,lastFace);
                control->FaceOverIn(lastFace);
        } 
        else if (face!=lastFace)
        {
                if (lastFace!=-1) lastControl->FaceOverOut(face);
                control->FaceOverIn(lastFace);
        }
}

BOOL Picking::Test()
{   
        ce.monitor.Begin("testPicking");
        // config du buffer de resultat du picking
        glSelectBuffer(MAX_BUFFER_SELECT,bufferSelect); // liste des noms en intersection
        glRenderMode(GL_SELECT);

        // inint des noms
        glInitNames();
        glPushName(-1);

        // on zoom sur la souris
        glMatrixMode(GL_PROJECTION);
        glPushMatrix();
        glLoadIdentity();
        gluPickMatrix(mouse.pos.x,(GLdouble)(ce.deltaYwin-mouse.pos.y),1,1,ce.viewPort);
        ce.SetPerspective(0,0);

        // on dessine la scene virtuelement
        glMatrixMode(GL_MODELVIEW); 
        ce.monitor.End("testPicking");
        ce.monitor.Begin("drawPicking");
        ce.DrawScene(TRUE);
        ce.monitor.End("drawPicking");
        ce.monitor.Begin("testPicking");
        // on ce replace comme avant le picking
        glMatrixMode(GL_PROJECTION);
        glPopMatrix();

        int idControl;
        int nbElem = glRenderMode(GL_RENDER);
        MyString fullText;
        MyString selectedText;
        MyString selectedTextTitle;
        static MyString oldFullText;
        fullText.Format("Find(%d): ",nbElem);
        UpdateLast();
        if (nbElem>0) 
        {
                GLuint *ptr=bufferSelect;
                float zMinMin;
                for (int i=0;i<nbElem;i++)
                {
                        int names = *ptr;
                        GLuint *ptr1= ++ptr;
                        GLuint *ptr2= ++ptr;
                        float zMin = (float)*ptr1/0x7fffffff;
                        float zMax = (float)*ptr2/0x7fffffff;
                        BOOL isMin;

                        // le quel est le plus pres de l'observeur
                        if (i==0) isMin=TRUE;
                        else 
                        {
                                if (zMinMin>zMin) isMin = TRUE;
                                else isMin = FALSE;
                        }
                        //temp.AddFormat("[%.1lf,%.1lf]",zMin,zMax);
                        ptr++;
                        fullText<<"{";
                        if (isMin) zMinMin=zMin;
                        for(int j=0;j<names;j++)
                        {
                                if (isMin)
                                {
                                        if (j==1) idControl = *ptr;
                                        if (j==2) faceHover = *ptr;
                                }
                                fullText.AddFormat("%d ",*ptr);
                                ptr++;
                        }
                        fullText<<"} ";
                }
                controlHover = Control::Find(idControl);
                if (!controlHover) 
                {
                        controlHover =ce.univers;
                        faceHover=-1;
                }
                else 
                {
                        Face *face;
                        if (controlHover->faceNode->childs.GetNbElem())
                                face = controlHover->faceNode->childs.i[faceHover]->elem;
                        else 
                                face = controlHover->faceNode->elem; // pour le cas d'un Tip par example
                        GLfloat zMouse;
                        glReadPixels(mouse.pos.x,(int)ce.dyWin-mouse.pos.y,1,1,GL_DEPTH_COMPONENT,GL_FLOAT,&zMouse);
                        zDist=zMinMin;

                        selectedTextTitle.Format("%s / %s",(char *)controlHover->name,(char *)face->name);
                        selectedText.Format("d1:%f d2:%f",zMinMin,zMouse);
                }
        }
        else 
        {
                if (ce.enablePicking) selectedTextTitle="<Nothing>";
                else selectedTextTitle="<Not tested>";
                controlHover = ce.univers;
                faceHover=-1;
        }       
        if (oldFullText!=fullText)
        {
                // partie a optimise, car fait chutter un peut les performances
                MyDebug::SendEvent("Picking",selectedTextTitle);
                oldFullText=fullText;
                if (ce.screenConfig.hWnd)
                {
                        Edit_SetText(GetDlgItem(ce.screenConfig.hWnd,IDC_STATIC_PICKING_FULL),fullText);
                        Edit_SetText(GetDlgItem(ce.screenConfig.hWnd,IDC_STATIC_PICKING_SELECTED),selectedText);
                        Edit_SetText(GetDlgItem(ce.screenConfig.hWnd,IDC_STATIC_PICKING_SELECTED_TITLE),selectedTextTitle);
                }
        }
        FindContainer();
        TestOvers();
        ce.monitor.End("testPicking");
        return TRUE;
}

BOOL Picking::FindContainer()
{
        if (!controlHover) return FALSE;

        FaceNode *faceNode;
        if (faceHover==-1) faceNode = controlHover->faceNode;
        else faceNode = controlHover->faceNode->childs.i[faceHover];
        FaceNode *faceNodeOld = faceNode;
        while 
        (
                (faceNode->parent!=ce.univers->faceNode)&&
                (faceNode->parent!=ce.masterContainer->faceNode)
        ) 
        {
                faceNodeOld=faceNode;
                faceNode=faceNode->parent;
        }
        controlContainer=Control::Find(faceNodeOld->elem->idControl);
        faceContainer=faceNodeOld->elem->idFace;

        /*
        Control *control = controlHover;
        while (control->parent!=ce.univers) control=control->parent;
        controlContainer=control;
        */
        return TRUE;
}

---