diff options
Diffstat (limited to 'src/parsec/g_telep.cpp')
| -rw-r--r-- | src/parsec/g_telep.cpp | 2006 |
1 files changed, 2006 insertions, 0 deletions
diff --git a/src/parsec/g_telep.cpp b/src/parsec/g_telep.cpp new file mode 100644 index 0000000..b0b732e --- /dev/null +++ b/src/parsec/g_telep.cpp @@ -0,0 +1,2006 @@ +/* + * PARSEC - Teleporter Model + * + * $Author: uberlinuxguy $ - $Date: 2004/09/26 03:43:37 $ + * + * Orginally written by: + * Copyright (c) Clemens Beer <cbx@parsec.org> 2001 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +// C library +#include <stddef.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <math.h> +#include <limits.h> + +// compilation flags/debug support +#include "config.h" +#include "debug.h" + +// general definitions +#include "general.h" +#include "objstruc.h" + +// global externals +#include "globals.h" + +// subsystem headers +#include "aud_defs.h" + +// subsystem linkage info +#include "linkinfo.h" + +// drawing subsystem +#include "d_iter.h" +#include "d_misc.h" + +// mathematics header +#include "utl_math.h" + +// model header +#include "utl_model.h" + +// local module header +#include "g_telep.h" + +// proprietary module headers +#include "aud_game.h" +#include "con_arg.h" +#include "con_aux.h" +#include "con_com.h" +#include "con_ext.h" +#include "con_info.h" +#include "con_main.h" +#include "e_callbk.h" +#include "e_level.h" +#include "e_supp.h" +#include "net_defs.h" +#include "obj_clas.h" +#include "obj_ctrl.h" +#include "obj_cust.h" +#include "sys_date.h" +#include "sys_path.h" + + +// string constants ----------------------------------------------------------- +// +static char telep_level_inval_level_spec[] = "invalid level specified"; +static char telep_level_inval_filename_spec[] = "invalid filename specified"; +static char telep_exit_class_not_found[] = "object class for teleporter exit not found."; +static char telep_texture_not_found[] = "texture '%s' was not found."; + +// flags ---------------------------------------------------------------------- +// +//#define ANIMATE_TUNNEL_FRAME PARSEC_DEBUG +//#define DONT_MOVE_REMOTE_SHIPS + +// teleporter limits and constants -------------------------------------------- +// +#define TELEPORTER_DEFAULT_TEX_NAME_INTERIOR "tp_int.3df" +#define TELEPORTER_DEFAULT_TEX_NAME_TUNNEL "tp_tun.3df" +#define TELEPORTER_EXIT_MODEL_NAME "telep_exit" +#define TELEP_BOUNDARY_HORIZ 38 // half of horizontal extent of the teleporter start interior rect +#define TELEP_BOUNDARY_VERT 30.5 // half of vertical extent of the teleporter start interior rect + +// helper macros -------------------------------------------------------------- +// +//#define SETRGBA( x, r,g,b,a ) { (x)->R = r; (x)->G = g; (x)->B = b; (x)->A = a; } + +// module local functions ----------------------------------------------------- +// +PRIVATE void Teleporter_Animate_Tunnel ( Teleporter* teleporter ); +PRIVATE void Teleporter_Calc_Tunnel_Verts ( Teleporter* teleporter ); +PRIVATE int Teleporter_Check_Tunnel_Visibility ( Teleporter* teleporter ); +PRIVATE void Teleporter_Draw_Tunnel ( Teleporter* teleporter ); +PRIVATE void Teleporter_Draw_Entry_Interior ( Teleporter* teleporter ); +PRIVATE void Teleporter_Debug_Show_Tunnel_Spline ( Teleporter* teleporter ); + +PRIVATE int TeleporterModify_ExitPropsChanged ( GenObject* base ); +PRIVATE int TeleporterModify_StartPropsChanged ( GenObject* base ); +PRIVATE int TeleporterModify_TexPropsChanged ( GenObject* base ); +PRIVATE int TeleporterModify_SplinePropsChanged ( GenObject* base ); + +PRIVATE void Teleporter_Rotation_Transform ( float phi, float theta, Xmatrx trafo ); + + +// offset definitions into the Teleporter ------------------------------------- +// +#define OFS_EXITDELTAX offsetof( Teleporter, exit_delta_x ) +#define OFS_EXITDELTAY offsetof( Teleporter, exit_delta_y ) +#define OFS_EXITDELTAZ offsetof( Teleporter, exit_delta_z ) +#define OFS_EXITROTPHI offsetof( Teleporter, exit_rot_phi ) +#define OFS_EXITROTTHETA offsetof( Teleporter, exit_rot_theta ) +#define OFS_ACTOFFSET offsetof( Teleporter, actoffset ) +#define OFS_ACTIVE offsetof( Teleporter, active ) +#define OFS_TEXNAME_INT offsetof( Teleporter, tex_name_interior ) +#define OFS_TEXNAME_TUNNEL offsetof( Teleporter, tex_name_tunnel ) +#define OFS_U_VAR1 offsetof( Teleporter, u_variation[ 0 ] ) +#define OFS_V_VAR1 offsetof( Teleporter, v_variation[ 0 ] ) +#define OFS_U_VAR2 offsetof( Teleporter, u_variation[ 1 ] ) +#define OFS_V_VAR2 offsetof( Teleporter, v_variation[ 1 ] ) +#define OFS_START_SEC_LY offsetof( Teleporter, start_tex_sec_layer ) +#define OFS_START_TEX_ALPHA offsetof( Teleporter, start_tex_alpha ) +#define OFS_ACT_CONE_ANGLE offsetof( Teleporter, act_cone_angle ) +#define OFS_TUNNEL_SLERP offsetof( Teleporter, tunnel_slerp ) +#define OFS_TUNNEL_LERP offsetof( Teleporter, tunnel_lerp) +#define OFS_TUNNEL_TAN_MUL1 offsetof( Teleporter, tunnel_tangent_scale1 ) +#define OFS_TUNNEL_TAN_MUL2 offsetof( Teleporter, tunnel_tangent_scale2 ) +#define OFS_TUNNEL_ANIM_SPD offsetof( Teleporter, tunnel_anim_speed ) +#define OFS_TUNNEL_SPLINE offsetof( Teleporter, tunnel_spline ) +#define OFS_TUNNEL_SPL_CORDS offsetof( Teleporter, tunnel_spline_cords ) +#define OFS_TUNNEL_TEX_ALPHA offsetof( Teleporter, tunnel_tex_alpha ) +#define OFS_TUNNEL_LEN offsetof( Teleporter, tunnel_len ) +#define OFS_START_X offsetof( Teleporter, start.X ) +#define OFS_START_Y offsetof( Teleporter, start.Y ) +#define OFS_START_Z offsetof( Teleporter, start.Z ) +#define OFS_STARTROTPHI offsetof( Teleporter, start_rot_phi ) +#define OFS_STARTROTTHETA offsetof( Teleporter, start_rot_theta ) + + +// list of console-accessible properties -------------------------------------- +// +PRIVATE +proplist_s Teleporter_PropList[] = { + + { "exit_delta_x", OFS_EXITDELTAX, -0x40000000,0x40000000, PROPTYPE_FLOAT, TeleporterModify_ExitPropsChanged }, + { "exit_delta_y", OFS_EXITDELTAY, -0x40000000,0x40000000, PROPTYPE_FLOAT, TeleporterModify_ExitPropsChanged }, + { "exit_delta_z", OFS_EXITDELTAZ, -0x40000000,0x40000000, PROPTYPE_FLOAT, TeleporterModify_ExitPropsChanged }, + { "exit_rot_phi", OFS_EXITROTPHI, 0x00000, 0x1680000, PROPTYPE_FLOAT, TeleporterModify_ExitPropsChanged }, + { "exit_rot_theta", OFS_EXITROTTHETA, 0x00000, 0x1680000, PROPTYPE_FLOAT, TeleporterModify_ExitPropsChanged }, + { "actoffset", OFS_ACTOFFSET, 0x10000, 0x4000000, PROPTYPE_FLOAT, NULL }, + { "active", OFS_ACTIVE, 0x0, 0x1, PROPTYPE_INT, NULL }, + { "tex_name_interior", OFS_TEXNAME_INT, 0, TELEPORTER_MAX_TEX_NAME, PROPTYPE_STRING, TeleporterModify_TexPropsChanged }, + { "tex_name_tunnel", OFS_TEXNAME_TUNNEL, 0, TELEPORTER_MAX_TEX_NAME, PROPTYPE_STRING, TeleporterModify_TexPropsChanged }, + { "tex_u_var1", OFS_U_VAR1, 0x00000, 0x0010000, PROPTYPE_FLOAT, TeleporterModify_TexPropsChanged }, + { "tex_v_var1", OFS_V_VAR1, 0x00000, 0x0010000, PROPTYPE_FLOAT, TeleporterModify_TexPropsChanged }, + { "tex_u_var2", OFS_U_VAR2, 0x00000, 0x0010000, PROPTYPE_FLOAT, TeleporterModify_TexPropsChanged }, + { "tex_v_var2", OFS_V_VAR2, 0x00000, 0x0010000, PROPTYPE_FLOAT, TeleporterModify_TexPropsChanged }, + { "secly", OFS_START_SEC_LY, 0x0, 0x1, PROPTYPE_INT, NULL }, + { "start_tex_alpha", OFS_START_TEX_ALPHA,0x0, 0xff, PROPTYPE_INT, NULL }, + { "act_cone_angle", OFS_ACT_CONE_ANGLE, 0x00000, 0x0590000, PROPTYPE_FLOAT, NULL }, + { "tslerp", OFS_TUNNEL_SLERP, 0x0, 0x1, PROPTYPE_INT, NULL }, + { "tlerp", OFS_TUNNEL_LERP, 0x0, 0x2, PROPTYPE_INT, NULL }, + { "tunnel_ts1", OFS_TUNNEL_TAN_MUL1,0x1, 0x40000000, PROPTYPE_FLOAT, TeleporterModify_SplinePropsChanged }, + { "tunnel_ts2", OFS_TUNNEL_TAN_MUL2,0x1, 0x40000000, PROPTYPE_FLOAT, TeleporterModify_SplinePropsChanged }, + { "tunnel_spline_cords", OFS_TUNNEL_SPL_CORDS,0x1, 0x800000, PROPTYPE_INT, TeleporterModify_SplinePropsChanged }, + { "tunnel_anim_speed", OFS_TUNNEL_ANIM_SPD,0x0, 0x2580000, PROPTYPE_FLOAT, NULL }, + { "tunnel_spline", OFS_TUNNEL_SPLINE, 0x0, 0x3f, PROPTYPE_INT, NULL }, + { "tunnel_tex_alpha", OFS_TUNNEL_TEX_ALPHA,0x0, 0xff, PROPTYPE_INT, NULL }, + { "tunnel_len", OFS_TUNNEL_LEN, 0x0, 0x4000000, PROPTYPE_INT, TeleporterModify_SplinePropsChanged }, + { "start.x", OFS_START_X, -0x7fffffff,0x7fffffff, PROPTYPE_GEOMV, TeleporterModify_StartPropsChanged }, + { "start.y", OFS_START_Y, -0x7fffffff,0x7fffffff, PROPTYPE_GEOMV, TeleporterModify_StartPropsChanged }, + { "start.z", OFS_START_Z, -0x7fffffff,0x7fffffff, PROPTYPE_GEOMV, TeleporterModify_StartPropsChanged }, + { "start_rot_phi", OFS_STARTROTPHI, -0x2d00000, 0x2d00000, PROPTYPE_FLOAT, TeleporterModify_StartPropsChanged }, + { "start_rot_theta", OFS_STARTROTTHETA, -0x2d00000, 0x2d00000, PROPTYPE_FLOAT, TeleporterModify_StartPropsChanged }, + + { NULL, 0, 0, 0, 0, NULL }, +}; + + +// calculate the vertices making up the tunnel geometry ----------------------- +// +PRIVATE +void Teleporter_Calc_Tunnel_Verts( Teleporter* teleporter ) +{ + ASSERT( teleporter != NULL ); + + // free any previous geometry + if ( teleporter->tunnel_verts != NULL ) + FREEMEM( teleporter->tunnel_verts ); + + int num_steps = ( teleporter->tunnel_spline_cords + 1 ); + int num_vtxs = 4 * num_steps; + Vertex3* vtxs; + + // allocate the space for the new vertices + size_t allocsize = (size_t)num_vtxs * sizeof( Vertex3 ); + teleporter->tunnel_verts = vtxs = (Vertex3*)ALLOCMEM( allocsize ); + if ( vtxs == NULL ) + OUTOFMEM( 0 ); + memset( vtxs, 0, allocsize ); + + Vector3 start_pos, end_pos; + Vector3 start_tan, end_tan; + + // get the tangents + FetchZVector( teleporter->ObjPosition, &start_tan ); + FetchZVector( teleporter->child_object->ObjPosition, &end_tan ); + + // scale the tangents + VECMULS( &start_tan, &start_tan, teleporter->tunnel_tangent_scale1 ); + VECMULS( &end_tan, &end_tan, teleporter->tunnel_tangent_scale2 ); + + // get the start/end pos + //FetchTVector( teleporter->ObjPosition, &start_pos ); + //FetchTVector( teleporter->child_object->ObjPosition, &end_pos ); + + // HACK to cover the different Z curve between OpenGL and our projection + Xmatrx start_frame_ospc, end_frame_ospc; + Xmatrx start_frame_wspc, end_frame_wspc; + CalcOrthoInverse( teleporter->ObjPosition, start_frame_ospc ); + CalcOrthoInverse( teleporter->child_object->ObjPosition, end_frame_ospc ); + start_frame_ospc[ 2 ][ 3 ] -= 6; + end_frame_ospc [ 2 ][ 3 ] += 6; + CalcOrthoInverse( start_frame_ospc, start_frame_wspc ); + CalcOrthoInverse( end_frame_ospc, end_frame_wspc ); + FetchTVector( start_frame_wspc, &start_pos ); + FetchTVector( end_frame_wspc, &end_pos ); + + // get the start and end frame + Xmatrx start_frame, end_frame; + MakeNonTranslationMatrx( teleporter->ObjPosition, start_frame ); + MakeNonTranslationMatrx( teleporter->child_object->ObjPosition, end_frame ); + + // norm the start/end frame + NormMtx( start_frame ); + NormMtx( end_frame ); + +/* // get the axis vects from start/end frame + Vector3 start_axis[ 3 ], end_axis[ 3 ]; + FetchXVector( start_frame, &start_axis[ 0 ] ); + FetchYVector( start_frame, &start_axis[ 1 ] ); + FetchZVector( start_frame, &start_axis[ 2 ] ); + FetchXVector( end_frame, &end_axis[ 0 ] ); + FetchYVector( end_frame, &end_axis[ 1 ] ); + FetchZVector( end_frame, &end_axis[ 2 ] ); + + // rotate start/end frame to be aligned to the positive z axis + Vector3 zAxis; + zAxis.X = GEOMV_0; + zAxis.Y = GEOMV_0; + zAxis.Z = GEOMV_1; + + // get the rotation axis + Vector3 rot_axis_start, rot_axis_end; + CrossProduct( &zAxis, &start_axis[ 2 ], &rot_axis_start ); + CrossProduct( &zAxis, &end_axis[ 2 ], &rot_axis_end ); + + int ignore_start = ( VctLenX( &rot_axis_start ) == GEOMV_0 ); + int ignore_end = ( VctLenX( &rot_axis_end ) == GEOMV_0 ); + + // norm the rotation axis + if ( !ignore_start ) NormVctX( &rot_axis_start ); + if ( !ignore_end ) NormVctX( &rot_axis_end ); + + // get the rotation angle + float alpha_start_rad = ignore_start ? 0.0f : acos( (double)DotProduct( &start_axis[ 2 ], &zAxis ) ); + float alpha_end_rad = ignore_end ? 0.0f : acos( (double)DotProduct( &end_axis[ 2 ], &zAxis ) ); + + // setup the transformations to rotate start/end frame + Xmatrx start_rot_into_z, end_rot_into_z; + if ( !ignore_start ) MatrxFromAngularDisplacement( start_rot_into_z, RAD_TO_BAMS( alpha_start_rad ), &rot_axis_start ); + if ( !ignore_end ) MatrxFromAngularDisplacement( end_rot_into_z, RAD_TO_BAMS( alpha_end_rad ), &rot_axis_end ); + + // rotate the axis vects into Z + Vector3 start_axis_rotated[ 3 ], end_axis_rotated[ 3 ]; + for( int axis = 0; axis < 3; axis++ ) { + if ( !ignore_start ) MtxVctMULt( start_rot_into_z, &start_axis[ axis ], &start_axis_rotated[ axis ] ); + if ( !ignore_end ) MtxVctMULt( end_rot_into_z, &end_axis[ axis ], &end_axis_rotated[ axis ] ); + } + + // store the rotated axis back into the start/end frame + if ( !ignore_start ) { + StoreXVector( start_frame, &start_axis_rotated[ 0 ] ); + StoreYVector( start_frame, &start_axis_rotated[ 1 ] ); + StoreZVector( start_frame, &start_axis_rotated[ 2 ] ); + } + if ( !ignore_end ) { + StoreXVector( end_frame, &end_axis_rotated[ 0 ] ); + StoreYVector( end_frame, &end_axis_rotated[ 1 ] ); + StoreZVector( end_frame, &end_axis_rotated[ 2 ] ); + } + +*/ + // setup the boundary in object space + Vector3 boundary[ 4 ]; + for( int i = 0; i < 4; i++ ) { + boundary[ i ].X = teleporter->start_vtxlist[ i ].X; + boundary[ i ].Y = teleporter->start_vtxlist[ i ].Y; + boundary[ i ].Z = GEOMV_0; + } + + // init the hermite arclen data + Hermite_ArcLen* hermite_data; + hermite_data = Hermite_ArcLen_InitData( num_steps * 10, &start_pos, &end_pos, &start_tan, &end_tan ); + + Vector3 interp_last; + Vector3 tangent_last; + Xmatrx frame_last; + + // hack to store the start/end frame for display + memcpy( teleporter->start_frame, start_frame, sizeof( Xmatrx ) ); + memcpy( teleporter->end_frame, end_frame, sizeof( Xmatrx ) ); + + if ( teleporter->spline_frames != NULL ) { + FREEMEM( teleporter->spline_frames ); + } + teleporter->spline_frames = (Xmatrx*)ALLOCMEM( (size_t)num_steps * sizeof( Xmatrx ) ); + + Xmatrx xy_plane_transf; + Xmatrx hermite_transf; + Xmatrx cur_frame; + MakeIdMatrx( xy_plane_transf ); + + // we make 2 passes in interpolating the frame along the spline. + // the first pass is to get the the correction of the rotation in the xy plane + // the second pass is to correct the frames for the rotation in the xy plane + for( int pass = 0; pass < 2; pass++ ) { + + // get the correction for the rotation in the xy plane + float xy_correction_alpha_rad = 0; + Xmatrx xy_frame_2_correct; + if( pass == 1 ) { + + // store the last cur_frame as correction frame in the xy plane + MakeNonTranslationMatrx( frame_last, xy_frame_2_correct ); + + // get the angle between the last interpolated frame in the first run and the exit_frame as specified by the user + Vector3 x_set, x_interp; + FetchXVector( end_frame, &x_set ); + FetchXVector( frame_last, &x_interp ); + xy_correction_alpha_rad = acos( (double)DotProduct( &x_set, &x_interp ) ); + xy_correction_alpha_rad /= num_steps ; + } + + // interpolate pos on spline and orientation with quaternion for calculating the + // boundary points of the tunnel ( all coordinates are in world space ) + for( int step = 0; step < num_steps; step++ ) { + + // init the sub transforms to identity + MakeIdMatrx( cur_frame ); + MakeIdMatrx( hermite_transf ); + + // normalize s + float s = (float)step / (float)( num_steps - 1); + +#ifdef ALLOW_Z_ROT + // get slerp frame + //QuaternionSlerpFrames( xy_plane_transf, start_frame, end_frame, s ); + //ReOrthoNormMtx( xy_plane_transf ); +#endif // ALLOW_Z_ROT + + // calculate the xy transform to be the correction between the set exit_frame and the last interpolated frame from the first pass + if ( ( pass == 1 ) && ( step != 0 ) ) { + MakeIdMatrx( xy_plane_transf ); + //QuaternionSlerpFrames( xy_plane_transf, xy_frame_2_correct, end_frame, s ); + + ObjRotZ( xy_plane_transf, RAD_TO_BAMS( xy_correction_alpha_rad ) ); + ReOrthoNormMtx( xy_plane_transf ); + } + + // calculate the interpolated pos at the center of the tunnel + Vector3 interp; + Hermite_ArcLen_Interpolate( hermite_data, s, &interp ); + StoreTVector( hermite_transf, &interp ); + + // get the next interpolation point + Vector3 interp_next; + if ( step < ( num_steps - 1 ) ) { + float s_next = (float)( step + 1 ) / (float)( num_steps - 1 ); + Hermite_ArcLen_Interpolate( hermite_data, s_next, &interp_next ); + } + + // when not at step 0, we get the tangent at the current step and rotate the frame_last to be z aligned with the tangent + Vector3 tangent; + if ( step == 0 ) { + FetchZVector( start_frame, &tangent ); + + Vector3 dummy; + FetchXVector( start_frame, &dummy ); StoreXVector( hermite_transf, &dummy ); + FetchYVector( start_frame, &dummy ); StoreYVector( hermite_transf, &dummy ); + FetchZVector( start_frame, &dummy ); StoreZVector( hermite_transf, &dummy ); + } else { + // calculate the tangent ( tangent is paralell to the connection from samplepoint i-1 to i+1 ) + if ( step < ( num_steps - 1 ) ) { + Vector3 D1, D2; + VECSUB( &D1, &interp, &interp_last ); + VECSUB( &D2, &interp_next, &interp ); + VECADD( &tangent, &D1, &D2 ); + VECMULS( &tangent, &tangent, FLOAT_TO_GEOMV( 0.5f ) ); + } else { + FetchZVector( end_frame, &tangent ); + } + + NormVctX( &tangent ); + + // get the rotation axis + Vector3 rot_axis; + CrossProduct( &tangent, &tangent_last, &rot_axis ); + + + Vector3 frame_axis_last[ 3 ]; + FetchXVector( frame_last, &frame_axis_last[ 0 ] ); + FetchYVector( frame_last, &frame_axis_last[ 1 ] ); + FetchZVector( frame_last, &frame_axis_last[ 2 ] ); + + // check if we have a decent rotation axis + if( VctLenX( &rot_axis ) > 1e-5 ) { + + NormVctX( &rot_axis ); + + // get the angle for rotation + float alpha_rad = acos( (double)DotProduct( &tangent, &tangent_last ) ); + + // get the rotation matrix + Xmatrx rot_into_tangent; + MatrxFromAngularDisplacement( rot_into_tangent, RAD_TO_BAMS( alpha_rad ), &rot_axis ); + + // rotate the (frame_last) axis vects into Z + Vector3 frame_axis_last_rotated[ 3 ]; + + for( int axis = 0; axis < 3; axis++ ) { + MtxVctMULt( rot_into_tangent, &frame_axis_last[ axis ], &frame_axis_last_rotated[ axis ] ); + } + + // store the rotated frame into the hermite transformation + StoreXVector( hermite_transf, &frame_axis_last_rotated[ 0 ] ); + StoreYVector( hermite_transf, &frame_axis_last_rotated[ 1 ] ); + StoreZVector( hermite_transf, &frame_axis_last_rotated[ 2 ] ); + } else { + + // there is no rotation necessary + // store the last frame into the hermite transformation + StoreXVector( hermite_transf, &frame_axis_last[ 0 ] ); + StoreYVector( hermite_transf, &frame_axis_last[ 1 ] ); + StoreZVector( hermite_transf, &frame_axis_last[ 2 ] ); + } + } + + // create current frame from transformation in plane ( rot around z ) and translation/rotation from hermite interpolation + MtxMtxMUL( hermite_transf, xy_plane_transf, cur_frame ); + //memcpy( cur_frame, hermite_transf, sizeof( Xmatrx ) ); + + memcpy( &teleporter->spline_frames[ step ], cur_frame, sizeof( Xmatrx ) ); + + // transform boundary from object to world space + for( int nCorner = 0; nCorner < 4; nCorner++ ) { + MtxVctMUL( cur_frame, &boundary[ nCorner ], &vtxs[ step * 4 + nCorner ] ); + } + + // store pos, tangent and frame for next step + memcpy( &interp_last, &interp, sizeof( Vector3 ) ); + memcpy( &tangent_last, &tangent, sizeof( Vector3 ) ); + memcpy( frame_last, cur_frame, sizeof( Xmatrx ) ); + } + } + + // store the total arclength of the spline + teleporter->tunnel_spline_arclen = hermite_data->total_arc_len; + + // kill the hermite arclen data + Hermite_ArcLen_KillData( hermite_data ); + + // calculate the cullbox in objectspace of the teleporter entry + CullBox3* cullbox = &teleporter->tunnel_cullbox; + cullbox->minmax[ 0 ] = INT_TO_GEOMV( INT_MAX ); + cullbox->minmax[ 1 ] = INT_TO_GEOMV( INT_MAX ); + cullbox->minmax[ 2 ] = INT_TO_GEOMV( INT_MAX ); + + cullbox->minmax[ 3 ] = -INT_TO_GEOMV( INT_MAX ); + cullbox->minmax[ 4 ] = -INT_TO_GEOMV( INT_MAX ); + cullbox->minmax[ 5 ] = -INT_TO_GEOMV( INT_MAX ); + + // get the transformation from world to teleporter entry objectspace + Xmatrx world2object; + CalcOrthoInverse( teleporter->ObjPosition, world2object ); + + Vertex3 vtx_in_ospc; + for( int nVertex = 0; nVertex < num_vtxs; nVertex++ ) { + MtxVctMUL( world2object, &vtxs[ nVertex ], &vtx_in_ospc ); + + cullbox->minmax[ 0 ] = min( cullbox->minmax[ 0 ], vtx_in_ospc.X ); + cullbox->minmax[ 1 ] = min( cullbox->minmax[ 1 ], vtx_in_ospc.Y ); + cullbox->minmax[ 2 ] = min( cullbox->minmax[ 2 ], vtx_in_ospc.Z ); + + cullbox->minmax[ 3 ] = max( cullbox->minmax[ 3 ], vtx_in_ospc.X ); + cullbox->minmax[ 4 ] = max( cullbox->minmax[ 4 ], vtx_in_ospc.Y ); + cullbox->minmax[ 5 ] = max( cullbox->minmax[ 5 ], vtx_in_ospc.Z ); + } +} + + +// notification callback when spline props changed ---------------------------- +// +PRIVATE +int TeleporterModify_SplinePropsChanged( GenObject* base ) +{ + ASSERT( base != NULL ); + Teleporter *teleporter = (Teleporter *) base; + + // calculate the vertices for the tunnel + Teleporter_Calc_Tunnel_Verts( teleporter ); + + // clamp to the total # of segs + if ( teleporter->tunnel_len > teleporter->tunnel_spline_cords ) + teleporter->tunnel_len = teleporter->tunnel_spline_cords; + + // reset the tunnel animation + teleporter->tunnel_cur_anim_step = GEOMV_0; + + return TRUE; +} + +// strip the quotations around a string --------------------------------------- +// +PRIVATE +void StripQuotations( char* str2modify ) +{ + ASSERT( str2modify != NULL ); + + char szBuffer[ 128 ]; + size_t len = strlen( str2modify ); + ASSERT( len < 128 ); + + // remove trainling + if ( str2modify[ len - 1 ] == '"' ) { + str2modify[ len - 1 ] = 0; + } + // remove leading + if ( str2modify[ 0 ] == '"' ) { + char* src = str2modify + 1; + char* dst = str2modify; + for(; *src != 0; src++, dst++ ) { + *dst = *src; + } + *dst = 0; + } +} + + +// notification callback when texture props changed --------------------------- +// +PRIVATE +int TeleporterModify_TexPropsChanged( GenObject* base ) +{ + ASSERT( base != NULL ); + Teleporter *teleporter = (Teleporter *) base; + + // eventually remove leadin/trainling quotations from the texture names + //StripQuotations( teleporter->tex_name_interior ); + //StripQuotations( teleporter->tex_name_tunnel ); + + // get pointer to texture map + teleporter->start_texmap = FetchTextureMap( teleporter->tex_name_interior ); + if ( teleporter->start_texmap == NULL ) { + MSGOUT( telep_texture_not_found, teleporter->tex_name_interior ); + } else { + // init the u/v deltas with some random value + geomv_t uwidth = INT_TO_GEOMV( 1L << teleporter->start_texmap->Width ); + geomv_t vheight = INT_TO_GEOMV( 1L << teleporter->start_texmap->Height ); + + teleporter->u_maxdelta[ 0 ] = uwidth * teleporter->u_variation[ 0 ]; + teleporter->v_maxdelta[ 0 ] = vheight * teleporter->v_variation[ 0 ]; + teleporter->u_maxdelta[ 1 ] = uwidth * teleporter->u_variation[ 1 ]; + teleporter->v_maxdelta[ 1 ] = vheight * teleporter->v_variation[ 1 ]; + } + + // get pointer to texture map + teleporter->tunnel_texmap = FetchTextureMap( teleporter->tex_name_tunnel ); + if ( teleporter->tunnel_texmap == NULL ) { + MSGOUT( telep_texture_not_found, teleporter->tex_name_tunnel ); + } + + + return TRUE; +} + +// init a quaternion from spherical coordinates ------------------------------- +// +void QuaternionFromSpherical_f( Quaternion_f *quat, float deg_angle, float deg_latitude, float deg_longitude ) +{ + ASSERT( quat != NULL ); + + float sin_a = sin( DEG_TO_RAD( deg_angle ) / 2 ); + float cos_a = cos( DEG_TO_RAD( deg_angle ) / 2 ); + + float sin_lat = sin( DEG_TO_RAD( deg_latitude ) ); + float cos_lat = cos( DEG_TO_RAD( deg_latitude ) ); + + float sin_long = sin( DEG_TO_RAD( deg_longitude ) ); + float cos_long = cos( DEG_TO_RAD( deg_longitude ) ); + + quat->X = sin_a * cos_lat * sin_long; + quat->Y = sin_a * sin_lat; + quat->Z = sin_a * sin_lat * cos_long; + quat->W = cos_a; +} + +// init a quaternion from spherical coordinates ------------------------------- +// +void QuaternionFromSpherical( Quaternion_f *quat, float deg_angle, float deg_latitude, float deg_longitude ) +{ + ASSERT( quat != NULL ); + + geomv_t sin_a = FLOAT_TO_GEOMV( sin( DEG_TO_RAD( deg_angle ) / 2 ) ); + geomv_t cos_a = FLOAT_TO_GEOMV( cos( DEG_TO_RAD( deg_angle ) / 2 ) ); + + geomv_t sin_lat = FLOAT_TO_GEOMV( sin( DEG_TO_RAD( deg_latitude ) ) ); + geomv_t cos_lat = FLOAT_TO_GEOMV( cos( DEG_TO_RAD( deg_latitude ) ) ); + + geomv_t sin_long = FLOAT_TO_GEOMV( sin( DEG_TO_RAD( deg_longitude ) ) ); + geomv_t cos_long = FLOAT_TO_GEOMV( cos( DEG_TO_RAD( deg_longitude ) ) ); + + quat->X = sin_a * cos_lat * sin_long; + quat->Y = sin_a * sin_lat; + quat->Z = sin_a * sin_lat * cos_long; + quat->W = cos_a; +} + +// calculate the transfomation for the exit rotation -------------------------- +// +PRIVATE +void Teleporter_Rotation_Transform( float phi, float theta, Xmatrx trafo ) +{ + ASSERT( ( phi >= 0.0f ) && ( phi <= 360.0f ) ); + ASSERT( ( theta >= 0.0f ) && ( theta <= 360.0f ) ); + ASSERT( trafo != NULL ); + + // NOTE: formula to get the position on the 1-sphere from angular coordinates: + // + // x = sin( phi ) * cos( theta ) + // y = sin( phi ) * sin( theta ) + // z = cos( phi ) + + // for the z_axis in the frame we must add 90 degs to phi + float sin_phi = sin( DEG_TO_RAD( phi ) ); + float cos_phi = cos( DEG_TO_RAD( phi ) ); + float sin_theta = sin( DEG_TO_RAD( 90 ) + DEG_TO_RAD( theta ) ); + float cos_theta = cos( DEG_TO_RAD( 90 ) + DEG_TO_RAD( theta ) ); + float sin_phi2 = sin( DEG_TO_RAD( 90 ) + DEG_TO_RAD( phi ) ); + float cos_phi2 = cos( DEG_TO_RAD( 90 ) + DEG_TO_RAD( phi ) ); + + Vector3 x_axis, y_axis, z_axis; + z_axis.X = sin_phi * cos_theta; + z_axis.Y = sin_phi * sin_theta; + z_axis.Z = cos_phi; + + y_axis.X = sin_phi2 * cos_theta; + y_axis.Y = sin_phi2 * sin_theta; + y_axis.Z = cos_phi2; + NormVctX( &z_axis ); + NormVctX( &y_axis ); + + CrossProduct( &y_axis, &z_axis, &x_axis ); + StoreXVector( trafo, &x_axis ); + StoreYVector( trafo, &y_axis ); + StoreZVector( trafo, &z_axis ); + + ReOrthoNormMtx( trafo ); +} + +// notification callback when exit props changed ------------------------------ +// +PRIVATE +int TeleporterModify_StartPropsChanged( GenObject* base ) +{ + ASSERT( base != NULL ); + Teleporter *teleporter = (Teleporter *) base; + + if ( teleporter->start_rot_phi > 360.0f ) { + teleporter->start_rot_phi -= 360.0f; + } + if ( teleporter->start_rot_phi < 0.0f ) { + teleporter->start_rot_phi += 360.0f; + } + if ( teleporter->start_rot_theta > 360.0f ) { + teleporter->start_rot_theta -= 360.0f; + } + if ( teleporter->start_rot_theta < 0.0f ) { + teleporter->start_rot_theta += 360.0f; + } + + // get the trafo for the start rotation + Xmatrx NewTrans; + MakeIdMatrx( NewTrans ); + Teleporter_Rotation_Transform( teleporter->start_rot_phi, teleporter->start_rot_theta, NewTrans ); + MakeNonTranslationMatrx( NewTrans, teleporter->ObjPosition ); + + // set the translational part + StoreTVector( teleporter->ObjPosition, &teleporter->start ); + + // recalc all start dependend data in the teleporter exit + TeleporterModify_ExitPropsChanged( teleporter ); + + return TRUE; +} + + +// notification callback when exit props changed ------------------------------ +// +PRIVATE +int TeleporterModify_ExitPropsChanged( GenObject* base ) +{ + ASSERT( base != NULL ); + Teleporter *teleporter = (Teleporter *) base; + + // modify the position of the teleporter exit + Xmatrx ChildTrans; + MakeIdMatrx( ChildTrans ); + + // get the trafo for the exit rotation + Teleporter_Rotation_Transform( teleporter->exit_rot_phi, teleporter->exit_rot_theta, ChildTrans ); + + ChildTrans[ 0 ][ 3 ] = teleporter->exit_delta_x; + ChildTrans[ 1 ][ 3 ] = teleporter->exit_delta_y; + ChildTrans[ 2 ][ 3 ] = teleporter->exit_delta_z; + + MtxMtxMUL( teleporter->ObjPosition, ChildTrans, teleporter->child_object->ObjPosition ); + + TeleporterModify_SplinePropsChanged( base ); + + return TRUE; +} + +// draw the interior of the teleporter entry gate ----------------------------- +// +void Teleporter_Draw_Entry_Interior( Teleporter* teleporter ) +{ + ASSERT( teleporter != NULL ); + + // ensure we have the texture for the start interior + if ( teleporter->start_texmap == NULL ) { + return; + } + + // only draw interior if front facing + { + Vector3 telepnormal; + FetchZVector( teleporter->ObjPosition, &telepnormal ); + + Vertex3 teleppos; + FetchTVector( teleporter->ObjPosition, &teleppos ); + + // get the world->view transform + Xmatrx CameraInWorldSpace; + CalcOrthoInverse( ViewCamera, CameraInWorldSpace ); + //FIXME: we should have a GLOBAL storage for the camera in world space + + Vertex3 campos; + FetchTVector( CameraInWorldSpace, &campos ); + + geomv_t camdot = -DOT_PRODUCT( &telepnormal, &campos ); + geomv_t telepdot = -DOT_PRODUCT( &telepnormal, &teleppos ); + + if ( camdot < telepdot ) { + return; + } + } + + // set vertex color to white with premultiplie alpha + float alpha = ( (float)teleporter->start_tex_alpha ) / 255.0f; + byte _red = (int)(255.0 * alpha); + byte _green = (int)(255.0 * alpha); + byte _blue = (int)(255.0 * alpha); + byte _alpha = teleporter->start_tex_alpha; + + // get the width/height in pixels + geomv_t uWidth = INT_TO_GEOMV( 1L << teleporter->start_texmap->Width ); + geomv_t vHeight = INT_TO_GEOMV( 1L << teleporter->start_texmap->Height ); + + // setup transformation matrix; transform is world->view + D_LoadIterMatrix( NULL ); + + IterRectangle3 itrect; + itrect.flags = ITERFLAG_NONDESTRUCTIVE | ITERFLAG_Z_DIV_XYZ | ITERFLAG_Z_DIV_UVW | ITERFLAG_Z_TO_DEPTH /* | ITERFLAG_ONESIDED */; + itrect.itertype = iter_texrgba | iter_specularadd; + itrect.raststate = rast_zcompare | rast_texwrap | rast_chromakeyoff; + itrect.rastmask = rast_nomask; + itrect.texmap = teleporter->start_texmap; + + // calculate transformation matrix + MtxMtxMUL( ViewCamera, teleporter->ObjPosition, DestXmatrx ); + int nVtx = 0; + for ( nVtx = 0; nVtx < 4; nVtx++ ) { + MtxVctMUL( DestXmatrx, &teleporter->start_vtxlist[ nVtx ], (Vertex3*)&itrect.Vtxs[ nVtx ] ); + itrect.Vtxs[ nVtx ].W = GEOMV_1; + itrect.Vtxs[ nVtx ].U = teleporter->u_delta[ 0 ]; + itrect.Vtxs[ nVtx ].V = teleporter->v_delta[ 0 ]; + itrect.Vtxs[ nVtx ].R = _red; + itrect.Vtxs[ nVtx ].G = _green; + itrect.Vtxs[ nVtx ].B = _blue; + itrect.Vtxs[ nVtx ].A = _alpha; + } + + + itrect.Vtxs[ 0 ].U += 0; + itrect.Vtxs[ 0 ].V += 0; + + itrect.Vtxs[ 1 ].U += uWidth; + itrect.Vtxs[ 1 ].V += 0; + + itrect.Vtxs[ 2 ].U += uWidth; + itrect.Vtxs[ 2 ].V += vHeight; + + itrect.Vtxs[ 3 ].U += 0; + itrect.Vtxs[ 3 ].V += vHeight; + + // draw quad + D_DrawIterRectangle3( &itrect, 0x3f ); + + // draw the second layer + for ( nVtx = 0; nVtx < 4; nVtx++ ) { + MtxVctMUL( DestXmatrx, &teleporter->start_vtxlist[ nVtx ], (Vertex3*)&itrect.Vtxs[ nVtx ] ); + itrect.Vtxs[ nVtx ].W = GEOMV_1; + itrect.Vtxs[ nVtx ].U = teleporter->u_delta[ 1 ]; + itrect.Vtxs[ nVtx ].V = teleporter->v_delta[ 1 ]; + } + + itrect.Vtxs[ 0 ].U += 0; + itrect.Vtxs[ 0 ].V += 0; + + itrect.Vtxs[ 1 ].U += uWidth; + itrect.Vtxs[ 1 ].V += 0; + + itrect.Vtxs[ 2 ].U += uWidth; + itrect.Vtxs[ 2 ].V += vHeight; + + itrect.Vtxs[ 3 ].U += 0; + itrect.Vtxs[ 3 ].V += vHeight; + + //itrect.flags = ITERFLAG_NONDESTRUCTIVE | ITERFLAG_Z_DIV_XYZ | ITERFLAG_Z_DIV_UVW | ITERFLAG_Z_TO_DEPTH; + + D_DrawIterRectangle3( &itrect, 0x3f ); + + // restore identity transformation + D_LoadIterMatrix( NULL ); +} + +// check whether tunnel is visible -------------------------------------------- +// +PRIVATE +int Teleporter_Check_Tunnel_Visibility( Teleporter* teleporter ) +{ + // NOTE: the teleporter cullbox is given as an axis aligned bounding box + // relative to the teleporter entry + + CullBox3 cullbox_world; + + MtxVctMUL( teleporter->ObjPosition, (Vector3*)&teleporter->tunnel_cullbox.minmax[ 0 ], (Vector3*)&cullbox_world.minmax[ 0 ] ); + MtxVctMUL( teleporter->ObjPosition, (Vector3*)&teleporter->tunnel_cullbox.minmax[ 3 ], (Vector3*)&cullbox_world.minmax[ 3 ] ); + + dword cullmask = 0x3f; + int cull_result = CULL_BoxAgainstVolume( &cullbox_world, World_ViewVolume, &cullmask ); + + return !cull_result; +} + + +// draw the teleporters ------------------------------------------------------- +// +PRIVATE +int Teleporter_Draw( void *param ) +{ + ASSERT( param != NULL ); + Teleporter *teleporter = (Teleporter *) param; + + // determine visibility + int entry_visible = ( teleporter->VisibleFrame == CurVisibleFrame ); + int exit_visible = ( teleporter->child_object->VisibleFrame == CurVisibleFrame ); + int tunnel_visible = entry_visible | exit_visible; + + if ( !tunnel_visible ) { + // cull tunnel against frustum + tunnel_visible = Teleporter_Check_Tunnel_Visibility( teleporter ); + } + + // check whether to draw the entry interior + if ( entry_visible ) { + Teleporter_Draw_Entry_Interior( teleporter ); + } + + // check whether the tunnel is visible + if ( tunnel_visible ) { + + // draw the tunnel + Teleporter_Draw_Tunnel( teleporter ); + + // draw the spline connecting start and exit ( for debugging only ) + if ( teleporter->tunnel_spline != 0 ) { + Teleporter_Debug_Show_Tunnel_Spline( teleporter ); + } + } + + return TRUE; +} + +// macro to set the properties of a itervertex -------------------------------- +// +#define SET_ITER_VTX( iter_vtx, in_vect3, u, v, r, g, b, a ) \ + MtxVctMUL( DestXmatrx, (in_vect3), (Vector3*)(iter_vtx) ); \ + (iter_vtx)->W = GEOMV_1; \ + (iter_vtx)->U = u; \ + (iter_vtx)->V = v; \ + (iter_vtx)->R = r; \ + (iter_vtx)->G = g; \ + (iter_vtx)->B = b; \ +(iter_vtx)->A = a; + +// do a lerp between 2 vectors ------------------------------------------------ +// +void VctLerp( Vector3* dst, Vector3* src1, Vector3* src2, float t ) +{ + Vector3 diff; + VECSUB( &diff, src2, src1 ); + + dst->X = src1->X + ( t * diff.X ); + dst->Y = src1->Y + ( t * diff.Y ); + dst->Z = src1->Z + ( t * diff.Z ); +} + + +// draw a part of the tunnel connecting teleporter entry with exit ------------ +// +PRIVATE +void Teleporter_Draw_Tunnel( Teleporter* teleporter ) +{ + ASSERT( teleporter != NULL ); + + if ( teleporter->tunnel_texmap == NULL ) + return; + + //NOTE: start_seg and end_seg specify points on the spline ( seperator planes of the tunnel ) + int num_total_spline_segs = ( teleporter->tunnel_spline_cords + 1 ); + + int start_seg = (int)(teleporter->tunnel_cur_anim_step - teleporter->tunnel_len); + int end_seg = start_seg + teleporter->tunnel_len; + + if ( start_seg < 0 ) + start_seg = 0; + + if ( end_seg >= num_total_spline_segs ) { + end_seg = num_total_spline_segs - 1; + } + + // no tunnel to draw + if ( start_seg == end_seg ) + return; + + // tunnel is vanishing at the teleporter exit + if( start_seg == ( teleporter->tunnel_spline_cords + 1 ) ) { + return; + } + + int num_tunnel_cords = ( end_seg - start_seg + 1 ); // we add a segment at the end of the tunnel, for smooth translation of the tunnel + int num_tunnel_segs = num_tunnel_cords + 1; + int num_verts = 4 * num_tunnel_segs; + int start_offset = start_seg * 4; + int end_offset = end_seg * 4; + + // calculate transformation matrix + memcpy( DestXmatrx, ViewCamera, sizeof( Xmatrx ) ); + + // get the width/height in pixels + geomv_t uWidth = INT_TO_GEOMV( 1L << teleporter->tunnel_texmap->Width ); + geomv_t vHeight = INT_TO_GEOMV( 1L << teleporter->tunnel_texmap->Height ); + + // calculate the u_delta ( u advance for one cord ) + geomv_t tunnel_height = teleporter->start_vtxlist[ 2 ].Y - teleporter->start_vtxlist[ 0 ].Y; + geomv_t u_delta = uWidth * ( ( teleporter->tunnel_spline_arclen / teleporter->tunnel_spline_cords ) / tunnel_height ); + + // we calculate the first/last segment vertices by interpolation between the precalculated segments + Vector3 first_seg_vtxs[ 4 ]; + Vector3 last_seg_vtxs [ 4 ]; + + // calculate the interstep + geomv_t cur_interseg = ( num_total_spline_segs - 1 ) * teleporter->tunnel_t; + + // clamp to the max + if ( cur_interseg > ( num_total_spline_segs - 1 ) ) + cur_interseg = ( num_total_spline_segs - 1 ); + + // calculate the interstep fraction ( that is the fraction between 2 spline points ) + //geomv_t cur_interseg_frac = cur_interseg - (geomv_t)start_seg; + geomv_t cur_interseg_frac = teleporter->tunnel_cur_anim_step - (geomv_t)floor( teleporter->tunnel_cur_anim_step ); + + geomv_t u_delta_first_cord = 0; + geomv_t u_delta_last_cord = 0; + + int last_cord_removed = FALSE; + + // determine whether start segment is fixed to teleporter start + int move_start_seg = teleporter->tunnel_cur_anim_step >= teleporter->tunnel_len; + + // snap to a already calculated point + if ( cur_interseg_frac < GEOMV_VANISHING ) { + for( int i = 0; i < 4; i++ ) { + memcpy( &first_seg_vtxs[ i ], &teleporter->tunnel_verts[ start_offset + i ], sizeof( Vector3 ) ); + memcpy( &last_seg_vtxs[ i ], &teleporter->tunnel_verts[ end_offset + i ], sizeof( Vector3 ) ); + } + + u_delta_first_cord = u_delta; + u_delta_last_cord = u_delta; + + // we do not draw the last cord as this has len 0 + num_tunnel_cords--; + num_tunnel_segs--; + + last_cord_removed = TRUE; + + } else { + + // determine whether to do lerping of start/end + int lerp_start = move_start_seg; + int lerp_end = ( end_seg < ( num_total_spline_segs - 1 ) ); + + // get the lerped position for the first/last segment + for( int i = 0; i < 4; i++ ) { + if ( lerp_start ) { + VctLerp( &first_seg_vtxs[ i ], &teleporter->tunnel_verts[ start_offset + i ], + &teleporter->tunnel_verts[ start_offset + 4 + i ], GEOMV_TO_FLOAT( cur_interseg_frac ) ); + } else { + memcpy( &first_seg_vtxs[ i ], &teleporter->tunnel_verts[ start_offset + i ], sizeof( Vector3 ) ); + } + if( lerp_end ) { + VctLerp( &last_seg_vtxs [ i ], &teleporter->tunnel_verts[ end_offset + i ], + &teleporter->tunnel_verts[ end_offset + 4 + i ], GEOMV_TO_FLOAT( cur_interseg_frac ) ); + } else { + memcpy( &last_seg_vtxs[ i ], &teleporter->tunnel_verts[ end_offset + i ], sizeof( Vector3 ) ); + } + } + + // get the u_delta for the first cord + Vector3 diff; + if ( lerp_start ) { + VECSUB( &diff, &first_seg_vtxs[ 0 ], &teleporter->tunnel_verts[ start_offset + 4 ] ); + geomv_t len = VctLenX( &diff ); + u_delta_first_cord = uWidth * ( len / tunnel_height ); + } else { + u_delta_first_cord = 0; + } + + // get the u_delta for the last cord + if( lerp_end ) { + VECSUB( &diff, &last_seg_vtxs[ 0 ], &teleporter->tunnel_verts[ end_offset + 4 ] ); + geomv_t len = VctLenX( &diff ); + u_delta_last_cord = uWidth * ( len / tunnel_height ); + } else { + u_delta_last_cord = u_delta; + } + } + + // create vertex array + IterArray3 *itarray = (IterArray3 *) ALLOCMEM( + (size_t)&((IterArray3*)0)->Vtxs[ num_verts ] ); + if ( itarray == NULL ) + OUTOFMEM( 0 ); + + + itarray->NumVerts = num_verts; + itarray->arrayinfo = ITERARRAY_USE_COLOR | ITERARRAY_USE_TEXTURE | ITERARRAY_GLOBAL_TEXTURE; + itarray->flags = ITERFLAG_Z_DIV_XYZ | ITERFLAG_Z_DIV_UVW | ITERFLAG_Z_TO_DEPTH; + itarray->itertype = iter_texrgba | iter_specularadd; //iter_rgba | iter_alphablend; + itarray->raststate = rast_zcompare | rast_texclamp | rast_chromakeyoff; + itarray->rastmask = rast_nomask; + itarray->texmap = teleporter->tunnel_texmap; + + geomv_t u = 0; + + float alpha = ( (float)teleporter->tunnel_tex_alpha ) / 255.0f; + float _fRed = 0.0f; + float _fGreen = 0.0f; + float _fBlue = 0.0f; + + float divisor = ( end_seg - start_seg ) / 3.0f; + float _color_delta = ( 255.0 * alpha ) / divisor; + + float ramp_segs_start = ( divisor ); + float ramp_segs_end = ( divisor * 2.0); + + for( int nSegment = 0; nSegment < num_tunnel_segs; nSegment++ ) { + int nVtx = nSegment * 4; + + float segment_frac = 0.0f; + if ( nSegment == ( num_tunnel_segs - 1 ) ) { + segment_frac = num_tunnel_segs - 2; + } else if ( nSegment == 0 ) { + segment_frac = 0; + } else { + segment_frac = ( nSegment - cur_interseg_frac ); + } + + // modify the color to do a fade in/out at the beginning and end of the tunnel + if ( nSegment < ramp_segs_start ) { + if ( move_start_seg ) { + _fRed = segment_frac * _color_delta; + _fGreen = segment_frac * _color_delta; + _fBlue = segment_frac * _color_delta; + } else { + _fRed = nSegment * _color_delta; + _fGreen = nSegment * _color_delta; + _fBlue = nSegment * _color_delta; + } + } else if ( segment_frac > ramp_segs_end ) { + _fRed = ( ( num_tunnel_segs - 2 ) - segment_frac ) * _color_delta; + _fGreen = ( ( num_tunnel_segs - 2 ) - segment_frac ) * _color_delta; + _fBlue = ( ( num_tunnel_segs - 2 ) - segment_frac ) * _color_delta; + } else { + _fRed = ( 255.0f * alpha ); + _fGreen = ( 255.0f * alpha ); + _fBlue = ( 255.0f * alpha ); + } + + byte _red = _fRed > 255.0 ? 255 : (byte)_fRed; + byte _green = _fGreen > 255.0 ? 255 : (byte)_fGreen; + byte _blue = _fBlue > 255.0 ? 255 : (byte)_fBlue; + byte _alpha = teleporter->tunnel_tex_alpha; + + if ( nSegment == 0 ) { + + SET_ITER_VTX( &itarray->Vtxs[ nVtx + 0 ], &first_seg_vtxs[ 0 ], u, vHeight, _red, _green, _blue, _alpha ); + SET_ITER_VTX( &itarray->Vtxs[ nVtx + 1 ], &first_seg_vtxs[ 1 ], u, GEOMV_0, _red, _green, _blue, _alpha ); + SET_ITER_VTX( &itarray->Vtxs[ nVtx + 2 ], &first_seg_vtxs[ 2 ], u, vHeight, _red, _green, _blue, _alpha ); + SET_ITER_VTX( &itarray->Vtxs[ nVtx + 3 ], &first_seg_vtxs[ 3 ], u, GEOMV_0, _red, _green, _blue, _alpha ); + + u += u_delta_first_cord; + } else { + + if ( nSegment == ( num_tunnel_segs - 1 ) ) { + + SET_ITER_VTX( &itarray->Vtxs[ nVtx + 0 ], &last_seg_vtxs[ 0 ], u, vHeight, _red, _green, _blue, _alpha ); + SET_ITER_VTX( &itarray->Vtxs[ nVtx + 1 ], &last_seg_vtxs[ 1 ], u, GEOMV_0, _red, _green, _blue, _alpha ); + SET_ITER_VTX( &itarray->Vtxs[ nVtx + 2 ], &last_seg_vtxs[ 2 ], u, vHeight, _red, _green, _blue, _alpha ); + SET_ITER_VTX( &itarray->Vtxs[ nVtx + 3 ], &last_seg_vtxs[ 3 ], u, GEOMV_0, _red, _green, _blue, _alpha ); + + //u += u_delta; + } else { + SET_ITER_VTX( &itarray->Vtxs[ nVtx + 0 ], &teleporter->tunnel_verts[ start_offset + nVtx + 0 ], u, vHeight, _red, _green, _blue, _alpha ); + SET_ITER_VTX( &itarray->Vtxs[ nVtx + 1 ], &teleporter->tunnel_verts[ start_offset + nVtx + 1 ], u, GEOMV_0, _red, _green, _blue, _alpha ); + SET_ITER_VTX( &itarray->Vtxs[ nVtx + 2 ], &teleporter->tunnel_verts[ start_offset + nVtx + 2 ], u, vHeight, _red, _green, _blue, _alpha ); + SET_ITER_VTX( &itarray->Vtxs[ nVtx + 3 ], &teleporter->tunnel_verts[ start_offset + nVtx + 3 ], u, GEOMV_0, _red, _green, _blue, _alpha ); + + if ( !last_cord_removed && ( nSegment == ( num_tunnel_segs - 1 - 1 ) ) ) { + u += ( u_delta - u_delta_last_cord ); + } else { + u += u_delta; + } + } + } + } + + size_t num_triindxs = num_tunnel_cords * 8 * 3; + + dword *vindxs = (dword *) ALLOCMEM( num_triindxs * sizeof( dword ) ); + if ( vindxs == NULL ) + OUTOFMEM( 0 ); + + + for( int nCord = 0; nCord < num_tunnel_cords; nCord++ ) { + for( int nSide = 0; nSide < 4; nSide++ ) { + vindxs[ ( nCord * 24 ) + ( nSide * 6 ) + 0 ] = ( nCord * 4 ) + ( nSide + 0 ); + vindxs[ ( nCord * 24 ) + ( nSide * 6 ) + 1 ] = ( nCord * 4 ) + ( nSide + 4 ); + vindxs[ ( nCord * 24 ) + ( nSide * 6 ) + 2 ] = ( nCord * 4 ) + 4 + ( ( nSide + 1 ) % 4 ); + + vindxs[ ( nCord * 24 ) + ( nSide * 6 ) + 3 ] = ( nCord * 4 ) + ( nSide + 0 ); + vindxs[ ( nCord * 24 ) + ( nSide * 6 ) + 4 ] = ( nCord * 4 ) + 4 + ( ( nSide + 1 ) % 4 ); + vindxs[ ( nCord * 24 ) + ( nSide * 6 ) + 5 ] = ( nCord * 4 ) + ( nSide + 1 ) % 4; + } + } + + // setup transformation matrix + D_LoadIterMatrix( NULL ); + + // lock array + D_LockIterArray3( itarray, 0, itarray->NumVerts ); + + // draw indexed triangles in a single call (no far-plane clipping!) + D_DrawIterArrayIndexed( ITERARRAY_MODE_TRIANGLES, num_triindxs , vindxs, 0x3d ); + + // unlock array + D_UnlockIterArray(); + + // restore identity transformation + D_LoadIterMatrix( NULL ); + + // free vertex index array + FREEMEM( vindxs ); + + // free vertex array + FREEMEM( itarray ); +} + + +// draw a spline line between start & end point ------------------------------- +// +void D_DrawSplineLine( int num_steps, const Xmatrx transform, + const Vector3* start, const Vector3* end, + const Vector3* start_tan, const Vector3* end_tan, dword mode ) +{ + ASSERT( start != NULL ); + ASSERT( end != NULL ); + ASSERT( start_tan != NULL ); + ASSERT( end_tan != NULL ); + + ASSERT( ( mode >= D_DRAWLINE_STYLE_DEFAULT ) && ( mode <= D_DRAWLINE_STYLE_STIPPLED ) ); + + IterLine3 itline; + itline.NumVerts = 2; + + itline.flags = ITERFLAG_Z_DIV_XYZ | ITERFLAG_Z_TO_DEPTH | ITERFLAG_NONDESTRUCTIVE; + itline.flags |= ( ( mode & 0x7 ) << 12 ); // map line drawing styles to iter line drawin styles + + itline.itertype = iter_rgba; + itline.raststate = rast_zbuffer; + itline.rastmask = rast_nomask; + + itline.Vtxs[ 0 ].W = GEOMV_1; + itline.Vtxs[ 0 ].R = 255; + itline.Vtxs[ 0 ].G = 255; + itline.Vtxs[ 0 ].B = 255; + itline.Vtxs[ 0 ].A = 255; + itline.Vtxs[ 0 ].flags = ITERVTXFLAG_NONE; + + itline.Vtxs[ 1 ].W = GEOMV_1; + itline.Vtxs[ 1 ].R = 255; + itline.Vtxs[ 1 ].G = 255; + itline.Vtxs[ 1 ].B = 255; + itline.Vtxs[ 1 ].A = itline.Vtxs[ 0 ].A; + itline.Vtxs[ 1 ].flags = ITERVTXFLAG_NONE; + + // setup transformation matrix + D_LoadIterMatrix( NULL ); + + // init the hermite arclen data + Hermite_ArcLen* hermite_data; + hermite_data = Hermite_ArcLen_InitData( num_steps * 10, start, end, start_tan, end_tan ); + + for( int step = 0; step < num_steps; step++ ) { + + float s = (float)step / (float)( num_steps - 1 ); + + // calculate the interpolated pos + Vector3 interp; + Hermite_ArcLen_Interpolate( hermite_data, s, &interp ); + + if( step == 0 ) { + + MtxVctMUL( transform, start, (Vertex3*)&itline.Vtxs[ 0 ] ); + MtxVctMUL( transform, &interp, (Vertex3*)&itline.Vtxs[ 1 ] ); + + } else { + memcpy( &itline.Vtxs[ 0 ], &itline.Vtxs[ 1 ], sizeof ( IterVertex3 ) ); + + MtxVctMUL( transform, &interp, (Vertex3*)&itline.Vtxs[ 1 ] ); + } + + if ( ( step % 2 ) == 0 ) { + SETRGBA( &itline.Vtxs[ 0 ], 255,0,0,255 ); + SETRGBA( &itline.Vtxs[ 1 ], 255,0,0,255 ); + } else { + SETRGBA( &itline.Vtxs[ 0 ], 255,255,255,255 ); + SETRGBA( &itline.Vtxs[ 1 ], 255,255,255,255 ); + } + + D_DrawIterLine3( &itline, 0x00 ); + } + + // kill the hermite arclen data + Hermite_ArcLen_KillData( hermite_data ); + + // restore identity transformation + D_LoadIterMatrix( NULL ); +} + +// make a cube out of a cullbox ----------------------------------------------- +// +PRIVATE +void CubeFromCullBox3( CullBox3* cullbox, Vertex3* vtxs ) +{ + ASSERT( cullbox != NULL ); + ASSERT( vtxs != NULL ); + + for( int nVertex = 0; nVertex < 8; nVertex++ ) { + vtxs[ nVertex ].X = cullbox->minmax[ 0 + ( ( nVertex % 4 ) / 2 ) * 3 ]; + vtxs[ nVertex ].Y = cullbox->minmax[ 1 + ( ( ( ( nVertex % 4 ) % 3 ) != 0 ) ? 3 : 0 ) ]; + vtxs[ nVertex ].Z = cullbox->minmax[ 2 + ( nVertex / 4 ) * 3 ]; + } +} + + + +// show the spline connecting the start with the exit of the teleporter ------- +// +PRIVATE +void Teleporter_Debug_Show_Tunnel_Spline( Teleporter* teleporter ) +{ + ASSERT( teleporter != NULL ); + + // get the tangents + Vector3 start_tan, end_tan; + FetchZVector( teleporter->ObjPosition, &start_tan ); + FetchZVector( teleporter->child_object->ObjPosition, &end_tan ); + + // scale the tangents + VECMULS( &start_tan, &start_tan, teleporter->tunnel_tangent_scale1 ); + VECMULS( &end_tan, &end_tan, teleporter->tunnel_tangent_scale2 ); + + // draw center of tunnel + if ( teleporter->tunnel_spline & 1 ) { + // get the start/end pos + Vector3 start_pos, end_pos; + FetchTVector( teleporter->ObjPosition, &start_pos ); + FetchTVector( teleporter->child_object->ObjPosition, &end_pos ); + + // draw the spline showing the center of the tunnel + D_DrawSplineLine( teleporter->tunnel_spline_cords + 1, ViewCamera, &start_pos, &end_pos, + &start_tan, &end_tan, D_DRAWLINE_STYLE_ANTIALIASED ); + } + + // draw tunnel boundary + if ( teleporter->tunnel_spline & 2 ) { + + // calculate the boundaries of the tunnel + Vector3 boundary_start, boundary_end; + + for( int nCorner = 0; nCorner < 4; nCorner++ ) { + + // transform the start/end boundary points from object to world space + MtxVctMUL( teleporter->ObjPosition, &teleporter->start_vtxlist[ nCorner ], &boundary_start ); + MtxVctMUL( teleporter->child_object->ObjPosition, &teleporter->start_vtxlist[ nCorner ], &boundary_end ); + + // draw the boundary spline + D_DrawSplineLine( teleporter->tunnel_spline_cords + 1, ViewCamera, &boundary_start, &boundary_end, + &start_tan, &end_tan, D_DRAWLINE_STYLE_ANTIALIASED ); + } + } + + // draw tunnel boundary rects + if ( teleporter->tunnel_spline & 4 ) { + + ASSERT( teleporter->tunnel_verts != NULL ); + + int num_steps = ( teleporter->tunnel_spline_cords + 1 ); + Vertex3* vtxs = teleporter->tunnel_verts; + + // setup transformation matrix + D_LoadIterMatrix( NULL ); + + for( int step = 0; step < num_steps; step++ ) { + + IterLine3 itline; + itline.NumVerts = 2; + + itline.flags = ITERFLAG_LS_ANTIALIASED | ITERFLAG_Z_DIV_XYZ | ITERFLAG_Z_TO_DEPTH | ITERFLAG_NONDESTRUCTIVE; + itline.itertype = iter_rgba; + itline.raststate = rast_zbuffer; + itline.rastmask = rast_nomask; + + itline.Vtxs[ 0 ].W = GEOMV_1; + itline.Vtxs[ 0 ].R = 0; + itline.Vtxs[ 0 ].G = 255; + itline.Vtxs[ 0 ].B = 0; + itline.Vtxs[ 0 ].A = 255; + itline.Vtxs[ 0 ].flags = ITERVTXFLAG_NONE; + + itline.Vtxs[ 1 ].W = GEOMV_1; + itline.Vtxs[ 1 ].R = 0; + itline.Vtxs[ 1 ].G = 255; + itline.Vtxs[ 1 ].B = 0; + itline.Vtxs[ 1 ].A = itline.Vtxs[ 0 ].A; + itline.Vtxs[ 1 ].flags = ITERVTXFLAG_NONE; + + for( int nCorner = 0; nCorner < 4; nCorner++ ) { + + if( nCorner != 3 ) { + + MtxVctMUL( ViewCamera, &vtxs[ nCorner ], (Vertex3*)&itline.Vtxs[ 0 ] ); + MtxVctMUL( ViewCamera, &vtxs[ nCorner + 1 ], (Vertex3*)&itline.Vtxs[ 1 ] ); + + } else { + memcpy( &itline.Vtxs[ 0 ], &itline.Vtxs[ 1 ], sizeof ( IterVertex3 ) ); + MtxVctMUL( ViewCamera, &vtxs[ 0 ], (Vertex3*)&itline.Vtxs[ 1 ] ); + } + + D_DrawIterLine3( &itline, 0x00 ); + } + + // advance to next rectangle + vtxs += 4; + } + + // restore identity transformation + D_LoadIterMatrix( NULL ); + } + + // draw the frames for start/exit + if ( teleporter->tunnel_spline & 8 ) { + Vector3 pos; + + FetchTVector( teleporter->ObjPosition, &pos ); + D_FrameOfReference( teleporter->start_frame, &pos ); + + FetchTVector( teleporter->child_object->ObjPosition, &pos ); + D_FrameOfReference( teleporter->end_frame, &pos ); + //Draw_FrameOfReference( teleporter->ObjPosition, NULL ); + } + + // draw the frames making up the spline + if ( teleporter->tunnel_spline & 16 ) { + + int num_steps = ( teleporter->tunnel_spline_cords + 1 ); + + for( int step = 0; step < num_steps; step++ ) { + D_FrameOfReference( teleporter->spline_frames[ step ], NULL ); + } + } + + // draw the bounding box of the tunnel + if ( teleporter->tunnel_spline & 32 ) { + + CullBox3* cullbox = &teleporter->tunnel_cullbox; + + Vector3 vtxs_ospc[ 8 ]; + CubeFromCullBox3( cullbox, vtxs_ospc ); + + + // transform from object to worldspace + Vector3 vtxs[ 8 ]; + int nVertex = 0; + for( nVertex = 0; nVertex < 8; nVertex++ ) { + MtxVctMUL( teleporter->ObjPosition, &vtxs_ospc[ nVertex ], &vtxs[ nVertex ] ); + } + + colrgba_s color; + SETRGBA( &color, 0, 0, 255, 255 ); + int nLine = 0; + for( nLine = 0; nLine < 8; nLine++ ) { + D_LineWorld( &vtxs[ 4 * ( nLine / 4 ) + nLine % 4 ], &vtxs[ 4 * ( nLine / 4 ) + ( nLine + 1 ) % 4 ], &color ); + } + for( nLine = 0; nLine < 4; nLine++ ) { + D_LineWorld( &vtxs[ nLine ], &vtxs[ 4 + nLine ], &color ); + } + } + + return; +} + +// type fields init function for teleporter ------------------------------------- +// +PRIVATE +void TeleporterInitType( CustomObject *base ) +{ + ASSERT( base != NULL ); + + Teleporter *teleporter = (Teleporter *) base; + + teleporter->active = TRUE; + + teleporter->exit_delta_x = 0; + teleporter->exit_delta_y = 0; + teleporter->exit_delta_z = 100; + + teleporter->exit_rot_phi = 0; + teleporter->exit_rot_theta = 0; + + teleporter->actoffset = 5; + teleporter->act_cone_angle = 30; + + teleporter->u_variation[ 0 ] = 0.05; // percentage of texture space + teleporter->v_variation[ 0 ] = 0.05; + teleporter->u_variation[ 1 ] = 0.03; // percentage of texture space + teleporter->v_variation[ 1 ] = 0.03; + + teleporter->start_tex_sec_layer = 1; + teleporter->start_tex_alpha = 128; + + teleporter->tunnel_slerp = 1; // do slerp + teleporter->tunnel_lerp = 2; // do hermite lerp + + teleporter->tunnel_tangent_scale1 = 300; + teleporter->tunnel_tangent_scale2 = 300; + + teleporter->tunnel_anim_speed = 2; + + teleporter->tunnel_spline = FALSE; + teleporter->tunnel_spline_cords = 30; + + strcpy( teleporter->tex_name_interior, TELEPORTER_DEFAULT_TEX_NAME_INTERIOR ); + strcpy( teleporter->tex_name_tunnel, TELEPORTER_DEFAULT_TEX_NAME_TUNNEL ); + + teleporter->start_texmap = NULL; + teleporter->tunnel_texmap = NULL; + + teleporter->start_vtxlist = NULL; + teleporter->start_texmap = NULL; + teleporter->tunnel_verts = NULL; + teleporter->tunnel_spline_arclen = GEOMV_0; + + teleporter->tunnel_tex_alpha = 128; +} + +// teleporter constructor (class instantiation) --------------------------------- +// +PRIVATE +void TeleporterInstantiate( CustomObject *base ) +{ + ASSERT( base != NULL ); + Teleporter *teleporter = (Teleporter *) base; + + teleporter->start_vtxlist = (Vertex3*)ALLOCMEM( 4 * sizeof( Vertex3 ) ); + memset( teleporter->start_vtxlist, 0, 4 * sizeof( Vertex3 ) ); + + // init the vertices making up the filled interior of the teleporter start + teleporter->start_vtxlist[ 0 ].X = (geomv_t)-TELEP_BOUNDARY_HORIZ; + teleporter->start_vtxlist[ 0 ].Y = (geomv_t)-TELEP_BOUNDARY_VERT; + teleporter->start_vtxlist[ 0 ].Z = GEOMV_0; + + teleporter->start_vtxlist[ 1 ].X = (geomv_t)TELEP_BOUNDARY_HORIZ; + teleporter->start_vtxlist[ 1 ].Y = (geomv_t)-TELEP_BOUNDARY_VERT; + teleporter->start_vtxlist[ 1 ].Z = GEOMV_0; + + teleporter->start_vtxlist[ 2 ].X = (geomv_t)TELEP_BOUNDARY_HORIZ; + teleporter->start_vtxlist[ 2 ].Y = (geomv_t)TELEP_BOUNDARY_VERT; + teleporter->start_vtxlist[ 2 ].Z = GEOMV_0; + + teleporter->start_vtxlist[ 3 ].X = (geomv_t)-TELEP_BOUNDARY_HORIZ; + teleporter->start_vtxlist[ 3 ].Y = (geomv_t)TELEP_BOUNDARY_VERT; + teleporter->start_vtxlist[ 3 ].Z = GEOMV_0; + + // summon the child teleporter ( exit ) as plain geometry type + dword objclass = OBJ_FetchObjectClassId( TELEPORTER_EXIT_MODEL_NAME ); + ASSERT( objclass != CLASS_ID_INVALID ); + if ( objclass >= (dword)NumObjClasses ) { + CON_AddLine( telep_exit_class_not_found ); + return; + } + + if ( objclass != CLASS_ID_INVALID ) { + + Xmatrx ChildTrans; + MakeIdMatrx( ChildTrans ); + + // translate the teleporter exit + ChildTrans[ 0 ][ 3 ] = teleporter->exit_delta_x; + ChildTrans[ 1 ][ 3 ] = teleporter->exit_delta_y; + ChildTrans[ 2 ][ 3 ] = teleporter->exit_delta_z; + + // get the trafo for the exit rotation + Teleporter_Rotation_Transform( teleporter->exit_rot_phi, teleporter->exit_rot_theta, ChildTrans ); + + Xmatrx ChildPos; + MtxMtxMUL( teleporter->ObjPosition, ChildTrans, ChildPos ); + + // summon a object from a class ( do not show stargate ) + teleporter->child_object = SummonObject( objclass, ChildPos ); + } + + // get the texture maps and calc the max u/v deltas + TeleporterModify_TexPropsChanged( teleporter ); + + // init the angles + teleporter->u_phi[ 0 ] = DEG_TO_BAMS( RAND() % 360 ); + teleporter->v_phi[ 0 ] = DEG_TO_BAMS( RAND() % 360 ); + teleporter->u_phi[ 1 ] = DEG_TO_BAMS( RAND() % 360 ); + teleporter->v_phi[ 1 ] = DEG_TO_BAMS( RAND() % 360 ); + + // init the delta angles + teleporter->u_phi_delta[ 0 ] = DEG_TO_BAMS( 0.1 ); + teleporter->v_phi_delta[ 0 ] = DEG_TO_BAMS( 0.1 ); + teleporter->u_phi_delta[ 1 ] = DEG_TO_BAMS( 0.1 ); + teleporter->v_phi_delta[ 1 ] = DEG_TO_BAMS( 0.1 ); + + // init the tunnel frame to the frame of the teleporter start + memcpy( &teleporter->tunnel_frame, &teleporter->ObjPosition, sizeof( Xmatrx ) ); + + // init the interpolation t + //teleporter->tunnel_t = 0.0f; + teleporter->tunnel_t = (float)RAND() / (float)0x7fff/*RAND_MAX*/; + + teleporter->spline_frames = NULL; + + // calculate the verts for the tunnel + Teleporter_Calc_Tunnel_Verts( teleporter ); + + // set the properties for the tunnel animation + teleporter->tunnel_len = 10; + teleporter->tunnel_cur_anim_step = GEOMV_0; + + // get the initial start position + FetchTVector( teleporter->ObjPosition, &teleporter->start ); + + //FIXME: we need to get the angles out of the matrix + teleporter->start_rot_phi = 0; + teleporter->start_rot_theta = 0; +} + +// callback type and flags ---------------------------------------------------- +// +static int callback_type = CBTYPE_DRAW_CUSTOM_ITER | CBFLAG_REMOVE; + + + +// teleporter destructor (instance destruction) --------------------------------- +// +PRIVATE +void TeleporterDestroy( CustomObject *base ) +{ + ASSERT( base != NULL ); + Teleporter *teleporter = (Teleporter *) base; + + // stop any playing teleporter sound + AUD_TeleporterOff( teleporter ); + + // destroy attached vertex info + ASSERT( teleporter->start_vtxlist != NULL ); + ASSERT( teleporter->tunnel_verts != NULL ); + + FREEMEM( teleporter->start_vtxlist ); + FREEMEM( teleporter->tunnel_verts ); + + teleporter->start_vtxlist = NULL; + teleporter->tunnel_verts = NULL; + + if ( teleporter->spline_frames != NULL ) { + FREEMEM( teleporter->spline_frames ); + } + + // ensure pending callbacks are destroyed to avoid + // calling them with invalid pointers + int numremoved = CALLBACK_DestroyCallback( callback_type, (void *) base ); + //ASSERT( numremoved <= 1 ); +} + + +// teleporter animation callback ---------------------------------------------- +// +PRIVATE +int TeleporterAnimate( CustomObject *base ) +{ + ASSERT( base != NULL ); + Teleporter *teleporter = (Teleporter *) base; + + // do nothing if teleporter inactive + if ( !teleporter->active ) + return TRUE; + + teleporter->u_phi[ 0 ] += teleporter->u_phi_delta[ 0 ] * CurScreenRefFrames; + teleporter->v_phi[ 0 ] += teleporter->v_phi_delta[ 0 ] * CurScreenRefFrames; + teleporter->u_phi[ 1 ] += teleporter->u_phi_delta[ 1 ] * CurScreenRefFrames; + teleporter->v_phi[ 1 ] += teleporter->v_phi_delta[ 1 ] * CurScreenRefFrames; + + sincosval_s sincosv; + GetSinCos( teleporter->u_phi[ 0 ], &sincosv ); + teleporter->u_delta[ 0 ] = GEOMV_MUL( teleporter->u_maxdelta[ 0 ], sincosv.cosval ); + GetSinCos( teleporter->v_phi[ 0 ], &sincosv ); + teleporter->v_delta[ 0 ] = GEOMV_MUL( teleporter->v_maxdelta[ 0 ], sincosv.sinval ); + GetSinCos( teleporter->u_phi[ 1 ], &sincosv ); + teleporter->u_delta[ 1 ] = GEOMV_MUL( teleporter->u_maxdelta[ 1 ], sincosv.cosval ); + GetSinCos( teleporter->v_phi[ 1 ], &sincosv ); + teleporter->v_delta[ 1 ] = GEOMV_MUL( teleporter->v_maxdelta[ 1 ], sincosv.sinval ); + + // animate the tunnel frame + Teleporter_Animate_Tunnel( teleporter ); + + // register the drawing callback for drawing the interior of the teleporter + CALLBACK_RegisterCallback( callback_type, Teleporter_Draw, (void *) base ); + + return TRUE; +} + +// animate the tunnel frame --------------------------------------------------- +// +PRIVATE +void Teleporter_Animate_Tunnel( Teleporter* teleporter ) +{ + ASSERT( teleporter != NULL ); + + // do nothing if teleporter inactive + if ( !teleporter->active ) + return; + + // reset the interpolation if it was at the end of the animation + if ( teleporter->tunnel_t == 1.0f ) { + teleporter->tunnel_t = 0.0f; + } else { + // advance the t paramater + teleporter->tunnel_t += (float)CurScreenRefFrames / ( (float)FRAME_MEASURE_TIMEBASE * (float)teleporter->tunnel_anim_speed ); + if ( teleporter->tunnel_t > 1.0f ) { + teleporter->tunnel_t = 1.0f; + } + } + + int num_steps = ( teleporter->tunnel_spline_cords + 1 ); + + teleporter->tunnel_cur_anim_step = ( num_steps - 1 + teleporter->tunnel_len ) * teleporter->tunnel_t; + + if ( teleporter->tunnel_cur_anim_step >= num_steps + teleporter->tunnel_len ) { + teleporter->tunnel_cur_anim_step = num_steps - 1 + teleporter->tunnel_len; + } + +#ifdef ANIMATE_TUNNEL_FRAME + + // reset the interpolation if it was at the end of the animation + if ( teleporter->tunnel_t == 1.0f ) { + teleporter->tunnel_t = 0.0f; + memcpy( teleporter->tunnel_frame, teleporter->ObjPosition, sizeof( Xmatrx ) ); + } + + // advance the t paramater + teleporter->tunnel_t += (float)CurScreenRefFrames / ( (float)FRAME_MEASURE_TIMEBASE * (float)teleporter->tunnel_anim_speed ); + if ( teleporter->tunnel_t > 1.0f ) { + teleporter->tunnel_t = 1.0f; + } + + // get the position of the tunnel frame ( source ) + Vector3 tunnel_pos; + FetchTVector( teleporter->tunnel_frame, &tunnel_pos ); + + // get the position of the teleporter exit ( destination ) + Vector3 exit_pos; + FetchTVector( teleporter->child_object->ObjPosition, &exit_pos ); + + // check whether to do the SLERP + if ( teleporter->tunnel_slerp == 1 ) { + + // we only want todo the quaterionien slerp on the orientations not on the poses + Xmatrx start_frame, end_frame; + MakeNonTranslationMatrx( teleporter->ObjPosition, start_frame ); + MakeNonTranslationMatrx( teleporter->child_object->ObjPosition, end_frame ); + + // get slerp frame + QuaternionSlerpFrames( teleporter->tunnel_frame, start_frame, end_frame, teleporter->tunnel_t ); + +/* // get source orientation quaternion + Quaternion srcquat; + QuaternionFromMatrx( &srcquat, start_frame ); + QuaternionMakeUnit( &srcquat ); + + // get destination orientation quaternion + Quaternion dstquat; + QuaternionFromMatrx( &dstquat, end_frame ); + QuaternionMakeUnit( &dstquat ); + + // do slerp from src to dst (filter output this frame) + Quaternion slerpquat; + QuaternionSlerp( &slerpquat, &srcquat, &dstquat, teleporter->tunnel_t ); + QuaternionMakeUnit( &slerpquat ); + + // fill R part of view camera matrix (filtered orientation this frame) + MatrxFromQuaternion( teleporter->tunnel_frame, &slerpquat ); +*/ + } + + // check whether to do simple LERP + if ( teleporter->tunnel_lerp == 1 ) { + + // get the position of the tunnel frame + FetchTVector( teleporter->tunnel_frame, &tunnel_pos ); + + // interpolation vector from last filtered to new filtered t + float lerpx = GEOMV_TO_FLOAT( exit_pos.X - tunnel_pos.X ) * teleporter->tunnel_t; + float lerpy = GEOMV_TO_FLOAT( exit_pos.Y - tunnel_pos.Y ) * teleporter->tunnel_t; + float lerpz = GEOMV_TO_FLOAT( exit_pos.Z - tunnel_pos.Z ) * teleporter->tunnel_t; + + Vector3 deltatvec; + deltatvec.X = FLOAT_TO_GEOMV( lerpx ); + deltatvec.Y = FLOAT_TO_GEOMV( lerpy ); + deltatvec.Z = FLOAT_TO_GEOMV( lerpz ); + + VECADD( &tunnel_pos, &deltatvec, &tunnel_pos ); + } + + // check whether to do Hermite LERP for the position + if ( teleporter->tunnel_lerp == 2 ) { + + Vector3 T1; + Vector3 T2; + FetchZVector( teleporter->ObjPosition, &T1 ); + FetchZVector( teleporter->child_object->ObjPosition, &T2 ); + + Vector3 teleporter_pos; + FetchTVector( teleporter->ObjPosition, &teleporter_pos ); + + VECMULS( &T1, &T1, teleporter->tunnel_tangent_scale1 ); + VECMULS( &T2, &T2, teleporter->tunnel_tangent_scale2 ); + + Hermite_Interpolate( &tunnel_pos, teleporter->tunnel_t, &teleporter_pos, &exit_pos, &T1, &T2 ); + } + + // store the tunnel pos back to the tunnel frame + StoreTVector( teleporter->tunnel_frame, &tunnel_pos ); + +#endif // ANIMATE_TUNNEL_FRAME +} + + +// check whether a ship is in range of a teleporter entry --------------------- +// +PRIVATE +int Teleporter_ShipInRange( Teleporter *teleporter, ShipObject *ship ) +{ + ASSERT( teleporter != NULL ); + ASSERT( ship != NULL ); + + //NOTE: + // the ship is treated as a sphere for activation + // range detection. + + Vector3 telepnormal; + FetchZVector( teleporter->ObjPosition, &telepnormal ); + + Vertex3 teleppos; + FetchTVector( teleporter->ObjPosition, &teleppos ); + + Vertex3 shippos; + FetchTVector( ship->ObjPosition, &shippos ); + + geomv_t shipdot = -DOT_PRODUCT( &telepnormal, &shippos ); + geomv_t telepdot = -DOT_PRODUCT( &telepnormal, &teleppos ); + geomv_t distance = shipdot - telepdot; + + // not in range if ship in wrong halfspace ( already behind teleporter ) + if ( GEOMV_NEGATIVE( distance ) ) { + return FALSE; + } + + // check whether inside of boundingsphere around teleporter + Vector3 telepship; + VECSUB( &telepship, &shippos, &teleppos ); + + geomv_t telepship_len = VctLenX( &telepship ); + if ( telepship_len > teleporter->BoundingSphere ) { + return FALSE; + } + + // inside the activation distance ? + if ( distance < teleporter->actoffset ) { + + // check whether inside of cone + Vector3 shipnormal; + FetchZVector( ship->ObjPosition, &shipnormal ); + + shipdot = DOT_PRODUCT( &telepnormal, &shipnormal ); + sincosval_s sincosv; + GetSinCos( DEG_TO_BAMS( teleporter->act_cone_angle ), &sincosv ); + + return ( shipdot >= sincosv.cosval ); + + } else { + return FALSE; + } +} + + + +// teleporter collision callback ------------------------------------------------ +// +PRIVATE +int TeleporterCollide( CustomObject *base ) +{ + ASSERT( base != NULL ); + + Teleporter *teleporter = (Teleporter *) base; + + // do nothing if teleporter inactive + if ( !teleporter->active ) + return TRUE; + + // determine whether MyShip is in audio range of teleporter + Vector3 diff; + Vertex3 teleppos; + Vertex3 shippos; + FetchTVector( teleporter->ObjPosition, &teleppos ); + FetchTVector( MyShip->ObjPosition, &shippos ); + VECSUB( &diff, &teleppos, &shippos ); + geomv_t distance = VctLenX( &diff ); + + if ( distance < MAX_VOLUME_DISTANCE_TELEPORTER ) { + AUD_Teleporter( teleporter ); + } else { + AUD_TeleporterOff( teleporter ); + } + + // get the world->object transform + Xmatrx World2Telep; + CalcOrthoInverse( teleporter->ObjPosition, World2Telep ); + + // first check local ship + if ( Teleporter_ShipInRange( teleporter, MyShip ) ) { + + // get the world->view transform + Xmatrx CameraInWorldSpace; + CalcOrthoInverse( ShipViewCamera, CameraInWorldSpace ); + + // transform the camera to object space + Xmatrx CameraInTelepSpace; + MtxMtxMUL( World2Telep, CameraInWorldSpace, CameraInTelepSpace ); + + // transform camera to world space ( using the teleporter exit frame ) + MtxMtxMUL( teleporter->child_object->ObjPosition, CameraInTelepSpace, CameraInWorldSpace ); + + // transform camera to view space + CalcOrthoInverse( CameraInWorldSpace, ShipViewCamera ); + + CameraMoved = TRUE; + } + +#ifndef DONT_MOVE_REMOTE_SHIPS + + // walk all ships and check for teleportings + ShipObject *shippo = FetchFirstShip(); + for ( ; shippo; shippo = (ShipObject *) shippo->NextObj ) { + if ( shippo != MyShip ) { + if ( Teleporter_ShipInRange( teleporter, shippo ) ) { + + // transform the ship to (teleporter) object space + Xmatrx ShipInTelepSpace; + MtxMtxMUL( World2Telep, shippo->ObjPosition, ShipInTelepSpace ); + + // transform ship to world space ( using the teleporter exit frame ) + MtxMtxMUL( teleporter->child_object->ObjPosition, ShipInTelepSpace, shippo->ObjPosition ); + } + } + } + +#endif // !DONT_MOVE_REMOTE_SHIPS + + return TRUE; +} + + +// register object type for Teleporter ------------------------------------------ +// +PRIVATE +void TeleporterRegisterCustomType() +{ + custom_type_info_s info; + memset( &info, 0, sizeof( info ) ); + + info.type_name = "teleporter"; + info.type_id = 0x00000000; + info.type_size = sizeof( Teleporter ); + info.type_template = NULL; + info.type_flags = CUSTOM_TYPE_DEFAULT; + info.callback_init = TeleporterInitType; + info.callback_instant = TeleporterInstantiate; + info.callback_destroy = TeleporterDestroy; + info.callback_animate = TeleporterAnimate; + info.callback_collide = TeleporterCollide; + info.callback_notify = NULL; + info.callback_persist = NULL;//TeleporterPersistFromStream; + + OBJ_RegisterCustomType( &info ); + CON_RegisterCustomType( info.type_id, Teleporter_PropList ); + + memset( &info, 0, sizeof( info ) ); + + info.type_name = "telep_exit"; + info.type_id = 0x00000000; + info.type_size = sizeof( Teleporter ); + info.type_template = NULL; + info.type_flags = CUSTOM_TYPE_DEFAULT | CUSTOM_TYPE_NOT_PERSISTANT; + info.callback_init = NULL; + info.callback_instant = NULL; + info.callback_destroy = NULL; + info.callback_animate = NULL; + info.callback_collide = NULL; + info.callback_notify = NULL; + info.callback_persist = NULL; + + OBJ_RegisterCustomType( &info ); +} + + +// module registration function ----------------------------------------------- +// +REGISTER_MODULE( G_TELEP ) +{ + // register type + TeleporterRegisterCustomType(); +} + |