absence_thelab: 1cffe3409164 src/3deng/lights.h

absence_thelab

view src/3deng/lights.h @ 0:1cffe3409164

initial commit

author	John Tsiombikas <nuclear@member.fsf.org>
date	Thu, 23 Oct 2014 01:46:07 +0300
parents
children

line source

1 #ifndef _LIGHTS_H_

2 #define _LIGHTS_H_

4 #include <string>

5 #include "switches.h"

6 #include "n3dmath.h"

7 #include "3dengine.h"

9 enum LightType {

10 LTDir = D3DLIGHT_DIRECTIONAL,

11 LTSpot = D3DLIGHT_SPOT,

12 LTPoint = D3DLIGHT_POINT

13 };

15 /////////////////////////////////////////////////////////////////////

16 // -- Abstract Base class Light -- //

17 // pure virtual functions for every possible light parameter, //

18 // implement non-applicable functions as private in each subclass. //

19 /////////////////////////////////////////////////////////////////////

21 class Light {

22 protected:

23 float intensity;

24 Color ambient_color, diffuse_color, specular_color;

25 bool CastShadows;

27 public:

28 std::string name;

30 Light();

32 // set parameters

33 virtual void SetPosition(const Vector3 &pos) = 0;

34 virtual void SetDirection(const Vector3 &dir) = 0;

35 virtual void SetColor(const Color &color, PhongComponent comp = (PhongComponent)-1);

36 virtual void SetIntensity(float intensity);

37 virtual void SetRange(float range) = 0;

38 virtual void SetAttenuation(float att0, float att1, float att2) = 0;

39 virtual void SetShadowCasting(bool enable);

41 // get parameters

42 virtual Vector3 GetPosition() const = 0;

43 virtual Vector3 GetDirection() const = 0;

44 virtual const Color &GetColor(PhongComponent comp = Diffuse) const;

45 virtual float GetIntensity() const;

46 virtual float GetRange() const = 0;

47 virtual float GetAttenuation(int degree) const = 0;

48 virtual bool GetShadowCasting() const;

50 virtual LightType GetType() const = 0;

52 virtual void SetCone(float InnerCone, float OuterCone) = 0;

53 virtual float GetInnerCone() const = 0;

54 virtual float GetOuterCone() const = 0;

56 virtual void SetFalloff(float falloff) = 0;

57 virtual float GetFalloff() const = 0;

59 // position transformations

60 virtual void ResetTransform() = 0;

61 virtual void ResetTranslation() = 0;

62 virtual void ResetRotation() = 0;

64 virtual void Transform(const Matrix4x4 &matrix) = 0;

65 virtual void Translate(float x, float y, float z) = 0;

66 virtual void Rotate(float x, float y, float z) = 0;

67 virtual void Rotate(const Vector3 &axis, float angle) = 0;

69 // direction transformations

70 virtual void ResetDirTransform() = 0;

71 virtual void ResetDirRotation() = 0;

73 virtual void TransformDir(const Matrix4x4 &matrix) = 0;

74 virtual void RotateDir(float x, float y, float z) = 0;

75 virtual void RotateDir(const Vector3 &axis, float angle) = 0;

77 // target transformations

78 virtual void ResetTargetTransform() = 0;

79 virtual void ResetTargetTranslation() = 0;

80 virtual void ResetTargetRotation() = 0;

81 virtual void TargetTransform(const Matrix4x4 &matrix) = 0;

82 virtual void TargetTranslate(float x, float y, float z) = 0;

83 virtual void TargetRotate(float x, float y, float z) = 0;

84 virtual void TargetRotate(const Vector3 &axis, float angle) = 0;

86 virtual void SetLight(dword index, GraphicsContext *gc) const = 0;

88 virtual void Draw(GraphicsContext *gc, float size = 1.0f) = 0;

89 };

91 // Directional Light

92 class DirLight : public Light {

93 private:

94 // Non-Applicable functions for this type of light

95 virtual void SetPosition(const Vector3 &pos);

96 virtual void SetRange(float range);

97 virtual void SetAttenuation(float att0, float att1, float att2);

98 virtual Vector3 GetPosition() const;

99 virtual float GetRange() const;

100 virtual float GetAttenuation(int degree) const;

101 virtual void ResetTransform();

102 virtual void ResetTranslation();

103 virtual void ResetRotation();

104 virtual void Transform(const Matrix4x4 &matrix);

105 virtual void Translate(float x, float y, float z);

106 virtual void Rotate(float x, float y, float z);

107 virtual void Rotate(const Vector3 &axis, float angle);

108 virtual void ResetTargetTransform();

109 virtual void ResetTargetTranslation();

110 virtual void ResetTargetRotation();

111 virtual void TargetTransform(const Matrix4x4 &matrix);

112 virtual void TargetTranslate(float x, float y, float z);

113 virtual void TargetRotate(float x, float y, float z);

114 virtual void TargetRotate(const Vector3 &axis, float angle);

115 virtual void SetCone(float InnerCone, float OuterCone);

116 virtual float GetInnerCone() const;

117 virtual float GetOuterCone() const;

118 virtual void SetFalloff(float falloff);

119 virtual float GetFalloff() const;

120

121

122 protected:

123 Vector3 Direction;

124 Matrix4x4 DirRot;

125

126 public:

127 DirLight();

128 DirLight(const Vector3 &dir);

129

130 // accessors

131 virtual void SetDirection(const Vector3 &dir);

132 virtual Vector3 GetDirection() const;

133

134 virtual LightType GetType() const;

135

136 // direction transformations

137 virtual void ResetDirTransform();

138 virtual void ResetDirRotation();

139

140 virtual void TransformDir(const Matrix4x4 &matrix);

141 virtual void RotateDir(float x, float y, float z);

142 virtual void RotateDir(const Vector3 &axis, float angle);

143

144 virtual void SetLight(dword index, GraphicsContext *gc) const;

145

146 virtual void Draw(GraphicsContext *gc, float size = 1.0f);

147 };

148

149 // Point Light (omni)

150 class PointLight : public Light {

151 private:

152 // Non-Applicable member functions

153 virtual void SetDirection(const Vector3 &dir);

154 virtual Vector3 GetDirection() const;

155 virtual void ResetDirTransform();

156 virtual void ResetDirRotation();

157 virtual void TransformDir(const Matrix4x4 &matrix);

158 virtual void RotateDir(float x, float y, float z);

159 virtual void RotateDir(const Vector3 &axis, float angle);

160 virtual void ResetTargetTransform();

161 virtual void ResetTargetTranslation();

162 virtual void ResetTargetRotation();

163 virtual void TargetTransform(const Matrix4x4 &matrix);

164 virtual void TargetTranslate(float x, float y, float z);

165 virtual void TargetRotate(float x, float y, float z);

166 virtual void TargetRotate(const Vector3 &axis, float angle);

167 virtual void SetCone(float InnerCone, float OuterCone);

168 virtual float GetInnerCone() const;

169 virtual float GetOuterCone() const;

170 virtual void SetFalloff(float falloff);

171 virtual float GetFalloff() const;

172

173 protected:

174 Vector3 Position;

175 float Range;

176 float Attenuation[3];

177

178 Matrix4x4 PosRot, PosTrans, PosXForm;

179

180 virtual Matrix4x4 GetTransform() const;

181

182 public:

183 PointLight();

184 PointLight(const Vector3 &pos, float range = 1000.0f, float att0 = 1.0f, float att1 = 0.0f, float att2 = 0.0f);

185

186 // accessors

187 virtual void SetPosition(const Vector3 &pos);

188 virtual void SetRange(float range);

189 virtual void SetAttenuation(float att0, float att1, float att2);

190

191 virtual Vector3 GetPosition() const;

192 virtual float GetRange() const;

193 virtual float GetAttenuation(int degree) const;

194

195 virtual LightType GetType() const;

196

197 // position transformations

198 virtual void ResetTransform();

199 virtual void ResetTranslation();

200 virtual void ResetRotation();

201

202 virtual void Transform(const Matrix4x4 &matrix);

203 virtual void Translate(float x, float y, float z);

204 virtual void Rotate(float x, float y, float z);

205 virtual void Rotate(const Vector3 &axis, float angle);

206

207 virtual void SetLight(dword index, GraphicsContext *gc) const;

208

209 virtual void Draw(GraphicsContext *gc, float size = 100.0f);

210 };

211

212 // Spotlight

213 class SpotLight : public PointLight {

214 private:

215 virtual void ResetTargetTransform();

216 virtual void ResetTargetTranslation();

217 virtual void ResetTargetRotation();

218 virtual void TargetTransform(const Matrix4x4 &matrix);

219 virtual void TargetTranslate(float x, float y, float z);

220 virtual void TargetRotate(float x, float y, float z);

221 virtual void TargetRotate(const Vector3 &axis, float angle);

222

223 protected:

224 Vector3 Direction;

225 Matrix4x4 DirRot;

226

227 float Falloff;

228 float Theta, Phi;

229

230 public:

231 SpotLight();

232 SpotLight(const Vector3 &pos, const Vector3 &dir, float InnerCone, float OuterCone, float range = 1000.0f, float att0 = 1.0f, float att1 = 0.0f, float att2 = 0.0f);

233

234 // accessors

235 virtual void SetDirection(const Vector3 &dir);

236 virtual Vector3 GetDirection() const;

237

238 // direction transformations

239 virtual void ResetDirTransform();

240 virtual void ResetDirRotation();

241

242 virtual void TransformDir(const Matrix4x4 &matrix);

243 virtual void RotateDir(float x, float y, float z);

244 virtual void RotateDir(const Vector3 &axis, float angle);

245

246 virtual LightType GetType() const;

247

248 virtual void SetCone(float InnerCone, float OuterCone);

249 virtual float GetInnerCone() const;

250 virtual float GetOuterCone() const;

251

252 virtual void SetFalloff(float falloff);

253 virtual float GetFalloff() const;

254

255 virtual void SetLight(dword index, GraphicsContext *gc) const;

256

257 virtual void Draw(GraphicsContext *gc, float size = 100.0f);

258 };

259

260 class TargetSpotLight : public SpotLight {

261 private:

262 // Non-Applicable shit

263 virtual void SetDirection(const Vector3 &dir);

264 virtual Vector3 GetDirection() const;

265 virtual void ResetDirTransform();

266 virtual void ResetDirRotation();

267 virtual void TransformDir(const Matrix4x4 &matrix);

268 virtual void RotateDir(float x, float y, float z);

269 virtual void RotateDir(const Vector3 &axis, float angle);

270

271 protected:

272 Vector3 Target;

273 Matrix4x4 TargRot, TargTrans, TargXForm;

274

275 virtual Matrix4x4 GetTargetTransform() const;

276

277 public:

278

279 TargetSpotLight();

280 TargetSpotLight(const Vector3 &pos, const Vector3 &target, float InnerCone, float OuterCone, float range = 1000.0f, float att0 = 1.0f, float att1 = 0.0f, float att2 = 0.0f);

281

282 virtual void ResetTargetTransform();

283 virtual void ResetTargetTranslation();

284 virtual void ResetTargetRotation();

285

286 virtual void TargetTransform(const Matrix4x4 &matrix);

287 virtual void TargetTranslate(float x, float y, float z);

288 virtual void TargetRotate(float x, float y, float z);

289 virtual void TargetRotate(const Vector3 &axis, float angle);

290

291 virtual void SetLight(dword index, GraphicsContext *gc) const;

292

293 virtual void Draw(GraphicsContext *gc, float size = 100.0f);

294 };

295

296 #endif // _LIGHTS_H_