Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/trunk/src/orxonox/graphics/Light.h

Last change on this file was 11071, checked in by landauf, 5 years ago

merged branch cpp11_v3 back to trunk

  • Property svn:eol-style set to native
File size: 6.8 KB
Line 
1/*
2 *   ORXONOX - the hottest 3D action shooter ever to exist
3 *                    > www.orxonox.net <
4 *
5 *
6 *   License notice:
7 *
8 *   This program is free software; you can redistribute it and/or
9 *   modify it under the terms of the GNU General Public License
10 *   as published by the Free Software Foundation; either version 2
11 *   of the License, or (at your option) any later version.
12 *
13 *   This program is distributed in the hope that it will be useful,
14 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
15 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 *   GNU General Public License for more details.
17 *
18 *   You should have received a copy of the GNU General Public License
19 *   along with this program; if not, write to the Free Software
20 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
21 *
22 *   Author:
23 *      Fabian 'x3n' Landau
24 *   Co-authors:
25 *      ...
26 *
27 */
28
29#ifndef _Light_H__
30#define _Light_H__
31
32#include "OrxonoxPrereqs.h"
33
34#include <string>
35#include "util/Math.h"
36#include "interfaces/TeamColourable.h"
37#include "worldentities/StaticEntity.h"
38
39namespace orxonox
40{
41    class _OrxonoxExport Light : public StaticEntity, public TeamColourable
42    {
43        public:
44            enum class Type // Copy from the Ogre enum
45            {
46                /// Point light sources give off light equally in all directions, so require only position not direction
47                Point,
48                /// Directional lights simulate parallel light beams from a distant source, hence have direction but no position
49                Directional,
50                /// Spotlights simulate a cone of light from a source so require position and direction, plus extra values for falloff
51                Spotlight
52            };
53
54        public:
55            Light(Context* context);
56            virtual ~Light();
57
58            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
59
60            virtual void changedVisibility() override;
61
62            inline Ogre::Light* getLight()
63                { return this->light_; }
64
65            inline void setType(Light::Type type)
66                { this->type_ = type; this->updateType(); }
67            inline Light::Type getType() const
68                { return this->type_; }
69
70            inline void setDiffuseColour(const ColourValue& colour)
71                { this->diffuse_ = colour; this->updateDiffuseColour(); }
72            inline const ColourValue& getDiffuseColour() const
73                { return this->diffuse_; }
74
75            inline void setSpecularColour(const ColourValue& colour)
76                { this->specular_ = colour; this->updateSpecularColour(); }
77            inline const ColourValue& getSpecularColour() const
78                { return this->specular_; }
79
80            virtual void setTeamColour(const ColourValue& colour) override
81                { this->setDiffuseColour(colour); this->setSpecularColour(colour); }
82
83            /**
84                @brief Sets the attenuation parameters of the light source i.e. how it diminishes with distance.
85                @param attenuation The parameters of the attenuation (see description)
86
87                 - @a attenuation.x range (The absolute upper range of the light in world units)
88                 - @a attenuation.y constant (The constant factor in the attenuation formula: 1.0 means never attenuate, 0.0 is complete attenuation)
89                 - @a attenuation.z linear (The linear factor in the attenuation formula: 1 means attenuate evenly over the distance)
90                 - @a attenuation.w quadratic (The quadratic factor in the attenuation formula: adds a curvature to the attenuation formula)
91
92                Quote from the Ogre API:
93                Lights normally get fainter the further they are away. Also, each light is given a maximum range beyond which it cannot affect any objects.
94                Light attenuation is not applicable to directional lights since they have an infinite range and constant intensity.
95                This follows a standard attenuation approach - see any good 3D text for the details of what they mean since i don't have room here!
96
97                Quote from the Ogre wiki:
98                "Using these numbers, the light has 100% intensity at 0 distance, and
99                trails off to near black at a distance equal to the Range. Keep in mind
100                that most of the light falls in the first 20% of the range."
101
102                Range   Constant   Linear     Quadratic
103                3250,     1.0,     0.0014,    0.000007
104                600,      1.0,     0.007,     0.0002
105                325,      1.0,     0.014,     0.0007
106                200,      1.0,     0.022,     0.0019
107                160,      1.0,     0.027,     0.0028
108                100,      1.0,     0.045,     0.0075
109                65,       1.0,     0.07,      0.017
110                50,       1.0,     0.09,      0.032
111                32,       1.0,     0.14,      0.07
112                20,       1.0,     0.22,      0.20
113                13,       1.0,     0.35,      0.44
114                7,        1.0,     0.7,       1.8
115            */
116            inline void setAttenuation(const Vector4& attenuation)
117                { this->attenuation_ = attenuation; this->updateAttenuation(); }
118            inline const Vector4& getAttenuation() const
119                { return this->attenuation_; }
120
121            /**
122                @brief Sets the range of a spotlight, i.e. the angle of the inner and outer cones and the rate of falloff between them.
123                @param spotlightRange The parameters of the spotlight (see description)
124               
125                 - @a spotlightRange.x innerAngle (The angle covered by the bright inner cone)
126                 - @a spotlightRange.x outerAngle (The angle covered by the outer cone)
127                 - @a spotlightRange.x falloff (The rate of falloff between the inner and outer cones. 1.0 means a linear falloff, less means slower falloff, higher means faster falloff.)
128            */
129            inline void setSpotlightRange(const Vector3& spotlightRange)
130                { this->spotlightRange_ = spotlightRange; this->updateSpotlightRange(); }
131            inline const Vector3& getSpotlightRange() const
132                { return this->spotlightRange_; }
133
134        private:
135            void registerVariables();
136            void setTypeString(const std::string& type);
137            std::string getTypeString() const;
138
139            void updateType();
140            void updateDiffuseColour();
141            void updateSpecularColour();
142            void updateAttenuation();
143            void updateSpotlightRange();
144
145            Ogre::Light* light_;
146            Light::Type type_;
147            ColourValue diffuse_;
148            ColourValue specular_;
149            Vector4 attenuation_;
150            Vector3 spotlightRange_;
151    };
152}
153
154#endif /* _Light_H__ */
Note: See TracBrowser for help on using the repository browser.