virtual void on_idle()
{
int i;
for(i = 0; i < 6; i++)
{
move_point(m_poly1.xn(i), m_poly1.yn(i), m_dx1[i], m_dy1[i]);
move_point(m_poly2.xn(i), m_poly2.yn(i), m_dx2[i], m_dy2[i]);
normalize_point(i);
}
force_redraw();
}
bool path_control_point_handle::drag (QPointF local_pos, QTransform /*transform*/, keyboard_modifier /*modifier*/)
{
m_drag_cur = local_pos;
move_point ();
m_editor->update ();
return true;
}
void move_net(struct net* pnet) {
int x, y = 0, l = pnet->layer, i = 1;
struct vector_t vt;
for (x=1; x<=pnet->w; ++x) {
struct point_t *p = &pnet->pt[l][y+1][x+0];
struct point_t *op = &(pnet->pt[l][y][x]);
vt = get_power( op, p->x, p->y - pnet->dth);
//vt = get_power( op, p->x, p->y, pnet->dtw, pnet->dth);
p->vt[i] = vt;
}
i = 0;
for (y=1; y<=pnet->h; ++y) {
x = 0;
{
struct point_t *p = &pnet->pt[l][y][x+1];
struct point_t *op = &(pnet->pt[l][y][x]);
vt = get_power( op, p->x - pnet->dtw, p->y);
//vt = get_power( op, p->x, p->y, pnet->dtw, pnet->dth);
p->vt[i] = vt;
for (x=1; x<=pnet->w; ++x) {
move_point(pnet, x, y);
}
}
}
pnet->layer ^= 1;
}
void screen_char(char c, color back_color, color fore_color )
{
int16 color_s = ((back_color | fore_color) << 8) | ((int16)c);
if (c == '\n') {
screen_abscissa ++; //换行
screen_ordinate = 0; //重头开始
} else if (c == 0x09) {
screen_ordinate = screen_ordinate + 8;
} else if (c == ' ') {
screen_ordinate ++;
}else {
screen_point[screen_abscissa * 80 + screen_ordinate] = color_s;
screen_ordinate ++;
}
if (screen_ordinate > 80) {
screen_abscissa ++;
screen_ordinate = 0;
}
move_point();
}
void PARTICLES::update(float time_passed)
{
static float friction_fraction = 0;
friction_fraction += time_passed;
if(friction_fraction > 2.0f) // safty messure
friction_fraction = 0;
int friction_count = 0;
while(friction_fraction > 0.05f)
{
friction_count++;
friction_fraction -= 0.05f;
}
for(int g = 0; g < NUM_GROUPS; g++)
{
int i = first_part[g];
while(i != -1)
{
int next = particles[i].next_part;
//particles[i].vel += flow_get(particles[i].pos)*time_passed * particles[i].flow_affected;
particles[i].vel.y += particles[i].gravity*time_passed;
for(int f = 0; f < friction_count; f++) // apply friction
particles[i].vel *= particles[i].friction;
// move the point
vec2 vel = particles[i].vel*time_passed;
move_point(&particles[i].pos, &vel, 0.1f+0.9f*frandom(), NULL);
particles[i].vel = vel* (1.0f/time_passed);
particles[i].life += time_passed;
particles[i].rot += time_passed * particles[i].rotspeed;
// check particle death
if(particles[i].life > particles[i].life_span)
{
// remove it from the group list
if(particles[i].prev_part != -1)
particles[particles[i].prev_part].next_part = particles[i].next_part;
else
first_part[g] = particles[i].next_part;
if(particles[i].next_part != -1)
particles[particles[i].next_part].prev_part = particles[i].prev_part;
// insert to the free list
if(first_free != -1)
particles[first_free].prev_part = i;
particles[i].prev_part = -1;
particles[i].next_part = first_free;
first_free = i;
}
i = next;
}
}
}
void path_control_point_handle::apply_drag ()
{
move_point ();
m_editor->begin_changes ();
m_drag_cur = m_drag_start = QPointF ();
m_edit_operation.reset ();
m_editor->end_changes ("Drag Handle");
}
void path_control_point_handle::interrupt_drag ()
{
m_drag_cur = m_drag_start;
move_point ();
m_edit_operation.reset ();
m_editor->update ();
return;
}
virtual void on_idle()
{
int i;
for(i = 0; i < 6; i++)
{
move_point(m_poly.xn(i), m_poly.yn(i), m_dx[i], m_dy[i]);
}
force_redraw();
}
std::vector<cart_point> Square_Grid_Footprint::points_from_point(cart_point point, double _source_grid_size)
{
std::vector<cart_point> output_fp = std::vector<cart_point>(foot_print.size());
for(int i=0; i<output_fp.size(); i++)
{
output_fp[i] = move_point(foot_print[i], point);
}
return output_fp;
}
void move_primitive(PRIMITIVE *p)
{
switch (p->size)
{
case 1:
move_point(&p->points[0], p->velocity);
break;
case 2:
move_line(&p->points[0], &p->points[1], &p->centroid, p->velocity, p->rotation);
break;
default:
move_polygon(p->points, p->size, &p->centroid, p->velocity, &p->angle, p->rotation, &p->bounding_box);
break;
}
}
/*!
Interpolates between camera positions.
\arg \c plyr_pos1 \c pos1 is relative to this position
\arg \c plyr_pos2 \c pos2 is relative to this position
\arg \c max_vec_angle Maximum downward pitch of vector from camera to player
\arg \c pos1 original camera position
\arg \c pos2 target camera position
\arg \c dist distance of interpolated camera position from player
\arg \c dt time step size (s)
\arg \c time_constant time constant to use in interpolation (s)
\return Interpolated camera position
\author jfpatry
\date Created: 2000-08-26
\date Modified: 2000-08-26
*/
point_t interpolate_view_pos( point_t plyr_pos1, point_t plyr_pos2,
scalar_t max_vec_angle,
point_t pos1, point_t pos2,
scalar_t dist, scalar_t dt,
scalar_t time_constant )
{
static vector_t y_vec = { 0.0, 1.0, 0.0 };
quaternion_t q1, q2;
vector_t vec1, vec2;
scalar_t alpha;
scalar_t theta;
matrixgl_t rot_mat;
vector_t axis;
vec1 = subtract_points( pos1, plyr_pos1 );
vec2 = subtract_points( pos2, plyr_pos2 );
normalize_vector( &vec1 );
normalize_vector( &vec2 );
q1 = make_rotation_quaternion( y_vec, vec1 );
q2 = make_rotation_quaternion( y_vec, vec2 );
alpha = min( MAX_INTERPOLATION_VALUE,
1.0 - exp ( -dt / time_constant ) );
q2 = interpolate_quaternions( q1, q2, alpha );
vec2 = rotate_vector( q2, y_vec );
/* Constrain angle with x-z plane */
theta = RADIANS_TO_ANGLES( M_PI/2 - acos( dot_product( vec2, y_vec ) ) );
if ( theta > max_vec_angle )
{
axis = cross_product( y_vec, vec2 );
normalize_vector( &axis );
make_rotation_about_vector_matrix( rot_mat, axis,
theta-max_vec_angle );
vec2 = transform_vector( rot_mat, vec2 );
}
return move_point( plyr_pos2,
scale_vector( dist, vec2 ) );
}
void screen_clear()
{
/*大端模式和小端的模式
*小端模式：大大小小
*内存地址是地址小的地方
*/
int16 back_white = ((screen_black | screen_white) << 8) | 0x20;
int i = 0;
for (i = 0; i < 80 * 25; i++) {
screen_point[i] = back_white;
}
screen_abscissa = 0;
screen_ordinate = 0;
move_point();
}
// make points more sparse according to new_numbers array.
// new_numbers[point_number] specifies new number of that point.
// -1 means that point is to be discarded.
void reduce_pointlist(siatkonator_program *program, triangulateio *polygon, int *new_numbers){
int old_no, new_no;
for (int cur_point = 0; cur_point < polygon->numberofpoints; ++cur_point){
if(-1 == new_numbers[cur_point])
continue;
old_no = cur_point;
new_no = new_numbers[old_no];
/*In place edit, so this has to be true, or data*/
/*WILL BE overwritten*/
assert(new_no <= old_no);
move_point(polygon, new_no, old_no);
if(program != NULL && polygon->pointmarkerlist[old_no] != polygon->pointmarkerlist[new_no])
polygon->pointmarkerlist[new_no] = resolve_marker_conflict(*program, polygon->pointmarkerlist[old_no], polygon->pointmarkerlist[new_no]);
}
}
point_t get_tux_view_pt( player_data_t *plyr )
{
matrixgl_t trans;
char *tux_root_node_name;
scene_node_t *tux_root_node;
make_identity_matrix( trans );
tux_root_node_name = get_tux_root_node();
if ( get_scene_node( tux_root_node_name, &tux_root_node ) != TCL_OK ) {
check_assertion(0, "couldn't load tux's root node" );
}
traverse_dag_for_view_point( tux_root_node, trans );
tux_view_pt = move_point( tux_view_pt,
scale_vector( 0.2, plyr->plane_nml ) );
return tux_view_pt;
}
/* Returns True iff the specified polygon intersections a unit-radius sphere
* centered at the origin. */
bool_t intersect_polygon( polygon_t p, point_t *v )
{
ray_t ray;
vector_t nml, edge_nml, edge_vec;
point_t pt;
double d, s, nuDotProd, wec;
double edge_len, t, distsq;
int i;
/* create a ray from origin along polygon normal */
nml = make_normal( p, v );
ray.pt = make_point( 0., 0., 0. );
ray.vec = nml;
nuDotProd = dot_product( nml, ray.vec );
if ( fabs(nuDotProd) < EPS )
return False;
/* determine distance of plane from origin */
d = -( nml.x * v[p.vertices[0]].x +
nml.y * v[p.vertices[0]].y +
nml.z * v[p.vertices[0]].z );
/* if plane's distance to origin > 1, immediately reject */
if ( fabs( d ) > 1 )
return False;
/* check distances of edges from origin */
for ( i=0; i < p.num_vertices; i++ ) {
point_t *v0, *v1;
v0 = &v[p.vertices[i]];
v1 = &v[p.vertices[ (i+1) % p.num_vertices ]];
edge_vec = subtract_points( *v1, *v0 );
edge_len = normalize_vector( &edge_vec );
/* t is the distance from v0 of the closest point on the line
to the origin */
t = - dot_product( *((vector_t *) v0), edge_vec );
if ( t < 0 ) {
/* use distance from v0 */
distsq = MAG_SQD( *v0 );
} else if ( t > edge_len ) {
/* use distance from v1 */
distsq = MAG_SQD( *v1 );
} else {
/* closest point to origin is on the line segment */
*v0 = move_point( *v0, scale_vector( t, edge_vec ) );
distsq = MAG_SQD( *v0 );
}
if ( distsq <= 1 ) {
return True;
}
}
/* find intersection point of ray and plane */
s = - ( d + dot_product( nml, make_vector(ray.pt.x, ray.pt.y, ray.pt.z) ) ) /
nuDotProd;
pt = move_point( ray.pt, scale_vector( s, ray.vec ) );
/* test if intersection point is in polygon by clipping against it
* (we are assuming that polygon is convex) */
for ( i=0; i < p.num_vertices; i++ ) {
edge_nml = cross_product( nml,
subtract_points( v[p.vertices[ (i+1) % p.num_vertices ]], v[p.vertices[i]] ) );
wec = dot_product( subtract_points( pt, v[p.vertices[i]] ), edge_nml );
if (wec < 0)
return False;
}
return True;
}
/*!
Draws a fog plane at the far clipping plane to mask out clipping of terrain.
\return none
\author jfpatry
\date Created: 2000-08-31
\date Modified: 2000-08-31
*/
void draw_fog_plane()
{
plane_t left_edge_plane, right_edge_plane;
plane_t left_clip_plane, right_clip_plane;
plane_t far_clip_plane;
plane_t bottom_clip_plane;
plane_t bottom_plane, top_plane;
scalar_t course_width, course_length;
scalar_t course_angle, slope;
point_t left_pt, right_pt, pt;
point_t top_left_pt, top_right_pt;
point_t bottom_left_pt, bottom_right_pt;
vector_t left_vec, right_vec;
scalar_t height;
GLfloat *fog_colour;
if ( is_fog_on() == False ) {
return;
}
set_gl_options( FOG_PLANE );
get_course_dimensions( &course_width, &course_length );
course_angle = get_course_angle();
slope = tan( ANGLES_TO_RADIANS( course_angle ) );
left_edge_plane = make_plane( 1.0, 0.0, 0.0, 0.0 );
right_edge_plane = make_plane( -1.0, 0.0, 0.0, course_width );
far_clip_plane = get_far_clip_plane();
left_clip_plane = get_left_clip_plane();
right_clip_plane = get_right_clip_plane();
bottom_clip_plane = get_bottom_clip_plane();
/* Find the bottom plane */
bottom_plane.nml = make_vector( 0.0, 1, -slope );
height = get_terrain_base_height( 0 );
/* Unoptimized version
pt = make_point( 0, height, 0 );
bottom_plane.d = -( pt.x * bottom_plane.nml.x +
pt.y * bottom_plane.nml.y +
pt.z * bottom_plane.nml.z );
*/
bottom_plane.d = -height * bottom_plane.nml.y;
/* Find the top plane */
top_plane.nml = bottom_plane.nml;
height = get_terrain_max_height( 0 );
top_plane.d = -height * top_plane.nml.y;
if(get_player_data(local_player())->view.mode == TUXEYE)
{
bottom_clip_plane.nml = make_vector( 0.0, 1, -slope );
height = get_terrain_base_height( 0 ) - 40;
bottom_clip_plane.d = -height * bottom_clip_plane.nml.y;
}
/* Now find the bottom left and right points of the fog plane */
if ( !intersect_planes( bottom_plane, far_clip_plane, left_clip_plane, &left_pt ) )
return;
if ( !intersect_planes( bottom_plane, far_clip_plane, right_clip_plane, &right_pt ) )
return;
if ( !intersect_planes( top_plane, far_clip_plane, left_clip_plane, &top_left_pt ) )
return;
if ( !intersect_planes( top_plane, far_clip_plane, right_clip_plane, &top_right_pt ) )
return;
if ( !intersect_planes( bottom_clip_plane, far_clip_plane, left_clip_plane, &bottom_left_pt ) )
return;
if ( !intersect_planes( bottom_clip_plane, far_clip_plane, right_clip_plane, &bottom_right_pt ) )
return;
left_vec = subtract_points( top_left_pt, left_pt );
right_vec = subtract_points( top_right_pt, right_pt );
/* Now draw the fog plane */
set_gl_options( FOG_PLANE );
fog_colour = get_fog_colour();
glColor4fv( fog_colour );
#ifdef __APPLE__DISABLED__
#undef glEnableClientState
#undef glDisableClientState
#undef glVertexPointer
#undef glColorPointer
#undef glDrawArrays
point_t pt1,pt2,pt3,pt4;
pt1 = move_point( top_left_pt, left_vec );
pt2 = move_point( top_right_pt, right_vec );
pt3 = move_point( top_left_pt, scale_vector( 3.0, left_vec ) );
pt4 = move_point( top_right_pt, scale_vector( 3.0, right_vec ) );
const GLfloat verticesFog []=
{
bottom_left_pt.x, bottom_left_pt.y, bottom_left_pt.z,
bottom_right_pt.x, bottom_right_pt.y, bottom_right_pt.z,
left_pt.x, left_pt.y, left_pt.z,
right_pt.x, right_pt.y, right_pt.z,
top_left_pt.x, top_left_pt.y, top_left_pt.z,
top_right_pt.x, top_right_pt.y, top_right_pt.z,
pt1.x, pt1.y, pt1.z,
pt2.x, pt2.y, pt2.z,
pt3.x, pt3.y, pt3.z,
pt4.x, pt4.y, pt4.z
};
const GLfloat colorsFog []=
{
fog_colour[0], fog_colour[1], fog_colour[2], fog_colour[3],
fog_colour[0], fog_colour[1], fog_colour[2], fog_colour[3],
fog_colour[0], fog_colour[1], fog_colour[2], fog_colour[3],
fog_colour[0], fog_colour[1], fog_colour[2], fog_colour[3],
fog_colour[0], fog_colour[1], fog_colour[2], 0.9 ,
fog_colour[0], fog_colour[1], fog_colour[2], 0.9 ,
fog_colour[0], fog_colour[1], fog_colour[2], 0.3 ,
fog_colour[0], fog_colour[1], fog_colour[2], 0.3 ,
fog_colour[0], fog_colour[1], fog_colour[2], 0.0 ,
fog_colour[0], fog_colour[1], fog_colour[2], 0.0 ,
};
glEnableClientState (GL_VERTEX_ARRAY);
// glEnableClientState (GL_COLOR_ARRAY);
// glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glVertexPointer (3, GL_FLOAT , 0, verticesFog);
glColorPointer(4, GL_FLOAT, 0, colorsFog);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 10);
//glDisableClientState(GL_COLOR_ARRAY_POINTER);
#else
glBegin( GL_QUAD_STRIP );
glVertex3f( bottom_left_pt.x, bottom_left_pt.y, bottom_left_pt.z );
glVertex3f( bottom_right_pt.x, bottom_right_pt.y, bottom_right_pt.z );
glVertex3f( left_pt.x, left_pt.y, left_pt.z );
glVertex3f( right_pt.x, right_pt.y, right_pt.z );
glColor4f( fog_colour[0], fog_colour[1], fog_colour[2], 0.9 );
glVertex3f( top_left_pt.x, top_left_pt.y, top_left_pt.z );
glVertex3f( top_right_pt.x, top_right_pt.y, top_right_pt.z );
glColor4f( fog_colour[0], fog_colour[1], fog_colour[2], 0.3 );
pt = move_point( top_left_pt, left_vec );
glVertex3f( pt.x, pt.y, pt.z );
pt = move_point( top_right_pt, right_vec );
glVertex3f( pt.x, pt.y, pt.z );
glColor4f( fog_colour[0], fog_colour[1], fog_colour[2], 0.0 );
pt = move_point( top_left_pt, scale_vector( 3.0, left_vec ) );
glVertex3f( pt.x, pt.y, pt.z );
pt = move_point( top_right_pt, scale_vector( 3.0, right_vec ) );
glVertex3f( pt.x, pt.y, pt.z );
glEnd();
#endif
}
void update_view( player_data_t *plyr, scalar_t dt )
{
point_t view_pt;
vector_t view_dir, up_dir, vel_dir, view_vec;
scalar_t ycoord;
scalar_t course_angle;
vector_t axis;
matrixgl_t rot_mat;
vector_t y_vec;
vector_t mz_vec;
vector_t vel_proj;
quaternion_t rot_quat;
scalar_t speed;
vector_t vel_cpy;
scalar_t time_constant_mult;
vel_cpy = plyr->vel;
speed = normalize_vector( &vel_cpy );
time_constant_mult = 1.0 /
min( 1.0,
max( 0.0,
( speed - NO_INTERPOLATION_SPEED ) /
( BASELINE_INTERPOLATION_SPEED - NO_INTERPOLATION_SPEED )));
up_dir = make_vector( 0, 1, 0 );
vel_dir = plyr->vel;
normalize_vector( &vel_dir );
course_angle = get_course_angle();
switch( plyr->view.mode ) {
case TUXEYE:
{
scalar_t f = 2;
vector_t v = plyr->plane_nml;
scalar_t n = 1.;
view_pt = plyr->pos;
view_pt.x += v.x / n * 0.3;
view_pt.y += v.y / n * 0.3;
view_pt.y += 0.1;
view_pt.z += v.z / n * 0.3;
if(plyr->control.flip_factor || plyr->control.barrel_roll_factor) {
matrixgl_t mat1, mat;
vector_t right;
scalar_t n = sqrt(plyr->viewdir_for_tuxeye.x * plyr->viewdir_for_tuxeye.x + plyr->viewdir_for_tuxeye.y * plyr->viewdir_for_tuxeye.y + plyr->viewdir_for_tuxeye.z * plyr->viewdir_for_tuxeye.z);
plyr->viewdir_for_tuxeye.x /= n;
plyr->viewdir_for_tuxeye.y /= n;
plyr->viewdir_for_tuxeye.z /= n;
n = sqrt(plyr->updir_for_tuxeye.x * plyr->updir_for_tuxeye.x + plyr->updir_for_tuxeye.y * plyr->updir_for_tuxeye.y + plyr->updir_for_tuxeye.z * plyr->updir_for_tuxeye.z);
plyr->updir_for_tuxeye.x /= n;
plyr->updir_for_tuxeye.y /= n;
plyr->updir_for_tuxeye.z /= n;
right = cross_product(plyr->updir_for_tuxeye, plyr->viewdir_for_tuxeye);
make_rotation_about_vector_matrix( mat1, right, jump_from_time(plyr->control.flip_factor) * 360 );
make_rotation_about_vector_matrix( mat, plyr->viewdir_for_tuxeye, jump_from_time(plyr->control.barrel_roll_factor) * 360 );
multiply_matrices(mat, mat1, mat);
view_dir = transform_vector(mat, plyr->viewdir_for_tuxeye);
up_dir = transform_vector(mat, plyr->updir_for_tuxeye);
}
else {
view_dir = plyr->direction;
view_dir.y += 0.1;
view_dir.x = (plyr->view.dir.x * f + view_dir.x) / (f + 1);
view_dir.y = (plyr->view.dir.y * f + view_dir.y) / (f + 1);
view_dir.z = (plyr->view.dir.z * f + view_dir.z) / (f + 1);
plyr->viewdir_for_tuxeye = view_dir;
up_dir = plyr->plane_nml;
up_dir.x = (plyr->view.up.x * f + up_dir.x) / (f + 1);
up_dir.y = (plyr->view.up.y * f + up_dir.y) / (f + 1);
up_dir.z = (plyr->view.up.z * f + up_dir.z) / (f + 1);
plyr->updir_for_tuxeye = up_dir;
}
break;
}
case BEHIND:
{
/* Camera-on-a-string mode */
/* Construct vector from player to camera */
view_vec = make_vector( 0,
sin( ANGLES_TO_RADIANS(
course_angle -
CAMERA_ANGLE_ABOVE_SLOPE +
PLAYER_ANGLE_IN_CAMERA ) ),
cos( ANGLES_TO_RADIANS(
course_angle -
CAMERA_ANGLE_ABOVE_SLOPE +
PLAYER_ANGLE_IN_CAMERA ) ) );
view_vec = scale_vector( CAMERA_DISTANCE, view_vec );
y_vec = make_vector( 0.0, 1.0, 0.0 );
mz_vec = make_vector( 0.0, 0.0, -1.0 );
vel_proj = project_into_plane( y_vec, vel_dir );
normalize_vector( &vel_proj );
/* Rotate view_vec so that it places the camera behind player */
rot_quat = make_rotation_quaternion( mz_vec, vel_proj );
view_vec = rotate_vector( rot_quat, view_vec );
/* Construct view point */
view_pt = move_point( plyr->pos, view_vec );
/* Make sure view point is above terrain */
ycoord = find_y_coord( view_pt.x, view_pt.z );
if ( view_pt.y < ycoord + MIN_CAMERA_HEIGHT ) {
view_pt.y = ycoord + MIN_CAMERA_HEIGHT;
}
/* Interpolate view point */
if ( plyr->view.initialized ) {
/* Interpolate twice to get a second-order filter */
int i;
for (i=0; i<2; i++) {
view_pt =
interpolate_view_pos( plyr->pos, plyr->pos,
MAX_CAMERA_PITCH, plyr->view.pos,
view_pt, CAMERA_DISTANCE, dt,
BEHIND_ORBIT_TIME_CONSTANT *
time_constant_mult );
}
}
/* Make sure interpolated view point is above terrain */
ycoord = find_y_coord( view_pt.x, view_pt.z );
if ( view_pt.y < ycoord + ABSOLUTE_MIN_CAMERA_HEIGHT ) {
view_pt.y = ycoord + ABSOLUTE_MIN_CAMERA_HEIGHT;
}
/* Construct view direction */
view_vec = subtract_points( view_pt, plyr->pos );
axis = cross_product( y_vec, view_vec );
normalize_vector( &axis );
make_rotation_about_vector_matrix( rot_mat, axis,
PLAYER_ANGLE_IN_CAMERA );
view_dir = scale_vector( -1.0,
transform_vector( rot_mat, view_vec ) );
/* Interpolate orientation of camera */
if ( plyr->view.initialized ) {
/* Interpolate twice to get a second-order filter */
int i;
for (i=0; i<2; i++) {
interpolate_view_frame( plyr->view.up, plyr->view.dir,
&up_dir, &view_dir, dt,
BEHIND_ORIENT_TIME_CONSTANT );
up_dir = make_vector( 0.0, 1.0, 0.0 );
}
}
break;
}
case FOLLOW:
{
/* Camera follows player (above and behind) */
up_dir = make_vector( 0, 1, 0 );
/* Construct vector from player to camera */
view_vec = make_vector( 0,
sin( ANGLES_TO_RADIANS(
course_angle -
CAMERA_ANGLE_ABOVE_SLOPE +
PLAYER_ANGLE_IN_CAMERA ) ),
cos( ANGLES_TO_RADIANS(
course_angle -
CAMERA_ANGLE_ABOVE_SLOPE +
PLAYER_ANGLE_IN_CAMERA ) ) );
view_vec = scale_vector( CAMERA_DISTANCE, view_vec );
y_vec = make_vector( 0.0, 1.0, 0.0 );
mz_vec = make_vector( 0.0, 0.0, -1.0 );
vel_proj = project_into_plane( y_vec, vel_dir );
normalize_vector( &vel_proj );
/* Rotate view_vec so that it places the camera behind player */
rot_quat = make_rotation_quaternion( mz_vec, vel_proj );
view_vec = rotate_vector( rot_quat, view_vec );
/* Construct view point */
view_pt = move_point( plyr->pos, view_vec );
/* Make sure view point is above terrain */
ycoord = find_y_coord( view_pt.x, view_pt.z );
if ( view_pt.y < ycoord + MIN_CAMERA_HEIGHT ) {
view_pt.y = ycoord + MIN_CAMERA_HEIGHT;
}
/* Interpolate view point */
if ( plyr->view.initialized ) {
/* Interpolate twice to get a second-order filter */
int i;
for ( i=0; i<2; i++ ) {
view_pt =
interpolate_view_pos( plyr->view.plyr_pos, plyr->pos,
MAX_CAMERA_PITCH, plyr->view.pos,
view_pt, CAMERA_DISTANCE, dt,
FOLLOW_ORBIT_TIME_CONSTANT *
time_constant_mult );
}
}
/* Make sure interpolate view point is above terrain */
ycoord = find_y_coord( view_pt.x, view_pt.z );
if ( view_pt.y < ycoord + ABSOLUTE_MIN_CAMERA_HEIGHT ) {
view_pt.y = ycoord + ABSOLUTE_MIN_CAMERA_HEIGHT;
}
/* Construct view direction */
view_vec = subtract_points( view_pt, plyr->pos );
axis = cross_product( y_vec, view_vec );
normalize_vector( &axis );
make_rotation_about_vector_matrix( rot_mat, axis,
PLAYER_ANGLE_IN_CAMERA );
view_dir = scale_vector( -1.0,
transform_vector( rot_mat, view_vec ) );
/* Interpolate orientation of camera */
if ( plyr->view.initialized ) {
/* Interpolate twice to get a second-order filter */
int i;
for ( i=0; i<2; i++ ) {
interpolate_view_frame( plyr->view.up, plyr->view.dir,
&up_dir, &view_dir, dt,
FOLLOW_ORIENT_TIME_CONSTANT );
up_dir = make_vector( 0.0, 1.0, 0.0 );
}
}
break;
}
case ABOVE:
{
/* Camera always uphill of player */
up_dir = make_vector( 0, 1, 0 );
/* Construct vector from player to camera */
view_vec = make_vector( 0,
sin( ANGLES_TO_RADIANS(
course_angle -
CAMERA_ANGLE_ABOVE_SLOPE+
PLAYER_ANGLE_IN_CAMERA ) ),
cos( ANGLES_TO_RADIANS(
course_angle -
CAMERA_ANGLE_ABOVE_SLOPE+
PLAYER_ANGLE_IN_CAMERA ) ) );
view_vec = scale_vector( CAMERA_DISTANCE, view_vec );
/* Construct view point */
view_pt = move_point( plyr->pos, view_vec );
/* Make sure view point is above terrain */
ycoord = find_y_coord( view_pt.x, view_pt.z );
if ( view_pt.y < ycoord + MIN_CAMERA_HEIGHT ) {
view_pt.y = ycoord + MIN_CAMERA_HEIGHT;
}
/* Construct view direction */
view_vec = subtract_points( view_pt, plyr->pos );
make_rotation_matrix( rot_mat, PLAYER_ANGLE_IN_CAMERA, 'x' );
view_dir = scale_vector( -1.0,
transform_vector( rot_mat, view_vec ) );
break;
}
default:
code_not_reached();
}
/* Create view matrix */
plyr->view.pos = view_pt;
plyr->view.dir = view_dir;
plyr->view.up = up_dir;
plyr->view.plyr_pos = plyr->pos;
plyr->view.initialized = True;
setup_view_matrix( plyr );
}
void draw_billboard( player_data_t *plyr,
point_t center_pt, scalar_t width, scalar_t height,
bool_t use_world_y_axis,
point2d_t min_tex_coord, point2d_t max_tex_coord )
{
point_t pt;
vector_t x_vec;
vector_t y_vec;
vector_t z_vec;
x_vec.x = plyr->view.inv_view_mat[0][0];
x_vec.y = plyr->view.inv_view_mat[0][1];
x_vec.z = plyr->view.inv_view_mat[0][2];
if ( use_world_y_axis ) {
y_vec = make_vector( 0, 1, 0 );
x_vec = project_into_plane( y_vec, x_vec );
normalize_vector( &x_vec );
z_vec = cross_product( x_vec, y_vec );
} else {
y_vec.x = plyr->view.inv_view_mat[1][0];
y_vec.y = plyr->view.inv_view_mat[1][1];
y_vec.z = plyr->view.inv_view_mat[1][2];
z_vec.x = plyr->view.inv_view_mat[2][0];
z_vec.y = plyr->view.inv_view_mat[2][1];
z_vec.z = plyr->view.inv_view_mat[2][2];
}
#ifdef __APPLE__DISABLED__
glNormal3f( z_vec.x, z_vec.y, z_vec.z );
pt = move_point( center_pt, scale_vector( -width/2.0, x_vec ) );
pt = move_point( pt, scale_vector( -height/2.0, y_vec ) );
point_t pt2 = move_point( pt, scale_vector( width, x_vec ) );
point_t pt3 = move_point( pt2, scale_vector( height, y_vec ) );
point_t pt4 = move_point( pt3, scale_vector( -width, x_vec ) );
const GLfloat vertices2 []=
{
pt.x, pt.y, pt.z,
pt2.x, pt2.y, pt2.z,
pt3.x, pt3.y, pt3.z,
pt4.x, pt4.y, pt4.z
};
const GLshort texCoords2 []=
{
min_tex_coord.x, min_tex_coord.y,
max_tex_coord.x, min_tex_coord.y,
max_tex_coord.x, max_tex_coord.y,
min_tex_coord.x, max_tex_coord.y,
};
glEnableClientState (GL_VERTEX_ARRAY);
glVertexPointer (3, GL_FLOAT , 0, vertices2);
glTexCoordPointer(2, GL_SHORT, 0, texCoords2);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
#else
glBegin( GL_QUADS );
{
pt = move_point( center_pt, scale_vector( -width/2.0, x_vec ) );
pt = move_point( pt, scale_vector( -height/2.0, y_vec ) );
glNormal3f( z_vec.x, z_vec.y, z_vec.z );
glTexCoord2f( min_tex_coord.x, min_tex_coord.y );
glVertex3f( pt.x, pt.y, pt.z );
pt = move_point( pt, scale_vector( width, x_vec ) );
glTexCoord2f( max_tex_coord.x, min_tex_coord.y );
glVertex3f( pt.x, pt.y, pt.z );
pt = move_point( pt, scale_vector( height, y_vec ) );
glTexCoord2f( max_tex_coord.x, max_tex_coord.y );
glVertex3f( pt.x, pt.y, pt.z );
pt = move_point( pt, scale_vector( -width, x_vec ) );
glTexCoord2f( min_tex_coord.x, max_tex_coord.y );
glVertex3f( pt.x, pt.y, pt.z );
}
glEnd();
#endif
}
