face.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 "face.h"
#include "trigo.h"
#include "controlEngine.h"

extern ControlEngine ce;

// ********************************************************************************

void Face::Set(char *_name,int _idControl,int _idFace,BOOL _view)
{
        idControl = _idControl;
        idFace = _idFace;
        name = _name;
        view = _view;
}

BOOL Face::ConfigDynamicLayout(Face *father,double xPosition,double yPosition,double xSize,double ySize)
{
        if (!father) return FALSE;
        position.x.SetPercent(xPosition,&father->computeSize.x);
        position.y.SetPercent(yPosition,&father->computeSize.y);
        size.x.SetPercent(xSize,&father->computeSize.x);
        size.y.SetPercent(ySize,&father->computeSize.y);
        return TRUE;
}

void Face::ConfigStaticLayout(double xPosition,double yPosition,double zPosition,double xSize,double ySize)
{
        MoveTo(xPosition,yPosition,zPosition);
        size.x.constValue=xSize;
        size.y.constValue=ySize;
}

void Face::ConfigCenter(int xCenter,int yCenter)
{
        center.x=xCenter;
        center.y=xCenter;
}

void Face::Move(double x,double y,double z)
{
        position.x.constValue+=x;
        position.y.constValue+=y;
        position.z.constValue+=z;
}

void Face::MoveTo(double x,double y,double z)
{
        position.x.constValue=x;
        position.y.constValue=y;
        position.z.constValue=z;
}

void Face::ComputeLayout()
{       
        computeSize.x = size.x.Compute()*scale.x;
        computeSize.y = size.y.Compute()*scale.y;
        computePosition.x = position.x.Compute()*scale.x;
        computePosition.y = position.y.Compute()*scale.y;
        computePosition.z = position.z.Compute();

        switch (center.x)
        {
        case -1: computeCenter.x = -computeSize.x/2.0; break;
        case 0: computeCenter.x = 0; break;
        case 1: computeCenter.x = computeSize.x/2.0; break;
        }
        switch (center.y)
        {
        case -1: computeCenter.y = -computeSize.y/2.0; break;
        case 0: computeCenter.y = 0; break;
        case 1: computeCenter.y = computeSize.y/2.0; break;
        }       
}

void Face::Draw(BOOL onPicking)
{
        GLdouble dx = computeSize.x/2.0;
        GLdouble dy = computeSize.y/2.0;
        if (!onPicking) material.Use();
        if (view) 
        {
                if (onPicking)
                {       // on est en mode picking
                        if (noPicking) return; // cette face ne dois pas etre considere pour le picking
                        glPushName(idControl);
                        glPushName(idFace);
                        childRecorder.Play(); // s'il y a un objet custom a dessine

                        if (curve.IsActive())
                        {       // dessine des sous rectangle pour plus de realisme
                                glTranslated(-dx,dy,0);
                                curve.Draw(computeSize,NULL);
                                glTranslated(dx,-dy,0);
                        }
                        else
                        {                       
                                glBegin(GL_QUADS);
                                glVertex2d(-dx,-dy);
                                glVertex2d(dx,-dy);
                                glVertex2d(dx,dy);
                                glVertex2d(-dx,dy);
                                glEnd();
                        }
                        
                        if (text) 
                        {       // le text a sont propre picking
                                text->SetClipping(computeSize);
                                text->SetRatioXY(ratioXY);
                                glTranslated(-dx,dy,0);
                                text->DrawPicking();
                                glTranslated(dx,-dy,0);
                        }

                        glPopName();
                        glPopName();
                }
                else
                {       // on est en mode affichage
                        if (!fog&&ce.fog.isEnable) glDisable(GL_FOG);

                        if (texture) 
                        {
                                glEnable(GL_TEXTURE_2D);
                                glBindTexture(GL_TEXTURE_2D,texture->id);
                        }
                        else glDisable(GL_TEXTURE_2D);
                        if (blending)
                        {
                                glEnable(GL_BLEND);
                                glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
                        }
                        else glDisable(GL_BLEND);                                       

                        childRecorder.Play(); // s'il y a un objet custom a dessine

                        if (ce.screenMain.region.enable)
                        {       // pour les region ou calcul du la distance z au picking:
                                // determination des coordonnées de chaque sommet sur l'ecrant
                                ce.RegionAdd(-dx,-dy);
                                ce.RegionAdd(dx,-dy);
                                ce.RegionAdd(dx,dy);
                                ce.RegionAdd(-dx,dy);
                        }

                        //glNormal3d(0,0,1); // utilisation GL_NORMALIZE sinon pb, a re-etudier, pise, les normal utilse t'elle la matrice de projection ?
                        if (curve.IsActive())
                        {       // dessine des sous rectangle pour plus de realisme
                                glTranslated(-dx,dy,0);
                                curve.Draw(computeSize,texture);
                                glTranslated(dx,-dy,0);
                        }
                        else
                        {
                                glBegin(GL_QUADS);
                                if (texture)
                                {
                                        texture->SetCoord(0,0);         glVertex2d(-dx,-dy);
                                        texture->SetCoord(1,0);         glVertex2d(dx,-dy);
                                        texture->SetCoord(1,1);         glVertex2d(dx,dy);
                                        texture->SetCoord(0,1);         glVertex2d(-dx,dy);
                                }
                                else
                                {
                                        glVertex2d(-dx,-dy);
                                        glVertex2d(dx,-dy);
                                        glVertex2d(dx,dy);
                                        glVertex2d(-dx,dy);
                                }
                                glEnd();
                        }
                        if (!fog&&ce.fog.isEnable) glEnable(GL_FOG);
                        if (texture) glDisable(GL_TEXTURE_2D);
                        if (blending) glDisable(GL_BLEND); 
                        
                        if (text) // affichage du text
                        {       // le text dois etre affiché apres la face sinon ca bug
                                // text->SetClipping(delta.x,delta.y);
                                text->SetClipping(computeSize);
                                glPushAttrib(GL_LIGHTING_BIT);
                                text->SetRatioXY(ratioXY);
                                glTranslated(-dx,dy,0); // a faire: transposé tout dans le draw
                                text->Draw();
                                glTranslated(dx,-dy,0);
                                glPopAttrib();
                        }
                }
        }
        else 
        {
                if (!onPicking)
                {
                        childRecorder.Play(); // s'il y a un objet custom a dessine
                }
        }
        if (!onPicking&&line)
        {
                if (antialias)
                {
                        glEnable(GL_BLEND);
                        glBlendFunc(GL_SRC_ALPHA,GL_ONE);
                }
                glPushAttrib(GL_LIGHTING_BIT);
                lineMaterial.Use();
                glLineWidth(line);
                glBegin(GL_LINE_LOOP);
                glVertex2d(-dx,-dy);
                glVertex2d(dx,-dy);
                glVertex2d(dx,dy);
                glVertex2d(-dx,dy);
                glEnd();
                glPopAttrib();
                if (antialias) glDisable(GL_BLEND);
        }
}

void Face::MovingInside()
{
        computePosition.glTranslated();                                 // deplacement par rapport au conteneur
        angle.glRotated();                                                              // effectue la rotation de face
        glTranslated(computeCenter.x,computeCenter.y,0);// centrage
}

void Face::GetCorners(Point3D<double> *corners)
{
        GLdouble dx = computeSize.x/2.0;
        GLdouble dy = computeSize.y/2.0;

        ce.RegionGet(-dx,-dy,&corners[0]);
        ce.RegionGet(dx,-dy,&corners[1]);
        ce.RegionGet(dx,dy,&corners[2]);
        ce.RegionGet(-dx,dy,&corners[3]);
}

// ********************************************************************************

Face::Face()
{
        Zero();
}

Face::~Face()
{
}

// ********************************************************************************

void Face::Zero()
{
        idFace = 0;
        childRecorder.Delete();
        idControl = 0;
        name = "";

        size.Zero();
        center.Zero();
        position.Zero();
        computeSize.Zero();
        computeCenter.Zero();
        computePosition.Zero();
        angle.Zero();
        scale.Set(1,1,1);
        ratioXY = 1;

        view = TRUE; 
        blending = FALSE;
        antialias = TRUE;
        noPicking = FALSE;
        fog = TRUE;
        line = 0;
        lineMaterial.Zero();

        texture = NULL;
        material.Zero();
        curve.Zero();

        text = NULL;
}

// ********************************************************************************

void Face::operator=(Face &src)
{
        line = src.line;
        lineMaterial = src.lineMaterial;
        name = src.name;
        idFace = src.idFace;
        idControl = src.idControl;

        fog = src.fog;

        size=src.size;
        center=src.center;
        position=src.position;
        computeSize=src.computeSize;
        computeCenter=src.computeCenter;
        computePosition=src.computePosition;
        angle=src.angle;
        scale=src.scale;
        ratioXY = src.ratioXY;

        view = src.view;
        blending = src.blending;
        noPicking = src.noPicking;
        antialias = src.antialias;
        texture = src.texture;
        material = src.material;
        curve = src.curve;

        angle = src.angle;
        text = src.text;
}

// ********************************************************************************

---