void render_scene(void) {
float angle = timer.GetElapsedSeconds() * 3.14f / 10.0f;
location[0] = -8.0f * cos(angle / 2.0f);
location[1] = -8.0f * sin(angle / 2.0f);
location[2] = 5.0f;
light_0.position[0] = 10.0f * cos(-angle);
light_0.position[1] = 10.0f * sin(-angle);
light_0.position[2] = 3.0f;
look_at(camera_frame, location, target, up_dir);
camera_frame.GetCameraMatrix(camera_matrix);
p_stack.LoadMatrix(view_frustum.GetProjectionMatrix());
mv_stack.LoadMatrix(camera_matrix);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
//--
glUseProgram(shader_color);
mv_stack.PushMatrix();
mv_stack.Translate(light_0.position[0], light_0.position[1], light_0.position[2]);
mv_stack.Scale(0.25f, 0.25f, 0.25f);
glUniformMatrix4fv(mvp_matrix_location_shader_color, 1, GL_FALSE, geometry_pipeline.GetModelViewProjectionMatrix());
draw_light();
mv_stack.PopMatrix();
//--
glUseProgram(shader_light);
glUniformMatrix3fv(normal_matrix_location, 1, GL_FALSE, geometry_pipeline.GetNormalMatrix());
glUniformMatrix4fv(v_matrix_location, 1, GL_FALSE, camera_matrix);
glUniform3fv(intensity_ambient_component_location, 1, intensity_ambient_component);
glUniform3fv(light_0_position_location, 1, light_0.position);
glUniform3fv(light_0_intensity_diffuse_location, 1, light_0.intensity_diffuse);
glUniform3fv(light_0_intensity_specular_location, 1, light_0.intensity_specular);
glUniform3fv(light_0_attenuation_location, 1, light_0.attenuation);
glUniform1f(material_0_ka_location, material_0.ka);
glUniform1f(material_0_kd_location, material_0.kd);
glUniform1f(material_0_ks_location, material_0.ks);
glUniform1f(material_0_alpha_location, material_0.alpha);
//--
for(int i = -10; i <= 10; i += 3)
for(int j = -10; j <= 10; j += 3) {
mv_stack.PushMatrix();
mv_stack.Translate(i, j, 0.0f);
glUniformMatrix4fv(mvp_matrix_location, 1, GL_FALSE, geometry_pipeline.GetModelViewProjectionMatrix());
glUniformMatrix4fv(mv_matrix_location, 1, GL_FALSE, geometry_pipeline.GetModelViewMatrix());
glDrawElements(GL_TRIANGLES, faces.size(), GL_UNSIGNED_INT, 0);
mv_stack.PopMatrix();
}
//--
glUseProgram(0);
glutSwapBuffers();
glutPostRedisplay();
}
void draw_lights(t_draw *draw, t_scene *scene)
{
t_node *node;
t_link *link;
t_lst *lst = scene_lst_get( scene, dt_light);
if( lst)
{
for(link=lst->first;link;link=link->next)
{
node = ( t_node *) link->data;
draw_light(draw,node);
}
}
}
static void moto_light_node_prepare_for_draw(MotoShapeNode *self)
{
MotoLightNodePriv* priv = MOTO_LIGHT_NODE_GET_PRIVATE(self);
MotoLightNode *view = (MotoLightNode *)self;
if(!glIsList(priv->dlist))
priv->dlist = glGenLists(1);
if(!priv->quadric)
priv->quadric = gluNewQuadric();
glNewList(priv->dlist, GL_COMPILE_AND_EXECUTE);
draw_light(view);
glEndList();
priv->prepared = TRUE;
}
void handler() {
process_keys();
update_projectiles();
update_animations();
step_monsters();
game.player.light->update_flicker();
process_sight();
draw_lights(game.fov_light, &game.map.block, game.map.lights);
{
lightsource *k = game.map.lights.head();
for (; k; k = k->next()) {
k->update_flicker();
draw_light(game.fov_light, &game.map.block, k);
}
}
u32 keys = keysHeld();
u32 down = keysDown();
touchPosition touch = touchReadXY();
if (down & KEY_TOUCH && keys & KEY_R && touch.px != 0 && touch.py != 0) {
luxel *l = torch.buf.luxat(torch.buf.scroll.x + touch.px/8, torch.buf.scroll.y + touch.py/8);
iprintf("c:%d,%d,%d v:%d, low:%d\n", l->lr, l->lg, l->lb, l->lval, torch.get_low_luminance());
}
refresh(&game.map.block);
if (game.player.hp <= 0) {
playerdeath();
game.player.clear();
new_game();
}
if (game.cooldown <= 0) game.player.regenerate();
statusbar();
}
/*!
* Main display function; called whenever the scene needs to be redrawn.
*/
static void
display(void)
{
Lib3dsNode *c,*t;
Lib3dsFloat fov, roll;
float near, far, dist;
float *campos;
float *tgt;
Lib3dsMatrix M;
Lib3dsCamera *cam;
Lib3dsVector v;
Lib3dsNode *p;
if( file != NULL && file->background.solid.use )
glClearColor(file->background.solid.col[0],
file->background.solid.col[1],
file->background.solid.col[2], 1.);
/* TODO: fog */
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if( anti_alias )
glEnable(GL_POLYGON_SMOOTH);
else
glDisable(GL_POLYGON_SMOOTH);
if (!file) {
return;
}
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, file->ambient);
c=lib3ds_file_node_by_name(file, camera, LIB3DS_CAMERA_NODE);
t=lib3ds_file_node_by_name(file, camera, LIB3DS_TARGET_NODE);
if( t != NULL )
tgt = t->data.target.pos;
if( c != NULL ) {
fov = c->data.camera.fov;
roll = c->data.camera.roll;
campos = c->data.camera.pos;
}
if ((cam = lib3ds_file_camera_by_name(file, camera)) == NULL)
return;
near = cam->near_range;
far = cam->far_range;
if (c == NULL || t == NULL) {
if( c == NULL ) {
fov = cam->fov;
roll = cam->roll;
campos = cam->position;
}
if( t == NULL )
tgt = cam->target;
}
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
/* KLUDGE alert: OpenGL can't handle a near clip plane of zero,
* so if the camera's near plane is zero, we give it a small number.
* In addition, many .3ds files I've seen have a far plane that's
* much too close and the model gets clipped away. I haven't found
* a way to tell OpenGL not to clip the far plane, so we move it
* further away. A factor of 10 seems to make all the models I've
* seen visible.
*/
if( near <= 0. ) near = far * .001;
gluPerspective( fov, 1.0*gl_width/gl_height, near, far);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glRotatef(-90, 1.0,0,0);
/* User rotates the view about the target point */
lib3ds_vector_sub(v, tgt, campos);
dist = lib3ds_vector_length(v);
glTranslatef(0.,dist, 0.);
glRotatef(view_rotx, 1., 0., 0.);
glRotatef(view_roty, 0., 1., 0.);
glRotatef(view_rotz, 0., 0., 1.);
glTranslatef(0.,-dist, 0.);
lib3ds_matrix_camera(M, campos, tgt, roll);
glMultMatrixf(&M[0][0]);
/* Lights. Set them from light nodes if possible. If not, use the
* light objects directly.
*/
{
static const GLfloat a[] = {0.0f, 0.0f, 0.0f, 1.0f};
static GLfloat c[] = {1.0f, 1.0f, 1.0f, 1.0f};
static GLfloat p[] = {0.0f, 0.0f, 0.0f, 1.0f};
Lib3dsLight *l;
int li=GL_LIGHT0;
for (l=file->lights; l; l=l->next) {
glEnable(li);
light_update(l);
c[0] = l->color[0];
c[1] = l->color[1];
c[2] = l->color[2];
glLightfv(li, GL_AMBIENT, a);
glLightfv(li, GL_DIFFUSE, c);
glLightfv(li, GL_SPECULAR, c);
p[0] = l->position[0];
p[1] = l->position[1];
p[2] = l->position[2];
glLightfv(li, GL_POSITION, p);
if (l->spot_light) {
p[0] = l->spot[0] - l->position[0];
p[1] = l->spot[1] - l->position[1];
p[2] = l->spot[2] - l->position[2];
glLightfv(li, GL_SPOT_DIRECTION, p);
}
++li;
}
}
if( show_object )
{
for (p=file->nodes; p!=0; p=p->next) {
render_node(p);
}
}
if( show_bounds )
draw_bounds(tgt);
if( show_cameras )
{
for( cam = file->cameras; cam != NULL; cam = cam->next )
{
lib3ds_matrix_camera(M, cam->position, cam->target, cam->roll);
lib3ds_matrix_inv(M);
glPushMatrix();
glMultMatrixf(&M[0][0]);
glScalef(size/20, size/20, size/20);
glCallList(cameraList);
glPopMatrix();
}
}
if( show_lights )
{
Lib3dsLight *light;
for( light = file->lights; light != NULL; light = light->next )
draw_light(light->position, light->color);
glMaterialfv(GL_FRONT, GL_EMISSION, black);
}
glutSwapBuffers();
}
