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

Region::Region()
{
        enable = FALSE;
        computeMinMax = FALSE;
        Reset();
}

void Region::Reset(int deltaXwin,int deltaYwin)
{
        points.i.SuprAll();
        xMin=deltaXwin;
        yMin=deltaYwin;
        zMin=10000;
        xMax=0;
        yMax=0;
        zMax=0;
        nbOr = 0;
        hRgnBase = NULL;
}

BOOL Region::Use(HWND hWnd)
{       
        if (!enable) return FALSE;

        // creation du tableau de points
        int nbPt = points.GetNbElem();
        int nbElem = nbPt/4;
        POINT *tabPoints = new POINT[nbPt+4]; // a voir: +4 sinon pb je sais pas pkoi!
        if (!tabPoints) return FALSE;
        POINT *ptrPoint = tabPoints;
        for (points.i=0;points.i.More();points.i++)
        {
                Point3D<double> *pt = points.i();
                ptrPoint->x=(LONG)pt->x;
                ptrPoint->y=(LONG)pt->y;
                ptrPoint++;
        }
        // creation de la liste de taille des polygones
        int     *tabPoly = new int[nbElem];
        if (!tabPoly)
        {
                delete tabPoints;
                return FALSE;
        }
        for (int i=0;i<nbElem;i++) tabPoly[i]=4;

        // normalisation des points
        ptrPoint = tabPoints-4;
        for (int i=0;i<nbElem;i++) NormalizeSens(ptrPoint+=4,4);

        // calcul des mins maxs
        if (computeMinMax)
        {
                ptrPoint = tabPoints-4;
                for (int i=0;i<nbElem;i++) SetMinMax(ptrPoint+=4,4);
        }

        // creation de la region
        hRgnBase = CreatePolyPolygonRgn(tabPoints,tabPoly,nbElem,WINDING);
        //hRgnBase = CreateRectRgn(xMin,yMin,xMax,yMax);
        if (!hRgnBase) 
        {
                delete []tabPoints;
                delete []tabPoly;                       
                return FALSE;
        }
        SetWindowRgn(hWnd,hRgnBase,TRUE);
        delete []tabPoints;
        delete []tabPoly;
        DeleteObject(hRgnBase);
        return TRUE;
}

void Region::NormalizeSens(POINT *tabPoints,int nbPt)
{
        // determination du sens de rotation (3 points suffisent)
        BOOL sensTrigo = GetTrigoSens(tabPoints);
        // si sens non trigonometrique change les points de sens sinon CreatePolyPolygonRgn fait un NON OR
        if (!sensTrigo) ChangeTrigoSens(tabPoints,nbPt);                                
}

void Region::SetMinMax(POINT *tabPoints,int nbPt)
{
        for (int i=0;i<nbPt;i++)
        {
                xMin = min(xMin,tabPoints->x);
                xMax = max(xMax,tabPoints->x);
                yMin = min(yMin,tabPoints->y);
                yMax = max(yMax,tabPoints->y);
                tabPoints++;
        } 
}

BOOL Region::AddElem(Point2D<GLdouble> pos,GLdouble *modelMatrix,GLdouble *projMatrix,GLint *viewPort)
{
        Point3D<double> *pt = points.i.AddNewLast();
        return Compute(pos,modelMatrix,projMatrix,viewPort,pt);
        return TRUE;
}

BOOL Region::Compute(Point2D<GLdouble> pos,GLdouble *modelMatrix,GLdouble *projMatrix,GLint *viewPort,Point3D<double> *pt)
{
        gluProject(pos.x,pos.y,0,modelMatrix,projMatrix,viewPort,&pt->x,&pt->y,&pt->z);
        pt->y=viewPort[3]-pt->y;
        return TRUE;
}

---