bestguigui_lab 0.12.0 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 232fd8759bb525cb0e243e8fa4eccfb4fa94dc9b4a0f6fb7ce73a003f52d505d
-  data.tar.gz: 666da34d4cea8a5f3d2efec9564e6d610854a249ffd9bf484d3b1a41dce7cc3a
+  metadata.gz: d384a7e131d476249187d97515f7f62f9c165702063908cfb7852ef261300d6c
+  data.tar.gz: 523552046db0a7e19c10556a4782ad37ad8ee272053d037345985717ed698fe1
 SHA512:
-  metadata.gz: 8950ebdc674b3141c96dd79872f55af0ac520c1e2bfc13270cffd887b337d7dc36c6890b7a28c86f6136bddd8c28aad565d274ef7830e97e2747e427e22c7752
-  data.tar.gz: '039120dc1ae9996040c279190835707d89ebdf935b7ffd6efc4cd5323b4ed0a2dd80f2e4b2796f2ee0c6ae4a517ea6ec6a1f349c77a820204e99d0ba1da02d8a'
+  metadata.gz: ed74df8e29395e4545125d07f8a53d17a927b59d2fe235f3c8ac75d22dcc0d6e0ff912775b03c2c9f3a0799c369c3d24e0c05c1ed466bbea2842c79fbe42b09c
+  data.tar.gz: 1441f99ec534d3cade5502c36c1c1ebcc6a3ddfaeda66ac1affd710405490f7a01f67a986242cf2b1440d6d5c161bd050a81c7993e5b1235644df311738b7238

data/lib/bestguigui_lab/assets.rb

@@ -10,7 +10,8 @@ module Bestguigui
         @sounds = Hash.new { |cache, path| cache[path] = Gosu::Sample.new(path) }
         @songs = Hash.new { |cache, path| cache[path] = Gosu::Song.new(path) }
         @fonts = Hash.new { |cache, key| cache[key] = Gosu::Font.new(key[1], name: key[0]) }
-        @models = Hash.new { |cache, path| cache[path] = ObjModel.new(path) }
+        @models = Hash.new { |cache, key| cache[key] = ObjModel.new(key[0], shading: key[1]) }
+        @gltf_models = Hash.new { |cache, key| cache[key] = GLTFModel.new(key[0], shading: key[1], rigid: key[2]) }
         @textures = Hash.new { |cache, path| cache[path] = GLTexture.new(path) }
         @frames = Hash.new { |cache, key| cache[key] = Gosu::Image.load_tiles(key[0], key[1], key[2], retro: true) }
 
@@ -28,7 +29,8 @@ module Bestguigui
             @fonts[[path, size]]
         end
 
-        def self.model(name) = @models[resolve(name)]
+        def self.model(name, shading: :texture) = @models[[resolve(name), shading]]
+        def self.gltf_model(name, shading: :texture, rigid: false) = @gltf_models[[resolve(name), shading, rigid]]
         def self.texture(name) = @textures[resolve(name)]
         def self.frames(name, tile_width, tile_height) = @frames[[resolve(name), tile_width, tile_height]]
     end

data/lib/bestguigui_lab/gl_buffer.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Bestguigui
+    # Envoie un buffer de floats vers un VBO OpenGL (GL_ARRAY_BUFFER) et
+    # renvoie son nom — utilisé par ObjModel pour charger sa géométrie.
+    class GLBuffer
+        def self.upload(data)
+            name_buffer = "\x00" * 4
+            glGenBuffers(1, name_buffer)
+            vbo = name_buffer.unpack1('L')
+
+            glBindBuffer(GL_ARRAY_BUFFER, vbo)
+            glBufferData(GL_ARRAY_BUFFER, data.bytesize, data, GL_STATIC_DRAW)
+
+            vbo
+        end
+    end
+end

data/lib/bestguigui_lab/gltf_animation.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Bestguigui
+    # Un clip d'animation glTF : un nom, une duree, et des canaux — chacun
+    # anime UNE propriete (:translation, :rotation ou :scale) d'UN noeud.
+    # local_pose_at echantillonne tous les canaux a un instant donne ; ne
+    # renvoie que les noeuds/proprietes reellement animes ici — GLTFSkeleton
+    # complete le reste avec la pose de repos de chaque noeud.
+    class GLTFAnimation
+        attr_reader :name, :duration
+
+        # channels : tableau de {node:, path:, times:, values:, interpolation:}
+        # — times triees (secondes), values un tableau de tableaux (une entree
+        # par keyframe : 3 composantes pour translation/scale, 4 pour
+        # rotation), interpolation 'LINEAR' ou 'STEP' (le seul autre cas
+        # standard, CUBICSPLINE, n'est pas gere — retombe sur un LINEAR).
+        def initialize(name, channels)
+            @name = name
+            @channels = channels
+            @duration = channels.map { |channel| channel[:times].last || 0.0 }.max || 0.0
+        end
+
+        def local_pose_at(time)
+            pose = Hash.new { |h, k| h[k] = {} }
+            @channels.each { |channel| pose[channel[:node]][channel[:path]] = sample_channel(channel, time) }
+            pose
+        end
+
+        private
+
+        def sample_channel(channel, time)
+            times = channel[:times]
+            values = channel[:values]
+            return values.first if times.size == 1 || time <= times.first
+            return values.last if time >= times.last
+
+            index = times.rindex { |t| t <= time }
+            interpolate(channel, values[index], values[index + 1], segment_progress(times, index, time))
+        end
+
+        def segment_progress(times, index, time)
+            span = times[index + 1] - times[index]
+            span.zero? ? 0.0 : (time - times[index]) / span
+        end
+
+        def interpolate(channel, from, dest, progress)
+            return from if channel[:interpolation] == 'STEP'
+            return GLTFMath.quat_slerp(from, dest, progress) if channel[:path] == :rotation
+
+            GLTFMath.vec3_lerp(from, dest, progress)
+        end
+    end
+end

data/lib/bestguigui_lab/gltf_animator.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Bestguigui
+    # Lit le temps d'une ou deux GLTFAnimation (pendant une transition) et
+    # renvoie la pose locale resultante — fondu enchaine entre les deux le
+    # temps de la transition, jamais de coupure nette d'une animation a
+    # l'autre. GLTFModel#play/#update s'en servent directement.
+    class GLTFAnimator
+        def initialize
+            @current = nil
+            @time = 0.0
+            @loop = true
+            @previous = nil
+            @previous_time = 0.0
+            @previous_loop = true
+            @transition_duration = 0.0
+            @transition_elapsed = 0.0
+        end
+
+        # loop: rejoue en boucle une fois la fin atteinte. transition: duree
+        # (secondes) du fondu enchaine depuis l'animation en cours ; 0 = coupe
+        # net (par defaut pour la toute premiere animation, rien avant elle).
+        def play(animation, loop: true, transition: 0.0)
+            transitioning = transition.positive? && @current
+            @previous = transitioning ? @current : nil
+            @previous_time = @time
+            @previous_loop = @loop
+            @current = animation
+            @loop = loop
+            @time = 0.0
+            @transition_duration = transition
+            @transition_elapsed = 0.0
+        end
+
+        def update(dt)
+            return unless @current
+
+            @time = advance_time(@time, dt, @current, @loop)
+            return unless @previous
+
+            @previous_time = advance_time(@previous_time, dt, @previous, @previous_loop)
+            @transition_elapsed += dt
+            @previous = nil if @transition_elapsed >= @transition_duration
+        end
+
+        # Pose locale courante, fondue enchainee si une transition est en
+        # cours — Hash node => {translation:/rotation:/scale: => [...]},
+        # partiel (seuls les noeuds/proprietes reellement animes ici).
+        def pose
+            return {} unless @current
+
+            current_pose = @current.local_pose_at(@time)
+            return current_pose unless @previous
+
+            blend_t = @transition_duration.zero? ? 1.0 : (@transition_elapsed / @transition_duration).clamp(0.0, 1.0)
+            blend_poses(@previous.local_pose_at(@previous_time), current_pose, blend_t)
+        end
+
+        private
+
+        def advance_time(time, dt, animation, loop)
+            time += dt
+            return time % animation.duration if loop && animation.duration.positive?
+
+            [time, animation.duration].min
+        end
+
+        def blend_poses(from_pose, dest_pose, progress)
+            nodes = from_pose.keys | dest_pose.keys
+            nodes.to_h { |node| [node, blend_node(from_pose[node], dest_pose[node], progress)] }
+        end
+
+        def blend_node(from, dest, progress)
+            from ||= {}
+            dest ||= {}
+            (from.keys | dest.keys).to_h { |path| [path, blend_property(path, from[path], dest[path], progress)] }
+        end
+
+        # Si une seule des deux animations definit cette propriete pour ce
+        # noeud, pas de vraie valeur "avant" a interpoler — on la garde telle
+        # quelle plutot que d'inventer une pose de depart arbitraire.
+        def blend_property(path, from, dest, progress)
+            return dest unless from
+            return from unless dest
+            return GLTFMath.quat_slerp(from, dest, progress) if path == :rotation
+
+            GLTFMath.vec3_lerp(from, dest, progress)
+        end
+    end
+end

data/lib/bestguigui_lab/gltf_buffer.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Bestguigui
+    # Parse un conteneur .glb (glTF binaire, un seul fichier auto-suffisant) :
+    # en-tete (magic/version/longueur) puis des chunks JSON et BIN — le seul
+    # buffer supporte est celui-la, embarque, jamais un fichier .bin externe
+    # reference par URI. #read_accessor lit un tableau glTF (positions,
+    # indices, temps de keyframes...) depuis le chunk BIN, en suivant
+    # bufferView/accessor comme le decrit la specification.
+    class GLTFBuffer
+        # component type (glTF) => [directive String#unpack, octets]
+        COMPONENT_TYPES = {
+            5120 => ['c', 1], 5121 => ['C', 1], 5122 => ['s<', 2],
+            5123 => ['v', 2], 5125 => ['V', 4], 5126 => ['e', 4]
+        }.freeze
+        TYPE_COMPONENT_COUNTS = { 'SCALAR' => 1, 'VEC2' => 2, 'VEC3' => 3, 'VEC4' => 4, 'MAT4' => 16 }.freeze
+
+        attr_reader :json
+
+        def initialize(path)
+            chunks = read_chunks(File.binread(path))
+            @json = JSON.parse(chunks.fetch('JSON'))
+            @bin = chunks['BIN']
+        end
+
+        def read_accessor(index)
+            accessor = @json['accessors'][index]
+            format, size, components, stride, base = accessor_layout(accessor)
+
+            Array.new(accessor['count']) { |i| read_element(base + (i * stride), format, size, components) }
+        end
+
+        # Sous-chaine brute du chunk BIN, pour une image embarquee (cf.
+        # GLTFModel#load_image) — pas un accessor, directement bufferView.
+        def read_buffer_view(index)
+            view = @json['bufferViews'][index]
+            @bin[(view['byteOffset'] || 0), view['byteLength']]
+        end
+
+        private
+
+        # format/size (cf. COMPONENT_TYPES), nombre de composantes (cf.
+        # TYPE_COMPONENT_COUNTS), pas et offset de depart en octets dans le
+        # chunk BIN pour cet accessor.
+        def accessor_layout(accessor)
+            view = @json['bufferViews'][accessor['bufferView']]
+            format, size = COMPONENT_TYPES.fetch(accessor['componentType'])
+            components = TYPE_COMPONENT_COUNTS.fetch(accessor['type'])
+            stride = view['byteStride'] || (size * components)
+            base = (view['byteOffset'] || 0) + (accessor['byteOffset'] || 0)
+            [format, size, components, stride, base]
+        end
+
+        def read_chunks(data)
+            chunks = {}
+            offset = 12 # apres l'en-tete de 12 octets (magic, version, longueur totale)
+            while offset < data.bytesize
+                chunk_length, chunk_type = data[offset, 8].unpack('Va4')
+                chunks[chunk_type.delete("\x00")] = data[offset + 8, chunk_length]
+                offset += 8 + chunk_length
+            end
+            chunks
+        end
+
+        def read_element(offset, format, size, components)
+            values = @bin[offset, size * components].unpack("#{format}#{components}")
+            components == 1 ? values.first : values
+        end
+    end
+end

data/lib/bestguigui_lab/gltf_math.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module Bestguigui
+    # Petite boite a outils matrices 4x4 / quaternions pour GLTFModel —
+    # matrices colonne-majeur (convention glTF). Jamais envoyees a la pile
+    # OpenGL (glLoadMatrixf) : uniquement du calcul CPU pour le skinning
+    # (voir GLTFPrimitive#skin!), donc aucune contrainte de convention avec
+    # le reste du kit (Render3D/ObjModel s'appuient sur glTranslatef/
+    # glRotatef, jamais sur des matrices explicites).
+    # rubocop:disable Naming/MethodParameterName, Metrics/AbcSize, Style/ParallelAssignment
+    # -- noms mathematiques usuels (a, b, m, p, q, r, s, t, v...) et arithmetique
+    # vectorielle deroulee (pas de boucle a extraire) partout dans cette classe.
+    class GLTFMath
+        def self.identity
+            [
+                1.0, 0.0, 0.0, 0.0,
+                0.0, 1.0, 0.0, 0.0,
+                0.0, 0.0, 1.0, 0.0,
+                0.0, 0.0, 0.0, 1.0
+            ]
+        end
+
+        # Compose T * R * S : t/s par defaut [0,0,0]/[1,1,1], r (quaternion
+        # [x, y, z, w]) par defaut la rotation identite.
+        def self.matrix_from_trs(t, r, s)
+            m = quat_to_matrix(r || [0.0, 0.0, 0.0, 1.0])
+            scale = s || [1.0, 1.0, 1.0]
+            (0..2).each { |col| (0..2).each { |row| m[(col * 4) + row] *= scale[col] } }
+            m[12], m[13], m[14] = t || [0.0, 0.0, 0.0]
+            m
+        end
+
+        def self.quat_to_matrix(q)
+            x, y, z, w = q
+            xx, yy, zz = x * x, y * y, z * z
+            xy, xz, yz = x * y, x * z, y * z
+            wx, wy, wz = w * x, w * y, w * z
+            [
+                1 - (2 * (yy + zz)), 2 * (xy + wz), 2 * (xz - wy), 0.0,
+                2 * (xy - wz), 1 - (2 * (xx + zz)), 2 * (yz + wx), 0.0,
+                2 * (xz + wy), 2 * (yz - wx), 1 - (2 * (xx + yy)), 0.0,
+                0.0, 0.0, 0.0, 1.0
+            ]
+        end
+
+        # c = a * b (b applique en premier).
+        def self.multiply(a, b)
+            Array.new(16) do |i|
+                col = i / 4
+                row = i % 4
+                (0..3).sum { |k| a[(k * 4) + row] * b[(col * 4) + k] }
+            end
+        end
+
+        def self.transform_point(m, p)
+            x, y, z = p
+            [
+                (m[0] * x) + (m[4] * y) + (m[8] * z) + m[12],
+                (m[1] * x) + (m[5] * y) + (m[9] * z) + m[13],
+                (m[2] * x) + (m[6] * y) + (m[10] * z) + m[14]
+            ]
+        end
+
+        # Comme transform_point, sans la translation — pour une normale.
+        # Simplification : ignore l'inverse-transposee (correcte pour une
+        # echelle uniforme, l'essentiel des rigs de jam ; peut legerement
+        # deformer une normale sous une echelle non uniforme sur un joint).
+        def self.transform_vector(m, v)
+            x, y, z = v
+            [
+                (m[0] * x) + (m[4] * y) + (m[8] * z),
+                (m[1] * x) + (m[5] * y) + (m[9] * z),
+                (m[2] * x) + (m[6] * y) + (m[10] * z)
+            ]
+        end
+
+        def self.vec3_lerp(a, b, t) = (0..2).map { |i| a[i] + ((b[i] - a[i]) * t) }
+
+        # Interpolation spherique entre deux quaternions [x, y, z, w] ; bascule
+        # sur un lerp normalise si l'angle est trop petit pour diviser dessus.
+        def self.quat_slerp(a, b, t)
+            dot = (0..3).sum { |i| a[i] * b[i] }
+            b, dot = negate(b), -dot if dot.negative?
+            return normalize_quat(vec4_lerp(a, b, t)) if dot > 0.9995
+
+            slerp_by_angle(a, b, dot, t)
+        end
+
+        def self.vec4_lerp(a, b, t) = (0..3).map { |i| a[i] + ((b[i] - a[i]) * t) }
+
+        def self.negate(v) = v.map(&:-@)
+
+        def self.normalize_quat(q)
+            length = Math.sqrt(q.sum { |c| c * c })
+            q.map { |c| c / length }
+        end
+
+        def self.slerp_by_angle(a, b, dot, t)
+            theta0 = Math.acos(dot.clamp(-1.0, 1.0))
+            sin_theta0 = Math.sin(theta0)
+            theta = theta0 * t
+            s0 = Math.cos(theta) - (dot * Math.sin(theta) / sin_theta0)
+            s1 = Math.sin(theta) / sin_theta0
+            (0..3).map { |i| (a[i] * s0) + (b[i] * s1) }
+        end
+
+        # Inverse generale d'une matrice 4x4, par elimination de Gauss-Jordan
+        # — necessaire pour repasser de l'espace monde d'un noeud de maillage
+        # a son espace local (cf. GLTFSkeleton#joint_matrices). Rare dans la
+        # boucle de rendu (quelques appels par frame, pas par sommet) : la
+        # simplicite prime ici sur la performance.
+        # rubocop:disable-next Metrics/MethodLength -- élimination de Gauss-Jordan, ne se découpe pas proprement
+        def self.invert(m)
+            rows = m.each_slice(4).to_a.transpose.map(&:dup)
+            inverse = Array.new(4) { |i| Array.new(4) { |j| i == j ? 1.0 : 0.0 } }
+
+            4.times do |col|
+                pivot_row = (col...4).max_by { |r| rows[r][col].abs }
+                rows[col], rows[pivot_row] = rows[pivot_row], rows[col]
+                inverse[col], inverse[pivot_row] = inverse[pivot_row], inverse[col]
+
+                pivot = rows[col][col]
+                raise ArgumentError, 'matrice non inversible' if pivot.abs < 1e-9
+
+                4.times do |k|
+                    rows[col][k] /= pivot
+                    inverse[col][k] /= pivot
+                end
+                eliminate_column(rows, inverse, col)
+            end
+
+            inverse.transpose.flatten
+        end
+
+        def self.eliminate_column(rows, inverse, col)
+            4.times do |row|
+                next if row == col
+
+                factor = rows[row][col]
+                4.times do |k|
+                    rows[row][k] -= factor * rows[col][k]
+                    inverse[row][k] -= factor * inverse[col][k]
+                end
+            end
+        end
+    end
+    # rubocop:enable Naming/MethodParameterName, Metrics/AbcSize, Style/ParallelAssignment
+end

data/lib/bestguigui_lab/gltf_model.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require 'tempfile'
+
+module Bestguigui
+    # Charge un modele .glb (glTF binaire, un seul fichier auto-suffisant —
+    # voir GLTFBuffer) : squelette et animations (voir GLTFSkeleton/
+    # GLTFAnimation/GLTFAnimator), rendu en shading: :texture (par defaut) ou
+    # :gouraud (voir GouraudShading), sans aucun shader — le skinning se fait
+    # sur le CPU (voir GLTFPrimitive). Un seul skin/squelette par fichier
+    # (cf. GLTFSkeleton).
+    #
+    #   model = Bestguigui::Assets.gltf_model('assets/jill.glb')
+    #   model.play('Idle')
+    #   # dans update(dt)/draw de ta Scene :
+    #   model.update(dt)
+    #   model.draw
+    #   model.play('walk', transition: 0.3) # fondu enchaine de 0.3s vers walk
+    #
+    # rigid: true interdit toute deformation du maillage par mise a
+    # l'echelle d'un os (seules rotation et translation l'articulent) — voir
+    # GLTFSkeleton.
+    class GLTFModel
+        def initialize(path, shading: :texture, rigid: false)
+            super()
+            @shading = shading
+            @rigid = rigid
+            load_scene(path)
+            @animator = GLTFAnimator.new
+            reskin
+        end
+
+        def animation_names = @animations.keys
+
+        def play(name, loop: true, transition: 0.0)
+            animation = @animations.fetch(name) { raise ArgumentError, "animation glTF inconnue : #{name.inspect}" }
+            @animator.play(animation, loop: loop, transition: transition)
+        end
+
+        def update(dt)
+            @animator.update(dt)
+            reskin
+        end
+
+        def draw
+            @primitives.each(&:draw)
+        end
+
+        private
+
+        def load_scene(path)
+            @buffer = GLTFBuffer.new(path)
+            @json = @buffer.json
+            @textures = (@json['images'] || []).map { |image| load_image(image) }
+            @skeleton = build_skeleton
+            @animations = build_animations
+            @primitives = build_primitives
+        end
+
+        def reskin
+            pose = @animator.pose
+            @primitives.each { |primitive| primitive.skin!(@skeleton.joint_matrices(pose, primitive.mesh_node)) }
+        end
+
+        # --- Squelette (un seul skin, cf. GLTFSkeleton) ---
+
+        def build_skeleton
+            skin = @json['skins'][0]
+            inverse_bind_matrices = @buffer.read_accessor(skin['inverseBindMatrices'])
+            GLTFSkeleton.new(@json['nodes'], skin['joints'], inverse_bind_matrices, rigid: @rigid)
+        end
+
+        # --- Animations (cf. GLTFAnimation) ---
+
+        def build_animations
+            (@json['animations'] || []).to_h do |animation|
+                channels = animation['channels'].map { |channel| build_channel(channel, animation['samplers']) }
+                [animation['name'], GLTFAnimation.new(animation['name'], channels)]
+            end
+        end
+
+        def build_channel(channel, samplers)
+            sampler = samplers[channel['sampler']]
+            {
+                node: channel['target']['node'],
+                path: channel['target']['path'].to_sym,
+                times: @buffer.read_accessor(sampler['input']),
+                values: @buffer.read_accessor(sampler['output']),
+                interpolation: sampler['interpolation'] || 'LINEAR'
+            }
+        end
+
+        # --- Maillages (cf. GLTFPrimitive) ---
+
+        def build_primitives
+            primitives = []
+            @json['nodes'].each_with_index do |node, node_index|
+                next unless node['mesh']
+
+                @json['meshes'][node['mesh']]['primitives'].each do |primitive|
+                    primitives << build_primitive(primitive, node_index)
+                end
+            end
+            primitives
+        end
+
+        def build_primitive(primitive, node_index)
+            attributes = primitive['attributes']
+            geometry = {
+                positions: @buffer.read_accessor(attributes['POSITION']),
+                normals: @buffer.read_accessor(attributes['NORMAL']),
+                texcoords: @buffer.read_accessor(attributes['TEXCOORD_0']),
+                joints: @buffer.read_accessor(attributes['JOINTS_0']),
+                weights: @buffer.read_accessor(attributes['WEIGHTS_0']),
+                indices: @buffer.read_accessor(primitive['indices'])
+            }
+            GLTFPrimitive.new(geometry, primitive_texture(primitive['material']), node_index, shading: @shading)
+        end
+
+        def primitive_texture(material_index)
+            return nil unless material_index
+
+            texture_ref = @json['materials'][material_index].dig('pbrMetallicRoughness', 'baseColorTexture')
+            return nil unless texture_ref
+
+            @textures[@json['textures'][texture_ref['index']]['source']]
+        end
+
+        # --- Texture embarquee : ecrite dans un fichier temporaire le temps
+        # du chargement (Gosu::Image.new ne sait lire qu'un chemin de
+        # fichier, pas un blob PNG/JPEG deja en memoire). Le fichier est
+        # ferme AVANT que Gosu ne le lise puis explicitement supprime juste
+        # apres : sous Windows, un fichier encore ouvert en ecriture ne peut
+        # pas etre rouvert en lecture par un autre appel (contrairement a
+        # POSIX, ou Tempfile.create avec bloc aurait suffi).
+        def load_image(image_json)
+            return nil unless image_json['bufferView']
+
+            bytes = @buffer.read_buffer_view(image_json['bufferView'])
+            extension = image_json['mimeType'] == 'image/jpeg' ? '.jpg' : '.png'
+            write_temp_texture(bytes, extension)
+        end
+
+        def write_temp_texture(bytes, extension)
+            file = Tempfile.new(['gltf_texture', extension])
+            file.binmode
+            file.write(bytes)
+            file.close
+            GLTexture.new(file.path)
+        ensure
+            file&.unlink
+        end
+    end
+end

data/lib/bestguigui_lab/gltf_primitive.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Bestguigui
+    # Un sous-maillage skinne d'un GLTFModel : geometrie de repos (espace du
+    # noeud squelette — position/normale/UV/joints/poids), indices et
+    # texture. #skin! recalcule les sommets deformes sur le CPU (aucun
+    # shader dans ce kit — meme philosophie que GouraudShading) et les
+    # renvoie au VBO ; #draw les affiche.
+    class GLTFPrimitive
+        FLOATS_PER_VERTEX = 8 # position (3) + texcoord (2) + normale ou teinte Gouraud (3)
+        STRIDE = FLOATS_PER_VERTEX * 4 # 4 octets par float
+
+        attr_reader :mesh_node
+
+        # geometry : {positions:, normals:, texcoords:, joints:, weights:,
+        # indices:} (tableaux deja decodes par GLTFModel). mesh_node : indice
+        # du noeud qui porte ce maillage (cf. GLTFSkeleton#joint_matrices).
+        def initialize(geometry, texture, mesh_node, shading: :texture)
+            assign_geometry(geometry)
+            @texture = texture || GLTexture.blank
+            @mesh_node = mesh_node
+            @gouraud = GouraudShading.new if shading == :gouraud
+            @material_color = [1.0, 1.0, 1.0]
+            @vertex_count = @positions.length
+            @vbo = GLBuffer.upload(Array.new(@vertex_count * FLOATS_PER_VERTEX, 0.0).pack('F*'))
+            @ibo = upload_index_buffer
+        end
+
+        # joint_matrices : une matrice par joint (meme ordre que WEIGHTS_0/
+        # JOINTS_0, cf. GLTFSkeleton#joint_matrices). A appeler avant chaque
+        # draw ou la pose a change (typiquement une fois par frame, depuis
+        # GLTFModel#update).
+        def skin!(joint_matrices)
+            data = Array.new(@vertex_count) { |i| skin_vertex(i, joint_matrices) }.flatten.pack('F*')
+            glBindBuffer(GL_ARRAY_BUFFER, @vbo)
+            glBufferSubData(GL_ARRAY_BUFFER, 0, data.bytesize, data)
+        end
+
+        def draw
+            glEnable(GL_TEXTURE_2D)
+            glBindTexture(GL_TEXTURE_2D, @texture.tex_name)
+            glBindBuffer(GL_ARRAY_BUFFER, @vbo)
+            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, @ibo)
+
+            enable_vertex_arrays
+            glDrawElements(GL_TRIANGLES, @indices.length, GL_UNSIGNED_INT, 0)
+            disable_vertex_arrays
+
+            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0)
+            glBindBuffer(GL_ARRAY_BUFFER, 0)
+            glDisable(GL_TEXTURE_2D)
+        end
+
+        private
+
+        def assign_geometry(geometry)
+            @positions = geometry[:positions]
+            @normals = geometry[:normals]
+            @texcoords = geometry[:texcoords]
+            @joints = geometry[:joints]
+            @weights = geometry[:weights]
+            @indices = geometry[:indices]
+        end
+
+        def upload_index_buffer
+            name_buffer = "\x00" * 4
+            glGenBuffers(1, name_buffer)
+            ibo = name_buffer.unpack1('L')
+
+            data = @indices.pack('L*')
+            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo)
+            glBufferData(GL_ELEMENT_ARRAY_BUFFER, data.bytesize, data, GL_STATIC_DRAW)
+            ibo
+        end
+
+        # Position/normale deformees par la moyenne ponderee (jusqu'a 4
+        # joints par sommet) des matrices de skinning courantes — le calcul
+        # classique du "linear blend skinning". extra est la normale
+        # deformee (shading: :texture) ou une teinte Gouraud recalculee a
+        # partir d'elle (shading: :gouraud, cf. GouraudShading) : la lumiere
+        # simulee suit donc l'animation, pas seulement la pose de repos.
+        def skin_vertex(index, joint_matrices)
+            joints = @joints[index]
+            weights = @weights[index]
+            position = blend_vector(@positions[index], joints, weights, joint_matrices) do |m, v|
+                GLTFMath.transform_point(m, v)
+            end
+            normal = blend_vector(@normals[index], joints, weights, joint_matrices) do |m, v|
+                GLTFMath.transform_vector(m, v)
+            end
+            extra = @gouraud ? @gouraud.vertex_color(normal, @material_color) : normal
+
+            position + @texcoords[index] + extra
+        end
+
+        def blend_vector(base, joints, weights, matrices)
+            result = [0.0, 0.0, 0.0]
+            joints.each_with_index do |joint_index, k|
+                weight = weights[k]
+                next if weight.zero?
+
+                transformed = yield(matrices[joint_index], base)
+                3.times { |i| result[i] += transformed[i] * weight }
+            end
+            result
+        end
+
+        def enable_vertex_arrays
+            glEnableClientState(GL_VERTEX_ARRAY)
+            glEnableClientState(GL_TEXTURE_COORD_ARRAY)
+            glVertexPointer(3, GL_FLOAT, STRIDE, 0)
+            glTexCoordPointer(2, GL_FLOAT, STRIDE, 3 * 4)
+            @gouraud ? enable_color_array : enable_normal_array
+        end
+
+        def enable_color_array
+            glEnableClientState(GL_COLOR_ARRAY)
+            glColorPointer(3, GL_FLOAT, STRIDE, 5 * 4)
+        end
+
+        def enable_normal_array
+            glEnableClientState(GL_NORMAL_ARRAY)
+            glNormalPointer(GL_FLOAT, STRIDE, 5 * 4)
+        end
+
+        def disable_vertex_arrays
+            glDisableClientState(@gouraud ? GL_COLOR_ARRAY : GL_NORMAL_ARRAY)
+            glDisableClientState(GL_TEXTURE_COORD_ARRAY)
+            glDisableClientState(GL_VERTEX_ARRAY)
+        end
+    end
+end

data/lib/bestguigui_lab/gltf_skeleton.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Bestguigui
+    # Hierarchie de noeuds glTF (pose de repos + parente) et son unique skin
+    # (liste de joints + matrices d'inverse bind pose, deja decodees par
+    # GLTFModel) : calcule, a partir d'une pose partielle (cf.
+    # GLTFAnimator#pose), la matrice monde de chaque noeud puis la matrice de
+    # skinning finale de chaque joint pour un noeud de maillage donne.
+    #
+    # Un seul skin gere (celui d'indice 0) : suffisant pour un personnage,
+    # pas pour plusieurs squelettes independants dans le meme fichier.
+    class GLTFSkeleton
+        Node = Struct.new(:translation, :rotation, :scale, :children, :parent)
+
+        # rigid: true ignore la mise a l'echelle de CHAQUE noeud (pose de
+        # repos ET animee) — seules rotation et translation bougent les os.
+        # Utile pour un squelette assemble a la main a partir de petits
+        # morceaux, ou une mise a l'echelle (voulue ou juste un artefact
+        # d'export, ex. 0.999998 au lieu de 1) etirerait le maillage au lieu
+        # de simplement l'articuler.
+        def initialize(nodes_json, joints, inverse_bind_matrices, rigid: false)
+            @nodes = nodes_json.map do |n|
+                Node.new(n['translation'], n['rotation'], n['scale'], n['children'] || [], nil)
+            end
+            @nodes.each_with_index { |node, i| node.children.each { |c| @nodes[c].parent = i } }
+            @joints = joints
+            @inverse_bind_matrices = inverse_bind_matrices
+            @rigid = rigid
+        end
+
+        # Une matrice de skinning par joint (meme ordre que WEIGHTS_0/
+        # JOINTS_0), pour un maillage porte par le noeud mesh_node_index.
+        def joint_matrices(pose, mesh_node_index)
+            world = world_matrices(pose)
+            mesh_inverse = GLTFMath.invert(world[mesh_node_index])
+
+            @joints.each_with_index.map do |joint_node, i|
+                skinned = GLTFMath.multiply(mesh_inverse, world[joint_node])
+                GLTFMath.multiply(skinned, @inverse_bind_matrices[i])
+            end
+        end
+
+        private
+
+        def world_matrices(pose)
+            world = Array.new(@nodes.length)
+            @nodes.each_index { |i| compute_world_matrix(i, pose, world) }
+            world
+        end
+
+        def compute_world_matrix(index, pose, world)
+            return world[index] if world[index]
+
+            local = local_matrix(index, pose)
+            parent = @nodes[index].parent
+            world[index] = parent ? GLTFMath.multiply(compute_world_matrix(parent, pose, world), local) : local
+        end
+
+        # Fusionne, composante par composante (translation/rotation/scale),
+        # la pose animee (si ce noeud/cette composante y figure) avec la pose
+        # de repos du noeud — cf. GLTFAnimation, seules les composantes
+        # reellement animees sont presentes dans la pose.
+        def local_matrix(index, pose)
+            node = @nodes[index]
+            override = pose[index] || {}
+            GLTFMath.matrix_from_trs(
+                override[:translation] || node.translation,
+                override[:rotation] || node.rotation,
+                @rigid ? nil : (override[:scale] || node.scale)
+            )
+        end
+    end
+end

data/lib/bestguigui_lab/gouraud_shading.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Bestguigui
+    # Calcule une couleur par sommet à partir de sa normale et d'une lumière
+    # fixe, quantifiée en peu de nuances par canal — utilisé par ObjModel en
+    # mode shading: :gouraud pour simuler, en plus de la texture (elle la
+    # module, ne la remplace pas), un rendu façon modèles de perso PSX
+    # (FF7 & co) : pas de lumière OpenGL temps réel, un effet "en bandes"
+    # plutôt qu'un dégradé lisse.
+    class GouraudShading
+        LIGHT_DIRECTION = [0.4, 0.8, 0.4].freeze # direction fixe
+        AMBIENT = 0.35 # part de lumière reçue même côté ombre
+        COLOR_LEVELS = 16 # teintes par canal : peu de nuances, façon banding PSX
+
+        def initialize(light_direction: LIGHT_DIRECTION, ambient: AMBIENT, color_levels: COLOR_LEVELS)
+            @light_direction = normalize(light_direction)
+            @ambient = ambient
+            @color_levels = color_levels
+        end
+
+        def vertex_color(normal, material_color)
+            intensity = @ambient + ((1.0 - @ambient) * [dot(normal, @light_direction), 0.0].max)
+            material_color.map { |channel| quantize(channel * intensity) }
+        end
+
+        private
+
+        def dot(vector_a, vector_b) = vector_a.zip(vector_b).sum { |x, y| x * y }
+
+        def normalize(vector)
+            length = Math.sqrt(vector.sum { |c| c * c })
+            vector.map { |c| c / length }
+        end
+
+        # Réduit à COLOR_LEVELS nuances entre 0 et 1 : le dégradé de lumière
+        # devient visiblement "en bandes", comme la faible précision couleur
+        # de la PSX.
+        def quantize(value)
+            step = 1.0 / (@color_levels - 1)
+            (value.clamp(0.0, 1.0) / step).round * step
+        end
+    end
+end

data/lib/bestguigui_lab/obj_model.rb

@@ -1,20 +1,23 @@
 # frozen_string_literal: true
 
 module Bestguigui
-    # Charge un modèle .obj/.mtl et le dessine via un VBO : géométrie
+    # Charge un modèle .obj/.mtl et le dessine via un VBO texturé. shading:
+    # :gouraud ajoute, en plus de la texture (ou d'un blanc si absente), une
+    # teinte par sommet calculée une fois au chargement à partir de sa
+    # normale et d'une lumière fixe (voir GouraudShading) : simule le rendu
+    # bas-poly des perso PSX (FF7 & co), sans lumière OpenGL temps réel.
     class ObjModel
-        # position (3) + texcoord (2) + normale (3) par sommet.
+        # position (3) + texcoord (2) + normale ou teinte Gouraud (3) par sommet.
         FLOATS_PER_VERTEX = 8
         STRIDE = FLOATS_PER_VERTEX * 4 # 4 octets par float
 
-        def initialize(obj_path)
+        def initialize(obj_path, shading: :texture)
             super()
-            @vertices = []
-            @tex_coords = []
-            @normals = []
-            @faces = []
+            @shading = shading
+            # rubocop:disable-next Style/ParallelAssignment -- reste sous la limite de Metrics/MethodLength
+            @vertices, @tex_coords, @normals, @faces = [], [], [], []
             @texture = nil
-
+            @material_color = [1.0, 1.0, 1.0]
             parse_obj(obj_path)
             @texture ||= GLTexture.blank
             @vertex_count = @faces.size
@@ -75,53 +78,60 @@ module Bestguigui
             end
         end
 
-        # Un seul matériau par modèle : la dernière texture (map_Kd) trouvée.
+        # Un seul matériau : dernière texture (map_Kd) et couleur diffuse (Kd) trouvées, Kd sert de base au Gouraud.
         def load_material(path)
             directory = File.dirname(path)
 
             File.foreach(path) do |line|
                 tokens = line.split
-                next if tokens.empty? || tokens.shift != 'map_Kd'
+                next if tokens.empty?
 
-                @texture = GLTexture.new(File.join(directory, tokens.first))
+                keyword = tokens.shift
+                case keyword
+                when 'Kd' then @material_color = tokens.map(&:to_f)
+                when 'map_Kd' then @texture = GLTexture.new(File.join(directory, tokens.first))
+                end
             end
         end
 
         # Buffer plat non indexé : les sommets partagés sont dupliqués, pas
         # d'index buffer pour rester simple.
         def build_vertex_buffer
-            data = @faces.flat_map { |v, vt, vn| vertex_attributes(v, vt, vn) }.pack('F*')
-
-            name_buffer = "\x00" * 4
-            glGenBuffers(1, name_buffer)
-            vbo = name_buffer.unpack1('L')
-
-            glBindBuffer(GL_ARRAY_BUFFER, vbo)
-            glBufferData(GL_ARRAY_BUFFER, data.bytesize, data, GL_STATIC_DRAW)
-
-            vbo
+            gouraud = GouraudShading.new if @shading == :gouraud
+            data = @faces.flat_map { |v, vt, vn| vertex_attributes(v, vt, vn, gouraud) }.pack('F*')
+            GLBuffer.upload(data)
         end
 
-        def vertex_attributes(vertex_index, tex_coord_index, normal_index)
+        # extra : la normale (mode :texture, inutilisée) ou une teinte Gouraud qui modulera la texture au dessin.
+        def vertex_attributes(vertex_index, tex_coord_index, normal_index, gouraud)
             position = @vertices[vertex_index]
             tex_coord = tex_coord_index ? @tex_coords[tex_coord_index] : [0.0, 0.0]
             normal = normal_index ? @normals[normal_index] : [0.0, 0.0, 1.0]
+            extra = gouraud ? gouraud.vertex_color(normal, @material_color) : normal
 
-            position + tex_coord + normal
+            position + tex_coord + extra
         end
 
         def enable_vertex_arrays
             glEnableClientState(GL_VERTEX_ARRAY)
             glEnableClientState(GL_TEXTURE_COORD_ARRAY)
-            glEnableClientState(GL_NORMAL_ARRAY)
-
             glVertexPointer(3, GL_FLOAT, STRIDE, 0)
             glTexCoordPointer(2, GL_FLOAT, STRIDE, 3 * 4)
+            @shading == :gouraud ? enable_color_array : enable_normal_array
+        end
+
+        def enable_color_array
+            glEnableClientState(GL_COLOR_ARRAY)
+            glColorPointer(3, GL_FLOAT, STRIDE, 5 * 4)
+        end
+
+        def enable_normal_array
+            glEnableClientState(GL_NORMAL_ARRAY)
             glNormalPointer(GL_FLOAT, STRIDE, 5 * 4)
         end
 
         def disable_vertex_arrays
-            glDisableClientState(GL_NORMAL_ARRAY)
+            glDisableClientState(@shading == :gouraud ? GL_COLOR_ARRAY : GL_NORMAL_ARRAY)
             glDisableClientState(GL_TEXTURE_COORD_ARRAY)
             glDisableClientState(GL_VERTEX_ARRAY)
         end

data/lib/bestguigui_lab/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Bestguigui
-    VERSION = '0.12.0'
+    VERSION = '0.14.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bestguigui_lab
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.14.0
 platform: ruby
 authors:
 - Bestguigui
@@ -45,7 +45,16 @@ files:
 - lib/bestguigui_lab/animation.rb
 - lib/bestguigui_lab/assets.rb
 - lib/bestguigui_lab/assets/splash_jingle.wav
+- lib/bestguigui_lab/gl_buffer.rb
 - lib/bestguigui_lab/gl_texture.rb
+- lib/bestguigui_lab/gltf_animation.rb
+- lib/bestguigui_lab/gltf_animator.rb
+- lib/bestguigui_lab/gltf_buffer.rb
+- lib/bestguigui_lab/gltf_math.rb
+- lib/bestguigui_lab/gltf_model.rb
+- lib/bestguigui_lab/gltf_primitive.rb
+- lib/bestguigui_lab/gltf_skeleton.rb
+- lib/bestguigui_lab/gouraud_shading.rb
 - lib/bestguigui_lab/helpers.rb
 - lib/bestguigui_lab/image_pixels.rb
 - lib/bestguigui_lab/input.rb