Bump engine submodule and rework resouces.

game/batch.py

@@ -26,13 +26,13 @@ class Batch:
     __slots__ = ('_batch', 'vertices', 'max_size', 'size',
         'flags', '_flags', 'mesh', '_meshes', 'param', '_params', '_name', '__dict__')
 
-    def __init__(self, vertices, max_size, max_meshes, **params_decls):
+    def __init__(self, vertices, max_size, **params_decls):
         assert max_size <= BATCH_MAX_SIZE
         nparams = len(params_decls)
         if nparams:
-            self._batch = create_batch(vertices._vertices, max_size, max_meshes, params_format(*params_decls.values()))
+            self._batch = create_batch(vertices._vertices, max_size, params_format(*params_decls.values()))
         else:
-            self._batch = create_batch(vertices._vertices, max_size, max_meshes, None)
+            self._batch = create_batch(vertices._vertices, max_size, None)
         self.vertices = vertices
         self.max_size = max_size
         self.size = 0

game/game.py

@@ -75,8 +75,10 @@ class PerfGroup(Group):
 class TestEntity(Entity):
     __slots__ = 'translation', 'orientation', 'spawn_translation', 'spawn_orientation'
 
-    def __init__(self, batch, model, translation, orientation):
+    def __init__(self, batch, mesh, translation, orientation):
-        Entity.__init__(self, batch, model.flags, model.mesh, translation = translation, orientation = orientation)
+        Entity.__init__(self, batch, INSTANCE_FLAG_VISIBLE, mesh,
+            translation = translation,
+            orientation = orientation)
         self.translation = batch.translation[self.index]
         self.orientation = batch.orientation[self.index]
         self.spawn_translation = translation
@@ -126,15 +128,16 @@ def create_scene(keyboard, mouse):
 
     print("Building tiles...")
     tiles_texture = Texture(*archive.get_texture('tiles'))
-    tiles_vertices = Vertices(*archive.get_vertices('tiles'))
+    tiles_vertices_data = archive.get_vertices('tiles')
-    water_model = archive.get_model('water')
+    tiles_vertices = Vertices(*tiles_vertices_data)
-    sand_model = archive.get_model('sand')
+    water_mesh = tiles_vertices_data.get_mesh('water')
-    grass_model = archive.get_model('grass')
+    sand_mesh = tiles_vertices_data.get_mesh('sand')
-    forest_model = archive.get_model('forest')
+    grass_mesh = tiles_vertices_data.get_mesh('grass')
-    rock_model = archive.get_model('rock')
+    forest_mesh = tiles_vertices_data.get_mesh('forest')
-    mud_model = archive.get_model('mud')
+    rock_mesh = tiles_vertices_data.get_mesh('rock')
-    lava_model = archive.get_model('lava')
+    mud_mesh = tiles_vertices_data.get_mesh('mud')
-    tiles_batch = Batch(tiles_vertices, generated.size ** 2, 8, translation = PARAM_FORMAT_VEC3_SHORT)
+    lava_mesh = tiles_vertices_data.get_mesh('lava')
+    tiles_batch = Batch(tiles_vertices, generated.size ** 2, translation = PARAM_FORMAT_VEC3_SHORT)
 
     #TODO: generator & for real
     vc = generated.volcano_c
@@ -146,44 +149,45 @@ def create_scene(keyboard, mouse):
         if h == 0.0:
             continue
         if r > 0.0:
-            model = water_model
+            mesh = water_mesh
         elif h < 2.0:
-            model = sand_model
+            mesh = sand_mesh
         elif h < 180:
             if nz > 0.9:
                 if ny < -0.01 and nz > 0.93:
-                    model = forest_model
+                    mesh = forest_mesh
                 else:
-                    model = grass_model
+                    mesh = grass_mesh
             else:
-                model = rock_model
+                mesh = rock_mesh
         elif vd < vr - 3.0 and nz > 0.999:
-            model = lava_model
+            mesh = lava_mesh
         elif vd < vr + 2.0:
-            model = mud_model
+            mesh = mud_mesh
         elif vd < vr + 6.0 and nz < 0.67:
-            model = mud_model
+            mesh = mud_mesh
         else:
-            model = rock_model
+            mesh = rock_mesh
-        tiles_batch.spawn(model.flags, model.mesh,
+        tiles_batch.spawn(INSTANCE_FLAG_VISIBLE, mesh,
             translation = vec3(float(((mx - 128) * 8) + 4), float(((127 - my) * 8) + 4), 0.0))
     tiles_batch.fill()
     tiles_batch.freeze(flags = True, mesh = True, translation = True)
 
     tests_texture = Texture(*archive.get_texture('tests'))
-    tests_vertices = Vertices(*archive.get_vertices('tests'))
+    tests_vertices_data = archive.get_vertices('tests')
-    blob_model = archive.get_model('blob')
+    tests_vertices = Vertices(*tests_vertices_data)
-    cube_model = archive.get_model('cube')
+    blob_mesh = tests_vertices_data.get_mesh('blob')
-    clouds_model = archive.get_model('clouds')
+    cube_mesh = tests_vertices_data.get_mesh('cube')
-    tests_batch = Batch(tests_vertices, 3, 3,
+    clouds_mesh = tests_vertices_data.get_mesh('clouds')
+    tests_batch = Batch(tests_vertices, 3,
         translation = PARAM_FORMAT_VEC3_FLOAT,
         orientation = PARAM_FORMAT_MAT3_INT10 | PARAM_FORMAT_NORMALIZE)
     blob_forward = math.vec3_normalize((sun_direction[0], sun_direction[1], 0.0))
     blob_right = math.vec3_cross(blob_forward, math.vec3_up)
     blob_orientation = mat3(vec3(*blob_right), vec3(*blob_forward), vec3_up)
-    blob = TestEntity(tests_batch, blob_model, translation = vec3(-100.0, -500.0, 0.0), orientation = blob_orientation)
+    blob = TestEntity(tests_batch, blob_mesh, translation = vec3(-100.0, -500.0, 0.0), orientation = blob_orientation)
-    cube = TestEntity(tests_batch, cube_model, translation = vec3(100.0, -500.0, 0.0), orientation = mat3_identity)
+    cube = TestEntity(tests_batch, cube_mesh, translation = vec3(100.0, -500.0, 0.0), orientation = mat3_identity)
-    clouds = TestEntity(tests_batch, clouds_model, translation = vec3(0.0, 0.0, 32.0), orientation = mat3_identity)
+    clouds = TestEntity(tests_batch, clouds_mesh, translation = vec3(0.0, 0.0, 32.0), orientation = mat3_identity)
     tests_batch.fill()
     tests_batch.freeze(flags = True, mesh = True)
 

game/obj2rkar.py

@@ -22,7 +22,7 @@ from itertools import starmap, chain, repeat
 from engine import *
 
 from game.math import float_s8, vec3_srgb8a8
-from game.resources import load_png, TextureData, VerticesData, ModelData, Archive
+from game.resources import load_png, TextureData, VerticesData, Archive
 
 _texture_flags = TEXTURE_FLAG_MIPMAPS | TEXTURE_FLAG_MIN_LINEAR | TEXTURE_FLAG_MAG_NEAREST
 
@@ -226,15 +226,13 @@ class ObjArchive(Archive):
             n = (pack_10(_nz) << 20) | (pack_10(_ny) << 10) | pack_10(_nx)
             t = ((_tl & 1023) << 20) | (pack_u10(_t) << 10) | pack_u10(_s)
             return struct.pack('fffII', _px, _py, _pz, n, t)
+        meshes = {}
+        for mesh_name, (offset, count) in sorted(models.items()):
+            meshes[mesh_name] = offset | (count << 16)
         self.vertices_db[name] = VerticesData(name,
             array('B', b''.join(starmap(pack_vertex, vertices))),
-            array('H', indices))
+            array('H', indices),
-        for name, (offset, count) in sorted(models.items()):
+            meshes)
-            if name[0] != '_':
-                print("Storing", name)
-                assert name not in self.models_db.keys()
-                self.models_db[name] = ModelData(
-                    name, INSTANCE_FLAG_VISIBLE, offset | count << 16)
 
 if __name__ == '__main__':
     if len(sys.argv) < 3:

game/resources.py

@@ -48,7 +48,7 @@ def _read_struct(file, format):
     _read_magic(file, b'RK')
     return struct.unpack(format, data)
 
-def _write_struct(file, format, elems):
+def _write_struct(file, format, *elems):
     assert format
     data = struct.pack(format, *elems)
     size = file.write(data)
@@ -56,7 +56,7 @@ def _write_struct(file, format, elems):
     _write_magic(file, b'RK')
 
 def _read_string(file):
-    length, = _read_struct(file, 'B')
+    length, = _read_struct(file, 'I')
     assert length
     data = file.read(length)
     assert len(data) == length
@@ -66,7 +66,7 @@ def _read_string(file):
 def _write_string(file, string):
     data = bytes(string, encoding='ascii')
     assert data and len(data) < 256
-    _write_struct(file, 'B', (len(data),))
+    _write_struct(file, 'I', len(data))
     size = file.write(data)
     assert size == len(data)
     _write_magic(file, b'RK')
@@ -96,7 +96,7 @@ def _read_blob(file):
 
 def _write_blob(file, array):
     assert array
-    _write_struct(file, 'II', (ord(array.typecode), len(array)))
+    _write_struct(file, 'II', ord(array.typecode), len(array))
     array.tofile(file)
     _write_magic(file, b'RK')
 
@@ -124,7 +124,7 @@ class TextureData:
 
     @classmethod
     def from_archive(cls, file):
-        _read_magic(file, b'TX')
+        _read_magic(file, b'TXTR')
         name = _read_string(file)
         format, width, height, nlevels, flags = _read_struct(file, 'IIIII')
         pixels = _read_blob(file)
@@ -133,70 +133,59 @@ class TextureData:
         return cls(name, format, width, height, nlevels, flags, pixels)
 
     def to_archive(self, file):
-        _write_magic(file, b'TX')
+        _write_magic(file, b'TXTR')
         _write_string(file, self.name)
-        _write_struct(file, 'IIIII', (self.format, self.width, self.height, self.nlevels, self.flags))
+        _write_struct(file, 'IIIII', self.format, self.width, self.height, self.nlevels, self.flags)
         _write_blob(file, self.pixels)
 
 class VerticesData:
-    __slots__ = 'name', 'vertices', 'indices'
+    __slots__ = 'name', 'vertices', 'indices', 'meshes'
 
-    def __init__(self, name, vertices, indices):
+    def __init__(self, name, vertices, indices, meshes):
         if len(vertices) % VERTEX_SIZE != 0:
             raise RuntimeError("Vertex format mismatch!")
         self.name = name
         self.vertices = vertices
         self.indices = indices
+        self.meshes = meshes
 
     def __iter__(self):
         yield VERTEX_FORMAT
         yield len(self.vertices) // VERTEX_SIZE
         yield self.vertices
         yield self.indices
+        yield array('I', self.meshes.values())
+
+    def get_mesh(self, name):
+        return self.meshes[name]
 
     @classmethod
     def from_archive(cls, file):
-        _read_magic(file, b'VT')
+        _read_magic(file, b'VERT')
         name = _read_string(file)
-        nvertices, nindices = _read_struct(file, 'II')
+        nvertices, nindices, nmeshes = _read_struct(file, 'III')
         vertices = _read_array(file, 'B', nvertices * VERTEX_SIZE)
         indices = _read_array(file, 'H', nindices)
-        return cls(name, vertices, indices)
+        meshes = _read_array(file, 'I', nmeshes)
+        names = [_read_string(file) for _ in range(nmeshes)]
+        return cls(name, vertices, indices, dict(zip(names, meshes)))
 
     def to_archive(self, file):
-        _write_magic(file, b'VT')
+        _write_magic(file, b'VERT')
         _write_string(file, self.name)
-        _write_struct(file, 'II', (len(self.vertices) // VERTEX_SIZE, len(self.indices)))
+        _write_struct(file, 'III', len(self.vertices) // VERTEX_SIZE, len(self.indices), len(self.meshes))
         _write_array(file, self.vertices)
         _write_array(file, self.indices)
-
+        _write_array(file, array('I', self.meshes.values()))
-class ModelData:
+        for name in self.meshes.keys():
-    __slots__ = 'name', 'flags', 'mesh'
+            _write_string(file, name)
-
-    def __init__(self, name, flags, mesh):
-        self.name = name
-        self.flags = flags
-        self.mesh = mesh
-
-    @classmethod
-    def from_archive(cls, file):
-        _read_magic(file, b'MD')
-        name = _read_string(file)
-        flags, mesh = _read_struct(file, 'II')
-        return ModelData(name, flags, mesh)
-
-    def to_archive(self, file):
-        _write_magic(file, b'MD')
-        _write_string(file, self.name)
-        _write_struct(file, 'II', (self.flags, self.mesh))
 
 class Archive:
-    __slots__ = 'textures_db', 'vertices_db', 'models_db'
+    __slots__ = 'textures_db', 'vertices_db'
 
-    def __init__(self, textures_db = None, vertices_db = None, models_db = None):
+    def __init__(self, textures_db = None, vertices_db = None):
         self.textures_db = textures_db or {}
         self.vertices_db = vertices_db or {}
-        self.models_db = models_db or {}
 
     def get_texture(self, name):
         return self.textures_db[name]
@@ -204,36 +193,27 @@ class Archive:
     def get_vertices(self, name):
         return self.vertices_db[name]
 
-    def get_model(self, name):
-        return self.models_db[name]
-
     @classmethod
     def from_archive(cls, file):
         textures_db = {}
         vertices_db = {}
-        models_db = {}
         _read_magic(file, b'RKAR')
-        ntextures, nvertices, nmodels = _read_struct(file, 'III')
+        ntextures, nvertices = _read_struct(file, 'II')
         for _ in range(ntextures):
             data = TextureData.from_archive(file)
             textures_db[data.name] = data
         for _ in range(nvertices):
             data = VerticesData.from_archive(file)
             vertices_db[data.name] = data
-        for _ in range(nmodels):
+        return cls(textures_db, vertices_db)
-            data = ModelData.from_archive(file)
-            models_db[data.name] = data
-        return cls(textures_db, vertices_db, models_db)
 
     def to_archive(self, file):
         _write_magic(file, b'RKAR')
-        _write_struct(file, 'III', (len(self.textures_db), len(self.vertices_db), len(self.models_db)))
+        _write_struct(file, 'II', len(self.textures_db), len(self.vertices_db))
         for _, data in self.textures_db.items():
             data.to_archive(file)
         for _, data in self.vertices_db.items():
             data.to_archive(file)
-        for _, data in self.models_db.items():
-            data.to_archive(file)
 
     @classmethod
     def load(cls, filename):

game/vertices.py

@@ -18,8 +18,8 @@ from engine import create_vertices, destroy_vertices
 class Vertices:
     __slots__ = '_vertices'
 
-    def __init__(self, format, nvertices, vertices, indices):
+    def __init__(self, format, nvertices, vertices, indices, meshes):
-        self._vertices = create_vertices(format, nvertices, vertices, indices)
+        self._vertices = create_vertices(format, nvertices, vertices, indices, meshes)
 
     def __del__(self):
         destroy_vertices(self._vertices)