blob: f853da822e24049b0b193255e1c1acfcc38f8fea (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
|
/*
model/classes.h
This file is part of the Osirion project and is distributed under
the terms of the GNU General Public License version 2
*/
#ifndef __INCLUDED_MODEL_CLASSES_H__
#define __INCLUDED_MODEL_CLASSES_H__
#include "math/axis.h"
#include "math/color.h"
#include "math/vector3f.h"
namespace model
{
/* ---- class MapClass --------------------------------------------- */
class MapClass
{
public:
MapClass();
~MapClass();
inline const math::Vector3f &location() const { return mapclass_location; }
inline const math::Axis &axis() const { return mapclass_axis; }
inline void set_location(const math::Vector3f location) { mapclass_location.assign(location); }
inline void set_axis(const math::Axis axis) { mapclass_axis.assign(axis); }
private:
math::Vector3f mapclass_location;
math::Axis mapclass_axis;
};
/* ---- class Light ------------------------------------------------ */
/// an exterior light
class Light
{
public:
Light();
Light(const math::Vector3f & location, const math::Color & color, bool strobe=false);
~Light();
inline const math::Vector3f & location() const
{
return light_location;
}
inline const math::Color & color() const
{
return light_color;
};
/// true if this is a strobe light
inline bool strobe() const
{
return light_strobe;
}
/// true if this light has entity color
inline bool entity() const
{
return light_entity;
}
/// size of the light, default is 1.0f
inline float radius() const
{
return light_radius;
}
/// strobe time offset, in seconds
inline float offset() const
{
return light_offset;
}
/// frequency in strobes per second
inline float frequency() const
{
return light_frequency;
}
/// fraction a strobe light will be on, default is 0.5f
inline float time() const
{
return light_time;
}
/// flare texture number
inline unsigned int flare() const
{
return light_flare;
}
/// render texture number
inline size_t texture() const
{
return render_texture;
}
math::Vector3f light_location;
math::Color light_color;
bool light_strobe;
bool light_entity;
float light_radius;
float light_frequency;
float light_offset;
float light_time;
unsigned int light_flare;
size_t render_texture;
};
/* ---- class Flare ------------------------------------------------ */
/// a flare is a directional light
class Flare : public Light
{
public:
Flare();
~Flare();
inline const math::Axis axis() const
{
return flare_axis;
}
inline bool engine() const
{
return flare_engine;
}
math::Axis flare_axis;
bool flare_engine;
};
/* ---- class Particles -------------------------------------------- */
/// a particle system
class Particles
{
public:
Particles();
Particles(const math::Vector3f & location);
~Particles();
inline const math::Vector3f & location() const
{
return particles_location;
}
inline const math::Axis &axis() const
{
return particles_axis;
}
inline const std::string & script() const
{
return particles_script;
}
inline bool entity() const
{
return particles_entity;
}
inline bool engine() const
{
return particles_engine;
}
std::string particles_script;
math::Vector3f particles_location;
math::Axis particles_axis;
bool particles_entity;
bool particles_engine;
};
/* ---- class Dock ------------------------------------------------- */
/// a docking location
class Dock
{
public:
Dock();
~Dock();
/// location of the dock
inline const math::Vector3f & location() const
{
return dock_location;
}
/// trigger distance default is 0.01f
inline float radius() const
{
return dock_radius;
}
math::Vector3f dock_location;
float dock_radius;
};
}
#endif // __INCLUDED_MODEL_CLASSES_H__
|
