cube.cpp

此程序需要Brew sdk2.1版本以上,是关于OpenGL的手机编程.

/*=================================================================================
FILE:			cube.cpp
  
DESCRIPTION:	This file is provide as a standard sample Brew source file. 
				Please refer to this OpenGL(R)ES brew sample application as a 
				reference on how to use the standard OpenGL-ES and EGL APIs.
                          
ABSTRACT:		The cube member functions 

AUTHOR:			QUALCOMM
                        
				Copyright (c) 2004 QUALCOMM Incorporated.
					   All Rights Reserved.
					QUALCOMM Proprietary/GTDR
=================================================================================*/

/*-------------------------------------------------------------------------------*
 *                      I N C L U D E   F I L E S                                *
 *-------------------------------------------------------------------------------*/
#include "ogles_demo_02.h"

/*===========================================================================
FUNCTION: cube::KeyEvent
  
DESCRIPTION:
	All key events to the cube demo are handled in this function. 
	The number keys "1","2","3" are used for this demo to change textures.
   
PROTOTYPE:
	boolean cube::KeyEvent( uint16 wParam,MM_STATE m_eState,IMenuCtl* m_pMenuCtl)
      
PARAMETERS:
	wParam:		Event specific data.
            
DEPENDENCIES
	none
              
RETURN VALUE
	TRUE	: If the event has been processed 
	FALSE	: If the event was not vaild or processed
                
===========================================================================*/
boolean cube::KeyEvent( uint16 wParam)
{
	
	switch(wParam)
	{
		case AVK_CLR:
			if (m_pDDBitmap)  IBITMAP_Release( m_pDDBitmap );
			if (m_pIFileMgr) IFILEMGR_Release( m_pIFileMgr );
			glDeleteTextures(7, texID);
			return FALSE;
			break;

		case AVK_SELECT:
			m_auto=TRUE;
			return TRUE;
			break;
			
		case AVK_LEFT:
			m_auto=FALSE;
			m_left_right-=m_spinFactor*3;
			return TRUE;
			break;
			
		case AVK_RIGHT:
			m_auto=FALSE;
			m_left_right+=m_spinFactor*3;
			return TRUE;
			break;
			
		case AVK_UP:
			m_auto=FALSE;
			m_up_down+=m_spinFactor*3;
			return TRUE;
			break;
			
		case AVK_DOWN:
			m_auto=FALSE;
			m_up_down-=m_spinFactor*3;
			return TRUE;
			break;
			
		case AVK_1:
			m_offset = 0;
			return TRUE;
			break;
			
		case AVK_2:
			m_offset = 1;
			return TRUE;
			break;
			
		case AVK_3:
			m_offset = -1;
			return TRUE;
			break;
			
		case AVK_4:
		case AVK_5:
		case AVK_6:
		case AVK_7:
		case AVK_8:
		case AVK_9:
		case AVK_STAR:
		case AVK_0:
		case AVK_POUND:
			
		default:
			return TRUE;
			break;
	}

	return FALSE;
	
}


/*===========================================================================
FUNCTION: cube::LoadTextures
  
DESCRIPTION:
	All textures for the cube are loaded using this function. 
   
PROTOTYPE:
	void cube::LoadTextures()
      
PARAMETERS:
	pIShell	: pointer to the IShell Interface object
            
DEPENDENCIES
	none
              
RETURN VALUE
	none
                
===========================================================================*/
void cube::LoadTextures(IShell *pIShell)
{
	
	int i;

	if (!isLoaded)
	{
		
		DBGPRINTF("_X_LOADTEXTURE __BEGIN");

		for(i=0;i<7;i++)
		{
			m_images[i].m_pIShell = pIShell;

			DBGPRINTF("_X_LOADTEXTURE __NEW_TGA=%d",i);
		}
		
		DBGPRINTF("_X_LOADTEXTURE __ALL created ");

		m_images[0].Load("ogles_demo_02_t0.tga"); // box texture
		DBGPRINTF("_X_LOADTEXTURE __0 loaded ");
		
		m_images[1].Load("ogles_demo_02_t1.tga"); // photo textures
		DBGPRINTF("_X_LOADTEXTURE __1 loaded ");
		m_images[2].Load("ogles_demo_02_t1.tga");
		DBGPRINTF("_X_LOADTEXTURE __2 loaded ");
		m_images[3].Load("ogles_demo_02_t2.tga");
		DBGPRINTF("_X_LOADTEXTURE __3 loaded ");
		m_images[4].Load("ogles_demo_02_t2.tga");
		DBGPRINTF("_X_LOADTEXTURE __4 loaded ");
		m_images[5].Load("ogles_demo_02_t3.tga");
		DBGPRINTF("_X_LOADTEXTURE __5 loaded ");
		m_images[6].Load("ogles_demo_02_t3.tga");
		DBGPRINTF("_X_LOADTEXTURE __6 loaded ");
		
		isLoaded = TRUE;
		m_offset = 1;

		glGenTextures(7, texID);

		for (int j=0;j <7;j++)
		{
			glBindTexture(GL_TEXTURE_2D, texID[j]);
			glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
			glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
			glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
			glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
			glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
			
			glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

			glTexImage2D(GL_TEXTURE_2D, 
				0, 
				m_images[j].GetDataFormat(),
				m_images[j].GetWidth(), 
				m_images[j].GetHeight(),
				0, 
				m_images[j].GetDataFormat(), 
				m_images[j].GetDataType(),
				m_images[j].GetData());
		}
	}

	DBGPRINTF("_X_LOADTEXTURE __COMPLETE___ ");
	DBGPRINTF("_X_LOADTEXTURE __COMPLETE___ ");
	
}

/*===========================================================================
FUNCTION: cube::Init
  
DESCRIPTION:
	The init function for cube class. The default constructor is not valid. 
   
PROTOTYPE:
	cube::cube(AEEApplet applet)
      
PARAMETERS:
	applet:  handle to applet
            
DEPENDENCIES
	Application must be created first
              
RETURN VALUE
	none
                
===========================================================================*/
void cube::Init(AEEApplet* applet)
{
    int v;// = ITOX(2);

	//DBGPRINTF("_X_cube __CONSTRUCTOR_START___ ");
	
	GLint _vertices[72]= {
			// bottom
		    -ITOX(2), -ITOX(2), ITOX(2),
			-ITOX(2), -ITOX(2), -ITOX(2),
			ITOX(2),  -ITOX(2), -ITOX(2),
			ITOX(2),  -ITOX(2), ITOX(2),
			// top
			-ITOX(2), ITOX(2), ITOX(2),
			ITOX(2),  ITOX(2), ITOX(2),
			ITOX(2),  ITOX(2), -ITOX(2),
			-ITOX(2), ITOX(2), -ITOX(2),
			// left
			-ITOX(2), -ITOX(2), -ITOX(2),
			-ITOX(2), -ITOX(2), ITOX(2),
			-ITOX(2), ITOX(2), ITOX(2),
			-ITOX(2), ITOX(2), -ITOX(2),
			//right
			ITOX(2), -ITOX(2), ITOX(2),
			ITOX(2), -ITOX(2), -ITOX(2),
			ITOX(2), ITOX(2), -ITOX(2),
			ITOX(2), ITOX(2), ITOX(2),
			// front
			-ITOX(2), -ITOX(2), ITOX(2),
			ITOX(2),  -ITOX(2), ITOX(2),
			ITOX(2),  ITOX(2), ITOX(2),
			-ITOX(2), ITOX(2), ITOX(2),
			// back
			ITOX(2),  -ITOX(2), -ITOX(2),
			-ITOX(2), -ITOX(2), -ITOX(2),
			-ITOX(2), ITOX(2), -ITOX(2),
			ITOX(2),  ITOX(2), -ITOX(2) };
				
	GLubyte _indices[24] = {
			0, 1, 2, 3,
			4, 5, 6, 7,
			8, 9, 10, 11,
			12, 13, 14, 15,
			16, 17, 18, 19,
			20, 21, 22, 23 };
			
	GLint _colors[96] = {
			// bottom
			ITOX(0), ITOX(0), ITOX(1), ITOX(33),
			ITOX(0), ITOX(0), ITOX(0), ITOX(0),
			ITOX(1), ITOX(0), ITOX(0), ITOX(33),
			ITOX(1), ITOX(0), ITOX(1), ITOX(67),
			// top
			ITOX(0), ITOX(1), ITOX(1), ITOX(67),
			ITOX(1), ITOX(1), ITOX(1), ITOX(1),
			ITOX(1), ITOX(1), ITOX(0), ITOX(67),
			ITOX(1), ITOX(1), ITOX(0), ITOX(67),
			// left
			ITOX(0), ITOX(0), ITOX(0), ITOX(0),
			ITOX(0), ITOX(0), ITOX(1), ITOX(33),
			ITOX(0), ITOX(1), ITOX(1), ITOX(67),
			ITOX(1), ITOX(1), ITOX(0), ITOX(67),
			//right
			ITOX(1), ITOX(0), ITOX(1), ITOX(67),
			ITOX(1), ITOX(0), ITOX(0), ITOX(33),
			ITOX(1), ITOX(1), ITOX(0), ITOX(67),
			ITOX(1), ITOX(1), ITOX(1), ITOX(1),
			// front
			ITOX(0), ITOX(0), ITOX(1), ITOX(33),
			ITOX(1), ITOX(0), ITOX(1), ITOX(67),
			ITOX(1), ITOX(1), ITOX(1), ITOX(1),
			ITOX(0), ITOX(1), ITOX(1), ITOX(67),
			// back
			ITOX(1), ITOX(0), ITOX(0), ITOX(33),
			ITOX(0), ITOX(0), ITOX(0), ITOX(0),
			ITOX(1), ITOX(1), ITOX(0), ITOX(67),
			ITOX(1), ITOX(1), ITOX(0), ITOX(67) };
				
	GLshort _texCoords[48] = {
			0, 0, 1, 0, 1, 1, 0, 1,
			0, 0, 1, 0, 1, 1, 0, 1,
			0, 0, 1, 0, 1, 1, 0, 1,
			0, 0, 1, 0, 1, 1, 0, 1,
			0, 0, 1, 0, 1, 1, 0, 1,
			0, 0, 1, 0, 1, 1, 0, 1	};

	DBGPRINTF("_X_cube __CONSTRUCTOR_MEMCPY___ ");

	for (v=0;v<72;v++)
	{
		vertices[v] = _vertices[v];
	}

	for (v=0;v<24;v++)
	{
		indices[v] = _indices[v];
	}

	for (v=0;v<96;v++)
	{
		colors[v] = _colors[v];
	}

	for (v=0;v<48;v++)
	{
		texCoords[v] = _texCoords[v];
	}

	//DBGPRINTF("_X_cube __CONSTRUCTOR_MEMCPY_COMPLETE___ ");
	
	m_offset = 1;
#ifdef AEE_SIMULATOR
	m_spinFactor = 1;
#else
   m_spinFactor = 1;
#endif
	counter=0;
	isLoaded = FALSE;
	m_applet = applet;
	m_auto = TRUE;
								
}


/*===========================================================================
FUNCTION: cube::~cube
  
DESCRIPTION:
	The cube default deconstructor.  
   
PROTOTYPE:
	cube::~cube()
      
PARAMETERS:
	none
            
DEPENDENCIES
	none
              
RETURN VALUE
	none
                
===========================================================================*/
cube::~cube()
{
	FreeData();	
}


/*===========================================================================
FUNCTION: cube::FreeData
  
DESCRIPTION:
	This function free the data of textures
   
PROTOTYPE:
	cube::FreeData()
      
PARAMETERS:
	none
            
DEPENDENCIES
	none
              
RETURN VALUE
	none
                
===========================================================================*/
void cube::FreeData( void )
{

	glDeleteTextures(7, texID);
	
	for (int i=0; i<7; i++)
	{
		m_images[i].FreeData();
	}
}

/*===========================================================================
FUNCTION: cube::Render
  
DESCRIPTION:
	The rendering routine for the cube classe. Draws a 3D cube.  
   
PROTOTYPE:
	void cube::Render()
      
PARAMETERS:
	none
            
DEPENDENCIES
	none
              
RETURN VALUE
	none
                
===========================================================================*/
void cube::Render()
{

	int index=0;

	glEnable( GL_DEPTH_TEST );
	glEnable( GL_CULL_FACE );
	glCullFace(GL_BACK);

	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	glPushMatrix();

	glLoadIdentity();
	glTranslatex( 0,	0,	ITOX(-15));


	m_pos1 = ITOX(counter )+ITOX(m_left_right);
	m_pos2 = ITOX(counter )+ITOX(m_up_down);

	if (m_auto)
	{
		counter+=m_spinFactor;
		glRotatex(m_pos1, 0, ITOX(2), 0);
		glRotatex(m_pos2, ITOX(3), ITOX(1), ITOX(1));
	}
	else
	{
		glRotatex(m_pos1, 0, ITOX(2), 0);
		glRotatex(m_pos2, ITOX(3), ITOX(1), ITOX(1));
	}

	glEnableClientState(GL_VERTEX_ARRAY);
	glEnableClientState(GL_COLOR_ARRAY);

	if (m_offset != -1)
	{
		glEnable(GL_TEXTURE_2D);
		glEnableClientState(GL_TEXTURE_COORD_ARRAY);
		glTexCoordPointer(2, GL_SHORT, 0, texCoords);
	}

	glColorPointer(4, GL_FIXED, 0, colors);
	glVertexPointer(3, GL_FIXED, 0, vertices);


	for (int side = 0; side < 6; ++side)
	{
		if (m_offset==0) 
			index=0;
		else 
			index=side+m_offset;						

		if (m_offset != -1)
			glBindTexture(GL_TEXTURE_2D, texID[index]);
		else
			glShadeModel( GL_SMOOTH );

		glDrawElements(GL_TRIANGLE_FAN, 4, GL_UNSIGNED_BYTE, indices + side * 4);
	}	
	
	glDisableClientState(GL_VERTEX_ARRAY);
	glDisableClientState(GL_COLOR_ARRAY);
	glDisableClientState(GL_TEXTURE_COORD_ARRAY);
	glDisable(GL_TEXTURE_2D);

	glPopMatrix();
		  
}