void game_update_view(float dt)
{
const float y[3] = { 0.f, 1.f, 0.f };
float dy;
float dz;
float k;
float e[3];
float d[3];
float s = 2.f * dt;
if (!state)
return;
/* Center the view about the ball. */
v_cpy(view_c, file.vary.uv[ball].p);
v_inv(view_v, file.vary.uv[ball].v);
switch (config_get_d(CONFIG_CAMERA))
{
case 2:
/* Camera 2: View vector is given by view angle. */
view_e[2][0] = fsinf(V_RAD(view_a));
view_e[2][1] = 0.f;
view_e[2][2] = fcosf(V_RAD(view_a));
s = 1.f;
break;
default:
/* View vector approaches the ball velocity vector. */
v_mad(e, view_v, y, v_dot(view_v, y));
v_inv(e, e);
k = v_dot(view_v, view_v);
v_sub(view_e[2], view_p, view_c);
v_mad(view_e[2], view_e[2], view_v, k * dt * 0.1f);
}
/* Orthonormalize the basis of the view in its new position. */
v_crs(view_e[0], view_e[1], view_e[2]);
v_crs(view_e[2], view_e[0], view_e[1]);
v_nrm(view_e[0], view_e[0]);
v_nrm(view_e[2], view_e[2]);
/* The current view (dy, dz) approaches the ideal (view_dy, view_dz). */
v_sub(d, view_p, view_c);
dy = v_dot(view_e[1], d);
dz = v_dot(view_e[2], d);
dy += (view_dy - dy) * s;
dz += (view_dz - dz) * s;
/* Compute the new view position. */
view_p[0] = view_p[1] = view_p[2] = 0.f;
v_mad(view_p, view_c, view_e[1], dy);
v_mad(view_p, view_p, view_e[2], dz);
view_a = V_DEG(fatan2f(view_e[2][0], view_e[2][2]));
}
void game_set_fly(float k)
{
struct s_vary *fp = &file.vary;
float x[3] = { 1.f, 0.f, 0.f };
float y[3] = { 0.f, 1.f, 0.f };
float z[3] = { 0.f, 0.f, 1.f };
float c0[3] = { 0.f, 0.f, 0.f };
float p0[3] = { 0.f, 0.f, 0.f };
float c1[3] = { 0.f, 0.f, 0.f };
float p1[3] = { 0.f, 0.f, 0.f };
float v[3];
if (!state)
return;
v_cpy(view_e[0], x);
v_cpy(view_e[1], y);
if (fp->base->zc > 0)
v_sub(view_e[2], fp->uv[ball].p, fp->base->zv[0].p);
else
v_cpy(view_e[2], z);
if (fabs(v_dot(view_e[1], view_e[2])) > 0.999)
v_cpy(view_e[2], z);
v_crs(view_e[0], view_e[1], view_e[2]);
v_crs(view_e[2], view_e[0], view_e[1]);
v_nrm(view_e[0], view_e[0]);
v_nrm(view_e[2], view_e[2]);
/* k = 0.0 view is at the ball. */
if (fp->uc > 0)
{
v_cpy(c0, fp->uv[ball].p);
v_cpy(p0, fp->uv[ball].p);
}
v_mad(p0, p0, view_e[1], view_dy);
v_mad(p0, p0, view_e[2], view_dz);
/* k = +1.0 view is s_view 0 */
if (k >= 0 && fp->base->wc > 0)
{
v_cpy(p1, fp->base->wv[0].p);
v_cpy(c1, fp->base->wv[0].q);
}
/* k = -1.0 view is s_view 1 */
if (k <= 0 && fp->base->wc > 1)
{
v_cpy(p1, fp->base->wv[1].p);
v_cpy(c1, fp->base->wv[1].q);
}
/* Interpolate the views. */
v_sub(v, p1, p0);
v_mad(view_p, p0, v, k * k);
v_sub(v, c1, c0);
v_mad(view_c, c0, v, k * k);
/* Orthonormalize the view basis. */
v_sub(view_e[2], view_p, view_c);
v_crs(view_e[0], view_e[1], view_e[2]);
v_crs(view_e[2], view_e[0], view_e[1]);
v_nrm(view_e[0], view_e[0]);
v_nrm(view_e[2], view_e[2]);
view_a = V_DEG(fatan2f(view_e[2][0], view_e[2][2]));
}
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_update_view(float dt)
{
float dc = view_dc * (jump_b ? 2.0f * fabsf(jump_dt - 0.5f) : 1.0f);
float dx = view_ry * dt * 5.0f;
float k;
view_a += view_ry * dt * 90.f;
/* Center the view about the ball. */
v_cpy(view_c, file.uv->p);
v_inv(view_v, file.uv->v);
switch (config_get_d(CONFIG_CAMERA))
{
case 1: /* Camera 1: Viewpoint chases the ball position. */
v_sub(view_e[2], view_p, view_c);
break;
case 2: /* Camera 2: View vector is given by view angle. */
view_e[2][0] = fsinf(V_RAD(view_a));
view_e[2][1] = 0.f;
view_e[2][2] = fcosf(V_RAD(view_a));
dx = 0.0f;
break;
default: /* Default: View vector approaches the ball velocity vector. */
k = v_dot(view_v, view_v);
v_sub(view_e[2], view_p, view_c);
v_mad(view_e[2], view_e[2], view_v, k * dt / 4);
break;
}
/* Orthonormalize the basis of the view in its new position. */
v_crs(view_e[0], view_e[1], view_e[2]);
v_crs(view_e[2], view_e[0], view_e[1]);
v_nrm(view_e[0], view_e[0]);
v_nrm(view_e[2], view_e[2]);
/* Compute the new view position. */
k = 1.0f + v_dot(view_e[2], view_v) / 10.0f;
view_k = view_k + (k - view_k) * dt;
if (view_k < 0.5) view_k = 0.5;
v_cpy(view_p, file.uv->p);
v_mad(view_p, view_p, view_e[0], dx * view_k);
v_mad(view_p, view_p, view_e[1], view_dp * view_k);
v_mad(view_p, view_p, view_e[2], view_dz * view_k);
/* Compute the new view center. */
v_cpy(view_c, file.uv->p);
v_mad(view_c, view_c, view_e[1], dc);
/* Note the current view angle. */
view_a = V_DEG(fatan2f(view_e[2][0], view_e[2][2]));
}
void game_draw(int pose, float st)
{
float fov = view_fov;
if (jump_b) fov *= 2.f * fabsf(jump_dt - 0.5);
if (game_state)
{
config_push_persp(fov, 0.1f, FAR_DIST);
glPushMatrix();
{
float v[3], rx, ry;
float pup[3];
float pdn[3];
v_cpy(pup, view_p);
v_cpy(pdn, view_p);
pdn[1] = -pdn[1];
/* Compute and apply the view. */
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])) + st;
glTranslatef(0.f, 0.f, -v_len(v));
glRotatef(rx, 1.f, 0.f, 0.f);
glRotatef(ry, 0.f, 1.f, 0.f);
glTranslatef(-view_c[0], -view_c[1], -view_c[2]);
#ifndef DREAMCAST_KGL_NOT_IMPLEMENT
if (config_get_d(CONFIG_REFLECTION))
{
/* Draw the mirror only into the stencil buffer. */
glDisable(GL_DEPTH_TEST);
glEnable(GL_STENCIL_TEST);
glStencilFunc(GL_ALWAYS, 1, 0xFFFFFFFF);
glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
game_refl_all(0);
/* Draw the scene reflected into color and depth buffers. */
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
glStencilFunc(GL_EQUAL, 1, 0xFFFFFFFF);
glEnable(GL_DEPTH_TEST);
glFrontFace(GL_CW);
glPushMatrix();
{
glScalef(+1.f, -1.f, +1.f);
game_draw_light();
game_draw_back(pose, -1, pdn);
game_draw_fore(pose, rx, ry, -1, pdn);
}
glPopMatrix();
glFrontFace(GL_CCW);
glDisable(GL_STENCIL_TEST);
}
#endif
/* Draw the scene normally. */
game_draw_light();
game_refl_all(pose ? 0 : config_get_d(CONFIG_SHADOW));
game_draw_back(pose, +1, pup);
game_draw_fore(pose, rx, ry, +1, pup);
}
glPopMatrix();
config_pop_matrix();
/* Draw the fade overlay. */
fade_draw(fade_k);
}
}
static void game_update_view(float dt)
{
float dc = view.dc * (jump_b > 0 ? 2.0f * fabsf(jump_dt - 0.5f) : 1.0f);
float da = input_get_r() * dt * 90.0f;
float k;
float M[16], v[3], Y[3] = { 0.0f, 1.0f, 0.0f };
float view_v[3];
float spd = (float) cam_speed(input_get_c()) / 1000.0f;
/* Track manual rotation time. */
if (da == 0.0f)
{
if (view_time < 0.0f)
{
/* Transition time is influenced by activity time. */
view_fade = CLAMP(VIEW_FADE_MIN, -view_time, VIEW_FADE_MAX);
view_time = 0.0f;
}
/* Inactivity. */
view_time += dt;
}
else
{
if (view_time > 0.0f)
{
view_fade = 0.0f;
view_time = 0.0f;
}
/* Activity (yes, this is negative). */
view_time -= dt;
}
/* Center the view about the ball. */
v_cpy(view.c, vary.uv->p);
view_v[0] = -vary.uv->v[0];
view_v[1] = 0.0f;
view_v[2] = -vary.uv->v[2];
/* Compute view vector. */
if (spd >= 0.0f)
{
/* Viewpoint chases ball position. */
if (da == 0.0f)
{
float s;
v_sub(view.e[2], view.p, view.c);
v_nrm(view.e[2], view.e[2]);
/* Gradually restore view vector convergence rate. */
s = fpowf(view_time, 3.0f) / fpowf(view_fade, 3.0f);
s = CLAMP(0.0f, s, 1.0f);
v_mad(view.e[2], view.e[2], view_v, v_len(view_v) * spd * s * dt);
}
}
else
{
/* View vector is given by view angle. */
view.e[2][0] = fsinf(V_RAD(view.a));
view.e[2][1] = 0.0;
view.e[2][2] = fcosf(V_RAD(view.a));
}
/* Apply manual rotation. */
if (da != 0.0f)
{
m_rot(M, Y, V_RAD(da));
m_vxfm(v, M, view.e[2]);
v_cpy(view.e[2], v);
}
/* Orthonormalize the new view reference frame. */
v_crs(view.e[0], view.e[1], view.e[2]);
v_crs(view.e[2], view.e[0], view.e[1]);
v_nrm(view.e[0], view.e[0]);
v_nrm(view.e[2], view.e[2]);
/* Compute the new view position. */
k = 1.0f + v_dot(view.e[2], view_v) / 10.0f;
view_k = view_k + (k - view_k) * dt;
if (view_k < 0.5) view_k = 0.5;
v_scl(v, view.e[1], view.dp * view_k);
v_mad(v, v, view.e[2], view.dz * view_k);
v_add(view.p, v, vary.uv->p);
/* Compute the new view center. */
v_cpy(view.c, vary.uv->p);
v_mad(view.c, view.c, view.e[1], dc);
/* Note the current view angle. */
view.a = V_DEG(fatan2f(view.e[2][0], view.e[2][2]));
game_cmd_updview();
}
