Shipwright/libultraship/libultraship/Scene.cpp
Random 09432ee7f4
Linux/GCC Support (#28)
* Initial Linux/GCC support commit

* Add instructins for linux in the README

* apply suggestions by @Erotemic and @Emill

* Fix python 3.10 symlink line

* Fix func_80041E80 type mismatch (#3)

Type mismatch functions.h:664

* Makefile: clean OTRExporter/libultraship/ZAPDTR with distclean and fix CXX_FILES

* Makefile: find C/CXX_FILES automatically

* Makefile: remove ugly conditions in find commands

* cleanup _MSC_VER usage

* fix Windows build

* cleanup extraction scripts

* fix Windows build

* Fix Windows path separator issue

* fix rumble support for linux

* use glew-cmake in dockerfile

* add pulseaudio backend

* fix ZAPDTR linkage

* Check for "soh.elf" in directory (#6)

hide second button if `soh.exe` or `soh.elf` is present

* Fix hardcoded segment addresses (#5)

* fix condition

* hack lus -> soh dep for ZAPDTR

Co-authored-by: sholdee <102821812+sholdee@users.noreply.github.com>
Co-authored-by: qurious-pixel <62252937+qurious-pixel@users.noreply.github.com>
Co-authored-by: GaryOderNichts <12049776+GaryOderNichts@users.noreply.github.com>
2022-05-11 13:18:24 -04:00

440 lines
12 KiB
C++

#include "Scene.h"
namespace Ship
{
Scene::~Scene()
{
int bp = 0;
}
void SceneV0::ParseFileBinary(BinaryReader* reader, Resource* res)
{
Scene* scene = (Scene*)res;
ResourceFile::ParseFileBinary(reader, res);
uint32_t cmdCnt = reader->ReadUInt32();
scene->commands.reserve(cmdCnt);
for (uint32_t i = 0; i < cmdCnt; i++)
scene->commands.push_back(ParseSceneCommand(reader));
}
SceneCommand* SceneV0::ParseSceneCommand(BinaryReader* reader)
{
SceneCommandID cmdID = (SceneCommandID)reader->ReadInt32();
reader->Seek(-4, SeekOffsetType::Current);
switch (cmdID)
{
case SceneCommandID::SetStartPositionList: return new SetStartPositionList(reader);
case SceneCommandID::SetActorList: return new SetActorList(reader);
case SceneCommandID::SetTransitionActorList: return new SetTransitionActorList(reader);
case SceneCommandID::SetWind: return new SetWind(reader);
case SceneCommandID::SetTimeSettings: return new SetTimeSettings(reader);
case SceneCommandID::SetSkyboxModifier: return new SetSkyboxModifier(reader);
case SceneCommandID::SetEchoSettings: return new SetEchoSettings(reader);
case SceneCommandID::SetSoundSettings: return new SetSoundSettings(reader);
case SceneCommandID::SetSkyboxSettings: return new SetSkyboxSettings(reader);
case SceneCommandID::SetRoomBehavior: return new SetRoomBehavior(reader);
case SceneCommandID::SetCsCamera: return new SetCsCamera(reader);
case SceneCommandID::SetMesh: return new SetMesh(reader);
case SceneCommandID::SetCameraSettings: return new SetCameraSettings(reader);
case SceneCommandID::SetLightingSettings: return new SetLightingSettings(reader);
case SceneCommandID::SetLightList: return new SetLightList(reader);
case SceneCommandID::SetRoomList: return new SetRoomList(reader);
case SceneCommandID::SetCollisionHeader: return new SetCollisionHeader(reader);
case SceneCommandID::SetEntranceList: return new SetEntranceList(reader);
case SceneCommandID::SetSpecialObjects: return new SetSpecialObjects(reader);
case SceneCommandID::SetObjectList: return new SetObjectList(reader);
case SceneCommandID::SetAlternateHeaders: return new SetAlternateHeaders(reader);
case SceneCommandID::SetExitList: return new ExitList(reader);
case SceneCommandID::SetCutscenes: return new SetCutscenes(reader);
case SceneCommandID::SetPathways: return new SetPathways(reader);
case SceneCommandID::EndMarker: return new EndMarker(reader);
default:
SPDLOG_ERROR("UNIMPLEMENTED COMMAND: {}", (int)cmdID);
reader->ReadInt32();
break;
}
return nullptr;
}
SceneCommand::SceneCommand(BinaryReader* reader)
{
cmdID = (SceneCommandID)reader->ReadInt32();
}
SetWind::SetWind(BinaryReader* reader) : SceneCommand(reader)
{
windWest = reader->ReadByte();
windVertical = reader->ReadByte();
windSouth = reader->ReadByte();
clothFlappingStrength = reader->ReadByte();
}
ExitList::ExitList(BinaryReader* reader) : SceneCommand(reader)
{
uint32_t numExits = reader->ReadUInt32();
exits.reserve(numExits);
for (uint32_t i = 0; i < numExits; i++)
exits.push_back(reader->ReadUInt16());
}
SetTimeSettings::SetTimeSettings(BinaryReader* reader) : SceneCommand(reader)
{
hour = reader->ReadByte();
min = reader->ReadByte();
unk = reader->ReadByte();
}
SetSkyboxModifier::SetSkyboxModifier(BinaryReader* reader) : SceneCommand(reader)
{
disableSky = reader->ReadByte();
disableSunMoon = reader->ReadByte();
}
SetEchoSettings::SetEchoSettings(BinaryReader* reader) : SceneCommand(reader)
{
echo = reader->ReadByte();
}
SetSoundSettings::SetSoundSettings(BinaryReader* reader) : SceneCommand(reader)
{
reverb = reader->ReadByte();
nightTimeSFX = reader->ReadByte();
musicSequence = reader->ReadByte();
}
SetSkyboxSettings::SetSkyboxSettings(BinaryReader* reader) : SceneCommand(reader)
{
unk1 = reader->ReadByte();
skyboxNumber = reader->ReadByte();
cloudsType = reader->ReadByte();
isIndoors = reader->ReadByte();
}
SetRoomBehavior::SetRoomBehavior(BinaryReader* reader) : SceneCommand(reader)
{
gameplayFlags = reader->ReadByte();
gameplayFlags2 = reader->ReadInt32();
}
SetCsCamera::SetCsCamera(BinaryReader* reader) : SceneCommand(reader)
{
reader->ReadByte(); // camSize
reader->ReadInt32(); // segOffset
// OTRTODO: FINISH!
}
MeshData::MeshData()
{
x = 0;
y = 0;
z = 0;
unk_06 = 0;
// opa;
// xlu;
}
SetMesh::SetMesh(BinaryReader* reader) : SceneCommand(reader)
{
data = reader->ReadByte();
meshHeaderType = reader->ReadByte();
uint32_t numPoly = 1;
if (meshHeaderType != 1)
numPoly = reader->ReadByte();
meshes.reserve(numPoly);
for (uint32_t i = 0; i < numPoly; i++)
{
MeshData mesh;
if (meshHeaderType == 0)
{
int polyType = reader->ReadByte();
mesh.x = 0;
mesh.y = 0;
mesh.z = 0;
mesh.unk_06 = 0;
}
else if (meshHeaderType == 2)
{
int polyType = reader->ReadByte();
mesh.x = reader->ReadInt16();
mesh.y = reader->ReadInt16();
mesh.z = reader->ReadInt16();
mesh.unk_06 = reader->ReadInt16();
}
else
{
mesh.imgFmt = reader->ReadUByte();
mesh.imgOpa = reader->ReadString();
mesh.imgXlu = reader->ReadString();
uint32_t imgCnt = reader->ReadUInt32();
mesh.images.reserve(imgCnt);
for (uint32_t i = 0; i < imgCnt; i++)
{
BGImage img;
img.unk_00 = reader->ReadUInt16();
img.id = reader->ReadUByte();
img.sourceBackground = reader->ReadString();
img.unk_0C = reader->ReadUInt32();
img.tlut = reader->ReadUInt32();
img.width = reader->ReadUInt16();
img.height = reader->ReadUInt16();
img.fmt = reader->ReadUByte();
img.siz = reader->ReadUByte();
img.mode0 = reader->ReadUInt16();
img.tlutCount = reader->ReadUInt16();
mesh.images.push_back(img);
}
int polyType = reader->ReadByte();
int bp = 0;
}
mesh.opa = reader->ReadString();
mesh.xlu = reader->ReadString();
meshes.push_back(mesh);
}
}
SetCameraSettings::SetCameraSettings(BinaryReader* reader) : SceneCommand(reader)
{
cameraMovement = reader->ReadByte();
mapHighlights = reader->ReadInt32();
}
SetLightingSettings::SetLightingSettings(BinaryReader* reader) : SceneCommand(reader)
{
uint32_t cnt = reader->ReadInt32();
settings.reserve(cnt);
for (uint32_t i = 0; i < cnt; i++)
{
LightingSettings entry = LightingSettings();
entry.ambientClrR = reader->ReadByte();
entry.ambientClrG = reader->ReadByte();
entry.ambientClrB = reader->ReadByte();
entry.diffuseDirA_X = reader->ReadByte();
entry.diffuseDirA_Y = reader->ReadByte();
entry.diffuseDirA_Z = reader->ReadByte();
entry.diffuseClrA_R = reader->ReadByte();
entry.diffuseClrA_G = reader->ReadByte();
entry.diffuseClrA_B = reader->ReadByte();
entry.diffuseDirB_X = reader->ReadByte();
entry.diffuseDirB_Y = reader->ReadByte();
entry.diffuseDirB_Z = reader->ReadByte();
entry.diffuseClrB_R = reader->ReadByte();
entry.diffuseClrB_G = reader->ReadByte();
entry.diffuseClrB_B = reader->ReadByte();
entry.fogClrR = reader->ReadByte();
entry.fogClrG = reader->ReadByte();
entry.fogClrB = reader->ReadByte();
entry.fogNear = reader->ReadInt16();
entry.fogFar = reader->ReadUInt16();
settings.push_back(entry);
}
}
SetRoom::SetRoom(BinaryReader* reader)
{
name = reader->ReadString();
vromStart = reader->ReadInt32();
vromEnd = reader->ReadInt32();
}
SetRoomList::SetRoomList(BinaryReader* reader) : SceneCommand(reader)
{
uint32_t numRooms = reader->ReadInt32();
rooms.reserve(numRooms);
for (uint32_t i = 0; i < numRooms; i++)
rooms.push_back(SetRoom(reader));
}
SetCollisionHeader::SetCollisionHeader(BinaryReader* reader) : SceneCommand(reader)
{
filePath = reader->ReadString();
}
SetEntranceList::SetEntranceList(BinaryReader* reader) : SceneCommand(reader)
{
uint32_t cnt = reader->ReadUInt32();
entrances.reserve(cnt);
for (uint32_t i = 0; i < cnt; i++)
{
EntranceEntry entry = EntranceEntry();
entry.startPositionIndex = reader->ReadByte();
entry.roomToLoad = reader->ReadByte();
entrances.push_back(entry);
}
}
SetSpecialObjects::SetSpecialObjects(BinaryReader* reader) : SceneCommand(reader)
{
elfMessage = reader->ReadByte();
globalObject = reader->ReadInt16();
}
SetObjectList::SetObjectList(BinaryReader* reader) : SceneCommand(reader)
{
uint32_t numEntries = reader->ReadUInt32();
objects.reserve(numEntries);
for (uint32_t i = 0; i < numEntries; i++)
objects.push_back(reader->ReadUInt16());
}
SetStartPositionList::SetStartPositionList(BinaryReader* reader) : SceneCommand(reader)
{
uint32_t cnt = reader->ReadUInt32();
entries.reserve(cnt);
for (uint32_t i = 0; i < cnt; i++)
{
ActorSpawnEntry entry = ActorSpawnEntry();
entry.actorNum = reader->ReadUInt16();
entry.posX = reader->ReadInt16();
entry.posY = reader->ReadInt16();
entry.posZ = reader->ReadInt16();
entry.rotX = reader->ReadInt16();
entry.rotY = reader->ReadInt16();
entry.rotZ = reader->ReadInt16();
entry.initVar = reader->ReadUInt16();
entries.push_back(entry);
}
}
SetActorList::SetActorList(BinaryReader* reader) : SceneCommand(reader)
{
uint32_t cnt = reader->ReadUInt32();
entries.reserve(cnt);
for (uint32_t i = 0; i < cnt; i++)
{
ActorSpawnEntry entry = ActorSpawnEntry();
entry.actorNum = reader->ReadUInt16();
entry.posX = reader->ReadInt16();
entry.posY = reader->ReadInt16();
entry.posZ = reader->ReadInt16();
entry.rotX = reader->ReadInt16();
entry.rotY = reader->ReadInt16();
entry.rotZ = reader->ReadInt16();
entry.initVar = reader->ReadUInt16();
entries.push_back(entry);
}
}
SetTransitionActorList::SetTransitionActorList(BinaryReader* reader) : SceneCommand(reader)
{
uint32_t cnt = reader->ReadUInt32();
entries.reserve(cnt);
for (uint32_t i = 0; i < cnt; i++)
{
TransitionActorEntry entry = TransitionActorEntry();
entry.frontObjectRoom = reader->ReadUByte();
entry.frontTransitionReaction = reader->ReadUByte();
entry.backObjectRoom = reader->ReadUByte();
entry.backTransitionReaction = reader->ReadUByte();
entry.actorNum = reader->ReadInt16();
entry.posX = reader->ReadInt16();
entry.posY = reader->ReadInt16();
entry.posZ = reader->ReadInt16();
entry.rotY = reader->ReadInt16();
entry.initVar = reader->ReadUInt16();
entries.push_back(entry);
}
}
EndMarker::EndMarker(BinaryReader* reader) : SceneCommand(reader)
{
}
LightInfo::LightInfo()
{
}
SetLightList::SetLightList(BinaryReader* reader) : SceneCommand(reader)
{
uint32_t cnt = reader->ReadUInt32();
lights.reserve(cnt);
for (uint32_t i = 0; i < cnt; i++)
{
LightInfo light = LightInfo();
light.type = reader->ReadUByte();
light.x = reader->ReadInt16();
light.y = reader->ReadInt16();
light.z = reader->ReadInt16();
light.r = reader->ReadUByte();
light.g = reader->ReadUByte();
light.b = reader->ReadUByte();
light.drawGlow = reader->ReadUByte();
light.radius = reader->ReadInt16();
lights.push_back(light);
}
}
SetAlternateHeaders::SetAlternateHeaders(BinaryReader* reader) : SceneCommand(reader)
{
uint32_t numHeaders = reader->ReadUInt32();
headers.reserve(numHeaders);
for (uint32_t i = 0; i < numHeaders; i++)
headers.push_back(reader->ReadString());
}
SetCutscenes::SetCutscenes(BinaryReader* reader) : SceneCommand(reader)
{
cutscenePath = reader->ReadString();
}
SetPathways::SetPathways(BinaryReader* reader) : SceneCommand(reader)
{
uint32_t numPaths = reader->ReadUInt32();
paths.reserve(numPaths);
for (uint32_t i = 0; i < numPaths; i++)
paths.push_back(reader->ReadString());
}
}