######################################################
#
#   MouseLook Finished blend -- Blender 2.48
#
#   Tutorial for using MouseLook.py can be found at
#	 
#   www.tutorialsforblender3d.com
#                                                                                                         
#   Released under the Creative Commons Attribution 3.0 Unported License.	
#
#   If you use this code, please include this information header.
#
######################################################


# define main program
def main():
	
	# set default values
	Sensitivity =  0.0005
	Invert = 1
	Capped = False
	
	# import Rasterizer
	import Rasterizer
	
	# get controller
	controller = GameLogic.getCurrentController()
	
	# get the object this script is attached to
	obj = controller.getOwner()
	
	# get the size of the game screen
	gameScreen = gameWindow(Rasterizer)
	
	# get mouse movement
	move = mouseMove(gameScreen, controller, obj)
	
	# change mouse sensitivity?
	sensitivity =  mouseSen(Sensitivity, obj)
	
	# invert mouse pitch?
	invert = mousePitch(Invert, obj)
	
	# upDown mouse capped?
	capped = mouseCap(Capped, move, invert, obj)
	
	# use mouse look
	useMouseLook(controller, capped, move, invert, sensitivity)
		
	# Center mouse in game window
	centerCursor(controller, gameScreen, Rasterizer)
	
#####################################################

# define game window
def gameWindow(Rasterizer):
	
	# get width and height of game window
	width = Rasterizer.getWindowWidth()
	height = Rasterizer.getWindowHeight()
	
	return (width, height)

#######################################################

# define mouse movement function
def mouseMove(gameScreen, controller, obj):

	# Get sensor named MouseLook
	mouse = controller.getSensor("MouseLook")

	# extract width and height from gameScreen
	width = gameScreen[0]
	height = gameScreen[1]

	# distance moved from screen center
	x = width/2 - mouse.getXPosition()
	y = height/2 - mouse.getYPosition()
	
	# initialize mouse so it doesn't jerk first time
	if hasattr(obj, 'mouseInit') == False:
		obj.mouseInit = True
		x = 0
		y = 0
	
	#########	stops drifting on mac osx
   	
	# if sensor is deactivated don't move
	if mouse.isPositive() == False:
		x = 0
		y = 0
	
	#########  -- contributed by Pelle Johnsen
		   	 
	# return mouse movement
	return (x, y)


######################################################

# define Mouse Sensitivity
def mouseSen(sensitivity, obj):
	
	# check so see if property named Adjust was added
	if hasattr(obj, 'Adjust') == True:
		
		# Don't want Negative values
		if obj.Adjust < 0.0:
			obj.Adjust = 0.0
		
		# adjust the sensitivity
		sensitivity = obj.Adjust * sensitivity

	# return sensitivity
	return sensitivity

#########################################################

# define Invert mouse pitch
def mousePitch(invert, obj):
	
	# check to see if property named Invert was added	
	if hasattr(obj, 'Invert') == True:
			
		# pitch to be inverted?
		if obj.Invert == True:
			invert = -1
		else:
			invert = 1
			
	# return mouse pitch
	return invert

#####################################################

# define Cap vertical mouselook
def mouseCap(capped, move, invert, obj):
	
	# check to see if property named Cap was added
	if hasattr(obj, 'Cap') == True:			
	
		# import mathutils
		import Mathutils
		
		# limit cap to 0 - 180 degrees
		if obj.Cap > 180:
			obj.Cap = 180
		if obj.Cap < 0:
			obj.Cap = 0
		
		# get the orientation of the camera to world axis
		camOrient = obj.orientation
		
		# get camera Z axis vector
		camZ = [camOrient[0][2], camOrient[1][2], camOrient[2][2]]
		
		# create camera z axis vector 
		vec1 = Mathutils.Vector(camZ)
		
		# get camera parent
		camParent = obj.parent
		
		# get parent orientation to world axis
		parentOrient = camParent.orientation
		
		# get parent z axis vector
		parentZ = [parentOrient[0][2], parentOrient[1][2], parentOrient[2][2]]
		
		# create parent z axis vector
		vec2 = Mathutils.Vector(parentZ)
		
		# find angle between two
		angle = Mathutils.AngleBetweenVecs(vec1, vec2)
			
		# get amount to limit mouselook
		capAngle = obj.Cap
				
		# get mouse up down movement
		moveY = move[1] * invert
			
		# check capped angle against against camera z-axis and mouse y movement
		if (angle > (90 + capAngle/2) and moveY > 0)   or (angle < (90 - capAngle/2) and moveY < 0)  == True:
			
			# no movement
			capped = True
	
	# return capped
	return capped

###############################################

# define useMouseLook
def useMouseLook(controller, capped, move, invert, sensitivity):
				
	# get up/down movement
	if capped == True:
		upDown = 0
	else:
		upDown = move[1] * sensitivity * invert 
		
	# get left/right movement
	leftRight = move[0] * sensitivity * invert 
		
	# Get the actuators
	act_LeftRight = controller.getActuator("LeftRight")
	act_UpDown = controller.getActuator("UpDown") 
	
	# set the values
	act_LeftRight.setDRot( 0.0, 0.0, leftRight, False)
	
	
	act_UpDown.setDRot(upDown, 0.0, 0.0, True)
	
	
	# Use the actuators 
	GameLogic.addActiveActuator(act_LeftRight, True)
	GameLogic.addActiveActuator(act_UpDown, True) 
	
#############################################

# define center mouse cursor
def centerCursor(controller, gameScreen, Rasterizer):
	
	# Get sensor named MouseLook
	mouse = controller.getSensor("MouseLook")

	# extract width and height from gameScreen
	width = gameScreen[0]
	height = gameScreen[1]

	# get cursor position
	x = mouse.getXPosition()
	y = mouse.getYPosition()
	
	#if cursor needs to be centered
	if x != width/2 or y != height/2:
		
		# Center mouse in game window
		Rasterizer.setMousePosition(width/2, height/2)
		
	# already centered.  Turn off actuators
	else:
		
		# Get the actuators
		act_LeftRight = controller.getActuator("LeftRight")
		act_UpDown = controller.getActuator("UpDown")  
		
		# turn off the actuators 
		GameLogic.addActiveActuator(act_LeftRight, False)
		GameLogic.addActiveActuator(act_UpDown, False) 

##############################################

# Run program
main()