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

#include "controlEngine.h"
extern ControlEngine ce;

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

void Config(Face *face,double dx,double dy,float alpha)
{
        face->size.x=dx;
        face->size.y=dy;
        face->blending=TRUE;
        face->noPicking=TRUE;
        face->material.SetDS(1,1,1,alpha);
        Face *faceMC = ce.masterContainer->faceNode->elem;
        face->position.x.SetPercent(-0.5,&faceMC->computeSize.x);
        face->position.y.SetPercent(0.5,&faceMC->computeSize.y);
}

Cursor::Cursor()
{
        curType=cursorArrow;
        leftType=cursorNothing;
        rightType=cursorNothing;
        midType=cursorNothing;
}

void Cursor::Create()
{
        recorderRepere.BeginRecord(FALSE);
        DrawRepere(); 
        recorderRepere.EndRecord();             

        Config(&curFace,32,32,1);
        Config(&leftFace,16,16,0.5f);
        Config(&midFace,16,16,0.5f);
        Config(&leftFace,16,16,0.5f);
        ApplyTypes();
}

void Cursor::Draw(double x,double y)
{
        glDisable(GL_DEPTH_TEST);
        glDepthMask(GL_FALSE);
        y=-y;
        
        glPushMatrix();
        curFace.MoveTo(x,y,0);
        curFace.ComputeLayout();
        curFace.MovingInside();
        curFace.Draw(FALSE);
        glPopMatrix();

        glPushMatrix();
        leftFace.MoveTo(x-16,y-16,0);
        leftFace.ComputeLayout();
        leftFace.MovingInside();
        leftFace.Draw(FALSE);
        glPopMatrix();

        glPushMatrix();
        midFace.MoveTo(x,y-16,0);
        midFace.ComputeLayout();
        midFace.MovingInside();
        midFace.Draw(FALSE);
        glPopMatrix();

        glPushMatrix();
        rightFace.MoveTo(x+16,y-16,0);
        rightFace.ComputeLayout();
        rightFace.MovingInside();
        rightFace.Draw(FALSE);
        glPopMatrix();

        glDepthMask(GL_TRUE);
        glEnable(GL_DEPTH_TEST);
}

Point2D<int> Cursor::GetHotSpot(CursorType type)
{       
        Point2D<int> hotSpot;
        switch (type)
        {
        case cursorArrow:  hotSpot.Set(11,10); break;
        case cursorPush: hotSpot.Set(11,10); break;
        //case cursorWait:
        //case cursorText:
        //case cursorMoving:
        //case cursorRepere:
        //case cursorNoChange:
        //case cursorNothing:
        }
        return hotSpot;
}

void Cursor::ApplyTypes(CursorType current,CursorType left,CursorType mid,CursorType right)
{
        if (current!=cursorNoChange) curType=current;
        if (left!=cursorNoChange) leftType=left;
        if (mid!=cursorNoChange) midType=mid;
        if (right!=cursorNoChange) rightType=right;
        ApplyType(&curFace,curType);
        ApplyType(&leftFace,leftType);
        ApplyType(&midFace,midType);
        ApplyType(&rightFace,rightType);
}

void Cursor::ApplyType(Face *face,CursorType type)
{
        face->view = TRUE;
        if (type!=cursorRepere) face->childRecorder.Zero();
        switch (type)
        {
        case cursorNothing: face->view = FALSE; break;
        case cursorArrow: face->texture = &ce.texture.cursorArrow; break;
        case cursorWait: face->texture = &ce.texture.cursorWait; break;
        case cursorPush: face->texture = &ce.texture.cursorPush; break;
        case cursorText: face->texture = &ce.texture.cursorText; break;
        case cursorMoving: face->texture = &ce.texture.cursorMoving; break;
        case cursorRepere: face->view = FALSE; face->childRecorder=recorderRepere; break;
        }
}

void Cursor::Rotate(Face *face,CursorType type,Point3D<double> angle)
{
        switch (type)
        {
        case cursorRepere: face->angle=angle; break;
        default: face->angle.Zero();
        }
}
void Cursor::Rotate(Point3D<double> angle)
{
        Rotate(&curFace,curType,angle);
        Rotate(&leftFace,leftType,angle);
        Rotate(&midFace,midType,angle);
        Rotate(&rightFace,rightType,angle);
}

BOOL Cursor::DrawVectorMinMax(double x,double y,double minIntensity,double maxIntensity)
{
        double intensity = sqrt(x*x+y*y);
        //MyDebug::SendEvent("draw vector","x:%lf y:%lf i:%lf",x,y,intensity);
        
        if (intensity<minIntensity) return FALSE;
        if (intensity>maxIntensity) 
        {
                double angle=atan2(y,-x);
                x=cos(angle)*maxIntensity;
                y=sin(angle)*maxIntensity;
        }
        DrawVector(x,y);
        return TRUE;
}

void Cursor::DrawVector(double x,double y)
{
        glDisable(GL_TEXTURE_2D);
        //glEnable(GL_BLEND);
        //glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
        double angle=atan2(y,-x)*(180.0/PI);
        double intensity = sqrt(x*x+y*y)/25.0;

        Point3D<double> rotate(0,0,angle);

        Material material;
        material.SetNull();
        //material.SetDS(0,0,1,0.5);
        material.emission.Set(0,0,1);
        material.Use();

        glPushMatrix();
        rotate.glRotated();
        glBegin(GL_POLYGON);
        glVertex2d(0,0);
        glVertex2d(intensity,0);
        glVertex2d(intensity-0.05,-0.05);
        glVertex2d(intensity-0.05,0.05);
        glVertex2d(intensity,0);
        glEnd();
        glPopMatrix();
        //glDisable(GL_BLEND);
}

void Cursor::DrawArrow(Color color)
{
        glDisable(GL_BLEND);
        glDisable(GL_TEXTURE_2D);
        Material material;

        material.SetNull();
        material.emission = color;
        material.Use();

        // tracement des regions
        glBegin(GL_POLYGON);
        glVertex2d(0,0);
        glVertex2d(0,-0.2);
        glVertex2d(0.05,-0.15);
        glVertex2d(0.12,-0.3);
        glVertex2d(0.20,-0.22);
        glVertex2d(0.10,-0.10);
        glVertex2d(0.15,-0.06);
        glVertex2d(0,0);
        glEnd();

        // les contours
        material.emission.SetNull();
        material.Use();
        glBegin(GL_LINE_LOOP);
        glVertex2d(0,0);
        glVertex2d(0,-0.2);
        glVertex2d(0.05,-0.15);
        glVertex2d(0.12,-0.3);
        glVertex2d(0.2,-0.22);
        glVertex2d(0.10,-0.10);
        glVertex2d(0.15,-0.06);
        glEnd();
}

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

void Cursor::DrawRepere()
{
        Material material;
        glDisable(GL_BLEND);
        glDisable(GL_TEXTURE_2D);

        material.SetNull();
        
        GLUquadric *newQuadric = gluNewQuadric();
        gluQuadricNormals(newQuadric,GLU_NONE); // sinon influ de maniere misterieuse les autre normales
        double size=0.6;
        double baseSize=8;
        double arrowSize=6;
        double baseArrowSize=3;

        glPushMatrix(); // les Z
                material.emission.Set(1,0,0);
                material.Use();
                gluCylinder(newQuadric,size,size,baseSize,3,3);
                glTranslated(0,0,baseSize);
                gluCylinder(newQuadric,baseArrowSize,0,arrowSize,3,3);
                //glTranslated(0,0,0.5);
                //DrawText("Z");
        glPopMatrix();

        glPushMatrix(); // les Y
                material.emission.Set(0,1,0);
                material.Use();
                glRotated(-90,1,0,0);
                gluCylinder(newQuadric,size,size,baseSize,3,3);
                glTranslated(0,0,baseSize);
                gluCylinder(newQuadric,baseArrowSize,0,arrowSize,3,3);
                //glTranslated(0,0,0.5);
                //DrawText("Y");
        glPopMatrix();
        
        glPushMatrix(); // les X
                material.emission.Set(0,0,1);
                material.Use();
                glRotated(90,0,1,0);
                gluCylinder(newQuadric,size,size,baseSize,3,3); 
                glTranslated(0,0,baseSize);
                gluCylinder(newQuadric,baseArrowSize,0,arrowSize,3,3);
                //glTranslated(0,0,0.5);
                //DrawText("X");
        glPopMatrix();

        gluDeleteQuadric(newQuadric);
        
        material.emission.SetNull();
        material.Use();
}


void Cursor::DrawText(char *text)
{

}

---