Most textures should be created with App
(as attributes)
for the method create_scene
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 create_scene()
do
# Let `create_scene` 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 create_scene
.
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.
gamnit :: Texture :: defaultinit
gamnit :: Texture :: offset_bottom
Offset of the bottom border onroot
from 0.0 to 1.0
gamnit :: Texture :: offset_left
Offset of the left border onroot
from 0.0 to 1.0
gamnit :: Texture :: offset_right
Offset of the right border onroot
from 0.0 to 1.0
gamnit :: Texture :: offset_top
Offset of the top border onroot
from 0.0 to 1.0
gamnit :: Texture :: pixelated=
Should this texture be drawn pixelated when magnified? otherwise it is interpolatedgamnit :: Texture :: subtexture
Prepare a subtexture from this texture, from the given pixel offsetsgamnit :: Texture :: to_animation
Convert to a sprite animation atfps
speed with x
or y
frames
core :: Object :: class_factory
Implementation used byget_class
to create the specific class.
core :: Object :: defaultinit
gamnit :: Texture :: defaultinit
core :: Object :: is_same_instance
Return true ifself
and other
are the same instance (i.e. same identity).
core :: Object :: is_same_serialized
Isself
the same as other
in a serialization context?
core :: Object :: is_same_type
Return true ifself
and other
have the same dynamic type.
gamnit :: Texture :: offset_bottom
Offset of the bottom border onroot
from 0.0 to 1.0
gamnit :: Texture :: offset_left
Offset of the left border onroot
from 0.0 to 1.0
gamnit :: Texture :: offset_right
Offset of the right border onroot
from 0.0 to 1.0
gamnit :: Texture :: offset_top
Offset of the top border onroot
from 0.0 to 1.0
core :: Object :: output_class_name
Display class name on stdout (debug only).gamnit :: Texture :: pixelated=
Should this texture be drawn pixelated when magnified? otherwise it is interpolatedgamnit :: Texture :: subtexture
Prepare a subtexture from this texture, from the given pixel offsetsgamnit :: Texture :: to_animation
Convert to a sprite animation atfps
speed with x
or y
frames
gamnit :: Subtexture
Texture derived from another texture, does not own its pixelsparent
root
texture
# Texture composed of pixels, loaded from the assets folder by default
#
# Most textures should be created with `App` (as attributes)
# for the method `create_scene` 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 create_scene()
# do
# # Let `create_scene` 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 `create_scene`.
#
# ~~~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
new (path: Text) do return new TextureAsset(path.to_s)
# Root texture from which `self` is derived
fun root: RootTexture is abstract
# Width in pixels of this texture
var width = 0.0
# Height in pixels of this texture
var height = 0.0
# Load this texture, force reloading it if `force`
fun load(force: nullable Bool) do end
# Last error on this texture
var error: nullable Error = null
# OpenGL handle to this texture
fun gl_texture: Int do return root.gl_texture
# Prepare a subtexture from this texture, from the given pixel offsets
fun subtexture(left, top, width, height: Numeric): Subtexture
do
return new AbsoluteSubtexture(self, left.to_f, top.to_f, width.to_f, height.to_f)
end
# Offset of the left border on `root` from 0.0 to 1.0
fun offset_left: Float do return 0.0
# Offset of the top border on `root` from 0.0 to 1.0
fun offset_top: Float do return 0.0
# Offset of the right border on `root` from 0.0 to 1.0
fun offset_right: Float do return 1.0
# Offset of the bottom border on `root` from 0.0 to 1.0
fun offset_bottom: Float do return 1.0
# Should this texture be drawn pixelated when magnified? otherwise it is interpolated
#
# This setting affects all the textures based on the same pixel data, or `root`.
#
# Must be set after a successful call to `load`.
fun pixelated=(pixelated: Bool)
do
if root.gl_texture == -1 then return
# TODO do not modify `root` by using *sampler objects* in glesv3
glBindTexture(gl_TEXTURE_2D, root.gl_texture)
var param = if pixelated then gl_NEAREST else gl_LINEAR
glTexParameteri(gl_TEXTURE_2D, gl_TEXTURE_MAG_FILTER, param)
end
end
lib/gamnit/textures.nit:20,1--113,3
redef class Texture
# Vertices coordinates of the base geometry
#
# Defines the default width and height of related sprites.
private var vertices: Array[Float] is lazy do
var w = width
var h = height
return [-0.5*w, 0.5*h, 0.0,
0.5*w, 0.5*h, 0.0,
-0.5*w, -0.5*h, 0.0,
0.5*w, -0.5*h, 0.0]
end
# Coordinates of this texture on the `root` texture, in `[0..1.0]`
private var texture_coords: Array[Float] is lazy do
var l = offset_left
var r = offset_right
var b = offset_bottom
var t = offset_top
return [l, t,
r, t,
l, b,
r, b]
end
# Coordinates of this texture on the `root` texture, inverting the X axis
private var texture_coords_invert_x: Array[Float] is lazy do
var l = offset_left
var r = offset_right
var b = offset_bottom
var t = offset_top
return [r, t,
l, t,
r, b,
l, b]
end
# Convert to a sprite animation at `fps` speed with `x` or `y` frames
#
# The arguments `x` and `y` set the number of frames in the texture.
# Use `x` for an horizontal arrangement or `y` for vertical.
# One and only one of the arguments must be different than 0,
# as an animation can only be on a line and cannot wrap.
fun to_animation(fps: Float, x, y: Int): Animation
do
assert (x == 0) != (y == 0)
var n_frames = x.max(y)
var frames = new Array[Texture]
var dx = (x/n_frames).to_f/n_frames.to_f
var dy = (y/n_frames).to_f/n_frames.to_f
var w = if x == 0 then 1.0 else dx
var h = if y == 0 then 1.0 else dy
var left = 0.0
var top = 0.0
for i in n_frames.times do
frames.add new RelativeSubtexture(root, left, top, left+w, top+h)
left += dx
top += dy
end
return new Animation(frames, fps)
end
end
lib/gamnit/flat/flat_core.nit:567,1--632,3