summaryrefslogtreecommitdiff
path: root/common/light.h
blob: f40118d23b25ffdb081fba34708c948b716b55f6 (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
#ifndef _LIGHT_H_
#define _LIGHT_H_

#include "opengl.h"
#include "object.h"

#define LC_LIGHT_HIDDEN			0x01
#define LC_LIGHT_SELECTED		0x02
#define LC_LIGHT_FOCUSED		0x04
#define LC_LIGHT_TARGET_SELECTED	0x08
#define LC_LIGHT_TARGET_FOCUSED		0x10
#define LC_LIGHT_ENABLED		0x20

class Light;
class LightTarget;

typedef enum { LK_POSITION, LK_TARGET, LK_COLOR } LK_TYPES;

typedef struct LC_LIGHT_KEY
{
  unsigned short  time;
  float	          param[3];
  unsigned char   type;
  LC_LIGHT_KEY*  next;
} LC_LIGHT_KEY;

class LightTarget : public Object
{
 public:
  LightTarget (Light *pParent);
  ~LightTarget ();

 public:
  void MinIntersectDist (LC_CLICKLINE* pLine);

  Light* GetParent () const
    { return m_pParent; }

 protected:
  Light* m_pParent;

  friend class Light; // FIXME: needed for BoundingBoxCalculate ()
  // remove and use UpdatePosition instead
};

class Light : public Object
{
 public:
  Light (float px, float py, float pz);
  Light (float px, float py, float pz, float tx, float ty, float tz);
  virtual ~Light ();





 public:
  Light* m_pNext;

  bool IsVisible()
    { return (m_nState & LC_LIGHT_HIDDEN) == 0; } 
  bool IsSelected()
    { return (m_nState & (LC_LIGHT_SELECTED|LC_LIGHT_TARGET_SELECTED)) != 0; } 
  bool IsEyeSelected()
    { return (m_nState & LC_LIGHT_SELECTED) != 0; } 
  bool IsTargetSelected()
    { return (m_nState & LC_LIGHT_TARGET_SELECTED) != 0; } 
  void Select()
    { m_nState |= (LC_LIGHT_SELECTED|LC_LIGHT_TARGET_SELECTED); } 
  void UnSelect()
    { m_nState &= ~(LC_LIGHT_SELECTED|LC_LIGHT_FOCUSED|LC_LIGHT_TARGET_SELECTED|LC_LIGHT_TARGET_FOCUSED); } 
  void UnFocus()
    { m_nState &= ~(LC_LIGHT_FOCUSED|LC_LIGHT_TARGET_FOCUSED); } 
  void FocusEye()
    { m_nState |= (LC_LIGHT_FOCUSED|LC_LIGHT_SELECTED); } 
  void FocusTarget()
    { m_nState |= (LC_LIGHT_TARGET_FOCUSED|LC_LIGHT_TARGET_SELECTED); } 
  const char* GetName()
    { return m_strName; }
  void GetTargetPos (float *pos) const
    { memcpy (pos, m_fTarget, sizeof (float[3])); }

  void Render (float fLineWidth);
  void MinIntersectDist (LC_CLICKLINE* Line);
  void UpdatePosition (unsigned short nTime, bool bAnimation);
  void CalculatePosition (unsigned short nTime, bool bAnimation, float pos[3], float target[3], float color[3]);
  void Move (unsigned short nTime, bool bAnimation, bool bAddKey, float dx, float dy, float dz);
  void ChangeKey (unsigned short nTime, bool bAnimation, bool bAddKey, float param[3], unsigned char nKeyType);
  void Setup (int index);

protected:
  void RemoveKeys ();
  void Initialize ();

  // Camera target
  LightTarget* m_pTarget;

  // Position
  LC_LIGHT_KEY* m_pAnimationKeys;
  LC_LIGHT_KEY* m_pInstructionKeys;

  // Attributes
  float m_fCone;
  unsigned char m_nState;
  char m_strName[81];
  bool m_bEnabled;

  GLuint m_nList;
  static GLuint m_nSphereList;
  static GLuint m_nTargetList;

  // Temporary position
  float m_fPos[4];
  float m_fTarget[4];
  float m_fColor[4];
};

#endif // _LIGHT_H_