Revert "Initial check-in for baking COLLADA animations in the encoder."

This reverts commit 05c8ffcad2655a5c05563421dcf8e3ed807a33c2.

gameplay-encoder/src/DAESceneEncoder.cpp

@@ -34,217 +34,6 @@ unsigned int getMaxOffset(domInputLocalOffset_Array& inputArray)
     return maxOffset;
 }
 
-void DAESceneEncoder::bakeAnimations()
-{
-    // Determine the animation frame rate to bake to. (Command line argument? Default 1/24 seconds?)
-
-
-    // Visit all nodes in the scene
-    const domCOLLADA::domSceneRef& domScene = _dom->getScene();
-    daeElement* element = domScene->getInstance_visual_scene()->getUrl().getElement();
-    if (element && element->getElementType() == COLLADA_TYPE::VISUAL_SCENE)
-    {
-        const domVisual_sceneRef visualScene = daeSafeCast<domVisual_scene>(element);
-        const domNode_Array& nodeArray = visualScene->getNode_array();
-        const size_t childCount = nodeArray.getCount();
-        for (size_t i = 0; i < childCount; ++i)
-        {
-            domNodeRef node = nodeArray[i];
-            bakeAnimations(node);
-        }
-    }
-}
-
-static std::string concat(const char* a, const char* b)
-{
-    std::string str;
-    str.reserve(strlen(a) + strlen(b) + 1);
-    str.append(a);
-    str.append(b);
-    return str;
-}
-
-domSource* createInputSource(domAnimationRef& animation, std::vector<float>& keyTimes)
-{
-    domSourceRef inputSource = daeSafeCast<domSource>(animation->createAndPlace("source"));
-    inputSource->setId(concat(animation->getId(), ".matrix-input").c_str());
-
-    domFloat_arrayRef floatArray = daeSafeCast<domFloat_array>(inputSource->createAndPlace("float_array"));
-    floatArray->setId(concat(inputSource->getId(), "-array").c_str());
-    
-    domListOfFloats floats;
-    const size_t count = keyTimes.size();
-    floats.setCount(count);
-    for (size_t i = 0; i < count; ++i)
-    {
-        floats.set(i, keyTimes[i]);
-    }
-    floatArray->setValue(floats);
-    floatArray->setCount(count);
-
-    domSource::domTechnique_commonRef technique = daeSafeCast<domSource::domTechnique_common>(inputSource->createAndPlace("technique_common"));
-    domAccessorRef accessor = daeSafeCast<domAccessor>(technique->createAndPlace("accessor"));
-    accessor->setSource(concat("#", floatArray->getId()).c_str());
-    accessor->setCount(count);
-    accessor->setStride(1);
-    domParamRef param = daeSafeCast<domParam>(accessor->createAndPlace("param"));
-    param->setName("TIME");
-    param->setType("float");
-
-    return inputSource.cast();
-}
-
-domSource* createOutputSource(domAnimationRef& animation, std::vector<Matrix>& matrices)
-{
-    domSourceRef outputSource = daeSafeCast<domSource>(animation->createAndPlace("source"));
-    outputSource->setId(concat(animation->getId(), ".matrix-output").c_str());
-
-    domFloat_arrayRef floatArray = daeSafeCast<domFloat_array>(outputSource->createAndPlace("float_array"));
-    floatArray->setId(concat(outputSource->getId(), "-array").c_str());
-
-    const size_t MATRIX_SIZE = 16;
-    domListOfFloats floats;
-    const size_t floatCount = matrices.size() * MATRIX_SIZE;
-    floats.setCount(floatCount);
-    const size_t matricesCount = matrices.size();
-    for (size_t i = 0; i < matricesCount; ++i)
-    {
-        const Matrix& matrix = matrices[i];
-        size_t index = i * MATRIX_SIZE;
-        floats.set(index, matrix.m[0]);
-        for (size_t j = 0; j < MATRIX_SIZE; ++j)
-        {
-            floats.set(index + j, matrix.m[j]);
-        }
-    }
-    floatArray->setValue(floats);
-    floatArray->setCount(floatCount);
-
-    domSource::domTechnique_commonRef technique = daeSafeCast<domSource::domTechnique_common>(outputSource->createAndPlace("technique_common"));
-    domAccessorRef accessor = daeSafeCast<domAccessor>(technique->createAndPlace("accessor"));
-    accessor->setSource(concat("#", floatArray->getId()).c_str());
-    accessor->setCount(matricesCount);
-    accessor->setStride(MATRIX_SIZE);
-    domParamRef param = daeSafeCast<domParam>(accessor->createAndPlace("param"));
-    param->setName("TRANSFORM");
-    param->setType("float4x4");
-
-    return outputSource.cast();
-}
-
-domSource* createInterpolationSource(domAnimationRef& animation, size_t count)
-{
-    domSourceRef interpolationSource = daeSafeCast<domSource>(animation->createAndPlace("source"));
-    interpolationSource->setId(concat(animation->getId(), ".matrix-interpolation").c_str());
-    
-    domName_arrayRef nameArray = daeSafeCast<domName_array>(interpolationSource->createAndPlace("Name_array"));
-    nameArray->setId(concat(interpolationSource->getId(), "-array").c_str());
-    
-    domListOfNames names;
-    names.setCount(count);
-    for (size_t i = 0; i < count; ++i)
-    {
-        names.set(i, "LINEAR");
-    }
-    nameArray->setValue(names);
-    nameArray->setCount(count);
-
-    domSource::domTechnique_commonRef technique = daeSafeCast<domSource::domTechnique_common>(interpolationSource->createAndPlace("technique_common"));
-    domAccessorRef accessor = daeSafeCast<domAccessor>(technique->createAndPlace("accessor"));
-    accessor->setSource(concat("#", nameArray->getId()).c_str());
-    accessor->setCount(count);
-    accessor->setStride(1);
-    domParamRef param = daeSafeCast<domParam>(accessor->createAndPlace("param"));
-    param->setName("INTERPOLATION");
-    param->setType("name");
-
-    return interpolationSource.cast();
-}
-
-void DAESceneEncoder::bakeAnimations(domNodeRef& node)
-{
-    // find all animation channels that target this node // (getAnimationChannels() in DAEUtil.h?)
-    std::list<domChannelRef> channels;
-    getAnimationChannels(node, channels, false);
-    
-    float bake_frame_rate = 0.04166666667f; // TODO: don't hard code
-    if (!channels.empty())
-    {
-        // find min start time of these channels
-        // find max end time of these channels
-        float startTime = 0, endTime = 0;
-        getStartAndEndTime(channels, &startTime, &endTime);
-        
-        std::vector<float> keyTimes;
-        std::vector<Matrix> matrices;
-        // TODO reserve?
-
-        // create temp container to store key times and key values?
-        for (float t = startTime; t < endTime; t += bake_frame_rate)
-        {
-            Matrix matrix;
-            getNodeTransform(node, channels, t, matrix);
-            //  determine the node's transform at time t from the channels // (will probably have to use Curve.h)
-            //  append(time t, transform)
-            keyTimes.push_back(t);
-            matrices.push_back(matrix);
-        }
-        // determine the node's transform at time end_time
-        // append(time end_time, transform)
-        // 
-
-        // create <animation>
-        domLibrary_animations_Array& animationsLibraryArray = _dom->getLibrary_animations_array();
-        assert(animationsLibraryArray.getCount() > 0);
-        domLibrary_animationsRef& animationsLibrary = animationsLibraryArray.get(0);
-        domAnimationRef animation = daeSafeCast<domAnimation>(animationsLibrary->createAndPlace("animation"));
-        // OpenCOLLADA sets the id equal to the node's ID
-        animation->setId(node->getId());
-
-        // create <source> for key times (INPUT)
-        domSourceRef inputSource = createInputSource(animation, keyTimes);
-
-        // create <source> for key values (OUTPUT)
-        domSourceRef outputSource = createOutputSource(animation, matrices);
-
-        // create <source> for interpolations (INTERPOLATION) (<Name_array>)
-        domSourceRef interpolationSource = createInterpolationSource(animation, keyTimes.size());
-        
-        // create <sampler>
-        domSamplerRef sampler = daeSafeCast<domSampler>(animation->createAndPlace("sampler"));
-        sampler->setId(concat(animation->getId(), "-sampler").c_str());
-        // create <input semantic="INPUT" source="id_of_source">
-        domInputLocalRef inputInput = daeSafeCast<domInputLocal>(sampler->createAndPlace("input"));
-        inputInput->setSemantic("INPUT");
-        inputInput->setSource(concat("#", inputSource->getId()).c_str());
-        // create <input semantic="OUTPUT" source="id_of_source">
-        domInputLocalRef outputInput = daeSafeCast<domInputLocal>(sampler->createAndPlace("input"));
-        outputInput->setSemantic("OUTPUT");
-        outputInput->setSource(concat("#", outputSource->getId()).c_str());
-        // create <input semantic="INTERPOLATION" source="id_of_source">
-        domInputLocalRef interpolationInput = daeSafeCast<domInputLocal>(sampler->createAndPlace("input"));
-        interpolationInput->setSemantic("INTERPOLATION");
-        interpolationInput->setSource(concat("#", interpolationSource->getId()).c_str());
-
-        // create <channel source="source_id" target="node_id/transform" />
-        domChannelRef channel = daeSafeCast<domChannel>(animation->createAndPlace("channel"));
-        channel->setSource(concat("#", sampler->getId()).c_str());
-        channel->setTarget(concat(node->getId(), "/transform").c_str());
-    }
-    // Calculate the baked transform of the Node from <rotate> <scale> <translate> and delete those elements.
-    // Add <matrix> element to the node with the calculated transform matrix. Make sure sid="transform". // Matches <channel target="node_id/transform">
-    bakeNodeTransform(node);
-
-    // visit all child nodes
-    const domNode_Array& nodeArray = node->getNode_array();
-    const size_t childCount = nodeArray.getCount();
-    for (size_t i = 0; i < childCount; ++i)
-    {
-        domNodeRef node = nodeArray[i];
-        bakeAnimations(node);
-    }
-}
-
 void DAESceneEncoder::optimizeCOLLADA(const EncoderArguments& arguments, domCOLLADA* dom)
 {
     DAEOptimizer optimizer(dom);
@@ -261,9 +50,6 @@ void DAESceneEncoder::optimizeCOLLADA(const EncoderArguments& arguments, domCOLL
         }
         end("groupAnimation");
     }
-
-    bakeAnimations();
-
     if (arguments.DAEOutputEnabled())
     {
         if (!_collada->writeTo(arguments.getFilePath(), arguments.getDAEOutputPath()))
@@ -1027,9 +813,9 @@ void DAESceneEncoder::transformNode(domNode* domNode, Node* node)
 
 void DAESceneEncoder::calcTransform(domNode* domNode, Matrix& dstTransform)
 {
-    daeTArray<daeSmartRef<daeElement>> children;
+    daeTArray<daeSmartRef<daeElement> > children;
     domNode->getChildren(children);
-    const size_t childCount = children.getCount();
+    size_t childCount = children.getCount();
     for (size_t i = 0; i < childCount; ++i)
     {
         daeElementRef childElement = children[i];

gameplay-encoder/src/DAESceneEncoder.h

@@ -81,9 +81,6 @@ private:
         }
     };
 
-    void bakeAnimations();
-    void bakeAnimations(domNodeRef& node);
-
     /**
      * Optimizes the COLLADA dom based on the arguments passed to the encoder.
      * 

gameplay-encoder/src/DAEUtil.cpp

@@ -1,8 +1,6 @@
 #include "Base.h"
 #include "DAEUtil.h"
 #include "StringUtil.h"
-#include "DAEChannelTarget.h"
-#include "Vector4.h"
 
 namespace gameplay
 {
@@ -17,7 +15,7 @@ namespace gameplay
  */
 int getIndex(const domInstance_controller::domSkeleton_Array& skeletonArray, const domNodeRef& node);
 
-void getAnimationChannels(const domNodeRef& node, std::list<domChannelRef>& channels, bool recursive)
+void getAnimationChannels(const domNodeRef& node, std::list<domChannelRef>& channels)
 {
     assert(node->getId());
     std::string nodeIdSlash (node->getId());
@@ -51,20 +49,17 @@ void getAnimationChannels(const domNodeRef& node, std::list<domChannelRef>& chan
         }
     }
 
-    if (recursive)
+    // Recursively do the same for all nodes
+    daeTArray< daeSmartRef<daeElement> > children;
+    node->getChildren(children);
+    size_t childCount = children.getCount();
+    for (size_t i = 0; i < childCount; ++i)
     {
-        // Recursively do the same for all nodes
-        daeTArray< daeSmartRef<daeElement>> children;
-        node->getChildren(children);
-        size_t childCount = children.getCount();
-        for (size_t i = 0; i < childCount; ++i)
+        daeElementRef childElement = children[i];
+        if (childElement->getElementType() == COLLADA_TYPE::NODE)
         {
-            daeElementRef childElement = children[i];
-            if (childElement->getElementType() == COLLADA_TYPE::NODE)
-            {
-                domNodeRef childNode = daeSafeCast<domNode>(childElement);
-                getAnimationChannels(childNode, channels);
-            }
+            domNodeRef childNode = daeSafeCast<domNode>(childElement);
+            getAnimationChannels(childNode, channels);
         }
     }
 }
@@ -267,199 +262,6 @@ const domInstance_controller::domSkeletonRef getSkeleton(const domInstance_contr
     return NULL;
 }
 
-void getStartAndEndTime(const domChannelRef& channel, float* startTime, float* endTime)
-{
-    domSourceRef source = getInputSource(channel);
-    const domFloat_arrayRef floatArray = source->getFloat_array();
-    const domListOfFloats& floatList = floatArray->getValue();
-    assert(floatList.getCount() > 0);
-    *startTime = (float)floatList.get(0);
-    *endTime = (float)floatList.get(floatList.getCount() - 1);
-}
-
-void getStartAndEndTime(const std::list<domChannelRef>& channels, float* startTime, float* endTime)
-{
-    float minStart = FLT_MAX, maxEnd = 0, start = FLT_MAX, end = 0;
-    for (std::list<domChannelRef>::const_iterator i = channels.begin(); i != channels.end(); ++i)
-    {
-        getStartAndEndTime(*i, &start, &end);
-        minStart = std::min(start, minStart);
-        maxEnd = std::max(end, maxEnd);
-    }
-    assert(minStart <= maxEnd);
-    *startTime = minStart;
-    *endTime = maxEnd;
-}
-
-DAEChannelTarget* getChannelTarget(std::list<DAEChannelTarget>& targets, const char* sid)
-{
-    if (!sid)
-        return NULL;
-
-    for (std::list<DAEChannelTarget>::const_iterator i = targets.begin(); i != targets.end(); ++i)
-    {
-        
-    }
-    return NULL;
-}
-
-void getRotate(Vector4& rotate, float time)
-{
-    // if property is ANGLE
-
-}
-
-void bakeNodeTransform(domNodeRef& node)
-{
-    Matrix nodeBakedMatrix;
-
-    daeTArray<daeSmartRef<daeElement>> children;
-    node->getChildren(children);
-    size_t childCount = children.getCount();
-    for (size_t i = 0; i < childCount; ++i)
-    {
-        daeElementRef childElement = children[i];
-        switch (childElement->getElementType())
-        {
-            case COLLADA_TYPE::TRANSLATE:
-                {
-                    domTranslateRef translateNode = daeSafeCast<domTranslate>(childElement);
-                    float x = (float)translateNode->getValue().get(0);
-                    float y = (float)translateNode->getValue().get(1);
-                    float z = (float)translateNode->getValue().get(2);
-                    nodeBakedMatrix.translate(x, y, z);
-                    break;
-                }
-            case COLLADA_TYPE::ROTATE:
-                {
-                    domRotateRef rotateNode = daeSafeCast<domRotate>(childElement);
-                    Vector4 rotate;
-                    rotate.x = (float)rotateNode->getValue().get(0);
-                    rotate.y = (float)rotateNode->getValue().get(1);
-                    rotate.z = (float)rotateNode->getValue().get(2);
-                    rotate.w = MATH_DEG_TO_RAD((float)rotateNode->getValue().get(3)); // COLLADA uses degrees, gameplay uses radians
-                    if (rotate.w != 0.0f)
-                    {
-                        nodeBakedMatrix.rotate(rotate.x, rotate.y, rotate.z, rotate.w);
-                    }
-                    break;
-                }
-            case COLLADA_TYPE::SCALE:
-                {
-                    domScaleRef scaleNode = daeSafeCast<domScale>(childElement);
-                    float x = (float)scaleNode->getValue().get(0);
-                    float y = (float)scaleNode->getValue().get(1);
-                    float z = (float)scaleNode->getValue().get(2);
-                    nodeBakedMatrix.scale(x, y, z);
-                    break;
-                }
-            default:
-                break;
-        }
-    }
-    // go through the list backwards because elements will be removed
-    for (int i = childCount - 1; i >= 0; --i)
-    {
-        daeElementRef childElement = children[i];
-        switch (childElement->getElementType())
-        {
-            case COLLADA_TYPE::TRANSLATE:
-            case COLLADA_TYPE::ROTATE:
-            case COLLADA_TYPE::SCALE:
-            case COLLADA_TYPE::EXTRA:
-                daeElement::removeFromParent(childElement);
-            default:
-                break;
-        }
-    }
-
-    domMatrixRef mat = daeSafeCast<domMatrix>(node->createAndPlaceAt(0, "matrix"));
-    mat->setSid("transform");
-    domFloat4x4 floatMatrix;
-    floatMatrix.setCount(16);
-    floatMatrix.set(0, nodeBakedMatrix.m[0]);
-    floatMatrix.set(1, nodeBakedMatrix.m[4]);
-    floatMatrix.set(2, nodeBakedMatrix.m[8]);
-    floatMatrix.set(3, nodeBakedMatrix.m[12]);
-    floatMatrix.set(4, nodeBakedMatrix.m[1]);
-    floatMatrix.set(5, nodeBakedMatrix.m[5]);
-    floatMatrix.set(6, nodeBakedMatrix.m[9]);
-    floatMatrix.set(7, nodeBakedMatrix.m[13]);
-    floatMatrix.set(8, nodeBakedMatrix.m[2]);
-    floatMatrix.set(9, nodeBakedMatrix.m[6]);
-    floatMatrix.set(10, nodeBakedMatrix.m[10]);
-    floatMatrix.set(11, nodeBakedMatrix.m[14]);
-    floatMatrix.set(12, nodeBakedMatrix.m[3]);
-    floatMatrix.set(13, nodeBakedMatrix.m[7]);
-    floatMatrix.set(14, nodeBakedMatrix.m[11]);
-    floatMatrix.set(15, nodeBakedMatrix.m[15]);
-    mat->setValue(floatMatrix);
-}
-
-void getNodeTransform(const domNodeRef& node, std::list<domChannelRef>& channels, float time, Matrix& dstTransform)
-{
-    // for each transform element in node
-    // modify the transform element if one (or more?) of the channels targets it
-    // bake the transform
-
-    std::list<DAEChannelTarget> targets;
-
-    //DAEChannelTarget channelTarget(
-    for (std::list<domChannelRef>::const_iterator i = channels.begin(); i != channels.end(); ++i)
-    {
-        targets.push_back(DAEChannelTarget(*i));
-    }
-    // TODO sort targets?
-
-    daeTArray<daeSmartRef<daeElement>> children;
-    node->getChildren(children);
-    size_t childCount = children.getCount();
-    for (size_t i = 0; i < childCount; ++i)
-    {
-        daeElementRef childElement = children[i];
-        switch (childElement->getElementType())
-        {
-            case COLLADA_TYPE::TRANSLATE:
-                {
-                    domTranslateRef translateNode = daeSafeCast<domTranslate>(childElement);
-                    float x = (float)translateNode->getValue().get(0);
-                    float y = (float)translateNode->getValue().get(1);
-                    float z = (float)translateNode->getValue().get(2);
-                    dstTransform.translate(x, y, z);
-                    break;
-                }
-            case COLLADA_TYPE::ROTATE:
-                {
-                    domRotateRef rotateNode = daeSafeCast<domRotate>(childElement);
-                    //rotateNode->getSid();
-                    Vector4 rotate;
-                    rotate.x = (float)rotateNode->getValue().get(0);
-                    rotate.y = (float)rotateNode->getValue().get(1);
-                    rotate.z = (float)rotateNode->getValue().get(2);
-                    rotate.w = MATH_DEG_TO_RAD((float)rotateNode->getValue().get(3)); // COLLADA uses degrees, gameplay uses radians
-
-                    if (rotate.w != 0.0f)
-                    {
-                        dstTransform.rotate(rotate.x, rotate.y, rotate.z, rotate.w);
-                    }
-                    break;
-                }
-            case COLLADA_TYPE::SCALE:
-                {
-                    domScaleRef scaleNode = daeSafeCast<domScale>(childElement);
-                    float x = (float)scaleNode->getValue().get(0);
-                    float y = (float)scaleNode->getValue().get(1);
-                    float z = (float)scaleNode->getValue().get(2);
-                    dstTransform.scale(x, y, z);
-                    break;
-                }
-            default:
-                break;
-        }
-
-    }
-}
-
 bool equalKeyTimes(const domSource* s1, const domSource* s2)
 {
     // TODO: shouldn't assume that the source has a float array.

gameplay-encoder/src/DAEUtil.h

@@ -1,8 +1,6 @@
 #ifndef DAEUTIL_H_
 #define DAEUTIL_H_
 
-#include "Matrix.h"
-
 namespace gameplay
 {
 
@@ -11,9 +9,8 @@ namespace gameplay
  * 
  * @param node The node that the animation channels target.
  * @param channels The list of channels to append to.
- * @param recursive True if channels that target child nodes should also be included.
  */
-void getAnimationChannels(const domNodeRef& node, std::list<domChannelRef>& channels, bool recursive = true);
+void getAnimationChannels(const domNodeRef& node, std::list<domChannelRef>& channels);
 
 /**
  * Gets the joint names for the given source and appends them to the given list.
@@ -69,13 +66,6 @@ const domSourceRef getSource(const domInputLocalRef& inputLocal, const domAnimat
  */
 const domName_arrayRef getSourceNameArray(const domSourceRef& source);
 
-void bakeNodeTransform(domNodeRef& node);
-
-/**
- * Gets the node's transform at the given time.
- */
-void getNodeTransform(const domNodeRef& node, std::list<domChannelRef>& channels, float time, Matrix& dstTransform);
-
 /**
  * Returns one skeleton from the given instance controller.
  * The COLLADA spec says that instance_controller can have multiple skeletons but we only need one.
@@ -87,17 +77,6 @@ void getNodeTransform(const domNodeRef& node, std::list<domChannelRef>& channels
  */
 const domInstance_controller::domSkeletonRef getSkeleton(const domInstance_controllerRef& instanceController);
 
-/**
- * Gets the start and end time for the given animation channel.
- * 
- * @param channel The channel.
- * @param startTime The start time returned.
- * @param endTime The end time returned.
- */
-void getStartAndEndTime(const domChannelRef& channel, float* startTime, float* endTime);
-
-void getStartAndEndTime(const std::list<domChannelRef>& channels, float* startTime, float* endTime);
-
 /**
  * Returns true if the two given animation channels have equal key time input source.
  *