Tasks and more II

src/adera/Shaders/PlumeShader.cpp

@@ -106,7 +106,7 @@ void PlumeShader::assign_plumes(
 {
     for (ActiveEnt ent : entities)
     {
-        rStorage.emplace(ent, EntityToDraw{&draw_plume, {&rData} });
+        //rStorage.emplace(ent, EntityToDraw{&draw_plume, {&rData} });
     }
 }
 

src/adera/machines/links.cpp

@@ -32,10 +32,6 @@ using osp::link::MachTypeId;
 namespace adera
 {
 
-MachTypeId const gc_mtUserCtrl      = MachTypeReg_t::create();
-MachTypeId const gc_mtMagicRocket   = MachTypeReg_t::create();
-MachTypeId const gc_mtRcsDriver     = MachTypeReg_t::create();
-
 float thruster_influence(Vector3 const pos, Vector3 const dir, Vector3 const cmdLin, Vector3 const cmdAng) noexcept
 {
     using Magnum::Math::cross;

src/adera/machines/links.h

@@ -35,9 +35,9 @@ using osp::link::gc_ntSigFloat;
 using osp::link::gc_sigIn;
 using osp::link::gc_sigOut;
 
-extern osp::link::MachTypeId const gc_mtUserCtrl;
-extern osp::link::MachTypeId const gc_mtMagicRocket;
-extern osp::link::MachTypeId const gc_mtRcsDriver;
+inline osp::link::MachTypeId const gc_mtUserCtrl    = osp::link::MachTypeReg_t::create();
+inline osp::link::MachTypeId const gc_mtMagicRocket = osp::link::MachTypeReg_t::create();
+inline osp::link::MachTypeId const gc_mtRcsDriver   = osp::link::MachTypeReg_t::create();
 
 constexpr osp::Vector3 gc_rocketForward{0.0f, 0.0f, 1.0f};
 

src/newtondynamics_physics/SysNewton.cpp

@@ -55,7 +55,6 @@ using namespace Magnum::Math::Literals;
 
 using osp::phys::EShape;
 
-using osp::active::acomp_view_t;
 using osp::active::acomp_storage_t;
 
 using osp::active::ActiveEnt;

src/osp/Active/SysPrefabInit.cpp

@@ -116,10 +116,12 @@ void SysPrefabInit::init_drawing(
         Resources&                          rResources,
         ACtxDrawing&                        rDrawing,
         ACtxDrawingRes&                     rDrawingRes,
-        std::optional<EntSetPair>           material) noexcept
+        std::optional<Material>             material) noexcept
 {
-    auto itPfEnts = std::begin(rPrefabInit.m_ents);
+    auto itPfEnts = rPrefabInit.m_ents.begin();
 
+    // stupidly make drawIDs first
+    // TODO: separate this into another step.
     for (TmpPrefabInitBasic const& rPfBasic : rPrefabInit.m_basicIn)
     {
         auto const &rImportData = rResources.data_get<osp::ImporterData const>(
@@ -131,13 +133,53 @@ void SysPrefabInit::init_drawing(
 
         for (std::size_t i = 0; i < objects.size(); ++i)
         {
+            int const meshImportId = rImportData.m_objMeshes[objects[i]];
+            if (meshImportId == -1)
+            {
+                continue;
+            }
+
             ActiveEnt const ent = (*itPfEnts)[i];
+            rDrawing.m_activeToDraw[ent] = rDrawing.m_drawIds.create();
+        }
+
+        ++itPfEnts;
+    }
+
+    // then resize containers
+    rDrawing.resize_draw();
+
+    itPfEnts = rPrefabInit.m_ents.begin();
 
-            // TODO: Don't actually do this. This marks every entity as drawable,
-            //       which considers them for draw transformations.
-            //       Only set drawable for entities that have a mesh or is an
-            //       ancestor of an entity with a mesh.
-            rDrawing.m_drawable.set(std::size_t(ent));
+    for (TmpPrefabInitBasic const& rPfBasic : rPrefabInit.m_basicIn)
+    {
+        auto const &rImportData = rResources.data_get<osp::ImporterData const>(
+                gc_importer, rPfBasic.m_importerRes);
+        auto const &rPrefabData = rResources.data_get<osp::Prefabs const>(
+                gc_importer, rPfBasic.m_importerRes);
+
+        auto const ents     = ArrayView<ActiveEnt const>{*itPfEnts};
+        auto const objects  = lgrn::Span<int const>{rPrefabData.m_prefabs[rPfBasic.m_prefabId]};
+        auto const parents  = lgrn::Span<int const>{rPrefabData.m_prefabParents[rPfBasic.m_prefabId]};
+
+        // All ancestors of  each entity that has a mesh
+        auto const needs_draw_transform
+            = [&parents, &ents, &rDrawing, &needDrawTf = rDrawing.m_needDrawTf]
+              (auto && self, int const object, ActiveEnt const ent) noexcept -> void
+        {
+            needDrawTf.set(std::size_t(ent));
+
+            int const parentObj = parents[object];
+
+            if (parentObj != -1)
+            {
+                self(self, parentObj, ents[parentObj]);
+            }
+        };
+
+        for (std::size_t i = 0; i < objects.size(); ++i)
+        {
+            ActiveEnt const ent = (*itPfEnts)[i];
 
             // Check if object has mesh
             int const meshImportId = rImportData.m_objMeshes[objects[i]];
@@ -146,10 +188,14 @@ void SysPrefabInit::init_drawing(
                 continue;
             }
 
+            needs_draw_transform(needs_draw_transform, objects[i], ent);
+
+            DrawEnt const drawEnt = rDrawing.m_activeToDraw[ent];
+
             osp::ResId const meshRes = rImportData.m_meshes[meshImportId];
             MeshId const meshId = SysRender::own_mesh_resource(rDrawing, rDrawingRes, rResources, meshRes);
-            rDrawing.m_mesh.emplace(ent, rDrawing.m_meshRefCounts.ref_add(meshId));
-            rDrawing.m_meshDirty.push_back(ent);
+            rDrawing.m_mesh[drawEnt] = rDrawing.m_meshRefCounts.ref_add(meshId);
+            rDrawing.m_meshDirty.push_back(drawEnt);
 
             int const matImportId = rImportData.m_objMaterials[objects[i]];
 
@@ -162,23 +208,22 @@ void SysPrefabInit::init_drawing(
                 {
                     osp::ResId const texRes = rImportData.m_textures[baseColor];
                     TexId const texId = SysRender::own_texture_resource(rDrawing, rDrawingRes, rResources, texRes);
-                    rDrawing.m_diffuseTex.emplace(ent, rDrawing.m_texRefCounts.ref_add(texId));
-                    rDrawing.m_diffuseDirty.push_back(ent);
+                    rDrawing.m_diffuseTex[drawEnt] = rDrawing.m_texRefCounts.ref_add(texId);
+                    rDrawing.m_diffuseDirty.push_back(drawEnt);
                 }
-
             }
 
-            rDrawing.m_opaque.emplace(ent);
-            rDrawing.m_visible.emplace(ent);
+            rDrawing.m_drawBasic[drawEnt] = { .m_opaque = true, .m_transparent = false };
+            rDrawing.m_visible.set(std::size_t(drawEnt));
 
             if (material.has_value())
             {
-                material.value().m_rEnts.set(std::size_t(ent));
-                material.value().m_rDirty.push_back(ent);
+                material.value().m_ents.set(std::size_t(drawEnt));
+                material.value().m_dirty.push_back(drawEnt);
             }
         }
 
-        std::advance(itPfEnts, 1);
+        ++itPfEnts;
     }
 }
 

src/osp/Active/SysPrefabInit.h

@@ -92,7 +92,7 @@ class SysPrefabInit
             Resources&                          rResources,
             ACtxDrawing&                        rDrawing,
             ACtxDrawingRes&                     rCtxDrawRes,
-            std::optional<EntSetPair>           material) noexcept;
+            std::optional<Material>             material) noexcept;
 
     static void init_physics(
             ACtxPrefabInit const&               rPrefabInit,

src/osp/Active/SysRender.cpp

@@ -91,47 +91,70 @@ void SysRender::set_dirty_all(ACtxDrawing &rCtxDrawing)
 {
     using osp::active::active_sparse_set_t;
 
-    // Set all meshs dirty
-    auto &rMeshSet = static_cast<active_sparse_set_t&>(rCtxDrawing.m_mesh);
-    rCtxDrawing.m_meshDirty.assign(std::begin(rMeshSet), std::end(rMeshSet));
 
-    // Set all textures dirty
-    auto &rDiffSet = static_cast<active_sparse_set_t&>(rCtxDrawing.m_diffuseTex);
-    rCtxDrawing.m_diffuseDirty.assign(std::begin(rMeshSet), std::end(rMeshSet));
-}
+    for (std::size_t const drawEntInt : rCtxDrawing.m_drawIds.bitview().zeros())
+    {
+        auto const drawEnt = DrawEnt(drawEntInt);
 
-void SysRender::clear_dirty_all(ACtxDrawing& rCtxDrawing)
-{
-    rCtxDrawing.m_meshDirty.clear();
-    rCtxDrawing.m_diffuseDirty.clear();
+        // Set all meshs dirty
+        if (rCtxDrawing.m_mesh[drawEnt] != lgrn::id_null<MeshId>())
+        {
+            rCtxDrawing.m_meshDirty.push_back(drawEnt);
+        }
+
+        // Set all textures dirty
+        if (rCtxDrawing.m_diffuseTex[drawEnt] != lgrn::id_null<TexId>())
+        {
+            rCtxDrawing.m_diffuseDirty.push_back(drawEnt);
+        }
+    }
+
+    for (std::size_t const materialInt : rCtxDrawing.m_materialIds.bitview().zeros())
+    {
+        Material &mat = rCtxDrawing.m_materials[MaterialId(materialInt)];
+        for (std::size_t const entInt : mat.m_ents.ones())
+        {
+            mat.m_dirty.push_back(DrawEnt(entInt));
+        }
+    }
 }
 
 
 void SysRender::update_draw_transforms_recurse(
         ACtxSceneGraph const&                   rScnGraph,
+        KeyedVec<ActiveEnt, DrawEnt> const&     activeToDraw,
         acomp_storage_t<ACompTransform> const&  rTf,
-        acomp_storage_t<Matrix4>&               rDrawTf,
-        EntSet_t const&                         rDrawable,
+        DrawTransforms_t&                       rDrawTf,
+        ActiveEntSet_t const&                   needDrawTf,
         ActiveEnt                               ent,
         Matrix4 const&                          parentTf,
         bool                                    root)
 {
-    Matrix4 const& entTf = rTf.get(ent).m_transform;
-    Matrix4 const& entDrawTf = root ? (entTf) : (parentTf * entTf);
+    Matrix4 const& entTf        = rTf.get(ent).m_transform;
+    Matrix4 const& entDrawTf    = root ? (entTf) : (parentTf * entTf);
 
-    if (rDrawTf.contains(ent))
+    if (DrawEnt const drawEnt = activeToDraw[ent];
+        drawEnt != lgrn::id_null<DrawEnt>())
     {
-        rDrawTf.get(ent) = entDrawTf;
+        rDrawTf[drawEnt] = entDrawTf;
     }
 
     for (ActiveEnt entChild : SysSceneGraph::children(rScnGraph, ent))
     {
-        if (rDrawable.test(std::size_t(entChild)))
+        if (needDrawTf.test(std::size_t(entChild)))
         {
-            update_draw_transforms_recurse(rScnGraph, rTf, rDrawTf, rDrawable, entChild, entDrawTf, false);
+            update_draw_transforms_recurse(rScnGraph, activeToDraw, rTf, rDrawTf, needDrawTf, entChild, entDrawTf, false);
         }
     }
+}
+
 
-    //parentTf.
+MeshIdOwner_t SysRender::add_drawable_mesh(ACtxDrawing& rDrawing, ACtxDrawingRes& rDrawingRes, Resources& rResources, PkgId const pkg, std::string_view const name)
+{
+    ResId const res = rResources.find(restypes::gc_mesh, pkg, name);
+    assert(res != lgrn::id_null<ResId>());
+    MeshId const meshId = SysRender::own_mesh_resource(rDrawing, rDrawingRes, rResources, res);
+    return rDrawing.m_meshRefCounts.ref_add(meshId);
 }
 
+