Celestia

1
// nebularenderer.cpp
2
//
3
// Copyright (C) 2001-present, the Celestia Development Team
4
// Original version by Chris Laurel, Fridger Schrempp, and Toti
5
//
6
// This program is free software; you can redistribute it and/or
7
// modify it under the terms of the GNU General Public License
8
// as published by the Free Software Foundation; either version 2
9
// of the License, or (at your option) any later version.
10

11
#include <algorithm>
12
#include <celengine/meshmanager.h>
13
#include <celengine/nebula.h>
14
#include <celengine/rendcontext.h>
15
#include <celengine/render.h>
16
#include <celmath/geomutil.h>
17
#include <celmath/vecgl.h>
18
#include <celutil/reshandle.h>
19
#include "nebularenderer.h"
20

21

22
namespace celestia::render
23
{
24

25
struct NebulaRenderer::Object
26
{
27
    Object(const Eigen::Vector3f &offset, float nearZ, float farZ, const Nebula *nebula) :
28
        offset(offset),
29
        nearZ(nearZ),
30
        farZ(farZ),
31
        nebula(nebula)
32
    {
33
    }
34

35
    Eigen::Vector3f offset; // distance to the nebula
36
    float           nearZ;  // if nearZ != & farZ != then use custom projection matrix
37
    float           farZ;
38
    const Nebula   *nebula;
39
};
40

41
NebulaRenderer::NebulaRenderer(Renderer &renderer) :
42
    m_renderer(renderer)
43
{
44
}
45

46
NebulaRenderer::~NebulaRenderer() = default; // define here as Object is not defined in the header file
47

48
void
49
NebulaRenderer::update(const Eigen::Quaternionf &viewerOrientation, float pixelSize, float fov, float zoom)
50
{
51
    m_viewerOrientation = viewerOrientation;
52
    m_pixelSize = pixelSize;
53
    m_fov = fov;
54
    m_zoom = zoom;
55
}
56

57
void
58
NebulaRenderer::add(const Nebula *nebula, const Eigen::Vector3f &offset, float /*brightness*/, float nearZ, float farZ)
59
{
60
    m_objects.emplace_back(offset, nearZ, farZ, nebula);
61
}
62

63
void
64
NebulaRenderer::render()
65
{
66
    // draw more distant objects first
67
    std::sort(m_objects.begin(), m_objects.end(),
68
        [](const auto &o1, const auto &o2){ return o1.offset.squaredNorm() > o2.offset.squaredNorm(); });
69

70
    for (const auto &obj : m_objects)
71
        renderNebula(obj);
72

73
    m_objects.clear();
74
}
75

76
void
77
NebulaRenderer::renderNebula(const Object &obj) const
78
{
79
    Geometry *g = nullptr;
80
    if (auto geometry = obj.nebula->getGeometry(); geometry != InvalidResource)
81
        g = engine::GetGeometryManager()->find(geometry);
82
    if (g == nullptr)
83
        return;
84

85
    Eigen::Matrix4f pr;
86
    if (obj.nearZ != 0.0f && obj.farZ != 0.0f)
87
        m_renderer.buildProjectionMatrix(pr, obj.nearZ, obj.farZ, m_zoom);
88
    else
89
        pr = m_renderer.getProjectionMatrix();
90

91
    Renderer::PipelineState ps;
92
    ps.smoothLines = true;
93
    m_renderer.setPipelineState(ps);
94

95
    float radius = obj.nebula->getRadius();
96

97
    Eigen::Matrix4f mv = math::rotate(
98
        math::scale(math::translate(m_renderer.getModelViewMatrix(), obj.offset), radius),
99
        obj.nebula->getOrientation());
100

101
    GLSLUnlit_RenderContext rc(&m_renderer, radius, &mv, &pr);
102
    rc.setPointScale(2.0f * radius / m_pixelSize);
103
    g->render(rc);
104
}
105

106
} // namespace celestia::render
107