lib/gamnit/textures.nit

   1 # This file is part of NIT ( http://www.nitlanguage.org ).
   2 #
   3 # Licensed under the Apache License, Version 2.0 (the "License");
   4 # you may not use this file except in compliance with the License.
   5 # You may obtain a copy of the License at
   6 #
   7 #     http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 # Unless required by applicable law or agreed to in writing, software
  10 # distributed under the License is distributed on an "AS IS" BASIS,
  11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 # See the License for the specific language governing permissions and
  13 # limitations under the License.
  14
  15 # Services to load textures, create subtextures and manage their life-cycle
  16 module textures
  17
  18 import display
  19
  20 # Abstract gamnit texture
  21 abstract class Texture
  22
  23         # Prepare a texture located at `path` within the `assets` folder
  24         new (path: Text) do return new TextureAsset(path.to_s)
  25
  26         # Root texture of which `self` is derived
  27         fun root: GamnitRootTexture is abstract
  28
  29         # Width in pixels of this texture
  30         var width = 0.0
  31
  32         # Height in pixels of this texture
  33         var height = 0.0
  34
  35         # Load this texture, force reloading it if `force`
  36         fun load(force: nullable Bool) do end
  37
  38         # Last error on this texture
  39         var error: nullable Error = null
  40
  41         # OpenGL handle to this texture
  42         fun gl_texture: Int do return root.gl_texture
  43
  44         # Prepare a subtexture from this texture, from the given pixel offsets
  45         fun subtexture(left, top, width, height: Numeric): GamnitSubtexture
  46         do
  47                 # Setup the subtexture
  48                 var subtex = new GamnitSubtexture(root, self, left.to_f, top.to_f, width.to_f, height.to_f)
  49                 return subtex
  50         end
  51
  52         # Offset of the left border on `root` from 0.0 to 1.0
  53         fun offset_left: Float do return 0.0
  54
  55         # Offset of the top border on `root` from 0.0 to 1.0
  56         fun offset_top: Float do return 0.0
  57
  58         # Offset of the right border on `root` from 0.0 to 1.0
  59         fun offset_right: Float do return 1.0
  60
  61         # Offset of the bottom border on `root` from 0.0 to 1.0
  62         fun offset_bottom: Float do return 1.0
  63 end
  64
  65 # Colorful small texture of 2x2 pixels
  66 class CheckerTexture
  67         super GamnitRootTexture
  68
  69         redef fun load(force)
  70         do
  71                 var pixels = [0xFFu8, 0x00u8, 0x00u8,
  72                               0x00u8, 0xFFu8, 0x00u8,
  73                               0x00u8, 0x00u8, 0xFFu8,
  74                               0xFFu8, 0xFFu8, 0xFFu8]
  75
  76                 var cpixels = new CByteArray.from(pixels)
  77
  78                 width = 2.0
  79                 height = 2.0
  80                 load_from_pixels(cpixels.native_array, 2, 2, gl_RGB)
  81
  82                 cpixels.destroy
  83         end
  84 end
  85
  86 # Texture with its own pixels
  87 class GamnitRootTexture
  88         super Texture
  89
  90         redef fun root do return self
  91
  92         # Has this texture been loaded yet?
  93         var loaded = false
  94
  95         redef var gl_texture = -1
  96
  97         init do all_root_textures.add self
  98
  99         private fun load_from_pixels(pixels: Pointer, width, height: Int, format: GLPixelFormat)
 100         do
 101                 var max_texture_size = glGetIntegerv(gl_MAX_TEXTURE_SIZE, 0)
 102                 if width > max_texture_size or height > max_texture_size then
 103                         error = new Error("Texture {self} width or height is over the GL_MAX_TEXTURE_SIZE of {max_texture_size}")
 104                         return
 105                 end
 106
 107                 glPixelStorei(gl_UNPACK_ALIGNEMENT, 1)
 108                 var tex = glGenTextures(1)[0]
 109                 gl_texture = tex
 110
 111                 glBindTexture(gl_TEXTURE_2D, tex)
 112                 glTexImage2D(gl_TEXTURE_2D, 0, format, width, height, 0, format, gl_UNSIGNED_BYTE, pixels)
 113
 114                 glHint(gl_GENERATE_MIPMAP_HINT, gl_NICEST)
 115                 glGenerateMipmap(gl_TEXTURE_2D)
 116         end
 117
 118         # Set whether this texture should be pixelated when drawn, otherwise it is interpolated
 119         fun pixelated=(pixelated: Bool)
 120         do
 121                 # TODO this service could be made available in `Texture` when using
 122                 # the kind of texture wrapper of gles v2 or maybe 3
 123
 124                 glBindTexture(gl_TEXTURE_2D, gl_texture)
 125
 126                 var param = if pixelated then gl_NEAREST else gl_LINEAR
 127                 glTexParameteri(gl_TEXTURE_2D, gl_TEXTURE_MIN_FILTER, param)
 128                 glTexParameteri(gl_TEXTURE_2D, gl_TEXTURE_MAG_FILTER, param)
 129         end
 130
 131         # Has this resource been deleted?
 132         var deleted = false
 133
 134         # Delete this texture and free all its resources
 135         #
 136         # Use caution with this service as the subtextures may rely on the deleted data.
 137         fun delete
 138         do
 139                 if deleted or not loaded then return
 140
 141                 deleted = true
 142         end
 143 end
 144
 145 # Texture loaded from the assets folder
 146 class TextureAsset
 147         super GamnitRootTexture
 148
 149         # Path to this texture within the `assets` folder
 150         var path: String
 151
 152         redef fun load(force)
 153         do
 154                 if loaded and force != true then return
 155
 156                 load_from_platform
 157
 158                 loaded = true
 159         end
 160
 161         # Partially load this texture from platform-specific features
 162         #
 163         # This method should fill `width`, `height` and `pixels`.
 164         private fun load_from_platform is abstract
 165
 166         redef fun to_s do return "<{class_name} path:{path}>"
 167 end
 168
 169 # Texture derived from another texture, does not own its pixels
 170 class GamnitSubtexture
 171         super Texture
 172
 173         redef var root
 174
 175         # Parent texture, from which this texture was created
 176         var parent: Texture
 177
 178         # Left border of this texture compared to `parent`
 179         var left: Float
 180
 181         # Top border of this texture compared to `parent`
 182         var top: Float
 183
 184         private fun set_wh(width, height: Float)
 185         is autoinit do
 186                 self.width = width
 187                 self.height = height
 188         end
 189
 190         redef fun load(force) do root.load(force)
 191
 192         redef var offset_left = parent.offset_left + left / root.width is lazy
 193         redef var offset_top = parent.offset_top + top / root.height is lazy
 194         redef var offset_right = offset_left + width / root.width is lazy
 195         redef var offset_bottom = offset_top + height / root.height is lazy
 196 end
 197
 198 redef class Sys
 199         # All declared root textures
 200         var all_root_textures = new TextureSet
 201 end
 202
 203 # Group of `Texture`
 204 class TextureSet
 205         super HashSet[Texture]
 206
 207         # Load all texture of this set
 208         fun load_all do for t in self do t.load
 209 end