basic/geometry/IGS/IGS_Image.cpp

Go to the documentation of this file.

#include <assert.h>
#include "synchronization/guid.h"
#include "IGS_Image.h"
#include <stdio.h>

#include "opengl/glos.h"
#include <gl/gl.h>



//=============================================================================
// Constructor
//
// Description: constructs an empty image with no pixels
//=============================================================================
IGS_Image::IGS_Image():
        guid( GuidGenerator::GenerateNewGuid() ),
        semaphore( guid ),
        format( GL_LUMINANCE ),
        posX( 0 ),
        poxY( 0 ),
        sizeX( 0 ),
        sizeY( 0 ),
        type( GL_BYTE )
{
}

//=============================================================================
// Copy Constructor
//
// Description: copies the image object
//=============================================================================
IGS_Image::IGS_Image( const IGS_Image& right ):
        guid( GuidGenerator::GenerateNewGuid() ),               //these must not be copied
        semaphore( guid )
{
}

//=============================================================================
// Destructor
//
// Description: cleans up the object
//=============================================================================
IGS_Image::~IGS_Image()
{
}

//=============================================================================
// ComputeIndex
//
// Description: computes the pixel index for a given XY position
//=============================================================================
int IGS_Image::ComputeIndex( const int x, const int y ) const
{
        assert( x < this->sizeX );
        assert( y < this->sizeY );
        assert( x >= 0 );
        assert( y >= 0 );
        return y * this->sizeX + x;
}

//=============================================================================
// ComputeIndex
//
// Description: computes the pixel index for a given XY position
//=============================================================================
int IGS_Image::ComputeMaxIndex() const
{
        return this->sizeX * this->sizeY;
}

//=============================================================================
// Draw
//
// Description: draws the image to the screen
//=============================================================================
void IGS_Image::Draw() const
{
/*      int i;
        int width = this->sizeX;
        int height = this->sizeY;
        for( i = 0; i < width * height; i++ )
        {
                char* pixel= ( char* )pixels + i;
                if( *pixel != 0x00 )
                {
                        int i = 0;
                }
        }

        GLenum errorcode;
        errorcode = glGetError();

        ::glBindTexture( GL_TEXTURE_2D, 1 );
        errorcode = glGetError();
        ::glPixelStorei (GL_UNPACK_ALIGNMENT, 1); 
        errorcode = glGetError();
        glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
        errorcode = glGetError();
        glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
        errorcode = glGetError();
        glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        errorcode = glGetError();
        glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        errorcode = glGetError();
        glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL); 
        errorcode = glGetError();
        glTexImage2D 
        (
                GL_TEXTURE_2D, 
                0, 
                GL_RGB, 
//              this->sizeX, 
//              this->sizeY, 
                256,                            //width
                256,                            //height
                0, 
                GL_GREEN, 
                GL_BYTE, 
                this->pixels
        );
        errorcode = glGetError();

        glColor3f( 1.0, 1.0, 1.0 );
        glBegin( GL_POLYGON );
                glTexCoord2f (0.0, 0.0);
                glVertex2f( 0, 0 );
                glTexCoord2f (1.0, 0.0);
                glVertex2f( 2, 0 );
                glTexCoord2f (1.0, 1.0);
                glVertex2f( 2, -2 );
                glTexCoord2f (0.0, 1.0);
                glVertex2f( 0, -2 );
        glEnd();
*/

        if( ( this->sizeX == 0 ) || ( this->sizeY == 0 ) )
        {
                return;
        }

        GLenum errorcode;
        errorcode = glGetError();

        int depth = 0;

        ::glDepthFunc( GL_ALWAYS );

        ::glMatrixMode( GL_PROJECTION );
        errorcode = ::glGetError();
        assert( errorcode == GL_NO_ERROR );

        ::glPushMatrix();
        errorcode = ::glGetError();
        assert( errorcode == GL_NO_ERROR );

        ::glLoadIdentity();
        errorcode = ::glGetError();
        assert( errorcode == GL_NO_ERROR );

        ::glOrtho( 0, this->sizeX, 0, this->sizeY, 100, -100 );
        errorcode = ::glGetError();
        assert( errorcode == GL_NO_ERROR );

        ::glMatrixMode( GL_MODELVIEW );
        errorcode = ::glGetError();
        assert( errorcode == GL_NO_ERROR );

        ::glPushMatrix();
        errorcode = ::glGetError();
        assert( errorcode == GL_NO_ERROR );

        ::glLoadIdentity();
        errorcode = ::glGetError();
        assert( errorcode == GL_NO_ERROR );

        ::glRasterPos2d( static_cast< double >( this->posX ), static_cast< double >( this->poxY ) );
        errorcode = ::glGetError();
        assert( errorcode == GL_NO_ERROR );

        //::glDrawBuffer( GL_BACK_LEFT );
        //::glDrawBuffer( GL_BACK_RIGHT );
        //::glDrawBuffer( GL_FRONT );                   //ok
        errorcode = ::glGetError();
        assert( errorcode == GL_NO_ERROR );
        //GL_INVALID_ENUM                   0x0500
        //GL_INVALID_OPERATION              0x0502

        GLenum formatToUse = this->format;
        if( format == GL_DEPTH )
        {
                formatToUse = GL_LUMINANCE;
        }

        this->semaphore.Lock();
        const void* const buffer = this->GetBuffer();
        if( buffer != NULL )
        {
                ::glDrawPixels
                ( 
                        this->sizeX, 
                        this->sizeY,
                        formatToUse,
                        this->type,
                        buffer
                );
        }
        this->semaphore.Unlock();
        errorcode = glGetError();
        assert( errorcode == GL_NO_ERROR );



        ::glPopMatrix();
        errorcode = ::glGetError();
        assert( errorcode == GL_NO_ERROR );

        ::glMatrixMode( GL_PROJECTION );
        errorcode = ::glGetError();
        assert( errorcode == GL_NO_ERROR );

        ::glPopMatrix();
        errorcode = ::glGetError();
        assert( errorcode == GL_NO_ERROR );
}

//=============================================================================
// GetSizeX
//
// Description: allows access to the image size
//=============================================================================
int IGS_Image::GetSizeX() const
{
        return this->sizeX;
}

//=============================================================================
// GetSizeY
//
// Description: allows access to the image size
//=============================================================================
int IGS_Image::GetSizeY() const
{
        return this->sizeY;
}

//=============================================================================
// GetSizeY
//
// Description: allows access to the image size
//=============================================================================
void IGS_Image::Invalidate()
{
        void*& buffer = this->GetBuffer();
        if( buffer != NULL )
        {
                delete[] buffer;
        }
}

//=============================================================================
// ScreenCapture
//
// Description: does a screen capture of this type of image
//=============================================================================
void IGS_Image::ScreenCapture()
{
        void* pixels = this->GetBuffer();
        if( pixels == NULL )
        {
                this->Initialize();
                pixels = this->GetBuffer();
                assert( pixels != NULL );
        }
        GLenum errorcode;
        errorcode = glGetError();

        ::glReadBuffer( GL_BACK );
        errorcode = glGetError();
        assert( errorcode == GL_NO_ERROR );

        GLenum formatToUse = this->format;
        if( format == GL_DEPTH )
        {
                formatToUse = GL_DEPTH_COMPONENT;
        }

        ::glReadPixels
        ( 
                this->posX, this->poxY,                 //x,y
                this->sizeX, this->sizeY,
                formatToUse,
                this->type,
                pixels
        );
        errorcode = glGetError();
        if( errorcode != GL_NO_ERROR )
        {
                assert( errorcode == GL_NO_ERROR );
                //GL_BYTE                           0x1400
                //GL_DEPTH                          0x1801
                //GL_DEPTH_COMPONENT                0x1902
                //GL_INVALID_ENUM                   0x0500
        }
}

//=============================================================================
// SetFormat
//
// Description: sets the format of the image
//=============================================================================
void IGS_Image::SetFormat( const GLenum format )
{
        this->format = format;
}

//=============================================================================
// SetPosition
//
// Description: sets the position that this image will be drawn at
//=============================================================================
void IGS_Image::SetPosition( const int x, const int y )
{
        this->posX = x;
        this->poxY = y;
}

//=============================================================================
// SetType
//
// Description: sets the type of the image
//=============================================================================
void IGS_Image::SetResolution( const int xres, const int yres )
{
        this->Invalidate();
        this->sizeX = xres;
        this->sizeY = yres;
}

//=============================================================================
// SetType
//
// Description: sets the type of the image
//=============================================================================
void IGS_Image::SetType( const GLenum type )
{
        this->type = type;
        this->Invalidate();
}

//=============================================================================
// SizeOfType
//
// Description: determines the size of a particular type for memory allocation
//=============================================================================
int IGS_Image::SizeOfType( const GLenum type )
{
        switch( type )
        {
        case GL_UNSIGNED_BYTE:
                {
                        return sizeof( GLubyte );
                }
        case GL_BYTE:
                {
                        return sizeof( GLbyte );
                }
        case GL_BITMAP:
                {
                        assert( false );                //I don't know what to do with this
                        return 0;
                }
        case GL_UNSIGNED_SHORT:
                {
                        return sizeof( GLushort );
                }
        case GL_SHORT:
                {
                        return sizeof( GLshort );
                }
        case GL_UNSIGNED_INT:
                {
                        return sizeof( GLuint );
                }
        case GL_INT:
                {
                        return sizeof( GLint );
                }
        case GL_FLOAT:
                {
                        return sizeof( GLfloat );
                }
        default:
                {
                        printf( "IGS_Image::SizeOfType - invalid type\n" );
                        assert( false );
                        return 0;
                }
        }
}
//=============================================================================
// Valid
//
// Description: determines if the image is valid
//=============================================================================
bool IGS_Image::Valid() const
{
        const void* buffer = this->GetBuffer();
        return ( buffer != NULL );
}

---