redef class EulerCamera
	# Zoom and scroll this camera from user input
	#
	# Scrolling is accomplished by moving the camera on the XY plane and
	# zooming by moving it on the Z axis.
	#
	# This method has distinct implementations per platform.
	# On desktop computers, the mouse wheel changes the zoom level, and
	# holding down the middle mouse button scrolls the camera.
	# On Android, a two finger pinch and slide gesture zoom and scroll.
	#
	# Returns `true` if the event is used.
	#
	# Should be called from `App::accept_event` before accepting pointer events:
	#
	# ~~~nitish
	# redef class App
	#     redef fun accept_event(event)
	#     do
	#         if world_camera.accept_scroll_and_zoom(event) then return true
	#
	#         # Handle other events...
	#         return false
	#     end
	# end
	# ~~~
	fun accept_scroll_and_zoom(event: InputEvent): Bool do return false
end

redef class EulerCamera
	# The returned matrix must not be modified as it is cached.
	redef fun mvp_matrix
	do
		var m = mvp_matrix_cache
		if m == null or check_position_changed then
			m = super
			mvp_matrix_cache = m
		end
		return m
	end

	redef fun pitch=(value)
	do
		super
		mvp_matrix_cache = null
	end

	redef fun yaw=(value)
	do
		super
		mvp_matrix_cache = null
	end

	redef fun roll=(value)
	do
		super
		mvp_matrix_cache = null
	end

	redef fun field_of_view_y=(value)
	do
		super
		mvp_matrix_cache = null
	end

	redef fun near=(value)
	do
		super
		mvp_matrix_cache = null
	end

	redef fun far=(value)
	do
		super
		mvp_matrix_cache = null
	end
end

redef class EulerCamera

	# Zoom factor, default at 1.2, higher means more reactive zoom effect
	var camera_zoom_mod = 1.2 is writable

	# Scroll trigger button mask from SDL2 (1: left, 2: middle, 4: right)
	#
	# Set to 0 to deactivate the scrolling feature.
	var camera_pan_mask = 2 is writable

	redef fun accept_scroll_and_zoom(event)
	do
		# Zoom
		if event isa GamnitMouseWheelEvent then
			var dy = event.y
			var mod = camera_zoom_mod
			if dy > 0.0 then
				# Zoom in when moving the wheel up
				mod = 1.0/mod
			else dy = -dy

			position.z *= dy * mod
			return true
		end

		# Scroll
		var but_mask = camera_pan_mask
		if but_mask != 0 and event isa GamnitPointerEvent then
			var native = event.native
			if native isa SDLMouseMotionEvent and native.state & but_mask == but_mask then
				var dx = native.xrel.to_f
				var dy = native.yrel.to_f

				var world_height = field_of_view_y.sin * position.z
				var mod = app.display.as(not null).height.to_f / world_height
				position.x -= dx / mod
				position.y += dy / mod # Y is inverted between the input and output
				return true
			end
		end

		return false
	end
end

redef class EulerCamera
	# Smoothened history of pointers in the current motion event
	private var last_motion_pointers = new HashMap[Int, Point[Float]] is lazy

	# Start time of the current motion event
	private var last_motion_start: Int = -1

	redef fun accept_scroll_and_zoom(event)
	do
		if not event isa AndroidMotionEvent then return false

		if event.pointers.length < 2 then
			# Intercept leftovers of the last motion
			return event.down_time == last_motion_start
		end

		# Collect active pointer and their world position
		var new_motion_pointers = new HashMap[Int, Point[Float]]
		var ids = new Array[Int]
		for pointer in event.pointers do
			var id = pointer.pointer_id
			ids.add id
			new_motion_pointers[id] = camera_to_world(pointer.x, pointer.y)
		end

		var last_motion_pointers = last_motion_pointers
		if last_motion_start == event.down_time and
		   last_motion_pointers.keys.has(ids[0]) and last_motion_pointers.keys.has(ids[1]) then
			# Continued motion event

			# Get new and old position for 2 fingers
			var new_motion_a = new_motion_pointers[ids[0]]
			var new_motion_b = new_motion_pointers[ids[1]]
			var prev_pos_a = last_motion_pointers[ids[0]]
			var prev_pos_b = last_motion_pointers[ids[1]]

			# Move camera
			var prev_middle_pos = prev_pos_a.lerp(prev_pos_b, 0.5)
			var new_middle_pos = new_motion_a.lerp(new_motion_b, 0.5)
			position.x -= new_middle_pos.x - prev_middle_pos.x
			position.y -= new_middle_pos.y - prev_middle_pos.y

			# Zoom camera
			var prev_dist = prev_pos_a.dist(prev_pos_b)
			var new_dist = new_motion_a.dist(new_motion_b)

			position.z = prev_dist * position.z / new_dist
		else
			# Prepare for a new motion event
			last_motion_pointers.clear
			last_motion_start = event.down_time
		end

		# Keep a smooth history
		for i in [0..1] do
			if last_motion_pointers.keys.has(ids[i]) then
				last_motion_pointers[ids[i]] = last_motion_pointers[ids[i]]*0.5 +
				                                new_motion_pointers[ids[i]]*0.5
			else last_motion_pointers[ids[i]] = new_motion_pointers[ids[i]]
		end

		return true
	end
end

redef class EulerCamera
	redef var mvp_matrix = new Matrix.identity(4)

	# Half of the distance between the eyes
	var eye_separation: Float = 0.03125

	# MVP matrix for the left eye
	fun mvp_matrix_left: Matrix do return mvp_matrix_eye(eye_separation)

	# MVP matrix for the right eye
	fun mvp_matrix_right: Matrix do return mvp_matrix_eye(-eye_separation)

	# Get an MVP matrix for an eye at `diff` world unit from the center
	private fun mvp_matrix_eye(diff: Float): Matrix
	do
		var view = new Matrix.identity(4)

		# Translate the world away from the camera
		view.translate(-position.x/2.0, -position.y/2.0, -position.z/2.0)

		# Rotate the camera, first by looking left or right, then up or down
		view = view * rotation_matrix

		# Apply eye transformation
		var translation = new Matrix.identity(4)
		translation.translate(diff, 0.0, 0.0)
		view = view * translation

		# Use a projection matrix with a depth
		var projection = new Matrix.perspective(pi*field_of_view_y/2.0,
			display.aspect_ratio, near, far)

		return view * projection
	end
end

redef class EulerCamera
	# Do not use `yaw` and `pitch`, the value will instead originate from the Cardboard API
	redef var rotation_matrix = new Matrix.identity(4)

	# Get the angle value from the `rotation_matrix`
	redef fun pitch
	do
		var a = rotation_matrix[0, 1]
		var b = rotation_matrix[1, 1]
		return -atan2(a, b)
	end

	# Get the angle value from the `rotation_matrix`
	redef fun yaw
	do
		var a = rotation_matrix[2, 0]
		var b = rotation_matrix[2, 2]
		return -atan2(a, b)
	end
end