Loading [MathJax]/extensions/TeX/AMSmath.js
Radium Engine  1.6.3
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
SpotLight.hpp
1#pragma once
2
3#include <Core/CoreMacros.hpp>
4#include <Core/Math/Math.hpp>
5#include <Eigen/Core>
6#include <Engine/Data/RenderParameters.hpp>
7#include <Engine/RaEngine.hpp>
8#include <Engine/Scene/Light.hpp>
9#include <map>
10#include <string>
11
12namespace Ra {
13namespace Engine {
14
15namespace Scene {
16class Entity;
20class RA_ENGINE_API SpotLight final : public Ra::Engine::Scene::Light
21{
22
23 public:
24 explicit SpotLight( Entity* entity, const std::string& name = "spotlight" );
25 ~SpotLight() override = default;
26
27 void setPosition( const Eigen::Matrix<Scalar, 3, 1>& position ) override;
28 inline const Eigen::Matrix<Scalar, 3, 1>& getPosition() const;
29
30 void setDirection( const Eigen::Matrix<Scalar, 3, 1>& direction ) override;
31 inline const Eigen::Matrix<Scalar, 3, 1>& getDirection() const;
32
33 inline void setInnerAngleInRadians( Scalar angle );
34 inline void setOuterAngleInRadians( Scalar angle );
35 inline void setInnerAngleInDegrees( Scalar angle );
36 inline void setOuterAngleInDegrees( Scalar angle );
37
38 inline Scalar getInnerAngle() const;
39 inline Scalar getOuterAngle() const;
40
41 inline void setAttenuation( const Attenuation& attenuation );
42 inline void setAttenuation( Scalar constant, Scalar linear, Scalar quadratic );
43 inline const Attenuation& getAttenuation() const;
44
45 std::string getShaderInclude() const override;
46
47 private:
48 Eigen::Matrix<Scalar, 3, 1> m_position { 0, 0, 0 };
49 Eigen::Matrix<Scalar, 3, 1> m_direction { 0, -1, 0 };
50
51 Scalar m_innerAngle { Core::Math::PiDiv4 };
52 Scalar m_outerAngle { Core::Math::PiDiv2 };
53
54 Attenuation m_attenuation { 1, 0, 0 };
55};
56
57// ---------------------------------------------------------------------------------------------
58// ---- inline methods implementation
59
60inline void SpotLight::setPosition( const Eigen::Matrix<Scalar, 3, 1>& position ) {
61 m_position = position;
62 getRenderParameters().setVariable( "light.spot.position", m_position );
63}
64
65inline const Eigen::Matrix<Scalar, 3, 1>& Scene::SpotLight::getPosition() const {
66 return m_position;
67}
68
69inline void SpotLight::setDirection( const Eigen::Matrix<Scalar, 3, 1>& direction ) {
70 m_direction = direction.normalized();
71 getRenderParameters().setVariable( "light.spot.direction", m_direction );
72}
73
74inline const Eigen::Matrix<Scalar, 3, 1>& SpotLight::getDirection() const {
75 return m_direction;
76}
77
78inline void SpotLight::setInnerAngleInRadians( Scalar angle ) {
79 m_innerAngle = angle;
80 getRenderParameters().setVariable( "light.spot.innerAngle", m_innerAngle );
81}
82
83inline void SpotLight::setOuterAngleInRadians( Scalar angle ) {
84 m_outerAngle = angle;
85 getRenderParameters().setVariable( "light.spot.outerAngle", m_outerAngle );
86}
87
88inline void SpotLight::setInnerAngleInDegrees( Scalar angle ) {
89 m_innerAngle = angle * Core::Math::toRad;
90}
91
92inline void SpotLight::setOuterAngleInDegrees( Scalar angle ) {
93 m_outerAngle = Core::Math::toRad * angle;
94}
95
96inline Scalar SpotLight::getInnerAngle() const {
97 return m_innerAngle;
98}
99
100inline Scalar SpotLight::getOuterAngle() const {
101 return m_outerAngle;
102}
103
104inline void SpotLight::setAttenuation( const Attenuation& attenuation ) {
105 m_attenuation = attenuation;
106 getRenderParameters().setVariable( "light.spot.attenuation.constant", m_attenuation.constant );
107 getRenderParameters().setVariable( "light.spot.attenuation.linear", m_attenuation.linear );
108 getRenderParameters().setVariable( "light.spot.attenuation.quadratic",
109 m_attenuation.quadratic );
110}
111
112inline void SpotLight::setAttenuation( Scalar constant, Scalar linear, Scalar quadratic ) {
113 setAttenuation( { constant, linear, quadratic } );
114}
115
116inline const SpotLight::Attenuation& SpotLight::getAttenuation() const {
117 return m_attenuation;
118}
119
120} // namespace Scene
121} // namespace Engine
122} // namespace Ra
void setVariable(const std::string &name, RenderParameters &rp)
overload create ref wrapper for RenderParameters variable
An entity is an scene element. It ties together components with a transform.
Definition Entity.hpp:23
const Data::RenderParameters & getRenderParameters() const
Gives read-only access to the renderParameters of the light.
Definition Light.hpp:96
void setDirection(const Eigen::Matrix< Scalar, 3, 1 > &direction) override
Definition SpotLight.hpp:69
void setPosition(const Eigen::Matrix< Scalar, 3, 1 > &position) override
Definition SpotLight.hpp:60
Scalar angle(const Vector_ &v1, const Vector_ &v2)
hepler function to manage enum as underlying types in VariableSet
Definition Cage.cpp:4