ld33_umonster: 4a6683050e29 src/object.cc

ld33_umonster

view src/object.cc @ 0:4a6683050e29

initial commit

author	John Tsiombikas <nuclear@member.fsf.org>
date	Sat, 22 Aug 2015 07:15:00 +0300
parents
children	35349df5392d

line source

1 #include "object.h"

2 #include "opengl.h"

3 #include "shadow.h"

5 Material::Material()

6 : diffuse(1, 1, 1), specular(0, 0, 0)

7 {

8 shininess = 60.0;

9 alpha = 1.0;

10 }

12 RenderOps::RenderOps()

13 {

14 zwrite = true;

15 cast_shadows = true;

16 transparent = false;

17 }

19 void RenderOps::setup() const

20 {

21 if(!zwrite) {

22 glDepthMask(0);

23 }

24 if(transparent) {

25 glEnable(GL_BLEND);

26 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

27 } else {

28 glDisable(GL_BLEND);

29 }

30 }

32 Object::Object()

33 {

34 mesh = 0;

35 tex = 0;

36 sdr = 0;

37 }

39 Object::~Object()

40 {

41 delete mesh;

42 }

44 Matrix4x4 &Object::xform()

45 {

46 return matrix;

47 }

49 const Matrix4x4 &Object::xform() const

50 {

51 return matrix;

52 }

54 Matrix4x4 &Object::tex_xform()

55 {

56 return tex_matrix;

57 }

59 const Matrix4x4 &Object::tex_xform() const

60 {

61 return tex_matrix;

62 }

64 void Object::set_mesh(Mesh *m)

65 {

66 this->mesh = m;

67 }

69 Mesh *Object::get_mesh() const

70 {

71 return mesh;

72 }

74 void Object::set_texture(unsigned int tex)

75 {

76 this->tex = tex;

77 }

79 void Object::set_shader(unsigned int sdr)

80 {

81 if(GLEW_ARB_vertex_shader && GLEW_ARB_fragment_shader) {

82 this->sdr = sdr;

83 }

84 }

86 unsigned int Object::get_shader() const

87 {

88 return sdr;

89 }

91 void Object::draw() const

92 {

93 if(!mesh) return;

95 if(shadow_pass && !rop.cast_shadows) {

96 return;

97 }

99 glPushAttrib(GL_ENABLE_BIT | GL_DEPTH_BUFFER_BIT);

100 rop.setup();

101

102 if(glcaps.shaders) {

103 if(sdr) {

104 if(!shadow_pass) {

105 glUseProgram(sdr);

106 }

107 } else {

108 glUseProgram(0);

109 }

110 }

111

112 if(tex) {

113 glBindTexture(GL_TEXTURE_2D, tex);

114 glEnable(GL_TEXTURE_2D);

115

116 glMatrixMode(GL_TEXTURE);

117 glPushMatrix();

118 glLoadTransposeMatrixf(tex_matrix[0]);

119 } else {

120 glDisable(GL_TEXTURE_2D);

121 }

122

123 glMatrixMode(GL_MODELVIEW);

124 glPushMatrix();

125 glMultTransposeMatrixf(matrix[0]);

126

127 float dcol[] = {mtl.diffuse.x, mtl.diffuse.y, mtl.diffuse.z, mtl.alpha};

128 glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, dcol);

129 float scol[] = {mtl.specular.x, mtl.specular.y, mtl.specular.z, 1.0f};

130 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, scol);

131 glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, mtl.shininess);

132

133 mesh->draw();

134

135 if(tex) {

136 glDisable(GL_TEXTURE_2D);

137

138 glMatrixMode(GL_TEXTURE);

139 glPopMatrix();

140 }

141

142 if(sdr) {

143 glUseProgram(0);

144 }

145

146 glMatrixMode(GL_MODELVIEW);

147 glPopMatrix();

148

149 glPopAttrib();

150 }

151

152 void Object::draw_wire(const Vector4 &col) const

153 {

154 if(shadow_pass) return;

155

156 glPushAttrib(GL_ENABLE_BIT);

157 glDisable(GL_LIGHTING);

158 glUseProgram(0);

159

160 glMatrixMode(GL_MODELVIEW);

161 glPushMatrix();

162 glMultTransposeMatrixf(matrix[0]);

163

164 glColor4f(col.x, col.y, col.z, col.w);

165 mesh->draw_wire();

166

167 glPopMatrix();

168 glPopAttrib();

169 }

170

171 void Object::draw_vertices(const Vector4 &col) const

172 {

173 glPushAttrib(GL_ENABLE_BIT);

174 glDisable(GL_LIGHTING);

175 glUseProgram(0);

176

177 glMatrixMode(GL_MODELVIEW);

178 glPushMatrix();

179 glMultTransposeMatrixf(matrix[0]);

180

181 glColor4f(col.x, col.y, col.z, col.w);

182 mesh->draw_vertices();

183

184 glPopMatrix();

185 glPopAttrib();

186 }

187

188 void Object::draw_normals(float len, const Vector4 &col) const

189 {

190 glPushAttrib(GL_ENABLE_BIT);

191 glDisable(GL_LIGHTING);

192

193 glMatrixMode(GL_MODELVIEW);

194 glPushMatrix();

195 glMultTransposeMatrixf(matrix[0]);

196

197 glColor4f(col.x, col.y, col.z, col.w);

198 mesh->set_vis_vecsize(len);

199 mesh->draw_normals();

200

201 glPopMatrix();

202 glPopAttrib();

203 }

204

205 void Object::draw_tangents(float len, const Vector4 &col) const

206 {

207 glPushAttrib(GL_ENABLE_BIT);

208 glDisable(GL_LIGHTING);

209

210 glMatrixMode(GL_MODELVIEW);

211 glPushMatrix();

212 glMultTransposeMatrixf(matrix[0]);

213

214 glColor4f(col.x, col.y, col.z, col.w);

215 mesh->set_vis_vecsize(len);

216 mesh->draw_tangents();

217

218 glPopMatrix();

219 glPopAttrib();

220 }

221

222 bool Object::intersect(const Ray &ray, HitPoint *hit) const

223 {

224 return false; // TODO

225 }