curve.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 "curve.h"

Curve::Curve()
{
        tabQuads = NULL;
        tabSommets = NULL;
        tabCoorTextures = NULL;
        Zero();
}

Curve::~Curve()
{
        UnAlloc();
}
void Curve::Zero()
{
        UnAlloc();
        nbCut.Set(1,1);
        center.Set(0.5,0.5);
        numList=0;
}

void Curve::operator=(Curve &source)
{
        nbCut = source.nbCut;
        center = source.center;
        oldCenter = source.oldCenter;
        oldNbCut = source.oldNbCut;
}

BOOL Curve::Set(GLdouble zCenter,int nbCutXY) 
{
        if (nbCutXY<0) return FALSE;
        nbCut.Set(nbCutXY,nbCutXY);
        center.Set(0.5,0.5,zCenter);
        return TRUE;
}

BOOL Curve::Set(GLdouble zCenter,int nbCutX,int nbCutY) 
{
        if ((nbCutX<0)||(nbCutY<0)) return FALSE;
        nbCut.Set(nbCutX,nbCutY);
        center.Set(0.5,0.5,zCenter);
        return TRUE;
}

BOOL Curve::IsActive()
{
        return ((nbCut.x>1)||(nbCut.y>1))?TRUE:FALSE;
}

BOOL Curve::Draw(Point2D<double> size,Texture *texture)
{
        if (!IsActive()) return FALSE;
        glBegin(GL_QUADS);
        GLdouble cdx = 1.0/(GLdouble)nbCut.x;
        GLdouble cdy = 1.0/(GLdouble)nbCut.y;
        BOOL noCutX = nbCut.x==1?TRUE:FALSE;
        BOOL noCutY = nbCut.y==1?TRUE:FALSE;
        GLdouble px = 0;
        GLdouble py = 0;
        GLdouble z1,z2,z3,z4;
        for (int x=0;x<nbCut.x;x++)
        {
                for (int y=0;y<nbCut.y;y++)                                             
                {
#define f(value) sin(PI*(value))
#define fxy(value,center) ((value<center)?sin((HALF_PI/center)*(value)):cos((HALF_PI/(1-center))*((value)-center)))
#define fx(value) fxy(value,center.x)
#define fy(value) fxy(value,center.y)
                        if (noCutX)
                        {
                                z1 = fy(py)*center.z;
                                z2 = fy(py)*center.z;
                                z3 = fy(py+cdy)*center.z;
                                z4 = fy(py+cdy)*center.z;
                        }
                        else if (noCutY)
                        {
                                z1 = fx(px)*center.z;
                                z2 = fx(px+cdx)*center.z;
                                z3 = fx(px+cdx)*center.z;
                                z4 = fx(px)*center.z;
                        }
                        else
                        {
                                z1 = (fx(px)*fy(py))*center.z;
                                z2 = (fx(px+cdx)*fy(py))*center.z;
                                z3 = (fx(px+cdx)*fy(py+cdy))*center.z;
                                z4 = (fx(px)*fy(py+cdy))*center.z;
                        }
                        GLdouble x1 = px*size.x;
                        GLdouble y1 = py*size.y-size.y;
                        GLdouble x2 = (px+cdx)*size.x;
                        GLdouble y2 = (py+cdy)*size.y-size.y;

                        if (texture)
                        {       
                                texture->SetCoord(px,py); 
                                glVertex3d(x1,y1,z1);
                                texture->SetCoord(px+cdx,py); 
                                glVertex3d(x2,y1,z2);
                                texture->SetCoord(px+cdx,py+cdy); 
                                glVertex3d(x2,y2,z3);
                                texture->SetCoord(px,py+cdy); 
                                glVertex3d(x1,y2,z4);
                        }
                        else
                        {
                                glVertex3d(x1,y1,z1);
                                glVertex3d(x2,y1,z2);
                                glVertex3d(x2,y2,z3);
                                glVertex3d(x1,y2,z4);
                        }
                        py+=cdy;
                }
                px+=cdx;
                py=0;
        }
        glEnd();
        return TRUE;
}

// le fonction ci-apres son pour utilisé l'optimisation (qui n'est pas mailleur d'ailleur)

void Curve::Refresh()
{
        nbCut.Set(-1,-1);
}

void Curve::UnAlloc()
{
        if (tabQuads) delete tabQuads;
        if (tabSommets) delete tabSommets;
        if (tabCoorTextures) delete tabCoorTextures;
        tabQuads = NULL;
        tabSommets = NULL;
        tabCoorTextures = NULL;
}

/*
BOOL Curve::Draw(Point2D<double> size,Texture *texture)
{
        if (!IsActive()) return FALSE;
        int nbFaces = nbCut.x*nbCut.y;

        BOOL isResize = oldNbCut!=nbCut;
        BOOL isRepositioning;
        GLdouble *ptrCoorTexture;
        if (isResize)
        {       // y a t'il eut des changement depuis le dernier appel ?
                UnAlloc();
                oldNbCut = nbCut;
                nbFaces = nbCut.x*nbCut.y;
                int nbSommets = (nbCut.x+1)*(nbCut.y+1);
                tabSommets = new GLdouble[nbSommets*3];
                tabCoorTextures = new GLdouble[nbSommets*2];
                tabQuads = new GLuint[nbFaces*4];
                isRepositioning = TRUE;
        }
        else isRepositioning = oldCenter!=center;

        if (texture) 
        {
                ptrCoorTexture = tabCoorTextures;
                glEnableClientState(GL_TEXTURE_COORD_ARRAY);
                glTexCoordPointer(2,GL_DOUBLE,0,tabCoorTextures);
        }
        else ptrCoorTexture = NULL;

        GLdouble *ptrSommet = tabSommets;
        GLuint *ptrQuad = tabQuads;
        glEnableClientState(GL_VERTEX_ARRAY);
        glVertexPointer(3,GL_DOUBLE,0,tabSommets);

        if (isRepositioning) 
        {
                oldCenter=center;
                GLdouble cdx = 1.0/(GLdouble)nbCut.x;
                GLdouble cdy = 1.0/(GLdouble)nbCut.y;
                BOOL noCutX = nbCut.x==1?TRUE:FALSE;
                BOOL noCutY = nbCut.y==1?TRUE:FALSE;
                GLdouble px = 0;
                GLdouble py = 0;
                GLdouble z;
                for (int x=0;x<=nbCut.x;x++)
                {
                        for (int y=0;y<=nbCut.y;y++)                                            
                        {
                        #define fxy(value,center) ((value<center)?sin((HALF_PI/center)*(value)):cos((HALF_PI/(1-center))*((value)-center)))
                        #define fx(value) fxy(value,center.x)
                        #define fy(value) fxy(value,center.y)
                        if (noCutX) z = fy(py);
                        else if (noCutY) z = fx(px);
                        else z = fx(px)*fy(py);
                        ptrSommet[0]=px*size.x;
                        ptrSommet[1]=py*size.y-size.y;
                        ptrSommet[2]=z*center.z;
                        ptrSommet+=3;
                        if (ptrCoorTexture)
                        {
                                ptrCoorTexture[0]=texture->GetXCoord(px);
                                ptrCoorTexture[1]=texture->GetYCoord(py);
                                ptrCoorTexture+=2;
                        }
                        py+=cdy;
                }
                px+=cdx;
                py=0;
        }

        int numSommet=0;
        for (int x=0;x<nbCut.x;x++)
        {
        for (int y=0;y<nbCut.y;y++)                                             
        {
        ptrQuad[1]=numSommet;
        ptrQuad[0]=numSommet+1;
        ptrQuad[3]=numSommet+nbCut.y+2;
        ptrQuad[2]=numSommet+nbCut.y+1;
        ptrQuad+=4;
        numSommet++;
        }
        numSommet++;
        }
        }

glDrawElements(GL_QUADS,nbFaces*4,GL_UNSIGNED_INT,tabQuads);
glDisableClientState(GL_VERTEX_ARRAY);
if (tabCoorTextures) glDisableClientState(GL_TEXTURE_COORD_ARRAY);

return TRUE;
}
*/

---