bool Animation::Save(Serializer& dest) const
{
// Write ID, name and length
dest.WriteFileID("UANI");
dest.WriteString(animationName_);
dest.WriteFloat(length_);
// Write tracks
dest.WriteUInt(tracks_.Size());
for (HashMap<StringHash, AnimationTrack>::ConstIterator i = tracks_.Begin(); i != tracks_.End(); ++i)
{
const AnimationTrack& track = i->second_;
dest.WriteString(track.name_);
dest.WriteUByte(track.channelMask_);
dest.WriteUInt(track.keyFrames_.Size());
// Write keyframes of the track
for (unsigned j = 0; j < track.keyFrames_.Size(); ++j)
{
const AnimationKeyFrame& keyFrame = track.keyFrames_[j];
dest.WriteFloat(keyFrame.time_);
if (track.channelMask_ & CHANNEL_POSITION)
dest.WriteVector3(keyFrame.position_);
if (track.channelMask_ & CHANNEL_ROTATION)
dest.WriteQuaternion(keyFrame.rotation_);
if (track.channelMask_ & CHANNEL_SCALE)
dest.WriteVector3(keyFrame.scale_);
}
}
// If triggers have been defined, write an XML file for them
if (!triggers_.Empty() || HasMetadata())
{
File* destFile = dynamic_cast<File*>(&dest);
if (destFile)
{
String xmlName = ReplaceExtension(destFile->GetName(), ".xml");
SharedPtr<XMLFile> xml(new XMLFile(context_));
XMLElement rootElem = xml->CreateRoot("animation");
for (unsigned i = 0; i < triggers_.Size(); ++i)
{
XMLElement triggerElem = rootElem.CreateChild("trigger");
triggerElem.SetFloat("time", triggers_[i].time_);
triggerElem.SetVariant(triggers_[i].data_);
}
SaveMetadataToXML(rootElem);
File xmlFile(context_, xmlName, FILE_WRITE);
xml->Save(xmlFile);
}
else
ATOMIC_LOGWARNING("Can not save animation trigger data when not saving into a file");
}
return true;
}
bool OTSignatureMetadata::operator==(const OTSignatureMetadata& rhs) const
{
return ((HasMetadata() == rhs.HasMetadata()) &&
(GetKeyType() == rhs.GetKeyType()) &&
(FirstCharNymID() == rhs.FirstCharNymID()) &&
(FirstCharMasterCredID() == rhs.FirstCharMasterCredID()) &&
(FirstCharChildCredID() == rhs.FirstCharChildCredID()));
}
/*static*/ bool
MP4Metadata::HasCompleteMetadata(Stream* aSource)
{
// The MoofParser requires a monitor, but we don't need one here.
mozilla::Monitor monitor("MP4Metadata::HasCompleteMetadata");
mozilla::MonitorAutoLock mon(monitor);
auto parser = mozilla::MakeUnique<MoofParser>(aSource, 0, false, &monitor);
return parser->HasMetadata();
}
/*static*/ mozilla::MediaByteRange
MP4Metadata::MetadataRange(Stream* aSource)
{
// The MoofParser requires a monitor, but we don't need one here.
mozilla::Monitor monitor("MP4Metadata::HasCompleteMetadata");
mozilla::MonitorAutoLock mon(monitor);
auto parser = mozilla::MakeUnique<MoofParser>(aSource, 0, false, &monitor);
if (parser->HasMetadata()) {
return parser->mInitRange;
}
return mozilla::MediaByteRange();
}
bool Model::Save(Serializer& dest) const
{
// Write ID
if (!dest.WriteFileID("UMD2"))
return false;
// Write vertex buffers
dest.WriteUInt(vertexBuffers_.Size());
for (unsigned i = 0; i < vertexBuffers_.Size(); ++i)
{
VertexBuffer* buffer = vertexBuffers_[i];
dest.WriteUInt(buffer->GetVertexCount());
const PODVector<VertexElement>& elements = buffer->GetElements();
dest.WriteUInt(elements.Size());
for (unsigned j = 0; j < elements.Size(); ++j)
{
unsigned elementDesc = ((unsigned)elements[j].type_) |
(((unsigned)elements[j].semantic_) << 8) |
(((unsigned)elements[j].index_) << 16);
dest.WriteUInt(elementDesc);
}
dest.WriteUInt(morphRangeStarts_[i]);
dest.WriteUInt(morphRangeCounts_[i]);
dest.Write(buffer->GetShadowData(), buffer->GetVertexCount() * buffer->GetVertexSize());
}
// Write index buffers
dest.WriteUInt(indexBuffers_.Size());
for (unsigned i = 0; i < indexBuffers_.Size(); ++i)
{
IndexBuffer* buffer = indexBuffers_[i];
dest.WriteUInt(buffer->GetIndexCount());
dest.WriteUInt(buffer->GetIndexSize());
dest.Write(buffer->GetShadowData(), buffer->GetIndexCount() * buffer->GetIndexSize());
}
// Write geometries
dest.WriteUInt(geometries_.Size());
for (unsigned i = 0; i < geometries_.Size(); ++i)
{
// Write bone mappings
dest.WriteUInt(geometryBoneMappings_[i].Size());
for (unsigned j = 0; j < geometryBoneMappings_[i].Size(); ++j)
dest.WriteUInt(geometryBoneMappings_[i][j]);
// Write the LOD levels
dest.WriteUInt(geometries_[i].Size());
for (unsigned j = 0; j < geometries_[i].Size(); ++j)
{
Geometry* geometry = geometries_[i][j];
dest.WriteFloat(geometry->GetLodDistance());
dest.WriteUInt(geometry->GetPrimitiveType());
dest.WriteUInt(LookupVertexBuffer(geometry->GetVertexBuffer(0), vertexBuffers_));
dest.WriteUInt(LookupIndexBuffer(geometry->GetIndexBuffer(), indexBuffers_));
dest.WriteUInt(geometry->GetIndexStart());
dest.WriteUInt(geometry->GetIndexCount());
}
}
// Write morphs
dest.WriteUInt(morphs_.Size());
for (unsigned i = 0; i < morphs_.Size(); ++i)
{
dest.WriteString(morphs_[i].name_);
dest.WriteUInt(morphs_[i].buffers_.Size());
// Write morph vertex buffers
for (HashMap<unsigned, VertexBufferMorph>::ConstIterator j = morphs_[i].buffers_.Begin();
j != morphs_[i].buffers_.End(); ++j)
{
dest.WriteUInt(j->first_);
dest.WriteUInt(j->second_.elementMask_);
dest.WriteUInt(j->second_.vertexCount_);
// Base size: size of each vertex index
unsigned vertexSize = sizeof(unsigned);
// Add size of individual elements
if (j->second_.elementMask_ & MASK_POSITION)
vertexSize += sizeof(Vector3);
if (j->second_.elementMask_ & MASK_NORMAL)
vertexSize += sizeof(Vector3);
if (j->second_.elementMask_ & MASK_TANGENT)
vertexSize += sizeof(Vector3);
dest.Write(j->second_.morphData_.Get(), vertexSize * j->second_.vertexCount_);
}
}
// Write skeleton
skeleton_.Save(dest);
// Write bounding box
dest.WriteBoundingBox(boundingBox_);
// Write geometry centers
for (unsigned i = 0; i < geometryCenters_.Size(); ++i)
dest.WriteVector3(geometryCenters_[i]);
// Write metadata
if (HasMetadata())
{
File* destFile = dynamic_cast<File*>(&dest);
if (destFile)
{
String xmlName = ReplaceExtension(destFile->GetName(), ".xml");
SharedPtr<XMLFile> xml(new XMLFile(context_));
XMLElement rootElem = xml->CreateRoot("model");
SaveMetadataToXML(rootElem);
File xmlFile(context_, xmlName, FILE_WRITE);
xml->Save(xmlFile);
}
else
URHO3D_LOGWARNING("Can not save model metadata when not saving into a file");
}
return true;
}
/*static*/ bool
MP4Metadata::HasCompleteMetadata(Stream* aSource)
{
auto parser = mozilla::MakeUnique<MoofParser>(aSource, 0, false);
return parser->HasMetadata();
}
bool
UsdPrim::HasAuthoredReferences() const
{
return HasMetadata(SdfFieldKeys->References);
}
bool
UsdPrim::HasAuthoredSpecializes() const
{
return HasMetadata(SdfFieldKeys->Specializes);
}
bool
UsdPrim::HasAuthoredInherits() const
{
return HasMetadata(SdfFieldKeys->InheritPaths);
}
bool
UsdPrim::HasVariantSets() const
{
return HasMetadata(SdfFieldKeys->VariantSetNames);
}
bool ReadTag ( IO::InputStream* inputStream, TagState & inOutTagState,
long* tagType, XMP_Uns32* tagLength, XMP_Uns64& inOutPosition )
{
try {
XMP_Uns64 startPosition = inOutPosition;
long bytesRead;
XMP_Uns8 buffer[4];
bytesRead = inputStream->Read ( buffer, 2 );
if ( bytesRead != 2 ) return false;
inOutPosition += 2;
XMP_Uns16 code = GetUns16LE ( buffer );
*tagType = code >> 6;
*tagLength = code & 0x3f;
bool longTag = false;
if ( *tagLength == 0x3f ) {
longTag = true;
bytesRead = inputStream->Read ( buffer, 4 );
if ( bytesRead != 4 ) return false;
inOutPosition += 4;
*tagLength = GetUns32LE ( buffer );
}
inOutPosition += *tagLength;
TagData newTag;
newTag.pos = startPosition;
newTag.len = *tagLength;
newTag.id = *tagType;
newTag.offset = ( (! longTag) ? 2 : 6 );
// we cannot check valid XMP within the handler
// provide validating XMP by invoking XMPCore
// check tag for XMP
if ( newTag.id == SWF_TAG_ID_METADATA ) {
newTag.xmp = true;
inOutTagState.xmpTag = newTag;
CheckTag ( inputStream, inOutTagState, newTag );
if ( ! inOutTagState.hasFileAttrTag ) inOutTagState.hasXMP = true;
}
//store FileAttribute Tag
if ( newTag.id == SWF_TAG_ID_FILEATTRIBUTES ) {
inOutTagState.hasFileAttrTag = true;
inOutTagState.fileAttrTag = newTag;
inOutTagState.hasXMP = HasMetadata ( inputStream, inOutTagState );
//decreasing since stream moved on within HasMetadata function
*tagLength -= 4;
}
//store tag in vector to process later
inOutTagState.tags.push_back ( newTag );
//seek to next tag
if ( ! newTag.xmp ) inputStream->Skip ( *tagLength );
if ( inputStream->IsEOF() ) return false;
} catch ( ... ) {
return false;
}
return true;
} // ReadTag
