247 lines
7.5 KiB
C++
247 lines
7.5 KiB
C++
#include "CKTexture.hpp"
|
|
#include "../CKStateChunk.hpp"
|
|
|
|
namespace LibCmo::CK2::ObjImpls {
|
|
|
|
/**
|
|
* @brief A fake struct define.
|
|
* This define is served for a buffer read / write in CKTexture.
|
|
* Because Virtools directly write a raw struct into file,
|
|
* and our defines are different with Virtools.
|
|
* So we need create a fake struct.
|
|
* @remark
|
|
* All pointers should translate to DWORD(32 bit) for platform independent.
|
|
* Otherwise this struct may be corrupted in x64 platform because pointer is QWORD in x64.
|
|
*/
|
|
struct FakeBitmapProperties {
|
|
CKINT m_Size;
|
|
struct {
|
|
// fake CKGUID
|
|
CKDWORD d1, d2;
|
|
}m_ReaderGuid;
|
|
struct {
|
|
// fake CKFileExtension
|
|
CKCHAR m_Data[4];
|
|
}m_Ext;
|
|
struct {
|
|
// fake VxImageDescEx
|
|
CKINT Size; ///< Size of the structure
|
|
CKDWORD Flags; ///< Reserved for special formats (such as compressed ) 0 otherwise
|
|
|
|
CKINT Width; ///< Width in pixel of the image
|
|
CKINT Height; ///< Height in pixel of the image
|
|
union {
|
|
CKINT BytesPerLine; ///< Pitch (width in bytes) of the image
|
|
CKINT TotalImageSize; ///< For compressed image (DXT1...) the total size of the image
|
|
};
|
|
CKINT BitsPerPixel; ///< Number of bits per pixel
|
|
union {
|
|
CKDWORD RedMask; ///< Mask for Red component
|
|
CKDWORD BumpDuMask; ///< Mask for Bump Du component
|
|
};
|
|
union {
|
|
CKDWORD GreenMask; ///< Mask for Green component
|
|
CKDWORD BumpDvMask; ///< Mask for Bump Dv component
|
|
};
|
|
union {
|
|
CKDWORD BlueMask; ///< Mask for Blue component
|
|
CKDWORD BumpLumMask; ///< Mask for Luminance component
|
|
|
|
};
|
|
CKDWORD AlphaMask; ///< Mask for Alpha component
|
|
|
|
CKWORD BytesPerColorEntry; ///< ColorMap Stride
|
|
CKWORD ColorMapEntries; ///< If other than 0 image is palletized
|
|
|
|
/*CKBYTE**/CKPTR ColorMap; ///< Palette colors
|
|
/*CKBYTE**/CKPTR Image; ///< Image
|
|
}m_Format;
|
|
/*void**/CKPTR m_Data;
|
|
};
|
|
|
|
CKTexture::CKTexture(CKContext* ctx, CK_ID ckid, CKSTRING name) :
|
|
CKBeObject(ctx, ckid, name),
|
|
m_ImageHost(ctx),
|
|
m_VideoFormat(VxMath::VX_PIXELFORMAT::_16_ARGB1555), m_UseMipMap(false), m_MipmapImages() {}
|
|
|
|
CKTexture::~CKTexture() {}
|
|
|
|
bool CKTexture::Save(CKStateChunk* chunk, CKFileVisitor* file, CKDWORD flags) {
|
|
bool suc = CKBeObject::Save(chunk, file, flags);
|
|
if (!suc) return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CKTexture::Load(CKStateChunk* chunk, CKFileVisitor* file) {
|
|
bool suc = CKBeObject::Load(chunk, file);
|
|
if (!suc) return false;
|
|
|
|
// read base image
|
|
suc = m_ImageHost.ReadFromChunk(chunk, file, CKBitmapDataReadIdentifiers {
|
|
.m_SpecificFormat = static_cast<CKDWORD>(CK_STATESAVEFLAGS_TEXTURE::CK_STATESAVE_TEXREADER),
|
|
.m_RawData = static_cast<CKDWORD>(CK_STATESAVEFLAGS_TEXTURE::CK_STATESAVE_TEXCOMPRESSED),
|
|
.m_OldRawData = static_cast<CKDWORD>(CK_STATESAVEFLAGS_TEXTURE::CK_STATESAVE_TEXBITMAPS),
|
|
.m_FileNames = static_cast<CKDWORD>(CK_STATESAVEFLAGS_TEXTURE::CK_STATESAVE_TEXFILENAMES),
|
|
.m_MovieFileName = static_cast<CKDWORD>(CK_STATESAVEFLAGS_TEXTURE::CK_STATESAVE_TEXAVIFILENAME)
|
|
});
|
|
if (!suc) return false;
|
|
|
|
if (chunk->GetDataVersion() < CK_STATECHUNK_DATAVERSION::CHUNK_MAJORCHANGE_VERSION) {
|
|
// MARK: old data process. i don't want to process it anymore.
|
|
// thus return false directly.
|
|
return false;
|
|
} else {
|
|
CKDWORD fmtbytesize;
|
|
// MARK: there is a patch for virtools 2.1 implement.
|
|
// CK_STATESAVE_TEXONLY is noy valid in 2.1 but we add it for cpmpatibility reason.
|
|
if (chunk->SeekIdentifierAndReturnSize(CK_STATESAVEFLAGS_TEXTURE::CK_STATESAVE_OLDTEXONLY, &fmtbytesize) ||
|
|
chunk->SeekIdentifierAndReturnSize(CK_STATESAVEFLAGS_TEXTURE::CK_STATESAVE_TEXONLY, &fmtbytesize)) {
|
|
// for mid data:
|
|
// HIGH >>> 0xFF (blank) 0xFF (save options) 0xFF (transparent + movie info + video fmt) 0xFF (mip map) <<< LOW
|
|
// for mixed flags:
|
|
// HIGH >>> 1(blank) 1(cubemap) 1(has video fmt) 1(is transparent)
|
|
CKDWORD mixdata;
|
|
chunk->ReadStruct(mixdata);
|
|
// set mipmap
|
|
m_UseMipMap = (mixdata & 0xFF);
|
|
mixdata >>= 8;
|
|
// mix flags
|
|
CKDWORD mixflags = mixdata & 0xFF;
|
|
mixdata >>= 8;
|
|
m_ImageHost.SetTransparent(mixflags & 0x1);
|
|
bool hasVideoFmt = mixflags & 0x2;
|
|
m_ImageHost.SetCubeMap(mixflags & 0x4);
|
|
// save options
|
|
m_ImageHost.SetSaveOptions(static_cast<CK_TEXTURE_SAVEOPTIONS>(mixdata & 0xFF));
|
|
mixdata >>= 8;
|
|
|
|
// set current slot, transparent color, and video format.
|
|
CKDWORD currentSlot, transColor;
|
|
fmtbytesize -= CKSizeof(CKDWORD);
|
|
switch (fmtbytesize) {
|
|
case (3 * CKSizeof(CKDWORD)):
|
|
chunk->ReadStruct(transColor);
|
|
m_ImageHost.SetTransparentColor(transColor);
|
|
chunk->ReadStruct(currentSlot);
|
|
m_ImageHost.SetCurrentSlot(currentSlot);
|
|
chunk->ReadStruct(m_VideoFormat);
|
|
break;
|
|
case (2 * CKSizeof(CKDWORD)):
|
|
if (m_ImageHost.GetSlotCount() <= 1 || !hasVideoFmt) {
|
|
chunk->ReadStruct(transColor);
|
|
m_ImageHost.SetTransparentColor(transColor);
|
|
}
|
|
if (m_ImageHost.GetSlotCount() > 1) {
|
|
chunk->ReadStruct(currentSlot);
|
|
m_ImageHost.SetCurrentSlot(currentSlot);
|
|
}
|
|
if (hasVideoFmt) {
|
|
chunk->ReadStruct(m_VideoFormat);
|
|
}
|
|
break;
|
|
case (CKSizeof(CKDWORD)):
|
|
if (hasVideoFmt) {
|
|
chunk->ReadStruct(m_VideoFormat);
|
|
} else if (m_ImageHost.GetSlotCount() <= 1) {
|
|
chunk->ReadStruct(transColor);
|
|
m_ImageHost.SetTransparentColor(transColor);
|
|
} else {
|
|
chunk->ReadStruct(currentSlot);
|
|
m_ImageHost.SetCurrentSlot(currentSlot);
|
|
}
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
// read mipmap
|
|
if (chunk->SeekIdentifier(CK_STATESAVEFLAGS_TEXTURE::CK_STATESAVE_USERMIPMAP)) {
|
|
CKDWORD mipmapCount;
|
|
chunk->ReadStruct(mipmapCount);
|
|
m_MipmapImages.resize(mipmapCount);
|
|
|
|
for (CKDWORD i = 0; i < mipmapCount; ++i) {
|
|
VxMath::VxImageDescEx cache;
|
|
if (CKBitmapData::ReadRawBitmap(chunk, &cache)) {
|
|
VxMath::VxDoBlitUpsideDown(&cache, &m_MipmapImages[i]);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// pick threshold
|
|
if (chunk->SeekIdentifier(CK_STATESAVEFLAGS_TEXTURE::CK_STATESAVE_PICKTHRESHOLD)) {
|
|
CKDWORD threshold;
|
|
chunk->ReadStruct(threshold);
|
|
m_ImageHost.SetPickThreshold(threshold);
|
|
}
|
|
|
|
// save properties
|
|
if (chunk->SeekIdentifier(CK_STATESAVEFLAGS_TEXTURE::CK_STATESAVE_TEXSAVEFORMAT)) {
|
|
auto buf = chunk->ReadBufferWrapper();
|
|
if (buf != nullptr) {
|
|
FakeBitmapProperties* props = static_cast<FakeBitmapProperties*>(buf.get());
|
|
|
|
CKBitmapProperties myprops(
|
|
CKGUID(props->m_ReaderGuid.d1, props->m_ReaderGuid.d2),
|
|
props->m_Ext.m_Data
|
|
);
|
|
m_ImageHost.SetSaveFormat(myprops);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// correct video format
|
|
if (m_VideoFormat > VxMath::VX_PIXELFORMAT::_32_X8L8V8U8) {
|
|
m_VideoFormat = VxMath::VX_PIXELFORMAT::_16_ARGB1555;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
#pragma region Visitor
|
|
|
|
CKBitmapData& CKTexture::GetUnderlyingData() {
|
|
return m_ImageHost;
|
|
}
|
|
|
|
bool CKTexture::IsUseMipmap() const {
|
|
return m_UseMipMap;
|
|
}
|
|
|
|
void CKTexture::UseMipmap(bool isUse) {
|
|
m_UseMipMap = isUse;
|
|
|
|
if (!m_UseMipMap) {
|
|
m_MipmapImages.clear();
|
|
}
|
|
}
|
|
|
|
CKDWORD CKTexture::GetMipmapLevel() const {
|
|
return static_cast<CKDWORD>(m_MipmapImages.size());
|
|
}
|
|
|
|
void CKTexture::SetMipmapLevel(CKDWORD level) {
|
|
m_MipmapImages.resize(level);
|
|
}
|
|
|
|
VxMath::VxImageDescEx* CKTexture::GetMipmapLevelData(CKDWORD level) {
|
|
if (!m_UseMipMap || level >= m_MipmapImages.size()) return nullptr;
|
|
return &m_MipmapImages[level];
|
|
}
|
|
|
|
VxMath::VX_PIXELFORMAT CKTexture::GetVideoFormat() const {
|
|
return m_VideoFormat;
|
|
}
|
|
|
|
void CKTexture::SetVideoFormat(VxMath::VX_PIXELFORMAT fmt) {
|
|
m_VideoFormat = fmt;
|
|
}
|
|
|
|
#pragma endregion
|
|
|
|
|
|
}
|