basic/opengl/GL_Range_Sensor.cpp

Go to the documentation of this file.

#include "OpenGL\GL_Range_Sensor.h"

#ifndef NOGL
#include "glos.h"
#include <gl\gl.h>
#endif

GL_Range_Sensor::GL_Range_Sensor (const GL_Range_Sensor& right)

  : Range_Sensor( right )
{
}

GL_Range_Sensor::GL_Range_Sensor (FrameManager* frameManager)
  :Range_Sensor( frameManager )
{
}


GL_Range_Sensor::~GL_Range_Sensor()
{
}


Entity* GL_Range_Sensor::Clone () const
{
        return new GL_Range_Sensor( *this ) ;
}


bool GL_Range_Sensor::DrawExplicit () const
{
        //TRACE("\nRange_Sensor::Generate_Ray_Array");
        int i,j;

        //generate inital ray array

        double newdir[3], temp[3];

        //tempvalues stores normalized rotation matrix needing scaling according to this->angle
        double tempvalues[3][3]; 
        double rayedgevalues[4][3];
        double pyramidvert[4][3];

        double angleratio;

        //can't access the protected absFrame member of Range_Sensor for some reason... so use what was
        //defined already in Range_Sensor ancestor

        //shoot rays in x direction from 0,0,0
        newdir[0] = ray_half_limit*this->absFrame.values[0][0];
        newdir[1] = ray_half_limit*this->absFrame.values[1][0];
        newdir[2] = ray_half_limit*this->absFrame.values[2][0];

        //calculate maximum extents for pre-normalized y,z directions
        angleratio = tan((this->angle)/2);
        for (i=0; i< 3; i++)
        {
                for (j=0; j < 3; j++)
                {
                        tempvalues[i][j] = angleratio * this->absFrame.values[i][j];
                }
        }

        //define ray targets in y direction
        temp[0] = newdir[0] + (lower_ray_lim_y - ray_half_limit)*tempvalues[0][1];
        temp[1] = newdir[1] + (lower_ray_lim_y - ray_half_limit)*tempvalues[1][1];
        temp[2] = newdir[2] + (lower_ray_lim_y - ray_half_limit)*tempvalues[2][1];
        //define ray targets in z direction
        rayedgevalues[0][0] = temp[0] + (lower_ray_lim_z - ray_half_limit)*tempvalues[0][2];
        rayedgevalues[0][1] = temp[1] + (lower_ray_lim_z - ray_half_limit)*tempvalues[1][2];
        rayedgevalues[0][2] = temp[2] + (lower_ray_lim_z - ray_half_limit)*tempvalues[2][2];
        normalize ( rayedgevalues[0][0], rayedgevalues[0][1], rayedgevalues[0][2] );

        //define ray targets in y direction
        temp[0] = newdir[0] + (lower_ray_lim_y - ray_half_limit)*tempvalues[0][1];
        temp[1] = newdir[1] + (lower_ray_lim_y - ray_half_limit)*tempvalues[1][1];
        temp[2] = newdir[2] + (lower_ray_lim_y - ray_half_limit)*tempvalues[2][1];
        //define ray targets in z direction
        rayedgevalues[1][0] = temp[0] + (upper_ray_lim_z - ray_half_limit)*tempvalues[0][2];
        rayedgevalues[1][1] = temp[1] + (upper_ray_lim_z - ray_half_limit)*tempvalues[1][2];
        rayedgevalues[1][2] = temp[2] + (upper_ray_lim_z - ray_half_limit)*tempvalues[2][2];
        normalize ( rayedgevalues[1][0], rayedgevalues[1][1], rayedgevalues[1][2] );

        //define ray targets in y direction
        temp[0] = newdir[0] + (upper_ray_lim_y - ray_half_limit)*tempvalues[0][1];
        temp[1] = newdir[1] + (upper_ray_lim_y - ray_half_limit)*tempvalues[1][1];
        temp[2] = newdir[2] + (upper_ray_lim_y - ray_half_limit)*tempvalues[2][1];
        //define ray targets in z direction
        rayedgevalues[2][0] = temp[0] + (upper_ray_lim_z - ray_half_limit)*tempvalues[0][2];
        rayedgevalues[2][1] = temp[1] + (upper_ray_lim_z - ray_half_limit)*tempvalues[1][2];
        rayedgevalues[2][2] = temp[2] + (upper_ray_lim_z - ray_half_limit)*tempvalues[2][2];
        normalize ( rayedgevalues[2][0], rayedgevalues[2][1], rayedgevalues[2][2] );

        //define ray targets in y direction
        temp[0] = newdir[0] + (upper_ray_lim_y - ray_half_limit)*tempvalues[0][1];
        temp[1] = newdir[1] + (upper_ray_lim_y - ray_half_limit)*tempvalues[1][1];
        temp[2] = newdir[2] + (upper_ray_lim_y - ray_half_limit)*tempvalues[2][1];
        //define ray targets in z direction
        rayedgevalues[3][0] = temp[0] + (lower_ray_lim_z - ray_half_limit)*tempvalues[0][2];
        rayedgevalues[3][1] = temp[1] + (lower_ray_lim_z - ray_half_limit)*tempvalues[1][2];
        rayedgevalues[3][2] = temp[2] + (lower_ray_lim_z - ray_half_limit)*tempvalues[2][2];
        normalize ( rayedgevalues[3][0], rayedgevalues[3][1], rayedgevalues[3][2] );

#ifndef NOGL
        //disable the lighting - this is being drawn in wireframe
        glPushAttrib( GL_ENABLE_BIT );
        glDisable( GL_LIGHTING );

        //rayedgevalues have been generated, now find the pyramid base points.
        for (i=0; i < 4; i++)
        {
                pyramidvert[i][0] = absFrame.values[0][3] + rayedgevalues[i][0] * maxrange;
                pyramidvert[i][1] = absFrame.values[1][3] + rayedgevalues[i][1] * maxrange;
                pyramidvert[i][2] = absFrame.values[2][3] + rayedgevalues[i][2] * maxrange;

                glBegin( GL_LINES ) ;
                glVertex3d( absFrame.values[0][3], absFrame.values[1][3], absFrame.values[2][3] ) ;
                glVertex3d( pyramidvert[i][0], pyramidvert[i][1], pyramidvert[i][2] ) ;
                glEnd() ;
                //TRACE("\npyramidvert %d, is %f,%f,%f", i, pyramidvert[i][0], pyramidvert[i][1], pyramidvert[i][2] );
        }

        for (i=0; i < 3; i++)
        {
                glBegin( GL_LINES ) ;
                glVertex3d( pyramidvert[i][0], pyramidvert[i][1], pyramidvert[i][2] ) ;
                glVertex3d( pyramidvert[i+1][0], pyramidvert[i+1][1], pyramidvert[i+1][2] ) ;
                glEnd() ;
        }
        glBegin( GL_LINES ) ;
        glVertex3d( pyramidvert[3][0], pyramidvert[3][1], pyramidvert[3][2] ) ;
        glVertex3d( pyramidvert[0][0], pyramidvert[0][1], pyramidvert[0][2] ) ;
        glEnd() ;
        glPopAttrib();
#endif
        return true ;
}

---