bestguigui_lab 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 96f6d3fcc750e5d014248e718d7002117e19cdbe90b3787bc7709e2bf20e940c
+  data.tar.gz: 4f3e25a6ccade65ceb49178db07e71d70ace4d9afb81482a4bd19089b8ef8809
+SHA512:
+  metadata.gz: 0512a0c2081412ef87f90d19690e38ba315eebd4ef51eb2f13047538384cf30f149db57bc46a216f30f1d37f3bd7a7800f630ca3ec0da9c7d9a32b5028b4f82b
+  data.tar.gz: 922ce4a677d389b45eb98272a260c83d620070da48f14979609e2738782f5ff61602a3b7750c19ccbd3f8677b54a520e3a3d816a621a8843b4eb2e03811ac871

data/lib/bestguigui_lab/assets.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Bestguigui
+    # Charge et met en cache les assets (images, sons, modèles 3D...) pour éviter de les recharger plusieurs fois.
+    class Assets
+        @root = Dir.pwd
+
+        @images = Hash.new { |cache, path| cache[path] = Gosu::Image.new(path, retro: true) }
+        @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) }
+        @textures = Hash.new { |cache, path| cache[path] = GLTexture.new(path) }
+
+        def self.resolve(name) = File.expand_path(name, @root)
+        def self.image(name) = @images[resolve(name)]
+        def self.sound(name) = @sounds[resolve(name)]
+        def self.song(name) = @songs[resolve(name)]
+
+        def self.font(name = Gosu.default_font_name, size: 20)
+            path = name == Gosu.default_font_name ? name : resolve(name)
+            @fonts[[path, size]]
+        end
+
+        def self.model(name) = @models[resolve(name)]
+        def self.texture(name) = @textures[resolve(name)]
+    end
+end

data/lib/bestguigui_lab/gl_texture.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Bestguigui
+    # Texture OpenGL indépendante de l'atlas partagé de Gosu, construite à
+    # partir des pixels bruts (`to_blob`) — permet un vrai GL_REPEAT natif.
+    class GLTexture
+        attr_reader :tex_name
+
+        def initialize(path)
+            super()
+            image = Gosu::Image.new(path, retro: true)
+            @tex_name = upload(image)
+        end
+
+        private
+
+        def upload(image)
+            name_buffer = "\x00" * 4
+            glGenTextures(1, name_buffer)
+            tex_name = name_buffer.unpack1('L')
+
+            # Garder les pixels dans une variable (pas `image.to_blob` inline
+            # en argument) : sinon Ruby peut libérer la String pendant
+            # l'appel FFI, avant qu'OpenGL l'ait lue (texture à zéro, sans
+            # erreur OpenGL).
+            pixels = image.to_blob
+
+            glBindTexture(GL_TEXTURE_2D, tex_name)
+            configure_wrapping
+            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image.width, image.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels)
+
+            tex_name
+        end
+
+        def configure_wrapping
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT)
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT)
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
+        end
+    end
+end

data/lib/bestguigui_lab/helpers.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Bestguigui
+    # Petites fonctions utilitaires pour les animations (interpolation, easing).
+    class Helpers
+        def self.lerp(from, dest, progress) = from + ((dest - from) * progress)
+
+        def self.ease_out(progress) = 1 - ((1 - progress)**2)
+    end
+end

data/lib/bestguigui_lab/input.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Bestguigui
+    # Mappe une action à plusieurs touches/boutons (ex. right: [KB_RIGHT, KB_D]).
+    class Input
+        def initialize(bindings = {})
+            @bindings = bindings
+        end
+
+        def button_down?(action) = @bindings[action].any? { |key| Gosu.button_down?(key) }
+        def button_down(action, id) = @bindings[action].any? { |key| key == id }
+        def button_up(action, id) = @bindings[action].any? { |key| key == id }
+    end
+end

data/lib/bestguigui_lab/obj_model.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Bestguigui
+    # Charge un modèle .obj/.mtl et le dessine via un VBO : géométrie
+    class ObjModel
+        # position (3) + texcoord (2) + normale (3) par sommet.
+        FLOATS_PER_VERTEX = 8
+        STRIDE = FLOATS_PER_VERTEX * 4 # 4 octets par float
+
+        def initialize(obj_path)
+            super()
+            @vertices = []
+            @tex_coords = []
+            @normals = []
+            @faces = []
+            @texture = nil
+
+            parse_obj(obj_path)
+            @vertex_count = @faces.size
+            @vbo = build_vertex_buffer
+        end
+
+        def draw
+            glEnable(GL_TEXTURE_2D)
+            glBindTexture(GL_TEXTURE_2D, @texture.tex_name)
+            glBindBuffer(GL_ARRAY_BUFFER, @vbo)
+
+            enable_vertex_arrays
+            glDrawArrays(GL_TRIANGLES, 0, @vertex_count)
+            disable_vertex_arrays
+
+            glBindBuffer(GL_ARRAY_BUFFER, 0)
+            glDisable(GL_TEXTURE_2D)
+        end
+
+        private
+
+        def parse_obj(path)
+            directory = File.dirname(path)
+
+            File.foreach(path) do |line|
+                tokens = line.split
+                next if tokens.empty?
+
+                keyword = tokens.shift
+                parse_line(keyword, tokens, directory)
+            end
+        end
+
+        def parse_line(keyword, tokens, directory)
+            case keyword
+            when 'v', 'vt', 'vn' then parse_coordinates(keyword, tokens)
+            when 'f' then @faces.concat(parse_face(tokens))
+            when 'mtllib' then load_material(File.join(directory, tokens.first))
+            end
+        end
+
+        def parse_coordinates(keyword, tokens)
+            values = tokens.map(&:to_f)
+
+            case keyword
+            when 'v' then @vertices << values
+            when 'vt' then @tex_coords << values
+            when 'vn' then @normals << values
+            end
+        end
+
+        # "f" contient des groupes "v/vt/vn" (indices 1-indexés, vt/vn
+        # parfois absents).
+        def parse_face(tokens)
+            tokens.map do |group|
+                v, vt, vn = group.split('/').map { |i| i.nil? || i.empty? ? nil : i.to_i - 1 }
+                [v, vt, vn]
+            end
+        end
+
+        # Un seul matériau par modèle : la dernière texture (map_Kd) trouvée.
+        def load_material(path)
+            directory = File.dirname(path)
+
+            File.foreach(path) do |line|
+                tokens = line.split
+                next if tokens.empty? || tokens.shift != 'map_Kd'
+
+                @texture = GLTexture.new(File.join(directory, tokens.first))
+            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
+        end
+
+        def vertex_attributes(vertex_index, tex_coord_index, normal_index)
+            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]
+
+            position + tex_coord + normal
+        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)
+            glNormalPointer(GL_FLOAT, STRIDE, 5 * 4)
+        end
+
+        def disable_vertex_arrays
+            glDisableClientState(GL_NORMAL_ARRAY)
+            glDisableClientState(GL_TEXTURE_COORD_ARRAY)
+            glDisableClientState(GL_VERTEX_ARRAY)
+        end
+    end
+end

data/lib/bestguigui_lab/render_3d.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Bestguigui
+    # Instancie-la une fois, garde une référence, utilise-la dans draw :
+    #   @renderer = Render3D.new
+    #   @renderer.render_3d(self) { @renderer.look_at(...) ; @model.draw }
+    class Render3D
+        # fov : angle de champ de vision vertical, en degrés.
+        # clip : [proche, lointain] — tout ce qui est en dehors n'est pas dessiné.
+        def render_3d(window, z_order: 0, fov: 60.0, clip: [0.1, 1000.0], &block)
+            w, h = window.fullscreen? ? [Gosu.screen_width, Gosu.screen_height] : [window.width, window.height]
+            Gosu.gl(z_order) { render_3d_frame(w, h, fov, clip, &block) }
+        end
+
+        # À appeler dans le bloc de render_3d, avant de dessiner, pour
+        # positionner la caméra : eye = position, center = point regardé.
+        def look_at(eye, center, up_vector = [0, 1, 0])
+            gluLookAt(*eye, *center, *up_vector)
+        end
+
+        private
+
+        # Gosu.gl isole déjà l'état (glPushAttrib/glPopAttrib) et remet sa
+        # propre projection/modelview en sortant du bloc — pas besoin de
+        # push/pop matrice de notre côté, juste de poser nos valeurs.
+        def render_3d_frame(width, height, fov, clip)
+            glEnable(GL_DEPTH_TEST)
+            glDepthFunc(GL_LESS)
+
+            setup_projection(width, height, fov, clip)
+            glMatrixMode(GL_MODELVIEW)
+            glLoadIdentity
+
+            yield
+        end
+
+        def setup_projection(width, height, fov, clip)
+            near, far = clip
+
+            glMatrixMode(GL_PROJECTION)
+            glLoadIdentity
+            gluPerspective(fov, width.to_f / height, near, far)
+        end
+    end
+end

data/lib/bestguigui_lab/scene.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Bestguigui
+    # Classe de base pour une scène (écran de jeu, menu, victoire...).
+    # Hérite-en et ne redéfinis que ce dont tu as besoin.
+    class Scene
+        def initialize(window)
+            @window = window
+            @font = Assets.font(size: 24)
+        end
+
+        def button_down(id); end
+
+        def update(dt); end
+
+        def draw; end
+    end
+end

data/lib/bestguigui_lab/splash_scene.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module Bestguigui
+    # Le rubis animé du splash screen : tombe du haut de l'écran, touche le
+    # titre, rebondit au-dessus, puis se stabilise. Dessiné en primitives
+    # Gosu (aucune image).
+    class SplashGem
+        SIZE = 220
+        GAP = 40
+        OVERSHOOT = 12
+        FALL = 0.5
+        BOUNCE_UP = 0.25
+        SETTLE = 0.2
+        IMPACT_DIP = 10
+
+        # Points du diamant, en fractions (0..1) d'une boîte carrée.
+        POINTS = {
+            tl: [0.30, 0.32],
+            tr: [0.70, 0.32],
+            l: [0.12, 0.45],
+            r: [0.88, 0.45],
+            hub: [0.50, 0.47],
+            bottom: [0.50, 0.88]
+        }.freeze
+
+        HIGHLIGHT = [240, 150, 155].freeze
+        BASE = [210, 90, 95].freeze
+        DARK = [180, 60, 65].freeze
+        OUTLINE_RGB = [40, 30, 40].freeze
+
+        FACETS = [
+            [%i[tl hub l], HIGHLIGHT],
+            [%i[tl tr hub], BASE],
+            [%i[tr r hub], DARK],
+            [%i[l hub bottom], HIGHLIGHT],
+            [%i[r bottom hub], DARK]
+        ].freeze
+
+        OUTLINE = %i[tl tr r bottom l].freeze
+
+        def initialize(window)
+            @window = window
+        end
+
+        def draw(elapsed, alpha)
+            center_x = @window.width / 2
+            center_y = center_y(elapsed)
+
+            FACETS.each { |names, rgb| draw_facet(names, rgb, center_x, center_y, alpha) }
+            draw_outline(center_x, center_y, alpha)
+        end
+
+        def title_offset(elapsed)
+            return 0 if elapsed < FALL
+
+            if elapsed < FALL + BOUNCE_UP
+                Helpers.lerp(IMPACT_DIP, 0, Helpers.ease_out((elapsed - FALL) / BOUNCE_UP))
+            else
+                0
+            end
+        end
+
+        private
+
+        def center_y(elapsed)
+            if elapsed < FALL
+                fall_y(elapsed)
+            elsif elapsed < FALL + BOUNCE_UP
+                bounce_up_y(elapsed)
+            elsif elapsed < FALL + BOUNCE_UP + SETTLE
+                settle_y(elapsed)
+            else
+                rest_y
+            end
+        end
+
+        def impact_y = (@window.height / 2) - bottom_offset
+
+        def bottom_offset = (POINTS[:bottom][1] - 0.6) * SIZE
+
+        def rest_y = impact_y - GAP
+
+        def top_y = rest_y - OVERSHOOT
+
+        def fall_y(elapsed) = Helpers.lerp(-SIZE, impact_y, Helpers.ease_out(elapsed / FALL))
+
+        def bounce_up_y(elapsed)
+            progress = Helpers.ease_out((elapsed - FALL) / BOUNCE_UP)
+            Helpers.lerp(impact_y, top_y, progress)
+        end
+
+        def settle_y(elapsed)
+            progress = Helpers.ease_out((elapsed - FALL - BOUNCE_UP) / SETTLE)
+            Helpers.lerp(top_y, rest_y, progress)
+        end
+
+        def draw_facet(names, rgb, center_x, center_y, alpha)
+            color = Gosu::Color.new(alpha, *rgb)
+            a, b, c = names.map { |name| point(name, center_x, center_y) }
+            Gosu.draw_triangle(a[0], a[1], color, b[0], b[1], color, c[0], c[1], color)
+        end
+
+        def draw_outline(center_x, center_y, alpha)
+            color = Gosu::Color.new(alpha, *OUTLINE_RGB)
+            points = OUTLINE.map { |name| point(name, center_x, center_y) }
+            points.each_with_index do |p, i|
+                next_p = points[(i + 1) % points.size]
+                Gosu.draw_line(p[0], p[1], color, next_p[0], next_p[1], color)
+            end
+        end
+
+        def point(name, center_x, center_y)
+            fx, fy = POINTS[name]
+            [center_x + ((fx - 0.5) * SIZE), center_y + ((fy - 0.6) * SIZE)]
+        end
+    end
+
+    # Écran de démarrage prêt à l'emploi : titre + "Powered by Gosu" en fondu,
+    # avec un SplashGem qui tombe et rebondit sur le titre. Bascule ensuite
+    # sur la scène suivante.
+    #
+    # Bestguigui::SplashScene.new(window, title: "Mon jeu", next_scene: :menu)
+    class SplashScene < Scene
+        FADE_IN = 0.6
+        HOLD = 1.2
+        FADE_OUT = 0.6
+
+        def initialize(window, title:, next_scene:)
+            super(window)
+            @title = title
+            @next_scene = next_scene
+            @gem = SplashGem.new(window)
+            @title_font = Assets.font(size: 64)
+            @subtitle_font = Assets.font(size: 24)
+            @gosu_font = Assets.font(size: 36)
+            @elapsed = 0.0
+        end
+
+        def update(dt)
+            @elapsed += dt / 1000.0
+            @window.switch_scene(@next_scene) if @elapsed >= FADE_IN + HOLD + FADE_OUT
+        end
+
+        def draw
+            color = Gosu::Color.new(fade_alpha, 255, 255, 255)
+            accent = Gosu::Color.new(fade_alpha, 220, 30, 40)
+            offset = @gem.title_offset(@elapsed)
+
+            @gem.draw(@elapsed, fade_alpha)
+            draw_centered(@title_font, @title, (@window.height / 2) + offset, color)
+            draw_powered_by((@window.height / 2) + 80 + offset, color, accent)
+        end
+
+        private
+
+        def draw_powered_by(top, color, accent)
+            prefix_width = @subtitle_font.text_width('Powered by ')
+            total_width = prefix_width + @gosu_font.text_width('Gosu')
+            x = (@window.width - total_width) / 2
+
+            @subtitle_font.draw_text('Powered by ', x, top + 6, 0, 1, 1, color)
+            @gosu_font.draw_text('Gosu', x + prefix_width, top, 0, 1, 1, accent)
+        end
+
+        def fade_alpha
+            if @elapsed < FADE_IN
+                (255 * (@elapsed / FADE_IN)).to_i
+            elsif @elapsed < FADE_IN + HOLD
+                255
+            else
+                remaining = FADE_IN + HOLD + FADE_OUT - @elapsed
+                (255 * (remaining / FADE_OUT)).clamp(0, 255).to_i
+            end
+        end
+
+        def draw_centered(font, text, top, color)
+            x = (@window.width - font.text_width(text)) / 2
+            font.draw_text(text, x, top, 0, 1, 1, color)
+        end
+    end
+end

data/lib/bestguigui_lab/version.rb

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

data/lib/bestguigui_lab.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'gosu'
+require 'opengl'
+require 'glu'
+
+include OpenGL
+include GLU
+
+# Sans ça, les fonctions OpenGL au-delà de la version 1.1 plantent en
+# silence (NoMethodError sur nil).
+OpenGL.load_lib
+GLU.load_lib
+
+Dir[File.join(__dir__, 'bestguigui_lab', '*.rb')].each { |fn| require_relative fn }

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: bestguigui_lab
+version: !ruby/object:Gem::Version
+  version: 0.4.0
+platform: ruby
+authors:
+- Bestguigui
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: gosu
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: opengl-bindings
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/bestguigui_lab.rb
+- lib/bestguigui_lab/assets.rb
+- lib/bestguigui_lab/gl_texture.rb
+- lib/bestguigui_lab/helpers.rb
+- lib/bestguigui_lab/input.rb
+- lib/bestguigui_lab/obj_model.rb
+- lib/bestguigui_lab/render_3d.rb
+- lib/bestguigui_lab/scene.rb
+- lib/bestguigui_lab/splash_scene.rb
+- lib/bestguigui_lab/version.rb
+homepage: https://github.com/guillaumequillet/bestguigui_lab
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: A Game Jam Starter Kit to optimize Game Jams
+test_files: []