diff --git a/.github/workflows/cmake-multi-platform.yml b/.github/workflows/cmake-multi-platform.yml index df00486..0d4bec3 100644 --- a/.github/workflows/cmake-multi-platform.yml +++ b/.github/workflows/cmake-multi-platform.yml @@ -20,7 +20,7 @@ jobs: # To add more build types (Release, Debug, RelWithDebInfo, etc.) customize the build_type list. matrix: os: [ubuntu-latest, windows-2025] - build_type: [Release] + build_type: [Release, Debug] c_compiler: [gcc, clang, cl] include: - os: windows-2025 @@ -32,6 +32,9 @@ jobs: - os: ubuntu-latest c_compiler: clang cpp_compiler: clang++ + #- os: macos-latest + # c_compiler: clang + # cpp_compiler: clang++ exclude: - os: windows-2025 c_compiler: gcc @@ -39,12 +42,20 @@ jobs: c_compiler: clang - os: ubuntu-latest c_compiler: cl + - os: macos-latest + c_compiler: gcc + - os: macos-latest + c_compiler: cl steps: - uses: actions/checkout@v4 with: submodules: recursive + - name: Update linux apt + if: ${{ matrix.os == 'ubuntu-latest' }} + run: sudo apt update + - name: Install linux dependencies if: ${{ matrix.os == 'ubuntu-latest' }} run: sudo apt install libx11-dev libopengl-dev libglx-dev mesa-common-dev build-essential git make diff --git a/.gitignore b/.gitignore index 823f92d..b9d3a16 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,4 @@ /build/vs2019 /FitdLib/shaders/generated -build/vs2022 +build data diff --git a/CMakeLists.txt b/CMakeLists.txt index 532e16d..4e179a5 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,6 +1,14 @@ project(FITD) cmake_minimum_required(VERSION 3.9) +set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DBX_CONFIG_DEBUG=0") +#set( CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /DBX_CONFIG_DEBUG=1") + +IF(MSVC) + #set( CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /D_MSVC_STL_HARDENING=1") + #set( CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /D_MSVC_STL_HARDENING=1") +ENDIF(MSVC) + set(THIRD_PARTY "${CMAKE_SOURCE_DIR}/ThirdParty") set(BGFX_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE) @@ -19,5 +27,22 @@ set(ZLIB_LIBRARY zlibstatic) set(ZLIB_TESTS OFF CACHE BOOL "Build zlib tests") add_subdirectory(${THIRD_PARTY}/zlib ${CMAKE_BINARY_DIR}/zlib/zlib-build) + add_subdirectory( FitdLib ) -add_subdirectory( Fitd ) \ No newline at end of file +add_subdirectory( Fitd ) + +#set(USE_SANITIZER ON) +if(USE_SANITIZER) + IF(MSVC) + set(SANITIZER_TYPE "address") + ELSE() + set(SANITIZER_TYPE "address,undefined,leak") + ENDIF() + + target_link_options(Fitd PRIVATE "-fsanitize=${SANITIZER_TYPE}") + target_compile_options(Fitd PRIVATE "-fsanitize=${SANITIZER_TYPE}") + target_compile_options(FitdLib PRIVATE "-fsanitize=${SANITIZER_TYPE}") + target_compile_options(bimg PRIVATE "-fsanitize=${SANITIZER_TYPE}") + target_compile_options(bgfx PRIVATE "-fsanitize=${SANITIZER_TYPE}") + target_compile_options(soloud PRIVATE "-fsanitize=${SANITIZER_TYPE}") +endif() diff --git a/Fitd/fitd.cpp b/Fitd/fitd.cpp index 3eaff39..76a82e4 100644 --- a/Fitd/fitd.cpp +++ b/Fitd/fitd.cpp @@ -1,12 +1,12 @@ extern "C" { int FitdMain(int argc, char* argv[]); -} - +} + int FitdInit(int argc, char* argv[]); int main(int argc, char* argv[]) -{ +{ FitdInit(argc, argv); FitdMain(argc, argv); return 0; -} +} diff --git a/FitdLib/AITD1.cpp b/FitdLib/AITD1.cpp index d25631a..bb76d7c 100644 --- a/FitdLib/AITD1.cpp +++ b/FitdLib/AITD1.cpp @@ -179,6 +179,7 @@ int ChoosePerso(void) int firsttime = 1; int choiceMade = 0; + uiLayer.fill(0); InitCopyBox(aux, logicalScreen); while (choiceMade == 0) @@ -316,7 +317,7 @@ void startAITD1() while (1) { #ifndef AITD_UE4 - int startupMenuResult = processStartupMenu(); + int startupMenuResult = MainMenu(); #else int startupMenuResult = 0; #endif @@ -372,11 +373,11 @@ void startAITD1() // updateShaking(); - flagInitView = 2; + FlagInitView = 2; - setupCamera(); + InitView(); - mainLoop(1, 1); + PlayWorld(1, 1); // freeScene(); diff --git a/FitdLib/AITD1_Tatou.cpp b/FitdLib/AITD1_Tatou.cpp index 6d08c5a..cf26914 100644 --- a/FitdLib/AITD1_Tatou.cpp +++ b/FitdLib/AITD1_Tatou.cpp @@ -4,9 +4,7 @@ void clearScreenTatou(void) { - int i; - - for(i=0;i<45120;i++) + for(int i=0;i<45120;i++) { frontBuffer[i] = 0; } @@ -14,26 +12,28 @@ void clearScreenTatou(void) int make3dTatou(void) { - char* tatou2d; - char* tatou3d; - unsigned char* tatouPal; - int time; + int zoom; int deltaTime; - int rotation; - int unk1; - unsigned char paletteBackup[768]; + int beta; + int alpha; unsigned int localChrono; + palette_t tatouPal; + palette_t paletteBackup; + + char* tatou2d = CheckLoadMallocPak("ITD_RESS",AITD1_TATOU_MCG); + + char* tatou3dRaw = CheckLoadMallocPak("ITD_RESS", AITD1_TATOU_3DO); + sBody* tatou3d = createBodyFromPtr(tatou3dRaw); - tatou2d = CheckLoadMallocPak("ITD_RESS",AITD1_TATOU_MCG); - tatou3d = CheckLoadMallocPak("ITD_RESS",AITD1_TATOU_3DO); - tatouPal = (unsigned char*)CheckLoadMallocPak("ITD_RESS",AITD1_TATOU_PAL); + char* tatouPalRaw = CheckLoadMallocPak("ITD_RESS",AITD1_TATOU_PAL); + copyPalette(tatouPalRaw, tatouPal); - time = 8920; + zoom = 8920; deltaTime = 50; - rotation = 256; - unk1 = 8; + beta = 256; + alpha = 8; - setupCameraProjection(160,100,128,500,490); + SetProjection(160,100,128,500,490); copyPalette(currentGamePalette,paletteBackup); @@ -58,15 +58,18 @@ int make3dTatou(void) //timeGlobal++; timer = timeGlobal; - if(evalChrono(&localChrono)<=180) // avant eclair + if(evalChrono(&localChrono)<=180) { + // before lightning strike if(key || Click) { break; } } - else // eclair + else { + // lightning strike + /* LastSample = -1; LastPriority = -1; */ @@ -81,7 +84,7 @@ int make3dTatou(void) clearScreenTatou(); - setCameraTarget(0,0,0,unk1,rotation,0,time); + setCameraTarget(0,0,0,alpha,beta,0,zoom); AffObjet(0,0,0,0,0,0,tatou3d); @@ -95,20 +98,22 @@ int make3dTatou(void) osystem_CopyBlockPhys((unsigned char*)frontBuffer,0,0,320,200); - while(key==0 && Click == 0 && JoyD == 0) // boucle de rotation du tatou + while(key==0 && Click == 0 && JoyD == 0) { + // Armadillo rotation loop + process_events(); - time+=deltaTime-25; + zoom += deltaTime; - if(time>16000) + if(zoom>16000) break; - rotation -=8; + beta -=8; clearScreenTatou(); - setCameraTarget(0,0,0,unk1,rotation,0,time); + setCameraTarget(0,0,0,alpha,beta,0,zoom); AffObjet(0,0,0,0,0,0,tatou3d); @@ -121,8 +126,9 @@ int make3dTatou(void) } }while(1); - free(tatouPal); - free(tatou3d); + delete[] tatou3dRaw; + delete tatou3d; + free(tatou2d); if(key || Click || JoyD) @@ -133,13 +139,13 @@ int make3dTatou(void) } FadeOutPhys(32,0); - copyPalette((unsigned char*)paletteBackup,currentGamePalette); + copyPalette(paletteBackup,currentGamePalette); return(1); } else { FadeOutPhys(16,0); - copyPalette((unsigned char*)paletteBackup,currentGamePalette); + copyPalette(paletteBackup,currentGamePalette); return(0); } diff --git a/FitdLib/AITD2.cpp b/FitdLib/AITD2.cpp index adeadf5..130c608 100644 --- a/FitdLib/AITD2.cpp +++ b/FitdLib/AITD2.cpp @@ -205,7 +205,7 @@ void startAITD2() while(1) { - int startupMenuResult = processStartupMenu(); + int startupMenuResult = MainMenu(); switch(startupMenuResult) { @@ -225,11 +225,11 @@ void startAITD2() { // updateShaking(); - flagInitView = 2; + FlagInitView = 2; - setupCamera(); + InitView(); - mainLoop(1, 1); + PlayWorld(1, 1); // freeScene(); @@ -271,7 +271,7 @@ void drawInventoryAITD2() statusRight = 159; statusBottom = 174; - setupCameraProjection(((statusRight-statusLeft)/2)+statusLeft,((statusBottom-statusTop)/2) + statusTop,128,400,390); + SetProjection(((statusRight-statusLeft)/2)+statusLeft,((statusBottom-statusTop)/2) + statusTop,128,400,390); } int TabXSprite [3] = {127,118,124}; @@ -291,8 +291,8 @@ void AITD2_ReadBook(int index, int type) case 0: // READ_MESSAGE { LoadPak("ITD_RESS", AITD2_LETTRE, aux); - unsigned char lpalette[0x300]; - copyPalette((unsigned char*)aux+64000,lpalette); + palette_t lpalette; + copyPalette(aux+64000,lpalette); convertPaletteIfRequired(lpalette); copyPalette(lpalette,currentGamePalette); setPalette(lpalette); @@ -304,8 +304,8 @@ void AITD2_ReadBook(int index, int type) case 1: // READ_BOOK { LoadPak("ITD_RESS", AITD2_LIVRE, aux); - unsigned char lpalette[0x300]; - copyPalette((unsigned char*)aux+64000,lpalette); + palette_t lpalette; + copyPalette(aux+64000,lpalette); convertPaletteIfRequired(lpalette); copyPalette(lpalette,currentGamePalette); setPalette(lpalette); @@ -317,8 +317,8 @@ void AITD2_ReadBook(int index, int type) case 2: // READ_CARNET { LoadPak("ITD_RESS", AITD2_CARNET, aux); - unsigned char lpalette[0x300]; - copyPalette((unsigned char*)aux+64000,lpalette); + palette_t lpalette; + copyPalette(aux+64000,lpalette); convertPaletteIfRequired(lpalette); copyPalette(lpalette,currentGamePalette); setPalette(lpalette); diff --git a/FitdLib/AITD3.cpp b/FitdLib/AITD3.cpp index af0a773..0d1d571 100644 --- a/FitdLib/AITD3.cpp +++ b/FitdLib/AITD3.cpp @@ -36,11 +36,11 @@ void startAITD3() { g_gameUseCDA = true; - //startGame(1,0,0); + startGame(1,0,0); while(1) { - int startupMenuResult = processStartupMenu(); + int startupMenuResult = MainMenu(); switch(startupMenuResult) { @@ -62,11 +62,11 @@ void startAITD3() { // updateShaking(); - flagInitView = 2; + FlagInitView = 2; - setupCamera(); + InitView(); - mainLoop(1, 1); + PlayWorld(1, 1); // freeScene(); @@ -108,5 +108,5 @@ void drawInventoryAITD3() statusRight = 159; statusBottom = 174; - setupCameraProjection(((statusRight-statusLeft)/2)+statusLeft,((statusBottom-statusTop)/2) + statusTop,128,400,390); + SetProjection(((statusRight-statusLeft)/2)+statusLeft,((statusBottom-statusTop)/2) + statusTop,128,400,390); } \ No newline at end of file diff --git a/FitdLib/CMakeLists.txt b/FitdLib/CMakeLists.txt index 86f3413..f04a4d0 100644 --- a/FitdLib/CMakeLists.txt +++ b/FitdLib/CMakeLists.txt @@ -49,52 +49,35 @@ function(assign_source_group) endforeach() endfunction(assign_source_group) -macro(addShaderProgramPermutation vsname psname varyingname platform api profileVS profilePS) - shaderc(FILE shaders/${vsname}.sc BIN2C ${vsname}_${api} OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/shaders/generated/${vsname}_${api}.h VERTEX ${platform} VARYINGDEF shaders/${varyingname}.sc INCLUDES ${BGFX_DIR}/src PROFILE ${profileVS}) - shaderc(FILE shaders/${psname}.sc BIN2C ${psname}_${api} OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/shaders/generated/${psname}_${api}.h FRAGMENT ${platform} VARYINGDEF shaders/${varyingname}.sc INCLUDES ${BGFX_DIR}/src PROFILE ${profilePS}) +macro(addShaderProgramPermutation vsname psname varyingname) + bgfx_compile_shaders(SHADERS shaders/${vsname}.sc AS_HEADERS OUTPUT_DIR ${CMAKE_CURRENT_SOURCE_DIR}/shaders/generated TYPE VERTEX VARYING_DEF ${CMAKE_CURRENT_SOURCE_DIR}/shaders/${varyingname}.sc INCLUDE_DIRS ${BGFX_DIR}/src AS_HEADERS) + bgfx_compile_shaders(SHADERS shaders/${psname}.sc AS_HEADERS OUTPUT_DIR ${CMAKE_CURRENT_SOURCE_DIR}/shaders/generated TYPE FRAGMENT VARYING_DEF ${CMAKE_CURRENT_SOURCE_DIR}/shaders/${varyingname}.sc INCLUDE_DIRS ${BGFX_DIR}/src AS_HEADERS) #shaderc(FILE shaders/${vsname}.sc BIN2C ${vsname}_${api} OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/shaders/generated/${vsname}_${api}.debug.h DEBUG VERTEX ${platform} VARYINGDEF shaders/${varyingname}.sc INCLUDES ${BGFX_DIR}/src PROFILE ${profileVS}) #shaderc(FILE shaders/${psname}.sc BIN2C ${psname}_${api} OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/shaders/generated/${psname}_${api}.debug.h DEBUG FRAGMENT ${platform} VARYINGDEF shaders/${varyingname}.sc INCLUDES ${BGFX_DIR}/src PROFILE ${profilePS}) - set(SOURCES - ${SOURCES} - ${CMAKE_CURRENT_SOURCE_DIR}/shaders/generated/${vsname}_${api}.h - ${CMAKE_CURRENT_SOURCE_DIR}/shaders/generated/${psname}_${api}.h + #set(SOURCES + # ${SOURCES} + # ${CMAKE_CURRENT_SOURCE_DIR}/shaders/generated/${vsname}_${api}.h + # ${CMAKE_CURRENT_SOURCE_DIR}/shaders/generated/${psname}_${api}.h #${CMAKE_CURRENT_SOURCE_DIR}/shaders/generated/${vsname}_${api}.debug.h #${CMAKE_CURRENT_SOURCE_DIR}/shaders/generated/${psname}_${api}.debug.h - ) + #) endmacro() macro(addShaderProgram vsname psname varyingname) -set(SOURCES - ${SOURCES} - shaders/${vsname}.sc - shaders/${psname}.sc - shaders/${varyingname}.sc -) - -IF(${CMAKE_SYSTEM_NAME} MATCHES iOS|tvOS) - addShaderProgramPermutation(${vsname} ${psname} ${varyingname} IOS glsl 430 430) - addShaderProgramPermutation(${vsname} ${psname} ${varyingname} IOS metal metal metal) -endif() - -IF(${CMAKE_SYSTEM_NAME} MATCHES Darwin) - addShaderProgramPermutation(${vsname} ${psname} ${varyingname} OSX glsl 430 430) - addShaderProgramPermutation(${vsname} ${psname} ${varyingname} OSX mtl metal metal) -endif() - -IF(${CMAKE_SYSTEM_NAME} MATCHES Windows) - addShaderProgramPermutation(${vsname} ${psname} ${varyingname} WINDOWS dx11 vs_5_0 ps_5_0) - addShaderProgramPermutation(${vsname} ${psname} ${varyingname} WINDOWS glsl 430 430) - addShaderProgramPermutation(${vsname} ${psname} ${varyingname} WINDOWS spv spirv spirv) -endif() + set(SOURCES + ${SOURCES} + shaders/${vsname}.sc + shaders/${psname}.sc + shaders/${varyingname}.sc + ) -IF(${CMAKE_SYSTEM_NAME} MATCHES Linux) - addShaderProgramPermutation(${vsname} ${psname} ${varyingname} WINDOWS glsl 430 430) - addShaderProgramPermutation(${vsname} ${psname} ${varyingname} WINDOWS spv spirv spirv) -endif() + addShaderProgramPermutation(${vsname} ${psname} ${varyingname}) + addShaderProgramPermutation(${vsname} ${psname} ${varyingname}) endmacro() +addShaderProgram(ui_vs ui_ps ui.varying.def) addShaderProgram(background_vs background_ps background.varying.def) addShaderProgram(maskBackground_vs maskBackground_ps maskBackground.varying.def) addShaderProgram(flat_vs flat_ps flat.varying.def) @@ -104,4 +87,16 @@ addShaderProgram(sphere_vs sphere_ps sphere.varying.def) assign_source_group(${SOURCES}) +if(MSVC) + add_compile_options(/Zc:__cplusplus) + add_compile_options(/Zc:preprocessor) +endif() + add_library (FitdLib ${SOURCES}) + + + +#set( CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /DBX_CONFIG_DEBUG=1") +#set( CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /DBX_CONFIG_DEBUG=1") + +set_property(TARGET FitdLib PROPERTY CXX_STANDARD 20) diff --git a/FitdLib/JACK.cpp b/FitdLib/JACK.cpp index 580c805..bbcfa86 100644 --- a/FitdLib/JACK.cpp +++ b/FitdLib/JACK.cpp @@ -20,7 +20,8 @@ void JACK_ReadBook(int index, int type) { unsigned char* pImage = (unsigned char*)loadPak("ITD_RESS", JACK_LIVRE); memcpy(aux, pImage, 320*200); - unsigned char* lpalette = pImage+320*200; + palette_t lpalette; + copyPalette(pImage + 320*200, lpalette); convertPaletteIfRequired(lpalette); copyPalette(lpalette,currentGamePalette); setPalette(lpalette); diff --git a/FitdLib/actorList.cpp b/FitdLib/actorList.cpp index 1907de9..bf89ae4 100644 --- a/FitdLib/actorList.cpp +++ b/FitdLib/actorList.cpp @@ -17,23 +17,23 @@ int sortCompareFunction(const void* param1, const void* param2) ASSERT(*(int*)param1 >=0 && *(int*)param1 < NUM_MAX_OBJECT); ASSERT(*(int*)param2 >=0 && *(int*)param2 < NUM_MAX_OBJECT); - actor1Ptr = &objectTable[*(int*)param1]; - actor2Ptr = &objectTable[*(int*)param2]; + actor1Ptr = &ListObjets[*(int*)param1]; + actor2Ptr = &ListObjets[*(int*)param2]; actor1ZvPtr = &actor1Ptr->zv; actor2ZvPtr = &actor2Ptr->zv; if(actor1Ptr->room != currentRoom) { - copyZv(actor1ZvPtr, &localZv1); - getZvRelativePosition(&localZv1, actor1Ptr->room, currentRoom); + CopyZV(actor1ZvPtr, &localZv1); + AdjustZV(&localZv1, actor1Ptr->room, currentRoom); actor1ZvPtr = &localZv1; } if(actor2Ptr->room != currentRoom) { - copyZv(actor2ZvPtr, &localZv2); - getZvRelativePosition(&localZv2, actor2Ptr->room, currentRoom); + CopyZV(actor2ZvPtr, &localZv2); + AdjustZV(&localZv2, actor2Ptr->room, currentRoom); actor2ZvPtr = &localZv2; } @@ -60,13 +60,13 @@ int sortCompareFunction(const void* param1, const void* param2) flag |= 2; } - //TODO: remove hack and find the exact cause of the bug in the sorting algorithme + //TODO: remove hack and find the exact cause of the bug in the sorting algorithm //flag = 0; if(flag == 0) { - distance1 = computeDistanceToPoint(translateX,translateZ,(actor1ZvPtr->ZVX1+actor1ZvPtr->ZVX2)/2,(actor1ZvPtr->ZVZ1+actor1ZvPtr->ZVZ2)/2); - distance2 = computeDistanceToPoint(translateX,translateZ,(actor2ZvPtr->ZVX1+actor2ZvPtr->ZVX2)/2,(actor2ZvPtr->ZVZ1+actor2ZvPtr->ZVZ2)/2); + distance1 = GiveDistance2D(translateX,translateZ,(actor1ZvPtr->ZVX1+actor1ZvPtr->ZVX2)/2,(actor1ZvPtr->ZVZ1+actor1ZvPtr->ZVZ2)/2); + distance2 = GiveDistance2D(translateX,translateZ,(actor2ZvPtr->ZVX1+actor2ZvPtr->ZVX2)/2,(actor2ZvPtr->ZVZ1+actor2ZvPtr->ZVZ2)/2); } else { @@ -134,5 +134,5 @@ int sortCompareFunction(const void* param1, const void* param2) void sortActorList() { - qsort(sortedActorTable, numActorInList, sizeof(int), sortCompareFunction); + qsort(Index.data(), NbAffObjets, sizeof(int), sortCompareFunction); } diff --git a/FitdLib/aitdBox.cpp b/FitdLib/aitdBox.cpp index 54df973..82b8d91 100644 --- a/FitdLib/aitdBox.cpp +++ b/FitdLib/aitdBox.cpp @@ -1,6 +1,6 @@ #include "common.h" -void afficheSprite(int left, int top, int index, char* gfxData) +void AffSpf(int left, int top, int index, char* gfxData) { char* outPtr; char* inPtr; @@ -17,17 +17,23 @@ void afficheSprite(int left, int top, int index, char* gfxData) return; outPtr = logicalScreen + top*320 + left; - inPtr = gfxData + READ_LE_U16(index * 2 + gfxData); // alignement unsafe + inPtr = gfxData + READ_LE_U16(index * 2 + gfxData); inPtr +=4; - width = READ_LE_U16(inPtr); // alignement unsafe + width = READ_LE_U16(inPtr); inPtr+=2; - height = READ_LE_U16(inPtr); // alignement unsafe + height = READ_LE_U16(inPtr); inPtr+=2; offset = 320 - width; + // Prevent overflow + if(height + top > 200) + { + height = top - 200; + } + for(i=0;i currentTopPosition) { - afficheSprite(currentLeftPosition,currentTopPosition,7,PtrCadre); + AffSpf(currentLeftPosition,currentTopPosition,7,PtrCadre); currentTopPosition += 20; } currentLeftPosition = left; - afficheSprite(currentLeftPosition,currentTopPosition,2,PtrCadre); // draw bottom left corner + AffSpf(currentLeftPosition,currentTopPosition,2,PtrCadre); // draw bottom left corner while(1) // draw bottom bar { @@ -154,19 +160,19 @@ void AffBigCadre(int x, int y, int width, int height) if(right-20 <= currentLeftPosition) break; - afficheSprite(currentLeftPosition,currentTopPosition+12,5,PtrCadre); + AffSpf(currentLeftPosition,currentTopPosition+12,5,PtrCadre); } - afficheSprite(currentLeftPosition,currentTopPosition,3,PtrCadre); // draw bottom right corner + AffSpf(currentLeftPosition,currentTopPosition,3,PtrCadre); // draw bottom right corner - afficheSprite(x-20,currentTopPosition+12,8,PtrCadre); // draw "in the dark" + AffSpf(x-20,currentTopPosition+12,8,PtrCadre); // draw "in the dark" WindowX1 = left + 8; WindowY1 = top + 8; WindowX2 = right - 9; WindowY2 = bottom - 9; - fillBox(WindowX1,WindowY1,WindowX2,WindowY2,0); + AffRect(WindowX1,WindowY1,WindowX2,WindowY2,0); SetClip(WindowX1,WindowY1,WindowX2,WindowY2); } diff --git a/FitdLib/anim.cpp b/FitdLib/anim.cpp index e5ad814..85dfb4a 100644 --- a/FitdLib/anim.cpp +++ b/FitdLib/anim.cpp @@ -1,126 +1,49 @@ -#include - #include "common.h" +#include "hybrid.h" -std::unordered_map g_bodyBufferMap; - -int SetAnimObjet(int frame, char* anim, char* body) -{ - sAnimation* pAnimation = getAnimationFromPtr(anim); - - s16 temp; - s16 ax; - s16 cx; - s16 bx; - char* saveAnim; - int i; - int flag; - - flag = (*(s16*)body); +hqrEntryStruct* HQ_Anims = nullptr; - temp = *(s16*)anim; - anim+=2; +std::vector BufferAnim; - if(frame >= temp) +int SetAnimObjet(int frame, sAnimation* pAnimation, sBody* body) +{ + if(frame >= pAnimation->m_numFrames) { return(0); } - ax = *(s16*)anim; - anim+=2; - - cx = ax; - - if(flag&INFO_OPTIMISE) - { - ax = ((ax<<4)+8)*frame; - } - else - { - ax = ((ax+1)<<3)*frame; - } - - anim+=ax; + int numGroupsInAnimation = pAnimation->m_numGroups; + sFrame& keyframe = pAnimation->m_frames[frame]; - animCurrentTime = *(s16*)anim; + animCurrentTime = keyframe.m_timestamp; animKeyframeLength = animCurrentTime; - if(!(flag&2)) + if(!(body->m_flags & INFO_ANIM)) { return(0); } - body +=14; - - g_bodyBufferMap[body + 2] = anim; - *(u16*)(body+6) = timer; - - body+= *(s16*)body; - body+=2; - - ax = *(s16*)body; - bx = ax; - - body+=(((ax << 1) + bx) << 1) +2; + body->startAnim = &keyframe; + *(u16*)(body->m_scratchBuffer.data() + 4) = timer; - bx = ax = *(s16*)body; + if(numGroupsInAnimation > body->m_groupOrder.size()) + numGroupsInAnimation = body->m_groupOrder.size(); - body+=bx<<1; + animStepX = keyframe.m_animStep.x; + animStepY = keyframe.m_animStep.y; + animStepZ = keyframe.m_animStep.z; - if(cx > ax) - cx = ax; - - body+=10; - - saveAnim = anim; - - anim += 8; - - for(i=0;im_groups[i].m_state.m_type = keyframe.m_groups[i].m_type; + body->m_groups[i].m_state.m_delta = keyframe.m_groups[i].m_delta; + + if(body->m_flags & INFO_OPTIMISE) { - *(s16*)(body) = *(s16*)(anim); - body+=2; - anim+=2; - *(s16*)(body) = *(s16*)(anim); - body+=2; - anim+=2; - *(s16*)(body) = *(s16*)(anim); - body+=2; - anim+=2; - *(s16*)(body) = *(s16*)(anim); - body+=2; - anim+=2; + body->m_groups[i].m_state.m_rotateDelta = keyframe.m_groups[i].m_rotateDelta; } - - body+=8; } - anim = saveAnim; - - anim+=2; - - animStepX = *(s16*)anim; - anim+=2; - animStepY = *(s16*)anim; - anim+=2; - animStepZ = *(s16*)anim; - anim+=2; - return(1); } @@ -129,23 +52,23 @@ int InitAnim(int animNum,int animType, int animInfo) { if(animNum == currentProcessedActorPtr->ANIM) { - if(!(currentProcessedActorPtr->_flags & AF_ANIMATED)) + if(!(currentProcessedActorPtr->objectType & AF_ANIMATED)) { - if(currentProcessedActorPtr->_flags & AF_BOXIFY) + if(currentProcessedActorPtr->objectType & AF_BOXIFY) { removeFromBGIncrust(currentProcessedActorIdx); } - currentProcessedActorPtr->_flags |= AF_ANIMATED; + currentProcessedActorPtr->objectType |= AF_ANIMATED; - SetAnimObjet(currentProcessedActorPtr->FRAME, HQR_Get(listAnim,animNum), HQR_Get(listBody, currentProcessedActorPtr->bodyNum)); + SetAnimObjet(currentProcessedActorPtr->frame, HQR_Get(HQ_Anims,animNum), HQR_Get(HQ_Bodys, currentProcessedActorPtr->bodyNum)); currentProcessedActorPtr->animType = animType; currentProcessedActorPtr->animInfo = animInfo; if(g_gameId > AITD1) { - currentProcessedActorPtr->FRAME = 0; + currentProcessedActorPtr->frame = 0; } return 1; @@ -164,23 +87,23 @@ int InitAnim(int animNum,int animType, int animInfo) return(1); } - if(!(currentProcessedActorPtr->_flags & AF_ANIMATED)) + if(!(currentProcessedActorPtr->objectType & AF_ANIMATED)) { - currentProcessedActorPtr->_flags |= AF_ANIMATED; + currentProcessedActorPtr->objectType |= AF_ANIMATED; - if(currentProcessedActorPtr->_flags & AF_BOXIFY) + if(currentProcessedActorPtr->objectType & AF_BOXIFY) { removeFromBGIncrust(currentProcessedActorIdx); } - SetAnimObjet(0, HQR_Get(listAnim,animNum), HQR_Get(listBody, currentProcessedActorPtr->bodyNum)); + SetAnimObjet(0, HQR_Get(HQ_Anims,animNum), HQR_Get(HQ_Bodys, currentProcessedActorPtr->bodyNum)); currentProcessedActorPtr->newAnim = animNum; currentProcessedActorPtr->newAnimType = animType; currentProcessedActorPtr->newAnimInfo = animInfo; if(g_gameId > AITD1) { - currentProcessedActorPtr->FRAME = 0; + currentProcessedActorPtr->frame = 0; } return 1; } @@ -215,35 +138,39 @@ int InitAnim(int animNum,int animType, int animInfo) if(g_gameId != AITD1) { - currentProcessedActorPtr->FRAME = 0; + currentProcessedActorPtr->frame = 0; } return(1); } -int evaluateReal(interpolatedValue* data) +int evaluateReal(RealValue* data) { - if(!data->param) - return data->newAngle; + if(!data->numSteps) + return data->endValue; - if(timer - data->timeOfRotate> (unsigned int)data->param) + if(timer - data->memoTicks> (unsigned int)data->numSteps) { - data->param = 0; - return data->newAngle; + data->numSteps = 0; + return data->endValue; } - return ((((data->newAngle - data->oldAngle)*(timer - data->timeOfRotate))/data->param)+data->oldAngle); + s32 valueDiff = data->endValue - data->startValue; + s32 currentTime = timer - data->memoTicks; + s32 interpolatedValue = data->startValue + ((valueDiff * currentTime) / data->numSteps); + + return interpolatedValue; } int manageFall(int actorIdx, ZVStruct* zvPtr) { int fallResult = 0; int i; - int room = objectTable[actorIdx].room; + int room = ListObjets[actorIdx].room; for(i=0;iindexInWorld != -1 && i != actorIdx) { @@ -252,20 +179,20 @@ int manageFall(int actorIdx, ZVStruct* zvPtr) if(currentTestedActorPtr->room != room) { ZVStruct localZv; - copyZv(zvPtr, &localZv); - getZvRelativePosition(&localZv, room, currentTestedActorPtr->room); + CopyZV(zvPtr, &localZv); + AdjustZV(&localZv, room, currentTestedActorPtr->room); - if(checkZvCollision(&localZv, testedZv)) + if(CubeIntersect(&localZv, testedZv)) { - objectTable[i].COL_BY = actorIdx; + ListObjets[i].COL_BY = actorIdx; fallResult++; } } else { - if(checkZvCollision(zvPtr, testedZv)) + if(CubeIntersect(zvPtr, testedZv)) { - objectTable[i].COL_BY = actorIdx; + ListObjets[i].COL_BY = actorIdx; fallResult++; } } @@ -275,8 +202,14 @@ int manageFall(int actorIdx, ZVStruct* zvPtr) return(fallResult); } -void updateAnimation(void) +void GereAnim(void) { + if (currentProcessedActorPtr->objectType & AF_OBJ_2D) { + if ((currentProcessedActorPtr->ANIM != -1) && (currentProcessedActorPtr->bodyNum != -1)) { + sHybrid* pHybrid = HQR_Get(HQ_Hybrides, currentProcessedActorPtr->ANIM); + } + } + int oldStepZ=0; int oldStepY=0; int oldStepX=0; @@ -289,63 +222,74 @@ void updateAnimation(void) int newAnim = currentProcessedActorPtr->newAnim; - if(newAnim != -1) // next anim ? - { - if(newAnim == -2) // completely stop anim and add actor to background - { - addActorToBgInscrust(currentProcessedActorIdx); - currentProcessedActorPtr->newAnim = -1; - currentProcessedActorPtr->newAnimType = 0; - currentProcessedActorPtr->newAnimInfo = -1; - currentProcessedActorPtr->END_ANIM = 1; + if (newAnim != -1) // next anim ? + { + if (newAnim == -2) // completely stop anim and add actor to background + { + addActorToBgInscrust(currentProcessedActorIdx); + currentProcessedActorPtr->newAnim = -1; + currentProcessedActorPtr->newAnimType = 0; + currentProcessedActorPtr->newAnimInfo = -1; + currentProcessedActorPtr->flagEndAnim = 1; - return; - } + return; + } + else { + if (!(currentProcessedActorPtr->newAnimType & ANIM_RESET)) // Reset + { + if (currentProcessedActorPtr->END_FRAME == 0) + { + currentProcessedActorPtr->worldX += currentProcessedActorPtr->stepX; + currentProcessedActorPtr->roomX += currentProcessedActorPtr->stepX; - if(currentProcessedActorPtr->END_FRAME == 0) - { - currentProcessedActorPtr->worldX += currentProcessedActorPtr->stepX; - currentProcessedActorPtr->roomX += currentProcessedActorPtr->stepX; + currentProcessedActorPtr->worldZ += currentProcessedActorPtr->stepZ; + currentProcessedActorPtr->roomZ += currentProcessedActorPtr->stepZ; - currentProcessedActorPtr->worldZ += currentProcessedActorPtr->stepZ; - currentProcessedActorPtr->roomZ += currentProcessedActorPtr->stepZ; + currentProcessedActorPtr->stepX = 0; + currentProcessedActorPtr->stepZ = 0; - currentProcessedActorPtr->stepX = 0; - currentProcessedActorPtr->stepZ = 0; + currentProcessedActorPtr->animNegX = 0; + currentProcessedActorPtr->animNegY = 0; + currentProcessedActorPtr->animNegZ = 0; + } - currentProcessedActorPtr->animNegX = 0; - currentProcessedActorPtr->animNegY = 0; - currentProcessedActorPtr->animNegZ = 0; - } + // TODO: AITD3 has some extra code here to handle bufferAnimCounter + StockInterAnim(BufferAnim[bufferAnimCounter], HQR_Get(HQ_Bodys, currentProcessedActorPtr->bodyNum)); - initBufferAnim(BufferAnim[bufferAnimCounter], HQR_Get(listBody,currentProcessedActorPtr->bodyNum)); + bufferAnimCounter++; + if (bufferAnimCounter == NB_BUFFER_ANIM) + bufferAnimCounter = 0; - bufferAnimCounter++; - if(bufferAnimCounter == NB_BUFFER_ANIM) - bufferAnimCounter = 0; + } + else { + ResetStartAnim(HQR_Get(HQ_Bodys, currentProcessedActorPtr->bodyNum)); + currentProcessedActorPtr->newAnimType &= ~ANIM_RESET; + } + currentProcessedActorPtr->ANIM = newAnim; + currentProcessedActorPtr->animType = currentProcessedActorPtr->newAnimType; + currentProcessedActorPtr->animInfo = currentProcessedActorPtr->newAnimInfo; - currentProcessedActorPtr->ANIM = newAnim; - currentProcessedActorPtr->animType = currentProcessedActorPtr->newAnimType; - currentProcessedActorPtr->animInfo = currentProcessedActorPtr->newAnimInfo; - currentProcessedActorPtr->newAnim = -1; - currentProcessedActorPtr->newAnimType = 0; - currentProcessedActorPtr->newAnimInfo = -1; - currentProcessedActorPtr->END_ANIM = 0; - currentProcessedActorPtr->FRAME = 0; + currentProcessedActorPtr->newAnim = -1; + currentProcessedActorPtr->newAnimType = 0; + currentProcessedActorPtr->newAnimInfo = -1; - currentProcessedActorPtr->numOfFrames = GetNbFramesAnim(HQR_Get(listAnim,newAnim)); - } + currentProcessedActorPtr->flagEndAnim = 0; + currentProcessedActorPtr->frame = 0; + + currentProcessedActorPtr->numOfFrames = GetNbFramesAnim(HQR_Get(HQ_Anims, newAnim)); + } + } if(currentProcessedActorPtr->ANIM == -1) // no animation { currentProcessedActorPtr->END_FRAME = 0; if(currentProcessedActorPtr->speed == 0) { - int numObjectCollisions = checkObjectCollisions(currentProcessedActorIdx, ¤tProcessedActorPtr->zv); + int numObjectCollisions = CheckObjectCol(currentProcessedActorIdx, ¤tProcessedActorPtr->zv); for(int i = 0; iCOL[i]].COL_BY = currentProcessedActorIdx; // collision with current actor + ListObjets[currentProcessedActorPtr->COL[i]].COL_BY = currentProcessedActorIdx; // collision with current actor } oldStepY = 0; @@ -378,7 +322,7 @@ void updateAnimation(void) oldStepY = currentProcessedActorPtr->stepY; oldStepZ = currentProcessedActorPtr->stepZ; - currentProcessedActorPtr->END_FRAME = SetInterAnimObjet(currentProcessedActorPtr->FRAME, HQR_Get(listAnim, currentProcessedActorPtr->ANIM), HQR_Get(listBody, currentProcessedActorPtr->bodyNum)); + currentProcessedActorPtr->END_FRAME = SetInterAnimObjet(currentProcessedActorPtr->frame, HQR_Get(HQ_Anims, currentProcessedActorPtr->ANIM), HQR_Get(HQ_Bodys, currentProcessedActorPtr->bodyNum)); walkStep(animStepX,animStepZ,currentProcessedActorPtr->beta); @@ -387,19 +331,19 @@ void updateAnimation(void) } - if(currentProcessedActorPtr->YHandler.param) // currently falling ? + if(currentProcessedActorPtr->YHandler.numSteps) // currently falling ? { - if(currentProcessedActorPtr->YHandler.param != -1) + if(currentProcessedActorPtr->YHandler.numSteps != -1) { stepY = evaluateReal(¤tProcessedActorPtr->YHandler) - oldStepY; } else // stop falling { - stepY = currentProcessedActorPtr->YHandler.newAngle - oldStepY; + stepY = currentProcessedActorPtr->YHandler.endValue - oldStepY; - currentProcessedActorPtr->YHandler.param = 0; - currentProcessedActorPtr->YHandler.newAngle = 0; - currentProcessedActorPtr->YHandler.oldAngle = 0; + currentProcessedActorPtr->YHandler.numSteps = 0; + currentProcessedActorPtr->YHandler.endValue = 0; + currentProcessedActorPtr->YHandler.startValue = 0; } } else @@ -412,7 +356,7 @@ void updateAnimation(void) if(stepX || stepY || stepZ) // start of movement management { zvPtr = ¤tProcessedActorPtr->zv; - copyZv(¤tProcessedActorPtr->zv,&zvLocal); + CopyZV(¤tProcessedActorPtr->zv,&zvLocal); zvLocal.ZVX1 += stepX; zvLocal.ZVX2 += stepX; @@ -423,6 +367,7 @@ void updateAnimation(void) zvLocal.ZVZ1 += stepZ; zvLocal.ZVZ2 += stepZ; + // check for wall collisions if(currentProcessedActorPtr->dynFlags & 1) // hard collision enabled for actor ? { int numCol = AsmCheckListCol(&zvLocal, &roomDataTable[currentProcessedActorPtr->room]); @@ -436,38 +381,42 @@ void updateAnimation(void) currentProcessedActorPtr->HARD_COL = (short)pHardCol->parameter; } + // climbable wall if(pHardCol->type == 3) { currentProcessedActorPtr->HARD_COL = 255; } - if(g_gameId == AITD1 || (g_gameId>=JACK && (pHardCol->type != 10 || currentProcessedActorIdx != currentCameraTargetActor))) + if (g_gameId >= JACK) { + // monster collision for floor changes + if ((pHardCol->type == 10) && (currentProcessedActorIdx == currentCameraTargetActor)) + continue; + } + + if(stepX || stepZ) // move on the X or Z axis ? update to avoid entering the hard col { - if(stepX || stepZ) // move on the X or Z axis ? update to avoid entering the hard col - { - //ZVStruct tempZv; + //ZVStruct tempZv; - hardColStepX = stepX; - hardColStepZ = stepZ; + hardColStepX = stepX; + hardColStepZ = stepZ; - handleCollision(zvPtr, &zvLocal, &pHardCol->zv); + GereCollision(zvPtr, &zvLocal, &pHardCol->zv); - currentProcessedActorPtr->animNegX += hardColStepX - stepX; - currentProcessedActorPtr->animNegZ += hardColStepZ - stepZ; + currentProcessedActorPtr->animNegX += hardColStepX - stepX; + currentProcessedActorPtr->animNegZ += hardColStepZ - stepZ; - zvLocal.ZVX1 += hardColStepX - stepX; - zvLocal.ZVX2 += hardColStepX - stepX; - zvLocal.ZVZ1 += hardColStepZ - stepZ; - zvLocal.ZVZ2 += hardColStepZ - stepZ; + zvLocal.ZVX1 += hardColStepX - stepX; + zvLocal.ZVX2 += hardColStepX - stepX; + zvLocal.ZVZ1 += hardColStepZ - stepZ; + zvLocal.ZVZ2 += hardColStepZ - stepZ; - stepX = hardColStepX; - stepZ = hardColStepZ; - } + stepX = hardColStepX; + stepZ = hardColStepZ; + } - if(stepY) - { - //assert(0); //not implemented - } + if(stepY) + { + //assert(0); //not implemented } } } @@ -483,34 +432,35 @@ void updateAnimation(void) } } - int numCol = checkObjectCollisions(currentProcessedActorIdx,&zvLocal); // get the number of actor/actor collision - + // check for object collisions + // TODO: AITD2 checks flag collision here + int numCol = CheckObjectCol(currentProcessedActorIdx,&zvLocal); // get the number of actor/actor collision for(int j=0;jCOL[j]; - tObject* actorTouchedPtr = &objectTable[collisionIndex]; + tObject* actorTouchedPtr = &ListObjets[collisionIndex]; actorTouchedPtr->COL_BY = currentProcessedActorIdx; ZVStruct* touchedZv = &actorTouchedPtr->zv; - if(actorTouchedPtr->_flags & AF_FOUNDABLE) // takable + if(actorTouchedPtr->objectType & AF_FOUNDABLE) // takable { if(currentProcessedActorPtr->trackMode == 1 /*&& ((gameId == AITD1 && defines.field_1E == 0) || (gameId >= JACK && defines.field_6 == 0))*/) // TODO: check if character isn't dead... { - foundObject(actorTouchedPtr->indexInWorld, 0); + FoundObjet(actorTouchedPtr->indexInWorld, 0); } + continue; } - else { - if(actorTouchedPtr->_flags & AF_MOVABLE) // can be pushed ? + if(actorTouchedPtr->objectType & AF_MOVABLE) // can be pushed ? { ZVStruct localZv2; bool isPushPossible = true; - copyZv(touchedZv, &localZv2); + CopyZV(touchedZv, &localZv2); localZv2.ZVX1 += stepX; localZv2.ZVX2 += stepX; @@ -518,17 +468,16 @@ void updateAnimation(void) localZv2.ZVZ1 += stepZ; localZv2.ZVZ2 += stepZ; - if(!AsmCheckListCol(&localZv2, &roomDataTable[currentProcessedActorPtr->room])) - { - if(checkObjectCollisions(collisionIndex, &localZv2)) - { - isPushPossible = false; - } - } - else + // check pushed object against walls + if(AsmCheckListCol(&localZv2, &roomDataTable[currentProcessedActorPtr->room])) { - isPushPossible = false; + isPushPossible = false; } + else if (CheckObjectCol(collisionIndex, &localZv2)) + { + // if no wall preventing to move object, check is there is a another object in the way + isPushPossible = false; + } if(!isPushPossible) { @@ -538,14 +487,14 @@ void updateAnimation(void) { ZVStruct localZv3; - copyZv(touchedZv, &localZv3); + CopyZV(touchedZv, &localZv3); - getZvRelativePosition(&localZv3, actorTouchedPtr->room, currentProcessedActorPtr->room); + AdjustZV(&localZv3, actorTouchedPtr->room, currentProcessedActorPtr->room); hardColStepX = stepX; hardColStepZ = stepZ; - handleCollision(zvPtr, &zvLocal, &localZv3); + GereCollision(zvPtr, &zvLocal, &localZv3); stepX = hardColStepX; stepZ = hardColStepZ; @@ -555,7 +504,7 @@ void updateAnimation(void) hardColStepX = stepX; hardColStepZ = stepZ; - handleCollision(zvPtr, &zvLocal, touchedZv); // manage as hard collision + GereCollision(zvPtr, &zvLocal, touchedZv); // manage as hard collision stepX = hardColStepX; stepZ = hardColStepZ; @@ -564,12 +513,12 @@ void updateAnimation(void) } else // push succeed { - if(actorTouchedPtr->_flags & AF_BOXIFY) + if(actorTouchedPtr->objectType & AF_BOXIFY) { removeFromBGIncrust(collisionIndex); } - actorTouchedPtr->_flags |= AF_ANIMATED; + actorTouchedPtr->objectType |= AF_ANIMATED; actorTouchedPtr->worldX += stepX; // apply push to object actorTouchedPtr->worldZ += stepZ; @@ -577,7 +526,7 @@ void updateAnimation(void) actorTouchedPtr->roomX += stepX; actorTouchedPtr->roomZ += stepZ; - copyZv(&localZv2,touchedZv); + CopyZV(&localZv2,touchedZv); } } else @@ -592,7 +541,7 @@ void updateAnimation(void) hardColStepX = stepX; hardColStepZ = stepZ; - handleCollision(zvPtr, &zvLocal, touchedZv); // manage as hard collision + GereCollision(zvPtr, &zvLocal, touchedZv); // manage as hard collision stepX = hardColStepX; stepZ = hardColStepZ; @@ -601,14 +550,14 @@ void updateAnimation(void) { ZVStruct localZv3; - copyZv(touchedZv, &localZv3); + CopyZV(touchedZv, &localZv3); - getZvRelativePosition(&localZv3, actorTouchedPtr->room, currentProcessedActorPtr->room); + AdjustZV(&localZv3, actorTouchedPtr->room, currentProcessedActorPtr->room); hardColStepX = stepX; hardColStepZ = stepZ; - handleCollision(zvPtr, &zvLocal, &localZv3); // manage as hard collision + GereCollision(zvPtr, &zvLocal, &localZv3); // manage as hard collision stepX = hardColStepX; stepZ = hardColStepZ; @@ -633,7 +582,7 @@ void updateAnimation(void) currentProcessedActorPtr->zv.ZVZ2 += stepZ; } // end of movement management - if(!currentProcessedActorPtr->YHandler.param) + if(!currentProcessedActorPtr->YHandler.numSteps) { // fall management ? currentProcessedActorPtr->worldY += currentProcessedActorPtr->stepY; @@ -641,11 +590,11 @@ void updateAnimation(void) currentProcessedActorPtr->stepY = 0; - if(currentProcessedActorPtr->_flags & AF_FALLABLE) + if(currentProcessedActorPtr->objectType & AF_FALLABLE) { zvPtr = ¤tProcessedActorPtr->zv; - copyZv(zvPtr, &zvLocal); + CopyZV(zvPtr, &zvLocal); zvLocal.ZVY2 += 100; @@ -661,7 +610,7 @@ void updateAnimation(void) } else { - if((currentProcessedActorPtr->YHandler.param != -1) && (currentProcessedActorPtr->_flags & AF_FALLABLE)) + if((currentProcessedActorPtr->YHandler.numSteps != -1) && (currentProcessedActorPtr->objectType & AF_FALLABLE)) { currentProcessedActorPtr->falling = 1; } @@ -673,9 +622,9 @@ void updateAnimation(void) if(collisionIndex != -1) { - tObject* actorTouchedPtr = &objectTable[collisionIndex]; + tObject* actorTouchedPtr = &ListObjets[collisionIndex]; - if(actorTouchedPtr->_flags & AF_MOVABLE) + if(actorTouchedPtr->objectType & AF_MOVABLE) { int i; @@ -687,7 +636,7 @@ void updateAnimation(void) if(i == 3) { - actorTouchedPtr->_flags &= ~AF_ANIMATED; + actorTouchedPtr->objectType &= ~AF_ANIMATED; addActorToBgInscrust(collisionIndex); } } @@ -696,12 +645,12 @@ void updateAnimation(void) if(currentProcessedActorPtr->END_FRAME) // key frame change { - currentProcessedActorPtr->FRAME++; + currentProcessedActorPtr->frame++; - if(currentProcessedActorPtr->FRAME >= currentProcessedActorPtr->numOfFrames) // end of anim ? + if(currentProcessedActorPtr->frame >= currentProcessedActorPtr->numOfFrames) // end of anim ? { - currentProcessedActorPtr->END_ANIM = 1; // end of anim - currentProcessedActorPtr->FRAME = 0; // restart anim + currentProcessedActorPtr->flagEndAnim = 1; // end of anim + currentProcessedActorPtr->frame = 0; // restart anim if(!(currentProcessedActorPtr->animType & 1) && (currentProcessedActorPtr->newAnim == -1)) // is another anim waiting ? { @@ -725,7 +674,7 @@ void updateAnimation(void) } else // not the end of anim { - if((currentProcessedActorPtr->ANIM == -1) && (currentProcessedActorPtr->speed != 0) && (currentProcessedActorPtr->speedChange.param == 0)) + if((currentProcessedActorPtr->ANIM == -1) && (currentProcessedActorPtr->speed != 0) && (currentProcessedActorPtr->speedChange.numSteps == 0)) { currentProcessedActorPtr->worldX += currentProcessedActorPtr->stepX; currentProcessedActorPtr->roomX += currentProcessedActorPtr->stepX; @@ -739,104 +688,49 @@ void updateAnimation(void) InitRealValue(0,currentProcessedActorPtr->speed,60,¤tProcessedActorPtr->speedChange); } - currentProcessedActorPtr->END_ANIM = 0; + currentProcessedActorPtr->flagEndAnim = 0; } } -void initBufferAnim(std::vector& buffer, char* bodyPtr) -{ - std::vector::iterator bufferIt = buffer.begin(); - - int flag = *(s16*)bodyPtr; - if(flag & 2) +void StockInterAnim(sFrame& buffer, sBody* bodyPtr) +{ + if(bodyPtr->m_flags & INFO_ANIM) { - char* source = bodyPtr+0x10; - s16 ax; - int cx; - int i; - - *(u16*)(source+4) = (u16)timer; - - g_bodyBufferMap[source] = (char*)&buffer[0]; - - source += *(s16*)(source-2); - - ax = *(s16*)(source); - - ax = (((ax * 2) + ax)*2)+2; - - source += ax; - - cx = *(s16*)source; + *(u16*)(bodyPtr->m_scratchBuffer.data()+4) = (u16)timer; + bodyPtr->startAnim = &buffer; - source += cx*2; - - bufferIt += 4; - source+= 10; - - for(i=0;im_groups.size()); + for (int i = 0; i < bodyPtr->m_groups.size(); i++) { + buffer.m_groups[i] = bodyPtr->m_groups[i].m_state; } + } +} - } +void ResetStartAnim(sBody* bodyPtr) { + *(u16*)(bodyPtr->m_scratchBuffer.data() + 4) = (u16)timer; // reset timer + bodyPtr->startAnim = nullptr; } -s16 GetNbFramesAnim(char* animPtr) +s16 GetNbFramesAnim(sAnimation* animPtr) { - return(*(s16*)animPtr); + return animPtr->m_numFrames; } -s16 PatchType(char** bodyPtr) // local +s16 PatchType(sGroupState* bodyPtr, u16 type) // local { - s16 temp = *(s16*)animVar1; - - animVar1+=2; - - animVar4+=2; + bodyPtr->m_type = type; - *(s16*)(*bodyPtr) = temp; - (*bodyPtr)+=2; - - return(temp); + return(bodyPtr->m_type); } -void PatchInterAngle(char** bodyPtr, int bp, int bx) // local +void PatchInterAngle(s16* value, s16 previousValue, s16 nextValue, int bp, int bx) // local { - s16 oldRotation = *(s16*)animVar4; - s16 newRotation; - s16 diff; - - animVar4+=2; - - newRotation = *(s16*)animVar1; - animVar1+=2; - - diff = newRotation - oldRotation; + s16 diff = nextValue - previousValue; if(diff == 0) { - *(s16*)(*bodyPtr) = newRotation; + *value = nextValue; } else { @@ -844,52 +738,44 @@ void PatchInterAngle(char** bodyPtr, int bp, int bx) // local { if(diff >= -0x200) { - *(s16*)(*bodyPtr) = ((diff*bp)/bx) + oldRotation; + *value = ((diff*bp)/bx) + previousValue; } else { - newRotation += 0x400; - newRotation -= oldRotation; + nextValue += 0x400; + nextValue -= previousValue; - *(s16*)(*bodyPtr) = ((newRotation*bp)/bx) + oldRotation; + *value = ((nextValue *bp)/bx) + previousValue; } } else { - oldRotation += 0x400; - newRotation -= oldRotation; + previousValue += 0x400; + nextValue -= previousValue; - *(s16*)(*bodyPtr) = ((newRotation*bp)/bx) + oldRotation; + *value = ((nextValue *bp)/bx) + previousValue; } } - - (*bodyPtr)+=2; } -void PatchInterStep(char** bodyPtr, int bp, int bx) // local +void PatchInterStep(s16* value, s16 previousValue, s16 nextValue, int bp, int bx) // local { - s16 cx = *(s16*)animVar4; - s16 ax; - animVar4+=2; - - ax = *(s16*)animVar1; - animVar1+=2; + s16 cx = previousValue; + s16 ax = nextValue; if(ax == cx) { - *(s16*)(*bodyPtr) = ax; + *value = ax; } else { - *(s16*)(*bodyPtr) = (((ax - cx)*bp)/bx) + cx; + *value = (((ax - cx)*bp)/bx) + cx; } - - (*bodyPtr)+=2; } -s16 SetInterAnimObjet(int frame, char* animPtr, char* bodyPtr) -{ - int numOfBonesInAnim = *(s16*)(animPtr+2); +s16 SetInterAnimObjet(int frame, sAnimation* pAnim, sBody* pBody) +{ + int numOfBonesInAnim = pAnim->m_numGroups; u16 keyframeLength; u16 timeOfKeyframeStart; int ax; @@ -897,65 +783,32 @@ s16 SetInterAnimObjet(int frame, char* animPtr, char* bodyPtr) u16 time; int bp; int flag; - - sBody* pBody = getBodyFromPtr(bodyPtr); flag = pBody->m_flags; - animPtr+=4; - - if(flag&INFO_OPTIMISE) - { - animPtr += ((numOfBonesInAnim<<4)+8)*frame; // seek to keyframe - } - else - { - animPtr += ((numOfBonesInAnim+1)*8)*frame; // seek to keyframe - } - - // animVar1 = ptr to the current keyFrame - animVar1 = animPtr; + sFrame* pKeyframe = &pAnim->m_frames[frame]; - keyframeLength = *(u16*)animPtr; // keyframe length + keyframeLength = pKeyframe->m_timestamp; // keyframe length if(!(pBody->m_flags & INFO_ANIM)) // do not anim if the model can't be animated { return(0); } - bodyPtr+=16;// skip the flags, ZV, scratch buffer size - - animVar3 = bodyPtr; // this is the scratch buffer - - timeOfKeyframeStart = *(u16*)(bodyPtr+4); // time of start of keyframe + timeOfKeyframeStart = *(u16*)(pBody->m_scratchBuffer.data() + 4); // time of start of keyframe - char* animBufferPtr = g_bodyBufferMap[bodyPtr]; + sFrame* pPreviousKeyframe = pBody->startAnim; - if(!animBufferPtr) + if(!pPreviousKeyframe) { - animBufferPtr = animVar1; + pPreviousKeyframe = pKeyframe; } - // animVar4 = ptr to previous key frame - animVar4 = animBufferPtr; - - bodyPtr+= *(s16*)(bodyPtr-2); // skip over scratch buffer - - ax = *(s16*)bodyPtr; // num vertices - ax = (ax*6)+2; - bodyPtr+=ax; // skip the vertices - - ax = *(s16*)bodyPtr; // num of group order - bx = ax; - bodyPtr+=bx*2; // skip group order table - if(numOfBonesInAnim > pBody->m_groupOrder.size()) { numOfBonesInAnim = pBody->m_groupOrder.size(); } - bodyPtr+=10; // skip bone 0 - time = (u16)timer - timeOfKeyframeStart; bx = keyframeLength; @@ -963,83 +816,63 @@ s16 SetInterAnimObjet(int frame, char* animPtr, char* bodyPtr) if(timem_groups[i].m_state.m_delta; + point3dStruct& previousState = pPreviousKeyframe->m_groups[i].m_delta; + point3dStruct& nextState = pKeyframe->m_groups[i].m_delta; + switch(PatchType(&pBody->m_groups[i].m_state, pKeyframe->m_groups[i].m_type)) { case 0: // rotate - PatchInterAngle(&bodyPtr,bp,bx); - PatchInterAngle(&bodyPtr,bp,bx); - PatchInterAngle(&bodyPtr,bp,bx); + PatchInterAngle(&state.x, previousState.x, nextState.x, bp, bx); + PatchInterAngle(&state.y, previousState.y, nextState.y, bp, bx); + PatchInterAngle(&state.z, previousState.z, nextState.z, bp, bx); break; case 1: // translate - PatchInterStep(&bodyPtr,bp,bx); - PatchInterStep(&bodyPtr,bp,bx); - PatchInterStep(&bodyPtr,bp,bx); - break; - case 2: // zoom - PatchInterStep(&bodyPtr,bp,bx); - PatchInterStep(&bodyPtr,bp,bx); - PatchInterStep(&bodyPtr,bp,bx); + PatchInterStep(&state.x, previousState.x, nextState.x, bp, bx); + PatchInterStep(&state.y, previousState.y, nextState.y, bp, bx); + PatchInterStep(&state.z, previousState.z, nextState.z, bp, bx); break; } - - bodyPtr+=8; } - while(--numOfBonesInAnim); } else { - do + for (int i = 0; i < numOfBonesInAnim; i++) { - switch(PatchType(&bodyPtr)) + point3dStruct& state = pBody->m_groups[i].m_state.m_delta; + point3dStruct& previousState = pPreviousKeyframe->m_groups[i].m_delta; + point3dStruct& nextState = pKeyframe->m_groups[i].m_delta; + switch (PatchType(&pBody->m_groups[i].m_state, pKeyframe->m_groups[i].m_type)) { case 0: - { - animVar4 += 6; - animVar1 += 6; - bodyPtr += 6; break; - } case 1: case 2: - { - PatchInterStep(&bodyPtr,bp,bx); - PatchInterStep(&bodyPtr,bp,bx); - PatchInterStep(&bodyPtr,bp,bx); - break; - } + PatchInterStep(&state.x, previousState.x, nextState.x, bp, bx); + PatchInterStep(&state.y, previousState.y, nextState.y, bp, bx); + PatchInterStep(&state.z, previousState.z, nextState.z, bp, bx); + break; } - PatchInterAngle(&bodyPtr,bp,bx); - PatchInterAngle(&bodyPtr,bp,bx); - PatchInterAngle(&bodyPtr,bp,bx); - - animVar4 += 2; - animVar1 += 2; - bodyPtr += 10; + { + point3dStruct& state = pBody->m_groups[i].m_state.m_rotateDelta.value(); + point3dStruct& previousState = pPreviousKeyframe->m_groups[i].m_rotateDelta.value(); + point3dStruct& nextState = pKeyframe->m_groups[i].m_rotateDelta.value(); + PatchInterAngle(&state.x, previousState.x, nextState.x, bp, bx); + PatchInterAngle(&state.y, previousState.y, nextState.y, bp, bx); + PatchInterAngle(&state.z, previousState.z, nextState.z, bp, bx); + } } - while(--numOfBonesInAnim); } - animVar1 = animVar1Backup; - - animVar1+=2; - - animStepX = ((*(s16*)(animVar1))*bp)/bx; // X - animStepY = ((*(s16*)(animVar1+2))*bp)/bx; // Y - animStepZ = ((*(s16*)(animVar1+4))*bp)/bx; // Z - - animVar1+=6; + animStepX = (pKeyframe->m_animStep.x * bp) / bx; + animStepY = (pKeyframe->m_animStep.y * bp) / bx; + animStepZ = (pKeyframe->m_animStep.z * bp) / bx; animCurrentTime = bx; animKeyframeLength = bp; @@ -1047,53 +880,23 @@ s16 SetInterAnimObjet(int frame, char* animPtr, char* bodyPtr) } else // change keyframe { - char* tempBx = animVar1; - char* si = animVar1; - - - si+=8; - - do + for (int i = 0; i < numOfBonesInAnim; i++) { - *(s16*)(bodyPtr) = *(s16*)(si); - *(s16*)(bodyPtr+2) = *(s16*)(si+2); - *(s16*)(bodyPtr+4) = *(s16*)(si+4); - *(s16*)(bodyPtr+6) = *(s16*)(si+6); + sGroupState& nextState = pKeyframe->m_groups[i]; + pBody->m_groups[i].m_state = nextState; + }; - bodyPtr+=8; - si+=8; + pBody->startAnim = pKeyframe; - if(flag&INFO_OPTIMISE) - { - *(s16*)(bodyPtr) = *(s16*)(si); - *(s16*)(bodyPtr+2) = *(s16*)(si+2); - *(s16*)(bodyPtr+4) = *(s16*)(si+4); - *(s16*)(bodyPtr+6) = *(s16*)(si+6); - bodyPtr+=8; - si+=8; - } - - bodyPtr+=8; - - }while(--numOfBonesInAnim); - - g_bodyBufferMap[animVar3] = animVar1; - //*(char**)animVar3 = animVar1; - - *(u16*)(animVar3+4) = (u16)timer; - - tempBx+=2; + *(u16*)(pBody->m_scratchBuffer.data()+4) = (u16)timer; animCurrentTime = bx; animKeyframeLength = bx; - animStepX = *(s16*)(tempBx); - animStepY = *(s16*)(tempBx+2); - animStepZ = *(s16*)(tempBx+4); - - tempBx += 6; + animStepX = pKeyframe->m_animStep.x; + animStepY = pKeyframe->m_animStep.y; + animStepZ = pKeyframe->m_animStep.z; return(1); - } } diff --git a/FitdLib/anim.h b/FitdLib/anim.h index 43f5b23..7278a40 100644 --- a/FitdLib/anim.h +++ b/FitdLib/anim.h @@ -3,11 +3,36 @@ #define INFO_TORTUE 4 #define INFO_OPTIMISE 8 + +struct sFrame +{ + u16 m_timestamp; + point3dStruct m_animStep; + std::vector m_groups; +}; + +struct sAnimation +{ + void* m_raw; + + u16 m_numFrames; + u16 m_numGroups; + std::vector m_frames; +}; + +extern hqrEntryStruct* HQ_Anims; + +#define NB_BUFFER_ANIM 25 // AITD1 was 20 +#define SIZE_BUFFER_ANIM (8*41) // AITD1 was 4*31 + +extern std::vector BufferAnim; + int InitAnim(int animNum,int animType, int animInfo); -int SetAnimObjet(int frame, char* anim, char* body); -s16 SetInterAnimObjet(int frame, char* animPtr, char* bodyPtr); -s16 GetNbFramesAnim(char* animPtr); -void initBufferAnim(std::vector& animBuffer, char* bodyPtr); -void updateAnimation(void); +int SetAnimObjet(int frame, sAnimation* anim, sBody* body); +s16 SetInterAnimObjet(int frame, sAnimation* animPtr, sBody* bodyPtr); +s16 GetNbFramesAnim(sAnimation* animPtr); +void StockInterAnim(sFrame& animBuffer, sBody* bodyPtr); +void ResetStartAnim(sBody* bodyPtr); +void GereAnim(void); void InitCopyBox(char* var0, char* var1); diff --git a/FitdLib/anim2d.cpp b/FitdLib/anim2d.cpp new file mode 100644 index 0000000..cf69075 --- /dev/null +++ b/FitdLib/anim2d.cpp @@ -0,0 +1,69 @@ +#include "common.h" +#include "anim2d.h" +#include "hybrid.h" + +std::array TabAnim2d; +int NbAnim2D = 0; + +sHybrid* PtrAnim2D = nullptr; +void load2dAnims(int cameraIdx) { + char name[16]; + + sprintf(name, "ANIM%02d", g_currentFloor); + + if (PtrAnim2D) + { + delete PtrAnim2D; + PtrAnim2D = nullptr; + } + + unsigned char* rawAnim2D = (unsigned char*)loadPak(name, cameraIdx); + PtrAnim2D = new sHybrid(rawAnim2D, getPakSize(name, cameraIdx)); + free(rawAnim2D); +} + +void handleAnim2d() { + + std::array Index2 = Index; + + for (int i = 0; i < currentCameraZoneList[NumCamera]->hybrids.size(); i++) { + auto& anim = TabAnim2d[i]; + if (timer - anim.time >= anim.pAnim->flag) { + anim.frame++; + if (anim.frame == anim.pAnimation->anims.size()) { + anim.frame = 0; + anim.pAnim = anim.pAnimation->anims.begin(); + } + else { + anim.pAnim++; + } + anim.time = timer; + } + + int j; + for (j = NbAffObjets + i - 1; j >= 0; j--) { + if (!(Index2[j] & 0x8000)) { + //TODO: test rects + } + } + + memmove(&Index2[j + 2], &Index2[j + 1], (NbAffObjets + i - j - 1) * sizeof(Index2[0])); + Index2[j + 1] = 0x8000 + i; + } + + Index = Index2; +} + +void resetAnim2D() { + NbAnim2D = 0; +} + +void startAnim2d(int index) { + auto& anim = PtrAnim2D->animations[index]; + + TabAnim2d[NbAnim2D].pAnimation = &anim; + TabAnim2d[NbAnim2D].pAnim = anim.anims.begin(); + TabAnim2d[NbAnim2D].frame = 0; + TabAnim2d[NbAnim2D].time = timer; + NbAnim2D++; +} \ No newline at end of file diff --git a/FitdLib/anim2d.h b/FitdLib/anim2d.h new file mode 100644 index 0000000..33be68d --- /dev/null +++ b/FitdLib/anim2d.h @@ -0,0 +1,24 @@ +#pragma once + +#include "hybrid.h" + +struct sAnim2d { + uint16_t frame; + uint32_t time; + uint16_t flagEndInterAnim; + std::vector::iterator pAnim; + sHybrid_Animation* pAnimation; + int16_t ScreenXMin; + int16_t ScreenYMin; + int16_t ScreenXMax; + int16_t ScreenYMax; +}; + +extern std::array TabAnim2d; +extern int NbAnim2D; +extern sHybrid* PtrAnim2D; + +void resetAnim2D(); +void load2dAnims(int cameraIdx); +void startAnim2d(int index); +void handleAnim2d(); \ No newline at end of file diff --git a/FitdLib/animAction.cpp b/FitdLib/animAction.cpp index 59633ea..10c09a7 100644 --- a/FitdLib/animAction.cpp +++ b/FitdLib/animAction.cpp @@ -29,7 +29,7 @@ void GereFrappe(void) return; } - if (currentProcessedActorPtr->FRAME == currentProcessedActorPtr->animActionFRAME) + if (currentProcessedActorPtr->frame == currentProcessedActorPtr->animActionFRAME) { currentProcessedActorPtr->animActionType = FRAPPE_OK; } @@ -63,21 +63,25 @@ void GereFrappe(void) rangeZv.ZVZ1 = z - range; rangeZv.ZVZ2 = z + range; + if (backgroundMode == backgroundModeEnum_3D) { + drawZv(rangeZv); + } + //drawProjectedBox(rangeZv.ZVX1,rangeZv.ZVX2,rangeZv.ZVY1,rangeZv.ZVY2,rangeZv.ZVZ1,rangeZv.ZVZ2,60,255); - collision = checkObjectCollisions(currentProcessedActorIdx,&rangeZv); + collision = CheckObjectCol(currentProcessedActorIdx,&rangeZv); for(i=0;iHIT = currentProcessedActorPtr->COL[i]; - actorPtr2 = &objectTable[currentProcessedActorPtr->COL[i]]; + actorPtr2 = &ListObjets[currentProcessedActorPtr->COL[i]]; actorPtr2->HIT_BY = currentProcessedActorIdx; actorPtr2->hitForce = currentProcessedActorPtr->hitForce; - if(actorPtr2->_flags & AF_ANIMATED) + if(actorPtr2->objectType & AF_ANIMATED) { currentProcessedActorPtr->animActionType = 0; return; @@ -90,7 +94,7 @@ void GereFrappe(void) if(currentProcessedActorPtr->ANIM != currentProcessedActorPtr->animActionANIM) return; - if(currentProcessedActorPtr->FRAME != currentProcessedActorPtr->animActionFRAME) + if(currentProcessedActorPtr->frame != currentProcessedActorPtr->animActionFRAME) return; currentProcessedActorPtr->animActionType = 5; @@ -137,8 +141,8 @@ void GereFrappe(void) currentProcessedActorPtr->HIT = touchedActor; - objectTable[touchedActor].HIT_BY = currentProcessedActorIdx; - objectTable[touchedActor].hitForce = currentProcessedActorPtr->hitForce; + ListObjets[touchedActor].HIT_BY = currentProcessedActorIdx; + ListObjets[touchedActor].hitForce = currentProcessedActorPtr->hitForce; currentProcessedActorPtr->animActionType = 0; } @@ -158,7 +162,7 @@ void GereFrappe(void) ZVStruct rangeZv; - GiveZVObjet(HQR_Get(listBody, objPtr->body),&rangeZv); + GiveZVObjet(HQR_Get(HQ_Bodys, objPtr->body),&rangeZv); rangeZv.ZVX1 += x; rangeZv.ZVX2 += x; @@ -174,7 +178,7 @@ void GereFrappe(void) } else { - if(currentProcessedActorPtr->FRAME == currentProcessedActorPtr->animActionFRAME) + if(currentProcessedActorPtr->frame == currentProcessedActorPtr->animActionFRAME) { currentProcessedActorPtr->animActionType = 7; @@ -193,7 +197,7 @@ void GereFrappe(void) objPtr->alpha = currentProcessedActorPtr->alpha; objPtr->beta = currentProcessedActorPtr->beta+0x200; - objPtr->flags2 &= 0xBFFF; + objPtr->foundFlag &= 0xBFFF; objPtr->flags |= 0x85; objPtr->flags &= 0xFFDF; @@ -225,13 +229,13 @@ void GereFrappe(void) if(actorIdx == -1) return; - actorPtr = &objectTable[actorIdx]; + actorPtr = &ListObjets[actorIdx]; actorPtr->roomX = x; actorPtr->roomY = y; actorPtr->roomZ = z; - GiveZVObjet(HQR_Get(listBody,actorPtr->bodyNum),&actorPtr->zv); + GiveZVObjet(HQR_Get(HQ_Bodys,actorPtr->bodyNum),&actorPtr->zv); actorPtr->zv.ZVX1 += x; actorPtr->zv.ZVX2 += x; @@ -240,8 +244,8 @@ void GereFrappe(void) actorPtr->zv.ZVZ1 += z; actorPtr->zv.ZVZ2 += z; - actorPtr->_flags |= AF_ANIMATED; - actorPtr->_flags &= ~AF_BOXIFY; + actorPtr->objectType |= AF_ANIMATED; + actorPtr->objectType &= ~AF_BOXIFY; ListWorldObjets[objIdx].x = x; ListWorldObjets[objIdx].y = y; @@ -283,8 +287,8 @@ void GereFrappe(void) int z3; int step; - copyZv(¤tProcessedActorPtr->zv, &rangeZv); - copyZv(¤tProcessedActorPtr->zv, &rangeZv2); + CopyZV(¤tProcessedActorPtr->zv, &rangeZv); + CopyZV(¤tProcessedActorPtr->zv, &rangeZv2); xtemp = currentProcessedActorPtr->roomX + currentProcessedActorPtr->stepX; ytemp = currentProcessedActorPtr->roomY + currentProcessedActorPtr->stepY; @@ -324,7 +328,7 @@ void GereFrappe(void) y2 = y1; z2 = z1 + animMoveZ; - copyZv(&rangeZv2,&rangeZv); + CopyZV(&rangeZv2,&rangeZv); rangeZv.ZVX1 = x2 - 200; rangeZv.ZVX2 = x2 + 200; @@ -333,7 +337,7 @@ void GereFrappe(void) rangeZv.ZVZ1 = z2 - 200; rangeZv.ZVZ2 = z2 + 200; - collision = checkObjectCollisions(currentProcessedActorIdx,&rangeZv); + collision = CheckObjectCol(currentProcessedActorIdx,&rangeZv); if(collision) { @@ -348,7 +352,7 @@ void GereFrappe(void) { int currentActorCol = currentProcessedActorPtr->COL[i]; - if(objectTable[currentActorCol].indexInWorld == objPtr->alpha) + if(ListObjets[currentActorCol].indexInWorld == objPtr->alpha) { collision2--; objPtr->x = xtemp; @@ -358,7 +362,7 @@ void GereFrappe(void) return; } - if(objectTable[currentActorCol].indexInWorld == CVars[getCVarsIdx((enumCVars)REVERSE_OBJECT)]) + if(ListObjets[currentActorCol].indexInWorld == CVars[getCVarsIdx((enumCVars)REVERSE_OBJECT)]) { objPtr->alpha = CVars[getCVarsIdx((enumCVars)REVERSE_OBJECT)]; currentProcessedActorPtr->beta += 0x200; @@ -372,7 +376,7 @@ void GereFrappe(void) currentProcessedActorPtr->stepX = 0; currentProcessedActorPtr->stepZ = 0; - copyZv(&rangeZv2, &rangeZv); + CopyZV(&rangeZv2, &rangeZv); rangeZv.ZVX1 += x3; rangeZv.ZVX2 += x3; @@ -381,7 +385,7 @@ void GereFrappe(void) rangeZv.ZVZ1 += z3; rangeZv.ZVZ2 += z3; - copyZv(&rangeZv, ¤tProcessedActorPtr->zv); + CopyZV(&rangeZv, ¤tProcessedActorPtr->zv); objPtr->x = xtemp; objPtr->y = ytemp; @@ -395,7 +399,7 @@ void GereFrappe(void) tObject* actorPtr; currentProcessedActorPtr->HIT = currentActorCol; - actorPtr = &objectTable[currentActorCol]; + actorPtr = &ListObjets[currentActorCol]; actorPtr->HIT_BY = currentProcessedActorIdx; actorPtr->hitForce = currentProcessedActorPtr->hitForce; } diff --git a/FitdLib/bgfxGlue.cpp b/FitdLib/bgfxGlue.cpp index a02818e..d8b90b8 100644 --- a/FitdLib/bgfxGlue.cpp +++ b/FitdLib/bgfxGlue.cpp @@ -134,7 +134,7 @@ void createBgfxInitParams() } #elif BX_PLATFORM_OSX initparam.platformData.ndt = NULL; - initparam.platformData.nwh = cbSetupMetalLayer(wmi.info.cocoa.window); + initparam.platformData.nwh = cbSetupMetalLayer((void*)SDL_GetPointerProperty(SDL_GetWindowProperties(gWindowBGFX), SDL_PROP_WINDOW_COCOA_WINDOW_POINTER, NULL)); #elif BX_PLATFORM_WINDOWS initparam.platformData.ndt = NULL; initparam.platformData.nwh = (HWND)SDL_GetPointerProperty(SDL_GetWindowProperties(gWindowBGFX), SDL_PROP_WINDOW_WIN32_HWND_POINTER, NULL); @@ -145,21 +145,35 @@ int initBgfxGlue(int argc, char* argv[]) { createBgfxInitParams(); //initparam.type = bgfx::RendererType::OpenGL; - initparam.type = bgfx::RendererType::Vulkan; + //initparam.type = bgfx::RendererType::Vulkan; + //initparam.type = bgfx::RendererType::Direct3D12; +#if BX_CONFIG_DEBUG + initparam.debug = true; +#endif bgfx::init(initparam); imguiCreate(); ImGuiIO& io = ImGui::GetIO(); //io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable; - -#if BX_PLATFORM_WINDOWS - ImGui_ImplSDL3_InitForD3D(gWindowBGFX); -#elif BX_PLATFORM_OSX - ImGui_ImplSDL3_InitForMetal(gWindowBGFX); -#else - ImGui_ImplSDL3_InitForVulkan(gWindowBGFX); -#endif + if ((bgfx::getRendererType() == bgfx::RendererType::Direct3D11) || (bgfx::getRendererType() == bgfx::RendererType::Direct3D12)) { + ImGui_ImplSDL3_InitForD3D(gWindowBGFX); + } + else + if (bgfx::getRendererType() == bgfx::RendererType::Metal) { + ImGui_ImplSDL3_InitForMetal(gWindowBGFX); + } + else + if (bgfx::getRendererType() == bgfx::RendererType::OpenGL) { + ImGui_ImplSDL3_InitForOpenGL(gWindowBGFX, SDL_GL_GetCurrentContext()); + } + else + if (bgfx::getRendererType() == bgfx::RendererType::Vulkan) { + ImGui_ImplSDL3_InitForVulkan(gWindowBGFX); + } + else { + ImGui_ImplSDL3_InitForOther(gWindowBGFX); + } return true; } diff --git a/FitdLib/common.h b/FitdLib/common.h index 57ca483..d0e8a99 100644 --- a/FitdLib/common.h +++ b/FitdLib/common.h @@ -87,7 +87,7 @@ int getCVarsIdx(int); ////////////////// - + #if !AITD_UE4 typedef unsigned char uint8; typedef unsigned short uint16; @@ -98,7 +98,7 @@ typedef unsigned int uint; typedef signed char int8; typedef signed short int16; typedef signed long int32; -#endif +#endif typedef unsigned char U8; typedef unsigned short U16; @@ -147,6 +147,7 @@ typedef signed long S32; #include "fmopl.h" #include "main.h" #include "sequence.h" +#include "palette.h" // include game specific stuff #include "AITD1.h" @@ -180,23 +181,25 @@ typedef signed long S32; #define FORCEINLINE inline #endif #endif - -FORCEINLINE u8 READ_LE_U8(void *ptr) -{ - return *(u8*)ptr; -} - -FORCEINLINE s8 READ_LE_S8(void *ptr) -{ - return *(s8*)ptr; -} + +FORCEINLINE u8 READ_LE_U8(void *ptr) +{ + return *(u8*)ptr; +} + +FORCEINLINE s8 READ_LE_S8(void *ptr) +{ + return *(s8*)ptr; +} FORCEINLINE u16 READ_LE_U16(void *ptr) { #ifdef MACOSX return (((u8*)ptr)[1]<<8)|((u8*)ptr)[0]; #else - return *(u16*)ptr; + u16 temp; + memcpy(&temp, ptr, 2); + return temp; #endif } @@ -224,7 +227,9 @@ FORCEINLINE u32 READ_LE_U32(void *ptr) #ifdef MACOSX return (((u8*)ptr)[3]<<24)|(((u8*)ptr)[2]<<16)|(((u8*)ptr)[1]<<8)|((u8*)ptr)[0]; #else - return *(u32*)ptr; + u32 temp; + memcpy(&temp, ptr, 4); + return temp; #endif } diff --git a/FitdLib/config.h b/FitdLib/config.h index 5e62851..f7a2abc 100644 --- a/FitdLib/config.h +++ b/FitdLib/config.h @@ -1,8 +1,10 @@ #pragma once #if __cplusplus -#include +#include #include +#include +#include #endif #ifdef __APPLE__ @@ -37,10 +39,10 @@ #define USE_IMGUI #define USE_OPENGL_3_2 #endif - -#ifdef AITD_UE4 -#undef USE_IMGUI -#endif + +#ifdef AITD_UE4 +#undef USE_IMGUI +#endif #ifdef MACOSX #define UNIX @@ -48,7 +50,8 @@ #define HAS_YM3812 1 -#if defined(HAS_STDINT) || AITD_UE4 +#include + typedef uint8_t u8; typedef uint16_t u16; typedef uint32_t u32; @@ -56,15 +59,6 @@ typedef uint32_t u32; typedef int8_t s8; typedef int16_t s16; typedef int32_t s32; -#else -typedef unsigned char u8; -typedef unsigned short int u16; -typedef unsigned long int u32; - -typedef signed char s8; -typedef signed short int s16; -typedef signed long int s32; -#endif #include #include diff --git a/FitdLib/debugger.cpp b/FitdLib/debugger.cpp index 8513059..49e0aaf 100644 --- a/FitdLib/debugger.cpp +++ b/FitdLib/debugger.cpp @@ -119,6 +119,8 @@ void debugger_draw(void) if (ImGui::BeginMenu("Debug")) { ImGui::MenuItem("No Collisions", nullptr, &debuggerVar_noHardClip); + ImGui::Combo("Collision", (int*)&hardColDisplayMode, "None\0Wireframe\0Filled\0"); + ImGui::Combo("Triggers", (int*)&sceColDisplayMode, "None\0Wireframe\0Filled\0"); ImGui::EndMenu(); } ImGui::EndMainMenuBar(); @@ -126,51 +128,53 @@ void debugger_draw(void) if(debuggerVar_debugMenuDisplayed) { - cameraDataStruct* pCamera = cameraDataTable[currentCamera]; - - ImGui::Begin("Camera"); - if (pCamera) + if(cameraDataTable.size()) { - ImGui::BeginGroup(); - ImGui::PushID("Position"); - ImGui::InputInt("X", &translateX); - ImGui::InputInt("Y", &translateY); - ImGui::InputInt("Z", &translateZ); - ImGui::PopID(); - ImGui::EndGroup(); - - ImGui::BeginGroup(); - ImGui::PushID("Center"); - InputS16("Pitch", &pCamera->alpha); - InputS16("Yaw", &pCamera->beta); - InputS16("Roll", &pCamera->gamma); - ImGui::PopID(); - ImGui::EndGroup(); - - SetAngleCamera(pCamera->alpha, pCamera->beta, pCamera->gamma); - - ImGui::BeginGroup(); - ImGui::PushID("Center"); - ImGui::InputInt("HCenter", &cameraCenterX); - ImGui::InputInt("VCenter", &cameraCenterY); - ImGui::PopID(); - ImGui::EndGroup(); - - ImGui::BeginGroup(); - ImGui::PushID("Projection"); - ImGui::InputInt("Perspective", &cameraPerspective); - ImGui::InputInt("XFov", &cameraFovX); - ImGui::InputInt("YFov", &cameraFovY); - ImGui::PopID(); - ImGui::EndGroup(); - } + cameraDataStruct* pCamera = cameraDataTable[NumCamera]; - if (ImGui::Button("DumpScene")) - { - SaveScene(); + ImGui::Begin("Camera"); + if (pCamera) + { + ImGui::BeginGroup(); + ImGui::PushID("Position"); + ImGui::InputInt("X", &translateX); + ImGui::InputInt("Y", &translateY); + ImGui::InputInt("Z", &translateZ); + ImGui::PopID(); + ImGui::EndGroup(); + + ImGui::BeginGroup(); + ImGui::PushID("Center"); + InputS16("Pitch", &pCamera->alpha); + InputS16("Yaw", &pCamera->beta); + InputS16("Roll", &pCamera->gamma); + ImGui::PopID(); + ImGui::EndGroup(); + + SetAngleCamera(pCamera->alpha, pCamera->beta, pCamera->gamma); + + ImGui::BeginGroup(); + ImGui::PushID("Center"); + ImGui::InputInt("HCenter", &cameraCenterX); + ImGui::InputInt("VCenter", &cameraCenterY); + ImGui::PopID(); + ImGui::EndGroup(); + + ImGui::BeginGroup(); + ImGui::PushID("Projection"); + ImGui::InputInt("Perspective", &cameraPerspective); + ImGui::InputInt("XFov", &cameraFovX); + ImGui::InputInt("YFov", &cameraFovY); + ImGui::PopID(); + ImGui::EndGroup(); + } + if (ImGui::Button("DumpScene")) + { + SaveScene(); + } + ImGui::End(); } - ImGui::End(); if(ListWorldObjets.size()) { @@ -194,7 +198,7 @@ void debugger_draw(void) InputS16("typeZV", &pWorldObject->typeZV); InputS16("foundBody", &pWorldObject->foundBody); InputS16("foundName", &pWorldObject->foundName); - InputS16("flags2", &pWorldObject->flags2); + InputS16("flags2", &pWorldObject->foundFlag); InputS16("foundLife", &pWorldObject->foundLife); InputS16("x", &pWorldObject->x); InputS16("y", &pWorldObject->y); @@ -231,7 +235,7 @@ void debugger_draw(void) if (selectedObject > NUM_MAX_OBJECT) selectedObject = NUM_MAX_OBJECT - 1; - tObject*pObject = &objectTable[selectedObject]; + tObject*pObject = &ListObjets[selectedObject]; ImGui::PushItemWidth(100); @@ -270,10 +274,10 @@ void debugger_draw(void) InputS16("newAnim", &pObject->newAnim); InputS16("newAnimType", &pObject->newAnimType); InputS16("newAnimInfo", &pObject->newAnimInfo); - InputS16("FRAME", &pObject->FRAME); + InputS16("FRAME", &pObject->frame); InputS16("numOfFrames", &pObject->numOfFrames); InputS16("END_FRAME", &pObject->END_FRAME); - InputS16("END_ANIM", &pObject->END_ANIM); + InputS16("END_ANIM", &pObject->flagEndAnim); InputS16("trackMode", &pObject->trackMode); InputS16("trackNumber", &pObject->trackNumber); InputS16("MARK", &pObject->MARK); diff --git a/FitdLib/evalVar.cpp b/FitdLib/evalVar.cpp index 7fa0e56..e605896 100644 --- a/FitdLib/evalVar.cpp +++ b/FitdLib/evalVar.cpp @@ -4,13 +4,13 @@ int getPosRelTable[] = {4,1,8,2,4,1,8,0}; int getMatrix(int param1, int actorIdx, int param2) { - unsigned char* matrixPtr = (unsigned char*)HQR_Get(listMatrix,param1); + unsigned char* matrixPtr = (unsigned char*)HQR_Get(HQ_Matrices,param1); int matrixWidth = *matrixPtr++; int matrixHeigh = *matrixPtr++; - matrixPtr+=(objectTable[actorIdx].hardMat-1)*matrixWidth; - matrixPtr+=(objectTable[param2].hardMat-1); + matrixPtr+=(ListObjets[actorIdx].hardMat-1)*matrixWidth; + matrixPtr+=(ListObjets[param2].hardMat-1); if(g_gameId == AITD3) { @@ -43,11 +43,11 @@ int getPosRel(tObject* actor1, tObject* actor2) } - copyZv(&actor2->zv, &localZv); + CopyZV(&actor2->zv, &localZv); if(actor1->room != actor2->room) { - getZvRelativePosition(&localZv, actor2->room, actor1->room); + AdjustZV(&localZv, actor2->room, actor1->room); } centerX = (localZv.ZVX1 + localZv.ZVX2) / 2; @@ -103,44 +103,29 @@ int calcDist(int X1, int Y1, int Z1, int X2, int Y2, int Z2) return(Xdist + Ydist + Zdist); // recheck overflow } -int testZvEndAnim(tObject* actorPtr,char* animPtr, int param) +int testZvEndAnim(tObject* actorPtr,sAnimation* animPtr, int param) { - s16 var_16; - s16 var_14; - s16 var_E = 0; - s16 var_12 = 0; - s16 var_10 = param; - s16 var_18; - ZVStruct localZv; - ASSERT(actorPtr); ASSERT(animPtr); - var_16 = *(s16*)(animPtr); - animPtr += 2; - var_14 = *(s16*)(animPtr); - animPtr += 2; + s16 stepX = 0; + s16 stepZ = 0; - for(var_18 = 0; var_18 < var_16; var_18 ++) + for(int i=0; i< animPtr->m_numFrames; i++) { - animPtr += 2; - var_12 += *(s16*)animPtr; - animPtr += 2; - animPtr += 2; - var_E += *(s16*)animPtr; // step depth - animPtr += 2; - - animPtr+= var_14*8; + stepZ += animPtr->m_frames[i].m_animStep.x; + stepX += animPtr->m_frames[i].m_animStep.z; } - copyZv(&actorPtr->zv, &localZv); + ZVStruct localZv; + CopyZV(&actorPtr->zv, &localZv); - walkStep(0,var_E,actorPtr->beta); + walkStep(0,stepX,actorPtr->beta); localZv.ZVX1 += animMoveX; localZv.ZVX2 += animMoveX; - localZv.ZVY1 += var_10; - localZv.ZVY2 += var_10; + localZv.ZVY1 += param; + localZv.ZVY2 += param; localZv.ZVZ1 += animMoveZ; localZv.ZVZ2 += animMoveZ; @@ -201,10 +186,10 @@ int evalVar(const char* name) actorIdx = ListWorldObjets[objectNumber].objIndex; currentLifePtr+=2; - actorPtr = &objectTable[actorIdx]; - + if(actorIdx==-1) { + actorPtr = nullptr; switch(var1 & 0x7FFF) { case 0x1F: @@ -224,6 +209,10 @@ int evalVar(const char* name) } } } + else { + actorPtr = &ListObjets[actorIdx]; + } + } { @@ -239,7 +228,7 @@ int evalVar(const char* name) if(temp1 != -1) { - return(objectTable[temp1].indexInWorld); + return(ListObjets[temp1].indexInWorld); } else { @@ -267,7 +256,7 @@ int evalVar(const char* name) } else { - return(objectTable[temp].indexInWorld); + return(ListObjets[temp].indexInWorld); } break; @@ -282,7 +271,7 @@ int evalVar(const char* name) } else { - return(objectTable[temp].indexInWorld); + return(ListObjets[temp].indexInWorld); } break; @@ -294,12 +283,12 @@ int evalVar(const char* name) } case 0x6: { - return(actorPtr->END_ANIM); + return(actorPtr->flagEndAnim); break; } case 0x7: { - return(actorPtr->FRAME); + return(actorPtr->frame); break; } case 0x8: @@ -343,9 +332,9 @@ int evalVar(const char* name) } else { - int tempX = objectTable[actorNumber].worldX; - int tempY = objectTable[actorNumber].worldY; - int tempZ = objectTable[actorNumber].worldZ; + int tempX = ListObjets[actorNumber].worldX; + int tempY = ListObjets[actorNumber].worldY; + int tempZ = ListObjets[actorNumber].worldZ; return(calcDist(actorPtr->worldX, actorPtr->worldY, actorPtr->worldZ, tempX, tempY, tempZ)); } @@ -357,12 +346,12 @@ int evalVar(const char* name) if(actorPtr->COL_BY == -1) return(-1); else - return(objectTable[actorPtr->COL_BY].indexInWorld); + return(ListObjets[actorPtr->COL_BY].indexInWorld); break; } case 0x10: // found { - if(ListWorldObjets[evalVar()].flags2 & 0x8000) + if(ListWorldObjets[evalVar()].foundFlag & 0x8000) { return(1); } @@ -390,7 +379,7 @@ int evalVar(const char* name) return 0; } - return (getPosRel(actorPtr, &objectTable[ListWorldObjets[objNum].objIndex])); + return (getPosRel(actorPtr, &ListObjets[ListWorldObjets[objNum].objIndex])); break; } @@ -423,7 +412,7 @@ int evalVar(const char* name) return -1; } - return objectTable[temp1].indexInWorld; + return ListObjets[temp1].indexInWorld; break; } case 0x16: @@ -453,7 +442,7 @@ int evalVar(const char* name) } case 0x1B: { - return(*(u16*)(((currentCamera+6)*2)+cameraPtr)); + return(*(u16*)(((NumCamera+6)*2)+cameraPtr)); break; } case 0x1C: @@ -485,7 +474,7 @@ int evalVar(const char* name) objNum = *(s16*)currentLifePtr; currentLifePtr+=2; - if(ListWorldObjets[objNum].flags2 & 0xC000) + if(ListWorldObjets[objNum].foundFlag & 0xC000) { return(1); } @@ -511,7 +500,7 @@ int evalVar(const char* name) temp2 = *(s16*)currentLifePtr; currentLifePtr +=2; - return(testZvEndAnim(actorPtr,HQR_Get(listAnim,temp1),temp2)); + return(testZvEndAnim(actorPtr,HQR_Get(HQ_Anims,temp1),temp2)); break; } @@ -539,7 +528,7 @@ int evalVar(const char* name) objNum = *(s16*)currentLifePtr; currentLifePtr+=2; - if(ListWorldObjets[objNum].flags2 & 0x1000) + if(ListWorldObjets[objNum].foundFlag & 0x1000) { return 1; } @@ -570,11 +559,11 @@ int evalVar2(const char* name) if(var1 == -1) { int temp = *(s16*)(currentLifePtr); - currentLifePtr+=2; + currentLifePtr+=2; - if (name) - appendFormated("%s:", name); - appendFormated("%d, ", temp); + if (name) + appendFormated("%s:", name); + appendFormated("%d, ", temp); return(temp); } @@ -582,11 +571,11 @@ int evalVar2(const char* name) if(var1 == 0) { int temp = *(s16*)(currentLifePtr); - currentLifePtr+=2; - - if (name) - appendFormated("%s:", name); - appendFormated("vars[%d], ", temp); + currentLifePtr+=2; + + if (name) + appendFormated("%s:", name); + appendFormated("vars[%d], ", temp); return(vars[temp]); } @@ -604,26 +593,26 @@ int evalVar2(const char* name) actorIdx = ListWorldObjets[objectNumber].objIndex; currentLifePtr+=2; - actorPtr = &objectTable[actorIdx]; + actorPtr = nullptr; if(actorIdx==-1) { switch(var1 & 0x7FFF) { case 0x1F: - { - if (name) - appendFormated("%s:", name); - appendFormated("worldObjects[%d].room, ", objectNumber); + { + if (name) + appendFormated("%s:", name); + appendFormated("worldObjects[%d].room, ", objectNumber); return(ListWorldObjets[objectNumber].room); break; } case 0x24: - { - if (name) - appendFormated("%s:", name); - appendFormated("worldObjects[%d].stage, ", objectNumber); + { + if (name) + appendFormated("%s:", name); + appendFormated("worldObjects[%d].stage, ", objectNumber); return(ListWorldObjets[objectNumber].stage); break; @@ -636,6 +625,9 @@ int evalVar2(const char* name) } } } + else { + actorPtr = &ListObjets[actorIdx]; + } } { @@ -646,16 +638,16 @@ int evalVar2(const char* name) switch(var1) { case 0x0: - { - int temp1 = actorPtr->COL[0]; - - if (name) - appendFormated("%s:", name); - appendFormated("objectTable[%d].COL, ", temp1); + { + int temp1 = actorPtr->COL[0]; + + if (name) + appendFormated("%s:", name); + appendFormated("objectTable[%d].COL, ", temp1); if(temp1 != -1) { - return(objectTable[temp1].indexInWorld); + return(ListObjets[temp1].indexInWorld); } else { @@ -664,26 +656,26 @@ int evalVar2(const char* name) break; } case 0x1: - { - if (name) - appendFormated("%s:", name); + { + if (name) + appendFormated("%s:", name); appendFormated("HARD_DEC, "); return(actorPtr->HARD_DEC); break; } case 0x2: - { - if (name) - appendFormated("%s:", name); + { + if (name) + appendFormated("%s:", name); appendFormated("HARD_COL, "); return(actorPtr->HARD_COL); break; } case 0x3: - { - if (name) - appendFormated("%s:", name); + { + if (name) + appendFormated("%s:", name); appendFormated("HIT, "); int temp = actorPtr->HIT; @@ -693,7 +685,7 @@ int evalVar2(const char* name) } else { - return(objectTable[temp].indexInWorld); + return(ListObjets[temp].indexInWorld); } break; @@ -708,7 +700,7 @@ int evalVar2(const char* name) } else { - return(objectTable[temp].indexInWorld); + return(ListObjets[temp].indexInWorld); } break; @@ -720,12 +712,12 @@ int evalVar2(const char* name) } case 0x6: { - return(actorPtr->END_ANIM); + return(actorPtr->flagEndAnim); break; } case 0x7: { - return(actorPtr->FRAME); + return(actorPtr->frame); break; } case 0x8: @@ -784,9 +776,9 @@ int evalVar2(const char* name) } else { - tempX = objectTable[objectIdx].worldX; - tempY = objectTable[objectIdx].worldY; - tempZ = objectTable[objectIdx].worldZ; + tempX = ListObjets[objectIdx].worldX; + tempY = ListObjets[objectIdx].worldY; + tempZ = ListObjets[objectIdx].worldZ; } return(calcDist(actorPtr->worldX, actorPtr->worldY, actorPtr->worldZ, tempX, tempY, tempZ)); @@ -798,12 +790,12 @@ int evalVar2(const char* name) if(actorPtr->COL_BY == -1) return(-1); else - return(objectTable[actorPtr->COL_BY].indexInWorld); + return(ListObjets[actorPtr->COL_BY].indexInWorld); break; } case 0x10: // found { - if(ListWorldObjets[evalVar()].flags2 & 0x8000) + if(ListWorldObjets[evalVar()].foundFlag & 0x8000) { return(1); } @@ -831,7 +823,7 @@ int evalVar2(const char* name) return 0; } - return (getPosRel(actorPtr, &objectTable[ListWorldObjets[objNum].objIndex])); + return (getPosRel(actorPtr, &ListObjets[ListWorldObjets[objNum].objIndex])); break; } @@ -864,7 +856,7 @@ int evalVar2(const char* name) return -1; } - return objectTable[temp1].indexInWorld; + return ListObjets[temp1].indexInWorld; break; } case 0x16: @@ -894,7 +886,7 @@ int evalVar2(const char* name) } case 0x1B: { - return(cameraDataTable[currentCamera]-&g_currentFloorCameraData[0]); + return(cameraDataTable[NumCamera]-&g_currentFloorCameraData[0]); break; } case 0x1C: @@ -926,7 +918,7 @@ int evalVar2(const char* name) objNum = *(s16*)currentLifePtr; currentLifePtr+=2; - if(ListWorldObjets[objNum].flags2 & 0xC000) + if(ListWorldObjets[objNum].foundFlag & 0xC000) { return(1); } @@ -961,7 +953,7 @@ int evalVar2(const char* name) objNum = *(s16*)currentLifePtr; currentLifePtr+=2; - if(ListWorldObjets[objNum].flags2 & 0x1000) + if(ListWorldObjets[objNum].foundFlag & 0x1000) { return 1; } @@ -994,16 +986,16 @@ int evalVar2(const char* name) { return 1; break; - } - case 0x2A: // related to samples + } + case 0x2A: // related to samples { - return 1; + return 1; break; } default: { printf("Unhandled test type %X in evalVar\n",var1); - assert(0); + assert(0); return 0; break; } diff --git a/FitdLib/floor.cpp b/FitdLib/floor.cpp index 74a90b9..f16906e 100644 --- a/FitdLib/floor.cpp +++ b/FitdLib/floor.cpp @@ -2,15 +2,13 @@ u32 g_currentFloorRoomRawDataSize = 0; u32 g_currentFloorCameraRawDataSize; -u32 g_currentFloorNumCamera = 0; std::vector g_currentFloorCameraData; -void loadFloor(int floorNumber) +void LoadEtage(int floorNumber) { int i; int expectedNumberOfRoom; int expectedNumberOfCamera; - char floorFileName[256]; if(g_currentFloorCameraRawData) { @@ -20,73 +18,64 @@ void loadFloor(int floorNumber) //stopSounds(); - HQR_Reset(listBody); - HQR_Reset(listAnim); + HQR_Reset(HQ_Bodys); + HQR_Reset(HQ_Anims); g_currentFloor = floorNumber; - if(g_gameId < AITD3) + if(g_gameId <= AITD3) { - sprintf(floorFileName,"ETAGE%02d",floorNumber); - - g_currentFloorRoomRawDataSize = getPakSize(floorFileName,0); - g_currentFloorCameraRawDataSize = getPakSize(floorFileName,1); + std::string floorFileName = std::format("ETAGE{:02d}", floorNumber); + if (fileExists((floorFileName+".PAK").c_str())) + { + g_currentFloorRoomRawDataSize = getPakSize(floorFileName.c_str(), 0); + g_currentFloorCameraRawDataSize = getPakSize(floorFileName.c_str(), 1); - g_currentFloorRoomRawData = CheckLoadMallocPak(floorFileName,0); - g_currentFloorCameraRawData = CheckLoadMallocPak(floorFileName,1); + g_currentFloorRoomRawData = CheckLoadMallocPak(floorFileName.c_str(), 0); + g_currentFloorCameraRawData = CheckLoadMallocPak(floorFileName.c_str(), 1); + } } - currentCamera = -1; - needChangeRoom = 1; - changeFloor = 0; + NumCamera = -1; + FlagChangeSalle = 1; + FlagChangeEtage = 0; ////////////////////////////////// - if(roomDataTable) - { - free(roomDataTable); - roomDataTable = NULL; - } + roomDataTable.clear(); expectedNumberOfRoom = getNumberOfRoom(); + assert(expectedNumberOfRoom); + + roomDataTable.reserve(expectedNumberOfRoom); for(i=0;i= AITD3) - { - char buffer[256]; - - if(g_gameId == AITD3) + if (g_currentFloorRoomRawDataSize == 0) { + if (fileExists(std::format("ETAGE{:02d}.PAK", floorNumber).c_str())) { - sprintf(buffer,"SAL%02d",floorNumber); + roomData = (u8*)CheckLoadMallocPak(std::format("ETAGE{:02d}", floorNumber).c_str(), i); } - else + else if (fileExists(std::format("SAL{:02d}.PAK", floorNumber).c_str())) { - sprintf(buffer,"ETAGE%02d",floorNumber); + roomData = (u8*)CheckLoadMallocPak(std::format("SAL{:02d}", floorNumber).c_str(), i); + } + else { + assert(0); } - - roomData = (u8*)CheckLoadMallocPak(buffer,i); } else { roomData = (u8*)(g_currentFloorRoomRawData + READ_LE_U32(g_currentFloorRoomRawData + i * 4)); } - currentRoomDataPtr = &roomDataTable[i]; + assert(roomData); + + roomDataStruct* currentRoomDataPtr = &roomDataTable.emplace_back(); currentRoomDataPtr->worldX = READ_LE_S16(roomData+4); currentRoomDataPtr->worldY = READ_LE_S16(roomData+6); @@ -94,11 +83,11 @@ void loadFloor(int floorNumber) currentRoomDataPtr->numCameraInRoom = READ_LE_U16(roomData+0xA); - currentRoomDataPtr->cameraIdxTable = (u16*)malloc(currentRoomDataPtr->numCameraInRoom*sizeof(s16)); + currentRoomDataPtr->cameraIdxTable.reserve(currentRoomDataPtr->numCameraInRoom); for(j=0;jnumCameraInRoom;j++) { - currentRoomDataPtr->cameraIdxTable[j] = READ_LE_U16(roomData+0xC+2*j); + currentRoomDataPtr->cameraIdxTable.push_back(READ_LE_U16(roomData+0xC+2*j)); } // hard col read @@ -107,15 +96,12 @@ void loadFloor(int floorNumber) currentRoomDataPtr->numHardCol = READ_LE_U16(hardColData); hardColData+=2; - if(currentRoomDataPtr->numHardCol) { - currentRoomDataPtr->hardColTable = (hardColStruct*)malloc(sizeof(hardColStruct)*currentRoomDataPtr->numHardCol); + currentRoomDataPtr->hardColTable.resize(currentRoomDataPtr->numHardCol); for(j=0;jnumHardCol;j++) { - ZVStruct* zvData; - - zvData = ¤tRoomDataPtr->hardColTable[j].zv; + ZVStruct* zvData = ¤tRoomDataPtr->hardColTable[j].zv; zvData->ZVX1 = READ_LE_S16(hardColData+0x00); zvData->ZVX2 = READ_LE_S16(hardColData+0x02); @@ -130,10 +116,6 @@ void loadFloor(int floorNumber) hardColData+=0x10; } } - else - { - currentRoomDataPtr->hardColTable = NULL; - } // sce zone read @@ -141,9 +123,8 @@ void loadFloor(int floorNumber) currentRoomDataPtr->numSceZone = READ_LE_U16(sceZoneData); sceZoneData+=2; - if(currentRoomDataPtr->numSceZone) { - currentRoomDataPtr->sceZoneTable = (sceZoneStruct*)malloc(sizeof(sceZoneStruct)*currentRoomDataPtr->numSceZone); + currentRoomDataPtr->sceZoneTable.resize(currentRoomDataPtr->numSceZone); for(j=0;jnumSceZone;j++) { @@ -164,23 +145,19 @@ void loadFloor(int floorNumber) sceZoneData+=0x10; } } - else - { - currentRoomDataPtr->sceZoneTable = NULL; - } } /////////////////////////////////// ///////////////////////////////////////////////// // camera stuff - if(g_gameId >= AITD3) + if(g_currentFloorCameraRawData == nullptr) { char buffer[256]; if(g_gameId == AITD3) { - sprintf(buffer,"CAM%02d",floorNumber); + sprintf(buffer,"CAMERA%02d",floorNumber); } else { @@ -221,22 +198,20 @@ void loadFloor(int floorNumber) unsigned int offset; unsigned char* currentCameraData; - if(g_gameId >= AITD3) + if (g_currentFloorCameraRawData == nullptr) { - char buffer[256]; - - if(g_gameId == AITD3) - { - sprintf(buffer,"CAM%02d",floorNumber); + if (fileExists(std::format("CAM{:02d}.PAK", g_currentFloor).c_str())) { + currentCameraData = (unsigned char*)CheckLoadMallocPak(std::format("CAM{:02d}", g_currentFloor).c_str(), i); } - else - { - sprintf(buffer,"CAMSAL%02d",floorNumber); + else if (fileExists(std::format("CAMSAL{:02d}.PAK", g_currentFloor).c_str())) { + currentCameraData = (unsigned char*)CheckLoadMallocPak(std::format("CAMSAL{:02d}", g_currentFloor).c_str(), i); + } + else { + assert(0); } offset = 0; g_currentFloorCameraRawDataSize = 1; - currentCameraData = (unsigned char*)CheckLoadMallocPak(buffer,i); } else { @@ -248,7 +223,7 @@ void loadFloor(int floorNumber) { unsigned char* backupDataPtr; - if(g_gameIdviewedRoomIdx = READ_LE_U16(currentCameraData+0x00); pCurrentCameraViewedRoom->offsetToMask = READ_LE_U16(currentCameraData+0x02); @@ -309,26 +280,22 @@ void loadFloor(int floorNumber) pMaskData = backupDataPtr + g_currentFloorCameraData[i].viewedRoomTable[k].offsetToMask; // for this camera, how many masks zone - pCurrentCameraViewedRoom->numMask = READ_LE_U16(pMaskData); - pMaskData+=2; - - pCurrentCameraViewedRoom->masks = (cameraMaskStruct*)malloc(sizeof(cameraMaskStruct)*pCurrentCameraViewedRoom->numMask); - memset(pCurrentCameraViewedRoom->masks, 0, sizeof(cameraMaskStruct)*pCurrentCameraViewedRoom->numMask); + int numMasks = READ_LE_U16(pMaskData); pMaskData+=2; + pCurrentCameraViewedRoom->masks.reserve(numMasks); - for(int k=0; knumMask; k++) + for(int k=0; k< numMasks; k++) { - cameraMaskStruct* pCurrentCameraMask = &pCurrentCameraViewedRoom->masks[k]; + cameraMaskStruct* pCurrentCameraMask = &pCurrentCameraViewedRoom->masks.emplace_back(); // for this overlay zone, how many pCurrentCameraMask->numTestRect = READ_LE_U16(pMaskData); pMaskData+=2; - pCurrentCameraMask->rectTests = (rectTestStruct*)malloc(sizeof(rectTestStruct)*pCurrentCameraMask->numTestRect); - memset(pCurrentCameraMask->rectTests, 0, sizeof(rectTestStruct)*pCurrentCameraMask->numTestRect); + pCurrentCameraMask->rectTests.reserve(pCurrentCameraMask->numTestRect); for(int j=0; jnumTestRect; j++) { - rectTestStruct* pCurrentRectTest = &pCurrentCameraMask->rectTests[j]; + rectTestStruct* pCurrentRectTest = &pCurrentCameraMask->rectTests.emplace_back(); pCurrentRectTest->zoneX1 = READ_LE_S16(pMaskData); pCurrentRectTest->zoneZ1 = READ_LE_S16(pMaskData+2); @@ -341,25 +308,17 @@ void loadFloor(int floorNumber) // load camera cover { - unsigned char* pZoneData; - int numZones; - int j; - - pZoneData = backupDataPtr + g_currentFloorCameraData[i].viewedRoomTable[k].offsetToCover; + unsigned char* pZoneData = backupDataPtr + g_currentFloorCameraData[i].viewedRoomTable[k].offsetToCover; if(pMaskData) { assert(pZoneData == pMaskData); } //pZoneData = currentCameraData; - pCurrentCameraViewedRoom->numCoverZones = numZones =READ_LE_U16(pZoneData); - pZoneData+=2; - - pCurrentCameraViewedRoom->coverZones = (cameraZoneEntryStruct*)malloc(sizeof(cameraZoneEntryStruct)*numZones); - - ASSERT(pCurrentCameraViewedRoom->coverZones); + int numCoverZones = READ_LE_U16(pZoneData); pZoneData += 2; + pCurrentCameraViewedRoom->coverZones.resize(numCoverZones); - for(j=0;jnumCoverZones;j++) + for(int j=0;j< numCoverZones;j++) { int pointIdx; int numPoints; @@ -382,6 +341,29 @@ void loadFloor(int floorNumber) } } + // load hybrids + if(pCurrentCameraViewedRoom->offsetToHybrids) + { + unsigned char* pHybridData = backupDataPtr + pCurrentCameraViewedRoom->offsetToHybrids; + int numHybrids = READ_LE_U16(pHybridData); pHybridData += 2; + pCurrentCameraViewedRoom->hybrids.reserve(numHybrids); + for (int i = 0; i < numHybrids; i++) { + auto& hybrid = pCurrentCameraViewedRoom->hybrids.emplace_back(); + int numRect = READ_LE_U16(pHybridData); pHybridData += 2; + hybrid.rects.reserve(numRect); + for (int j = 0; j < numRect; j++) { + auto& rect = hybrid.rects.emplace_back(); + rect.zoneX1 = READ_LE_S16(pHybridData); pHybridData += 2; + rect.zoneZ1 = READ_LE_S16(pHybridData); pHybridData += 2; + rect.zoneX2 = READ_LE_S16(pHybridData); pHybridData += 2; + rect.zoneZ2 = READ_LE_S16(pHybridData); pHybridData += 2; + } + } + if (pCurrentCameraViewedRoom->offsetCamOptims) { + assert(backupDataPtr + pCurrentCameraViewedRoom->offsetCamOptims == pHybridData); + } + } + if(g_gameId == AITD1) currentCameraData+=0x0C; else @@ -399,8 +381,6 @@ void loadFloor(int floorNumber) } } - g_currentFloorNumCamera = i-1; - // globalCameraDataTable = (cameraDataStruct*)realloc(globalCameraDataTable,sizeof(cameraDataStruct)*numGlobalCamera); /* roomCameraData+=0x14; diff --git a/FitdLib/floor.h b/FitdLib/floor.h index b704ca4..3f9ffe2 100644 --- a/FitdLib/floor.h +++ b/FitdLib/floor.h @@ -1,11 +1,10 @@ #ifndef _FLOOR_H_ -#define _FLOOR_H_ +#define _FLOOR_H_ extern std::vector g_currentFloorCameraData; extern u32 g_currentFloorRoomRawDataSize; -extern u32 g_currentFloorNumCamera; -void loadFloor(int floorNumber); +void LoadEtage(int floorNumber); #endif diff --git a/FitdLib/font.cpp b/FitdLib/font.cpp index c9cc65a..285550f 100644 --- a/FitdLib/font.cpp +++ b/FitdLib/font.cpp @@ -21,7 +21,7 @@ s16 fontSm9 = 0x80; unsigned char flagTable[]= {0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01}; -void ExtSetFont(char* fontData, int color) +void SetFont(char* fontData, int color) { s16 tempDx; s16 tempAxFlip; @@ -90,7 +90,7 @@ int ExtGetSizeFont(u8* string) return(width); } -void renderText(int x, int y, char* surface, u8* string) +void PrintFont(int x, int y, char* surface, u8* string) { unsigned char character; @@ -134,7 +134,7 @@ void renderText(int x, int y, char* surface, u8* string) { if (bp >= 200) return; - char* outPtr = logicalScreen + bp*320 + fontSm8; + char* outPtr = (char*)uiLayer.data() + bp * 320 + fontSm8; int dh = fontSm9; @@ -192,11 +192,11 @@ void SelectedMessage(int x, int y, int index, int color1, int color2) textPtr = entryPtr->textPtr; - ExtSetFont(PtrFont,color2); - renderText(x,y+1,logicalScreen,textPtr); + SetFont(PtrFont,color2); + PrintFont(x,y+1,logicalScreen,textPtr); - ExtSetFont(PtrFont,color1); - renderText(x,y,logicalScreen,textPtr); + SetFont(PtrFont,color1); + PrintFont(x,y,logicalScreen,textPtr); } @@ -211,7 +211,7 @@ void SimpleMessage(int x, int y, int index, int color) u8* textPtr = entryPtr->textPtr; - ExtSetFont(PtrFont,color); + SetFont(PtrFont,color); - renderText(x,y+1,logicalScreen,textPtr); + PrintFont(x,y+1,logicalScreen,textPtr); } diff --git a/FitdLib/font.h b/FitdLib/font.h index 2bcbaa2..397af55 100644 --- a/FitdLib/font.h +++ b/FitdLib/font.h @@ -1,8 +1,8 @@ extern int fontHeight; -void ExtSetFont(char* fontData, int color); +void SetFont(char* fontData, int color); void SetFontSpace(int interWordSpace, int interLetterSpace); int ExtGetSizeFont(u8* string); -void renderText(int x, int y, char* surface, u8* string); +void PrintFont(int x, int y, char* surface, u8* string); void SelectedMessage(int x, int y, int index, int color1, int color2); void SimpleMessage(int x, int y, int index, int color); diff --git a/FitdLib/gameTime.cpp b/FitdLib/gameTime.cpp index 927f98a..4d4dc6a 100644 --- a/FitdLib/gameTime.cpp +++ b/FitdLib/gameTime.cpp @@ -3,7 +3,7 @@ int timerSaved = false; unsigned int timerSavedValue = 0; -void freezeTime(void) +void SaveTimerAnim(void) { if(timerSaved==0) { @@ -12,7 +12,7 @@ void freezeTime(void) timerSaved++; } -void unfreezeTime(void) +void RestoreTimerAnim(void) { assert(timerSaved); timerSaved--; diff --git a/FitdLib/gameTime.h b/FitdLib/gameTime.h index 343f27c..4826b98 100644 --- a/FitdLib/gameTime.h +++ b/FitdLib/gameTime.h @@ -1,5 +1,5 @@ #ifndef _ITD_TIME_H_ #define _ITD_TIME_H_ -void freezeTime(void); -void unfreezeTime(void); +void SaveTimerAnim(void); +void RestoreTimerAnim(void); #endif \ No newline at end of file diff --git a/FitdLib/hqr.cpp b/FitdLib/hqr.cpp index 16b13c3..7ebe671 100644 --- a/FitdLib/hqr.cpp +++ b/FitdLib/hqr.cpp @@ -1,53 +1,66 @@ #include "common.h" +#include "hybrid.h" -hqrSubEntryStruct* quickFindEntry(int index, int numMax, hqrSubEntryStruct* ptr) // no RE. Original was probably faster +template +struct hqrSubEntryStruct { - int i; - - for(i=0;i +struct hqrEntryStruct +{ + std::string string; + u16 maxFreeData; + u16 sizeFreeData; + u16 numMaxEntry; + u16 numUsedEntry; + std::vector> entries; +}; + +template +hqrSubEntryStruct* quickFindEntry(int index, int numMax, std::vector>& ptr) // no RE. Original was probably faster +{ + for(int i=0;i +hqrEntryStruct* HQR_InitRessource(const char* name, int size, int numEntries) { - int i; - hqrEntryStruct* dest; - - dest = (hqrEntryStruct*)malloc(sizeof(hqrEntryStruct)); + hqrEntryStruct* dest = new hqrEntryStruct(); if(!dest) return NULL; numEntries = 2000; - - strcpy(dest->string," "); - strncpy(dest->string,name,8); - + dest->string = name; dest->sizeFreeData = size; dest->maxFreeData = size; dest->numMaxEntry = numEntries; dest->numUsedEntry = 0; - dest->entries = (hqrSubEntryStruct*)malloc(numEntries*sizeof(hqrSubEntryStruct)); + dest->entries.resize(numEntries); - for(i=0;ientries[i].ptr = NULL; + dest->entries[i].ptr = nullptr; } return(dest); } -int HQ_Malloc(hqrEntryStruct* hqrPtr,int size) +int HQ_Malloc(hqrEntryStruct* hqrPtr,int size) { - hqrSubEntryStruct* dataPtr1; - hqrSubEntryStruct* dataPtr2; int key; int entryNum; @@ -56,15 +69,13 @@ int HQ_Malloc(hqrEntryStruct* hqrPtr,int size) entryNum = hqrPtr->numUsedEntry; - dataPtr1 = dataPtr2 = hqrPtr->entries; - key = hqrKeyGen; - dataPtr1[entryNum].key = key; + hqrPtr->entries[entryNum].key = key; // dataPtr1[entryNum].offset = hqrPtr->maxFreeData - hqrPtr->sizeFreeData; - dataPtr1[entryNum].size = size; - dataPtr1[entryNum].ptr = (char*)malloc(size); + hqrPtr->entries[entryNum].size = size; + hqrPtr->entries[entryNum].ptr = (char*)malloc(size); hqrPtr->numUsedEntry++; hqrPtr->sizeFreeData -= size; @@ -74,17 +85,13 @@ int HQ_Malloc(hqrEntryStruct* hqrPtr,int size) return(key); } -char* HQ_PtrMalloc(hqrEntryStruct* hqrPtr, int index) +char* HQ_PtrMalloc(hqrEntryStruct* hqrPtr, int index) { - hqrSubEntryStruct* ptr; - hqrSubEntryStruct* dataPtr; if(index<0) return NULL; - dataPtr = hqrPtr->entries; - - ptr = quickFindEntry(index, hqrPtr->numUsedEntry, dataPtr); + hqrSubEntryStruct* ptr = quickFindEntry(index, hqrPtr->numUsedEntry, hqrPtr->entries); if(!ptr) return NULL; @@ -92,79 +99,65 @@ char* HQ_PtrMalloc(hqrEntryStruct* hqrPtr, int index) return(ptr->ptr); } -void moveHqrEntry(hqrEntryStruct* hqrPtr, int index) +sAnimation* createAnimationFromPtr(void* ptr, int size) { - /* hqrSubEntryStruct* hqrSubPtr = (hqrSubEntryStruct*)(((char*)hqrPtr)+sizeof(hqrEntryStruct)); - hqrSubEntryStruct* hqrSubPtr2 = hqrSubPtr; + u8* animPtr = (u8*)ptr; + + sAnimation* pAnimation = new sAnimation; + + pAnimation->m_raw = ptr; + pAnimation->m_numFrames = READ_LE_U16(animPtr); animPtr += 2; + pAnimation->m_numGroups = READ_LE_U16(animPtr); animPtr += 2; - int size = hqrSubPtr[index].size; + int fullSizeNoOptim = 2 + 2 + pAnimation->m_numFrames * (2 + 2 + 2 + 2 + pAnimation->m_numGroups * (2 + 2 + 2 + 2)); + int fullSizeWithOptim = 2 + 2 + pAnimation->m_numFrames * (2 + 2 + 2 + 2 + pAnimation->m_numGroups * (2 + 2 + 2 + 2 + 2 + 2 + 2 + 2)); + + bool bUseOptim = false; + + if (size == fullSizeWithOptim) { + bUseOptim = true; + } + else { + assert(size == fullSizeNoOptim); + } - if(hqrPtr->numUsedEntry - 1 > index ) //if not last entry + pAnimation->m_frames.resize(pAnimation->m_numFrames); + for (int i = 0; i < pAnimation->m_numFrames; i++) { - char* dest = hqrPtr->dataPtr + hqrSubPtr2[index].offset; - char* src = dest + size; - - memcpy(dest,src,hqrPtr->dataPtr + hqrPtr->maxFreeData - src); - - dest = (char*)&hqrSubPtr2[index]; - src = (char*)&hqrSubPtr2[index+1]; - memcpy(dest,src,hqrPtr->numMaxEntry-(index+1) * sizeof(hqrSubEntryStruct)); - }*/ - - int size = hqrPtr->entries[index].size; - - free(hqrPtr->entries[index].ptr); - - hqrPtr->numUsedEntry --; - hqrPtr->sizeFreeData += size; -} - -std::vector vAnimations; - -sAnimation* createAnimationFromPtr(void* ptr) -{ - u8* animPtr = (u8*)ptr; - - sAnimation* pAnimation = new sAnimation; - - pAnimation->m_raw = ptr; - pAnimation->m_numFrames = READ_LE_U16(animPtr); animPtr += 2; - pAnimation->m_numGroups = READ_LE_U16(animPtr); animPtr += 2; - - pAnimation->m_frames.resize(pAnimation->m_numFrames); - for (int i = 0; i < pAnimation->m_numFrames; i++) - { - sFrame* pFrame = &pAnimation->m_frames[i]; - - pFrame->m_timestamp = READ_LE_U16(animPtr); animPtr += 2; - pFrame->m_animStep[0] = READ_LE_S16(animPtr); animPtr += 2; - pFrame->m_animStep[1] = READ_LE_S16(animPtr); animPtr += 2; - pFrame->m_animStep[2] = READ_LE_S16(animPtr); animPtr += 2; - - pFrame->m_groups.resize(pAnimation->m_numGroups); - for (int i = 0; i < pAnimation->m_numGroups; i++) - { - sGroupState* pGroup = &pFrame->m_groups[i]; - + sFrame* pFrame = &pAnimation->m_frames[i]; + + pFrame->m_timestamp = READ_LE_U16(animPtr); animPtr += 2; + pFrame->m_animStep.x = READ_LE_S16(animPtr); animPtr += 2; + pFrame->m_animStep.y = READ_LE_S16(animPtr); animPtr += 2; + pFrame->m_animStep.z = READ_LE_S16(animPtr); animPtr += 2; + + pFrame->m_groups.resize(pAnimation->m_numGroups); + for (int i = 0; i < pAnimation->m_numGroups; i++) + { + sGroupState* pGroup = &pFrame->m_groups[i]; + pGroup->m_type = READ_LE_S16(animPtr); animPtr += 2; - pGroup->m_delta[0] = READ_LE_S16(animPtr); animPtr += 2; - pGroup->m_delta[1] = READ_LE_S16(animPtr); animPtr += 2; - pGroup->m_delta[2] = READ_LE_S16(animPtr); animPtr += 2; - } - } - - vAnimations.push_back(pAnimation); - return pAnimation; -} - -std::vector vBodies; + pGroup->m_delta.x = READ_LE_S16(animPtr); animPtr += 2; + pGroup->m_delta.y = READ_LE_S16(animPtr); animPtr += 2; + pGroup->m_delta.z = READ_LE_S16(animPtr); animPtr += 2; + if (bUseOptim) { + pGroup->m_rotateDelta.emplace(); + pGroup->m_rotateDelta.value().x = READ_LE_S16(animPtr); animPtr += 2; + pGroup->m_rotateDelta.value().y = READ_LE_S16(animPtr); animPtr += 2; + pGroup->m_rotateDelta.value().z = READ_LE_S16(animPtr); animPtr += 2; + animPtr += 2; + } + } + } + return pAnimation; +} sBody* createBodyFromPtr(void* ptr) -{ - u8* bodyBuffer = (u8*)ptr; +{ + u8* bodyBuffer = (u8*)ptr; sBody* newBody = new sBody; - + newBody->m_raw = ptr; newBody->m_flags = READ_LE_U16(bodyBuffer); bodyBuffer += 2; @@ -190,19 +183,19 @@ sBody* createBodyFromPtr(void* ptr) newBody->m_vertices[i].y = READ_LE_S16(bodyBuffer); bodyBuffer += 2; newBody->m_vertices[i].z = READ_LE_S16(bodyBuffer); bodyBuffer += 2; } - + if (newBody->m_flags & INFO_TORTUE) { assert(0); // never used - } - - if (newBody->m_flags & INFO_ANIM) - { + } + + if (newBody->m_flags & INFO_ANIM) + { u16 numGroups = READ_LE_U16(bodyBuffer); bodyBuffer += 2; newBody->m_groupOrder.reserve(numGroups); newBody->m_groups.resize(numGroups); - - if (newBody->m_flags & INFO_OPTIMISE) // AITD2+ + + if (newBody->m_flags & INFO_OPTIMISE) // AITD2+ { for (int i = 0; i < numGroups; i++) { @@ -220,16 +213,17 @@ sBody* createBodyFromPtr(void* ptr) newBody->m_groups[i].m_orgGroup = READ_LE_S8(bodyBuffer); bodyBuffer += 1; newBody->m_groups[i].m_numGroup = READ_LE_S8(bodyBuffer); bodyBuffer += 1; newBody->m_groups[i].m_state.m_type = READ_LE_S16(bodyBuffer); bodyBuffer += 2; - newBody->m_groups[i].m_state.m_delta[0] = READ_LE_S16(bodyBuffer); bodyBuffer += 2; - newBody->m_groups[i].m_state.m_delta[1] = READ_LE_S16(bodyBuffer); bodyBuffer += 2; - newBody->m_groups[i].m_state.m_delta[2] = READ_LE_S16(bodyBuffer); bodyBuffer += 2; - newBody->m_groups[i].m_state.m_rotateDelta[0] = READ_LE_S16(bodyBuffer); bodyBuffer += 2; - newBody->m_groups[i].m_state.m_rotateDelta[1] = READ_LE_S16(bodyBuffer); bodyBuffer += 2; - newBody->m_groups[i].m_state.m_rotateDelta[2] = READ_LE_S16(bodyBuffer); bodyBuffer += 2; - bodyBuffer += 2; // padding? + newBody->m_groups[i].m_state.m_delta.x = READ_LE_S16(bodyBuffer); bodyBuffer += 2; + newBody->m_groups[i].m_state.m_delta.y = READ_LE_S16(bodyBuffer); bodyBuffer += 2; + newBody->m_groups[i].m_state.m_delta.z = READ_LE_S16(bodyBuffer); bodyBuffer += 2; + newBody->m_groups[i].m_state.m_rotateDelta.emplace(); + newBody->m_groups[i].m_state.m_rotateDelta.value().x = READ_LE_S16(bodyBuffer); bodyBuffer += 2; + newBody->m_groups[i].m_state.m_rotateDelta.value().y = READ_LE_S16(bodyBuffer); bodyBuffer += 2; + newBody->m_groups[i].m_state.m_rotateDelta.value().z = READ_LE_S16(bodyBuffer); bodyBuffer += 2; + bodyBuffer += 2; } - } - else + } + else { for (int i = 0; i < numGroups; i++) { @@ -247,13 +241,13 @@ sBody* createBodyFromPtr(void* ptr) newBody->m_groups[i].m_orgGroup = READ_LE_S8(bodyBuffer); bodyBuffer += 1; newBody->m_groups[i].m_numGroup = READ_LE_S8(bodyBuffer); bodyBuffer += 1; newBody->m_groups[i].m_state.m_type = READ_LE_S16(bodyBuffer); bodyBuffer += 2; - newBody->m_groups[i].m_state.m_delta[0] = READ_LE_S16(bodyBuffer); bodyBuffer += 2; - newBody->m_groups[i].m_state.m_delta[1] = READ_LE_S16(bodyBuffer); bodyBuffer += 2; - newBody->m_groups[i].m_state.m_delta[2] = READ_LE_S16(bodyBuffer); bodyBuffer += 2; + newBody->m_groups[i].m_state.m_delta.x = READ_LE_S16(bodyBuffer); bodyBuffer += 2; + newBody->m_groups[i].m_state.m_delta.y = READ_LE_S16(bodyBuffer); bodyBuffer += 2; + newBody->m_groups[i].m_state.m_delta.z = READ_LE_S16(bodyBuffer); bodyBuffer += 2; } } - - } + + } u16 numPrimitives = READ_LE_U16(bodyBuffer); bodyBuffer += 2; newBody->m_primitives.resize(numPrimitives); @@ -262,12 +256,12 @@ sBody* createBodyFromPtr(void* ptr) newBody->m_primitives[i].m_type = (primTypeEnum)READ_LE_U8(bodyBuffer); bodyBuffer += 1; switch (newBody->m_primitives[i].m_type) - { - case primTypeEnum_Line: + { + case primTypeEnum_Line: newBody->m_primitives[i].m_material = READ_LE_U8(bodyBuffer); bodyBuffer += 1; - newBody->m_primitives[i].m_color = READ_LE_U8(bodyBuffer); bodyBuffer += 1; - newBody->m_primitives[i].m_even = READ_LE_U8(bodyBuffer); bodyBuffer += 1; - newBody->m_primitives[i].m_points.resize(2); + newBody->m_primitives[i].m_color = READ_LE_U8(bodyBuffer); bodyBuffer += 1; + newBody->m_primitives[i].m_even = READ_LE_U8(bodyBuffer); bodyBuffer += 1; + newBody->m_primitives[i].m_points.resize(2); for (int j = 0; j < newBody->m_primitives[i].m_points.size(); j++) { newBody->m_primitives[i].m_points[j] = READ_LE_U16(bodyBuffer) / 6; bodyBuffer += 2; @@ -281,25 +275,25 @@ sBody* createBodyFromPtr(void* ptr) { newBody->m_primitives[i].m_points[j] = READ_LE_U16(bodyBuffer) / 6; bodyBuffer += 2; } - break; - case primTypeEnum_Point: - case primTypeEnum_BigPoint: - case primTypeEnum_Zixel: + break; + case primTypeEnum_Point: + case primTypeEnum_BigPoint: + case primTypeEnum_Zixel: newBody->m_primitives[i].m_material = READ_LE_U8(bodyBuffer); bodyBuffer += 1; - newBody->m_primitives[i].m_color = READ_LE_U8(bodyBuffer); bodyBuffer += 1; - newBody->m_primitives[i].m_even = READ_LE_U8(bodyBuffer); bodyBuffer += 1; - newBody->m_primitives[i].m_points.resize(1); + newBody->m_primitives[i].m_color = READ_LE_U8(bodyBuffer); bodyBuffer += 1; + newBody->m_primitives[i].m_even = READ_LE_U8(bodyBuffer); bodyBuffer += 1; + newBody->m_primitives[i].m_points.resize(1); for (int j = 0; j < newBody->m_primitives[i].m_points.size(); j++) { newBody->m_primitives[i].m_points[j] = READ_LE_U16(bodyBuffer) / 6; bodyBuffer += 2; } - break; - case primTypeEnum_Sphere: + break; + case primTypeEnum_Sphere: newBody->m_primitives[i].m_material = READ_LE_U8(bodyBuffer); bodyBuffer += 1; - newBody->m_primitives[i].m_color = READ_LE_U8(bodyBuffer); bodyBuffer += 1; - newBody->m_primitives[i].m_even = READ_LE_U8(bodyBuffer); bodyBuffer += 1; - newBody->m_primitives[i].m_size = READ_LE_U16(bodyBuffer); bodyBuffer += 2; - newBody->m_primitives[i].m_points.resize(1); + newBody->m_primitives[i].m_color = READ_LE_U8(bodyBuffer); bodyBuffer += 1; + newBody->m_primitives[i].m_even = READ_LE_U8(bodyBuffer); bodyBuffer += 1; + newBody->m_primitives[i].m_size = READ_LE_U16(bodyBuffer); bodyBuffer += 2; + newBody->m_primitives[i].m_points.resize(1); for (int j = 0; j < newBody->m_primitives[i].m_points.size(); j++) { newBody->m_primitives[i].m_points[j] = READ_LE_U16(bodyBuffer) / 6; bodyBuffer += 2; @@ -336,13 +330,13 @@ sBody* createBodyFromPtr(void* ptr) } } - vBodies.push_back(newBody); return newBody; -} +} -char* HQR_Get(hqrEntryStruct* hqrPtr, int index) -{ - hqrSubEntryStruct* foundEntry; +template +T* HQR_Get(hqrEntryStruct* hqrPtr, int index) +{ + hqrSubEntryStruct* foundEntry; if(index<0) return NULL; @@ -358,78 +352,20 @@ char* HQR_Get(hqrEntryStruct* hqrPtr, int index) } else { - /* int size; - unsigned int time; - char* ptr; - - freezeTime(); - size = getPakSize(hqrPtr->string,index); - - if(size>=hqrPtr->maxFreeData) - { - theEnd(1,hqrPtr->string); - } - - time = timer; - - foundEntry = hqrSubPtr; - - while(size>hqrPtr->sizeFreeData || hqrPtr->numUsedEntry>= hqrPtr->numMaxEntry) - { - int bestEntry = 0; - unsigned int bestTime = 0; - int entryIdx = 0; - - for(entryIdx = 0; entryIdxnumUsedEntry; entryIdx++) - { - if(time - foundEntry[entryIdx].lastTimeUsed > bestTime) - { - bestTime = time - foundEntry[entryIdx].lastTimeUsed; - bestEntry = entryIdx; - } - } - - moveHqrEntry(hqrPtr,bestEntry); - } - - ptr = hqrPtr->dataPtr + (hqrPtr->maxFreeData - hqrPtr->sizeFreeData); - - if(!loadPakToPtr(hqrPtr->string,index,ptr)) - { - theEnd(1,hqrPtr->string); - } - - hqrVar1 = 1; - - foundEntry[hqrPtr->numUsedEntry].key = index; - foundEntry[hqrPtr->numUsedEntry].lastTimeUsed = timer; - foundEntry[hqrPtr->numUsedEntry].offset = hqrPtr->maxFreeData - hqrPtr->sizeFreeData; - foundEntry[hqrPtr->numUsedEntry].size = size; - - hqrPtr->numUsedEntry++; - hqrPtr->sizeFreeData -= size; - - unfreezeTime();*/ - - int size; - unsigned int time; - char* ptr; - int i; - - freezeTime(); - size = getPakSize(hqrPtr->string,index); + SaveTimerAnim(); + int size = getPakSize(hqrPtr->string.c_str(),index); if(size == 0) return NULL; if(size>=hqrPtr->maxFreeData) { - fatalError(1,hqrPtr->string); + fatalError(1,hqrPtr->string.c_str()); } - time = timer; + unsigned int time = timer; - for(i=0;inumMaxEntry;i++) + for(int i=0;inumMaxEntry;i++) { if(hqrPtr->entries[i].ptr == NULL) { @@ -448,31 +384,44 @@ char* HQR_Get(hqrEntryStruct* hqrPtr, int index) foundEntry->lastTimeUsed = timer; //foundEntry[hqrPtr->numUsedEntry].offset = hqrPtr->maxFreeData - hqrPtr->sizeFreeData; foundEntry->size = size; - foundEntry->ptr = (char*)malloc(size); - ptr = foundEntry->ptr; + char* buffer = new char[size]; + LoadPak(hqrPtr->string.c_str(), index, buffer); - LoadPak(hqrPtr->string,index,foundEntry->ptr); + if constexpr (std::is_same_v) { + foundEntry->ptr = buffer; + } + else if constexpr (std::is_same_v) { + foundEntry->ptr = createBodyFromPtr(buffer); + delete[] buffer; + } + else if constexpr (std::is_same_v) { + foundEntry->ptr = createAnimationFromPtr(buffer, size); + delete[] buffer; + } + else if constexpr (std::is_same_v) { + foundEntry->ptr = new sHybrid((uint8_t*)buffer, size); + delete[] buffer; + } + else { + assert(0); + } hqrPtr->numUsedEntry++; hqrPtr->sizeFreeData -= size; - unfreezeTime(); + RestoreTimerAnim(); - return(ptr); + return(foundEntry->ptr); } } -hqrEntryStruct* HQR_Init(int size,int numEntry) +hqrEntryStruct* HQR_Init(int size,int numEntry) { - int i; - hqrEntryStruct* dest; - char* dest2; - ASSERT(size > 0); ASSERT(numEntry > 0); - dest = (hqrEntryStruct*)malloc(sizeof(hqrEntryStruct)); + hqrEntryStruct* dest = new hqrEntryStruct(); numEntry = 2000; @@ -481,101 +430,90 @@ hqrEntryStruct* HQR_Init(int size,int numEntry) if(!dest) return NULL; - dest2 = (char*)malloc(size); - - ASSERT_PTR(dest2); - - if(!dest2) - return NULL; - - strcpy(dest->string,"_MEMORY_"); - + dest->string = "_MEMORY_"; dest->sizeFreeData = size; dest->maxFreeData = size; dest->numMaxEntry = numEntry; dest->numUsedEntry = 0; - dest->entries = (hqrSubEntryStruct*)malloc(numEntry*sizeof(hqrSubEntryStruct)); + dest->entries.resize(numEntry); - for(i=0;ientries[i].ptr = NULL; + dest->entries[i].ptr = nullptr; } return(dest); } -void HQR_Reset(hqrEntryStruct* hqrPtr) +template +void HQR_Reset(hqrEntryStruct* hqrPtr) { - int i; hqrPtr->sizeFreeData = hqrPtr->maxFreeData; - hqrPtr->numUsedEntry = 0; - - if (hqrPtr == listBody) - { - for (int i = 0; i < vBodies.size(); i++) - { - delete vBodies[i]; - } - vBodies.resize(0); - } + hqrPtr->numUsedEntry = 0; - for(i=0;inumMaxEntry;i++) + for(int i =0;inumMaxEntry;i++) { - if(hqrPtr->entries[i].ptr) - free(hqrPtr->entries[i].ptr); - - hqrPtr->entries[i].ptr = NULL; + if (hqrPtr->entries[i].ptr) + { + if constexpr (std::is_same_v) { + delete[] hqrPtr->entries[i].ptr; + } + else { + delete hqrPtr->entries[i].ptr; + } + hqrPtr->entries[i].ptr = nullptr; + } } } -void HQR_Free(hqrEntryStruct* hqrPtr) +template +void HQR_Free(hqrEntryStruct* hqrPtr) { - int i; - - if(!hqrPtr) - return; - - if (hqrPtr == listBody) - { - for (int i = 0; i < vBodies.size(); i++) - { - delete vBodies[i]; - } - vBodies.clear(); - } - - for(i=0;inumMaxEntry;i++) - { - if(hqrPtr->entries[i].ptr) - free(hqrPtr->entries[i].ptr); - } + HQR_Reset(hqrPtr); + + delete hqrPtr; +} - free(hqrPtr); +template +void configureHqrHero(hqrEntryStruct* hqrPtr, const char* name) +{ + hqrPtr->string = name; } - -sBody* getBodyFromPtr(void* ptr) -{ - for (int i = 0; i < vBodies.size(); i++) - { - if (vBodies[i]->m_raw == ptr) - { - return vBodies[i]; - } - } - - return createBodyFromPtr(ptr); -} - -sAnimation* getAnimationFromPtr(void* ptr) -{ - for (int i = 0; i < vAnimations.size(); i++) - { - if (vAnimations[i]->m_raw == ptr) - { - return vAnimations[i]; - } - } - - return createAnimationFromPtr(ptr); -} + +void HQ_Free_Malloc(hqrEntryStruct* hqrPtr, int index) +{ +} + +template +hqrEntryStruct* HQR_InitRessource(const char* name, int size, int numEntries); + +template +char* HQR_Get(hqrEntryStruct* hqrPtr, int index); + +template +void HQR_Free(hqrEntryStruct* hqrPtr); + +template +void HQR_Reset(hqrEntryStruct* hqrPtr); + +template +void configureHqrHero(hqrEntryStruct* hqrPtr, const char* name); + +/// body +template hqrEntryStruct* HQR_InitRessource(const char* name, int size, int numEntries); +template sBody* HQR_Get(hqrEntryStruct* hqrPtr, int index); +template void HQR_Free(hqrEntryStruct* hqrPtr); +template void configureHqrHero(hqrEntryStruct* hqrPtr, const char* name); + +/// anim +template hqrEntryStruct* HQR_InitRessource(const char* name, int size, int numEntries); +template sAnimation* HQR_Get(hqrEntryStruct* hqrPtr, int index); +template void HQR_Free(hqrEntryStruct* hqrPtr); +template void HQR_Reset(hqrEntryStruct* hqrPtr); +template void configureHqrHero(hqrEntryStruct* hqrPtr, const char* name); + +/// hybrids +template hqrEntryStruct* HQR_InitRessource(const char* name, int size, int numEntries); +template sHybrid* HQR_Get(hqrEntryStruct* hqrPtr, int index); +template void HQR_Free(hqrEntryStruct* hqrPtr); diff --git a/FitdLib/hqr.h b/FitdLib/hqr.h index 1e0356c..3257e05 100644 --- a/FitdLib/hqr.h +++ b/FitdLib/hqr.h @@ -1,14 +1,31 @@ -#ifndef _HQR_ -#define _HQR_ -char* HQR_Get(hqrEntryStruct* hqrPtr, int index); -int HQ_Malloc(hqrEntryStruct* hqrPtr,int size); -char* HQ_PtrMalloc(hqrEntryStruct* hqrPtr, int index); -hqrEntryStruct* HQR_InitRessource(const char* name, int size, int numEntries); -hqrEntryStruct* HQR_Init(int size,int numEntry); -void HQR_Reset(hqrEntryStruct* hqrPtr); -void HQR_Free(hqrEntryStruct* hqrPtr); +#pragma once + +template +struct hqrSubEntryStruct; + +template +struct hqrEntryStruct; + +template +T* HQR_Get(hqrEntryStruct* hqrPtr, int index); + +hqrEntryStruct* HQR_Init(int size, int numEntry); +int HQ_Malloc(hqrEntryStruct* hqrPtr,int size); +char* HQ_PtrMalloc(hqrEntryStruct* hqrPtr, int index); +void HQ_Free_Malloc(hqrEntryStruct* hqrPtr, int index); + +template +void HQR_Free(hqrEntryStruct* hqrPtr); + +template +hqrEntryStruct* HQR_InitRessource(const char* name, int size, int numEntries); + +template +void HQR_Reset(hqrEntryStruct* hqrPtr); + +template +void configureHqrHero(hqrEntryStruct* hqrPtr, const char* name); + +struct sBody* createBodyFromPtr(void* ptr); -sBody* getBodyFromPtr(void* ptr); -sAnimation* getAnimationFromPtr(void* ptr); -#endif diff --git a/FitdLib/hybrid.cpp b/FitdLib/hybrid.cpp new file mode 100644 index 0000000..d9a6893 --- /dev/null +++ b/FitdLib/hybrid.cpp @@ -0,0 +1,120 @@ +#include "common.h" +#include "hybrid.h" + +hqrEntryStruct* HQ_Hybrides = nullptr; + +sHybrid::sHybrid(uint8_t* buffer, int size) { + assert(size == READ_LE_U32(buffer + 20)); // EOF offset + + for (int i = 0; i < 5; i++) { + if (int startOffset = READ_LE_U32(buffer + 4 * i)) { + int blockSize = 0; + for (int j = i + 1; j < 6; j++) { + if (int nextOffset = READ_LE_U32(buffer + 4 * j)) { + blockSize = nextOffset - startOffset; + break; + } + } + assert(blockSize); + + switch (i) { + case 0: // Entities + readEntites(buffer + startOffset, blockSize); + break; + case 1: // Sprites + readSprites(buffer + startOffset, blockSize); + break; + case 2: // Animation + readAnimations(buffer + startOffset, blockSize); + break; + default: + break; + } + } + } +} + +void sHybrid::readSprites(uint8_t* buffer, int size) { + int count = (READ_LE_U32(buffer) - 2) / 4; + sprites.reserve(count); + for (int i = 0; i < count; i++) { + uint8_t* data = buffer + READ_LE_U32(buffer + i * 4) - 2; + uint32_t spriteSize; + if (i < count - 1) { + spriteSize = (READ_LE_U32(buffer + (i + 1) * 4) - 2) - (READ_LE_U32(buffer + i * 4) - 2); + } + else { + spriteSize = size - (READ_LE_U32(buffer + i * 4) - 2); + } + sprites.emplace_back().read(data, spriteSize); + } +} + +void sHybrid::readEntites(uint8_t* buffer, int size) { + int count = READ_LE_U32(buffer) / 4; + entities.reserve(count); + for (int i = 0; i < count; i++) { + uint8_t* data = buffer + READ_LE_U32(buffer + i * 4); + + auto& entity = entities.emplace_back(); + entity.flags = READ_LE_U16(data); data+=2; + + int numEntities = (entity.flags >> 8) & 0xFF; + + entity.parts.reserve(numEntities); + for (int j = 0; j < numEntities; j++) { + auto& part = entity.parts.emplace_back(); + + part.id = READ_LE_U8(data); data++; + part.nbpt = READ_LE_U8(data); data++; + part.cout = READ_LE_U8(data); data++; + part.cin = READ_LE_U8(data); data++; + + part.XY.resize(part.nbpt); + for (int k = 0; k < part.nbpt; k++) { + part.XY[k][0] = READ_LE_S16(data); data += 2; + part.XY[k][1] = READ_LE_S16(data); data += 2; + } + } + } +} + +void sHybrid::readAnimations(uint8_t* buffer, int size) { + int count = READ_LE_U32(buffer) / 4; + animations.reserve(count); + for (int i = 0; i < count; i++) { + uint8_t* animStart = buffer + READ_LE_U32(buffer + i * 4); + auto& anim = animations.emplace_back(); + anim.flag = READ_LE_U8(animStart); animStart++; + anim.count = READ_LE_U8(animStart); animStart++; + anim.anims.reserve(anim.count); + for (int j = 0; j < anim.count; j++) { + auto& animation = anim.anims.emplace_back(); + animation.id = READ_LE_U16(animStart); animStart += 2; + animation.flag = READ_LE_U16(animStart); animStart += 2; + animation.deltaX = READ_LE_S16(animStart); animStart += 2; + animation.deltaY = READ_LE_S16(animStart); animStart += 2; + } + } +} + +void AffHyb(int index, int X, int Y, sHybrid* pHybrid) { + auto& entity = pHybrid->entities[index]; + for (int i = 0; i < entity.parts.size(); i++) { + auto& part = entity.parts[i]; + switch (part.id) { + case 1: // sprite + { + int spriteNumber = part.cout + (((int)part.cin) << 8); + // TODO: dx/dy + AffSpr(spriteNumber, part.XY[0][0] + X, part.XY[0][1] + Y + 1, logicalScreen, pHybrid->sprites); + break; + } + case 6: // line + for (int i = 0; i < part.XY.size()-1; i++) { + osystem_draw3dLine(part.XY[i][0], part.XY[i][1], 0, part.XY[i+1][0], part.XY[i+1][1], 0, part.cin); + } + break; + } + } +} \ No newline at end of file diff --git a/FitdLib/hybrid.h b/FitdLib/hybrid.h new file mode 100644 index 0000000..df1e4c7 --- /dev/null +++ b/FitdLib/hybrid.h @@ -0,0 +1,47 @@ +#pragma once + +#include "sprite.h" + +struct sHybrid_EntityPart { + uint8_t id; + uint8_t nbpt; + uint8_t cout; + uint8_t cin; + std::vector> XY; +}; + +struct sHybrid_Entity { + uint16_t flags; + + std::vector parts; +}; + +struct sHybrid_Anim { + uint16_t id; + uint16_t flag; + int16_t deltaX; + int16_t deltaY; +}; + +struct sHybrid_Animation { + uint8_t flag; + uint8_t count; + std::vector anims; +}; + +struct sHybrid { + sHybrid(uint8_t* buffer, int size); + + std::vector entities; + std::vector sprites; + std::vector animations; + +private: + void readEntites(uint8_t* buffer, int size); + void readSprites(uint8_t* buffer, int size); + void readAnimations(uint8_t* buffer, int size); +}; + +extern hqrEntryStruct* HQ_Hybrides; + +void AffHyb(int index, int X, int Y, sHybrid* pHybrid); \ No newline at end of file diff --git a/FitdLib/imguiBGFX.cpp b/FitdLib/imguiBGFX.cpp index 1f3ba22..610a1d4 100644 --- a/FitdLib/imguiBGFX.cpp +++ b/FitdLib/imguiBGFX.cpp @@ -490,13 +490,13 @@ static OcornutImguiContext s_ctx; static void* memAlloc(size_t _size, void* _userData) { BX_UNUSED(_userData); - return BX_ALLOC(s_ctx.m_allocator, _size); + return bx::alloc(s_ctx.m_allocator, _size); } static void memFree(void* _ptr, void* _userData) { BX_UNUSED(_userData); - BX_FREE(s_ctx.m_allocator, _ptr); + bx::free(s_ctx.m_allocator, _ptr); } void imguiCreate(float _fontSize, bx::AllocatorI* _allocator) diff --git a/FitdLib/input.cpp b/FitdLib/input.cpp index 266174c..c9d82fb 100644 --- a/FitdLib/input.cpp +++ b/FitdLib/input.cpp @@ -6,18 +6,18 @@ extern float nearVal; extern float farVal; extern float cameraZoom; extern float fov; - -extern bool debuggerVar_debugMenuDisplayed; - -void handleKeyDown(SDL_Event& event) -{ - switch (event.key.key) - { - case SDL_SCANCODE_GRAVE: - debuggerVar_debugMenuDisplayed ^= 1; - break; - } -} + +extern bool debuggerVar_debugMenuDisplayed; + +void handleKeyDown(SDL_Event& event) +{ + switch (event.key.key) + { + case SDL_SCANCODE_GRAVE: + debuggerVar_debugMenuDisplayed ^= 1; + break; + } +} void readKeyboard(void) { @@ -34,9 +34,9 @@ void readKeyboard(void) ImGui_ImplSDL3_ProcessEvent(&event); - switch (event.type) { - case SDL_EVENT_KEY_DOWN: - handleKeyDown(event); + switch (event.type) { + case SDL_EVENT_KEY_DOWN: + handleKeyDown(event); break; case SDL_EVENT_QUIT: cleanupAndExit(); @@ -111,7 +111,7 @@ void readKeyboard(void) case SDL_SCANCODE_SPACE: Click = 1; break; -#ifdef FITD_DEBUGGER +#ifdef FITD_DEBUGGER case SDL_SCANCODE_O: debufferVar_topCameraZoom += 100; break; @@ -125,7 +125,7 @@ void readKeyboard(void) case SDL_SCANCODE_Y: debuggerVar_topCamera = false; backgroundMode = backgroundModeEnum_2D; - flagInitView = 1; + FlagInitView = 1; break; case SDL_SCANCODE_C: debuggerVar_noHardClip = !debuggerVar_noHardClip; diff --git a/FitdLib/inventory.cpp b/FitdLib/inventory.cpp index 9911be6..87475d5 100644 --- a/FitdLib/inventory.cpp +++ b/FitdLib/inventory.cpp @@ -1,5 +1,9 @@ #include "common.h" +sBody* ShowObjet; +int ShowBody; +int ShowBeta; + s16 currentInventory = 0; s16 numObjInInventoryTable[NUM_MAX_INVENTORY]; s16 inHandTable[NUM_MAX_INVENTORY]; @@ -30,7 +34,7 @@ int DrawListObjets(int startIdx, int selectIdx, int selectColor) else { SetClip(27,25,292,98); - fillBox(27,25,292,98,0); + AffRect(27,25,292,98,0); WindowX1 = 30; WindowY1 = 27; @@ -55,7 +59,7 @@ int DrawListObjets(int startIdx, int selectIdx, int selectColor) { if(selectColor == 15) { - fillBox(0xA,y,0x135,y+0x10,0x64); + AffRect(0xA,y,0x135,y+0x10,0x64); } SelectedMessage(160,y,objPtr->foundName,selectColor,4); @@ -93,19 +97,19 @@ int DrawListObjets(int startIdx, int selectIdx, int selectColor) void renderInventoryObject(int arg) { SetClip(statusLeft,statusTop,statusRight,statusBottom); - fillBox(statusLeft,statusTop,statusRight,statusBottom,0); + AffRect(statusLeft,statusTop,statusRight,statusBottom,0); - statusVar1 -= 8; + ShowBeta -= 8; - setCameraTarget(0,0,0,60,statusVar1,0,24000); - AffObjet(0,0,0,0,0,0,currentFoundBody); + setCameraTarget(0,0,0,60,ShowBeta,0,24000); + AffObjet(0,0,0,0,0,0,ShowObjet); if(arg!=-1) { u8 buffer[256]; - ExtSetFont(PtrFont,4); + SetFont(PtrFont,4); sprintf((char*)buffer,"%d",vars[arg]); - renderText(statusLeft+4,statusTop+4,logicalScreen,buffer); + PrintFont(statusLeft+4,statusTop+4,logicalScreen,buffer); } switch(g_gameId) @@ -132,7 +136,7 @@ void drawInventoryActions(int arg) else { SetClip(162,100,292,174); - fillBox(162,100,292,174, 0); + AffRect(162,100,292,174, 0); WindowX1 = 166; WindowY1 = 104; @@ -148,7 +152,7 @@ void drawInventoryActions(int arg) { if(g_gameId <= JACK) { - fillBox(170,y,309,y+16,100); + AffRect(170,y,309,y+16,100); SelectedMessage(240,y,inventoryActionTable[i],15,4); } else @@ -199,9 +203,9 @@ void processInventory(void) modeSelect = 0; antiBounce = 2; - statusVar1 = 0; + ShowBeta = 0; - freezeTime(); + SaveTimerAnim(); //pauseShaking(); if(lightOff!=0) @@ -220,7 +224,7 @@ void processInventory(void) statusRight = WindowX2; statusBottom = WindowY2; - setupCameraProjection(((statusRight-statusLeft)/2)+statusLeft,((statusBottom-statusTop)/2) + statusTop,128,400,390); + SetProjection(((statusRight-statusLeft)/2)+statusLeft,((statusBottom-statusTop)/2) + statusTop,128,400,390); break; case AITD2: @@ -321,11 +325,11 @@ void processInventory(void) { selectedWorldObjectIdx = DrawListObjets(firstObjectDisplayedIdx,selectedObjectIdx,15); - currentFoundBodyIdx = ListWorldObjets[selectedWorldObjectIdx].foundBody; + ShowBody = ListWorldObjets[selectedWorldObjectIdx].foundBody; - currentFoundBody = HQR_Get(listBody,currentFoundBodyIdx); + ShowObjet = HQR_Get(HQ_Bodys,ShowBody); - var_C = ListWorldObjets[selectedWorldObjectIdx].flags2; + var_C = ListWorldObjets[selectedWorldObjectIdx].foundFlag; numInventoryActions = 0; numActionForObject = 0; @@ -421,9 +425,9 @@ void processInventory(void) //osystem_flip(NULL); } - unfreezeTime(); + RestoreTimerAnim(); - flagInitView = 1; + FlagInitView = 1; while(Click || key || JoyD) { @@ -441,3 +445,207 @@ void processInventory(void) //updateShaking(); } + + +void cleanClip() +{ + for (int x = clipLeft; x < clipRight; x++) + { + for (int y = clipTop; y < clipBottom; y++) + { + logicalScreen[y * 320 + x] = 0; + uiLayer[y * 320 + x] = 0; + } + } +} + +void DrawFoundWindow(int menuState, int objectName, int zoomFactor) +{ + cleanClip(); + + setCameraTarget(0, 0, 0, 60, ShowBeta, 0, zoomFactor); + + AffObjet(0, 0, 0, 0, 0, 0, HQR_Get(HQ_Bodys, ShowBody)); + + SimpleMessage(160, WindowY1, 20, 1); + SimpleMessage(160, WindowY1 + 16, objectName, 1); + SimpleMessage(160, WindowY1 + 16, objectName, 1); + + switch (menuState) + { + case 0: + { + SelectedMessage(130, WindowY2 - 16, 21, 1, 4); + SimpleMessage(190, WindowY2 - 16, 22, 4); + break; + } + case 1: + { + SimpleMessage(130, WindowY2 - 16, 21, 4); + SelectedMessage(190, WindowY2 - 16, 22, 1, 4); + break; + } + case 2: + { + SelectedMessage(160, WindowY2 - 16, 10, 1, 4); + break; + } + } +} + +void FoundObjet(int objIdx, int param) +{ + tWorldObject* objPtr; + + if (objIdx < 0) + return; + + if (param == 2) + { + printf("foundObject with param == 2\n"); + } + + objPtr = &ListWorldObjets[objIdx]; + + if (param != 0 && (objPtr->foundFlag & 0xC000)) + { + return; + } + + if (objPtr->trackNumber) + { + if (timer - objPtr->trackNumber < 300) // prevent from reopening the window every frame + return; + } + + objPtr->trackNumber = 0; + + SaveTimerAnim(); + // setupShaking(1000); // probably to remove the shaking when in foundObject screen + + int weight = 0; + for (int i = 0; i < numObjInInventoryTable[currentInventory]; i++) + { + weight += ListWorldObjets[inventoryTable[currentInventory][i]].positionInTrack; + } + + int choix = 1; + + if (objPtr->positionInTrack + weight > CVars[getCVarsIdx(MAX_WEIGHT_LOADABLE)] || numObjInInventoryTable[currentInventory] + 1 == 30) + { + choix = 3; + } + + ShowBody = objPtr->foundBody; + ShowObjet = HQR_Get(HQ_Bodys, ShowBody); + + SetProjection(160, 100, 128, 300, 298); + + int zoom = 15000; + int stepzoom = -200; + ShowBeta = 0; + + memset(frontBuffer, 0, 320 * 200); + FastCopyScreen(frontBuffer, logicalScreen); + + AffBigCadre(160, 100, 240, 120); + + DrawFoundWindow(choix, objPtr->foundName, zoom); + osystem_flip(NULL); + + AntiRebond = 1; + + int exitflag = 0; + while (!exitflag) + { + osystem_CopyBlockPhys((unsigned char*)logicalScreen, 0, 0, 320, 200); + + process_events(); + osystem_drawBackground(); + + localKey = key; + localJoyD = JoyD; + localClick = Click; + + if (!AntiRebond) + { + if (localKey == 1) + { + if (choix != 2) + { + choix = 0; + } + + exitflag = 1; + } + if (choix != 2) + { + if (localJoyD & 4) + { + choix = 0; + } + + if (localJoyD & 8) + { + choix = 1; + } + } + + if (localKey == 28 || localClick != 0) + { + while (key) + { + process_events(); + } + + exitflag = 1; + } + } + else + { + if (!localKey && !localJoyD && !localClick) + AntiRebond = 0; + } + + ShowBeta -= 8; + + zoom += stepzoom; // zoom / dezoom + + if (zoom > 8000) // zoom management + stepzoom = -stepzoom; + + if (zoom < 25000) + stepzoom = -stepzoom; + + DrawFoundWindow(choix, objPtr->foundName, zoom); + + // menuWaitVSync(); + } + + RestoreTimerAnim(); + + if (choix == 1) + { + take(objIdx); + } + else + { + objPtr->trackNumber = timer; + } + + while (key && Click) + { + process_events(); + } + + localJoyD = 0; + localKey = 0; + localClick = 0; + + // if(mainLoopVar1 != 0) + { + //setupShaking(-600); + } + + FlagInitView = 1; +} \ No newline at end of file diff --git a/FitdLib/life.cpp b/FitdLib/life.cpp index 5eff648..e9f33df 100644 --- a/FitdLib/life.cpp +++ b/FitdLib/life.cpp @@ -1,6 +1,7 @@ #include #include "common.h" +#include "hybrid.h" int groundLevel; s16 specialTable[4] = { 144, 192, 48, 112 }; @@ -11,7 +12,7 @@ sequenceParamStruct sequenceParams[NUM_MAX_SEQUENCE_PARAM]; void resetRotateParam(void) { - currentProcessedActorPtr->rotate.param = 0; + currentProcessedActorPtr->rotate.numSteps = 0; } void throwObj(int animThrow, int frameThrow, int arg_4, int objToThrowIdx, int throwRotated, int throwForce, int animNext) @@ -30,7 +31,7 @@ void throwObj(int animThrow, int frameThrow, int arg_4, int objToThrowIdx, int t ListWorldObjets[objToThrowIdx].gamma -= 0x100; } - ListWorldObjets[objToThrowIdx].flags2 |= 0x1000; + ListWorldObjets[objToThrowIdx].foundFlag |= 0x1000; } } @@ -51,7 +52,7 @@ void put(int x, int y, int z, int room, int stage, int alpha, int beta, int gamm DeleteInventoryObjet(idx); - objPtr->flags2 |= 0x4000; + objPtr->foundFlag |= 0x4000; /* FlagGenereActiveList = 1; FlagRefreshAux2 = 1; */ @@ -84,14 +85,11 @@ int randRange(int min, int max) int InitSpecialObjet(int mode, int X, int Y, int Z, int stage, int room, int alpha, int beta, int gamma, ZVStruct* zvPtr) { s16 localSpecialTable[4]; - tObject* currentActorPtr; - int i; - ZVStruct* actorZvPtr; - memcpy(localSpecialTable, specialTable, 8); - currentActorPtr = objectTable; + tObject* currentActorPtr = ListObjets.data(); + int i; for (i = 0; i < NUM_MAX_OBJECT; i++) // count the number of active actors { if (currentActorPtr->indexInWorld == -1) @@ -104,10 +102,10 @@ int InitSpecialObjet(int mode, int X, int Y, int Z, int stage, int room, int alp return(-1); } - currentActorPtr->_flags = AF_SPECIAL; + currentActorPtr->objectType = AF_SPECIAL; currentActorPtr->indexInWorld = -2; currentActorPtr->life = -1; - currentActorPtr->lifeMode = 2; + currentActorPtr->lifeMode = 2; // TODO: probably incorrect betweem AITD1/2 currentActorPtr->bodyNum = 0; currentActorPtr->worldX = currentActorPtr->roomX = X; currentActorPtr->worldY = currentActorPtr->roomY = Y; @@ -129,10 +127,11 @@ int InitSpecialObjet(int mode, int X, int Y, int Z, int stage, int room, int alp currentActorPtr->stepY = 0; currentActorPtr->stepZ = 0; + ZVStruct* actorZvPtr = nullptr; if (zvPtr) { actorZvPtr = ¤tActorPtr->zv; - copyZv(zvPtr, actorZvPtr); + CopyZV(zvPtr, actorZvPtr); } switch (mode) @@ -149,9 +148,9 @@ int InitSpecialObjet(int mode, int X, int Y, int Z, int stage, int room, int alp actorZvPtr->ZVZ1 -= Z; actorZvPtr->ZVZ2 -= Z; - currentActorPtr->FRAME = HQ_Malloc(HQ_Memory, 304); + currentActorPtr->frame = HQ_Malloc(HQ_Memory, 304); - flowPtr = HQ_PtrMalloc(HQ_Memory, currentActorPtr->FRAME); + flowPtr = HQ_PtrMalloc(HQ_Memory, currentActorPtr->frame); if (!flowPtr) { @@ -200,7 +199,7 @@ int InitSpecialObjet(int mode, int X, int Y, int Z, int stage, int room, int alp } } - actorTurnedToObj = 1; + FlagGenereAffList = 1; return(i); } @@ -227,7 +226,7 @@ void getHardClip() zvCol.ZVZ1 = READ_LE_S16(etageData + 0x08); zvCol.ZVZ2 = READ_LE_S16(etageData + 0x0A); - if (checkZvCollision(zvPtr, &zvCol)) + if (CubeIntersect(zvPtr, &zvCol)) { hardClip.ZVX1 = zvCol.ZVX1; hardClip.ZVX2 = zvCol.ZVX2; @@ -347,16 +346,16 @@ void setStage(int newStage, int newRoomLocal, int X, int Y, int Z) { if (newStage != g_currentFloor) { - changeFloor = 1; - newFloor = newStage; - newRoom = newRoomLocal; + FlagChangeEtage = 1; + NewNumEtage = newStage; + NewNumSalle = newRoomLocal; } else { if (currentRoom != newRoomLocal) { - needChangeRoom = 1; - newRoom = newRoomLocal; + FlagChangeSalle = 1; + NewNumSalle = newRoomLocal; } } } @@ -375,9 +374,6 @@ void setStage(int newStage, int newRoomLocal, int X, int Y, int Z) void setupRealZv(ZVStruct* zvPtr) { - int i; - s16* ptr = pointBuffer; - zvPtr->ZVX1 = 32000; zvPtr->ZVY1 = 32000; zvPtr->ZVZ1 = 32000; @@ -385,47 +381,36 @@ void setupRealZv(ZVStruct* zvPtr) zvPtr->ZVY2 = -32000; zvPtr->ZVZ2 = -32000; - for (i = 0; i < numOfPoints; i++) + for (int i = 0; i < numOfPoints; i++) { - if (zvPtr->ZVX1 >(*ptr)) + point3dStruct* ptr = &pointBuffer[i]; + if (zvPtr->ZVX1 > ptr->x) { - zvPtr->ZVX1 = *(ptr); + zvPtr->ZVX1 = ptr->x; } - else + else if (zvPtr->ZVX2 < ptr->x) { - if (zvPtr->ZVX2 < (*ptr)) - { - zvPtr->ZVX2 = *(ptr); - } + zvPtr->ZVX2 = ptr->x; } - ptr++; - if (zvPtr->ZVY1 >(*ptr)) + if (zvPtr->ZVY1 > ptr->y) { - zvPtr->ZVY1 = *(ptr); + zvPtr->ZVY1 = ptr->y; } - else + else if (zvPtr->ZVY2 < ptr->y) { - if (zvPtr->ZVY2 < (*ptr)) - { - zvPtr->ZVY2 = *(ptr); - } + zvPtr->ZVY2 = ptr->y; } - ptr++; - if (zvPtr->ZVZ1 >(*ptr)) + if (zvPtr->ZVZ1 > ptr->z) { - zvPtr->ZVZ1 = *(ptr); + zvPtr->ZVZ1 = ptr->z; } else + if (zvPtr->ZVZ2 < ptr->z) { - if (zvPtr->ZVZ2 < (*ptr)) - { - zvPtr->ZVZ2 = *(ptr); - } + zvPtr->ZVZ2 = ptr->z; } - ptr++; - } } @@ -433,7 +418,7 @@ void doRealZv(tObject* actorPtr) { ZVStruct* zvPtr; - computeScreenBox(0, 0, 0, actorPtr->alpha, actorPtr->beta, actorPtr->gamma, HQR_Get(listBody, actorPtr->bodyNum)); + computeScreenBox(0, 0, 0, actorPtr->alpha, actorPtr->beta, actorPtr->gamma, HQR_Get(HQ_Bodys, actorPtr->bodyNum)); zvPtr = &actorPtr->zv; @@ -517,7 +502,7 @@ void processLife(int lifeNum, bool callFoundLife) if (currentProcessedActorIdx != -1) { - currentProcessedActorPtr = &objectTable[currentProcessedActorIdx]; + currentProcessedActorPtr = &ListObjets[currentProcessedActorIdx]; goto processOpcode; } @@ -704,8 +689,8 @@ void processLife(int lifeNum, bool callFoundLife) } case LM_FOUND_FLAG: // FOUND_FLAG { - ListWorldObjets[var_6].flags2 &= 0xE000; - ListWorldObjets[var_6].flags2 |= *(s16*)(currentLifePtr); + ListWorldObjets[var_6].foundFlag &= 0xE000; + ListWorldObjets[var_6].foundFlag |= *(s16*)(currentLifePtr); currentLifePtr += 2; break; @@ -758,12 +743,11 @@ void processLife(int lifeNum, bool callFoundLife) { currentProcessedActorPtr->bodyNum = lifeTempVar1; - if (currentProcessedActorPtr->_flags & AF_ANIMATED) + if (currentProcessedActorPtr->objectType & AF_ANIMATED) { if ((currentProcessedActorPtr->ANIM != -1) && (currentProcessedActorPtr->bodyNum != -1)) { - char* pAnim = HQR_Get(listAnim, currentProcessedActorPtr->ANIM); - char* pBody; + sAnimation* pAnim = HQR_Get(HQ_Anims, currentProcessedActorPtr->ANIM); if (g_gameId >= JACK) { @@ -771,7 +755,7 @@ void processLife(int lifeNum, bool callFoundLife) gereDecal(); */ } - pBody = HQR_Get(listBody, currentProcessedActorPtr->bodyNum); + sBody* pBody = HQR_Get(HQ_Bodys, currentProcessedActorPtr->bodyNum); /* if(gameId >= JACK) { @@ -779,13 +763,13 @@ void processLife(int lifeNum, bool callFoundLife) } else */ { - SetInterAnimObjet(currentProcessedActorPtr->FRAME, pAnim, pBody); + SetInterAnimObjet(currentProcessedActorPtr->frame, pAnim, pBody); } } } else { - flagInitView = 1; + FlagInitView = 1; } } break; @@ -802,10 +786,9 @@ void processLife(int lifeNum, bool callFoundLife) currentProcessedActorPtr->bodyNum = param1; - if (currentProcessedActorPtr->_flags & AF_ANIMATED) + if (currentProcessedActorPtr->objectType & AF_ANIMATED) { - char* pAnim = HQR_Get(listAnim, currentProcessedActorPtr->ANIM); - char* pBody; + sAnimation* pAnim = HQR_Get(HQ_Anims, currentProcessedActorPtr->ANIM); if (g_gameId >= JACK) { @@ -813,14 +796,14 @@ void processLife(int lifeNum, bool callFoundLife) gereDecal(); */ } - pBody = HQR_Get(listBody, currentProcessedActorPtr->bodyNum); + sBody* pBody = HQR_Get(HQ_Bodys, currentProcessedActorPtr->bodyNum); SetAnimObjet(0, pAnim, pBody); InitAnim(param2, 4, -1); } else { - flagInitView = 1; + FlagInitView = 1; } break; } @@ -873,7 +856,7 @@ void processLife(int lifeNum, bool callFoundLife) case LM_DO_ROT_ZV: // DO_ROT_ZV { appendFormated("LM_DO_ROT_ZV "); - getZvRot(HQR_Get(listBody, currentProcessedActorPtr->bodyNum), ¤tProcessedActorPtr->zv, + getZvRot(HQR_Get(HQ_Bodys, currentProcessedActorPtr->bodyNum), ¤tProcessedActorPtr->zv, currentProcessedActorPtr->alpha, currentProcessedActorPtr->beta, currentProcessedActorPtr->gamma); @@ -887,10 +870,24 @@ void processLife(int lifeNum, bool callFoundLife) break; } + case LM_DO_MAX_ZV: + { + appendFormated("LM_DO_MAX_ZV "); + getZvMax(HQR_Get(HQ_Bodys, currentProcessedActorPtr->bodyNum), ¤tProcessedActorPtr->zv); + + currentProcessedActorPtr->zv.ZVX1 += currentProcessedActorPtr->roomX; + currentProcessedActorPtr->zv.ZVX2 += currentProcessedActorPtr->roomX; + currentProcessedActorPtr->zv.ZVY1 += currentProcessedActorPtr->roomY; + currentProcessedActorPtr->zv.ZVY2 += currentProcessedActorPtr->roomY; + currentProcessedActorPtr->zv.ZVZ1 += currentProcessedActorPtr->roomZ; + currentProcessedActorPtr->zv.ZVZ2 += currentProcessedActorPtr->roomZ; + + break; + } case LM_DO_CARRE_ZV: // DO_CARRE_ZV { appendFormated("LM_DO_CARRE_ZV "); - getZvCube(HQR_Get(listBody, currentProcessedActorPtr->bodyNum), ¤tProcessedActorPtr->zv); + getZvCube(HQR_Get(HQ_Bodys, currentProcessedActorPtr->bodyNum), ¤tProcessedActorPtr->zv); currentProcessedActorPtr->zv.ZVX1 += currentProcessedActorPtr->roomX; currentProcessedActorPtr->zv.ZVX2 += currentProcessedActorPtr->roomX; @@ -906,9 +903,9 @@ void processLife(int lifeNum, bool callFoundLife) appendFormated("LM_TYPE "); lifeTempVar1 = readNextArgument("type") & AF_MASK; - lifeTempVar2 = currentProcessedActorPtr->_flags; + lifeTempVar2 = currentProcessedActorPtr->objectType; - currentProcessedActorPtr->_flags = (currentProcessedActorPtr->_flags & ~AF_MASK) + lifeTempVar1; + currentProcessedActorPtr->objectType = (currentProcessedActorPtr->objectType & ~AF_MASK) + lifeTempVar1; if (g_gameId > AITD1) { @@ -989,7 +986,7 @@ void processLife(int lifeNum, bool callFoundLife) } else { - InitAnim(anim, 4, animFlag); + InitAnim(anim, ANIM_ONCE | ANIM_RESET, animFlag); } break; @@ -997,21 +994,55 @@ void processLife(int lifeNum, bool callFoundLife) case LM_ANIM_HYBRIDE_ONCE: { appendFormated("LM_ANIM_HYBRIDE_ONCE "); - // TODO - int anim = readNextArgument("Anim"); - int body = readNextArgument("Body?"); - //printf("LM_ANIM_HYBRIDE_ONCE(anim:%d, body:%d)\n", anim, body); + int anim = readNextArgument("Anim"); + int body = readNextArgument("Body"); + + if ((currentProcessedActorPtr->ANIM != anim) || (currentProcessedActorPtr->bodyNum != body)) { + currentProcessedActorPtr->ANIM = anim; + currentProcessedActorPtr->bodyNum = body; + currentProcessedActorPtr->memoTicks = timer; + currentProcessedActorPtr->frame = 0; + + if ((currentProcessedActorPtr->ANIM != -1) && (currentProcessedActorPtr->bodyNum != -1)) { + sHybrid* pHybrid = HQR_Get(HQ_Hybrides, currentProcessedActorPtr->ANIM); + currentProcessedActorPtr->numOfFrames = pHybrid->animations[currentProcessedActorPtr->bodyNum].count; + currentProcessedActorPtr->animInfo = -1; + currentProcessedActorPtr->animType = ANIM_ONCE; + currentProcessedActorPtr->objectType |= AF_OBJ_2D; + } + else { + currentProcessedActorPtr->numOfFrames = 0; + currentProcessedActorPtr->objectType = 0; + } + } break; } case LM_ANIM_HYBRIDE_REPEAT: { appendFormated("LM_ANIM_HYBRIDE_REPEAT "); - // TODO - int anim = readNextArgument("Anim"); - int body = readNextArgument("Body?"); - //printf("LM_ANIM_HYBRIDE_REPEAT(anim:%d, body:%d)\n", anim, body); + int anim = readNextArgument("Anim"); + int body = readNextArgument("Body"); + + if ((currentProcessedActorPtr->ANIM != anim) || (currentProcessedActorPtr->bodyNum != body)) { + currentProcessedActorPtr->ANIM = anim; + currentProcessedActorPtr->bodyNum = body; + currentProcessedActorPtr->memoTicks = timer; + currentProcessedActorPtr->frame = 0; + + if ((currentProcessedActorPtr->ANIM != -1) && (currentProcessedActorPtr->bodyNum != -1)) { + sHybrid* pHybrid = HQR_Get(HQ_Hybrides, currentProcessedActorPtr->ANIM); + currentProcessedActorPtr->numOfFrames = pHybrid->animations[currentProcessedActorPtr->bodyNum].count; + currentProcessedActorPtr->animInfo = -1; + currentProcessedActorPtr->animType = ANIM_REPEAT; + currentProcessedActorPtr->objectType |= AF_OBJ_2D; + } + else { + currentProcessedActorPtr->numOfFrames = 0; + currentProcessedActorPtr->objectType = 0; + } + } break; } //////////////////////////////////////////////////////////////////////// @@ -1138,7 +1169,7 @@ void processLife(int lifeNum, bool callFoundLife) lifeTempVar1 = readNextArgument("TrackMode"); lifeTempVar2 = readNextArgument("TrackNumber"); - setMoveMode(lifeTempVar1, lifeTempVar2); + InitDeplacement(lifeTempVar1, lifeTempVar2); break; } @@ -1166,14 +1197,7 @@ void processLife(int lifeNum, bool callFoundLife) case LM_DO_MOVE: { appendFormated("LM_DO_MOVE "); - if (g_gameId == AITD1) - { - processTrack(); - } - else - { - processTrack2(); - } + processTrack(); break; } case LM_ANIM_MOVE: @@ -1212,7 +1236,7 @@ void processLife(int lifeNum, bool callFoundLife) if (currentProcessedActorPtr->beta != lifeTempVar1) { - if (currentProcessedActorPtr->rotate.param == 0 || currentProcessedActorPtr->rotate.newAngle != lifeTempVar1) + if (currentProcessedActorPtr->rotate.numSteps == 0 || currentProcessedActorPtr->rotate.endValue != lifeTempVar1) { InitRealValue(currentProcessedActorPtr->beta, lifeTempVar1, lifeTempVar2, ¤tProcessedActorPtr->rotate); } @@ -1230,7 +1254,7 @@ void processLife(int lifeNum, bool callFoundLife) if (currentProcessedActorPtr->alpha != lifeTempVar1) { - if (currentProcessedActorPtr->rotate.param == 0 || lifeTempVar1 != currentProcessedActorPtr->rotate.newAngle) + if (currentProcessedActorPtr->rotate.numSteps == 0 || lifeTempVar1 != currentProcessedActorPtr->rotate.endValue) { InitRealValue(currentProcessedActorPtr->alpha, lifeTempVar1, lifeTempVar2, ¤tProcessedActorPtr->rotate); } @@ -1260,9 +1284,9 @@ void processLife(int lifeNum, bool callFoundLife) currentProcessedActorPtr->gamma = ListWorldObjets[object].gamma; } else { - currentProcessedActorPtr->alpha = objectTable[localObjectIndex].alpha; - currentProcessedActorPtr->beta = objectTable[localObjectIndex].beta; - currentProcessedActorPtr->gamma = objectTable[localObjectIndex].gamma; + currentProcessedActorPtr->alpha = ListObjets[localObjectIndex].alpha; + currentProcessedActorPtr->beta = ListObjets[localObjectIndex].beta; + currentProcessedActorPtr->gamma = ListObjets[localObjectIndex].gamma; } break; } @@ -1290,7 +1314,7 @@ void processLife(int lifeNum, bool callFoundLife) } else { - currentProcessedActorPtr->dynFlags &= 0xFFFE; + currentProcessedActorPtr->dynFlags &= ~1; } break; @@ -1354,9 +1378,9 @@ void processLife(int lifeNum, bool callFoundLife) { if (g_gameId == AITD1) // TODO: check, really useful ? { - ListWorldObjets[lifeTempVar1].flags2 &= 0x7FFF; + ListWorldObjets[lifeTempVar1].foundFlag &= ~0x8000; } - ListWorldObjets[lifeTempVar1].flags2 |= 0x4000; + ListWorldObjets[lifeTempVar1].foundFlag |= 0x4000; } break; @@ -1384,7 +1408,7 @@ void processLife(int lifeNum, bool callFoundLife) } case 1: // flow { - currentProcessedActorPtr = &objectTable[currentProcessedActorPtr->HIT_BY]; + currentProcessedActorPtr = &ListObjets[currentProcessedActorPtr->HIT_BY]; InitSpecialObjet(1, currentProcessedActorPtr->roomX + currentProcessedActorPtr->stepX + currentProcessedActorPtr->hotPoint.x, @@ -1434,17 +1458,17 @@ void processLife(int lifeNum, bool callFoundLife) if (g_gameId == AITD1) { - foundObject(lifeTempVar1, 1); + FoundObjet(lifeTempVar1, 1); } else { if (callFoundLife) { - foundObject(lifeTempVar1, 2); + FoundObjet(lifeTempVar1, 2); } else { - foundObject(lifeTempVar1, 1); + FoundObjet(lifeTempVar1, 1); } } @@ -1572,8 +1596,8 @@ void processLife(int lifeNum, bool callFoundLife) case LM_FOUND_FLAG: // FOUND_FLAG { appendFormated("LM_FOUND_FLAG "); - ListWorldObjets[currentProcessedActorPtr->indexInWorld].flags2 &= 0xE000; - ListWorldObjets[currentProcessedActorPtr->indexInWorld].flags2 |= *(s16*)(currentLifePtr); + ListWorldObjets[currentProcessedActorPtr->indexInWorld].foundFlag &= 0xE000; + ListWorldObjets[currentProcessedActorPtr->indexInWorld].foundFlag |= *(s16*)(currentLifePtr); currentLifePtr += 2; break; } @@ -1615,7 +1639,7 @@ void processLife(int lifeNum, bool callFoundLife) FadeOutPhys(4, 0); } - flagInitView = 2; + FlagInitView = 2; break; } @@ -1639,21 +1663,21 @@ void processLife(int lifeNum, bool callFoundLife) lifeTempVar8 = *(s16*)(currentLifePtr); currentLifePtr += 2; - freezeTime(); + SaveTimerAnim(); FadeOutPhys(32, 0); LoadPak("ITD_RESS", lifeTempVar1, aux); - unsigned char lpalette[0x300]; - copyPalette((unsigned char*)aux + 64000, lpalette); + palette_t lpalette; + copyPalette(aux + 64000, lpalette); convertPaletteIfRequired(lpalette); copyPalette(lpalette, currentGamePalette); setPalette(lpalette); turnPageFlag = false; Lire(lifeTempVar2 + 1, lifeTempVar3, lifeTempVar4, lifeTempVar5, lifeTempVar6, 0, lifeTempVar7, lifeTempVar8); - flagInitView = 2; + FlagInitView = 2; - unfreezeTime(); + RestoreTimerAnim(); break; } @@ -1662,11 +1686,11 @@ void processLife(int lifeNum, bool callFoundLife) { appendFormated("LM_ANIM_SAMPLE "); lifeTempVar1 = evalVar(); - + if (g_gameId == TIMEGATE) { currentLifePtr += 2; - } + } lifeTempVar2 = *(s16*)(currentLifePtr); currentLifePtr += 2; @@ -1677,7 +1701,7 @@ void processLife(int lifeNum, bool callFoundLife) { if (currentProcessedActorPtr->ANIM == lifeTempVar2) { - if (currentProcessedActorPtr->FRAME == lifeTempVar3) + if (currentProcessedActorPtr->frame == lifeTempVar3) { playSound(lifeTempVar1); //setSampleFreq(0); @@ -1923,36 +1947,36 @@ void processLife(int lifeNum, bool callFoundLife) currentWorldTarget = lifeTempVar1; currentCameraTargetActor = lifeTempVar2; - lifeTempVar3 = objectTable[currentCameraTargetActor].room; + lifeTempVar3 = ListObjets[currentCameraTargetActor].room; if (lifeTempVar3 != currentRoom) { - needChangeRoom = 1; - newRoom = lifeTempVar3; + FlagChangeSalle = 1; + NewNumSalle = lifeTempVar3; } } else { // security case, the target actor may be still be in list while already changed of stage // TODO: check if AITD1 could use the same code (quite probable as it's only security) - if (objectTable[lifeTempVar2].stage != g_currentFloor) + if (ListObjets[lifeTempVar2].stage != g_currentFloor) { currentWorldTarget = lifeTempVar1; - changeFloor = 1; - newFloor = objectTable[lifeTempVar2].stage; - newRoom = objectTable[lifeTempVar2].room; + FlagChangeEtage = 1; + NewNumEtage = ListObjets[lifeTempVar2].stage; + NewNumSalle = ListObjets[lifeTempVar2].room; } else { currentWorldTarget = lifeTempVar1; currentCameraTargetActor = lifeTempVar2; - lifeTempVar3 = objectTable[currentCameraTargetActor].room; + lifeTempVar3 = ListObjets[currentCameraTargetActor].room; if (lifeTempVar3 != currentRoom) { - needChangeRoom = 1; - newRoom = lifeTempVar3; + FlagChangeSalle = 1; + NewNumSalle = lifeTempVar3; } } } @@ -1962,16 +1986,16 @@ void processLife(int lifeNum, bool callFoundLife) currentWorldTarget = lifeTempVar1; if (ListWorldObjets[lifeTempVar1].stage != g_currentFloor) { - changeFloor = 1; - newFloor = ListWorldObjets[lifeTempVar1].stage; - newRoom = ListWorldObjets[lifeTempVar1].room; + FlagChangeEtage = 1; + NewNumEtage = ListWorldObjets[lifeTempVar1].stage; + NewNumSalle = ListWorldObjets[lifeTempVar1].room; } else { if (currentRoom != ListWorldObjets[lifeTempVar1].room) { - needChangeRoom = 1; - newRoom = ListWorldObjets[lifeTempVar1].room; + FlagChangeSalle = 1; + NewNumSalle = ListWorldObjets[lifeTempVar1].room; } } } @@ -1997,15 +2021,15 @@ void processLife(int lifeNum, bool callFoundLife) sampleId = readNextArgument("sampleId"); } - freezeTime(); + SaveTimerAnim(); LoadPak("ITD_RESS", pictureIndex, aux); if (g_gameId > AITD1) { FadeOutPhys(0x10, 0); - unsigned char lpalette[0x300]; - copyPalette((unsigned char*)aux + 64000, lpalette); + palette_t lpalette; + copyPalette(aux + 64000, lpalette); convertPaletteIfRequired(lpalette); copyPalette(lpalette, currentGamePalette); setPalette(lpalette); @@ -2034,9 +2058,9 @@ void processLife(int lifeNum, bool callFoundLife) break; } while (!key && !Click); - unfreezeTime(); + RestoreTimerAnim(); - flagInitView = 1; + FlagInitView = 1; if (g_gameId > AITD1) { @@ -2051,7 +2075,7 @@ void processLife(int lifeNum, bool callFoundLife) u16 fadeEntry; u16 fadeOut; - freezeTime(); + SaveTimerAnim(); sequenceIdx = *(u16*)(currentLifePtr); currentLifePtr += 2; @@ -2064,7 +2088,7 @@ void processLife(int lifeNum, bool callFoundLife) playSequence(sequenceIdx, fadeEntry, fadeOut); - unfreezeTime(); + RestoreTimerAnim(); break; } @@ -2421,7 +2445,7 @@ void processLife(int lifeNum, bool callFoundLife) { process_events(); } - giveUp = 1; + FlagGameOver = 1; exitLife = 1; break; } @@ -2436,7 +2460,7 @@ void processLife(int lifeNum, bool callFoundLife) { process_events(); } - giveUp = 1; + FlagGameOver = 1; exitLife = 1; break; } diff --git a/FitdLib/main.cpp b/FitdLib/main.cpp index 4a0f7cc..494bfb4 100644 --- a/FitdLib/main.cpp +++ b/FitdLib/main.cpp @@ -7,6 +7,9 @@ // seg002 #include "common.h" +#include "hybrid.h" +#include "anim2d.h" + #include #ifndef AITD_UE4 @@ -26,7 +29,7 @@ FILE* Open(const char* filename, const char* mode) { return fopen(path.string().c_str(), mode); } -int input5; +int AntiRebond; int* currentCVarTable = NULL; @@ -194,7 +197,7 @@ void executeFoundLife(int objIdx) if(actorIdx==-1) { - tObject* currentActorEntryPtr = &objectTable[NUM_MAX_OBJECT-1]; + tObject* currentActorEntryPtr = &ListObjets[NUM_MAX_OBJECT-1]; int currentActorEntry = NUM_MAX_OBJECT-1; while(currentActorEntry>=0) @@ -209,21 +212,21 @@ void executeFoundLife(int objIdx) if(currentActorEntry==-1) // no space, we will have to overwrite the last actor ! { currentActorEntry = NUM_MAX_OBJECT-1; - currentActorEntryPtr = &objectTable[NUM_MAX_OBJECT-1]; + currentActorEntryPtr = &ListObjets[NUM_MAX_OBJECT-1]; } actorIdx = currentActorEntry; var_2 = 1; - currentProcessedActorPtr = &objectTable[actorIdx]; - currentLifeActorPtr = &objectTable[actorIdx]; + currentProcessedActorPtr = &ListObjets[actorIdx]; + currentLifeActorPtr = &ListObjets[actorIdx]; currentProcessedActorIdx = actorIdx; currentLifeActorIdx = actorIdx; currentProcessedActorPtr->indexInWorld = objIdx; currentProcessedActorPtr->life = -1; currentProcessedActorPtr->bodyNum = -1; - currentProcessedActorPtr->_flags = 0; + currentProcessedActorPtr->objectType = 0; currentProcessedActorPtr->trackMode = -1; currentProcessedActorPtr->room = -1; currentProcessedActorPtr->lifeMode = -1; @@ -278,11 +281,6 @@ void allocTextes(void) } // setup languageNameString - if(g_gameId == AITD3) - { - strcpy(languageNameString,"TEXTES"); - } - else { for (int i=0; i("LISTMUS",110000,40); } char sampleFileName[256] = ""; @@ -509,7 +482,7 @@ void OpenProgram(void) strcpy(sampleFileName, "LISTSAMP"); } - listSamp = HQR_InitRessource(sampleFileName,64000,30); + listSamp = HQR_InitRessource(sampleFileName,64000,30); HQ_Memory = HQR_Init(10000,50); } @@ -559,12 +532,13 @@ textEntryStruct* getTextFromIdx(int index) return(NULL); } -void fillBox(int x1, int y1, int x2, int y2, char color) // fast recode. No RE +void AffRect(int x1, int y1, int x2, int y2, char color) // fast recode. No RE { int width = x2 - x1 + 1; int height = y2 - y1 + 1; char* dest = logicalScreen + y1*320 + x1; + char* dest2 = (char*)uiLayer.data() + y1*320 + x1; int i; int j; @@ -574,15 +548,17 @@ void fillBox(int x1, int y1, int x2, int y2, char color) // fast recode. No RE for(j=0;jtextPtr); + PrintFont(currentTextX, currentTextY, logicalScreen, currentText->textPtr); currentTextX += currentText->width + interWordSpace; // add inter word space currentText++; } @@ -1029,7 +1002,7 @@ extern "C" { extern char homePath[512]; } -void initEngine(void) +void LoadWorld(void) { u8* pObjectData; u8* pObjectDataBackup; @@ -1042,11 +1015,12 @@ void initEngine(void) strcpy(objectPath, homePath); strcat(objectPath, "OBJETS.ITD"); fHandle = fopen(objectPath,"rb"); - if(!fHandle) - fatalError(0,"OBJETS.ITD"); + if (!fHandle) { + fatalError(0, "OBJETS.ITD"); + } fseek(fHandle,0,SEEK_END); - objectDataSize= ftell(fHandle); + objectDataSize = ftell(fHandle); fseek(fHandle,0,SEEK_SET); pObjectDataBackup = pObjectData = (u8*)malloc(objectDataSize); @@ -1080,7 +1054,7 @@ void initEngine(void) ListWorldObjets[i].foundName = READ_LE_U16(pObjectData); pObjectData+=2; - ListWorldObjets[i].flags2 = READ_LE_U16(pObjectData); + ListWorldObjets[i].foundFlag = READ_LE_U16(pObjectData); pObjectData+=2; ListWorldObjets[i].foundLife = READ_LE_U16(pObjectData); @@ -1186,28 +1160,31 @@ void initEngine(void) CVars[getCVarsIdx(CHOOSE_PERSO)] = choosePersoBackup; } - listLife = HQR_InitRessource("LISTLIFE", 65000, 100); - listTrack = HQR_InitRessource("LISTTRAK", 20000, 100); + listLife = HQR_InitRessource("LISTLIFE", 65000, 100); + listTrack = HQR_InitRessource("LISTTRAK", 20000, 100); + if (g_gameId >= JACK) { + HQ_Hybrides = HQR_InitRessource("LISTHYB", 20000, 10); // TODO: recheck size for other games + } // TODO: missing dos memory check here if(g_gameId == AITD1) { - listBody = HQR_InitRessource(listBodySelect[CVars[getCVarsIdx(CHOOSE_PERSO)]],37000, 50); // was calculated from free mem size - listAnim = HQR_InitRessource(listAnimSelect[CVars[getCVarsIdx(CHOOSE_PERSO)]],30000, 80); // was calculated from free mem size + HQ_Bodys = HQR_InitRessource(listBodySelect[CVars[getCVarsIdx(CHOOSE_PERSO)]], 37000, 50); // was calculated from free mem size + HQ_Anims = HQR_InitRessource(listAnimSelect[CVars[getCVarsIdx(CHOOSE_PERSO)]], 30000, 80); // was calculated from free mem size } else { - listBody = HQR_InitRessource("LISTBODY",37000, 50); // was calculated from free mem size - listAnim = HQR_InitRessource("LISTANIM",30000, 80); // was calculated from free mem size + HQ_Bodys = HQR_InitRessource("LISTBODY", 37000, 50); // was calculated from free mem size + HQ_Anims = HQR_InitRessource("LISTANIM",30000, 80); // was calculated from free mem size - listMatrix = HQR_InitRessource("LISTMAT",64000,5); + HQ_Matrices = HQR_InitRessource("LISTMAT",64000,5); } for(i=0;i= JACK) { - copyPalette((unsigned char*)aux+64000,currentGamePalette); + copyPalette(aux+64000,currentGamePalette); if(g_gameId == AITD3) { - //memcpy(palette,defaultPaletteAITD3,0x30); + for (int i = 0; i < 16; i++) { + currentGamePalette[i][0] = defaultPaletteAITD3[i * 3 + 0]; + currentGamePalette[i][1] = defaultPaletteAITD3[i * 3 + 1]; + currentGamePalette[i][2] = defaultPaletteAITD3[i * 3 + 2]; + } } else { - memcpy(currentGamePalette,defaultPalette,0x30); - convertPaletteIfRequired((unsigned char*)currentGamePalette); + for (int i = 0; i < 16; i++) { + currentGamePalette[i][0] = defaultPalette[i * 3 + 0]; + currentGamePalette[i][1] = defaultPalette[i * 3 + 1]; + currentGamePalette[i][2] = defaultPalette[i * 3 + 2]; + } } + convertPaletteIfRequired(currentGamePalette); - osystem_setPalette(currentGamePalette); + osystem_setPalette(¤tGamePalette); } } -struct maskStruct +struct sMaskStruct { u16 x1; u16 y1; @@ -1355,7 +1340,7 @@ struct maskStruct std::array mask; }; -maskStruct g_maskBuffers[10][10]; +std::vector> g_maskBuffers; void loadMask(int cameraIdx) { @@ -1373,17 +1358,19 @@ void loadMask(int cameraIdx) g_MaskPtr = (unsigned char*)loadPak(name,cameraIdx); - for(int i=0; inumViewedRooms; i++) + g_maskBuffers.clear(); + g_maskBuffers.resize(cameraDataTable[NumCamera]->numViewedRooms); + for(int i=0; inumViewedRooms; i++) { - cameraViewedRoomStruct* pRoomView = &cameraDataTable[currentCamera]->viewedRoomTable[i]; + cameraViewedRoomStruct* pRoomView = &cameraDataTable[NumCamera]->viewedRoomTable[i]; unsigned char* pViewedRoomMask = g_MaskPtr + READ_LE_U32(g_MaskPtr + i*4); - for(int j=0; jnumMask; j++) + g_maskBuffers[i].reserve(pRoomView->masks.size()); + for(int j=0; jmasks.size(); j++) { + sMaskStruct* pDestMask = &g_maskBuffers[i].emplace_back(); unsigned char* pMaskData = pViewedRoomMask + READ_LE_U32(pViewedRoomMask + j*4); - maskStruct* pDestMask = &g_maskBuffers[i][j]; - pDestMask->mask.fill(0); pDestMask->x1 = READ_LE_U16(pMaskData); @@ -1426,7 +1413,7 @@ void loadMask(int cameraIdx) } } - osystem_createMask(pDestMask->mask, i, j, (unsigned char*)aux, pDestMask->x1, pDestMask->y1, pDestMask->x2, pDestMask->y2); + osystem_createMask(pDestMask->mask, i, j, pDestMask->x1, pDestMask->y1, pDestMask->x2, pDestMask->y2); } } } @@ -1436,11 +1423,11 @@ extern unsigned char* polyBackBuffer; void createAITD1Mask() { - for(int viewedRoomIdx=0; viewedRoomIdxnumViewedRooms; viewedRoomIdx++) + for(int viewedRoomIdx=0; viewedRoomIdxnumViewedRooms; viewedRoomIdx++) { - cameraViewedRoomStruct* pcameraViewedRoomData = &cameraDataTable[currentCamera]->viewedRoomTable[viewedRoomIdx]; + cameraViewedRoomStruct* pcameraViewedRoomData = &cameraDataTable[NumCamera]->viewedRoomTable[viewedRoomIdx]; - char* data2 = room_PtrCamera[currentCamera] + pcameraViewedRoomData->offsetToMask; + char* data2 = room_PtrCamera[NumCamera] + pcameraViewedRoomData->offsetToMask; char* data = data2; data+=2; @@ -1448,13 +1435,13 @@ void createAITD1Mask() for(int maskIdx=0;maskIdxmask.fill(0); - polyBackBuffer = &pDestMask->mask[0]; + polyBackBuffer = pDestMask->mask.data(); - char* src = data2 + *(u16*)(data+2); - - int numMaskZone = *(s16*)(data); + int numMaskZone = READ_LE_U16(data); + char* src = data2 + READ_LE_U16(data+2); int minX = 319; int maxX = 0; @@ -1466,12 +1453,12 @@ void createAITD1Mask() data+4, *(s16*)(data) ))*/ { - int numMaskPoly = *(s16*)src; + int numMaskPoly = READ_LE_U16(src); src += 2; for(int maskPolyIdx=0;maskPolyIdxmask, viewedRoomIdx, maskIdx, (unsigned char*)aux, minX-1, minY-1, maxX+1, maxY+1); + osystem_createMask(pDestMask->mask, viewedRoomIdx, maskIdx, minX-1, minY-1, maxX+1, maxY+1); - int numOverlay = *(s16*)(data); + int numOverlay = READ_LE_U16(data); data+=2; data+=((numOverlay*4)+1)*2; } @@ -1611,7 +1598,7 @@ void SetPosCamera(int x, int y, int z) translateZ = z; } -void setupCameraProjection(int centerX, int centerY, int x, int y, int z) +void SetProjection(int centerX, int centerY, int x, int y, int z) { cameraCenterX = centerX; cameraCenterY = centerY; @@ -1638,7 +1625,7 @@ int isInViewList(int value) } // setup visibility list -void setupCameraSub1() +void InitViewedRoomList() { u32 i; int j; @@ -1663,11 +1650,11 @@ void setupCameraSub1() } // visibility list: add room seen by the current camera - for(j=0;jnumViewedRooms;j++) + for(j=0;jnumViewedRooms;j++) { - if(!isInViewList(cameraDataTable[currentCamera]->viewedRoomTable[j].viewedRoomIdx)) + if(!isInViewList(cameraDataTable[NumCamera]->viewedRoomTable[j].viewedRoomIdx)) { - *(dataTabPos++) = (char)cameraDataTable[currentCamera]->viewedRoomTable[j].viewedRoomIdx; + *(dataTabPos++) = (char)cameraDataTable[NumCamera]->viewedRoomTable[j].viewedRoomIdx; *(dataTabPos) = -1; } } @@ -1675,7 +1662,7 @@ void setupCameraSub1() void DeleteObjet(int index) // remove actor { - tObject *actorPtr = &objectTable[index]; + tObject *actorPtr = &ListObjets[index]; if(actorPtr->indexInWorld == -2) // flow { @@ -1686,7 +1673,7 @@ void DeleteObjet(int index) // remove actor CVars[getCVarsIdx(FOG_FLAG)] = 0; } - HQ_Free_Malloc(HQ_Memory,actorPtr->FRAME); + HQ_Free_Malloc(HQ_Memory,actorPtr->frame); } else { @@ -1699,10 +1686,10 @@ void DeleteObjet(int index) // remove actor objectPtr->body = actorPtr->bodyNum; objectPtr->anim = actorPtr->ANIM; - objectPtr->frame = actorPtr->FRAME; + objectPtr->frame = actorPtr->frame; objectPtr->animType = actorPtr->animType; objectPtr->animInfo = actorPtr->animInfo; - objectPtr->flags = actorPtr->_flags & ~AF_BOXIFY; + objectPtr->flags = actorPtr->objectType & ~AF_BOXIFY; objectPtr->flags |= AF_SPECIAL * actorPtr->dynFlags; // ugly hack, need rewrite objectPtr->life = actorPtr->life; objectPtr->lifeMode = actorPtr->lifeMode; @@ -1729,7 +1716,7 @@ void DeleteObjet(int index) // remove actor objectPtr->stage = actorPtr->stage; objectPtr->room = actorPtr->room; - actorTurnedToObj = 1; + FlagGenereAffList = 1; } } } @@ -1789,129 +1776,19 @@ void pointRotate(int x, int y, int z, int* destX, int* destY, int* destZ) } } -void zvRotSub(int X, int Y, int Z, int alpha, int beta, int gamma) -{ - if( alpha || beta || gamma ) - { - setupPointRotate(alpha,beta,gamma); - pointRotate(X, Y, Z, &animMoveX,&animMoveY,&animMoveZ); - } - else - { - animMoveX = X; - animMoveY = Y; - animMoveZ = Z; - } -} - -void getZvRot(char* bodyPtr, ZVStruct* zvPtr, int alpha, int beta, int gamma) -{ - int X1 = 32000; - int Y1 = 32000; - int Z1 = 32000; - - int X2 = -32000; - int Y2 = -32000; - int Z2 = -32000; - - int i; - int tempX; - int tempY; - int tempZ; - - GiveZVObjet(bodyPtr, zvPtr); - - for(i=0;i<8;i++) - { - switch(i) - { - case 0: - { - tempX = zvPtr->ZVX1; - tempY = zvPtr->ZVY1; - tempZ = zvPtr->ZVZ1; - break; - } - case 1: - { - tempZ = zvPtr->ZVZ2; - break; - } - case 2: - { - tempX = zvPtr->ZVX2; - break; - } - case 3: - { - tempZ = zvPtr->ZVZ1; - break; - } - case 4: - { - tempY = zvPtr->ZVY2; - break; - } - case 5: - { - tempX = zvPtr->ZVX1; - break; - } - case 6: - { - tempZ = zvPtr->ZVZ2; - break; - } - case 7: - { - tempX = zvPtr->ZVX2; - break; - } - } - - zvRotSub(tempX, tempY, tempZ, alpha, beta, gamma); - - if(animMoveXX2) - X2 = animMoveX; - - if(animMoveYY2) - Y2 = animMoveY; - - if(animMoveZZ2) - Z2 = animMoveZ; - - } - - zvPtr->ZVX1 = X1; - zvPtr->ZVX2 = X2; - zvPtr->ZVY1 = Y1; - zvPtr->ZVY2 = Y2; - zvPtr->ZVZ1 = Z1; - zvPtr->ZVZ2 = Z2; -} - -void copyZv(ZVStruct* source, ZVStruct* dest) +void CopyZV(ZVStruct* source, ZVStruct* dest) { memcpy(dest,source,sizeof(ZVStruct)); } -void setupCameraSub4(void) +void RefreshAux2(void) { FastCopyScreen(aux,aux2); //TODO: implementer la suite } -void setMoveMode(int trackMode, int trackNumber) +void InitDeplacement(int trackMode, int trackNumber) { currentProcessedActorPtr->trackMode = trackMode; @@ -1933,22 +1810,22 @@ void setMoveMode(int trackMode, int trackNumber) } } -s16 cameraVisibilityVar = 0; +s16 ObjSalleRel = 0; int IsInCamera(int roomNumber) { - int numZone = cameraDataTable[currentCamera]->numViewedRooms; + int numZone = cameraDataTable[NumCamera]->numViewedRooms; for(int i=0;iviewedRoomTable[i].viewedRoomIdx == roomNumber) + if(cameraDataTable[NumCamera]->viewedRoomTable[i].viewedRoomIdx == roomNumber) { - cameraVisibilityVar = i; + ObjSalleRel = i; return(1); } } - cameraVisibilityVar = -1; + ObjSalleRel = -1; return 0; } @@ -1961,376 +1838,283 @@ int IsInCamRectTestAITD2(int X, int Z) // TODO: not 100% exact return 0; } -int updateActorAitd2Only(int actorIdx) -{ - tObject *currentActor = &objectTable[actorIdx]; - - if(g_gameId == AITD1) - { - return 0; - } - - if(currentActor->bodyNum != -1) - { - if(IsInCamera(currentActor->room)) - { - if(IsInCamRectTestAITD2(currentActor->roomX + currentActor->stepX, currentActor->roomZ + currentActor->stepZ)) - { - currentActor->lifeMode |= 4; - return 1; - } - } - } - - return 0; -} - void updateAllActorAndObjectsAITD2() { - for(int i=0;iindexInWorld == -1) - { - continue; - } - - pObject->lifeMode &= ~4; + for (int i = 0; i < NUM_MAX_OBJECT; i++) + { + tObject* pObject = &ListObjets[i]; - if(pObject->stage == g_currentFloor) - { - switch(pObject->lifeMode) - { - case 0: // OFF - break; - case 1: // STAGE - continue; - case 2: // ROOM - if(pObject->room == currentRoom) - { - continue; - } - break; - case 3: // CAMERA - if(isInViewList(pObject->room)) - { - continue; - } - break; - default: - //assert(0); - break; - } + if (pObject->indexInWorld == -1) + { + continue; + } - if(updateActorAitd2Only(i)) - { - pObject->lifeMode |= 4; - continue; - } - } - DeleteObjet(i); - } + pObject->lifeMode &= ~4; - for(int i=0;istage == g_currentFloor) + { + switch (pObject->lifeMode) + { + case 0: // OFF + break; + case 1: // STAGE + continue; + case 2: // ROOM + if (pObject->room == currentRoom) + { + continue; + } + break; + case 3: // CAMERA + if (isInViewList(pObject->room)) + { + continue; + } + break; + default: + break; + } - if(currentObject->objIndex != -1) - { - if(currentWorldTarget == i) - { - currentCameraTargetActor = currentObject->objIndex; - } - } - else - { - if(currentObject->stage == g_currentFloor) - { - if(currentObject->life != -1) - { - if(currentObject->lifeMode != -1) - { - int actorIdx; - int di; + if (pObject->bodyNum != -1) + { + if (IsInCamera(pObject->room)) + { + if (IsInCamRectTestAITD2(pObject->roomX + pObject->stepX, pObject->roomZ + pObject->stepZ)) + { + pObject->lifeMode |= 4; + continue; + } + } + } + } + DeleteObjet(i); + } - switch(currentObject->lifeMode&3) - { - case 0: - { - di = 0; - break; - } - case 1: - { - di = 1; - break; - } - case 2: - { - if(currentObject->room != currentRoom) - { - di = 0; - } - else - { - di = 1; - } - break; - } - case 3: - { - if(!isInViewList(currentObject->room)) - { - di = 0; - } - else - { - di = 1; - } - break; - } - } + for (int i = 0; i < maxObjects; i++) + { + tWorldObject* currentObject = &ListWorldObjets[i]; - if(!di) - { - if(currentObject->body != -1) - { - if(IsInCamera(currentObject->room)) - { - if(IsInCamRectTestAITD2(currentObject->x,currentObject->z)) - { - currentObject->lifeMode |= 4; - } - else - { - continue; - } - } - else - { - continue; - } - } - else - { - continue; - } - } + if (currentObject->objIndex != -1) + { + if (currentWorldTarget == i) + { + currentCameraTargetActor = currentObject->objIndex; + } + continue; + } - //int var_C = currentObject->flags & 0xFFDF; - //int var_E = currentObject->field_2; - //int var_A = currentObject->anim; -addObject: - actorIdx = copyObjectToActor( currentObject->body, currentObject->typeZV, currentObject->foundName, - currentObject->flags & 0xFFDF, - currentObject->x, currentObject->y, currentObject->z, - currentObject->stage, currentObject->room, - currentObject->alpha, currentObject->beta, currentObject->gamma, - currentObject->anim, - currentObject->frame, currentObject->animType, currentObject->animInfo); + if (currentObject->stage != g_currentFloor) + continue; - currentObject->objIndex = actorIdx; + bool isOk = false; + switch (currentObject->lifeMode & 3) + { + case 0: // OFF + isOk = false; + break; + case 1: // STAGE + isOk = true; + break; + case 3: // CAMERA + if (!isInViewList(currentObject->room)) + { + isOk = false; + } + else + { + isOk = true; + } + break; + case 2: // ROOM + if (currentObject->room != currentRoom) + { + isOk = false; + } + else + { + isOk = true; + } + break; + } - if(actorIdx != -1) - { - currentProcessedActorPtr = &objectTable[actorIdx]; - currentProcessedActorIdx = actorIdx; + if (!isOk) { + if ((currentObject->body == -1) || (!IsInCamera(currentObject->room)) || (!IsInCamRectTestAITD2(currentObject->x, currentObject->z))) + { + continue; + } + else { + currentObject->lifeMode |= 4; + } + } - if(currentWorldTarget == i) - { - currentCameraTargetActor = currentProcessedActorIdx; - } + currentObject->objIndex = InitObjet(currentObject->body, currentObject->typeZV, currentObject->foundName, + currentObject->flags & ~AF_SPECIAL, + currentObject->x, currentObject->y, currentObject->z, + currentObject->stage, currentObject->room, + currentObject->alpha, currentObject->beta, currentObject->gamma, + currentObject->anim, + currentObject->frame, currentObject->animType, currentObject->animInfo); - currentProcessedActorPtr->dynFlags = (currentObject->flags & 0x20) / 0x20; // recheck - currentProcessedActorPtr->life = currentObject->life; - currentProcessedActorPtr->lifeMode = currentObject->lifeMode; + if (currentObject->objIndex != -1) + { + currentProcessedActorPtr = &ListObjets[currentObject->objIndex]; + currentProcessedActorIdx = currentObject->objIndex; - currentProcessedActorPtr->indexInWorld = i; + if (currentWorldTarget == i) + { + currentCameraTargetActor = currentProcessedActorIdx; + } - setMoveMode(currentObject->trackMode, currentObject->trackNumber); + currentProcessedActorPtr->dynFlags = (currentObject->flags & 0x20) / 0x20; // recheck + currentProcessedActorPtr->life = currentObject->life; + currentProcessedActorPtr->lifeMode = currentObject->lifeMode; - currentProcessedActorPtr->positionInTrack = currentObject->positionInTrack; + currentProcessedActorPtr->indexInWorld = i; - if(g_gameId != AITD1) - { - currentProcessedActorPtr->MARK = currentObject->mark; - } + InitDeplacement(currentObject->trackMode, currentObject->trackNumber); - actorTurnedToObj = 1; - } - } - } - else - { - if(isInViewList(currentObject->room)) - goto addObject; - } - } - } - } + currentProcessedActorPtr->positionInTrack = currentObject->positionInTrack; - // objModifFlag1 = 0; + if (g_gameId != AITD1) + { + currentProcessedActorPtr->MARK = currentObject->mark; + } - //TODO: object update + FlagGenereAffList = 1; + } + } + //FlagGenereActiveList = true; } + -void updateAllActorAndObjects() +void GenereActiveList() { - int i; - tObject *currentActor = objectTable; - tWorldObject* currentObject; - if(g_gameId > JACK) { updateAllActorAndObjectsAITD2(); return; } - for(i=0;iindexInWorld != -1) + tObject* currentActor = &ListObjets[i]; + if (currentActor->indexInWorld == -1) + continue; + + if(currentActor->stage == g_currentFloor) { - if(currentActor->stage == g_currentFloor) + if(currentActor->life != -1) { - if(currentActor->life != -1) + switch(currentActor->lifeMode) { - switch(currentActor->lifeMode) + case 0: // STAGE + continue; + case 1: // ROOM + if(currentActor->room == currentRoom) { - case 0: - { - break; - } - case 1: - { - if(currentActor->room != currentRoom) - { - DeleteObjet(i); - } - break; - } - case 2: - { - if(!isInViewList(currentActor->room)) - { - DeleteObjet(i); - } - break; - } - default: - { - DeleteObjet(i); - break; - } + continue; } - } - else - { - if(!isInViewList(currentActor->room)) + break; + case 2: // CAMERA + if(isInViewList(currentActor->room)) + { + continue; + } + break; + default: { - DeleteObjet(i); + break; } } } else { - DeleteObjet(i); + if(isInViewList(currentActor->room)) + { + continue; + } } } - currentActor++; + DeleteObjet(i); } - currentObject = &ListWorldObjets[0]; - - for(i=0;iobjIndex != -1) - { + tWorldObject* currentObject = &ListWorldObjets[i]; + if(currentObject->objIndex != -1) { if(currentWorldTarget == i) { currentCameraTargetActor = currentObject->objIndex; } + continue; } - else - { - if(currentObject->stage == g_currentFloor) - { - if(currentObject->life != -1) - { - if(currentObject->lifeMode != -1) - { - int actorIdx; - switch(currentObject->lifeMode) - { - case 1: - { - if(currentObject->room != currentRoom) - { - currentObject++; - continue; - } - break; - } - case 2: - { - if(!isInViewList(currentObject->room)) - { - currentObject++; - continue; - } - break; - } - } + if (currentObject->stage != g_currentFloor) { + continue; + } - //int var_C = currentObject->flags & 0xFFDF; - //int var_E = currentObject->field_2; - //int var_A = currentObject->anim; + if (currentObject->life != -1) + { + switch (currentObject->lifeMode) + { + case -1: + continue; -addObject: actorIdx = copyObjectToActor( currentObject->body, currentObject->typeZV, currentObject->foundName, - currentObject->flags & 0xFFDF, - currentObject->x, currentObject->y, currentObject->z, - currentObject->stage, currentObject->room, - currentObject->alpha, currentObject->beta, currentObject->gamma, - currentObject->anim, - currentObject->frame, currentObject->animType, currentObject->animInfo); + case 0: // Stage + break; - currentObject->objIndex = actorIdx; + case 1: // Room + if (currentObject->room != currentRoom) + { + continue; + } + break; + case 2: // Camera + if (!isInViewList(currentObject->room)) + { + continue; + } + break; + } + } + else + { + if (!isInViewList(currentObject->room)) { + continue; + } + } - if(actorIdx != -1) - { - currentProcessedActorPtr = &objectTable[actorIdx]; - currentProcessedActorIdx = actorIdx; + currentObject->objIndex = InitObjet( currentObject->body, currentObject->typeZV, currentObject->foundName, + currentObject->flags & ~AF_SPECIAL, + currentObject->x, currentObject->y, currentObject->z, + currentObject->stage, currentObject->room, + currentObject->alpha, currentObject->beta, currentObject->gamma, + currentObject->anim, + currentObject->frame, currentObject->animType, currentObject->animInfo); - if(currentWorldTarget == i) - { - currentCameraTargetActor = currentProcessedActorIdx; - } + if(currentObject->objIndex != -1) + { + currentProcessedActorPtr = &ListObjets[currentObject->objIndex]; + currentProcessedActorIdx = currentObject->objIndex; - currentProcessedActorPtr->dynFlags = (currentObject->flags & 0x20) / 0x20; // recheck - currentProcessedActorPtr->life = currentObject->life; - currentProcessedActorPtr->lifeMode = currentObject->lifeMode; + if(currentWorldTarget == i) + { + currentCameraTargetActor = currentProcessedActorIdx; + } - currentProcessedActorPtr->indexInWorld = i; + currentProcessedActorPtr->dynFlags = (currentObject->flags & 0x20) / 0x20; // recheck + currentProcessedActorPtr->life = currentObject->life; + currentProcessedActorPtr->lifeMode = currentObject->lifeMode; - setMoveMode(currentObject->trackMode, currentObject->trackNumber); + currentProcessedActorPtr->indexInWorld = i; - currentProcessedActorPtr->positionInTrack = currentObject->positionInTrack; + InitDeplacement(currentObject->trackMode, currentObject->trackNumber); - actorTurnedToObj = 1; - } - } - } - else - { - if(isInViewList(currentObject->room)) - goto addObject; - } - } - } + currentProcessedActorPtr->positionInTrack = currentObject->positionInTrack; - currentObject++; + FlagGenereAffList = 1; + } } // FlagGenereActiveList = 0; @@ -2342,9 +2126,9 @@ int checkActorInRoom(int room) { int i; - for(i=0;inumViewedRooms;i++) + for(i=0;inumViewedRooms;i++) { - if(cameraDataTable[currentCamera]->viewedRoomTable[i].viewedRoomIdx == room) + if(cameraDataTable[NumCamera]->viewedRoomTable[i].viewedRoomIdx == room) { return(1); } @@ -2353,52 +2137,47 @@ int checkActorInRoom(int room) return(0); } -void createActorList() +void GenereAffList() { - int i; - tObject* actorPtr; - - numActorInList = 0; + NbAffObjets = 0; - actorPtr = objectTable; - - for(i=0;iindexInWorld != -1 && actorPtr->bodyNum != -1) { if(checkActorInRoom(actorPtr->room)) { - sortedActorTable[numActorInList] = i; - if(!(actorPtr->_flags & (AF_SPECIAL & AF_ANIMATED))) + Index[NbAffObjets] = i; + if(!(actorPtr->objectType & (AF_SPECIAL & AF_ANIMATED))) { - actorPtr->_flags |= AF_BOXIFY; + actorPtr->objectType |= AF_BOXIFY; // FlagRefreshAux2 = 1; } - numActorInList++; + NbAffObjets++; } } - - actorPtr++; } } -void setupCamera() +void InitView() { int x; int y; int z; - cameraDataStruct* pCamera; - freezeTime(); + SaveTimerAnim(); + + resetAnim2D(); - currentCamera = startGameVar1; + NumCamera = NewNumCamera; - assert(startGameVar1 < roomDataTable[currentRoom].numCameraInRoom); + assert(NewNumCamera < roomDataTable[currentRoom].numCameraInRoom); - loadCamera(roomDataTable[currentRoom].cameraIdxTable[startGameVar1]); + loadCamera(roomDataTable[currentRoom].cameraIdxTable[NewNumCamera]); if(g_gameId >= JACK) { - loadMask(roomDataTable[currentRoom].cameraIdxTable[startGameVar1]); + loadMask(roomDataTable[currentRoom].cameraIdxTable[NewNumCamera]); } else { @@ -2406,7 +2185,11 @@ void setupCamera() } cameraBackgroundChanged = true; - pCamera = cameraDataTable[currentCamera]; + if (g_gameId >= JACK) { + load2dAnims(roomDataTable[currentRoom].cameraIdxTable[NewNumCamera]); + } + + cameraDataStruct* pCamera = cameraDataTable[NumCamera]; SetAngleCamera(pCamera->alpha,pCamera->beta,pCamera->gamma); @@ -2424,29 +2207,29 @@ void setupCamera() { if(currentCameraTargetActor != -1) { - x = objectTable[currentCameraTargetActor].worldX + objectTable[currentCameraTargetActor].stepX; + x = ListObjets[currentCameraTargetActor].worldX + ListObjets[currentCameraTargetActor].stepX; y = debufferVar_topCameraZoom; - z = objectTable[currentCameraTargetActor].worldZ + objectTable[currentCameraTargetActor].stepZ; + z = ListObjets[currentCameraTargetActor].worldZ + ListObjets[currentCameraTargetActor].stepZ; } } #endif SetPosCamera(x,y,z); // setup camera position - setupCameraProjection(160,100,pCamera->focal1,pCamera->focal2,pCamera->focal3); // setup focale + SetProjection(160,100,pCamera->focal1,pCamera->focal2,pCamera->focal3); // setup projection #ifdef FITD_DEBUGGER if(debuggerVar_topCamera) - setupCameraProjection(160,100,1000,100,100); // setup focale + SetProjection(160,100,1000,100,100); #endif - setupCameraSub1(); - updateAllActorAndObjects(); - createActorList(); - // setupCameraSub3(); - setupCameraSub4(); - /* setupCameraSub5(); + InitViewedRoomList(); + GenereActiveList(); + GenereAffList(); + // TriListObjet(); + RefreshAux2(); + /* InitScreenCoors(); */ - if(flagInitView==2) + if(FlagInitView==2) { flagRedraw = 2; } @@ -2458,11 +2241,15 @@ void setupCamera() } } - flagInitView = 0; - unfreezeTime(); + FlagInitView = 0; + RestoreTimerAnim(); + + for (int i = 0; i < currentCameraZoneList[NumCamera]->hybrids.size(); i++) { + startAnim2d(i); + } } -s16 computeDistanceToPoint(int x1, int z1, int x2, int z2) +s16 GiveDistance2D(int x1, int z1, int x2, int z2) { //int axBackup = x1; x1 -= x2; @@ -2487,57 +2274,57 @@ s16 computeDistanceToPoint(int x1, int z1, int x2, int z2) } } -void InitRealValue(s16 beta, s16 newBeta, s16 param, interpolatedValue* rotatePtr) +void InitRealValue(s16 startValue, s16 endValue, s16 time, RealValue* realValue) { - rotatePtr->oldAngle = beta; - rotatePtr->newAngle = newBeta; - rotatePtr->param = param; - rotatePtr->timeOfRotate = timer; + realValue->startValue = startValue; + realValue->endValue = endValue; + realValue->numSteps = time; + realValue->memoTicks = timer; } -s16 updateActorRotation(interpolatedValue* rotatePtr) +s16 updateActorRotation(RealValue* rotatePtr) { int timeDif; int angleDif; - if(!rotatePtr->param) - return(rotatePtr->newAngle); + if(!rotatePtr->numSteps) + return(rotatePtr->endValue); - timeDif = timer - rotatePtr->timeOfRotate; + timeDif = timer - rotatePtr->memoTicks; - if(timeDif>rotatePtr->param) + if(timeDif>rotatePtr->numSteps) { - rotatePtr->param = 0; - return(rotatePtr->newAngle); + rotatePtr->numSteps = 0; + return(rotatePtr->endValue); } - angleDif = (rotatePtr->newAngle&0x3FF) - (rotatePtr->oldAngle&0x3FF); + angleDif = (rotatePtr->endValue&0x3FF) - (rotatePtr->startValue&0x3FF); if(angleDif<=0x200) { if(angleDif>=-0x200) { - int angle = (rotatePtr->newAngle&0x3FF) - (rotatePtr->oldAngle&0x3FF); - return (rotatePtr->oldAngle&0x3FF) + (angle*timeDif)/rotatePtr->param; + int angle = (rotatePtr->endValue&0x3FF) - (rotatePtr->startValue&0x3FF); + return (rotatePtr->startValue&0x3FF) + (angle*timeDif)/rotatePtr->numSteps; } else { - s16 angle = ((rotatePtr->newAngle&0x3FF)+0x400) - ((rotatePtr->oldAngle&0x3FF)); - return (((rotatePtr->oldAngle&0x3FF)) + ((angle*timeDif)/rotatePtr->param)); + s16 angle = ((rotatePtr->endValue&0x3FF)+0x400) - ((rotatePtr->startValue&0x3FF)); + return (((rotatePtr->startValue&0x3FF)) + ((angle*timeDif)/rotatePtr->numSteps)); } } else { - int angle = (rotatePtr->newAngle&0x3FF) - ((rotatePtr->oldAngle&0x3FF)+0x400); - return ((angle*timeDif)/rotatePtr->param) + ((rotatePtr->oldAngle&0x3FF)); + int angle = (rotatePtr->endValue&0x3FF) - ((rotatePtr->startValue&0x3FF)+0x400); + return ((angle*timeDif)/rotatePtr->numSteps) + ((rotatePtr->startValue&0x3FF)); } } void removeFromBGIncrust(int actorIdx) { - tObject* actorPtr = &objectTable[actorIdx]; + tObject* actorPtr = &ListObjets[actorIdx]; - actorPtr->_flags &= ~AF_BOXIFY; + actorPtr->objectType &= ~AF_BOXIFY; // FlagRefreshAux2 = 1; @@ -2579,7 +2366,7 @@ void DeleteInventoryObjet(int objIdx) numObjInInventoryTable[currentInventory]--; } - ListWorldObjets[objIdx].flags2 &= 0x7FFF; + ListWorldObjets[objIdx].foundFlag &= 0x7FFF; } void deleteObject(int objIdx) @@ -2593,14 +2380,14 @@ void deleteObject(int objIdx) if(actorIdx != -1) { - actorPtr = &objectTable[actorIdx]; + actorPtr = &ListObjets[actorIdx]; actorPtr->room = -1; actorPtr->stage = -1; // FlagGenereActiveList = 1; - if(actorPtr->_flags & AF_BOXIFY) + if(actorPtr->objectType & AF_BOXIFY) { removeFromBGIncrust(actorIdx); } @@ -2661,45 +2448,42 @@ void drawProjectedLine(s32 x1s, s32 y1s, s32 z1s, s32 x2s, s32 y2s, s32 z2s,int #endif } +void drawZv(const ZVStruct& localZv) { + // bottom + drawProjectedLine(localZv.ZVX1, localZv.ZVY2, localZv.ZVZ1, localZv.ZVX1, localZv.ZVY2, localZv.ZVZ2, 10); + drawProjectedLine(localZv.ZVX1, localZv.ZVY2, localZv.ZVZ2, localZv.ZVX2, localZv.ZVY2, localZv.ZVZ2, 10); + drawProjectedLine(localZv.ZVX2, localZv.ZVY2, localZv.ZVZ2, localZv.ZVX2, localZv.ZVY2, localZv.ZVZ1, 10); + drawProjectedLine(localZv.ZVX2, localZv.ZVY2, localZv.ZVZ1, localZv.ZVX1, localZv.ZVY2, localZv.ZVZ1, 10); + + // top + drawProjectedLine(localZv.ZVX1, localZv.ZVY1, localZv.ZVZ1, localZv.ZVX1, localZv.ZVY1, localZv.ZVZ2, 10); + drawProjectedLine(localZv.ZVX1, localZv.ZVY1, localZv.ZVZ2, localZv.ZVX2, localZv.ZVY1, localZv.ZVZ2, 10); + drawProjectedLine(localZv.ZVX2, localZv.ZVY1, localZv.ZVZ2, localZv.ZVX2, localZv.ZVY1, localZv.ZVZ1, 10); + drawProjectedLine(localZv.ZVX2, localZv.ZVY1, localZv.ZVZ1, localZv.ZVX1, localZv.ZVY1, localZv.ZVZ1, 10); + + drawProjectedLine(localZv.ZVX1, localZv.ZVY2, localZv.ZVZ1, localZv.ZVX1, localZv.ZVY1, localZv.ZVZ1, 10); + drawProjectedLine(localZv.ZVX1, localZv.ZVY2, localZv.ZVZ2, localZv.ZVX1, localZv.ZVY1, localZv.ZVZ2, 10); + drawProjectedLine(localZv.ZVX2, localZv.ZVY2, localZv.ZVZ2, localZv.ZVX2, localZv.ZVY1, localZv.ZVZ2, 10); + drawProjectedLine(localZv.ZVX2, localZv.ZVY2, localZv.ZVZ1, localZv.ZVX2, localZv.ZVY1, localZv.ZVZ1, 10); +} + void drawZv(tObject* actorPtr) { ZVStruct localZv; - if( actorPtr->room != objectTable[currentCameraTargetActor].room ) + if( actorPtr->room != ListObjets[currentCameraTargetActor].room ) { - getZvRelativePosition(&localZv, actorPtr->room, objectTable[currentCameraTargetActor].room); + if (ListObjets[currentCameraTargetActor].room == -1) { + return; + } + AdjustZV(&localZv, actorPtr->room, ListObjets[currentCameraTargetActor].room); } else { - copyZv(&actorPtr->zv,&localZv); + CopyZV(&actorPtr->zv,&localZv); } - - // bottom - drawProjectedLine( localZv.ZVX1, - localZv.ZVY2, - localZv.ZVZ1, - localZv.ZVX1, - localZv.ZVY2, - localZv.ZVZ2, - 10); - - drawProjectedLine(localZv.ZVX1,localZv.ZVY2,localZv.ZVZ2,localZv.ZVX2,localZv.ZVY2,localZv.ZVZ2,10); - drawProjectedLine(localZv.ZVX2,localZv.ZVY2,localZv.ZVZ2,localZv.ZVX2,localZv.ZVY2,localZv.ZVZ1,10); - drawProjectedLine(localZv.ZVX2,localZv.ZVY2,localZv.ZVZ1,localZv.ZVX1,localZv.ZVY2,localZv.ZVZ1,10); - - // top - drawProjectedLine(localZv.ZVX1,localZv.ZVY1,localZv.ZVZ1,localZv.ZVX1,localZv.ZVY1,localZv.ZVZ2,10); - drawProjectedLine(localZv.ZVX1,localZv.ZVY1,localZv.ZVZ2,localZv.ZVX2,localZv.ZVY1,localZv.ZVZ2,10); - drawProjectedLine(localZv.ZVX2,localZv.ZVY1,localZv.ZVZ2,localZv.ZVX2,localZv.ZVY1,localZv.ZVZ1,10); - drawProjectedLine(localZv.ZVX2,localZv.ZVY1,localZv.ZVZ1,localZv.ZVX1,localZv.ZVY1,localZv.ZVZ1,10); - - drawProjectedLine( localZv.ZVX1,localZv.ZVY2,localZv.ZVZ1, localZv.ZVX1,localZv.ZVY1,localZv.ZVZ1,10); - drawProjectedLine( localZv.ZVX1,localZv.ZVY2,localZv.ZVZ2, localZv.ZVX1,localZv.ZVY1,localZv.ZVZ2,10); - drawProjectedLine( localZv.ZVX2,localZv.ZVY2,localZv.ZVZ2, localZv.ZVX2,localZv.ZVY1,localZv.ZVZ2,10); - drawProjectedLine( localZv.ZVX2,localZv.ZVY2,localZv.ZVZ1, localZv.ZVX2,localZv.ZVY1,localZv.ZVZ1,10); - - + drawZv(localZv); } void drawConverZone(cameraZoneEntryStruct* zonePtr) @@ -2729,7 +2513,7 @@ void drawConverZones() if(cameraDataTable[i]->viewedRoomTable[j].viewedRoomIdx == currentRoom) { - for(k=0;kviewedRoomTable[j].numCoverZones;k++) + for(k=0;kviewedRoomTable[j].coverZones.size();k++) { drawConverZone(&cameraDataTable[i]->viewedRoomTable[j].coverZones[k]); } @@ -2750,14 +2534,14 @@ void drawMaskZone(cameraMaskStruct* maskZonePtr) { for(int i=0; inumTestRect; i++) { - drawAAQuad(maskZonePtr->rectTests->zoneX1*10, maskZonePtr->rectTests->zoneX2*10, maskZonePtr->rectTests->zoneZ1*10, maskZonePtr->rectTests->zoneZ2*10); + drawAAQuad(maskZonePtr->rectTests[i].zoneX1*10, maskZonePtr->rectTests[i].zoneX2*10, maskZonePtr->rectTests[i].zoneZ1*10, maskZonePtr->rectTests[i].zoneZ2*10); } } void drawMaskZones() { { - cameraDataStruct* pCamera = cameraDataTable[currentCamera]; + cameraDataStruct* pCamera = cameraDataTable[NumCamera]; for(int j=0;jnumViewedRooms;j++) { @@ -2765,7 +2549,7 @@ void drawMaskZones() //if(cameraDataTable[i]->viewedRoomTable[j].viewedRoomIdx == currentDisplayedRoom) { - for(k=0;kviewedRoomTable[j].numMask;k++) + for(k=0;kviewedRoomTable[j].masks.size();k++) { drawMaskZone(&pCamera->viewedRoomTable[j].masks[k]); } @@ -2860,7 +2644,7 @@ void drawRoomZv(ZVStruct* zoneData, int color, int transparency) cameraZv.ZVZ1 += translateZ; cameraZv.ZVZ2 += translateZ; - if(checkZvCollision(&cameraZv,zoneData)) + if(CubeIntersect(&cameraZv,zoneData)) { return; } @@ -2881,7 +2665,7 @@ void drawRoomZvLine(ZVStruct* zoneData, int color) cameraZv.ZVZ1 += translateZ; cameraZv.ZVZ2 += translateZ; - if(checkZvCollision(&cameraZv,zoneData)) + if(CubeIntersect(&cameraZv,zoneData)) { return; } @@ -2944,7 +2728,7 @@ void drawZone(char* zoneData,int color) tempZv.ZVZ1 = READ_LE_S16(zoneData+0x08); tempZv.ZVZ2 = READ_LE_S16(zoneData+0x0A); - if(checkZvCollision(&cameraZv,&tempZv)) + if(CubeIntersect(&cameraZv,&tempZv)) { return; } @@ -2984,7 +2768,7 @@ void drawSceZone(int roomNumber) memcpy(&dataLocal,&roomDataTable[roomNumber].sceZoneTable[i].zv,sizeof(ZVStruct)); if(roomNumber!=currentRoom) { - getZvRelativePosition(&dataLocal,roomNumber,currentRoom); + AdjustZV(&dataLocal,roomNumber,currentRoom); } // if(roomDataTable[roomNumber].sceZoneTable[i].parameter == 4) @@ -3004,11 +2788,11 @@ void drawHardCol(int roomNumber) /*if(roomDataTable[roomNumber].hardColTable[i].type != 9) continue;*/ - copyZv(&roomDataTable[roomNumber].hardColTable[i].zv,&dataLocal); + CopyZV(&roomDataTable[roomNumber].hardColTable[i].zv,&dataLocal); if(roomNumber!=currentRoom) { - getZvRelativePosition(&dataLocal,roomNumber,currentRoom); + AdjustZV(&dataLocal,roomNumber,currentRoom); } switch(roomDataTable[roomNumber].hardColTable[i].type) @@ -3086,7 +2870,7 @@ void drawBgOverlay(tObject* actorPtr) SetClip(BBox3D1, BBox3D2, BBox3D3, BBox3D4); - cameraDataStruct* pCamera = cameraDataTable[currentCamera]; + cameraDataStruct* pCamera = cameraDataTable[NumCamera]; // look for the correct room data of that camera cameraViewedRoomStruct* pcameraViewedRoomData = NULL; @@ -3105,7 +2889,7 @@ void drawBgOverlay(tObject* actorPtr) if(g_gameId == AITD1) { - data2 = room_PtrCamera[currentCamera] + pcameraViewedRoomData->offsetToMask; + data2 = room_PtrCamera[NumCamera] + pcameraViewedRoomData->offsetToMask; data = data2; data+=2; @@ -3153,7 +2937,7 @@ void drawBgOverlay(tObject* actorPtr) } else { - for(int i=0;inumMask;i++) + for(int i=0;imasks.size();i++) { cameraMaskStruct* pMaskZones = &pcameraViewedRoomData->masks[i]; @@ -3180,7 +2964,7 @@ void drawBgOverlay(tObject* actorPtr) SetClip(0,0,319,199); } -void mainDrawSub2(int actorIdx) // draw flow +void AffSpecialObjet(int actorIdx) // draw flow { //actorStruct* actorPtr = &actorTable[actorIdx]; @@ -3189,74 +2973,30 @@ void mainDrawSub2(int actorIdx) // draw flow // TODO: finish } -void getHotPoint(int hotPointIdx, char* bodyPtr, point3dStruct* hotPoint) +void getHotPoint(int hotPointIdx, sBody* bodyPtr, point3dStruct* hotPoint) { - s16 flag; - - flag = *(s16*)bodyPtr; - bodyPtr += 2; + hotPoint->x = 0; + hotPoint->y = 0; + hotPoint->z = 0; - if(flag&2) + if(bodyPtr->m_flags &2) { - s16 offset; - bodyPtr += 12; + ASSERT(hotPointIdx < bodyPtr->m_groups.size()); - offset = *(s16*)bodyPtr; - bodyPtr+=2; - bodyPtr+=offset; - - offset = *(s16*)bodyPtr; // num points - bodyPtr+=2; - bodyPtr+=offset*6; // skip point buffer - - offset = *(s16*)bodyPtr; // num bones - bodyPtr+=2; - bodyPtr+=offset*2; // skip bone buffer - - ASSERT(hotPointIdx < offset); - - if(hotPointIdx < offset) + if(hotPointIdx < bodyPtr->m_groups.size()) { - int pointIdx; - s16* source; - - if(flag&INFO_OPTIMISE) - { - bodyPtr+=hotPointIdx*0x18; - } - else - { - bodyPtr+=hotPointIdx*16; - } + auto& group = bodyPtr->m_groups[hotPointIdx]; - pointIdx = *(s16*)(bodyPtr+4); // first point - - //ASSERT(pointIdx > 0 && pointIdx < 1200); - - source = (s16*)(((char*)pointBuffer) + pointIdx); - - hotPoint->x = source[0]; - hotPoint->y = source[1]; - hotPoint->z = source[2]; - } - else - { - hotPoint->x = 0; - hotPoint->y = 0; - hotPoint->z = 0; + int pointIdx = group.m_baseVertices; // first point + *hotPoint = pointBuffer[pointIdx]; } } - else - { - hotPoint->x = 0; - hotPoint->y = 0; - hotPoint->z = 0; - } } -void mainDraw(int flagFlip) +void AllRedraw(int flagFlip) { - int i; + uiLayer.fill(0); + //if(flagFlip == 2) { if(cameraBackgroundChanged) @@ -3268,126 +3008,143 @@ void mainDraw(int flagFlip) if(flagFlip== 0) { - //restoreDirtyRects(); + //ClsAuxLog(); } else { - genVar5 = 0; + NbPhysBoxs = 0; FastCopyScreen(aux2,logicalScreen); } - //osystem_drawBackground(); - SetClip(0,0,319,199); - genVar6 = 0; + NbLogBoxs = 0; -#ifdef FITD_DEBUGGER - if(backgroundMode == backgroundModeEnum_3D) + for(int i=0;iid, 0, 0, PtrAnim2D); + // TODO: Clipping stuff + osystem_CopyBlockPhys((unsigned char*)logicalScreen, 0, 0, 320, 200); + } + else { + tObject* actorPtr = &ListObjets[currentDrawActor]; - osystem_startModelRender(); + // this is commented out to draw actors backed into the background + //if(actorPtr->_flags & (AF_ANIMATED + AF_DRAWABLE + AF_SPECIAL)) + { + actorPtr->objectType &= ~AF_DRAWABLE; - for(i=0;iobjectType & AF_SPECIAL) + { + AffSpecialObjet(currentDrawActor); + } + else + { + if (actorPtr->objectType & AF_OBJ_2D) { + sHybrid* pHybrid = HQR_Get(HQ_Hybrides, actorPtr->ANIM); + s16 numHybrid = pHybrid->animations[actorPtr->bodyNum].anims[actorPtr->frame].id; + AffHyb(numHybrid, 0, 0, pHybrid); - actorPtr = &objectTable[currentDrawActor]; + // TODO: bounding volume + } + else + { + sBody* bodyPtr = HQR_Get(HQ_Bodys, actorPtr->bodyNum); - // this is commented out to draw actors incrusted in background - //if(actorPtr->_flags & (AF_ANIMATED + AF_DRAWABLE + AF_SPECIAL)) - { - actorPtr->_flags &= ~AF_DRAWABLE; + if (HQ_Load) + { + // initAnimInBody(actorPtr->FRAME, HQR_Get(listAnim, actorPtr->ANIM), bodyPtr); + } - if(actorPtr->_flags & AF_SPECIAL) - { - mainDrawSub2(currentDrawActor); - } - else - { - char* bodyPtr = HQR_Get(listBody,actorPtr->bodyNum); + AffObjet(actorPtr->worldX + actorPtr->stepX, actorPtr->worldY + actorPtr->stepY, actorPtr->worldZ + actorPtr->stepZ, actorPtr->alpha, actorPtr->beta, actorPtr->gamma, bodyPtr); - if(HQ_Load) - { - // initAnimInBody(actorPtr->FRAME, HQR_Get(listAnim, actorPtr->ANIM), bodyPtr); - } - AffObjet(actorPtr->worldX + actorPtr->stepX, actorPtr->worldY + actorPtr->stepY, actorPtr->worldZ + actorPtr->stepZ, actorPtr->alpha, actorPtr->beta, actorPtr->gamma, bodyPtr); + if (actorPtr->animActionType != 0) + { + if (actorPtr->hotPointID != -1) + { + getHotPoint(actorPtr->hotPointID, bodyPtr, &actorPtr->hotPoint); + } + } + } + } + if (BBox3D1 < 0) + BBox3D1 = 0; + if (BBox3D3 > 319) + BBox3D3 = 319; + if (BBox3D2 < 0) + BBox3D2 = 0; + if (BBox3D4 > 199) + BBox3D4 = 199; - if(actorPtr->animActionType != 0) - { - if(actorPtr->hotPointID != -1) - { - getHotPoint(actorPtr->hotPointID, bodyPtr, &actorPtr->hotPoint); - } - } + if (BBox3D1 <= 319 && BBox3D2 <= 199 && BBox3D3 >= 0 && BBox3D4 >= 0) // is the character on screen ? + { + if (g_gameId == AITD1) + { + if (actorPtr->indexInWorld == CVars[getCVarsIdx(LIGHT_OBJECT)]) + { + lightX = (BBox3D3 + BBox3D1) / 2; + lightY = (BBox3D4 + BBox3D2) / 2; + } + } - ///////////////////////////////////// DEBUG #ifdef FITD_DEBUGGER - // if(debuggerVar_drawModelZv) - { - if(backgroundMode == backgroundModeEnum_3D) - { - drawZv(actorPtr); - } - } + if (backgroundMode == backgroundModeEnum_2D) #endif - ///////////////////////////////////// - } + { + //if(g_gameId == AITD1) + drawBgOverlay(actorPtr); + } + //addToRedrawBox(); + } + else + { + actorPtr->screenYMax = -1; + actorPtr->screenXMax = -1; + actorPtr->screenYMin = -1; + actorPtr->screenXMin = -1; + } + } + } + } - if(BBox3D1 < 0) - BBox3D1 = 0; - if(BBox3D3 > 319) - BBox3D3 = 319; - if(BBox3D2 < 0) - BBox3D2 = 0; - if(BBox3D4 > 199) - BBox3D4 = 199; +#ifdef FITD_DEBUGGER + { + if (backgroundMode == backgroundModeEnum_3D) + { + for (int i = 0; i < NUM_MAX_OBJECT; i++) + { + tObject* actorPtr = &ListObjets[i]; - if(BBox3D1<=319 && BBox3D2<=199 && BBox3D3>=0 && BBox3D4>=0) // is the character on screen ? - { - if(g_gameId == AITD1) - { - if(actorPtr->indexInWorld == CVars[getCVarsIdx(LIGHT_OBJECT)]) - { - lightX = (BBox3D3 + BBox3D1) / 2; - lightY = (BBox3D4 + BBox3D2) / 2; - } - } + if (actorPtr->indexInWorld != -1) + { + drawZv(actorPtr); + } + } + } -#ifdef FITD_DEBUGGER - if(backgroundMode == backgroundModeEnum_2D) -#endif - { - //if(g_gameId == AITD1) - drawBgOverlay(actorPtr); - } - //addToRedrawBox(); - } - else - { - actorPtr->screenYMax = -1; - actorPtr->screenXMax = -1; - actorPtr->screenYMin = -1; - actorPtr->screenXMin = -1; - } - } - } + ///////////////////////////////////// + for (int i = 0; i < getNumberOfRoom(); i++) + { + if (hardColDisplayMode != displayNone) { + drawHardCol(i); + } - osystem_stopModelRender(); + if (sceColDisplayMode != displayNone) { + drawSceZone(i); + } + } + + //drawConverZones(); + //drawMaskZones(); + } +#endif if(drawTextOverlay()) { @@ -3433,13 +3190,13 @@ void walkStep(int angle1, int angle2, int angle3) void addActorToBgInscrust(int actorIdx) { - objectTable[actorIdx]._flags |= AF_BOXIFY + AF_DRAWABLE; - objectTable[actorIdx]._flags &= ~AF_ANIMATED; + ListObjets[actorIdx].objectType |= AF_BOXIFY + AF_DRAWABLE; + ListObjets[actorIdx].objectType &= ~AF_ANIMATED; //FlagRefreshAux2 = 1; } -int checkZvCollision(ZVStruct* zvPtr1,ZVStruct* zvPtr2) +int CubeIntersect(ZVStruct* zvPtr1,ZVStruct* zvPtr2) { if(zvPtr1->ZVX1 >= zvPtr2->ZVX2) return 0; @@ -3462,7 +3219,7 @@ int checkZvCollision(ZVStruct* zvPtr1,ZVStruct* zvPtr2) return 1; } -void getZvRelativePosition(ZVStruct* zvPtr, int startRoom, int destRoom) +void AdjustZV(ZVStruct* zvPtr, int startRoom, int destRoom) { unsigned int Xdif = 10*(roomDataTable[destRoom].worldX - roomDataTable[startRoom].worldX); unsigned int Ydif = 10*(roomDataTable[destRoom].worldY - roomDataTable[startRoom].worldY); @@ -3476,11 +3233,11 @@ void getZvRelativePosition(ZVStruct* zvPtr, int startRoom, int destRoom) zvPtr->ZVZ2 += Zdif; } -int checkObjectCollisions(int actorIdx, ZVStruct* zvPtr) +int CheckObjectCol(int actorIdx, ZVStruct* zvPtr) { int currentCollisionSlot = 0; - tObject* currentActor = objectTable; - int actorRoom = objectTable[actorIdx].room; + + int actorRoom = ListObjets[actorIdx].room; for(int i=0;i<3;i++) { @@ -3489,86 +3246,44 @@ int checkObjectCollisions(int actorIdx, ZVStruct* zvPtr) for(int i=0;iindexInWorld != -1 && i!=actorIdx) - { - ZVStruct* currentActorZv = ¤tActor->zv; + tObject* currentActor = &ListObjets.at(i); - if(currentActor->room != actorRoom) - { - ZVStruct localZv; + if (currentActor->indexInWorld == -1) + continue; + if (i == actorIdx) + continue; - copyZv(zvPtr,&localZv); + ZVStruct* currentActorZv = ¤tActor->zv; - getZvRelativePosition(&localZv,actorRoom,currentActor->room); + if (currentActor->room != actorRoom) + { + ZVStruct localZv; - if(checkZvCollision(&localZv,currentActorZv)) - { - currentProcessedActorPtr->COL[currentCollisionSlot++] = i; + CopyZV(zvPtr, &localZv); - if(currentCollisionSlot == 3) - return(3); - } - } - else - { - if(checkZvCollision(zvPtr,currentActorZv)) - { - currentProcessedActorPtr->COL[currentCollisionSlot++] = i; + AdjustZV(&localZv, actorRoom, currentActor->room); - if(currentCollisionSlot == 3) - return(3); - } - } - } - currentActor++; - } + if (CubeIntersect(&localZv, currentActorZv)) + { + currentProcessedActorPtr->COL[currentCollisionSlot++] = i; - return(currentCollisionSlot); -} + if (currentCollisionSlot == 3) + return(3); + } + } + else + { + if (CubeIntersect(zvPtr, currentActorZv)) + { + currentProcessedActorPtr->COL[currentCollisionSlot++] = i; -void cleanClip() -{ - for(int x=clipLeft; xobjIndex); } - objPtr->flags2 &= 0xBFFF; - objPtr->flags2 |= 0x8000; + objPtr->foundFlag &= 0xBFFF; + objPtr->foundFlag |= 0x8000; objPtr->room = -1; objPtr->stage = -1; } -void foundObject(int objIdx, int param) -{ - tWorldObject* objPtr; - int var_C = 0; - int var_6 = 1; - int i; - int var_A = 15000; - int var_8 = -200; - - if(objIdx < 0) - return; - - if(param == 2) - { - printf("foundObject with param == 2\n"); - } - - objPtr = &ListWorldObjets[objIdx]; - - if( param != 0 && (objPtr->flags2 & 0xC000)) - { - return; - } - - if(objPtr->trackNumber) - { - if(timer - objPtr->trackNumber < 300) // prevent from reopening the window every frame - return; - } - - objPtr->trackNumber = 0; - - freezeTime(); - // setupShaking(1000); // probably to remove the shaking when in foundObject screen - - int weight = 0; - for(i=0;ipositionInTrack + weight > CVars[getCVarsIdx(MAX_WEIGHT_LOADABLE)] || numObjInInventoryTable[currentInventory] +1 == 30) - { - var_6 = 3; - } - - currentFoundBodyIdx = objPtr->foundBody; - currentFoundBody = HQR_Get(listBody,currentFoundBodyIdx); - - setupCameraProjection(160,100,128,300,298); - - statusVar1 = 0; - - memset(frontBuffer, 0, 320*200); - FastCopyScreen(frontBuffer,logicalScreen); - - AffBigCadre(160,100,240,120); - - drawFoundObect(var_6, objPtr->foundName, var_A); - osystem_flip(NULL); - - input5 = 1; - - while(!var_C) - { - osystem_CopyBlockPhys((unsigned char*)logicalScreen,0,0,320,200); - - process_events(); - osystem_drawBackground(); - - localKey = key; - localJoyD = JoyD; - localClick = Click; - - if(!input5) - { - if(localKey == 1) - { - if(var_6 != 2) - { - var_6 = 0; - } - - var_C = 1; - } - if(var_6 != 2) - { - if(localJoyD&4) - { - var_6 = 0; - } - - if(localJoyD&8) - { - var_6 = 1; - } - } - - if(localKey == 28 || localClick !=0) - { - while(key) - { - process_events(); - } - - var_C = 1; - } - } - else - { - if(!localKey && !localJoyD && !localClick) - input5 = 0; - } - - statusVar1 -= 8; - - var_A += var_8; // zoom / dezoom - - if(var_A> 8000) // zoom management - var_8 = -var_8; - - if(var_A< 25000) - var_8 = -var_8; - - drawFoundObect(var_6,objPtr->foundName,var_A); - - // menuWaitVSync(); - } - - unfreezeTime(); - - if(var_6 == 1) - { - take(objIdx); - } - else - { - objPtr->trackNumber = timer; - } - - while(key && Click) - { - process_events(); - } - - localJoyD = 0; - localKey = 0; - localClick = 0; - - // if(mainLoopVar1 != 0) - { - //setupShaking(-600); - } - - flagInitView = 1; -} - -void hardColSuB1Sub1(int flag) +void Glisser(int flag) { switch(flag) { @@ -3789,48 +3347,54 @@ void hardColSuB1Sub1(int flag) } } -void handleCollision(ZVStruct* startZv, ZVStruct* zvPtr2, ZVStruct* zvPtr3) +void GereCollision(ZVStruct* oldZv, ZVStruct* animatedZv, ZVStruct* fixZv) { - s32 flag = 0; - s32 var_8; + s32 oldpos = 0; + s32 oldtype; s32 halfX; s32 halfZ; - s32 var_A; - s32 var_6; + s32 pos; + s32 type; - if(startZv->ZVX2 > zvPtr3->ZVX1) + if(oldZv->ZVX2 > fixZv->ZVX1) { - if(zvPtr3->ZVX2 <= startZv->ZVX1) + if(fixZv->ZVX2 <= oldZv->ZVX1) { - flag = 8; + oldpos = 8; // right } + else { + oldpos = 0; // center + } } else { - flag = 4; + oldpos = 4; // left } - if(startZv->ZVZ2 > zvPtr3->ZVZ1) + if(oldZv->ZVZ2 > fixZv->ZVZ1) { - if(startZv->ZVZ1 >= zvPtr3->ZVZ2) + if(oldZv->ZVZ1 >= fixZv->ZVZ2) { - flag |= 2; + oldpos |= 2; } + else { + oldpos |= 0; // center + } } else { - flag |= 1; + oldpos |= 1; } - if( flag == 5 || flag == 9 || flag == 6 || flag == 10 ) + if( (oldpos == 5) || (oldpos == 9) || (oldpos == 6) || (oldpos == 10) ) { - var_8 = 2; + oldtype = 2; // corner } else { - if(!flag) + if(oldpos == 0) { - var_8 = 0; + oldtype = 0; hardColStepZ = 0; hardColStepX = 0; @@ -3839,106 +3403,107 @@ void handleCollision(ZVStruct* startZv, ZVStruct* zvPtr2, ZVStruct* zvPtr3) } else { - var_8 = 1; + oldtype = 1; // corner } } - halfX = (zvPtr2->ZVX1 + zvPtr2->ZVX2) / 2; - halfZ = (zvPtr2->ZVZ1 + zvPtr2->ZVZ2) / 2; + halfX = (animatedZv->ZVX1 + animatedZv->ZVX2) / 2; + halfZ = (animatedZv->ZVZ1 + animatedZv->ZVZ2) / 2; - if(zvPtr3->ZVX1 > halfX) + if(fixZv->ZVX1 > halfX) { - var_A = 4; + pos = 4; // left } else { - if(zvPtr3->ZVX2 < halfX) + if(fixZv->ZVX2 < halfX) { - var_A = 0; + pos = 0; // center } else { - var_A = 8; + pos = 8; // right } } - if(zvPtr3->ZVZ1 > halfZ) + if(fixZv->ZVZ1 > halfZ) { - var_A |= 1; + pos |= 1; // up } else { - if(zvPtr3->ZVZ2 < halfZ) + if(fixZv->ZVZ2 < halfZ) { - var_A |= 0; // once again, not that much usefull + pos |= 0; // center } else { - var_A |= 2; + pos |= 2; // bellow } } - if( var_A == 5 || var_A == 9 || var_A == 6 || var_A == 10 ) + if( (pos == 5) || (pos == 9) || (pos == 6) || (pos == 10) ) { - var_6 = 2; + type = 2; // corner } else { - if(!var_A) + if(pos == 0) { - var_6 = 0; + type = 0; // center } else { - var_6 = 1; + type = 1; // border } } - if(var_8 == 1) - { - hardColSuB1Sub1(flag); - return; - } - - if(var_6 == 1 && (var_A & flag)) + if(oldtype == 1) // border { - hardColSuB1Sub1(var_A); - return; + Glisser(oldpos); } + else + { + if ((type == 1) && (pos & oldpos)) + { + Glisser(pos); + } + else { + if ((pos == oldpos) || (pos+oldpos == 15)) + { + int Xmod = abs(animatedZv->ZVX1 - oldZv->ZVX1); // recheck + int Zmod = abs(animatedZv->ZVZ1 - oldZv->ZVZ1); - if(var_A == flag || flag == 15) - { - int Xmod = abs(zvPtr2->ZVX1 - startZv->ZVX1); // recheck - int Zmod = abs(zvPtr2->ZVZ1 - startZv->ZVZ1); - - if(Xmod > Zmod) - { - hardColStepZ = 0; - } - else - { - hardColStepX = 0; - } - } - else - { - if(!var_6 || (var_6 == 1 && !(var_A & flag))) - { - hardColStepZ = 0; - hardColStepX = 0; - } - else - { - hardColSuB1Sub1(flag&var_A); - } - } + if (Xmod > Zmod) + { + hardColStepZ = 0; + } + else + { + hardColStepX = 0; + } + } + else + { + if ((type == 0) || ((type == 1) && ((pos & oldpos) == 0))) + { + hardColStepZ = 0; + hardColStepX = 0; + } + else + { + Glisser(oldpos & pos); + } + } + } + } } int AsmCheckListCol(ZVStruct* zvPtr, roomDataStruct* pRoomData) { u16 i; int hardColVar = 0; - hardColStruct* pCurrentEntry = pRoomData->hardColTable; + hardColStruct* pCurrentEntry = pRoomData->hardColTable.data(); #ifdef FITD_DEBUGGER if(debuggerVar_noHardClip) @@ -4010,7 +3575,7 @@ int isInPoly(int x1, int x2, int z1, int z2, cameraViewedRoomStruct* pCameraZone int i; - for(i=0;inumCoverZones;i++) + for(i=0;icoverZones.size();i++) { int j; int flag = 0; @@ -4052,7 +3617,7 @@ int findBestCamera(void) int foundAngle = 32000; int foundCamera = -1; - tObject* actorPtr = &objectTable[currentCameraTargetActor]; + tObject* actorPtr = &ListObjets[currentCameraTargetActor]; int x1 = actorPtr->zv.ZVX1/10; int x2 = actorPtr->zv.ZVX2/10; @@ -4086,20 +3651,26 @@ int findBestCamera(void) return(foundCamera); } -void checkIfCameraChangeIsRequired(void) +void GereSwitchCamera(void) { - int localCurrentCam = currentCamera; + int localCurrentCam = NumCamera; int newCamera; - if(currentCamera!=-1) + if(NumCamera!=-1) { + if (currentCameraTargetActor == -1) + { + // TODO: Happens at the start of AITD3, likely a bug + return; + } + tObject* actorPtr; int zvx1; int zvx2; int zvz1; int zvz2; - actorPtr = &objectTable[currentCameraTargetActor]; + actorPtr = &ListObjets[currentCameraTargetActor]; zvx1 = actorPtr->zv.ZVX1/10; zvx2 = actorPtr->zv.ZVX2/10; @@ -4107,7 +3678,7 @@ void checkIfCameraChangeIsRequired(void) zvz1 = actorPtr->zv.ZVZ1/10; zvz2 = actorPtr->zv.ZVZ2/10; - if(isInPoly(zvx1,zvx2,zvz1,zvz2,currentCameraZoneList[currentCamera])) // is still in current camera zone ? + if(isInPoly(zvx1,zvx2,zvz1,zvz2,currentCameraZoneList[NumCamera])) // is still in current camera zone ? { return; } @@ -4124,10 +3695,10 @@ void checkIfCameraChangeIsRequired(void) localCurrentCam = newCamera; } - if(currentCamera != localCurrentCam) + if(NumCamera != localCurrentCam) { - startGameVar1 = localCurrentCam; - flagInitView = 1; + NewNumCamera = localCurrentCam; + FlagInitView = 1; } #ifdef FITD_DEBUGGER @@ -4159,7 +3730,7 @@ sceZoneStruct* processActor2Sub(int x, int y, int z, roomDataStruct* pRoomData) u32 i; sceZoneStruct* pCurrentZone; - pCurrentZone = pRoomData->sceZoneTable; + pCurrentZone = pRoomData->sceZoneTable.data(); for(i=0;inumSceZone;i++) { @@ -4181,7 +3752,7 @@ sceZoneStruct* processActor2Sub(int x, int y, int z, roomDataStruct* pRoomData) } -void processActor2() +void GereDec() { bool onceMore = false; bool flagFloorChange = false; @@ -4204,17 +3775,13 @@ void processActor2() { case 0: { - int x; - int y; - int z; - int oldRoom = currentProcessedActorPtr->room; currentProcessedActorPtr->room = (short)pCurrentZone->parameter; - x = (roomDataTable[currentProcessedActorPtr->room].worldX - roomDataTable[oldRoom].worldX) * 10; - y = (roomDataTable[currentProcessedActorPtr->room].worldY - roomDataTable[oldRoom].worldY) * 10; - z = (roomDataTable[currentProcessedActorPtr->room].worldZ - roomDataTable[oldRoom].worldZ) * 10; + int x = (roomDataTable[currentProcessedActorPtr->room].worldX - roomDataTable[oldRoom].worldX) * 10; + int y = (roomDataTable[currentProcessedActorPtr->room].worldY - roomDataTable[oldRoom].worldY) * 10; + int z = (roomDataTable[currentProcessedActorPtr->room].worldZ - roomDataTable[oldRoom].worldZ) * 10; currentProcessedActorPtr->roomX -= x; currentProcessedActorPtr->roomY += y; @@ -4232,14 +3799,19 @@ void processActor2() onceMore = true; if(currentProcessedActorIdx == currentCameraTargetActor) { - needChangeRoom = 1; - newRoom = (short)pCurrentZone->parameter; - if(g_gameId > AITD1) - loadRoom(newRoom); + FlagChangeSalle = 1; + NewNumSalle = (short)pCurrentZone->parameter; + if (g_gameId > AITD1) + { + ChangeSalle(NewNumSalle); + + // Hack: this wasn't in the original game, but is required here, or else we would use the current camera index in the new room and potentially go out of bound + InitView(); + } } else { - actorTurnedToObj = 1; + FlagGenereAffList = 1; } startChrono(¤tProcessedActorPtr->ROOM_CHRONO); @@ -4266,9 +3838,7 @@ void processActor2() } case 10: // stage { - int life; - - life = ListWorldObjets[currentProcessedActorPtr->indexInWorld].floorLife; + int life = ListWorldObjets[currentProcessedActorPtr->indexInWorld].floorLife; if(life==-1) return; @@ -4332,13 +3902,10 @@ int checkLineProjectionWithActors( int actorIdx, int X, int Y, int Z, int beta, } else { - tObject* currentActorPtr = objectTable; - - int i; - - for(i=0;iindexInWorld != -1 && i != actorIdx && !(currentActorPtr->_flags & AF_SPECIAL)) + tObject* currentActorPtr = &ListObjets[i]; + if(currentActorPtr->indexInWorld != -1 && i != actorIdx && !(currentActorPtr->objectType & AF_SPECIAL)) { ZVStruct* zvPtr = ¤tActorPtr->zv; @@ -4346,10 +3913,10 @@ int checkLineProjectionWithActors( int actorIdx, int X, int Y, int Z, int beta, { ZVStruct localZv2; - copyZv(&localZv, &localZv2); - getZvRelativePosition(&localZv2, room, currentActorPtr->room); + CopyZV(&localZv, &localZv2); + AdjustZV(&localZv2, room, currentActorPtr->room); - if(!checkZvCollision(&localZv2,zvPtr)) + if(!CubeIntersect(&localZv2,zvPtr)) { currentActorPtr++; continue; @@ -4357,7 +3924,7 @@ int checkLineProjectionWithActors( int actorIdx, int X, int Y, int Z, int beta, } else { - if(!checkZvCollision(&localZv,zvPtr)) + if(!CubeIntersect(&localZv,zvPtr)) { currentActorPtr++; continue; @@ -4367,8 +3934,6 @@ int checkLineProjectionWithActors( int actorIdx, int X, int Y, int Z, int beta, foundFlag = i; break; } - - currentActorPtr++; } } } @@ -4387,7 +3952,7 @@ void PutAtObjet(int objIdx, int objIdxToPutAt) if(objPtrToPutAt->objIndex != -1) { - tObject* actorToPutAtPtr = &objectTable[objPtrToPutAt->objIndex]; + tObject* actorToPutAtPtr = &ListObjets[objPtrToPutAt->objIndex]; DeleteInventoryObjet(objIdx); @@ -4402,7 +3967,7 @@ void PutAtObjet(int objIdx, int objIdxToPutAt) objPtr->beta = actorToPutAtPtr->beta; objPtr->gamma = actorToPutAtPtr->gamma; - objPtr->flags2 |= 0x4000; + objPtr->foundFlag |= 0x4000; objPtr->flags |= 0x80; // FlagGenereActiveList = 1; @@ -4419,7 +3984,7 @@ void PutAtObjet(int objIdx, int objIdxToPutAt) currentProcessedActorPtr->beta = actorToPutAtPtr->beta; currentProcessedActorPtr->gamma = actorToPutAtPtr->gamma; - ListWorldObjets[currentProcessedActorPtr->indexInWorld].flags2 |= 0x4000; + ListWorldObjets[currentProcessedActorPtr->indexInWorld].foundFlag |= 0x4000; ListWorldObjets[currentProcessedActorPtr->indexInWorld].flags |= 0x80; // FlagGenereActiveList = 1; @@ -4442,7 +4007,7 @@ void PutAtObjet(int objIdx, int objIdxToPutAt) objPtr->beta = objPtrToPutAt->beta; objPtr->gamma = objPtrToPutAt->gamma; - objPtr->flags2 |= 0x4000; + objPtr->foundFlag |= 0x4000; objPtr->flags |= 0x80; // FlagGenereActiveList = 1; @@ -4459,7 +4024,7 @@ void PutAtObjet(int objIdx, int objIdxToPutAt) currentProcessedActorPtr->beta = objPtrToPutAt->beta; currentProcessedActorPtr->gamma = objPtrToPutAt->gamma; - ListWorldObjets[currentProcessedActorPtr->indexInWorld].flags2 |= 0x4000; + ListWorldObjets[currentProcessedActorPtr->indexInWorld].foundFlag |= 0x4000; ListWorldObjets[currentProcessedActorPtr->indexInWorld].flags |= 0x80; // FlagGenereActiveList = 1; @@ -4478,11 +4043,10 @@ void throwStoppedAt(int x, int z) ZVStruct zvCopy; ZVStruct zvLocal; - u8* bodyPtr; - bodyPtr = (u8*)HQR_Get(listBody,currentProcessedActorPtr->bodyNum); + sBody* bodyPtr = HQR_Get(HQ_Bodys,currentProcessedActorPtr->bodyNum); - GiveZVObjet((char*)bodyPtr,&zvLocal); + GiveZVObjet(bodyPtr,&zvLocal); x2 = x; y2 = (currentProcessedActorPtr->roomY/2000)*2000; @@ -4494,7 +4058,7 @@ void throwStoppedAt(int x, int z) while(!foundPosition) { walkStep(0,-step,currentProcessedActorPtr->beta+0x200); - copyZv(&zvLocal,&zvCopy); + CopyZV(&zvLocal,&zvCopy); x2 = x + animMoveX; z2 = z + animMoveZ; @@ -4552,7 +4116,7 @@ void throwStoppedAt(int x, int z) currentProcessedActorPtr->speed = 0; currentProcessedActorPtr->gamma = 0; - GiveZVObjet((char*)bodyPtr,¤tProcessedActorPtr->zv); + GiveZVObjet(bodyPtr,¤tProcessedActorPtr->zv); currentProcessedActorPtr->zv.ZVX1 += x2; currentProcessedActorPtr->zv.ZVX2 += x2; @@ -4561,29 +4125,29 @@ void throwStoppedAt(int x, int z) currentProcessedActorPtr->zv.ZVZ1 += z2; currentProcessedActorPtr->zv.ZVZ2 += z2; - ListWorldObjets[currentProcessedActorPtr->indexInWorld].flags2 |= 0x4000; - ListWorldObjets[currentProcessedActorPtr->indexInWorld].flags2 &= 0xEFFF; + ListWorldObjets[currentProcessedActorPtr->indexInWorld].foundFlag |= 0x4000; + ListWorldObjets[currentProcessedActorPtr->indexInWorld].foundFlag &= 0xEFFF; addActorToBgInscrust(currentProcessedActorIdx); } void startGame(int startupFloor, int startupRoom, int allowSystemMenu) { - initEngine(); + LoadWorld(); initVars(); - loadFloor(startupFloor); + LoadEtage(startupFloor); - currentCamera = -1; + NumCamera = -1; - loadRoom(startupRoom); + ChangeSalle(startupRoom); - startGameVar1 = 0; - flagInitView = 2; + NewNumCamera = 0; + FlagInitView = 2; - setupCamera(); + InitView(); - mainLoop(allowSystemMenu, 1); + PlayWorld(allowSystemMenu, 1); /*freeScene(); @@ -4596,12 +4160,6 @@ int parseAllSaves(int arg) // TODO : make real implementation } -void configureHqrHero(hqrEntryStruct* hqrPtr, const char* name) -{ - strcpy(hqrPtr->string," "); - strncpy(hqrPtr->string,name,8); -} - void detectGame(void) { if(fileExists("LISTBOD2.PAK")) @@ -4757,14 +4315,14 @@ int drawTextOverlay(void) { if(currentMessage->time<26) { - ExtSetFont(PtrFont,16); + SetFont(PtrFont,16); } else { - ExtSetFont(PtrFont,16+(currentMessage->time-26)/2); + SetFont(PtrFont,16+(currentMessage->time-26)/2); } - renderText(X,var_10+1,logicalScreen,currentMessage->string->textPtr); + PrintFont(X,var_10+1,logicalScreen,currentMessage->string->textPtr); } var_10 -= 16; @@ -4848,8 +4406,8 @@ void cleanupAndExit(void) HQR_Free(HQ_Memory); HQR_Free(listLife); HQR_Free(listTrack); - HQR_Free(listBody); - HQR_Free(listAnim); + HQR_Free(HQ_Bodys); + HQR_Free(HQ_Anims); /* free(tabTextes); free(aux); diff --git a/FitdLib/main.h b/FitdLib/main.h index e5ad165..ac1165c 100644 --- a/FitdLib/main.h +++ b/FitdLib/main.h @@ -1,84 +1,75 @@ #ifndef _MAIN_ #define _MAIN_ -extern int input5; +extern int AntiRebond; void menuWaitVSync(); void AffSpfI(int x, int y, int param, char* gfx); -void processActor2(); -void loadFloor(int floorNumber); -void loadRoom(int roomNumber); +void GereDec(); +void LoadEtage(int floorNumber); +void ChangeSalle(int roomNumber); void executeFoundLife(int objIdx); -void setupCamera(); -void checkIfCameraChangeIsRequired(void); -void updateAllActorAndObjects(); -void createActorList(); -void mainDraw(int mode); -int checkObjectCollisions(int actorIdx, ZVStruct* zvPtr); +void InitView(); +void GereSwitchCamera(void); +void GenereActiveList(); +void GenereAffList(); +void AllRedraw(int mode); +int CheckObjectCol(int actorIdx, ZVStruct* zvPtr); int checkLineProjectionWithActors( int actorIdx, int X, int Y, int Z, int beta, int room, int param ); -void GiveZVObjet(char* bodyPtr, ZVStruct* zvPtr); int AsmCheckListCol(ZVStruct* zvPtr, roomDataStruct* pRoomData); void DeleteInventoryObjet(int objIdx); void walkStep(int angle1, int angle2, int angle3); void throwStoppedAt(int x, int z); sceZoneStruct* processActor2Sub(int x, int y, int z, roomDataStruct* pRoomData); -void initEngine(void); +void LoadWorld(void); void initVars(); -void configureHqrHero(hqrEntryStruct* hqrPtr, const char* name); + void flushScreen(void); int parseAllSaves(int arg); textEntryStruct* getTextFromIdx(int index); void cleanupAndExit(void); void drawProjectedBox(int x1,int x2,int y1,int y2,int z1,int z2, int color, int transparency); -void HQ_Free_Malloc(hqrEntryStruct* hqrPtr, int index); void playSequence(int sequenceIdx, int fadeStart, int fadeOutVar); -#ifndef WIN32 -extern "C" { -#endif -int fileExists(const char* name); -#ifndef WIN32 -} -#endif +bool fileExists(const char* name); void OpenProgram(void); void freeAll(void); void startGame(int startupEtage, int startupRoom, int allowSystemMenu); -void fillBox(int x1, int y1, int x2, int y2, char color); // fast recode. No RE -void copyZv(ZVStruct* source, ZVStruct* dest); -void getZvRelativePosition(ZVStruct* zvPtr, int startRoom, int destRoom); +void AffRect(int x1, int y1, int x2, int y2, char color); // fast recode. No RE +void CopyZV(ZVStruct* source, ZVStruct* dest); +void AdjustZV(ZVStruct* zvPtr, int startRoom, int destRoom); void take(int objIdx); -void foundObject(int objIdx, int param); +void FoundObjet(int objIdx, int param); void hit(int animNumber,int arg_2,int arg_4,int arg_6,int hitForce,int arg_A); -int checkZvCollision(ZVStruct* zvPtr1,ZVStruct* zvPtr2); -void getZvCube(char* bodyPtr, ZVStruct* zvPtr); +int CubeIntersect(ZVStruct* zvPtr1,ZVStruct* zvPtr2); void PutAtObjet(int objIdx, int objIdxToPutAt); void SetClip(int left, int top, int right, int bottom); +void drawZv(const ZVStruct& localZv); + /// void readBook(int index, int type); int Lire(int index, int left, int top, int right, int bottom, int mode, int color, int shadow); -void setupCameraProjection(int centerX, int centerY, int x, int y, int z); +void SetProjection(int centerX, int centerY, int x, int y, int z); void SetAngleCamera(int x, int y, int z); void SetPosCamera(int x, int y, int z); -s16 computeDistanceToPoint(int x1, int z1, int x2, int z2); -void setMoveMode(int trackMode, int trackNumber); -void InitRealValue(s16 beta, s16 newBeta, s16 param, interpolatedValue* rotatePtr); -s16 updateActorRotation(interpolatedValue* rotatePtr); -s16 GetNbFramesAnim(char* animPtr); -int SetAnimObjet(int frame, char* anim, char* body); +s16 GiveDistance2D(int x1, int z1, int x2, int z2); +void InitDeplacement(int trackMode, int trackNumber); +void InitRealValue(s16 beta, s16 newBeta, s16 param, RealValue* rotatePtr); +s16 updateActorRotation(RealValue* rotatePtr); void deleteObject(int objIdx); void removeFromBGIncrust(int actorIdx); void makeMessage(int messageIdx); int drawTextOverlay(void); -s16 SetInterAnimObjet(int frame, char* animPtr, char* bodyPtr); -void handleCollision(ZVStruct* startZv, ZVStruct* zvPtr2, ZVStruct* zvPtr3); - -void getZvRot(char* bodyPtr, ZVStruct* zvPtr, int alpha, int beta, int gamma); +void GereCollision(ZVStruct* startZv, ZVStruct* zvPtr2, ZVStruct* zvPtr3); void addActorToBgInscrust(int actorIdx); +void setupPointRotate(int alpha, int beta, int gamma); +void pointRotate(int x, int y, int z, int* destX, int* destY, int* destZ); + #endif diff --git a/FitdLib/mainLoop.cpp b/FitdLib/mainLoop.cpp index 3ef0aa3..2a29648 100644 --- a/FitdLib/mainLoop.cpp +++ b/FitdLib/mainLoop.cpp @@ -1,4 +1,5 @@ #include "common.h" +#include "anim2d.h" #ifndef WIN32 #include @@ -37,11 +38,7 @@ void updatePendingEvents(void) } } -extern "C" { - void mainLoop(int allowSystemMenu, int deltaTime); -} - -void mainLoop(int allowSystemMenu, int deltaTime) +void PlayWorld(int allowSystemMenu, int deltaTime) { bool bLoop = true; @@ -103,7 +100,7 @@ void mainLoop(int allowSystemMenu, int deltaTime) executeFoundLife(inHandTable[currentInventory]); - if(changeFloor == 0) + if(FlagChangeEtage == 0) { if(g_gameId == AITD1) { @@ -114,10 +111,9 @@ void mainLoop(int allowSystemMenu, int deltaTime) } } - currentProcessedActorPtr = objectTable; - for(currentProcessedActorIdx = 0; currentProcessedActorIdx < NUM_MAX_OBJECT; currentProcessedActorIdx++) { + currentProcessedActorPtr = &ListObjets[currentProcessedActorIdx]; if(currentProcessedActorPtr->indexInWorld >= 0) { currentProcessedActorPtr->COL_BY = -1; @@ -126,24 +122,22 @@ void mainLoop(int allowSystemMenu, int deltaTime) currentProcessedActorPtr->HARD_DEC = -1; currentProcessedActorPtr->HARD_COL = -1; } - - currentProcessedActorPtr++; } - currentProcessedActorPtr = objectTable; for(currentProcessedActorIdx = 0; currentProcessedActorIdx < NUM_MAX_OBJECT; currentProcessedActorIdx++) { + currentProcessedActorPtr = &ListObjets[currentProcessedActorIdx]; if(currentProcessedActorPtr->indexInWorld >= 0) { - int flag = currentProcessedActorPtr->_flags; + int flag = currentProcessedActorPtr->objectType; if((flag & AF_ANIMATED) || (g_gameId >= AITD2 && flag & 0x200)) { - updateAnimation(); + GereAnim(); } if(flag & AF_TRIGGER) { - processActor2(); + GereDec(); } if(currentProcessedActorPtr->animActionType) @@ -151,13 +145,12 @@ void mainLoop(int allowSystemMenu, int deltaTime) GereFrappe(); } } - - currentProcessedActorPtr++; } - currentProcessedActorPtr = objectTable; + for(currentProcessedActorIdx = 0; currentProcessedActorIdx < NUM_MAX_OBJECT; currentProcessedActorIdx++) { + currentProcessedActorPtr = &ListObjets[currentProcessedActorIdx]; if(currentProcessedActorPtr->indexInWorld >= 0) { if(currentProcessedActorPtr->life != -1) @@ -185,89 +178,86 @@ void mainLoop(int allowSystemMenu, int deltaTime) } } - if(changeFloor) + if(FlagChangeEtage) break; - - currentProcessedActorPtr++; } - if(giveUp) + if(FlagGameOver) break; } - if(changeFloor) + if(FlagChangeEtage) { - loadFloor(newFloor); + LoadEtage(NewNumEtage); } - if(needChangeRoom) + if(FlagChangeSalle) { - loadRoom(newRoom); - setupCamera(); + ChangeSalle(NewNumSalle); + InitView(); + continue; } - else - { - checkIfCameraChangeIsRequired(); - if(g_gameId >= AITD2) - { - int tempCurrentCamera; - tempCurrentCamera = currentCamera; + GereSwitchCamera(); + + // Handle 2d objects + //if (g_gameId >= AITD2) // no need for this test since it would do anything if there are 2d objects + { + int memocam = NumCamera; - currentCamera = startGameVar1; + NumCamera = NewNumCamera; - currentProcessedActorPtr = objectTable; - for(currentProcessedActorIdx = 0; currentProcessedActorIdx < NUM_MAX_OBJECT; currentProcessedActorIdx++) + for (currentProcessedActorIdx = 0; currentProcessedActorIdx < NUM_MAX_OBJECT; currentProcessedActorIdx++) + { + currentProcessedActorPtr = &ListObjets[currentProcessedActorIdx]; + if (currentProcessedActorPtr->indexInWorld >= 0) { - if(currentProcessedActorPtr->indexInWorld >= 0) + if (currentProcessedActorPtr->life != -1) { - if(currentProcessedActorPtr->life != -1) + if (currentProcessedActorPtr->objectType & AF_OBJ_2D) { - if(currentProcessedActorPtr->_flags & 0x200) - { - if(currentProcessedActorPtr->lifeMode&3) - if(!(currentProcessedActorPtr->lifeMode&4)) - { - processLife(currentProcessedActorPtr->life, false); - actorTurnedToObj = 1; - } - } + if (currentProcessedActorPtr->lifeMode & 3) + if (!(currentProcessedActorPtr->lifeMode & 4)) + { + processLife(currentProcessedActorPtr->life, false); + FlagGenereAffList = 1; + } } } - - if(changeFloor) - break; - - currentProcessedActorPtr++; } - if(giveUp) + if (FlagChangeEtage) break; - - currentCamera = tempCurrentCamera; } - if(flagInitView + + if (FlagGameOver) + break; + + NumCamera = memocam; + } + if (FlagInitView #ifdef FITD_DEBUGGER - || debuggerVar_topCamera + || debuggerVar_topCamera #endif - ) - { - setupCamera(); - } + ) + { + InitView(); } // if(FlagGenereActiveList) { - updateAllActorAndObjects(); + GenereActiveList(); } // if(actorTurnedToObj) { - createActorList(); + GenereAffList(); } sortActorList(); + handleAnim2d(); + // if(FlagRefreshAux2) { // setupCameraSub4(); @@ -277,7 +267,7 @@ void mainLoop(int allowSystemMenu, int deltaTime) //osystem_delay(100); - mainDraw(flagRedraw); + AllRedraw(flagRedraw); updatePendingEvents(); } diff --git a/FitdLib/mainLoop.h b/FitdLib/mainLoop.h index c5dc061..f0300a1 100644 --- a/FitdLib/mainLoop.h +++ b/FitdLib/mainLoop.h @@ -1,3 +1,3 @@ extern "C" { -void mainLoop(int allowSystemMenu, int deltaTime); +void PlayWorld(int allowSystemMenu, int deltaTime); } \ No newline at end of file diff --git a/FitdLib/object.cpp b/FitdLib/object.cpp index 626f68f..c37a582 100644 --- a/FitdLib/object.cpp +++ b/FitdLib/object.cpp @@ -1,11 +1,10 @@ #include "common.h" -int copyObjectToActor(int body, int typeZv, int hardZvIdx, s16 objectType, int x, int y, int z, int stage, int room, int alpha, int beta, int gamma, int anim, int frame, int animtype, int animInfo) +int InitObjet(int body, int typeZv, int hardZvIdx, s16 objectType, int x, int y, int z, int stage, int room, int alpha, int beta, int gamma, int anim, int frame, int animtype, int animInfo) { int i; int j; - tObject* actorPtr = objectTable; - char* bodyPtr; + tObject* actorPtr = ListObjets.data(); ZVStruct* zvPtr; for(i=0;ibodyNum = body; - actorPtr->_flags = objectType; + actorPtr->objectType = objectType; actorPtr->stage = stage; actorPtr->room = room; actorPtr->worldX = actorPtr->roomX = x; @@ -44,13 +43,13 @@ int copyObjectToActor(int body, int typeZv, int hardZvIdx, s16 objectType, int x actorPtr->dynFlags = 1; actorPtr->ANIM = anim; - actorPtr->FRAME = frame; + actorPtr->frame = frame; actorPtr->animType = animtype; actorPtr->animInfo = animInfo; actorPtr->END_FRAME = 1; - actorPtr->END_ANIM = 1; + actorPtr->flagEndAnim = 1; actorPtr->newAnim = -1; actorPtr->newAnimType = 0; actorPtr->newAnimInfo = -1; @@ -73,13 +72,13 @@ int copyObjectToActor(int body, int typeZv, int hardZvIdx, s16 objectType, int x actorPtr->hardMat = -1; } - actorPtr->rotate.oldAngle = 0; - actorPtr->rotate.newAngle = 0; - actorPtr->rotate.param = 0; + actorPtr->rotate.startValue = 0; + actorPtr->rotate.endValue = 0; + actorPtr->rotate.numSteps = 0; - actorPtr->YHandler.oldAngle = 0; - actorPtr->YHandler.newAngle = 0; - actorPtr->YHandler.param = 0; + actorPtr->YHandler.startValue = 0; + actorPtr->YHandler.endValue = 0; + actorPtr->YHandler.numSteps = 0; actorPtr->falling = 0; @@ -94,19 +93,21 @@ int copyObjectToActor(int body, int typeZv, int hardZvIdx, s16 objectType, int x actorPtr->HIT = -1; actorPtr->HIT_BY = -1; + sBody* bodyPtr = nullptr; + if(body != -1) { - bodyPtr = HQR_Get(listBody,actorPtr->bodyNum); + bodyPtr = HQR_Get(HQ_Bodys,actorPtr->bodyNum); if(anim != -1) { - char* animPtr = HQR_Get(listAnim,anim); + sAnimation* animPtr = HQR_Get(HQ_Anims,anim); - SetAnimObjet(frame,animPtr,bodyPtr); + SetAnimObjet(frame,animPtr, bodyPtr); actorPtr->numOfFrames = GetNbFramesAnim(animPtr); - actorPtr->END_ANIM = 0; - actorPtr->_flags |= AF_ANIMATED; + actorPtr->flagEndAnim = 0; + actorPtr->objectType |= AF_ANIMATED; // computeScreenBox(actorPtr->field_22 + actorPtr->field_5A, actorPtr->field_24 + actorPtr->field_5C, actorPtr->anim + actorPtr->field_5E, actorPtr->alpha, actorPtr->beta, actorPtr->gamma, bodyPtr); @@ -129,9 +130,9 @@ int copyObjectToActor(int body, int typeZv, int hardZvIdx, s16 objectType, int x } else { - if(!(actorPtr->_flags & AF_DRAWABLE)) + if(!(actorPtr->objectType & AF_DRAWABLE)) { - actorPtr->_flags &= ~AF_ANIMATED; // do not animate an object that is invisible + actorPtr->objectType &= ~AF_ANIMATED; // do not animate an object that is invisible } } } @@ -199,7 +200,7 @@ int copyObjectToActor(int body, int typeZv, int hardZvIdx, s16 objectType, int x { if((roomDataTable[room].hardColTable[hardColIdx].type == 9) && (roomDataTable[room].hardColTable[hardColIdx].parameter == hardZvIdx)) { - copyZv(&roomDataTable[room].hardColTable[hardColIdx].zv, zvPtr); + CopyZV(&roomDataTable[room].hardColTable[hardColIdx].zv, zvPtr); x = 0; y = 0; diff --git a/FitdLib/object.h b/FitdLib/object.h index f434465..30dc2e7 100644 --- a/FitdLib/object.h +++ b/FitdLib/object.h @@ -1,4 +1,4 @@ #ifndef _OBJECT_H_ #define _OBJECT_H_ -int copyObjectToActor(int body, int typeZv, int hardZvIdx, s16 objectType, int x, int y, int z, int stage, int room, int alpha, int beta, int gamma, int anim, int frame, int animtype, int animInfo); +int InitObjet(int body, int typeZv, int hardZvIdx, s16 objectType, int x, int y, int z, int stage, int room, int alpha, int beta, int gamma, int anim, int frame, int animtype, int animInfo); #endif diff --git a/FitdLib/osystem.h b/FitdLib/osystem.h index 53fc4cd..0be9233 100644 --- a/FitdLib/osystem.h +++ b/FitdLib/osystem.h @@ -10,7 +10,8 @@ #include "debugFont.h" #endif -extern "C"{ +#include "palette.h" + #endif #define byte char @@ -49,6 +50,7 @@ extern "C"{ void osystem_putpixel(int x, int y, int pixel); void osystem_setColor(byte i, byte R, byte G, byte B); void osystem_setPalette(unsigned byte * palette); + void osystem_setPalette(palette_t* palette); void osystem_setPalette320x200(byte * palette); void osystem_flip(unsigned char *videoBuffer); void osystem_draw320x200BufferToScreen(unsigned char *videoBuffer); @@ -57,18 +59,15 @@ extern "C"{ void osystem_drawText(int X, int Y, char *text); void osystem_drawTextColor(int X, int Y, char *string, unsigned char R, unsigned char G, unsigned char B); void osystem_drawLine(int X1,int X2,int Y1,int Y2,unsigned char color, unsigned char* palette); - void osystem_getPalette(unsigned char* palette); void osystem_playSampleFromName(char* sampleName); void osystem_playSample(char* samplePtr,int size); // void getMouseStatus(mouseStatusStruct * mouseData); - void osystem_createMask(const std::array& mask, int roomId, int maskId, unsigned char* refImage, int maskX1, int maskY1, int maskX2, int maskY2); - void osystem_drawMask(int roomId, int maskId); + void osystem_createMask(const std::array& mask, int roomId, int maskId, int maskX1, int maskY1, int maskX2, int maskY2); + void osystem_drawMask(int roomId, int maskId); void osystem_startFrame(); void osystem_stopFrame(); - void osystem_startModelRender(); - void osystem_stopModelRender(); // clip void osystem_setClip(float left, float top, float right, float bottom); @@ -82,6 +81,7 @@ extern "C"{ void osystem_drawSphere(float X, float Y, float Z, u8 color, u8 material, float size); void osystem_drawPoint(float X, float Y, float Z, u8 color, u8 material, float size); void osystem_flushPendingPrimitives(); + void osystem_drawUILayer(); void osystem_startBgPoly(); void osystem_endBgPoly(); @@ -90,8 +90,4 @@ extern "C"{ int osystem_playTrack(int trackId); void osystem_playAdlib(); -#ifdef __cplusplus -} -#endif - #endif diff --git a/FitdLib/osystemSDL.cpp b/FitdLib/osystemSDL.cpp index 9e693a8..fb6aa5e 100644 --- a/FitdLib/osystemSDL.cpp +++ b/FitdLib/osystemSDL.cpp @@ -105,7 +105,7 @@ int FitdInit(int argc, char* argv[]) // Game is running in dos resolution 13h, ie 320x200x256, but is displayed in 4:3, so pixel are not square (1.6:1) // We still need to create a 4:3 window for the actual display on screen. int scale = 4; - int resolution[2] = { 320 * scale, 240 * scale }; + int resolution[2] = { 80 * 4 * scale, 80 * 3 * scale }; gWindowBGFX = SDL_CreateWindow("FITD", resolution[0], resolution[1], flags); @@ -113,7 +113,7 @@ int FitdInit(int argc, char* argv[]) getVersion(version); - printf(version); + printf("%s", version); detectGame(); @@ -219,6 +219,8 @@ void osystem_endOfFrame() { osystem_flushPendingPrimitives(); + osystem_drawUILayer(); + #ifdef FITD_DEBUGGER debugger_draw(); #endif @@ -241,7 +243,7 @@ void osystem_endOfFrame() } -int fileExists(const char* name) +bool fileExists(const char* name) { FILE* fHandle; @@ -258,7 +260,7 @@ int fileExists(const char* name) void osystem_init() // that's the constructor of the system dependent // object used for the SDL port { - if (SDL_Init(SDL_INIT_VIDEO) < 0) + if (!SDL_Init(SDL_INIT_VIDEO)) { fprintf(stderr, "Couldn't initialize SDL: %s\n", SDL_GetError()); assert(0); diff --git a/FitdLib/pak.cpp b/FitdLib/pak.cpp index 1b363d9..4ad5717 100644 --- a/FitdLib/pak.cpp +++ b/FitdLib/pak.cpp @@ -10,7 +10,7 @@ extern "C" { extern char homePath[512]; } -typedef struct pakInfoStruct // warning: allignement unsafe +typedef struct pakInfoStruct // warning: alignment unsafe { s32 discSize; s32 uncompressedSize; @@ -92,6 +92,7 @@ int LoadPak(const char* name, int index, char* ptr) memcpy(ptr,lptr,getPakSize(name,index)); + free(lptr); return(1); @@ -138,15 +139,12 @@ int getPakSize(const char* name, int index) fseek(fileHandle,(index+1)*4,SEEK_SET); fread(&fileOffset,4,1,fileHandle); -#ifdef MACOSX fileOffset = READ_LE_U32(&fileOffset); -#endif + fseek(fileHandle,fileOffset,SEEK_SET); fread(&additionalDescriptorSize,4,1,fileHandle); -#ifdef MACOSX additionalDescriptorSize = READ_LE_U32(&additionalDescriptorSize); -#endif readPakInfo(&pakInfo,fileHandle); @@ -225,19 +223,14 @@ char* loadPak(const char* name, int index) fseek(fileHandle,(index+1)*4,SEEK_SET); fread(&fileOffset,4,1,fileHandle); - -#ifdef MACOSX fileOffset = READ_LE_U32(&fileOffset); -#endif fseek(fileHandle,fileOffset,SEEK_SET); fread(&additionalDescriptorSize,4,1,fileHandle); - -#ifdef MACOSX additionalDescriptorSize = READ_LE_U32(&additionalDescriptorSize); -#endif - if(additionalDescriptorSize) + + if(additionalDescriptorSize) { fseek(fileHandle, additionalDescriptorSize-4, SEEK_CUR); } @@ -328,18 +321,13 @@ void dumpPak(const char* name) fseek(fileHandle, (index + 1) * 4, SEEK_SET); fread(&fileOffset, 4, 1, fileHandle); - -#ifdef MACOSX fileOffset = READ_LE_U32(&fileOffset); -#endif fseek(fileHandle, fileOffset, SEEK_SET); fread(&additionalDescriptorSize, 4, 1, fileHandle); - -#ifdef MACOSX additionalDescriptorSize = READ_LE_U32(&additionalDescriptorSize); -#endif + if (additionalDescriptorSize) { fseek(fileHandle, additionalDescriptorSize - 4, SEEK_CUR); diff --git a/FitdLib/palette.cpp b/FitdLib/palette.cpp new file mode 100644 index 0000000..dcd0350 --- /dev/null +++ b/FitdLib/palette.cpp @@ -0,0 +1,63 @@ +#include "common.h" +#include "palette.h" + +void paletteFill(palette_t& palette, unsigned char r, unsigned char g, unsigned b) +{ + r <<= 1; + g <<= 1; + b <<= 1; + + for (int i = 0; i < 256; i++) + { + palette[i][0] = r; + palette[i][1] = g; + palette[i][2] = b; + } +} + +void setPalette(palette_t& sourcePal) +{ + osystem_setPalette(&sourcePal); +} + +void copyPalette(palette_t& source, palette_t& dest) +{ + for (int i = 0; i < 256; i++) + { + dest[i] = source[i]; + } +} + +void copyPalette(void* source, palette_t& dest) +{ + for (int i = 0; i < 256; i++) + { + for (int j = 0; j < 3; j++) { + dest[i][j] = ((uint8*)source)[i * 3 + j]; + } + } +} + +void convertPaletteIfRequired(palette_t& lpalette) +{ + if (g_gameId >= JACK && g_gameId <= AITD3) + { + for (int i = 0; i < 256; i++) + { + for (int j = 0; j < 3; j++) + { + lpalette[i][j] = (((unsigned int)lpalette[i][j] * 255) / 63) & 0xFF; + } + } + } +} + +void SetLevelDestPal(palette_t& inPalette, palette_t& outPalette, int coef) +{ + for (int i = 0; i < 256; i++) + { + for (int j = 0; j < 3; j++) { + outPalette[i][j] = (inPalette[i][j] * coef) >> 8; + } + } +} \ No newline at end of file diff --git a/FitdLib/palette.h b/FitdLib/palette.h new file mode 100644 index 0000000..dfc7ca7 --- /dev/null +++ b/FitdLib/palette.h @@ -0,0 +1,12 @@ +#pragma once + +#include +typedef std::array, 256> palette_t; +void paletteFill(palette_t& palette, unsigned char r, unsigned char g, unsigned b); +void setPalette(palette_t& palette); +void copyPalette(void* source, palette_t& dest); +void copyPalette(palette_t& source, palette_t& dest); +void convertPaletteIfRequired(palette_t& lpalette); +void SetLevelDestPal(palette_t& inPalette, palette_t& outPalette, int coef); + +extern palette_t currentGamePalette; diff --git a/FitdLib/renderer.cpp b/FitdLib/renderer.cpp index 4ec0abe..d6632d6 100644 --- a/FitdLib/renderer.cpp +++ b/FitdLib/renderer.cpp @@ -77,7 +77,7 @@ int renderZ; int numOfPoints; int numOfBones; -s16 pointBuffer[NUM_MAX_POINT_IN_POINT_BUFFER*3]; +std::array pointBuffer; s16 cameraSpaceBuffer[NUM_MAX_POINT_IN_POINT_BUFFER*3]; s16 bonesBuffer[NUM_MAX_BONES]; @@ -95,9 +95,9 @@ int boneRotateZSin; char primBuffer[30000]; int renderVar3; - + #ifndef AITD_UE4 -void fillpoly(s16 * datas, int n, char c); +void fillpoly(s16 * datas, int n, char c); #endif /* @@ -208,19 +208,19 @@ void InitGroupeRot(int transX,int transY,int transZ) } } -void RotateList(s16* pointPtr, int numOfPoint) +void RotateList(point3dStruct* pointPtr, int numOfPoint) { for(int i=0;i>16)<<1; z = ((((tempX * boneRotateYCos) + (tempZ * boneRotateYSin)))>>16)<<1; } @@ -241,14 +241,12 @@ void RotateList(s16* pointPtr, int numOfPoint) y = ((((tempX * boneRotateZCos) + ( tempY * boneRotateZSin)))>>16)<<1; } - *(s16*)(pointPtr) = x; - *(s16*)(pointPtr+1) = y; - *(s16*)(pointPtr+2) = z; - - pointPtr+=3; + point.x = x; + point.y = y; + point.z = z; } } - + void RotateGroupeOptimise(sGroup* ptr) { if (ptr->m_numGroup) // if group number is 0 @@ -256,10 +254,10 @@ void RotateGroupeOptimise(sGroup* ptr) int baseBone = ptr->m_start; int numPoints = ptr->m_numVertices; - RotateList(pointBuffer + baseBone * 3, numPoints); + RotateList(pointBuffer.data() + baseBone, numPoints); } } - + void RotateGroupe(sGroup* ptr) { int baseBone = ptr->m_start; @@ -267,7 +265,7 @@ void RotateGroupe(sGroup* ptr) int temp; int temp2; - RotateList(pointBuffer + baseBone * 3, numPoints); + RotateList(pointBuffer.data() + baseBone, numPoints); temp = ptr->m_numGroup; // group number @@ -282,53 +280,49 @@ void RotateGroupe(sGroup* ptr) ptr++; } while (--temp2); -} - +} + void TranslateGroupe(int transX, int transY, int transZ, sGroup* ptr) { - s16* ptrSource = &pointBuffer[ptr->m_start * 3]; - for (int i = 0; i < ptr->m_numVertices; i++) { - *(ptrSource++) += transX; - *(ptrSource++) += transY; - *(ptrSource++) += transZ; + point3dStruct& point = pointBuffer[ptr->m_start + i]; + point.x += transX; + point.y += transY; + point.z += transZ; } } - + void ZoomGroupe(int zoomX, int zoomY, int zoomZ, sGroup* ptr) { - s16* ptrSource = &pointBuffer[ptr->m_start * 3]; - for (int i = 0; i < ptr->m_numVertices; i++) { - *(ptrSource++) = (*(ptrSource) * (zoomX + 256)) / 256; - *(ptrSource++) = (*(ptrSource) * (zoomY + 256)) / 256; - *(ptrSource++) = (*(ptrSource) * (zoomZ + 256)) / 256; + point3dStruct& point = pointBuffer[ptr->m_start + i]; + point.x = (point.x * (zoomX + 256)) / 256; + point.y = (point.y * (zoomY + 256)) / 256; + point.z = (point.z * (zoomZ + 256)) / 256; } } int AnimNuage(int x,int y,int z,int alpha,int beta,int gamma, sBody* pBody) -{ +{ renderX = x - translateX; renderY = y; renderZ = z - translateZ; ASSERT(pBody->m_vertices.size()m_vertices.size(); i++) - { - pointBuffer[i * 3 + 0] = pBody->m_vertices[i].x; - pointBuffer[i * 3 + 1] = pBody->m_vertices[i].y; - pointBuffer[i * 3 + 2] = pBody->m_vertices[i].z; - } - - numOfPoints = pBody->m_vertices.size(); + + for (int i = 0; i < pBody->m_vertices.size(); i++) + { + pointBuffer[i] = pBody->m_vertices[i]; + } + + numOfPoints = pBody->m_vertices.size(); numOfBones = pBody->m_groupOrder.size(); ASSERT(numOfBonesm_flags & INFO_OPTIMISE) - { + { for(int i=0;im_groupOrder.size();i++) { int boneDataOffset = pBody->m_groupOrder[i]; @@ -337,37 +331,37 @@ int AnimNuage(int x,int y,int z,int alpha,int beta,int gamma, sBody* pBody) switch(pGroup->m_state.m_type) { case 1: - if(pGroup->m_state.m_delta[0] || pGroup->m_state.m_delta[1] || pGroup->m_state.m_delta[2]) + if(pGroup->m_state.m_delta.x || pGroup->m_state.m_delta.y || pGroup->m_state.m_delta.z) { - TranslateGroupe(pGroup->m_state.m_delta[0], pGroup->m_state.m_delta[1], pGroup->m_state.m_delta[2], pGroup); - } + TranslateGroupe(pGroup->m_state.m_delta.x, pGroup->m_state.m_delta.y, pGroup->m_state.m_delta.z, pGroup); + } break; case 2: - if (pGroup->m_state.m_delta[0] || pGroup->m_state.m_delta[1] || pGroup->m_state.m_delta[2]) + if (pGroup->m_state.m_delta.x || pGroup->m_state.m_delta.y || pGroup->m_state.m_delta.z) { - ZoomGroupe(pGroup->m_state.m_delta[0], pGroup->m_state.m_delta[1], pGroup->m_state.m_delta[2], pGroup); + ZoomGroupe(pGroup->m_state.m_delta.x, pGroup->m_state.m_delta.y, pGroup->m_state.m_delta.z, pGroup); } break; } - InitGroupeRot(pGroup[0].m_state.m_rotateDelta[0], pGroup[0].m_state.m_rotateDelta[1], pGroup[0].m_state.m_rotateDelta[2]); + InitGroupeRot(pGroup->m_state.m_rotateDelta.value().x, pGroup->m_state.m_rotateDelta.value().y, pGroup->m_state.m_rotateDelta.value().z); RotateGroupeOptimise(pGroup); } } else { - pBody->m_groups[0].m_state.m_delta[0] = alpha; - pBody->m_groups[0].m_state.m_delta[1] = beta; - pBody->m_groups[0].m_state.m_delta[2] = gamma; + pBody->m_groups[0].m_state.m_delta.x = alpha; + pBody->m_groups[0].m_state.m_delta.y = beta; + pBody->m_groups[0].m_state.m_delta.z = gamma; for(int i=0;im_groups.size();i++) { int boneDataOffset = pBody->m_groupOrder[i]; sGroup* pGroup = &pBody->m_groups[pBody->m_groupOrder[i]]; - int transX = pGroup->m_state.m_delta[0]; - int transY = pGroup->m_state.m_delta[1]; - int transZ = pGroup->m_state.m_delta[2]; + int transX = pGroup->m_state.m_delta.x; + int transY = pGroup->m_state.m_delta.y; + int transZ = pGroup->m_state.m_delta.z; if(transX || transY || transZ) { @@ -395,81 +389,39 @@ int AnimNuage(int x,int y,int z,int alpha,int beta,int gamma, sBody* pBody) } for(int i=0;im_groups.size();i++) - { - sGroup* pGroup = &pBody->m_groups[i]; - - int j; - - int point1; - int point2; - - s16* ptr1; - s16* ptr2; - - int number; - - int ax; - int bx; - int dx; - - point1 = pGroup->m_baseVertices * 6; - point2 = pGroup->m_start * 6; - - ASSERT(point1%2 == 0); - ASSERT(point2%2 == 0); - - point1/=2; - point2/=2; - - ASSERT(point1/3m_numVertices; - - ax = ptr1[0]; - bx = ptr1[1]; - dx = ptr1[2]; - - for(j=0;jm_groups[i]; + for(int j=0;j< pGroup->m_numVertices;j++) { - *(ptr2++) += ax; - *(ptr2++) += bx; - *(ptr2++) += dx; + pointBuffer[pGroup->m_start + j].x += pointBuffer[pGroup->m_baseVertices].x; + pointBuffer[pGroup->m_start + j].y += pointBuffer[pGroup->m_baseVertices].y; + pointBuffer[pGroup->m_start + j].z += pointBuffer[pGroup->m_baseVertices].z; } } if(modelFlags & INFO_OPTIMISE) { InitGroupeRot(alpha,beta,gamma); - RotateList(pointBuffer,numOfPoints); + RotateList(pointBuffer.data(),numOfPoints); } { - char* ptr = (char*)pointBuffer; s16* outPtr = cameraSpaceBuffer; - int k = numOfPoints; - - - float* outPtr2; - for(int i=0;i10000) // height clamp { @@ -486,30 +438,29 @@ int AnimNuage(int x,int y,int z,int alpha,int beta,int gamma, sBody* pBody) *(outPtr++) = (s16)X; *(outPtr++) = (s16)Y; *(outPtr++) = (s16)Z; - } + } #endif } - ptr = (char*)cameraSpaceBuffer; - outPtr2 = renderPointList; + s16* ptr = cameraSpaceBuffer; + float* outPtr2 = renderPointList; + int k = numOfPoints; do { float X; float Y; float Z; - X = *(s16*)ptr; - ptr+=2; - Y = *(s16*)ptr; - ptr+=2; - Z = *(s16*)ptr; - ptr+=2; - -#if defined(AITD_UE4) + X = ptr[0]; + Y = ptr[1]; + Z = ptr[2]; + ptr+=3; + +#if defined(AITD_UE4) *(outPtr2++) = X; *(outPtr2++) = Y; - *(outPtr2++) = Z; + *(outPtr2++) = Z; #else Z += cameraPerspective; @@ -544,7 +495,7 @@ int AnimNuage(int x,int y,int z,int alpha,int beta,int gamma, sBody* pBody) *(outPtr2++) = Z; } -#endif +#endif k--; if(k==0) @@ -566,7 +517,7 @@ z - cameraZ */ int RotateNuage(int x,int y,int z,int alpha,int beta,int gamma, sBody* pBody) -{ +{ float* outPtr; renderX = x - translateX; @@ -592,7 +543,7 @@ int RotateNuage(int x,int y,int z,int alpha,int beta,int gamma, sBody* pBody) } outPtr = renderPointList; - + for(int i=0; im_vertices.size(); i++) { float X = pBody->m_vertices[i].x; @@ -631,12 +582,12 @@ int RotateNuage(int x,int y,int z,int alpha,int beta,int gamma, sBody* pBody) X += renderX; Y += renderY; - Z += renderZ; - -#if defined(AITD_UE4) + Z += renderZ; + +#if defined(AITD_UE4) *(outPtr++) = X; *(outPtr++) = Y; - *(outPtr++) = Z; + *(outPtr++) = Z; #else if(Y>10000) // height clamp { @@ -696,50 +647,48 @@ void primFunctionDefault(int primType,char** ptr,char** out) assert(0); } -void processPrim_Line(int primType, char** ptr, char** out) // line tested +void processPrim_Line(int primType, sPrimitive* ptr, char** out) { - float depth = 32000.f; primEntryStruct* pCurrentPrimEntry = &primTable[positionInPrimEntry]; - (*ptr)++; - u8 lineColor = **ptr; - (*ptr)++; - (*ptr)++; + ASSERT(positionInPrimEntry < NUM_MAX_PRIM_ENTRY); pCurrentPrimEntry->type = primTypeEnum_Line; - pCurrentPrimEntry->color = lineColor; - + pCurrentPrimEntry->numOfVertices = 2; + pCurrentPrimEntry->color = ptr->m_color; + pCurrentPrimEntry->material = ptr->m_material; - for(int i=0;i<2;i++) + float depth = 32000.f; + ASSERT(pCurrentPrimEntry->numOfVertices < NUM_MAX_VERTEX_IN_PRIM); + for (int i = 0; i < pCurrentPrimEntry->numOfVertices; i++) { u16 pointIndex; - pointIndex = *(u16*)(*ptr); - (*ptr)+=2; + pointIndex = ptr->m_points[i] * 6; - ASSERT((pointIndex%2) == 0); + ASSERT((pointIndex % 2) == 0); - pCurrentPrimEntry->vertices[i].X = renderPointList[pointIndex/2]; - pCurrentPrimEntry->vertices[i].Y = renderPointList[(pointIndex/2)+1]; - pCurrentPrimEntry->vertices[i].Z = renderPointList[(pointIndex/2)+2]; + pCurrentPrimEntry->vertices[i].X = renderPointList[pointIndex / 2]; + pCurrentPrimEntry->vertices[i].Y = renderPointList[(pointIndex / 2) + 1]; + pCurrentPrimEntry->vertices[i].Z = renderPointList[(pointIndex / 2) + 2]; - if(depth>pCurrentPrimEntry->vertices[i].Z) + if (pCurrentPrimEntry->vertices[i].Z < depth) depth = pCurrentPrimEntry->vertices[i].Z; + } - if(depth > 0) +#if !defined(AITD_UE4) + if (depth > 100) +#endif { positionInPrimEntry++; + numOfPrimitiveToRender++; - ASSERT(positionInPrimEntry < NUM_MAX_PRIM_ENTRY); + ASSERT(positionInPrimEntry < NUM_MAX_PRIM_ENTRY); } } - -void processPrim_Line(int primType, sPrimitive* ptr, char** out) -{ -} - -void processPrim_Poly(int primType, sPrimitive* ptr, char** out) + +void processPrim_Poly(int primType, sPrimitive* ptr, char** out) { primEntryStruct* pCurrentPrimEntry = &primTable[positionInPrimEntry]; @@ -768,19 +717,19 @@ void processPrim_Poly(int primType, sPrimitive* ptr, char** out) depth = pCurrentPrimEntry->vertices[i].Z; } - + #if !defined(AITD_UE4) - if (depth > 100) + if (depth > 100) #endif { positionInPrimEntry++; numOfPrimitiveToRender++; ASSERT(positionInPrimEntry < NUM_MAX_PRIM_ENTRY); - } -} - -void processPrim_Point(primTypeEnum primType, sPrimitive* ptr, char** out) + } +} + +void processPrim_Point(primTypeEnum primType, sPrimitive* ptr, char** out) { primEntryStruct* pCurrentPrimEntry = &primTable[positionInPrimEntry]; @@ -802,20 +751,20 @@ void processPrim_Point(primTypeEnum primType, sPrimitive* ptr, char** out) depth = pCurrentPrimEntry->vertices[0].Z; } - + #if !defined(AITD_UE4) - if (depth > 100) + if (depth > 100) #endif { positionInPrimEntry++; numOfPrimitiveToRender++; ASSERT(positionInPrimEntry < NUM_MAX_PRIM_ENTRY); - } -} - -void processPrim_Sphere(int primType, sPrimitive* ptr, char** out) -{ + } +} + +void processPrim_Sphere(int primType, sPrimitive* ptr, char** out) +{ primEntryStruct* pCurrentPrimEntry = &primTable[positionInPrimEntry]; ASSERT(positionInPrimEntry < NUM_MAX_PRIM_ENTRY); @@ -837,16 +786,16 @@ void processPrim_Sphere(int primType, sPrimitive* ptr, char** out) depth = pCurrentPrimEntry->vertices[0].Z; } - + #if !defined(AITD_UE4) - if (depth > 100) + if (depth > 100) #endif { positionInPrimEntry++; numOfPrimitiveToRender++; ASSERT(positionInPrimEntry < NUM_MAX_PRIM_ENTRY); - } + } } void primType5(int primType, char** ptr, char** out) // draw out of hardClip @@ -914,7 +863,7 @@ void renderPoly(primEntryStruct* pEntry) // poly void renderZixel(primEntryStruct* pEntry) // point { - float pointSize = 20.f; + static float pointSize = 20.f; float transformedSize = ((pointSize * (float)cameraFovX) / (float)(pEntry->vertices[0].Z+cameraPerspective)); osystem_drawPoint(pEntry->vertices[0].X,pEntry->vertices[0].Y,pEntry->vertices[0].Z,pEntry->color,pEntry->material, transformedSize); @@ -922,13 +871,13 @@ void renderZixel(primEntryStruct* pEntry) // point void renderPoint(primEntryStruct* pEntry) // point { - float pointSize = 0.3f; // TODO: better way to compute that? + static float pointSize = 0.3f; // TODO: better way to compute that? osystem_drawPoint(pEntry->vertices[0].X,pEntry->vertices[0].Y,pEntry->vertices[0].Z,pEntry->color, pEntry->material, pointSize); } void renderBigPoint(primEntryStruct* pEntry) // point { - float bigPointSize = 2.f; // TODO: better way to compute that? + static float bigPointSize = 1.f; // TODO: better way to compute that? osystem_drawPoint(pEntry->vertices[0].X,pEntry->vertices[0].Y,pEntry->vertices[0].Z,pEntry->color, pEntry->material, bigPointSize); } @@ -960,10 +909,8 @@ renderFunction renderFunctions[]={ renderZixel, }; -int AffObjet(int x,int y,int z,int alpha,int beta,int gamma,void* modelPtr) -{ - sBody* pBody = getBodyFromPtr(modelPtr); - char* ptr = (char*)modelPtr; +int AffObjet(int x,int y,int z,int alpha,int beta,int gamma, sBody* pBody) +{ int numPrim; int i; char* out; @@ -984,14 +931,10 @@ int AffObjet(int x,int y,int z,int alpha,int beta,int gamma,void* modelPtr) renderVar2 = renderBuffer; - modelFlags = READ_LE_S16(ptr); ptr+=2; - ptr+=12; // skip the ZV - - ptr+=READ_LE_S16(ptr) + 2; // skip scratch buffer + modelFlags = pBody->m_flags; if(modelFlags&INFO_ANIM) - { - pBody->sync(); + { if(!AnimNuage(x,y,z,alpha,beta,gamma, pBody)) { BBox3D3 = -32000; @@ -1039,7 +982,7 @@ int AffObjet(int x,int y,int z,int alpha,int beta,int gamma,void* modelPtr) // create the list of all primitives to render for(i=0;im_primitives[i]; primTypeEnum primType = pPrimitive->m_type; @@ -1062,7 +1005,6 @@ int AffObjet(int x,int y,int z,int alpha,int beta,int gamma,void* modelPtr) case processPrim_PolyTexture9: case processPrim_PolyTexture10: processPrim_Poly(primType, pPrimitive, &out); - ptr += 3 * 2; break; default: return 0; @@ -1145,10 +1087,8 @@ int AffObjet(int x,int y,int z,int alpha,int beta,int gamma,void* modelPtr) return(0); } -void computeScreenBox(int x, int y, int z, int alpha, int beta, int gamma, char* bodyPtr) -{ - sBody* pBody = getBodyFromPtr(bodyPtr); - +void computeScreenBox(int x, int y, int z, int alpha, int beta, int gamma, sBody* bodyPtr) +{ BBox3D1 = 0x7FFF; BBox3D2 = 0x7FFF; @@ -1161,41 +1101,10 @@ void computeScreenBox(int x, int y, int z, int alpha, int beta, int gamma, char* renderVar2 = renderBuffer; - modelFlags = pBody->m_flags; - + modelFlags = bodyPtr->m_flags; + if(modelFlags&INFO_ANIM) - { - pBody->sync(); - AnimNuage(x,y,z,alpha,beta,gamma, pBody); + { + AnimNuage(x,y,z,alpha,beta,gamma, bodyPtr); } } - -void sBody::sync() -{ - u8* ptr = (u8*)m_raw; - - ptr += 2; // skip the flag - ptr += 12; // skip the ZV - ptr += READ_LE_S16(ptr) + 2; // skip scratch buffer - ptr += READ_LE_S16(ptr) * 6 + 2; // skip vertices - u16 numGroups = READ_LE_U16(ptr); - ptr += numGroups * 2 + 2; // skip group order - - assert(numGroups == m_groups.size()); - - for (int i = 0; i < numGroups; i++) - { - m_groups[i].m_state.m_type = READ_LE_S16(ptr + 8); - m_groups[i].m_state.m_delta[0] = READ_LE_S16(ptr + 10); - m_groups[i].m_state.m_delta[1] = READ_LE_S16(ptr + 12); - m_groups[i].m_state.m_delta[2] = READ_LE_S16(ptr + 14); - ptr += 16; - if (m_flags & INFO_OPTIMISE) - { - m_groups[i].m_state.m_rotateDelta[0] = READ_LE_S16(ptr + 0); - m_groups[i].m_state.m_rotateDelta[1] = READ_LE_S16(ptr + 2); - m_groups[i].m_state.m_rotateDelta[2] = READ_LE_S16(ptr + 4); - ptr += 8; - } - } -} diff --git a/FitdLib/renderer.h b/FitdLib/renderer.h index 56faee8..47206a9 100644 --- a/FitdLib/renderer.h +++ b/FitdLib/renderer.h @@ -9,13 +9,13 @@ extern int BBox3D4; #define NUM_MAX_POINT_IN_POINT_BUFFER 800 #define NUM_MAX_BONES 50 -extern s16 pointBuffer[NUM_MAX_POINT_IN_POINT_BUFFER*3]; +extern std::array pointBuffer; extern int numOfPoints; void transformPoint(float* ax, float* bx, float* cx); -int AffObjet(int var0,int var1,int var2,int var3,int var4,int var5,void* modelPtr); +int AffObjet(int x, int y, int z, int alpha, int beta, int gamma, sBody* pBody); -void computeScreenBox(int x, int y, int z, int alpha, int beta, int gamma, char* bodyPtr); +void computeScreenBox(int x, int y, int z, int alpha, int beta, int gamma, sBody* bodyPtr); #endif diff --git a/FitdLib/rendererBGFX.cpp b/FitdLib/rendererBGFX.cpp index 2a2444f..f36db88 100644 --- a/FitdLib/rendererBGFX.cpp +++ b/FitdLib/rendererBGFX.cpp @@ -27,6 +27,7 @@ email : yaz0r@yaz0r.net unsigned int gameViewId = 1; bgfx::TextureHandle g_backgroundTexture = BGFX_INVALID_HANDLE; +bgfx::TextureHandle g_uiLayerTexture = BGFX_INVALID_HANDLE; bgfx::TextureHandle g_paletteTexture = BGFX_INVALID_HANDLE; extern int outputResolution[2]; extern bool debuggerVar_debugMenuDisplayed; @@ -45,10 +46,10 @@ struct maskStruct { bgfx::TextureHandle maskTexture = BGFX_INVALID_HANDLE; bgfx::VertexBufferHandle vertexBuffer = BGFX_INVALID_HANDLE; - int maskX1; - int maskY1; - int maskX2; - int maskY2; + int maskX1 = 0; + int maskY1 = 0; + int maskX2 = 0; + int maskY2 = 0; }; std::vector> maskTextures; // [room][mask] @@ -62,11 +63,6 @@ struct polyVertex float U; float V; - - unsigned char R; - unsigned char G; - unsigned char B; - unsigned char A; }; struct sphereVertex @@ -95,6 +91,7 @@ std::array noiseVertices; std::array transparentVertices; std::array rampVertices; std::array sphereVertices; +std::vector g_lineVertices; int numUsedFlatVertices = 0; int numUsedNoiseVertices = 0; @@ -208,9 +205,15 @@ void osystem_setPalette(u8* palette) bgfx::updateTexture2D(g_paletteTexture, 0, 0, 0, 0, 3, 256, bgfx::copy(RGB_Pal, 256 * 3)); } -void osystem_getPalette(unsigned char* palette) +void osystem_setPalette(palette_t* palette) { - memcpy(palette, RGB_Pal, 256 * 3); + for (int i = 0; i < 256; i++) { + for (int j = 0; j < 3; j++) { + RGB_Pal[i * 3 + j] = palette->at(i)[j]; + } + } + + bgfx::updateTexture2D(g_paletteTexture, 0, 0, 0, 0, 3, 256, bgfx::copy(RGB_Pal, 256 * 3)); } struct s_vertexData @@ -240,6 +243,17 @@ bgfx::ShaderHandle loadBgfxShader(const std::string& filename) return handle; } +bgfx::ProgramHandle getUIShader() +{ + static bgfx::ProgramHandle programHandle = BGFX_INVALID_HANDLE; + if (!bgfx::isValid(programHandle)) + { + programHandle = loadBgfxProgram("ui_vs", "ui_ps"); + } + + return programHandle; +} + bgfx::ProgramHandle getBackgroundShader() { static bgfx::ProgramHandle programHandle = BGFX_INVALID_HANDLE; @@ -306,6 +320,107 @@ bgfx::ProgramHandle getSphereShader() return programHandle; } +void osystem_drawUILayer() +{ + bgfx::updateTexture2D(g_uiLayerTexture, 0, 0, 0, 0, 320, 200, bgfx::copy(uiLayer.data(), 320 * 200)); + + if (backgroundMode == backgroundModeEnum_2D) + { + bgfx::VertexLayout layout; + layout + .begin() + .add(bgfx::Attrib::Position, 3, bgfx::AttribType::Float) + .add(bgfx::Attrib::TexCoord0, 2, bgfx::AttribType::Float) + .end(); + + bgfx::TransientVertexBuffer transientBuffer; + bgfx::allocTransientVertexBuffer(&transientBuffer, 6, layout); + + struct sVertice + { + float position[3]; + float texcoord[2]; + }; + + sVertice* pVertices = (sVertice*)transientBuffer.data; + + float quadVertices[6 * 3]; + float quadUV[6 * 2]; + + // 0 + pVertices->position[0] = 0.f; + pVertices->position[1] = 0.f; + pVertices->position[2] = 1000.f; + pVertices->texcoord[0] = 0.f; + pVertices->texcoord[1] = 0.f; + pVertices++; + + //2 + pVertices->position[0] = 320.f; + pVertices->position[1] = 200.f; + pVertices->position[2] = 1000.f; + pVertices->texcoord[0] = 1.f; + pVertices->texcoord[1] = 1.f; + pVertices++; + + //1 + pVertices->position[0] = 320.f; + pVertices->position[1] = 0.f; + pVertices->position[2] = 1000.f; + pVertices->texcoord[0] = 1.f; + pVertices->texcoord[1] = 0.f; + pVertices++; + + //------------------------ + //3 + pVertices->position[0] = 0.f; + pVertices->position[1] = 0.f; + pVertices->position[2] = 1000.f; + pVertices->texcoord[0] = 0.f; + pVertices->texcoord[1] = 0.f; + pVertices++; + + //4 + pVertices->position[0] = 0.f; + pVertices->position[1] = 200.f; + pVertices->position[2] = 1000.f; + pVertices->texcoord[0] = 0.f; + pVertices->texcoord[1] = 1.f; + pVertices++; + + //5 + pVertices->position[0] = 320.f; + pVertices->position[1] = 200.f; + pVertices->position[2] = 1000.f; + pVertices->texcoord[0] = 1.f; + pVertices->texcoord[1] = 1.f; + pVertices++; + + static bgfx::UniformHandle backgroundTextureUniform = BGFX_INVALID_HANDLE; + if (!bgfx::isValid(backgroundTextureUniform)) + { + backgroundTextureUniform = bgfx::createUniform("s_backgroundTexture", bgfx::UniformType::Sampler); + } + static bgfx::UniformHandle paletteTextureUniform = BGFX_INVALID_HANDLE; + if (!bgfx::isValid(paletteTextureUniform)) + { + paletteTextureUniform = bgfx::createUniform("s_paletteTexture", bgfx::UniformType::Sampler); + } + + + bgfx::setState(0 | BGFX_STATE_WRITE_RGB + | BGFX_STATE_MSAA + | BGFX_STATE_DEPTH_TEST_ALWAYS + ); + + bgfx::setVertexBuffer(0, &transientBuffer); + + bgfx::setTexture(0, backgroundTextureUniform, g_uiLayerTexture); + bgfx::setTexture(1, paletteTextureUniform, g_paletteTexture); + bgfx::submit(gameViewId, getUIShader()); + } +} + void osystem_drawBackground() { if (backgroundMode == backgroundModeEnum_2D) @@ -416,6 +531,7 @@ void initBgfxMainResources() { // create background texture g_backgroundTexture = bgfx::createTexture2D(320, 200, false, 1, bgfx::TextureFormat::R8U); + g_uiLayerTexture = bgfx::createTexture2D(320, 200, false, 1, bgfx::TextureFormat::R8U); g_paletteTexture = bgfx::createTexture2D(3, 256, false, 1, bgfx::TextureFormat::R8U); } @@ -445,6 +561,8 @@ void osystem_startFrame() g_bgfxMainResourcesInitialized = true; } + //uiLayer.fill(0x0); + static ImVec2 oldWindowSize = { -1,-1 }; if (debuggerVar_debugMenuDisplayed) @@ -514,16 +632,12 @@ void osystem_startFrame() unsigned char frontBuffer[320 * 200]; unsigned char physicalScreen[320 * 200]; -unsigned char physicalScreenRGB[320 * 200 * 3]; +std::array uiLayer; void osystem_CopyBlockPhys(unsigned char* videoBuffer, int left, int top, int right, int bottom) { - unsigned char* out = physicalScreenRGB; unsigned char* in = (unsigned char*)&videoBuffer[0] + left + top * 320; - int i; - int j; - while ((right - left) % 4) { right++; @@ -534,19 +648,13 @@ void osystem_CopyBlockPhys(unsigned char* videoBuffer, int left, int top, int ri bottom++; } - for (i = top; i < bottom; i++) + for (int i = top; i < bottom; i++) { in = (unsigned char*)&videoBuffer[0] + left + i * 320; unsigned char* out2 = physicalScreen + left + i * 320; - for (j = left; j < right; j++) + for (int j = left; j < right; j++) { - unsigned char color = *(in++); - - *(out++) = RGB_Pal[color * 3]; - *(out++) = RGB_Pal[color * 3 + 1]; - *(out++) = RGB_Pal[color * 3 + 2]; - - *(out2++) = color; + *(out2++) = *(in++); } } @@ -555,21 +663,6 @@ void osystem_CopyBlockPhys(unsigned char* videoBuffer, int left, int top, int ri void osystem_refreshFrontTextureBuffer() { - unsigned char* out = physicalScreenRGB; - unsigned char* in = physicalScreen; - - int i; - int j; - - for (i = 0; i < 200 * 320; i++) - { - unsigned char color = *(in++); - *(out++) = RGB_Pal[color * 3]; - *(out++) = RGB_Pal[color * 3 + 1]; - *(out++) = RGB_Pal[color * 3 + 2]; - } - - bgfx::updateTexture2D(g_backgroundTexture, 0, 0, 0, 0, 320, 200, bgfx::copy(physicalScreen, 320 * 200)); } void osystem_initBuffer() @@ -619,16 +712,6 @@ void osystem_stopFrame() { } -void osystem_startModelRender() -{ - -} - -void osystem_stopModelRender() -{ - osystem_flushPendingPrimitives(); -} - void osystem_flushPendingPrimitives() { if (numUsedFlatVertices) @@ -638,7 +721,6 @@ void osystem_flushPendingPrimitives() .begin() .add(bgfx::Attrib::Position, 3, bgfx::AttribType::Float) .add(bgfx::Attrib::TexCoord0, 2, bgfx::AttribType::Float) - .add(bgfx::Attrib::Color0, 4, bgfx::AttribType::Uint8) .end(); bgfx::TransientVertexBuffer transientBuffer; @@ -651,6 +733,7 @@ void osystem_flushPendingPrimitives() | BGFX_STATE_WRITE_Z | BGFX_STATE_DEPTH_TEST_LEQUAL | BGFX_STATE_MSAA + | BGFX_STATE_CULL_CCW ); static bgfx::UniformHandle paletteTextureUniform = BGFX_INVALID_HANDLE; @@ -672,7 +755,6 @@ void osystem_flushPendingPrimitives() .begin() .add(bgfx::Attrib::Position, 3, bgfx::AttribType::Float) .add(bgfx::Attrib::TexCoord0, 2, bgfx::AttribType::Float) - .add(bgfx::Attrib::Color0, 4, bgfx::AttribType::Uint8) .end(); bgfx::TransientVertexBuffer transientBuffer; @@ -685,6 +767,7 @@ void osystem_flushPendingPrimitives() | BGFX_STATE_WRITE_Z | BGFX_STATE_DEPTH_TEST_LEQUAL | BGFX_STATE_MSAA + | BGFX_STATE_CULL_CCW ); static bgfx::UniformHandle paletteTextureUniform = BGFX_INVALID_HANDLE; @@ -695,6 +778,24 @@ void osystem_flushPendingPrimitives() bgfx::setTexture(1, paletteTextureUniform, g_paletteTexture); + // noise texture + static bgfx::TextureHandle noiseTexture = BGFX_INVALID_HANDLE; + if(!bgfx::isValid(noiseTexture)) + { + const int noiseTextureDim = 256; + std::array noiseTextureData; + for (int i = 0; i < noiseTextureData.size(); i++) { + noiseTextureData[i] = rand(); + } + noiseTexture = bgfx::createTexture2D(noiseTextureDim, noiseTextureDim, false, 1, bgfx::TextureFormat::R8U, 0, bgfx::copy(noiseTextureData.data(), noiseTextureDim * noiseTextureDim)); + } + static bgfx::UniformHandle noiseTextureUniform = BGFX_INVALID_HANDLE; + if (!bgfx::isValid(noiseTextureUniform)) { + noiseTextureUniform = bgfx::createUniform("s_noiseTexture", bgfx::UniformType::Sampler); + } + + bgfx::setTexture(0, noiseTextureUniform, noiseTexture); + bgfx::setVertexBuffer(0, &transientBuffer); bgfx::submit(gameViewId, getNoiseShader()); } @@ -706,7 +807,6 @@ void osystem_flushPendingPrimitives() .begin() .add(bgfx::Attrib::Position, 3, bgfx::AttribType::Float) .add(bgfx::Attrib::TexCoord0, 2, bgfx::AttribType::Float) - .add(bgfx::Attrib::Color0, 4, bgfx::AttribType::Uint8) .end(); bgfx::TransientVertexBuffer transientBuffer; @@ -719,6 +819,7 @@ void osystem_flushPendingPrimitives() | BGFX_STATE_WRITE_Z | BGFX_STATE_DEPTH_TEST_LEQUAL | BGFX_STATE_MSAA + | BGFX_STATE_CULL_CCW ); static bgfx::UniformHandle paletteTextureUniform = BGFX_INVALID_HANDLE; @@ -764,6 +865,39 @@ void osystem_flushPendingPrimitives() bgfx::setVertexBuffer(0, &transientBuffer); bgfx::submit(gameViewId, getSphereShader()); } + + if (g_lineVertices.size()) { + bgfx::VertexLayout layout; + layout + .begin() + .add(bgfx::Attrib::Position, 3, bgfx::AttribType::Float) + .add(bgfx::Attrib::TexCoord0, 2, bgfx::AttribType::Float) + .end(); + + bgfx::TransientVertexBuffer transientBuffer; + bgfx::allocTransientVertexBuffer(&transientBuffer, g_lineVertices.size(), layout); + + memcpy(transientBuffer.data, g_lineVertices.data(), sizeof(polyVertex) * g_lineVertices.size()); + + bgfx::setState(0 | BGFX_STATE_PT_LINES + | BGFX_STATE_WRITE_RGB + | BGFX_STATE_WRITE_A + | BGFX_STATE_WRITE_Z + | BGFX_STATE_DEPTH_TEST_LEQUAL + | BGFX_STATE_MSAA + ); + + static bgfx::UniformHandle paletteTextureUniform = BGFX_INVALID_HANDLE; + if (!bgfx::isValid(paletteTextureUniform)) + { + paletteTextureUniform = bgfx::createUniform("s_paletteTexture", bgfx::UniformType::Sampler); + } + + bgfx::setTexture(1, paletteTextureUniform, g_paletteTexture); + + bgfx::setVertexBuffer(0, &transientBuffer); + bgfx::submit(gameViewId, getFlatShader()); + } #if 0 if (numUsedTransparentVertices) { @@ -781,6 +915,7 @@ void osystem_flushPendingPrimitives() numUsedRampVertices = 0; numUsedSpheres = 0; numUsedTransparentVertices = 0; + g_lineVertices.clear(); } void osystem_fillPoly(float* buffer, int numPoint, unsigned char color, u8 polyType) @@ -904,10 +1039,11 @@ void osystem_fillPoly(float* buffer, int numPoint, unsigned char color, u8 polyT pVertex->Y = buffer[i * 3 + 1]; pVertex->Z = buffer[i * 3 + 2]; - pVertex->R = RGB_Pal[color * 3]; - pVertex->G = RGB_Pal[color * 3 + 1]; - pVertex->B = RGB_Pal[color * 3 + 2]; - pVertex->A = 128; + int bank = (color & 0xF0) >> 4; + int startColor = color & 0xF; + float colorf = startColor; + pVertex->U = colorf / 15.f; + pVertex->V = bank / 15.f; pVertex++; } break; @@ -1024,130 +1160,33 @@ void osystem_fillPoly(float* buffer, int numPoint, unsigned char color, u8 polyT void osystem_draw3dLine(float x1, float y1, float z1, float x2, float y2, float z2, unsigned char color) { -#if 0 - GLfloat lineVertices[2 * 3]; - GLubyte lineColor[2 * 4]; - - for (int i = 0; i < 2; i++) - { - lineColor[4 * i + 0] = RGB_Pal[color * 3 + 0]; - lineColor[4 * i + 1] = RGB_Pal[color * 3 + 1]; - lineColor[4 * i + 2] = RGB_Pal[color * 3 + 2]; - lineColor[4 * i + 3] = 255; - } - lineVertices[0] = x1; - lineVertices[1] = y1; - lineVertices[2] = z1; - lineVertices[3] = x2; - lineVertices[4] = y2; - lineVertices[5] = z2; - - static GLuint shaderprogram = 0; - static GLuint vertexp = 0; - static GLuint colorp = 0; - if (shaderprogram == 0) - { - shaderprogram = compileShader(flatQuadVS, flatQuadPS); - vertexp = glGetAttribLocation(shaderprogram, (const GLchar*)"in_Position"); - colorp = glGetAttribLocation(shaderprogram, (const GLchar*)"in_Color"); - } - - glUseProgram(shaderprogram); - - static GLuint vbo = 0; - if (vbo == 0) - { - glGenBuffers(1, &vbo); - } + polyVertex vertex1; + polyVertex vertex2; - for (int i = 0; i < 2; i++) - { - gVertexArray[i].positions[0] = lineVertices[i * 3 + 0]; - gVertexArray[i].positions[1] = lineVertices[i * 3 + 1]; - gVertexArray[i].positions[2] = lineVertices[i * 3 + 2]; - - gVertexArray[i].color[0] = lineColor[i * 4 + 0] / 255.f; - gVertexArray[i].color[1] = lineColor[i * 4 + 1] / 255.f; - gVertexArray[i].color[2] = lineColor[i * 4 + 2] / 255.f; - gVertexArray[i].color[3] = lineColor[i * 4 + 3] / 255.f; - } + vertex1.X = x1; + vertex1.Y = y1; + vertex1.Z = z1; - glBindBuffer(GL_ARRAY_BUFFER, vbo); checkGL(); - glBufferData(GL_ARRAY_BUFFER, sizeof(s_vertexData) * 2, &gVertexArray[0], GL_STATIC_DRAW); checkGL(); - glVertexAttribPointer(vertexp, 3, GL_FLOAT, GL_FALSE, sizeof(s_vertexData), (void*)&((s_vertexData*)NULL)->positions); checkGL(); - glEnableVertexAttribArray(vertexp); checkGL(); + vertex2.X = x2; + vertex2.Y = y2; + vertex2.Z = z2; - if (colorp != -1) - { - glVertexAttribPointer(colorp, 4, GL_FLOAT, GL_FALSE, sizeof(s_vertexData), (void*)&((s_vertexData*)NULL)->color); - glEnableVertexAttribArray(colorp); - } - - glDrawArrays(GL_LINE_LOOP, 0, 2); checkGL(); + int bank = (color & 0xF0) >> 4; + int startColor = color & 0xF; + float colorf = startColor; + vertex1.U = vertex2.U = colorf / 15.f; + vertex1.V = vertex2.V = bank / 15.f; - checkGL(); -#endif + g_lineVertices.push_back(vertex1); + g_lineVertices.push_back(vertex2); } void osystem_draw3dQuad(float x1, float y1, float z1, float x2, float y2, float z2, float x3, float y3, float z3, float x4, float y4, float z4, unsigned char color, int transparency) { - float lineVertices[4 * 3]; - unsigned char lineColor1[4 * 4]; - unsigned char lineColor2[4 * 4]; - - for (int i = 0; i < 4; i++) - { - lineColor1[i * 4 + 0] = RGB_Pal[(color + 3) * 3]; - lineColor1[i * 4 + 1] = RGB_Pal[(color + 3) * 3 + 1]; - lineColor1[i * 4 + 2] = RGB_Pal[(color + 3) * 3 + 2]; - lineColor1[i * 4 + 3] = 255; - - lineColor2[i * 4 + 0] = RGB_Pal[color * 3]; - lineColor2[i * 4 + 1] = RGB_Pal[color * 3 + 1]; - lineColor2[i * 4 + 2] = RGB_Pal[color * 3 + 2]; - lineColor2[i * 4 + 3] = 255; - - } - - lineVertices[0] = x1; - lineVertices[1] = y1; - lineVertices[2] = z1; - - lineVertices[3] = x2; - lineVertices[4] = y2; - lineVertices[5] = z2; - - lineVertices[6] = x4; - lineVertices[7] = y4; - lineVertices[8] = z4; - - lineVertices[9] = x3; - lineVertices[10] = y3; - lineVertices[11] = z3; - osystem_draw3dLine(x1, y1, z1, x2, y2, z2, color); osystem_draw3dLine(x2, y2, z2, x3, y3, z3, color); osystem_draw3dLine(x3, y3, z3, x4, y4, z4, color); osystem_draw3dLine(x4, y4, z4, x1, y1, z1, color); - - //glEnable(GL_DEPTH_TEST); - //glDisable(GL_BLEND); - - /*glColor4ub(1.f, 1.f, 1.f, 1.f); - glVertexPointer(3, GL_FLOAT, 0, lineVertices); - glColorPointer(4, GL_UNSIGNED_BYTE, 0, lineColor1); - glDrawArrays(GL_LINE_LOOP, 0, 4); - checkGL();*/ - /* - { - checkGL(); - glVertexPointer(3, GL_FLOAT, 0, lineVertices); - glColorPointer(4, GL_UNSIGNED_BYTE, 0, lineColor2); - glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); - checkGL(); - } - */ - } void osystem_drawSphere(float X, float Y, float Z, u8 color, u8 material, float size) @@ -1157,21 +1196,22 @@ void osystem_drawSphere(float X, float Y, float Z, u8 color, u8 material, float void osystem_drawPoint(float X, float Y, float Z, u8 color, u8 material, float size) { + float fScaleRatio = 6.f / 5.f; std::array corners; - corners[0].X = X + size; - corners[0].Y = Y + size; + corners[0].X = X + size * fScaleRatio; + corners[0].Y = Y + size * fScaleRatio; corners[0].Z = Z; - corners[1].X = X + size; - corners[1].Y = Y - size; + corners[1].X = X + size * fScaleRatio; + corners[1].Y = Y - size * fScaleRatio; corners[1].Z = Z; - corners[2].X = X - size; - corners[2].Y = Y - size; + corners[2].X = X - size * fScaleRatio; + corners[2].Y = Y - size * fScaleRatio; corners[2].Z = Z; - corners[3].X = X - size; - corners[3].Y = Y + size; + corners[3].X = X - size * fScaleRatio; + corners[3].Y = Y + size * fScaleRatio; corners[3].Z = Z; std::array mapping = { { @@ -1202,7 +1242,7 @@ void osystem_flip(unsigned char* videoBuffer) osystem_flushPendingPrimitives(); } -void osystem_createMask(const std::array& mask, int roomId, int maskId, unsigned char* refImage, int maskX1, int maskY1, int maskX2, int maskY2) +void osystem_createMask(const std::array& mask, int roomId, int maskId, int maskX1, int maskY1, int maskX2, int maskY2) { if (maskTextures.size() < roomId + 1) { @@ -1225,7 +1265,7 @@ void osystem_createMask(const std::array& mask, int roomId, int m maskTextures[roomId][maskId].vertexBuffer = BGFX_INVALID_HANDLE; } - maskTextures[roomId][maskId].maskTexture = bgfx::createTexture2D(320, 200, false, 1, bgfx::TextureFormat::R8U, 0, bgfx::copy(&mask[0], 320 * 200)); + maskTextures[roomId][maskId].maskTexture = bgfx::createTexture2D(320, 200, false, 1, bgfx::TextureFormat::R8U, 0, bgfx::copy(mask.data(), 320 * 200)); maskTextures[roomId][maskId].maskX1 = maskX1; maskTextures[roomId][maskId].maskX2 = maskX2 + 1; maskTextures[roomId][maskId].maskY1 = maskY1; diff --git a/FitdLib/room.cpp b/FitdLib/room.cpp index 02e60dc..8290a6e 100644 --- a/FitdLib/room.cpp +++ b/FitdLib/room.cpp @@ -13,9 +13,9 @@ etageVar1 -> table for camera data */ -roomDataStruct* roomDataTable = NULL; -cameraDataStruct* cameraDataTable[NUM_MAX_CAMERA_IN_ROOM]; -cameraViewedRoomStruct* currentCameraZoneList[NUM_MAX_CAMERA_IN_ROOM]; +std::vector roomDataTable; +std::vector cameraDataTable; +std::vector currentCameraZoneList; roomDefStruct* getRoomData(int roomNumber) { @@ -24,32 +24,13 @@ roomDefStruct* getRoomData(int roomNumber) int getNumberOfRoom() { - int i; - int j = 0; - - if(g_gameId >= AITD3) - { - char buffer[256]; - - if(g_gameId == AITD3) - { - sprintf(buffer,"SAL%02d",g_currentFloor); - } - else - { - sprintf(buffer,"ETAGE%02d",g_currentFloor); - } - - return PAK_getNumFiles(buffer); - } - else - { - - int numMax = (((READ_LE_U32(g_currentFloorRoomRawData))/4)); + if (g_currentFloorRoomRawData) { + int numMax = (((READ_LE_U32(g_currentFloorRoomRawData)) / 4)); - for(i=0;i= READ_LE_U32(g_currentFloorRoomRawData + i * 4)) + if (g_currentFloorRoomRawDataSize >= READ_LE_U32(g_currentFloorRoomRawData + i * 4)) { j++; } @@ -58,11 +39,25 @@ int getNumberOfRoom() return j; } } + return j; + } + else { + if (fileExists(std::format("ETAGE{:02d}.PAK", g_currentFloor).c_str())) { + return PAK_getNumFiles(std::format("ETAGE{:02d}", g_currentFloor).c_str()); + } + else if (fileExists(std::format("SAL{:02d}.PAK", g_currentFloor).c_str())) { + return PAK_getNumFiles(std::format("SAL{:02d}", g_currentFloor).c_str()); + } + else { + assert(0); + } } - return j; + + assert(false); + return 0; } -void loadRoom(int roomNumber) +void ChangeSalle(int roomNumber) { int i; int cameraVar0; @@ -71,11 +66,11 @@ void loadRoom(int roomNumber) int oldCameraIdx; roomDefStruct* roomDataPtr; - freezeTime(); + SaveTimerAnim(); ASSERT(roomNumber >=0); - if(currentCamera == -1) + if(NumCamera == -1) { oldCameraIdx = -1; } @@ -85,7 +80,7 @@ void loadRoom(int roomNumber) cameraVar1 = roomDataTable[currentRoom].worldY; cameraVar2 = roomDataTable[currentRoom].worldZ; - oldCameraIdx = roomDataTable[currentRoom].cameraIdxTable[currentCamera]; + oldCameraIdx = roomDataTable[currentRoom].cameraIdxTable[NumCamera]; } if(g_gameId < AITD3) @@ -117,12 +112,17 @@ void loadRoom(int roomNumber) int newNumCamera = 0; int newAbsCamera = -1; + cameraDataTable.clear(); + + currentCameraZoneList.clear(); + currentCameraZoneList.resize(numCameraInRoom, nullptr); + // load the new camera table and try to keep the same camera (except if changing floor) for(i=0;inumViewedRooms; @@ -148,8 +148,9 @@ void loadRoom(int roomNumber) } ASSERT(cameraDataTable[i]->viewedRoomTable[j].viewedRoomIdx == currentRoom); - if(cameraDataTable[i]->viewedRoomTable[j].viewedRoomIdx == currentRoom) + if(cameraDataTable[i]->viewedRoomTable[j].viewedRoomIdx == currentRoom) { currentCameraZoneList[i] = &cameraDataTable[i]->viewedRoomTable[j]; + } } // reajust world coordinates @@ -161,7 +162,7 @@ void loadRoom(int roomNumber) for(i=0;i rectTests; +}; + +struct cameraHybridStruct { + std::vector rects; }; struct cameraViewedRoomStruct @@ -64,28 +68,27 @@ struct cameraViewedRoomStruct s16 lightY; s16 lightZ; - u16 numMask; - cameraMaskStruct* masks; - u16 numCoverZones; - cameraZoneEntryStruct* coverZones; + std::vector masks; + std::vector coverZones; + std::vector hybrids; }; struct cameraDataStruct { - s16 alpha; - s16 beta; - s16 gamma; + s16 alpha; // 0 + s16 beta; // 2 + s16 gamma; // 4 - s16 x; - s16 y; - s16 z; + s16 x; // 6 + s16 y; // 8 + s16 z; // 10 - s16 focal1; - s16 focal2; - s16 focal3; + s16 focal1; // 12 + s16 focal2; // 14 + s16 focal3; // 16 - u16 numViewedRooms; - cameraViewedRoomStruct* viewedRoomTable; + u16 numViewedRooms; // 18 + std::vector viewedRoomTable; // 20 }; struct roomDataStruct @@ -93,25 +96,25 @@ struct roomDataStruct u32 numCameraInRoom; u32 numHardCol; - hardColStruct* hardColTable; + std::vector hardColTable; u32 numSceZone; - sceZoneStruct* sceZoneTable; + std::vector sceZoneTable; s32 worldX; s32 worldY; s32 worldZ; - u16* cameraIdxTable; + std::vector cameraIdxTable; }; typedef struct roomDataStruct roomDataStruct; -extern cameraDataStruct* cameraDataTable[NUM_MAX_CAMERA_IN_ROOM]; -extern cameraViewedRoomStruct* currentCameraZoneList[NUM_MAX_CAMERA_IN_ROOM]; -extern roomDataStruct* roomDataTable; +extern std::vector cameraDataTable; +extern std::vector currentCameraZoneList; +extern std::vector roomDataTable; roomDefStruct* getRoomData(int roomNumber); -void loadRoom(int roomNumber); +void ChangeSalle(int roomNumber); int getNumberOfRoom(); #endif diff --git a/FitdLib/save.cpp b/FitdLib/save.cpp index cb81d84..141f987 100644 --- a/FitdLib/save.cpp +++ b/FitdLib/save.cpp @@ -9,34 +9,34 @@ void* getSaveEntry(int index) return(saveTable[index].ptr); } -void loadInterpolatedValue(interpolatedValue* pRotateStruct, FILE* fHandle) +void loadInterpolatedValue(RealValue* pRotateStruct, FILE* fHandle) { - ASSERT(sizeof(pRotateStruct->oldAngle) == 2); - fread(&pRotateStruct->oldAngle,2,1,fHandle); + ASSERT(sizeof(pRotateStruct->startValue) == 2); + fread(&pRotateStruct->startValue,2,1,fHandle); - ASSERT(sizeof(pRotateStruct->newAngle) == 2); - fread(&pRotateStruct->newAngle,2,1,fHandle); + ASSERT(sizeof(pRotateStruct->endValue) == 2); + fread(&pRotateStruct->endValue,2,1,fHandle); - ASSERT(sizeof(pRotateStruct->param) == 2); - fread(&pRotateStruct->param,2,1,fHandle); + ASSERT(sizeof(pRotateStruct->numSteps) == 2); + fread(&pRotateStruct->numSteps,2,1,fHandle); - ASSERT(sizeof(pRotateStruct->timeOfRotate) == 4); - fread(&pRotateStruct->timeOfRotate,2,1,fHandle); + ASSERT(sizeof(pRotateStruct->memoTicks) == 4); + fread(&pRotateStruct->memoTicks,2,1,fHandle); } -void saveInterpolatedValue(interpolatedValue* pRotateStruct, FILE* fHandle) +void saveInterpolatedValue(RealValue* pRotateStruct, FILE* fHandle) { - ASSERT(sizeof(pRotateStruct->oldAngle) == 2); - fwrite(&pRotateStruct->oldAngle,2,1,fHandle); + ASSERT(sizeof(pRotateStruct->startValue) == 2); + fwrite(&pRotateStruct->startValue,2,1,fHandle); - ASSERT(sizeof(pRotateStruct->newAngle) == 2); - fwrite(&pRotateStruct->newAngle,2,1,fHandle); + ASSERT(sizeof(pRotateStruct->endValue) == 2); + fwrite(&pRotateStruct->endValue,2,1,fHandle); - ASSERT(sizeof(pRotateStruct->param) == 2); - fwrite(&pRotateStruct->param,2,1,fHandle); + ASSERT(sizeof(pRotateStruct->numSteps) == 2); + fwrite(&pRotateStruct->numSteps,2,1,fHandle); - ASSERT(sizeof(pRotateStruct->timeOfRotate) == 4); - fwrite(&pRotateStruct->timeOfRotate,2,1,fHandle); + ASSERT(sizeof(pRotateStruct->memoTicks) == 4); + fwrite(&pRotateStruct->memoTicks,2,1,fHandle); } int loadSave(int saveNumber) @@ -61,7 +61,7 @@ int loadSave(int saveNumber) return(0); } - initEngine(); + LoadWorld(); initVars(); fseek(fHandle,8,SEEK_SET); @@ -78,8 +78,8 @@ int loadSave(int saveNumber) ASSERT(sizeof(g_currentFloor) == 2); fread(&g_currentFloor,2,1,fHandle); - ASSERT(sizeof(currentCamera) == 2); - fread(¤tCamera,2,1,fHandle); + ASSERT(sizeof(NumCamera) == 2); + fread(&NumCamera,2,1,fHandle); ASSERT(sizeof(currentWorldTarget) == 2); fread(¤tWorldTarget,2,1,fHandle); @@ -116,8 +116,8 @@ int loadSave(int saveNumber) ASSERT(sizeof(ListWorldObjets[i].foundName) == 2); fread(&ListWorldObjets[i].foundName,2,1,fHandle); - ASSERT(sizeof(ListWorldObjets[i].flags2) == 2); - fread(&ListWorldObjets[i].flags2,2,1,fHandle); + ASSERT(sizeof(ListWorldObjets[i].foundFlag) == 2); + fread(&ListWorldObjets[i].foundFlag,2,1,fHandle); ASSERT(sizeof(ListWorldObjets[i].foundLife) == 2); fread(&ListWorldObjets[i].foundLife,2,1,fHandle); @@ -216,8 +216,8 @@ int loadSave(int saveNumber) ASSERT(sizeof(statusScreenAllowed) == 2); fread(&statusScreenAllowed,2,1,fHandle); - ASSERT(sizeof(giveUp) == 2); - fread(&giveUp,2,1,fHandle); + ASSERT(sizeof(FlagGameOver) == 2); + fread(&FlagGameOver,2,1,fHandle); ASSERT(sizeof(lightOff) == 2); fread(&lightOff,2,1,fHandle); @@ -239,11 +239,11 @@ int loadSave(int saveNumber) //timerFreeze = 1; - var_E = currentCamera; + var_E = NumCamera; - loadFloor(g_currentFloor); - currentCamera = -1; - loadRoom(currentRoom); + LoadEtage(g_currentFloor); + NumCamera = -1; + ChangeSalle(currentRoom); var_16 = currentMusic; currentMusic = -1; playMusic(var_16); @@ -260,8 +260,8 @@ int loadSave(int saveNumber) if(g_gameId == AITD1) { - configureHqrHero(listBody,listBodySelect[CVars[getCVarsIdx(CHOOSE_PERSO)]]); - configureHqrHero(listAnim,listAnimSelect[CVars[getCVarsIdx(CHOOSE_PERSO)]]); + configureHqrHero(HQ_Bodys,listBodySelect[CVars[getCVarsIdx(CHOOSE_PERSO)]]); + configureHqrHero(HQ_Anims,listAnimSelect[CVars[getCVarsIdx(CHOOSE_PERSO)]]); } else { @@ -278,233 +278,233 @@ int loadSave(int saveNumber) for(i=0;i= JACK && g_gameId < AITD3) - { - int i; - unsigned char* ptr2 = lpalette; - for(i=0;i<256;i++) - { - int j; - for(j=0;j<3;j++) - { - unsigned int composante = *(ptr2); - composante*=255; - composante/=63; - *(ptr2++) = composante&0xFF; - } - } - } -} - const char* sequenceListAITD2[]= { "BATL", @@ -156,7 +136,6 @@ void playSequence(int sequenceIdx, int fadeStart, int fadeOutVar) int var_4 = 1; int quitPlayback = 0; int nextFrame = 1; - unsigned char localPalette[0x300]; char buffer[256]; if (g_gameId == AITD2) @@ -194,7 +173,8 @@ void playSequence(int sequenceIdx, int fadeStart, int fadeOutVar) if(!currentFrameId) // first frame { - memcpy(localPalette,logicalScreen,0x300); // copy palette + palette_t localPalette; + copyPalette(logicalScreen, localPalette); // copy palette memcpy(aux,logicalScreen+0x300,64000); nextFrame = READ_LE_U16(logicalScreen+64768); @@ -213,7 +193,7 @@ void playSequence(int sequenceIdx, int fadeStart, int fadeOutVar) flipOtherPalette(palette); } */ - osystem_setPalette(localPalette); + osystem_setPalette(&localPalette); copyPalette(localPalette,currentGamePalette); } } @@ -272,5 +252,5 @@ void playSequence(int sequenceIdx, int fadeStart, int fadeOutVar) } } - flagInitView = 2; + FlagInitView = 2; } diff --git a/FitdLib/sequence.h b/FitdLib/sequence.h index 52ada68..824329f 100644 --- a/FitdLib/sequence.h +++ b/FitdLib/sequence.h @@ -12,5 +12,3 @@ typedef struct sequenceParamStruct sequenceParamStruct; extern int numSequenceParam; extern sequenceParamStruct sequenceParams[NUM_MAX_SEQUENCE_PARAM]; - -void convertPaletteIfRequired(unsigned char* lpalette); diff --git a/FitdLib/shaders/background_ps.sc b/FitdLib/shaders/background_ps.sc index 005b1c2..c4a2c18 100644 --- a/FitdLib/shaders/background_ps.sc +++ b/FitdLib/shaders/background_ps.sc @@ -1,15 +1,13 @@ $input v_texcoord0 #include "bgfx_shader.sh" +#include "palette.sh" -highp USAMPLER2D(s_backgroundTexture, 0); -highp USAMPLER2D(s_paletteTexture, 1); +USAMPLER2D(s_backgroundTexture, 0); void main() { - uvec4 rawTexel = texelFetch(s_backgroundTexture, ivec2(v_texcoord0.x * 320, v_texcoord0.y * 200), 0); - gl_FragColor.r = (texelFetch(s_paletteTexture, ivec2(0, rawTexel.r), 0) / 255.f).r; - gl_FragColor.g = (texelFetch(s_paletteTexture, ivec2(1, rawTexel.r), 0) / 255.f).r; - gl_FragColor.b = (texelFetch(s_paletteTexture, ivec2(2, rawTexel.r), 0) / 255.f).r; - gl_FragColor.a = 1.f; + vec2 position = vec2(v_texcoord0.xy) * vec2(320, 200); + uvec4 rawTexel = texelFetch(s_backgroundTexture, ivec2(position), 0); + gl_FragColor = getColorFromRawOffset(rawTexel.r); } diff --git a/FitdLib/shaders/embeddedShaders.cpp b/FitdLib/shaders/embeddedShaders.cpp index 487450f..2ff6c8a 100644 --- a/FitdLib/shaders/embeddedShaders.cpp +++ b/FitdLib/shaders/embeddedShaders.cpp @@ -2,69 +2,78 @@ #include "config.h" #if BGFX_PLATFORM_SUPPORTS_SPIRV -#include "shaders/generated/background_vs_spv.h" -#include "shaders/generated/background_ps_spv.h" -#include "shaders/generated/maskBackground_vs_spv.h" -#include "shaders/generated/maskBackground_ps_spv.h" -#include "shaders/generated/ramp_vs_spv.h" -#include "shaders/generated/ramp_ps_spv.h" -#include "shaders/generated/noise_vs_spv.h" -#include "shaders/generated/noise_ps_spv.h" -#include "shaders/generated/flat_vs_spv.h" -#include "shaders/generated/flat_ps_spv.h" -#include "shaders/generated/sphere_vs_spv.h" -#include "shaders/generated/sphere_ps_spv.h" +#include "shaders/generated/spirv/ui_vs.sc.bin.h" +#include "shaders/generated/spirv/ui_ps.sc.bin.h" +#include "shaders/generated/spirv/background_vs.sc.bin.h" +#include "shaders/generated/spirv/background_ps.sc.bin.h" +#include "shaders/generated/spirv/maskBackground_vs.sc.bin.h" +#include "shaders/generated/spirv/maskBackground_ps.sc.bin.h" +#include "shaders/generated/spirv/ramp_vs.sc.bin.h" +#include "shaders/generated/spirv/ramp_ps.sc.bin.h" +#include "shaders/generated/spirv/noise_vs.sc.bin.h" +#include "shaders/generated/spirv/noise_ps.sc.bin.h" +#include "shaders/generated/spirv/flat_vs.sc.bin.h" +#include "shaders/generated/spirv/flat_ps.sc.bin.h" +#include "shaders/generated/spirv/sphere_vs.sc.bin.h" +#include "shaders/generated/spirv/sphere_ps.sc.bin.h" #endif #if BGFX_PLATFORM_SUPPORTS_METAL -#include "shaders/generated/background_vs_mtl.h" -#include "shaders/generated/background_ps_mtl.h" -#include "shaders/generated/maskBackground_vs_mtl.h" -#include "shaders/generated/maskBackground_ps_mtl.h" -#include "shaders/generated/ramp_vs_mtl.h" -#include "shaders/generated/ramp_ps_mtl.h" -#include "shaders/generated/noise_vs_mtl.h" -#include "shaders/generated/noise_ps_mtl.h" -#include "shaders/generated/flat_vs_mtl.h" -#include "shaders/generated/flat_ps_mtl.h" -#include "shaders/generated/sphere_vs_mtl.h" -#include "shaders/generated/sphere_ps_mtl.h" +#include "shaders/generated/metal/ui_vs.sc.bin.h" +#include "shaders/generated/metal/ui_ps.sc.bin.h" +#include "shaders/generated/metal/background_vs.sc.bin.h" +#include "shaders/generated/metal/background_ps.sc.bin.h" +#include "shaders/generated/metal/maskBackground_vs.sc.bin.h" +#include "shaders/generated/metal/maskBackground_ps.sc.bin.h" +#include "shaders/generated/metal/ramp_vs.sc.bin.h" +#include "shaders/generated/metal/ramp_ps.sc.bin.h" +#include "shaders/generated/metal/noise_vs.sc.bin.h" +#include "shaders/generated/metal/noise_ps.sc.bin.h" +#include "shaders/generated/metal/flat_vs.sc.bin.h" +#include "shaders/generated/metal/flat_ps.sc.bin.h" +#include "shaders/generated/metal/sphere_vs.sc.bin.h" +#include "shaders/generated/metal/sphere_ps.sc.bin.h" #endif #if BGFX_PLATFORM_SUPPORTS_GLSL -#include "shaders/generated/background_vs_glsl.h" -#include "shaders/generated/background_ps_glsl.h" -#include "shaders/generated/maskBackground_vs_glsl.h" -#include "shaders/generated/maskBackground_ps_glsl.h" -#include "shaders/generated/ramp_vs_glsl.h" -#include "shaders/generated/ramp_ps_glsl.h" -#include "shaders/generated/noise_vs_glsl.h" -#include "shaders/generated/noise_ps_glsl.h" -#include "shaders/generated/flat_vs_glsl.h" -#include "shaders/generated/flat_ps_glsl.h" -#include "shaders/generated/sphere_vs_glsl.h" -#include "shaders/generated/sphere_ps_glsl.h" +#include "shaders/generated/glsl/ui_vs.sc.bin.h" +#include "shaders/generated/glsl/ui_ps.sc.bin.h" +#include "shaders/generated/glsl/background_vs.sc.bin.h" +#include "shaders/generated/glsl/background_ps.sc.bin.h" +#include "shaders/generated/glsl/maskBackground_vs.sc.bin.h" +#include "shaders/generated/glsl/maskBackground_ps.sc.bin.h" +#include "shaders/generated/glsl/ramp_vs.sc.bin.h" +#include "shaders/generated/glsl/ramp_ps.sc.bin.h" +#include "shaders/generated/glsl/noise_vs.sc.bin.h" +#include "shaders/generated/glsl/noise_ps.sc.bin.h" +#include "shaders/generated/glsl/flat_vs.sc.bin.h" +#include "shaders/generated/glsl/flat_ps.sc.bin.h" +#include "shaders/generated/glsl/sphere_vs.sc.bin.h" +#include "shaders/generated/glsl/sphere_ps.sc.bin.h" #endif #if BGFX_PLATFORM_SUPPORTS_DXBC -#include "shaders/generated/background_vs_dx11.h" -#include "shaders/generated/background_ps_dx11.h" -#include "shaders/generated/maskBackground_vs_dx11.h" -#include "shaders/generated/maskBackground_ps_dx11.h" - -#include "shaders/generated/ramp_vs_dx11.h" -#include "shaders/generated/ramp_ps_dx11.h" -#include "shaders/generated/noise_vs_dx11.h" -#include "shaders/generated/noise_ps_dx11.h" -#include "shaders/generated/flat_vs_dx11.h" -#include "shaders/generated/flat_ps_dx11.h" -#include "shaders/generated/sphere_vs_dx11.h" -#include "shaders/generated/sphere_ps_dx11.h" +#include "shaders/generated/dx11/ui_vs.sc.bin.h" +#include "shaders/generated/dx11/ui_ps.sc.bin.h" +#include "shaders/generated/dx11/background_vs.sc.bin.h" +#include "shaders/generated/dx11/background_ps.sc.bin.h" +#include "shaders/generated/dx11/maskBackground_vs.sc.bin.h" +#include "shaders/generated/dx11/maskBackground_ps.sc.bin.h" +#include "shaders/generated/dx11/ramp_vs.sc.bin.h" +#include "shaders/generated/dx11/ramp_ps.sc.bin.h" +#include "shaders/generated/dx11/noise_vs.sc.bin.h" +#include "shaders/generated/dx11/noise_ps.sc.bin.h" +#include "shaders/generated/dx11/flat_vs.sc.bin.h" +#include "shaders/generated/dx11/flat_ps.sc.bin.h" +#include "shaders/generated/dx11/sphere_vs.sc.bin.h" +#include "shaders/generated/dx11/sphere_ps.sc.bin.h" #endif static const bgfx::EmbeddedShader s_embeddedShaders[] = { - BGFX_EMBEDDED_SHADER(background_vs), + BGFX_EMBEDDED_SHADER(ui_vs), + BGFX_EMBEDDED_SHADER(ui_ps), + BGFX_EMBEDDED_SHADER(background_vs), BGFX_EMBEDDED_SHADER(background_ps), BGFX_EMBEDDED_SHADER(maskBackground_vs), BGFX_EMBEDDED_SHADER(maskBackground_ps), diff --git a/FitdLib/shaders/embeddedShadersMacro.h b/FitdLib/shaders/embeddedShadersMacro.h index d430d7d..a0d9394 100644 --- a/FitdLib/shaders/embeddedShadersMacro.h +++ b/FitdLib/shaders/embeddedShadersMacro.h @@ -109,7 +109,7 @@ /*BGFX_EMBEDDED_SHADER_PSSL (bgfx::RendererType::Agc, _name)*/ \ /*BGFX_EMBEDDED_SHADER_DX9BC(bgfx::RendererType::Direct3D9, _name)*/ \ BGFX_EMBEDDED_SHADER_DXBC (bgfx::RendererType::Direct3D11, _name) \ - /*BGFX_EMBEDDED_SHADER_DXBC (bgfx::RendererType::Direct3D12, _name)*/ \ + BGFX_EMBEDDED_SHADER_DXBC (bgfx::RendererType::Direct3D12, _name) \ /*BGFX_EMBEDDED_SHADER_PSSL (bgfx::RendererType::Gnm, _name)*/ \ BGFX_EMBEDDED_SHADER_METAL(bgfx::RendererType::Metal, _name) \ /*BGFX_EMBEDDED_SHADER_NVN (bgfx::RendererType::Nvn, _name)*/ \ diff --git a/FitdLib/shaders/flat_ps.sc b/FitdLib/shaders/flat_ps.sc index ee495e3..a1cce6c 100644 --- a/FitdLib/shaders/flat_ps.sc +++ b/FitdLib/shaders/flat_ps.sc @@ -1,18 +1,11 @@ $input v_texcoord0 #include "bgfx_shader.sh" - -highp USAMPLER2D(s_paletteTexture, 1); +#include "palette.sh" void main() { int color = int(v_texcoord0.x * 15.f); int bank = int(v_texcoord0.y * 15.f); - - int colorOffset = (bank << 4) + color; - - gl_FragColor.r = (texelFetch(s_paletteTexture, ivec2(0, colorOffset), 0) / 255.f).r; - gl_FragColor.g = (texelFetch(s_paletteTexture, ivec2(1, colorOffset), 0) / 255.f).r; - gl_FragColor.b = (texelFetch(s_paletteTexture, ivec2(2, colorOffset), 0) / 255.f).r; - gl_FragColor.w = 1; + gl_FragColor = getColor(bank, color); } diff --git a/FitdLib/shaders/maskBackground_ps.sc b/FitdLib/shaders/maskBackground_ps.sc index 9dd1209..de102e7 100644 --- a/FitdLib/shaders/maskBackground_ps.sc +++ b/FitdLib/shaders/maskBackground_ps.sc @@ -1,20 +1,18 @@ $input v_texcoord0 #include "bgfx_shader.sh" +#include "palette.sh" -highp USAMPLER2D(s_maskPaletteTexture, 0); -highp USAMPLER2D(s_paletteTexture, 1); -highp USAMPLER2D(s_backgroundTexture, 2); +USAMPLER2D(s_maskPaletteTexture, 0); +USAMPLER2D(s_backgroundTexture, 2); void main() { - uvec4 rawMask = texelFetch(s_maskPaletteTexture, ivec2(v_texcoord0.x * 320, v_texcoord0.y * 200), 0); - if(rawMask.r == 0) + vec2 position = vec2(v_texcoord0.xy) * vec2(320, 200); + uvec4 rawMask = texelFetch(s_maskPaletteTexture, ivec2(position), 0); + if(int(rawMask.r) == 0) discard; - uvec4 rawTexel = texelFetch(s_backgroundTexture, ivec2(v_texcoord0.x * 320, v_texcoord0.y * 200), 0); - gl_FragColor.r = (texelFetch(s_paletteTexture, ivec2(0, rawTexel.r), 0) / 255.f).r; - gl_FragColor.g = (texelFetch(s_paletteTexture, ivec2(1, rawTexel.r), 0) / 255.f).r; - gl_FragColor.b = (texelFetch(s_paletteTexture, ivec2(2, rawTexel.r), 0) / 255.f).r; - gl_FragColor.a = 1.f; + uvec4 rawTexel = texelFetch(s_backgroundTexture, ivec2(position), 0); + gl_FragColor = getColorFromRawOffset(rawTexel.r); } diff --git a/FitdLib/shaders/noise.varying.def.sc b/FitdLib/shaders/noise.varying.def.sc index e0f07e2..c09e62c 100644 --- a/FitdLib/shaders/noise.varying.def.sc +++ b/FitdLib/shaders/noise.varying.def.sc @@ -3,4 +3,5 @@ vec2 a_texcoord0 : TEXCOORD0; vec2 v_texcoord0 : TEXCOORD0 = vec2(0.0, 0.0); +vec3 v_screenSpacePosition : TEXCOORD2 = vec3(0.0, 0.0, 0.0); diff --git a/FitdLib/shaders/noise_ps.sc b/FitdLib/shaders/noise_ps.sc index ee495e3..351b961 100644 --- a/FitdLib/shaders/noise_ps.sc +++ b/FitdLib/shaders/noise_ps.sc @@ -1,18 +1,19 @@ -$input v_texcoord0 +$input v_texcoord0, v_screenSpacePosition #include "bgfx_shader.sh" +#include "palette.sh" -highp USAMPLER2D(s_paletteTexture, 1); +USAMPLER2D(s_noiseTexture, 0); void main() { int color = int(v_texcoord0.x * 15.f); int bank = int(v_texcoord0.y * 15.f); - int colorOffset = (bank << 4) + color; + uvec2 noiseSampler = uvec2(v_screenSpacePosition.xy * v_screenSpacePosition.z) % uvec2(255, 255); + float noise = float(texelFetch(s_noiseTexture, ivec2(noiseSampler), 0).r) / 255.f; + //color = int(noise * 15.f); - gl_FragColor.r = (texelFetch(s_paletteTexture, ivec2(0, colorOffset), 0) / 255.f).r; - gl_FragColor.g = (texelFetch(s_paletteTexture, ivec2(1, colorOffset), 0) / 255.f).r; - gl_FragColor.b = (texelFetch(s_paletteTexture, ivec2(2, colorOffset), 0) / 255.f).r; - gl_FragColor.w = 1; + vec4 baseColor = getColor(bank, color); + gl_FragColor = baseColor * (0.5f + noise/2.f); } diff --git a/FitdLib/shaders/noise_vs.sc b/FitdLib/shaders/noise_vs.sc index 18e6ad0..1548a60 100644 --- a/FitdLib/shaders/noise_vs.sc +++ b/FitdLib/shaders/noise_vs.sc @@ -1,5 +1,5 @@ $input a_position, a_texcoord0 -$output v_texcoord0 +$output v_texcoord0, v_screenSpacePosition #include "bgfx_shader.sh" @@ -7,4 +7,5 @@ void main() { gl_Position = vec4(a_position.x/160.0-1.0, 1.0-a_position.y/100.0, a_position.z/40960.f, 1.0); v_texcoord0 = a_texcoord0; + v_screenSpacePosition = a_position.xyz; } diff --git a/FitdLib/shaders/palette.sh b/FitdLib/shaders/palette.sh new file mode 100644 index 0000000..b5e7fe8 --- /dev/null +++ b/FitdLib/shaders/palette.sh @@ -0,0 +1,16 @@ +USAMPLER2D(s_paletteTexture, 1); + +vec4 getColorFromRawOffset(uint colorOffset) { + vec4 outputColor; + outputColor.r = float(texelFetch(s_paletteTexture, ivec2(0, colorOffset), 0).r) / 255.f; + outputColor.g = float(texelFetch(s_paletteTexture, ivec2(1, colorOffset), 0).r) / 255.f; + outputColor.b = float(texelFetch(s_paletteTexture, ivec2(2, colorOffset), 0).r) / 255.f; + outputColor.w = 1.f; + + return outputColor; +} + +vec4 getColor(int bank, int color) { + uint colorOffset = uint((bank << 4) + color); + return getColorFromRawOffset(colorOffset); +} \ No newline at end of file diff --git a/FitdLib/shaders/ramp_ps.sc b/FitdLib/shaders/ramp_ps.sc index 803a881..21584ff 100644 --- a/FitdLib/shaders/ramp_ps.sc +++ b/FitdLib/shaders/ramp_ps.sc @@ -1,14 +1,18 @@ $input v_texcoord0 #include "bgfx_shader.sh" +#include "palette.sh" -highp USAMPLER2D(s_paletteTexture, 1); +float _mod(float x, float y) +{ + return x - y * floor(x/y); +} void main() { float colorf = v_texcoord0.x; - colorf %= 2.f; + colorf = _mod(colorf, 2.f); if(colorf > 1.f) { colorf = 1.f - (colorf - 1.f); @@ -16,11 +20,5 @@ void main() int color = int(colorf * 15.f); int bank = int(v_texcoord0.y * 15.f); - - int colorOffset = (bank << 4) + color; - - gl_FragColor.r = (texelFetch(s_paletteTexture, ivec2(0, colorOffset), 0) / 255.f).r; - gl_FragColor.g = (texelFetch(s_paletteTexture, ivec2(1, colorOffset), 0) / 255.f).r; - gl_FragColor.b = (texelFetch(s_paletteTexture, ivec2(2, colorOffset), 0) / 255.f).r; - gl_FragColor.w = 1; + gl_FragColor = getColor(bank, color); } diff --git a/FitdLib/shaders/sphere_ps.sc b/FitdLib/shaders/sphere_ps.sc index 14afe43..ecef1a1 100644 --- a/FitdLib/shaders/sphere_ps.sc +++ b/FitdLib/shaders/sphere_ps.sc @@ -1,49 +1,42 @@ $input v_texcoord0, v_sphereParams, v_screenSpacePosition #include "bgfx_shader.sh" - -highp USAMPLER2D(s_paletteTexture, 1); +#include "palette.sh" void main() { vec2 sphereCenter = v_sphereParams.xy; float sphereSize = v_sphereParams.z; - float fDistanceToCenter = length(v_screenSpacePosition.xy - sphereCenter); - if(fDistanceToCenter > sphereSize) + + float distanceToCircleOnScanline; + vec2 normalizedPosition = (v_screenSpacePosition.xy - sphereCenter.xy) / sphereSize; + + float xScalingRatio = 5.f/6.f; + + normalizedPosition.x *= xScalingRatio; + if(length(normalizedPosition) > 1.f) discard; int color = int(v_texcoord0.x * 15.f); int bank = int(v_texcoord0.y * 15.f); - int material = (int)v_sphereParams.w; + int material = int(v_sphereParams.w); - if(material == 0) { // flat - int colorOffset = (bank << 4) + color; - gl_FragColor.r = (texelFetch(s_paletteTexture, ivec2(0, colorOffset), 0) / 255.f).r; - gl_FragColor.g = (texelFetch(s_paletteTexture, ivec2(1, colorOffset), 0) / 255.f).r; - gl_FragColor.b = (texelFetch(s_paletteTexture, ivec2(2, colorOffset), 0) / 255.f).r; - gl_FragColor.w = 1; - } else if(material == 2) { // transparent - int colorOffset = (bank << 4) + color; - gl_FragColor.r = (texelFetch(s_paletteTexture, ivec2(0, colorOffset), 0) / 255.f).r; - gl_FragColor.g = (texelFetch(s_paletteTexture, ivec2(1, colorOffset), 0) / 255.f).r; - gl_FragColor.b = (texelFetch(s_paletteTexture, ivec2(2, colorOffset), 0) / 255.f).r; - gl_FragColor.w = 0.5; - } else if(material == 3) { // marbre - vec2 normalizedPosition = (v_screenSpacePosition.xy - sphereCenter.xy) / sphereSize; + switch(material) { + case 0: // flat + gl_FragColor = getColor(bank, color); + break; + case 2: //transparent + gl_FragColor = getColor(bank, color); + gl_FragColor.w = 0.5f; + break; + case 3: //marbre float angle = asin(normalizedPosition.y); - float distanceToCircleOnScanline = cos(angle) - normalizedPosition.x; // value is in 0/2 range - distanceToCircleOnScanline /= 2.f; // remap to 0 / 1 - color = (1.f - distanceToCircleOnScanline) * 15.f; - - int colorOffset = (bank << 4) + color; - gl_FragColor.r = (texelFetch(s_paletteTexture, ivec2(0, colorOffset), 0) / 255.f).r; - gl_FragColor.g = (texelFetch(s_paletteTexture, ivec2(1, colorOffset), 0) / 255.f).r; - gl_FragColor.b = (texelFetch(s_paletteTexture, ivec2(2, colorOffset), 0) / 255.f).r; - gl_FragColor.w = 1; - } else { - gl_FragColor.r = 1.f; - gl_FragColor.g = 0; - gl_FragColor.b = 0; - gl_FragColor.w = 1; + distanceToCircleOnScanline = ((normalizedPosition.x / cos(angle)) / 2.f) + 0.5f; + color = int((distanceToCircleOnScanline) * 15.f); + gl_FragColor = getColor(bank, color); + break; + default: + gl_FragColor = getColor(bank, color); + break; } } diff --git a/FitdLib/shaders/ui.varying.def.sc b/FitdLib/shaders/ui.varying.def.sc new file mode 100644 index 0000000..91fd257 --- /dev/null +++ b/FitdLib/shaders/ui.varying.def.sc @@ -0,0 +1,6 @@ +vec3 a_position : POSITION; +vec2 a_texcoord0 : TEXCOORD0; + +vec4 v_color0 : COLOR0 = vec4(1.0, 0.0, 0.0, 1.0); +vec2 v_texcoord0 : TEXCOORD0 = vec2(0.0, 0.0); + diff --git a/FitdLib/shaders/ui_ps.sc b/FitdLib/shaders/ui_ps.sc new file mode 100644 index 0000000..71afc9b --- /dev/null +++ b/FitdLib/shaders/ui_ps.sc @@ -0,0 +1,15 @@ +$input v_texcoord0 + +#include "bgfx_shader.sh" +#include "palette.sh" + +USAMPLER2D(s_backgroundTexture, 0); + +void main() +{ + vec2 position = vec2(v_texcoord0.xy) * vec2(320, 200); + uvec4 rawTexel = texelFetch(s_backgroundTexture, ivec2(position), 0); + if(rawTexel.r == uint(0)) + discard; + gl_FragColor = getColorFromRawOffset(rawTexel.r); +} diff --git a/FitdLib/shaders/ui_vs.sc b/FitdLib/shaders/ui_vs.sc new file mode 100644 index 0000000..5e3d0e7 --- /dev/null +++ b/FitdLib/shaders/ui_vs.sc @@ -0,0 +1,10 @@ +$input a_position, a_texcoord0 +$output v_texcoord0 + +#include "bgfx_shader.sh" + +void main() +{ + gl_Position = vec4(a_position.x/160.0-1.0, 1.0-a_position.y/100.0, 0.0, 1.0); + v_texcoord0 = a_texcoord0; +} diff --git a/FitdLib/sprite.cpp b/FitdLib/sprite.cpp new file mode 100644 index 0000000..b7a210c --- /dev/null +++ b/FitdLib/sprite.cpp @@ -0,0 +1,45 @@ +#include "common.h" +#include "sprite.h" + +void sHybrid_Sprite::read(uint8_t* buffer, int bufferSize) { + flags = READ_LE_U16(buffer); buffer+=2; + dx = READ_LE_U8(buffer); buffer++; + dy = READ_LE_U8(buffer); buffer++; + + lines.reserve(dy); + for (int i = 0; i < dy; i++) { + auto& line = lines.emplace_back(); + int numBlocks = READ_LE_U8(buffer); buffer++; + line.blocks.reserve(numBlocks); + for (int j = 0; j < numBlocks; j++) { + auto& block = line.blocks.emplace_back(); + block.unk0 = READ_LE_U8(buffer); buffer++; + block.numWords = READ_LE_U8(buffer); buffer++; + block.numBytes = READ_LE_U8(buffer); buffer++; + + int dataSize = block.numWords * 4 + block.numBytes; + block.data.resize(dataSize); + for (int k = 0; k < dataSize; k++) { + block.data[k] = READ_LE_U8(buffer); buffer++; + } + } + line.unk = READ_LE_U8(buffer); buffer++; + } +} + +void AffSpr(int spriteNumber, int X, int Y, char* screen, std::vector& sprites) { + sHybrid_Sprite& sprite = sprites[spriteNumber]; + + Y -= sprite.dy; + for (int y = 0; y < sprite.dy; y++) { + auto& lineData = sprite.lines[y]; + + char* lineStart = screen + ((y + Y) * 320 + X); + for (int i = 0; i < lineData.blocks.size(); i++) { + auto& block = lineData.blocks[i]; + lineStart += block.unk0; + memcpy(lineStart, block.data.data(), block.data.size()); + lineStart += block.data.size(); + } + } +} diff --git a/FitdLib/sprite.h b/FitdLib/sprite.h new file mode 100644 index 0000000..6259bbc --- /dev/null +++ b/FitdLib/sprite.h @@ -0,0 +1,24 @@ +#pragma once + +struct sHybrid_SpriteBlock { + uint8_t unk0; + uint8_t numWords; + uint8_t numBytes; + std::vector data; +}; + +struct sHybrid_SpriteLine { + std::vector blocks; + uint8_t unk; +}; + +struct sHybrid_Sprite { + uint16_t flags; + uint8_t dx; + uint8_t dy; + std::vector lines; + + void read(uint8_t* buffer, int bufferSize); +}; + +void AffSpr(int spriteNumber, int X, int Y, char* screen, std::vector& sprites); \ No newline at end of file diff --git a/FitdLib/startupMenu.cpp b/FitdLib/startupMenu.cpp index 655d83d..3d2a57a 100644 --- a/FitdLib/startupMenu.cpp +++ b/FitdLib/startupMenu.cpp @@ -1,30 +1,38 @@ #include "common.h" -void drawStartupMenu(int selectedEntry) +void DrawMenu(int selectedEntry) { + if (g_gameId == AITD3) { + LoadPak("ITD_RESS", 13, logicalScreen); + } + else { + AffBigCadre(160, 100, 320, 80); + } + int currentY = 76; - int currentTextNum = 0; - AffBigCadre(160,100,320,80); - - while(currentTextNum<3) + for(int i=0; i<3; i++) { - if(currentTextNum == selectedEntry) // hilight selected entry + if(i == selectedEntry) // highlight selected entry { - fillBox(10,currentY,309,currentY+16,100); - SelectedMessage(160,currentY,currentTextNum+11,15,4); + if (g_gameId == AITD3) { + SelectedMessage(160, currentY+1, i + 11, 1, 4); + } + else { + AffRect(10, currentY, 309, currentY + 16, 100); + SelectedMessage(160, currentY, i + 11, 15, 4); + } } else { - SimpleMessage(160,currentY,currentTextNum+11,4); + SimpleMessage(160,currentY,i+11,4); } currentY+=16; // next line - currentTextNum++; // next text } } -int processStartupMenu(void) +int MainMenu(void) { int currentSelectedEntry = 0; unsigned int chrono; @@ -32,7 +40,17 @@ int processStartupMenu(void) flushScreen(); - drawStartupMenu(0); + if (g_gameId == AITD3) { + LoadPak("ITD_RESS", 47, aux); + + palette_t lpalette; + copyPalette(aux, lpalette); + convertPaletteIfRequired(lpalette); + copyPalette(lpalette, currentGamePalette); + setPalette(lpalette); + } + + DrawMenu(0); osystem_startFrame(); osystem_stopFrame(); @@ -64,7 +82,7 @@ int processStartupMenu(void) currentSelectedEntry = 2; } - drawStartupMenu(currentSelectedEntry); + DrawMenu(currentSelectedEntry); osystem_flip(NULL); // menuWaitVSync(); @@ -86,7 +104,7 @@ int processStartupMenu(void) currentSelectedEntry = 0; } - drawStartupMenu(currentSelectedEntry); + DrawMenu(currentSelectedEntry); //menuWaitVSync(); osystem_flip(NULL); diff --git a/FitdLib/startupMenu.h b/FitdLib/startupMenu.h index cfb0344..137e34b 100644 --- a/FitdLib/startupMenu.h +++ b/FitdLib/startupMenu.h @@ -1,5 +1,5 @@ #ifndef _STARTUPMENU_H_ #define _STARTUPMENU_H_ -void drawStartupMenu(int selectedEntry); -int processStartupMenu(void); +void DrawMenu(int selectedEntry); +int MainMenu(void); #endif diff --git a/FitdLib/systemMenu.cpp b/FitdLib/systemMenu.cpp index bf203b1..4852c33 100644 --- a/FitdLib/systemMenu.cpp +++ b/FitdLib/systemMenu.cpp @@ -56,7 +56,7 @@ void processSystemMenu(void) int exitMenu = 0; int currentSelectedEntry; - freezeTime(); + SaveTimerAnim(); //pauseShaking(); if(lightOff) @@ -88,7 +88,7 @@ void processSystemMenu(void) localClick = Click; localJoyD = JoyD; - if(!input5) + if(!AntiRebond) { if(localKey == 0x1C || localClick) // enter { @@ -103,8 +103,8 @@ void processSystemMenu(void) case 2: // load if(restoreSave(46,1)) { - flagInitView = 2; - unfreezeTime(); + FlagInitView = 2; + RestoreTimerAnim(); //updateShaking(); return; } @@ -125,7 +125,7 @@ void processSystemMenu(void) if(currentSelectedEntry<0) currentSelectedEntry = 6; - input5 = 1; + AntiRebond = 1; } if(localJoyD == 2) // bottom { @@ -134,7 +134,7 @@ void processSystemMenu(void) if(currentSelectedEntry>6) currentSelectedEntry = 0; - input5 = 1; + AntiRebond = 1; } } } @@ -142,7 +142,7 @@ void processSystemMenu(void) { if(!localKey && !localJoyD) { - input5 = 0; + AntiRebond = 0; } } } @@ -156,6 +156,6 @@ void processSystemMenu(void) process_events(); } localKey = localClick = localJoyD = 0; - flagInitView = 2; - unfreezeTime(); + FlagInitView = 2; + RestoreTimerAnim(); } \ No newline at end of file diff --git a/FitdLib/tatou.cpp b/FitdLib/tatou.cpp index 2adda77..74dded9 100644 --- a/FitdLib/tatou.cpp +++ b/FitdLib/tatou.cpp @@ -22,57 +22,14 @@ void blitScreenTatou(void) */ } -void copyPalette(unsigned char* source, unsigned char* dest) -{ - int i; - - for(i=0;i<768;i++) - { - dest[i] = source[i]; - } -} - void FastCopyScreen(void* source, void* dest) { memcpy(dest, source, 64000); } -void paletteFill(void* palette, unsigned char r, unsigned char g, unsigned b) -{ - unsigned char* paletteLocal = (unsigned char*) palette; - int offset = 0; - int i; - - r<<=1; - g<<=1; - b<<=1; - - for(i=0;i<256;i++) - { - paletteLocal[offset] = r; - paletteLocal[offset+1] = g; - paletteLocal[offset+2] = b; - offset += 3; - } -} - -void computePalette(unsigned char* inPalette, unsigned char* outPalette, int coef) -{ - int i; - - for(i=0;i<256;i++) - { - *(outPalette++) = ((*(inPalette++))*coef)>> 8; - *(outPalette++) = ((*(inPalette++))*coef)>> 8; - *(outPalette++) = ((*(inPalette++))*coef)>> 8; - } -} - void FadeInPhys(int step,int start) { - unsigned char localPalette[0x300]; - - freezeTime(); + SaveTimerAnim(); if(fadeState == 2) // only used for the ending ? { @@ -82,7 +39,8 @@ void FadeInPhys(int step,int start) for(int i=0;i<256;i+=step) { process_events(); - computePalette(currentGamePalette,localPalette,i); + palette_t localPalette; + SetLevelDestPal(currentGamePalette,localPalette,i); setPalette(localPalette); osystem_refreshFrontTextureBuffer(); osystem_drawBackground(); @@ -91,30 +49,24 @@ void FadeInPhys(int step,int start) fadeState = 1; - unfreezeTime(); + RestoreTimerAnim(); } -void FadeOutPhys(int var1, int var2) +void FadeOutPhys(int step, int var2) { - unsigned char localPalette[0x300]; - - freezeTime(); + SaveTimerAnim(); - for(int i=256;i>=0;i-=var1) + for(int i=256;i>=0;i-=step) { process_events(); - computePalette(currentGamePalette,localPalette,i); + palette_t localPalette; + SetLevelDestPal(currentGamePalette,localPalette,i); setPalette(localPalette); osystem_refreshFrontTextureBuffer(); osystem_drawBackground(); } - unfreezeTime(); -} - -void setPalette(void* sourcePal) -{ - osystem_setPalette((unsigned char*)sourcePal); + RestoreTimerAnim(); } #ifdef PCLIKE diff --git a/FitdLib/tatou.h b/FitdLib/tatou.h index 72b9e2b..b7e3cf9 100644 --- a/FitdLib/tatou.h +++ b/FitdLib/tatou.h @@ -3,17 +3,15 @@ int make3dTatou(void); //////////////// to mode -void paletteFill(void* palette, unsigned char r, unsigned char g, unsigned b); -void setPalette(void* palette); -void startChrono(unsigned int* chrono); -int evalChrono(unsigned int* chrono); void process_events( void ); -void copyPalette(unsigned char* source, unsigned char* dest); void FastCopyScreen(void* source, void* dest); void Rotate(unsigned int x, unsigned int y, unsigned int z, int* xOut, int* yOut); void FadeInPhys(int var1,int var2); void FadeOutPhys(int var1, int var2); void playSound(int num); void setCameraTarget(int x,int y,int z,int alpha,int beta,int gamma,int time); + +void startChrono(unsigned int* chrono); +int evalChrono(unsigned int* chrono); ////////////// #endif diff --git a/FitdLib/track.cpp b/FitdLib/track.cpp index 15531b1..b1f4fbc 100644 --- a/FitdLib/track.cpp +++ b/FitdLib/track.cpp @@ -6,10 +6,10 @@ #define TL_END 2 #define TL_REPEAT 3 #define TL_MARK 4 -#define TL_WALK 5 -#define TL_RUN 6 +#define TL_WALK 5 // removed in AITD2+ +#define TL_RUN 6 // removed in AITD2+ #define TL_STOP 7 -#define TL_BACK 8 +#define TL_BACK 8 // removed in AITD2+ #define TL_SET_ANGLE 9 #define TL_COL_OFF 10 #define TL_COL_ON 11 @@ -23,6 +23,22 @@ #define TL_ANGLE 19 #define TL_CLOSE 20 +// AITD2+ has removed a few entries, so covert the enum to match +s16 convertTrackMacro(s16 inTrackMacro) { + if (g_gameId == AITD1) { + return inTrackMacro; + } + + if (inTrackMacro <= 4) + return inTrackMacro; + + if (inTrackMacro >= 6) + return inTrackMacro + 3; + + assert(inTrackMacro == 5); + return TL_STOP; +} + int makeProportional(int x1, int x2, int y1, int y2) { return x1 + ((x2 - x1) * y2) / y1; @@ -49,7 +65,7 @@ int computeAngleModificatorToPositionSub1(int ax) return(-1); } -int computeAngleModificatorToPosition(int x1,int z1, int beta, int x2, int z2) +int CapObjet(int x1,int z1, int beta, int x2, int z2) { int resultMin; int resultMax; @@ -77,12 +93,12 @@ void GereManualRot(int param) { if(currentProcessedActorPtr->direction != 1) { - currentProcessedActorPtr->rotate.param = 0; + currentProcessedActorPtr->rotate.numSteps = 0; } currentProcessedActorPtr->direction = 1; - if(currentProcessedActorPtr->rotate.param == 0) + if(currentProcessedActorPtr->rotate.numSteps == 0) { int oldBeta = currentProcessedActorPtr->beta; @@ -102,12 +118,12 @@ void GereManualRot(int param) { if(currentProcessedActorPtr->direction != -1) { - currentProcessedActorPtr->rotate.param = 0; + currentProcessedActorPtr->rotate.numSteps = 0; } currentProcessedActorPtr->direction = -1; - if(currentProcessedActorPtr->rotate.param == 0) + if(currentProcessedActorPtr->rotate.numSteps == 0) { int oldBeta = currentProcessedActorPtr->beta; @@ -126,7 +142,7 @@ void GereManualRot(int param) if(!(localJoyD&0xC)) { currentProcessedActorPtr->direction = 0; - currentProcessedActorPtr->rotate.param = 0; + currentProcessedActorPtr->rotate.numSteps = 0; } } @@ -226,37 +242,51 @@ void processTrack(void) } else { - tObject* followedActorPtr = &objectTable[followedActorIdx]; + tObject* followedActorPtr = &ListObjets[followedActorIdx]; - int roomNumber = followedActorPtr->room; - int x = followedActorPtr->roomX; - int y = followedActorPtr->roomY; - int z = followedActorPtr->roomZ; + int targetRoomNumber = followedActorPtr->room; + int targetX = followedActorPtr->roomX; + int targetY = followedActorPtr->roomY; + int targetZ = followedActorPtr->roomZ; int angleModif; - if(currentProcessedActorPtr->room != roomNumber) - { - char* link = getRoomLink(currentProcessedActorPtr->room,roomNumber); + if (g_gameId == AITD1) { + // in AITD1, if the target entity is in a different room, the entity would aim for the center of the trigger zone to get to that room + if (currentProcessedActorPtr->room != targetRoomNumber) + { + char* link = getRoomLink(currentProcessedActorPtr->room, targetRoomNumber); + + targetX = *(s16*)(link + 0) + (((*(s16*)(link + 2)) - (*(s16*)(link + 0))) / 2); + targetY = *(s16*)(link + 4) + (((*(s16*)(link + 6)) - (*(s16*)(link + 4))) / 2); + targetZ = *(s16*)(link + 8) + (((*(s16*)(link + 10)) - (*(s16*)(link + 8))) / 2); + } + } + else { + // This was changed from AITD2+ to aim for the target in world-space + if((followedActorPtr->room >= 0) && (currentProcessedActorPtr->room>=0)) + { + const auto& targetRoom = roomDataTable[followedActorPtr->room]; + const auto& sourceRoom = roomDataTable[currentProcessedActorPtr->room]; - x = *(s16*)(link)+(((*(s16*)(link+2))-(*(s16 *)(link))) / 2); - y = *(s16*)(link+4)+(((*(s16*)(link+6))-(*(s16 *)(link+4))) / 2); - z = *(s16*)(link+8)+(((*(s16*)(link+10))-(*(s16 *)(link+8))) / 2); + targetX -= (sourceRoom.worldX - targetRoom.worldX) * 10; + targetZ += (sourceRoom.worldZ - targetRoom.worldZ) * 10; + } } - angleModif = computeAngleModificatorToPosition( currentProcessedActorPtr->roomX + currentProcessedActorPtr->stepX, + angleModif = CapObjet( currentProcessedActorPtr->roomX + currentProcessedActorPtr->stepX, currentProcessedActorPtr->roomZ + currentProcessedActorPtr->stepZ, - currentProcessedActorPtr->beta, x, z ); + currentProcessedActorPtr->beta, targetX, targetZ); - if( currentProcessedActorPtr->rotate.param == 0 || currentProcessedActorPtr->direction != angleModif ) + if( (currentProcessedActorPtr->rotate.numSteps == 0) || (currentProcessedActorPtr->direction != angleModif) ) { - InitRealValue( currentProcessedActorPtr->beta, currentProcessedActorPtr->beta - (angleModif << 8), 60, ¤tProcessedActorPtr->rotate); + InitRealValue( currentProcessedActorPtr->beta, currentProcessedActorPtr->beta - (angleModif * 256), 60, ¤tProcessedActorPtr->rotate); } currentProcessedActorPtr->direction = angleModif; if( currentProcessedActorPtr->direction == 0 ) { - currentProcessedActorPtr->rotate.param = 0; + currentProcessedActorPtr->rotate.numSteps = 0; } else { @@ -271,11 +301,9 @@ void processTrack(void) case 3: // track { char* trackPtr = HQR_Get(listTrack,currentProcessedActorPtr->trackNumber); - s16 trackMacro; - trackPtr+=currentProcessedActorPtr->positionInTrack * 2; - trackMacro = *(s16*)trackPtr; + s16 trackMacro = convertTrackMacro(*(s16*)trackPtr); trackPtr += 2; //printf("Track macro %X\n",trackMacro); @@ -291,8 +319,8 @@ void processTrack(void) { if(currentCameraTargetActor == currentProcessedActorIdx) { - needChangeRoom = 1; - newRoom = roomNumber; + FlagChangeSalle = 1; + NewNumSalle = roomNumber; } currentProcessedActorPtr->room = roomNumber; @@ -325,7 +353,7 @@ void processTrack(void) currentProcessedActorPtr->speed = 0; currentProcessedActorPtr->direction = 0; - currentProcessedActorPtr->rotate.param = 0; + currentProcessedActorPtr->rotate.numSteps = 0; currentProcessedActorPtr->positionInTrack += 5; break; @@ -353,19 +381,19 @@ void processTrack(void) z += (roomDataTable[currentProcessedActorPtr->room].worldZ - roomDataTable[roomNumber].worldZ) * 10; } - distanceToPoint = computeDistanceToPoint( currentProcessedActorPtr->roomX + currentProcessedActorPtr->stepX, + distanceToPoint = GiveDistance2D( currentProcessedActorPtr->roomX + currentProcessedActorPtr->stepX, currentProcessedActorPtr->roomZ + currentProcessedActorPtr->stepZ, x,z ); if(distanceToPoint >= DISTANCE_TO_POINT_TRESSHOLD) // not yet at position { - int angleModif = computeAngleModificatorToPosition( currentProcessedActorPtr->roomX + currentProcessedActorPtr->stepX, + int angleModif = CapObjet( currentProcessedActorPtr->roomX + currentProcessedActorPtr->stepX, currentProcessedActorPtr->roomZ + currentProcessedActorPtr->stepZ, currentProcessedActorPtr->beta, x,z ); - if((currentProcessedActorPtr->rotate.param == 0) || (currentProcessedActorPtr->direction != angleModif)) + if((currentProcessedActorPtr->rotate.numSteps == 0) || (currentProcessedActorPtr->direction != angleModif)) { InitRealValue(currentProcessedActorPtr->beta, currentProcessedActorPtr->beta - (angleModif * 64), 15, ¤tProcessedActorPtr->rotate); } @@ -374,7 +402,7 @@ void processTrack(void) if(!angleModif) { - currentProcessedActorPtr->rotate.param = 0; + currentProcessedActorPtr->rotate.numSteps = 0; } else { @@ -387,7 +415,7 @@ void processTrack(void) } break; - } + } case TL_GOTO_3D: // goToPosition { int roomNumber = *(s16*)(trackPtr); @@ -400,49 +428,53 @@ void processTrack(void) x = *(s16*)(trackPtr); trackPtr += 2; - y = *(s16*)(trackPtr); + y = *(s16*)(trackPtr); trackPtr += 2; z = *(s16*)(trackPtr); - trackPtr += 2; + trackPtr += 2; int time = *(s16*)(trackPtr); trackPtr += 2; if (roomNumber != currentProcessedActorPtr->room) { // TODO: fix bug here... - x -= (roomDataTable[currentProcessedActorPtr->room].worldX - roomDataTable[roomNumber].worldX) * 10; + x -= (roomDataTable[currentProcessedActorPtr->room].worldX - roomDataTable[roomNumber].worldX) * 10; y += (roomDataTable[currentProcessedActorPtr->room].worldY - roomDataTable[roomNumber].worldY) * 10; z += (roomDataTable[currentProcessedActorPtr->room].worldZ - roomDataTable[roomNumber].worldZ) * 10; - } - - // reached position? - if ((y == currentProcessedActorPtr->roomY) && (computeDistanceToPoint(currentProcessedActorPtr->roomX + currentProcessedActorPtr->stepX, currentProcessedActorPtr->roomZ + currentProcessedActorPtr->stepZ, x, z) < DISTANCE_TO_POINT_TRESSHOLD)) - { - currentProcessedActorPtr->positionInTrack += 6; } - else + + // reached position? + if (y == currentProcessedActorPtr->roomY) + { + int distance = GiveDistance2D(currentProcessedActorPtr->roomX + currentProcessedActorPtr->stepX, currentProcessedActorPtr->roomZ + currentProcessedActorPtr->stepZ, x, z); + if (distance < DISTANCE_TO_POINT_TRESSHOLD) { + currentProcessedActorPtr->positionInTrack += 6; + break; + } + } + { - int angleModif = computeAngleModificatorToPosition( + int direction = CapObjet( currentProcessedActorPtr->roomX + currentProcessedActorPtr->stepX, currentProcessedActorPtr->roomZ + currentProcessedActorPtr->stepZ, currentProcessedActorPtr->beta, x, z); - - if (currentProcessedActorPtr->YHandler.param == 0) - { - InitRealValue(0, y - (currentProcessedActorPtr->roomY + currentProcessedActorPtr->stepY), time, ¤tProcessedActorPtr->YHandler); - } - if ((currentProcessedActorPtr->rotate.param == 0) || (currentProcessedActorPtr->direction != angleModif)) + if (currentProcessedActorPtr->YHandler.numSteps == 0) { - InitRealValue(currentProcessedActorPtr->beta, currentProcessedActorPtr->beta - (angleModif * 256), 60, ¤tProcessedActorPtr->rotate); + InitRealValue(0, y - (currentProcessedActorPtr->roomY + currentProcessedActorPtr->stepY), time, ¤tProcessedActorPtr->YHandler); } - currentProcessedActorPtr->direction = angleModif; + if ((currentProcessedActorPtr->rotate.numSteps == 0) || (currentProcessedActorPtr->direction != direction)) + { + InitRealValue(currentProcessedActorPtr->beta, currentProcessedActorPtr->beta - (direction * 256), 60, ¤tProcessedActorPtr->rotate); + } - if (!angleModif) + currentProcessedActorPtr->direction = direction; + + if (!direction) { - currentProcessedActorPtr->rotate.param = 0; + currentProcessedActorPtr->rotate.numSteps = 0; } else { @@ -456,7 +488,7 @@ void processTrack(void) { currentProcessedActorPtr->speed = 0; currentProcessedActorPtr->trackNumber = -1; - setMoveMode(0,0); + InitDeplacement(0,0); break; } case TL_REPEAT: @@ -485,8 +517,12 @@ void processTrack(void) } case TL_STOP: { - currentProcessedActorPtr->speed = 0; - currentProcessedActorPtr->positionInTrack++; + // Stop only has a meaning in AITD1 where it means stop walking + if (g_gameId == AITD1) + { + currentProcessedActorPtr->speed = 0; + currentProcessedActorPtr->positionInTrack++; + } break; } case TL_SET_ANGLE: // TL_SET_ANGLE @@ -503,7 +539,7 @@ void processTrack(void) currentProcessedActorPtr->direction = -1; // right } - if(!currentProcessedActorPtr->rotate.param) + if(!currentProcessedActorPtr->rotate.numSteps) { InitRealValue(currentProcessedActorPtr->beta, betaDif, 120, ¤tProcessedActorPtr->rotate); } @@ -521,7 +557,7 @@ void processTrack(void) } case TL_COL_OFF: { - currentProcessedActorPtr->dynFlags &= 0xFFFE; + currentProcessedActorPtr->dynFlags &= ~1; currentProcessedActorPtr->positionInTrack++; break; } @@ -533,13 +569,13 @@ void processTrack(void) } case TL_DEC_OFF: // background collision off { - currentProcessedActorPtr->_flags &= ~AF_TRIGGER; + currentProcessedActorPtr->objectType &= ~AF_TRIGGER; currentProcessedActorPtr->positionInTrack++; break; } case TL_DEC_ON: // background collision on { - currentProcessedActorPtr->_flags |= AF_TRIGGER; + currentProcessedActorPtr->objectType |= AF_TRIGGER; currentProcessedActorPtr->positionInTrack++; break; } @@ -588,12 +624,12 @@ void processTrack(void) currentProcessedActorPtr->zv.ZVY1 += difY; currentProcessedActorPtr->zv.ZVY2 += difY; - angleModif = computeAngleModificatorToPosition( currentProcessedActorPtr->roomX + currentProcessedActorPtr->stepX, + angleModif = CapObjet( currentProcessedActorPtr->roomX + currentProcessedActorPtr->stepX, currentProcessedActorPtr->roomZ + currentProcessedActorPtr->stepZ, currentProcessedActorPtr->beta, x,z ); - if(!currentProcessedActorPtr->rotate.param || currentProcessedActorPtr->direction != angleModif) + if(!currentProcessedActorPtr->rotate.numSteps || currentProcessedActorPtr->direction != angleModif) { InitRealValue(currentProcessedActorPtr->beta, currentProcessedActorPtr->beta - (angleModif<<8), 60, ¤tProcessedActorPtr->rotate); } @@ -606,7 +642,7 @@ void processTrack(void) } else { - currentProcessedActorPtr->rotate.param = 0; + currentProcessedActorPtr->rotate.numSteps = 0; } } @@ -659,12 +695,12 @@ void processTrack(void) currentProcessedActorPtr->zv.ZVY1 += difY; currentProcessedActorPtr->zv.ZVY2 += difY; - angleModif = computeAngleModificatorToPosition( currentProcessedActorPtr->roomX + currentProcessedActorPtr->stepX, + angleModif = CapObjet( currentProcessedActorPtr->roomX + currentProcessedActorPtr->stepX, currentProcessedActorPtr->roomZ + currentProcessedActorPtr->stepZ, currentProcessedActorPtr->beta, x,z ); - if(!currentProcessedActorPtr->rotate.param || currentProcessedActorPtr->direction != angleModif) + if(!currentProcessedActorPtr->rotate.numSteps || currentProcessedActorPtr->direction != angleModif) { InitRealValue(currentProcessedActorPtr->beta, currentProcessedActorPtr->beta - (angleModif<<8), 60, ¤tProcessedActorPtr->rotate); } @@ -677,7 +713,7 @@ void processTrack(void) } else { - currentProcessedActorPtr->rotate.param = 0; + currentProcessedActorPtr->rotate.numSteps = 0; } } @@ -726,478 +762,3 @@ void processTrack(void) currentProcessedActorPtr->beta &= 0x3FF; } -void processTrack2(void) -{ - switch(currentProcessedActorPtr->trackMode) - { - case 1: // manual - { - GereManualRot(60); - if(localJoyD&1) // forward - { - if(timer - lastTimeForward < 10 && currentProcessedActorPtr->speed != 4) - currentProcessedActorPtr->speed = 5; - else - if(currentProcessedActorPtr->speed == 0 || currentProcessedActorPtr->speed == -1) - currentProcessedActorPtr->speed = 4; - - /* if(currentProcessedActorPtr->speed>0 && currentProcessedActorPtr->speed<4) - currentProcessedActorPtr->speed = 5; */ - - - lastTimeForward = timer; - } - else - { - if(currentProcessedActorPtr->speed>0 && currentProcessedActorPtr->speed<=4) - { - currentProcessedActorPtr->speed--; - } - else - { - currentProcessedActorPtr->speed = 0; - } - } - - if(localJoyD&2) // backward - { - if(currentProcessedActorPtr->speed == 0 || currentProcessedActorPtr->speed >= 4) - currentProcessedActorPtr->speed = -1; - - if(currentProcessedActorPtr->speed == 5) - currentProcessedActorPtr->speed = 0; - } - - break; - } - case 2: // follow - { - int followedActorIdx = ListWorldObjets[currentProcessedActorPtr->trackNumber].objIndex; - - if(followedActorIdx == -1) - { - currentProcessedActorPtr->direction = 0; - currentProcessedActorPtr->speed = 0; - } - else - { - tObject* followedActorPtr = &objectTable[followedActorIdx]; - - int roomNumber = followedActorPtr->room; - int x = followedActorPtr->roomX; - //int y = followedActorPtr->roomY; - int z = followedActorPtr->roomZ; - int angleModif; - - if(currentProcessedActorPtr->room != roomNumber) - { - /* char* link = getRoomLink(currentProcessedActorPtr->room,roomNumber); - - x = *(s16*)(link)+(((*(s16*)(link+2))-(*(s16 *)(link))) / 2); - y = *(s16*)(link+4)+(((*(s16*)(link+6))-(*(s16 *)(link+4))) / 2); - z = *(s16*)(link+8)+(((*(s16*)(link+10))-(*(s16 *)(link+8))) / 2); */ - } - - angleModif = computeAngleModificatorToPosition( currentProcessedActorPtr->roomX + currentProcessedActorPtr->stepX, - currentProcessedActorPtr->roomZ + currentProcessedActorPtr->stepZ, - currentProcessedActorPtr->beta, x, z ); - - if( currentProcessedActorPtr->rotate.param == 0 || currentProcessedActorPtr->direction != angleModif ) - { - InitRealValue( currentProcessedActorPtr->beta, currentProcessedActorPtr->beta - (angleModif << 8), 60, ¤tProcessedActorPtr->rotate); - } - - currentProcessedActorPtr->direction = angleModif; - - if( currentProcessedActorPtr->direction == 0 ) - { - currentProcessedActorPtr->rotate.param = 0; - } - else - { - currentProcessedActorPtr->beta = updateActorRotation(¤tProcessedActorPtr->rotate); - } - - currentProcessedActorPtr->speed = 4; - - } - break; - } - case 3: // track - { - char* trackPtr = HQR_Get(listTrack,currentProcessedActorPtr->trackNumber); - s16 trackMacro; - - trackPtr+=currentProcessedActorPtr->positionInTrack * 2; - - trackMacro = *(s16*)trackPtr; - trackPtr += 2; - - //printf("Track macro %X\n",trackMacro); - - switch(trackMacro) - { - case 0: // warp - { - int roomNumber = *(s16*)(trackPtr); - trackPtr += 2; - - if(currentProcessedActorPtr->room != roomNumber) - { - if(currentCameraTargetActor == currentProcessedActorIdx) - { - needChangeRoom = 1; - newRoom = roomNumber; - } - - currentProcessedActorPtr->room = roomNumber; - } - - currentProcessedActorPtr->zv.ZVX1 -= currentProcessedActorPtr->roomX + currentProcessedActorPtr->stepX; - currentProcessedActorPtr->zv.ZVX2 -= currentProcessedActorPtr->roomX + currentProcessedActorPtr->stepX; - currentProcessedActorPtr->zv.ZVY1 -= currentProcessedActorPtr->roomY + currentProcessedActorPtr->stepY; - currentProcessedActorPtr->zv.ZVY2 -= currentProcessedActorPtr->roomY + currentProcessedActorPtr->stepY; - currentProcessedActorPtr->zv.ZVZ1 -= currentProcessedActorPtr->roomZ + currentProcessedActorPtr->stepZ; - currentProcessedActorPtr->zv.ZVZ2 -= currentProcessedActorPtr->roomZ + currentProcessedActorPtr->stepZ; - - currentProcessedActorPtr->worldX = currentProcessedActorPtr->roomX = *(s16*)(trackPtr); - trackPtr += 2; - currentProcessedActorPtr->worldY = currentProcessedActorPtr->roomY = *(s16*)(trackPtr); - trackPtr += 2; - currentProcessedActorPtr->worldZ = currentProcessedActorPtr->roomZ = *(s16*)(trackPtr); - trackPtr += 2; - - currentProcessedActorPtr->worldX -= (s16)((roomDataTable[currentRoom].worldX - roomDataTable[currentProcessedActorPtr->room].worldX) * 10); - currentProcessedActorPtr->worldY += (s16)((roomDataTable[currentRoom].worldY - roomDataTable[currentProcessedActorPtr->room].worldY) * 10); - currentProcessedActorPtr->worldZ += (s16)((roomDataTable[currentRoom].worldZ - roomDataTable[currentProcessedActorPtr->room].worldZ) * 10); - - currentProcessedActorPtr->zv.ZVX1 += currentProcessedActorPtr->roomX + currentProcessedActorPtr->stepX; - currentProcessedActorPtr->zv.ZVX2 += currentProcessedActorPtr->roomX + currentProcessedActorPtr->stepX; - currentProcessedActorPtr->zv.ZVY1 += currentProcessedActorPtr->roomY + currentProcessedActorPtr->stepY; - currentProcessedActorPtr->zv.ZVY2 += currentProcessedActorPtr->roomY + currentProcessedActorPtr->stepY; - currentProcessedActorPtr->zv.ZVZ1 += currentProcessedActorPtr->roomZ + currentProcessedActorPtr->stepZ; - currentProcessedActorPtr->zv.ZVZ2 += currentProcessedActorPtr->roomZ + currentProcessedActorPtr->stepZ; - - currentProcessedActorPtr->speed = 0; - currentProcessedActorPtr->direction = 0; - currentProcessedActorPtr->rotate.param = 0; - currentProcessedActorPtr->positionInTrack += 5; - - break; - } - case 1: // goToPosition - { - int roomNumber = *(s16*)(trackPtr); - int x; - int y; - int z; - unsigned int distanceToPoint; - - trackPtr += 2; - - x = *(s16*)(trackPtr); - trackPtr += 2; - y = 0; - z = *(s16*)(trackPtr); - trackPtr += 2; - - if(roomNumber != currentProcessedActorPtr->room) - { - x -= (roomDataTable[currentProcessedActorPtr->room].worldX - roomDataTable[roomNumber].worldX) * 10; - z += (roomDataTable[currentProcessedActorPtr->room].worldZ - roomDataTable[roomNumber].worldZ) * 10; - } - - distanceToPoint = computeDistanceToPoint( currentProcessedActorPtr->roomX + currentProcessedActorPtr->stepX, - currentProcessedActorPtr->roomZ + currentProcessedActorPtr->stepZ, - x,z ); - - - if(distanceToPoint >= DISTANCE_TO_POINT_TRESSHOLD) // not yet at position - { - int angleModif = computeAngleModificatorToPosition( currentProcessedActorPtr->roomX + currentProcessedActorPtr->stepX, - currentProcessedActorPtr->roomZ + currentProcessedActorPtr->stepZ, - currentProcessedActorPtr->beta, - x,z ); - - if(currentProcessedActorPtr->rotate.param == 0 || currentProcessedActorPtr->direction != angleModif) - { - InitRealValue(currentProcessedActorPtr->beta, currentProcessedActorPtr->beta - (angleModif<<6), 15, ¤tProcessedActorPtr->rotate); - } - - currentProcessedActorPtr->direction = angleModif; - - if(!angleModif) - { - currentProcessedActorPtr->rotate.param = 0; - } - else - { - currentProcessedActorPtr->beta = updateActorRotation(¤tProcessedActorPtr->rotate); - } - } - else // reached position - { - currentProcessedActorPtr->positionInTrack += 4; - } - - break; - } - case 2: // stop - { - currentProcessedActorPtr->speed = 0; - currentProcessedActorPtr->trackNumber = -1; - setMoveMode(0,0); - break; - } - case 3: - { - currentProcessedActorPtr->positionInTrack = 0; - break; - } - case 4: // MARK - { - currentProcessedActorPtr->MARK = *(s16*)(trackPtr); - trackPtr += 2; - currentProcessedActorPtr->positionInTrack += 2; - break; - } - case 5: - { - break; - } - case 0x6: - { - int betaDif = *(s16*)(trackPtr); - trackPtr += 2; - - if(((currentProcessedActorPtr->beta - betaDif)&0x3FF) > 0x200) - { - currentProcessedActorPtr->direction = 1; - } - else - { - currentProcessedActorPtr->direction = -1; - } - - if(!currentProcessedActorPtr->rotate.param) - { - InitRealValue(currentProcessedActorPtr->beta, betaDif, 120, ¤tProcessedActorPtr->rotate); - } - - currentProcessedActorPtr->beta = updateActorRotation(¤tProcessedActorPtr->rotate); - - if(currentProcessedActorPtr->beta == betaDif) - { - currentProcessedActorPtr->direction = 0; - - currentProcessedActorPtr->positionInTrack+=2; - } - - break; - } - case 0x7: - { - currentProcessedActorPtr->dynFlags &= 0xFFFE; - currentProcessedActorPtr->positionInTrack++; - break; - } - case 0x8: - { - currentProcessedActorPtr->dynFlags |= 1; - currentProcessedActorPtr->positionInTrack++; - break; - } - case 0xA: - { - currentProcessedActorPtr->_flags &= 0xFFBF; - currentProcessedActorPtr->positionInTrack++; - break; - } - case 0xB: - { - currentProcessedActorPtr->_flags |= 0x40; - currentProcessedActorPtr->positionInTrack++; - break; - }/* - case 0x10: - { - int objNum = currentProcessedActorPtr->field_0; - - objectTable[objNum].x = currentProcessedActorPtr->roomX + currentProcessedActorPtr->modX; - objectTable[objNum].y = currentProcessedActorPtr->roomY + currentProcessedActorPtr->modY; - objectTable[objNum].z = currentProcessedActorPtr->roomZ + currentProcessedActorPtr->modZ; - - currentProcessedActorPtr->positionInTrack++; - - break; - } - case 0x11: // walk up/down stairs on X - { - int x; - int y; - int z; - int objX; - int objY; - int objZ; - - x = *(s16*)(trackPtr); - trackPtr += 2; - y = *(s16*)(trackPtr); - trackPtr += 2; - z = *(s16*)(trackPtr); - trackPtr += 2; - - objX = objectTable[currentProcessedActorPtr->field_0].x; - objY = objectTable[currentProcessedActorPtr->field_0].y; - objZ = objectTable[currentProcessedActorPtr->field_0].z; - - if( currentProcessedActorPtr->roomY + currentProcessedActorPtr->modY < y - 100 - || currentProcessedActorPtr->roomY + currentProcessedActorPtr->modY > y + 100) - { - int propX = makeProportional(objY, y, x - objX, (currentProcessedActorPtr->roomX + currentProcessedActorPtr->modX) - objX); - - int difY = propX - currentProcessedActorPtr->worldY; - int angleModif; - - currentProcessedActorPtr->worldY += difY; - currentProcessedActorPtr->roomY += difY; - currentProcessedActorPtr->zv.ZVY1 += difY; - currentProcessedActorPtr->zv.ZVY2 += difY; - - angleModif = computeAngleModificatorToPosition( currentProcessedActorPtr->roomX + currentProcessedActorPtr->modX, - currentProcessedActorPtr->roomZ + currentProcessedActorPtr->modZ, - currentProcessedActorPtr->beta, - x,z ); - - if(!currentProcessedActorPtr->rotate.param || currentProcessedActorPtr->field_72 != angleModif) - { - startActorRotation(currentProcessedActorPtr->beta, currentProcessedActorPtr->beta - (angleModif<<8), 60, ¤tProcessedActorPtr->rotate); - } - - currentProcessedActorPtr->field_72 = angleModif; - - if(angleModif) - { - currentProcessedActorPtr->beta = updateActorRotation(¤tProcessedActorPtr->rotate); - } - else - { - currentProcessedActorPtr->rotate.param = 0; - } - - } - else - { - int difY = y - currentProcessedActorPtr->worldY; - - currentProcessedActorPtr->modY = 0; - currentProcessedActorPtr->worldY += difY; - currentProcessedActorPtr->roomY += difY; - currentProcessedActorPtr->zv.ZVY1 += difY; - currentProcessedActorPtr->zv.ZVY2 += difY; - - currentProcessedActorPtr->positionInTrack +=4; - } - - break; - } - case 0x12: // walk up/down stairs on Z - { - int x; - int y; - int z; - int objX; - int objY; - int objZ; - - x = *(s16*)(trackPtr); - trackPtr += 2; - y = *(s16*)(trackPtr); - trackPtr += 2; - z = *(s16*)(trackPtr); - trackPtr += 2; - - objX = objectTable[currentProcessedActorPtr->field_0].x; - objY = objectTable[currentProcessedActorPtr->field_0].y; - objZ = objectTable[currentProcessedActorPtr->field_0].z; - - if( currentProcessedActorPtr->roomY + currentProcessedActorPtr->modY < y - 100 - || currentProcessedActorPtr->roomY + currentProcessedActorPtr->modY > y + 100) - { - int propZ = makeProportional(objY, y, z - objZ, (currentProcessedActorPtr->roomZ + currentProcessedActorPtr->modZ) - objZ); - - int difY = propZ - currentProcessedActorPtr->worldY; - - int angleModif; - - currentProcessedActorPtr->worldY += difY; - currentProcessedActorPtr->roomY += difY; - currentProcessedActorPtr->zv.ZVY1 += difY; - currentProcessedActorPtr->zv.ZVY2 += difY; - - angleModif = computeAngleModificatorToPosition( currentProcessedActorPtr->roomX + currentProcessedActorPtr->modX, - currentProcessedActorPtr->roomZ + currentProcessedActorPtr->modZ, - currentProcessedActorPtr->beta, - x,z ); - - if(!currentProcessedActorPtr->rotate.param || currentProcessedActorPtr->field_72 != angleModif) - { - startActorRotation(currentProcessedActorPtr->beta, currentProcessedActorPtr->beta - (angleModif<<8), 60, ¤tProcessedActorPtr->rotate); - } - - currentProcessedActorPtr->field_72 = angleModif; - - if(angleModif) - { - currentProcessedActorPtr->beta = updateActorRotation(¤tProcessedActorPtr->rotate); - } - else - { - currentProcessedActorPtr->rotate.param = 0; - } - - } - else - { - int difY = y - currentProcessedActorPtr->worldY; - - currentProcessedActorPtr->modY = 0; - currentProcessedActorPtr->worldY += difY; - currentProcessedActorPtr->roomY += difY; - currentProcessedActorPtr->zv.ZVY1 += difY; - currentProcessedActorPtr->zv.ZVY2 += difY; - - currentProcessedActorPtr->positionInTrack +=4; - } - - break; - } - case 0x13: // rotate - { - currentProcessedActorPtr->alpha = *(s16*)(trackPtr); - trackPtr += 2; - currentProcessedActorPtr->beta = *(s16*)(trackPtr); - trackPtr += 2; - currentProcessedActorPtr->gamma = *(s16*)(trackPtr); - trackPtr += 2; - - currentProcessedActorPtr->field_72 = 0; - - currentProcessedActorPtr->positionInTrack +=4; - - break; - } */ - default: - { - printf("Unknown track macro %X\n",trackMacro); - assert(0); - break; - } - } - - break; - } - } - - currentProcessedActorPtr->beta &= 0x3FF; -} diff --git a/FitdLib/track.h b/FitdLib/track.h index 7bbe32b..9a585b7 100644 --- a/FitdLib/track.h +++ b/FitdLib/track.h @@ -2,7 +2,6 @@ #define _TRACK_ void processTrack(void); -void processTrack2(void); void GereManualRot(int param); #endif diff --git a/FitdLib/vars.cpp b/FitdLib/vars.cpp index d3de9ac..a7dfc41 100644 --- a/FitdLib/vars.cpp +++ b/FitdLib/vars.cpp @@ -2,11 +2,7 @@ enum gameTypeEnum g_gameId; -char* currentFoundBody; -int currentFoundBodyIdx; -int statusVar1; - -hqrEntryStruct* HQ_Memory; +hqrEntryStruct* HQ_Memory; int videoMode; int musicConfigured; @@ -14,7 +10,6 @@ int musicEnabled; char* aux; char* aux2; -std::vector> BufferAnim; char* logicalScreen; @@ -29,12 +24,10 @@ char* PtrFont; char* PtrCadre; -unsigned char currentGamePalette[256*3]; +palette_t currentGamePalette; //OSystem osystem; -char rgbaBuffer[320*200*4]; - unsigned int timer; unsigned int timeGlobal; @@ -55,14 +48,16 @@ char localClick; const std::vector languageNameTable = { + "TEXTES", + "ENGLISH", + "USA", "FRANCAIS", "ITALIANO", - "ENGLISH", "ESPAGNOL", "DEUTSCH", }; -char languageNameString[20] = ""; +std::string languageNameString; regularTextEntryStruct textTable[NUM_MAX_TEXT]; @@ -76,17 +71,16 @@ char* screenSm3; char* screenSm4; char* screenSm5; -tObject objectTable[NUM_MAX_OBJECT]; +std::array ListObjets; s16 currentWorldTarget; int fileSize; -hqrEntryStruct* listBody; -hqrEntryStruct* listAnim; -hqrEntryStruct* listLife; -hqrEntryStruct* listTrack; -hqrEntryStruct* listMatrix; +hqrEntryStruct* HQ_Bodys = nullptr; +hqrEntryStruct* listLife = nullptr; +hqrEntryStruct* listTrack = nullptr; +hqrEntryStruct* HQ_Matrices = nullptr; s16 maxObjects; @@ -106,12 +100,12 @@ boxStruct genVar4[50]; boxStruct *genVar1; boxStruct *genVar3; -int genVar5; -int genVar6; +int NbPhysBoxs; +int NbLogBoxs; int nextSample; int nextMusic; s16 currentCameraTargetActor; -s16 giveUp; +s16 FlagGameOver; s16 lightOff; int lightVar2; int LastPriority; @@ -121,23 +115,23 @@ s16 statusScreenAllowed; char* g_currentFloorRoomRawData = NULL; char* g_currentFloorCameraRawData = NULL; -int changeFloor; -s16 currentCamera; +int FlagChangeEtage; +s16 NumCamera; s16 g_currentFloor; -int needChangeRoom; +int FlagChangeSalle; char* cameraPtr; roomDefStruct* pCurrentRoomData; s16 currentRoom; -int flagInitView; +int FlagInitView; int numCameraInRoom; int numCameraZone; char* cameraZoneData; int numRoomZone; char* roomZoneData; char* room_PtrCamera[NUM_MAX_CAMERA_IN_ROOM]; -int startGameVar1; +int NewNumCamera; int transformX; int transformY; @@ -164,7 +158,7 @@ int cameraFovY; char currentCameraVisibilityList[30]; -int actorTurnedToObj = 0; +int FlagGenereAffList = 0; int currentProcessedActorIdx; tObject* currentProcessedActorPtr; @@ -197,8 +191,8 @@ int flagRedraw; float renderPointList[6400]; -int numActorInList; -int sortedActorTable[NUM_MAX_OBJECT]; +int NbAffObjets; +std::array Index; int angleCompX; int angleCompZ; @@ -217,11 +211,7 @@ int animStepX; int animStepZ; int animStepY; -char* animVar1; -char* animVar3; -char* animVar4; - -s16 newFloor; +s16 NewNumEtage; int fadeState; @@ -239,7 +229,7 @@ int overlaySize2; int bgOverlayVar1; -s16 newRoom; +s16 NewNumSalle; @@ -277,9 +267,11 @@ int clipBottom = 119; unsigned char* g_MaskPtr = NULL; -hqrEntryStruct* listMus; -hqrEntryStruct* listSamp; +hqrEntryStruct* listMus; +hqrEntryStruct* listSamp; #if defined(FITD_DEBUGGER) backgroundModeEnum backgroundMode = backgroundModeEnum_2D; +collisiosDisplayMode hardColDisplayMode = displayNone; +collisiosDisplayMode sceColDisplayMode = displayNone; #endif diff --git a/FitdLib/vars.h b/FitdLib/vars.h index ff9faaa..d998728 100644 --- a/FitdLib/vars.h +++ b/FitdLib/vars.h @@ -2,10 +2,6 @@ #include "osystem.h" -extern char* currentFoundBody; -extern int currentFoundBodyIdx; -extern int statusVar1; - enum gameTypeEnum { AITD1, @@ -59,28 +55,6 @@ struct regularTextEntryStruct typedef struct regularTextEntryStruct regularTextEntryStruct; -struct hqrSubEntryStruct -{ - s16 key; - s16 size; - unsigned int lastTimeUsed; - char* ptr; -}; - -typedef struct hqrSubEntryStruct hqrSubEntryStruct; - -struct hqrEntryStruct -{ - char string[10]; - u16 maxFreeData; - u16 sizeFreeData; - u16 numMaxEntry; - u16 numUsedEntry; - hqrSubEntryStruct* entries; -}; - -typedef struct hqrEntryStruct hqrEntryStruct; - struct ZVStruct { s32 ZVX1; @@ -93,15 +67,25 @@ struct ZVStruct typedef struct ZVStruct ZVStruct; -struct interpolatedValue +struct ZVStruct16 { - s16 oldAngle; - s16 newAngle; - s16 param; - unsigned int timeOfRotate; + s16 ZVX1; + s16 ZVX2; + s16 ZVY1; + s16 ZVY2; + s16 ZVZ1; + s16 ZVZ2; }; -typedef struct interpolatedValue interpolatedValue; +struct RealValue +{ + s16 startValue; + s16 endValue; + s16 numSteps; + unsigned int memoTicks; +}; + +typedef struct RealValue RealValue; enum actorFlags { @@ -115,14 +99,18 @@ enum actorFlags AF_FOUNDABLE = 0x0080, AF_FALLABLE = 0x0100, - AF_MASK = AF_ANIMATED + AF_MOVABLE + AF_TRIGGER + AF_FOUNDABLE + AF_FALLABLE, + // >= JACK + AF_OBJ_2D = 0x0200, + AF_WATER = 0x0400, + + AF_MASK = AF_ANIMATED + AF_MOVABLE + AF_TRIGGER + AF_FOUNDABLE + AF_FALLABLE + AF_WATER, }; struct tObject // used to read data from file too { s16 indexInWorld; s16 bodyNum; - u16 _flags; + u16 objectType; s16 dynFlags; ZVStruct zv; s16 screenXMin; @@ -150,10 +138,11 @@ struct tObject // used to read data from file too s16 newAnim; s16 newAnimType; s16 newAnimInfo; - s16 FRAME; + s16 frame; s16 numOfFrames; s16 END_FRAME; - s16 END_ANIM; + s16 flagEndAnim; + u32 memoTicks; // for 2d objects s16 trackMode; s16 trackNumber; s16 MARK; @@ -167,12 +156,12 @@ struct tObject // used to read data from file too s16 animNegY; s16 animNegZ; - interpolatedValue YHandler; + RealValue YHandler; s16 falling; - interpolatedValue rotate; + RealValue rotate; s16 direction; s16 speed; - interpolatedValue speedChange; + RealValue speedChange; s16 COL[3]; s16 COL_BY; s16 HARD_DEC; @@ -205,7 +194,7 @@ struct tWorldObject s16 typeZV; s16 foundBody; s16 foundName; - s16 flags2; + s16 foundFlag; s16 foundLife; s16 x; s16 y; @@ -254,10 +243,10 @@ struct roomDefStruct typedef struct roomDefStruct roomDefStruct; -extern hqrEntryStruct* HQ_Memory; - -extern hqrEntryStruct* listMus; -extern hqrEntryStruct* listSamp; +#include "hqr.h" +extern hqrEntryStruct* HQ_Memory; +extern hqrEntryStruct* listMus; +extern hqrEntryStruct* listSamp; extern int videoMode; extern int musicConfigured; @@ -266,11 +255,6 @@ extern int musicEnabled; extern char* aux; extern char* aux2; -#define NB_BUFFER_ANIM 25 // AITD1 was 20 -#define SIZE_BUFFER_ANIM (8*41) // AITD1 was 4*31 - -extern std::vector> BufferAnim; - extern char* logicalScreen; extern int screenBufferSize; @@ -284,11 +268,8 @@ extern char* PtrFont; extern char* PtrCadre; -extern unsigned char currentGamePalette[0x300]; - //extern OSystem osystem; extern unsigned char frontBuffer[320*200]; -extern char rgbaBuffer[320*200*4]; extern unsigned int timer; extern unsigned int timeGlobal; @@ -310,7 +291,7 @@ extern char localKey; extern char localJoyD; extern char localClick; -extern char languageNameString[]; +extern std::string languageNameString; extern const std::vector languageNameTable; extern regularTextEntryStruct textTable[40]; @@ -325,17 +306,16 @@ extern char* screenSm3; extern char* screenSm4; extern char* screenSm5; -extern tObject objectTable[NUM_MAX_OBJECT]; +extern std::array ListObjets; extern s16 currentWorldTarget; extern int fileSize; -extern hqrEntryStruct* listBody; -extern hqrEntryStruct* listAnim; -extern hqrEntryStruct* listLife; -extern hqrEntryStruct* listTrack; -extern hqrEntryStruct* listMatrix; +extern hqrEntryStruct* HQ_Bodys; +extern hqrEntryStruct* listLife; +extern hqrEntryStruct* listTrack; +extern hqrEntryStruct* HQ_Matrices; extern s16 maxObjects; @@ -355,12 +335,12 @@ extern boxStruct genVar4[50]; extern boxStruct *genVar1; extern boxStruct *genVar3; -extern int genVar5; -extern int genVar6; +extern int NbPhysBoxs; +extern int NbLogBoxs; extern int nextSample; extern int nextMusic; extern s16 currentCameraTargetActor; -extern s16 giveUp; +extern s16 FlagGameOver; extern s16 lightOff; extern int lightVar2; extern int LastPriority; @@ -370,22 +350,22 @@ extern s16 statusScreenAllowed; extern char* g_currentFloorRoomRawData; extern char* g_currentFloorCameraRawData; -extern int changeFloor; -extern s16 currentCamera; +extern int FlagChangeEtage; +extern s16 NumCamera; extern s16 g_currentFloor; -extern int needChangeRoom; +extern int FlagChangeSalle; extern char* cameraPtr; extern roomDefStruct* pCurrentRoomData; extern s16 currentRoom; -extern int flagInitView; +extern int FlagInitView; extern int numCameraInRoom; extern int numCameraZone; extern char* cameraZoneData; extern int numRoomZone; extern char* roomZoneData; extern char* room_PtrCamera[NUM_MAX_CAMERA_IN_ROOM]; -extern int startGameVar1; +extern int NewNumCamera; extern int transformX; extern int transformY; @@ -412,7 +392,7 @@ extern int cameraFovY; extern char currentCameraVisibilityList[30]; -extern int actorTurnedToObj; +extern int FlagGenereAffList; extern int currentProcessedActorIdx; extern tObject* currentProcessedActorPtr; @@ -430,8 +410,8 @@ extern int flagRedraw; extern float renderPointList[6400]; -extern int numActorInList; -extern int sortedActorTable[NUM_MAX_OBJECT]; +extern int NbAffObjets; +extern std::array Index; extern int angleCompX; extern int angleCompZ; @@ -447,11 +427,8 @@ extern int animMoveZ; extern int animStepZ; extern int animStepX; extern int animStepY; -extern char* animVar1; -extern char* animVar3; -extern char* animVar4; -extern s16 newFloor; +extern s16 NewNumEtage; extern int fadeState; @@ -469,7 +446,7 @@ extern int overlaySize2; extern int bgOverlayVar1; -extern s16 newRoom; +extern s16 NewNumSalle; extern const char* listBodySelect[]; extern const char* listAnimSelect[]; @@ -498,6 +475,8 @@ extern int clipBottom; extern unsigned char* g_MaskPtr; +extern std::array uiLayer; + #if defined(FITD_DEBUGGER) enum backgroundModeEnum { @@ -508,13 +487,25 @@ enum backgroundModeEnum typedef enum backgroundModeEnum backgroundModeEnum; extern backgroundModeEnum backgroundMode; + +enum collisiosDisplayMode : int +{ + displayNone, + displayWired, + displayFull, +}; +extern collisiosDisplayMode hardColDisplayMode; +extern collisiosDisplayMode sceColDisplayMode; + #endif struct sGroupState { - s16 m_type; // 8 - s16 m_delta[3]; // A - s16 m_rotateDelta[3]; // 10 (AITD2+) if Info_optimise + s16 m_type; // 0 + point3dStruct m_delta; // 2 + // (AITD2+) if Info_optimise + std::optional m_rotateDelta; // 8 + // 8 / 0x10 }; struct sGroup @@ -524,7 +515,8 @@ struct sGroup s16 m_baseVertices; // 4 s8 m_orgGroup; // 6 s8 m_numGroup; // 7 - sGroupState m_state; + sGroupState m_state;//8 + // 0x16 / 0x22 (AITD2+) if Info_optimise }; enum primTypeEnum @@ -565,30 +557,12 @@ struct sBody { void* m_raw; - u16 m_flags; - ZVStruct m_zv; - std::vector m_scratchBuffer; - std::vector m_vertices; - std::vector m_groupOrder; - std::vector m_groups; + u16 m_flags; //0 size 0x2 + ZVStruct16 m_zv; //2 size 0xC + struct sFrame* startAnim = nullptr; // This is normally stored as 4 bytes at the beginning of scratchBuffer, but we store it here due to pointer size + std::vector m_scratchBuffer; //0xE size u16 + data + std::vector m_vertices; // size u16 count * 6 + std::vector m_groupOrder; // size u16 * 2 + std::vector m_groups; // size u16 std::vector m_primitives; - - void sync(); -}; - -struct sFrame -{ - u16 m_timestamp; - s16 m_animStep[3]; - std::vector m_groups; -}; - -struct sAnimation -{ - void* m_raw; - - u16 m_numFrames; - u16 m_numGroups; - std::vector m_frames; }; - diff --git a/FitdLib/zv.cpp b/FitdLib/zv.cpp index 7b302a8..597835e 100644 --- a/FitdLib/zv.cpp +++ b/FitdLib/zv.cpp @@ -1,34 +1,21 @@ #include "common.h" -void getZvCube(char* bodyPtr, ZVStruct* zvPtr) +void GiveZVObjet(sBody* bodyPtr, ZVStruct* zvPtr) { - s16* ptr; - - ptr = (s16*)(bodyPtr+2); - - zvPtr->ZVX1 = *(ptr++); - zvPtr->ZVX2 = *(ptr++); - zvPtr->ZVY1 = *(ptr++); - zvPtr->ZVY2 = *(ptr++); - zvPtr->ZVZ1 = *(ptr++); - zvPtr->ZVZ2 = *(ptr++); - - zvPtr->ZVZ2 = zvPtr->ZVX2 = (zvPtr->ZVX2 + zvPtr->ZVZ2)/2; - zvPtr->ZVX1 = zvPtr->ZVZ1 = -zvPtr->ZVZ2; + zvPtr->ZVX1 = bodyPtr->m_zv.ZVX1; + zvPtr->ZVX2 = bodyPtr->m_zv.ZVX2; + zvPtr->ZVY1 = bodyPtr->m_zv.ZVY1; + zvPtr->ZVY2 = bodyPtr->m_zv.ZVY2; + zvPtr->ZVZ1 = bodyPtr->m_zv.ZVZ1; + zvPtr->ZVZ2 = bodyPtr->m_zv.ZVZ2; } -void GiveZVObjet(char* bodyPtr, ZVStruct* zvPtr) +void getZvCube(sBody* bodyPtr, ZVStruct* zvPtr) { - s16* ptr; - - ptr = (s16*)(bodyPtr+2); - - zvPtr->ZVX1 = *(ptr++); - zvPtr->ZVX2 = *(ptr++); - zvPtr->ZVY1 = *(ptr++); - zvPtr->ZVY2 = *(ptr++); - zvPtr->ZVZ1 = *(ptr++); - zvPtr->ZVZ2 = *(ptr++); + GiveZVObjet(bodyPtr, zvPtr); + + zvPtr->ZVZ2 = zvPtr->ZVX2 = (zvPtr->ZVX2 + zvPtr->ZVZ2)/2; + zvPtr->ZVX1 = zvPtr->ZVZ1 = -zvPtr->ZVZ2; } void makeDefaultZV(ZVStruct* zvPtr) @@ -43,7 +30,7 @@ void makeDefaultZV(ZVStruct* zvPtr) zvPtr->ZVZ2 = 100; } -void getZvMax(char* bodyPtr, ZVStruct* zvPtr) +void getZvMax(sBody* bodyPtr, ZVStruct* zvPtr) { int x1; int x2; @@ -74,3 +61,113 @@ void getZvMax(char* bodyPtr, ZVStruct* zvPtr) zvPtr->ZVZ1 = -x2; zvPtr->ZVZ2 = x2; } + +void zvRotSub(int X, int Y, int Z, int alpha, int beta, int gamma) +{ + if (alpha || beta || gamma) + { + setupPointRotate(alpha, beta, gamma); + pointRotate(X, Y, Z, &animMoveX, &animMoveY, &animMoveZ); + } + else + { + animMoveX = X; + animMoveY = Y; + animMoveZ = Z; + } +} + +void getZvRot(sBody* bodyPtr, ZVStruct* zvPtr, int alpha, int beta, int gamma) +{ + int X1 = 32000; + int Y1 = 32000; + int Z1 = 32000; + + int X2 = -32000; + int Y2 = -32000; + int Z2 = -32000; + + int i; + int tempX; + int tempY; + int tempZ; + + GiveZVObjet(bodyPtr, zvPtr); + + for (i = 0; i < 8; i++) + { + switch (i) + { + case 0: + { + tempX = zvPtr->ZVX1; + tempY = zvPtr->ZVY1; + tempZ = zvPtr->ZVZ1; + break; + } + case 1: + { + tempZ = zvPtr->ZVZ2; + break; + } + case 2: + { + tempX = zvPtr->ZVX2; + break; + } + case 3: + { + tempZ = zvPtr->ZVZ1; + break; + } + case 4: + { + tempY = zvPtr->ZVY2; + break; + } + case 5: + { + tempX = zvPtr->ZVX1; + break; + } + case 6: + { + tempZ = zvPtr->ZVZ2; + break; + } + case 7: + { + tempX = zvPtr->ZVX2; + break; + } + } + + zvRotSub(tempX, tempY, tempZ, alpha, beta, gamma); + + if (animMoveX < X1) + X1 = animMoveX; + + if (animMoveX > X2) + X2 = animMoveX; + + if (animMoveY < Y1) + Y1 = animMoveY; + + if (animMoveY > Y2) + Y2 = animMoveY; + + if (animMoveZ < Z1) + Z1 = animMoveZ; + + if (animMoveZ > Z2) + Z2 = animMoveZ; + + } + + zvPtr->ZVX1 = X1; + zvPtr->ZVX2 = X2; + zvPtr->ZVY1 = Y1; + zvPtr->ZVY2 = Y2; + zvPtr->ZVZ1 = Z1; + zvPtr->ZVZ2 = Z2; +} diff --git a/FitdLib/zv.h b/FitdLib/zv.h index a0d85ac..ad47f74 100644 --- a/FitdLib/zv.h +++ b/FitdLib/zv.h @@ -1,8 +1,8 @@ #ifndef _ZV_H_ #define _ZV_H_ -void getZvCube(char* bodyPtr, ZVStruct* zvPtr); -void GiveZVObjet(char* bodyPtr, ZVStruct* zvPtr); -void getZvMax(char* bodyPtr, ZVStruct* zvPtr); +void getZvCube(sBody* bodyPtr, ZVStruct* zvPtr); +void GiveZVObjet(sBody* bodyPtr, ZVStruct* zvPtr); +void getZvMax(sBody* bodyPtr, ZVStruct* zvPtr); +void getZvRot(sBody* bodyPtr, ZVStruct* zvPtr, int alpha, int beta, int gamma); void makeDefaultZV(ZVStruct* zvPtr); -void getZvMax(char* bodyPtr, ZVStruct* zvPtr); #endif diff --git a/README.md b/README.md index 357a637..505a162 100644 --- a/README.md +++ b/README.md @@ -2,10 +2,28 @@ Free in the Dark, a Alone in the Dark engine reimplementation. -Long overdue source code update from the version that was released on source forge in the 2000s. -Only buildable with Visual Studio 2022 for now but other platform should be fairly straight forward. +The goal of this project is to make playable on modern machines the "Alone in the Dark" (AITD) games released from 1992 to 1995 by Infograms. +The focus is on the versions currently available on Steam and GOG (some other versions like Alone in the Dark 3 windows versions are incompatible for now). -Rendering is being rewritten to bgfx, for better portability. There is still some graphical artifacts. +Steam: +* [Alone in the Dark 1](https://store.steampowered.com/app/548090/Alone_in_the_Dark_1/) +* [Alone in the Dark 2](https://store.steampowered.com/app/548890/Alone_in_the_Dark_2/) +* [Alone in the Dark 3](https://store.steampowered.com/app/548900/Alone_in_the_Dark_3/) + +[GOG](https://www.gog.com/en/game/alone_in_the_dark_the_trilogy_123) version available as a trilogy. + +Jack in the Dark that was included in some releases is also supported. + +Additionaly, there is (very) early support for "Timegate: Knights Chase" released by Infogram in 1995 using a slightly upgraded engine. + +[Steam](https://store.steampowered.com/app/781280/Time_Gate_Knights_Chase/) version, and [GOG](https://www.gog.com/en/game/time_gate_knights_chase) versions. + +## Status +* Graphical issues and missing features in all games +* AITD1 was completable at some point (with some missing features), but might have regressed +* Jack in the Dark was also completable at some point. +* Other games are considered non-completable due to a variety of missing features or bugs. +* Current focus is to make games completable and fixing some of the graphics shortcomings. ## Build instructions * Requires VS2022 with CMake module installed (you can also provide your own cmake but vs2022.bat won't work out of the box). diff --git a/ThirdParty/SDL b/ThirdParty/SDL index 877399b..8d60435 160000 --- a/ThirdParty/SDL +++ b/ThirdParty/SDL @@ -1 +1 @@ -Subproject commit 877399b2b2cf21e67554ed9046410f268ce1d1b2 +Subproject commit 8d604353a53853fa56d1bdce0363535605ca868f diff --git a/ThirdParty/bgfx.cmake b/ThirdParty/bgfx.cmake index 417f8b8..657dd62 160000 --- a/ThirdParty/bgfx.cmake +++ b/ThirdParty/bgfx.cmake @@ -1 +1 @@ -Subproject commit 417f8b82ef76ef19a0f3efd93d32088c9b3331a0 +Subproject commit 657dd625515d6324a82b734c1e6f81e08cf1f1ee diff --git a/ThirdParty/soloud.cmake/CMakeLists.txt b/ThirdParty/soloud.cmake/CMakeLists.txt index 9a98654..0532c76 100644 --- a/ThirdParty/soloud.cmake/CMakeLists.txt +++ b/ThirdParty/soloud.cmake/CMakeLists.txt @@ -1,16 +1,6 @@ cmake_minimum_required(VERSION 3.0.0) project(soloud C) -IF(${CMAKE_SYSTEM_NAME} MATCHES iOS) -set(SOLOUD_LIB_NAME soloud) -ELSEIF(${CMAKE_SYSTEM_NAME} MATCHES tvOS) -Set(SOLOUD_LIB_NAME soloud) -ELSEIF(${CMAKE_SYSTEM_NAME} MATCHES Darwin) -Set(SOLOUD_LIB_NAME soloud) -ELSE() -set(SOLOUD_LIB_NAME soloud) -ENDIF() - file(GLOB_RECURSE SOLOUD_HEADERS ${soloud_SOURCE_DIR}/soloud/include/*.h) file(GLOB_RECURSE SOLOUD_SOURCES ${soloud_SOURCE_DIR}/soloud/src/core/*.cpp @@ -26,11 +16,7 @@ ${SOLOUD_HEADERS} ${SOLOUD_SOURCES} ) -add_library(${SOLOUD_LIB_NAME} STATIC ${SOLOUD_SOURCES}) +add_library(soloud STATIC ${SOLOUD_SOURCES}) set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3") -IF(${CMAKE_SYSTEM_NAME} STREQUAL watchOS) -target_compile_definitions(${SOLOUD_LIB_NAME} PRIVATE WITH_NULL=1) -ELSE() -target_compile_definitions(${SOLOUD_LIB_NAME} PRIVATE WITH_SDL3_STATIC=1) -ENDIF() +target_compile_definitions(soloud PRIVATE WITH_SDL3_STATIC=1) diff --git a/ThirdParty/soloud.cmake/soloud b/ThirdParty/soloud.cmake/soloud index 467259e..e9e8aea 160000 --- a/ThirdParty/soloud.cmake/soloud +++ b/ThirdParty/soloud.cmake/soloud @@ -1 +1 @@ -Subproject commit 467259ef305251b43b26ad91229189f659240c91 +Subproject commit e9e8aea38d65a6f3a565ccf6103a4883ae8bb9c6