Skip to content

Commit

Permalink
#5584: Remove old light vertex rendering code
Browse files Browse the repository at this point in the history
  • Loading branch information
@codereader
codereader committed Jan 21, 2022
1 parent 840bd64 commit fde64a9
Show file tree
Hide file tree
Showing 6 changed files with 1 addition and 333 deletions.
10 changes: 1 addition & 9 deletions radiantcore/entity/light/Doom3LightRadius.h
View file
Expand Up @@ -22,25 +22,17 @@ class Doom3LightRadius: public sigc::trackable
Vector3 m_center;
Vector3 m_centerTransformed;

// The colour of the light center point
Vector3 _centerColour;

std::function<void()> m_changed;

Doom3LightRadius()
: _defaultRadius(game::current::getValue<Vector3>("/defaults/lightRadius")),
m_radius(_defaultRadius),
m_radiusTransformed(0, 0, 0),
m_center(0, 0, 0),
m_centerTransformed(0, 0, 0),
_centerColour(0,0,0)
m_centerTransformed(0, 0, 0)
{
}

void setCenterColour(const Vector3& colour) {
_centerColour = colour;
}

void lightRadiusChanged(const std::string& value)
{
Vector3 candidate = string::convert<Vector3>(value);
Expand Down
166 changes: 0 additions & 166 deletions radiantcore/entity/light/LightNode.cpp
View file
Expand Up @@ -19,14 +19,6 @@ LightNode::LightNode(const IEntityClassPtr& eclass)
m_originKey(std::bind(&LightNode::originChanged, this)),
_originTransformed(ORIGINKEY_IDENTITY),
m_rotationKey(std::bind(&LightNode::rotationChanged, this)),
_rCentre(m_doom3Radius.m_centerTransformed, _lightBox.origin, m_doom3Radius._centerColour),
_rTarget(_projVectors.transformed.target, _lightBox.origin, _projColours.target),
_rUp(_projVectors.transformed.up, _projVectors.transformed.target, _lightBox.origin,
_projColours.up),
_rRight(_projVectors.transformed.right, _projVectors.transformed.target, _lightBox.origin,
_projColours.right),
_rStart(_projVectors.transformed.start, _lightBox.origin, _projColours.start),
_rEnd(_projVectors.transformed.end, _lightBox.origin, _projColours.end),
m_transformChanged(std::bind(&scene::Node::transformChanged, this)),
m_boundsChanged(std::bind(&scene::Node::boundsChanged, this)),
_instances(getDoom3Radius().m_centerTransformed, _projVectors.transformed,
Expand All @@ -46,14 +38,6 @@ LightNode::LightNode(const LightNode& other)
m_originKey(std::bind(&LightNode::originChanged, this)),
_originTransformed(ORIGINKEY_IDENTITY),
m_rotationKey(std::bind(&LightNode::rotationChanged, this)),
_rCentre(m_doom3Radius.m_centerTransformed, _lightBox.origin, m_doom3Radius._centerColour),
_rTarget(_projVectors.transformed.target, _lightBox.origin, _projColours.target),
_rUp(_projVectors.transformed.up, _projVectors.transformed.target, _lightBox.origin,
_projColours.up),
_rRight(_projVectors.transformed.right, _projVectors.transformed.target, _lightBox.origin,
_projColours.right),
_rStart(_projVectors.transformed.start, _lightBox.origin, _projColours.start),
_rEnd(_projVectors.transformed.end, _lightBox.origin, _projColours.end),
m_transformChanged(std::bind(&Node::transformChanged, this)),
m_boundsChanged(std::bind(&Node::boundsChanged, this)),
_instances(getDoom3Radius().m_centerTransformed, _projVectors.transformed,
Expand All @@ -80,12 +64,6 @@ void LightNode::construct()
{
EntityNode::construct();

_projColours.target = Vector3(255,255,0);
_projColours.up = Vector3(255,0,255);
_projColours.right = Vector3(255,0,255);
_projColours.start = Vector3(0,0,0);
_projColours.end = Vector3(0,0,0);

m_rotation.setIdentity();
_lightBox.origin = Vector3(0, 0, 0);
_lightBox.extents = Vector3(8, 8, 8);
Expand Down Expand Up @@ -116,9 +94,6 @@ void LightNode::construct()

_projectionChanged = true;

// set the colours to their default values
m_doom3Radius.setCenterColour(_spawnArgs.getEntityClass()->getColour());

_spawnArgs.setIsContainer(true);

// Load the light colour (might be inherited)
Expand Down Expand Up @@ -391,18 +366,6 @@ void LightNode::renderSolid(IRenderableCollector& collector, const VolumeTest& v
collector.addLight(*this);

EntityNode::renderSolid(collector, volume);

// Render the visible representation of the light entity (origin, bounds etc)
const bool lightIsSelected = isSelected();
renderInactiveComponents(collector, volume, lightIsSelected);
}

void LightNode::renderWireframe(IRenderableCollector& collector, const VolumeTest& volume) const
{
EntityNode::renderWireframe(collector, volume);

const bool lightIsSelected = isSelected();
renderInactiveComponents(collector, volume, lightIsSelected);
}

void LightNode::renderHighlights(IRenderableCollector& collector, const VolumeTest& volume)
Expand All @@ -422,14 +385,6 @@ void LightNode::setRenderSystem(const RenderSystemPtr& renderSystem)
_renderableLightVolume.clear();
_renderableVertices.clear();

// The renderable vertices are maintaining shader objects, acquire/free them now
_rCentre.setRenderSystem(renderSystem);
_rTarget.setRenderSystem(renderSystem);
_rUp.setRenderSystem(renderSystem);
_rRight.setRenderSystem(renderSystem);
_rStart.setRenderSystem(renderSystem);
_rEnd.setRenderSystem(renderSystem);

m_shader.setRenderSystem(renderSystem);

if (renderSystem)
Expand All @@ -450,97 +405,6 @@ void LightNode::setRenderSystem(const RenderSystemPtr& renderSystem)
_instances.end.setRenderSystem(renderSystem);
}

// Renders the components of this light instance
void LightNode::renderComponents(IRenderableCollector& collector, const VolumeTest& volume) const
{
#if 0
// Render the components (light center) as selected/deselected, if we are in the according mode
if (GlobalSelectionSystem().ComponentMode() == selection::ComponentSelectionMode::Vertex)
{
if (isProjected())
{
// A projected light

EntitySettings& settings = *EntitySettings::InstancePtr();

const Vector3& colourStartEndSelected = settings.getLightVertexColour(LightEditVertexType::StartEndSelected);
const Vector3& colourStartEndDeselected = settings.getLightVertexColour(LightEditVertexType::StartEndDeselected);
const Vector3& colourVertexSelected = settings.getLightVertexColour(LightEditVertexType::Selected);
const Vector3& colourVertexDeselected = settings.getLightVertexColour(LightEditVertexType::Deselected);

// Update the colour of the light center dot
_projColours.target = (_instances.target.isSelected()) ? colourVertexSelected
: colourVertexDeselected;
_projColours.right = (_instances.right.isSelected()) ? colourVertexSelected
: colourVertexDeselected;
_projColours.up = (_instances.up.isSelected()) ? colourVertexSelected
: colourVertexDeselected;

_projColours.start = (_instances.start.isSelected()) ? colourStartEndSelected
: colourStartEndDeselected;
_projColours.end = (_instances.end.isSelected()) ? colourStartEndSelected
: colourStartEndDeselected;

// Render the projection points
renderProjectionPoints(collector, volume, localToWorld());
}
else
{
// A point light

// Update the colour of the light center dot
if (_instances.center.isSelected())
{
const_cast<LightNode&>(*this).getDoom3Radius().setCenterColour(
EntitySettings::InstancePtr()->getLightVertexColour(LightEditVertexType::Selected));
renderLightCentre(collector, volume, localToWorld());
}
else
{
const_cast<LightNode&>(*this).getDoom3Radius().setCenterColour(
EntitySettings::InstancePtr()->getLightVertexColour(LightEditVertexType::Deselected));
renderLightCentre(collector, volume, localToWorld());
}
}
}
#endif
}

void LightNode::renderInactiveComponents(IRenderableCollector& collector, const VolumeTest& volume, const bool selected) const
{
#if 0
// greebo: We are not in component selection mode (and the light is still selected),
// check if we should draw the center of the light anyway
if (selected
&& GlobalSelectionSystem().ComponentMode() != selection::ComponentSelectionMode::Vertex
&& EntitySettings::InstancePtr()->getAlwaysShowLightVertices())
{
if (isProjected())
{
EntitySettings& settings = *EntitySettings::InstancePtr();
const Vector3& colourStartEndInactive = settings.getLightVertexColour(LightEditVertexType::StartEndDeselected);
const Vector3& colourVertexInactive = settings.getLightVertexColour(LightEditVertexType::Deselected);

_projColours.start = colourStartEndInactive;
_projColours.end = colourStartEndInactive;
_projColours.target = colourVertexInactive;
_projColours.right = colourVertexInactive;
_projColours.up = colourVertexInactive;

// Render the projection points
renderProjectionPoints(collector, volume, localToWorld());
}
else
{
const Vector3& colourVertexInactive = EntitySettings::InstancePtr()->getLightVertexColour(LightEditVertexType::Inactive);

const_cast<LightNode&>(*this).getDoom3Radius().setCenterColour(colourVertexInactive);
renderLightCentre(collector, volume, localToWorld());
}
}
#endif
}

Vector4 LightNode::getEntityColour() const
{
return _overrideColKey.get() ? EntityNode::getEntityColour() : Vector4(_colourKey.getColour(), 1.0);
Expand Down Expand Up @@ -983,36 +847,6 @@ Doom3LightRadius& LightNode::getDoom3Radius() {
return m_doom3Radius;
}

void LightNode::renderProjectionPoints(IRenderableCollector& collector,
const VolumeTest& volume,
const Matrix4& localToWorld) const
{
// Add the renderable light target
collector.setHighlightFlag(IRenderableCollector::Highlight::Primitives, false);
collector.setHighlightFlag(IRenderableCollector::Highlight::Faces, false);

collector.addRenderable(*_rRight.getShader(), _rRight, localToWorld);
collector.addRenderable(*_rUp.getShader(), _rUp, localToWorld);
collector.addRenderable(*_rTarget.getShader(), _rTarget, localToWorld);

if (_projUseFlags.start)
{
collector.addRenderable(*_rStart.getShader(), _rStart, localToWorld);
}

if (_projUseFlags.end)
{
collector.addRenderable(*_rEnd.getShader(), _rEnd, localToWorld);
}
}

// Adds the light centre renderable to the given collector
void LightNode::renderLightCentre(IRenderableCollector& collector, const VolumeTest& volume,
const Matrix4& localToWorld) const
{
collector.addRenderable(*_rCentre.getShader(), _rCentre, localToWorld);
}

void LightNode::translate(const Vector3& translation)
{
_originTransformed += translation;
Expand Down
27 changes: 0 additions & 27 deletions radiantcore/entity/light/LightNode.h
View file
@@ -1,7 +1,6 @@
#pragma once

#include "Doom3LightRadius.h"
#include "RenderableVertices.h"
#include "Renderables.h"
#include "LightShader.h"

Expand Down Expand Up @@ -43,23 +42,12 @@ class LightNode :

Doom3LightRadius m_doom3Radius;

// Renderable components of this light
RenderableLightTarget _rCentre;
RenderableLightTarget _rTarget;
RenderableLightRelative _rUp;
RenderableLightRelative _rRight;
RenderableLightTarget _rStart;
RenderableLightTarget _rEnd;

RotationMatrix m_lightRotation;
bool m_useLightRotation = false;

// Projected light vectors, both base and transformed
scene::TransformedCopy<Projected<Vector3>> _projVectors;

// Projected light vector colours
mutable Projected<Vector3> _projColours;

// Projected light use flags
Projected<bool> _projUseFlags;

Expand Down Expand Up @@ -172,10 +160,8 @@ class LightNode :
// Renderable implementation
void onPreRender(const VolumeTest& volume) override;
void renderSolid(IRenderableCollector& collector, const VolumeTest& volume) const override;
void renderWireframe(IRenderableCollector& collector, const VolumeTest& volume) const override;
void renderHighlights(IRenderableCollector& collector, const VolumeTest& volume) override;
void setRenderSystem(const RenderSystemPtr& renderSystem) override;
void renderComponents(IRenderableCollector& collector, const VolumeTest& volume) const override;

bool isOriented() const override
{
Expand Down Expand Up @@ -222,7 +208,6 @@ class LightNode :
void onSelectionStatusChange(bool changeGroupStatus) override;

private:
void renderInactiveComponents(IRenderableCollector& collector, const VolumeTest& volume, const bool selected) const;
void evaluateTransform();

// Ensure the start and end points are set to sensible values
Expand All @@ -235,21 +220,9 @@ class LightNode :
void lightRightChanged(const std::string& value);
void lightStartChanged(const std::string& value);
void lightEndChanged(const std::string& value);
void writeLightOrigin();
void rotationChanged();
void lightRotationChanged(const std::string& value);
void onLightRadiusChanged();
void destroy();

// Renderable submission functions
void renderWireframe(IRenderableCollector& collector,
const VolumeTest& volume,
const Matrix4& localToWorld,
bool selected) const;

// Adds the light centre renderable to the given collector
void renderLightCentre(IRenderableCollector& collector, const VolumeTest& volume, const Matrix4& localToWorld) const;
void renderProjectionPoints(IRenderableCollector& collector, const VolumeTest& volume, const Matrix4& localToWorld) const;

// Returns a reference to the member class Doom3LightRadius (used to set colours)
Doom3LightRadius& getDoom3Radius();
Expand Down

0 comments on commit fde64a9

Please sign in to comment.