WebSVN – Games.Carmageddon – Blame – //src/DETHRACE/common/piping.c

Rev	Author	Line No.	Line
1	pmbaty	1	#include "piping.h"
20	pmbaty	2	#include "brender/brender.h"
1	pmbaty	3	#include "car.h"
		4	#include "crush.h"
		5	#include "errors.h"
		6	#include "globvars.h"
		7	#include "globvrpb.h"
		8	#include "graphics.h"
		9	#include "harness/trace.h"
		10	#include "oil.h"
		11	#include "opponent.h"
		12	#include "pedestrn.h"
		13	#include "replay.h"
		14	#include "skidmark.h"
		15	#include "sound.h"
		16	#include "spark.h"
		17	#include "sys.h"
		18	#include "utility.h"
		19	#include "world.h"
		20	#include <stdlib.h>
		21	#include <string.h>
		22
		23	tU8* gPipe_buffer_start = NULL;
		24	int gDisable_sound = 0;
		25	int gDisable_advance = 0;
		26	int gMax_rewind_chunks = 1000;
		27	float gWall_severity = 0.f;
		28	tPipe_reset_proc* gReset_procs[32] = {
		29	NULL,
		30	NULL,
		31	NULL,
		32	NULL,
		33	NULL,
		34	NULL,
		35	NULL,
		36	NULL,
		37	NULL,
		38	NULL,
		39	NULL,
		40	ResetAllPedestrians,
		41	NULL,
		42	NULL,
		43	NULL,
		44	NULL,
		45	NULL,
		46	ResetAllPedGibs,
		47	NULL,
		48	ResetSparks,
		49	ResetShrapnel,
		50	ResetScreenWobble,
		51	NULL,
		52	NULL,
		53	ResetSmoke,
		54	NULL,
		55	NULL,
		56	NULL,
		57	NULL,
		58	NULL,
		59	ResetProxRay,
		60	NULL,
		61	};
		62	tPiped_registration_snapshot gRegistration_snapshots[5];
		63	tPipe_smudge_data* gSmudge_space;
		64	tU32 gOldest_time;
		65	int gCurrent_snapshot_registration_index;
		66	tPipe_chunk* gMr_chunky;
		67	tCar_spec* gCar_ptr;
		68	br_vector3 gZero_vector;
		69	tPipe_chunk_type gReentrancy_array[5];
		70	tU32 gLast_time;
		71	tPipe_model_geometry_data* gModel_geometry_space;
		72	tU32 gEnd_time;
		73	tU32 gTrigger_time;
		74	int gReentrancy_count;
		75	br_vector3 gCar_pos;
		76	br_vector3 gReference_pos;
		77	br_scalar gMax_distance;
		78	tU32 gLoop_abort_time;
		79	br_vector3 gWall_impact_point;
		80	tU8* gPipe_buffer_working_end;
		81	tU32 gYoungest_time;
		82	tU8* gPipe_buffer_phys_end;
		83	tU8* gLocal_buffer_record_ptr;
		84	tU8* gPipe_play_ptr;
		85	tU8* gEnd_of_session;
		86	tU8* gPipe_record_ptr;
		87	tU8* gPipe_buffer_oldest;
		88	tU32 gPipe_buffer_size;
		89	tU8* gLocal_buffer;
		90	tU32 gLocal_buffer_size;
		91	tPipe_chunk* gIncidentChunk; // FIXME: added by DethRace (really needed?)
		92
		93	#define LOCAL_BUFFER_SIZE 15000
		94
		95	#if defined(DETHRACE_REPLAY_DEBUG)
		96	#define REPLAY_DEBUG_CHUNK_MAGIC1 0x1ed6ef85
		97	#define REPLAY_DEBUG_SESSION_MAGIC1 0x617bbc04
		98	#define REPLAY_DEBUG_ASSERT(test) assert(test)
		99	#include <assert.h>
		100	#else
		101	#define REPLAY_DEBUG_ASSERT(test)
		102	#endif
		103
		104	#if defined(DETHRACE_FIX_BUGS)
		105	#define PIPE_ALIGN(V) (((V) + sizeof(void) - 1) & ~(sizeof(void) - 1))
		106	#endif
		107
		108	// IDA: void __usercall GetReducedPos(br_vector3 v@<EAX>, tReduced_pos p@<EDX>)
		109	void GetReducedPos(br_vector3* v, tReduced_pos* p) {
		110	LOG_TRACE("(%p, %p)", v, p);
		111
		112	v->v[0] = p->v[0] / 800.f;
		113	v->v[1] = p->v[1] / 800.f;
		114	v->v[2] = p->v[2] / 800.f;
		115	BrVector3Accumulate(v, &gProgram_state.current_car.car_master_actor->t.t.translate.t);
		116	}
		117
		118	// IDA: void __usercall SaveReducedPos(tReduced_pos p@<EAX>, br_vector3 v@<EDX>)
		119	void SaveReducedPos(tReduced_pos* p, br_vector3* v) {
		120	br_vector3 tv;
		121	LOG_TRACE("(%p, %p)", p, v);
		122
		123	BrVector3Sub(&tv, v, &gProgram_state.current_car.car_master_actor->t.t.translate.t);
		124	p->v[0] = tv.v[0] * 800.f;
		125	p->v[1] = tv.v[1] * 800.f;
		126	p->v[2] = tv.v[2] * 800.f;
		127	}
		128
		129	// IDA: int __cdecl PipeSearchForwards()
		130	int PipeSearchForwards(void) {
		131	LOG_TRACE("()");
		132
		133	if (gPipe_play_ptr == gPipe_record_ptr) {
		134	return 0;
		135	}
		136	if (gPipe_play_ptr == gPipe_buffer_oldest) {
		137	return 1;
		138	}
		139	if (GetReplayRate() == 0.f) {
		140	return GetReplayDirection() > 0;
		141	} else {
		142	return GetReplayRate() > 0.f;
		143	}
		144	}
		145
		146	// IDA: int __cdecl IsActionReplayAvailable()
		147	int IsActionReplayAvailable(void) {
		148	LOG_TRACE("()");
		149
		150	return gPipe_buffer_start != NULL;
		151	}
		152
		153	// IDA: int __cdecl SomeReplayLeft()
		154	int SomeReplayLeft(void) {
		155	LOG_TRACE("()");
		156
		157	return ((GetReplayDirection() >= 1 && gPipe_play_ptr != gPipe_record_ptr) \|\| (GetReplayDirection() <= -1 && gPipe_play_ptr != gPipe_buffer_oldest));
		158	}
		159
		160	// IDA: void __cdecl DisablePipedSounds()
		161	void DisablePipedSounds(void) {
		162	LOG_TRACE("()");
		163
		164	gDisable_sound = 1;
		165	}
		166
		167	// IDA: void __cdecl EnablePipedSounds()
		168	void EnablePipedSounds(void) {
		169	LOG_TRACE("()");
		170
		171	gDisable_sound = 0;
		172	}
		173
		174	// IDA: tU32 __usercall LengthOfSession@<EAX>(tPipe_session *pSession@<EAX>)
		175	tU32 LengthOfSession(tPipe_session* pSession) {
		176	int i;
		177	tU32 running_total;
		178	tPipe_chunk* the_chunk;
		179	LOG_TRACE("(%p)", pSession);
		180
		181	#define SIZEOF_CHUNK(MEMBER) (offsetof(tPipe_chunk, chunk_data) + sizeof(pSession->chunks.chunk_data.MEMBER))
		182	#define ROUND_UP(V, M) (((V) + (M)-1) & (~((M)-1)))
		183
		184	REPLAY_DEBUG_ASSERT(pSession->pipe_magic1 == REPLAY_DEBUG_SESSION_MAGIC1);
		185
		186	switch (pSession->chunk_type) {
		187	case ePipe_chunk_actor_rstyle:
		188	running_total = SIZEOF_CHUNK(actor_rstyle_data) * pSession->number_of_chunks;
		189	break;
		190	case ePipe_chunk_actor_translate:
		191	running_total = SIZEOF_CHUNK(actor_translate_data) * pSession->number_of_chunks;
		192	break;
		193	case ePipe_chunk_actor_transform:
		194	running_total = SIZEOF_CHUNK(actor_transform_data) * pSession->number_of_chunks;
		195	break;
		196	case ePipe_chunk_actor_create:
		197	running_total = 0;
		198	break;
		199	case ePipe_chunk_actor_destroy:
		200	running_total = 0;
		201	break;
		202	case ePipe_chunk_actor_relink:
		203	running_total = SIZEOF_CHUNK(actor_relink_data) * pSession->number_of_chunks;
		204	break;
		205	case ePipe_chunk_actor_material:
		206	running_total = SIZEOF_CHUNK(actor_material_data) * pSession->number_of_chunks;
		207	break;
		208	case ePipe_chunk_face_material:
		209	running_total = SIZEOF_CHUNK(face_material_data) * pSession->number_of_chunks;
		210	break;
		211	case ePipe_chunk_material_trans:
		212	running_total = SIZEOF_CHUNK(material_trans_data) * pSession->number_of_chunks;
		213	break;
		214	case ePipe_chunk_material_pixelmap:
		215	running_total = SIZEOF_CHUNK(material_pixelmap_data) * pSession->number_of_chunks;
		216	break;
		217	case ePipe_chunk_model_geometry:
		218	running_total = 0;
		219	for (i = 0; i < pSession->number_of_chunks; i++) {
		220	the_chunk = (tPipe_chunk)&((tU8)&pSession->chunks)[running_total];
		221	running_total += the_chunk->chunk_data.model_geometry_data.vertex_count * sizeof(tChanged_vertex) + offsetof(tPipe_model_geometry_data, vertex_changes) + offsetof(tPipe_chunk, chunk_data);
		222	}
		223	break;
		224	case ePipe_chunk_pedestrian:
		225	running_total = 0;
		226	for (i = 0; i < pSession->number_of_chunks; i++) {
		227	the_chunk = (tPipe_chunk)&(((tU8)&pSession->chunks)[running_total]);
		228	if (the_chunk->chunk_data.pedestrian_data.hit_points <= 0) {
		229	running_total += SIZEOF_CHUNK(pedestrian_data);
		230	} else {
		231	running_total += offsetof(tPipe_pedestrian_data, spin_period) + offsetof(tPipe_chunk, chunk_data);
		232	}
		233	}
		234	break;
		235	case ePipe_chunk_frame_boundary:
		236	running_total = SIZEOF_CHUNK(frame_boundary_data);
		237	break;
		238	case ePipe_chunk_car:
		239	running_total = SIZEOF_CHUNK(car_data) * pSession->number_of_chunks;
		240	break;
		241	case ePipe_chunk_sound:
		242	running_total = SIZEOF_CHUNK(sound_data) * pSession->number_of_chunks;
		243	break;
		244	case ePipe_chunk_damage:
		245	running_total = SIZEOF_CHUNK(damage_data);
		246	break;
		247	case ePipe_chunk_special:
		248	running_total = SIZEOF_CHUNK(special_data) * pSession->number_of_chunks;
		249	break;
		250	case ePipe_chunk_ped_gib:
		251	running_total = SIZEOF_CHUNK(ped_gib_data) * pSession->number_of_chunks;
		252	break;
		253	case ePipe_chunk_incident:
		254	running_total = SIZEOF_CHUNK(incident_data) * pSession->number_of_chunks;
		255	break;
		256	case ePipe_chunk_spark:
		257	running_total = SIZEOF_CHUNK(spark_data) * pSession->number_of_chunks;
		258	break;
		259	case ePipe_chunk_shrapnel:
		260	running_total = 0;
		261	for (i = 0; i < pSession->number_of_chunks; i++) {
		262	the_chunk = (tPipe_chunk)&((tU8)&pSession->chunks)[running_total];
		263	if (the_chunk->subject_index & 0x8000) {
		264	running_total += SIZEOF_CHUNK(shrapnel_data);
		265	} else {
		266	running_total += offsetof(tPipe_shrapnel_data, age) + offsetof(tPipe_chunk, chunk_data);
		267	}
		268	}
		269	break;
		270	case ePipe_chunk_screen_shake:
		271	running_total = SIZEOF_CHUNK(screen_shake_data) * pSession->number_of_chunks;
		272	break;
		273	case ePipe_chunk_groove_stop:
		274	running_total = SIZEOF_CHUNK(groove_stop_data) * pSession->number_of_chunks;
		275	break;
		276	case ePipe_chunk_non_car:
		277	running_total = SIZEOF_CHUNK(non_car_data) * pSession->number_of_chunks;
		278	break;
		279	case ePipe_chunk_smoke:
		280	running_total = SIZEOF_CHUNK(smoke_data) * pSession->number_of_chunks;
		281	break;
		282	case ePipe_chunk_oil_spill:
		283	running_total = SIZEOF_CHUNK(oil_data) * pSession->number_of_chunks;
		284	break;
		285	case ePipe_chunk_smoke_column:
		286	running_total = ROUND_UP(SIZEOF_CHUNK(smoke_column_data), 4) * pSession->number_of_chunks;
		287	break;
		288	case ePipe_chunk_flame:
		289	running_total = SIZEOF_CHUNK(flame_data) * pSession->number_of_chunks;
		290	break;
		291	case ePipe_chunk_smudge:
		292	running_total = 0;
		293	for (i = 0; i < pSession->number_of_chunks; i++) {
		294	the_chunk = (tPipe_chunk)&((tU8)&pSession->chunks)[running_total];
		295	running_total += the_chunk->chunk_data.smudge_data.vertex_count * sizeof(tSmudged_vertex) + offsetof(tPipe_smudge_data, vertex_changes) + offsetof(tPipe_chunk, chunk_data);
		296	}
		297	break;
		298	case ePipe_chunk_splash:
		299	running_total = SIZEOF_CHUNK(splash_data) * pSession->number_of_chunks;
		300	break;
		301	case ePipe_chunk_prox_ray:
		302	running_total = SIZEOF_CHUNK(prox_ray_data) * pSession->number_of_chunks;
		303	break;
		304	case ePipe_chunk_skid_adjustment:
		305	running_total = SIZEOF_CHUNK(skid_adjustment) * pSession->number_of_chunks;
		306	break;
		307	default:
		308	running_total = 0;
		309	break;
		310	}
		311	running_total += offsetof(tPipe_session, chunks) + sizeof(tU16);
		312	if (running_total % 2 != 0) {
		313	FatalError(kFatalError_PipingSystem);
		314	}
		315	return running_total;
		316	}
		317
		318	// IDA: void __usercall StartPipingSession2(tPipe_chunk_type pThe_type@<EAX>, int pMunge_reentrancy@<EDX>)
		319	void StartPipingSession2(tPipe_chunk_type pThe_type, int pMunge_reentrancy) {
		320	LOG_TRACE("(%d, %d)", pThe_type, pMunge_reentrancy);
		321
		322	if (gPipe_buffer_start != NULL && !gAction_replay_mode && gProgram_state.racing) {
		323	if (pMunge_reentrancy) {
		324	if (gReentrancy_count != 0) {
		325	gReentrancy_array[gReentrancy_count - 1] = ((tPipe_session*)gLocal_buffer)->chunk_type;
		326	EndPipingSession2(0);
		327	}
		328	gReentrancy_count++;
		329	}
		330	((tPipe_session*)gLocal_buffer)->chunk_type = pThe_type;
		331	((tPipe_session*)gLocal_buffer)->number_of_chunks = 0;
		332	#if defined(DETHRACE_REPLAY_DEBUG)
		333	((tPipe_session*)gLocal_buffer)->pipe_magic1 = REPLAY_DEBUG_SESSION_MAGIC1;
		334	#endif
		335	gLocal_buffer_size = offsetof(tPipe_session, chunks);
		336	gMr_chunky = &((tPipe_session*)gLocal_buffer)->chunks;
		337	}
		338	}
		339
		340	// IDA: void __usercall StartPipingSession(tPipe_chunk_type pThe_type@<EAX>)
		341	void StartPipingSession(tPipe_chunk_type pThe_type) {
		342	LOG_TRACE("(%d)", pThe_type);
		343
		344	StartPipingSession2(pThe_type, 1);
		345	}
		346
		347	// IDA: void __usercall EndPipingSession2(int pMunge_reentrancy@<EAX>)
		348	void EndPipingSession2(int pMunge_reentrancy) {
		349	int a;
		350	LOG_TRACE("(%d)", pMunge_reentrancy);
		351
		352	if (gPipe_buffer_start != NULL && !gAction_replay_mode && gProgram_state.racing) {
		353	// Each session ends with a tU16, containing the session size
		354	(tU16)&gLocal_buffer[gLocal_buffer_size] = gLocal_buffer_size;
		355	a = gLocal_buffer_size;
		356	gLocal_buffer_size += sizeof(tU16);
		357	REPLAY_DEBUG_ASSERT(LengthOfSession((tPipe_session*)gLocal_buffer) == gLocal_buffer_size);
		358	#if defined(DETHRACE_FIX_BUGS)
		359	gLocal_buffer_size = PIPE_ALIGN(gLocal_buffer_size);
		360	(tU16)&gLocal_buffer[gLocal_buffer_size - sizeof(tU16)] = gLocal_buffer_size - sizeof(tU16);
		361	#endif
		362	if (((tPipe_session*)gLocal_buffer)->number_of_chunks != 0 && (gLocal_buffer_size < LOCAL_BUFFER_SIZE \|\| a == LOCAL_BUFFER_SIZE - 2)) {
		363	if (gPipe_buffer_phys_end < gPipe_record_ptr + gLocal_buffer_size) {
		364	// Put session at begin of pipe, as no place at end
		365	gPipe_buffer_working_end = gPipe_record_ptr;
		366	gPipe_buffer_oldest = gPipe_buffer_start;
		367	gPipe_record_ptr = gPipe_buffer_start;
		368	}
		369	while (gPipe_record_ptr <= gPipe_buffer_oldest && gPipe_buffer_oldest < gPipe_record_ptr + gLocal_buffer_size) {
		370	// Remove older sessions
		371	#if defined(DETHRACE_FIX_BUGS)
		372	gPipe_buffer_oldest += PIPE_ALIGN(LengthOfSession((tPipe_session*)gPipe_buffer_oldest));
		373	#else
		374	gPipe_buffer_oldest += LengthOfSession((tPipe_session*)gPipe_buffer_oldest);
		375	#endif
		376	if (gPipe_buffer_working_end <= gPipe_buffer_oldest) {
		377	gPipe_buffer_working_end = gPipe_buffer_phys_end;
		378	gPipe_buffer_oldest = gPipe_buffer_start;
		379	}
		380	}
		381	if (gPipe_buffer_oldest == NULL) {
		382	gPipe_buffer_oldest = gPipe_record_ptr;
		383	}
		384	memcpy(gPipe_record_ptr, gLocal_buffer, gLocal_buffer_size);
		385	gPipe_record_ptr += gLocal_buffer_size;
		386	if (gPipe_buffer_working_end < gPipe_record_ptr) {
		387	gPipe_buffer_working_end = gPipe_record_ptr;
		388	}
		389	}
		390	if (pMunge_reentrancy) {
		391	if (gReentrancy_count != 0) {
		392	gReentrancy_count--;
		393	if (gReentrancy_count != 0) {
		394	StartPipingSession2(gReentrancy_array[gReentrancy_count - 1], 0);
		395	}
		396	}
		397	}
		398	}
		399	}
		400
		401	// IDA: void __cdecl EndPipingSession()
		402	void EndPipingSession(void) {
		403	LOG_TRACE("()");
		404
		405	EndPipingSession2(1);
		406	}
		407
		408	// IDA: void __usercall AddDataToSession(int pSubject_index@<EAX>, void *pData@<EDX>, tU32 pData_length@<EBX>)
		409	void AddDataToSession(int pSubject_index, void* pData, tU32 pData_length) {
		410	tU32 temp_buffer_size;
		411	//int variable_for_breaking_on; // Pierre-Marie Baty -- unused variable
		412	LOG_TRACE("(%d, %p, %d)", pSubject_index, pData, pData_length);
		413
		414	if (gPipe_buffer_start != NULL && !gAction_replay_mode && gProgram_state.racing) {
		415	temp_buffer_size = gLocal_buffer_size + offsetof(tPipe_chunk, chunk_data) + pData_length;
		416	if (temp_buffer_size >= LOCAL_BUFFER_SIZE) {
		417	return;
		418	}
		419	REPLAY_DEBUG_ASSERT(((tPipe_session*)gLocal_buffer)->pipe_magic1 == REPLAY_DEBUG_SESSION_MAGIC1);
		420	((tPipe_session*)gLocal_buffer)->number_of_chunks++;
		421	gMr_chunky->subject_index = pSubject_index;
		422	#if defined(DETHRACE_REPLAY_DEBUG)
		423	gMr_chunky->chunk_magic1 = REPLAY_DEBUG_CHUNK_MAGIC1;
		424	#endif
		425	memcpy(&gMr_chunky->chunk_data, pData, pData_length);
		426	gMr_chunky = (tPipe_chunk)(((tU8)&gMr_chunky->chunk_data) + pData_length);
		427	gLocal_buffer_size = temp_buffer_size;
		428	}
		429	}
		430
		431	// IDA: void __usercall AddModelGeometryToPipingSession(tU16 pCar_ID@<EAX>, int pModel_index@<EDX>, int pVertex_count@<EBX>, tChanged_vertex *pCoordinates@<ECX>)
		432	void AddModelGeometryToPipingSession(tU16 pCar_ID, int pModel_index, int pVertex_count, tChanged_vertex* pCoordinates) {
		433	tU32 data_size;
		434	LOG_TRACE("(%d, %d, %d, %p)", pCar_ID, pModel_index, pVertex_count, pCoordinates);
		435
		436	if (gModel_geometry_space != NULL) {
		437	if (pVertex_count > 600) {
		438	pVertex_count = 600;
		439	}
		440	data_size = offsetof(tPipe_model_geometry_data, vertex_changes) + pVertex_count * sizeof(tChanged_vertex);
		441	gModel_geometry_space->vertex_count = pVertex_count;
		442	gModel_geometry_space->model_index = pModel_index;
		443	memcpy(gModel_geometry_space->vertex_changes, pCoordinates, pVertex_count * sizeof(tChanged_vertex));
		444	AddDataToSession(pCar_ID, gModel_geometry_space, data_size);
		445	}
		446	}
		447
		448	// IDA: void __usercall AddSmudgeToPipingSession(tU16 pCar_ID@<EAX>, int pModel_index@<EDX>, int pVertex_count@<EBX>, tSmudged_vertex *pCoordinates@<ECX>)
		449	void AddSmudgeToPipingSession(tU16 pCar_ID, int pModel_index, int pVertex_count, tSmudged_vertex* pCoordinates) {
		450	tU32 data_size;
		451	LOG_TRACE("(%d, %d, %d, %p)", pCar_ID, pModel_index, pVertex_count, pCoordinates);
		452
		453	if (gSmudge_space != NULL) {
		454	if (pVertex_count > 600) {
		455	pVertex_count = 600;
		456	}
		457	gSmudge_space->vertex_count = pVertex_count;
		458	gSmudge_space->model_index = pModel_index;
		459	memcpy(gSmudge_space->vertex_changes, pCoordinates, pVertex_count * sizeof(tSmudged_vertex));
		460	data_size = offsetof(tPipe_smudge_data, vertex_changes) + pVertex_count * sizeof(tSmudged_vertex);
		461	AddDataToSession(pCar_ID, gSmudge_space, data_size);
		462	}
		463	}
		464
		465	// IDA: void __usercall AddPedestrianToPipingSession(int pPedestrian_index@<EAX>, br_matrix34 pTrans@<EDX>, tU8 pAction_index@<EBX>, tU8 pFrame_index@<ECX>, tS8 pHit_points, int pDone_initial, tU16 pParent_ID, float pSpin_period, br_scalar pJump_magnitude, br_vector3 pOffset)
		466	void AddPedestrianToPipingSession(int pPedestrian_index, br_matrix34* pTrans, tU8 pAction_index, tU8 pFrame_index, tS8 pHit_points, int pDone_initial, tU16 pParent_ID, float pSpin_period, br_scalar pJump_magnitude, br_vector3* pOffset) {
		467	tPipe_pedestrian_data data;
		468	tU32 data_size;
		469	LOG_TRACE("(%d, %p, %d, %d, %d, %d, %d, %f, %f, %p)", pPedestrian_index, pTrans, pAction_index, pFrame_index, pHit_points, pDone_initial, pParent_ID, pSpin_period, pJump_magnitude, pOffset);
		470
		471	if (pFrame_index == 0xff) {
		472	pFrame_index = 0;
		473	}
		474	data.action_and_frame_index = (pDone_initial ? 1 : 0) << 7 \| pAction_index << 4 \| pFrame_index;
		475	data.hit_points = pHit_points;
		476	data.new_translation.v[0] = pTrans->m[3][0];
		477	data.new_translation.v[1] = pTrans->m[3][1];
		478	data.new_translation.v[2] = pTrans->m[3][2];
		479	data.parent = pParent_ID;
		480	if (pHit_points <= 0) {
		481	data.spin_period = pSpin_period;
		482	data.parent_actor = GetPedestrianActor(pPedestrian_index)->parent;
		483	BrVector3Copy(&data.offset, pOffset);
		484	data.jump_magnitude = pJump_magnitude;
		485	data_size = sizeof(tPipe_pedestrian_data);
		486	} else {
		487	data_size = offsetof(tPipe_pedestrian_data, spin_period);
		488	}
		489	AddDataToSession(pPedestrian_index, &data, data_size);
		490	}
		491
		492	// IDA: void __usercall AddSparkToPipingSession(int pSpark_index@<EAX>, br_vector3 pPos@<EDX>, br_vector3 pV@<EBX>)
		493	void AddSparkToPipingSession(int pSpark_index, br_vector3* pPos, br_vector3* pV) {
		494	tPipe_spark_data data;
		495	LOG_TRACE("(%d, %p, %p)", pSpark_index, pPos, pV);
		496
		497	BrVector3Copy(&data.pos, pPos);
		498	BrVector3Copy(&data.v, pV);
		499	AddDataToSession(pSpark_index, &data, sizeof(tPipe_spark_data));
		500	}
		501
		502	// IDA: void __usercall AddShrapnelToPipingSession(int pShrapnel_index@<EAX>, br_vector3 pPos@<EDX>, tU16 pAge@<EBX>, br_material pMaterial@<ECX>)
		503	void AddShrapnelToPipingSession(int pShrapnel_index, br_vector3* pPos, tU16 pAge, br_material* pMaterial) {
		504	tPipe_shrapnel_data data;
		505	tU32 data_size;
		506	LOG_TRACE("(%d, %p, %d, %p)", pShrapnel_index, pPos, pAge, pMaterial);
		507
		508	BrVector3Copy(&data.pos, pPos);
		509	if ((pShrapnel_index & 0x8000) != 0) {
		510	data.age = pAge;
		511	data.material = pMaterial;
		512	data_size = sizeof(tPipe_shrapnel_data);
		513	} else {
		514	data_size = offsetof(tPipe_shrapnel_data, age);
		515	}
		516	AddDataToSession(pShrapnel_index, &data, data_size);
		517	}
		518
		519	// IDA: void __usercall AddScreenWobbleToPipingSession(int pWobble_x@<EAX>, int pWobble_y@<EDX>)
		520	void AddScreenWobbleToPipingSession(int pWobble_x, int pWobble_y) {
		521	tPipe_screen_shake_data data;
		522	LOG_TRACE("(%d, %d)", pWobble_x, pWobble_y);
		523
		524	data.wobble_x = pWobble_x;
		525	data.wobble_y = pWobble_y;
		526	AddDataToSession(0, &data, sizeof(tPipe_screen_shake_data));
		527	}
		528
		529	// IDA: void __usercall AddGrooveStopToPipingSession(int pGroove_index@<EAX>, br_matrix34 *pMatrix@<EDX>, int pPath_interrupt@<EBX>, int pObject_interrupt@<ECX>, float pPath_resumption, float pObject_resumption)
		530	void AddGrooveStopToPipingSession(int pGroove_index, br_matrix34* pMatrix, int pPath_interrupt, int pObject_interrupt, float pPath_resumption, float pObject_resumption) {
		531	tPipe_groove_stop_data data;
		532	LOG_TRACE("(%d, %p, %d, %d, %f, %f)", pGroove_index, pMatrix, pPath_interrupt, pObject_interrupt, pPath_resumption, pObject_resumption);
		533
		534	BrMatrix34Copy(&data.matrix, pMatrix);
		535	data.path_interrupt = pPath_interrupt;
		536	data.object_interrupt = pObject_interrupt;
		537	data.path_resumption = pPath_resumption;
		538	data.object_resumption = pObject_resumption;
		539	AddDataToSession(pGroove_index, &data, sizeof(tPipe_groove_stop_data));
		540	}
		541
		542	// IDA: void __usercall AddNonCarToPipingSession(int pIndex@<EAX>, br_actor *pActor@<EDX>)
		543	void AddNonCarToPipingSession(int pIndex, br_actor* pActor) {
		544	tPipe_non_car_data data;
		545	LOG_TRACE("(%d, %p)", pIndex, pActor);
		546
		547	BrMatrix34Copy(&data.mat, &pActor->t.t.mat);
		548	data.actor = pActor;
		549	AddDataToSession(pIndex, &data, sizeof(tPipe_non_car_data));
		550	}
		551
		552	// IDA: void __usercall AddSmokeToPipingSession(int pIndex@<EAX>, tU8 pType@<EDX>, br_vector3 *pPos@<EBX>, br_scalar pRadius, br_scalar pStrength)
		553	void AddSmokeToPipingSession(int pIndex, tU8 pType, br_vector3* pPos, br_scalar pRadius, br_scalar pStrength) {
		554	tPipe_smoke_data data;
		555	LOG_TRACE("(%d, %d, %p, %f, %f)", pIndex, pType, pPos, pRadius, pStrength);
		556
		557	SaveReducedPos(&data.pos, pPos);
		558	data.type = pType;
		559	data.radius = pRadius * 1024.f;
		560	data.strength = pStrength * 255.f;
		561	AddDataToSession(pIndex, &data, sizeof(tPipe_smoke_data));
		562	}
		563
		564	// IDA: void __usercall AddSmokeColumnToPipingSession(int pIndex@<EAX>, tCar_spec *pCar@<EDX>, int pVertex@<EBX>, int pColour@<ECX>)
		565	void AddSmokeColumnToPipingSession(int pIndex, tCar_spec* pCar, int pVertex, int pColour) {
		566	tPipe_smoke_column_data data;
		567	LOG_TRACE("(%d, %p, %d, %d)", pIndex, pCar, pVertex, pColour);
		568
		569	data.car_ID = pCar->car_ID;
		570	data.vertex = pVertex;
		571	AddDataToSession(pColour << 14 \| pIndex, &data, sizeof(tPipe_smoke_column_data));
		572	}
		573
		574	// IDA: void __usercall AddFlameToPipingSession(int pIndex@<EAX>, int pFrame_count@<EDX>, br_scalar pScale_x, br_scalar pScale_y, br_scalar pOffset_x, br_scalar pOffset_z)
		575	void AddFlameToPipingSession(int pIndex, int pFrame_count, br_scalar pScale_x, br_scalar pScale_y, br_scalar pOffset_x, br_scalar pOffset_z) {
		576	tPipe_flame_data data;
		577	LOG_TRACE("(%d, %d, %f, %f, %f, %f)", pIndex, pFrame_count, pScale_x, pScale_y, pOffset_x, pOffset_z);
		578
		579	data.frame_count = pFrame_count;
		580	data.scale_x = pScale_x;
		581	data.scale_y = pScale_y;
		582	data.offset_x = pOffset_x;
		583	data.offset_z = pOffset_z;
		584	AddDataToSession(pIndex, &data, sizeof(tPipe_flame_data));
		585	}
		586
		587	// IDA: void __usercall AddSplashToPipingSession(tCollision_info *pCar@<EAX>)
		588	void AddSplashToPipingSession(tCollision_info* pCar) {
		589	tPipe_splash_data data;
		590	LOG_TRACE("(%p)", pCar);
		591
		592	if (pCar->driver >= eDriver_oppo) {
		593	data.d = pCar->water_d;
		594	BrVector3Copy(&data.normal, &pCar->water_normal);
		595	AddDataToSession(pCar->car_ID, &data, sizeof(tPipe_splash_data));
		596	}
		597	}
		598
		599	// IDA: void __usercall AddOilSpillToPipingSession(int pIndex@<EAX>, br_matrix34 pMat@<EDX>, br_scalar pFull_size, br_scalar pGrow_rate, tU32 pSpill_time, tU32 pStop_time, tCar_spec pCar, br_vector3 pOriginal_pos, br_pixelmap pPixelmap)
		600	void AddOilSpillToPipingSession(int pIndex, br_matrix34* pMat, br_scalar pFull_size, br_scalar pGrow_rate, tU32 pSpill_time, tU32 pStop_time, tCar_spec* pCar, br_vector3* pOriginal_pos, br_pixelmap* pPixelmap) {
		601	tPipe_oil_spill_data data;
		602	LOG_TRACE("(%d, %p, %f, %f, %d, %d, %p, %p, %p)", pIndex, pMat, pFull_size, pGrow_rate, pSpill_time, pStop_time, pCar, pOriginal_pos, pPixelmap);
		603
		604	BrMatrix34Copy(&data.mat, pMat);
		605	data.full_size = pFull_size;
		606	data.grow_rate = pGrow_rate;
		607	data.spill_time = pSpill_time;
		608	data.previous_stop_time = pStop_time;
		609	data.car = pCar;
		610	BrVector3Copy(&data.original_pos, pOriginal_pos);
		611	data.pixelmap = pPixelmap;
		612	AddDataToSession(pIndex, &data, sizeof(tPipe_oil_spill_data));
		613	}
		614
		615	// IDA: void __usercall AddFrameFinishToPipingSession(tU32 pThe_time@<EAX>)
		616	void AddFrameFinishToPipingSession(tU32 pThe_time) {
		617	tPipe_frame_boundary_data data;
		618	LOG_TRACE("(%d)", pThe_time);
		619
		620	data.time = pThe_time;
		621	AddDataToSession(0, &data, sizeof(tPipe_frame_boundary_data));
		622	}
		623
		624	// IDA: void __usercall AddCarToPipingSession(int pCar_ID@<EAX>, br_matrix34 pCar_mat@<EDX>, br_vector3 pCar_velocity@<EBX>, float pSpeedo_speed, float pLf_sus_position, float pRf_sus_position, float pLr_sus_position, float pRr_sus_position, float pSteering_angle, br_scalar pRevs, int pGear, int pFrame_coll_flag)
		625	void AddCarToPipingSession(int pCar_ID, br_matrix34* pCar_mat, br_vector3* pCar_velocity, float pSpeedo_speed, float pLf_sus_position, float pRf_sus_position, float pLr_sus_position, float pRr_sus_position, float pSteering_angle, br_scalar pRevs, int pGear, int pFrame_coll_flag) {
		626	tPipe_car_data data;
		627	LOG_TRACE("(%d, %p, %p, %f, %f, %f, %f, %f, %f, %f, %d, %d)", pCar_ID, pCar_mat, pCar_velocity, pSpeedo_speed, pLf_sus_position, pRf_sus_position, pLr_sus_position, pRr_sus_position, pSteering_angle, pRevs, pGear, pFrame_coll_flag);
		628
		629	BrMatrix34Copy(&data.transformation, pCar_mat);
		630	BrVector3Copy(&data.velocity, pCar_velocity);
		631	data.speedo_speed = pSpeedo_speed * 32767.f / 0.07f;
		632	data.lf_sus_position = pLf_sus_position * 127.f / .15f;
		633	data.rf_sus_position = pRf_sus_position * 127.f / .15f;
		634	data.lr_sus_position = pLr_sus_position * 127.f / .15f;
		635	data.rr_sus_position = pRr_sus_position * 127.f / .15f;
		636	data.steering_angle = pSteering_angle * 32767.f / 60.f;
		637	data.revs_and_gear = (pGear + 1) << 12 \| (pFrame_coll_flag ? 0 : 1) << 11 \| ((((int)pRevs) / 10) & 0x7ff);
		638	AddDataToSession(pCar_ID, &data, sizeof(tPipe_car_data));
		639	}
		640
		641	// IDA: void __usercall AddSoundToPipingSession(tS3_outlet_ptr pOutlet@<EAX>, int pSound_index@<EDX>, tS3_volume pL_volume@<EBX>, tS3_volume pR_volume@<ECX>, tS3_pitch pPitch, br_vector3 *pPos)
		642	void AddSoundToPipingSession(tS3_outlet_ptr pOutlet, int pSound_index, tS3_volume pL_volume, tS3_volume pR_volume, tS3_pitch pPitch, br_vector3* pPos) {
		643	tPipe_sound_data data;
		644	LOG_TRACE("(%d, %d, %d, %d, %d, %p)", pOutlet, pSound_index, pL_volume, pR_volume, pPitch, pPos);
		645
		646	data.pitch = pPitch;
		647	if (pPos == NULL) {
		648	BrVector3Set(&data.position, 0.f, 0.f, 0.f);
		649	} else {
		650	BrVector3Copy(&data.position, pPos);
		651	}
		652	data.volume = (pR_volume << 8) \| (pL_volume << 0);
		653	data.outlet_index = GetIndexFromOutlet(pOutlet);
		654	AddDataToSession(pSound_index, &data, sizeof(tPipe_sound_data));
		655	}
		656
		657	// IDA: void __usercall AddDamageToPipingSession(int pCar_ID@<EAX>, tS8 *pDifferences@<EDX>)
		658	void AddDamageToPipingSession(int pCar_ID, tS8* pDifferences) {
		659	tPipe_damage_data data;
		660	int i;
		661	LOG_TRACE("(%d, %p)", pCar_ID, pDifferences);
		662
		663	for (i = 0; i < COUNT_OF(data.damage_delta); i++) {
		664	data.damage_delta[i] = pDifferences[i];
		665	}
		666	AddDataToSession(pCar_ID, &data, sizeof(tPipe_damage_data));
		667	}
		668
		669	// IDA: void __usercall AddSpecialToPipingSession(tSpecial_type pType@<EAX>)
		670	void AddSpecialToPipingSession(tSpecial_type pType) {
		671	tPipe_special_data data;
		672	LOG_TRACE("(%d)", pType);
		673
		674	AddDataToSession(pType, &data, sizeof(tPipe_special_data));
		675	}
		676
		677	// IDA: void __usercall AddPedGibToPipingSession(int pIndex@<EAX>, br_matrix34 *pTrans@<EDX>, int pSize@<EBX>, int pGib_index@<ECX>, int pPed_index)
		678	void AddPedGibToPipingSession(int pIndex, br_matrix34* pTrans, int pSize, int pGib_index, int pPed_index) {
		679	tPipe_ped_gib_data data;
		680	LOG_TRACE("(%d, %p, %d, %d, %d)", pIndex, pTrans, pSize, pGib_index, pPed_index);
		681
		682	data.ped_parent_index = pPed_index;
		683	data.size = pSize;
		684	data.gib_index = pGib_index;
		685	BrMatrix34Copy(&data.transform, pTrans);
		686	AddDataToSession(pIndex, &data, sizeof(tPipe_ped_gib_data));
		687	}
		688
		689	// IDA: void __cdecl AddCarIncidentToPipingSession(float pSeverity, tCar_spec pCar, br_vector3 pImpact_point)
		690	void AddCarIncidentToPipingSession(float pSeverity, tCar_spec* pCar, br_vector3* pImpact_point) {
		691	tPipe_incident_data data;
		692	LOG_TRACE("(%f, %p, %p)", pSeverity, pCar, pImpact_point);
		693
		694	data.severity = pSeverity;
		695	data.info.car_info.car_ID = pCar->car_ID;
		696	BrVector3Copy(&data.info.car_info.impact_point, pImpact_point);
		697	AddDataToSession(1, &data, sizeof(tPipe_incident_data));
		698	}
		699
		700	// IDA: void __usercall AddPedIncidentToPipingSession(int pPed_index@<EAX>, br_actor *pActor@<EDX>)
		701	void AddPedIncidentToPipingSession(int pPed_index, br_actor* pActor) {
		702	tPipe_incident_data data;
		703	LOG_TRACE("(%d, %p)", pPed_index, pActor);
		704
		705	data.severity = 0.f;
		706	data.info.ped_info.ped_index = pPed_index;
		707	data.info.ped_info.actor = pActor;
		708	AddDataToSession(0, &data, sizeof(tPipe_incident_data));
		709	}
		710
		711	// IDA: void __cdecl AddWallIncidentToPipingSession(float pSeverity, br_vector3 *pImpact_point)
		712	void AddWallIncidentToPipingSession(float pSeverity, br_vector3* pImpact_point) {
		713	tPipe_incident_data data;
		714	LOG_TRACE("(%f, %p)", pSeverity, pImpact_point);
		715
		716	data.severity = pSeverity;
		717	BrVector3Copy(&data.info.wall_info.pos, pImpact_point);
		718	AddDataToSession(2, &data, sizeof(tPipe_incident_data));
		719	}
		720
		721	// IDA: void __usercall AddProxRayToPipingSession(int pRay_index@<EAX>, tCar_spec *pCar@<EDX>, tU16 pPed_index@<EBX>, tU32 pTime@<ECX>)
		722	void AddProxRayToPipingSession(int pRay_index, tCar_spec* pCar, tU16 pPed_index, tU32 pTime) {
		723	tPipe_prox_ray_data data;
		724	LOG_TRACE("(%d, %p, %d, %d)", pRay_index, pCar, pPed_index, pTime);
		725
		726	data.ped_index = pPed_index;
		727	data.car_ID = pCar->car_ID;
		728	data.time = pTime;
		729	AddDataToSession(pRay_index, &data, sizeof(tPipe_prox_ray_data));
		730	}
		731
		732	// IDA: void __usercall AddSkidAdjustmentToPipingSession(int pSkid_num@<EAX>, br_matrix34 *pMatrix@<EDX>, int pMaterial_index@<EBX>)
		733	void AddSkidAdjustmentToPipingSession(int pSkid_num, br_matrix34* pMatrix, int pMaterial_index) {
		734	tPipe_skid_adjustment adjustment;
		735	LOG_TRACE("(%d, %p, %d)", pSkid_num, pMatrix, pMaterial_index);
		736
		737	BrMatrix34Copy(&adjustment.matrix, pMatrix);
		738	adjustment.material_index = pMaterial_index;
		739	AddDataToSession(pSkid_num, &adjustment, sizeof(tPipe_skid_adjustment));
		740	}
		741
		742	// IDA: void __usercall PipeSingleModelGeometry(tU16 pCar_ID@<EAX>, int pModel_index@<EDX>, int pVertex_count@<EBX>, tChanged_vertex *pCoordinates@<ECX>)
		743	void PipeSingleModelGeometry(tU16 pCar_ID, int pModel_index, int pVertex_count, tChanged_vertex* pCoordinates) {
		744	LOG_TRACE("(%d, %d, %d, %p)", pCar_ID, pModel_index, pVertex_count, pCoordinates);
		745
		746	StartPipingSession(ePipe_chunk_model_geometry);
		747	AddModelGeometryToPipingSession(pCar_ID, pModel_index, pVertex_count, pCoordinates);
		748	EndPipingSession();
		749	}
		750
		751	// IDA: void __usercall PipeSinglePedestrian(int pPedestrian_index@<EAX>, br_matrix34 pTrans@<EDX>, tU8 pAction_index@<EBX>, tU8 pFrame_index@<ECX>, tS8 pHit_points, int pDone_initial, tU16 pParent_ID, float pSpin_period, br_scalar pJump_magnitude, br_vector3 pOffset)
		752	void PipeSinglePedestrian(int pPedestrian_index, br_matrix34* pTrans, tU8 pAction_index, tU8 pFrame_index, tS8 pHit_points, int pDone_initial, tU16 pParent_ID, float pSpin_period, br_scalar pJump_magnitude, br_vector3* pOffset) {
		753	LOG_TRACE("(%d, %p, %d, %d, %d, %d, %d, %f, %f, %p)", pPedestrian_index, pTrans, pAction_index, pFrame_index, pHit_points, pDone_initial, pParent_ID, pSpin_period, pJump_magnitude, pOffset);
		754
		755	StartPipingSession(ePipe_chunk_pedestrian);
		756	AddPedestrianToPipingSession(pPedestrian_index, pTrans, pAction_index,
		757	pFrame_index, pHit_points, pDone_initial, pParent_ID, pSpin_period,
		758	pJump_magnitude, pOffset);
		759	EndPipingSession();
		760	}
		761
		762	// IDA: void __usercall PipeSingleCar(int pCar_ID@<EAX>, br_matrix34 pCar_mat@<EDX>, br_vector3 pCar_velocity@<EBX>, float pSpeedo_speed, float pLf_sus_position, float pRf_sus_position, float pLr_sus_position, float pRr_sus_position, float pSteering_angle, br_scalar pRevs, int pGear, int pFrame_coll_flag)
		763	void PipeSingleCar(int pCar_ID, br_matrix34* pCar_mat, br_vector3* pCar_velocity, float pSpeedo_speed, float pLf_sus_position, float pRf_sus_position, float pLr_sus_position, float pRr_sus_position, float pSteering_angle, br_scalar pRevs, int pGear, int pFrame_coll_flag) {
		764	LOG_TRACE("(%d, %p, %p, %f, %f, %f, %f, %f, %f, %f, %d, %d)", pCar_ID, pCar_mat, pCar_velocity, pSpeedo_speed, pLf_sus_position, pRf_sus_position, pLr_sus_position, pRr_sus_position, pSteering_angle, pRevs, pGear, pFrame_coll_flag);
		765
		766	StartPipingSession(ePipe_chunk_car);
		767	AddCarToPipingSession(pCar_ID, pCar_mat, pCar_velocity, pSpeedo_speed,
		768	pLf_sus_position, pRf_sus_position, pLr_sus_position, pRr_sus_position,
		769	pSteering_angle, pRevs, pGear, pFrame_coll_flag);
		770	EndPipingSession();
		771	}
		772
		773	// IDA: void __usercall PipeSingleSound(tS3_outlet_ptr pOutlet@<EAX>, int pSound_index@<EDX>, tS3_volume pL_volume@<EBX>, tS3_volume pR_volume@<ECX>, tS3_pitch pPitch, br_vector3 *pPos)
		774	void PipeSingleSound(tS3_outlet_ptr pOutlet, int pSound_index, tS3_volume pL_volume, tS3_volume pR_volume, tS3_pitch pPitch, br_vector3* pPos) {
		775	LOG_TRACE("(%d, %d, %d, %d, %d, %p)", pOutlet, pSound_index, pL_volume, pR_volume, pPitch, pPos);
		776
		777	if (!gAction_replay_mode && gProgram_state.racing) {
		778	StartPipingSession(ePipe_chunk_sound);
		779	AddSoundToPipingSession(pOutlet, pSound_index, pL_volume, pR_volume, pPitch, pPos);
		780	EndPipingSession();
		781	}
		782	}
		783
		784	// IDA: void __usercall PipeSingleOilSpill(int pIndex@<EAX>, br_matrix34 pMat@<EDX>, br_scalar pFull_size, br_scalar pGrow_rate, tU32 pSpill_time, tU32 pStop_time, tCar_spec pCar, br_vector3 pOriginal_pos, br_pixelmap pPixelmap)
		785	void PipeSingleOilSpill(int pIndex, br_matrix34* pMat, br_scalar pFull_size, br_scalar pGrow_rate, tU32 pSpill_time, tU32 pStop_time, tCar_spec* pCar, br_vector3* pOriginal_pos, br_pixelmap* pPixelmap) {
		786	LOG_TRACE("(%d, %p, %f, %f, %d, %d, %p, %p, %p)", pIndex, pMat, pFull_size, pGrow_rate, pSpill_time, pStop_time, pCar, pOriginal_pos, pPixelmap);
		787
		788	StartPipingSession(ePipe_chunk_oil_spill);
		789	AddOilSpillToPipingSession(pIndex, pMat, pFull_size, pGrow_rate,
		790	pSpill_time, pStop_time, pCar, pOriginal_pos, pPixelmap);
		791	EndPipingSession();
		792	}
		793
		794	// IDA: void __usercall PipeSingleDamage(int pCar_ID@<EAX>, tS8 *pDifferences@<EDX>)
		795	void PipeSingleDamage(int pCar_ID, tS8* pDifferences) {
		796	LOG_TRACE("(%d, %p)", pCar_ID, pDifferences);
		797
		798	StartPipingSession(ePipe_chunk_damage);
		799	AddDamageToPipingSession(pCar_ID, pDifferences);
		800	EndPipingSession();
		801	}
		802
		803	// IDA: void __usercall PipeSingleSpecial(tSpecial_type pType@<EAX>)
		804	void PipeSingleSpecial(tSpecial_type pType) {
		805	LOG_TRACE("(%d)", pType);
		806
		807	StartPipingSession(ePipe_chunk_special);
		808	AddSpecialToPipingSession(pType);
		809	EndPipingSession();
		810	}
		811
		812	// IDA: void __usercall PipeSinglePedGib(int pIndex@<EAX>, br_matrix34 *pTrans@<EDX>, int pSize@<EBX>, int pGib_index@<ECX>, int pPed_index)
		813	void PipeSinglePedGib(int pIndex, br_matrix34* pTrans, int pSize, int pGib_index, int pPed_index) {
		814	LOG_TRACE("(%d, %p, %d, %d, %d)", pIndex, pTrans, pSize, pGib_index, pPed_index);
		815
		816	StartPipingSession(ePipe_chunk_ped_gib);
		817	AddPedGibToPipingSession(pIndex, pTrans, pSize, pGib_index, pPed_index);
		818	EndPipingSession();
		819	}
		820
		821	// IDA: void __cdecl PipeSingleCarIncident(float pSeverity, tCar_spec pCar, br_vector3 pImpact_point)
		822	void PipeSingleCarIncident(float pSeverity, tCar_spec* pCar, br_vector3* pImpact_point) {
		823	LOG_TRACE("(%f, %p, %p)", pSeverity, pCar, pImpact_point);
		824
		825	StartPipingSession(ePipe_chunk_incident);
		826	AddCarIncidentToPipingSession(pSeverity, pCar, pImpact_point);
		827	EndPipingSession();
		828	}
		829
		830	// IDA: void __usercall PipeSinglePedIncident(int pPed_index@<EAX>, br_actor *pActor@<EDX>)
		831	void PipeSinglePedIncident(int pPed_index, br_actor* pActor) {
		832	LOG_TRACE("(%d, %p)", pPed_index, pActor);
		833
		834	StartPipingSession(ePipe_chunk_incident);
		835	AddPedIncidentToPipingSession(pPed_index, pActor);
		836	EndPipingSession();
		837	gWall_severity = 0.f;
		838	}
		839
		840	// IDA: void __cdecl PipeSingleWallIncident(float pSeverity, br_vector3 *pImpact_point)
		841	void PipeSingleWallIncident(float pSeverity, br_vector3* pImpact_point) {
		842	LOG_TRACE("(%f, %p)", pSeverity, pImpact_point);
		843
		844	if (pSeverity > gWall_severity) {
		845	gWall_severity = pSeverity;
		846	BrVector3Copy(&gWall_impact_point, pImpact_point);
		847	}
		848	}
		849
		850	// IDA: void __usercall PipeSingleScreenShake(int pWobble_x@<EAX>, int pWobble_y@<EDX>)
		851	void PipeSingleScreenShake(int pWobble_x, int pWobble_y) {
		852	LOG_TRACE("(%d, %d)", pWobble_x, pWobble_y);
		853
		854	StartPipingSession(ePipe_chunk_screen_shake);
		855	AddScreenWobbleToPipingSession(pWobble_x, pWobble_y);
		856	EndPipingSession();
		857	}
		858
		859	// IDA: void __usercall PipeSingleGrooveStop(int pGroove_index@<EAX>, br_matrix34 *pMatrix@<EDX>, int pPath_interrupt@<EBX>, int pObject_interrupt@<ECX>, float pPath_resumption, float pObject_resumption)
		860	void PipeSingleGrooveStop(int pGroove_index, br_matrix34* pMatrix, int pPath_interrupt, int pObject_interrupt, float pPath_resumption, float pObject_resumption) {
		861	LOG_TRACE("(%d, %p, %d, %d, %f, %f)", pGroove_index, pMatrix, pPath_interrupt, pObject_interrupt, pPath_resumption, pObject_resumption);
		862
		863	StartPipingSession(ePipe_chunk_groove_stop);
		864	AddGrooveStopToPipingSession(pGroove_index, pMatrix, pPath_interrupt,
		865	pObject_interrupt, pPath_resumption, pObject_resumption);
		866	EndPipingSession();
		867	}
		868
		869	// IDA: void __cdecl PipeFrameFinish()
		870	void PipeFrameFinish(void) {
		871	LOG_TRACE("()");
		872
		873	if (gWall_severity != 0.f) {
		874	StartPipingSession(ePipe_chunk_incident);
		875	AddWallIncidentToPipingSession(gWall_severity, &gWall_impact_point);
		876	EndPipingSession();
		877	gWall_severity = 0.f;
		878	}
		879	StartPipingSession(ePipe_chunk_frame_boundary);
		880	AddFrameFinishToPipingSession(GetTotalTime());
		881	EndPipingSession();
		882	}
		883
		884	// IDA: void __cdecl PipingFrameReset()
		885	void PipingFrameReset(void) {
		886	int i;
		887	LOG_TRACE("()");
		888
		889	for (i = 0; i < COUNT_OF(gReset_procs); i++) {
		890	if (gReset_procs[i] != NULL) {
		891	gReset_procs[i]();
		892	}
		893	}
		894	}
		895
		896	// IDA: void __usercall PipeSingleSkidAdjustment(int pSkid_num@<EAX>, br_matrix34 *pMatrix@<EDX>, int pMaterial_index@<EBX>)
		897	void PipeSingleSkidAdjustment(int pSkid_num, br_matrix34* pMatrix, int pMaterial_index) {
		898	LOG_TRACE("(%d, %p, %d)", pSkid_num, pMatrix, pMaterial_index);
		899
		900	StartPipingSession(ePipe_chunk_skid_adjustment);
		901	AddSkidAdjustmentToPipingSession(pSkid_num, pMatrix, pMaterial_index);
		902	EndPipingSession();
		903	}
		904
		905	// IDA: void __cdecl ResetPiping()
		906	void ResetPiping(void) {
		907	LOG_TRACE("()");
		908
		909	gWall_severity = 0.f;
		910	gPipe_buffer_oldest = NULL;
		911	gPipe_record_ptr = gPipe_buffer_start;
		912	gPipe_buffer_working_end = gPipe_buffer_phys_end;
		913	gReentrancy_count = 0;
		914	}
		915
		916	// IDA: void __cdecl InitialisePiping()
		917	void InitialisePiping(void) {
		918	LOG_TRACE("()");
		919
		920	if (!gAusterity_mode && gNet_mode == eNet_mode_none) {
		921	PDAllocateActionReplayBuffer((char**)&gPipe_buffer_start, &gPipe_buffer_size);
		922	gPipe_buffer_phys_end = gPipe_buffer_start + gPipe_buffer_size;
		923	gSmudge_space = BrMemAllocate(offsetof(tPipe_smudge_data, vertex_changes) + sizeof(tSmudged_vertex) * 2400, kMem_pipe_model_geometry);
		924	// DAT_00532008 = 0;
		925	BrVector3SetFloat(&gZero_vector, 0.f, 0.f, 0.f);
		926	gModel_geometry_space = (tPipe_model_geometry_data*)gSmudge_space;
		927	gLocal_buffer = BrMemAllocate(LOCAL_BUFFER_SIZE, kMem_pipe_model_geometry);
		928	} else {
		929	gPipe_buffer_start = NULL;
		930	gLocal_buffer = NULL;
		931	gModel_geometry_space = NULL;
		932	gSmudge_space = NULL;
		933	}
		934	ResetPiping();
		935	}
		936
		937	// IDA: void __cdecl DisposePiping()
		938	void DisposePiping(void) {
		939	LOG_TRACE("()");
		940
		941	if (gPipe_buffer_start != NULL) {
		942	PDDisposeActionReplayBuffer((char*)gPipe_buffer_start);
		943	}
		944	gPipe_buffer_start = NULL;
		945	if (gModel_geometry_space != NULL) {
		946	BrMemFree(gModel_geometry_space);
		947	gModel_geometry_space = NULL;
		948	}
		949	if (gLocal_buffer != NULL) {
		950	BrMemFree(gLocal_buffer);
		951	gLocal_buffer = NULL;
		952	}
		953	}
		954
		955	// IDA: void __cdecl InitLastDamageArrayEtc()
		956	void InitLastDamageArrayEtc(void) {
		957	int i;
		958	int j;
		959	int cat;
		960	int car_count;
		961	tCar_spec* car;
		962	LOG_TRACE("()");
		963
		964	for (cat = eVehicle_self; cat <= eVehicle_not_really; cat++) {
		965	if (cat == eVehicle_self) {
		966	car_count = 1;
		967	} else {
		968	car_count = GetCarCount(cat);
		969	}
		970	for (i = 0; i < car_count; i++) {
		971	if (cat == eVehicle_self) {
		972	car = &gProgram_state.current_car;
		973	} else {
		974	car = GetCarSpec(cat, i);
		975	}
		976	if (cat != eVehicle_not_really) {
		977	for (j = 0; j < COUNT_OF(car->frame_start_damage); j++) {
		978	car->frame_start_damage[j] = 0;
		979	}
		980	}
		981	car->car_ID = (cat << 8) \| i;
		982	}
		983	}
		984	}
		985
		986	// IDA: void __cdecl ResetCars()
		987	void ResetCars(void) {
		988	tCar_spec* car;
		989	int cat;
		990	int i;
		991	int car_count;
		992	LOG_TRACE("()");
		993
		994	for (cat = eVehicle_self; cat < eVehicle_not_really; cat++) {
		995	if (cat == eVehicle_self) {
		996	car_count = 1;
		997	} else {
		998	car_count = GetCarCount(cat);
		999	}
		1000	for (i = 0; i < car_count; i++) {
		1001	if (cat == eVehicle_self) {
		1002	car = &gProgram_state.current_car;
		1003	} else {
		1004	car = GetCarSpec(cat, i);
		1005	}
		1006	car->active = 0;
		1007	}
		1008	}
		1009	}
		1010
		1011	// IDA: void __cdecl PipeCarPositions()
		1012	void PipeCarPositions(void) {
		1013	tCar_spec* car;
		1014	int cat;
		1015	int i;
		1016	int j;
		1017	int car_count;
		1018	int session_started;
		1019	int difference_found;
		1020	tS8 damage_deltas[12];
		1021	LOG_TRACE("()");
		1022
		1023	StartPipingSession(ePipe_chunk_car);
		1024	for (cat = eVehicle_self; cat < eVehicle_not_really; cat++) {
		1025	if (cat == eVehicle_self) {
		1026	car_count = 1;
		1027	} else {
		1028	car_count = GetCarCount(cat);
		1029	}
		1030	for (i = 0; i < car_count; i++) {
		1031	if (cat == eVehicle_self) {
		1032	car = &gProgram_state.current_car;
		1033	} else {
		1034	car = GetCarSpec(cat, i);
		1035	}
		1036	AddCarToPipingSession((cat << 8) \| i,
		1037	&car->car_master_actor->t.t.mat, &car->v, car->speedo_speed,
		1038	car->lf_sus_position, car->rf_sus_position, car->lr_sus_position, car->rr_sus_position,
		1039	car->steering_angle, car->revs, car->gear, car->frame_collision_flag);
		1040	}
		1041	}
		1042	EndPipingSession();
		1043	session_started = 0;
		1044	for (cat = eVehicle_self; cat < eVehicle_net_player; cat++) {
		1045	if (cat == eVehicle_self) {
		1046	car_count = 1;
		1047	} else {
		1048	car_count = GetCarCount(cat);
		1049	}
		1050	for (i = 0; i < car_count; i++) {
		1051	if (cat == eVehicle_self) {
		1052	car = &gProgram_state.current_car;
		1053	} else {
		1054	car = GetCarSpec(cat, i);
		1055	}
		1056	if (car->active) {
		1057	difference_found = 0;
		1058	for (j = 0; j < COUNT_OF(car->damage_units); j++) {
		1059	damage_deltas[j] = car->damage_units[j].damage_level - car->frame_start_damage[j];
		1060	difference_found \|= damage_deltas[j];
		1061	car->frame_start_damage[j] = car->damage_units[j].damage_level;
		1062	}
		1063	if (difference_found) {
		1064	if (!session_started) {
		1065	StartPipingSession(ePipe_chunk_damage);
		1066	session_started = 1;
		1067	}
		1068	AddDamageToPipingSession((cat << 8) \| i, damage_deltas);
		1069	}
		1070	}
		1071	}
		1072	}
		1073	if (session_started) {
		1074	EndPipingSession();
		1075	}
		1076	}
		1077
		1078	// IDA: void __cdecl ResetPipePlayToEnd()
		1079	void ResetPipePlayToEnd(void) {
		1080	LOG_TRACE("()");
		1081
		1082	gPipe_play_ptr = gPipe_record_ptr;
		1083	}
		1084
		1085	// IDA: void __cdecl ResetPipePlayToStart()
		1086	void ResetPipePlayToStart(void) {
		1087	LOG_TRACE("()");
		1088
		1089	gPipe_play_ptr = gPipe_buffer_oldest;
		1090	}
		1091
		1092	// IDA: tU8* __cdecl GetPipePlayPtr()
		1093	tU8* GetPipePlayPtr(void) {
		1094	LOG_TRACE("()");
		1095
		1096	return gPipe_play_ptr;
		1097	}
		1098
		1099	// IDA: void __usercall SetPipePlayPtr(tU8 *pPtr@<EAX>)
		1100	void SetPipePlayPtr(tU8* pPtr) {
		1101	LOG_TRACE("(%p)", pPtr);
		1102
		1103	gPipe_play_ptr = pPtr;
		1104	}
		1105
		1106	// IDA: void __usercall AdvanceChunkPtr(tPipe_chunk **pChunk@<EAX>, tChunk_subject_index pType@<EDX>)
		1107	void AdvanceChunkPtr(tPipe_chunk** pChunk, tChunk_subject_index pType) {
		1108	tPipe_chunk* old_chunk;
		1109	LOG_TRACE("(%p, %d)", pChunk, pType);
		1110
		1111	old_chunk = *pChunk;
		1112	if (gDisable_advance) {
		1113	return;
		1114	}
		1115	switch (pType) {
		1116	case ePipe_chunk_model_geometry:
		1117	(tU8)pChunk += offsetof(tPipe_model_geometry_data, vertex_changes) + (pChunk)->chunk_data.model_geometry_data.vertex_count * sizeof(tChanged_vertex);
		1118	break;
		1119	case ePipe_chunk_pedestrian:
		1120	(tU8)pChunk += (((pChunk)->chunk_data.pedestrian_data.hit_points <= 0) ? sizeof(tPipe_pedestrian_data) : offsetof(tPipe_pedestrian_data, spin_period));
		1121	break;
		1122	case ePipe_chunk_frame_boundary:
		1123	(tU8*)pChunk += sizeof(tPipe_frame_boundary_data);
		1124	break;
		1125	case ePipe_chunk_car:
		1126	(tU8*)pChunk += sizeof(tPipe_car_data);
		1127	break;
		1128	case ePipe_chunk_sound:
		1129	(tU8*)pChunk += sizeof(tPipe_sound_data);
		1130	break;
		1131	case ePipe_chunk_damage:
		1132	(tU8*)pChunk += sizeof(tPipe_damage_data);
		1133	break;
		1134	case ePipe_chunk_special:
		1135	(tU8*)pChunk += sizeof(tPipe_special_data);
		1136	break;
		1137	case ePipe_chunk_ped_gib:
		1138	(tU8*)pChunk += sizeof(tPipe_ped_gib_data);
		1139	break;
		1140	case ePipe_chunk_incident:
		1141	(tU8*)pChunk += sizeof(tPipe_incident_data);
		1142	break;
		1143	case ePipe_chunk_spark:
		1144	(tU8*)pChunk += sizeof(tPipe_spark_data);
		1145	break;
		1146	case ePipe_chunk_shrapnel:
		1147	(tU8)pChunk += (((pChunk)->subject_index & 0x8000) ? sizeof(tPipe_shrapnel_data) : offsetof(tPipe_shrapnel_data, age));
		1148	break;
		1149	case ePipe_chunk_screen_shake:
		1150	(tU8*)pChunk += sizeof(tPipe_screen_shake_data);
		1151	break;
		1152	case ePipe_chunk_groove_stop:
		1153	(tU8*)pChunk += sizeof(tPipe_groove_stop_data);
		1154	break;
		1155	case ePipe_chunk_non_car:
		1156	(tU8*)pChunk += sizeof(tPipe_non_car_data);
		1157	break;
		1158	case ePipe_chunk_smoke:
		1159	(tU8*)pChunk += sizeof(tPipe_smoke_data);
		1160	break;
		1161	case ePipe_chunk_oil_spill:
		1162	(tU8*)pChunk += sizeof(tPipe_oil_spill_data);
		1163	break;
		1164	case ePipe_chunk_smoke_column:
		1165	(tU8*)pChunk += sizeof(tPipe_smoke_column_data);
		1166	break;
		1167	case ePipe_chunk_flame:
		1168	(tU8*)pChunk += sizeof(tPipe_flame_data);
		1169	break;
		1170	case ePipe_chunk_smudge:
		1171	(tU8)pChunk += offsetof(tPipe_smudge_data, vertex_changes) + (pChunk)->chunk_data.smudge_data.vertex_count * sizeof(tSmudged_vertex);
		1172	break;
		1173	case ePipe_chunk_splash:
		1174	(tU8*)pChunk += sizeof(tPipe_splash_data);
		1175	break;
		1176	case ePipe_chunk_prox_ray:
		1177	(tU8*)pChunk += sizeof(tPipe_prox_ray_data);
		1178	break;
		1179	case ePipe_chunk_skid_adjustment:
		1180	(tU8*)pChunk += sizeof(tPipe_skid_adjustment);
		1181	break;
		1182	}
		1183	(tU8*)pChunk += offsetof(tPipe_chunk, chunk_data);
		1184
		1185	/* Fail-safe to avoid reading junk data from the session after */
		1186	if ((tU8*)pChunk == gEnd_of_session) {
		1187	*pChunk = old_chunk;
		1188	} else if ((tU8*)pChunk > gEnd_of_session) {
		1189	*pChunk = old_chunk;
		1190	}
		1191	}
		1192
		1193	// IDA: void __usercall ApplyModelGeometry(tPipe_chunk **pChunk@<EAX>)
		1194	void ApplyModelGeometry(tPipe_chunk** pChunk) {
		1195	int i;
		1196	br_model* model_ptr;
		1197	tCar_spec* car;
		1198	LOG_TRACE("(%p)", pChunk);
		1199
		1200	if (((*pChunk)->subject_index & 0xff00) == 0) {
		1201	car = &gProgram_state.current_car;
		1202	} else {
		1203	car = GetCarSpec((pChunk)->subject_index >> 8, (pChunk)->subject_index & 0xff);
		1204	}
		1205	model_ptr = car->car_model_actors[(*pChunk)->chunk_data.model_geometry_data.model_index].actor->model;
		1206	for (i = 0; i < (*pChunk)->chunk_data.model_geometry_data.vertex_count; i++) {
		1207	BrVector3Accumulate(&model_ptr->vertices[(*pChunk)->chunk_data.model_geometry_data.vertex_changes[i].vertex_index].p,
		1208	&(*pChunk)->chunk_data.model_geometry_data.vertex_changes[i].delta_coordinates);
		1209	}
		1210	SetModelForUpdate(model_ptr, car, 0);
		1211	AdvanceChunkPtr(pChunk, ePipe_chunk_model_geometry);
		1212	}
		1213
		1214	// IDA: void __usercall DoSmudge(tPipe_chunk **pChunk@<EAX>, int pDir@<EDX>)
		1215	void DoSmudge(tPipe_chunk** pChunk, int pDir) {
		1216	int i;
		1217	int v;
		1218	tU8 inc;
		1219	br_model* model_ptr;
		1220	tCar_spec* car;
		1221	//int group; // Pierre-Marie Baty -- unused variable
		1222	LOG_TRACE("(%p, %d)", pChunk, pDir);
		1223
		1224	if (((*pChunk)->subject_index & 0xff00) == 0) {
		1225	car = &gProgram_state.current_car;
		1226	} else {
		1227	car = GetCarSpec((pChunk)->subject_index >> 8, (pChunk)->subject_index & 0xff);
		1228	}
		1229	model_ptr = car->car_model_actors[(*pChunk)->chunk_data.smudge_data.model_index].actor->model;
		1230	for (i = 0; i < (*pChunk)->chunk_data.smudge_data.vertex_count; i++) {
		1231	v = (*pChunk)->chunk_data.smudge_data.vertex_changes[i].vertex_index;
		1232	inc = (pChunk)->chunk_data.smudge_data.vertex_changes[i].light_index pDir;
		1233	V11MODEL(model_ptr)->groups->vertex_colours[v] = ((V11MODEL(model_ptr)->groups->vertex_colours[v] >> 24) + inc) << 24;
		1234	if (model_ptr->flags & BR_MODF_UPDATEABLE) {
		1235	model_ptr->vertices[V11MODEL(model_ptr)->groups->vertex_user[v]].index = (V11MODEL(model_ptr)->groups->vertex_colours[v] >> 24) + inc;
		1236	}
		1237	}
		1238	}
		1239
		1240	// IDA: void __usercall ApplySmudge(tPipe_chunk **pChunk@<EAX>)
		1241	void ApplySmudge(tPipe_chunk** pChunk) {
		1242	LOG_TRACE("(%p)", pChunk);
		1243
		1244	DoSmudge(pChunk, 1);
		1245	AdvanceChunkPtr(pChunk, ePipe_chunk_smudge);
		1246	}
		1247
		1248	// IDA: void __usercall ApplyPedestrian(tPipe_chunk **pChunk@<EAX>)
		1249	void ApplyPedestrian(tPipe_chunk** pChunk) {
		1250	LOG_TRACE("(%p)", pChunk);
		1251
		1252	AdjustPedestrian(
		1253	(*pChunk)->subject_index,
		1254	((*pChunk)->chunk_data.pedestrian_data.action_and_frame_index & 0x70) >> 4,
		1255	(*pChunk)->chunk_data.pedestrian_data.action_and_frame_index & 0x0f,
		1256	(*pChunk)->chunk_data.pedestrian_data.hit_points,
		1257	(*pChunk)->chunk_data.pedestrian_data.action_and_frame_index >> 7,
		1258	(*pChunk)->chunk_data.pedestrian_data.parent,
		1259	(*pChunk)->chunk_data.pedestrian_data.parent_actor,
		1260	(*pChunk)->chunk_data.pedestrian_data.spin_period,
		1261	(*pChunk)->chunk_data.pedestrian_data.jump_magnitude,
		1262	&(*pChunk)->chunk_data.pedestrian_data.offset,
		1263	&(*pChunk)->chunk_data.pedestrian_data.new_translation);
		1264	AdvanceChunkPtr(pChunk, ePipe_chunk_pedestrian);
		1265	}
		1266
		1267	// IDA: void __usercall ApplySpark(tPipe_chunk **pChunk@<EAX>)
		1268	void ApplySpark(tPipe_chunk** pChunk) {
		1269	LOG_TRACE("(%p)", pChunk);
		1270
		1271	AdjustSpark((*pChunk)->subject_index,
		1272	&(*pChunk)->chunk_data.spark_data.pos,
		1273	&(*pChunk)->chunk_data.spark_data.v);
		1274	AdvanceChunkPtr(pChunk, ePipe_chunk_spark);
		1275	}
		1276
		1277	// IDA: void __usercall ApplyShrapnel(tPipe_chunk **pChunk@<EAX>)
		1278	void ApplyShrapnel(tPipe_chunk** pChunk) {
		1279	LOG_TRACE("(%p)", pChunk);
		1280
		1281	AdjustShrapnel((*pChunk)->subject_index,
		1282	&(*pChunk)->chunk_data.shrapnel_data.pos,
		1283	(*pChunk)->chunk_data.shrapnel_data.age,
		1284	(*pChunk)->chunk_data.shrapnel_data.material);
		1285	AdvanceChunkPtr(pChunk, ePipe_chunk_shrapnel);
		1286	}
		1287
		1288	// IDA: void __usercall ApplyScreenWobble(tPipe_chunk **pChunk@<EAX>)
		1289	void ApplyScreenWobble(tPipe_chunk** pChunk) {
		1290	LOG_TRACE("(%p)", pChunk);
		1291
		1292	SetScreenWobble((*pChunk)->chunk_data.screen_shake_data.wobble_x,
		1293	(*pChunk)->chunk_data.screen_shake_data.wobble_y);
		1294	AdvanceChunkPtr(pChunk, ePipe_chunk_screen_shake);
		1295	}
		1296
		1297	// IDA: void __usercall ApplyGrooveStop(tPipe_chunk **pChunk@<EAX>)
		1298	void ApplyGrooveStop(tPipe_chunk** pChunk) {
		1299	LOG_TRACE("(%p)", pChunk);
		1300
		1301	SetGrooveInterrupt((*pChunk)->subject_index,
		1302	&(*pChunk)->chunk_data.groove_stop_data.matrix,
		1303	(*pChunk)->chunk_data.groove_stop_data.path_interrupt,
		1304	(*pChunk)->chunk_data.groove_stop_data.object_interrupt,
		1305	(*pChunk)->chunk_data.groove_stop_data.path_resumption,
		1306	(*pChunk)->chunk_data.groove_stop_data.object_resumption);
		1307	AdvanceChunkPtr(pChunk, ePipe_chunk_groove_stop);
		1308	}
		1309
		1310	// IDA: void __usercall ApplyNonCar(tPipe_chunk **pChunk@<EAX>)
		1311	void ApplyNonCar(tPipe_chunk** pChunk) {
		1312	LOG_TRACE("(%p)", pChunk);
		1313
		1314	AdjustNonCar((*pChunk)->chunk_data.non_car_data.actor,
		1315	&(*pChunk)->chunk_data.non_car_data.mat);
		1316	AdvanceChunkPtr(pChunk, ePipe_chunk_non_car);
		1317	}
		1318
		1319	// IDA: void __usercall ApplySmoke(tPipe_chunk **pChunk@<EAX>)
		1320	void ApplySmoke(tPipe_chunk** pChunk) {
		1321	br_vector3 pos;
		1322	LOG_TRACE("(%p)", pChunk);
		1323
		1324	GetReducedPos(&pos, &(*pChunk)->chunk_data.smoke_data.pos);
		1325	AdjustSmoke((*pChunk)->subject_index,
		1326	(*pChunk)->chunk_data.smoke_data.type,
		1327	&pos,
		1328	(*pChunk)->chunk_data.smoke_data.radius / 1024.f,
		1329	(*pChunk)->chunk_data.smoke_data.strength / 256.f);
		1330	AdvanceChunkPtr(pChunk, ePipe_chunk_smoke);
		1331	}
		1332
		1333	// IDA: void __usercall ApplySmokeColumn(tPipe_chunk **pChunk@<EAX>)
		1334	void ApplySmokeColumn(tPipe_chunk** pChunk) {
		1335	LOG_TRACE("(%p)", pChunk);
		1336
		1337	AdjustSmokeColumn((*pChunk)->subject_index & 0x3fff,
		1338	((((pChunk)->chunk_data.smoke_column_data.car_ID) >> 8) == 0) ? &gProgram_state.current_car : GetCarSpec((pChunk)->chunk_data.smoke_column_data.car_ID >> 8, (*pChunk)->chunk_data.smoke_column_data.car_ID & 0xff),
		1339	(*pChunk)->chunk_data.smoke_column_data.vertex,
		1340	(*pChunk)->subject_index >> 14);
		1341	AdvanceChunkPtr(pChunk, ePipe_chunk_smoke_column);
		1342	}
		1343
		1344	// IDA: void __usercall ApplyFlame(tPipe_chunk **pChunk@<EAX>)
		1345	void ApplyFlame(tPipe_chunk** pChunk) {
		1346	LOG_TRACE("(%p)", pChunk);
		1347
		1348	AdjustFlame((*pChunk)->subject_index,
		1349	(*pChunk)->chunk_data.flame_data.frame_count,
		1350	(*pChunk)->chunk_data.flame_data.scale_x,
		1351	(*pChunk)->chunk_data.flame_data.scale_y,
		1352	(*pChunk)->chunk_data.flame_data.offset_x,
		1353	#if DETHRACE_FIX_BUGS
		1354	(*pChunk)->chunk_data.flame_data.offset_z);
		1355	#else
		1356	(*pChunk)->chunk_data.flame_data.offset_x);
		1357	#endif
		1358	AdvanceChunkPtr(pChunk, ePipe_chunk_flame);
		1359	}
		1360
		1361	// IDA: void __usercall ApplySplash(tPipe_chunk **pChunk@<EAX>)
		1362	void ApplySplash(tPipe_chunk** pChunk) {
		1363	tCar_spec* c;
		1364	LOG_TRACE("(%p)", pChunk);
		1365
		1366	if (((*pChunk)->subject_index & 0xff00) == 0) {
		1367	c = &gProgram_state.current_car;
		1368	} else {
		1369	c = GetCarSpec((pChunk)->subject_index >> 8, (pChunk)->subject_index & 0xff);
		1370	}
		1371	c->water_d = (*pChunk)->chunk_data.splash_data.d;
		1372	BrVector3Copy(&c->water_normal, &(*pChunk)->chunk_data.splash_data.normal);
		1373	AdvanceChunkPtr(pChunk, ePipe_chunk_splash);
		1374	}
		1375
		1376	// IDA: void __usercall ApplyOilSpill(tPipe_chunk **pChunk@<EAX>, tU32 pStop_time@<EDX>)
		1377	void ApplyOilSpill(tPipe_chunk** pChunk, tU32 pStop_time) {
		1378	LOG_TRACE("(%p, %d)", pChunk, pStop_time);
		1379
		1380	AdjustOilSpill((*pChunk)->subject_index,
		1381	&(*pChunk)->chunk_data.oil_data.mat,
		1382	(*pChunk)->chunk_data.oil_data.full_size,
		1383	(*pChunk)->chunk_data.oil_data.grow_rate,
		1384	(*pChunk)->chunk_data.oil_data.spill_time,
		1385	pStop_time,
		1386	(*pChunk)->chunk_data.oil_data.car,
		1387	&(*pChunk)->chunk_data.oil_data.original_pos,
		1388	(*pChunk)->chunk_data.oil_data.pixelmap);
		1389	AdvanceChunkPtr(pChunk, ePipe_chunk_oil_spill);
		1390	}
		1391
		1392	// IDA: void __usercall ApplyFrameBoundary(tPipe_chunk **pChunk@<EAX>)
		1393	void ApplyFrameBoundary(tPipe_chunk** pChunk) {
		1394	//tU32 result; // Pierre-Marie Baty -- unused variable
		1395	LOG_TRACE("(%p)", pChunk);
		1396
		1397	gLast_replay_frame_time = (*pChunk)->chunk_data.frame_boundary_data.time;
		1398	// DAT_0054b244 = PDGetTotalTime();
		1399	AdvanceChunkPtr(pChunk, ePipe_chunk_frame_boundary);
		1400	}
		1401
		1402	// IDA: void __usercall ApplySound(tPipe_chunk **pChunk@<EAX>)
		1403	void ApplySound(tPipe_chunk** pChunk) {
		1404	LOG_TRACE("(%p)", pChunk);
		1405
		1406	if (!gDisable_sound) {
		1407	if ((*pChunk)->chunk_data.sound_data.volume == 0) {
		1408	DRS3StartSound2(GetOutletFromIndex((*pChunk)->chunk_data.sound_data.outlet_index),
		1409	(*pChunk)->subject_index,
		1410	1,
		1411	-1,
		1412	-1,
		1413	65535.f * GetReplayRate(),
		1414	0x10000);
		1415	} else if (BrVector3LengthSquared(&(*pChunk)->chunk_data.sound_data.position) == 0) {
		1416	DRS3StartSound2(GetOutletFromIndex((*pChunk)->chunk_data.sound_data.outlet_index),
		1417	(*pChunk)->subject_index,
		1418	1,
		1419	(*pChunk)->chunk_data.sound_data.volume & 0xff,
		1420	(*pChunk)->chunk_data.sound_data.volume >> 8,
		1421	(float)(pChunk)->chunk_data.sound_data.pitch fabsf(GetReplayRate()),
		1422	0x10000);
		1423	} else {
		1424	DRS3StartSound3D(GetOutletFromIndex((*pChunk)->chunk_data.sound_data.outlet_index),
		1425	(*pChunk)->subject_index,
		1426	&(*pChunk)->chunk_data.sound_data.position,
		1427	&gZero_vector,
		1428	1,
		1429	(*pChunk)->chunk_data.sound_data.volume,
		1430	(float)(pChunk)->chunk_data.sound_data.pitch fabsf(GetReplayRate()),
		1431	0x10000);
		1432	}
		1433	}
		1434	AdvanceChunkPtr(pChunk, ePipe_chunk_sound);
		1435	}
		1436
		1437	// IDA: void __usercall ApplyCar(tPipe_chunk **pChunk@<EAX>)
		1438	void ApplyCar(tPipe_chunk** pChunk) {
		1439	tCar_spec* car;
		1440	br_vector3 com_offset_c;
		1441	br_vector3 com_offset_w;
		1442	LOG_TRACE("(%p)", pChunk);
		1443
		1444	if (((*pChunk)->subject_index & 0xff00) == 0) {
		1445	car = &gProgram_state.current_car;
		1446	} else {
		1447	car = GetCarSpec((pChunk)->subject_index >> 8, (pChunk)->subject_index & 0x00ff);
		1448	}
		1449	BrMatrix34Copy(&car->car_master_actor->t.t.mat, &(*pChunk)->chunk_data.car_data.transformation);
		1450	BrVector3Copy(&car->v, &(*pChunk)->chunk_data.car_data.velocity);
		1451	BrMatrix34TApplyV(&car->velocity_car_space, &car->v, &car->car_master_actor->t.t.mat);
		1452	BrVector3InvScale(&car->velocity_car_space, &car->velocity_car_space, WORLD_SCALE);
		1453	if (BrVector3LengthSquared(&car->velocity_car_space) >= .0001f) {
		1454	BrVector3Normalise(&car->direction, &car->v);
		1455	} else {
		1456	BrVector3Negate(&car->direction, (br_vector3*)car->car_master_actor->t.t.mat.m[2]);
		1457	}
		1458	BrVector3Copy(&car->pos, &car->car_master_actor->t.t.translate.t);
		1459	BrVector3InvScale(&com_offset_c, &car->cmpos, WORLD_SCALE);
		1460	BrMatrix34ApplyV(&com_offset_w, &com_offset_c, &car->car_master_actor->t.t.mat);
		1461	BrVector3Accumulate(&car->pos, &com_offset_w);
		1462	car->speedo_speed = .07f * (*pChunk)->chunk_data.car_data.speedo_speed / 32767.f;
		1463	car->lf_sus_position = 0.15f * (*pChunk)->chunk_data.car_data.lf_sus_position / 127.f;
		1464	car->rf_sus_position = 0.15f * (*pChunk)->chunk_data.car_data.rf_sus_position / 127.f;
		1465	car->lr_sus_position = 0.15f * (*pChunk)->chunk_data.car_data.lr_sus_position / 127.f;
		1466	car->rr_sus_position = 0.15f * (*pChunk)->chunk_data.car_data.rr_sus_position / 127.f;
		1467	car->steering_angle = 60.f * (*pChunk)->chunk_data.car_data.steering_angle / 32767.f;
		1468	car->revs = 10 * ((*pChunk)->chunk_data.car_data.revs_and_gear & 0x7ff);
		1469	car->gear = ((*pChunk)->chunk_data.car_data.revs_and_gear >> 12) - 1;
		1470	car->frame_collision_flag = ((*pChunk)->chunk_data.car_data.revs_and_gear >> 11) & 0x1;
		1471	AdvanceChunkPtr(pChunk, ePipe_chunk_car);
		1472	}
		1473
		1474	// IDA: void __usercall ApplyDamage(tPipe_chunk **pChunk@<EAX>)
		1475	void ApplyDamage(tPipe_chunk** pChunk) {
		1476	tCar_spec* car;
		1477	int i;
		1478	LOG_TRACE("(%p)", pChunk);
		1479
		1480	if (((*pChunk)->subject_index & 0xff00) == 0) {
		1481	car = &gProgram_state.current_car;
		1482	} else {
		1483	car = GetCarSpec((pChunk)->subject_index >> 8, (pChunk)->subject_index & 0x00ff);
		1484	}
		1485	for (i = 0; i < COUNT_OF(car->damage_units); i++) {
		1486	car->damage_units[i].damage_level += (*pChunk)->chunk_data.damage_data.damage_delta[i];
		1487	}
		1488	AdvanceChunkPtr(pChunk, ePipe_chunk_damage);
		1489	}
		1490
		1491	// IDA: void __usercall ApplySpecial(tPipe_chunk **pChunk@<EAX>)
		1492	void ApplySpecial(tPipe_chunk** pChunk) {
		1493	LOG_TRACE("(%p)", pChunk);
		1494
		1495	switch ((*pChunk)->subject_index) {
		1496	case 0:
		1497	if (fabsf(GetReplayRate()) <= 1.f) {
		1498	FadePaletteDown();
		1499	}
		1500	break;
		1501	case 1:
		1502	gPed_scale_factor = 2.0f;
		1503	break;
		1504	case 2:
		1505	gPed_scale_factor = 1.0f;
		1506	break;
		1507	case 3:
		1508	gPed_scale_factor = 0.5f;
		1509	break;
		1510	case 4:
		1511	gPed_scale_factor = 1.0f;
		1512	break;
		1513	}
		1514	AdvanceChunkPtr(pChunk, ePipe_chunk_special);
		1515	}
		1516
		1517	// IDA: void __usercall ApplyPedGib(tPipe_chunk **pChunk@<EAX>)
		1518	void ApplyPedGib(tPipe_chunk** pChunk) {
		1519	LOG_TRACE("(%p)", pChunk);
		1520
		1521	AdjustPedGib((*pChunk)->subject_index,
		1522	(*pChunk)->chunk_data.ped_gib_data.size,
		1523	(*pChunk)->chunk_data.ped_gib_data.gib_index,
		1524	(*pChunk)->chunk_data.ped_gib_data.ped_parent_index,
		1525	&(*pChunk)->chunk_data.ped_gib_data.transform);
		1526	AdvanceChunkPtr(pChunk, ePipe_chunk_ped_gib);
		1527	}
		1528
		1529	// IDA: void __usercall ApplyProxRay(tPipe_chunk **pChunk@<EAX>)
		1530	void ApplyProxRay(tPipe_chunk** pChunk) {
		1531	LOG_TRACE("(%p)", pChunk);
		1532
		1533	AdjustProxRay(
		1534	(*pChunk)->subject_index,
		1535	(*pChunk)->chunk_data.prox_ray_data.car_ID,
		1536	(*pChunk)->chunk_data.prox_ray_data.ped_index,
		1537	(*pChunk)->chunk_data.prox_ray_data.time);
		1538	AdvanceChunkPtr(pChunk, ePipe_chunk_prox_ray);
		1539	}
		1540
		1541	// IDA: void __usercall ApplySkidAdjustment(tPipe_chunk **pChunk@<EAX>)
		1542	void ApplySkidAdjustment(tPipe_chunk** pChunk) {
		1543	LOG_TRACE("(%p)", pChunk);
		1544
		1545	AdjustSkid((*pChunk)->subject_index,
		1546	&(*pChunk)->chunk_data.skid_adjustment.matrix,
		1547	(*pChunk)->chunk_data.skid_adjustment.material_index);
		1548	AdvanceChunkPtr(pChunk, ePipe_chunk_skid_adjustment);
		1549	}
		1550
		1551	// IDA: int __usercall ApplyPipedSession@<EAX>(tU8 **pPtr@<EAX>)
		1552	int ApplyPipedSession(tU8** pPtr) {
		1553	int i;
		1554	int return_value;
		1555	tPipe_chunk* chunk_ptr;
		1556	tPipe_chunk_type chunk_type;
		1557	LOG_TRACE("(%p)", pPtr);
		1558
		1559	if (*pPtr == gPipe_record_ptr) {
		1560	return 1;
		1561	}
		1562	gEnd_of_session = pPtr + (LengthOfSession((tPipe_session)*pPtr) - sizeof(tU16));
		1563	REPLAY_DEBUG_ASSERT(((tPipe_session)pPtr)->pipe_magic1 == REPLAY_DEBUG_SESSION_MAGIC1);
		1564	chunk_ptr = (tPipe_chunk)(pPtr + offsetof(tPipe_session, chunks));
		1565	return_value = 0;
		1566	chunk_type = ((tPipe_session)pPtr)->chunk_type;
		1567	for (i = 0; i < ((tPipe_session)pPtr)->number_of_chunks; i++) {
		1568	switch (chunk_type) {
		1569	case ePipe_chunk_model_geometry:
		1570	ApplyModelGeometry(&chunk_ptr);
		1571	break;
		1572	case ePipe_chunk_pedestrian:
		1573	ApplyPedestrian(&chunk_ptr);
		1574	break;
		1575	case ePipe_chunk_frame_boundary:
		1576	ApplyFrameBoundary(&chunk_ptr);
		1577	return_value = 1;
		1578	break;
		1579	case ePipe_chunk_car:
		1580	ApplyCar(&chunk_ptr);
		1581	break;
		1582	case ePipe_chunk_sound:
		1583	ApplySound(&chunk_ptr);
		1584	break;
		1585	case ePipe_chunk_damage:
		1586	ApplyDamage(&chunk_ptr);
		1587	break;
		1588	case ePipe_chunk_special:
		1589	ApplySpecial(&chunk_ptr);
		1590	break;
		1591	case ePipe_chunk_ped_gib:
		1592	ApplyPedGib(&chunk_ptr);
		1593	break;
		1594	case ePipe_chunk_incident:
		1595	AdvanceChunkPtr(&chunk_ptr, ePipe_chunk_incident);
		1596	break;
		1597	case ePipe_chunk_spark:
		1598	ApplySpark(&chunk_ptr);
		1599	break;
		1600	case ePipe_chunk_shrapnel:
		1601	ApplyShrapnel(&chunk_ptr);
		1602	break;
		1603	case ePipe_chunk_screen_shake:
		1604	ApplyScreenWobble(&chunk_ptr);
		1605	break;
		1606	case ePipe_chunk_groove_stop:
		1607	ApplyGrooveStop(&chunk_ptr);
		1608	break;
		1609	case ePipe_chunk_non_car:
		1610	ApplyNonCar(&chunk_ptr);
		1611	break;
		1612	case ePipe_chunk_smoke:
		1613	ApplySmoke(&chunk_ptr);
		1614	break;
		1615	case ePipe_chunk_oil_spill:
		1616	ApplyOilSpill(&chunk_ptr, 0);
		1617	break;
		1618	case ePipe_chunk_smoke_column:
		1619	ApplySmokeColumn(&chunk_ptr);
		1620	break;
		1621	case ePipe_chunk_flame:
		1622	ApplyFlame(&chunk_ptr);
		1623	break;
		1624	case ePipe_chunk_smudge:
		1625	ApplySmudge(&chunk_ptr);
		1626	break;
		1627	case ePipe_chunk_splash:
		1628	ApplySplash(&chunk_ptr);
		1629	break;
		1630	case ePipe_chunk_prox_ray:
		1631	ApplyProxRay(&chunk_ptr);
		1632	break;
		1633	case ePipe_chunk_skid_adjustment:
		1634	ApplySkidAdjustment(&chunk_ptr);
		1635	break;
		1636	default:
		1637	break;
		1638	}
		1639	}
		1640	#if defined(DETHRACE_FIX_BUGS)
		1641	pPtr += PIPE_ALIGN(LengthOfSession((tPipe_session)*pPtr));
		1642	#else
		1643	pPtr += LengthOfSession((tPipe_session)*pPtr);
		1644	#endif
		1645	if (pPtr >= gPipe_buffer_working_end && pPtr != gPipe_record_ptr) {
		1646	*pPtr = gPipe_buffer_start;
		1647	}
		1648	return return_value;
		1649	}
		1650
		1651	// IDA: int __usercall MoveSessionPointerBackOne@<EAX>(tU8 **pPtr@<EAX>)
		1652	int MoveSessionPointerBackOne(tU8** pPtr) {
		1653	LOG_TRACE("(%p)", pPtr);
		1654
		1655	if (pPtr == gPipe_buffer_oldest && pPtr != gPipe_record_ptr) {
		1656	return 1;
		1657	}
		1658	if (*pPtr == gPipe_buffer_start) {
		1659	*pPtr = gPipe_buffer_working_end;
		1660	}
		1661	*pPtr -= sizeof(tU16);
		1662	REPLAY_DEBUG_ASSERT((tU16)*pPtr != 0);
		1663	pPtr -= (tU16)pPtr;
		1664	REPLAY_DEBUG_ASSERT(((tPipe_session)pPtr)->pipe_magic1 == REPLAY_DEBUG_SESSION_MAGIC1);
		1665	return 0;
		1666	}
		1667
		1668	// IDA: int __usercall MoveSessionPointerForwardOne@<EAX>(tU8 **pPtr@<EAX>)
		1669	int MoveSessionPointerForwardOne(tU8** pPtr) {
		1670	LOG_TRACE("(%p)", pPtr);
		1671
		1672	REPLAY_DEBUG_ASSERT(((tPipe_session)pPtr)->pipe_magic1 == REPLAY_DEBUG_SESSION_MAGIC1);
		1673	#if defined(DETHRACE_FIX_BUGS)
		1674	pPtr += PIPE_ALIGN(LengthOfSession((tPipe_session)*pPtr));
		1675	#else
		1676	pPtr += LengthOfSession((tPipe_session)*pPtr);
		1677	#endif
		1678	if (pPtr >= gPipe_buffer_working_end && pPtr != gPipe_record_ptr) {
		1679	*pPtr = gPipe_buffer_start;
		1680	}
		1681	return *pPtr == gPipe_record_ptr;
		1682	}
		1683
		1684	// IDA: tPipe_chunk* __usercall FindPreviousChunk@<EAX>(tU8 *pPtr@<EAX>, tPipe_chunk_type pType@<EDX>, tChunk_subject_index pIndex@<EBX>)
		1685	tPipe_chunk* FindPreviousChunk(tU8* pPtr, tPipe_chunk_type pType, tChunk_subject_index pIndex) {
		1686	tU8* ptr;
		1687	int i;
		1688	int reached_end;
		1689	int chunk_counter;
		1690	tPipe_chunk* mr_chunky;
		1691	tChunk_subject_index masked_index;
		1692	LOG_TRACE("(%p, %d, %d)", pPtr, pType, pIndex);
		1693
		1694	ptr = pPtr;
		1695	chunk_counter = 0;
		1696	masked_index = pIndex & 0x0fff;
		1697	while (1) {
		1698	if (!MoveSessionPointerBackOne(&ptr)) {
		1699	reached_end = chunk_counter >= gMax_rewind_chunks;
		1700	chunk_counter++;
		1701	} else {
		1702	reached_end = 1;
		1703	}
		1704	if (!reached_end) {
		1705	gEnd_of_session = ptr + LengthOfSession((tPipe_session*)ptr) - sizeof(tU16);
		1706	mr_chunky = &((tPipe_session*)ptr)->chunks;
		1707	for (i = 0; i < ((tPipe_session)ptr)->number_of_chunks && ((tPipe_session)ptr)->chunk_type == pType; i++) {
		1708	if ((mr_chunky->subject_index & 0xfff) == masked_index) {
		1709	return mr_chunky;
		1710	}
		1711	AdvanceChunkPtr(&mr_chunky, pType);
		1712	}
		1713	}
		1714	if (reached_end) {
		1715	return NULL;
		1716	}
		1717	}
		1718	}
		1719
		1720	// IDA: void __usercall UndoModelGeometry(tPipe_chunk **pChunk@<EAX>)
		1721	void UndoModelGeometry(tPipe_chunk** pChunk) {
		1722	int i;
		1723	br_model* model_ptr;
		1724	tCar_spec* car;
		1725	LOG_TRACE("(%p)", pChunk);
		1726
		1727	if (((*pChunk)->subject_index & 0xff00) == 0) {
		1728	car = &gProgram_state.current_car;
		1729	} else {
		1730	car = GetCarSpec((pChunk)->subject_index >> 8, (pChunk)->subject_index & 0x00ff);
		1731	}
		1732	model_ptr = car->car_model_actors[(*pChunk)->chunk_data.model_geometry_data.model_index].actor->model;
		1733	for (i = 0; i < (*pChunk)->chunk_data.model_geometry_data.vertex_count; i++) {
		1734	BrVector3Sub(&model_ptr->vertices[(*pChunk)->chunk_data.model_geometry_data.vertex_changes[i].vertex_index].p,
		1735	&model_ptr->vertices[(*pChunk)->chunk_data.model_geometry_data.vertex_changes[i].vertex_index].p,
		1736	&(*pChunk)->chunk_data.model_geometry_data.vertex_changes[i].delta_coordinates);
		1737	}
		1738	SetModelForUpdate(model_ptr, car, 0);
		1739	AdvanceChunkPtr(pChunk, ePipe_chunk_model_geometry);
		1740	}
		1741
		1742	// IDA: void __usercall UndoSmudge(tPipe_chunk **pChunk@<EAX>)
		1743	void UndoSmudge(tPipe_chunk** pChunk) {
		1744	//int i; // Pierre-Marie Baty -- unused variable
		1745	//br_model* model_ptr; // Pierre-Marie Baty -- unused variable
		1746	//tCar_spec* car; // Pierre-Marie Baty -- unused variable
		1747	LOG_TRACE("(%p)", pChunk);
		1748
		1749	DoSmudge(pChunk, -1);
		1750	AdvanceChunkPtr(pChunk, ePipe_chunk_smudge);
		1751	}
		1752
		1753	// IDA: void __usercall UndoPedestrian(tPipe_chunk *pChunk@<EAX>, tPipe_chunk pPrev_chunk@<EDX>)
		1754	void UndoPedestrian(tPipe_chunk** pChunk, tPipe_chunk* pPrev_chunk) {
		1755	tPipe_chunk* temp_prev_chunk;
		1756	LOG_TRACE("(%p, %p)", pChunk, pPrev_chunk);
		1757
		1758	temp_prev_chunk = pPrev_chunk;
		1759	if (pPrev_chunk == NULL) {
		1760	ApplyPedestrian(pChunk);
		1761	} else {
		1762	gDisable_advance = 1;
		1763	ApplyPedestrian(&temp_prev_chunk);
		1764	gDisable_advance = 0;
		1765	AdvanceChunkPtr(pChunk, ePipe_chunk_pedestrian);
		1766	}
		1767	}
		1768
		1769	// IDA: void __usercall UndoFrameBoundary(tPipe_chunk *pChunk@<EAX>, tPipe_chunk pPrev_chunk@<EDX>)
		1770	void UndoFrameBoundary(tPipe_chunk** pChunk, tPipe_chunk* pPrev_chunk) {
		1771	//tPipe_chunk* temp_prev_chunk; // Pierre-Marie Baty -- unused variable
		1772	LOG_TRACE("(%p, %p)", pChunk, pPrev_chunk);
		1773
		1774	ApplyFrameBoundary(pChunk);
		1775	AdvanceChunkPtr(pChunk, ePipe_chunk_frame_boundary);
		1776	}
		1777
		1778	// IDA: void __usercall UndoCar(tPipe_chunk *pChunk@<EAX>, tPipe_chunk pPrev_chunk@<EDX>)
		1779	void UndoCar(tPipe_chunk** pChunk, tPipe_chunk* pPrev_chunk) {
		1780	tPipe_chunk* temp_prev_chunk;
		1781	LOG_TRACE("(%p, %p)", pChunk, pPrev_chunk);
		1782
		1783	temp_prev_chunk = pPrev_chunk;
		1784	if (pPrev_chunk == NULL) {
		1785	ApplyCar(pChunk);
		1786	} else {
		1787	gDisable_advance = 1;
		1788	ApplyCar(&temp_prev_chunk);
		1789	gDisable_advance = 0;
		1790	AdvanceChunkPtr(pChunk, ePipe_chunk_car);
		1791	}
		1792	}
		1793
		1794	// IDA: void __usercall UndoSound(tPipe_chunk **pChunk@<EAX>)
		1795	void UndoSound(tPipe_chunk** pChunk) {
		1796	LOG_TRACE("(%p)", pChunk);
		1797
		1798	AdvanceChunkPtr(pChunk, ePipe_chunk_sound);
		1799	}
		1800
		1801	// IDA: void __usercall UndoDamage(tPipe_chunk **pChunk@<EAX>)
		1802	void UndoDamage(tPipe_chunk** pChunk) {
		1803	tCar_spec* car;
		1804	int i;
		1805	LOG_TRACE("(%p)", pChunk);
		1806
		1807	if (((*pChunk)->subject_index & 0xff00) == 0) {
		1808	car = &gProgram_state.current_car;
		1809	} else {
		1810	car = GetCarSpec((pChunk)->subject_index >> 8, (pChunk)->subject_index & 0xff);
		1811	}
		1812	for (i = 0; i < COUNT_OF(car->damage_units); i++) {
		1813	car->damage_units[i].damage_level -= (*pChunk)->chunk_data.damage_data.damage_delta[i];
		1814	}
		1815	AdvanceChunkPtr(pChunk, ePipe_chunk_damage);
		1816	}
		1817
		1818	// IDA: void __usercall UndoSpecial(tPipe_chunk **pChunk@<EAX>)
		1819	void UndoSpecial(tPipe_chunk** pChunk) {
		1820	LOG_TRACE("(%p)", pChunk);
		1821
		1822	if ((*pChunk)->subject_index == 0) {
		1823	ApplySpecial(pChunk);
		1824	} else {
		1825	switch ((*pChunk)->subject_index) {
		1826	case 1:
		1827	gPed_scale_factor = 1.0f;
		1828	break;
		1829	case 2:
		1830	gPed_scale_factor = 2.0f;
		1831	break;
		1832	case 3:
		1833	gPed_scale_factor = 1.0f;
		1834	break;
		1835	case 4:
		1836	gPed_scale_factor = 0.5f;
		1837	break;
		1838	}
		1839	AdvanceChunkPtr(pChunk, ePipe_chunk_special);
		1840	}
		1841	}
		1842
		1843	// IDA: void __usercall UndoPedGib(tPipe_chunk *pChunk@<EAX>, tPipe_chunk pPrev_chunk@<EDX>)
		1844	void UndoPedGib(tPipe_chunk** pChunk, tPipe_chunk* pPrev_chunk) {
		1845	tPipe_chunk* temp_prev_chunk;
		1846	LOG_TRACE("(%p, %p)", pChunk, pPrev_chunk);
		1847
		1848	temp_prev_chunk = pPrev_chunk;
		1849	gDisable_advance = 1;
		1850	if (pPrev_chunk != NULL) {
		1851	ApplyPedGib(&temp_prev_chunk);
		1852	}
		1853	gDisable_advance = 0;
		1854	AdvanceChunkPtr(pChunk, ePipe_chunk_ped_gib);
		1855	}
		1856
		1857	// IDA: void __usercall UndoSpark(tPipe_chunk *pChunk@<EAX>, tPipe_chunk pPrev_chunk@<EDX>)
		1858	void UndoSpark(tPipe_chunk** pChunk, tPipe_chunk* pPrev_chunk) {
		1859	tPipe_chunk* temp_prev_chunk;
		1860	LOG_TRACE("(%p, %p)", pChunk, pPrev_chunk);
		1861
		1862	temp_prev_chunk = pPrev_chunk;
		1863	gDisable_advance = 1;
		1864	if (pPrev_chunk != NULL) {
		1865	ApplySpark(&temp_prev_chunk);
		1866	}
		1867	gDisable_advance = 0;
		1868	AdvanceChunkPtr(pChunk, ePipe_chunk_spark);
		1869	}
		1870
		1871	// IDA: void __usercall UndoShrapnel(tPipe_chunk *pChunk@<EAX>, tPipe_chunk pPrev_chunk@<EDX>)
		1872	void UndoShrapnel(tPipe_chunk** pChunk, tPipe_chunk* pPrev_chunk) {
		1873	tPipe_chunk* temp_prev_chunk;
		1874	LOG_TRACE("(%p, %p)", pChunk, pPrev_chunk);
		1875
		1876	temp_prev_chunk = pPrev_chunk;
		1877	gDisable_advance = 1;
		1878	if (pPrev_chunk != NULL) {
		1879	ApplyShrapnel(&temp_prev_chunk);
		1880	}
		1881	gDisable_advance = 0;
		1882	AdvanceChunkPtr(pChunk, ePipe_chunk_shrapnel);
		1883	}
		1884
		1885	// IDA: void __usercall UndoScreenWobble(tPipe_chunk *pChunk@<EAX>, tPipe_chunk pPrev_chunk@<EDX>)
		1886	void UndoScreenWobble(tPipe_chunk** pChunk, tPipe_chunk* pPrev_chunk) {
		1887	tPipe_chunk* temp_prev_chunk;
		1888	LOG_TRACE("(%p, %p)", pChunk, pPrev_chunk);
		1889
		1890	temp_prev_chunk = pPrev_chunk;
		1891	gDisable_advance = 1;
		1892	if (pPrev_chunk == NULL) {
		1893	SetScreenWobble(0, 0);
		1894	} else {
		1895	ApplyScreenWobble(&temp_prev_chunk);
		1896	}
		1897	gDisable_advance = 0;
		1898	AdvanceChunkPtr(pChunk, ePipe_chunk_screen_shake);
		1899	}
		1900
		1901	// IDA: void __usercall UndoGrooveStop(tPipe_chunk *pChunk@<EAX>, tPipe_chunk pPrev_chunk@<EDX>)
		1902	void UndoGrooveStop(tPipe_chunk** pChunk, tPipe_chunk* pPrev_chunk) {
		1903	tPipe_chunk* temp_prev_chunk;
		1904	LOG_TRACE("(%p, %p)", pChunk, pPrev_chunk);
		1905
		1906	temp_prev_chunk = pPrev_chunk;
		1907	gDisable_advance = 1;
		1908	if (pPrev_chunk != NULL) {
		1909	ApplyGrooveStop(&temp_prev_chunk);
		1910	}
		1911	gDisable_advance = 0;
		1912	AdvanceChunkPtr(pChunk, ePipe_chunk_groove_stop);
		1913	}
		1914
		1915	// IDA: void __usercall UndoNonCar(tPipe_chunk *pChunk@<EAX>, tPipe_chunk pPrev_chunk@<EDX>)
		1916	void UndoNonCar(tPipe_chunk** pChunk, tPipe_chunk* pPrev_chunk) {
		1917	tPipe_chunk* temp_prev_chunk;
		1918	LOG_TRACE("(%p, %p)", pChunk, pPrev_chunk);
		1919
		1920	temp_prev_chunk = pPrev_chunk;
		1921	gDisable_advance = 1;
		1922	if (pPrev_chunk != NULL) {
		1923	ApplyNonCar(&temp_prev_chunk);
		1924	}
		1925	gDisable_advance = 0;
		1926	AdvanceChunkPtr(pChunk, ePipe_chunk_non_car);
		1927	}
		1928
		1929	// IDA: void __usercall UndoSmoke(tPipe_chunk *pChunk@<EAX>, tPipe_chunk pPrev_chunk@<EDX>)
		1930	void UndoSmoke(tPipe_chunk** pChunk, tPipe_chunk* pPrev_chunk) {
		1931	tPipe_chunk* temp_prev_chunk;
		1932	LOG_TRACE("(%p, %p)", pChunk, pPrev_chunk);
		1933
		1934	temp_prev_chunk = pPrev_chunk;
		1935	gDisable_advance = 1;
		1936	if (pPrev_chunk != NULL) {
		1937	ApplySmoke(&temp_prev_chunk);
		1938	}
		1939	gDisable_advance = 0;
		1940	AdvanceChunkPtr(pChunk, ePipe_chunk_smoke);
		1941	}
		1942
		1943	// IDA: void __usercall UndoSmokeColumn(tPipe_chunk *pChunk@<EAX>, tPipe_chunk pPrev_chunk@<EDX>)
		1944	void UndoSmokeColumn(tPipe_chunk** pChunk, tPipe_chunk* pPrev_chunk) {
		1945	//tPipe_chunk* temp_prev_chunk; // Pierre-Marie Baty -- unused variable
		1946	LOG_TRACE("(%p, %p)", pChunk, pPrev_chunk);
		1947
		1948	ApplySmokeColumn(pChunk);
		1949	}
		1950
		1951	// IDA: void __usercall UndoFlame(tPipe_chunk *pChunk@<EAX>, tPipe_chunk pPrev_chunk@<EDX>)
		1952	void UndoFlame(tPipe_chunk** pChunk, tPipe_chunk* pPrev_chunk) {
		1953	LOG_TRACE("(%p, %p)", pChunk, pPrev_chunk);
		1954
		1955	ApplyFlame(pChunk);
		1956	}
		1957
		1958	// IDA: void __usercall UndoSplash(tPipe_chunk *pChunk@<EAX>, tPipe_chunk pPrev_chunk@<EDX>)
		1959	void UndoSplash(tPipe_chunk** pChunk, tPipe_chunk* pPrev_chunk) {
		1960	tPipe_chunk* temp_prev_chunk;
		1961	LOG_TRACE("(%p, %p)", pChunk, pPrev_chunk);
		1962
		1963	temp_prev_chunk = pPrev_chunk;
		1964	gDisable_advance = 1;
		1965	if (pPrev_chunk == NULL) {
		1966	((((pChunk)->subject_index & 0xff00) == 0) ? &gProgram_state.current_car : GetCarSpec((pChunk)->subject_index >> 8, (*pChunk)->subject_index & 0xff))->water_d = 10000.f;
		1967	} else {
		1968	ApplySplash(&temp_prev_chunk);
		1969	}
		1970	gDisable_advance = 0;
		1971	AdvanceChunkPtr(pChunk, ePipe_chunk_splash);
		1972	}
		1973
		1974	// IDA: void __usercall UndoOilSpill(tPipe_chunk *pChunk@<EAX>, tPipe_chunk pPrev_chunk@<EDX>)
		1975	void UndoOilSpill(tPipe_chunk** pChunk, tPipe_chunk* pPrev_chunk) {
		1976	tPipe_chunk* temp_prev_chunk;
		1977	LOG_TRACE("(%p, %p)", pChunk, pPrev_chunk);
		1978
		1979	temp_prev_chunk = pPrev_chunk;
		1980	gDisable_advance = 1;
		1981	if (pPrev_chunk != NULL) {
		1982	ApplyOilSpill(&temp_prev_chunk, (*pChunk)->chunk_data.oil_data.previous_stop_time);
		1983	}
		1984	gDisable_advance = 0;
		1985	AdvanceChunkPtr(pChunk, ePipe_chunk_oil_spill);
		1986	}
		1987
		1988	// IDA: void __usercall UndoProxRay(tPipe_chunk **pChunk@<EAX>)
		1989	void UndoProxRay(tPipe_chunk** pChunk) {
		1990	LOG_TRACE("(%p)", pChunk);
		1991
		1992	ApplyProxRay(pChunk);
		1993	}
		1994
		1995	// IDA: void __usercall UndoSkidAdjustment(tPipe_chunk *pChunk@<EAX>, tPipe_chunk pPrev_chunk@<EDX>)
		1996	void UndoSkidAdjustment(tPipe_chunk** pChunk, tPipe_chunk* pPrev_chunk) {
		1997	LOG_TRACE("(%p, %p)", pChunk, pPrev_chunk);
		1998
		1999	gDisable_advance = 1;
		2000	if (pPrev_chunk == NULL) {
		2001	HideSkid((*pChunk)->subject_index);
		2002	} else {
		2003	ApplySkidAdjustment(&pPrev_chunk);
		2004	}
		2005	gDisable_advance = 0;
		2006	AdvanceChunkPtr(pChunk, ePipe_chunk_skid_adjustment);
		2007	}
		2008
		2009	// IDA: int __usercall UndoPipedSession@<EAX>(tU8 **pPtr@<EAX>)
		2010	int UndoPipedSession(tU8** pPtr) {
		2011	tPipe_chunk* chunk_ptr;
		2012	tPipe_chunk* prev_chunk;
		2013	tU8* temp_ptr;
		2014	tU8* pushed_end_of_session;
		2015	int i;
		2016	tPipe_chunk_type chunk_type;
		2017	LOG_TRACE("(%p)", pPtr);
		2018
		2019	if (MoveSessionPointerBackOne(pPtr)) {
		2020	return 1;
		2021	}
		2022	REPLAY_DEBUG_ASSERT(((tPipe_session)pPtr)->pipe_magic1 == REPLAY_DEBUG_SESSION_MAGIC1);
		2023	gEnd_of_session = pPtr + LengthOfSession((tPipe_session)*pPtr) - sizeof(tU16);
		2024	chunk_ptr = &((tPipe_session)pPtr)->chunks;
		2025	chunk_type = ((tPipe_session)pPtr)->chunk_type;
		2026	pushed_end_of_session = gEnd_of_session;
		2027	for (i = 0; i < ((tPipe_session)pPtr)->number_of_chunks; i++) {
		2028	if (!(chunk_type == ePipe_chunk_model_geometry \|\| chunk_type == ePipe_chunk_sound \|\| chunk_type == ePipe_chunk_damage \|\| chunk_type == ePipe_chunk_special \|\| chunk_type == ePipe_chunk_incident \|\| chunk_type == ePipe_chunk_prox_ray \|\| chunk_type == ePipe_chunk_smudge)) {
		2029	prev_chunk = FindPreviousChunk(pPtr, ((tPipe_session)*pPtr)->chunk_type, chunk_ptr->subject_index);
		2030	}
		2031	REPLAY_DEBUG_ASSERT(((tPipe_chunk*)chunk_ptr)->chunk_magic1 == REPLAY_DEBUG_CHUNK_MAGIC1);
		2032	gEnd_of_session = pushed_end_of_session;
		2033	switch (chunk_type) {
		2034	case ePipe_chunk_model_geometry:
		2035	UndoModelGeometry(&chunk_ptr);
		2036	break;
		2037	case ePipe_chunk_pedestrian:
		2038	UndoPedestrian(&chunk_ptr, prev_chunk);
		2039	break;
		2040	case ePipe_chunk_frame_boundary:
		2041	UndoFrameBoundary(&chunk_ptr, prev_chunk);
		2042	break;
		2043	case ePipe_chunk_car:
		2044	UndoCar(&chunk_ptr, prev_chunk);
		2045	break;
		2046	case ePipe_chunk_sound:
		2047	UndoSound(&chunk_ptr);
		2048	break;
		2049	case ePipe_chunk_damage:
		2050	UndoDamage(&chunk_ptr);
		2051	break;
		2052	case ePipe_chunk_special:
		2053	UndoSpecial(&chunk_ptr);
		2054	break;
		2055	case ePipe_chunk_ped_gib:
		2056	UndoPedGib(&chunk_ptr, prev_chunk);
		2057	break;
		2058	case ePipe_chunk_incident:
		2059	AdvanceChunkPtr(&chunk_ptr, ePipe_chunk_incident);
		2060	break;
		2061	case ePipe_chunk_spark:
		2062	UndoSpark(&chunk_ptr, prev_chunk);
		2063	break;
		2064	case ePipe_chunk_shrapnel:
		2065	UndoShrapnel(&chunk_ptr, prev_chunk);
		2066	break;
		2067	case ePipe_chunk_screen_shake:
		2068	UndoScreenWobble(&chunk_ptr, prev_chunk);
		2069	break;
		2070	case ePipe_chunk_groove_stop:
		2071	UndoGrooveStop(&chunk_ptr, prev_chunk);
		2072	break;
		2073	case ePipe_chunk_non_car:
		2074	UndoNonCar(&chunk_ptr, prev_chunk);
		2075	break;
		2076	case ePipe_chunk_smoke:
		2077	UndoSmoke(&chunk_ptr, prev_chunk);
		2078	break;
		2079	case ePipe_chunk_oil_spill:
		2080	UndoOilSpill(&chunk_ptr, prev_chunk);
		2081	break;
		2082	case ePipe_chunk_smoke_column:
		2083	UndoSmokeColumn(&chunk_ptr, prev_chunk);
		2084	break;
		2085	case ePipe_chunk_flame:
		2086	UndoFlame(&chunk_ptr, prev_chunk);
		2087	break;
		2088	case ePipe_chunk_smudge:
		2089	UndoSmudge(&chunk_ptr);
		2090	break;
		2091	case ePipe_chunk_splash:
		2092	UndoSplash(&chunk_ptr, prev_chunk);
		2093	break;
		2094	case ePipe_chunk_prox_ray:
		2095	UndoProxRay(&chunk_ptr);
		2096	break;
		2097	case ePipe_chunk_skid_adjustment:
		2098	UndoSkidAdjustment(&chunk_ptr, prev_chunk);
		2099	break;
		2100	default:
		2101	break;
		2102	}
		2103	}
		2104	temp_ptr = *pPtr;
		2105	if (MoveSessionPointerBackOne(&temp_ptr)) {
		2106	return 1;
		2107	}
		2108	return ((tPipe_session*)temp_ptr)->chunk_type == ePipe_chunk_frame_boundary;
		2109	}
		2110
		2111	// IDA: tU32 __usercall FindPrevFrameTime@<EAX>(tU8 *pPtr@<EAX>)
		2112	tU32 FindPrevFrameTime(tU8* pPtr) {
		2113	tU8* temp_ptr;
		2114	LOG_TRACE("(%p)", pPtr);
		2115
		2116	temp_ptr = pPtr;
		2117	do {
		2118	if (MoveSessionPointerBackOne(&temp_ptr)) {
		2119	return 0;
		2120	}
		2121	} while (((tPipe_session*)temp_ptr)->chunk_type != ePipe_chunk_frame_boundary);
		2122	return ((tPipe_session*)temp_ptr)->chunks.chunk_data.frame_boundary_data.time;
		2123	}
		2124
		2125	// IDA: void __usercall ScanBuffer(tU8 *pPtr@<EAX>, tPipe_chunk_type pType@<EDX>, tU32 pDefault_time@<EBX>, int (pCall_back)(tPipe_chunk, int, tU32)@<ECX>, int (pTime_check)(tU32))
		2126	void ScanBuffer(tU8** pPtr, tPipe_chunk_type pType, tU32 pDefault_time, int (pCall_back)(tPipe_chunk, int, tU32), int (*pTime_check)(tU32)) {
		2127	//tPipe_chunk* chunk_ptr; // Pierre-Marie Baty -- unused variable
		2128	tU32 the_time;
		2129	LOG_TRACE("(%p, %d, %d, %p, %p)", pPtr, pType, pDefault_time, pCall_back, pTime_check);
		2130
		2131	the_time = pDefault_time;
		2132	while (1) {
		2133	if (PipeSearchForwards() ? MoveSessionPointerForwardOne(pPtr) : MoveSessionPointerBackOne(pPtr)) {
		2134	return;
		2135	}
		2136	gEnd_of_session = pPtr + LengthOfSession((tPipe_session)*pPtr) - sizeof(tU16);
		2137	if (((tPipe_session)pPtr)->chunk_type == ePipe_chunk_frame_boundary) {
		2138	the_time = ((tPipe_session)pPtr)->chunks.chunk_data.frame_boundary_data.time;
		2139	} else if (((tPipe_session)pPtr)->chunk_type == pType) {
		2140	if (pCall_back(&((tPipe_session)pPtr)->chunks, ((tPipe_session)pPtr)->number_of_chunks, the_time)) {
		2141	return;
		2142	}
		2143	}
		2144	if (pTime_check != NULL) {
		2145	if (!pTime_check(the_time)) {
		2146	return;
		2147	}
		2148	}
		2149	}
		2150	}
		2151
		2152	// IDA: int __usercall CheckSound@<EAX>(tPipe_chunk *pChunk_ptr@<EAX>, int pChunk_count@<EDX>, tU32 pTime@<EBX>)
		2153	int CheckSound(tPipe_chunk* pChunk_ptr, int pChunk_count, tU32 pTime) {
		2154	//int i; // Pierre-Marie Baty -- unused variable
		2155	//int sound_length; // Pierre-Marie Baty -- unused variable
		2156	//tPipe_chunk* temp_ptr; // Pierre-Marie Baty -- unused variable
		2157	LOG_TRACE("(%p, %d, %d)", pChunk_ptr, pChunk_count, pTime);
		2158
		2159	STUB_ONCE();
		2160	return 1;
		2161	}
		2162
		2163	// IDA: int __usercall SoundTimeout@<EAX>(tU32 pTime@<EAX>)
		2164	int SoundTimeout(tU32 pTime) {
		2165	LOG_TRACE("(%d)", pTime);
		2166	NOT_IMPLEMENTED();
		2167	}
		2168
		2169	// IDA: void __usercall ScanAndPlaySoundsToBe(tU8 *pPtr@<EAX>, tU32 pOldest_time@<EDX>, tU32 pYoungest_time@<EBX>)
		2170	void ScanAndPlaySoundsToBe(tU8* pPtr, tU32 pOldest_time, tU32 pYoungest_time) {
		2171	//tU8* temp_ptr; // Pierre-Marie Baty -- unused variable
		2172	LOG_TRACE("(%p, %d, %d)", pPtr, pOldest_time, pYoungest_time);
		2173	NOT_IMPLEMENTED();
		2174	}
		2175
		2176	// IDA: int __usercall CheckCar@<EAX>(tPipe_chunk *pChunk_ptr@<EAX>, int pChunk_count@<EDX>, tU32 pTime@<EBX>)
		2177	int CheckCar(tPipe_chunk* pChunk_ptr, int pChunk_count, tU32 pTime) {
		2178	int i;
		2179	tCar_spec* car;
		2180	br_vector3 com_offset_c;
		2181	br_vector3 com_offset_w;
		2182	br_vector3 difference;
		2183	tPipe_chunk* temp_ptr;
		2184	LOG_TRACE("(%p, %d, %d)", pChunk_ptr, pChunk_count, pTime);
		2185
		2186	temp_ptr = pChunk_ptr;
		2187	if (PipeSearchForwards()) {
		2188	if (pTime <= gOldest_time) {
		2189	return 0;
		2190	}
		2191	} else {
		2192	if (pTime >= gOldest_time) {
		2193	return 0;
		2194	}
		2195	}
		2196	for (i = 0; i < pChunk_count; i++) {
		2197	if ((temp_ptr->subject_index & 0xff00) == 0) {
		2198	car = &gProgram_state.current_car;
		2199	} else {
		2200	car = GetCarSpec(temp_ptr->subject_index >> 8, temp_ptr->subject_index & 0xff);
		2201	}
		2202	if (car == gCar_ptr) {
		2203	BrVector3Copy(&gCar_pos, (br_vector3*)temp_ptr->chunk_data.car_data.transformation.m[3]);
		2204	BrVector3InvScale(&com_offset_c, &car->cmpos, WORLD_SCALE);
		2205	BrMatrix34ApplyV(&com_offset_w, &com_offset_c, &temp_ptr->chunk_data.car_data.transformation);
		2206	BrVector3Accumulate(&gCar_pos, &com_offset_w);
		2207	BrVector3Sub(&difference, &gCar_pos, &gReference_pos);
		2208	if (BrVector3LengthSquared(&difference) <= gMax_distance) {
		2209	gTrigger_time = pTime;
		2210	return 0;
		2211	} else {
		2212	gTrigger_time = pTime;
		2213	return 1;
		2214	}
		2215	}
		2216	AdvanceChunkPtr(&temp_ptr, ePipe_chunk_car);
		2217	}
		2218	return 0;
		2219	}
		2220
		2221	// IDA: int __usercall CarTimeout@<EAX>(tU32 pTime@<EAX>)
		2222	int CarTimeout(tU32 pTime) {
		2223	LOG_TRACE("(%d)", pTime);
		2224
		2225	if (PipeSearchForwards()) {
		2226	if (pTime > gYoungest_time) {
		2227	return 0;
		2228	}
		2229	} else {
		2230	if (pTime < gYoungest_time) {
		2231	return 0;
		2232	}
		2233	}
		2234	return 1;
		2235	}
		2236
		2237	// IDA: void __usercall ScanCarsPositions(tCar_spec pCar@<EAX>, br_vector3 pSource_pos@<EDX>, br_scalar pMax_distance_sqr, tU32 pOffset_time, tU32 pTime_period, br_vector3 pCar_pos, tU32 pTime_returned)
		2238	void ScanCarsPositions(tCar_spec* pCar, br_vector3* pSource_pos, br_scalar pMax_distance_sqr, tU32 pOffset_time, tU32 pTime_period, br_vector3* pCar_pos, tU32* pTime_returned) {
		2239	tU8* temp_ptr;
		2240	LOG_TRACE("(%p, %p, %f, %d, %d, %p, %p)", pCar, pSource_pos, pMax_distance_sqr, pOffset_time, pTime_period, pCar_pos, pTime_returned);
		2241
		2242	temp_ptr = gPipe_play_ptr;
		2243	gTrigger_time = 0;
		2244	gMax_distance = pMax_distance_sqr;
		2245	BrVector3Copy(&gReference_pos, pSource_pos);
		2246	gCar_ptr = pCar;
		2247
		2248	if (PipeSearchForwards()) {
		2249	gOldest_time = GetTotalTime() + pOffset_time;
		2250	gYoungest_time = gOldest_time + pTime_period;
		2251	} else {
		2252	gOldest_time = GetTotalTime() - pOffset_time;
		2253	gYoungest_time = gOldest_time - pTime_period;
		2254	}
		2255
		2256	ScanBuffer(&temp_ptr, ePipe_chunk_car, GetTotalTime(), CheckCar, CarTimeout);
		2257	BrVector3Copy(pCar_pos, &gCar_pos);
		2258	if (pCar_pos->v[0] > 500.f) {
		2259	Vector3AddFloats(pCar_pos, pCar_pos, -1000.f, -1000.f, -1000.f);
		2260	}
		2261	*pTime_returned = gTrigger_time;
		2262	}
		2263
		2264	// IDA: int __usercall CheckIncident@<EAX>(tPipe_chunk *pChunk_ptr@<EAX>, int pChunk_count@<EDX>, tU32 pTime@<EBX>)
		2265	int CheckIncident(tPipe_chunk* pChunk_ptr, int pChunk_count, tU32 pTime) {
		2266	LOG_TRACE("(%p, %d, %d)", pChunk_ptr, pChunk_count, pTime);
		2267
		2268	if (PipeSearchForwards()) {
		2269	if (pTime <= gOldest_time) {
		2270	return 0;
		2271	}
		2272	} else {
		2273	if (gOldest_time <= pTime) {
		2274	return 0;
		2275	}
		2276	}
		2277	gIncidentChunk = pChunk_ptr;
		2278	gTrigger_time = pTime;
		2279	return 1;
		2280	}
		2281
		2282	// IDA: int __usercall GetNextIncident@<EAX>(tU32 pOffset_time@<EAX>, tIncident_type pIncident_type@<EDX>, float pSeverity@<EBX>, tIncident_info pInfo@<ECX>, tU32 pTime_away)
		2283	int GetNextIncident(tU32 pOffset_time, tIncident_type* pIncident_type, float* pSeverity, tIncident_info* pInfo, tU32* pTime_away) {
		2284	tU8* temp_ptr;
		2285	LOG_TRACE("(%d, %p, %p, %p, %p)", pOffset_time, pIncident_type, pSeverity, pInfo, pTime_away);
		2286
		2287	temp_ptr = gPipe_play_ptr;
		2288	gTrigger_time = 0;
		2289	if (PipeSearchForwards()) {
		2290	gOldest_time = GetTotalTime() + pOffset_time;
		2291	} else {
		2292	gOldest_time = GetTotalTime() - pOffset_time;
		2293	}
		2294	ScanBuffer(&temp_ptr, ePipe_chunk_incident, GetTotalTime(), CheckIncident, NULL);
		2295	if (gTrigger_time != 0) {
		2296	*pTime_away = gTrigger_time - GetTotalTime();
		2297	*pIncident_type = gIncidentChunk->subject_index;
		2298	*pSeverity = gIncidentChunk->chunk_data.incident_data.severity;
		2299	if (*pIncident_type == eIncident_ped) {
		2300	pInfo->ped_info.ped_actor = GetPedestrianActor(gIncidentChunk->chunk_data.incident_data.info.ped_info.ped_index);
		2301	pInfo->ped_info.murderer_actor = gIncidentChunk->chunk_data.incident_data.info.ped_info.actor;
		2302	} else if (*pIncident_type == eIncident_car) {
		2303	if ((gIncidentChunk->chunk_data.incident_data.info.car_info.car_ID & 0xff00) == 0) {
		2304	pInfo->car_info.car = &gProgram_state.current_car;
		2305	} else {
		2306	pInfo->car_info.car = GetCarSpec(gIncidentChunk->chunk_data.incident_data.info.car_info.car_ID >> 8,
		2307	gIncidentChunk->chunk_data.incident_data.info.car_info.car_ID & 0xff);
		2308	}
		2309	BrVector3Copy(&pInfo->car_info.impact_point, &gIncidentChunk->chunk_data.incident_data.info.car_info.impact_point);
		2310	} else if (*pIncident_type == eIncident_wall) {
		2311	BrVector3Copy(&pInfo->wall_info.pos, &gIncidentChunk->chunk_data.incident_data.info.wall_info.pos);
		2312	}
		2313	}
		2314	return gTrigger_time;
		2315	}
		2316
		2317	// IDA: tU32 __cdecl GetARStartTime()
		2318	tU32 GetARStartTime(void) {
		2319	tU8* temp_ptr;
		2320	LOG_TRACE("()");
		2321
		2322	temp_ptr = gPipe_buffer_oldest;
		2323	do {
		2324	if (MoveSessionPointerForwardOne(&temp_ptr)) {
		2325	return 0;
		2326	}
		2327	} while (((tPipe_session*)temp_ptr)->chunk_type != ePipe_chunk_frame_boundary);
		2328	return ((tPipe_session*)temp_ptr)->chunks.chunk_data.frame_boundary_data.time;
		2329	}

Subversion Repositories Games.Carmageddon

Games.Carmageddon//src/DETHRACE/common/piping.c – Rev 20