add animation time range helper

Author: recp

include/ak/animation.h

@@ -244,6 +244,20 @@ AK_EXPORT
 size_t
 ak_animationsCount(struct AkDoc * __restrict doc);
 
+/*!
+ * @brief Compute the authored time range covered by an animation and its
+ *        child animation tree.
+ *
+ *        The function scans INPUT sampler accessors only; it does not allocate
+ *        and it does not resolve channel targets. Returns false when no valid
+ *        key time accessor is reachable.
+ */
+AK_EXPORT
+bool
+ak_animationTimeRange(AkAnimation * __restrict anim,
+                      float       * __restrict outStart,
+                      float       * __restrict outEnd);
+
 /*!
  * @brief Convenience over `ak_animationsCompatibleSet` that walks the
  *        document's animation libraries itself — so callers don't have to

src/anim/conflict.c

@@ -48,6 +48,37 @@
 
 #include "../common.h"
 
+static bool
+ak_animationSamplerTimeRange(AkAnimSampler * __restrict sampler,
+                             float         * __restrict outStart,
+                             float         * __restrict outEnd) {
+  AkInput    *inp;
+  AkAccessor *acc;
+  AkBuffer   *buff;
+  const float *times;
+  uint32_t    count;
+
+  if (!sampler) return false;
+
+  for (inp = sampler->input; inp; inp = inp->next) {
+    if (inp->semantic != AK_INPUT_INPUT)
+      continue;
+
+    acc  = inp->accessor;
+    buff = acc ? acc->buffer : NULL;
+    if (!buff || !buff->data || acc->count == 0)
+      continue;
+
+    times    = (const float *)((const char *)buff->data + acc->byteOffset);
+    count    = acc->count;
+    *outStart = times[0];
+    *outEnd   = times[count - 1];
+    return true;
+  }
+
+  return false;
+}
+
 AK_EXPORT
 bool
 ak_animationsConflict(AkContext   * __restrict ctx,
@@ -129,6 +160,62 @@ ak_animationsCount(AkDoc * __restrict doc) {
   return count;
 }
 
+AK_EXPORT
+bool
+ak_animationTimeRange(AkAnimation * __restrict anim,
+                      float       * __restrict outStart,
+                      float       * __restrict outEnd) {
+  AkAnimation *stack[256], *next;
+  AkChannel   *ch;
+  AkAnimSampler *sampler;
+  float        start, end, minTime, maxTime;
+  int          top;
+  bool         found, includeSiblings;
+
+  if (!anim || !outStart || !outEnd)
+    return false;
+
+  top             = 0;
+  found           = false;
+  includeSiblings = false;
+  minTime         = 0.0f;
+  maxTime         = 0.0f;
+
+  while (anim) {
+    for (ch = anim->channel; ch; ch = ch->next) {
+      sampler = ak_getObjectByUrl(&ch->source);
+      if (!ak_animationSamplerTimeRange(sampler, &start, &end))
+        continue;
+
+      if (!found || start < minTime) minTime = start;
+      if (!found || end   > maxTime) maxTime = end;
+      found = true;
+    }
+
+    if (anim->animation) {
+      next = includeSiblings ? anim->next : NULL;
+      if (next && top < (int)(sizeof(stack) / sizeof(stack[0])))
+        stack[top++] = next;
+      anim = anim->animation;
+      includeSiblings = true;
+    } else if (includeSiblings && anim->next) {
+      anim = anim->next;
+    } else if (top > 0) {
+      anim = stack[--top];
+      includeSiblings = true;
+    } else {
+      anim = NULL;
+    }
+  }
+
+  if (!found)
+    return false;
+
+  *outStart = minTime;
+  *outEnd   = maxTime;
+  return true;
+}
+
 AK_EXPORT
 size_t
 ak_animationsCompatibleSetFromDoc(AkContext     * __restrict ctx,

test/CMakeLists.txt

@@ -1,5 +1,6 @@
 add_executable(assetkit_tests
   runner.c
+  src/core/animation.c
   src/core/memory.c
   src/core/coord.c
   src/core/format_edge.c

test/src/core/animation.c

@@ -0,0 +1,103 @@
+/*
+ * Copyright (C) 2020 Recep Aslantas
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "../test_export_common.h"
+
+static AkAnimSampler *
+ak_test_make_time_sampler(AkHeap     *heap,
+                          void       *parent,
+                          const float *times,
+                          uint32_t    count) {
+  AkAnimSampler *sampler;
+  AkInput       *timeInput;
+  AkInput       *valueInput;
+  static const float values[2] = {0.0f, 1.0f};
+
+  sampler    = ak_heap_calloc(heap, parent, sizeof(*sampler));
+  timeInput  = ak_heap_calloc(heap, sampler, sizeof(*timeInput));
+  valueInput = ak_heap_calloc(heap, sampler, sizeof(*valueInput));
+  if (!sampler || !timeInput || !valueInput)
+    return NULL;
+
+  timeInput->semantic  = AK_INPUT_INPUT;
+  timeInput->accessor  = ak_test_make_float_accessor(heap,
+                                                     timeInput,
+                                                     times,
+                                                     1,
+                                                     count);
+  valueInput->semantic = AK_INPUT_OUTPUT;
+  valueInput->accessor = ak_test_make_float_accessor(heap,
+                                                     valueInput,
+                                                     values,
+                                                     1,
+                                                     2);
+  if (!timeInput->accessor || !valueInput->accessor)
+    return NULL;
+
+  timeInput->next = valueInput;
+  sampler->input  = timeInput;
+  return sampler;
+}
+
+static AkAnimation *
+ak_test_make_time_animation(AkHeap      *heap,
+                            void        *parent,
+                            const float *times,
+                            uint32_t     count) {
+  AkAnimation *anim;
+  AkChannel   *channel;
+
+  anim    = ak_heap_calloc(heap, parent, sizeof(*anim));
+  channel = ak_heap_calloc(heap, anim, sizeof(*channel));
+  if (!anim || !channel)
+    return NULL;
+
+  anim->sampler       = ak_test_make_time_sampler(heap, anim, times, count);
+  channel->source.ptr = anim->sampler;
+  anim->channel       = channel;
+  return anim;
+}
+
+TEST_IMPL(animation_time_range_walks_child_tree) {
+  AkHeap      *heap;
+  AkAnimation *root;
+  AkAnimation *childA;
+  AkAnimation *childB;
+  float        start, end;
+  const float  rootTimes[2]  = {1.0f, 3.0f};
+  const float  childATimes[2] = {0.25f, 2.0f};
+  const float  childBTimes[2] = {4.0f, 7.5f};
+
+  heap = ak_heap_new(NULL, NULL, NULL);
+  ASSERT(heap != NULL);
+
+  root   = ak_test_make_time_animation(heap, NULL, rootTimes, 2);
+  childA = ak_test_make_time_animation(heap, root, childATimes, 2);
+  childB = ak_test_make_time_animation(heap, root, childBTimes, 2);
+  ASSERT(root != NULL);
+  ASSERT(childA != NULL);
+  ASSERT(childB != NULL);
+
+  root->animation = childA;
+  childA->next    = childB;
+
+  ASSERT(ak_animationTimeRange(root, &start, &end));
+  ASSERT(start == 0.25f);
+  ASSERT(end == 7.5f);
+
+  ak_heap_destroy(heap);
+  TEST_SUCCESS
+}

test/tests.h

@@ -27,6 +27,7 @@
 
 TEST_DECLARE(heap)
 TEST_DECLARE(heap_multiple)
+TEST_DECLARE(animation_time_range_walks_child_tree)
 TEST_DECLARE(coord_change_doc_converts_scene_payloads)
 TEST_DECLARE(mesh_triangulate_polygon_sets_triangle_mode)
 TEST_DECLARE(instance_attach_helpers)
@@ -235,6 +236,7 @@ TEST_DECLARE(format_edge_cases)
 TEST_LIST {
   TEST_ENTRY(heap)
   TEST_ENTRY(heap_multiple)
+  TEST_ENTRY(animation_time_range_walks_child_tree)
   TEST_ENTRY(coord_change_doc_converts_scene_payloads)
   TEST_ENTRY(mesh_triangulate_polygon_sets_triangle_mode)
   TEST_ENTRY(instance_attach_helpers)