Apple Community Discussions

Oh, here it is formatted better:

//Generates textures for a game object
- (void)GenerateTextures:(Hairball::Objects)Obj
{
	CGImageRef spriteImage;
	CGContextRef spriteContext;
	GLubyte *spriteData;
	size_t	width, height;
	int texIndex = 0;
 
	
	// Creates a Core Graphics image from an image file
	switch (Obj) 
	{
		case Hairball::PLAYER:
			spriteImage = [UIImage imageNamed:@"Sprite.png"].CGImage;
			texIndex = 0;
			break;
			
		case Hairball::BACKGROUND:
			spriteImage = [UIImage imageNamed:@"BG1.png"].CGImage;
			texIndex = 1;
			break;
			
		case Hairball::HUD:
			spriteImage = [UIImage imageNamed:@"Icon.png"].CGImage;
			texIndex = 2;
			break;
			
		default:
			break;
	}
	
	// Get the width and height of the image
	width = CGImageGetWidth(spriteImage);
	height = CGImageGetHeight(spriteImage);
	
	if(spriteImage)
	{
		// Allocated memory needed for the bitmap context
		spriteData = (GLubyte *) malloc(width * height * 4);
		// Uses the bitmatp creation function provided by the Core Graphics framework. 
		spriteContext = CGBitmapContextCreate(spriteData, width, height, 8, width * 4, CGImageGetColorSpace(spriteImage), kCGImageAlphaPremultipliedLast);
		// After you create the context, you can draw the sprite image to the context.
		CGContextDrawImage(spriteContext, CGRectMake(0.0, 0.0, (CGFloat)width, (CGFloat)height), spriteImage);
		// You don't need the context at this point, so you need to release it to avoid memory leaks.
		CGContextRelease(spriteContext);
		// Bind the texture name. 
		glBindTexture(GL_TEXTURE_2D, TextureArray[texIndex]);
		// Speidfy a 2D texture image, provideing the a pointer to the image data in memory
		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, spriteData);
		// Release the image data
		free(spriteData);
	}
}
 
 
//Inits OpenGl for drawing
- (void)setupView
{		
	//Creates object Manager to handle
    ObjectMgr = new ObjectManager();
	
	//Create Objects
	GameObject* Object1 = new GameObject(Hairball::BACKGROUND, 0.0f, 0.0f, 0.0f, 0.0f, 3.2f, 3.2f);
	ObjectMgr->AddToList(Object1);
	
	GameObject* Object2 = new GameObject(Hairball::PLAYER, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f);
	ObjectMgr->AddToList(Object2);
	
 
	//Generate all textures
	glGenTextures(NUMTEXTURES, TextureArray);	// Use OpenGL ES to generate a name for the texture.
	[self GenerateTextures:Hairball::BACKGROUND];
	[self GenerateTextures:Hairball::PLAYER];
	
	//For each obj assign a texture
	std::list<GameObject*>::iterator Object = (ObjectMgr->mObjectList.begin());
	std::list<GameObject*>::iterator End = (ObjectMgr->mObjectList.end());
	
	//For each game object
	while(Object != End)
	{
		//Apply texture to each object
		switch ((*Object)->mObjectType) 
		{
			case Hairball::PLAYER:     (*Object)->mSpriteTexture = TextureArray[0]; break;
				
			case Hairball::BACKGROUND: (*Object)->mSpriteTexture = TextureArray[1]; break;
			
			case Hairball::HUD:        (*Object)->mSpriteTexture = TextureArray[2]; break;
				
			default:
				break;
		}
		++Object;
	}
	
	// Clears the view with grey
	glClearColor(0.5f, 0.5f, 0.5f, 1.0f);
 
	// Set the texture parameters to use a minifying filter and a linear filer (weighted average)
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
		
	// Enable use of the texture
	glEnable(GL_TEXTURE_2D);
	// Set a blending function to use
	glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
	// Enable blending
	glEnable(GL_BLEND);
}
 
- (void)drawView 
{
	[EAGLContext setCurrentContext:context];
	
	glBindFramebufferOES(GL_FRAMEBUFFER_OES, viewFramebuffer);
	glViewport(0, 0, backingWidth, backingHeight);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	glOrthof(-1.0f, 1.0f, -1.5f, 1.5f, -1.0f, 1.0f);
	glMatrixMode(GL_MODELVIEW);
	
	//Clear the backbuffer
	glClear(GL_COLOR_BUFFER_BIT);
	
	std::list<GameObject*>::iterator Object = (ObjectMgr->mObjectList.begin());
	std::list<GameObject*>::iterator End = (ObjectMgr->mObjectList.end());
	
	//For each game object
	while(Object != End)
	{
		// Bind the texture name.
		glBindTexture(GL_TEXTURE_2D, (*Object)->mSpriteTexture);
		
	    //apply transformations
	    glPushMatrix();
	    glTranslatef((*Object)->mPosition.x, (*Object)->mPosition.y, (*Object)->mPosition.z);
	    glRotatef((*Object)->mRotation, 0.0f, 0.0f, 1.0f);
	
	    //(*Object)->mRotation += 0.5f; //Rotate
	
	    //Get current sprites verticies
	    glVertexPointer(2, GL_FLOAT, 0, (*Object)->mSpriteVertices);
	    glEnableClientState(GL_VERTEX_ARRAY);
	    //Get current sprites tex coords
	    glTexCoordPointer(2, GL_SHORT, 0, (*Object)->mSpriteTexcoords);
	    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
	    //Render the vertex array
	    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
	
	    //pop the transformation matrix
	    glPopMatrix();
		++Object;
	}
	
	glBindRenderbufferOES(GL_RENDERBUFFER_OES, viewRenderbuffer);
	[context presentRenderbuffer:GL_RENDERBUFFER_OES];
}
 
 

 	// Set the texture parameters to use a minifying filter and a linear filer (weighted average)
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	// Enable use of the texture
	glEnable(GL_TEXTURE_2D);
	// Set a blending function to use
	glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
	// Enable blending
	glEnable(GL_BLEND);