#!/usr/bin/python

from OpenGL.GL import *
from OpenGL.GLUT import *
from OpenGL.GLU import *
from gobject.option import OptionGroup, OptionParser, make_option, OptionError
from gobject import GError
import math
import random
import os
import string
import time
import sys
import gtk
import gc

class textureLoader:
	def __init__(self, filename, idl, buffersize, tilesize, tilequality):
		print filename
		self.buffersize = buffersize
		self.tilesize = tilesize
		self.tilequality = tilequality
		self.filename = filename
		self.closed = False
		self.resize = False
		self.loaded = 0
		self.f=open(filename,"r")
		self.pixbuf = gtk.gdk.PixbufLoader()
		self.pixbuf_new = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB,True,8,self.tilesize,self.tilesize)
		self.pixbuf_new.fill(0x00000000)

	def next_chunk(self):
		if not self.closed:
			tmpdta = self.f.read(self.buffersize)
			if tmpdta == "":
				self.pixbuf.close()
				self.f.close()
				self.closed = True
				self.pixbuf_old = self.pixbuf.get_pixbuf()
				self.pixbuf_old=self.pixbuf_old.add_alpha(False, "a","a","a")
				ix = self.pixbuf_old.get_width()
				iy = self.pixbuf_old.get_height()
				if ix > iy:
					self.nix = self.tilesize-4
					self.niy = (float(self.nix) / float(ix)) * float(iy)
				
				else:
					self.niy = self.tilesize-4
					self.nix = (float(self.niy) / float(iy)) * float(ix)
				return True
			else:
				self.pixbuf.write(tmpdta)
				return True
		elif not self.resize:
			try:
				self.pixbuf_old = self.pixbuf_old.scale_simple(self.nix,self.niy,self.tilequality)
				#GPU RESCALING				
				#self.pixbuf_new = gluScaleImage(GL_RGBA, self.pixbuf_old.get_width(), self.pixbuf_old.get_height(), GL_UNSIGNED_BYTE, self.pixbuf_old.get_pixels(),self.tilesize, self.tilesize, GL_UNSIGNED_BYTE) 
			except AttributeError:
				sys.exit(0)
			#Disable below line for GPU rescaling
			self.pixbuf_old.copy_area(0, 0, self.nix, self.niy, self.pixbuf_new, (2+(self.tilesize - 4 - self.nix)/2), (2+(self.tilesize - 4 - self.niy)/2))
			self.resize = True
			return False

	def transfer(self):
		pixels = self.pixbuf_new.get_pixels()
		w = self.pixbuf_new.get_width()
		h = self.pixbuf_new.get_height()
		del self.pixbuf
		del self.pixbuf_old
		del self.pixbuf_new
		gc.collect()
		return pixels, w, h
		#GPU Rescaling
		#return self.pixbuf_new, self.tilesize, self.tilesize

class phimage:
	def __init__(self):
		self.d2 =0
		self.init_options()
		try:
			self.parser.parse_args()
		except GError, e:
			print "Error: " + str(e)
			sys.exit(0)
		self.check_options()
		self.tex = [0,1]
		self.ESCAPE = '\033'
		self.state = 0
		self.stateCounter = 0
		self.stateTime = time.time() 
		self.startTime = self.stateTime
		self.window = 0
		self.texture = range(3)
		self.alpha = [1,0]
		self.theta = 0
		self.thetar = 0
		self.frameCnt = 0
		self.counter = 0
		self.textureName = ''
		self.files = os.listdir(self.workingPath)
		self.files = filter(self.isImage, self.files)
		self.image2 = [0, 1]
		self.image = [0, 1]
		self.lastx = 400
		self.lasty = 400
		self.main()

	def init_options(self):
		self.parser = OptionParser("", 
		    description="PHimage",
		    option_list = [
			make_option("--tilesize", "-t",
				    type="string",
				    action="store",
				    dest="tilesize",
				    help="Size of tile to use, must be n^2"),

		        make_option("--tilequality", "-q", 
		                    type="string", 
		                    action="store", 
		                    dest="tilequality",
		                    help="Quality of resize operation, 0 = bad, 1 = good"),

			make_option("--dir", "-d", 
				    type="string",
		                    action="store", 
		                    dest="dir",
		                    help="Directory in which to recurse for images"),

		        make_option("--angle", "-a", 
				    type="string",
		                    action="store", 
		                    dest="angle", 
		                    help="Angle of two images to each other, -90 to 90"),

			make_option("--buffersize", "-b",
				    type="string",
				    action="store",
				    dest="buffersize",
				    help="Size of progressive buffer"),

		        make_option("--blendtime", "-B", 
				    type="string",
		                    action="store", 
		                    dest="blendtime", 
		                    help="How long to take for blend operation in 100s of second, default = 100"),

		        make_option("--hangtime", "-H", 
				    type="string",
		                    action="store", 
		                    dest="hangtime", 
		                    help="How long an image is displayed for before it is removed in 100s of second, default = 300"),

			make_option("--constraint", "-c",
				    type="string",
				    action="store",
				    dest="constraint",
				    help="Form xm,ym,xr,yr of the constraints, default = 0.5,0.5,30,30"),

		        make_option("--speed", "-s", 
				    type="string",
		                    action="store", 
		                    dest="speed", 
		                    help="Form c,r of the speed, set to 0 to disable movement or rotation, default = 0.005,0.005"),

		        make_option("--resolution", "-r", 
				    type="string",
		                    action="store", 
		                    dest="resolution", 
		                    help="Form 1024x768:8@75 of the resolution, default = 1024x768:8@75"),
				    
		        make_option("--window", "-w", 
				    type="string",
		                    action="store", 
		                    dest="window", 
		                    help="Use a window 0, 1, default 0"),

		        make_option("--distance", "-D", 
				    type="string",
		                    action="store", 
		                    dest="distance", 
		                    help="Distance from object, default 2.5"),

		        make_option("--perspective", "-p", 
				    type="string",
		                    action="store", 
		                    dest="perspective", 
		                    help="Perspective of view, default 45.0"),

		        # ...
		    ])

	def check_options(self):
		if self.parser.values.blendtime != None:
			self.blendTime = int(self.parser.values.blendtime)
		else:
			self.blendTime = 100

		if self.parser.values.hangtime != None:
			self.displayTime = int(self.parser.values.hangtime)
		else:
			self.displayTime = 300

		if self.parser.values.dir != None:
			self.workingPath = self.parser.values.dir
		else:
			self.workingPath = os.getcwd()

		if self.parser.values.angle != None:
			self.angle = float(self.parser.values.angle)
		else:
			self.angle = float(10)

		if self.parser.values.buffersize != None:
			self.buffersize = float(self.parser.values.buffersize)
		else:
			self.buffersize = 16384

		if self.parser.values.tilesize != None:
			self.tilesize = int(self.parser.values.tilesize)
		else:
			self.tilesize = 512

		if self.parser.values.tilequality == "0":
			self.tilequality = gtk.gdk.INTERP_NEAREST
		else:
			self.tilequality = gtk.gdk.INTERP_BILINEAR

		if self.parser.values.resolution != None:
			self.gamemode = self.parser.values.resolution
		else:
			self.gamemode = None

		if self.parser.values.window != None:
			self.windowmode = self.parser.values.window
		else:
			self.windowmode = 0

		if self.parser.values.constraint != None:
			tmp = self.parser.values.constraint.split(",")
			if len(tmp) == 4:
				self.xm = float(tmp[0])
				self.ym = float(tmp[1])
				self.xr = float(tmp[2])
				self.yr = float(tmp[3])
			else:
				sys.exit(0)
		else:
			self.xm = 0.5
			self.ym = 0.5
			self.xr = 30
			self.yr = 30

		if self.parser.values.speed != None:
			tmp = self.parser.values.speed.split(",")
			if len(tmp) == 2:
				self.movth = float(tmp[0])
				self.rotth = float(tmp[1])
			else:
				sys.exit(0)
		else:
			self.movth = 0.005
			self.rotth = 0.005

		if self.parser.values.distance != None:
			self.distance = float(self.parser.values.distance)
		else:
			self.distance = 2.5

		if self.parser.values.perspective != None:
			self.perspective = float(self.parser.values.perspective)
		else:
			self.perspective = 45.0


	def isImage(self, filename):
		if os.path.splitext(filename)[-1].lower() in ('.png', '.jpg', '.bmp'):
			return True
		else:
			return False


	def storeIDLTexture(self, data, idl, w, h):		
		glPixelStorei(GL_UNPACK_ALIGNMENT,1)
		glBindTexture(GL_TEXTURE_2D,self.textureName[idl])
		glTexImage2D(GL_TEXTURE_2D, 0, 3, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, data)
		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP)
		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP)
		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT)
		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT)
		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
		glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL)

	def InitGL(self, Width, Height):

		test = textureLoader(self.nextFile() ,0, self.buffersize, self.tilesize, self.tilequality)
		while test.next_chunk()==True:
			True
		data, w, h = test.transfer()
		self.storeIDLTexture(data, 0, w, h)

		test = textureLoader(self.nextFile() ,1, self.buffersize, self.tilesize, self.tilequality)
		while test.next_chunk()==True:
			True
		data, w, h = test.transfer()
		self.storeIDLTexture(data, 1, w, h)

		glHint (GL_LINE_SMOOTH_HINT, GL_DONT_CARE);
		#glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST )		
		glEnable(GL_TEXTURE_2D)
		glClearColor(0.0, 0.0, 0.0, 0.0)
		glClearDepth(1.0)

		glDepthFunc(GL_LESS)			
#		glEnable(GL_DEPTH_TEST)
		#This is changed to FLAT to improve speed.....We are not making any curved
		#surfaces here			
		glShadeModel(GL_FLAT)	
 
		glMatrixMode(GL_PROJECTION)
		glLoadIdentity()

		gluPerspective(self.perspective, float(Width)/float(Height), 0.1, 100.0)
 
		glMatrixMode(GL_MODELVIEW)
 
		glBlendFunc(GL_SRC_ALPHA,GL_ONE) 
		glEnable(GL_BLEND)		    # Turn Blending On
		glDisable(GL_DEPTH_TEST)            # Turn Depth Testing Off

	def stateChecker(self):
		"""This function does the main state checking for the entire process
		It knows which plane is currently being displayed and which to load next
		It is run in delta time for everything now"""

		diffTime = time.time() - self.stateTime
		self.diffTime = diffTime
		if self.state == 0:
			self.alpha[0] = (1.0 / self.blendTime) * self.stateCounter
			self.alpha[1] = (self.blendTime - self.stateCounter) * (1.0 / self.blendTime)
			self.stateCounter = self.stateCounter + (diffTime * 100)
			if self.stateCounter > self.blendTime:
				self.alpha[0] = 1
				self.alpha[1] = 0
				self.state = 1
				self.stateCounter = 0

		elif self.state == 1:
			self.tex[1] = textureLoader(self.nextFile(), 1, self.buffersize, self.tilesize, self.tilequality)
			self.state = 2

		elif self.state == 2: 
			if self.tex[1].next_chunk() == False:
				data, w, h = self.tex[1].transfer()
				self.storeIDLTexture(data, 1, w, h)
			self.stateCounter = self.stateCounter + (diffTime * 100)
			if self.stateCounter > self.displayTime:
				self.state = 3
				self.stateCounter = 0

		elif self.state == 3:
			self.alpha[1] = (1.0 / self.blendTime) * self.stateCounter
			self.alpha[0] = (self.blendTime - self.stateCounter) * (1.0 / self.blendTime)
			self.stateCounter = self.stateCounter + (diffTime * 100)
			if self.stateCounter > self.blendTime:
				self.alpha[1] = 1
				self.alpha[0] = 0
				self.state = 4
				self.stateCounter = 0

		elif self.state == 4:
			self.tex[0] = textureLoader(self.nextFile(), 0, self.buffersize, self.tilesize, self.tilequality)
			self.state = 5

		elif self.state == 5: 
			if self.tex[0].next_chunk() == False:
				data, w, h = self.tex[0].transfer()
				self.storeIDLTexture(data, 0, w, h)
			self.stateCounter = self.stateCounter + (diffTime * 100)
			if self.stateCounter > self.displayTime:
				self.state = 0
				self.stateCounter = 0

		self.stateTime = self.stateTime + diffTime
		self.frameCnt = self.frameCnt + 1
		print self.frameCnt / (self.stateTime - self.startTime)
		#print self.stateTime
		
	def DrawGLScene(self):
		self.stateChecker()
		#Trying to imporve performance here
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
		#glClear(GL_COLOR_BUFFER_BIT)
		glLoadIdentity()
		glTranslatef(0.0,0.0,-self.distance)

		xmov = math.sin(self.theta)
		ymov = math.cos(self.theta)
		xmovr = math.sin(self.thetar)
		ymovr = math.cos(self.thetar)

		glTranslate(xmov*self.xm,ymov*self.ym,0)

		glRotatef (-ymovr*self.yr, 0.0, 1.0, 0.0)

		glRotatef (xmovr*self.xr, 1.0, 0.0, 0.0) 
		glRotatef(self.angle,0.0,1.0,0.0)			# Rotate The Cube On It's Y Axis
 
       		glColor4f(1.0, 1.0, 1.0, self.alpha[0])
		glBindTexture(GL_TEXTURE_2D, self.textureName[0])
		glBegin(GL_QUADS)			    # Start Drawing The Cube

		glTexCoord2f(0.0, 1.0); glVertex2f(-1.0, -1.0)	
		glTexCoord2f(1.0, 1.0); glVertex2f( 1.0, -1.0)
		glTexCoord2f(1.0, 0.0); glVertex2f( 1.0,  1.0)
		glTexCoord2f(0.0, 0.0); glVertex2f(-1.0,  1.0)

 
		glEnd()				# Done Drawing The Cube

		glTranslate(-2*xmov*self.xm,-2*ymov*self.ym,0)
		glRotatef(-2*(self.angle),0.0,1.0,0.0)			# Rotate The Cube On It's Y Axis

		glColor4f(1.0, 1.0, 1.0, self.alpha[1])
		glBindTexture(GL_TEXTURE_2D,self.textureName[1])
		glBegin(GL_QUADS)			    # Start Drawing The Cube
 
		glTexCoord2f(0.0, 1.0); glVertex2f(-1.0, -1.0)	
		glTexCoord2f(1.0, 1.0); glVertex2f( 1.0, -1.0)
		glTexCoord2f(1.0, 0.0); glVertex2f( 1.0,  1.0)
		glTexCoord2f(0.0, 0.0); glVertex2f(-1.0,  1.0)
 
		glEnd();				# Done Drawing The Cube

		if time.time() - self.d2 >= .0001:
			self.d2 = time.time()
			self.theta = self.theta + self.movth
			self.thetar = self.thetar + self.rotth

		glBlendFunc(GL_SRC_ALPHA,GL_ONE)
		glFlush()
		glutSwapBuffers()

	def ReSizeGLScene(self, Width, Height):
		if Height == 0:	
			Height = 1
 
		glViewport(0, 0, Width, Height)
		glMatrixMode(GL_PROJECTION)
		glLoadIdentity()
		gluPerspective(self.perspective, float(Width)/float(Height), 0.1, 100.0)
		glMatrixMode(GL_MODELVIEW)
		glLoadIdentity()

	def nextFile(self):
		self.counter = self.counter + 1
		if self.counter >= len(self.files):
			self.counter = 0
		return self.workingPath + "/" + self.files[self.counter]

	def keyPressed(self, *args):
		# If escape is pressed, kill everything.
		if args[0] == self.ESCAPE:
			glutDestroyWindow(self.window)
			sys.exit()
		if args[0] == " ":
			glutTimerFunc(500, self.skipImage,0)	

	def skipImage(self,void):
			if self.state==2:
				self.state = self.state + 1
				self.stateCounter=0
			if self.state==5:
				self.state = 0
				self.stateCounter=0


	def MouseMotion (self, x, y):

		self.lastx = x/24

		self.lasty = y/24

		glutPostRedisplay ()

	def MouseClick (self, button, button_state, cursor_x, cursor_y):
		True

	def main(self):
		glutInit(())
		glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_ALPHA | GLUT_DEPTH)

		if self.windowmode == "1" or not glutGameModeGet(GLUT_GAME_MODE_POSSIBLE):
			if self.gamemode == None:
				glutInitWindowSize(800, 600)
			else:
				tmp = self.gamemode.split(":")[0].split("x")
				glutInitWindowSize(int(tmp[0]), int(tmp[1]))
			glutInitWindowPosition(0, 0)
			self.window = glutCreateWindow("Phimage")

		else:
			if self.gamemode == None:
				
				glutGameModeString(str(glutGet(GLUT_SCREEN_WIDTH))+"x"+str(glutGet(GLUT_SCREEN_HEIGHT))+":8@75");
			else:
				glutGameModeString(self.gamemode)
			glutEnterGameMode();
		
		glutDisplayFunc(self.DrawGLScene)
		glutIdleFunc(self.DrawGLScene)
		glutReshapeFunc(self.ReSizeGLScene)
		glutKeyboardFunc(self.keyPressed)
		glutMotionFunc(self.MouseMotion)
		glutMouseFunc(self.MouseClick)
		self.textureName = glGenTextures(2)
		self.InitGL(1024, 768)
		glutMainLoop()

test = phimage()