From 367e0a4aa5a65e3ff73239fb84e57e3e0ccd8b7e Mon Sep 17 00:00:00 2001 From: Kevin Date: Sat, 30 Mar 2024 23:37:58 -0400 Subject: [PATCH] [WIP] Build lander game --- .gitignore | 1 + src/osp/util/logging.h | 2 +- src/testapp/main.cpp | 3 +- src/testapp/scenarios.cpp | 95 ++++++++++ src/testapp/sessions/universe.cpp | 305 ++++++++++++++++++++++++++++++ src/testapp/sessions/universe.h | 9 + 6 files changed, 413 insertions(+), 2 deletions(-) diff --git a/.gitignore b/.gitignore index d89e602c..30e831fe 100644 --- a/.gitignore +++ b/.gitignore @@ -12,4 +12,5 @@ OSP-MAGNUM.cbp CMakeSettings.json out/ .vs/ +.vscode/ build/ diff --git a/src/osp/util/logging.h b/src/osp/util/logging.h index 38a7eb26..1afde911 100644 --- a/src/osp/util/logging.h +++ b/src/osp/util/logging.h @@ -24,7 +24,7 @@ */ #pragma once -#define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_INFO +#define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_DEBUG #include namespace osp diff --git a/src/testapp/main.cpp b/src/testapp/main.cpp index 97b61b6e..f1594591 100644 --- a/src/testapp/main.cpp +++ b/src/testapp/main.cpp @@ -115,7 +115,7 @@ int main(int argc, char** argv) { Corrade::Utility::Arguments args; args.addSkippedPrefix("magnum", "Magnum options") - .addOption("scene", "none") .setHelp("scene", "Set the scene to launch") + .addOption("scene", "lander") .setHelp("scene", "Set the scene to launch") .addOption("config") .setHelp("config", "path to configuration file to use") .addBooleanOption("norepl") .setHelp("norepl", "don't enter read, evaluate, print, loop.") .addBooleanOption("log-exec") .setHelp("log-exec", "Log Task/Pipeline Execution (Extremely chatty!)") @@ -308,6 +308,7 @@ void start_magnum_async() g_testApp.close_session(g_testApp.m_windowApp); OSP_LOG_INFO("Closed Magnum Application"); + std::exit(0); }); g_magnumThread.swap(t); } diff --git a/src/testapp/scenarios.cpp b/src/testapp/scenarios.cpp index 14afef6b..1a968ff8 100644 --- a/src/testapp/scenarios.cpp +++ b/src/testapp/scenarios.cpp @@ -370,6 +370,101 @@ static ScenarioMap_t make_scenarios() return setup_renderer; }); + add_scenario("lander", "Lander simulation game", [] (TestApp& rTestApp) -> RendererSetupFunc_t { + #define SCENE_SESSIONS scene, commonScene, uniCore, uniScnFrame, uniPlanet, physics, \ + prefabs, parts, signalsFloat, vehicleSpawn, vehicleSpawnVB, vehicles, \ + newton, vehicleSpawnNwt, nwtRocketSet, rocketsNwt, \ + machRocket, machRcsDriver + #define SCENE_SESSIONS_COUNT 18 + #define RENDERER_SESSIONS sceneRenderer, magnumScene, planetDraw, \ + cameraCtrl, cameraFree, shVisual, shFlat, shPhong, \ + prefabDraw, vehicleDraw, vehicleCtrl, cameraVehicle + #define RENDERER_SESSIONS_COUNT 12 + + using namespace testapp::scenes; + + auto const defaultPkg = rTestApp.m_defaultPkg; + auto const application = rTestApp.m_application; + auto & rTopData = rTestApp.m_topData; + + TopTaskBuilder builder{rTestApp.m_tasks, rTestApp.m_scene.m_edges, rTestApp.m_taskData}; + + auto & [SCENE_SESSIONS] = resize_then_unpack(rTestApp.m_scene.m_sessions); + + scene = setup_scene(builder, rTopData, application); + commonScene = setup_common_scene (builder, rTopData, scene, application, defaultPkg); + + auto const tgApp = application.get_pipelines< PlApplication >(); + uniCore = setup_uni_core (builder, rTopData, tgApp.mainLoop); + uniScnFrame = setup_uni_sceneframe (builder, rTopData, uniCore); + uniPlanet = setup_uni_landerplanet (builder, rTopData, uniCore, uniScnFrame); + + physics = setup_physics (builder, rTopData, scene, commonScene); + prefabs = setup_prefabs (builder, rTopData, application, scene, commonScene, physics); + parts = setup_parts (builder, rTopData, application, scene); + signalsFloat = setup_signals_float (builder, rTopData, scene, parts); + vehicleSpawn = setup_vehicle_spawn (builder, rTopData, scene); + vehicleSpawnVB = setup_vehicle_spawn_vb (builder, rTopData, application, scene, commonScene, prefabs, parts, vehicleSpawn, signalsFloat); + vehicles = setup_prebuilt_vehicles (builder, rTopData, application, scene); + + machRocket = setup_mach_rocket (builder, rTopData, scene, parts, signalsFloat); + machRcsDriver = setup_mach_rcsdriver (builder, rTopData, scene, parts, signalsFloat); + + newton = setup_newton (builder, rTopData, scene, commonScene, physics); + vehicleSpawnNwt = setup_vehicle_spawn_newton(builder, rTopData, application, commonScene, physics, prefabs, parts, vehicleSpawn, newton); + nwtRocketSet = setup_newton_factors (builder, rTopData); + rocketsNwt = setup_rocket_thrust_newton(builder, rTopData, scene, commonScene, physics, prefabs, parts, signalsFloat, newton, nwtRocketSet); + + + OSP_DECLARE_GET_DATA_IDS(vehicleSpawn, TESTAPP_DATA_VEHICLE_SPAWN); + OSP_DECLARE_GET_DATA_IDS(vehicleSpawnVB, TESTAPP_DATA_VEHICLE_SPAWN_VB); + OSP_DECLARE_GET_DATA_IDS(vehicles, TESTAPP_DATA_TEST_VEHICLES); + + auto &rVehicleSpawn = top_get (rTopData, idVehicleSpawn); + auto &rVehicleSpawnVB = top_get (rTopData, idVehicleSpawnVB); + auto &rPrebuiltVehicles = top_get (rTopData, idPrebuiltVehicles); + + rVehicleSpawn.spawnRequest.push_back( + { + .position = {30.0f, 0.0f, 0.0f}, + .velocity = {0.0f, 0.0f, 0.0f}, + .rotation = {} + }); + rVehicleSpawnVB.dataVB.push_back(rPrebuiltVehicles[gc_pbvSimpleCommandServiceModule].get()); + + RendererSetupFunc_t const setup_renderer = [] (TestApp& rTestApp) -> void + { + auto const application = rTestApp.m_application; + auto const windowApp = rTestApp.m_windowApp; + auto const magnum = rTestApp.m_magnum; + auto & rTopData = rTestApp.m_topData; + + TopTaskBuilder builder{rTestApp.m_tasks, rTestApp.m_renderer.m_edges, rTestApp.m_taskData}; + + auto & [SCENE_SESSIONS] = unpack(rTestApp.m_scene.m_sessions); + auto & [RENDERER_SESSIONS] = resize_then_unpack(rTestApp.m_renderer.m_sessions); + + sceneRenderer = setup_scene_renderer (builder, rTopData, application, windowApp, commonScene); + create_materials(rTopData, sceneRenderer, sc_materialCount); + + magnumScene = setup_magnum_scene (builder, rTopData, application, rTestApp.m_windowApp, sceneRenderer, rTestApp.m_magnum, scene, commonScene); + cameraCtrl = setup_camera_ctrl (builder, rTopData, windowApp, sceneRenderer, magnumScene); + // cameraFree = setup_camera_free (builder, rTopData, windowApp, scene, cameraCtrl); + shVisual = setup_shader_visualizer (builder, rTopData, windowApp, sceneRenderer, magnum, magnumScene, sc_matVisualizer); + // shFlat = setup_shader_flat (builder, rTopData, windowApp, sceneRenderer, magnum, magnumScene, sc_matFlat); + shPhong = setup_shader_phong (builder, rTopData, windowApp, sceneRenderer, magnum, magnumScene, sc_matPhong); + planetDraw = setup_testplanets_draw (builder, rTopData, windowApp, sceneRenderer, cameraCtrl, commonScene, uniCore, uniScnFrame, uniPlanet, sc_matVisualizer, sc_matFlat); + + prefabDraw = setup_prefab_draw (builder, rTopData, application, windowApp, sceneRenderer, commonScene, prefabs, sc_matPhong); + vehicleDraw = setup_vehicle_spawn_draw (builder, rTopData, sceneRenderer, vehicleSpawn); + vehicleCtrl = setup_vehicle_control (builder, rTopData, windowApp, scene, parts, signalsFloat); + cameraVehicle = setup_camera_vehicle (builder, rTopData, windowApp, scene, sceneRenderer, commonScene, physics, parts, cameraCtrl, vehicleCtrl); + + setup_magnum_draw(rTestApp, scene, sceneRenderer, magnumScene); + }; + return setup_renderer; + }); + return scenarioMap; } diff --git a/src/testapp/sessions/universe.cpp b/src/testapp/sessions/universe.cpp index 73f2ab70..656878e2 100644 --- a/src/testapp/sessions/universe.cpp +++ b/src/testapp/sessions/universe.cpp @@ -86,7 +86,103 @@ Session setup_uni_sceneframe( } // setup_uni_sceneframe +Session setup_uni_landerplanet( + TopTaskBuilder& rBuilder, + ArrayView topData, + Session const& uniCore, + Session const& uniScnFrame) +{ + using CoSpaceIdVec_t = std::vector; + using Corrade::Containers::Array; + + OSP_DECLARE_GET_DATA_IDS(uniCore, TESTAPP_DATA_UNI_CORE); + OSP_DECLARE_GET_DATA_IDS(uniScnFrame, TESTAPP_DATA_UNI_SCENEFRAME); + + auto const tgUCore = uniCore .get_pipelines(); + auto const tgUSFrm = uniScnFrame.get_pipelines(); + + auto &rUniverse = top_get< Universe >(topData, idUniverse); + + constexpr int precision = 10; + constexpr int planetCount = 1; + + // Create coordinate spaces + CoSpaceId const mainSpace = rUniverse.m_coordIds.create(); + std::vector satSurfaceSpaces(planetCount); + rUniverse.m_coordIds.create(satSurfaceSpaces.begin(), satSurfaceSpaces.end()); + rUniverse.m_coordCommon.resize(rUniverse.m_coordIds.capacity()); + + CoSpaceCommon &rMainSpaceCommon = rUniverse.m_coordCommon[mainSpace]; + rMainSpaceCommon.m_satCount = planetCount; + rMainSpaceCommon.m_satCapacity = planetCount; + + // Associate each planet satellite with their surface coordinate space + for (SatId satId = 0; satId < planetCount; ++satId) + { + CoSpaceId const surfaceSpaceId = satSurfaceSpaces[satId]; + CoSpaceCommon &rCommon = rUniverse.m_coordCommon[surfaceSpaceId]; + rCommon.m_parent = mainSpace; + rCommon.m_parentSat = satId; + } + + // Coordinate space data is a single allocation partitioned to hold positions, velocities, and + // rotations. + // TODO: Alignment is needed for SIMD (not yet implemented). see Corrade alignedAlloc + + std::size_t bytesUsed = 0; + + // Positions and velocities are arranged as XXXX... YYYY... ZZZZ... + partition(bytesUsed, planetCount, rMainSpaceCommon.m_satPositions[0]); + partition(bytesUsed, planetCount, rMainSpaceCommon.m_satPositions[1]); + partition(bytesUsed, planetCount, rMainSpaceCommon.m_satPositions[2]); + partition(bytesUsed, planetCount, rMainSpaceCommon.m_satVelocities[0]); + partition(bytesUsed, planetCount, rMainSpaceCommon.m_satVelocities[1]); + partition(bytesUsed, planetCount, rMainSpaceCommon.m_satVelocities[2]); + + // Rotations use XYZWXYZWXYZWXYZW... + partition(bytesUsed, planetCount, rMainSpaceCommon.m_satRotations[0], + rMainSpaceCommon.m_satRotations[1], + rMainSpaceCommon.m_satRotations[2], + rMainSpaceCommon.m_satRotations[3]); + + // Allocate data for all planets + rMainSpaceCommon.m_data = Array{Corrade::NoInit, bytesUsed}; + + // Create easily accessible array views for each component + auto const [x, y, z] = sat_views(rMainSpaceCommon.m_satPositions, rMainSpaceCommon.m_data, planetCount); + auto const [vx, vy, vz] = sat_views(rMainSpaceCommon.m_satVelocities, rMainSpaceCommon.m_data, planetCount); + auto const [qx, qy, qz, qw] = sat_views(rMainSpaceCommon.m_satRotations, rMainSpaceCommon.m_data, planetCount); + + for (std::size_t i = 0; i < planetCount; ++i) + { + // Assign each planet random positions and velocities + x[i] = 0; + y[i] = 0; + z[i] = 0; + vx[i] = 0; + vy[i] = 0; + vz[i] = 0; + + // No rotation + qx[i] = 0.0; + qy[i] = 0.0; + qz[i] = 0.0; + qw[i] = 1.0; + } + + auto &rScnFrame = top_get(topData, idScnFrame); + rScnFrame.m_parent = mainSpace; + rScnFrame.m_position = math::mul_2pow({400, 400, 400}, precision); + + Session out; + OSP_DECLARE_CREATE_DATA_IDS(out, topData, TESTAPP_DATA_UNI_PLANETS); + top_emplace< CoSpaceId > (topData, idPlanetMainSpace, mainSpace); + top_emplace< float > (topData, tgUniDeltaTimeIn, 1.0f / 60.0f); + top_emplace< CoSpaceIdVec_t > (topData, idSatSurfaceSpaces, std::move(satSurfaceSpaces)); + + return out; +} Session setup_uni_testplanets( TopTaskBuilder& rBuilder, @@ -318,6 +414,215 @@ struct PlanetDraw MaterialId matAxis; }; +Session setup_landerplanet_draw( + TopTaskBuilder& rBuilder, + ArrayView const topData, + Session const& windowApp, + Session const& sceneRenderer, + Session const& cameraCtrl, + Session const& commonScene, + Session const& uniCore, + Session const& uniScnFrame, + Session const& uniLanderPlanet, + MaterialId const matPlanets, + MaterialId const matAxis +) { + OSP_DECLARE_GET_DATA_IDS(commonScene, TESTAPP_DATA_COMMON_SCENE); + OSP_DECLARE_GET_DATA_IDS(sceneRenderer, TESTAPP_DATA_SCENE_RENDERER); + OSP_DECLARE_GET_DATA_IDS(cameraCtrl, TESTAPP_DATA_CAMERA_CTRL); + OSP_DECLARE_GET_DATA_IDS(uniCore, TESTAPP_DATA_UNI_CORE); + OSP_DECLARE_GET_DATA_IDS(uniScnFrame, TESTAPP_DATA_UNI_SCENEFRAME); + OSP_DECLARE_GET_DATA_IDS(uniLanderPlanet, TESTAPP_DATA_UNI_PLANETS); + + auto const tgWin = windowApp .get_pipelines(); + auto const tgScnRdr = sceneRenderer .get_pipelines(); + auto const tgCmCt = cameraCtrl .get_pipelines(); + auto const tgUSFrm = uniScnFrame .get_pipelines(); + + Session out; + + auto const [idPlanetDraw] = out.acquire_data<1>(topData); + auto &rPlanetDraw = top_emplace(topData, idPlanetDraw); + rPlanetDraw.matPlanets = matPlanets; + rPlanetDraw.matAxis = matAxis; + + rBuilder.task() + .name ("Position SceneFrame center to Camera Controller target") + .run_on ({tgWin.inputs(Run)}) + .sync_with ({tgCmCt.camCtrl(Ready), tgUSFrm.sceneFrame(Modify)}) + .push_to (out.m_tasks) + .args ({ idCamCtrl, idScnFrame }) + .func([] (ACtxCameraController& rCamCtrl, SceneFrame& rScnFrame) noexcept + { + if ( ! rCamCtrl.m_target.has_value()) + { + return; + } + Vector3 &rCamPl = rCamCtrl.m_target.value(); + + // check origin translation + // ADL used for Magnum::Math::sign/floor/abs + float const maxDist = 512.0f; + Vector3 const translate = sign(rCamPl) * floor(abs(rCamPl) / maxDist) * maxDist; + + if ( ! translate.isZero()) + { + rCamCtrl.m_transform.translation() -= translate; + rCamPl -= translate; + + // a bit janky to modify universe stuff directly here, but it works lol + Vector3 const rotated = Quaternion(rScnFrame.m_rotation).transformVector(translate); + rScnFrame.m_position += Vector3g(math::mul_2pow(rotated, rScnFrame.m_precision)); + } + + rScnFrame.m_scenePosition = Vector3g(math::mul_2pow(rCamCtrl.m_target.value(), rScnFrame.m_precision)); + }); + + rBuilder.task() + .name ("Resync test planets, create DrawEnts") + .run_on ({tgWin.resync(Run)}) + .sync_with ({tgScnRdr.drawEntResized(ModifyOrSignal)}) + .push_to (out.m_tasks) + .args ({ idScnRender, idPlanetDraw, idUniverse, idPlanetMainSpace}) + .func([] (ACtxSceneRender& rScnRender, PlanetDraw& rPlanetDraw, Universe& rUniverse, CoSpaceId const planetMainSpace) noexcept + { + CoSpaceCommon &rMainSpace = rUniverse.m_coordCommon[planetMainSpace]; + + rPlanetDraw.drawEnts.resize(rMainSpace.m_satCount, lgrn::id_null()); + + rScnRender.m_drawIds.create(rPlanetDraw.drawEnts .begin(), rPlanetDraw.drawEnts .end()); + rScnRender.m_drawIds.create(rPlanetDraw.axis .begin(), rPlanetDraw.axis .end()); + rPlanetDraw.attractor = rScnRender.m_drawIds.create(); + }); + + rBuilder.task() + .name ("Resync test planets, add mesh and material") + .run_on ({tgWin.resync(Run)}) + .sync_with ({tgScnRdr.drawEntResized(Done), tgScnRdr.materialDirty(Modify_), tgScnRdr.entMeshDirty(Modify_)}) + .push_to (out.m_tasks) + .args ({ idDrawing, idScnRender, idNMesh, idPlanetDraw, idUniverse, idPlanetMainSpace}) + .func([] (ACtxDrawing& rDrawing, ACtxSceneRender& rScnRender, NamedMeshes& rNMesh, PlanetDraw& rPlanetDraw, Universe& rUniverse, CoSpaceId const planetMainSpace) noexcept + { + CoSpaceCommon &rMainSpace = rUniverse.m_coordCommon[planetMainSpace]; + + Material &rMatPlanet = rScnRender.m_materials[rPlanetDraw.matPlanets]; + Material &rMatAxis = rScnRender.m_materials[rPlanetDraw.matAxis]; + + MeshId const sphereMeshId = rNMesh.m_shapeToMesh.at(EShape::Sphere); + MeshId const cubeMeshId = rNMesh.m_shapeToMesh.at(EShape::Box); + + for (std::size_t i = 0; i < rMainSpace.m_satCount; ++i) + { + DrawEnt const drawEnt = rPlanetDraw.drawEnts[i]; + + rScnRender.m_mesh[drawEnt] = rDrawing.m_meshRefCounts.ref_add(sphereMeshId); + rScnRender.m_meshDirty.push_back(drawEnt); + rScnRender.m_visible.set(std::size_t(drawEnt)); + rScnRender.m_opaque.set(std::size_t(drawEnt)); + rMatPlanet.m_ents.set(std::size_t(drawEnt)); + rMatPlanet.m_dirty.push_back(drawEnt); + } + + rScnRender.m_mesh[rPlanetDraw.attractor] = rDrawing.m_meshRefCounts.ref_add(sphereMeshId); + rScnRender.m_meshDirty.push_back(rPlanetDraw.attractor); + rScnRender.m_visible.set(std::size_t(rPlanetDraw.attractor)); + rScnRender.m_opaque.set(std::size_t(rPlanetDraw.attractor)); + rMatPlanet.m_ents.set(std::size_t(rPlanetDraw.attractor)); + rMatPlanet.m_dirty.push_back(rPlanetDraw.attractor); + + for (DrawEnt const drawEnt : rPlanetDraw.axis) + { + rScnRender.m_mesh[drawEnt] = rDrawing.m_meshRefCounts.ref_add(cubeMeshId); + rScnRender.m_meshDirty.push_back(drawEnt); + rScnRender.m_visible.set(std::size_t(drawEnt)); + rScnRender.m_opaque.set(std::size_t(drawEnt)); + rMatAxis.m_ents.set(std::size_t(drawEnt)); + rMatAxis.m_dirty.push_back(drawEnt); + } + + rScnRender.m_color[rPlanetDraw.axis[0]] = {1.0f, 0.0f, 0.0f, 1.0f}; + rScnRender.m_color[rPlanetDraw.axis[1]] = {0.0f, 1.0f, 0.0f, 1.0f}; + rScnRender.m_color[rPlanetDraw.axis[2]] = {0.0f, 0.0f, 1.0f, 1.0f}; + }); + + rBuilder.task() + .name ("Reposition test planet DrawEnts") + .run_on ({tgScnRdr.render(Run)}) + .sync_with ({tgScnRdr.drawTransforms(Modify_), tgScnRdr.drawEntResized(Done), tgCmCt.camCtrl(Ready), tgUSFrm.sceneFrame(Modify)}) + .push_to (out.m_tasks) + .args ({ idDrawing, idScnRender, idPlanetDraw, idUniverse, idScnFrame, idPlanetMainSpace}) + .func([] (ACtxDrawing& rDrawing, ACtxSceneRender& rScnRender, PlanetDraw& rPlanetDraw, Universe& rUniverse, SceneFrame const& rScnFrame, CoSpaceId const planetMainSpace) noexcept + { + + CoSpaceCommon &rMainSpace = rUniverse.m_coordCommon[planetMainSpace]; + auto const [x, y, z] = sat_views(rMainSpace.m_satPositions, rMainSpace.m_data, rMainSpace.m_satCount); + auto const [qx, qy, qz, qw] = sat_views(rMainSpace.m_satRotations, rMainSpace.m_data, rMainSpace.m_satCount); + + // Calculate transform from universe to area/local-space for rendering. + // This can be generalized by finding a common ancestor within the tree + // of coordinate spaces. Since there's only two possibilities, an if + // statement works. + CoordTransformer mainToArea; + if (rScnFrame.m_parent == planetMainSpace) + { + mainToArea = coord_parent_to_child(rMainSpace, rScnFrame); + } + else + { + CoSpaceId const landedId = rScnFrame.m_parent; + CoSpaceCommon &rLanded = rUniverse.m_coordCommon[landedId]; + + CoSpaceTransform const landedTf = coord_get_transform(rLanded, rLanded, x, y, z, qx, qy, qz, qw); + CoordTransformer const mainToLanded = coord_parent_to_child(rMainSpace, landedTf); + CoordTransformer const landedToArea = coord_parent_to_child(landedTf, rScnFrame); + + mainToArea = coord_composite(landedToArea, mainToLanded); + } + Quaternion const mainToAreaRot{mainToArea.rotation()}; + + float const scale = math::mul_2pow(1.0f, -rMainSpace.m_precision); + + Vector3 const attractorPos = Vector3(mainToArea.transform_position({0, 0, 0})) * scale; + + // Attractor + rScnRender.m_drawTransform[rPlanetDraw.attractor] + = Matrix4::translation(attractorPos) + * Matrix4{mainToAreaRot.toMatrix()} + * Matrix4::scaling({500, 500, 500}); + + rScnRender.m_drawTransform[rPlanetDraw.axis[0]] + = Matrix4::translation(attractorPos) + * Matrix4{mainToAreaRot.toMatrix()} + * Matrix4::scaling({500000, 10, 10}); + rScnRender.m_drawTransform[rPlanetDraw.axis[1]] + = Matrix4::translation(attractorPos) + * Matrix4{mainToAreaRot.toMatrix()} + * Matrix4::scaling({10, 500000, 10}); + rScnRender.m_drawTransform[rPlanetDraw.axis[2]] + = Matrix4::translation(attractorPos) + * Matrix4{mainToAreaRot.toMatrix()} + * Matrix4::scaling({10, 10, 500000}); + + for (std::size_t i = 0; i < rMainSpace.m_satCount; ++i) + { + Vector3g const relative = mainToArea.transform_position({x[i], y[i], z[i]}); + Vector3 const relativeMeters = Vector3(relative) * scale; + + Quaterniond const rot{{qx[i], qy[i], qz[i]}, qw[i]}; + + DrawEnt const drawEnt = rPlanetDraw.drawEnts[i]; + + rScnRender.m_drawTransform[drawEnt] + = Matrix4::translation(relativeMeters) + * Matrix4::scaling({200, 200, 200}) + * Matrix4{(mainToAreaRot * Quaternion{rot}).toMatrix()}; + } + + }); + + return out; +} + Session setup_testplanets_draw( TopTaskBuilder& rBuilder, ArrayView const topData, diff --git a/src/testapp/sessions/universe.h b/src/testapp/sessions/universe.h index 94039d16..30a1064f 100644 --- a/src/testapp/sessions/universe.h +++ b/src/testapp/sessions/universe.h @@ -47,6 +47,15 @@ osp::Session setup_uni_sceneframe( osp::ArrayView topData, osp::Session const& uniCore); +/** + * @brief A single planet setup for landing on + */ +osp::Session setup_uni_landerplanet( + osp::TopTaskBuilder& rBuilder, + osp::ArrayView topData, + osp::Session const& uniCore, + osp::Session const& uniScnFrame); + /** * @brief Unrealistic planets test, allows SceneFrame to move around and get captured into planets */