bool DecompressStream(Serializer& dest, Deserializer& src)
{
if (src.IsEof())
return false;
unsigned destSize = src.ReadUInt();
unsigned srcSize = src.ReadUInt();
if (!srcSize || !destSize)
return true; // No data
if (srcSize > src.GetSize())
return false; // Illegal source (packed data) size reported, possibly not valid data
SharedArrayPtr<unsigned char> srcBuffer(new unsigned char[srcSize]);
SharedArrayPtr<unsigned char> destBuffer(new unsigned char[destSize]);
if (src.Read(srcBuffer, srcSize) != srcSize)
return false;
LZ4_decompress_fast((const char*)srcBuffer.Get(), (char*)destBuffer.Get(), destSize);
return dest.Write(destBuffer, destSize) == destSize;
}
bool Skeleton::Load(Deserializer& source)
{
ClearBones();
if (source.IsEof())
return false;
unsigned bones = source.ReadUInt();
bones_.Reserve(bones);
for (unsigned i = 0; i < bones; ++i)
{
Bone newBone;
newBone.name_ = source.ReadString();
newBone.nameHash_ = newBone.name_;
newBone.parentIndex_ = source.ReadUInt();
newBone.initialPosition_ = source.ReadVector3();
newBone.initialRotation_ = source.ReadQuaternion();
newBone.initialScale_ = source.ReadVector3();
source.Read(&newBone.offsetMatrix_.m00_, sizeof(Matrix3x4));
// Read bone collision data
newBone.collisionMask_ = source.ReadUByte();
if (newBone.collisionMask_ & BONECOLLISION_SPHERE)
newBone.radius_ = source.ReadFloat();
if (newBone.collisionMask_ & BONECOLLISION_BOX)
newBone.boundingBox_ = source.ReadBoundingBox();
if (newBone.parentIndex_ == i)
rootBoneIndex_ = i;
bones_.Push(newBone);
}
return true;
}
bool Node::Load(Deserializer& source, SceneResolver& resolver, bool readChildren, bool rewriteIDs, CreateMode mode)
{
// Remove all children and components first in case this is not a fresh load
RemoveAllChildren();
RemoveAllComponents();
// ID has been read at the parent level
if (!Animatable::Load(source))
return false;
unsigned numComponents = source.ReadVLE();
for (unsigned i = 0; i < numComponents; ++i)
{
VectorBuffer compBuffer(source, source.ReadVLE());
StringHash compType = compBuffer.ReadStringHash();
unsigned compID = compBuffer.ReadUInt();
Component* newComponent = SafeCreateComponent(String::EMPTY, compType,
(mode == REPLICATED && compID < FIRST_LOCAL_ID) ? REPLICATED : LOCAL, rewriteIDs ? 0 : compID);
if (newComponent)
{
resolver.AddComponent(compID, newComponent);
// Do not abort if component fails to load, as the component buffer is nested and we can skip to the next
newComponent->Load(compBuffer);
}
}
if (!readChildren)
return true;
unsigned numChildren = source.ReadVLE();
for (unsigned i = 0; i < numChildren; ++i)
{
unsigned nodeID = source.ReadUInt();
Node* newNode = CreateChild(rewriteIDs ? 0 : nodeID, (mode == REPLICATED && nodeID < FIRST_LOCAL_ID) ? REPLICATED :
LOCAL);
resolver.AddNode(nodeID, newNode);
if (!newNode->Load(source, resolver, readChildren, rewriteIDs, mode))
return false;
}
return true;
}
bool Animation::BeginLoad(Deserializer& source)
{
unsigned memoryUse = sizeof(Animation);
// Check ID
if (source.ReadFileID() != "UANI")
{
URHO3D_LOGERROR(source.GetName() + " is not a valid animation file");
return false;
}
// Read name and length
animationName_ = source.ReadString();
animationNameHash_ = animationName_;
length_ = source.ReadFloat();
tracks_.Clear();
unsigned tracks = source.ReadUInt();
memoryUse += tracks * sizeof(AnimationTrack);
// Read tracks
for (unsigned i = 0; i < tracks; ++i)
{
AnimationTrack* newTrack = CreateTrack(source.ReadString());
newTrack->channelMask_ = source.ReadUByte();
unsigned keyFrames = source.ReadUInt();
newTrack->keyFrames_.Resize(keyFrames);
memoryUse += keyFrames * sizeof(AnimationKeyFrame);
// Read keyframes of the track
for (unsigned j = 0; j < keyFrames; ++j)
{
AnimationKeyFrame& newKeyFrame = newTrack->keyFrames_[j];
newKeyFrame.time_ = source.ReadFloat();
if (newTrack->channelMask_ & CHANNEL_POSITION)
newKeyFrame.position_ = source.ReadVector3();
if (newTrack->channelMask_ & CHANNEL_ROTATION)
newKeyFrame.rotation_ = source.ReadQuaternion();
if (newTrack->channelMask_ & CHANNEL_SCALE)
newKeyFrame.scale_ = source.ReadVector3();
}
}
// Optionally read triggers from an XML file
ResourceCache* cache = GetSubsystem<ResourceCache>();
String xmlName = ReplaceExtension(GetName(), ".xml");
SharedPtr<XMLFile> file(cache->GetTempResource<XMLFile>(xmlName, false));
if (file)
{
XMLElement rootElem = file->GetRoot();
XMLElement triggerElem = rootElem.GetChild("trigger");
while (triggerElem)
{
if (triggerElem.HasAttribute("normalizedtime"))
AddTrigger(triggerElem.GetFloat("normalizedtime"), true, triggerElem.GetVariant());
else if (triggerElem.HasAttribute("time"))
AddTrigger(triggerElem.GetFloat("time"), false, triggerElem.GetVariant());
triggerElem = triggerElem.GetNext("trigger");
}
memoryUse += triggers_.Size() * sizeof(AnimationTriggerPoint);
SetMemoryUse(memoryUse);
return true;
}
// Optionally read triggers from a JSON file
String jsonName = ReplaceExtension(GetName(), ".json");
SharedPtr<JSONFile> jsonFile(cache->GetTempResource<JSONFile>(jsonName, false));
if (jsonFile)
{
const JSONValue& rootVal = jsonFile->GetRoot();
JSONArray triggerArray = rootVal.Get("triggers").GetArray();
for (unsigned i = 0; i < triggerArray.Size(); i++)
{
const JSONValue& triggerValue = triggerArray.At(i);
JSONValue normalizedTimeValue = triggerValue.Get("normalizedTime");
if (!normalizedTimeValue.IsNull())
AddTrigger(normalizedTimeValue.GetFloat(), true, triggerValue.GetVariant());
else
{
JSONValue timeVal = triggerValue.Get("time");
if (!timeVal.IsNull())
AddTrigger(timeVal.GetFloat(), false, triggerValue.GetVariant());
}
}
memoryUse += triggers_.Size() * sizeof(AnimationTriggerPoint);
SetMemoryUse(memoryUse);
return true;
}
SetMemoryUse(memoryUse);
return true;
}
bool Animation::Load(Deserializer& source)
{
PROFILE(LoadAnimation);
unsigned memoryUse = sizeof(Animation);
// Check ID
if (source.ReadFileID() != "UANI")
{
LOGERROR(source.GetName() + " is not a valid animation file");
return false;
}
// Read name and length
animationName_ = source.ReadString();
animationNameHash_ = animationName_;
length_ = source.ReadFloat();
tracks_.Clear();
unsigned tracks = source.ReadUInt();
tracks_.Resize(tracks);
memoryUse += tracks * sizeof(AnimationTrack);
// Read tracks
for (unsigned i = 0; i < tracks; ++i)
{
AnimationTrack& newTrack = tracks_[i];
newTrack.name_ = source.ReadString();
newTrack.nameHash_ = newTrack.name_;
newTrack.channelMask_ = source.ReadUByte();
unsigned keyFrames = source.ReadUInt();
newTrack.keyFrames_.Resize(keyFrames);
memoryUse += keyFrames * sizeof(AnimationKeyFrame);
// Read keyframes of the track
for (unsigned j = 0; j < keyFrames; ++j)
{
AnimationKeyFrame& newKeyFrame = newTrack.keyFrames_[j];
newKeyFrame.time_ = source.ReadFloat();
if (newTrack.channelMask_ & CHANNEL_POSITION)
newKeyFrame.position_ = source.ReadVector3();
if (newTrack.channelMask_ & CHANNEL_ROTATION)
newKeyFrame.rotation_ = source.ReadQuaternion();
if (newTrack.channelMask_ & CHANNEL_SCALE)
newKeyFrame.scale_ = source.ReadVector3();
}
}
// Optionally read triggers from an XML file
ResourceCache* cache = GetSubsystem<ResourceCache>();
String xmlName = ReplaceExtension(GetName(), ".xml");
if (cache->Exists(xmlName))
{
XMLFile* file = cache->GetResource<XMLFile>(xmlName);
if (file)
{
XMLElement rootElem = file->GetRoot();
XMLElement triggerElem = rootElem.GetChild("trigger");
while (triggerElem)
{
if (triggerElem.HasAttribute("normalizedtime"))
AddTrigger(triggerElem.GetFloat("normalizedtime"), true, triggerElem.GetVariant());
else if (triggerElem.HasAttribute("time"))
AddTrigger(triggerElem.GetFloat("time"), false, triggerElem.GetVariant());
triggerElem = triggerElem.GetNext("trigger");
}
memoryUse += triggers_.Size() * sizeof(AnimationTriggerPoint);
}
}
SetMemoryUse(memoryUse);
return true;
}
bool Model::BeginLoad(Deserializer& source)
{
// Check ID
String id = source.ReadFileID();
bool umdl = false;
if (id == "UMDL") // we only support UMDL for some current legacy mdl's (ToonTown)
umdl = true;
if (!umdl && id != "AMDL")
{
LOGERROR(source.GetName() + " is not a valid model file");
return false;
}
geometries_.Clear();
geometryBoneMappings_.Clear();
geometryCenters_.Clear();
morphs_.Clear();
vertexBuffers_.Clear();
indexBuffers_.Clear();
unsigned memoryUse = sizeof(Model);
bool async = GetAsyncLoadState() == ASYNC_LOADING;
// Read vertex buffers
unsigned numVertexBuffers = source.ReadUInt();
vertexBuffers_.Reserve(numVertexBuffers);
morphRangeStarts_.Resize(numVertexBuffers);
morphRangeCounts_.Resize(numVertexBuffers);
loadVBData_.Resize(numVertexBuffers);
for (unsigned i = 0; i < numVertexBuffers; ++i)
{
unsigned vertexCount = source.ReadUInt();
unsigned elementMask = source.ReadUInt();
morphRangeStarts_[i] = source.ReadUInt();
morphRangeCounts_[i] = source.ReadUInt();
SharedPtr<VertexBuffer> buffer(new VertexBuffer(context_));
unsigned vertexSize = VertexBuffer::GetVertexSize(elementMask);
// Prepare vertex buffer data to be uploaded during EndLoad()
if (async)
{
loadVBData_[i].vertexCount_ = vertexCount;
loadVBData_[i].elementMask_ = elementMask;
loadVBData_[i].dataSize_ = vertexCount * vertexSize;
loadVBData_[i].data_ = new unsigned char[loadVBData_[i].dataSize_];
source.Read(loadVBData_[i].data_.Get(), loadVBData_[i].dataSize_);
}
else
{
// If not async loading, use locking to avoid extra allocation & copy
loadVBData_[i].data_.Reset(); // Make sure no previous data
buffer->SetShadowed(true);
buffer->SetSize(vertexCount, elementMask);
void* dest = buffer->Lock(0, vertexCount);
source.Read(dest, vertexCount * vertexSize);
buffer->Unlock();
}
memoryUse += sizeof(VertexBuffer) + vertexCount * vertexSize;
vertexBuffers_.Push(buffer);
}
// Read index buffers
unsigned numIndexBuffers = source.ReadUInt();
indexBuffers_.Reserve(numIndexBuffers);
loadIBData_.Resize(numIndexBuffers);
for (unsigned i = 0; i < numIndexBuffers; ++i)
{
unsigned indexCount = source.ReadUInt();
unsigned indexSize = source.ReadUInt();
SharedPtr<IndexBuffer> buffer(new IndexBuffer(context_));
// Prepare index buffer data to be uploaded during EndLoad()
if (async)
{
loadIBData_[i].indexCount_ = indexCount;
loadIBData_[i].indexSize_ = indexSize;
loadIBData_[i].dataSize_ = indexCount * indexSize;
loadIBData_[i].data_ = new unsigned char[loadIBData_[i].dataSize_];
source.Read(loadIBData_[i].data_.Get(), loadIBData_[i].dataSize_);
}
else
{
// If not async loading, use locking to avoid extra allocation & copy
loadIBData_[i].data_.Reset(); // Make sure no previous data
buffer->SetShadowed(true);
buffer->SetSize(indexCount, indexSize > sizeof(unsigned short));
void* dest = buffer->Lock(0, indexCount);
source.Read(dest, indexCount * indexSize);
buffer->Unlock();
}
memoryUse += sizeof(IndexBuffer) + indexCount * indexSize;
indexBuffers_.Push(buffer);
}
// Read geometries
unsigned numGeometries = source.ReadUInt();
geometries_.Reserve(numGeometries);
geometryBoneMappings_.Reserve(numGeometries);
geometryCenters_.Reserve(numGeometries);
loadGeometries_.Resize(numGeometries);
for (unsigned i = 0; i < numGeometries; ++i)
{
// Read bone mappings
unsigned boneMappingCount = source.ReadUInt();
PODVector<unsigned> boneMapping(boneMappingCount);
for (unsigned j = 0; j < boneMappingCount; ++j)
boneMapping[j] = source.ReadUInt();
geometryBoneMappings_.Push(boneMapping);
unsigned numLodLevels = source.ReadUInt();
Vector<SharedPtr<Geometry> > geometryLodLevels;
geometryLodLevels.Reserve(numLodLevels);
loadGeometries_[i].Resize(numLodLevels);
for (unsigned j = 0; j < numLodLevels; ++j)
{
float distance = source.ReadFloat();
PrimitiveType type = (PrimitiveType)source.ReadUInt();
unsigned vbRef = source.ReadUInt();
unsigned ibRef = source.ReadUInt();
unsigned indexStart = source.ReadUInt();
unsigned indexCount = source.ReadUInt();
if (vbRef >= vertexBuffers_.Size())
{
LOGERROR("Vertex buffer index out of bounds");
loadVBData_.Clear();
loadIBData_.Clear();
loadGeometries_.Clear();
return false;
}
if (ibRef >= indexBuffers_.Size())
{
LOGERROR("Index buffer index out of bounds");
loadVBData_.Clear();
loadIBData_.Clear();
loadGeometries_.Clear();
return false;
}
SharedPtr<Geometry> geometry(new Geometry(context_));
geometry->SetLodDistance(distance);
// Prepare geometry to be defined during EndLoad()
loadGeometries_[i][j].type_ = type;
loadGeometries_[i][j].vbRef_ = vbRef;
loadGeometries_[i][j].ibRef_ = ibRef;
loadGeometries_[i][j].indexStart_ = indexStart;
loadGeometries_[i][j].indexCount_ = indexCount;
geometryLodLevels.Push(geometry);
memoryUse += sizeof(Geometry);
}
geometries_.Push(geometryLodLevels);
}
// Read morphs
unsigned numMorphs = source.ReadUInt();
morphs_.Reserve(numMorphs);
for (unsigned i = 0; i < numMorphs; ++i)
{
ModelMorph newMorph;
newMorph.name_ = source.ReadString();
newMorph.nameHash_ = newMorph.name_;
newMorph.weight_ = 0.0f;
unsigned numBuffers = source.ReadUInt();
for (unsigned j = 0; j < numBuffers; ++j)
{
VertexBufferMorph newBuffer;
unsigned bufferIndex = source.ReadUInt();
newBuffer.elementMask_ = source.ReadUInt();
newBuffer.vertexCount_ = source.ReadUInt();
// Base size: size of each vertex index
unsigned vertexSize = sizeof(unsigned);
// Add size of individual elements
if (newBuffer.elementMask_ & MASK_POSITION)
vertexSize += sizeof(Vector3);
if (newBuffer.elementMask_ & MASK_NORMAL)
vertexSize += sizeof(Vector3);
if (newBuffer.elementMask_ & MASK_TANGENT)
vertexSize += sizeof(Vector3);
newBuffer.dataSize_ = newBuffer.vertexCount_ * vertexSize;
newBuffer.morphData_ = new unsigned char[newBuffer.dataSize_];
source.Read(&newBuffer.morphData_[0], newBuffer.vertexCount_ * vertexSize);
newMorph.buffers_[bufferIndex] = newBuffer;
memoryUse += sizeof(VertexBufferMorph) + newBuffer.vertexCount_ * vertexSize;
}
morphs_.Push(newMorph);
memoryUse += sizeof(ModelMorph);
}
// Read skeleton
skeleton_.Load(source);
memoryUse += skeleton_.GetNumBones() * sizeof(Bone);
// Read bounding box
boundingBox_ = source.ReadBoundingBox();
// Read geometry centers
for (unsigned i = 0; i < geometries_.Size() && !source.IsEof(); ++i)
geometryCenters_.Push(source.ReadVector3());
while (geometryCenters_.Size() < geometries_.Size())
geometryCenters_.Push(Vector3::ZERO);
memoryUse += sizeof(Vector3) * geometries_.Size();
if (umdl)
{
SetMemoryUse(memoryUse);
return true;
}
// MODEL_VERSION
unsigned version = source.ReadUInt();
ResourceRefList animList = source.ReadResourceRefList();
animationsResources_.Clear();
ResourceCache* cache = GetSubsystem<ResourceCache>();
for (unsigned i = 0; i < animList.names_.Size(); ++i)
{
AddAnimationResource(cache->GetResource<Animation>(animList.names_[i]));
}
SetMemoryUse(memoryUse);
return true;
}
bool Sound::LoadWav(Deserializer& source)
{
WavHeader header;
// Try to open
memset(&header, 0, sizeof header);
source.Read(&header.riffText_, 4);
header.totalLength_ = source.ReadUInt();
source.Read(&header.waveText_, 4);
if (memcmp("RIFF", header.riffText_, 4) || memcmp("WAVE", header.waveText_, 4))
{
LOGERROR("Could not read WAV data from " + source.GetName());
return false;
}
// Search for the FORMAT chunk
for (;;)
{
source.Read(&header.formatText_, 4);
header.formatLength_ = source.ReadUInt();
if (!memcmp("fmt ", &header.formatText_, 4))
break;
source.Seek(source.GetPosition() + header.formatLength_);
if (!header.formatLength_ || source.GetPosition() >= source.GetSize())
{
LOGERROR("Could not read WAV data from " + source.GetName());
return false;
}
}
// Read the FORMAT chunk
header.format_ = source.ReadUShort();
header.channels_ = source.ReadUShort();
header.frequency_ = source.ReadUInt();
header.avgBytes_ = source.ReadUInt();
header.blockAlign_ = source.ReadUShort();
header.bits_ = source.ReadUShort();
// Skip data if the format chunk was bigger than what we use
source.Seek(source.GetPosition() + header.formatLength_ - 16);
// Check for correct format
if (header.format_ != 1)
{
LOGERROR("Could not read WAV data from " + source.GetName());
return false;
}
// Search for the DATA chunk
for (;;)
{
source.Read(&header.dataText_, 4);
header.dataLength_ = source.ReadUInt();
if (!memcmp("data", &header.dataText_, 4))
break;
source.Seek(source.GetPosition() + header.dataLength_);
if (!header.dataLength_ || source.GetPosition() >= source.GetSize())
{
LOGERROR("Could not read WAV data from " + source.GetName());
return false;
}
}
// Allocate sound and load audio data
unsigned length = header.dataLength_;
SetSize(length);
SetFormat(header.frequency_, header.bits_ == 16, header.channels_ == 2);
source.Read(data_.Get(), length);
// Convert 8-bit audio to signed
if (!sixteenBit_)
{
for (unsigned i = 0; i < length; ++i)
data_[i] -= 128;
}
return true;
}
bool Model::Load(Deserializer& source)
{
PROFILE(LoadModel);
// Check ID
if (source.ReadFileID() != "UMDL")
{
LOGERROR(source.GetName() + " is not a valid model file");
return false;
}
geometries_.Clear();
geometryBoneMappings_.Clear();
geometryCenters_.Clear();
morphs_.Clear();
vertexBuffers_.Clear();
indexBuffers_.Clear();
unsigned memoryUse = sizeof(Model);
// Read vertex buffers
unsigned numVertexBuffers = source.ReadUInt();
vertexBuffers_.Reserve(numVertexBuffers);
morphRangeStarts_.Resize(numVertexBuffers);
morphRangeCounts_.Resize(numVertexBuffers);
for (unsigned i = 0; i < numVertexBuffers; ++i)
{
unsigned vertexCount = source.ReadUInt();
unsigned elementMask = source.ReadUInt();
morphRangeStarts_[i] = source.ReadUInt();
morphRangeCounts_[i] = source.ReadUInt();
SharedPtr<VertexBuffer> buffer(new VertexBuffer(context_));
buffer->SetShadowed(true);
buffer->SetSize(vertexCount, elementMask);
void* dest = buffer->Lock(0, vertexCount);
unsigned vertexSize = buffer->GetVertexSize();
source.Read(dest, vertexCount * vertexSize);
buffer->Unlock();
memoryUse += sizeof(VertexBuffer) + vertexCount * vertexSize;
vertexBuffers_.Push(buffer);
}
// Read index buffers
unsigned numIndexBuffers = source.ReadUInt();
indexBuffers_.Reserve(numIndexBuffers);
for (unsigned i = 0; i < numIndexBuffers; ++i)
{
unsigned indexCount = source.ReadUInt();
unsigned indexSize = source.ReadUInt();
SharedPtr<IndexBuffer> buffer(new IndexBuffer(context_));
buffer->SetShadowed(true);
buffer->SetSize(indexCount, indexSize > sizeof(unsigned short));
void* dest = buffer->Lock(0, indexCount);
source.Read(dest, indexCount * indexSize);
buffer->Unlock();
memoryUse += sizeof(IndexBuffer) + indexCount * indexSize;
indexBuffers_.Push(buffer);
}
// Read geometries
unsigned numGeometries = source.ReadUInt();
geometries_.Reserve(numGeometries);
geometryBoneMappings_.Reserve(numGeometries);
geometryCenters_.Reserve(numGeometries);
for (unsigned i = 0; i < numGeometries; ++i)
{
// Read bone mappings
unsigned boneMappingCount = source.ReadUInt();
PODVector<unsigned> boneMapping(boneMappingCount);
for (unsigned j = 0; j < boneMappingCount; ++j)
boneMapping[j] = source.ReadUInt();
geometryBoneMappings_.Push(boneMapping);
unsigned numLodLevels = source.ReadUInt();
Vector<SharedPtr<Geometry> > geometryLodLevels;
geometryLodLevels.Reserve(numLodLevels);
for (unsigned j = 0; j < numLodLevels; ++j)
{
float distance = source.ReadFloat();
PrimitiveType type = (PrimitiveType)source.ReadUInt();
unsigned vertexBufferRef = source.ReadUInt();
unsigned indexBufferRef = source.ReadUInt();
unsigned indexStart = source.ReadUInt();
unsigned indexCount = source.ReadUInt();
if (vertexBufferRef >= vertexBuffers_.Size())
{
LOGERROR("Vertex buffer index out of bounds");
return false;
}
if (indexBufferRef >= indexBuffers_.Size())
{
LOGERROR("Index buffer index out of bounds");
return false;
}
SharedPtr<Geometry> geometry(new Geometry(context_));
geometry->SetVertexBuffer(0, vertexBuffers_[vertexBufferRef]);
geometry->SetIndexBuffer(indexBuffers_[indexBufferRef]);
geometry->SetDrawRange(type, indexStart, indexCount);
geometry->SetLodDistance(distance);
geometryLodLevels.Push(geometry);
memoryUse += sizeof(Geometry);
}
geometries_.Push(geometryLodLevels);
}
// Read morphs
unsigned numMorphs = source.ReadUInt();
morphs_.Reserve(numMorphs);
for (unsigned i = 0; i < numMorphs; ++i)
{
ModelMorph newMorph;
newMorph.name_ = source.ReadString();
newMorph.nameHash_ = newMorph.name_;
newMorph.weight_ = 0.0f;
unsigned nubuffers_ = source.ReadUInt();
for (unsigned j = 0; j < nubuffers_; ++j)
{
VertexBufferMorph newBuffer;
unsigned bufferIndex = source.ReadUInt();
newBuffer.elementMask_ = source.ReadUInt();
newBuffer.vertexCount_ = source.ReadUInt();
// Base size: size of each vertex index
unsigned vertexSize = sizeof(unsigned);
// Add size of individual elements
if (newBuffer.elementMask_ & MASK_POSITION)
vertexSize += sizeof(Vector3);
if (newBuffer.elementMask_ & MASK_NORMAL)
vertexSize += sizeof(Vector3);
if (newBuffer.elementMask_ & MASK_TANGENT)
vertexSize += sizeof(Vector3);
newBuffer.morphData_ = new unsigned char[newBuffer.vertexCount_ * vertexSize];
source.Read(&newBuffer.morphData_[0], newBuffer.vertexCount_ * vertexSize);
newMorph.buffers_[bufferIndex] = newBuffer;
memoryUse += sizeof(VertexBufferMorph) + newBuffer.vertexCount_ * vertexSize;
}
morphs_.Push(newMorph);
memoryUse += sizeof(ModelMorph);
}
// Read skeleton
skeleton_.Load(source);
memoryUse += skeleton_.GetNumBones() * sizeof(Bone);
// Read bounding box
boundingBox_ = source.ReadBoundingBox();
// Read geometry centers
for (unsigned i = 0; i < geometries_.Size() && !source.IsEof(); ++i)
geometryCenters_.Push(source.ReadVector3());
while (geometryCenters_.Size() < geometries_.Size())
geometryCenters_.Push(Vector3::ZERO);
memoryUse += sizeof(Vector3) * geometries_.Size();
SetMemoryUse(memoryUse);
return true;
}
