SceneView.cpp

#include "SceneView.hpp"
#include <Nazara/Graphics/GraphicalMesh.hpp>
#include <Nazara/Graphics/Material.hpp>
#include <Nazara/Graphics/Model.hpp>
#include <Nazara/Core/Primitive.hpp>
#include <iostream>
#include <type_traits>
#include <algorithm>
#include <cmath>
#include <limits>



SceneView::SceneView(QWidget* parent)
    : QWidget(parent)
{
    setMinimumSize(800, 600);
    setAttribute(Qt::WA_NativeWindow);
    setFocusPolicy(Qt::StrongFocus);
    setMouseTracking(true);
    // Nécessaire pour obtenir un HWND exploitable par Nazara
    setAttribute(Qt::WA_NativeWindow);

    renderTimer.setInterval(16);

    connect(
        &renderTimer,
        &QTimer::timeout,
        this,
        &SceneView::render
    );
}

SceneView::~SceneView()
{
    renderTimer.stop();

    // Important :
    // les entités ECS doivent disparaître avant le monde Nazara.
    cameraEntity = {};

    renderSystem = nullptr;
    windowSwapchain = nullptr;

    world.reset();
    nazaraWindow.reset();
}

void SceneView::showEvent(QShowEvent* event)
{
    QWidget::showEvent(event);

    if (!initialized)
        initializeNazara();
}

void SceneView::resizeEvent(QResizeEvent* event)
{
    QWidget::resizeEvent(event);

    if (!initialized || !windowSwapchain)
        return;

    Nz::Vector2ui size = windowSwapchain->GetSize();

    std::cout
        << "Resize SceneView : "
        << size.x << " x "
        << size.y
        << std::endl;
}

void SceneView::initializeNazara()
{
    std::cout
        << "=== INITIALISATION SCENEVIEW ECS ==="
        << std::endl;

    if (initialized)
        return;

    WId id = winId();

    if (!id)
    {
        std::cout << "ERREUR : HWND Qt invalide" << std::endl;
        return;
    }

    std::cout
        << "HWND Qt = "
        << reinterpret_cast<void*>(id)
        << std::endl;

    // ------------------------------------------------------------
    // 1. Création du handle de fenêtre Nazara
    // ------------------------------------------------------------

    Nz::WindowHandle handle;

    handle.type = Nz::WindowBackend::Windows;
    handle.windows.window =
        reinterpret_cast<void*>(id);

    nazaraWindow =
        std::make_unique<Nz::Window>(handle);
    // =========================
// CUBE
// =========================

    Nz::MeshParams meshParams;
    meshParams.vertexDeclaration =
        Nz::VertexDeclaration::Get(
            Nz::VertexLayout::XYZ_Normal_UV
        );

    std::shared_ptr<Nz::GraphicalMesh> cubeMesh =
        Nz::GraphicalMesh::Build(
            Nz::Primitive::Box(
                Nz::Vector3f(0.5f, 0.5f, 0.5f)
            ),
            meshParams
        );

    cubeModel =
        std::make_shared<Nz::Model>(
            std::move(cubeMesh)
        );

    cubeMaterial =
        Nz::MaterialInstance::Instantiate(
            Nz::MaterialType::Phong
        );

    cubeModel->SetMaterial(
        0,
        cubeMaterial
    );
    Nz::Boxf aabb = cubeModel->GetAABB();

    std::cout
        << "Cube AABB = "
        << "x=" << aabb.x
        << " y=" << aabb.y
        << " z=" << aabb.z
        << " width=" << aabb.width
        << " height=" << aabb.height
        << " depth=" << aabb.depth
        << std::endl;
    std::cout
        << "Cube material count = "
        << cubeModel->GetMaterialCount()
        << std::endl;

    std::cout
        << "Cube material[0] = "
        << (cubeModel->GetMaterial(0) != nullptr)
        << std::endl;




    if (!nazaraWindow)
    {
        std::cout
            << "ERREUR : création Nz::Window"
            << std::endl;

        return;
    }

    std::cout
        << "Nz::Window OK"
        << std::endl;

    // ------------------------------------------------------------
    // 2. Création du monde ECS
    // ------------------------------------------------------------

    world =
        std::make_unique<Nz::EnttWorld>();

    std::cout
        << "EnttWorld OK"
        << std::endl;

    // ------------------------------------------------------------
    // 3. Ajout du RenderSystem
    // ------------------------------------------------------------

    renderSystem =
        &world->AddSystem<Nz::RenderSystem>();

    std::cout
        << "RenderSystem OK"
        << std::endl;

    // ------------------------------------------------------------
    // 4. Création de la swapchain
    // ------------------------------------------------------------

    windowSwapchain =
        &renderSystem->CreateSwapchain(
            *nazaraWindow
        );

    if (!windowSwapchain)
    {
        std::cout
            << "ERREUR : WindowSwapchain"
            << std::endl;

        return;
    }

    std::cout
        << "WindowSwapchain OK"
        << std::endl;

    // ------------------------------------------------------------
    // 5. Création de l'entité caméra
    // ------------------------------------------------------------

    cameraEntity = world->CreateEntity();

    if (!cameraEntity)
    {
        qFatal("Impossible de créer l'entité caméra");
    }

    std::cout
        << "Camera Entity OK"
        << std::endl;

    // ------------------------------------------------------------
   // 6. Node de la caméra
   // ------------------------------------------------------------

    auto& cameraNode =
        cameraEntity.emplace<Nz::NodeComponent>();

    orbitTarget = Nz::Vector3f::Zero();

    orbitDistance = 5.f;
    orbitYaw = 0.f;
    orbitPitch = 0.f;

    updateOrbitCamera();

    std::cout
        << "=== CAMERA DEBUG ===" << std::endl
        << "position = " << cameraNode.GetPosition() << std::endl
        << "forward = " << cameraNode.GetForward() << std::endl
        << "backward = " << cameraNode.GetBackward() << std::endl;

    std::cout
        << "Camera Node OK"
        << std::endl;

    // ------------------------------------------------------------
    // 7. CameraComponent
    // ------------------------------------------------------------

    auto& cameraComponent =
        cameraEntity.emplace<Nz::CameraComponent>(
            std::make_shared<Nz::RenderWindow>(
                *windowSwapchain
            )
        );

    cameraComponent.UpdateZNear(0.1f);
    cameraComponent.UpdateZFar(1000.f);

    cameraComponent.UpdateRenderMask(1);

    // On conserve le rouge pour vérifier que la nouvelle
    // architecture ECS fonctionne.
    cameraComponent.UpdateClearColor(
        Nz::Color::DarkBlue()
    );

    std::cout
        << "CameraComponent OK"
        << std::endl;
    // ------------------------------------------------------------
// 8. Création du cube
// ------------------------------------------------------------

    cubeEntity = world->CreateEntity();

    std::cout
        << "=== ENTITY IDS ===" << std::endl
        << "cameraEntity = "
        << static_cast<std::uint32_t>(cameraEntity.entity())
        << std::endl
        << "cubeEntity   = "
        << static_cast<std::uint32_t>(cubeEntity.entity())
        << std::endl;

    auto& cubeNode = cubeEntity.emplace<Nz::NodeComponent>();

    std::cout
        << "cube position AVANT = "
        << cubeNode.GetPosition()
        << std::endl;

    cubeNode.SetPosition(Nz::Vector3f::Zero());

    std::cout
        << "cube position APRES = "
        << cubeNode.GetPosition()
        << std::endl;
    
    cubeNode.SetRotation(
        Nz::Quaternionf(
            Nz::EulerAnglesf(
                Nz::DegreeAnglef(25.f),
                Nz::DegreeAnglef(35.f),
                Nz::DegreeAnglef(0.f)
            )
        )
    );

    auto& cubeGraphics =
        cubeEntity.emplace<Nz::GraphicsComponent>();
    std::cout
        << "Cube model material count avant AttachRenderable = "
        << cubeModel->GetMaterialCount()
        << std::endl;

    std::cout
        << "cubeEntity final = "
        << static_cast<std::uint32_t>(cubeEntity.entity())
        << std::endl
        << "cubeNode final position = "
        << cubeNode.GetPosition()
        << std::endl;
    
    cubeGraphics.AttachRenderable(
        cubeModel
    );
    
    
    
    initializeFaceHighlights();

    std::cout << "=== CUBE AABB ===" << std::endl;
    std::cout << "Valid    = " << aabb.IsValid() << std::endl;
    std::cout << "Null     = " << aabb.IsNull() << std::endl;

    std::cout
        << "Position = "
        << aabb.GetPosition().x << ", "
        << aabb.GetPosition().y << ", "
        << aabb.GetPosition().z
        << std::endl;

    std::cout
        << "Lengths  = "
        << aabb.GetLengths().x << ", "
        << aabb.GetLengths().y << ", "
        << aabb.GetLengths().z
        << std::endl;

    std::cout
        << "Minimum  = "
        << aabb.GetMinimum().x << ", "
        << aabb.GetMinimum().y << ", "
        << aabb.GetMinimum().z
        << std::endl;

    std::cout
        << "Maximum  = "
        << aabb.GetMaximum().x << ", "
        << aabb.GetMaximum().y << ", "
        << aabb.GetMaximum().z
        << std::endl;
    const auto& renderables = cubeGraphics.GetRenderables();

    for (std::size_t i = 0; i < Nz::GraphicsComponent::MaxRenderableCount; ++i)
    {
        if (renderables[i].renderable)
        {
            std::cout
                << "Renderable[" << i << "] PRESENT"
                << " mask=" << renderables[i].renderMask
                << std::endl;
        }
    }

    std::cout << "Has NodeComponent = "
        << cubeEntity.all_of<Nz::NodeComponent>()
        << std::endl;

    std::cout << "Has GraphicsComponent = "
        << cubeEntity.all_of<Nz::GraphicsComponent>()
        << std::endl;

    std::cout << "Cube Entity OK" << std::endl;
    std::cout << "Cube model = " << cubeModel.get() << std::endl;
    std::cout << "Cube graphics OK" << std::endl;
    
    // ------------------------------------------------------------
    // 8. Vérification de la taille
    // ------------------------------------------------------------

    Nz::Vector2ui size =
        windowSwapchain->GetSize();

    std::cout
        << "Swapchain size = "
        << size.x
        << " x "
        << size.y
        << std::endl;

    if (size.y == 0)
    {
        std::cout
            << "ERREUR : hauteur swapchain = 0"
            << std::endl;

        return;
    }

    // ------------------------------------------------------------
    // 9. Initialisation terminée
    // ------------------------------------------------------------

    initialized = true;

    std::cout
        << "=== SCENEVIEW ECS INITIALISE ==="
        << std::endl;

    // Premier rendu
    render();

    // Puis rendu continu
    renderTimer.start();
}

void SceneView::initializeFaceHighlights()
{
    highlightMaterial =
        Nz::MaterialInstance::Instantiate(Nz::MaterialType::Phong);

    highlightMaterial->SetValueProperty(
        "BaseColor",
        Nz::MaterialSettings::Value{ Nz::Color::Orange() }
    );

    const float offset = 0.502f;
    const float size = 0.96f;

    struct FaceInfo
    {
        Nz::Vector3f position;
        Nz::Quaternionf rotation;
    };

    const std::array<FaceInfo, 6> faces =
    { {
            // Front
            {
                Nz::Vector3f(0.f, 0.f, -offset),
                Nz::Quaternionf(Nz::EulerAnglesf(
                    Nz::DegreeAnglef(0.f),
                    Nz::DegreeAnglef(180.f),
                    Nz::DegreeAnglef(0.f)))
            },

        // Back
        {
            Nz::Vector3f(0.f, 0.f, offset),
            Nz::Quaternionf::Identity()
        },

        // Left
        {
            Nz::Vector3f(-offset, 0.f, 0.f),
            Nz::Quaternionf(Nz::EulerAnglesf(
                Nz::DegreeAnglef(0.f),
                Nz::DegreeAnglef(-90.f),
                Nz::DegreeAnglef(0.f)))
        },

        // Right
        {
            Nz::Vector3f(offset, 0.f, 0.f),
            Nz::Quaternionf(Nz::EulerAnglesf(
                Nz::DegreeAnglef(0.f),
                Nz::DegreeAnglef(90.f),
                Nz::DegreeAnglef(0.f)))
        },

        // Top
        {
            Nz::Vector3f(0.f, offset, 0.f),
            Nz::Quaternionf(Nz::EulerAnglesf(
                Nz::DegreeAnglef(-90.f),
                Nz::DegreeAnglef(0.f),
                Nz::DegreeAnglef(0.f)))
        },

        // Bottom
        {
            Nz::Vector3f(0.f, -offset, 0.f),
            Nz::Quaternionf(Nz::EulerAnglesf(
                Nz::DegreeAnglef(90.f),
                Nz::DegreeAnglef(0.f),
                Nz::DegreeAnglef(0.f)))
        }
    } };

    for (std::size_t i = 0; i < faces.size(); ++i)
    {
        Nz::MeshParams meshParams;
        meshParams.vertexDeclaration =
            Nz::VertexDeclaration::Get(
                Nz::VertexLayout::XYZ_Normal_UV
            );

        auto mesh = Nz::GraphicalMesh::Build(
            Nz::Primitive::Box(
                Nz::Vector3f(0.96f, 0.96f, 0.01f)
            ),
            meshParams
        );

        auto model = std::make_shared<Nz::Model>(mesh);
        model->SetMaterial(0, highlightMaterial);

        faceHighlights[i] = world->CreateEntity();

        auto& node =
            faceHighlights[i].emplace<Nz::NodeComponent>();

        // Attachement au cube en conservant le repère local
        node.SetParent(
            cubeEntity.get<Nz::NodeComponent>(),
            false
        );

        // Position locale sur la face
        node.SetPosition(faces[i].position);

        std::cout << "Position locale : "
            << node.GetPosition() << std::endl;

        std::cout << "Position globale : "
            << node.GetGlobalPosition() << std::endl;

        // Orientation locale de la face
        node.SetRotation(faces[i].rotation);

        // Échelle locale
        node.SetScale(Nz::Vector3f(1.f, 1.f, 1.f));

        auto& graphics =
            faceHighlights[i].emplace<Nz::GraphicsComponent>();

        graphics.AttachRenderable(model);
        //graphics.Show(false);
    }
}

void SceneView::updateFaceHighlight()
{
    if (faceHighlights[0])
        faceHighlights[0].get<Nz::GraphicsComponent>().Show();
}

void SceneView::pickCubeFace(const QPoint& mousePosition)
{
    if (!cubeEntity || !cameraEntity ||
        !cubeModel ||
        !cubeEntity.all_of<Nz::NodeComponent>() ||
        !cameraEntity.all_of<Nz::NodeComponent,
        Nz::CameraComponent>())
        return;

    auto& cameraNode =
        cameraEntity.get<Nz::NodeComponent>();

    auto& camera =
        cameraEntity.get<Nz::CameraComponent>();

    auto& cubeNode =
        cubeEntity.get<Nz::NodeComponent>();

    // --------------------------------
    // 1. Coordonnées de la souris
    // --------------------------------

    const float viewportWidth = float(width());
    const float viewportHeight = float(height());

    if (viewportWidth <= 0.f || viewportHeight <= 0.f)
        return;

    const float x =
        2.f * float(mousePosition.x()) / viewportWidth - 1.f;

    const float y =
        1.f - 2.f * float(mousePosition.y()) / viewportHeight;

    // Camera.hpp indique un FOV initial de 90 degrés.
    // tan(90 / 2) = 1.
    const float tanHalfFov = 1.f;

    const float aspect = camera.GetAspectRatio();

    // --------------------------------
    // 2. Construction du rayon 3D
    // --------------------------------

    Nz::Vector3f rayOrigin =
        cameraNode.GetGlobalPosition();

    Nz::Vector3f rayDirection =
        cameraNode.GetForward()
        + cameraNode.GetRight() * (x * aspect * tanHalfFov)
        + cameraNode.GetUp() * (y * tanHalfFov);

    rayDirection.Normalize();

    // --------------------------------
    // 3. Passage dans le repère local
    // --------------------------------

    Nz::Vector3f localOrigin =
        cubeNode.ToLocalPosition(rayOrigin);

    Nz::Vector3f localDirection =
        cubeNode.ToLocalDirection(rayDirection);

    // --------------------------------
    // 4. Récupération des limites du cube
    // --------------------------------

    Nz::Boxf aabb = cubeModel->GetAABB();

    Nz::Vector3f minimum = aabb.GetMinimum();
    Nz::Vector3f maximum = aabb.GetMaximum();

    float origins[3] = {
        localOrigin.x,
        localOrigin.y,
        localOrigin.z
    };

    float directions[3] = {
        localDirection.x,
        localDirection.y,
        localDirection.z
    };

    float mins[3] = {
        minimum.x,
        minimum.y,
        minimum.z
    };

    float maxs[3] = {
        maximum.x,
        maximum.y,
        maximum.z
    };

    // --------------------------------
    // 5. Intersection rayon / AABB
    // --------------------------------

    float tNear = 0.f;
    float tFar = std::numeric_limits<float>::max();

    int hitAxis = -1;
    int hitSign = 0;

    for (int axis = 0; axis < 3; ++axis)
    {
        if (std::abs(directions[axis]) < 0.000001f)
        {
            if (origins[axis] < mins[axis] ||
                origins[axis] > maxs[axis])
            {
                selectedFace = CubeFace::None;updateFaceHighlight();
                std::cout << "AUCUNE FACE" << std::endl;
                return;
            }

            continue;
        }

        float t1;
        float t2;
        int sign;

        if (directions[axis] > 0.f)
        {
            t1 = (mins[axis] - origins[axis])
                / directions[axis];

            t2 = (maxs[axis] - origins[axis])
                / directions[axis];

            sign = -1;
        }
        else
        {
            t1 = (maxs[axis] - origins[axis])
                / directions[axis];

            t2 = (mins[axis] - origins[axis])
                / directions[axis];

            sign = 1;
        }

        if (t1 > tNear)
        {
            tNear = t1;
            hitAxis = axis;
            hitSign = sign;
        }

        tFar = std::min(tFar, t2);

        if (tNear > tFar)
        {
            selectedFace = CubeFace::None;updateFaceHighlight();
            std::cout << "AUCUNE FACE" << std::endl;
            return;
        }
    }

    if (hitAxis < 0 || tFar < 0.f)
    {
        selectedFace = CubeFace::None;updateFaceHighlight();
        std::cout << "AUCUNE FACE" << std::endl;
        return;
    }

    // --------------------------------
    // 6. Identification de la face
    // --------------------------------

    if (hitAxis == 0)
        selectedFace = (hitSign < 0)
        ? CubeFace::Left
        : CubeFace::Right;

    else if (hitAxis == 1)
        selectedFace = (hitSign < 0)
        ? CubeFace::Bottom
        : CubeFace::Top;

    else
        selectedFace = (hitSign < 0)
        ? CubeFace::Front
        : CubeFace::Back;

    // --------------------------------
    // 7. Affichage du résultat
    // --------------------------------

    const char* faceNames[] = {
        "NONE",
        "FRONT",
        "BACK",
        "LEFT",
        "RIGHT",
        "TOP",
        "BOTTOM"
    };

    std::cout
        << "FACE SELECTIONNEE : "
        << faceNames[static_cast<int>(selectedFace)]
        << std::endl;

	updateFaceHighlight();
}



void SceneView::updateOrbitCamera()
{
    if (!world || !cameraEntity ||
        !cameraEntity.all_of<Nz::NodeComponent>())
        return;

    auto& cameraNode =
        cameraEntity.get<Nz::NodeComponent>();

    const float cosPitch = std::cos(orbitPitch);
    const float sinPitch = std::sin(orbitPitch);

    const float cosYaw = std::cos(orbitYaw);
    const float sinYaw = std::sin(orbitYaw);

    Nz::Vector3f offset(
        orbitDistance * sinYaw * cosPitch,
        orbitDistance * sinPitch,
        -orbitDistance * cosYaw * cosPitch
    );

    Nz::Vector3f cameraPosition =
        orbitTarget + offset;

    cameraNode.SetPosition(cameraPosition);

    Nz::Vector3f direction =
        (orbitTarget - cameraPosition).GetNormal();

    Nz::Vector3f lookDirection = -direction;

    Nz::Vector3f worldUp = Nz::Vector3f::Up();

    Nz::Vector3f right =
        Nz::Vector3f::CrossProduct(
            worldUp,
            lookDirection
        ).GetNormal();

    Nz::Vector3f correctedUp =
        Nz::Vector3f::CrossProduct(
            lookDirection,
            right
        ).GetNormal();

    cameraNode.SetRotation(
        Nz::Quaternionf::LookAt(
            lookDirection,
            correctedUp,
            right
        )
    );

    std::cout
        << "\n=== ORBIT CAMERA DEBUG ===" << std::endl
        << "yaw      = " << orbitYaw << std::endl
        << "pitch    = " << orbitPitch << std::endl
        << "distance = " << orbitDistance << std::endl
        << "position = " << cameraNode.GetPosition() << std::endl
        << "direction attendue = " << direction << std::endl
        << "forward obtenu     = " << cameraNode.GetForward() << std::endl
        << "up obtenu          = " << cameraNode.GetUp() << std::endl
        << "target   = " << orbitTarget << std::endl;
}
void SceneView::mousePressEvent(QMouseEvent* event)
{
    std::cout
        << "MOUSE PRESS : button = "
        << static_cast<int>(event->button())
        << std::endl;
    
    if (event->button() == Qt::LeftButton)
    {
        pickCubeFace(event->pos());

        event->accept();
        return;
    }
    if (event->button() == Qt::RightButton)
    {
        orbitRotating = true;
        lastMousePosition = event->pos();
        setFocus();
        std::cout << "ORBIT START" << std::endl;

        event->accept();
        return;
    }

    if (event->button() == Qt::MiddleButton)
    {
        orbitPanning = true;
        lastMousePosition = event->pos();

        setFocus();

        std::cout << "PAN START" << std::endl;

        event->accept();
        return;
    }

    QWidget::mousePressEvent(event);
}
void SceneView::mouseMoveEvent(QMouseEvent* event)
{
    QPoint delta = event->pos() - lastMousePosition;
    lastMousePosition = event->pos();

    // ROTATION CAMERA : CLIC DROIT
    if (orbitRotating &&
        (event->buttons() & Qt::RightButton))
    {
        orbitYaw += delta.x() * orbitSensitivity;
        orbitPitch += delta.y() * orbitSensitivity;

        constexpr float pitchLimit = 1.55334f;

        orbitPitch = std::clamp(
            orbitPitch,
            -pitchLimit,
            pitchLimit
        );

        updateOrbitCamera();

        event->accept();
        return;
    }

    // PANORAMIQUE CAMERA : CLIC MOLETTE
    if (orbitPanning &&
        (event->buttons() & Qt::MiddleButton))
    {
        auto& cameraNode =
            cameraEntity.get<Nz::NodeComponent>();

        Nz::Vector3f right = cameraNode.GetRight();
        Nz::Vector3f up = cameraNode.GetUp();

        const float panSpeed = orbitDistance * 0.002f;

        Nz::Vector3f offset =
            right * (-delta.x() * panSpeed) +
            up * (delta.y() * panSpeed);

        // Déplacer la cible
        orbitTarget += offset;

        // Déplacer la caméra exactement de la même distance
        Nz::Vector3f newPosition =
            cameraNode.GetPosition() + offset;

        cameraNode.SetPosition(newPosition);

        event->accept();
        return;
    }

    QWidget::mouseMoveEvent(event);
}

void SceneView::keyPressEvent(QKeyEvent* event)
{
    switch (event->key()) {
    case Qt::Key_Plus:
    case Qt::Key_8:
        orbitDistance *= 0.9f;
            break;
    case Qt::Key_Minus:
        case Qt::Key_2:
            orbitDistance *= 1.1f;
            break;
        case Qt::Key_F:
            orbitTarget = Nz::Vector3f::Zero();
            orbitDistance = 5.f;

            orbitYaw = 0.f;
            orbitPitch = 0.f;

            updateOrbitCamera();
            break;
        default:
            QWidget::keyPressEvent(event);
            return;
    
    }
	orbitDistance = std::clamp(
		orbitDistance,
		0.5f,
		100.f
	);

	updateOrbitCamera();
	event->accept();
}


void SceneView::mouseReleaseEvent(QMouseEvent* event)
{
    if (event->button() == Qt::RightButton)
    {
        orbitRotating = false;

        std::cout << "ORBIT STOP" << std::endl;

        event->accept();
        return;
    }
    if (event->button() == Qt::MiddleButton)
    {
        orbitPanning = false;

        std::cout << "PAN STOP" << std::endl;

        event->accept();
        return;
    }

    QWidget::mouseReleaseEvent(event);
}
void SceneView::render()
{
    static unsigned int frameCounter = 0;

    if (++frameCounter % 120 == 0)
    {
        std::cout
            << "SceneView render frame = "
            << frameCounter
            << std::endl;
    }
    if (!initialized || !world)
        return;

    auto& registry = world->GetRegistry();

    auto view = registry.view<Nz::NodeComponent, Nz::GraphicsComponent>();

    std::size_t count = 0;

    for (auto entity : view)
    {
        ++count;

        std::cout
            << "Renderable entity = "
            << static_cast<std::underlying_type_t<entt::entity>>(entity)
            << std::endl;
    }

    std::cout << "Renderable count = " << count << std::endl;

    world->Update(Nz::Time::Milliseconds(16));
}