AxioDL/PrimeWorldEditor
2
0
Fork 0
mirror of https://github.com/AxioDL/PrimeWorldEditor.git synced 2025-12-17 08:57:09 +00:00
Code Issues Packages Projects Releases Wiki Activity

Refactor so PWE compiles with the newly externalized LibCommon

Browse Source
This commit is contained in:
Aruki
2018-12-11 22:50:46 -07:00
parent dacd21d7fc
commit 2287b05bc3
298 changed files with 3192 additions and 3184 deletions
Download Patch File Download Diff File Expand all files Collapse all files

78
src/Core/Resource/Cooker/CAreaCooker.cpp
View File

@@ -30,8 +30,8 @@ void CAreaCooker::DetermineSectionNumbersPrime()
// Determine how many sections are taken up by geometry...
// Each world mesh has 7-9 sections (depending on game) plus one section per surface.
u32 GeometrySections = 0;
u32 OriginalMeshCount = mpArea->mOriginalWorldMeshCount;
uint32 GeometrySections = 0;
uint32 OriginalMeshCount = mpArea->mOriginalWorldMeshCount;
switch (mVersion)
{
@@ -47,11 +47,11 @@ void CAreaCooker::DetermineSectionNumbersPrime()
break;
}
for (u32 iMesh = 0; iMesh < mpArea->mWorldModels.size(); iMesh++)
for (uint32 iMesh = 0; iMesh < mpArea->mWorldModels.size(); iMesh++)
GeometrySections += mpArea->mWorldModels[iMesh]->GetSurfaceCount();
// Set section numbers
u32 SecNum = GeometrySections;
uint32 SecNum = GeometrySections;
if (mVersion <= EGame::Prime) mAROTSecNum = SecNum++;
if (mVersion >= EGame::EchoesDemo) mFFFFSecNum = SecNum++;
@@ -81,7 +81,7 @@ void CAreaCooker::DetermineSectionNumbersCorruption()
{
// Because we're copying these from the original file (because not all the numbers
// are present in every file), we don't care about any of these except SCLY and SCGN.
for (u32 iNum = 0; iNum < mpArea->mSectionNumbers.size(); iNum++)
for (uint32 iNum = 0; iNum < mpArea->mSectionNumbers.size(); iNum++)
{
CGameArea::SSectionNumber& rNum = mpArea->mSectionNumbers[iNum];
if (rNum.SectionID == "SOBJ") mSCLYSecNum = rNum.Index;
@@ -124,7 +124,7 @@ void CAreaCooker::WritePrimeHeader(IOutputStream& rOut)
rOut.WriteToBoundary(32, 0);
}
for (u32 iSec = 0; iSec < mSectionSizes.size(); iSec++)
for (uint32 iSec = 0; iSec < mSectionSizes.size(); iSec++)
rOut.WriteLong(mSectionSizes[iSec]);
rOut.WriteToBoundary(32, 0);
@@ -144,14 +144,14 @@ void CAreaCooker::WriteCorruptionHeader(IOutputStream& rOut)
rOut.WriteLong(mpArea->mSectionNumbers.size());
rOut.WriteToBoundary(32, 0);
for (u32 iSec = 0; iSec < mSectionSizes.size(); iSec++)
for (uint32 iSec = 0; iSec < mSectionSizes.size(); iSec++)
rOut.WriteLong(mSectionSizes[iSec]);
rOut.WriteToBoundary(32, 0);
WriteCompressionHeader(rOut);
for (u32 iNum = 0; iNum < mpArea->mSectionNumbers.size(); iNum++)
for (uint32 iNum = 0; iNum < mpArea->mSectionNumbers.size(); iNum++)
{
CGameArea::SSectionNumber& rNum = mpArea->mSectionNumbers[iNum];
rOut.WriteLong(rNum.SectionID.ToLong());
@@ -162,7 +162,7 @@ void CAreaCooker::WriteCorruptionHeader(IOutputStream& rOut)
void CAreaCooker::WriteCompressionHeader(IOutputStream& rOut)
{
for (u32 iCmp = 0; iCmp < mCompressedBlocks.size(); iCmp++)
for (uint32 iCmp = 0; iCmp < mCompressedBlocks.size(); iCmp++)
{
SCompressedBlock& rBlock = mCompressedBlocks[iCmp];
bool IsCompressed = (rBlock.CompressedSize != 0);
@@ -190,37 +190,37 @@ void CAreaCooker::WritePrimeSCLY(IOutputStream& rOut)
rOut.WriteFourCC( FOURCC('SCLY') );
mVersion <= EGame::Prime ? rOut.WriteLong(1) : rOut.WriteByte(1);
u32 NumLayers = mpArea->mScriptLayers.size();
uint32 NumLayers = mpArea->mScriptLayers.size();
rOut.WriteLong(NumLayers);
u32 LayerSizesStart = rOut.Tell();
for (u32 LayerIdx = 0; LayerIdx < NumLayers; LayerIdx++)
uint32 LayerSizesStart = rOut.Tell();
for (uint32 LayerIdx = 0; LayerIdx < NumLayers; LayerIdx++)
rOut.WriteLong(0);
// SCLY
CScriptCooker ScriptCooker(mVersion, true);
std::vector<u32> LayerSizes(NumLayers);
std::vector<uint32> LayerSizes(NumLayers);
for (u32 LayerIdx = 0; LayerIdx < NumLayers; LayerIdx++)
for (uint32 LayerIdx = 0; LayerIdx < NumLayers; LayerIdx++)
{
u32 LayerStart = rOut.Tell();
uint32 LayerStart = rOut.Tell();
ScriptCooker.WriteLayer(rOut, mpArea->mScriptLayers[LayerIdx]);
// Pad the layer to 32 bytes
u32 LayerSize = rOut.Tell() - LayerStart;
u32 PaddedSize = (LayerSize + 31) & ~31;
u32 NumPadBytes = PaddedSize - LayerSize;
uint32 LayerSize = rOut.Tell() - LayerStart;
uint32 PaddedSize = (LayerSize + 31) & ~31;
uint32 NumPadBytes = PaddedSize - LayerSize;
for (u32 Pad = 0; Pad < NumPadBytes; Pad++)
for (uint32 Pad = 0; Pad < NumPadBytes; Pad++)
rOut.WriteByte(0);
LayerSizes[LayerIdx] = PaddedSize;
}
u32 LayersEnd = rOut.Tell();
uint32 LayersEnd = rOut.Tell();
rOut.Seek(LayerSizesStart, SEEK_SET);
for (u32 LayerIdx = 0; LayerIdx < NumLayers; LayerIdx++)
for (uint32 LayerIdx = 0; LayerIdx < NumLayers; LayerIdx++)
rOut.WriteLong(LayerSizes[LayerIdx]);
rOut.Seek(LayersEnd, SEEK_SET);
@@ -241,7 +241,7 @@ void CAreaCooker::WriteEchoesSCLY(IOutputStream& rOut)
// SCLY
CScriptCooker ScriptCooker(mVersion);
for (u32 LayerIdx = 0; LayerIdx < mpArea->mScriptLayers.size(); LayerIdx++)
for (uint32 LayerIdx = 0; LayerIdx < mpArea->mScriptLayers.size(); LayerIdx++)
{
rOut.WriteFourCC( FOURCC('SCLY') );
rOut.WriteByte(1);
@@ -261,7 +261,7 @@ void CAreaCooker::WriteDependencies(IOutputStream& rOut)
{
// Build dependency list
std::list<CAssetID> Dependencies;
std::list<u32> LayerOffsets;
std::list<uint32> LayerOffsets;
CAreaDependencyListBuilder Builder(mpArea->Entry());
Builder.BuildDependencyList(Dependencies, LayerOffsets);
@@ -289,7 +289,7 @@ void CAreaCooker::WriteModules(IOutputStream& rOut)
{
// Build module list
std::vector<TString> ModuleNames;
std::vector<u32> LayerOffsets;
std::vector<uint32> LayerOffsets;
CAreaDependencyTree *pAreaDeps = static_cast<CAreaDependencyTree*>(mpArea->Entry()->Dependencies());
pAreaDeps->GetModuleDependencies(mpArea->Game(), ModuleNames, LayerOffsets);
@@ -297,12 +297,12 @@ void CAreaCooker::WriteModules(IOutputStream& rOut)
// Write
rOut.WriteLong(ModuleNames.size());
for (u32 ModuleIdx = 0; ModuleIdx < ModuleNames.size(); ModuleIdx++)
for (uint32 ModuleIdx = 0; ModuleIdx < ModuleNames.size(); ModuleIdx++)
rOut.WriteString( ModuleNames[ModuleIdx] );
rOut.WriteLong(LayerOffsets.size());
for (u32 OffsetIdx = 0; OffsetIdx < LayerOffsets.size(); OffsetIdx++)
for (uint32 OffsetIdx = 0; OffsetIdx < LayerOffsets.size(); OffsetIdx++)
rOut.WriteLong(LayerOffsets[OffsetIdx]);
FinishSection(false);
@@ -320,10 +320,10 @@ void CAreaCooker::AddSectionToBlock()
void CAreaCooker::FinishSection(bool SingleSectionBlock)
{
// Our section data is now finished in mSection...
const u32 kSizeThreshold = 0x20000;
const uint32 kSizeThreshold = 0x20000;
mSectionData.WriteToBoundary(32, 0);
u32 SecSize = mSectionData.Size();
uint32 SecSize = mSectionData.Size();
mSectionSizes.push_back(SecSize);
// Only track compressed blocks for MP2+. Write everything to one block for MP1.
@@ -349,26 +349,26 @@ void CAreaCooker::FinishBlock()
{
if (mCurBlock.NumSections == 0) return;
std::vector<u8> CompressedBuf(mCompressedData.Size() * 2);
std::vector<uint8> CompressedBuf(mCompressedData.Size() * 2);
bool EnableCompression = (mVersion >= EGame::Echoes) && mpArea->mUsesCompression && !gkForceDisableCompression;
bool UseZlib = (mVersion == EGame::DKCReturns);
u32 CompressedSize = 0;
uint32 CompressedSize = 0;
bool WriteCompressedData = false;
if (EnableCompression)
{
bool Success = CompressionUtil::CompressSegmentedData((u8*) mCompressedData.Data(), mCompressedData.Size(), CompressedBuf.data(), CompressedSize, UseZlib, true);
u32 PadBytes = (32 - (CompressedSize % 32)) & 0x1F;
WriteCompressedData = Success && (CompressedSize + PadBytes < (u32) mCompressedData.Size());
bool Success = CompressionUtil::CompressSegmentedData((uint8*) mCompressedData.Data(), mCompressedData.Size(), CompressedBuf.data(), CompressedSize, UseZlib, true);
uint32 PadBytes = (32 - (CompressedSize % 32)) & 0x1F;
WriteCompressedData = Success && (CompressedSize + PadBytes < (uint32) mCompressedData.Size());
}
if (WriteCompressedData)
{
u32 PadBytes = 32 - (CompressedSize % 32);
uint32 PadBytes = 32 - (CompressedSize % 32);
PadBytes &= 0x1F;
for (u32 iPad = 0; iPad < PadBytes; iPad++)
for (uint32 iPad = 0; iPad < PadBytes; iPad++)
mAreaData.WriteByte(0);
mAreaData.WriteBytes(CompressedBuf.data(), CompressedSize);
@@ -400,7 +400,7 @@ bool CAreaCooker::CookMREA(CGameArea *pArea, IOutputStream& rOut)
Cooker.DetermineSectionNumbersCorruption();
// Write pre-SCLY data sections
for (u32 iSec = 0; iSec < Cooker.mSCLYSecNum; iSec++)
for (uint32 iSec = 0; iSec < Cooker.mSCLYSecNum; iSec++)
{
if (iSec == Cooker.mDepsSecNum)
Cooker.WriteDependencies(Cooker.mSectionData);
@@ -419,8 +419,8 @@ bool CAreaCooker::CookMREA(CGameArea *pArea, IOutputStream& rOut)
Cooker.WriteEchoesSCLY(Cooker.mSectionData);
// Write post-SCLY data sections
u32 PostSCLY = (Cooker.mVersion <= EGame::Prime ? Cooker.mSCLYSecNum + 1 : Cooker.mSCGNSecNum + 1);
for (u32 iSec = PostSCLY; iSec < pArea->mSectionDataBuffers.size(); iSec++)
uint32 PostSCLY = (Cooker.mVersion <= EGame::Prime ? Cooker.mSCLYSecNum + 1 : Cooker.mSCGNSecNum + 1);
for (uint32 iSec = PostSCLY; iSec < pArea->mSectionDataBuffers.size(); iSec++)
{
if (iSec == Cooker.mModulesSecNum)
Cooker.WriteModules(Cooker.mSectionData);
@@ -444,7 +444,7 @@ bool CAreaCooker::CookMREA(CGameArea *pArea, IOutputStream& rOut)
return true;
}
u32 CAreaCooker::GetMREAVersion(EGame Version)
uint32 CAreaCooker::GetMREAVersion(EGame Version)
{
switch (Version)
{

38
src/Core/Resource/Cooker/CAreaCooker.h
View File

@@ -11,28 +11,28 @@ class CAreaCooker
TResPtr<CGameArea> mpArea;
EGame mVersion;
std::vector<u32> mSectionSizes;
std::vector<uint32> mSectionSizes;
u32 mGeometrySecNum;
u32 mSCLYSecNum;
u32 mSCGNSecNum;
u32 mCollisionSecNum;
u32 mUnknownSecNum;
u32 mLightsSecNum;
u32 mVISISecNum;
u32 mPATHSecNum;
u32 mAROTSecNum;
u32 mFFFFSecNum;
u32 mPTLASecNum;
u32 mEGMCSecNum;
u32 mDepsSecNum;
u32 mModulesSecNum;
uint32 mGeometrySecNum;
uint32 mSCLYSecNum;
uint32 mSCGNSecNum;
uint32 mCollisionSecNum;
uint32 mUnknownSecNum;
uint32 mLightsSecNum;
uint32 mVISISecNum;
uint32 mPATHSecNum;
uint32 mAROTSecNum;
uint32 mFFFFSecNum;
uint32 mPTLASecNum;
uint32 mEGMCSecNum;
uint32 mDepsSecNum;
uint32 mModulesSecNum;
struct SCompressedBlock
{
u32 CompressedSize;
u32 DecompressedSize;
u32 NumSections;
uint32 CompressedSize;
uint32 DecompressedSize;
uint32 NumSections;
SCompressedBlock()
: CompressedSize(0), DecompressedSize(0), NumSections(0) {}
@@ -70,7 +70,7 @@ class CAreaCooker
public:
static bool CookMREA(CGameArea *pArea, IOutputStream& rOut);
static u32 GetMREAVersion(EGame Version);
static uint32 GetMREAVersion(EGame Version);
};
#endif // CAREACOOKER_H

112
src/Core/Resource/Cooker/CMaterialCooker.cpp
View File

@@ -6,9 +6,9 @@ CMaterialCooker::CMaterialCooker()
{
}
u32 CMaterialCooker::ConvertFromVertexDescription(FVertexDescription VtxDesc)
uint32 CMaterialCooker::ConvertFromVertexDescription(FVertexDescription VtxDesc)
{
u32 Flags = 0;
uint32 Flags = 0;
if (VtxDesc & ePosition) Flags |= 0x00000003;
if (VtxDesc & eNormal) Flags |= 0x0000000C;
if (VtxDesc & eColor0) Flags |= 0x00000030;
@@ -36,14 +36,14 @@ void CMaterialCooker::WriteMatSetPrime(IOutputStream& rOut)
{
// Gather texture list from the materials before starting
mTextureIDs.clear();
u32 NumMats = mpSet->mMaterials.size();
uint32 NumMats = mpSet->mMaterials.size();
for (u32 iMat = 0; iMat < NumMats; iMat++)
for (uint32 iMat = 0; iMat < NumMats; iMat++)
{
CMaterial *pMat = mpSet->mMaterials[iMat];
u32 NumPasses = pMat->PassCount();
for (u32 iPass = 0; iPass < NumPasses; iPass++)
uint32 NumPasses = pMat->PassCount();
for (uint32 iPass = 0; iPass < NumPasses; iPass++)
{
CTexture *pTex = pMat->Pass(iPass)->Texture();
if (pTex)
@@ -58,21 +58,21 @@ void CMaterialCooker::WriteMatSetPrime(IOutputStream& rOut)
// Write texture IDs
rOut.WriteLong(mTextureIDs.size());
for (u32 iTex = 0; iTex < mTextureIDs.size(); iTex++)
for (uint32 iTex = 0; iTex < mTextureIDs.size(); iTex++)
rOut.WriteLong(mTextureIDs[iTex]);
// Write material offset filler
rOut.WriteLong(NumMats);
u32 MatOffsetsStart = rOut.Tell();
uint32 MatOffsetsStart = rOut.Tell();
for (u32 iMat = 0; iMat < NumMats; iMat++)
for (uint32 iMat = 0; iMat < NumMats; iMat++)
rOut.WriteLong(0);
// Write materials
u32 MatsStart = rOut.Tell();
std::vector<u32> MatEndOffsets(NumMats);
uint32 MatsStart = rOut.Tell();
std::vector<uint32> MatEndOffsets(NumMats);
for (u32 iMat = 0; iMat < NumMats; iMat++)
for (uint32 iMat = 0; iMat < NumMats; iMat++)
{
mpMat = mpSet->mMaterials[iMat];
WriteMaterialPrime(rOut);
@@ -80,10 +80,10 @@ void CMaterialCooker::WriteMatSetPrime(IOutputStream& rOut)
}
// Write material offsets
u32 MatsEnd = rOut.Tell();
uint32 MatsEnd = rOut.Tell();
rOut.Seek(MatOffsetsStart, SEEK_SET);
for (u32 iMat = 0; iMat < NumMats; iMat++)
for (uint32 iMat = 0; iMat < NumMats; iMat++)
rOut.WriteLong(MatEndOffsets[iMat]);
// Done!
@@ -98,19 +98,19 @@ void CMaterialCooker::WriteMatSetCorruption(IOutputStream& /*rOut*/)
void CMaterialCooker::WriteMaterialPrime(IOutputStream& rOut)
{
// Gather data from the passes before we start writing
u32 TexFlags = 0;
u32 NumKonst = 0;
std::vector<u32> TexIndices;
uint32 TexFlags = 0;
uint32 NumKonst = 0;
std::vector<uint32> TexIndices;
for (u32 iPass = 0; iPass < mpMat->mPasses.size(); iPass++)
for (uint32 iPass = 0; iPass < mpMat->mPasses.size(); iPass++)
{
CMaterialPass *pPass = mpMat->Pass(iPass);
if ((pPass->KColorSel() >= 0xC) || (pPass->KAlphaSel() >= 0x10))
{
// Determine the highest Konst index being used
u32 KColorIndex = pPass->KColorSel() % 4;
u32 KAlphaIndex = pPass->KAlphaSel() % 4;
uint32 KColorIndex = pPass->KColorSel() % 4;
uint32 KAlphaIndex = pPass->KAlphaSel() % 4;
if (KColorIndex >= NumKonst)
NumKonst = KColorIndex + 1;
@@ -122,9 +122,9 @@ void CMaterialCooker::WriteMaterialPrime(IOutputStream& rOut)
if (pPassTex != nullptr)
{
TexFlags |= (1 << iPass);
u32 TexID = pPassTex->ID().ToLong();
uint32 TexID = pPassTex->ID().ToLong();
for (u32 iTex = 0; iTex < mTextureIDs.size(); iTex++)
for (uint32 iTex = 0; iTex < mTextureIDs.size(); iTex++)
{
if (mTextureIDs[iTex] == TexID)
{
@@ -136,11 +136,11 @@ void CMaterialCooker::WriteMaterialPrime(IOutputStream& rOut)
}
// Get group index
u32 GroupIndex;
u64 MatHash = mpMat->HashParameters();
uint32 GroupIndex;
uint64 MatHash = mpMat->HashParameters();
bool NewHash = true;
for (u32 iHash = 0; iHash < mMaterialHashes.size(); iHash++)
for (uint32 iHash = 0; iHash < mMaterialHashes.size(); iHash++)
{
if (mMaterialHashes[iHash] == MatHash)
{
@@ -159,7 +159,7 @@ void CMaterialCooker::WriteMaterialPrime(IOutputStream& rOut)
// Start writing!
// Generate flags value
bool HasKonst = (NumKonst > 0);
u32 Flags;
uint32 Flags;
if (mVersion <= EGame::Prime)
Flags = 0x1003;
@@ -172,11 +172,11 @@ void CMaterialCooker::WriteMaterialPrime(IOutputStream& rOut)
// Texture indices
rOut.WriteLong(TexIndices.size());
for (u32 iTex = 0; iTex < TexIndices.size(); iTex++)
for (uint32 iTex = 0; iTex < TexIndices.size(); iTex++)
rOut.WriteLong(TexIndices[iTex]);
// Vertex description
u32 VtxFlags = ConvertFromVertexDescription( mpMat->VtxDesc() );
uint32 VtxFlags = ConvertFromVertexDescription( mpMat->VtxDesc() );
if (mVersion < EGame::Echoes)
VtxFlags &= 0x00FFFFFF;
@@ -197,14 +197,14 @@ void CMaterialCooker::WriteMaterialPrime(IOutputStream& rOut)
if (HasKonst)
{
rOut.WriteLong(NumKonst);
for (u32 iKonst = 0; iKonst < NumKonst; iKonst++)
for (uint32 iKonst = 0; iKonst < NumKonst; iKonst++)
rOut.WriteLong( mpMat->Konst(iKonst).ToLongRGBA() );
}
// Blend Mode
// Some modifications are done to convert the GLenum to the corresponding GX enum
u16 BlendSrcFac = (u16) mpMat->BlendSrcFac();
u16 BlendDstFac = (u16) mpMat->BlendDstFac();
uint16 BlendSrcFac = (uint16) mpMat->BlendSrcFac();
uint16 BlendDstFac = (uint16) mpMat->BlendDstFac();
if (BlendSrcFac >= 0x300) BlendSrcFac -= 0x2FE;
if (BlendDstFac >= 0x300) BlendDstFac -= 0x2FE;
rOut.WriteShort(BlendDstFac);
@@ -215,24 +215,24 @@ void CMaterialCooker::WriteMaterialPrime(IOutputStream& rOut)
rOut.WriteLong(0x3000 | (mpMat->IsLightingEnabled() ? 1 : 0));
// TEV
u32 NumPasses = mpMat->PassCount();
uint32 NumPasses = mpMat->PassCount();
rOut.WriteLong(NumPasses);
for (u32 iPass = 0; iPass < NumPasses; iPass++)
for (uint32 iPass = 0; iPass < NumPasses; iPass++)
{
CMaterialPass *pPass = mpMat->Pass(iPass);
u32 ColorInputFlags = ((pPass->ColorInput(0)) |
uint32 ColorInputFlags = ((pPass->ColorInput(0)) |
(pPass->ColorInput(1) << 5) |
(pPass->ColorInput(2) << 10) |
(pPass->ColorInput(3) << 15));
u32 AlphaInputFlags = ((pPass->AlphaInput(0)) |
uint32 AlphaInputFlags = ((pPass->AlphaInput(0)) |
(pPass->AlphaInput(1) << 5) |
(pPass->AlphaInput(2) << 10) |
(pPass->AlphaInput(3) << 15));
u32 ColorOpFlags = 0x100 | (pPass->ColorOutput() << 9);
u32 AlphaOpFlags = 0x100 | (pPass->AlphaOutput() << 9);
uint32 ColorOpFlags = 0x100 | (pPass->ColorOutput() << 9);
uint32 AlphaOpFlags = 0x100 | (pPass->AlphaOutput() << 9);
rOut.WriteLong(ColorInputFlags);
rOut.WriteLong(AlphaInputFlags);
@@ -245,37 +245,37 @@ void CMaterialCooker::WriteMaterialPrime(IOutputStream& rOut)
}
// TEV Tex/UV input selection
u32 CurTexIdx = 0;
uint32 CurTexIdx = 0;
for (u32 iPass = 0; iPass < NumPasses; iPass++)
for (uint32 iPass = 0; iPass < NumPasses; iPass++)
{
rOut.WriteShort(0); // Padding
if (mpMat->Pass(iPass)->Texture())
{
rOut.WriteByte((u8) CurTexIdx);
rOut.WriteByte((u8) CurTexIdx);
rOut.WriteByte((uint8) CurTexIdx);
rOut.WriteByte((uint8) CurTexIdx);
CurTexIdx++;
}
else
rOut.WriteShort((u16) 0xFFFF);
rOut.WriteShort((uint16) 0xFFFF);
}
// TexGen
u32 NumTexCoords = CurTexIdx; // TexIdx is currently equal to the tex coord count
uint32 NumTexCoords = CurTexIdx; // TexIdx is currently equal to the tex coord count
rOut.WriteLong(NumTexCoords);
u32 CurTexMtx = 0;
uint32 CurTexMtx = 0;
for (u32 iPass = 0; iPass < NumPasses; iPass++)
for (uint32 iPass = 0; iPass < NumPasses; iPass++)
{
CMaterialPass *pPass = mpMat->Pass(iPass);
if (pPass->Texture() == nullptr) continue;
u32 AnimType = pPass->AnimMode();
u32 CoordSource = pPass->TexCoordSource();
uint32 AnimType = pPass->AnimMode();
uint32 CoordSource = pPass->TexCoordSource();
u32 TexMtxIdx, PostMtxIdx;
uint32 TexMtxIdx, PostMtxIdx;
bool Normalize;
// No animation - set TexMtx and PostMtx to identity, disable normalization
@@ -304,21 +304,21 @@ void CMaterialCooker::WriteMaterialPrime(IOutputStream& rOut)
CurTexMtx += 3;
}
u32 TexGenFlags = (CoordSource << 4) | (TexMtxIdx << 9) | (Normalize << 14) | (PostMtxIdx << 15);
uint32 TexGenFlags = (CoordSource << 4) | (TexMtxIdx << 9) | (Normalize << 14) | (PostMtxIdx << 15);
rOut.WriteLong(TexGenFlags);
}
// Animations
u32 AnimSizeOffset = rOut.Tell();
u32 NumAnims = CurTexMtx; // CurTexMtx is currently equal to the anim count
uint32 AnimSizeOffset = rOut.Tell();
uint32 NumAnims = CurTexMtx; // CurTexMtx is currently equal to the anim count
rOut.WriteLong(0); // Anim size filler
u32 AnimsStart = rOut.Tell();
uint32 AnimsStart = rOut.Tell();
rOut.WriteLong(NumAnims);
for (u32 iPass = 0; iPass < NumPasses; iPass++)
for (uint32 iPass = 0; iPass < NumPasses; iPass++)
{
CMaterialPass *pPass = mpMat->Pass(iPass);
u32 AnimMode = pPass->AnimMode();
uint32 AnimMode = pPass->AnimMode();
if (AnimMode == eNoUVAnim) continue;
rOut.WriteLong(AnimMode);
@@ -336,8 +336,8 @@ void CMaterialCooker::WriteMaterialPrime(IOutputStream& rOut)
}
}
u32 AnimsEnd = rOut.Tell();
u32 AnimsSize = AnimsEnd - AnimsStart;
uint32 AnimsEnd = rOut.Tell();
uint32 AnimsSize = AnimsEnd - AnimsStart;
rOut.Seek(AnimSizeOffset, SEEK_SET);
rOut.WriteLong(AnimsSize);
rOut.Seek(AnimsEnd, SEEK_SET);

6
src/Core/Resource/Cooker/CMaterialCooker.h
View File

@@ -10,11 +10,11 @@ class CMaterialCooker
CMaterialSet *mpSet;
CMaterial *mpMat;
EGame mVersion;
std::vector<u32> mTextureIDs;
std::vector<u64> mMaterialHashes;
std::vector<uint32> mTextureIDs;
std::vector<uint64> mMaterialHashes;
CMaterialCooker();
u32 ConvertFromVertexDescription(FVertexDescription VtxDesc);
uint32 ConvertFromVertexDescription(FVertexDescription VtxDesc);
void WriteMatSetPrime(IOutputStream& rOut);
void WriteMatSetCorruption(IOutputStream& rOut);
void WriteMaterialPrime(IOutputStream& rOut);

80
src/Core/Resource/Cooker/CModelCooker.cpp
View File

@@ -20,27 +20,27 @@ void CModelCooker::GenerateSurfaceData()
// Get vertex attributes
mVtxAttribs = eNoAttributes;
for (u32 iMat = 0; iMat < mpModel->GetMatCount(); iMat++)
for (uint32 iMat = 0; iMat < mpModel->GetMatCount(); iMat++)
{
CMaterial *pMat = mpModel->GetMaterialByIndex(0, iMat);
mVtxAttribs |= pMat->VtxDesc();
}
// Get vertices
u32 MaxIndex = 0;
uint32 MaxIndex = 0;
for (u32 iSurf = 0; iSurf < mNumSurfaces; iSurf++)
for (uint32 iSurf = 0; iSurf < mNumSurfaces; iSurf++)
{
u32 NumPrimitives = mpModel->mSurfaces[iSurf]->Primitives.size();
uint32 NumPrimitives = mpModel->mSurfaces[iSurf]->Primitives.size();
for (u32 iPrim = 0; iPrim < NumPrimitives; iPrim++)
for (uint32 iPrim = 0; iPrim < NumPrimitives; iPrim++)
{
SSurface::SPrimitive *pPrim = &mpModel->mSurfaces[iSurf]->Primitives[iPrim];
u32 NumVerts = pPrim->Vertices.size();
uint32 NumVerts = pPrim->Vertices.size();
for (u32 iVtx = 0; iVtx < NumVerts; iVtx++)
for (uint32 iVtx = 0; iVtx < NumVerts; iVtx++)
{
u32 VertIndex = pPrim->Vertices[iVtx].ArrayPosition;
uint32 VertIndex = pPrim->Vertices[iVtx].ArrayPosition;
mVertices[VertIndex] = pPrim->Vertices[iVtx];
if (VertIndex > MaxIndex) MaxIndex = VertIndex;
@@ -66,17 +66,17 @@ void CModelCooker::WriteModelPrime(IOutputStream& rOut)
rOut.WriteLong(mpModel->IsSkinned() ? 6 : 5);
mpModel->mAABox.Write(rOut);
u32 NumSections = mNumMatSets + mNumSurfaces + 6;
uint32 NumSections = mNumMatSets + mNumSurfaces + 6;
rOut.WriteLong(NumSections);
rOut.WriteLong(mNumMatSets);
u32 SectionSizesOffset = rOut.Tell();
for (u32 iSec = 0; iSec < NumSections; iSec++)
uint32 SectionSizesOffset = rOut.Tell();
for (uint32 iSec = 0; iSec < NumSections; iSec++)
rOut.WriteLong(0);
rOut.WriteToBoundary(32, 0);
std::vector<u32> SectionSizes;
std::vector<uint32> SectionSizes;
SectionSizes.reserve(NumSections);
CSectionMgrOut SectionMgr;
@@ -84,7 +84,7 @@ void CModelCooker::WriteModelPrime(IOutputStream& rOut)
SectionMgr.Init(rOut);
// Materials
for (u32 iSet = 0; iSet < mNumMatSets; iSet++)
for (uint32 iSet = 0; iSet < mNumMatSets; iSet++)
{
CMaterialCooker::WriteCookedMatSet(mpModel->mMaterialSets[iSet], mVersion, rOut);
rOut.WriteToBoundary(32, 0);
@@ -92,33 +92,33 @@ void CModelCooker::WriteModelPrime(IOutputStream& rOut)
}
// Vertices
for (u32 iPos = 0; iPos < mNumVertices; iPos++)
for (uint32 iPos = 0; iPos < mNumVertices; iPos++)
mVertices[iPos].Position.Write(rOut);
rOut.WriteToBoundary(32, 0);
SectionMgr.AddSize(rOut);
// Normals
for (u32 iNrm = 0; iNrm < mNumVertices; iNrm++)
for (uint32 iNrm = 0; iNrm < mNumVertices; iNrm++)
mVertices[iNrm].Normal.Write(rOut);
rOut.WriteToBoundary(32, 0);
SectionMgr.AddSize(rOut);
// Colors
for (u32 iColor = 0; iColor < mNumVertices; iColor++)
for (uint32 iColor = 0; iColor < mNumVertices; iColor++)
mVertices[iColor].Color[0].Write(rOut);
rOut.WriteToBoundary(32, 0);
SectionMgr.AddSize(rOut);
// Float UV coordinates
for (u32 iTexSlot = 0; iTexSlot < 8; iTexSlot++)
for (uint32 iTexSlot = 0; iTexSlot < 8; iTexSlot++)
{
bool HasTexSlot = (mVtxAttribs & (eTex0 << iTexSlot)) != 0;
if (HasTexSlot)
{
for (u32 iTex = 0; iTex < mNumVertices; iTex++)
for (uint32 iTex = 0; iTex < mNumVertices; iTex++)
mVertices[iTex].Tex[iTexSlot].Write(rOut);
}
}
@@ -129,53 +129,53 @@ void CModelCooker::WriteModelPrime(IOutputStream& rOut)
// Surface offsets
rOut.WriteLong(mNumSurfaces);
u32 SurfaceOffsetsStart = rOut.Tell();
uint32 SurfaceOffsetsStart = rOut.Tell();
for (u32 iSurf = 0; iSurf < mNumSurfaces; iSurf++)
for (uint32 iSurf = 0; iSurf < mNumSurfaces; iSurf++)
rOut.WriteLong(0);
rOut.WriteToBoundary(32, 0);
SectionMgr.AddSize(rOut);
// Surfaces
u32 SurfacesStart = rOut.Tell();
std::vector<u32> SurfaceEndOffsets(mNumSurfaces);
uint32 SurfacesStart = rOut.Tell();
std::vector<uint32> SurfaceEndOffsets(mNumSurfaces);
for (u32 iSurf = 0; iSurf < mNumSurfaces; iSurf++)
for (uint32 iSurf = 0; iSurf < mNumSurfaces; iSurf++)
{
SSurface *pSurface = mpModel->GetSurface(iSurf);
pSurface->CenterPoint.Write(rOut);
rOut.WriteLong(pSurface->MaterialID);
rOut.WriteShort((u16) 0x8000);
u32 PrimTableSizeOffset = rOut.Tell();
rOut.WriteShort((uint16) 0x8000);
uint32 PrimTableSizeOffset = rOut.Tell();
rOut.WriteShort(0);
rOut.WriteLongLong(0);
rOut.WriteLong(0);
pSurface->ReflectionDirection.Write(rOut);
rOut.WriteToBoundary(32, 0);
u32 PrimTableStart = rOut.Tell();
uint32 PrimTableStart = rOut.Tell();
FVertexDescription VtxAttribs = mpModel->GetMaterialBySurface(0, iSurf)->VtxDesc();
for (u32 iPrim = 0; iPrim < pSurface->Primitives.size(); iPrim++)
for (uint32 iPrim = 0; iPrim < pSurface->Primitives.size(); iPrim++)
{
SSurface::SPrimitive *pPrimitive = &pSurface->Primitives[iPrim];
rOut.WriteByte((u8) pPrimitive->Type);
rOut.WriteShort((u16) pPrimitive->Vertices.size());
rOut.WriteByte((uint8) pPrimitive->Type);
rOut.WriteShort((uint16) pPrimitive->Vertices.size());
for (u32 iVert = 0; iVert < pPrimitive->Vertices.size(); iVert++)
for (uint32 iVert = 0; iVert < pPrimitive->Vertices.size(); iVert++)
{
CVertex *pVert = &pPrimitive->Vertices[iVert];
if (mVersion == EGame::Echoes)
{
for (u32 iMtxAttribs = 0; iMtxAttribs < 8; iMtxAttribs++)
for (uint32 iMtxAttribs = 0; iMtxAttribs < 8; iMtxAttribs++)
if (VtxAttribs & (ePosMtx << iMtxAttribs))
rOut.WriteByte(pVert->MatrixIndices[iMtxAttribs]);
}
u16 VertexIndex = (u16) pVert->ArrayPosition;
uint16 VertexIndex = (uint16) pVert->ArrayPosition;
if (VtxAttribs & ePosition)
rOut.WriteShort(VertexIndex);
@@ -189,23 +189,23 @@ void CModelCooker::WriteModelPrime(IOutputStream& rOut)
if (VtxAttribs & eColor1)
rOut.WriteShort(VertexIndex);
u16 TexOffset = 0;
for (u32 iTex = 0; iTex < 8; iTex++)
uint16 TexOffset = 0;
for (uint32 iTex = 0; iTex < 8; iTex++)
{
if (VtxAttribs & (eTex0 << iTex))
{
rOut.WriteShort(VertexIndex + TexOffset);
TexOffset += (u16) mNumVertices;
TexOffset += (uint16) mNumVertices;
}
}
}
}
rOut.WriteToBoundary(32, 0);
u32 PrimTableEnd = rOut.Tell();
u32 PrimTableSize = PrimTableEnd - PrimTableStart;
uint32 PrimTableEnd = rOut.Tell();
uint32 PrimTableSize = PrimTableEnd - PrimTableStart;
rOut.Seek(PrimTableSizeOffset, SEEK_SET);
rOut.WriteShort((u16) PrimTableSize);
rOut.WriteShort((uint16) PrimTableSize);
rOut.Seek(PrimTableEnd, SEEK_SET);
SectionMgr.AddSize(rOut);
@@ -215,7 +215,7 @@ void CModelCooker::WriteModelPrime(IOutputStream& rOut)
// Done writing the file - now we go back to fill in surface offsets + section sizes
rOut.Seek(SurfaceOffsetsStart, SEEK_SET);
for (u32 iSurf = 0; iSurf < mNumSurfaces; iSurf++)
for (uint32 iSurf = 0; iSurf < mNumSurfaces; iSurf++)
rOut.WriteLong(SurfaceEndOffsets[iSurf]);
rOut.Seek(SectionSizesOffset, SEEK_SET);
@@ -244,7 +244,7 @@ bool CModelCooker::CookCMDL(CModel *pModel, IOutputStream& rOut)
}
}
u32 CModelCooker::GetCMDLVersion(EGame Version)
uint32 CModelCooker::GetCMDLVersion(EGame Version)
{
switch (Version)
{

10
src/Core/Resource/Cooker/CModelCooker.h
View File

@@ -9,10 +9,10 @@ class CModelCooker
{
TResPtr<CModel> mpModel;
EGame mVersion;
u32 mNumMatSets;
u32 mNumSurfaces;
u32 mNumVertices;
u8 mVertexFormat;
uint32 mNumMatSets;
uint32 mNumSurfaces;
uint32 mNumVertices;
uint8 mVertexFormat;
std::vector<CVertex> mVertices;
FVertexDescription mVtxAttribs;
@@ -23,7 +23,7 @@ class CModelCooker
public:
static bool CookCMDL(CModel *pModel, IOutputStream& rOut);
static u32 GetCMDLVersion(EGame Version);
static uint32 GetCMDLVersion(EGame Version);
};
#endif // CMODELCOOKER_H

8
src/Core/Resource/Cooker/CPoiToWorldCooker.cpp
View File

@@ -5,12 +5,12 @@ bool CPoiToWorldCooker::CookEGMC(CPoiToWorld *pPoiToWorld, IOutputStream& rOut)
// Create mappings list
struct SPoiMapping
{
u32 MeshID;
u32 PoiID;
uint32 MeshID;
uint32 PoiID;
};
std::vector<SPoiMapping> Mappings;
for (u32 iPoi = 0; iPoi < pPoiToWorld->NumMappedPOIs(); iPoi++)
for (uint32 iPoi = 0; iPoi < pPoiToWorld->NumMappedPOIs(); iPoi++)
{
const CPoiToWorld::SPoiMap *pkMap = pPoiToWorld->MapByIndex(iPoi);
@@ -26,7 +26,7 @@ bool CPoiToWorldCooker::CookEGMC(CPoiToWorld *pPoiToWorld, IOutputStream& rOut)
// Write EGMC
rOut.WriteLong(Mappings.size());
for (u32 iMap = 0; iMap < Mappings.size(); iMap++)
for (uint32 iMap = 0; iMap < Mappings.size(); iMap++)
{
rOut.WriteLong(Mappings[iMap].MeshID);
rOut.WriteLong(Mappings[iMap].PoiID);

2
src/Core/Resource/Cooker/CResourceCooker.h
View File

@@ -26,7 +26,7 @@ public:
case eWorld: return CWorldCooker::CookMLVL((CWorld*) pRes, rOutput);
default:
Log::Warning("Failed to cook " + pEntry->CookedExtension().ToString() + " asset; this resource type is not supported for cooking");
warnf("Failed to cook %s asset; this resource type is not supported for cooking", *pEntry->CookedExtension().ToString());
return false;
}
}

50
src/Core/Resource/Cooker/CScriptCooker.cpp
View File

@@ -7,7 +7,7 @@
void CScriptCooker::WriteProperty(IOutputStream& rOut, IProperty* pProperty, bool InAtomicStruct)
{
u32 SizeOffset = 0, PropStart = 0;
uint32 SizeOffset = 0, PropStart = 0;
void* pData = (mpArrayItemData ? mpArrayItemData : mpObject->PropertyData());
if (mGame >= EGame::EchoesDemo && !InAtomicStruct)
@@ -180,7 +180,7 @@ void CScriptCooker::WriteProperty(IOutputStream& rOut, IProperty* pProperty, boo
CStructProperty* pStruct = TPropCast<CStructProperty>(pProperty);
std::vector<IProperty*> PropertiesToWrite;
for (u32 ChildIdx = 0; ChildIdx < pStruct->NumChildren(); ChildIdx++)
for (uint32 ChildIdx = 0; ChildIdx < pStruct->NumChildren(); ChildIdx++)
{
IProperty *pChild = pStruct->ChildByIndex(ChildIdx);
@@ -193,10 +193,10 @@ void CScriptCooker::WriteProperty(IOutputStream& rOut, IProperty* pProperty, boo
if (mGame <= EGame::Prime)
rOut.WriteLong(PropertiesToWrite.size());
else
rOut.WriteShort((u16) PropertiesToWrite.size());
rOut.WriteShort((uint16) PropertiesToWrite.size());
}
for (u32 PropertyIdx = 0; PropertyIdx < PropertiesToWrite.size(); PropertyIdx++)
for (uint32 PropertyIdx = 0; PropertyIdx < PropertiesToWrite.size(); PropertyIdx++)
WriteProperty(rOut, PropertiesToWrite[PropertyIdx], pStruct->IsAtomic());
break;
@@ -205,12 +205,12 @@ void CScriptCooker::WriteProperty(IOutputStream& rOut, IProperty* pProperty, boo
case EPropertyType::Array:
{
CArrayProperty* pArray = TPropCast<CArrayProperty>(pProperty);
u32 Count = pArray->ArrayCount(pData);
uint32 Count = pArray->ArrayCount(pData);
rOut.WriteLong(Count);
void* pOldItemData = mpArrayItemData;
for (u32 ElementIdx = 0; ElementIdx < pArray->ArrayCount(pData); ElementIdx++)
for (uint32 ElementIdx = 0; ElementIdx < pArray->ArrayCount(pData); ElementIdx++)
{
mpArrayItemData = pArray->ItemPointer(pData, ElementIdx);
WriteProperty(rOut, pArray->ItemArchetype(), true);
@@ -224,9 +224,9 @@ void CScriptCooker::WriteProperty(IOutputStream& rOut, IProperty* pProperty, boo
if (SizeOffset != 0)
{
u32 PropEnd = rOut.Tell();
uint32 PropEnd = rOut.Tell();
rOut.Seek(SizeOffset, SEEK_SET);
rOut.WriteShort((u16) (PropEnd - PropStart));
rOut.WriteShort((uint16) (PropEnd - PropStart));
rOut.Seek(PropEnd, SEEK_SET);
}
}
@@ -240,20 +240,20 @@ void CScriptCooker::WriteInstance(IOutputStream& rOut, CScriptObject *pInstance)
// number of fields changed size between MP1 and 2, but they're still the same fields
bool IsPrime1 = (mGame <= EGame::Prime);
u32 ObjectType = pInstance->ObjectTypeID();
IsPrime1 ? rOut.WriteByte((u8) ObjectType) : rOut.WriteLong(ObjectType);
uint32 ObjectType = pInstance->ObjectTypeID();
IsPrime1 ? rOut.WriteByte((uint8) ObjectType) : rOut.WriteLong(ObjectType);
u32 SizeOffset = rOut.Tell();
uint32 SizeOffset = rOut.Tell();
IsPrime1 ? rOut.WriteLong(0) : rOut.WriteShort(0);
u32 InstanceStart = rOut.Tell();
u32 InstanceID = (pInstance->Layer()->AreaIndex() << 26) | pInstance->InstanceID();
uint32 InstanceStart = rOut.Tell();
uint32 InstanceID = (pInstance->Layer()->AreaIndex() << 26) | pInstance->InstanceID();
rOut.WriteLong(InstanceID);
u32 NumLinks = pInstance->NumLinks(eOutgoing);
IsPrime1 ? rOut.WriteLong(NumLinks) : rOut.WriteShort((u16) NumLinks);
uint32 NumLinks = pInstance->NumLinks(eOutgoing);
IsPrime1 ? rOut.WriteLong(NumLinks) : rOut.WriteShort((uint16) NumLinks);
for (u32 LinkIdx = 0; LinkIdx < NumLinks; LinkIdx++)
for (uint32 LinkIdx = 0; LinkIdx < NumLinks; LinkIdx++)
{
CLink *pLink = pInstance->Link(eOutgoing, LinkIdx);
rOut.WriteLong(pLink->State());
@@ -263,11 +263,11 @@ void CScriptCooker::WriteInstance(IOutputStream& rOut, CScriptObject *pInstance)
mpObject = pInstance;
WriteProperty(rOut, pInstance->Template()->Properties(), false);
u32 InstanceEnd = rOut.Tell();
uint32 InstanceEnd = rOut.Tell();
rOut.Seek(SizeOffset, SEEK_SET);
u32 Size = InstanceEnd - InstanceStart;
IsPrime1 ? rOut.WriteLong(Size) : rOut.WriteShort((u16) Size);
uint32 Size = InstanceEnd - InstanceStart;
IsPrime1 ? rOut.WriteLong(Size) : rOut.WriteShort((uint16) Size);
rOut.Seek(InstanceEnd, SEEK_SET);
}
@@ -277,11 +277,11 @@ void CScriptCooker::WriteLayer(IOutputStream& rOut, CScriptLayer *pLayer)
rOut.WriteByte( mGame <= EGame::Prime ? 0 : 1 ); // Version
u32 InstanceCountOffset = rOut.Tell();
u32 NumWrittenInstances = 0;
uint32 InstanceCountOffset = rOut.Tell();
uint32 NumWrittenInstances = 0;
rOut.WriteLong(0);
for (u32 iInst = 0; iInst < pLayer->NumInstances(); iInst++)
for (uint32 iInst = 0; iInst < pLayer->NumInstances(); iInst++)
{
CScriptObject *pInstance = pLayer->InstanceByIndex(iInst);
@@ -298,7 +298,7 @@ void CScriptCooker::WriteLayer(IOutputStream& rOut, CScriptLayer *pLayer)
// Generate/Attach message (MP3+) should be written to SCGN, not SCLY
else
{
for (u32 LinkIdx = 0; LinkIdx < pInstance->NumLinks(eIncoming); LinkIdx++)
for (uint32 LinkIdx = 0; LinkIdx < pInstance->NumLinks(eIncoming); LinkIdx++)
{
CLink *pLink = pInstance->Link(eIncoming, LinkIdx);
@@ -336,7 +336,7 @@ void CScriptCooker::WriteLayer(IOutputStream& rOut, CScriptLayer *pLayer)
}
}
u32 LayerEnd = rOut.Tell();
uint32 LayerEnd = rOut.Tell();
rOut.GoTo(InstanceCountOffset);
rOut.WriteLong(NumWrittenInstances);
rOut.GoTo(LayerEnd);
@@ -347,6 +347,6 @@ void CScriptCooker::WriteGeneratedLayer(IOutputStream& rOut)
rOut.WriteByte(1); // Version
rOut.WriteLong(mGeneratedObjects.size());
for (u32 ObjectIdx = 0; ObjectIdx < mGeneratedObjects.size(); ObjectIdx++)
for (uint32 ObjectIdx = 0; ObjectIdx < mGeneratedObjects.size(); ObjectIdx++)
WriteInstance(rOut, mGeneratedObjects[ObjectIdx]);
}

14
src/Core/Resource/Cooker/CSectionMgrOut.h
View File

@@ -1,17 +1,17 @@
#ifndef CBLOCKMGROUT_H
#define CBLOCKMGROUT_H
#include <Common/types.h>
#include <Common/BasicTypes.h>
#include <Common/FileIO/IOutputStream.h>
#include <vector>
// Small class to manage file sections for CMDL/MREA output
class CSectionMgrOut
{
u32 mSectionCount;
u32 mCurSectionStart;
u32 mCurSectionIndex;
std::vector<u32> mSectionSizes;
uint32 mSectionCount;
uint32 mCurSectionStart;
uint32 mCurSectionIndex;
std::vector<uint32> mSectionSizes;
public:
CSectionMgrOut()
@@ -20,7 +20,7 @@ public:
, mCurSectionIndex(0)
{}
void SetSectionCount(u32 Count)
void SetSectionCount(uint32 Count)
{
mSectionCount = Count;
mSectionSizes.resize(Count);
@@ -41,7 +41,7 @@ public:
void WriteSizes(IOutputStream& rOut)
{
for (u32 iSec = 0; iSec < mSectionCount; iSec++)
for (uint32 iSec = 0; iSec < mSectionCount; iSec++)
rOut.WriteLong(mSectionSizes[iSec]);
}
};

24
src/Core/Resource/Cooker/CTextureEncoder.cpp
View File

@@ -14,19 +14,19 @@ void CTextureEncoder::WriteTXTR(IOutputStream& rTXTR)
rTXTR.WriteShort(mpTexture->mHeight);
rTXTR.WriteLong(mpTexture->mNumMipMaps);
u32 MipW = mpTexture->Width() / 4;
u32 MipH = mpTexture->Height() / 4;
uint32 MipW = mpTexture->Width() / 4;
uint32 MipH = mpTexture->Height() / 4;
CMemoryInStream Image(mpTexture->mpImgDataBuffer, mpTexture->mImgDataSize, IOUtil::eLittleEndian);
u32 MipOffset = Image.Tell();
uint32 MipOffset = Image.Tell();
for (u32 iMip = 0; iMip < mpTexture->mNumMipMaps; iMip++)
for (uint32 iMip = 0; iMip < mpTexture->mNumMipMaps; iMip++)
{
for (u32 iBlockY = 0; iBlockY < MipH; iBlockY += 2)
for (u32 iBlockX = 0; iBlockX < MipW; iBlockX += 2)
for (u32 iImgY = iBlockY; iImgY < iBlockY + 2; iImgY++)
for (u32 iImgX = iBlockX; iImgX < iBlockX + 2; iImgX++)
for (uint32 iBlockY = 0; iBlockY < MipH; iBlockY += 2)
for (uint32 iBlockX = 0; iBlockX < MipW; iBlockX += 2)
for (uint32 iImgY = iBlockY; iImgY < iBlockY + 2; iImgY++)
for (uint32 iImgX = iBlockX; iImgX < iBlockX + 2; iImgX++)
{
u32 SrcPos = ((iImgY * MipW) + iImgX) * 8;
uint32 SrcPos = ((iImgY * MipW) + iImgX) * 8;
Image.Seek(MipOffset + SrcPos, SEEK_SET);
ReadSubBlockCMPR(Image, rTXTR);
@@ -50,9 +50,9 @@ void CTextureEncoder::ReadSubBlockCMPR(IInputStream& rSource, IOutputStream& rDe
rDest.WriteShort(rSource.ReadShort());
rDest.WriteShort(rSource.ReadShort());
for (u32 iByte = 0; iByte < 4; iByte++)
for (uint32 iByte = 0; iByte < 4; iByte++)
{
u8 Byte = rSource.ReadByte();
uint8 Byte = rSource.ReadByte();
Byte = ((Byte & 0x3) << 6) | ((Byte & 0xC) << 2) | ((Byte & 0x30) >> 2) | ((Byte & 0xC0) >> 6);
rDest.WriteByte(Byte);
}
@@ -63,7 +63,7 @@ void CTextureEncoder::EncodeTXTR(IOutputStream& rTXTR, CTexture *pTex)
{
if (pTex->mTexelFormat != eDXT1)
{
Log::Error("Unsupported texel format for decoding");
errorf("Unsupported texel format for decoding");
return;
}

38
src/Core/Resource/Cooker/CWorldCooker.cpp
View File

@@ -53,7 +53,7 @@ bool CWorldCooker::CookMLVL(CWorld *pWorld, IOutputStream& rMLVL)
{
rMLVL.WriteLong( pWorld->mMemoryRelays.size() );
for (u32 iMem = 0; iMem < pWorld->mMemoryRelays.size(); iMem++)
for (uint32 iMem = 0; iMem < pWorld->mMemoryRelays.size(); iMem++)
{
CWorld::SMemoryRelay& rRelay = pWorld->mMemoryRelays[iMem];
rMLVL.WriteLong(rRelay.InstanceID);
@@ -68,7 +68,7 @@ bool CWorldCooker::CookMLVL(CWorld *pWorld, IOutputStream& rMLVL)
if (Game <= EGame::Prime) rMLVL.WriteLong(1); // Unknown
std::set<CAssetID> AudioGroups;
for (u32 iArea = 0; iArea < pWorld->mAreas.size(); iArea++)
for (uint32 iArea = 0; iArea < pWorld->mAreas.size(); iArea++)
{
// Area Header
CWorld::SArea& rArea = pWorld->mAreas[iArea];
@@ -87,7 +87,7 @@ bool CWorldCooker::CookMLVL(CWorld *pWorld, IOutputStream& rMLVL)
{
rMLVL.WriteLong( rArea.AttachedAreaIDs.size() );
for (u32 iAttach = 0; iAttach < rArea.AttachedAreaIDs.size(); iAttach++)
for (uint32 iAttach = 0; iAttach < rArea.AttachedAreaIDs.size(); iAttach++)
rMLVL.WriteShort(rArea.AttachedAreaIDs[iAttach]);
}
@@ -95,7 +95,7 @@ bool CWorldCooker::CookMLVL(CWorld *pWorld, IOutputStream& rMLVL)
if (Game <= EGame::Echoes)
{
std::list<CAssetID> Dependencies;
std::list<u32> LayerDependsOffsets;
std::list<uint32> LayerDependsOffsets;
CAreaDependencyListBuilder Builder(pAreaEntry);
Builder.BuildDependencyList(Dependencies, LayerDependsOffsets, &AudioGroups);
@@ -121,12 +121,12 @@ bool CWorldCooker::CookMLVL(CWorld *pWorld, IOutputStream& rMLVL)
{
rMLVL.WriteLong( rArea.Docks.size() );
for (u32 iDock = 0; iDock < rArea.Docks.size(); iDock++)
for (uint32 iDock = 0; iDock < rArea.Docks.size(); iDock++)
{
CWorld::SArea::SDock& rDock = rArea.Docks[iDock];
rMLVL.WriteLong( rDock.ConnectingDocks.size() );
for (u32 iCon = 0; iCon < rDock.ConnectingDocks.size(); iCon++)
for (uint32 iCon = 0; iCon < rDock.ConnectingDocks.size(); iCon++)
{
CWorld::SArea::SDock::SConnectingDock& rConDock = rDock.ConnectingDocks[iCon];
rMLVL.WriteLong(rConDock.AreaIndex);
@@ -135,7 +135,7 @@ bool CWorldCooker::CookMLVL(CWorld *pWorld, IOutputStream& rMLVL)
rMLVL.WriteLong( rDock.DockCoordinates.size() );
for (u32 iCoord = 0; iCoord < rDock.DockCoordinates.size(); iCoord++)
for (uint32 iCoord = 0; iCoord < rDock.DockCoordinates.size(); iCoord++)
rDock.DockCoordinates[iCoord].Write(rMLVL);
}
}
@@ -144,18 +144,18 @@ bool CWorldCooker::CookMLVL(CWorld *pWorld, IOutputStream& rMLVL)
if (Game == EGame::EchoesDemo || Game == EGame::Echoes)
{
std::vector<TString> ModuleNames;
std::vector<u32> ModuleLayerOffsets;
std::vector<uint32> ModuleLayerOffsets;
CAreaDependencyTree *pAreaDeps = static_cast<CAreaDependencyTree*>(pAreaEntry->Dependencies());
pAreaDeps->GetModuleDependencies(Game, ModuleNames, ModuleLayerOffsets);
rMLVL.WriteLong(ModuleNames.size());
for (u32 iMod = 0; iMod < ModuleNames.size(); iMod++)
for (uint32 iMod = 0; iMod < ModuleNames.size(); iMod++)
rMLVL.WriteString(ModuleNames[iMod]);
rMLVL.WriteLong(ModuleLayerOffsets.size());
for (u32 iOff = 0; iOff < ModuleLayerOffsets.size(); iOff++)
for (uint32 iOff = 0; iOff < ModuleLayerOffsets.size(); iOff++)
rMLVL.WriteLong(ModuleLayerOffsets[iOff]);
}
@@ -199,7 +199,7 @@ bool CWorldCooker::CookMLVL(CWorld *pWorld, IOutputStream& rMLVL)
// Write sorted audio group list to file
rMLVL.WriteLong(SortedAudioGroups.size());
for (u32 iGrp = 0; iGrp < SortedAudioGroups.size(); iGrp++)
for (uint32 iGrp = 0; iGrp < SortedAudioGroups.size(); iGrp++)
{
CAudioGroup *pGroup = SortedAudioGroups[iGrp];
rMLVL.WriteLong(pGroup->GroupID());
@@ -213,18 +213,18 @@ bool CWorldCooker::CookMLVL(CWorld *pWorld, IOutputStream& rMLVL)
rMLVL.WriteLong(pWorld->mAreas.size());
std::vector<TString> LayerNames;
std::vector<CSavedStateID> LayerStateIDs;
std::vector<u32> LayerNameOffsets;
std::vector<uint32> LayerNameOffsets;
// Layer Flags
for (u32 iArea = 0; iArea < pWorld->mAreas.size(); iArea++)
for (uint32 iArea = 0; iArea < pWorld->mAreas.size(); iArea++)
{
CWorld::SArea& rArea = pWorld->mAreas[iArea];
LayerNameOffsets.push_back(LayerNames.size());
rMLVL.WriteLong(rArea.Layers.size());
u64 LayerActiveFlags = -1;
uint64 LayerActiveFlags = -1;
for (u32 iLyr = 0; iLyr < rArea.Layers.size(); iLyr++)
for (uint32 iLyr = 0; iLyr < rArea.Layers.size(); iLyr++)
{
CWorld::SArea::SLayer& rLayer = rArea.Layers[iLyr];
if (!rLayer.Active)
@@ -240,7 +240,7 @@ bool CWorldCooker::CookMLVL(CWorld *pWorld, IOutputStream& rMLVL)
// Layer Names
rMLVL.WriteLong(LayerNames.size());
for (u32 iLyr = 0; iLyr < LayerNames.size(); iLyr++)
for (uint32 iLyr = 0; iLyr < LayerNames.size(); iLyr++)
rMLVL.WriteString(LayerNames[iLyr]);
// Layer Saved State IDs
@@ -248,20 +248,20 @@ bool CWorldCooker::CookMLVL(CWorld *pWorld, IOutputStream& rMLVL)
{
rMLVL.WriteLong(LayerStateIDs.size());
for (u32 iLyr = 0; iLyr < LayerStateIDs.size(); iLyr++)
for (uint32 iLyr = 0; iLyr < LayerStateIDs.size(); iLyr++)
LayerStateIDs[iLyr].Write(rMLVL);
}
// Layer Name Offsets
rMLVL.WriteLong(LayerNameOffsets.size());
for (u32 iOff = 0; iOff < LayerNameOffsets.size(); iOff++)
for (uint32 iOff = 0; iOff < LayerNameOffsets.size(); iOff++)
rMLVL.WriteLong(LayerNameOffsets[iOff]);
return true;
}
u32 CWorldCooker::GetMLVLVersion(EGame Version)
uint32 CWorldCooker::GetMLVLVersion(EGame Version)
{
switch (Version)
{

4
src/Core/Resource/Cooker/CWorldCooker.h
View File

@@ -2,15 +2,15 @@
#define CWORLDCOOKER_H
#include "Core/Resource/CWorld.h"
#include <Common/BasicTypes.h>
#include <Common/EGame.h>
#include <Common/types.h>
class CWorldCooker
{
CWorldCooker();
public:
static bool CookMLVL(CWorld *pWorld, IOutputStream& rOut);
static u32 GetMLVLVersion(EGame Version);
static uint32 GetMLVLVersion(EGame Version);
};
#endif // CWORLDCOOKER_H