static void game_draw_back(int pose, int d, const float p[3])
{
float c[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
float t = SDL_GetTicks() / 1000.f + 120.0f;
glPushMatrix();
{
if (d < 0)
{
glRotatef(game_rz * 2, view_e[2][0], view_e[2][1], view_e[2][2]);
glRotatef(game_rx * 2, view_e[0][0], view_e[0][1], view_e[0][2]);
}
glTranslatef(p[0], p[1], p[2]);
glColor4fv(c);
if (config_get_d(CONFIG_BACKGROUND))
{
/* Draw all background layers back to front. */
sol_back(&back, BACK_DIST, FAR_DIST, t);
back_draw(0);
sol_back(&back, 0, BACK_DIST, t);
/* Draw all foreground geometry in the background file. */
sol_draw(&back);
}
else back_draw(0);
}
glPopMatrix();
}
void flag_draw(struct s_rend *rend, const GLfloat *p)
{
glPushMatrix();
{
glTranslatef(p[0], p[1], p[2]);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
sol_draw(&flag.draw, rend, 1, 1);
}
glPopMatrix();
}
void beam_draw(struct s_rend *rend, const GLfloat *p,
const GLfloat *c, GLfloat r, GLfloat h)
{
glPushMatrix();
{
glTranslatef(p[0], p[1], p[2]);
glScalef(r, h, r);
glColor4f(c[0], c[1], c[2], c[3]);
sol_draw(&beam.draw, rend, 1, 1);
}
glPopMatrix();
}
void jump_draw(struct s_rend *rend, const GLfloat *p, GLfloat r, GLfloat h)
{
GLfloat height = (hmd_stat() ? 0.3f : 1.0f) * config_get_d(CONFIG_HEIGHT);
glPointSize(height / 12);
glPushMatrix();
{
glTranslatef(p[0], p[1], p[2]);
glScalef(r, h, r);
sol_draw(&jump.draw, rend, 1, 1);
}
glPopMatrix();
}
void item_draw(const struct s_item *hp, float r)
{
float c[3];
struct s_file *fp = NULL;
switch (hp->t)
{
case ITEM_COIN: fp = &item_coin_file; break;
case ITEM_GROW: fp = &item_grow_file; break;
case ITEM_SHRINK: fp = &item_shrink_file; break;
}
item_color(hp, c);
glColor3fv(c);
sol_draw(fp, 0, 1);
}
void back_draw(struct s_rend *rend)
{
glDisable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE);
glDisable(GL_LIGHTING);
glDepthMask(GL_FALSE);
glPushMatrix();
{
glScalef(-BACK_DIST, BACK_DIST, -BACK_DIST);
sol_draw(&back.draw, rend, 1, 1);
}
glPopMatrix();
glDepthMask(GL_TRUE);
glEnable(GL_LIGHTING);
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
}
void item_draw(struct s_rend *rend,
const struct v_item *hp,
const GLfloat *M, float t)
{
const GLfloat s = ITEM_RADIUS;
struct s_draw *draw = item_file(hp);
glPushMatrix();
{
glScalef(s, s, s);
glDepthMask(GL_FALSE);
{
sol_bill(draw, rend, M, t);
}
glDepthMask(GL_TRUE);
sol_draw(draw, rend, 0, 1);
}
glPopMatrix();
}
void game_draw(int pose, float t)
{
const float light_p[4] = { 8.f, 32.f, 8.f, 0.f };
struct s_draw *fp = &file.draw;
struct s_rend rend;
float fov = FOV;
if (!state)
return;
fp->shadow_ui = ball;
game_shadow_conf(1);
sol_draw_enable(&rend);
if (jump_b) fov *= 2.0f * fabsf(jump_dt - 0.5f);
video_push_persp(fov, 0.1f, FAR_DIST);
glPushMatrix();
{
float T[16], M[16], v[3], c[3];
/* In VR, move the view center up to keep the viewer level. */
v_cpy(c, view_c);
if (hmd_stat())
c[1] += view_dy;
video_calc_view(T, c, view_p, view_e[1]);
m_xps(M, T);
v_sub(v, c, view_p);
glTranslatef(0.f, 0.f, -v_len(v));
glMultMatrixf(M);
glTranslatef(-c[0], -c[1], -c[2]);
/* Center the skybox about the position of the camera. */
glPushMatrix();
{
glTranslatef(view_p[0], view_p[1], view_p[2]);
back_draw(&rend);
}
glPopMatrix();
glEnable(GL_LIGHT0);
glLightfv(GL_LIGHT0, GL_POSITION, light_p);
/* Draw the floor. */
sol_draw(fp, &rend, 0, 1);
/* Draw the game elements. */
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
if (pose == 0)
{
game_draw_balls(&rend, fp->vary, T, t);
game_draw_vect(&rend, fp->vary);
}
glDisable(GL_LIGHTING);
glDepthMask(GL_FALSE);
{
game_draw_flags(&rend, fp->base);
game_draw_beams(&rend, fp->base, fp->vary);
}
glDepthMask(GL_TRUE);
glEnable(GL_LIGHTING);
}
glPopMatrix();
video_pop_matrix();
sol_draw_disable(&rend);
game_shadow_conf(0);
}
static void game_draw_fore(struct s_rend *rend,
struct game_draw *gd,
int pose, const float *M,
int d, float t)
{
const float *ball_p = gd->vary.uv[0].p;
struct s_draw *draw = &gd->draw;
glPushMatrix();
{
/* Rotate the environment about the position of the ball. */
game_draw_tilt(gd, d);
/* Compute clipping planes for reflection and ball facing. */
game_clip_refl(d);
game_clip_ball(gd, d, ball_p);
if (d < 0)
glEnable(GL_CLIP_PLANE0);
switch (pose)
{
case POSE_LEVEL:
sol_draw(draw, rend, 0, 1);
break;
case POSE_BALL:
if (curr_tex_env == &tex_env_pose)
{
/*
* We need the check above because otherwise the
* active texture env is set up in a way that makes
* level geometry visible, and we don't want that.
*/
glDepthMask(GL_FALSE);
sol_draw(draw, rend, 0, 1);
glDepthMask(GL_TRUE);
}
game_draw_balls(rend, draw->vary, M, t);
break;
case POSE_NONE:
/* Draw the coins. */
game_draw_items(rend, draw->vary, M, t);
/* Draw the floor. */
sol_draw(draw, rend, 0, 1);
/* Draw the ball. */
game_draw_balls(rend, draw->vary, M, t);
break;
}
/* Draw the billboards, entities, and particles. */
glDisable(GL_LIGHTING);
glDepthMask(GL_FALSE);
{
sol_bill(draw, rend, M, t);
game_draw_goals(rend, gd, M, t);
game_draw_jumps(rend, gd, M, t);
game_draw_swchs(rend, draw->vary);
part_draw_coin(rend);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
}
glDepthMask(GL_TRUE);
glEnable(GL_LIGHTING);
if (d < 0)
glDisable(GL_CLIP_PLANE0);
}
glPopMatrix();
}
void game_draw(int pose, float t)
{
const float light_p[4] = { 8.f, 32.f, 8.f, 0.f };
struct s_draw *fp = &file.draw;
struct s_rend rend;
float fov = FOV;
if (!state)
return;
fp->shadow_ui = ball;
game_shadow_conf(1);
sol_draw_enable(&rend);
if (jump_b) fov *= 2.0f * fabsf(jump_dt - 0.5f);
video_push_persp(fov, 0.1f, FAR_DIST);
glPushMatrix();
{
float T[16], M[16], v[3], rx, ry;
m_view(T, view_c, view_p, view_e[1]);
m_xps(M, T);
v_sub(v, view_c, view_p);
rx = V_DEG(fatan2f(-v[1], fsqrtf(v[0] * v[0] + v[2] * v[2])));
ry = V_DEG(fatan2f(+v[0], -v[2]));
glTranslatef(0.f, 0.f, -v_len(v));
glMultMatrixf(M);
glTranslatef(-view_c[0], -view_c[1], -view_c[2]);
/* Center the skybox about the position of the camera. */
glPushMatrix();
{
glTranslatef(view_p[0], view_p[1], view_p[2]);
back_draw(&rend, 0);
}
glPopMatrix();
glEnable(GL_LIGHT0);
glLightfv(GL_LIGHT0, GL_POSITION, light_p);
/* Draw the floor. */
sol_draw(fp, &rend, 0, 1);
/* Draw the game elements. */
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
if (pose == 0)
{
game_draw_balls(&rend, fp->vary, T, t);
game_draw_vect(&rend, fp->vary);
}
glDisable(GL_LIGHTING);
glDepthMask(GL_FALSE);
{
game_draw_goals(&rend, fp->base);
game_draw_jumps(&rend, fp->base);
game_draw_swchs(&rend, fp->vary);
}
glDepthMask(GL_TRUE);
glEnable(GL_LIGHTING);
}
glPopMatrix();
video_pop_matrix();
sol_draw_disable(&rend);
game_shadow_conf(0);
}
void game_draw(int pose, float t)
{
static const float a[4] = { 0.2f, 0.2f, 0.2f, 1.0f };
static const float s[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
static const float e[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
static const float h[1] = { 0.0f };
const float light_p[4] = { 8.f, 32.f, 8.f, 1.f };
const struct s_file *fp = &file;
float fov = FOV;
if (jump_b) fov *= 2.0f * fabsf(jump_dt - 0.5f);
video_push_persp(fov, 0.1f, FAR_DIST);
glPushAttrib(GL_LIGHTING_BIT);
glPushMatrix();
{
float T[16], M[16], v[3], rx, ry;
m_view(T, view_c, view_p, view_e[1]);
m_xps(M, T);
v_sub(v, view_c, view_p);
rx = V_DEG(fatan2f(-v[1], fsqrtf(v[0] * v[0] + v[2] * v[2])));
ry = V_DEG(fatan2f(+v[0], -v[2]));
glTranslatef(0.f, 0.f, -v_len(v));
glMultMatrixf(M);
glTranslatef(-view_c[0], -view_c[1], -view_c[2]);
/* Center the skybox about the position of the camera. */
glPushMatrix();
{
glTranslatef(view_p[0], view_p[1], view_p[2]);
back_draw(0);
}
glPopMatrix();
glEnable(GL_LIGHT0);
glLightfv(GL_LIGHT0, GL_POSITION, light_p);
/* Draw the floor. */
sol_draw(fp, 0, 1);
if (config_get_d(CONFIG_SHADOW) && !pose)
{
shad_draw_set(fp->uv[ball].p, fp->uv[ball].r);
sol_shad(fp);
shad_draw_clr();
}
/* Draw the game elements. */
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
if (pose == 0)
{
game_draw_balls(fp, T, t);
game_draw_vect(fp);
}
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, a);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, s);
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, e);
glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, h);
game_draw_goals(fp);
glEnable(GL_COLOR_MATERIAL);
glDisable(GL_LIGHTING);
glDisable(GL_TEXTURE_2D);
glDepthMask(GL_FALSE);
{
game_draw_jumps(fp);
game_draw_swchs(fp);
}
glDepthMask(GL_TRUE);
glEnable(GL_TEXTURE_2D);
glEnable(GL_LIGHTING);
glDisable(GL_COLOR_MATERIAL);
}
glPopMatrix();
glPopAttrib();
video_pop_matrix();
}
static void game_draw_fore(int pose, float rx, float ry, int d, const float p[3])
{
const float *ball_p = file.uv->p;
const float ball_r = file.uv->r;
#ifndef NO_LIGHT
glPushAttrib(GL_LIGHTING_BIT | GL_COLOR_BUFFER_BIT);
#else
glPushAttrib(GL_COLOR_BUFFER_BIT);
#endif
{
glPushMatrix();
{
/* Rotate the environment about the position of the ball. */
glTranslatef(+ball_p[0], +ball_p[1] * d, +ball_p[2]);
glRotatef(-game_rz * d, view_e[2][0], view_e[2][1], view_e[2][2]);
glRotatef(-game_rx * d, view_e[0][0], view_e[0][1], view_e[0][2]);
glTranslatef(-ball_p[0], -ball_p[1] * d, -ball_p[2]);
#ifndef DREAMCAST_KGL_NOT_IMPLEMENT
if (d < 0)
{
GLdouble e[4];
e[0] = +0;
e[1] = +1;
e[2] = +0;
e[3] = -0.00001;
glEnable(GL_CLIP_PLANE0);
glClipPlane(GL_CLIP_PLANE0, e);
}
#endif
/* Draw the floor. */
sol_draw(&file); // 50 %
if (config_get_d(CONFIG_SHADOW))
{
shad_draw_set(ball_p, ball_r);
sol_shad(&file);
shad_draw_clr();
}
/* Draw the game elements. */
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
if (pose == 0)
{
part_draw_coin(-rx * d, -ry);
game_draw_coins(&file); // 5%
game_draw_balls(&file); // 5%
}
game_draw_goals(&file, -rx * d, -ry);
game_draw_jumps(&file);
game_draw_swchs(&file);
#ifndef DREAMCAST_KGL_NOT_IMPLEMENT
glDisable(GL_CLIP_PLANE0);
#endif
}
glPopMatrix();
}
glPopAttrib();
}
void vect_draw(struct s_rend *rend)
{
sol_draw(&vect.draw, rend, 0, 1);
sol_draw(&vect.draw, rend, 0, 0);
}
void mark_draw(struct s_rend *rend)
{
sol_draw(&mark.draw, rend, 1, 1);
}