From 2e2f83a775f517094859b9c739b90546cfcbd116 Mon Sep 17 00:00:00 2001 From: Colin Miller Date: Sun, 15 Jun 2025 20:54:45 -0400 Subject: [PATCH 1/2] Started Filling out zWad1. Updated some Big structs like the globals --- .../Engine/Game/zStreamedSound.h | 24 + src/SB/Core/gc/iSnd.h | 8 + src/SB/Core/x/xAnim.h | 12 +- src/SB/Core/x/xCamera.h | 99 + src/SB/Core/x/xEnv.h | 3 +- src/SB/Core/x/xGlobals.h | 99 +- src/SB/Core/x/xModel.h | 2 +- src/SB/Core/x/xModelBlur.h | 30 + src/SB/Game/zCar.h | 275 +++ src/SB/Game/zConfig.h | 39 + src/SB/Game/zCutsceneMgr.h | 2 + src/SB/Game/zEntPlayer.h | 205 +- src/SB/Game/zEntPlayerCar.h | 15 + src/SB/Game/zEnv.h | 21 +- src/SB/Game/zGlobals.h | 147 +- src/SB/Game/zNPCFXCinematic.h | 201 ++ src/SB/Game/zNPCSupplement.h | 305 +++ src/SB/Game/zScene.h | 36 +- src/SB/Game/zStreamedSound.h | 24 + src/SB/Game/zWad1.cpp | 1138 ++++++++++ src/SB/Game/zWad1.h | 39 + src/SB/Game/zWad3.cpp | 1856 +---------------- 22 files changed, 2589 insertions(+), 1991 deletions(-) create mode 100644 dwarf/SB04_Multi_Sku/Engine/Game/zStreamedSound.h create mode 100644 src/SB/Core/x/xModelBlur.h create mode 100644 src/SB/Game/zCar.h create mode 100644 src/SB/Game/zConfig.h create mode 100644 src/SB/Game/zEntPlayerCar.h create mode 100644 src/SB/Game/zNPCFXCinematic.h create mode 100644 src/SB/Game/zNPCSupplement.h create mode 100644 src/SB/Game/zStreamedSound.h create mode 100644 src/SB/Game/zWad1.h diff --git a/dwarf/SB04_Multi_Sku/Engine/Game/zStreamedSound.h b/dwarf/SB04_Multi_Sku/Engine/Game/zStreamedSound.h new file mode 100644 index 0000000..9c18981 --- /dev/null +++ b/dwarf/SB04_Multi_Sku/Engine/Game/zStreamedSound.h @@ -0,0 +1,24 @@ +#ifndef ZSTREAMEDSOUND_H +#define ZSTREAMEDSOUND_H + +#include "iSnd.h" + +struct zStreamedSoundList +{ + U32 mNumSounds; + zStreamedSound* mSounds; + + void Reset(); + void InitWithSounds(zStreamedSound* soundList); +}; + +struct zStreamedSound +{ + char* mAssetName; + F32 mCycleTime; + U32 mFlags; + F32 mSoonestTimeToPlay; + iSndGroupHandle mSoundGroupHdl; +}; + +#endif diff --git a/src/SB/Core/gc/iSnd.h b/src/SB/Core/gc/iSnd.h index 0455a3e..7a9d256 100644 --- a/src/SB/Core/gc/iSnd.h +++ b/src/SB/Core/gc/iSnd.h @@ -45,6 +45,14 @@ enum isound_effect iSND_EFFECT_CAVE }; +enum iSndHandle +{ +}; + +enum iSndGroupHandle +{ +}; + void arq_callback(long); void iSndExit(); diff --git a/src/SB/Core/x/xAnim.h b/src/SB/Core/x/xAnim.h index d9a5823..b9bb6c5 100644 --- a/src/SB/Core/x/xAnim.h +++ b/src/SB/Core/x/xAnim.h @@ -65,7 +65,7 @@ struct xAnimState F32 Speed; xAnimFile* Data; xAnimEffect* Effects; - + // 0x20 xAnimTransitionList* Default; xAnimTransitionList* List; @@ -177,17 +177,18 @@ struct xAnimPlay void (*BeforeAnimMatrices)(xAnimPlay*, xQuat*, xVec3*, S32); }; -class AnimTableList { // size: 0xC +class AnimTableList +{ // size: 0xC public: - char * name; // offset 0x0, size 0x4 - class xAnimTable * (* constructor)(); // offset 0x4, size 0x4 + char* name; // offset 0x0, size 0x4 + class xAnimTable* (*constructor)(); // offset 0x4, size 0x4 unsigned int id; // offset 0x8, size 0x4 }; void xAnimInit(); void xAnimTempTransitionInit(U32 count); xAnimFile* xAnimFileNew(void* rawData, const char* name, U32 flags, xAnimFile** linkedList); -xAnimTable* xAnimTableNew(const char* name, xAnimTable** linkedList, U32 userFlags); +xAnimTable* xAnimTableNew(const char* name, U32 userFlags); xAnimState* xAnimTableNewState(xAnimTable* table, const char* name, U32 flags, U32 userFlags, F32 speed, F32* boneBlend, F32* timeSnap, F32 fadeRecip, U16* fadeOffset, void* callbackData, @@ -225,5 +226,4 @@ inline F32 xAnimFileRawTime(xAnimFile* data, float time) return data->TimeOffset + time; } - #endif diff --git a/src/SB/Core/x/xCamera.h b/src/SB/Core/x/xCamera.h index b60b095..16212fb 100644 --- a/src/SB/Core/x/xCamera.h +++ b/src/SB/Core/x/xCamera.h @@ -11,6 +11,8 @@ #include +#include "xPad.h" + struct xScene; enum _tagTransType @@ -28,6 +30,23 @@ enum _tagTransType eTransType_Total }; +enum xCamCoordType +{ + XCAM_COORD_CART, + XCAM_COORD_CYLINDER, + XCAM_COORD_SPHERE, + XCAM_COORD_MAX, + XCAM_COORD_INVALID = 0xffffffff, +}; + +enum xCamOrientType +{ + XCAM_ORIENT_QUAT, + XCAM_ORIENT_EULER, + XCAM_ORIENT_MAX, + XCAM_ORIENT_INVALID = 0xffffffff, +}; + struct _tagxCamFollowAsset { F32 rotation; @@ -213,6 +232,86 @@ struct xBinaryCamera void render_debug(); }; +struct xCamConfigCommon +{ + U8 priority; + U8 pad1; + U8 pad2; + U8 pad3; + F32 blend_time; +}; + +struct xCamBlend; +struct xCam; + +struct xCamGroup +{ + xMat4x3 mat; + xVec3 vel; + F32 fov; + F32 fov_default; + S32 flags; + xCam* primary; + analog_data analog; + xCam* owned[32]; + S32 size; + S32 primary_index; + S32 child_flags; + S32 child_flags_mask; + xCamBlend* blend_cam[4]; +}; + +struct xCam +{ + struct _class_0 + { + union + { + //xVec3 cart; + //xCamCoordCylinder cylinder; + //xCamCoordSphere sphere; + }; + }; + + struct _class_1 + { + union + { + //xQuat quat; + //xCamOrientEuler euler; + }; + }; + + xMat4x3 mat; + F32 fov; + S32 flags; + U32 owner; + xCamGroup* group; + analog_data analog; + F32 motion_factor; + xCamCoordType coord_type; + xCamOrientType orient_type; + _class_0 coord; + _class_1 orient; + xCamConfigCommon cfg_common; + S32 group_index; + S32 group_flags; + xCamBlend* blender; +}; + +struct xCamBlend : xCam +{ + xCam* src; + xCam* dst; + F32 time; +}; + +struct xCamScreen +{ + RwCamera* icam; + F32 fov; +}; + F32 xVec3Length(const xVec3* vec); void xCameraInit(xCamera* cam, U32 width, U32 height); void xCameraSetScene(xCamera* cam, xScene* sc); diff --git a/src/SB/Core/x/xEnv.h b/src/SB/Core/x/xEnv.h index d72573b..45c1c55 100644 --- a/src/SB/Core/x/xEnv.h +++ b/src/SB/Core/x/xEnv.h @@ -27,7 +27,7 @@ struct xEnvAsset : xBaseAsset U32 bspCameraAssetID; U32 bspMapperID; U32 bspMapperCollisionID; - U32 bspMapperFXID; + U32 bspMapperFXID; // 0x3C F32 loldHeight; }; @@ -50,5 +50,6 @@ void xEnvLoadBsp(xEnv* env, const void* data, U32 datasize, S32 dataType); void xEnvFree(xEnv* env); void xEnvSetup(xEnv* env); void xEnvRender(xEnv* env); +void xEnvRender(xEnv* env, bool); #endif diff --git a/src/SB/Core/x/xGlobals.h b/src/SB/Core/x/xGlobals.h index b254ffe..a2fc32a 100644 --- a/src/SB/Core/x/xGlobals.h +++ b/src/SB/Core/x/xGlobals.h @@ -6,55 +6,106 @@ #include "xUpdateCull.h" #include "iCamera.h" #include "iTime.h" +#include "zScene.h" #include #include -struct xGlobals +// U8's may be bools +// chars were originally int8 + +enum sceDemoEndReason +{ + SCE_DEMO_ENDREASON_ATTRACT_INTERRUPTED, + SCE_DEMO_ENDREASON_ATTRACT_COMPLETE, + SCE_DEMO_ENDREASON_PLAYABLE_INACTIVITY_TIMEOUT, + SCE_DEMO_ENDREASON_PLAYABLE_GAMEPLAY_TIMEOUT, + SCE_DEMO_ENDREASON_PLAYABLE_COMPLETE, + SCE_DEMO_ENDREASON_PLAYABLE_QUIT, + SCE_DEMO_ENDREASON_NETCONFIG_REQUEST, + SCE_DEMO_ENDREASON_NETCONFIG_COMPLETE +}; + +struct zPlayer { - // 0x00 in globals - xCamera camera; + // Why empty? (iFMV dwarf shows this) + // Non-empty ones exist in the zWads +}; + +struct PS2DemoGlobals +{ + U16 language; + U16 aspect; + U16 play_mode; + U16 inactive_timeout; + U16 gameplay_timeout; + sceDemoEndReason exit_code; + struct + { + U32 FMV_playing : 1; + U32 more_padding : 31; + }; + F32 bail_timer; + F32 inactive_timer; + F32 gameplay_timer; + s8 subdir[16]; + U16 quit; // 0x30 + U16 vmode; +}; - // 0x31C in globals +struct xGlobals +{ + xCamera oldSkoolCamera; + xCamGroup* cam; + xCamScreen* screen; + xVec4 frustplane[12]; _tagxPad* pad0; _tagxPad* pad1; _tagxPad* pad2; _tagxPad* pad3; + _tagxPad* pad[4]; S32 profile; - - // 0x330 in globals - char profFunc[6][128]; - - // 0x630 in globals + char profFunc[128][6]; xUpdateCullMgr* updateMgr; S32 sceneFirst; char sceneStart[32]; - RpWorld* currWorld; - - // 0x65C in globals + RpWorld* currWorld; // 0x730 iFogParams fog; iFogParams fogA; iFogParams fogB; - - // 0x6B0 in globals - iTime fog_t0; - iTime fog_t1; - - // 0x6C0 in globals + S64 fog_t0; + S64 fog_t1; S32 option_vibration; - U32 QuarterSpeed; + S32 option_subtitles; + U32 slowdown; F32 update_dt; + S16 ForceCinematic; + S16 ForceAllCinematics; S32 useHIPHOP; - - // 0x6D0 in globals U8 NoMusic; - U8 currentActivePad; + U8 NoCutscenes; + U8 NoPadCheck; + char currentActivePad; U8 firstStartPressed; - - // 0x6D4 in globals + U8 fromLauncher; + U8 FlashWIP; + U8 inLoadingScreen; + U8 LoadingScene; + U8 InitializingLoadingScreen; + U8 ForceMono; U32 minVSyncCnt; U8 dontShowPadMessageDuringLoadingOrCutScene; U8 autoSaveFeature; + S32 asyncLoadingScreen; + S32 asyncLoadingFlags; + char fromLauncherUser[32]; + zPlayer* ___player_ent_dont_use_directly; + zScene* sceneCur; // 0x7f0 + zScene* scenePreload; // 0x7f4 + PS2DemoGlobals* PS2demo; + char watermark[127]; + U8 watermarkAlpha; + F32 watermarkSize; }; #endif diff --git a/src/SB/Core/x/xModel.h b/src/SB/Core/x/xModel.h index 9ff8f9d..5b78c59 100644 --- a/src/SB/Core/x/xModel.h +++ b/src/SB/Core/x/xModel.h @@ -20,7 +20,7 @@ struct xModelPool xModelInstance* List; }; -struct xModelInstance +struct xModelInstance // NEEDS UPDATED WITH TSSM DWARF { xModelInstance* Next; xModelInstance* Parent; diff --git a/src/SB/Core/x/xModelBlur.h b/src/SB/Core/x/xModelBlur.h new file mode 100644 index 0000000..b79b9e2 --- /dev/null +++ b/src/SB/Core/x/xModelBlur.h @@ -0,0 +1,30 @@ +#ifndef XMODELBLUR_H +#define XMODELBLUR_H + +#include "xFX.h" + +struct activity_data_2 +{ + struct tier_queue + { + U32 first; + U32 _size; + U32 wrap_mask; + tier_queue_allocator* alloc; + U8 blocks[32]; + }; + xFXRibbon* owner; + activity_data_2** position; + tier_queue joints; + S32 curve_index; + F32 ilife; + U32 mtime; + U32 mlife; +}; + +struct xModelBlur +{ + activity_data_2* activity; +}; + +#endif diff --git a/src/SB/Game/zCar.h b/src/SB/Game/zCar.h new file mode 100644 index 0000000..e5cbd35 --- /dev/null +++ b/src/SB/Game/zCar.h @@ -0,0 +1,275 @@ +#ifndef ZCAR_H +#define ZCAR_H + +#include "types.h" +#include "xAnim.h" +#include "xBase.h" +#include "xEnt.h" +#include "zEnt.h" +#include "xModel.h" +#include "iSnd.h" +#include "xParEmitter.h" +#include "xModelBlur.h" +#include "xCounter.h" +#include "zStreamedSound.h" +#include "zEntPlayerCar.h" + +// Remember: +// U8 is commonly a bool + +enum eDamage +{ + eDamageNone, + eDamage1, + eDamage2, + eDamage3, + eDamageMax +}; + +enum eCollisionType +{ + eCollisionTypeHeadOn, + eCollisionTypeSideKnock, + eCollisionTypeJumpLand, + eCollisionTypeDamage +}; + +enum zDrivingSurf +{ + ezDRIVINGSURF_Default, + ezDRIVINGSURF_Tarmac, + ezDRIVINGSURF_Cement, + ezDRIVINGSURF_HardDirt, + ezDRIVINGSURF_Railroad, + ezDRIVINGSURF_Grass, + ezDRIVINGSURF_SoftDirt, + ezDRIVINGSURF_SideWalk, + ezDRIVINGSURF_Sand, + ezDRIVINGSURF_SurfaceWater, + ezDRIVINGSURF_ThickOil, + ezDRIVINGSURF_HotSauce, + ezDRIVINGSURF_NumNormalDrivableSurfaces, + ezDRIVINGSURF_Wall, + ezDRIVINGSURF_SlideTubWood, + ezDRIVINGSURF_SlideTubSand, + ezDRIVINGSURF_SlideTubHardRock, + ezDRIVINGSURF_SlideShellHardRock, + ezDRIVINGSURF_SlideShellTongue, + ezDRIVINGSURF_SlideCrownRubberHose, + ezDRIVINGSURF_SlideCrownRubberCable, + ezDRIVINGSURF_SlideCrownMetalLamp, + ezDRIVINGSURF_MaxTypes +}; + +enum animState +{ + eANIMSTATE_Idle, + eANIMSTATE_Drive, + eANIMSTATE_DriveSlippy, + eANIMSTATE_Boosting, + eANIMSTATE_Reversing, + eANIMSTATE_Jump, + eANIMSTATE_JumpLandSquash, + eANIMSTATE_Crash, + eANIMSTATE_SpinLeft, + eANIMSTATE_SpinRight, + eANIMSTATE_Success, + eANIMSTATE_Failed, + eANIMSTATE_Death +}; + +struct effectAsset : xDynAsset +{ + F32 time; + F32 intensity; + U32 id; + U8 priority; + U8 type; + U8 rumbleInPause; + U8 pad; + F32 param1; + F32 param2; + F32 shakeMagnitude; + F32 shakeCycleMax; + F32 shakeRotationalMagnitude; + U8 shakeY; +}; + +struct emitterBase : xBase +{ + effectAsset* pEffectAsset; + + void SetIntensity(F32 intensity); +}; + +struct effect : emitterBase +{ +}; + +struct driveSurfaceDescriptor +{ + F32 staticTraction; + F32 slidingTraction; + F32 slideThreshold; + U8 useSlideAnimation; + F32 topSpeedFactor; + iSndGroupHandle soundGroupDrive; + iSndGroupHandle soundGroupSkid; +}; + +struct zCar +{ + xEnt* pEnt; + xMat4x3 lastMat; + xMat4x3 mat; + F32 boundYShift; + F32 boundRadius; + F32 shockHalfRange; + U8 engineRunning; + U8 playShutDownSound; + iSndHandle soundBoostStartHandle; + F32 modelYaw; + xVec3 velocity; + U8 inGroundContact; + F32 timeOffGround; + F32 shockExtension; + F32 steeringPosition; + U8 isSliding; + U8 isInDamageSpin; + F32 oilPenaltyTimer; + driveSurfaceDescriptor* pCurrentSurface; + zDrivingSurf currentSurfaceType; + S32 numCollisions; + xCollis collisions[12]; + U32 collisionUserFlags[12]; + xBound bound; + char collisionTypes[22]; + S32 numNitros; + F32 boostTimeRemaining; + xModelBlur nitroBlur; + animState currentAnimState; + animState idealDrivingAnimState; + U8 animReversing; + U8 animBrakeLightsOn; + S32 animPropellorAngle; + F32 animLean; + xVec3 animVirtualBunTopPos; + xVec3 animVirtualBunTopVel; + F32 animVirtualBunTopHeight; + F32 animVirtualBunTopVerticalVel; + F32 animJumpOpeness; + U8 animCrash; + U8 animStartSpinLeft; + U8 animStartSpinRight; + U8 animHeavyLanding; + U8 animInJumpAnimation; //0x598 + U8 animSuccessMode; + U8 animFailedMode; + F32 skidFXIntensity; //0x59C + xVec3 lastPositionPar[4]; //0x5a0 + xVec3 lastVelocityPar[4]; // + xVec3 lastPositionSeed; + xVec3 lastPositionKetchup; + xVec3 lastVelocityKetchup; + xVec3 lastPositionMustard; + xVec3 lastVelocityMustard; + eDamage damageLevel; //0x63C + F32 soundEnginePitch; //0x640 + iSndHandle soundEngineHandle; + eDamage soundCurrentEngineType; + iSndHandle soundBoostLoopHandle; + S64 soundReverseActivationTime; // long32 + iSndHandle soundReverseBeepHandle; + driveSurfaceDescriptor* pSoundCurrentSurface; + iSndHandle soundDriveLoopHandle; + iSndHandle soundSkidLoopHandle; + iSndHandle soundSkidLoopHandles[22]; + U8 soundGearCrunchReady; + _xCounter* nitroUsedCounter; + U8 oilOneLinerPlayed; + zStreamedSoundList carOneLiners; + effect* mpRumbleCollision; + effect* mpRumbleDamage; + effect* mpRumbleBoostStart; + effect* mpRumbleBoost; + + void SoundInitAssetTable(); + xAnimTable* CreateAnimTable(); + U32 JumpEndedCB(xAnimTransition*, xAnimSingle* anim, void*); + U32 JumpStartedCB(); + U32 AnimDefaultCB(xAnimSingle* anim); + U32 DamageSpinCompleteCB(xAnimSingle* anim); + U32 DeathCheck(); + U32 FailedCheck(); + U32 SuccessCheck(); + U32 SpinRightCheck(); + U32 SpinLeftCheck(); + U32 CrashCheck(); + U32 JumpEndCheck(); + U32 JumpCheck(); + U32 ReverseCheck(); + U32 StartBoostingCheck(); + U32 StartDrivingSlippyCheck(); + U32 StartDrivingCheck(); + U32 IdleCheck(); + void PreventPoppingThroughWorld(xVec3* pStartPosition, xVec3* pEndPosition, xVec3* pVelocity); + void Exit(); +}; + +void SoundUpdate(); +void SoundPlayCollision(eCollisionType type, F32 strength); +void SoundPlayHorn(); +void SoundInitAssetTable(); +void ModelSwap(eDamage newDamageLevel, U8 swapEffects); +void StreakFX(xEnt* ent, F32 dt); +void DriveSurfaceFXInternal(xModelInstance* pModel, F32 dt, zDrivingSurf collisionType); +void RenderBrakeLights(xModelInstance* pModel); +void zCarRenderOneBrakeLight(xMat4x3* pMat); +void UpdateEffects(F32 dt); +void UpdateVirtualBunTop(F32 dt); +xAnimTable* CreateAnimTable(); +U32 JumpEndedCB(); +U32 JumpStartedCB(); +U32 AnimDefaultCB(xAnimSingle* anim); +U32 DamageSpinCompleteCB(xAnimSingle* anim); +U32 DeathCheck(); +U32 FailedCheck(); +U32 SuccessCheck(); +U32 SpinRightCheck(); +U32 SpinLeftCheck(); +U32 CrashCheck(); +U32 JumpEndCheck(); +U32 JumpCheck(); +U32 ReverseCheck(); +U32 StartBoostingCheck(); +U32 StartDrivingSlippyCheck(); +U32 StartDrivingCheck(); +U32 IdleCheck(); +void UpdateAnimState(xEnt* pEnt); +void ApplyCollisionRebounds(xVec3* pVelocity); +void DepenetrateCollisionList(xVec3* pPosition); +void PreventPoppingThroughWorld(xVec3* pStartPosition, xVec3* pEndPosition, xVec3* pVelocity); +void SphereCollision(xVec3* pNewCarPosition, xVec3* pVelocity, U8* pInGroundContact, + F32* pShockExtension, xVec3* pGroundNormal); +U8 __cl(xEnt& ent); +void UpdateGroundCharacteristics(); +void CalculateIdealOrientation(F32 yaw, xMat3x3* pIdealOrientation, xVec3* pGroundNormal); +void CarUpdate(F32 dt, F32 steer, U8 accelOn, U8 brakeOn, U8 boostOn); +void StartBoost(); +U32* GetVarNitros(); +U8 CanPickupNitros(); +void AddNitros(S32 nitros); +xMat4x3* GetMatrix(); +void SetMatrix(xMat4x3* pSource); +void GiveHealth(S32 health); +void SetFullHealth(); +void TakeDamage(U8 spinClockwise); +void HandleEvent(xBase* from, xBase* to, U32 toEvent, F32* toParam, xBase* toParamWidget, + U32 UNUSEDtoParamWidgetID); +void Exit(); +void Reset(xEnt* pCarEnt, F32 initialYaw, xVec3* pPosition); +void Initialize(xEnt* pCarEnt); +void SceneInit(); +zCar* zEntPlayerCarGetCar(); + +#endif diff --git a/src/SB/Game/zConfig.h b/src/SB/Game/zConfig.h new file mode 100644 index 0000000..b1a6800 --- /dev/null +++ b/src/SB/Game/zConfig.h @@ -0,0 +1,39 @@ +#ifndef ZCONFIG_H +#define ZCONFIG_H + +enum ePlayerEnum +{ + PLAYER_BEGIN, + COSTUME_SB_1 = 0, + COSTUME_SB_2, + COSTUME_SB_3, + COSTUME_SB_4, + COSTUME_SB_5, + COSTUME_SB_6, + COSTUME_SB_7, + COSTUME_SB_A, + COSTUME_SB_B, + COSTUME_SB_C, + COSTUME_SB_D, + COSTUME_SB_X = 0xa, + COSTUME_PAT_1, + COSTUME_PAT_2, + COSTUME_PAT_3, + COSTUME_PAT_4, + COSTUME_PAT_5, + COSTUME_PAT_6, + COSTUME_PAT_7, + COSTUME_PAT_A, + COSTUME_PAT_B, + COSTUME_PAT_C, + COSTUME_PAT_D, + COSTUME_PAT_X = 0x15, + SPONGEPAT_0, + SPONGEPAT_1, + SPONGEPAT_2, + CAR_NORMAL, + SPONGEBALL_NORMAL, + PLAYER_COUNT +}; + +#endif diff --git a/src/SB/Game/zCutsceneMgr.h b/src/SB/Game/zCutsceneMgr.h index 5c2719f..4077322 100644 --- a/src/SB/Game/zCutsceneMgr.h +++ b/src/SB/Game/zCutsceneMgr.h @@ -4,6 +4,8 @@ #include "xCutsceneMgr.h" #include "rpworld.h" +extern F32 gSkipTimeCutscene; + struct xScene; struct zCutsceneMgr : xCutsceneMgr { diff --git a/src/SB/Game/zEntPlayer.h b/src/SB/Game/zEntPlayer.h index ae42d00..86aae4e 100644 --- a/src/SB/Game/zEntPlayer.h +++ b/src/SB/Game/zEntPlayer.h @@ -58,12 +58,7 @@ enum _tagePlayerSnd ePlayerSnd_LassoThrow, ePlayerSnd_LassoYank, ePlayerSnd_LassoStretch, - ePlayerSnd_Ouch1, - ePlayerSnd_OuchStart = 0x1b, - ePlayerSnd_Ouch2, - ePlayerSnd_Ouch3, - ePlayerSnd_Ouch4, - ePlayerSnd_OuchEnd = 0x1e, + ePlayerSnd_Ouch, ePlayerSnd_Death, ePlayerSnd_FruitCrackle, ePlayerSnd_CheckPoint, @@ -73,144 +68,143 @@ enum _tagePlayerSnd ePlayerSnd_Taxi, ePlayerSnd_SlideLoop, ePlayerSnd_BeginBungee, - ePlayerSnd_BungeeWind = 0x27, + ePlayerSnd_BungeeWind = 0x24, ePlayerSnd_BungeeAttach, ePlayerSnd_BungeeRelease, - ePlayerSnd_EndBungee = 0x29, + ePlayerSnd_EndBungee = 0x26, ePlayerSnd_PickupSpatulaComment, - ePlayerSnd_BungeeDive1, - ePlayerSnd_BungeeDive2, + ePlayerSnd_BungeeDive, ePlayerSnd_Sneak, ePlayerSnd_SlipLoop, + ePlayerSnd_BubbleBashMiss, + ePlayerSnd_WallJumpLand, + ePlayerSnd_CartwheelLoop, + ePlayerSnd_HammerThrow, + ePlayerSnd_HammerThrowLoop, + ePlayerSnd_GauntletTick, + ePlayerSnd_Cartwheel2Loop, + ePlayerSnd_MeleeDeflect, + ePlayerSnd_BellySmash2, ePlayerSnd_Total }; enum _tagePlayerStreamSnd { ePlayerStreamSnd_Invalid, - ePlayerStreamSnd_PickupSock1, - ePlayerStreamSnd_PickupSock2, - ePlayerStreamSnd_PickupSock3, - ePlayerStreamSnd_UnderwearComment1, - ePlayerStreamSnd_UnderwearComment2, - ePlayerStreamSnd_UnderwearComment3, + ePlayerStreamSnd_PickupSock, + ePlayerStreamSnd_UnderwearComment, ePlayerStreamSnd_EnterScene1, ePlayerStreamSnd_EnterScene2, ePlayerStreamSnd_EnterScene3, ePlayerStreamSnd_EnterScene4, ePlayerStreamSnd_EnterScene5, - ePlayerStreamSnd_EnterScene6, - ePlayerStreamSnd_EnterScene7, ePlayerStreamSnd_SpatulaComment1, - ePlayerStreamSnd_ShinyComment1, - ePlayerStreamSnd_ShinyComment2, - ePlayerStreamSnd_ShinyComment3, - ePlayerStreamSnd_ShinyComment4, - ePlayerStreamSnd_ShinyComment5, - ePlayerStreamSnd_SpongeBallComment1, - ePlayerStreamSnd_SpongeBallComment2, - ePlayerStreamSnd_SpongeBallComment3, - ePlayerStreamSnd_CruiseComment1, // 0x17 -> "Say hello to my little bubble friend." - ePlayerStreamSnd_CruiseComment2, // 0x18 -> "SpongeBob to mission control, the launch is a go." - ePlayerStreamSnd_CruiseComment3, // 0x19 -> "Bubble Power!" + ePlayerStreamSnd_ShinyComment, + ePlayerStreamSnd_SpongeBallComment, + ePlayerStreamSnd_CruiseComment, ePlayerStreamSnd_BowlComment1, ePlayerStreamSnd_BowlComment2, ePlayerStreamSnd_BowlComment3, - ePlayerStreamSnd_BowlComment4, - ePlayerStreamSnd_BowlComment5, - ePlayerStreamSnd_PushButton1, - ePlayerStreamSnd_PushButton2, - ePlayerStreamSnd_PushButton3, - ePlayerStreamSnd_BellySmashComment1, - ePlayerStreamSnd_BellySmashComment2, - ePlayerStreamSnd_BellySmashComment3, - ePlayerStreamSnd_ChopComment1, - ePlayerStreamSnd_ChopComment2, - ePlayerStreamSnd_ChopComment3, - ePlayerStreamSnd_KickComment1, - ePlayerStreamSnd_KickComment2, - ePlayerStreamSnd_KickComment3, - ePlayerStreamSnd_RopingComment1, - ePlayerStreamSnd_RopingComment2, - ePlayerStreamSnd_RopingComment3, - ePlayerStreamSnd_HeliComment1, - ePlayerStreamSnd_HeliComment2, - ePlayerStreamSnd_HeliComment3, - ePlayerStreamSnd_DestroyTiki1, - ePlayerStreamSnd_DestroyTiki2, - ePlayerStreamSnd_DestroyTiki3, - ePlayerStreamSnd_DestroyRobot1, - ePlayerStreamSnd_DestroyRobot2, - ePlayerStreamSnd_DestroyRobot3, + ePlayerStreamSnd_PushButton, + ePlayerStreamSnd_BellySmashComment, + ePlayerStreamSnd_ChopComment, + ePlayerStreamSnd_KickComment, + ePlayerStreamSnd_RopingComment, + ePlayerStreamSnd_HeliComment, + ePlayerStreamSnd_DestroyTiki, + ePlayerStreamSnd_DestroyRobot, ePlayerStreamSnd_SeeWoodTiki, ePlayerStreamSnd_SeeLoveyTiki, ePlayerStreamSnd_SeeShhhTiki, ePlayerStreamSnd_SeeThunderTiki, ePlayerStreamSnd_SeeStoneTiki, - ePlayerStreamSnd_SeeFodder, - ePlayerStreamSnd_SeeHammer, - ePlayerStreamSnd_SeeTarTar, - ePlayerStreamSnd_SeeGLove, - ePlayerStreamSnd_SeeMonsoon, - ePlayerStreamSnd_SeeSleepyTime, - ePlayerStreamSnd_SeeArf, - ePlayerStreamSnd_SeeTubelets, - ePlayerStreamSnd_SeeSlick, - ePlayerStreamSnd_SeeKingJellyfish, - ePlayerStreamSnd_SeePrawn, - ePlayerStreamSnd_SeeDutchman, - ePlayerStreamSnd_SeeSandyBoss, ePlayerStreamSnd_SeePatrickBoss1, ePlayerStreamSnd_SeePatrickBoss2, ePlayerStreamSnd_SeeSpongeBobBoss, ePlayerStreamSnd_SeeRobotPlankton, ePlayerStreamSnd_PickupSpecialGeneric1, ePlayerStreamSnd_PickupSpecialGeneric2, - ePlayerStreamSnd_GoldenUnderwear4, - ePlayerStreamSnd_GoldenUnderwear5, - ePlayerStreamSnd_GoldenUnderwear6, - ePlayerStreamSnd_Combo1, - ePlayerStreamSnd_Combo2, - ePlayerStreamSnd_Combo3, - ePlayerStreamSnd_Combo4, - ePlayerStreamSnd_Combo5, + ePlayerStreamSnd_GoldenUnderwear, + ePlayerStreamSnd_Combo, ePlayerStreamSnd_BigCombo1, ePlayerStreamSnd_BigCombo2, ePlayerStreamSnd_BigCombo3, ePlayerStreamSnd_BigCombo4, ePlayerStreamSnd_BigCombo5, ePlayerStreamSnd_Lift1, - ePlayerStreamSnd_Exclaim1, - ePlayerStreamSnd_Exclaim2, - ePlayerStreamSnd_Exclaim3, - ePlayerStreamSnd_Exclaim4, + ePlayerStreamSnd_Exclaim, ePlayerStreamSnd_BeginBungee, - ePlayerStreamSnd_BungeeAttachComment = 0x61, + ePlayerStreamSnd_BungeeAttachComment = 0x2b, ePlayerStreamSnd_BungeeBeginDive, - ePlayerStreamSnd_BungeeDive1 = 0x62, + ePlayerStreamSnd_BungeeDive1 = 0x2c, ePlayerStreamSnd_BungeeDive2, - ePlayerStreamSnd_BungeeEndDive = 0x63, - ePlayerStreamSnd_BungeeBeginDeath, - ePlayerStreamSnd_BungeeDeath1 = 0x64, - ePlayerStreamSnd_BungeeDeath2, - ePlayerStreamSnd_BungeeDeath3, - ePlayerStreamSnd_BungeeDeath4, - ePlayerStreamSnd_BungeeDeath5, - ePlayerStreamSnd_BungeeDeath6, - ePlayerStreamSnd_BungeeDeath7, - ePlayerStreamSnd_BungeeDeath8, - ePlayerStreamSnd_BungeeDeath9, - ePlayerStreamSnd_BungeeDeath10, - ePlayerStreamSnd_BungeeDeath11, - ePlayerStreamSnd_BungeeDeath12, - ePlayerStreamSnd_BungeeDeath13, - ePlayerStreamSnd_BungeeDeath14, - ePlayerStreamSnd_BungeeDeath15, - ePlayerStreamSnd_BungeeDeath16, - ePlayerStreamSnd_BungeeDeath17, - ePlayerStreamSnd_BungeeDeath18, - ePlayerStreamSnd_BungeeEndDeath = 0x75, - ePlayerStreamSnd_EndBungee = 0x75, + ePlayerStreamSnd_BungeeEndDive = 0x2d, + ePlayerStreamSnd_BungeeDeath, + ePlayerStreamSnd_SharedSpaceStart, + ePlayerStreamSnd_SBKarateSpin = 0x2f, + ePlayerStreamSnd_MeleeDeflect, + ePlayerStreamSnd_SBKarateDeflect = 0x30, + ePlayerStreamSnd_SBHelmetBash, + ePlayerStreamSnd_SBHelmetEmbedded, + ePlayerStreamSnd_SBUnderWearBungee, + ePlayerStreamSnd_SBBowl, + ePlayerStreamSnd_SBMachoBowl, + ePlayerStreamSnd_SBSonicGuitar, + ePlayerStreamSnd_SBSonicGuitarReleased, + ePlayerStreamSnd_SBSpongeBallMove, + ePlayerStreamSnd_SBLastSharedEnum = 0x38, + ePlayerStreamSnd_PatBellyBounce = 0x2f, + ePlayerStreamSnd_PatBellyDeflect, + ePlayerStreamSnd_PatCartwheel, + ePlayerStreamSnd_PatTongueSwing, + ePlayerStreamSnd_PatLift, + ePlayerStreamSnd_PatCarry, + ePlayerStreamSnd_PatThrow, + ePlayerStreamSnd_PatHammerThrowRelease, + ePlayerStreamSnd_PatBellyFlop, + ePlayerStreamSnd_PatBellyFlopStun, + ePlayerStreamSnd_PatLastSharedEnum = 0x38, + ePlayerStreamSnd_Waiting, + ePlayerStreamSnd_Jumping, + ePlayerStreamSnd_IntoGoo, + ePlayerStreamSnd_Icy, + ePlayerStreamSnd_Defeated, + ePlayerStreamSnd_StartingOut, + ePlayerStreamSnd_RunningLong, + ePlayerStreamSnd_LedgeHang, + ePlayerStreamSnd_WallJump, + ePlayerStreamSnd_UpgradeComment1, + ePlayerStreamSnd_UpgradeCommentsBase = 0x42, + ePlayerStreamSnd_UpgradeComment2, + ePlayerStreamSnd_UpgradeComment3, + ePlayerStreamSnd_UpgradeComment4, + ePlayerStreamSnd_UpgradeComment4Health, + ePlayerStreamSnd_UpgradeCommentsHealthBase = 0x46, + ePlayerStreamSnd_UpgradeComment5Health, + ePlayerStreamSnd_UpgradeComment6Health, + ePlayerStreamSnd_Laughing, + ePlayerStreamSnd_SuggestOtherCharacter, + ePlayerStreamSnd_SmashTiki, + ePlayerStreamSnd_SmashWoodTiki, + ePlayerStreamSnd_SmashLoveyTiki, + ePlayerStreamSnd_SmashShrinkyTiki, + ePlayerStreamSnd_SmashExplodeTiki, + ePlayerStreamSnd_SmashSteelTiki, + ePlayerStreamSnd_EnemyDefeated, + ePlayerStreamSnd_SeeFogger, + ePlayerStreamSnd_SeeSlammer, + ePlayerStreamSnd_SeePopper, + ePlayerStreamSnd_SeeSpinner, + ePlayerStreamSnd_SeeFlinger, + ePlayerStreamSnd_SeeMiniMerv, + ePlayerStreamSnd_SeeTurret, + ePlayerStreamSnd_SeeJellyFish, + ePlayerStreamSnd_SeeMervyn, + ePlayerStreamSnd_SeeBucketotron, + ePlayerStreamSnd_GotManliness, + ePlayerStreamSnd_GotHealth, + ePlayerStreamSnd_GotGGToken, + ePlayerStreamSnd_GotTreasureChest, ePlayerStreamSnd_Total }; @@ -285,7 +279,6 @@ struct zLedgeGrabParams F32 endrot; }; -// Size: 0x448 struct zPlayerSettings { _zPlayerType pcType; @@ -311,6 +304,8 @@ struct zPlayerSettings U8 talk_anims; U8 talk_filter_size; U8 talk_filter[4]; + U32 Health; + U32 MaxHealth; }; struct zPlayerCarryInfo diff --git a/src/SB/Game/zEntPlayerCar.h b/src/SB/Game/zEntPlayerCar.h new file mode 100644 index 0000000..e3f09b9 --- /dev/null +++ b/src/SB/Game/zEntPlayerCar.h @@ -0,0 +1,15 @@ +#ifndef ZENTPLAYERCAR_H +#define ZENTPLAYERCAR_H + +#include "xEnt.h" +#include "zCar.h" + +void zEntPlayerCarHandleEvents(xBase* from, xBase* to, U32 toEvent, F32* toParam, + xBase* toParamWidget, U32 toParamWidgetID); +void zEntPlayerCarUpdateHealth(xEnt* ent, F32 dt); +void zEntPlayerCarRenderFX(xEnt* ent); +U8 zEntPlayerCarUpdate(xEnt* ent, xScene* sc, F32 dt); +void zEntPlayerCarExit(); +//zCar* zEntPlayerCarGetCar(); + +#endif diff --git a/src/SB/Game/zEnv.h b/src/SB/Game/zEnv.h index 6c21e77..b31d2c1 100644 --- a/src/SB/Game/zEnv.h +++ b/src/SB/Game/zEnv.h @@ -3,20 +3,15 @@ #include "xBase.h" #include "xEnv.h" +#include "iEnv.h" -struct _zEnv : xBase -{ - xEnvAsset* easset; -}; - -void zEnvInit(void* env, void* easset); -void zEnvInit(_zEnv* env, xEnvAsset* easset); -void zEnvSetup(_zEnv* env); -void zEnvStartingCamera(_zEnv* env); -void zEnvRender(xEnv* env); -void zEnvSave(_zEnv* ent, xSerial* s); +void zEnvEventCB(xBase* to, U32 toEvent, F32* toParam, xBase* toParamWidget); void zEnvLoad(_zEnv* ent, xSerial* s); -void zEnvReset(_zEnv* env); -S32 zEnvEventCB(xBase*, xBase* to, U32 toEvent, const F32* toParam, xBase*); +void zEnvSave(_zEnv* ent, xSerial* s); +void zEnvRender(xEnv* env); +void zEnvStartingCamera(); +void zEnvSetup(_zEnv* env); +void zEnvInit(_zEnv* env, xEnvAsset* easset); +void zEnvInit(void* env, void* easset); #endif diff --git a/src/SB/Game/zGlobals.h b/src/SB/Game/zGlobals.h index 348052a..7e4aac0 100644 --- a/src/SB/Game/zGlobals.h +++ b/src/SB/Game/zGlobals.h @@ -9,24 +9,28 @@ #include "zEntPlayer.h" #include "zScene.h" +enum zGlobalDemoType +{ + zDT_NONE, + zDT_E3, + zDT_PUBLICITY, + zDT_OPM, + zDT_LAST +}; + struct zGlobalSettings { - // 0x874 in globals U16 AnalogMin; U16 AnalogMax; F32 SundaeTime; F32 SundaeMult; U32 InitialShinyCount; U32 InitialSpatulaCount; - - // 0x888 in globals S32 ShinyValuePurple; S32 ShinyValueBlue; S32 ShinyValueGreen; S32 ShinyValueYellow; S32 ShinyValueRed; - - // 0x89C in globals S32 ShinyValueCombo0; S32 ShinyValueCombo1; S32 ShinyValueCombo2; @@ -43,8 +47,6 @@ struct zGlobalSettings S32 ShinyValueCombo13; S32 ShinyValueCombo14; S32 ShinyValueCombo15; - - // 0x8DC in globals F32 ComboTimer; U32 Initial_Specials; U32 TakeDamage; @@ -57,9 +59,7 @@ struct zGlobalSettings U32 CheatPlayerSwitch; U32 CheatAlwaysPortal; U32 CheatFlyToggle; - U32 DisableForceConversation; - F32 StartSlideAngle; - F32 StopSlideAngle; + U32 FriendlySelectMode; F32 RotMatchMaxAngle; F32 RotMatchMatchTime; F32 RotMatchRelaxTime; @@ -69,12 +69,14 @@ struct zGlobalSettings F32 BBashDelay; F32 BBashCVTime; F32 BBounceSpeed; + F32 BBashGauntletDelay; + F32 BBashGauntletBlastRadius; F32 BSpinMinFrame; F32 BSpinMaxFrame; F32 BSpinRadius; - F32 SandyMeleeMinFrame; - F32 SandyMeleeMaxFrame; - F32 SandyMeleeRadius; + F32 BSpinReach; + F32 BSpinReachUpgrade; + F32 CartwheelDamageSize; F32 BubbleBowlTimeDelay; F32 BubbleBowlLaunchPosLeft; F32 BubbleBowlLaunchPosUp; @@ -102,9 +104,9 @@ struct zGlobalSettings F32 SlideAirDblSlowTime; F32 SlideVelDblBoost; U8 SlideApplyPhysics; - // 0x9BD in globals - U8 PowerUp[2]; - U8 InitialPowerUp[2]; + U8 PowerUp[10]; + U8 InitialPowerUp[10]; + U8 AttractModeDuringGameplay; }; struct xEntBoulder; @@ -123,32 +125,23 @@ struct zCheckPoint #define LEVEL_COUNT 15 +struct zRewardsMgr; + struct zPlayerGlobals { - // 0x6E0 in globals - zEnt ent; - - // 0x7B4 in globals xEntShadow entShadow_embedded; xShadowSimpleCache simpShadow_embedded; - - // 0x874 in globals zGlobalSettings g; - - // 0x9C4 in globals zPlayerSettings* s; zPlayerSettings sb; zPlayerSettings patrick; - zPlayerSettings sandy; - - // 0x16A0 in globals + zPlayerSettings spongepat; + xLightKit* pPlayerLightKit; xModelInstance* model_spongebob; xModelInstance* model_patrick; - xModelInstance* model_sandy; - - // 0x16AC in globals + xModelInstance* model_spongepat; + xModelInstance* model_car; U32 Visible; - U32 Health; // 0x16b0 S32 Speed; F32 SpeedMult; S32 Sneak; @@ -159,8 +152,6 @@ struct zPlayerGlobals S32 Stepping; S32 JumpState; S32 LastJumpState; - - // 0x16DC in globals F32 JumpTimer; F32 LookAroundTimer; U32 LookAroundRand; @@ -172,33 +163,21 @@ struct zPlayerGlobals F32 ScareTimer; xBase* ScareSource; F32 CowerTimer; - F32 DamageTimer; // 0x1708 + F32 DamageTimer; F32 SundaeTimer; F32 ControlOffTimer; F32 HelmetTimer; - - // Offset: 0x1718 U32 WorldDisguise; U32 Bounced; F32 FallDeathTimer; F32 HeadbuttVel; F32 HeadbuttTimer; - U32 SpecialReceived; - xEnt* MountChimney; - F32 MountChimOldY; - U32 MaxHealth; - - // Offset: 0x173C U32 DoMeleeCheck; - F32 VictoryTimer; - F32 BadGuyNearTimer; F32 ForceSlipperyTimer; F32 ForceSlipperyFriction; F32 ShockRadius; F32 ShockRadiusOld; F32 Face_ScareTimer; - - // Offset: 0x175C U32 Face_ScareRandom; U32 Face_Event; F32 Face_EventTimer; @@ -210,22 +189,21 @@ struct zPlayerGlobals F32 IdleSitTimer; S32 Transparent; zEnt* FireTarget; - U32 ControlOff; // 0x1788 + U32 PlayerIsFrozen; + U32 ControlOff; U32 ControlOnEvent; - - // Offset: 0x1790 U32 AutoMoveSpeed; F32 AutoMoveDist; xVec3 AutoMoveTarget; xBase* AutoMoveObject; zEnt* Diggable; - F32 DigTimer; // 0x17AC + F32 DigTimer; zPlayerCarryInfo carry; zPlayerLassoInfo lassoInfo; xModelTag BubbleWandTag[2]; - xModelInstance* model_wand; // 0x19E0 - xEntBoulder* bubblebowl; - F32 bbowlInitVel; // 0x19E8 + xModelInstance* model_wand; + xEntBoulder* bubblebowl[2]; + F32 bbowlInitVel; zEntHangable* HangFound; zEntHangable* HangEnt; zEntHangable* HangEntLast; @@ -240,8 +218,6 @@ struct zPlayerGlobals F32 Jump_CurrGravity; F32 Jump_HoldTimer; F32 Jump_ChangeTimer; - - // Offset: 0x1AB8 S32 Jump_CanDouble; S32 Jump_CanFloat; S32 Jump_SpringboardStart; @@ -250,8 +226,6 @@ struct zPlayerGlobals S32 CanBubbleSpin; S32 CanBubbleBounce; S32 CanBubbleBash; - - // Offset: 0x1AD8 in globals S32 IsJumping; S32 IsDJumping; S32 IsBubbleSpinning; @@ -259,29 +233,28 @@ struct zPlayerGlobals S32 IsBubbleBashing; S32 IsBubbleBowling; S32 WasDJumping; - S32 IsCoptering; _zPlayerWallJumpState WallJumpState; S32 cheat_mode; - - // Offset: 0x1B00 in globals - U32 Inv_Shiny; - U32 Inv_Spatula; - U32 Inv_PatsSock[LEVEL_COUNT]; - U32 Inv_PatsSock_Max[LEVEL_COUNT]; - - // Offset: 0x1B80 in globals - U32 Inv_PatsSock_CurrentLevel; - U32 Inv_LevelPickups[LEVEL_COUNT]; - U32 Inv_LevelPickups_CurrentLevel; - - // Offset: 0x1BC4 in globals - U32 Inv_PatsSock_Total; + zRewardsMgr* rewardsMgr; + U32 ManlinessPointsCurrentRange; + U32 InvManlinessPoints; + U32 InvManlinessPointsMultiplier; + U32 InvGoofyGoober; + U32 InvTreasureChest[20]; + U32 InvTreasureChestMax[20]; + U32 InvTreasureChestCurrentLevel; + U32 InvLevelPickups[20]; + U32 InvLevelPickupsCurrentLevel; + U32 InvTreasureChestTotal; + U32 InvTreasureChestOpened; + U32 CurrentSkillLevel; + U32 InitialUnusedSkillPoints; + S16 CurrentUnusedSkillPoints; + S16 CurrentSpentSkillPoints; xModelTag BubbleTag; xEntDrive drv; xSurface* floor_surf; xVec3 floor_norm; - - // Offset: 0x1C74 in globals S32 slope; xCollis earc_coll; xSphere head_sph; @@ -290,18 +263,18 @@ struct zPlayerGlobals U32 TongueFlags[2]; xVec3 RootUp; xVec3 RootUpTarget; - zCheckPoint cp; + zCheckPoint checkpoint; U32 SlideTrackSliding; U32 SlideTrackCount; - xEnt* SlideTrackEnt[111]; + xEnt* SlideTrackEnt[161]; U32 SlideNotGroundedSinceSlide; xVec3 SlideTrackDir; xVec3 SlideTrackVel; F32 SlideTrackDecay; F32 SlideTrackLean; F32 SlideTrackLand; - U8 sb_model_indices[14]; - xModelInstance* sb_models[14]; + char* sb_model_indices; + xModelInstance* sb_models[11]; U32 currentPlayer; xVec3 PredictRotate; xVec3 PredictTranslate; @@ -309,16 +282,24 @@ struct zPlayerGlobals xVec3 PredictCurrDir; F32 PredictCurrVel; F32 KnockBackTimer; - F32 KnockIntoAirTimer; // 0x1FB4 + F32 KnockIntoAirTimer; }; struct zGlobals : xGlobals { + U32 playerTag; + U32 playerLoaded; + U32 playerLoadOrder[8]; + U8 invertJoystick; zPlayerGlobals player; - zAssetPickupTable* pickupTable; // 0x1FB8 - zCutsceneMgr* cmgr; // 0x1FBC - zScene* sceneCur; // 0x1FC0 - zScene* scenePreload; + zAssetPickupTable* pickupTable; + zCutsceneMgr* cmgr; + zCutsceneMgr* DisabledCutsceneDoneMgr; + char startDebugMode[32]; + U32 noMovies; + U32 boundUpdateTime; + U8 draw_player_after_fx; + zGlobalDemoType demoType; }; extern zGlobals globals; diff --git a/src/SB/Game/zNPCFXCinematic.h b/src/SB/Game/zNPCFXCinematic.h new file mode 100644 index 0000000..b0ca25a --- /dev/null +++ b/src/SB/Game/zNPCFXCinematic.h @@ -0,0 +1,201 @@ +#ifndef ZNPCFXCINEMATIC_H +#define ZNPCFXCINEMATIC_H + +#include +#include "zCutsceneMgr.h" +#include "zNPCSupplement.h" +#include "xVec3.h" +#include "zLightning.h" +#include "zNPCHazard.h" +#include "zParEmitter.h" +#include "zShrapnel.h" +#include "rwcore.h" + +void zNPCFXStartup(); +void zNPCFXShutdown(); +S32 zNPCFXCutscenePrep(const xScene*, F32, const zCutsceneMgr* csnmgr); +void zNPCFXCutscene(const xScene*, F32, const zCutsceneMgr* csnmgr); +void zNPCFXCutsceneDone(const xScene*, F32, const zCutsceneMgr* csnmgr); + +struct NCINLyt +{ + zLightning* lyt_zap; +}; + +struct NCINHaz +{ + NPCHazard* npchaz; +}; + +struct NCINLamp +{ + xVec3 pos_robo; + RwRaster* rast; +}; + +struct NCINDRay +{ + RwRaster* rast; +}; + +struct NCINStrk +{ + U32 sid_vert; + U32 sid_horz; +}; + +struct NCINArc +{ + zLightning* lightning; + xVec3 endPos; +}; + +struct NCINPar +{ + zParEmitter* emitter; +}; + +struct NCINEnts +{ + xEnt* ent[4]; +}; + +struct NCINShrap +{ + zShrapnelAsset* shrap; +}; + +struct NCINCustom +{ + F32 f[1]; + xVec3 v[2]; +}; + +struct NCINRast +{ + RwRaster* raster; +}; + +struct NCINMat +{ + RwMatrixTag* mat; +}; + +struct NCINData +{ + union + { + NCINLyt lytdata; + NCINHaz hazdata; + NCINLamp lampdata; + NCINDRay draydata; + NCINStrk strkdata; + NCINArc arcdata; + NCINPar pardata; + NCINEnts entdata; + NCINShrap shrapdata; + NCINCustom customdata; + NCINRast rastinfo; + NCINMat matdata; + }; +}; + +enum en_ncinfx +{ + NCIN_FXTYP_UNKNOWN, + NCIN_FXTYP_EXAMPLE, + NCIN_FXTYP_BUBSLAM_LG, + NCIN_FXTYP_BUBSLAM_SM, + NCIN_FXTYP_SMOKETRAIL, + NCIN_FXTYP_BUBTRAIL, + NCIN_FXTYP_BUBTRAILBONE, + NCIN_FXTYP_BUBWIPE, + NCIN_FXTYP_JELLYLIGHT_01, + NCIN_FXTYP_WATERSPLASH, + NCIN_FXTYP_TARTARSHOOT, + NCIN_FXTYP_OILSHOOT, + NCIN_FXTYP_BONESHOOT, + NCIN_FXTYP_BONETRAIL, + NCIN_FXTYP_BOMBTRAIL, + NCIN_FXTYP_OILHAZARD, + NCIN_FXTYP_TARTARSTEAM, + NCIN_FXTYP_ARFDOGBOOM, + NCIN_FXTYP_SHIELDPOP, + NCIN_FXTYP_TTGUNSMOKE, + NCIN_FXTYP_SPATULAGLOW, + NCIN_FXTYP_HOOKRECOIL, + NCIN_FXTYP_FODDERPROD, + NCIN_FXTYP_BZZTDANCE, + NCIN_FXTYP_BZZTBEAM, + NCIN_FXTYP_BADBREATH, + NCIN_FXTYP_BOMBBLINK, + NCIN_FXTYP_HAMSHOCK, + NCIN_FXTYP_HAMSTREAK, + NCIN_FXTYP_MONCLOUD, + NCIN_FXTYP_MIDFISH, + NCIN_FXTYP_GLOVEFRAG, + NCIN_FXTYP_MARYBOOM, + NCIN_FXTYP_PETEBONK, + NCIN_FXTYP_FIRESPIRAL, + NCIN_FXTYP_SLEEPYLAMP, + NCIN_FXTYP_SLEEPYDRAY, + NCIN_FXTYP_B101OPEN_SBENTER, + NCIN_FXTYP_B101OPEN_PATENTER, + NCIN_FXTYP_B101OPEN_SHOCKWAVE, + NCIN_FXTYP_B101ROUND1_SHOCK1, + NCIN_FXTYP_B101ROUND1_SHOCK2, + NCIN_FXTYP_B101ROUND1_SHOCK3, + NCIN_FXTYP_B101ENDING_SHOCK1, + NCIN_FXTYP_B101ENDING_SHOCK2, + NCIN_FXTYP_B101ENDING_SHOCK3, + NCIN_FXTYP_B101ENDING_SHOCK4, + NCIN_FXTYP_B101ENDING_SHOCKWAVE, + NCIN_FXTYP_B201OPEN_FREEZE, + NCIN_FXTYP_B201ROUND1_FREEZE, + NCIN_FXTYP_B201HIDECONVEYOR, + NCIN_FXTYP_B201GOOLEVER, + NCIN_FXTYP_B201FRAG, + NCIN_FXTYP_B303STUFF, + NCIN_FXTYP_PAR_ENTITY_BONE, + NCIN_FXTYP_PROBE, + NCIN_FXTYP_DUPLOPUFFS, + NCIN_FXTYP_SPAWNRING, + NCIN_FXTYP_BUBPLYRSKEL, + NCIN_FXTYP_GLINT, + NCIN_FXTYP_NOMORE, + NCIN_FXTYP_FORCE = 0x7fffffff +}; + +struct NCINEntry +{ + en_ncinfx typ_ncinfx; + void (*cb_fxupd)(zCutsceneMgr*, NCINEntry*, U32); + void (*cb_fxanim)(zCutsceneMgr*, NCINEntry*, RpAtomic*, RwMatrixTag*, U32, U32); + void (*cb_fxrend)(zCutsceneMgr*, NCINEntry*); + F32 tym_beg; + F32 tym_end; + xVec3 pos_A[2]; + xVec3 pos_B[2]; + S8* twk_name; + S32 idx_anim; + S32 idx_bone; + S32 flg_stat; + NCINData fxdata; +}; + +struct NPCCone +{ + F32 rad_cone; + RwRGBA rgba_top; + RwRGBA rgba_bot; + RwRaster* rast_cone; + F32 uv_tip[2]; + F32 uv_slice[2]; + void TextureSet(RwRaster* raster); + void UVSliceSet(F32 u, F32 v); + void UVBaseSet(F32 u, F32 v); + void ColorSet(RwRGBA top, RwRGBA bot); + void RadiusSet(F32); +}; + +#endif diff --git a/src/SB/Game/zNPCSupplement.h b/src/SB/Game/zNPCSupplement.h new file mode 100644 index 0000000..11a411d --- /dev/null +++ b/src/SB/Game/zNPCSupplement.h @@ -0,0 +1,305 @@ +#ifndef ZNPCSUPPLEMENT_H +#define ZNPCSUPPLEMENT_H + +#include "iColor.h" + +#include "xMath2.h" +#include "xPtankPool.h" +#include "xVec3.h" + +#include +#include +#include + +enum en_nparptyp +{ + NPAR_TYP_UNKNOWN, + NPAR_TYP_OILBUB, + NPAR_TYP_TUBESPIRAL, + NPAR_TYP_TUBECONFETTI, + NPAR_TYP_GLOVEDUST, + NPAR_TYP_MONSOONRAIN, + NPAR_TYP_SLEEPYZEEZ, + NPAR_TYP_CHUCKSPLASH, + NPAR_TYP_TARTARGUNK, + NPAR_TYP_DOGBREATH, + NPAR_TYP_VISSPLASH, + NPAR_TYP_FIREWORKS, + NPAR_TYP_NOMORE, + NPAR_TYP_FORCE = 0x7fffffff +}; + +enum en_npcstreak +{ + NPC_STRK_TARTARBLOB, + NPC_STRK_OILBUBBLE, + NPC_STRK_HAMMERSMASH_VERT, + NPC_STRK_HAMMERSMASH_HORZ, + NPC_STRK_ARFMELEE, + NPC_STRK_TOSSEDROBOT, + NPC_STRK_TOSSEDJELLY, + NPC_STRK_TOSSEDJELLYBLUE, + NPC_STRK_NOMORE, + NPC_STRK_FORCE = 0x7fffffff +}; + +enum en_nparmode +{ + NPAR_MODE_STD = 0, + NPAR_MODE_ALT_A = 1, + NPAR_MODE_ALT_B = 2, + NPAR_MODE_ALT_C = 3, + NPAR_MODE_ALT_D = 4, + NPAR_MODE_ALT_E = 5, + NPAR_MODE_SPIRALNORM = 1, + NPAR_MODE_SPIRALCALT = 2, + NPAR_MODE_SPIRALCINE = 3, + NPAR_MODE_OIL_TRAIL = 1, + NPAR_MODE_OIL_VAPOR = 2, + NPAR_MODE_OIL_SPLASH = 3, + NPAR_MODE_FETTI_SPARKLIES = 1, + NPAR_MODE_DRIP = 1, + NPAR_MODE_DROP = 2, + NPAR_MODE_SPLASH = 3, + NPAR_MODE_TRAIL = 4, + NPAR_MODE_TTNOZZLE = 1, + NPAR_MODE_TTTRAIL = 2, + NPAR_MODE_TTSPLASH = 3, + NPAR_MODE_TTSPOIL = 4, + NPAR_MODE_TTSMOKE = 5, + NPAR_MODE_DOGGYWISP = 1, + NPAR_MODE_DOGGYATTACK = 2, + NPAR_MODE_FWEXHAUST = 1, + NPAR_MODE_FWSTARBURST = 2, + NPAR_MODE_FWGLITTER = 3, + NPAR_MODE_NOMORE = 4, +}; + +struct NPARData +{ + xVec3 pos; + F32 xy_size[2]; + F32 uv_tl[2]; + F32 uv_br[2]; + RwRGBA color; + F32 tmr_remain; + F32 tym_exist; + F32 fac_abuse; + xVec3 vel; + struct + { + S32 flg_popts : 24; + S32 nparmode : 8; + }; + F32 unused[3]; +}; + +struct NPARXtraData +{ +}; + +class NPARParmVisSplash +{ + // total size: 0x20 +public: + F32 tym_lifespan; // offset 0x0, size 0x4 + RwRGBA colr_base; // offset 0x4, size 0x4 + F32 siz_base[2]; // offset 0x8, size 0x8 + xVec3 acc_base; // offset 0x10, size 0xC + S32 pct_keep; // offset 0x1C, size 0x4 + + void ConfigPar(NPARData* par, en_nparmode pmod, const xVec3* pos, const xVec3* vel) const; +}; + +class NPARParmTarTarGunk +{ + // total size: 0x28 +public: + F32 tym_lifespan; // offset 0x0, size 0x4 + RwRGBA colr_base; // offset 0x4, size 0x4 + F32 siz_base[2]; // offset 0x8, size 0x8 + xVec3 acc_base; // offset 0x10, size 0xC + F32 uv_scroll[2]; // offset 0x1C, size 0x8 + U8 row_uvstart; // offset 0x24, size 0x1 + U8 num_uvcell[2]; // offset 0x25, size 0x2 + U8 pct_keep; // offset 0x27, size 0x1 + + void ConfigPar(NPARData*, en_nparmode, const xVec3*, const xVec3*) const; +}; + +class NPARParmFahrwerkz +{ + // total size: 0x28 +public: + F32 tym_lifespan; // offset 0x0, size 0x4 + RwRGBA colr_base; // offset 0x4, size 0x4 + F32 siz_base[2]; // offset 0x8, size 0x8 + xVec3 acc_base; // offset 0x10, size 0xC + F32 uv_scroll[2]; // offset 0x1C, size 0x8 + U8 row_uvstart; // offset 0x24, size 0x1 + U8 num_uvcell[2]; // offset 0x25, size 0x2 + U8 pct_keep; // offset 0x27, size 0x1 + + void ConfigPar(NPARData*, en_nparmode, const xVec3*, const xVec3*) const; +}; + +class NPARParmSleepyZeez +{ + // total size: 0x28 +public: + F32 tym_lifespan; // offset 0x0, size 0x4 + RwRGBA colr_base; // offset 0x4, size 0x4 + F32 siz_base[2]; // offset 0x8, size 0x8 + xVec3 acc_base; // offset 0x10, size 0xC + F32 uv_scroll[2]; // offset 0x1C, size 0x8 + U8 row_uvstart; // offset 0x24, size 0x1 + U8 num_uvcell[2]; // offset 0x25, size 0x2 + U8 pct_keep; // offset 0x27, size 0x1 + + void ConfigPar(NPARData*, en_nparmode, const xVec3*, const xVec3*) const; +}; + +class NPARParmDogBreath +{ + // total size: 0x20 +public: + F32 tym_lifespan; // offset 0x0, size 0x4 + RwRGBA colr_base; // offset 0x4, size 0x4 + F32 siz_base[2]; // offset 0x8, size 0x8 + xVec3 acc_base; // offset 0x10, size 0xC + U8 pct_keep; // offset 0x1C, size 0x1 + U8 unused[3]; // offset 0x1D, size 0x3 + + void ConfigPar(NPARData* par, en_nparmode pmod, const xVec3* pos, const xVec3* vel) const; +}; + +class NPARParmGloveDust +{ + // total size: 0x1C +public: + F32 tym_lifespan; // offset 0x0, size 0x4 + RwRGBA colr_base; // offset 0x4, size 0x4 + F32 siz_base[2]; // offset 0x8, size 0x8 + xVec3 acc_base; // offset 0x10, size 0xC + + void ConfigPar(NPARData* par, en_nparmode pmod, const xVec3* pos, const xVec3* vel) const; +}; + +class NPARParmOilBub +{ + // total size: 0x1C +public: + F32 tym_lifespan; // offset 0x0, size 0x4 + RwRGBA colr_base; // offset 0x4, size 0x4 + xVec3 acc_oilBubble; // offset 0x8, size 0xC + F32 siz_base[2]; // offset 0x14, size 0x8 + + void ConfigPar(NPARData*, en_nparmode, const xVec3*, const xVec3*) const; +}; + +class NPARParmTubeConfetti +{ + // total size: 0x28 +public: + F32 tym_lifespan; // offset 0x0, size 0x4 + RwRGBA colr_base; // offset 0x4, size 0x4 + F32 siz_base[2]; // offset 0x8, size 0x8 + xVec3 acc_base; // offset 0x10, size 0xC + F32 uv_scroll[2]; // offset 0x1C, size 0x8 + U8 row_uvstart; // offset 0x24, size 0x1 + U8 num_uvcell[2]; // offset 0x25, size 0x2 + U8 pct_keep; // offset 0x27, size 0x1 + + void ConfigPar(NPARData*, en_nparmode, const xVec3*, const xVec3*) const; +}; + +class NPARParmTubeSpiral +{ + // total size: 0xC +public: + RwRGBA colr_base; // offset 0x0, size 0x4 + F32 siz_base[2]; // offset 0x4, size 0x8 + + void ConfigPar(NPARData*, en_nparmode, const xVec3*, const xVec3*, F32 dt) const; +}; + +class NPARParmChuckSplash +{ + // total size: 0x20 +public: + F32 tym_lifespan; // offset 0x0, size 0x4 + RwRGBA colr_base; // offset 0x4, size 0x4 + F32 siz_base[2]; // offset 0x8, size 0x8 + xVec3 acc_base; // offset 0x10, size 0xC + S32 pct_keep; // offset 0x1C, size 0x4 + + void ConfigPar(NPARData*, en_nparmode, const xVec3*, const xVec3*) const; +}; + +struct NPARMgmt +{ + en_nparptyp typ_npar; + S32 flg_npar; + NPARData* par_buf; + S32 cnt_active; + S32 num_max; + RwTexture* txtr; + NPARXtraData* xtra_data; + void** user_data; + void KillAll(); + + void Init(en_nparptyp parType, void** userData, NPARXtraData* xtraData); + void Clear(); + void Done(); + void Reset(); + S32 IsReady(); + void UpdateAndRender(F32 param_1); + void XtraDataSet(NPARXtraData* param_1); + void UserDataSet(void** user_data); + NPARData* NextAvail(); +}; + +struct NPARInfo +{ + void (*fun_update)(NPARMgmt*, F32); + S32 num_maxParticles; + char* nam_texture; + S32 flg_npar; +}; + +struct StreakInfo +{ + F32 freq; + F32 alf_fade; + F32 alf_start; + U32 idx_useTxtr; + iColor_tag rgba_left; + iColor_tag rgba_right; + S32 taper; +}; + +void NPCC_MakeASplash(const xVec3* pos, F32 radius); +void NPCSupplement_Startup(); +void NPCSupplement_Shutdown(); +void NPCSupplement_ScenePrepare(); +void NPCSupplement_SceneFinish(); +void NPCSupplement_SceneReset(); +void NPCSupplement_ScenePostInit(); +void NPCSupplement_Timestep(F32 dt); +void NPAR_ScenePrepare(); +void NPAR_SceneFinish(); +void NPAR_EmitTarTarTrail(const xVec3*, const xVec3*); +NPARMgmt* NPAR_PartySetup(en_nparptyp parType, void** userData, NPARXtraData* xtraData); +void NPAR_SceneReset(); +static void NPCC_ShadowCacheReset(); +void NPAR_Timestep(F32 dt); +void NPAR_EmitDroplets(en_nparmode, const xVec3*, const xVec3*); +void NPCC_MakeStreakInfo(en_npcstreak styp, StreakInfo* info); +U32 xFXStreakStart(StreakInfo* styp); +U32 NPCC_StreakCreate(en_npcstreak styp); +void UpdateAndRender(NPARMgmt param_1, F32 dt); +F32 BOWL3(F32 param_1); +F32 QUB(F32 param_1); +F32 BOWL(F32 param_1); + +#endif diff --git a/src/SB/Game/zScene.h b/src/SB/Game/zScene.h index 227e12f..dcb0d57 100644 --- a/src/SB/Game/zScene.h +++ b/src/SB/Game/zScene.h @@ -8,27 +8,39 @@ #include "xEnt.h" #include "xEnv.h" #include "zBase.h" +#include "xDynAsset.h" struct zEnt; +struct zSceneParameters : xDynAsset +{ + U32 idle03ExtraCount; + xAnimFile** idle03Extras; + U32 idle04ExtraCount; + xAnimFile** idle04Extras; + U8 bombCount; + U8 extraIdleDelay; + U8 hdrGlow; + U8 hdrDarken; + U32 uDefaultMusicHash; + U32 flags; + F32 waterTileWidth; + F32 lodFadeDistance; + U32 pad[4]; +}; + struct zScene : xScene { _zPortal* pendingPortal; - union - { - U32 num_ents; - U32 num_base; - }; - union - { - xBase** base; - zEnt** ents; - }; + S32 num_base; + xBase** base; U32 num_update_base; xBase** update_base; - U32 baseCount[eBaseTypeCount]; - xBase* baseList[eBaseTypeCount]; + S32 baseCount[141]; + xBase* baseList[141]; _zEnv* zen; + zSceneParameters* parameters; + U8 enableDrawing; }; struct zSceneObjectInstanceDesc diff --git a/src/SB/Game/zStreamedSound.h b/src/SB/Game/zStreamedSound.h new file mode 100644 index 0000000..63e5c6f --- /dev/null +++ b/src/SB/Game/zStreamedSound.h @@ -0,0 +1,24 @@ +#ifndef ZSTREAMEDSOUND_H +#define ZSTREAMEDSOUND_H + +#include "iSnd.h" + +struct zStreamedSound +{ + char* mAssetName; + F32 mCycleTime; + U32 mFlags; + F32 mSoonestTimeToPlay; + iSndGroupHandle mSoundGroupHdl; +}; + +struct zStreamedSoundList +{ + U32 mNumSounds; + zStreamedSound* mSounds; + + void Reset(); + void InitWithSounds(zStreamedSound* soundList); +}; + +#endif diff --git a/src/SB/Game/zWad1.cpp b/src/SB/Game/zWad1.cpp index e69de29..f072bc4 100644 --- a/src/SB/Game/zWad1.cpp +++ b/src/SB/Game/zWad1.cpp @@ -0,0 +1,1138 @@ +#include "zWad1.h" +#include "xGlobals.h" +#include "zGlobals.h" + +// zEnv + +void zEnvEventCB(xBase* to, U32 toEvent, F32* toParam, xBase* toParamWidget) +{ +} + +void zEnvLoad(_zEnv* ent, xSerial* s) +{ + xBaseLoad(ent, s); +} + +void zEnvSave(_zEnv* ent, xSerial* s) +{ + xBaseSave(ent, s); +} + +void zEnvRender(xEnv* env) +{ + RpWorld* world = env->geom->world; + S32 num = RpWorldGetNumMaterials(world); + + for (S32 i = 0; i < num; i++) + { + xSurface* sp = zSurfaceGetSurface(i); + zSurfaceProps* pp = (zSurfaceProps*)sp->moprops; + + if (pp && pp->asset && pp->texanim_flags & 0x1) + { + RpMaterial* mp = RpWorldGetMaterial(world, i); + + if (mp) + { + xGroup* g = (xGroup*)pp->texanim[0].group_ptr; + + if (g) + { + U32 texid = xGroupGetItem(g, pp->texanim[0].group_idx); + RwTexture* texptr = (RwTexture*)xSTFindAsset(texid, NULL); + + if (texptr) + { + RpMaterialSetTexture(mp, texptr); + } + } + } + } + } + + xEnvRender(env, FALSE); +} + +void zEnvStartingCamera(_zEnv*) +{ + return; +} + +void zEnvSetup(_zEnv* env) +{ + // TODO + // I don't think the struct is correct + + // This function seems to be correct in BFBB, our globals struct is fucked though. + // Keep this the way it is, and fix the struct + + xBaseSetup(env); + iEnvLightingBasics((iEnv*)globals.sceneCur->env->geom, (xEnvAsset*)env->easset); +} + +// Again, Copied from Battle, Needs a good amount of work +void zEnvInit(_zEnv* env, xEnvAsset* easset) +{ + U32 bufsize; + void* buf; + + xBaseInit(env, easset); + + env->easset = easset; + env->eventFunc = zEnvEventCB; + + if (env->linkCount) + { + env->link = (xLinkAsset*)(env->easset + 1); + } + + globals.sceneCur->zen = env; + globals.sceneCur->zen = env; + + xSTAssetCountByType('BSP '); + + buf = xSTFindAsset(easset->bspAssetID, &bufsize); + + if (buf) + { + xEnvLoadBsp(globals.sceneCur->env, buf, bufsize, 0); + } + + zSurfaceRegisterMapper(easset->bspMapperID); + + if (easset->bspCollisionAssetID) + { + buf = xSTFindAsset(easset->bspCollisionAssetID, &bufsize); + + if (buf) + { + xEnvLoadBsp(globals.sceneCur->env, buf, bufsize, 1); + } + } + + if (easset->bspFXAssetID) + { + buf = xSTFindAsset(easset->bspFXAssetID, &bufsize); + + if (buf) + { + xEnvLoadBsp(globals.sceneCur->env, buf, bufsize, 2); + } + } + + if (easset->bspCameraAssetID) + { + buf = xSTFindAsset(easset->bspCameraAssetID, &bufsize); + + if (buf) + { + xEnvLoadBsp(globals.sceneCur->env, buf, bufsize, 3); + } + } + + if (globals.sceneCur->env && globals.sceneCur->env->geom) + { + zLightResetAll(globals.sceneCur->env); + iLightInit(globals.sceneCur->env->geom->world); + } +} + +void zEnvInit(void* env, void* easset) +{ + zEnvInit((_zEnv*)env, (xEnvAsset*)easset); +} + +// zEGenerator + +void zEGenerator_TurnOn(zEGenerator* egen) +{ + zEGenAsset* zasset; + xAnimPlay* aplay; + xAnimSingle* asing; + U16 itgt; + U16 imp; + S32 i; + xLinkAsset* link; + U32 dstAssetID; + xBase* b; + xVec3 destOffset; + xEnt* ent; + //S32 i; + _tagLightningAdd add; +} + +void zEGenerator_Render(zEGenerator* egen) +{ + xEntRender(egen); +} + +void zEGenerator_Update(zEGenerator* egen, xScene* sc, F32 dt) +{ + xBase* b; + zEnt* ent; +} + +void zEGenerator_Move(zEGenerator* egen, xScene* xscn, F32 tmpFloat) +{ +} + +void zEGenerator_Reset(zEGenerator* egen, xScene* xscn) +{ + zEntReset((zEnt*)egen); + zEGenAsset* zasset = (zEGenAsset*)egen->asset; + egen->flags = (U16)zasset->flags; + if (egen->flags & 1) + { + zEGenerator_TurnOn(egen); + } + else + { + zEGenerator_TurnOff(egen); + } + if (zasset->moreFlags & 0b100) + { + egen->chkby = XENT_COLLTYPE_NONE; + } + else + { + egen->chkby = XENT_COLLTYPE_PLYR | XENT_COLLTYPE_NPC; + } + egen->bupdate((xEnt*)egen, (xVec3*)&egen->model->Mat->pos); +} + +void zEGenerator_Load(zEGenerator* ent, xSerial* s) +{ + zEntLoad(ent, s); +} + +void zEGenerator_Save(zEGenerator* ent, xSerial* s) +{ + zEntSave(ent, s); +} + +void zEGenerator_Setup(zEGenerator* egen, xScene* xscn) +{ + zEntSetup(egen); + egen->num_dsts = 0; + for (S32 i = 0; i < egen->linkCount; i++) + { + xLinkAsset* la = (xLinkAsset*)&egen->link[i]; + xBase* b = (xBase*)zSceneFindObject(la->dstAssetID); + if (b != NULL && la->dstEvent == 0xc0) + { + if (b->baseType == eBaseTypeMovePoint) + { + egen->num_dsts++; + } + else if (b->baseFlags & 0x20) + { + egen->num_dsts++; + } + } + } +} + +void zEGenerator_Init(void* egen, void* asset) +{ +} + +// zDispatcher + +extern st_ZDISPATCH_CONTEXT lbl_80254E00; +extern char lbl_80254E10[512]; + +extern S32 g_zdsp_init; +extern S32 warned_zDispatcher; +extern signed char init_zDispatcher; +extern S32 oldVibrationOption; +extern U32 oldSoundMode; +extern U32 oldMusicVolume; +extern U32 oldSFXVolume; + +extern st_ZDISPATCH_DEPOT g_zdsp_depot; + +extern iColor_tag _1143; + +extern iColor_tag _1142; +extern F32 _1179; +extern F32 _1180; +extern F32 _1181; +extern F32 _1197; +extern F64 _1199; + +extern U8 menu_fmv_played; +extern char zEventLogBuf[256][20]; + +S16 zDispatcher_GetCurrentWorld() +{ +} + +U32 zDispatcher_FindNextValidWorld(U32 sceneID) +{ + char sceneName[4]; + S32 worldIndex; + S32 i; + S32 j; + S32 newIndex; +} + +U32 zDispatcher_FindTaskPointer(U32 sceneID, S32 task) +{ + char sceneName[4]; + S32 i; + S32 j; +} + +void zDispatcher_FindWorldTask(U32 sceneID, S32& world, S32& task) +{ + char sceneName[4]; + S32 i; + S32 j; +} + +// WIP +// FIXME: This switch is a mess, good luck. + +// PORTED DIRECTLY FROM BFBB +// NEEDS A LOT OF WORK +S32 ZDSP_elcb_event(xBase*, xBase* xb, U32 toEvent, const F32* toParam, xBase* toParamWidget) +{ + st_ZDISPATCH_DATA* dspdata = (st_ZDISPATCH_DATA*)xb; + switch (toEvent) + { + case 10: + ZDSP_instReset(dspdata, globals.sceneCur); + break; + case 0x129: + zMusicNotifyEvent(toParam, toParamWidget); + break; + case 0x60: + ZDSP_injectCmd(dspdata, ZDSP_CMD_CTRL_CFGSET, 0); + break; + case 0x61: + ZDSP_injectCmd(dspdata, ZDSP_CMD_CTRL_CFGSET, 1); + break; + case 0x62: + ZDSP_injectCmd(dspdata, ZDSP_CMD_CTRL_CFGSET, 2); + break; + case 0x63: + ZDSP_injectCmd(dspdata, ZDSP_CMD_CTRL_CFGSET, 3); + break; + case 0x64: + ZDSP_injectCmd(dspdata, ZDSP_CMD_CTRL_VIBESET, 1); + break; + case 0x65: + ZDSP_injectCmd(dspdata, ZDSP_CMD_CTRL_VIBESET, 0); + break; + case 0x66: + ZDSP_injectCmd(dspdata, ZDSP_CMD_SNDMOD_SET, 0); + break; + case 0x67: + ZDSP_injectCmd(dspdata, ZDSP_CMD_SNDMOD_SET, 1); + break; + + case 0x68: + ZDSP_injectCmd(dspdata, ZDSP_CMD_SNDVOL_INCR); + break; + case 0x69: + ZDSP_injectCmd(dspdata, ZDSP_CMD_SNDVOL_DECR); + break; + case 0x6a: + ZDSP_injectCmd(dspdata, ZDSP_CMD_MUSVOL_INCR); + break; + case 0x6b: + ZDSP_injectCmd(dspdata, ZDSP_CMD_MUSVOL_DECR); + break; + + case 0x6c: + ZDSP_injectCmd(dspdata, ZDSP_CMD_SFXVOL_INCR); + break; + case 0x6d: + ZDSP_injectCmd(dspdata, ZDSP_CMD_SFXVOL_DECR); + break; + case 0xa9: + zGameStateSwitchEvent(toEvent); + break; + case 0x9e: + globals.currentActivePad = 0; + zGameStateSwitchEvent(0x9e); + break; + case 0xa7: + break; + case 0xa8: + zSaveLoad_DispatchCB(toEvent, toParam); + break; + + case 0xc2: + zEntPlayer_SNDPlay(ePlayerSnd_CheckPoint, _1179); + F32 fVar2; + if (*toParam != _1179) + { + fVar2 = _1180 * *toParam; + } + else + { + //fVar2 = globals.player.ent.frame->rot.angle; + } + zEntPlayer_StoreCheckPoint((xVec3*)toParamWidget, fVar2, globals.oldSkoolCamera.id); + break; + case 0x11e: + zhud::show(); + break; + case 0x11f: + zhud::hide(); + break; + case 0x120: + iColor_tag black = _1142; + iColor_tag clear = _1143; + xScrFxFade(&clear, &black, *toParam, 0, 1); + break; + case 0x126: + menu_fmv_played = 1; + //zFMVPlay(zFMVFileGetName((eFMVFile)(U32)*toParam), 0x10001, _1181, 1, 0); + break; + case 0x130: + zSceneEnableScreenAdj(1); + zSceneSetOldScreenAdj(); + break; + case 0x131: + zSceneEnableScreenAdj(0); + break; + case 0x101: + globals.player.g.PowerUp[(int)*toParam] = 1; + break; + + case 0x1fd: + xCameraFXShake(*toParam, toParam[1], toParam[2], toParam[3], _1179, NULL, NULL); + break; + case 0x210: + xCMstart((xCreditsData*)toParamWidget, *toParam, xb); + break; + + case 0x211: + xCMstop(); + break; + + case 0x217: + char events[512]; + U32 c; + U32 len; + U32 i; + char log[512]; + + for (i = 0; i < 512; i++) + { + events[i] = lbl_80254E10[i]; + } + + c = 0; + for (i = 0; i < 8; i += len) + { + c += 1; + len = strlen((char*)&ringlist[i]); + } + + strcpy(lbl_80254E10, zEventLogBuf[c + 1]); + for (i = c + 2; i < 0x13; i++) + { + strcat(log, zEventLogBuf[i]); + } + strncpy(events, log, 0x200); + break; + case 0x21b: + zDispatcherStoreOptions(); + break; + + case 0x21c: + zDispatcherRestoreOptions(); + break; + } + return 1; +} + +S32 ZDSP_doCommand(st_ZDISPATCH_DATA* dspdata, st_ZDISPATCH_CONTEXT* cmdCtxt) +{ + S32 iv; + en_DISPATCH_COMMAND cmd = cmdCtxt->cmd; + void* indata = cmdCtxt->indata; + void* result = cmdCtxt->result; + + if (init_zDispatcher == 0) + { + warned_zDispatcher = 0; + init_zDispatcher = 1; + } + if (warned_zDispatcher == 0) + { + warned_zDispatcher = 1; + } + + switch (cmd) + { + case ZDSP_CMD_CTRL_CFGGET: + *(S32*)result = 0; + break; + case ZDSP_CMD_CTRL_CFGSET: + if (result != NULL) + { + *(S32*)result = 0; + } + break; + case ZDSP_CMD_CTRL_VIBEGET: + *(S32*)result = zVarEntryCB_VibrationOn(NULL); + break; + case ZDSP_CMD_CTRL_VIBESET: + if (globals.option_vibration != *(S32*)indata) + { + globals.option_vibration = *(S32*)indata; + xPadRumbleEnable(globals.currentActivePad, globals.option_vibration); + zRumbleStart(globals.currentActivePad, SDR_Test); + } + break; + case ZDSP_CMD_SNDMOD_GET: + *(S32*)result = zVarEntryCB_SndMode(NULL); + break; + case ZDSP_CMD_SNDMOD_SET: + if (*(S32*)indata == 0) + { + iSndStereo(0); + } + else if (*(S32*)indata == 1) + { + iSndStereo(1); + } + + if (result != NULL) + { + *(S32*)result = zVarEntryCB_SndMode(NULL); + } + break; + case ZDSP_CMD_MUSVOL_GET: + *(S32*)result = zVarEntryCB_SndMusicVol(NULL); + break; + case ZDSP_CMD_MUSVOL_SET: + WRAP_xsnd_setMusicVolume(*(S32*)indata); + if (result != NULL) + { + *(S32*)result = zVarEntryCB_SndMusicVol(NULL); + } + break; + case ZDSP_CMD_MUSVOL_INCR: + iv = zVarEntryCB_SndMusicVol(NULL); + if (indata != NULL) + { + iv += *(S32*)indata; + } + else + { + iv += 1; + } + WRAP_xsnd_setMusicVolume(iv); + if (result != NULL) + { + *(S32*)result = zVarEntryCB_SndMusicVol(NULL); + } + break; + case ZDSP_CMD_MUSVOL_DECR: + iv = zVarEntryCB_SndMusicVol(NULL); + if (indata != NULL) + { + iv -= *(S32*)indata; + } + else + { + iv -= 1; + } + WRAP_xsnd_setMusicVolume(iv); + if (result != NULL) + { + *(S32*)result = zVarEntryCB_SndMusicVol(NULL); + } + break; + case ZDSP_CMD_SFXVOL_GET: + *(S32*)result = zVarEntryCB_SndFXVol(NULL); + break; + case ZDSP_CMD_SFXVOL_SET: + WRAP_xsnd_setSFXVolume(*(S32*)indata); + if (result != NULL) + { + *(S32*)result = zVarEntryCB_SndFXVol(NULL); + } + break; + case ZDSP_CMD_SFXVOL_INCR: + iv = zVarEntryCB_SndFXVol(NULL); + if (indata != NULL) + { + iv += *(S32*)indata; + } + else + { + iv += 1; + } + WRAP_xsnd_setSFXVolume(iv); + if (result != NULL) + { + *(S32*)result = zVarEntryCB_SndFXVol(NULL); + } + break; + case ZDSP_CMD_SFXVOL_DECR: + iv = zVarEntryCB_SndFXVol(NULL); + if (indata != NULL) + { + iv -= *(S32*)indata; + } + else + { + iv -= 1; + } + WRAP_xsnd_setSFXVolume(iv); + if (result != NULL) + { + *(S32*)result = zVarEntryCB_SndFXVol(NULL); + } + break; + case ZDSP_CMD_GSTATE_GET: + *(S32*)result = zGameStateGet(); + break; + case ZDSP_CMD_GSTATE_SET: + zGameStateSwitch(*(S32*)indata); + if (result != NULL) + { + *(S32*)result = zGameStateGet(); + } + break; + case ZDSP_CMD_GMODE_GET: + *(S32*)result = zGameModeGet(); + break; + case ZDSP_CMD_GMODE_SET: + zGameModeSwitch(*(eGameMode*)indata); + if (result != NULL) + { + *(S32*)result = zGameModeGet(); + } + break; + case ZDSP_CMD_SNDVOL_GET: + case ZDSP_CMD_SNDVOL_SET: + case ZDSP_CMD_SNDVOL_INCR: + case ZDSP_CMD_SNDVOL_DECR: + case ZDSP_CHECKPNT_SET: + break; + } + return 1; +} + +void zDispatcher_Load(st_ZDISPATCH_DATA* dspdata, xSerial* s) +{ + xBaseLoad(dspdata, s); +} + +void zDispatcher_Save(st_ZDISPATCH_DATA* dspdata, xSerial* s) +{ + xBaseSave(dspdata, s); +} + +void zDispatcher_InitDep(st_ZDISPATCH_DATA* dspdata, zScene* zscn) +{ +} + +void zDispatcher_Init(st_ZDISPATCH_DATA* dspdata, xBaseAsset* bass) +{ + xBaseInit(dspdata, bass); + dspdata->rawass = bass; + dspdata->eventFunc = ZDSP_elcb_event; + if (dspdata->linkCount != 0) + { + dspdata->link = (xLinkAsset*)(dspdata->rawass + 1); + } + else + { + dspdata->link = NULL; + } +} + +st_ZDISPATCH_DATA* zDispatcher_getInst(st_ZDISPATCH_DATA* pool, S32 idx) +{ + return &pool[idx]; +} + +st_ZDISPATCH_DATA* zDispatcher_memPool(S32 cnt) +{ + st_ZDISPATCH_DATA* pool; + st_ZDISPATCH_DEPOT* depot = &g_zdsp_depot; + if (cnt < 1) + { + return NULL; + } + else + { + pool = (st_ZDISPATCH_DATA*)xMemAlloc(gActiveHeap, cnt * sizeof(st_ZDISPATCH_DATA), 0); + memset(pool, 0, cnt * sizeof(st_ZDISPATCH_DATA)); + depot->raw_pool = pool; + depot->raw_cnt = cnt; + return pool; + } +} + +void zDispatcher_sceneFinish() +{ + st_ZDISPATCH_DEPOT* depot = &g_zdsp_depot; + + g_zdsp_init--; + if (g_zdsp_init == 0) + { + memset(depot, 0, sizeof(st_ZDISPATCH_DEPOT)); + } +} + +void zDispatcher_scenePrepare() +{ + st_ZDISPATCH_DEPOT* depot = &g_zdsp_depot; + if (g_zdsp_init++ == 0) + { + memset(depot, 0, sizeof(st_ZDISPATCH_DEPOT)); + } +} + +void zDispatcher_Shutdown() +{ +} + +void zDispatcher_Startup() +{ +} + +void zDispatcherParseINI(xIniFile* ini) +{ + S32 i; + char itemName[16]; + char value[256]; + char* value_; + S32 j; + char* ltok; + char* tok; +} + +// z_disco_floor + +// REQUIRES A LOT OF STUFF TO BE PORTED +// TOO LAZY TO DO IT RN + +// zDestructible + +// zCutsceneMgr + +static S32 gCutsceneSkipOK; +static S32 donpcfx; +static U8 ents_hidden; +static S32 s_atomicNumber; + +void zCutsceneMgrUpdate(xBase* to, xScene* sc, F32 dt) +{ + zCutsceneMgr* t = (zCutsceneMgr*)to; + if (t->csn->ShutDownWait) + { + if (donpcfx) + { + zNPCFXCutsceneDone(sc, dt, t); + } + donpcfx = 0; + if (xCutscene_Destroy(t->csn)) + { + zCutsceneMgrKillFX(t); + t->csn = NULL; + globals.cmgr = NULL; + xCameraSetFOV(&globals.oldSkoolCamera, t->oldfov); + } + } + else + { + if (t->csn->Ready) + { + if (!donpcfx) + { + donpcfx = zNPCFXCutscenePrep(sc, dt, t); + } + if (donpcfx) + { + zNPCFXCutscene(sc, dt, t); + } + + zCutsceneMgrUpdateFX(t); + if (t->stop || !xCutscene_Update(t->csn, dt)) + { + if (!t->stop) + { + zEntEvent(to, to, 0x13); + } + + t->csn->PlaybackSpeed = 0.0f; + //zEntEvent(&globals.player.ent, 9); + //zEntEvent(&globals.player.ent, 3); + zEntEvent(to, to, 0xbf); + iCameraSetNearFarClip(0.0f, 0.0f); + + if ((globals.sceneCur->pendingPortal)) + { + //zEntEvent(&globals.player.ent, 8); + //zEntEvent(&globals.player.ent, 4); + xSndStopAll(0xffff); + return; + } + + if (donpcfx) + { + zNPCFXCutsceneDone(sc, dt, t); + } + donpcfx = 0; + + if (xCutscene_Destroy(t->csn)) + { + zCutsceneMgrKillFX(t); + t->csn = NULL; + globals.cmgr = NULL; + xCameraSetFOV(&globals.oldSkoolCamera, t->oldfov); + } + + zMusicUnpause(0); + } + else + { + if (gCutsceneSkipOK && t->csn->Time > gSkipTimeCutscene && + globals.pad0->pressed & 0x50000) + { + zEntEvent(to, to, 0x13); + } + } + } + else + { + iCSLoadStep(t->csn); + if (t->csn->Ready) + { + zCutsceneMgrPlayStart(t); + zEntEvent(to, to, 0x18); + //zEntEvent(&globals.player.ent, 8); + //zEntEvent(&globals.player.ent, 4); + donpcfx = zNPCFXCutscenePrep(sc, dt, t); + } + } + } + check_hide_entities(); +} + +void zCutsceneMgrFinishExit(xBase* to) +{ + zCutsceneMgr* t = (zCutsceneMgr*)to; + + while (1) + { + iFileAsyncService(); + xSndUpdate(); + if (t->csn->Waiting == 0) + break; + iVSync(); + } + if (donpcfx != 0) + { + zNPCFXCutsceneDone(globals.sceneCur, 0.0f, t); + } + donpcfx = 0; + if (xCutscene_Destroy(t->csn) == 0) + { + return; + } + + //zEntEvent(&globals.player.ent, 9); + //zEntEvent(&globals.player.ent, 3); + zCutsceneMgrKillFX(t); + t->csn = NULL; + globals.cmgr = NULL; +} + +void zCutsceneMgrFinishLoad(xBase* to) +{ + zCutsceneMgr* t = (zCutsceneMgr*)to; + + while (true) + { + iFileAsyncService(); + xSndUpdate(); + iCSLoadStep(t->csn); + iTRCDisk::CheckDVDAndResetState(); + if (t->csn->Ready) + { + break; + } + iVSync(); + } + zCutsceneMgrPlayStart(t); + zEntEvent(to, to, 0x18); + //zEntEvent(&globals.player.ent, 8); + //zEntEvent(&globals.player.ent, 4); + return; +} + +void zCutsceneMgrLoad(zCutsceneMgr*, xSerial* s) +{ +} + +void zCutsceneMgrSave(zCutsceneMgr*, xSerial* s) +{ +} + +// zConfig + +U8 zConfig_isPlayerPatrick(ePlayerEnum playerEnum) +{ + U8 isPatrick = 0; + if ((playerEnum >= 10) && (playerEnum <= 0x15)) + { + isPatrick = 1; + } + return isPatrick; +} + +U8 zConfig_isPlayerSpongebob(ePlayerEnum playerEnum) +{ + U8 isSpongebob = 0; + if ((playerEnum >= 0) && (playerEnum <= 10)) + { + isSpongebob = 1; + } + return isSpongebob; +} + +// zConditional + +S32 zConditionalEventCB(xBase*, xBase*, U32, const F32*, xBase*); + +void zConditionalLoad(_zConditional* ent, xSerial* s) +{ + xBaseLoad(ent, s); +} + +void zConditionalSave(_zConditional* ent, xSerial* s) +{ + xBaseSave(ent, s); +} + +void zConditionalInit(void* b, void* asset) +{ + _zConditional* cond = (_zConditional*)b; + + xBaseInit((xBase*)cond, (xBaseAsset*)asset); + cond->eventFunc = (xBaseEventCB)zConditionalEventCB; + //cond->asset = asset; + + if (cond->linkCount != 0) + { + cond->link = (xLinkAsset*)(cond->asset + 1); + } + else + { + cond->link = NULL; + } + zVarInit(zVarEntryTable); +} + +// zCollGeom + +static volatile U32 sNumTables; +static U32 sTableCount[3]; +static zCollGeomTable* sTableList[3]; + +void zCollGeom_CamDisable(xEnt* ent) +{ + ent->camcollModel = NULL; +} + +void zCollGeom_CamEnable(xEnt* ent) +{ + if (!ent->camcollModel) + { + ent->camcollModel = ent->model; + } +} + +void zCollGeom_Init() +{ + sNumTables = xSTAssetCountByType('COLL'); + + if (sNumTables) + { + U32 tmpsize, i, k; + void* data; + + for (k = 0; k < sNumTables; k++) + { + data = xSTFindAssetByType('COLL', k, &tmpsize); + + if (!data) + { + break; + } + + sTableCount[k] = *(U32*)data; + + if (!sTableCount[k]) + { + sTableList[k] = NULL; + break; + } + + sTableList[k] = (zCollGeomTable*)((U32*)data + 1); + + for (i = 0; i < sTableCount[k]; i++) + { + if ((U32)sTableList[k][i].baseModel) + { + sTableList[k][i].baseModel = + (RpAtomic*)xSTFindAsset((U32)sTableList[k][i].baseModel, NULL); + } + + if ((U32)sTableList[k][i].colModel[0]) + { + sTableList[k][i].colModel[0] = + (RpAtomic*)xSTFindAsset((U32)sTableList[k][i].colModel[0], NULL); + } + + if (!sTableList[k][i].colModel[0]) + { + if (sTableList[k][i].camcolModel) + { + sTableList[k][i].camcolModel = + (RpAtomic*)xSTFindAsset((U32)sTableList[k][i].camcolModel, NULL); + } + } + } + } + } +} + +// PORTED FROM BATTLE, GOOD REFERENCE +U32 zCollGeom_EntSetup(xEnt* ent) +{ + U32 i, j; + S32 auto_cam_coll; + + auto_cam_coll = (ent->baseType == eBaseTypeStatic); + + ent->collModel = NULL; + ent->camcollModel = NULL; + + if (ent->model) + { + for (j = 0; j < sNumTables; j++) + { + for (i = 0; i < sTableCount[j]; i++) + { + if (sTableList[j][i].baseModel == ent->model->Data) + { + RpAtomic* imodel; + + if (imodel = sTableList[j][i].colModel[0]) + { + xModelInstance* model = xModelInstanceAlloc(imodel, ent, 0x2000, 0, NULL); + + ent->collModel = model; + ent->collModel->Mat = ent->model->Mat; + + while (imodel = iModelFile_RWMultiAtomic(imodel)) + { + xModelInstanceAttach(xModelInstanceAlloc(imodel, ent, 0x2000, 0, NULL), + model); + } + } + else if (imodel = sTableList[j][i].camcolModel) + { + xModelInstance* model = xModelInstanceAlloc(imodel, ent, 0x2000, 0, NULL); + + ent->camcollModel = model; + ent->camcollModel->Mat = ent->model->Mat; + + while (imodel = iModelFile_RWMultiAtomic(imodel)) + { + xModelInstanceAttach(xModelInstanceAlloc(imodel, ent, 0x2000, 0, NULL), + model); + } + } + else + { + auto_cam_coll = 0; + } + } + } + } + } + + if (auto_cam_coll && !ent->camcollModel) + { + ent->camcollModel = ent->model; + } + + if (ent->collModel) + { + return 1; + } + + ent->collModel = ent->model; + return 0; +} + +// zCar + +#define Car 1 +#define Idle01 2 +#define Drive 3 +#define DriveSlippy 4 +#define Boosting 5 +#define Reversing 6 +#define Crash 7 +#define SpinLeft 8 +#define SpinRight 9 +#define Success 10 +#define Failed 11 +#define Death 12 +#define Jump 13 +#define JumpLandSquash 14 + +#define ANIM_COUNT 78 +extern U32 g_hash_caranim[ANIM_COUNT]; +const char* g_strz_caranim[ANIM_COUNT]; + +// Needs the functions calls updated +// NewState and DefaultBeforeEnter do not have correct amount of params yet + +xAnimTable* CreateAnimTable() +{ + S32 ourAnims[32] = { + // clang-format off + Car, + Idle01, + Drive, + DriveSlippy, + Boosting, + Reversing, + Crash, + SpinLeft, + SpinRight, + Success, + Failed, + Death, + Jump, + JumpLandSquash, + + // clang-format on + }; + + xAnimTable* table = xAnimTableNew("stop0", 0); + + xAnimTableNewState(table, "Car", 0x10, 0, 1.0f, NULL, NULL, 0.0f, NULL, NULL, + xAnimDefaultBeforeEnter, NULL, NULL); +} + +U32 zCar::JumpEndedCB(xAnimTransition* unk0, xAnimSingle* anim, void* unk3) +{ + zCar* pCar = zEntPlayerCarGetCar(); + lastPositionPar[0]; +} diff --git a/src/SB/Game/zWad1.h b/src/SB/Game/zWad1.h new file mode 100644 index 0000000..0bd719c --- /dev/null +++ b/src/SB/Game/zWad1.h @@ -0,0 +1,39 @@ +#ifndef ZWAD1_H +#define ZWAD1_H + +#include +#include +#include + +#include "zEnv.h" +#include "zSurface.h" +#include "xGroup.h" +#include "xstransvc.h" +#include "iLight.h" +#include "zLight.h" +#include "zEGenerator.h" +#include "zDispatcher.h" +#include "xIni.h" +#include "zGameState.h" +#include "zVar.h" +#include "zRumble.h" +#include "zHud.h" +#include "zSaveLoad.h" +#include "xScrFx.h" +#include "zFMV.h" +#include "zMusic.h" +#include "xCM.h" +#include "zDiscoFloor.h" +#include "zCutsceneMgr.h" +#include "xCutsceneMgr.h" +#include "zNPCFXCinematic.h" +#include "iCutscene.h" +#include "iSystem.h" +#include "iTRC.h" +#include "zConfig.h" +#include "xserializer.h" +#include "zConditional.h" +#include "zCar.h" +#include "xString.h" + +#endif diff --git a/src/SB/Game/zWad3.cpp b/src/SB/Game/zWad3.cpp index 65daa1f..e3f0795 100644 --- a/src/SB/Game/zWad3.cpp +++ b/src/SB/Game/zWad3.cpp @@ -791,265 +791,13 @@ void zSceneRenderPostFX() void zSceneRender() { zSceneRenderPreFX(); - xScrFxRender(globals.camera.lo_cam); + xScrFxRender(globals.oldSkoolCamera.lo_cam); zSceneRenderPostFX(); } void zSceneUpdate(F32 dt) { - U32 i; - S32 isPaused; - zScene* s; - xBase** b; - - if (_1496_0 == dt) - { - return; - } - - isPaused = zGameIsPaused(); - gSceneUpdateTime = dt; - - if (!isPaused) - { - zEntPickup_SceneUpdate(dt); - zEntButton_SceneUpdate(dt); - } - - xEntSetTimePassed(dt); - - if (globals.cmgr) - { - zCutsceneMgrUpdate(globals.cmgr, globals.sceneCur, dt); - } - - s = globals.sceneCur; - b = s->update_base; - - gUIMgr.PreUpdate(s, dt); - - if (s->baseCount[eBaseTypeUIFont]) - { - zUIFont* ui = (zUIFont*)s->baseList[eBaseTypeUIFont]; - - for (i = 0; i < s->baseCount[eBaseTypeUIFont]; i++) - { - zUIFont_PreUpdate(&ui[i], s, dt); - } - } - - if (!isPaused) - { - zNPCMgr_sceneTimestep(s, dt); - } - else if (s->sceneID == 'B101') - { - //zNPCBSandy_GameIsPaused(s); - } - else if (s->sceneID == 'B201') - { - //zNPCBPatrick_GameIsPaused(s); - } - - ztextbox::update_all(*s, dt); - //ztalkbox::update_all(*s, dt); - - gUIMgr.Update(s, dt); - - if (xVec3Dist(&sOldPosPlayer, (xVec3*)&globals.player.ent.model->Mat->pos) > _2242 || - xVec3Dist(&sOldPosCamera, &globals.camera.mat.pos) > _2242) - { - sSuddenMove = 1; - } - else - { - sSuddenMove = 0; - } - - sOldPosPlayer = *(xVec3*)&globals.player.ent.model->Mat->pos; - sOldPosCamera = globals.camera.mat.pos; - - xUpdateCull_Update(globals.updateMgr, sSuddenMove ? 100 : 5); - - for (i = 0; i < s->num_update_base; i++) - { - if (!(b[i]->baseFlags & 0x40)) - { - switch (b[i]->baseType) - { - case eBaseTypeUIFont: - { - if (((xEnt*)b[i])->update) - { - ((xEnt*)b[i])->update((xEnt*)b[i], s, dt); - } - break; - } - case eBaseTypeZipLine: - { - if (((xEnt*)b[i])->update && !isPaused) - { - ((xEnt*)b[i])->update((xEnt*)b[i], s, dt); - } - break; - } - case eBaseTypeTrigger: - case eBaseTypePickup: - case eBaseTypePlatform: - case eBaseTypeDoor: - case eBaseTypeSavePoint: - case eBaseTypeItem: - case eBaseTypeDynamic: - case eBaseTypePendulum: - case eBaseTypeHangable: - case eBaseTypeButton: - case eBaseTypeDestructObj: - case eBaseTypeEGenerator: - case eBaseTypeNPC: - case eBaseTypeBoulder: - case eBaseTypeTeleportBox: - { - if (((xEnt*)b[i])->update && !isPaused) - { - ((xEnt*)b[i])->update((xEnt*)b[i], s, dt); - } - break; - } - case eBaseTypeTimer: - { - if (!isPaused || ((xTimer*)b[i])->runsInPause) - { - xTimerUpdate(b[i], s, dt); - } - break; - } - case eBaseTypeScript: - { - if (!isPaused) - { - //zScriptUpdate(b[i], s, dt); - } - break; - } - case eBaseTypeFog: - { - if (!isPaused) - { - xFogUpdate(b[i], s, dt); - } - break; - } - case eBaseTypeParticleEmitter: - { - if (!isPaused) - { - xParEmitterUpdate(b[i], s, dt); - } - break; - } - case eBaseTypeParticleSystem: - { - if (!isPaused && !zGameIsPaused()) - { - xParSysUpdate(b[i], s, dt); - } - break; - } - case eBaseTypeLight: - { - if (!isPaused) - { - zLightUpdate(b[i], s, dt); - } - break; - } - case eBaseTypeSurface: - { - if (!isPaused || ((xSurface*)b[i])->type == XSURFACE_TYPE_3) - { - zSurfaceUpdate(b[i], s, dt); - } - break; - } - case eBaseTypeBusStop: - { - if (!isPaused) - { - //zBusStop_Update(b[i], s, dt); - } - break; - } - case eBaseTypeDiscoFloor: - { - if (!isPaused) - { - ((z_disco_floor*)b[i])->update(*s, dt); - } - - break; - } - case eBaseTypeTaxi: - { - if (!isPaused) - { - //zTaxi_Update(b[i], s, dt); - } - break; - } - case eBaseTypeCameraFly: - { - if (!isPaused) - { - //zCameraFly_Update(b[i], s, dt); - } - break; - } - } - } - } - - if (!isPaused) - { - zEntSimpleObj_MgrCustomUpdate(s, dt); - } - - if (isPaused) - { - zUI_ScenePortalUpdate(); - } - else - { - zUI_ScenePortalSetToCurrentLevel(s); - } - - zNPCCommon_EjectPhlemOnPawz(); - - if (!isPaused) - { - zActionLineUpdate(dt); - xFXStreakUpdate(dt); - xFXShineUpdate(dt); - xFXFireworksUpdate(dt); - zLightningUpdate(dt); - //zGustUpdateFX(dt); - xClimateUpdate(&gClimate, dt); - zShrapnel_Update(dt); - //zCombo_Update(dt); - zFXUpdate(dt); - zLOD_Update(sSuddenMove ? 100 : 5); - zParPTankUpdate(dt); - xDecalUpdate(dt); - xCMupdate(dt); - - if (s->pendingPortal) - { - zGameStateSwitch(eGameState_SceneSwitch); - } - } - else - { - //zCombo_HideImmediately(); - } + // REFERENCE BFBB } S32 zSceneSetup_serialTraverseCB(U32 clientID, xSerial* xser) @@ -1093,1363 +841,173 @@ static void DeactivateCB(xBase* base) void zSceneSetup() { - zScene* s = globals.sceneCur; - - globals.cmgr = NULL; + // REFERENCE BFBB +} - xSceneSetup(s); - gUIMgr.Setup(s); +void zSceneReset() +{ + zScene* s = globals.sceneCur; - s->gravity = _2094; - s->drag = _2095_0; - s->flags = 0x5; + zEntPlayerPreReset(); - zNPCMgr_scenePostInit(); + gOccludeCount = 0; - if (s->baseCount[eBaseTypeGust]) - { - //zGustSetup(); - } + xScrFxLetterboxReset(); + zEntPickup_FlushGrabbed(); + zEntPickup_SceneReset(); + zMusicReset(); + //zThrown_Reset(); + zShrapnel_Reset(); + zFX_SceneReset(); + xFXSceneReset(); + xShadowManager_Reset(); + //ztalkbox::reset_all(); + //zCameraTweakGlobal_Reset(); + xPadDestroyRumbleChain(0); - if (s->baseCount[eBaseTypeVolume]) - { - zVolumeSetup(); - } + globals.cmgr = NULL; - { - U32 dontcaresize; - xCutscene_Init(xSTFindAssetByType('CTOC', 0, &dontcaresize)); - } + zEntEventAll(NULL, 0, eEventRoomEnd, NULL); + zEntEventAll(NULL, 0, eEventSceneEnd, NULL); - zLOD_Setup(); + zSceneSave(s, NULL); + zSceneAutoSave(); - gCurEnv = NULL; + xSndStopAll(~SND_CAT_UI); + xSndUpdate(); + iSndWaitForDeadSounds(); for (U32 i = 0; i < s->num_base; i++) - { - if (s->base[i]) - { - switch (s->base[i]->baseType) - { - case eBaseTypeEnv: - { - gCurEnv = (_zEnv*)s->base[i]; - - zEnvSetup(gCurEnv); - xClimateInitAsset(&gClimate, gCurEnv->easset); - - break; - } - case eBaseTypeNPC: - { - ((xNPCBasic*)s->base[i])->Setup(); - break; - } - case eBaseTypePlatform: - { - //zPlatform_Reset((zPlatform*)s->base[i], s); - //zPlatform_Setup((zPlatform*)s->base[i], s); - break; - } - case eBaseTypeMovePoint: - { - zMovePointSetup((zMovePoint*)s->base[i], s); - break; - } - case eBaseTypePendulum: - { - //zPendulum_Reset((_zPendulum*)s->base[i], s); - //zPendulum_Setup((_zPendulum*)s->base[i], s); - break; - } - case eBaseTypeButton: - { - zEntButton_Reset((_zEntButton*)s->base[i], s); - zEntButton_Setup((_zEntButton*)s->base[i], s); - break; - } - case eBaseTypeStatic: - { - zEntSimpleObj_Setup((zEntSimpleObj*)s->base[i]); - break; - } - case eBaseTypeTrackPhysics: - { - zEntSimpleObj_Setup((zEntSimpleObj*)s->base[i]); - break; - } - case eBaseTypeDispatcher: - { - //zDispatcher_InitDep((st_ZDISPATCH_DATA*)s->base[i], s); - break; - } - case eBaseTypeEGenerator: - { - //zEGenerator_Setup((zEGenerator*)s->base[i], s); - //zEGenerator_Reset((zEGenerator*)s->base[i], s); - break; - } - case eBaseTypePickup: - { - zEntPickup_Setup((zEntPickup*)s->base[i]); - zEntPickup_Reset((zEntPickup*)s->base[i]); - break; - } - case eBaseTypeParticleSystem: - { - xParSysSetup((xParSys*)s->base[i]); - break; - } - case eBaseTypeSurface: - { - zSurfaceSetup((xSurface*)s->base[i]); - break; - } - case eBaseTypeParticleEmitter: - { - xParEmitterSetup((xParEmitter*)s->base[i]); - break; - } - case eBaseTypeGroup: - { - xGroupSetup((xGroup*)s->base[i]); - break; - } - case eBaseTypeTeleportBox: - { - //zEntTeleportBox_Setup((_zEntTeleportBox*)s->base[i]); - break; - } - case eBaseTypeBusStop: - { - //zBusStop_Setup((zBusStop*)s->base[i]); - break; - } - case eBaseTypeDiscoFloor: - { - ((z_disco_floor*)s->base[i])->setup(); - break; - } - case eBaseTypeTaxi: - { - //zTaxi_Setup((zTaxi*)s->base[i]); - break; - } - case eBaseTypeCameraFly: - { - //zCameraFly_Setup((zCameraFly*)s->base[i]); - break; - } - case eBaseTypeDestructObj: - { - //zEntDestructObj_Setup((zEntDestructObj*)s->base[i]); - break; - } - case eBaseTypeBoulder: - { - xEntBoulder_Setup((xEntBoulder*)s->base[i]); - break; - } - case eBaseTypeUnknown: - case eBaseTypeZipLine: - case eBaseTypeHUD_text: - { - break; - } - } - } - } - - zEntPickup_Setup(); - //zEntTeleportBox_InitAll(); - //zEntHangable_SetupFX(); - //zThrown_Setup(globals.sceneCur); - - for (U32 i = 0; i < s->num_base; i++) - { - if (s->base[i] && s->base[i]->baseType == eBaseTypeMovePoint) - { - xMovePointSplineSetup((xMovePoint*)s->base[i]); - } - } - - xFXSceneSetup(); - zSceneEnableVisited(s); - xSerialTraverse(zSceneSetup_serialTraverseCB); - xQuickCullInit(xEntGetAllEntsBox()); - zGridInit(s); - //zNPCBSandy_AddBoundEntsToGrid(s); - //zNPCBPatrick_AddBoundEntsToGrid(s); - //zNPCTiki_InitStacking(globals.sceneCur); - //zNPCTiki_InitFX(globals.sceneCur); - - enableScreenAdj = 0; - - for (U32 i = 0; i < s->num_base; i++) - { - if (s->base[i] && s->base[i]->baseType == eBaseTypeNPC) - { - xEnt* ent = (xEnt*)s->base[i]; - zLODTable* lod = zLOD_Get(ent); - - if (lod) - { - RpAtomic* tryshad = NULL; - - if (lod->lodBucket[2]) - { - tryshad = lod->lodBucket[2][0]->Data; - } - else if (lod->lodBucket[1]) - { - tryshad = lod->lodBucket[1][0]->Data; - } - else if (lod->lodBucket[0]) - { - tryshad = lod->lodBucket[0][0]->Data; - } - - if (tryshad && RpClumpGetNumAtomics(RpAtomicGetClump(tryshad)) == 1) - { - ent->entShadow->shadowModel = tryshad; - } - } - } - } - - { - int max_drivensort_tiers = 256; - U32 driven_swapped; - U32 i, j; - - do - { - driven_swapped = 0; - - for (i = 0; i < s->num_update_base; i++) - { - if (s->update_base[i]->baseFlags & 0x20) - { - xEnt* bdriven = (xEnt*)s->update_base[i]; - - if (bdriven->driver) - { - for (j = (i + 1) * 2; j < s->num_update_base; j++) - { - if (bdriven->driver == s->update_base[j]) - { - driven_swapped = 1; - - xBase* btmp = s->update_base[i]; - - s->update_base[i] = s->update_base[j]; - s->update_base[j] = btmp; - } - } - } - } - } - } while (--max_drivensort_tiers && driven_swapped); - } - - { - S32 i; - U32 f; - - xEnvAsset* easset = globals.sceneCur->zen->easset; - - if (easset->bspLightKit) - { - globals.sceneCur->env->lightKit = (xLightKit*)xSTFindAsset(easset->bspLightKit, NULL); - } - - if (easset->objectLightKit) - { - xLightKit* objLightKit = (xLightKit*)xSTFindAsset(easset->objectLightKit, NULL); - - if (objLightKit) - { - zScene* zsc = globals.sceneCur; - - for (i = 0; i < s->num_base; i++) - { - if (s->base[i]->baseFlags & 0x20) - { - xEnt* tgtent = (xEnt*)s->base[i]; - - if (tgtent->model) - { - f = tgtent->model->PipeFlags & (0x40 | 0x80); - - if (f != 0x40) - { - tgtent->lightKit = objLightKit; - } - } - } - } - } - } - - S32 lkitCount = xSTAssetCountByType('LKIT'); - - for (i = 0; i < lkitCount; i++) - { - xLightKit* lkit = (xLightKit*)xSTFindAssetByType('LKIT', i, NULL); - - if (lkit->groupID) - { - xGroup* group = (xGroup*)zSceneFindObject(lkit->groupID); - - if (group) - { - U32 j, nitam; - - nitam = xGroupGetCount(group); - - for (j = 0; j < nitam; j++) - { - xBase* itamz = xGroupGetItemPtr(group, j); - - if (itamz && (itamz->baseFlags & 0x20)) - { - xEnt* entitam = (xEnt*)itamz; - - if (entitam->model) - { - f = entitam->model->PipeFlags & (0x40 | 0x80); - - if (f != 0x40) - { - entitam->lightKit = lkit; - } - } - } - } - } - } - } - } - - zEntSimpleObj_MgrInit((zEntSimpleObj**)s->act_ents + s->baseCount[eBaseTypeTrigger] + - s->baseCount[eBaseTypePickup], - s->baseCount[eBaseTypeStatic]); - - xEnt** entList = - s->act_ents + s->baseCount[eBaseTypeTrigger] + s->baseCount[eBaseTypePickup]; // r28 - U32 entCount = s->baseCount[eBaseTypeStatic] + s->baseCount[eBaseTypePlatform] + - s->baseCount[eBaseTypePendulum] + s->baseCount[eBaseTypeHangable] + - s->baseCount[eBaseTypeDestructObj] + s->baseCount[eBaseTypeBoulder] + - s->baseCount[eBaseTypeNPC] + s->baseCount[eBaseTypeButton]; // r27 - - U32 i, j, k; - U32 numPrimeMovers = 0; // r24 - U32 numDriven = 0; // r25 - - for (i = 0; i < s->num_ents; i++) - { - if (s->ents[i]->baseFlags & 0x20) - { - s->ents[i]->isCulled = 0; - } - } - - for (i = 0; i < s->num_ents; i++) - { - if (s->ents[i]->baseFlags & 0x20) - { - if (s->ents[i]->driver) - { - if (!s->ents[i]->isCulled) - { - numDriven++; - s->ents[i]->isCulled = 2; - } - - xEnt* ent = s->ents[i]; - - while (ent->driver) - { - ent = ent->driver; - } - - if (!ent->isCulled) - { - numPrimeMovers++; - ent->isCulled = 1; - } - } - } - } - - U32 numGroups = 0; - - for (i = 0; i < s->num_base; i++) - { - if (s->base[i]->baseType == eBaseTypeGroup) - { - xGroup* grp = (xGroup*)s->base[i]; - - for (j = 0; j < grp->linkCount; j++) - { - // bug: grp->link needs to be changed to grp->link[j] - // currently the 1st link is checked over and over - // and any links after that are not checked - - if (grp->link->srcEvent == eEventSceneBegin && - grp->link->dstEvent == eEventGroupUpdateTogether) - { - numGroups++; - - U32 gcnt = xGroupGetCount(grp); - - for (k = 0; k < gcnt; k++) - { - xBase* gbase = xGroupGetItemPtr(grp, k); - - if (gbase && (gbase->baseFlags & 0x20)) - { - xEnt* gent = (xEnt*)gbase; - - if (gent->isCulled) - { - if (gent->isCulled == 1) - { - numDriven--; - } - - if (gent->isCulled != 1) - { - numPrimeMovers--; - } - - gent->isCulled = 0; - } - } - } - } - } - } - } - - xGroup* driveGroupList = NULL; - - if (numDriven) - { - U32 allocsize = numDriven * sizeof(xGroup) + numDriven * sizeof(xGroupAsset) + - (numDriven + numPrimeMovers) * sizeof(xBase*); - - driveGroupList = (xGroup*)RwMalloc(allocsize); - - memset(driveGroupList, 0, allocsize); - - xGroupAsset* grpAssetList = (xGroupAsset*)(driveGroupList + numDriven); - xBase** grpBaseList = (xBase**)(grpAssetList + numDriven); - - for (i = 0; i < numDriven; i++) - { - driveGroupList[i].baseType = eBaseTypeGroup; - driveGroupList[i].asset = &grpAssetList[i]; - driveGroupList[i].flg_group |= 0x1; - } - - for (i = 0, j = 0; i < s->num_base; i++) - { - if (s->base[i]->baseFlags & 0x20) - { - xEnt* ent = (xEnt*)s->base[i]; - - if (ent->isCulled == 1) - { - xGroupAsset* gasset = driveGroupList[j].asset; - - driveGroupList[j].item = grpBaseList; - *grpBaseList++ = ent; - gasset->itemCount++; - - for (k = 0; k < s->num_base; k++) - { - if (s->base[k]->baseFlags & 0x20) - { - xEnt* other = (xEnt*)s->base[k]; - - if (other->isCulled == 2) - { - xEnt* r12 = other; - - while (r12->driver) - { - r12 = r12->driver; - } - - if (ent == r12) - { - *grpBaseList++ = other; - gasset->itemCount++; - } - } - } - } - - if (gasset->itemCount > 1) - { - numPrimeMovers++; - } - - j++; - } - } - } - } - - xGroup** tempGrpList = NULL; - - if (numGroups) - { - tempGrpList = (xGroup**)RwMalloc(numGroups * sizeof(xGroup*)); - - xGroup** tempGrpCurr = tempGrpList; - - for (i = 0; i < s->num_base; i++) - { - if (s->base[i]->baseType == eBaseTypeGroup) - { - xGroup* grp = (xGroup*)s->base[i]; - - for (j = 0; j < grp->linkCount; j++) - { - // same bug as above - // grp->link should be changed to grp->link[j] - - if (grp->link->srcEvent == eEventSceneBegin && - grp->link->dstEvent == eEventGroupUpdateTogether) - { - *tempGrpCurr++ = grp; - } - } - } - } - - for (i = 0; i < numDriven; i++) - { - if (driveGroupList[i].asset->itemCount > 1) - { - *tempGrpCurr++ = &driveGroupList[i]; - } - } - } - - globals.updateMgr = xUpdateCull_Init((void**)entList, entCount, tempGrpList, numGroups); - globals.updateMgr->activateCB = (xUpdateCullActivateCallback)ActivateCB; - globals.updateMgr->deactivateCB = (xUpdateCullDeactivateCallback)DeactivateCB; - - FloatAndVoid defaultDist; - defaultDist.f = _2096_0; - - FloatAndVoid lodDist; - lodDist.f = _1496_0; - - for (i = 0; i < entCount; i++) - { - zLODTable* lod = zLOD_Get(entList[i]); - - if (lod) - { - if (lod->noRenderDist == _1496_0) - { - lod = NULL; - } - else - { - lodDist.f = SQR(_2097_0 + xsqrt(lod->noRenderDist)); - } - } - - xUpdateCull_SetCB(globals.updateMgr, entList[i], xUpdateCull_DistanceSquaredCB, - (lod) ? lodDist.v : defaultDist.v); - } - - if (tempGrpList) - { - RwFree(tempGrpList); - } - - if (driveGroupList) - { - RwFree(driveGroupList); - } - - for (i = 0; i < s->num_base; i++) - { - if (s->base[i]->baseFlags & 0x20) - { - ((xEnt*)s->base[i])->isCulled = 0; - } - } - - zNPCMgr_scenePostSetup(); - z_disco_floor::post_setup(); - zEntPickup_RewardPostSetup(); - - iColor_tag black; - *(U32*)&black = _2013; - - iColor_tag clear; - *(U32*)&clear = _2014; - - xScrFxFade(&black, &clear, _1374, NULL, 0); -} - -void zSceneReset() -{ - zScene* s = globals.sceneCur; - - zEntPlayerPreReset(); - - gOccludeCount = 0; - - xScrFxLetterboxReset(); - zEntPickup_FlushGrabbed(); - zEntPickup_SceneReset(); - zMusicReset(); - //zThrown_Reset(); - zShrapnel_Reset(); - zFX_SceneReset(); - xFXSceneReset(); - xShadowManager_Reset(); - //ztalkbox::reset_all(); - //zCameraTweakGlobal_Reset(); - xPadDestroyRumbleChain(0); - - globals.cmgr = NULL; - - zEntEventAll(NULL, 0, eEventRoomEnd, NULL); - zEntEventAll(NULL, 0, eEventSceneEnd, NULL); - - zSceneSave(s, NULL); - zSceneAutoSave(); - - xSndStopAll(~SND_CAT_UI); - xSndUpdate(); - iSndWaitForDeadSounds(); - - for (U32 i = 0; i < s->num_base; i++) - { - if (s->base[i]) - { - switch (s->base[i]->baseType) - { - case eBaseTypePickup: - case eBaseTypeCamera: - case eBaseTypeDoor: - case eBaseTypeSavePoint: - case eBaseTypeItem: - case eBaseTypeStatic: - case eBaseTypeDynamic: - case eBaseTypeMovePoint: - case eBaseTypeTimer: - case eBaseTypeBubble: - case eBaseTypePortal: - case eBaseTypeGroup: - case eBaseTypeSFX: - case eBaseTypeFFX: - case eBaseTypeVFX: - case eBaseTypeButton: - case eBaseTypeProjectile: - case eBaseTypeSurface: - case eBaseTypeDestructObj: - case eBaseTypeGust: - case eBaseTypeVolume: - case eBaseTypeDispatcher: - case eBaseTypeCond: - case eBaseTypeUI: - case eBaseTypeUIFont: - case eBaseTypeProjectileType: - case eBaseTypeFog: - case eBaseTypeLight: - case eBaseTypeParticleEmitter: - case eBaseTypeParticleSystem: - case eBaseTypeCutsceneMgr: - default: - { - zEntEvent(NULL, 0, s->base[i], eEventReset, NULL, NULL, 1); - break; - } - case eBaseTypeCounter: - { - //xCounterReset(s->base[i]); - break; - } - case eBaseTypePlayer: - { - zEntPlayerReset((xEnt*)s->base[i]); - break; - } - case eBaseTypePlatform: - { - //zPlatform_Reset((zPlatform*)s->base[i], globals.sceneCur); - break; - } - case eBaseTypePendulum: - { - //zPendulum_Reset((_zPendulum*)s->base[i], globals.sceneCur); - break; - } - case eBaseTypeHangable: - { - //zEntHangable_Reset((zEntHangable*)s->base[i]); - break; - } - case eBaseTypeLobMaster: - { - zEntEvent(s->base[i], eEventReset); - break; - } - case eBaseTypeEGenerator: - { - //zEGenerator_Reset((zEGenerator*)s->base[i], globals.sceneCur); - break; - } - case eBaseTypeEnv: - { - _zEnv* env = (_zEnv*)s->base[i]; - - if (env) - { - if (zSceneFindObject(env->easset->startCameraAssetID)) - { - //zCameraReset(&globals.camera); - } - - xClimateInitAsset(&gClimate, env->easset); - } - } - } - } - } - - zNPCMgr_sceneReset(); - zEntPlayer_LoadCheckPoint(); - zSceneLoad(globals.sceneCur, NULL); - zSceneEnableVisited(s); - xSerialTraverse(zSceneSetup_serialTraverseCB); - xSkyDome_Setup(); - xUpdateCull_Reset(globals.updateMgr); - xUpdateCull_Update(globals.updateMgr, 100); - zGridReset(s); - - zEntEventAll(NULL, 0, eEventSceneBegin, NULL); - zEntEventAll(NULL, 0, eEventRoomBegin, NULL); - zEntEventAll(NULL, 0, eEventSceneReset, NULL); - - //zNPCTiki_InitStacking(globals.sceneCur); - //zNPCTiki_InitFX(globals.sceneCur); - - xUpdateCull_Update(globals.updateMgr, 100); - zLOD_Update(100); - - //zGameExtras_SceneReset(); -} - -void zSceneLoad(zScene* ent) -{ - xSerial* s; - xSerial xser; - S32 sceneExist; - - s = &xser; - - s->setClient('PLYR'); - - sceneExist = 0; - s->Read_b1(&sceneExist); - - if (sceneExist) - { - s->Read(&globals.player.MaxHealth); - - globals.player.Health = globals.player.MaxHealth; - - s->Read((U32*)&gCurrentPlayer); - s->Read(&globals.player.Inv_Shiny); - s->Read(&globals.player.Inv_Spatula); - s->Read(&globals.player.g.PowerUp[0]); - s->Read(&globals.player.g.PowerUp[1]); - - for (S32 i = 0; i < LEVEL_COUNT; i++) - { - s->Read(&globals.player.Inv_PatsSock[i]); - s->Read(&globals.player.Inv_LevelPickups[i]); - } - - s->Read(&globals.player.Inv_PatsSock_Total); - - zCutsceneMgrLoad(NULL, s); - //oob_state::read_persistent(*s); - } - - s->setClient('CNTR'); - - sceneExist = 0; - s->Read_b1(&sceneExist); - - if (sceneExist) - { - char tempString[32]; - - zUI_ScenePortalLoad(s); - - strcpy(tempString, "HB09 ROBOT COUNTER 01"); - - char c = '1'; - S32 i; - U32 id; - - for (i = 0; i < LEVEL_COUNT; i++) - { - if (c > '9') - { - c = '0'; - tempString[19]++; - } - - tempString[20] = c; - - c++; - - id = xStrHash(tempString); - - //s->Read(&((_xCounter*)zSceneFindObject(id))->count); - } - - id = xStrHash("REMINDER_SOCK_CNTR"); - - //s->Read(&((_xCounter*)zSceneFindObject(id))->count); - - //zGameExtras_Load(s); - } - - s->setClient(ent->sceneID); - - sceneExist = 0; - s->Read_b1(&sceneExist); - - if (sceneExist) - { - xSceneLoad(ent, s); - - s->Read(&offsetx); - s->Read(&offsety); - - for (U16 i = 0; i < globals.sceneCur->num_base; i++) - { - xBase* b = globals.sceneCur->base[i]; - - if (b->baseFlags & 0x2) - { - switch (b->baseType) - { - case eBaseTypeTrigger: - { - //zEntTriggerLoad((zEntTrigger*)b, s); - break; - } - case eBaseTypeNPC: - { - ((xNPCBasic*)b)->Load(s); - break; - } - case eBaseTypePlayer: - { - zEntPlayer_Load((xEnt*)b, s); - break; - } - case eBaseTypePickup: - { - zEntPickup_Load((zEntPickup*)b, s); - break; - } - case eBaseTypeEnv: - { - zEnvLoad((_zEnv*)b, s); - break; - } - case eBaseTypeFog: - { - xFogLoad((_xFog*)b, s); - break; - } - case eBaseTypeLight: - { - zLightLoad((_zLight*)b, s); - break; - } - case eBaseTypePlatform: - { - //zPlatform_Load((zPlatform*)b, s); - break; - } - case eBaseTypeCamera: - { - zCamMarkerLoad((zCamMarker*)b, s); - break; - } - case eBaseTypeStatic: - { - zEntSimpleObj_Load((zEntSimpleObj*)b, s); - break; - } - case eBaseTypeMovePoint: - { - zMovePointLoad((zMovePoint*)b, s); - break; - } - case eBaseTypeTimer: - { - xTimerLoad((xTimer*)b, s); - break; - } - case eBaseTypePortal: - { - zPortalLoad((_zPortal*)b, s); - break; - } - case eBaseTypeGroup: - { - xGroupLoad((xGroup*)b, s); - break; - } - case eBaseTypePendulum: - { - //zPendulum_Load((_zPendulum*)b, s); - break; - } - case eBaseTypeSFX: - { - xSFXLoad((xSFX*)b, s); - break; - } - case eBaseTypeCounter: - { - //xCounterLoad((_xCounter*)b, s); - break; - } - case eBaseTypeHangable: - { - //zEntHangable_Load((zEntHangable*)b, s); - break; - } - case eBaseTypeButton: - { - zEntButton_Load((_zEntButton*)b, s); - break; - } - case eBaseTypeSurface: - { - zSurfaceLoad((xSurface*)b, s); - break; - } - case eBaseTypeDestructObj: - { - //zEntDestructObj_Load((zEntDestructObj*)b, s); - break; - } - case eBaseTypeGust: - { - //zGustLoad((zGust*)b, s); - break; - } - case eBaseTypeScript: - { - //zScriptLoad((_zScript*)b, s); - break; - } - case eBaseTypeVolume: - { - ((xVolume*)b)->Load(s); - break; - } - case eBaseTypeDispatcher: - { - //zDispatcher_Load((st_ZDISPATCH_DATA*)b, s); - break; - } - case eBaseTypeCond: - { - //zConditionalLoad((_zConditional*)b, s); - break; - } - case eBaseTypeUI: - { - zUI_Load((_zUI*)b, s); - break; - } - case eBaseTypeUIFont: - { - zUIFont_Load((zUIFont*)b, s); - break; - } - case eBaseTypeEGenerator: - { - //zEGenerator_Load((zEGenerator*)b, s); - break; - } - case eBaseTypeTeleportBox: - { - zEntTeleportBox_Load((_zEntTeleportBox*)b, s); - break; - } - case eBaseTypeTaskBox: - { - ((ztaskbox*)b)->read(*s); - break; - } - case eBaseTypeTaxi: - { - //zTaxi_Load((zTaxi*)b, s); - break; - } - case eBaseTypeCameraFly: - { - zCameraFly_Load((zCameraFly*)b, s); - break; - } - case eBaseTypeCameraTweak: - { - zCameraTweak_Load((zCameraTweak*)b, s); - break; - } - } - } - } - } -} - -void zSceneSave(zScene* ent) -{ - zEntPickup_FlushGrabbed(); - - xSerial* s; - U32 i; - xSerial xser; - - s = &xser; - - s->setClient('PLYR'); - s->Write_b1(1); - s->Write(globals.player.MaxHealth); - s->Write(gCurrentPlayer); - s->Write(globals.player.Inv_Shiny); - s->Write(globals.player.Inv_Spatula); - s->Write(globals.player.g.PowerUp[0]); - s->Write(globals.player.g.PowerUp[1]); - - for (i = 0; i < LEVEL_COUNT; i++) - { - s->Write(globals.player.Inv_PatsSock[i]); - s->Write(globals.player.Inv_LevelPickups[i]); - } - - s->Write(globals.player.Inv_PatsSock_Total); - - zCutsceneMgrSave(NULL, s); - //oob_state::write_persistent(*s); - - s->setClient('CNTR'); - s->Write_b1(1); - - zUI_ScenePortalSave(s); - - char tempString[32]; - - strcpy(tempString, "HB09 ROBOT COUNTER 01"); - - char c = '1'; - U32 id; - - for (i = 0; i < LEVEL_COUNT; i++) - { - if (c > '9') - { - c = '0'; - tempString[19]++; - } - - tempString[20] = c; - - c++; - - id = xStrHash(tempString); - - //s->Write(((_xCounter*)zSceneFindObject(id))->count); - } - - id = xStrHash("REMINDER_SOCK_CNTR"); - - //s->Write(((_xCounter*)zSceneFindObject(id))->count); - - //zGameExtras_Save(s); - - s->setClient(ent->sceneID); - s->Write_b1(1); - - xSceneSave(ent, s); - - s->Write(offsetx); - s->Write(offsety); - - for (U32 i = 0; i < globals.sceneCur->num_base; i++) - { - xBase* b = globals.sceneCur->base[i]; - - if (b->baseFlags & 0x2) - { - switch (b->baseType) - { - case eBaseTypeTrigger: - { - //zEntTriggerSave((zEntTrigger*)b, s); - break; - } - case eBaseTypeNPC: + { + if (s->base[i]) + { + switch (s->base[i]->baseType) { - ((xNPCBasic*)b)->Save(s); - break; - } case eBaseTypePickup: - { - zEntPickup_Save((zEntPickup*)b, s); - break; - } - case eBaseTypeEnv: - { - zEnvSave((_zEnv*)b, s); - break; - } - case eBaseTypeFog: - { - xFogSave((_xFog*)b, s); - break; - } - case eBaseTypeLight: - { - zLightSave((_zLight*)b, s); - break; - } - case eBaseTypePlatform: - { - //zPlatform_Save((zPlatform*)b, s); - break; - } case eBaseTypeCamera: - { - zCamMarkerSave((zCamMarker*)b, s); - break; - } + case eBaseTypeDoor: + case eBaseTypeSavePoint: + case eBaseTypeItem: case eBaseTypeStatic: - { - zEntSimpleObj_Save((zEntSimpleObj*)b, s); - break; - } + case eBaseTypeDynamic: case eBaseTypeMovePoint: - { - zMovePointSave((zMovePoint*)b, s); - break; - } case eBaseTypeTimer: - { - xTimerSave((xTimer*)b, s); - break; - } + case eBaseTypeBubble: case eBaseTypePortal: - { - zPortalSave((_zPortal*)b, s); - break; - } case eBaseTypeGroup: - { - xGroupSave((xGroup*)b, s); - break; - } - case eBaseTypePendulum: - { - //zPendulum_Save((_zPendulum*)b, s); - break; - } case eBaseTypeSFX: - { - xSFXSave((xSFX*)b, s); - break; - } - case eBaseTypeCounter: - { - //xCounterSave((_xCounter*)b, s); - break; - } - case eBaseTypeHangable: - { - //zEntHangable_Save((zEntHangable*)b, s); - break; - } + case eBaseTypeFFX: + case eBaseTypeVFX: case eBaseTypeButton: - { - zEntButton_Save((_zEntButton*)b, s); - break; - } + case eBaseTypeProjectile: case eBaseTypeSurface: - { - zSurfaceSave((xSurface*)b, s); - break; - } case eBaseTypeDestructObj: - { - //zEntDestructObj_Save((zEntDestructObj*)b, s); - break; - } case eBaseTypeGust: - { - //zGustSave((zGust*)b, s); - break; - } - case eBaseTypeScript: - { - //zScriptSave((_zScript*)b, s); - break; - } case eBaseTypeVolume: - { - ((xVolume*)b)->Save(s); - break; - } case eBaseTypeDispatcher: - { - //zDispatcher_Save((st_ZDISPATCH_DATA*)b, s); - break; - } case eBaseTypeCond: - { - //zConditionalSave((_zConditional*)b, s); - break; - } case eBaseTypeUI: + case eBaseTypeUIFont: + case eBaseTypeProjectileType: + case eBaseTypeFog: + case eBaseTypeLight: + case eBaseTypeParticleEmitter: + case eBaseTypeParticleSystem: + case eBaseTypeCutsceneMgr: + default: { - zUI_Save((_zUI*)b, s); + zEntEvent(NULL, 0, s->base[i], eEventReset, NULL, NULL, 1); break; } - case eBaseTypeUIFont: + case eBaseTypeCounter: { - zUIFont_Save((zUIFont*)b, s); + //xCounterReset(s->base[i]); break; } - case eBaseTypeEGenerator: + case eBaseTypePlayer: { - //zEGenerator_Save((zEGenerator*)b, s); + zEntPlayerReset((xEnt*)s->base[i]); break; } - case eBaseTypeTeleportBox: + case eBaseTypePlatform: { - zEntTeleportBox_Save((_zEntTeleportBox*)b, s); + //zPlatform_Reset((zPlatform*)s->base[i], globals.sceneCur); break; } - case eBaseTypeTaskBox: + case eBaseTypePendulum: { - ((ztaskbox*)b)->write(*s); + //zPendulum_Reset((_zPendulum*)s->base[i], globals.sceneCur); break; } - case eBaseTypeTaxi: + case eBaseTypeHangable: { - //zTaxi_Save((zTaxi*)b, s); + //zEntHangable_Reset((zEntHangable*)s->base[i]); break; } - case eBaseTypeCameraFly: + case eBaseTypeLobMaster: { - zCameraFly_Save((zCameraFly*)b, s); + zEntEvent(s->base[i], eEventReset); break; } - case eBaseTypeCameraTweak: + case eBaseTypeEGenerator: { - zCameraTweak_Save((zCameraTweak*)b, s); + //zEGenerator_Reset((zEGenerator*)s->base[i], globals.sceneCur); break; } - } - } - } -} - -void zSceneSwitch(_zPortal* p, S32 forceSameScene) -{ - globals.sceneCur->pendingPortal = p; - - xPortalAsset* passet = globals.sceneCur->pendingPortal->passet; - - gLevelChanged = (zSceneLeavingLevel() != 0); - - if (((char*)&passet->sceneID)[3] < '0' || ((char*)&passet->sceneID)[3] > '9') - { - char* id = (char*)&passet->sceneID; - //HackSwapIt(id, 4); - } - - U32 nextSceneID = (((char*)&passet->sceneID)[0] << 24) | (((char*)&passet->sceneID)[1] << 16) | - (((char*)&passet->sceneID)[2] << 8) | ((char*)&passet->sceneID)[3]; - - if (!forceSameScene && nextSceneID == globals.sceneCur->sceneID) - { - U32 PlayerMarkerStartID = passet->assetMarkerID; - U32 PlayerMarkerStartCamID = passet->assetCameraID; - F32 PlayerStartAngle = passet->ang; - - if (zSceneFindObject(PlayerMarkerStartCamID)) - { - globals.player.cp.initCamID = PlayerMarkerStartCamID; - } - - if (PlayerStartAngle >= _1493) - { - xMarkerAsset* marker = (xMarkerAsset*)xSTFindAsset(PlayerMarkerStartID, NULL); - - if (marker) + case eBaseTypeEnv: { - xEnt& player = globals.player.ent; - xVec3& loc = (xVec3&)player.model->Mat->pos; - - xVec3 offset = marker->pos - loc; + _zEnv* env = (_zEnv*)s->base[i]; - loc = player.frame->mat.pos = marker->pos; + if (env) + { + if (zSceneFindObject(env->easset->startCameraAssetID)) + { + //zCameraReset(&globals.camera); + } - xCameraMove(&globals.camera, globals.camera.mat.pos + offset); + xClimateInitAsset(&gClimate, env->easset); + } + } } } - else - { - U32 size; - xMarkerAsset* m = (xMarkerAsset*)xSTFindAsset(PlayerMarkerStartID, &size); - - if (m) - { - xVec3Copy(&globals.player.ent.frame->mat.pos, &m->pos); - xVec3Copy((xVec3*)&globals.player.ent.model->Mat->pos, &m->pos); + } - xCameraSetTargetMatrix(&globals.camera, xEntGetFrame(&globals.player.ent)); - } + zNPCMgr_sceneReset(); + zEntPlayer_LoadCheckPoint(); + zSceneLoad(globals.sceneCur, NULL); + zSceneEnableVisited(s); + xSerialTraverse(zSceneSetup_serialTraverseCB); + xSkyDome_Setup(); + xUpdateCull_Reset(globals.updateMgr); + xUpdateCull_Update(globals.updateMgr, 100); + zGridReset(s); - xEntFrame* frame = globals.player.ent.frame; + zEntEventAll(NULL, 0, eEventSceneBegin, NULL); + zEntEventAll(NULL, 0, eEventRoomBegin, NULL); + zEntEventAll(NULL, 0, eEventSceneReset, NULL); - frame->rot.angle = _1494 * PlayerStartAngle / _1495; - frame->rot.axis = xVec3::create(_1496_0, _1374, _1496_0); + //zNPCTiki_InitStacking(globals.sceneCur); + //zNPCTiki_InitFX(globals.sceneCur); - xMat3x3Euler(&frame->mat, frame->rot.angle, _1496_0, _1496_0); + xUpdateCull_Update(globals.updateMgr, 100); + zLOD_Update(100); - *(xMat3x3*)globals.player.ent.model->Mat = frame->mat; + //zGameExtras_SceneReset(); +} - zCameraReset(&globals.camera); - } +void zSceneLoad(zScene* ent) +{ + // REFERENCE BFBB +} - // non-matching: instruction order +void zSceneSave(zScene* ent) +{ + // REFERENCE BFBB +} - //oob_player_teleported = true; - globals.sceneCur->pendingPortal = NULL; - } +void zSceneSwitch(_zPortal* p, S32 forceSameScene) +{ + // REFERENCE BFBB } void zSceneUpdateSFXWidgets() @@ -2461,106 +1019,7 @@ void zSceneUpdateSFXWidgets() void zSceneExit(S32 beginReload) { - zScene* s = globals.sceneCur; - - //zThrown_Reset(); - zEntPickup_FlushGrabbed(); - zGridExit(s); - zSceneForAllBase(zSceneExitSoundIteratorCB, NULL); - xSndStopAll(~SND_CAT_UI); - xSndUpdate(); - iSndWaitForDeadSounds(); - iSndSceneExit(); - xSFXEnvironmentalStreamSceneExit(); - iSndSuspendCD(1); - iFuncProfileDump(); - - RpWorld* world = s->env->geom->world; - - xModel_SceneExit(world); - zFX_SceneExit(world); - zEntEventAll(NULL, 0, eEventRoomEnd, NULL); - zEntEventAll(NULL, 0, eEventSceneEnd, NULL); - - if (globals.sceneCur->pendingPortal) - { - char nextScene[8]; - char curScene[8]; - - strcpy(nextScene, xUtil_idtag2string(globals.sceneCur->pendingPortal->passet->sceneID, 0)); - strcpy(curScene, xUtil_idtag2string(globals.sceneCur->sceneID, 0)); - } - - // non-matching: two instructions are swapped here... - gOccludeCount = 0; - - if (globals.sceneCur->sceneID != 'MNU3') - { - zSceneSave(s, NULL); - } - - zEntPlayerExit(&globals.player.ent); - zSurfaceExit(); - zLightDestroyAll(); - xEntSceneExit(); - xEntMotionDebugExit(); - zSceneObjHashtableExit(); - - if (s->baseCount[eBaseTypeParticleSystem]) - { - zParSys* ps = (zParSys*)s->baseList[eBaseTypeParticleSystem]; - - for (U32 i = 0; i < s->baseCount[eBaseTypeParticleSystem]; i++) - { - if (xBaseIsValid(&ps[i])) - { - xParSysExit(&ps[i]); - } - } - } - - xParEmitterDestroy(); - xModelBucket_Deinit(); - xFXSceneFinish(); - zGooExit(); - zParPTankExit(); - zAnimListExit(); - zNPCMgr_sceneFinish(); - zDispatcher_sceneFinish(); - z_disco_floor::destroy(); - xDecalDestroy(); - zParPTankSceneExit(); - xPTankPoolSceneExit(); - zEntPlayer_UnloadSounds(); - - if (beginReload) - { - xSTUnLoadScene(globals.sceneCur->sceneID, 1); - xMemPopBase(sMemDepthJustHIPStart); - - sMemDepthJustHIPStart = -1; - } - else - { - xSTUnLoadScene(globals.sceneCur->sceneID, 1); - - if (globals.useHIPHOP) - { - xSTUnLoadScene(globals.sceneCur->sceneID, 2); - } - - xMemPopBase(sMemDepthSceneStart); - - sMemDepthSceneStart = -1; - sMemDepthJustHIPStart = -1; - } - - xSystem_GapTrackReport(); - xUtil_idtag2string(globals.sceneCur->sceneID, 0); - - globals.sceneCur = NULL; - - xSceneExit(s); + // REFERENCE BFBB } void zSceneInit(U32 theSceneID, S32 reloadInProgress) @@ -3101,40 +1560,8 @@ static U32 zSceneInitFunc_Camera(zScene* s, zSceneObjectInstanceDesc* desc, U32 static U32 zSceneInitFunc_Player(zScene* s, zSceneObjectInstanceDesc* desc, U32 base_idx) { - S32 count; - zEnt* entBlock; - - count = s->baseCount[desc->baseType]; - - if (count) - { - entBlock = (zEnt*)xMemAllocSize(count * sizeof(zEnt)); - - s->baseList[desc->baseType] = entBlock; - - for (S32 idx = 0; idx < count; idx++) - { - xBase* b = &globals.player.ent; - xEntAsset* asset; - - zSceneSet(b, base_idx); - - if (idx == count - 1) - { - xSceneAddEnt(s, s->ents[base_idx]); - } - - asset = (xEntAsset*)xSTFindAssetByType('PLYR', idx, NULL); - - globals.player.ent.id = asset->id; - - zSceneObjHashtableAdd(asset->id, b); - - base_idx++; - } - } - - return base_idx; + // REFERENCE BFBB + return 0; } static U32 zSceneInitFunc_MovePoint(zScene* s, zSceneObjectInstanceDesc* desc, U32 base_idx) @@ -3237,7 +1664,7 @@ static U32 zSceneInitFunc_DefaultEnt(zScene* s, zSceneObjectInstanceDesc* desc, desc->objectInitFunc(b, asset); } - xSceneAddEnt(s, s->ents[base_idx]); + //xSceneAddEnt(s, s->ents[base_idx]); zSceneObjHashtableAdd(b->id, b); base_idx++; @@ -4880,68 +3307,5 @@ S32 format(S32 num, S32 mode) void zSaveLoad_Tick(bool) { - time_current = (1.0f / (GET_BUS_FREQUENCY() / 4)) * (float)iTimeGet(); - - time_elapsed = time_current - time_last; - if (time_elapsed < 0.0f) - { - time_elapsed = 1.0f / 60.f; - } - else if (time_elapsed > 0.1f) - { - time_elapsed = 1.0f / 60.f; - } - - dontPoll = dontPoll - time_elapsed; - t0 = t1; - time_last = time_current; - t1 = iTimeGet(); - sTimeCurrent = iTimeGet(); - sTimeElapsed = iTimeDiffSec(sTimeLast, sTimeCurrent); - sTimeLast = sTimeCurrent; - xPadUpdate(globals.currentActivePad, time_elapsed); - iTRCDisk::CheckDVDAndResetState(); - xDrawBegin(); - xParMgrUpdate(time_elapsed); - zSceneUpdate(time_elapsed); - - xMat4x3 playerMat; - xMat4x3* ma = xEntGetFrame(&(xEnt)globals.player.ent); - // This feels like a normal assignment but that calls the assignment operator function. - *(U32*)&playerMat.right.x = *(U32*)&ma->right.x; - *(U32*)&playerMat.right.y = *(U32*)&ma->right.y; - *(U32*)&playerMat.right.z = *(U32*)&ma->right.z; - *(U32*)&playerMat.flags = *(U32*)&ma->flags; - *(U32*)&playerMat.up.x = *(U32*)&ma->up.x; - *(U32*)&playerMat.up.y = *(U32*)&ma->up.y; - *(U32*)&playerMat.up.z = *(U32*)&ma->up.z; - *(U32*)&playerMat.pad1 = *(U32*)&ma->pad1; - *(U32*)&playerMat.at.x = *(U32*)&ma->at.x; - *(U32*)&playerMat.at.y = *(U32*)&ma->at.y; - *(U32*)&playerMat.at.z = *(U32*)&ma->at.z; - *(U32*)&playerMat.pad2 = *(U32*)&ma->pad2; - *(U32*)&playerMat.pos.x = *(U32*)&ma->pos.x; - *(U32*)&playerMat.pos.z = *(U32*)&ma->pos.z; - *(U32*)&playerMat.pad3 = *(U32*)&ma->pad3; - *(U32*)&playerMat.pos.y = *(U32*)&ma->pos.y; - playerMat.pos.y += 0.6f; - - xSndSetListenerData(SND_LISTENER_CAMERA, &globals.camera.mat); - xSndSetListenerData(SND_LISTENER_PLAYER, &playerMat); - xSndUpdate(); - if (gGameMode == 6 && gGameState != 0) - { - zhud::update(sTimeElapsed); - } - - zCameraUpdate(&globals.camera, time_elapsed); - xCameraBegin(&globals.camera, 1); - zUpdateThumbIcon(); - zSceneRender(); - //xDebugUpdate(); - xDrawEnd(); - xCameraEnd(&globals.camera, time_elapsed, 1); - iEnvEndRenderFX(0); - xCameraShowRaster(&globals.camera); - gFrameCount = gFrameCount + 1; + // REFERENCE BFBB } From 6c6bc17c30994c0277880690ae0be32f4f7f0228 Mon Sep 17 00:00:00 2001 From: Colin Miller Date: Sun, 15 Jun 2025 23:10:55 -0400 Subject: [PATCH 2/2] Linked more of the SDK --- .vscode/settings.json | 4 +- configure.py | 56 +- .../MSL_C/MSL_Common/math_api.h | 9 +- .../src/MSL_C/MSL_Common/float.c | 16 +- .../src/MSL_C/MSL_Common/locale.c | 55 +- .../src/MSL_C/MSL_Common/misc_io.c | 21 +- .../src/MSL_C/MSL_Common/rand.c | 2 +- .../Math/Double_precision/e_pow.c | 469 ++++++++------- .../Math/Double_precision/s_ldexp.c | 70 +-- .../src/Runtime/global_destructor_chain.c | 9 + src/dolphin/src/axfx/axfx.c | 2 +- src/dolphin/src/axfx/chorus.c | 544 +++++++++--------- src/dolphin/src/axfx/delay.c | 10 +- src/dolphin/src/card/CARDBios.c | 4 +- src/dolphin/src/card/CARDCreate.c | 18 +- src/dolphin/src/card/CARDDelete.c | 20 +- src/dolphin/src/card/CARDWrite.c | 2 +- src/dolphin/src/dvd/dvdlow.c | 26 +- src/dolphin/src/exi/EXIBios.c | 2 +- 19 files changed, 681 insertions(+), 658 deletions(-) diff --git a/.vscode/settings.json b/.vscode/settings.json index f43221b..d71959b 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -22,7 +22,9 @@ "__gx.h": "c", "gxenum.h": "c", "gxmanage.h": "c", - "__ax.h": "c" + "__ax.h": "c", + "math_api.h": "c", + "arith.h": "c" }, // Disable C/C++ IntelliSense, use clangd instead "C_Cpp.intelliSenseEngine": "default", diff --git a/configure.py b/configure.py index e3c8415..47e2ca0 100644 --- a/configure.py +++ b/configure.py @@ -475,33 +475,33 @@ def MatchingFor(*versions): Object(NonMatching, "dolphin/src/axfx/reverb_hi.c"), Object(NonMatching, "dolphin/src/axfx/reverb_std.c"), Object(NonMatching, "dolphin/src/axfx/chorus.c"), - Object(NonMatching, "dolphin/src/axfx/delay.c"), - Object(NonMatching, "dolphin/src/axfx/axfx.c"), + Object(Matching, "dolphin/src/axfx/delay.c"), + Object(Matching, "dolphin/src/axfx/axfx.c"), Object(NonMatching, "dolphin/src/axfx/reverb_hi_4ch.c"), ] ), DolphinLib( "base", [ - Object(NonMatching, "dolphin/src/base/PPCArch.c") + Object(Matching, "dolphin/src/base/PPCArch.c") ] ), DolphinLib( "card", [ - Object(NonMatching, "dolphin/src/card/CARDBios.c"), + Object(Matching, "dolphin/src/card/CARDBios.c"), Object(NonMatching, "dolphin/src/card/CARDUnlock.c"), - Object(NonMatching, "dolphin/src/card/CARDRdwr.c"), - Object(NonMatching, "dolphin/src/card/CARDBlock.c"), - Object(NonMatching, "dolphin/src/card/CARDDir.c"), - Object(NonMatching, "dolphin/src/card/CARDCheck.c"), - Object(NonMatching, "dolphin/src/card/CARDMount.c"), - Object(NonMatching, "dolphin/src/card/CARDFormat.c"), + Object(Matching, "dolphin/src/card/CARDRdwr.c"), + Object(Matching, "dolphin/src/card/CARDBlock.c"), + Object(Matching, "dolphin/src/card/CARDDir.c"), + Object(Matching, "dolphin/src/card/CARDCheck.c"), + Object(Matching, "dolphin/src/card/CARDMount.c"), + Object(Matching, "dolphin/src/card/CARDFormat.c"), Object(NonMatching, "dolphin/src/card/CARDOpen.c"), - Object(NonMatching, "dolphin/src/card/CARDCreate.c"), + Object(Matching, "dolphin/src/card/CARDCreate.c"), Object(NonMatching, "dolphin/src/card/CARDRead.c"), - Object(NonMatching, "dolphin/src/card/CARDWrite.c"), - Object(NonMatching, "dolphin/src/card/CARDDelete.c"), + Object(Matching, "dolphin/src/card/CARDWrite.c"), + Object(Matching, "dolphin/src/card/CARDDelete.c"), Object(NonMatching, "dolphin/src/card/CARDStat.c"), Object(NonMatching,"dolphin/src/card/CARDStatEx.c"), Object(NonMatching, "dolphin/src/card/CARDNet.c"), @@ -510,14 +510,14 @@ def MatchingFor(*versions): DolphinLib( "db", [ - Object(NonMatching, "dolphin/src/db/db.c"), + Object(Matching, "dolphin/src/db/db.c"), ] ), DolphinLib( "dsp", [ Object(NonMatching, "dolphin/src/dsp/dsp.c"), - Object(NonMatching, "dolphin/src/dsp/dsp_debug.c"), + Object(Matching, "dolphin/src/dsp/dsp_debug.c"), Object(NonMatching, "dolphin/src/dsp/dsp_task.c") ] ), @@ -527,18 +527,18 @@ def MatchingFor(*versions): Object(NonMatching, "dolphin/src/dvd/dvdlow.c"), Object(NonMatching, "dolphin/src/dvd/dvdfs.c"), Object(NonMatching, "dolphin/src/dvd/dvd.c"), - Object(NonMatching, "dolphin/src/dvd/dvdqueue.c"), - Object(NonMatching, "dolphin/src/dvd/dvderror.c"), - Object(NonMatching, "dolphin/src/dvd/dvdidutils.c"), - Object(NonMatching, "dolphin/src/dvd/dvdFatal.c"), - Object(NonMatching, "dolphin/src/dvd/emu_level2/fstload.c"), + Object(Matching, "dolphin/src/dvd/dvdqueue.c"), + Object(Matching, "dolphin/src/dvd/dvderror.c"), + Object(Matching, "dolphin/src/dvd/dvdidutils.c"), + Object(Matching, "dolphin/src/dvd/dvdFatal.c"), + Object(Matching, "dolphin/src/dvd/emu_level2/fstload.c"), ], ), DolphinLib( "exi", [ - Object(NonMatching, "dolphin/src/exi/EXIBios.c"), - Object(NonMatching, "dolphin/src/exi/EXIUart.c") + Object(Matching, "dolphin/src/exi/EXIBios.c"), + Object(Matching, "dolphin/src/exi/EXIUart.c") ] ), DolphinLib( @@ -669,11 +669,11 @@ def MatchingFor(*versions): Object(Matching, "MSL_C/MSL_Common/errno.c"), Object(NonMatching, "MSL_C/MSL_Common/file_io.c"), Object(NonMatching, "MSL_C/MSL_Common/FILE_POS.C"), - Object(NonMatching, "MSL_C/MSL_Common/locale.c"), + Object(Matching, "MSL_C/MSL_Common/locale.c"), Object(NonMatching, "MSL_C/MSL_Common/mbstring.c"), Object(NonMatching, "MSL_C/MSL_Common/mem.c"), Object(NonMatching, "MSL_C/MSL_Common/mem_funcs.c"), - Object(NonMatching, "MSL_C/MSL_Common/misc_io.c"), + Object(Matching, "MSL_C/MSL_Common/misc_io.c"), Object(NonMatching, "MSL_C/MSL_Common/printf.c"), Object(NonMatching, "MSL_C/MSL_Common/qsort.c"), Object(NonMatching, "MSL_C/MSL_Common/rand.c"), @@ -682,7 +682,7 @@ def MatchingFor(*versions): Object(NonMatching, "MSL_C/MSL_Common/string.c"), Object(NonMatching, "MSL_C/MSL_Common/strtold.c"), Object(NonMatching, "MSL_C/MSL_Common/strtoul.c"), - Object(NonMatching, "MSL_C/MSL_Common/float.c"), + Object(Matching, "MSL_C/MSL_Common/float.c"), Object(NonMatching, "MSL_C/MSL_Common/char_io.c"), Object(NonMatching, "MSL_C/MSL_Common/wchar_io.c"), Object(NonMatching, "MSL_C/MSL_Common_Embedded/uart_console_io_gcn.c") @@ -692,8 +692,8 @@ def MatchingFor(*versions): "fdlibm.PPCEABI.H", [], [ - Object(NonMatching, "MSL_C/MSL_Common_Embedded/Math/Double_precision/e_acos.c"), - Object(NonMatching, "MSL_C/MSL_Common_Embedded/Math/Double_precision/e_asin.c"), + Object(Matching, "MSL_C/MSL_Common_Embedded/Math/Double_precision/e_acos.c"), + Object(Matching, "MSL_C/MSL_Common_Embedded/Math/Double_precision/e_asin.c"), Object(Matching, "MSL_C/MSL_Common_Embedded/Math/Double_precision/e_atan2.c"), Object(Matching, "MSL_C/MSL_Common_Embedded/Math/Double_precision/e_exp.c"), Object(Matching, "MSL_C/MSL_Common_Embedded/Math/Double_precision/e_fmod.c"), @@ -721,7 +721,7 @@ def MatchingFor(*versions): Object(Matching, "MSL_C/MSL_Common_Embedded/Math/Double_precision/w_fmod.c"), Object(Matching, "MSL_C/MSL_Common_Embedded/Math/Double_precision/w_log.c"), Object(Matching, "MSL_C/MSL_Common_Embedded/Math/Double_precision/w_pow.c"), - Object(NonMatching, "MSL_C/PPC_EABI/math_ppc.c"), + Object(Matching, "MSL_C/PPC_EABI/math_ppc.c"), ] ), trkLib( diff --git a/src/PowerPC_EABI_Support/include/PowerPC_EABI_Support/MSL_C/MSL_Common/math_api.h b/src/PowerPC_EABI_Support/include/PowerPC_EABI_Support/MSL_C/MSL_Common/math_api.h index d443171..56c5fe9 100644 --- a/src/PowerPC_EABI_Support/include/PowerPC_EABI_Support/MSL_C/MSL_Common/math_api.h +++ b/src/PowerPC_EABI_Support/include/PowerPC_EABI_Support/MSL_C/MSL_Common/math_api.h @@ -31,12 +31,15 @@ MATH_INLINE float cosf(float __x) return cos((double)__x); } -MATH_INLINE float atanf(float __x) +// The 3 inlines below were originally MATH_INLINE +// Changed to correct issues. Change back if needed + +inline float atanf(float __x) { return atan((double)__x); } -MATH_INLINE int __fpclassifyf(f32 x) +inline int __fpclassifyf(f32 x) { switch ((*(s32*)&x) & 0x7f800000) { @@ -60,7 +63,7 @@ MATH_INLINE int __fpclassifyf(f32 x) return 4; } -MATH_INLINE int __fpclassifyd(f64 x) +inline int __fpclassifyd(f64 x) { switch (__HI(x) & 0x7ff00000) { diff --git a/src/PowerPC_EABI_Support/src/MSL_C/MSL_Common/float.c b/src/PowerPC_EABI_Support/src/MSL_C/MSL_Common/float.c index 1aa55ea..add9731 100644 --- a/src/PowerPC_EABI_Support/src/MSL_C/MSL_Common/float.c +++ b/src/PowerPC_EABI_Support/src/MSL_C/MSL_Common/float.c @@ -1,8 +1,8 @@ -long __float_nan[] = { 0x7FFFFFFF }; -long __float_huge[] = { 0x7F800000 }; -long __double_max[] = { 0x7FEFFFFF, 0xFFFFFFFF }; -long __double_huge[] = { 0x7FF00000, 0 }; -long __extended_min[] = { 0x00100000, 0 }; -long __extended_max[] = { 0x7FEFFFFF, 0xFFFFFFFF }; -long __float_max[] = { 0x7F7FFFFF }; -long __float_epsilon[] = { 0x34000000 }; +long __float_nan[] = { 0x7FFFFFFF }; +long __float_huge[] = { 0x7F800000 }; +long __double_min[] = { 0x00100000, 0x00000000 }; +long __double_max[] = { 0x7FEFFFFF, 0xFFFFFFFF }; +long __double_huge[] = { 0x7FF00000, 0 }; +long __extended_min[] = { 0x00100000, 0 }; +long __extended_max[] = { 0x7FEFFFFF, 0xFFFFFFFF }; +long __float_max[] = { 0x7F7FFFFF }; diff --git a/src/PowerPC_EABI_Support/src/MSL_C/MSL_Common/locale.c b/src/PowerPC_EABI_Support/src/MSL_C/MSL_Common/locale.c index 7b7961b..3d6fd69 100644 --- a/src/PowerPC_EABI_Support/src/MSL_C/MSL_Common/locale.c +++ b/src/PowerPC_EABI_Support/src/MSL_C/MSL_Common/locale.c @@ -1,33 +1,34 @@ #include "types.h" -typedef struct { - char* _0; - char* _4; - char* _8; - char* _C; - char* _10; - char* _14; - char* _18; - char* _1C; - char* _20; - char _24; - char _25; - char _26; - char _27; - char _28; - char _29; - char _2A; - char* _2C; - char _30; - char _31; - char _32; - char _33; - char _34; - char _35; - char _36; +typedef struct +{ + char* _0; + char* _4; + char* _8; + char* _C; + char* _10; + char* _14; + char* _18; + char* _1C; + char* _20; + char _24; + char _25; + char _26; + char _27; + char _28; + char _29; + char _2A; + char* _2C; + char _30; + char _31; + char _32; + char _33; + char _34; + char _35; + char _36; } lconv; -lconv __lconv - = { ".", "", "", "", "", "", "", "", "", 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, "", 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F }; +lconv __lconv = { ".", "", "", "", "", "", "", "", "", 0x7F, 0x7F, 0x7F, + 0x7F, 0x7F, 0x7F, 0x7F, "", 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F }; const char* dummy = "C"; diff --git a/src/PowerPC_EABI_Support/src/MSL_C/MSL_Common/misc_io.c b/src/PowerPC_EABI_Support/src/MSL_C/MSL_Common/misc_io.c index dc4b05c..490bc0f 100644 --- a/src/PowerPC_EABI_Support/src/MSL_C/MSL_Common/misc_io.c +++ b/src/PowerPC_EABI_Support/src/MSL_C/MSL_Common/misc_io.c @@ -2,24 +2,7 @@ extern void (*__stdio_exit)(void); extern void __close_all(void); -void clearerr(void) +void __stdio_atexit(void) { - // UNUSED FUNCTION + __stdio_exit = __close_all; } - -void feof(void) -{ - // UNUSED FUNCTION -} - -void ferror(void) -{ - // UNUSED FUNCTION -} - -void perror(void) -{ - // UNUSED FUNCTION -} - -void __stdio_atexit(void) { __stdio_exit = __close_all; } diff --git a/src/PowerPC_EABI_Support/src/MSL_C/MSL_Common/rand.c b/src/PowerPC_EABI_Support/src/MSL_C/MSL_Common/rand.c index f6ed2b7..3bd508a 100644 --- a/src/PowerPC_EABI_Support/src/MSL_C/MSL_Common/rand.c +++ b/src/PowerPC_EABI_Support/src/MSL_C/MSL_Common/rand.c @@ -8,7 +8,7 @@ int rand() return ((next >> 16) & 0x7fff); } -void srand(u32 seed) +inline void srand(u32 seed) { next = seed; } diff --git a/src/PowerPC_EABI_Support/src/MSL_C/MSL_Common_Embedded/Math/Double_precision/e_pow.c b/src/PowerPC_EABI_Support/src/MSL_C/MSL_Common_Embedded/Math/Double_precision/e_pow.c index 5f9af11..0f0e51c 100644 --- a/src/PowerPC_EABI_Support/src/MSL_C/MSL_Common_Embedded/Math/Double_precision/e_pow.c +++ b/src/PowerPC_EABI_Support/src/MSL_C/MSL_Common_Embedded/Math/Double_precision/e_pow.c @@ -157,250 +157,279 @@ ivln2_l = 1.92596299112661746887e-08; /* 0x3E54AE0B, 0xF85DDF44 =1/ln2 tail*/ #ifdef __STDC__ double __ieee754_pow(double x, double y) #else -double __ieee754_pow(x, y) double x, y; +double __ieee754_pow(x, y) +double x, y; #endif { - double z, ax, z_h, z_l, p_h, p_l; - double y1, t1, t2, r, s, t, u, v, w; - double qqq; // necessary temp - int i0, i1, i, j, k, yisint, n; - int hx, hy, ix, iy; - u32 lx, ly; + double z, ax, z_h, z_l, p_h, p_l; + double y1, t1, t2, r, s, t, u, v, w; + double qqq; // necessary temp + int i0, i1, i, j, k, yisint, n; + int hx, hy, ix, iy; + u32 lx, ly; - i0 = ((*(int*)&one) >> 29) ^ 1; - i1 = 1 - i0; - hx = __HI(x); - lx = __LO(x); - hy = __HI(y); - ly = __LO(y); - ix = hx & 0x7fffffff; - iy = hy & 0x7fffffff; + i0 = ((*(int*)&one) >> 29) ^ 1; + i1 = 1 - i0; + hx = __HI(x); + lx = __LO(x); + hy = __HI(y); + ly = __LO(y); + ix = hx & 0x7fffffff; + iy = hy & 0x7fffffff; - /* y==zero: x**0 = 1 */ - if ((iy | ly) == 0) - return one; + /* y==zero: x**0 = 1 */ + if ((iy | ly) == 0) + return one; - /* +-NaN return x+y */ - if (ix > 0x7ff00000 || ((ix == 0x7ff00000) && (lx != 0)) || iy > 0x7ff00000 || ((iy == 0x7ff00000) && (ly != 0))) - return x + y; + /* +-NaN return x+y */ + if (ix > 0x7ff00000 || ((ix == 0x7ff00000) && (lx != 0)) || iy > 0x7ff00000 || + ((iy == 0x7ff00000) && (ly != 0))) + return x + y; - /* determine if y is an odd int when x < 0 + /* determine if y is an odd int when x < 0 * yisint = 0 ... y is not an integer * yisint = 1 ... y is an odd int * yisint = 2 ... y is an even int */ - yisint = 0; - if (hx < 0) { - if (iy >= 0x43400000) - yisint = 2; /* even integer y */ - else if (iy >= 0x3ff00000) { - k = (iy >> 20) - 0x3ff; /* exponent */ - if (k > 20) { - j = ly >> (52 - k); - if ((j << (52 - k)) == ly) - yisint = 2 - (j & 1); - } else if (ly == 0) { - j = iy >> (20 - k); - if ((j << (20 - k)) == iy) - yisint = 2 - (j & 1); - } - } - } + yisint = 0; + if (hx < 0) + { + if (iy >= 0x43400000) + yisint = 2; /* even integer y */ + else if (iy >= 0x3ff00000) + { + k = (iy >> 20) - 0x3ff; /* exponent */ + if (k > 20) + { + j = ly >> (52 - k); + if ((j << (52 - k)) == ly) + yisint = 2 - (j & 1); + } + else if (ly == 0) + { + j = iy >> (20 - k); + if ((j << (20 - k)) == iy) + yisint = 2 - (j & 1); + } + } + } - /* special value of y */ - if (ly == 0) { - if (iy == 0x7ff00000) { /* y is +-inf */ - if (((ix - 0x3ff00000) | lx) == 0) - return y - y; /* inf**+-1 is NaN */ - else if (ix >= 0x3ff00000) /* (|x|>1)**+-inf = inf,0 */ - return (hy >= 0) ? y : zero; - else /* (|x|<1)**-,+inf = inf,0 */ - return (hy < 0) ? -y : zero; - } - if (iy == 0x3ff00000) { /* y is +-1 */ - if (hy < 0) - return one / x; - else - return x; - } - if (hy == 0x40000000) - return x * x; /* y is 2 */ - if (hy == 0x3fe00000) { /* y is 0.5 */ - if (hx >= 0) /* x >= +0 */ - return sqrt(x); - } - } + /* special value of y */ + if (ly == 0) + { + if (iy == 0x7ff00000) + { /* y is +-inf */ + if (((ix - 0x3ff00000) | lx) == 0) + return y - y; /* inf**+-1 is NaN */ + else if (ix >= 0x3ff00000) /* (|x|>1)**+-inf = inf,0 */ + return (hy >= 0) ? y : zero; + else /* (|x|<1)**-,+inf = inf,0 */ + return (hy < 0) ? -y : zero; + } + if (iy == 0x3ff00000) + { /* y is +-1 */ + if (hy < 0) + return one / x; + else + return x; + } + if (hy == 0x40000000) + return x * x; /* y is 2 */ + if (hy == 0x3fe00000) + { /* y is 0.5 */ + if (hx >= 0) /* x >= +0 */ + return sqrt(x); + } + } - ax = __fabs(x); - qqq = ax; /*x is +-0,+-inf,+-1*/ - /* special value of x */ - if (lx == 0) { - if (ix == 0x7ff00000 || ix == 0 || ix == 0x3ff00000) { - z = qqq; /*x is +-0,+-inf,+-1*/ - if (hy < 0) - z = one / z; /* z = (1/|x|) */ - if (hx < 0) { - if (((ix - 0x3ff00000) | yisint) == 0) { - z = (z - z) / (z - z); /* (-1)**non-int is NaN */ - } else if (yisint == 1) - z = -z; /* (x<0)**odd = -(|x|**odd) */ - } - return z; - } - } + ax = __fabs(x); + qqq = ax; /*x is +-0,+-inf,+-1*/ + /* special value of x */ + if (lx == 0) + { + if (ix == 0x7ff00000 || ix == 0 || ix == 0x3ff00000) + { + z = qqq; /*x is +-0,+-inf,+-1*/ + if (hy < 0) + z = one / z; /* z = (1/|x|) */ + if (hx < 0) + { + if (((ix - 0x3ff00000) | yisint) == 0) + { + z = (z - z) / (z - z); /* (-1)**non-int is NaN */ + } + else if (yisint == 1) + z = -z; /* (x<0)**odd = -(|x|**odd) */ + } + return z; + } + } - /* (x<0)**(non-int) is NaN */ - /* CYGNUS LOCAL: This used to be + /* (x<0)**(non-int) is NaN */ + /* CYGNUS LOCAL: This used to be if((((hx>>31)+1)|yisint)==0) return (x-x)/(x-x); but ANSI C says a right shift of a signed negative quantity is implementation defined. */ - if (((((int)hx >> 31) + 1) | yisint) == 0) { - errno = 33; - return (double)NAN; - }; + if (((((int)hx >> 31) + 1) | yisint) == 0) + { + errno = 33; + return (double)NAN; + }; - /* |y| is huge */ - if (iy > 0x41e00000) { /* if |y| > 2**31 */ - if (iy > 0x43f00000) { /* if |y| > 2**64, must o/uflow */ - if (ix <= 0x3fefffff) - return (hy < 0) ? huge * huge : tiny * tiny; - if (ix >= 0x3ff00000) - return (hy > 0) ? huge * huge : tiny * tiny; - } - /* over/underflow if x is not close to one */ - if (ix < 0x3fefffff) - return (hy < 0) ? huge * huge : tiny * tiny; - if (ix > 0x3ff00000) - return (hy > 0) ? huge * huge : tiny * tiny; - /* now |1-x| is tiny <= 2**-20, suffice to compute + /* |y| is huge */ + if (iy > 0x41e00000) + { /* if |y| > 2**31 */ + if (iy > 0x43f00000) + { /* if |y| > 2**64, must o/uflow */ + if (ix <= 0x3fefffff) + return (hy < 0) ? huge * huge : tiny * tiny; + if (ix >= 0x3ff00000) + return (hy > 0) ? huge * huge : tiny * tiny; + } + /* over/underflow if x is not close to one */ + if (ix < 0x3fefffff) + return (hy < 0) ? huge * huge : tiny * tiny; + if (ix > 0x3ff00000) + return (hy > 0) ? huge * huge : tiny * tiny; + /* now |1-x| is tiny <= 2**-20, suffice to compute log(x) by x-x^2/2+x^3/3-x^4/4 */ - t = x - 1; /* t has 20 trailing zeros */ - w = (t * t) * (0.5 - t * (0.3333333333333333333333 - t * 0.25)); - u = ivln2_h * t; /* ivln2_h has 21 sig. bits */ - v = t * ivln2_l - w * ivln2; - t1 = u + v; - __LO(t1) = 0; - t2 = v - (t1 - u); - } else { - double s2, s_h, s_l, t_h, t_l; - n = 0; - /* take care subnormal number */ - if (ix < 0x00100000) { - ax *= two53; - n -= 53; - ix = __HI(ax); - } - n += ((ix) >> 20) - 0x3ff; - j = ix & 0x000fffff; - /* determine interval */ - ix = j | 0x3ff00000; /* normalize ix */ - if (j <= 0x3988E) - k = 0; /* |x|> 20) - 0x3ff; + j = ix & 0x000fffff; + /* determine interval */ + ix = j | 0x3ff00000; /* normalize ix */ + if (j <= 0x3988E) + k = 0; /* |x|> 1) | 0x20000000) + 0x00080000 + (k << 18); - t_l = ax - (t_h - bp[k]); - s_l = v * ((u - s_h * t_h) - s_h * t_l); - /* compute log(ax) */ - s2 = s * s; - r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6))))); - r += s_l * (s_h + s); - s2 = s_h * s_h; - t_h = 3.0 + s2 + r; - __LO(t_h) = 0; - t_l = r - ((t_h - 3.0) - s2); - /* u+v = s*(1+...) */ - u = s_h * t_h; - v = s_l * t_h + t_l * s; - /* 2/(3log2)*(s+...) */ - p_h = u + v; - __LO(p_h) = 0; - p_l = v - (p_h - u); - z_h = cp_h * p_h; /* cp_h+cp_l = 2/(3*log2) */ - z_l = cp_l * p_h + p_l * cp + dp_l[k]; - /* log2(ax) = (s+..)*2/(3*log2) = n + dp_h + z_h + z_l */ - t = (double)n; - t1 = (((z_h + z_l) + dp_h[k]) + t); - __LO(t1) = 0; - t2 = z_l - (((t1 - t) - dp_h[k]) - z_h); - } + /* compute s = s_h+s_l = (x-1)/(x+1) or (x-1.5)/(x+1.5) */ + u = ax - bp[k]; /* bp[0]=1.0, bp[1]=1.5 */ + v = one / (ax + bp[k]); + s = u * v; + s_h = s; + __LO(s_h) = 0; + /* t_h=ax+bp[k] High */ + t_h = zero; + __HI(t_h) = ((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18); + t_l = ax - (t_h - bp[k]); + s_l = v * ((u - s_h * t_h) - s_h * t_l); + /* compute log(ax) */ + s2 = s * s; + r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6))))); + r += s_l * (s_h + s); + s2 = s_h * s_h; + t_h = 3.0 + s2 + r; + __LO(t_h) = 0; + t_l = r - ((t_h - 3.0) - s2); + /* u+v = s*(1+...) */ + u = s_h * t_h; + v = s_l * t_h + t_l * s; + /* 2/(3log2)*(s+...) */ + p_h = u + v; + __LO(p_h) = 0; + p_l = v - (p_h - u); + z_h = cp_h * p_h; /* cp_h+cp_l = 2/(3*log2) */ + z_l = cp_l * p_h + p_l * cp + dp_l[k]; + /* log2(ax) = (s+..)*2/(3*log2) = n + dp_h + z_h + z_l */ + t = (double)n; + t1 = (((z_h + z_l) + dp_h[k]) + t); + __LO(t1) = 0; + t2 = z_l - (((t1 - t) - dp_h[k]) - z_h); + } - s = one; /* s (sign of result -ve**odd) = -1 else = 1 */ - if (((((int)hx >> 31) + 1) | (yisint - 1)) == 0) - s = -one; /* (-ve)**(odd int) */ + s = one; /* s (sign of result -ve**odd) = -1 else = 1 */ + if (((((int)hx >> 31) + 1) | (yisint - 1)) == 0) + s = -one; /* (-ve)**(odd int) */ - /* split up y into y1+y2 and compute (y1+y2)*(t1+t2) */ - y1 = y; - __LO(y1) = 0; - p_l = (y - y1) * t1 + y * t2; - p_h = y1 * t1; - z = p_l + p_h; - j = __HI(z); - i = __LO(z); - if (j >= 0x40900000) { /* z >= 1024 */ - if (((j - 0x40900000) | i) != 0) /* if z > 1024 */ - return s * huge * huge; /* overflow */ - else { - if (p_l + ovt > z - p_h) - return s * huge * huge; /* overflow */ - } - } else if ((j & 0x7fffffff) >= 0x4090cc00) { /* z <= -1075 */ - if (((j - 0xc090cc00) | i) != 0) /* z < -1075 */ - return s * tiny * tiny; /* underflow */ - else { - if (p_l <= z - p_h) - return s * tiny * tiny; /* underflow */ - } - } - /* + /* split up y into y1+y2 and compute (y1+y2)*(t1+t2) */ + y1 = y; + __LO(y1) = 0; + p_l = (y - y1) * t1 + y * t2; + p_h = y1 * t1; + z = p_l + p_h; + j = __HI(z); + i = __LO(z); + if (j >= 0x40900000) + { /* z >= 1024 */ + if (((j - 0x40900000) | i) != 0) /* if z > 1024 */ + return s * huge * huge; /* overflow */ + else + { + if (p_l + ovt > z - p_h) + return s * huge * huge; /* overflow */ + } + } + else if ((j & 0x7fffffff) >= 0x4090cc00) + { /* z <= -1075 */ + if (((j - 0xc090cc00) | i) != 0) /* z < -1075 */ + return s * tiny * tiny; /* underflow */ + else + { + if (p_l <= z - p_h) + return s * tiny * tiny; /* underflow */ + } + } + /* * compute 2**(p_h+p_l) */ - i = j & 0x7fffffff; - k = (i >> 20) - 0x3ff; - n = 0; - if (i > 0x3fe00000) { /* if |z| > 0.5, set n = [z+0.5] */ - n = j + (0x00100000 >> (k + 1)); - k = ((n & 0x7fffffff) >> 20) - 0x3ff; /* new k for n */ - t = zero; - __HI(t) = (n & ~(0x000fffff >> k)); - n = ((n & 0x000fffff) | 0x00100000) >> (20 - k); - if (j < 0) - n = -n; - p_h -= t; - } - t = p_l + p_h; - __LO(t) = 0; - u = t * lg2_h; - v = (p_l - (t - p_h)) * lg2 + t * lg2_l; - z = u + v; - w = v - (z - u); - t = z * z; - t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5)))); - r = (z * t1) / (t1 - two) - (w + z * w); - z = one - (r - z); - j = __HI(z); - j += (n << 20); - if ((j >> 20) <= 0) - z = ldexp(z, n); /* subnormal output */ - else - __HI(z) += (n << 20); - return s * z; + i = j & 0x7fffffff; + k = (i >> 20) - 0x3ff; + n = 0; + if (i > 0x3fe00000) + { /* if |z| > 0.5, set n = [z+0.5] */ + n = j + (0x00100000 >> (k + 1)); + k = ((n & 0x7fffffff) >> 20) - 0x3ff; /* new k for n */ + t = zero; + __HI(t) = (n & ~(0x000fffff >> k)); + n = ((n & 0x000fffff) | 0x00100000) >> (20 - k); + if (j < 0) + n = -n; + p_h -= t; + } + t = p_l + p_h; + __LO(t) = 0; + u = t * lg2_h; + v = (p_l - (t - p_h)) * lg2 + t * lg2_l; + z = u + v; + w = v - (z - u); + t = z * z; + t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5)))); + r = (z * t1) / (t1 - two) - (w + z * w); + z = one - (r - z); + j = __HI(z); + j += (n << 20); + if ((j >> 20) <= 0) + z = ldexp(z, n); /* subnormal output */ + else + __HI(z) += (n << 20); + return s * z; } #endif /* defined(_DOUBLE_IS_32BITS) */ diff --git a/src/PowerPC_EABI_Support/src/MSL_C/MSL_Common_Embedded/Math/Double_precision/s_ldexp.c b/src/PowerPC_EABI_Support/src/MSL_C/MSL_Common_Embedded/Math/Double_precision/s_ldexp.c index 74609e3..4110904 100644 --- a/src/PowerPC_EABI_Support/src/MSL_C/MSL_Common_Embedded/Math/Double_precision/s_ldexp.c +++ b/src/PowerPC_EABI_Support/src/MSL_C/MSL_Common_Embedded/Math/Double_precision/s_ldexp.c @@ -16,47 +16,47 @@ #include "PowerPC_EABI_Support/MSL_C/MSL_Common/math_api.h" /* for isfinite macro */ static const double - two54 - = 1.80143985094819840000e+16, /* 0x43500000, 0x00000000 */ + two54 = 1.80143985094819840000e+16, /* 0x43500000, 0x00000000 */ twom54 = 5.55111512312578270212e-17, /* 0x3C900000, 0x00000000 */ big = 1.0e+300, tiny = 1.0e-300; double ldexp(double x, int n) { - s32 k, hx, lx; /*- cc 020130 -*/ - if (!isfinite(x) || x == 0.0) - return x; + s32 k, hx, lx; /*- cc 020130 -*/ + if (!isfinite(x) || x == 0.0) + return x; - hx = __HI(x); - lx = __LO(x); - k = (hx & 0x7ff00000) >> 20; /* extract exponent */ - if (k == 0) { /* 0 or subnormal x */ - if ((lx | (hx & 0x7fffffff)) == 0) - return x; /* +-0 */ - x *= two54; - hx = __HI(x); - k = ((hx & 0x7ff00000) >> 20) - 54; - if (n < -50000) - return tiny * x; /*underflow*/ - } - if (k == 0x7ff) - return x + x; /* NaN or Inf */ - k = k + n; - if (k > 0x7fe) - return big * copysign(big, x); /* overflow */ - if (k > 0) /* normal result */ - { - __HI(x) = (hx & 0x800fffff) | (k << 20); - return x; - } - if (k <= -54) - if (n > 50000) /* in case integer overflow in n+k */ - return big * copysign(big, x); /*overflow*/ - else - return tiny * copysign(tiny, x); /*underflow*/ - k += 54; /* subnormal result */ - __HI(x) = (hx & 0x800fffff) | (k << 20); - return x * twom54; + hx = __HI(x); + lx = __LO(x); + k = (hx & 0x7ff00000) >> 20; /* extract exponent */ + if (k == 0) + { /* 0 or subnormal x */ + if ((lx | (hx & 0x7fffffff)) == 0) + return x; /* +-0 */ + x *= two54; + hx = __HI(x); + k = ((hx & 0x7ff00000) >> 20) - 54; + if (n < -50000) + return tiny * x; /*underflow*/ + } + if (k == 0x7ff) + return x + x; /* NaN or Inf */ + k = k + n; + if (k > 0x7fe) + return big * copysign(big, x); /* overflow */ + if (k > 0) /* normal result */ + { + __HI(x) = (hx & 0x800fffff) | (k << 20); + return x; + } + if (k <= -54) + if (n > 50000) /* in case integer overflow in n+k */ + return big * copysign(big, x); /*overflow*/ + else + return tiny * copysign(tiny, x); /*underflow*/ + k += 54; /* subnormal result */ + __HI(x) = (hx & 0x800fffff) | (k << 20); + return x * twom54; } /* changed __finite to __isfinite to match new naming convention 141097 bds */ diff --git a/src/PowerPC_EABI_Support/src/Runtime/global_destructor_chain.c b/src/PowerPC_EABI_Support/src/Runtime/global_destructor_chain.c index b09b0fa..b2680f3 100644 --- a/src/PowerPC_EABI_Support/src/Runtime/global_destructor_chain.c +++ b/src/PowerPC_EABI_Support/src/Runtime/global_destructor_chain.c @@ -14,5 +14,14 @@ void __destroy_global_chain(void) } } +void* __register_global_object(void* object, void* destructor, void* regmem) +{ + ((DestructorChain*)regmem)->next = __global_destructor_chain; + ((DestructorChain*)regmem)->destructor = destructor; + ((DestructorChain*)regmem)->object = object; + __global_destructor_chain = (DestructorChain*)regmem; + return object; +} + __declspec(section ".dtors") static void* const __destroy_global_chain_reference = __destroy_global_chain; diff --git a/src/dolphin/src/axfx/axfx.c b/src/dolphin/src/axfx/axfx.c index b011649..889dec9 100644 --- a/src/dolphin/src/axfx/axfx.c +++ b/src/dolphin/src/axfx/axfx.c @@ -16,7 +16,7 @@ static void __AXFXFreeFunction(void* p) void* (*__AXFXAlloc)(u32) = __AXFXAllocFunction; void (*__AXFXFree)(void*) = __AXFXFreeFunction; -void AXFXSetHooks(void* (*alloc)(u32), void (*free)(void*)) +inline void AXFXSetHooks(void* (*alloc)(u32), void (*free)(void*)) { ASSERTLINE(46, alloc && free); diff --git a/src/dolphin/src/axfx/chorus.c b/src/dolphin/src/axfx/chorus.c index 26ef726..0efb9c7 100644 --- a/src/dolphin/src/axfx/chorus.c +++ b/src/dolphin/src/axfx/chorus.c @@ -116,7 +116,7 @@ const static double i2fMagic = 4503601774854144.0; static void do_src1(AXFX_CHORUS_SRCINFO* src); static void do_src2(AXFX_CHORUS_SRCINFO* src); -asm static void do_src1(register AXFX_CHORUS_SRCINFO* src) +inline asm static void do_src1(register AXFX_CHORUS_SRCINFO* src) { nofralloc; stwu r1, -64(r1); @@ -228,199 +228,199 @@ L_00000160:; blr } -asm static void do_src2(register AXFX_CHORUS_SRCINFO* src) -{ - nofralloc; - stwu r1, -64(r1); - stmw r26, 40(r1); - lwz r4, AXFX_CHORUS_SRCINFO.posLo(src); - lwz r5, AXFX_CHORUS_SRCINFO.posHi(src); - lwz r6, AXFX_CHORUS_SRCINFO.pitchLo(src); - lwz r8, AXFX_CHORUS_SRCINFO.trigger(src); - lwz r7, AXFX_CHORUS_SRCINFO.target(src); - lwz r31, AXFX_CHORUS_SRCINFO.smpBase(src); - lwz r30, AXFX_CHORUS_SRCINFO.dest(src); - lwz r9, AXFX_CHORUS_SRCINFO.old(src); - lis r10, 0x4330; - stw r10, 8(r1); - stw r10, 16(r1); - stw r10, 24(r1); - stw r10, 32(r1); - lis r10, i2fMagic @ha; - lfd f9, i2fMagic @l(r10); - slwi r10, r5, 2; - lwz r11, 0(r9); - lwz r29, 4(r9); - lwz r28, 8(r9); - lwzx r27, r31, r10; - xoris r11, r11, 0x8000; - xoris r29, r29, 0x8000; - stw r11, 12(r1); - xoris r28, r28, 0x8000; - stw r29, 20(r1); - xoris r27, r27, 0x8000; - stw r28, 28(r1); - lfd f1, 8(r1); - stw r27, 36(r1); - lfd f2, 16(r1); - fsubs f1, f1, f9; - lfd f3, 24(r1); - fsubs f2, f2, f9; - lfd f4, 32(r1); - fsubs f3, f3, f9; - fsubs f4, f4, f9; - li r26, -4; - lis r12, rsmpTab12khz @ha; - addi r12, r12, rsmpTab12khz @l; - li r9, 160; - mtctr r9; -L_00000244:; - rlwinm r10, r4, 7, 21, 27; - addc r4, r4, r6; - add r10, r10, r12; - mcrxr cr0; - addi r5, r5, 1; - lfs f5, 0(r10); - beq L_000002C0; - lfs f6, 4(r10); - fmuls f10, f1, f5; - cmpw r5, r8; - fmr f1, f2; - lfs f7, 8(r10); - fmadds f10, f2, f6, f10; - fmr f2, f3; - lfs f8, 12(r10); - fmadds f10, f3, f7, f10; - addi r30, r30, 4; - fmr f3, f4; - bne + L_00000294; - mr r5, r7; -L_00000294:; - fmadds f10, f4, f8, f10; - slwi r9, r5, 2; - bdz L_00000344; - lwzx r10, r9, r31; - fctiwz f10, f10; - xoris r10, r10, 0x8000; - stw r10, 12(r1); - stfiwx f10, r26, r30; - lfd f4, 8(r1); - fsubs f4, f4, f9; - b L_00000244; -L_000002C0:; - cmpw r5, r8; - lfs f6, 4(r10); - bne + L_000002D0; - mr r5, r7; -L_000002D0:; - slwi r11, r5, 2; - addi r5, r5, 1; - lwzx r29, r11, r31; - fmuls f10, f1, f5; - cmpw r5, r8; - xoris r29, r29, 0x8000; - fmr f1, f3; - lfs f7, 8(r10); - stw r29, 12(r1); - fmadds f10, f2, f6, f10; - lfs f8, 12(r10); - fmadds f10, f3, f7, f10; - lfd f3, 8(r1); - fmr f2, f4; - addi r30, r30, 4; - fsubs f3, f3, f9; - bne + L_00000318; - mr r5, r7; -L_00000318:; - fmadds f10, f4, f8, f10; - slwi r9, r5, 2; - bdz L_00000344; - lwzx r10, r9, r31; - fctiwz f10, f10; - xoris r10, r10, 0x8000; - stw r10, 12(r1); - stfiwx f10, r26, r30; - lfd f4, 8(r1); - fsubs f4, f4, f9; - b L_00000244; -L_00000344:; - fctiwz f10, f10; - stfiwx f10, r26, r30; - lwz r9, AXFX_CHORUS_SRCINFO.old(src); - fctiwz f1, f1; - fctiwz f2, f2; - fctiwz f3, f3; - stfiwx f1, r0, r9; - addi r10, r9, 4; - stfiwx f2, r0, r10; - addi r10, r9, 8; - stfiwx f3, r0, r10; - stw r4, AXFX_CHORUS_SRCINFO.posLo(src); - stw r5, AXFX_CHORUS_SRCINFO.posHi(src); - lmw r26, 40(r1); - addi r1, r1, 64; - blr -} +// asm static void do_src2(register AXFX_CHORUS_SRCINFO* src) +// { +// nofralloc; +// stwu r1, -64(r1); +// stmw r26, 40(r1); +// lwz r4, AXFX_CHORUS_SRCINFO.posLo(src); +// lwz r5, AXFX_CHORUS_SRCINFO.posHi(src); +// lwz r6, AXFX_CHORUS_SRCINFO.pitchLo(src); +// lwz r8, AXFX_CHORUS_SRCINFO.trigger(src); +// lwz r7, AXFX_CHORUS_SRCINFO.target(src); +// lwz r31, AXFX_CHORUS_SRCINFO.smpBase(src); +// lwz r30, AXFX_CHORUS_SRCINFO.dest(src); +// lwz r9, AXFX_CHORUS_SRCINFO.old(src); +// lis r10, 0x4330; +// stw r10, 8(r1); +// stw r10, 16(r1); +// stw r10, 24(r1); +// stw r10, 32(r1); +// lis r10, i2fMagic @ha; +// lfd f9, i2fMagic @l(r10); +// slwi r10, r5, 2; +// lwz r11, 0(r9); +// lwz r29, 4(r9); +// lwz r28, 8(r9); +// lwzx r27, r31, r10; +// xoris r11, r11, 0x8000; +// xoris r29, r29, 0x8000; +// stw r11, 12(r1); +// xoris r28, r28, 0x8000; +// stw r29, 20(r1); +// xoris r27, r27, 0x8000; +// stw r28, 28(r1); +// lfd f1, 8(r1); +// stw r27, 36(r1); +// lfd f2, 16(r1); +// fsubs f1, f1, f9; +// lfd f3, 24(r1); +// fsubs f2, f2, f9; +// lfd f4, 32(r1); +// fsubs f3, f3, f9; +// fsubs f4, f4, f9; +// li r26, -4; +// lis r12, rsmpTab12khz @ha; +// addi r12, r12, rsmpTab12khz @l; +// li r9, 160; +// mtctr r9; +// L_00000244:; +// rlwinm r10, r4, 7, 21, 27; +// addc r4, r4, r6; +// add r10, r10, r12; +// mcrxr cr0; +// addi r5, r5, 1; +// lfs f5, 0(r10); +// beq L_000002C0; +// lfs f6, 4(r10); +// fmuls f10, f1, f5; +// cmpw r5, r8; +// fmr f1, f2; +// lfs f7, 8(r10); +// fmadds f10, f2, f6, f10; +// fmr f2, f3; +// lfs f8, 12(r10); +// fmadds f10, f3, f7, f10; +// addi r30, r30, 4; +// fmr f3, f4; +// bne + L_00000294; +// mr r5, r7; +// L_00000294:; +// fmadds f10, f4, f8, f10; +// slwi r9, r5, 2; +// bdz L_00000344; +// lwzx r10, r9, r31; +// fctiwz f10, f10; +// xoris r10, r10, 0x8000; +// stw r10, 12(r1); +// stfiwx f10, r26, r30; +// lfd f4, 8(r1); +// fsubs f4, f4, f9; +// b L_00000244; +// L_000002C0:; +// cmpw r5, r8; +// lfs f6, 4(r10); +// bne + L_000002D0; +// mr r5, r7; +// L_000002D0:; +// slwi r11, r5, 2; +// addi r5, r5, 1; +// lwzx r29, r11, r31; +// fmuls f10, f1, f5; +// cmpw r5, r8; +// xoris r29, r29, 0x8000; +// fmr f1, f3; +// lfs f7, 8(r10); +// stw r29, 12(r1); +// fmadds f10, f2, f6, f10; +// lfs f8, 12(r10); +// fmadds f10, f3, f7, f10; +// lfd f3, 8(r1); +// fmr f2, f4; +// addi r30, r30, 4; +// fsubs f3, f3, f9; +// bne + L_00000318; +// mr r5, r7; +// L_00000318:; +// fmadds f10, f4, f8, f10; +// slwi r9, r5, 2; +// bdz L_00000344; +// lwzx r10, r9, r31; +// fctiwz f10, f10; +// xoris r10, r10, 0x8000; +// stw r10, 12(r1); +// stfiwx f10, r26, r30; +// lfd f4, 8(r1); +// fsubs f4, f4, f9; +// b L_00000244; +// L_00000344:; +// fctiwz f10, f10; +// stfiwx f10, r26, r30; +// lwz r9, AXFX_CHORUS_SRCINFO.old(src); +// fctiwz f1, f1; +// fctiwz f2, f2; +// fctiwz f3, f3; +// stfiwx f1, r0, r9; +// addi r10, r9, 4; +// stfiwx f2, r0, r10; +// addi r10, r9, 8; +// stfiwx f3, r0, r10; +// stw r4, AXFX_CHORUS_SRCINFO.posLo(src); +// stw r5, AXFX_CHORUS_SRCINFO.posHi(src); +// lmw r26, 40(r1); +// addi r1, r1, 64; +// blr +// } -int AXFXChorusInit(AXFX_CHORUS* c) -{ - s32* left; - s32* right; - s32* sur; - u32 i; - BOOL old; +// int AXFXChorusInit(AXFX_CHORUS* c) +// { +// s32* left; +// s32* right; +// s32* sur; +// u32 i; +// BOOL old; - ASSERTMSGLINE(1074, - c->baseDelay >= 5 && c->baseDelay <= 15 && c->variation >= 0 && - c->variation <= 5 && c->period >= 500 && c->period <= 10000, - "The value of specified parameter is out of range."); +// ASSERTMSGLINE(1074, +// c->baseDelay >= 5 && c->baseDelay <= 15 && c->variation >= 0 && +// c->variation <= 5 && c->period >= 500 && c->period <= 10000, +// "The value of specified parameter is out of range."); - if (c->baseDelay < 5 || c->baseDelay > 15 || c->variation < 0 || c->variation > 5 || - c->period < 500 || c->period > 10000) - { - return 0; - } +// if (c->baseDelay < 5 || c->baseDelay > 15 || c->variation < 0 || c->variation > 5 || +// c->period < 500 || c->period > 10000) +// { +// return 0; +// } - old = OSDisableInterrupts(); - c->work.lastLeft[0] = __AXFXAlloc(0x1680); - ASSERTMSGLINE(0x442, c->work.lastLeft[0], "Can't allocate the memory."); +// old = OSDisableInterrupts(); +// c->work.lastLeft[0] = __AXFXAlloc(0x1680); +// ASSERTMSGLINE(0x442, c->work.lastLeft[0], "Can't allocate the memory."); - if (c->work.lastLeft[0] != NULL) - { - c->work.lastRight[0] = (void*)(c->work.lastLeft[0] + 0x1E0); - c->work.lastSur[0] = (void*)(c->work.lastRight[0] + 0x1E0); +// if (c->work.lastLeft[0] != NULL) +// { +// c->work.lastRight[0] = (void*)(c->work.lastLeft[0] + 0x1E0); +// c->work.lastSur[0] = (void*)(c->work.lastRight[0] + 0x1E0); - for (i = 1; i < 3; i++) - { - c->work.lastLeft[i] = (void*)&c->work.lastLeft[0][i * 0xA0]; - c->work.lastRight[i] = (void*)&c->work.lastRight[0][i * 0xA0]; - c->work.lastSur[i] = (void*)&c->work.lastSur[0][i * 0xA0]; - } +// for (i = 1; i < 3; i++) +// { +// c->work.lastLeft[i] = (void*)&c->work.lastLeft[0][i * 0xA0]; +// c->work.lastRight[i] = (void*)&c->work.lastRight[0][i * 0xA0]; +// c->work.lastSur[i] = (void*)&c->work.lastSur[0][i * 0xA0]; +// } - left = c->work.lastLeft[0]; - right = c->work.lastRight[0]; - sur = c->work.lastSur[0]; +// left = c->work.lastLeft[0]; +// right = c->work.lastRight[0]; +// sur = c->work.lastSur[0]; - for (i = 0; i < 0x140; i++) - { - *left++ = 0; - *right++ = 0; - *sur++ = 0; - } +// for (i = 0; i < 0x140; i++) +// { +// *left++ = 0; +// *right++ = 0; +// *sur++ = 0; +// } - c->work.currentLast = 1; - c->work.oldLeft[0] = c->work.oldLeft[1] = c->work.oldLeft[2] = c->work.oldLeft[3] = 0; - c->work.oldRight[0] = c->work.oldRight[1] = c->work.oldRight[2] = c->work.oldRight[3] = 0; - c->work.oldSur[0] = c->work.oldSur[1] = c->work.oldSur[2] = c->work.oldSur[3] = 0; - c->work.src.trigger = 0x1E0; - c->work.src.target = 0; - OSRestoreInterrupts(old); - return AXFXChorusSettings(c); - } +// c->work.currentLast = 1; +// c->work.oldLeft[0] = c->work.oldLeft[1] = c->work.oldLeft[2] = c->work.oldLeft[3] = 0; +// c->work.oldRight[0] = c->work.oldRight[1] = c->work.oldRight[2] = c->work.oldRight[3] = 0; +// c->work.oldSur[0] = c->work.oldSur[1] = c->work.oldSur[2] = c->work.oldSur[3] = 0; +// c->work.src.trigger = 0x1E0; +// c->work.src.target = 0; +// OSRestoreInterrupts(old); +// return AXFXChorusSettings(c); +// } - OSRestoreInterrupts(old); - return 0; -} +// OSRestoreInterrupts(old); +// return 0; +// } int AXFXChorusShutdown(AXFX_CHORUS* c) { @@ -432,100 +432,100 @@ int AXFXChorusShutdown(AXFX_CHORUS* c) return 1; } -int AXFXChorusSettings(AXFX_CHORUS* c) -{ - BOOL old; +// int AXFXChorusSettings(AXFX_CHORUS* c) +// { +// BOOL old; - ASSERTMSGLINE(1159, - c->baseDelay >= 5 && c->baseDelay <= 15 && c->variation >= 0 && - c->variation <= 5 && c->period >= 500 && c->period <= 10000, - "The value of specified parameter is out of range."); - if (c->baseDelay < 5 || c->baseDelay > 15 || c->variation < 0 || c->variation > 5 || - c->period < 500 || c->period > 10000) - { - return 0; - } +// ASSERTMSGLINE(1159, +// c->baseDelay >= 5 && c->baseDelay <= 15 && c->variation >= 0 && +// c->variation <= 5 && c->period >= 500 && c->period <= 10000, +// "The value of specified parameter is out of range."); +// if (c->baseDelay < 5 || c->baseDelay > 15 || c->variation < 0 || c->variation > 5 || +// c->period < 500 || c->period > 10000) +// { +// return 0; +// } - old = OSDisableInterrupts(); - c->work.currentPosHi = 0x140 - ((c->baseDelay - 5) << 5); - c->work.currentPosLo = 0; - c->work.currentPosHi = (c->work.currentPosHi + ((c->work.currentLast - 1) * 0xA0 / 1)) % 480; - c->work.pitchOffsetPeriod = ((c->period / 5) + 1) & ~(1); - c->work.pitchOffsetPeriodCount = c->work.pitchOffsetPeriod >> 1; - c->work.pitchOffset = (c->variation << 0x10) / (c->work.pitchOffsetPeriod * 5); - OSRestoreInterrupts(old); - return 1; -} +// old = OSDisableInterrupts(); +// c->work.currentPosHi = 0x140 - ((c->baseDelay - 5) << 5); +// c->work.currentPosLo = 0; +// c->work.currentPosHi = (c->work.currentPosHi + ((c->work.currentLast - 1) * 0xA0 / 1)) % 480; +// c->work.pitchOffsetPeriod = ((c->period / 5) + 1) & ~(1); +// c->work.pitchOffsetPeriodCount = c->work.pitchOffsetPeriod >> 1; +// c->work.pitchOffset = (c->variation << 0x10) / (c->work.pitchOffsetPeriod * 5); +// OSRestoreInterrupts(old); +// return 1; +// } -void AXFXChorusCallback(AXFX_BUFFERUPDATE* bufferUpdate, AXFX_CHORUS* chorus) -{ - s32* leftD; - s32* rightD; - s32* surD; - s32* leftS; - s32* rightS; - s32* surS; - u32 i; - u8 nextCurrentLast; +// void AXFXChorusCallback(AXFX_BUFFERUPDATE* bufferUpdate, AXFX_CHORUS* chorus) +// { +// s32* leftD; +// s32* rightD; +// s32* surD; +// s32* leftS; +// s32* rightS; +// s32* surS; +// u32 i; +// u8 nextCurrentLast; - nextCurrentLast = (chorus->work.currentLast + 1) % 3; - leftD = chorus->work.lastLeft[nextCurrentLast]; - rightD = chorus->work.lastRight[nextCurrentLast]; - surD = chorus->work.lastSur[nextCurrentLast]; - leftS = bufferUpdate->left; - rightS = bufferUpdate->right; - surS = bufferUpdate->surround; +// nextCurrentLast = (chorus->work.currentLast + 1) % 3; +// leftD = chorus->work.lastLeft[nextCurrentLast]; +// rightD = chorus->work.lastRight[nextCurrentLast]; +// surD = chorus->work.lastSur[nextCurrentLast]; +// leftS = bufferUpdate->left; +// rightS = bufferUpdate->right; +// surS = bufferUpdate->surround; - for (i = 0; i < 0xA0; i++) - { - *leftD++ = *leftS++; - *rightD++ = *rightS++; - *surD++ = *surS++; - } +// for (i = 0; i < 0xA0; i++) +// { +// *leftD++ = *leftS++; +// *rightD++ = *rightS++; +// *surD++ = *surS++; +// } - chorus->work.src.pitchHi = (chorus->work.pitchOffset >> 0x10) + 1; - chorus->work.src.pitchLo = (chorus->work.pitchOffset & 0xFFFF) << 0x10; +// chorus->work.src.pitchHi = (chorus->work.pitchOffset >> 0x10) + 1; +// chorus->work.src.pitchLo = (chorus->work.pitchOffset & 0xFFFF) << 0x10; - if (--chorus->work.pitchOffsetPeriodCount == 0) - { - chorus->work.pitchOffsetPeriodCount = chorus->work.pitchOffsetPeriod; - chorus->work.pitchOffset = -chorus->work.pitchOffset; - } +// if (--chorus->work.pitchOffsetPeriodCount == 0) +// { +// chorus->work.pitchOffsetPeriodCount = chorus->work.pitchOffsetPeriod; +// chorus->work.pitchOffset = -chorus->work.pitchOffset; +// } - for (i = 0; i < 3; i++) - { - chorus->work.src.posHi = chorus->work.currentPosHi; - chorus->work.src.posLo = chorus->work.currentPosLo; - switch (i) - { - case 0: - chorus->work.src.smpBase = chorus->work.lastLeft[0]; - chorus->work.src.dest = bufferUpdate->left; - chorus->work.src.old = &chorus->work.oldLeft[0]; - break; - case 1: - chorus->work.src.smpBase = chorus->work.lastRight[0]; - chorus->work.src.dest = bufferUpdate->right; - chorus->work.src.old = &chorus->work.oldRight[0]; - break; - case 2: - chorus->work.src.smpBase = chorus->work.lastSur[0]; - chorus->work.src.dest = bufferUpdate->surround; - chorus->work.src.old = &chorus->work.oldSur[0]; - break; - } - switch (chorus->work.src.pitchHi) - { - case 0: - do_src1(&chorus->work.src); - break; - case 1: - do_src2(&chorus->work.src); - break; - } - } +// for (i = 0; i < 3; i++) +// { +// chorus->work.src.posHi = chorus->work.currentPosHi; +// chorus->work.src.posLo = chorus->work.currentPosLo; +// switch (i) +// { +// case 0: +// chorus->work.src.smpBase = chorus->work.lastLeft[0]; +// chorus->work.src.dest = bufferUpdate->left; +// chorus->work.src.old = &chorus->work.oldLeft[0]; +// break; +// case 1: +// chorus->work.src.smpBase = chorus->work.lastRight[0]; +// chorus->work.src.dest = bufferUpdate->right; +// chorus->work.src.old = &chorus->work.oldRight[0]; +// break; +// case 2: +// chorus->work.src.smpBase = chorus->work.lastSur[0]; +// chorus->work.src.dest = bufferUpdate->surround; +// chorus->work.src.old = &chorus->work.oldSur[0]; +// break; +// } +// switch (chorus->work.src.pitchHi) +// { +// case 0: +// do_src1(&chorus->work.src); +// break; +// case 1: +// do_src2(&chorus->work.src); +// break; +// } +// } - chorus->work.currentPosHi = (chorus->work.src.posHi % 480); - chorus->work.currentPosLo = chorus->work.src.posLo; - chorus->work.currentLast = nextCurrentLast; -} +// chorus->work.currentPosHi = (chorus->work.src.posHi % 480); +// chorus->work.currentPosLo = chorus->work.src.posLo; +// chorus->work.currentLast = nextCurrentLast; +// } diff --git a/src/dolphin/src/axfx/delay.c b/src/dolphin/src/axfx/delay.c index e4b1d22..dbb560b 100644 --- a/src/dolphin/src/axfx/delay.c +++ b/src/dolphin/src/axfx/delay.c @@ -4,7 +4,7 @@ #include -void AXFXDelayCallback(AXFX_BUFFERUPDATE* bufferUpdate, AXFX_DELAY* delay) +inline void AXFXDelayCallback(AXFX_BUFFERUPDATE* bufferUpdate, AXFX_DELAY* delay) { s32 l; s32 r; @@ -42,7 +42,7 @@ void AXFXDelayCallback(AXFX_BUFFERUPDATE* bufferUpdate, AXFX_DELAY* delay) delay->currentPos[2] = (s32)((delay->currentPos[2] + 1) % delay->currentSize[2]); } -int AXFXDelaySettings(AXFX_DELAY* delay) +inline int AXFXDelaySettings(AXFX_DELAY* delay) { u32 i; s32* l; @@ -116,7 +116,7 @@ int AXFXDelaySettings(AXFX_DELAY* delay) return 1; } -int AXFXDelayInit(AXFX_DELAY* delay) +inline int AXFXDelayInit(AXFX_DELAY* delay) { BOOL old; @@ -148,10 +148,6 @@ int AXFXDelayShutdown(AXFX_DELAY* delay) __AXFXFree(delay->sur); } - delay->left = NULL; - delay->right = NULL; - delay->sur = NULL; - OSRestoreInterrupts(old); return 1; } diff --git a/src/dolphin/src/card/CARDBios.c b/src/dolphin/src/card/CARDBios.c index 8988eac..f97954a 100644 --- a/src/dolphin/src/card/CARDBios.c +++ b/src/dolphin/src/card/CARDBios.c @@ -1,7 +1,7 @@ #include const char* __CARDVersion = - "<< Dolphin SDK - CARD\trelease build: Apr 17 2003 12:34:19 (0x2301) >>"; + "<< Dolphin SDK - CARD\trelease build: Sep 5 2002 05:35:20 (0x2301) >>"; CARDControl __CARDBlock[2]; DVDDiskID __CARDDiskNone; @@ -719,4 +719,4 @@ static BOOL OnReset(BOOL f) } return TRUE; -} \ No newline at end of file +} diff --git a/src/dolphin/src/card/CARDCreate.c b/src/dolphin/src/card/CARDCreate.c index 06132d9..55d3a68 100644 --- a/src/dolphin/src/card/CARDCreate.c +++ b/src/dolphin/src/card/CARDCreate.c @@ -130,12 +130,12 @@ s32 CARDCreateAsync(s32 chan, const char* fileName, u32 size, CARDFileInfo* file return result; } -s32 CARDCreate(s32 channel, const char* fileName, u32 size, CARDFileInfo* fileInfo) -{ - s32 result = CARDCreateAsync(channel, fileName, size, fileInfo, __CARDSyncCallback); - if (result < 0) - { - return result; - } - return __CARDSync(channel); -} \ No newline at end of file +// s32 CARDCreate(s32 channel, const char* fileName, u32 size, CARDFileInfo* fileInfo) +// { +// s32 result = CARDCreateAsync(channel, fileName, size, fileInfo, __CARDSyncCallback); +// if (result < 0) +// { +// return result; +// } +// return __CARDSync(channel); +// } diff --git a/src/dolphin/src/card/CARDDelete.c b/src/dolphin/src/card/CARDDelete.c index 2286e20..daeb78b 100644 --- a/src/dolphin/src/card/CARDDelete.c +++ b/src/dolphin/src/card/CARDDelete.c @@ -71,15 +71,15 @@ s32 CARDDeleteAsync(s32 chan, const char* fileName, CARDCallback callback) return result; } -s32 CARDDelete(s32 chan, const char* fileName) -{ - s32 result; +// s32 CARDDelete(s32 chan, const char* fileName) +// { +// s32 result; - result = CARDDeleteAsync(chan, fileName, __CARDSyncCallback); +// result = CARDDeleteAsync(chan, fileName, __CARDSyncCallback); - if (result < 0) - { - return result; - } - return __CARDSync(chan); -} \ No newline at end of file +// if (result < 0) +// { +// return result; +// } +// return __CARDSync(chan); +// } diff --git a/src/dolphin/src/card/CARDWrite.c b/src/dolphin/src/card/CARDWrite.c index a077a96..ae4793d 100644 --- a/src/dolphin/src/card/CARDWrite.c +++ b/src/dolphin/src/card/CARDWrite.c @@ -109,7 +109,7 @@ s32 CARDWriteAsync(CARDFileInfo* fileInfo, const void* buf, s32 length, s32 offs dir = __CARDGetDirBlock(card); ent = &dir[fileInfo->fileNo]; - result = __CARDIsWritable(card, ent); + result = __CARDAccess(card, ent); if (result < 0) { return __CARDPutControlBlock(card, result); diff --git a/src/dolphin/src/dvd/dvdlow.c b/src/dolphin/src/dvd/dvdlow.c index 55baa4e..1769db3 100644 --- a/src/dolphin/src/dvd/dvdlow.c +++ b/src/dolphin/src/dvd/dvdlow.c @@ -504,16 +504,16 @@ void __DVDLowSetWAType(u32 type, u32 location) OSRestoreInterrupts(enabled); } -// BOOL __DVDLowTestAlarm(OSAlarm* alarm) -// { -// if (alarm == &AlarmForBreak) -// { -// return TRUE; -// } -// if (alarm == &AlarmForTimeout) -// { -// return TRUE; -// } - -// return FALSE; -// } \ No newline at end of file +BOOL __DVDLowTestAlarm(OSAlarm* alarm) +{ + if (alarm == &AlarmForBreak) + { + return TRUE; + } + if (alarm == &AlarmForTimeout) + { + return TRUE; + } + + return FALSE; +} diff --git a/src/dolphin/src/exi/EXIBios.c b/src/dolphin/src/exi/EXIBios.c index 0e34b61..4ae56c5 100644 --- a/src/dolphin/src/exi/EXIBios.c +++ b/src/dolphin/src/exi/EXIBios.c @@ -2,7 +2,7 @@ #include "dolphin/hw_regs.h" static const char* __EXIVersion = - "<< Dolphin SDK - EXI\trelease build: Apr 17 2003 12:33:17 (0x2301) >>"; + "<< Dolphin SDK - EXI\trelease build: Mar 11 2003 11:19:00 (0x2301) >>"; #define MAX_DEV 3 #define MAX_CHAN 3