Int32List* MtpDataPacket::getAInt32() {
Int32List* result = new Int32List;
int count = getUInt32();
for (int i = 0; i < count; i++)
result->push_back(getInt32());
return result;
}
Int32List* MtpDataPacket::getAInt32() {
uint32_t count;
if (!getUInt32(count))
return NULL;
Int32List* result = new Int32List;
for (uint32_t i = 0; i < count; i++) {
int32_t value;
if (!getInt32(value)) {
delete result;
return NULL;
}
result->push(value);
}
return result;
}
void FArchiveXML::LoadAnimatable(FCDocument* document, FCDParameterListAnimatable* animatable, xmlNode* node)
{
if (animatable == NULL || node == NULL) return;
// Look for an animation on this list object
Int32List animatedIndices;
FArchiveXML::FindAnimationChannelsArrayIndices(document, node, animatedIndices);
for (Int32List::iterator it = animatedIndices.begin(); it != animatedIndices.end(); ++it)
{
// Check for repeated animated indices
if (it > animatedIndices.find(*it)) continue;
FCDAnimated* animated = animatable->GetAnimated(*it);
if (!FArchiveXML::LinkAnimated(animated, node)) SAFE_RELEASE(animated);
}
}
bool Object_content::Read(Environment &env,
Stream &stream, Image::Format format)
{
Signal &sig = env.GetSignal();
int cntIcons = 0;
do {
IconDir iconDir;
if (stream.Read(sig, &iconDir, IconDir::Size) < IconDir::Size) {
sig.SetError(ERR_FormatError, "invalid ICO format");
return false;
}
cntIcons = Gura_UnpackUInt16(iconDir.idCount);
} while (0);
Int32List imageOffsets;
for (int iIcon = 0; iIcon < cntIcons; iIcon++) {
IconDirEntry iconDirEntry;
if (stream.Read(sig, &iconDirEntry, IconDirEntry::Size) < IconDirEntry::Size) {
sig.SetError(ERR_FormatError, "invalid ICO format");
return false;
}
long imageOffset = Gura_UnpackInt32(iconDirEntry.dwImageOffset);
imageOffsets.push_back(imageOffset);
}
foreach (Int32List, pImageOffset, imageOffsets) {
long imageOffset = *pImageOffset;
if (!stream.Seek(sig, imageOffset, Stream::SeekSet)) return false;
Image::BitmapInfoHeader bih;
if (stream.Read(sig, &bih, Image::BitmapInfoHeader::Size) < Image::BitmapInfoHeader::Size) {
sig.SetError(ERR_FormatError, "invalid ICO format");
return false;
}
int biWidth = Gura_UnpackInt32(bih.biWidth);
int biHeight = Gura_UnpackInt32(bih.biHeight) / 2;
UInt16 biBitCount = Gura_UnpackUInt16(bih.biBitCount);
AutoPtr<Image> pImage(new Image(format));
if (!pImage->ReadDIBPalette(env, stream, biBitCount)) return false;
if (!pImage->ReadDIB(sig, stream, biWidth, biHeight, biBitCount, true)) {
return false;
}
_valList.push_back(Value(new Object_image(env, pImage.release())));
}
// Retrieves a list of signed integers from a source node
void ReadSource(xmlNode* sourceNode, Int32List& array)
{
if (sourceNode != NULL)
{
// Get the accessor's count
xmlNode* accessorNode = FindTechniqueAccessor(sourceNode);
array.resize(ReadNodeCount(accessorNode));
xmlNode* arrayNode = FindChildByType(sourceNode, DAE_FLOAT_ARRAY_ELEMENT);
const char* arrayContent = ReadNodeContentDirect(arrayNode);
FUStringConversion::ToInt32List(arrayContent, array);
}
}
void FArchiveXML::FindAnimationChannelsArrayIndices(FCDocument* fcdocument, xmlNode* targetArray, Int32List& animatedIndices)
{
// Calculte the node's pointer
fm::string pointer;
CalculateNodeTargetPointer(targetArray, pointer);
if (pointer.empty()) return;
// Retrieve the channels for this pointer and extract their matrix indices.
FCDAnimationChannelList channels;
FArchiveXML::FindAnimationChannels(fcdocument, pointer, channels);
for (FCDAnimationChannelList::iterator it = channels.begin(); it != channels.end(); ++it)
{
FCDAnimationChannelDataMap::iterator itData = FArchiveXML::documentLinkDataMap[(*it)->GetDocument()].animationChannelData.find(*it);
FUAssert(itData != FArchiveXML::documentLinkDataMap[(*it)->GetDocument()].animationChannelData.end(),);
FCDAnimationChannelData& data = itData->second;
int32 animatedIndex = FUStringConversion::ParseQualifier(data.targetQualifier);
if (animatedIndex != -1) animatedIndices.push_back(animatedIndex);
}
}
void GenerateSampledAnimation(FCDSceneNode* node)
{
sampleKeys.clear();
sampleValues.clear();
FCDAnimatedList animateds;
// Special case for rotation angles: need to check for changes that are greater than 180 degrees.
Int32List angleIndices;
// Collect all the animation curves
size_t transformCount = node->GetTransformCount();
for (size_t t = 0; t < transformCount; ++t)
{
FCDTransform* transform = node->GetTransform(t);
FCDAnimated* animated = transform->GetAnimated();
if (animated != NULL)
{
if (animated->HasCurve()) animateds.push_back(animated);
// Figure out whether this is a rotation and then, which animated value contains the angle.
if (!transform->HasType(FCDTRotation::GetClassType())) angleIndices.push_back(-1);
else angleIndices.push_back((int32) animated->FindQualifier(".ANGLE"));
}
}
if (animateds.empty()) return;
// Make a list of the ordered key times to sample
size_t animatedsCount = animateds.size();
for (size_t i = 0; i < animatedsCount; ++i)
{
FCDAnimated* animated = animateds[i];
int32 angleIndex = angleIndices[i];
const FCDAnimationCurveListList& allCurves = animated->GetCurves();
size_t valueCount = allCurves.size();
for (size_t curveIndex = 0; curveIndex < valueCount; ++curveIndex)
{
const FCDAnimationCurveTrackList& curves = allCurves[curveIndex];
if (curves.empty()) continue;
size_t curveKeyCount = curves.front()->GetKeyCount();
const FCDAnimationKey** curveKeys = curves.front()->GetKeys();
size_t sampleKeyCount = sampleKeys.size();
// Merge this curve's keys in with the sample keys
// This assumes both key lists are in increasing order
size_t s = 0, c = 0;
while (s < sampleKeyCount && c < curveKeyCount)
{
float sampleKey = sampleKeys[s], curveKey = curveKeys[c]->input;
if (IsEquivalent(sampleKey, curveKey)) { ++s; ++c; }
else if (sampleKey < curveKey) { ++s; }
else
{
// Add this curve key to the sampling key list
sampleKeys.insert(sampleKeys.begin() + (s++), curveKeys[c++]->input);
sampleKeyCount++;
}
}
// Add all the left-over curve keys to the sampling key list
while (c < curveKeyCount) sampleKeys.push_back(curveKeys[c++]->input);
// Check for large angular rotations..
if (angleIndex == (intptr_t) curveIndex)
{
for (size_t c = 1; c < curveKeyCount; ++c)
{
const FCDAnimationKey* previousKey = curveKeys[c - 1];
const FCDAnimationKey* currentKey = curveKeys[c];
float halfWrapAmount = (currentKey->output - previousKey->output) / 180.0f;
halfWrapAmount *= FMath::Sign(halfWrapAmount);
if (halfWrapAmount >= 1.0f)
{
// Need to add sample times.
size_t addSampleCount = (size_t) floorf(halfWrapAmount);
for (size_t d = 1; d <= addSampleCount; ++d)
{
float fd = (float) d;
float fid = (float) (addSampleCount + 1 - d);
float addSampleTime = (currentKey->input * fd + previousKey->input * fid) / (fd + fid);
// Sorted insert.
float* endIt = sampleKeys.end();
for (float* sampleKeyTime = sampleKeys.begin(); sampleKeyTime != endIt; ++sampleKeyTime)
{
if (IsEquivalent(*sampleKeyTime, addSampleTime)) break;
else if (*sampleKeyTime > addSampleTime)
{
sampleKeys.insert(sampleKeyTime, addSampleTime);
break;
}
}
}
}
}
}
}
}
size_t sampleKeyCount = sampleKeys.size();
if (sampleKeyCount == 0) return;
// Pre-allocate the value array;
sampleValues.reserve(sampleKeyCount);
// Sample the scene node transform
for (size_t i = 0; i < sampleKeyCount; ++i)
{
float sampleTime = sampleKeys[i];
for (FCDAnimatedList::iterator it = animateds.begin(); it != animateds.end(); ++it)
{
// Sample each animated, which changes the transform values directly
(*it)->Evaluate(sampleTime);
}
// Retrieve the new transform matrix for the COLLADA scene node
sampleValues.push_back(node->ToMatrix());
}
}