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

extern ControlEngine ce;

Primitive::Primitive()
{
        //layout.SetFull();
}

Primitive::~Primitive()
{
        tree.SuprAll();
}

void Primitive::Push()
{
        stack.Push(tree.GetCurrent());
}

void Primitive::Pop()
{
        tree.GoTo(stack.Pop());
}

FaceNode * Primitive::GoTo(int childNumber)
{
        return tree.GoToChild(childNumber);
}

FaceNode * Primitive::GoTo(FaceNode *node)
{
        return tree.GoTo(node);
}

FaceNode * Primitive::GoToParent()
{
        return tree.GoToParent();
}

FaceNode * Primitive::Peek()
{
        if (!stack.GetNbElem()) return NULL;
        return stack.Peek();
}

void Primitive::ViewDebug(FaceNode *node)
{
        if (!node) node= tree.GetRoot();
        static MyString message;
        static int level=0;
        for (int i=0;i<level;i++) message+="| ";
        level++;
        message<<node->elem->name<<"\n";
        for (node->childs.i=0;node->childs.i.More();node->childs.i++) 
                ViewDebug(node->childs.i.GetElem());
        level--;
        if (!level) 
        {
                MessageBox(NULL,message,"Debug of primitive",0);
                message="";
        }
}

void Primitive::ComputeLayout(FaceNode *faceNode)
{
        if (!faceNode) return;
        ComputeLayout(faceNode->parent);
        faceNode->elem->ComputeLayout();
}

void Primitive::ReOrderForBlending()
{
        ReOrderForBlending(tree.GetRoot());
}

BOOL Primitive::ReOrderForBlending(FaceNode *faceNode)
{
        if (!faceNode) return FALSE;
        FaceNode *curChild;
        MyListItem<FaceNode *> *item;
        item = faceNode->childs.first;
        BOOL contentBlending = FALSE;
        while (item)
        {
                curChild = *item->elem;
                item = item->after;
                if (ReOrderForBlending(curChild)) contentBlending=TRUE;
        }
        if (faceNode->elem->blending||contentBlending) 
        {
                faceNode->MoveToLastChild();
                return TRUE;
        }
        return FALSE;

}

void Primitive::GetCorners(FaceNode *faceNode,Point3D<double> *points)
{
        glMatrixMode(GL_MODELVIEW);
        glPushMatrix();
        glLoadIdentity();
        gluLookAt(0,0,ce.depth,0,0,0,0,1,0);
        ce.ApplyScaleView();
        GetCornersRecursive(faceNode,TRUE,points);
        glPopMatrix();
}

Point2D<double> Primitive::GetLocalPos(FaceNode *faceNode,Point2D<double> absolutePos)
{
        Point3D<double> corners[4];
        GetCorners(faceNode,corners);

        Point2D<double> a,b,c,d,p;
        a.Set(corners[0].x,corners[0].y);
        b.Set(corners[1].x,corners[1].y);
        c.Set(corners[2].x,corners[2].y);
        d.Set(corners[3].x,corners[3].y);
        double alphaX=0,alphaY=0;
        if (!absolutePos.GetRelativePtOnQuadrilatere(a,b,c,d,&alphaX,&alphaY)) return p; // erreur
        p.Set(faceNode->elem->computeSize.x*alphaX,faceNode->elem->computeSize.y*(1.0-alphaY));
        return p;
}

void Primitive::GetCornersRecursive(FaceNode *faceNode,BOOL isObjective,Point3D<double> *points)
{
        if (!faceNode) return ;
        GetCornersRecursive(faceNode->parent,FALSE,points);
        Face *face = faceNode->elem;
        face->MovingInside();
        if (face->scale.x!=1||face->scale.y!=1||face->scale.z) face->scale.glScale();
        if (isObjective) face->GetCorners(points);
}

BOOL Primitive::Draw(BOOL isPicking) 
{ 
        if (isPicking) glLoadName(0);
        FaceNode *node = tree.GetRoot();
        if (!isPicking) node->elem->ComputeLayout();
        return Draw(node,isPicking); 
}

BOOL Primitive::Draw(FaceNode *faceNode,BOOL isPicking)
{       
        if (!faceNode) return FALSE;
        FaceNode *childNode;
        Face *child;
        Face *father = faceNode->elem;
        glPushMatrix();
        father->MovingInside();
        father->Draw(isPicking);
        if (faceNode->childs.GetNbElem()) // contenueur ?
        {   // gestion des fils
                for (faceNode->childs.i=0;faceNode->childs.i.More();faceNode->childs.i++)
                {
                        childNode = faceNode->childs.i.GetElem();
                        child = childNode->elem;

                        if (!isPicking)
                        {       // calcul des dimentions et position suivant les layouts par rapport au pere
                                child->ComputeLayout();
                                child->ratioXY = father->ratioXY*(child->scale.x/child->scale.y); // donne le ratio entre X et Y
                        }
                        if (child->scale.x!=1||child->scale.y!=1) glScaled(child->scale.x,child->scale.y,1);
                        if (!Draw(childNode,isPicking)) return FALSE;
                }
        }
        glPopMatrix();
        return TRUE;
}

/*

BOOL Primitive::Draw(FaceNode *faceNode,BOOL isPicking)
{       
        if (!faceNode) return FALSE;
        FaceNode *childNode;
        Face *child;
        Face *father = faceNode->elem;
        glPushMatrix();
        father->Draw(isPicking);
        if (faceNode->childs.GetNbElem()) // contenueur ?
        {   // gestion des fils
                for (faceNode->childs=0;faceNode->childs.More();faceNode->childs++)
                {
                        childNode = faceNode->childs.GetElem();
                        child = childNode->elem;

                        if (!isPicking)
                        {       // calcul des dimentions et position suivant les layouts par rapport au pere
                                child->ComputeLayout();
                                child->ratioXY = father->ratioXY*(child->scale.x/child->scale.y); // donne le ratio entre X et Y
                        }
                        if (child->scale.x!=1||child->scale.y!=1) glScaled(child->scale.x,child->scale.y,1);
                        if (!Draw(childNode,isPicking)) return FALSE;
                }
        }
        glPopMatrix();
#ifdef DEBUG_3D
        static BOOL isFirst = TRUE;
        if (!faceNode->parent&&isFirst) { isFirst = FALSE; ViewDebug();  }
#endif
        return TRUE;
}
*/
FaceNode * Primitive::Find(int idControl,int idFace,FaceNode *node)
{
        FaceNode *result;
        if (!node) node = tree.GetRoot();
        if (node->elem->idControl==idControl && node->elem->idFace==idFace) return node;

        for (node->childs.i=0;node->childs.i.More();node->childs.i++)
        {
                result = Find(idControl,idFace,node->childs.i.GetElem());
                if (result) return result;
        }               
        return NULL;
}

FaceNode * Primitive::AddFace (char *name,int idControl,int idFace,BOOL view)
{
        Face face;
        face.Set(name,idControl,idFace,view);
        return tree.Add(face);
}

FaceNode * Primitive::AddFace (
        char *name,int idControl,int idFace,BOOL view,
        double xConstPosition,double xPercentPosition,
        double yConstPosition,double yPercentPosition,
        double zConstPosition,
        double xConstSize,double xPercentSize,
        double yConstSize,double yPercentSize)
{
        FaceNode *nodeFace = AddFace(name,idControl,idFace,view);
        Face *face = nodeFace->elem;
        Face *father = nodeFace->parent?nodeFace->parent->elem:NULL;
        face->ConfigStaticLayout(xConstPosition,yConstPosition,zConstPosition,xConstSize,yConstSize);
        face->ConfigDynamicLayout(father,xPercentPosition,yPercentPosition,xPercentSize,yPercentSize);
        return nodeFace;
}

void Primitive::BeginContainer(
        int idControl,
        double xConstPosition,double xPercentPosition,
        double yConstPosition,double yPercentPosition,
        double xConstSize,double xPercentSize,
        double yConstSize,double yPercentSize)
{
        AddFace("container",idControl,0,FALSE,
                xConstPosition,xPercentPosition,
                yConstPosition,yPercentPosition,
                0,
                xConstSize,xPercentSize,
                yConstSize,yPercentSize);
        Push();
        GoTo(0);
}

void Primitive::EndContainer()
{
        Pop();
}


FaceNode * Primitive::AddBox (char *name,int idControl,GLdouble depth,BOOL viewBack)
{
        GLdouble depthTemp = depth;
        return AddBox(name,idControl,FALSE,&depthTemp,viewBack);
}

FaceNode * Primitive::AddBox (char *name,int idControl,GLdouble *depth,BOOL viewBack)
{
        return AddBox(name,idControl,TRUE,depth,viewBack);
}

FaceNode * Primitive::AddBox (char *name,int idControl,BOOL isDynamic,GLdouble *depth,BOOL viewBack)
{   
        // une boite est contenu dans une face non visible afin de pouvoir faire des
        // rotation et translation libre
        FaceNode * nodeBase;
        nodeBase=AddFace(name,idControl,-1,FALSE); // creation de la face container (jamais visisble: pure conteneur)
        Face *child = nodeBase->elem;

        Push();
        GoTo(nodeBase);

        // ajout des 6 faces
        // pour des pb de blending, l'ordre d'insertion doit etre du cachant au caché, sinon certaine facette ne sont pas affiché
        MyString nameCur;

        nameCur<<clear<<name<<" [back]";
        FaceNode *nodeFace;
        Face *childFace;
        nodeFace=AddFace(nameCur,idControl,FACE_BACK,viewBack);
        childFace=nodeFace->elem;
        childFace->angle.Set(180,0);
        childFace->size.x.Set(0,1,&child->computeSize.x);
        childFace->size.y.Set(0,1,&child->computeSize.y);
        childFace->view=viewBack;

        nameCur<<clear<<name<<" [bottom]";
        nodeFace=AddFace(nameCur,idControl,FACE_BOTTOM,TRUE);
        childFace=nodeFace->elem;
        childFace->angle.Set(90,0);
        childFace->position.y.Set(0,-0.5,&child->computeSize.y);
        if (isDynamic) 
        {
                childFace->position.z.Set(0,0.5,depth);
                childFace->size.y.Set(0,1,depth);
        }
        else 
        {
                childFace->position.z.Set(*depth/2.0);
                childFace->size.y.Set(*depth);
        }
        childFace->size.x.Set(0,1,&child->computeSize.x);

        nameCur<<clear<<name<<" [top]";
        nodeFace=AddFace(nameCur,idControl,FACE_TOP,TRUE);
        childFace=nodeFace->elem;
        childFace->angle.Set(-90,0);
        childFace->position.y.Set(0,0.5,&child->computeSize.y);
        if (isDynamic) 
        {
                childFace->position.z.Set(0,0.5,depth);
                childFace->size.y.Set(0,1,depth);
        }
        else 
        {
                childFace->position.z.Set(*depth/2.0);
                childFace->size.y.Set(*depth);
        }
        childFace->size.x.Set(0,1,&child->computeSize.x);

        nameCur<<clear<<name<<" [left]";
        nodeFace=AddFace(nameCur,idControl,FACE_LEFT,TRUE);
        childFace=nodeFace->elem;
        childFace->angle.Set(0,-90);
        childFace->position.x.Set(0,-0.5,&child->computeSize.x);
        if (isDynamic) 
        {
                childFace->position.z.Set(0,0.5,depth);
                childFace->size.x.Set(0,1,depth);
        }
        else 
        {
                childFace->position.z.Set(*depth/2.0);
                childFace->size.x.Set(*depth);
        }
        childFace->size.y.Set(0,1,&child->computeSize.y);

        nameCur<<clear<<name<<" [right]";
        nodeFace=AddFace(nameCur,idControl,FACE_RIGHT,TRUE);
        childFace=nodeFace->elem;
        childFace->angle.Set(0,90);
        childFace->position.x.Set(0,0.5,&child->computeSize.x);
        if (isDynamic) 
        {
                childFace->position.z.Set(0,0.5,depth);
                childFace->size.x.Set(0,1,depth);
        }
        else 
        {
                childFace->position.z.Set(*depth/2.0);
                childFace->size.x.Set(*depth);
        }
        childFace->size.y.Set(0,1,&child->computeSize.y);

        nameCur<<clear<<name<<" [front]";
        nodeFace=AddFace(nameCur,idControl,FACE_FRONT,TRUE);
        childFace=nodeFace->elem;
        childFace->angle.Set(0,0);
        if (isDynamic) childFace->position.z.Set(0,1,depth);
        else childFace->position.z.Set(*depth);
        childFace->size.x.Set(0,1,&child->computeSize.x);
        childFace->size.y.Set(0,1,&child->computeSize.y);

        Pop();
        return nodeBase;
}

---