dev 25 Fixed Mesh tree system

Author: FrewtyPebbles

Loxoc/core.pxd

@@ -3,13 +3,51 @@ from libcpp.vector cimport vector
 from libcpp.string cimport string
 from libcpp.map cimport map
 
+cdef extern from "<variant>" namespace "std" nogil:
+    cdef cppclass variant:
+        variant& operator=(variant&)
+
+        # value status
+        bint valueless_by_exception()
+        size_t index()
+
+    cdef struct monostate:
+        pass
+
+    cdef T get_if[T](...)
+
+    cdef T get[T](...)
+
+    cdef Z holds_alternative[Z](...)
+
+cdef extern from "../src/util.h" namespace "std" nogil:
+    cdef cppclass variant2[T,A]:
+        variant2() except +
+        variant2(T) except +
+        variant2(A) except +
+        variant2[T,A]& operator=(variant2[T,A]&)
+
+        # value status
+        bint valueless_by_exception()
+        size_t index()
+
+    cdef struct monostate:
+        pass
+
+    cdef Z get_if[Z](...)
+
+    cdef Z get[Z](...)
+
+    cdef Z holds_alternative[Z](...)
+
 cdef extern from "../src/RC.h":
     cdef cppclass RC[T]:
         RC() except +
         RC(T data) except +
         T inc()
         void dec()
         T data
+        int refcount
 
     cdef void RC_collect[T](RC[T*]* rc)
 
@@ -57,18 +95,7 @@ cdef class Shader:
     cdef shader* c_class
 
 
-cdef extern from "<variant>" namespace "std" nogil:
-    cdef cppclass variant:
-        variant& operator=(variant&)
-
-        # value status
-        bint valueless_by_exception()
-        size_t index()
-
-    cdef struct monostate:
-        pass
 
-    cdef T* get_if[T](...)
 
 cdef extern from "../src/Material.h":
 
@@ -383,6 +410,7 @@ cdef Vec2 vec2_from_cpp(vec2 cppinst)
 
 
 cdef extern from "../src/Mesh.h":
+
     cdef enum illum_model:
         CONSTANT_COLOR, 
         DIFFUSE,
@@ -404,7 +432,7 @@ cdef extern from "../src/Mesh.h":
         mesh(const mesh& rhs) except +
         mesh(vector[mesh_material*] materials, vector[vec3]* vertexes, vector[vec3]* diffuse_coordinates, vector[vec3]* vertex_normals, vector[tup3ui]* faces, vec3 transform, vector[RC[texture*]*] diffuse_textures, vector[RC[texture*]*] specular_textures, vector[RC[texture*]*] normals_textures) except +
         @staticmethod
-        mesh_dict from_file(string file_path) except +
+        RC[mesh_dict*]* from_file(string file_path) except +
         string name
         vector[mesh_material*] materials
         vector[vec3]* vertexes
@@ -416,36 +444,35 @@ cdef extern from "../src/Mesh.h":
         vector[RC[texture*]*] specular_textures
         vector[RC[texture*]*] normals_textures
 
-    
+
+    ctypedef variant2[RC[mesh*]*, RC[mesh_dict*]*] mesh_dict_child
 
     cdef cppclass mesh_dict:
-        ctypedef map[string, vector[RC[mesh*]*]].iterator meshmap_iterator
-        ctypedef map[string, vector[RC[mesh*]*]].const_iterator const_meshmap_iterator
-        
+        ctypedef map[string, mesh_dict_child].iterator meshmap_iterator
+        ctypedef map[string, mesh_dict_child].const_iterator const_meshmap_iterator
+        #
         mesh_dict() except +
-        mesh_dict(map[string, vector[RC[mesh*]*]] data) except +
+        mesh_dict(string name, map[string, mesh_dict_child] data) except +
         mesh_dict(mesh_dict& rhs) except +
-        void insert(RC[mesh*]* m)
-        vector[RC[mesh*]*] get(string name)
+        void insert(mesh_dict_child m)
+        mesh_dict_child get(string name)
         void remove(string name)
-        vector[RC[mesh*]*] operator[](string name)
+        mesh_dict_child operator[](string name)
         meshmap_iterator begin() noexcept
         const_meshmap_iterator cbegin() noexcept
         meshmap_iterator end() noexcept
         const_meshmap_iterator cend()
-
-        map[string, vector[RC[mesh*]*]] data
+        string name
+        map[string, mesh_dict_child] data
 
 cdef class MeshDict:
-    cdef mesh_dict* c_class
-    cpdef void insert(self, Mesh m)
-    cpdef list[Mesh] get(self, str name)
+    cdef RC[mesh_dict*]* c_class
     cpdef void remove(self, str name)
 
     @staticmethod
     cdef MeshDict from_cpp(mesh_dict cppinst)
     @staticmethod
-    cdef MeshDict from_cpp_ptr(mesh_dict* cppinst)
+    cdef MeshDict from_cpp_ptr(RC[mesh_dict*]* cppinst)
 
 
 cdef class Mesh:
@@ -462,9 +489,9 @@ cpdef MeshDict mesh_from_file(str file_path)
 cdef extern from "../src/Object3d.h":
     cdef cppclass object3d:
         object3d() except +
-        object3d(mesh_dict* mesh, vec3* position, quaternion* rotation, vec3* scale) except +
-        object3d(mesh_dict* mesh, vec3* position, quaternion* rotation, vec3* scale, material* mat) except +
-        mesh_dict* mesh_data
+        object3d(RC[mesh_dict*]* mesh, vec3* position, quaternion* rotation, vec3* scale) except +
+        object3d(RC[mesh_dict*]* mesh, vec3* position, quaternion* rotation, vec3* scale, material* mat) except +
+        RC[mesh_dict*]* mesh_data
         vec3* position
         quaternion* rotation
         vec3* scale

Loxoc/core.pyi

@@ -65,20 +65,40 @@ class Mesh:
 
 class MeshDict:
     """
-    A fast :class:`Mesh` container that can be used like a statically typed dict.
+    :class:`Loxoc.MeshDict` is a datastructure that acts like a statically typed dictionary storing each :class:`Mesh<Loxoc.Mesh>` by name.
+    This is nessicary because 3D asset files can have more than one :class:`Mesh<Loxoc.Mesh>` in them.  If you have a 3D
+    asset file with more than one :class:`Mesh<Loxoc.Mesh>` inside of it, you can extract them from their :class:`MeshDict<Loxoc.MeshDict>`
+    to new individual :class:`MeshDict<Loxoc.MeshDict>` s to be used in :class:`Object3D<Loxoc.Object3D>` s like so:
+
+        .. code-block:: python
+
+            my_assets: MeshDict = Mesh.from_file("./assets/models/model_name/model_name.gltf")
+            # Import the 3D asset file.
+            
+            player_model = MeshDict([my_assets["player_model"]])
+            # Extract the Mesh into its own group/MeshDict
+
+            player_object = Object3D(player_model, Vec3(0.0, 0.0, 20.0), vec3(0.0, 0.0, 0.0), vec3(1.0, 1.0, 1.0))
+            # Now our model is ready to be used.
+
+    We can extract the :class:`Mesh` s we need from the ``my_assets``  :class:`MeshDict` by name.
+    Hence we use ``my_assets["player_model"]``.  This is assuming your desired :class:`Mesh`
+    is at the top level of your imported 3D file/asset's heirarchy.  if it is in a group inside
+    the 3D file/asset you imported you could do something like:
+    ``my_assets["group_name"]["player_model"]``
     """
 
-    def __init__(self, meshes: list[Mesh]) -> None:
+    def __init__(self, meshes: list[Mesh|MeshDict]) -> None:
         """
         A fast :class:`Mesh` container that can be used like a statically typed dict.
         """
 
-    def insert(self, m: Mesh) -> None:
+    def insert(self, m: Mesh|MeshDict) -> None:
         """
         Insert a Mesh.  It will use the Mesh name as a key.
         """
 
-    def get(self, name: str) -> list[Mesh]:
+    def get(self, name: str) -> Mesh|MeshDict:
         """
         Get a Mesh from the dict by name.
         """
@@ -88,12 +108,12 @@ class MeshDict:
         Remove a Mesh from the dict by name.
         """
 
-    def __iter__(self) -> Generator[tuple[str, list[Mesh]], None, None]:
+    def __iter__(self) -> Generator[tuple[str, Mesh|MeshDict], None, None]:
         """
         Itterates through the key value pairs of the dict.
         """
 
-    def __getitem__(self, key: str) -> list[Mesh]:
+    def __getitem__(self, key: str) -> Mesh|MeshDict:
         """
         Get a Mesh from the dict by name.
         """

Loxoc/core.pyx

@@ -71,76 +71,114 @@ cdef class Camera:
             self._rotation = value
         self.c_class.rotation = self._rotation.c_class
 
+ctypedef mesh_dict* mesh_dict_ptr
+ctypedef RC[mesh*]* rc_mesh
+ctypedef RC[mesh_dict*]* rc_mesh_dict
+ctypedef mesh* mesh_ptr
+
 cdef class MeshDict:
 
-    def __init__(self, list[Mesh] meshes) -> None:
+    def __init__(self, str name, meshes:list[Mesh | MeshDict]) -> None:
         cdef:
             Mesh m
             mesh_dict md = mesh_dict()
         for m in meshes:
-            md.insert(m.c_class)
+            md.insert(mesh_dict_child(m.c_class))
+
+        md.name = name.encode()
 
-        self.c_class = new mesh_dict(md)
+        self.c_class = new RC[mesh_dict_ptr](new mesh_dict(md))
 
     def __repr__(self) -> str:
-        return "\n".join([
+        return "".join([
             "MeshDict {",
-            *["\t{}: {}".format(m_n, m) for m_n, m in self],
+            *["{}: {}".format(m_n, m) for m_n, m in self],
             "}"
         ])
 
     def __dealloc__(self):
         # Collect the mesh_dict and decrement each mesh's refcount
         cdef:
-            pair[string, vector[RC[mesh*]*]] _pair
-            RC[mesh*]* m
-        for _pair in self.c_class.data:
-            for m in _pair.second:
-                RC_collect(m)
-        del self.c_class
-
-    cpdef void insert(self, Mesh m):
-        self.c_class.insert(m.c_class)
+            pair[string, mesh_dict_child] _pair
+            mesh_dict_child m
+            rc_mesh _m
+            rc_mesh_dict _m_d
+        RC_collect(self.c_class)
+        
 
-    cpdef list[Mesh] get(self, str name):
+    def insert(self, m: Mesh | MeshDict) -> None:
         cdef:
-            RC[mesh*]* m
-            list[Mesh] ret = []
-        for m in self.c_class.get(name.encode()):
-            ret.append(Mesh.from_cpp(m))
-        return ret
+            Mesh msh
+            MeshDict msh_d
+        if isinstance(m, Mesh):
+            msh = m
+            msh.c_class.inc()
+            self.c_class.data.insert(mesh_dict_child(msh.c_class))
+        elif isinstance(m, MeshDict):
+            msh_d = m
+            msh_d.c_class.inc()
+            self.c_class.data.insert(mesh_dict_child(msh_d.c_class))
+
+    def get(self, str name) -> Mesh|MeshDict :
+        cdef:
+            mesh_dict_child m = self.c_class.data.get(name.encode())
+            RC[mesh*]* _m
+            RC[mesh_dict*]* _m_d
+        if holds_alternative[rc_mesh](m):
+            _m = get[rc_mesh](m)
+            return Mesh.from_cpp(_m)
+        elif holds_alternative[rc_mesh_dict](m):
+            _m_d = get[rc_mesh_dict](m)
+            return MeshDict.from_cpp_ptr(_m_d)
 
     cpdef void remove(self, str name):
-        self.c_class.remove(name.encode())
-
-    def __iter__(self) -> Generator[(str, list[Mesh]), None, None]:
         cdef:
-            pair[string, vector[RC[mesh*]*]] _pair
-            RC[mesh*]* m
-            Mesh M
-            list[Mesh] M_list = []
-        for _pair in self.c_class.data:
-            for m in _pair.second:
-                M = Mesh.from_cpp(m)
-                M_list.append(M)
-            yield (
-                bytes(_pair.first).decode(), 
-                M_list
-            )
+            mesh_dict_child m = self.c_class.data.data[name]
+            RC[mesh*]* _m
+            RC[mesh_dict*]* _m_d
+        self.c_class.data.remove(name.encode())
+        if holds_alternative[rc_mesh](m):
+            _m = get[rc_mesh](m)
+            _m.dec()
+        elif holds_alternative[rc_mesh_dict](m):
+            _m_d = get[rc_mesh_dict](m)
+            _m_d.dec()
+
+    def __iter__(self) -> Generator[(str, Mesh|MeshDict), None, None]:
+        cdef:
+            pair[string, mesh_dict_child] _pair
+            RC[mesh*]* _m
+            RC[mesh_dict*]* _m_d
+            mesh_dict_child m
+        for _pair in self.c_class.data[0]:
+            m = _pair.second
+            if holds_alternative[rc_mesh](m):
+                _m = get[rc_mesh](m)
+                yield (
+                    bytes(_pair.first).decode(), 
+                    Mesh.from_cpp(_m)
+                )
+            elif holds_alternative[rc_mesh_dict](m):
+                _m_d = get[rc_mesh_dict](m)
+                yield (
+                    bytes(_pair.first).decode(), 
+                    MeshDict.from_cpp_ptr(_m_d)
+                )
 
     def __getitem__(self, str key) -> list[Mesh]:
         return self.get(key)
 
     @staticmethod
     cdef MeshDict from_cpp(mesh_dict cppinst):
         cdef MeshDict ret = MeshDict.__new__(MeshDict)
-        ret.c_class = new mesh_dict(cppinst)
+        ret.c_class = new RC[mesh_dict_ptr](new mesh_dict(cppinst))
         return ret
 
     @staticmethod
-    cdef MeshDict from_cpp_ptr(mesh_dict* cppinst):
+    cdef MeshDict from_cpp_ptr(RC[mesh_dict*]* cppinst):
         cdef MeshDict ret = MeshDict.__new__(MeshDict)
         ret.c_class = cppinst
+        ret.c_class.inc()
         return ret
 
 cdef class Mesh:
@@ -183,7 +221,7 @@ cdef class Mesh:
         for _tex in ret.c_class.data.specular_textures:
             tex_spec = Texture.__new__(Texture)
             tex_spec.c_class = _tex
-            tex_diff.c_class.inc()
+            tex_spec.c_class.inc()
             specular_textures.append(tex_spec)
 
         ret.specular_textures = specular_textures
@@ -192,19 +230,18 @@ cdef class Mesh:
         for _tex in ret.c_class.data.normals_textures:
             tex_norm = Texture.__new__(Texture)
             tex_norm.c_class = _tex
-            tex_diff.c_class.inc()
+            tex_norm.c_class.inc()
             normals_textures.append(tex_norm)
 
         ret.normals_textures = normals_textures
-
         return ret
 
     @staticmethod
     def from_file(file_path:str) -> MeshDict:
         return mesh_from_file(file_path)
 
 cpdef MeshDict mesh_from_file(str file_path):
-    return MeshDict.from_cpp(mesh.from_file(file_path.encode()))
+    return MeshDict.from_cpp_ptr(mesh.from_file(file_path.encode()))
 
 cdef class Object3D:
     def __init__(self, MeshDict mesh_data, Vec3 position = Vec3(0.0,0.0,0.0),