---

CToxiGLRenderer.cpp

Go to the documentation of this file.

/* 
        ---- Copyright (C) 2002  Jose Eduardo R. Mourão (eduardo_rdm@hotmail.com) ----
          
        This file is part of ToxiTea.

    ToxiTea 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.

    ToxiTea 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.

    You should have received a copy of the GNU General Public License
    along with ToxiTea; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

        For more information and updates visit: 
        http://toxitea.sourceforge.net
        or mail to: eduardo_rdm@hotmail.com

        COMPILING AND/OR USING YOU ARE ACCEPTING ALL TERMS ABOVE.
        THIS LICENSE CAN BE CHANGED ANY TIME FOR ANY REASON WITHOUT NO COMMUNICATION.
*/

#include "CToxiGLRenderer.h"

#ifdef TOXITEA_GL

CToxiGLRenderer::CToxiGLRenderer()
{
}

CToxiGLRenderer::~CToxiGLRenderer()
{
}

void CToxiGLRenderer::sampleDrawScene()
{
        glPushMatrix();
                glBegin(GL_TRIANGLES);
                        glColor3f(1.0f,0.0f,0.0f);
                        glVertex3f( 0.0f, 1.0f, 0.0f);
                        glColor3f(0.0f,1.0f,0.0f);
                        glVertex3f(-1.0f,-1.0f, 0.0f);
                        glColor3f(0.0f,0.0f,1.0f);
                        glVertex3f( 1.0f,-1.0f, 0.0f);
                glEnd();
        glPopMatrix();
}

void CToxiGLRenderer::sampleInitScene()
{

}

void CToxiGLRenderer::sampleResizeContext()
{       
        if(windowHeight==0) windowHeight=1;                                                                             
        glViewport(0,0,windowWidth,windowHeight);                                               
        glMatrixMode(GL_PROJECTION);                                    
        glLoadIdentity();                                                               
        gluPerspective(viewportAngle,(GLfloat)windowWidth/(GLfloat)windowHeight,viewportClose,viewportFar);
        glMatrixMode(GL_MODELVIEW);                                                     
        glLoadIdentity();
}

void CToxiGLRenderer::setupRenderer(int _width,int _height,int _bits)
{
        this->windowWidth       = _width;
        this->windowHeight      = _height;
        this->windowBits        = _bits;
}

bool CToxiGLRenderer::createContext()
{
        GLuint PixelFormat;

        static  PIXELFORMATDESCRIPTOR pfd=                              
        {
                sizeof(PIXELFORMATDESCRIPTOR),                          
                1,                                                                                      
                PFD_DRAW_TO_WINDOW |                                            
                PFD_SUPPORT_OPENGL |                                            
                PFD_DOUBLEBUFFER,                                                       
                PFD_TYPE_RGBA,                                                          
                windowBits,                                                                             
                0, 0, 0, 0, 0, 0,                                                       
                0,                                                                                      
                0,                                                                                      
                0,                                                                                      
                0, 0, 0, 0,                                                                     
                16,                                                                                     
                0,                                                                                      
                0,                                                                                      
                PFD_MAIN_PLANE,                                                         
                0,                                                                                      
                0, 0, 0                                                                         
        };
        
        if(!(hDC=GetDC(hWnd))) {                                                        
                MessageBox(NULL,REGISTER_DC,ERROR_TITLE,MB_OK|MB_ICONEXCLAMATION);
                return false;                                                           
        }

        if(!(PixelFormat=ChoosePixelFormat(hDC,&pfd)))  {                                                               
                MessageBox(NULL,REGISTER_PFD,ERROR_TITLE,MB_OK|MB_ICONEXCLAMATION);
                return false;                                                           
        }

        if(!SetPixelFormat(hDC,PixelFormat,&pfd)) {;                                                    
                MessageBox(NULL,REGISTER_SET_PFD,ERROR_TITLE,MB_OK|MB_ICONEXCLAMATION);
                return false;                                                   
        }

        if(!(hRC=wglCreateContext(hDC))) {;                                                     
                MessageBox(NULL,REGISTER_RC,ERROR_TITLE,MB_OK|MB_ICONEXCLAMATION);
                return false;                                                   
        }

        if(!wglMakeCurrent(hDC,hRC)) {                                                  
                MessageBox(NULL,REGISTER_SET_RC,ERROR_TITLE,MB_OK|MB_ICONEXCLAMATION);
                return false;                                                   
        }

        ShowWindow(hWnd,SW_SHOW);                                       
        SetForegroundWindow(hWnd);                                      
        SetFocus(hWnd);                                                         
        resizeContext();                                
        return true;                                                            
}


bool CToxiGLRenderer::killContext()
{
        if(hRC) {
                if (!wglMakeCurrent(NULL,NULL)) {                       
                        MessageBox(NULL,RELEASE_DC_RC,ERROR_SHOT_TITLE,MB_OK | MB_ICONINFORMATION);
                        hRC=NULL;
                        return false;
                }

                if (!wglDeleteContext(hRC)) {                                           
                        MessageBox(NULL,RELEASE_RC,ERROR_SHOT_TITLE,MB_OK | MB_ICONINFORMATION);
                        hRC=NULL;
                        return false;
                }
                return true;
        }
        return false;
}


void CToxiGLRenderer::swapBuffers()
{
        SwapBuffers(hDC);       
}

int CToxiGLRenderer::getRendererType()
{       
        return this->rendererType;                                                              
}

#endif

---