bestguigui_jam_kit 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9eab78344f9a0d2b2fbef670ffa2549ccf9095f617c76aa4fb04e0bcf30cf45b
+  data.tar.gz: f719011fee460de08633a08350ffac7a9982720e3e342902bf3f8fd184104670
+SHA512:
+  metadata.gz: 6444d4704051d68a6c3f255b6a06ced4c5c70c18bc4701ff3b882798b96bc9deb3e3a77856d3b0c2e150cf53a8e0db8628c32abc7ba9e92c18e6eb3180e4c12b
+  data.tar.gz: 03c8e61a6632efa0a5d20a3ba88ef719046e8ea889073080bc39de908420191f4ce2428114589adf375284673a5ac20a14c600742f738551d0866864ed0294f9

data/lib/gosu_jam_kit/assets.rb

@@ -0,0 +1,31 @@
+# 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) }
+
+        # À fixer une fois au démarrage (ex. `Assets.root = __dir__` dans ta
+        # fenêtre principale) : dossier depuis lequel résoudre les chemins
+        # relatifs passés aux méthodes ci-dessous.
+        class << self
+            attr_writer :root
+        end
+
+        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, size = 20) = @fonts[[resolve(name), size]]
+        def self.model(name) = @models[resolve(name)]
+        def self.texture(name) = @textures[resolve(name)]
+    end
+end

data/lib/gosu_jam_kit/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/gosu_jam_kit/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/gosu_jam_kit/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/gosu_jam_kit/version.rb

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

data/lib/gosu_jam_kit.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__, 'gosu_jam_kit', '*.rb')].each { |fn| require_relative fn }

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: bestguigui_jam_kit
+version: !ruby/object:Gem::Version
+  version: 0.1.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/gosu_jam_kit.rb
+- lib/gosu_jam_kit/assets.rb
+- lib/gosu_jam_kit/gl_texture.rb
+- lib/gosu_jam_kit/obj_model.rb
+- lib/gosu_jam_kit/render_3d.rb
+- lib/gosu_jam_kit/version.rb
+homepage: https://github.com/guillaumequillet/bestguigui_jam_kit
+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: []