VertexArray.m (revision 100)

To get this branch, use:

bzr branch
/browse/iphone/common


//
//  VertexArray.m
//
//  Created by döme on 28.07.2009.
//

/*
 * Copyright (c) 2009 Doemoetoer Gulyas.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#import <OpenGLES/ES2/gl.h>
#import <OpenGLES/ES2/glext.h>

#import <malloc/malloc.h>

#import "VertexArray.h"

#import "ESShader.h"

@implementation VertexArray

static inline size_t _sizeofFormat(int format)
{
	switch(format)
	{
		case VA_FORMAT_POS3F:
			return sizeof(Position3f);
		case VA_FORMAT_POS3F_TEX2F:
			return sizeof(PositionTex3f2f);
		case VA_FORMAT_POS3F_COL4B_TEX2F:
			return sizeof(PositionColorTex3f4b2f);
		case VA_FORMAT_POS3F_NORMAL3F_TEX2F:
			return sizeof(PositionNormalTex3f3f2f);
		default:
			return -1;
	}
}

- (size_t) sizeofFormat
{
	return _sizeofFormat(vertexFormat);
}

+ (VertexArray*) coneWithFraction: (float) fraction
{
	VertexArray* va = [[VertexArray alloc] init];

	size_t divisions = 72;
	
	
	
	va->numVertices = (divisions+1)*2;
	PositionNormalTex3f3f2f* vertices = calloc(va->numVertices,sizeof(*vertices));
	va->_vertices = vertices;
	va->vertexFormat = VA_FORMAT_POS3F_NORMAL3F_TEX2F;

	for (size_t i = 0; i <= divisions; ++i)
	{
		float t = (float)i/(float)divisions;
		float alpha = t*2.0*M_PI;
		float sina = sinf(alpha);
		float cosa = cosf(alpha);
		
		vertices[2*i].pos[0] = cosa;
		vertices[2*i].pos[1] = sina;
		vertices[2*i].pos[2] = 0.0;
		vertices[2*i+1].pos[0] = (1.0-fraction)*cosa;
		vertices[2*i+1].pos[1] = (1.0-fraction)*sina;
		vertices[2*i+1].pos[2] = fraction;

		vertices[2*i].normal[0] = cosa*M_SQRT1_2;
		vertices[2*i].normal[1] = sina*M_SQRT1_2;
		vertices[2*i].normal[2] = M_SQRT1_2;
		vertices[2*i+1].normal[0] = cosa*M_SQRT1_2;
		vertices[2*i+1].normal[1] = sina*M_SQRT1_2;
		vertices[2*i+1].normal[2] = M_SQRT1_2;

		vertices[2*i].texcoord[0] = 1.0-t;
		vertices[2*i].texcoord[1] = 0.0;
		vertices[2*i+1].texcoord[0] = 1.0-t;
		vertices[2*i+1].texcoord[1] = 1.0;
	}
	
	va->mode = GL_TRIANGLE_STRIP;

	return va;
}

static VertexArray* cylinderva = nil;

+ (VertexArray*) sharedCylinder
{
	VertexArray* va = cylinderva;
	if (!va)
	{
		va = [[VertexArray alloc] init];
		cylinderva = va;
		size_t divisions = 72;
		
		va->numVertices = (divisions+1)*2;
		PositionNormalTex3f3f2f* vertices = calloc(va->numVertices,sizeof(*vertices));
		va->_vertices = vertices;
		va->vertexFormat = VA_FORMAT_POS3F_NORMAL3F_TEX2F;
		
		for (size_t i = 0; i <= divisions; ++i)
		{
			float t = (float)i/(float)divisions;
			float alpha = t*2.0*M_PI;
			float sina = sinf(alpha);
			float cosa = cosf(alpha);
			
			vertices[2*i].pos[0] = cosa;
			vertices[2*i].pos[1] = sina;
			vertices[2*i].pos[2] = 1.0;
			vertices[2*i+1].pos[0] = cosa;
			vertices[2*i+1].pos[1] = sina;
			vertices[2*i+1].pos[2] = -1.0;

			vertices[2*i].normal[0] = cosa;
			vertices[2*i].normal[1] = sina;
			vertices[2*i].normal[2] = 0.0;
			vertices[2*i+1].normal[0] = cosa;
			vertices[2*i+1].normal[1] = sina;
			vertices[2*i+1].normal[2] = 0.0;

			vertices[2*i].texcoord[0] = t;
			vertices[2*i].texcoord[1] = 0.0;
			vertices[2*i+1].texcoord[0] = t;
			vertices[2*i+1].texcoord[1] = 1.0;
		}
	}
	
	va->mode = GL_TRIANGLE_STRIP;
	return va;
}

static VertexArray* diskva = nil;

+ (VertexArray*) sharedDisk
{
	VertexArray* va = diskva;
	if (!va)
	{
		va = [[VertexArray alloc] init];
		diskva = va;
		
		unsigned divisions = 72;
		
		va->numVertices = (divisions+1) + 1;
		PositionNormalTex3f3f2f* vertices = calloc(va->numVertices,sizeof(*vertices));
		va->_vertices = vertices;
		va->vertexFormat = VA_FORMAT_POS3F_NORMAL3F_TEX2F;

		vertices->pos[0] = 0.0;
		vertices->pos[1] = 0.0;
		vertices->pos[2] = 0.0;
		vertices->normal[0] = 0.0;
		vertices->normal[1] = 0.0;
		vertices->normal[2] = 1.0;
		vertices->texcoord[0] = 0.5;
		vertices->texcoord[1] = 0.5;
		for (size_t i = 0; i <= divisions; ++i)
		{
			float t = (float)i/(float)divisions;
			float alpha = t*2.0*M_PI;
			float sina = sinf(alpha);
			float cosa = cosf(alpha);
			
			vertices[i+1].pos[0] = cosa;
			vertices[i+1].pos[1] = sina;
			vertices[i+1].pos[2] = 0.0;

			vertices[i+1].normal[0] = 0.0;
			vertices[i+1].normal[1] = 0.0;
			vertices[i+1].normal[2] = 1.0;

			vertices[i+1].texcoord[0] = 0.5 + 0.5*cosa;
			vertices[i+1].texcoord[1] = 0.5 - 0.5*sina;
		}
	}
	
	va->mode = GL_TRIANGLE_FAN;
	return va;
}

static VertexArray* quadva = nil;

+ (VertexArray*) sharedQuad
{
	VertexArray* va = quadva;
	if (!va)
	{
		va = [[VertexArray alloc] init];
		quadva = va;
		
		va->numVertices = 4;
		PositionNormalTex3f3f2f* vertices = calloc(va->numVertices, sizeof(*vertices));
		va->_vertices = vertices;
		va->vertexFormat = VA_FORMAT_POS3F_NORMAL3F_TEX2F;
		/*
		va->numIndices = 4;
		va->indices = calloc(sizeof(*va->indices), va->numIndices);
		for (size_t i = 0; i < 4; ++i)
			va->indices[i] = i;
		*/

		vertices[0].pos[0] = 1.0;
		vertices[0].pos[1] = -1.0;
		vertices[0].normal[2] = 1.0;
		vertices[0].texcoord[0] = 1.0;
		vertices[0].texcoord[1] = 0.0;
		vertices[1].pos[0] = 1.0;
		vertices[1].pos[1] = 1.0;
		vertices[1].normal[2] = 1.0;
		vertices[1].texcoord[0] = 1.0;
		vertices[1].texcoord[1] = 1.0;
		vertices[3].pos[0] = -1.0;
		vertices[3].pos[1] = 1.0;
		vertices[3].normal[2] = 1.0;
		vertices[3].texcoord[0] = 0.0;
		vertices[3].texcoord[1] = 1.0;
		vertices[2].pos[0] = -1.0;
		vertices[2].pos[1] = -1.0;
		vertices[2].normal[2] = 1.0;
		vertices[2].texcoord[0] = 0.0;
		vertices[2].texcoord[1] = 0.0;
	}
	
	va->mode = GL_TRIANGLE_STRIP;
	return va;
}

static VertexArray* sphereva = nil;

+ (VertexArray*) sharedSphere
{
	VertexArray* va = sphereva;
	if (!va)
	{
		va = [[VertexArray alloc] init];
		sphereva = va;
		
		unsigned londivisions = 72;
		unsigned latdivisions = 36;
		
		va->numVertices = (londivisions+1)*(latdivisions+1);
		PositionNormalTex3f3f2f* vertices = calloc(va->numVertices,sizeof(*vertices));
		va->_vertices = vertices;
		va->vertexFormat = VA_FORMAT_POS3F_NORMAL3F_TEX2F;
		
		int soff = (latdivisions+1);

		for (size_t i = 0; i <= londivisions; ++i)
		{
			float ti = (float)i/(float)londivisions;
			float alpha = ti*2.0*M_PI;
			float sini = sinf(alpha);
			float cosi = cosf(alpha);
			for (size_t j = 0; j <= latdivisions; ++j)
			{
				float tj = (float)j/(float)latdivisions;
				float aj = tj*M_PI;
				float sinj = sinf(aj);
				float cosj = cosf(aj);
				
				vertices[i*soff + j].pos[0] = sinj*cosi;
				vertices[i*soff + j].pos[1] = sinj*sini;
				vertices[i*soff + j].pos[2] = cosj;

				vertices[i*soff + j].normal[0] = sinj*cosi;
				vertices[i*soff + j].normal[1] = sinj*sini;
				vertices[i*soff + j].normal[2] = cosj;

				vertices[i*soff + j].texcoord[0] = ti;
				vertices[i*soff + j].texcoord[1] = tj;
			}
		}

		va->numIndices = (londivisions)*(latdivisions+1)*2;
		va->indices = calloc(2*va->numIndices,sizeof(*va->indices));
		
		uint16_t* indices = va->indices;
		
		for (size_t i = 0; i < londivisions; ++i)
		{
			for (size_t j = 0; j <= latdivisions; ++j)
			{
				int x0 = i*soff + j;
				int x1 = (i+1)*soff + j;
				
				indices[2*(i*soff + j) + 0] = x1;
				indices[2*(i*soff + j) + 1] = x0;
			}
		}
		
	}

	
	
	va->mode = GL_TRIANGLE_STRIP;
	return va;
}

static VertexArray* xsemisphereva = nil;

+ (VertexArray*) sharedXSemiSphere
{
	VertexArray* va = xsemisphereva;
	if (!va)
	{
		va = [[VertexArray alloc] init];
		xsemisphereva = va;
		
		
		unsigned londivisions = 36;
		unsigned latdivisions = 36;
		
		va->numVertices = (londivisions+1)*(latdivisions+1);
		PositionNormalTex3f3f2f* vertices = calloc(va->numVertices,sizeof(*vertices));
		va->_vertices = vertices;
		va->vertexFormat = VA_FORMAT_POS3F_NORMAL3F_TEX2F;
		
		int soff = (latdivisions+1);

		for (size_t i = 0; i <= londivisions; ++i)
		{
			float ti = 0.5*(float)i/(float)londivisions - 0.25;
			float alpha = ti*2.0*M_PI;
			float sini = sinf(alpha);
			float cosi = cosf(alpha);
			for (size_t j = 0; j <= latdivisions; ++j)
			{
				float tj = (float)j/(float)latdivisions;
				float aj = tj*M_PI;
				float sinj = sinf(aj);
				float cosj = cosf(aj);
				
				vertices[i*soff + j].pos[0] = sinj*cosi;
				vertices[i*soff + j].pos[1] = sinj*sini;
				vertices[i*soff + j].pos[2] = cosj;

				vertices[i*soff + j].normal[0] = sinj*cosi;
				vertices[i*soff + j].normal[1] = sinj*sini;
				vertices[i*soff + j].normal[2] = cosj;

				vertices[i*soff + j].texcoord[0] = ti;
				vertices[i*soff + j].texcoord[1] = tj;
			}
		}

		va->numIndices = (londivisions)*(latdivisions+1)*2;
		va->indices = calloc(2*va->numIndices,sizeof(*va->indices));
		
		uint16_t* indices = va->indices;
		
		for (size_t i = 0; i < londivisions; ++i)
		{
			for (size_t j = 0; j <= latdivisions; ++j)
			{
				int x0 = i*soff + j;
				int x1 = (i+1)*soff + j;
				
				indices[2*(i*soff + j) + 0] = x1;
				indices[2*(i*soff + j) + 1] = x0;
			}
		}
		
	}

	
	
	va->mode = GL_TRIANGLE_STRIP;
	return va;
}

+ (void) releaseSharedObjects
{
	cylinderva = nil;
	diskva = nil;
	quadva = nil;
	sphereva = nil;
	xsemisphereva = nil;
}


- (id) init
{
	if (!(self = [super init]))
		return nil;

	
	usageHint = GL_STATIC_DRAW;
	vertexFormat = VA_FORMAT_POS3F_NORMAL3F_TEX2F;
	
	float osVersion = [[[UIDevice currentDevice] systemVersion] floatValue];
	
	if (osVersion >= 4.0f)
		useVAO = YES;

	needsVertexBufferUpdate = YES;
	needsIndexBufferUpdate = YES;

	return self;
}


- (void) dealloc
{
	if (vertexBufferName)
		glDeleteBuffers(1, &vertexBufferName);
	if (indexBufferName)
		glDeleteBuffers(1, &indexBufferName);
	if (vertexArrayObject)
		glDeleteVertexArraysOES(1, &vertexArrayObject);
	
	if (_vertices)
		free(_vertices);

	if (indices)
		free(indices);

}

- (id) initWithCoder: (NSCoder*) coder
{
	if (!(self = [super init]))
		return nil;

	usageHint = [coder decodeIntegerForKey: @"usageHint"];
	mode = [coder decodeIntegerForKey: @"mode"];
	vertexFormat = [coder decodeIntegerForKey: @"vertexFormat"];
	numVertices = [coder decodeIntegerForKey: @"numVertices"];
	numIndices = [coder decodeIntegerForKey: @"numIndices"];
	
	_vertices = calloc(_sizeofFormat(vertexFormat),numVertices);
	indices = calloc(sizeof(*indices),numIndices);
	
	memcpy(_vertices, [[coder decodeObjectForKey: @"vertices"] bytes], _sizeofFormat(vertexFormat)*numVertices);
	memcpy(indices, [[coder decodeObjectForKey: @"indices"] bytes], sizeof(*indices)*numIndices);

	float osVersion = [[[UIDevice currentDevice] systemVersion] floatValue];
	
	if (osVersion >= 4.0f)
		useVAO = YES;

	needsVertexBufferUpdate = YES;
	needsIndexBufferUpdate = YES;

	return self;
}

- (void) encodeWithCoder: (NSCoder*) coder
{
	[coder encodeInteger: usageHint forKey: @"usageHint"];
	[coder encodeInteger: mode forKey: @"mode"];
	[coder encodeInteger: vertexFormat forKey: @"vertexFormat"];
	[coder encodeInteger: numVertices forKey: @"numVertices"];
	[coder encodeInteger: numIndices forKey: @"numIndices"];
	[coder encodeObject: [NSData dataWithBytes: _vertices length: _sizeofFormat(vertexFormat)*numVertices] forKey: @"vertices"];
	[coder encodeObject: [NSData dataWithBytes: indices length: sizeof(*indices)*numIndices] forKey: @"indices"];
}

- (void) setupArrayState
{
	glBindBuffer(GL_ARRAY_BUFFER, vertexBufferName);
	
	if (indexBufferName)
		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBufferName);
	else
		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

	EAGLRenderingAPI api = [[EAGLContext currentContext] API];

	switch(api)
	{
		case kEAGLRenderingAPIOpenGLES2:
			switch (vertexFormat)
			{
				case VA_FORMAT_POS3F_NORMAL3F_TEX2F:
					glVertexAttribPointer(POSITION_ATTRIB_INDEX, 3, GL_FLOAT, GL_FALSE, sizeof(PositionNormalTex3f3f2f), (void*)offsetof(PositionNormalTex3f3f2f,pos));
					glVertexAttribPointer(NORMAL_ATTRIB_INDEX, 3, GL_FLOAT, GL_FALSE, sizeof(PositionNormalTex3f3f2f), (void*)offsetof(PositionNormalTex3f3f2f,normal));
					glVertexAttribPointer(TEXCOORD_ATTRIB_INDEX, 2, GL_FLOAT, GL_FALSE, sizeof(PositionNormalTex3f3f2f), (void*)offsetof(PositionNormalTex3f3f2f,texcoord));

					glEnableVertexAttribArray(POSITION_ATTRIB_INDEX);
					glEnableVertexAttribArray(NORMAL_ATTRIB_INDEX);
					glDisableVertexAttribArray(COLOR_ATTRIB_INDEX);
					glEnableVertexAttribArray(TEXCOORD_ATTRIB_INDEX);

					break;
				case VA_FORMAT_POS3F_COL4B_TEX2F:
					glVertexAttribPointer(POSITION_ATTRIB_INDEX, 3, GL_FLOAT, GL_FALSE, sizeof(PositionColorTex3f4b2f), (void*)offsetof(PositionColorTex3f4b2f,pos));
					glVertexAttribPointer(COLOR_ATTRIB_INDEX, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(PositionColorTex3f4b2f), (void*)offsetof(PositionColorTex3f4b2f,color));
					glVertexAttribPointer(TEXCOORD_ATTRIB_INDEX, 2, GL_FLOAT, GL_FALSE, sizeof(PositionColorTex3f4b2f), (void*)offsetof(PositionColorTex3f4b2f,texcoord));

					glEnableVertexAttribArray(POSITION_ATTRIB_INDEX);
					glDisableVertexAttribArray(NORMAL_ATTRIB_INDEX);
					glEnableVertexAttribArray(COLOR_ATTRIB_INDEX);
					glEnableVertexAttribArray(TEXCOORD_ATTRIB_INDEX);

					break;
				case VA_FORMAT_POS3F_TEX2F:
					glVertexAttribPointer(POSITION_ATTRIB_INDEX, 3, GL_FLOAT, GL_FALSE, sizeof(PositionTex3f2f), (void*)offsetof(PositionTex3f2f,pos));
					glVertexAttribPointer(TEXCOORD_ATTRIB_INDEX, 2, GL_FLOAT, GL_FALSE, sizeof(PositionTex3f2f), (void*)offsetof(PositionTex3f2f,texcoord));

					glEnableVertexAttribArray(POSITION_ATTRIB_INDEX);
					glDisableVertexAttribArray(NORMAL_ATTRIB_INDEX);
					glDisableVertexAttribArray(COLOR_ATTRIB_INDEX);
					glEnableVertexAttribArray(TEXCOORD_ATTRIB_INDEX);

					break;
				case VA_FORMAT_POS3F:
					glVertexAttribPointer(POSITION_ATTRIB_INDEX, 3, GL_FLOAT, GL_FALSE, sizeof(Position3f), (void*)offsetof(Position3f,pos));

					glEnableVertexAttribArray(POSITION_ATTRIB_INDEX);
					glDisableVertexAttribArray(NORMAL_ATTRIB_INDEX);
					glDisableVertexAttribArray(COLOR_ATTRIB_INDEX);
					glDisableVertexAttribArray(TEXCOORD_ATTRIB_INDEX);

					break;
				default:
					assert(0);
			}
			break;

		case kEAGLRenderingAPIOpenGLES1:
			switch (vertexFormat)
			{
				case VA_FORMAT_POS3F_NORMAL3F_TEX2F:
					glNormalPointer(GL_FLOAT, sizeof(PositionNormalTex3f3f2f), (void*)offsetof(PositionNormalTex3f3f2f,normal));
					glTexCoordPointer(2, GL_FLOAT, sizeof(PositionNormalTex3f3f2f), (void*)offsetof(PositionNormalTex3f3f2f,texcoord));
					glVertexPointer(3, GL_FLOAT, sizeof(PositionNormalTex3f3f2f), (void*)offsetof(PositionNormalTex3f3f2f,pos));
					
					glEnableClientState(GL_VERTEX_ARRAY);
					glEnableClientState(GL_NORMAL_ARRAY);
					glDisableClientState(GL_COLOR_ARRAY);
					glEnableClientState(GL_TEXTURE_COORD_ARRAY);
					break;
					
				case VA_FORMAT_POS3F_COL4B_TEX2F:
					glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(PositionColorTex3f4b2f), (void*)offsetof(PositionColorTex3f4b2f,color));
					glTexCoordPointer(2, GL_FLOAT, sizeof(PositionColorTex3f4b2f), (void*)offsetof(PositionColorTex3f4b2f,texcoord));
					glVertexPointer(3, GL_FLOAT, sizeof(PositionColorTex3f4b2f), (void*)offsetof(PositionColorTex3f4b2f,pos));
					
					glEnableClientState(GL_VERTEX_ARRAY);
					glDisableClientState(GL_NORMAL_ARRAY);
					glEnableClientState(GL_COLOR_ARRAY);
					glEnableClientState(GL_TEXTURE_COORD_ARRAY);
					break;
					
				case VA_FORMAT_POS3F_TEX2F:
					glTexCoordPointer(2, GL_FLOAT, sizeof(PositionTex3f2f), (void*)offsetof(PositionTex3f2f,texcoord));
					glVertexPointer(3, GL_FLOAT, sizeof(PositionTex3f2f), (void*)offsetof(PositionTex3f2f,pos));
					
					glEnableClientState(GL_VERTEX_ARRAY);
					glDisableClientState(GL_NORMAL_ARRAY);
					glDisableClientState(GL_COLOR_ARRAY);
					glEnableClientState(GL_TEXTURE_COORD_ARRAY);
					break;
					
				case VA_FORMAT_POS3F:
					glVertexPointer(3, GL_FLOAT, sizeof(Position3f), (void*)offsetof(Position3f,pos));
					
					glEnableClientState(GL_VERTEX_ARRAY);
					glDisableClientState(GL_NORMAL_ARRAY);
					glDisableClientState(GL_COLOR_ARRAY);
					glDisableClientState(GL_TEXTURE_COORD_ARRAY);
					break;
				default:
					assert(0);
			}
			break;
			
		default:
			[[NSException exceptionWithName: @"com.elmonkey.invalidShader" reason: @" OpenGL ES API selected not supported by VertexArray." userInfo: nil] raise];
			break;
	}
}


- (void) generateVBO
{
	BOOL regenVAO = !vertexBufferName && useVAO;

	if (!vertexBufferName)
	{
		glGenBuffers(1, &vertexBufferName);
		glBindBuffer(GL_ARRAY_BUFFER, vertexBufferName);
		glBufferData(GL_ARRAY_BUFFER, _sizeofFormat(vertexFormat)*numVertices, _vertices, usageHint);
		glBindBuffer(GL_ARRAY_BUFFER, 0);
	}
	if (needsVertexBufferUpdate)
	{
		glBindBuffer(GL_ARRAY_BUFFER, vertexBufferName);
		glBufferSubData(GL_ARRAY_BUFFER, 0, _sizeofFormat(vertexFormat)*numVertices, _vertices);
		glBindBuffer(GL_ARRAY_BUFFER, 0);
		needsVertexBufferUpdate = NO;
	}
	if (!indexBufferName && numIndices)
	{
		glGenBuffers(1, &indexBufferName);
		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBufferName);
		glBufferData(GL_ELEMENT_ARRAY_BUFFER, 2*numIndices, indices, usageHint);
		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
	}
	if (indexBufferName && needsIndexBufferUpdate)
	{
		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBufferName);
		glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, 2*numIndices, indices);
		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
		needsIndexBufferUpdate = NO;
	}

	if (!vertexArrayObject && useVAO)
	{
		glGenVertexArraysOES(1, &vertexArrayObject);
		regenVAO = YES;
	}
	if (regenVAO)
	{
		glBindVertexArrayOES(vertexArrayObject);
		
		[self setupArrayState];
		glBindVertexArrayOES(0);
	}
}

- (void) convertTriangleIndicesToLines
{
	uint16_t* tris = NULL;
	@synchronized(self)
	{
		tris = indices;
		indices = calloc(sizeof(*indices), numIndices*2);
		
		for (size_t i = 0; i < numIndices/3; ++i)
		{
			indices[6*i+0] = tris[3*i+0];
			indices[6*i+1] = tris[3*i+1];
			indices[6*i+2] = tris[3*i+1];
			indices[6*i+3] = tris[3*i+2];
			indices[6*i+4] = tris[3*i+2];
			indices[6*i+5] = tris[3*i+0];
		}
		numIndices *= 2;
		mode = GL_LINES;
		needsIndexBufferUpdate = YES;
	}
	free(tris);
}
- (void) convertPseudoQuadIndicesToLines
{
	uint16_t* tris = NULL;
	@synchronized(self)
	{
		tris = indices;
		indices = calloc(sizeof(*indices), numIndices*2);
		size_t ii = 0;
		for (size_t i = 0; i < numIndices/3; ++i)
		{
			indices[ii++] = tris[3*i+0];
			indices[ii++] = tris[3*i+1];
			indices[ii++] = tris[3*i+2];
			indices[ii++] = tris[3*i+0];
		}
		numIndices = ii;
		mode = GL_LINES;
		needsIndexBufferUpdate = YES;
	}
	free(tris);
}


- (void) draw
{
	if (!numVertices)
		return;
	
	@synchronized(self)
	{

		[self generateVBO];

		if (useVAO)
		{
			glBindVertexArrayOES(vertexArrayObject);
		}
		else
		{
			[self setupArrayState];
		}
		
		if (!indexBufferName)
			glDrawArrays(mode, 0, numVertices);
		else
			glDrawElements(mode, numIndices, GL_UNSIGNED_SHORT, (void*)0);
		
	}

	if (useVAO)
		glBindVertexArrayOES(0);
	
	GLenum err = glGetError();
	if(err)
	{
		assert(err);
	};
}

- (void) drawRangeFrom: (int) fromi to: (int) toi
{
	int numi = toi-fromi;
	assert(numi >= 0);
	assert(fromi >= 0);
	
	@synchronized(self)
	{

		[self generateVBO];

		if (useVAO)
		{
			glBindVertexArrayOES(vertexArrayObject);
		}
		else
		{
			[self setupArrayState];
		}
		
		if (!indexBufferName)
		{
			assert(toi <= (int)numVertices);
			glDrawArrays(mode, fromi, numi);
		}
		else
		{
			assert(toi <= (int)numIndices);
			glDrawElements(mode, numi, GL_UNSIGNED_SHORT, (void*)(2*fromi));
		}
	}

	if (useVAO)
		glBindVertexArrayOES(0);
	
	GLenum err = glGetError();
	if(err)
	{
		assert(err);
	};
}

- (void) applyVertexTransform: (m16) m
{
	@synchronized(self)
	{
		switch (vertexFormat)
		{
			case VA_FORMAT_POS3F_NORMAL3F_TEX2F:
			{
				PositionNormalTex3f3f2f* vertices = _vertices;
				for (size_t i = 0; i < numVertices; ++i)
				{
					v3 v = {{vertices[i].pos[0], vertices[i].pos[1], vertices[i].pos[2]}};
					v = mtransformpos3(m, v);
					vertices[i].pos[0] = v.a[0];
					vertices[i].pos[1] = v.a[1];
					vertices[i].pos[2] = v.a[2];
				}
				
				break;
			}
			case VA_FORMAT_POS3F_COL4B_TEX2F:
			{
				PositionColorTex3f4b2f* vertices = _vertices;
				for (size_t i = 0; i < numVertices; ++i)
				{
					v3 v = {{vertices[i].pos[0], vertices[i].pos[1], vertices[i].pos[2]}};
					v = mtransformpos3(m, v);
					vertices[i].pos[0] = v.a[0];
					vertices[i].pos[1] = v.a[1];
					vertices[i].pos[2] = v.a[2];
				}
				
				break;
			}
			case VA_FORMAT_POS3F_TEX2F:
			{
				PositionTex3f2f* vertices = _vertices;
				for (size_t i = 0; i < numVertices; ++i)
				{
					v3 v = {{vertices[i].pos[0], vertices[i].pos[1], vertices[i].pos[2]}};
					v = mtransformpos3(m, v);
					vertices[i].pos[0] = v.a[0];
					vertices[i].pos[1] = v.a[1];
					vertices[i].pos[2] = v.a[2];
				}
				
				break;
			}
			case VA_FORMAT_POS3F:
			{
				Position3f* vertices = _vertices;
				for (size_t i = 0; i < numVertices; ++i)
				{
					v3 v = {{vertices[i].pos[0], vertices[i].pos[1], vertices[i].pos[2]}};
					v = mtransformpos3(m, v);
					vertices[i].pos[0] = v.a[0];
					vertices[i].pos[1] = v.a[1];
					vertices[i].pos[2] = v.a[2];
				}
				
				break;
			}
			default:
				assert(0);
		}
		needsVertexBufferUpdate = YES;
	}
}

- (void) disposeOfNormals
{
	@synchronized(self)
	{
		switch (vertexFormat)
		{
			case VA_FORMAT_POS3F_NORMAL3F_TEX2F:
			{
				PositionNormalTex3f3f2f* vertices = _vertices;
				PositionTex3f2f* nvertices = calloc(sizeof(*nvertices),numVertices);
				for (size_t i = 0; i < numVertices; ++i)
				{
					nvertices[i].pos[0] = vertices[i].pos[0];
					nvertices[i].pos[1] = vertices[i].pos[1];
					nvertices[i].pos[2] = vertices[i].pos[2];
					nvertices[i].texcoord[0] = vertices[i].texcoord[0];
					nvertices[i].texcoord[1] = vertices[i].texcoord[1];
				}
				free(vertices);
				_vertices = nvertices;
				vertexFormat = VA_FORMAT_POS3F_TEX2F;
				
				needsVertexBufferUpdate = YES;
				break;
			}
			case VA_FORMAT_POS3F_COL4B_TEX2F:
			{
				break;
			}
			case VA_FORMAT_POS3F_TEX2F:
			{
				break;
			}
			case VA_FORMAT_POS3F:
			{			
				break;
			}
			default:
				assert(0);
		}
	}
}

- (size_t) memoryUsage
{
	return malloc_size((__bridge void*)self) + _sizeofFormat(vertexFormat)*numVertices*2 + sizeof(*indices)*numIndices;
}

@synthesize numVertices;

@end



Loggerhead 1.17 is a web-based interface for Bazaar branches