camera.py

# -*- coding: utf-8 -*-
 
import math
import collections
 
import pyglet
 
class FirstPersonCamera(object):
	"""First person camera implementation
 
	Usage:
		import pyglet
		from pyglet.gl import *
		from camera import FirstPersonCamera
 
 
		window = pyglet.window.Window(fullscreen=True)
		window.set_exclusive_mouse(True)
		camera = FirstPersonCamera(window)
 
		@window.event
		def on_draw():
			glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
			glLoadIdentity()
 
			camera.draw()
 
			# Your draw code here
 
			return pyglet.event.EVENT_HANDLED
 
		def on_update(delta_time):
			camera.update(delta_time)
 
			# Your update code here
 
		if __name__ == '__main__':
			pyglet.clock.schedule(on_update)
			pyglet.app.run()
	"""
 
	DEFAULT_MOVEMENT_SPEED = 10.0
 
	DEFAULT_MOUSE_SENSITIVITY = 1.0
 
	DEFAULT_KEY_MAP = {
		'forward': pyglet.window.key.Z,
		'backward': pyglet.window.key.S,
		'left': pyglet.window.key.Q,
		'right': pyglet.window.key.D,
		'up': pyglet.window.key.SPACE,
		'down': pyglet.window.key.LSHIFT
	}
 
	class InputHandler(object):
		def __init__(self):
			self.pressed = collections.defaultdict(bool)
			self.dx = 0
			self.dy = 0
			self.__left_mouse_pressed = False

		def on_key_press(self, symbol, modifiers):
			self.pressed[symbol] = True

		def on_key_release(self, symbol, modifiers):
			self.pressed[symbol] = False

		def on_mouse_drag(self, x, y, dx, dy, buttons, modifiers):
			if buttons & pyglet.window.mouse.LEFT:
				self.dx = dx
				self.dy = dy

		# def on_mouse_motion(self, x, y, dx, dy):
		# 	self.dx = dx
		# 	self.dy = dy


	def __init__(self, window, position=(0, 0, 0), key_map=DEFAULT_KEY_MAP, movement_speed=DEFAULT_MOVEMENT_SPEED, mouse_sensitivity=DEFAULT_MOUSE_SENSITIVITY, y_inv=True):
		"""Create camera object
 
		Arguments:
			window -- pyglet window which camera attach
			position -- position of camera
			key_map -- dict like FirstPersonCamera.DEFAULT_KEY_MAP
			movement_speed -- speed of camera move (scalar)
			mouse_sensitivity -- sensitivity of mouse (scalar)
			y_inv -- inversion turn above y-axis
		"""
 
		self.__position = list(position)
 
		self.__yaw = 0.0
		self.__pitch = 0.0

		self.__max_mouse_speed = 8.0
		self.__max_pitch_angle = 80.0
		self.__min_pitch_angle = -40.0
 
		self.__input_handler = FirstPersonCamera.InputHandler()
 
		window.push_handlers(self.__input_handler)
 
		self.y_inv = y_inv
		self.key_map = key_map
		self.movement_speed = movement_speed
		self.mouse_sensitivity = mouse_sensitivity

	def deg2degLimit(self,d):
		"""
			Overwrite the given angle if it is to superior to 360 !
		"""
		if abs(d) > 360: return d % 360.0
		else : return d
 
	def yaw(self, yaw):
		"""Turn above x-axis"""
		new_yaw = yaw * self.mouse_sensitivity
		self.__yaw += new_yaw
		self.__yaw = self.deg2degLimit(self.__yaw)

	def pitch(self, pitch):
		"""Turn above y-axis"""
		new_pitch = pitch * self.mouse_sensitivity * ((-1) if self.y_inv else 1)

		self.__pitch += new_pitch

		#restriction to don't invert the camera ...
		if self.__pitch > self.__max_pitch_angle : self.__pitch = self.__max_pitch_angle
		elif self.__pitch < self.__min_pitch_angle : self.__pitch = self.__min_pitch_angle
		
		self.__pitch = self.deg2degLimit(self.__pitch)
 
	def move_forward(self, distance):
		"""Move forward on distance"""
		self.__position[0] -= distance * math.sin(math.radians(self.__yaw))
		self.__position[2] += distance * math.cos(math.radians(self.__yaw))
 
	def move_backward(self, distance):
		"""Move backward on distance"""
		self.__position[0] += distance * math.sin(math.radians(self.__yaw))
		self.__position[2] -= distance * math.cos(math.radians(self.__yaw))
 
	def move_left(self, distance):
		"""Move left on distance"""
		self.__position[0] -= distance * math.sin(math.radians(self.__yaw - 90))
		self.__position[2] += distance * math.cos(math.radians(self.__yaw - 90))
 
	def move_right(self, distance):
		"""Move right on distance"""
		self.__position[0] -= distance * math.sin(math.radians(self.__yaw + 90))
		self.__position[2] += distance * math.cos(math.radians(self.__yaw + 90))
 
	def move_up(self, distance):
		"""Move up on distance"""
		self.__position[1] -= distance
 
	def move_down(self, distance):
		"""Move down on distance"""
		self.__position[1] += distance
 
	def update(self, delta_time):
		"""Update camera state"""
		self.yaw(self.__input_handler.dx)
		self.__input_handler.dx = 0
 
		self.pitch(self.__input_handler.dy)
		self.__input_handler.dy = 0
 
		if self.__input_handler.pressed[self.key_map['forward']]:
			self.move_forward(delta_time * self.movement_speed)
 
		if self.__input_handler.pressed[self.key_map['backward']]:
			self.move_backward(delta_time * self.movement_speed)

		if self.__input_handler.pressed[self.key_map['left']]:
			self.move_left(delta_time * self.movement_speed)
 
		if self.__input_handler.pressed[self.key_map['right']]:
			self.move_right(delta_time * self.movement_speed)
 
		if self.__input_handler.pressed[self.key_map['up']]:
			self.move_up(delta_time * self.movement_speed)
 
		if self.__input_handler.pressed[self.key_map['down']]:
			self.move_down(delta_time * self.movement_speed)
 
	def draw(self):
		"""Apply transform"""
		pyglet.gl.glRotatef(self.__pitch, 1.0, 0.0, 0.0)
		pyglet.gl.glRotatef(self.__yaw, 0.0, 1.0, 0.0)
		pyglet.gl.glTranslatef(*self.__position)