Merge: gamnit: intro textures, programs, camera and the globe example

Intro 3 core modules for gamnit with a lot of features:

* textures: Provices portable services to load textures. Textures are organized as trees where only the roots have the pixels data and subtextures relay load calls to the root. This structure should remain as is but more features need to be implemented, namely automating the use of offsets in the subtexture, auto reloading textures when invalidated and services to unload the textures.

* programs: Structures to organize GL programs and shaders and to facilitate access to shader variables. The main advantages of this API are static types on shader variables and the gamnit programs that can be specialized.

  I'm not 100% satisfied with the structure of GamnitProgram and GamnitProgramFromSource, but I don't have a better idea on how to organize it. Also I will probably review the implementation of how `GamnitProgram::attributes` and `uniforms` are populated, but it shouldn't change the API much.

* cameras: Add an abstract Camera class and a simple EulerCamera based on euler angles, perfect for FPS type games or top-down strategy games. These camera main feature is to produce the MVP matrix.

  More camera should be implemented, they should also be considered objects attachable to a scene when we have scenes. The EulerCamera lacks some feature, like the usual `look_at`.

These services are independent, it's clean but maybe it's not the best idea. We can't pass a camera to a mat4 shader variable, we have to manually extract the MVP matrix from the camera and pass it to the shader. Also to assign a texture to a sampler2d shader variable, we have to load the texture, assign its GL id to a texture unit and assign the unit's index as the shader variable value. This last issue could be simplified by more code in gamnit itself, but it will add coupling, it will be for a next PR.

The globe examples should replace the triangle example as the "minimal" example for gamnit. However I plan on updating it as I integrate more code into gamnit services allowing me to remove custom calls to OpenGL ES 2.0 from the example.

Pull-Request: #1890
Reviewed-by: Jean Privat <jean@pryen.org>

Author: privat

lib/android/load_image.nit

@@ -31,8 +31,11 @@ redef extern class NativeBitmap
 	# Copy the pixel data into a new `CByteArray`
 	#
 	# If `pad_to_pow2` the new buffer contains artificial pixels used to make
-	# the width and the height powers of 2 for compatibility with OpenGL.
-	fun copy_pixels(pad_to_pow2: nullable Bool): CByteArray
+	# the width and the height powers of 2 for compatibility with older OpenGL.
+	#
+	# If `unmultiply`, extra work is done to revert the multiplication of color
+	# values per the alpha channel applied by the Android system.
+	fun copy_pixels(pad_to_pow2, unmultiply: nullable Bool): CByteArray
 	do
 		var height = height
 		var row_bytes = row_bytes
@@ -49,7 +52,7 @@ redef extern class NativeBitmap
 		var java_buf = buf.to_java_nio_buffer
 		copy_pixels_to_buffer java_buf
 
-		if has_alpha then buf.native_array.unmultiply(width, height)
+		if has_alpha and unmultiply == true then buf.native_array.unmultiply(width, height)
 
 		if pad_to_pow2 == true then
 			for r in [height-1..0[.step(-1) do

lib/c.nit

@@ -93,7 +93,7 @@ class CIntArray
 		super size
 	end
 
-	# Create from an `SequenceRead[Int]`
+	# Create from a `SequenceRead[Int]`
 	new from(array: SequenceRead[Int])
 	do
 		var carray = new CIntArray(array.length)
@@ -118,6 +118,42 @@ extern class NativeCIntArray `{ int* `}
 	redef fun +(offset) `{ return self + offset; `}
 end
 
+# Wrapper of a C array of type `uint16_t*` with length and destroy state
+class CUInt16Array
+	super CArray[Int]
+	redef type NATIVE: NativeCUInt16Array
+
+	# Initialize a new CIntArray of `size` elements.
+	init(size: Int) is old_style_init do
+		native_array = new NativeCUInt16Array(size)
+		super size
+	end
+
+	# Create from a `SequenceRead[Int]`
+	new from(array: SequenceRead[Int])
+	do
+		var carray = new CUInt16Array(array.length)
+		for i in array.length.times do
+			carray[i] = array[i]
+		end
+		return carray
+	end
+end
+
+# An array of `uint16_t` in C
+extern class NativeCUInt16Array `{ uint16_t* `}
+	super NativeCArray
+	redef type E: Int
+
+	# Initialize a new NativeCUInt16Array of `size` elements.
+	new(size: Int) `{ return calloc(size, sizeof(uint16_t)); `}
+
+	redef fun [](index) `{ return self[index]; `}
+	redef fun []=(index, val) `{ self[index] = val; `}
+
+	redef fun +(offset) `{ return self + offset; `}
+end
+
 # Wrapper around an array of `unsigned char` in C (`unsigned char*`) with length and destroy state
 class CByteArray
 	super CArray[Byte]

lib/gamnit/cameras.nit

@@ -0,0 +1,130 @@
+# This file is part of NIT (http://www.nitlanguage.org).
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#	 http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Camera services producing Model-View-Projection matrices
+module cameras
+
+import geometry
+import matrix::projection
+
+import display
+
+# A camera with a point of view on the world
+abstract class Camera
+
+	# TODO make this a physical object in the world
+
+	# The host `GamnitDisplay`
+	var display: GamnitDisplay
+
+	# Position of this camera in world space
+	var position = new Point3d[Float](0.0, 0.0, 0.0) is writable
+
+	# The Model-View-Projection matrix created by this camera
+	#
+	# This method should only be called by the display at the moment
+	# of drawing to the screen.
+	fun mvp_matrix: Matrix is abstract
+end
+
+# Simple camera with perspective oriented with Euler angles (`pitch`, `yaw`, `roll`)
+class EulerCamera
+	super Camera
+
+	# Rotation around the X axis (looking down or up)
+	var pitch = 0.0 is writable
+
+	# Rotation around the Y axis (looking left or right)
+	var yaw = 0.0 is writable
+
+	# Rotation around the Z axis
+	var roll = 0.0 is writable
+
+	# Field of view in radians on the vertical axis of the screen
+	#
+	# Default at `0.8`
+	var field_of_view_y = 0.8 is writable
+
+	# Clipping wall near the camera, in world dimensions
+	#
+	# Default at `0.01`.
+	var near = 0.01 is writable
+
+	# Clipping wall the farthest of the camera, in world dimensions
+	#
+	# Default at `100.0` but this one should be adapted to each context.
+	var far = 100.0 is writable
+
+	# Look around sensitivity, used by `turn`
+	var sensitivity = 0.005 is writable
+
+	# Apply a mouse movement (or similar) to the camera
+	#
+	# `dx` and `dy` are relative mouse movements in pixels.
+	fun turn(dx, dy: Float)
+	do
+		# Moving on x, turn around the y axis
+		yaw -= dx*sensitivity
+		pitch -= dy*sensitivity
+
+		# Protect rotation around then x axis for not falling on your back
+		pitch = pitch.min(pi/2.0)
+		pitch = pitch.max(-pi/2.0)
+	end
+
+	# Move the camera considering the current orientation
+	fun move(dx, dy, dz: Float)
+	do
+		# +dz move forward
+		position.x -= yaw.sin*dz
+		position.z -= yaw.cos*dz
+
+		# +dx strafe to the right
+		position.x += yaw.cos*dx
+		position.z -= yaw.sin*dx
+
+		# +dz move towards the sky
+		position.y += dy
+	end
+
+	# Rotation matrix produced by the current rotation of the camera
+	protected fun rotation_matrix: Matrix
+	do
+		var view = new Matrix.identity(4)
+
+		# Rotate the camera, first by looking left or right, then up or down
+		view.rotate(yaw,   0.0, 1.0, 0.0)
+		view.rotate(pitch, 1.0, 0.0, 0.0)
+		view.rotate(roll,  0.0, 0.0, 1.0)
+
+		return view
+	end
+
+	redef fun mvp_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
+
+		# 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

lib/gamnit/display.nit

@@ -32,6 +32,9 @@ class GamnitDisplay
 	# Height of the display, in pixels
 	fun height: Int is abstract
 
+	# Aspect ratio of the screen, `width / height`
+	var aspect_ratio: Float is lazy do return width.to_f / height.to_f
+
 	# Prepare this display
 	#
 	# The implementation varies per platform.

lib/gamnit/display_android.nit

@@ -22,8 +22,10 @@ module display_android is
 end
 
 import ::android
+intrude import android::load_image
 
 private import gamnit::egl
+intrude import textures
 
 redef class GamnitDisplay
 
@@ -45,3 +47,29 @@ redef class GamnitDisplay
 
 	redef fun close do close_egl
 end
+
+redef class GamnitAssetTexture
+
+	redef fun load_from_platform
+	do
+		jni_env.push_local_frame 4
+
+		var asset_manager = app.asset_manager
+		var bmp = asset_manager.bitmap(path)
+		if bmp.is_java_null then
+			error = new Error("Failed to load texture at '{path}'")
+			jni_env.pop_local_frame
+			return
+		end
+
+		var buf = bmp.copy_pixels
+		loaded = true
+		width = bmp.width.to_f
+		height = bmp.height.to_f
+		var pixels = buf.native_array
+
+		load_from_pixels(pixels, bmp.width, bmp.height, gl_RGBA)
+
+		jni_env.pop_local_frame
+	end
+end

lib/gamnit/display_linux.nit

@@ -19,7 +19,8 @@ import sdl
 import x11
 
 import egl # local to gamnit
-import display
+intrude import display
+intrude import textures
 
 redef class GamnitDisplay
 
@@ -89,3 +90,24 @@ redef class GamnitDisplay
 		return x11_display
 	end
 end
+
+redef class GamnitAssetTexture
+
+	redef fun load_from_platform
+	do
+		var path = "assets" / path # TODO use app.assets_dir
+		var sdl_tex = new SDLImage.from_file(path)
+
+		if sdl_tex.address_is_null then
+			error = new Error("Failed to load texture at '{path}'")
+			return
+		end
+
+		self.width = sdl_tex.width.to_f
+		self.height = sdl_tex.height.to_f
+		var format = if sdl_tex.amask > 0 then gl_RGBA else gl_RGB
+		var pixels = sdl_tex.pixels
+
+		load_from_pixels(pixels, sdl_tex.width, sdl_tex.height, format)
+	end
+end

lib/gamnit/examples/globe/Makefile

@@ -0,0 +1,41 @@
+NITC=../../../../bin/nitc
+NITLS=../../../../bin/nitls
+
+all: bin/globe
+
+bin/globe: $(shell ${NITLS} -M src/globe.nit linux) ${NITC}
+	${NITC} src/globe.nit -m linux -o $@ -D n_parallels=100
+
+check: bin/globe
+	bin/globe
+
+# ---
+# Android
+
+android: bin/globe.apk
+bin/globe.apk: $(shell ${NITLS} -M src/globe.nit android) ${NITC} res/drawable-hdpi/icon.png assets/ld/earth.jpg
+	${NITC} src/globe.nit -m android -o $@
+
+android-release: $(shell ${NITLS} -M src/globe.nit android) ${NITC} res/drawable-hdpi/icon.png assets/ld/earth.jpg
+	${NITC} src/globe.nit -m android -o bin/globe.apk --release
+
+android-wear: $(shell ${NITLS} -M src/globe.nit android) ${NITC} res/drawable-hdpi/icon.png assets/ld/earth.jpg
+	${NITC} src/globe.nit -m android -o bin/planet_wear.apk -D n_parallels=10
+
+res/drawable-hdpi/icon.png: art/icon.png
+	mkdir -p res/drawable-ldpi/ res/drawable-mdpi/ res/drawable-hdpi/ \
+		res/drawable-xhdpi/ res/drawable-xxhdpi/ res/drawable-xxxhdpi/
+	convert -resize 36x36   art/icon.png res/drawable-ldpi/icon.png
+	convert -resize 48x48   art/icon.png res/drawable-mdpi/icon.png
+	convert -resize 72x72   art/icon.png res/drawable-hdpi/icon.png
+	convert -resize 96x96   art/icon.png res/drawable-xhdpi/icon.png
+	convert -resize 144x144 art/icon.png res/drawable-xxhdpi/icon.png
+	convert -resize 192x192 art/icon.png res/drawable-xxxhdpi/icon.png
+
+assets/ld/earth.jpg:
+	mkdir -p assets/ld
+	convert -resize 2048x1024 assets/hd/earth.jpg assets/ld/earth.jpg
+	convert -resize 2048x1024 assets/hd/seas.jpg assets/ld/seas.jpg
+	convert -resize 2048x1024 assets/hd/clouds.png assets/ld/clouds.png
+	convert -resize 2048x1024 assets/hd/elevation.jpg assets/ld/elevation.jpg
+	convert -resize 2048x1024 assets/hd/lights.jpg assets/ld/lights.jpg

lib/gamnit/examples/globe/README

@@ -0,0 +1,13 @@
+Sample gamnit app rendering the earth with elevated surface, cloud layer, city lights and Phong lighting.
+
+# Possible variations
+
+It would have been possible to achieve the same result with different approaches.
+They should be explored as they could provide better performances or be easier to understand.
+
+* Use a single set of vertices, normals and indices because we only need spheres.
+* Alternatively, use one program per sphere.
+
+# Art
+
+Images credit: NASA, Visible Earth