X-Git-Url: http://nitlanguage.org

diff --git a/lib/gamnit/textures.nit b/lib/gamnit/textures.nit
index fd45ec5..271e688 100644
--- a/lib/gamnit/textures.nit
+++ b/lib/gamnit/textures.nit
@@ -12,12 +12,48 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# Services to load textures, create subtextures and manage their life-cycle
+# Load textures, create subtextures and manage their life-cycle
 module textures
 
 import display
 
-# Abstract gamnit texture
+# Texture composed of pixels, loaded from the assets folder by default
+#
+# Most textures should be created with `App` (as attributes)
+# for the method `on_create` to load them.
+#
+# ~~~
+# import gamnit::flat
+#
+# redef class App
+#     # Create the texture object, it will be loaded automatically
+#     var texture = new Texture("path/in/assets.png")
+#
+#     redef fun on_create()
+#     do
+#         # Let `on_create` load the texture
+#         super
+#
+#         # Use the texture
+#         var sprite = new Sprite(texture, new Point3d[Float](0.0, 0.0, 0.0))
+#         app.sprites.add sprite
+#     end
+# end
+# ~~~
+#
+# Otherwise, they can be loaded and error checked explicitly after `on_create`.
+#
+# ~~~nitish
+# var texture = new Texture("path/in/assets.png")
+# texture.load
+# var error = texture.error
+# if error != null then print_error error
+# ~~~
+#
+# A texture may also be created programmatically, like `CheckerTexture`,
+# or derived from another texture, using `subtexture`.
+# Textures with actual pixel data (not `Subtexture`) are `RootTexture`.
+# Texture loaded from the assets folder may in the PNG or JPG formats.
 abstract class Texture
 
 	# Prepare a texture located at `path` within the `assets` folder
@@ -62,24 +98,76 @@ abstract class Texture
 	fun offset_bottom: Float do return 1.0
 end
 
-# Colorful small texture of 2x2 pixels
+# Colorful small texture of 32x32 pixels by default
 class CheckerTexture
 	super RootTexture
 
+	# Width and height in pixels, defaults to 32
+	var size = 32 is optional
+
 	redef fun load(force)
 	do
-		var pixels = [0xFFu8, 0x00u8, 0x00u8,
-		              0x00u8, 0xFFu8, 0x00u8,
-		              0x00u8, 0x00u8, 0xFFu8,
-		              0xFFu8, 0xFFu8, 0xFFu8]
+		if gl_texture != -1 then return
+		load_checker size
+		loaded = true
+	end
+end
 
-		var cpixels = new CByteArray.from(pixels)
+# Custom texture with pixel values filled programmatically
+#
+# At creation, the texture is composed of `width` by `height` (rounded down)
+# transparent pixels. The pixels value can be set using `[]=`.
+#
+# ~~~
+# # Build a texture with 4 colors
+# var tex = new CustomTexture(2.0, 2.0)
+# tex[0, 0] = [1.0, 0.0, 0.0] # Red
+# tex[0, 1] = [0.0, 1.0, 0.0] # Green
+# tex[1, 0] = [0.0, 0.0, 1.0] # Blue
+# tex[1, 1] = [1.0, 1.0, 1.0, 0.5] # Transparent white
+# tex.load
+# ~~~
+class CustomTexture
+	super RootTexture
 
-		width = 2.0
-		height = 2.0
-		load_from_pixels(cpixels.native_array, 2, 2, gl_RGB)
+	redef var width
+	redef var height
+
+	private var cpixels = new CByteArray(4*width.to_i*height.to_i) is lazy
+
+	# Set the `color` of the pixel at `x`, `y` (from the top-left corner)
+	#
+	# The argument `color` should be an array of up to 4 floats (RGBA).
+	# If `color` has less than 4 items, the missing items are replaced by 1.0.
+	#
+	# Require: `not loaded and x < width.to_i and y < height.to_i`
+	fun []=(x, y: Int, color: Array[Float])
+	do
+		assert not loaded else print_error "{class_name}::[]= already loaded"
+		assert x < width.to_i and y < height.to_i else print_error "{class_name}::[] out of bounds"
+
+		# Simple conversion from [0.0..1.0] to [0..255]
+		var bytes = [for c in color do (c*255.0).round.to_i.clamp(0, 255).to_bytes.last]
+		while bytes.length < 4 do bytes.add 255u8
+
+		var offset = 4*(x + y*width.to_i)
+		for i in [0..4[ do cpixels[offset+i] = bytes[i]
+	end
+
+	redef fun load(force)
+	do
+		if loaded then return
+
+		# Round down the desired dimension
+		var width = width.to_i
+		var height = height.to_i
+		self.width = width.to_f
+		self.height = height.to_f
+
+		load_from_pixels(cpixels.native_array, width, height, gl_RGBA)
 
 		cpixels.destroy
+		loaded = true
 	end
 end
 
@@ -115,6 +203,31 @@ class RootTexture
 		glGenerateMipmap(gl_TEXTURE_2D)
 	end
 
+	private fun load_checker(size: Int)
+	do
+		var cpixels = new CByteArray(3*size*size)
+
+		var i = 0
+		for x in [0..size[ do
+			var quadrant_x = if x < size/2 then 0 else 1
+			for y in [0..size[ do
+				var quadrant_y = if y < size/2 then 0 else 1
+				var color = if quadrant_x == quadrant_y then
+					[0u8, 0u8, 0u8, 255u8]
+				else [255u8, 255u8, 255u8, 255u8]
+
+				for j in [0..3[ do cpixels[i+j] = color[j]
+				i += 3
+			end
+		end
+
+		width = size.to_f
+		height = size.to_f
+		load_from_pixels(cpixels.native_array, size, size, gl_RGB)
+
+		cpixels.destroy
+	end
+
 	# Set whether this texture should be pixelated when drawn, otherwise it is interpolated
 	fun pixelated=(pixelated: Bool)
 	do
@@ -154,6 +267,9 @@ class TextureAsset
 
 		load_from_platform
 
+		# If no pixel data was loaded, load the pixel default texture
+		if gl_texture == -1 then load_checker 32
+
 		loaded = true
 	end