import enums

class Vertex(object):
	__slots__ = [
		'v',	# vertex coordinates
		'n',	# normal
		't',	# texture coordinates
		'c',	# color
	]

class Model_Manager(object):
	def __init__(self):
		self.load_textypes()
		self.load_textures()
		self.load_materials()
		self.load_models()
		
	def load_textypes():
		self.textypes = {}
		self.textypes[enums.tt.diffuse] = TextureType(GL_TEXTURE0, GL_TEXTURE_2D, GL_CLAMP, GL_CLAMP, GL_NEAREST, GL_NEAREST)
		self.textypes[enums.tt.dark] = TextureType(GL_TEXTURE1, GL_TEXTURE_2D)
		self.textypes[enums.tt.specular] = TextureType(GL_TEXTURE2, GL_TEXTURE_2D)
		self.textypes[enums.tt.normal] = TextureType(GL_TEXTURE3, GL_TEXTURE_2D)

	def get_textype(self, textype):
		if isinstance(textype, TextureType):
			return textype
		return self.textypes[textype]
				
	def load_textures(self):
		gamedata.get('textures')

	def load_textures(self):
		gamedata.get('materials')

	def load_textures(self):
		gamedata.get('models')
		
mgr = Model_Manager()

class TextureType(object):
	def __init__(self, texunit, texdim, wrap_s=GL_CLAMP, wrap_t=GL_CLAMP, mag=GL_LINEAR, min=GL_LINEAR)
		self.texunit = texunit
		self.texdim = texdim
		self.wrap_s = wrap_s
		self.wrap_t = wrap_t
		self.mag = mag
		self.min = min
	
	def initialize(self):
		glActiveTexture(self.texunit)
		glTexParameterf(self.texdim, GL_TEXTURE_WRAP_S, self.wrap_s)
		glTexParameterf(self.texdim, GL_TEXTURE_WRAP_T, self.wrap_t)
		glTexParameterf(self.texdim, GL_TEXTURE_MAG_FILTER, self.mag)
		glTexParameterf(self.texdim, GL_TEXTURE_MIN_FILTER, self.min)
		
	def get_dimension(self):
		return self.texdim
		
	def activate(self):
		glActiveTexture(self.texunit)
	

		

class Material(object):
		
	def __init__(self):
		pass
	def attach_texture(self, textype, texid):
		textype = mgr.get_textype(textype)
		textype.activate()
		
		self.texid

class Texture(object):
	def __init__(self):
		pass
	def load(self, file):
		img = files.mgr.png(file)
		texid, = glGenTextures(1)
		
		self.id = texid
		
		imgdata = pygame.image.tostring(img, "RGBA")
		imgr = img.get_rect()
		
		glBindTexture(textype.get_dimension(), texid)
		glTexImage2D(textype.get_dimension(), 0, GL_RGBA8, imgr.w, imgr.h, 0, GL_RGBA, GL_UNSIGNED_BYTE, imgdata)
		glBindTexture(textype.get_dimension(), 0)

class Model(object):
	def __init__(self):
		self.vertexes = []
		
		
	def set_rotation(self):
		glPushMatrix()
		glMultMatrixf(self.rot.get_matrix())
		
	def unset_rotation(self):
		glPopMatrix()
		
	def bind_textures(self):
		glBindTexture(GL_TEXTURE_2D
	def unbind_textures(self):
	
	def draw(self):
		self.bind_textures()
		glBegin(GL_TRIANGLES)
		for v in self.vertexes:
			self.draw_vertex(v)
		glEnd(GL_TRIANGLES)
		self.unbind_textures()
	
	def draw_vertex(self, v):
		glColor3f(v.c[0], v.c[1], v.c[2])
		glNormal3f(v.n.x, v.n.y, v.n.z)
		glTexCoord2f(v.t[0], v.t[1])
		glVertex3f(v.v.x, v.v.y, v.v.z)
	
	
			
		
class Sprite(object):
	def __init__(self):
		Model.__init__(self)
		vl = [Vertex() for x in xrange(4)]
		
		normal = vect(0.0, 0.0, 1.0)
		white = (1.0, 1.0, 1.0)
		for v in vl:
			v.n = normal
			v.c = white
		
		tl, bl, tr, br = vl
			
		tl.v = vect(-0.5, -0.5,  0.0); tl.t = (0.0, 0.0)
		bl.v = vect(-0.5,  0.5,  0.0); bl.t = (0.0, 1.0)
		tr.v = vect( 0.5, -0.5,  0.0); tr.t = (1.0, 0.0)
		br.v = vect( 0.5,  0.5,  0.0); br.t = (1.0, 1.0)
		
		self.corners = vl
		self.vertexes = [tl, bl, tr, bl, tr, br]

	def set_texture(