void nebu_Camera_Zoom(nebu_Camera *pCamera, float d) {
vec3 v;
vec3_Sub(&v, &pCamera->vLookAt, &pCamera->vEye);
vec3_Normalize(&v, &v);
vec3_Scale(&v, &v, d);
vec3_Add(&pCamera->vEye, &pCamera->vEye, &v);
}
static void doLookAt(const float *cam, const float *target, const float *up) {
matrix m;
vec3 x, y, z;
vec3_Sub(&z, (vec3*) cam, (vec3*) target);
vec3_Normalize(&z, &z);
vec3_Cross(&x, (vec3*) up, &z);
vec3_Normalize(&x, &x);
vec3_Cross(&y, &z, &x);
vec3_Normalize(&y, &y);
#define M(row,col) m.m[col*4+row]
M(0,0) = x.v[0];
M(0,1) = x.v[1];
M(0,2) = x.v[2];
M(0,3) = 0.0;
M(1,0) = y.v[0];
M(1,1) = y.v[1];
M(1,2) = y.v[2];
M(1,3) = 0.0;
M(2,0) = z.v[0];
M(2,1) = z.v[1];
M(2,2) = z.v[2];
M(2,3) = 0.0;
M(3,0) = 0.0;
M(3,1) = 0.0;
M(3,2) = 0.0;
M(3,3) = 1.0;
#undef M
glMultMatrixf( m.m );
/* Translate Eye to Origin */
glTranslatef( -cam[0], -cam[1], -cam[2]);
}
void nebu_Camera_GetRotationMatrix(nebu_Matrix4D *matrix,
const nebu_Camera *pCamera) {
vec3 x, y, z;
vec3_Sub(&z, &pCamera->vEye, &pCamera->vLookAt);
vec3_Normalize(&z, &z);
vec3_Cross(&x, &pCamera->vUp, &z);
vec3_Normalize(&x, &x);
vec3_Cross(&y, &z, &x);
vec3_Normalize(&y, &y);
#define M(row,col) matrix->m[col*4+row]
M(0,0) = x.v[0];
M(0,1) = x.v[1];
M(0,2) = x.v[2];
M(0,3) = 0.0;
M(1,0) = y.v[0];
M(1,1) = y.v[1];
M(1,2) = y.v[2];
M(1,3) = 0.0;
M(2,0) = z.v[0];
M(2,1) = z.v[1];
M(2,2) = z.v[2];
M(2,3) = 0.0;
M(3,0) = 0.0;
M(3,1) = 0.0;
M(3,2) = 0.0;
M(3,3) = 1.0;
#undef M
return;
}
void nebu_Camera_Roll(nebu_Camera *pCamera, float d) {
vec3 v;
matrix m;
vec3_Sub(&v, &pCamera->vLookAt, &pCamera->vEye);
vec3_Normalize(&v, &v);
matrixRotationAxis(&m, d * 2 * (float)M_PI / 360.0f, &v);
vec3_Transform(&pCamera->vUp, &pCamera->vUp, &m);
}
int playerVisible(int eyePlayer, int targetPlayer) {
vec3 v1, v2, tmp;
float s;
float d;
int i;
int lod_level;
float x, y;
vec3_Sub(&v1, (vec3*) gPlayerVisuals[eyePlayer].camera.target, (vec3*) gPlayerVisuals[eyePlayer].camera.cam);
vec3_Normalize(&v1, &v1);
getPositionFromData(&x, &y, game->player[targetPlayer].data);
tmp.v[0] = x;
tmp.v[1] = y;
tmp.v[2] = 0;
lod_level = (gSettingsCache.lod > MAX_LOD_LEVEL) ?
MAX_LOD_LEVEL : gSettingsCache.lod;
/* calculate lod */
vec3_Sub(&v2, (vec3*) &gPlayerVisuals[eyePlayer].camera.cam, &tmp);
d = vec3_Length(&v2);
for(i = 0; i < LC_LOD && d >= lod_dist[lod_level][i]; i++);
if(i >= LC_LOD)
return -1;
vec3_Sub(&v2, &tmp, (vec3*) gPlayerVisuals[eyePlayer].camera.cam);
vec3_Normalize(&v2, &v2);
s = vec3_Dot(&v1, &v2);
/* maybe that's not exactly correct, but I didn't notice anything */
d = cosf((gSettingsCache.fov / 2) * 2 * PI / 360.0);
/*
printf("v1: %.2f %.2f %.2f\nv2: %.2f %.2f %.2f\ns: %.2f d: %.2f\n\n",
v1[0], v1[1], v1[2], v2[0], v2[1], v2[2],
s, d);
*/
if(s < d-(((gltron_Mesh*)resource_Get(gpTokenLightcycles[i], eRT_GLtronTriMesh))->BBox.fRadius*2))
return -1;
else
return i;
}
int playerVisible(Player *eye, Player *target) {
vec3 v1, v2, tmp;
float s;
float d;
int i;
int lod_level;
float x, y;
vec3_Sub(&v1, (vec3*) eye->camera->target, (vec3*) eye->camera->cam);
vec3_Normalize(&v1, &v1);
getPositionFromData(&x, &y, target->data);
tmp.v[0] = x;
tmp.v[1] = y;
tmp.v[2] = 0;
lod_level = (gSettingsCache.lod > MAX_LOD_LEVEL) ?
MAX_LOD_LEVEL : gSettingsCache.lod;
/* calculate lod */
vec3_Sub(&v2, (vec3*) eye->camera->cam, &tmp);
d = vec3_Length(&v2);
for(i = 0; i < LC_LOD && d >= lod_dist[lod_level][i]; i++);
if(i >= LC_LOD)
return -1;
vec3_Sub(&v2, &tmp, (vec3*) eye->camera->cam);
vec3_Normalize(&v2, &v2);
s = vec3_Dot(&v1, &v2);
/* maybe that's not exactly correct, but I didn't notice anything */
d = cosf((gSettingsCache.fov / 2) * 2 * PI / 360.0);
/*
printf("v1: %.2f %.2f %.2f\nv2: %.2f %.2f %.2f\ns: %.2f d: %.2f\n\n",
v1[0], v1[1], v1[2], v2[0], v2[1], v2[2],
s, d);
*/
if(s < d-(lightcycle[i]->BBox.fRadius*2))
return -1;
else
return i;
}
void Camera_GetViewMat(Camera *camera)
{
mat4x4 R;
mat4x4_Rot(R, camera->transform.quaternion);
vec3 forward = { 0.0f, 0.0f, -1.0f };
vec3 cam_forward;
mat3x3_MulVec3(cam_forward, R, forward);
vec3 right = { 1.0f, 0.0f, 0.0f };
vec3 cam_right;
mat3x3_MulVec3(cam_right, R, right);
vec3 cam_up;
vec3_CrossProd(cam_up, cam_right, cam_forward);
vec3 target;
vec3_Add(target, cam_forward, camera->transform.position);
vec3 n;
vec3_Sub(n, camera->transform.position, target);
vec3_Norm(n, n);
vec3 u;
vec3_CrossProd(u, cam_up, n);
vec3_Norm(u, u);
vec3 v;
vec3_CrossProd(v, n, u);
int i = 0;
for(i = 0; i < 3; ++i)
camera->view_matrix[0][i] = u[i];
for(i = 0; i < 3; ++i)
camera->view_matrix[1][i] = v[i];
for(i = 0; i < 3; ++i)
camera->view_matrix[2][i] = n[i];
for(i = 0; i < 3; ++i)
camera->view_matrix[3][i] = 0.0f;
vec3_Negate(u, u);
vec3_Negate(v, v);
vec3_Negate(n, n);
camera->view_matrix[0][3] = vec3_DotProd(u, camera->transform.position);
camera->view_matrix[1][3] = vec3_DotProd(v, camera->transform.position);
camera->view_matrix[2][3] = vec3_DotProd(n, camera->transform.position);
camera->view_matrix[3][3] = 1.0f;
}
void nebu_Camera_Slide(nebu_Camera *pCamera, float dx, float dy, float dz)
{
vec3 vLook, vUp, vRight, vMovement;
vec3_Sub(&vLook, &pCamera->vLookAt, &pCamera->vEye);
vec3_Cross(&vRight, &vLook, &pCamera->vUp);
vec3_Cross(&vUp, &vRight, &vLook);
vec3_Normalize(&vUp, &vUp);
vec3_Normalize(&vRight, &vRight);
vec3_Normalize(&vLook, &vLook);
vec3_Scale(&vUp, &vUp, dy);
vec3_Scale(&vRight, &vRight, dx);
vec3_Scale(&vLook, &vLook, dz);
vec3_Add(&vMovement, &vUp, &vRight);
vec3_Add(&vMovement, &vMovement, &vLook);
vec3_Add(&pCamera->vEye, &pCamera->vEye, &vMovement);
vec3_Add(&pCamera->vLookAt, &pCamera->vLookAt, &vMovement);
}
void nebu_Camera_Rotate(nebu_Camera *pCamera, int flags,
float dx, float dy)
{
// adjust up vector, so that it is orthogonal to
// view direction
vec3 vDiff, vView, vRight, vUp;
vec3 vdx, vdy;
vec3 *pvCenter, *pvMoving;
switch(flags & NEBU_CAMERA_ROTATE_MASK)
{
case NEBU_CAMERA_ROTATE_AROUND_EYE:
pvCenter = &pCamera->vEye;
pvMoving = &pCamera->vLookAt;
break;
case NEBU_CAMERA_ROTATE_AROUND_LOOKAT:
pvCenter = &pCamera->vLookAt;
pvMoving = &pCamera->vEye;
break;
default:
assert(0);
return;
}
vec3_Sub(&vDiff, pvCenter, pvMoving);
vec3_Normalize(&vView, &vDiff);
vec3_Cross(&vRight, &pCamera->vUp, &vView);
vec3_Normalize(&vRight, &vRight);
vec3_Cross(&vUp, &vView, &vRight);
vec3_Normalize(&vUp, &vUp);
// horizontal movement (dx):
if(dx == 0) {
vec3_Zero(&vdx);
} else {
// rotate moving around up vector through center point
vec3 v = vDiff;
float fAngle = dx * 2 * (float)M_PI / 360.0f;
matrix matRotation;
matrixRotationAxis(&matRotation, fAngle, &vUp);
vec3_Transform(&v, &vDiff, &matRotation);
vec3_Sub(&vdx, &v, &vDiff);
}
// vertical movement (dy):
if(dy == 0) {
vec3_Zero(&vdy);
} else {
// rotate eye point around up vector through lookAt point
vec3 v = vDiff;
float fAngle = dy * 2 * (float)M_PI / 360.0f;
matrix matRotation;
matrixRotationAxis(&matRotation, fAngle, &vRight);
vec3_Transform(&v, &vDiff, &matRotation);
vec3_Sub(&vdy, &v, &vDiff);
matrixTranspose(&matRotation, &matRotation);
if(!(flags & NEBU_CAMERA_FIXED_UP))
vec3_Transform(&pCamera->vUp, &pCamera->vUp, &matRotation);
}
{
vec3 v;
vec3_Add(&v, &vdx, &vdy);
vec3_Add(&v, &v, pvMoving);
vec3_Sub(&v, &v, pvCenter);
vec3_Normalize(&v, &v);
// printf("up dot view: %.4f\n", - vec3_Dot(&v, &pCamera->vUp));
vec3_Scale(&v, &v, vec3_Length(&vDiff));
vec3_Add(pvMoving, &v, pvCenter);
}
}
void drawCam(int player) {
int i;
float up[3] = { 0, 0, 1 };
Visual *d = & gPlayerVisuals[player].display;
float reflectivity = getReflectivity();
// compute shadow color based on glocal constant & reflectivity
for(i = 0; i < 4; i++)
gCurrentShadowColor[i] = gShadowColor[i] * (1 - reflectivity);
glColor3f(0.0, 1.0, 0.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
doPerspective(gSettingsCache.fov, (float) d->vp_w / (float) d->vp_h,
gSettingsCache.znear, box2_Diameter(& game2->level->boundingBox) * 6.5f);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
{
vec3 vLookAt;
vec3 vTarget;
matrix matRotate;
vec3_Sub(&vLookAt, (vec3*)gPlayerVisuals[player].camera.target, (vec3*)gPlayerVisuals[player].camera.cam);
vec3_Normalize(&vLookAt, &vLookAt);
matrixRotationAxis(&matRotate, 90.0f * (float) gPlayerVisuals[player].camera.bIsGlancing, (vec3*)up);
vec3_Transform(&vLookAt, &vLookAt, &matRotate);
vec3_Add(&vTarget, (vec3*)gPlayerVisuals[player].camera.cam, &vLookAt);
doLookAt(gPlayerVisuals[player].camera.cam, (float*)&vTarget, up);
}
glDisable(GL_LIGHTING); // initial config at frame start
glDisable(GL_BLEND); // initial config at frame start
// disable writes to alpha
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE);
/* skybox */
glDepthMask(GL_FALSE);
glDisable(GL_DEPTH_TEST);
drawSkybox( box2_Diameter( & game2->level->boundingBox ) * 2.5f );
glDepthMask(GL_TRUE);
glEnable(GL_DEPTH_TEST);
/* skybox done */
/* floor */
if(reflectivity == 0) {
// draw floor to fb and stencil (set to 1),
// using alpha-blending
// TODO: draw floor alpha to fb
video_Shader_Setup(& gWorld->floor_shader);
glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
glStencilFunc(GL_ALWAYS, 1, 255);
glEnable(GL_STENCIL_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
nebu_Mesh_DrawGeometry( gWorld->floor );
glDisable(GL_BLEND);
glDisable(GL_STENCIL_TEST);
video_Shader_Cleanup(& gWorld->floor_shader);
} else {
/* reflections */
/* first draw reflector to stencil */
/* and reflector alpha to fb */
video_Shader_Setup(& gWorld->floor_shader);
// store only reflector alpha in framebuffer
glDepthMask(GL_FALSE);
glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
glStencilFunc(GL_ALWAYS, 1, 255);
glEnable(GL_STENCIL_TEST);
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_TRUE);
// glEnable(GL_ALPHA_TEST);
// glAlphaFunc(GL_GREATER, 0.1f);
nebu_Mesh_DrawGeometry( gWorld->floor );
// glDisable(GL_ALPHA_TEST);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
glDepthMask(GL_TRUE);
glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
glStencilFunc(GL_EQUAL, 1, 255);
video_Shader_Cleanup(& gWorld->floor_shader);
/* then draw world & skybox reflected, where stencil is set */
/* protect the alpha buffer */
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE);
isRenderingReflection = 1; // hack: reverse lighting
glPushMatrix();
glScalef(1,1,-1);
glCullFace(GL_FRONT); // reverse culling
// clip skybox & world to floor plane
glEnable(GL_CLIP_PLANE0);
{
double plane[] = { 0, 0, 1, 0 };
glClipPlane(GL_CLIP_PLANE0, plane);
}
drawSkybox( box2_Diameter( & game2->level->boundingBox ) * 2.5f );
drawWorld(player);
glDisable(GL_CLIP_PLANE0);
glCullFace(GL_BACK);
glPopMatrix();
isRenderingReflection = 0; // hack: normal lighting
/* then blend the skybox into the scene, where stencil is set */
/* modulate with the destination alpha */
glDisable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_DST_ALPHA);
drawSkybox( box2_Diameter( & game2->level->boundingBox ) * 2.5f );
glDisable(GL_BLEND);
glEnable(GL_DEPTH_TEST);
/* then blend reflector into the scene */
glDisable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glColor4f(1, 1, 1, 1 - reflectivity);
glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
glStencilFunc(GL_ALWAYS, 1, 255);
video_Shader_Setup(& gWorld->floor_shader);
nebu_Mesh_DrawGeometry( gWorld->floor );
video_Shader_Cleanup(& gWorld->floor_shader);
glDisable(GL_STENCIL_TEST);
glDisable(GL_BLEND);
glEnable(GL_DEPTH_TEST);
}
/* floor done */
/* planar shadows */
glDepthMask(GL_FALSE);
glDisable(GL_DEPTH_TEST);
if(reflectivity != 1) // there are no shadows on perfect mirrors
drawPlanarShadows(player);
glDepthMask(GL_TRUE);
glEnable(GL_DEPTH_TEST);
/* planar shadows done */
drawWorld(player);
/* transparent stuff */
/* draw the glow around the other players: */
if (gSettingsCache.show_glow == 1) {
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
for (i = 0; i < game->players; i++)
{
if (i != player && PLAYER_IS_ACTIVE(game->player + i))
{
drawGlow(&gPlayerVisuals[player].camera, game->player + i, gPlayerVisuals + i,
d, TRAIL_HEIGHT * 4);
}
}
glDisable(GL_BLEND);
}
}
void nebu_Camera_RotateAroundTarget(nebu_Camera *pCamera,
float dx, float dy) {
// adjust up vector, so that it is orthogonal to
// view direction
vec3 vDiff, vView, vRight, vUp;
vec3 vdx, vdy;
vec3_Sub(&vDiff, &pCamera->vLookAt, &pCamera->vEye);
vec3_Normalize(&vView, &vDiff);
vec3_Cross(&vRight, &pCamera->vUp, &vView);
vec3_Normalize(&vRight, &vRight);
vec3_Cross(&vUp, &vView, &vRight);
vec3_Normalize(&vUp, &vUp);
// horizontal movement (dx):
if(dx == 0) {
vec3_Zero(&vdx);
} else {
// rotate eye point around up vector through lookAt point
vec3 v = vDiff;
float fAngle = dx * 2 * M_PI / 360.0;
matrix matRotation;
matrixRotationAxis(&matRotation, fAngle, &vUp);
vec3_Transform(&v, &vDiff, &matRotation);
vec3_Sub(&vdx, &v, &vDiff);
}
// vertical movement (dy):
if(dy == 0) {
vec3_Zero(&vdy);
} else {
// rotate eye point around up vector through lookAt point
vec3 v = vDiff;
float fAngle = dy * 2 * M_PI / 360.0;
matrix matRotation;
matrixRotationAxis(&matRotation, fAngle, &vRight);
vec3_Transform(&v, &vDiff, &matRotation);
vec3_Sub(&vdy, &v, &vDiff);
matrixTranspose(&matRotation, &matRotation);
vec3_Transform(&pCamera->vUp, &pCamera->vUp, &matRotation);
}
// add relative movements to camera position
/*
vec3_Add(&pCamera->vEye, &pCamera->vEye, &vdx);
vec3_Add(&pCamera->vEye, &pCamera->vEye, &vdy);
*/
{
vec3 v;
vec3_Add(&v, &vdx, &vdy);
vec3_Add(&v, &v, &pCamera->vEye);
vec3_Sub(&v, &v, &pCamera->vLookAt);
vec3_Normalize(&v, &v);
// printf("up dot view: %.4f\n", - vec3_Dot(&v, &pCamera->vUp));
vec3_Scale(&v, &v, vec3_Length(&vDiff));
vec3_Add(&pCamera->vEye, &v, &pCamera->vLookAt);
}
}
