src/animation/blend_accumulator.cpp

#include "rive/animation/blend_accumulator.hpp"
#include "rive/generated/core_registry.hpp"

using namespace rive;

static uint32_t slotOf(const Core* object, int propertyKey)
{
  // Fibonacci hashing of the pointer, with the key folded in.
  uint64_t h = ((uint64_t)(uintptr_t)object ^
                ((uint64_t)(uint32_t)propertyKey << 48)) *
               UINT64_C(0x9E3779B97F4A7C15);
  return (uint32_t)(h >> 32);
}

uint32_t BlendAccumulator::find(Core* object, int propertyKey) const
{
  if (m_index.empty())
  {
    return 0;
  }
  const uint32_t mask = (uint32_t)m_index.size() - 1;
  for (uint32_t i = slotOf(object, propertyKey) & mask;; i = (i + 1) & mask)
  {
    uint32_t entry = m_index[i];
    if (entry == 0)
    {
      return 0;
    }
    const Value& value = m_values[entry - 1];
    if (value.object == object && value.propertyKey == propertyKey)
    {
      return entry;
    }
  }
}

void BlendAccumulator::index(uint32_t valueIndex)
{
  const uint32_t mask = (uint32_t)m_index.size() - 1;
  const Value& value = m_values[valueIndex];
  uint32_t i = slotOf(value.object, value.propertyKey) & mask;
  while (m_index[i] != 0)
  {
    i = (i + 1) & mask;
  }
  m_index[i] = valueIndex + 1;
}

BlendAccumulator::Value& BlendAccumulator::value(
    Core* object,
    int propertyKey,
    bool isColor,
    bool seeding)
{
  uint32_t entry = find(object, propertyKey);
  if (entry == 0)
  {
    m_values.push_back({object, propertyKey, isColor, 0, 0.0f, 0});
    if (m_values.size() * 2 > m_index.size())
    {
      m_index.assign(m_index.empty() ? 16 : m_index.size() * 2, 0);
      for (uint32_t i = 0; i < (uint32_t)m_values.size(); i++)
      {
        index(i);
      }
    }
    else
    {
      index((uint32_t)m_values.size() - 1);
    }
    entry = (uint32_t)m_values.size();
  }
  Value& value = m_values[entry - 1];
  if (value.frame != m_frame)
  {
    value.frame = m_frame;
    m_written.push_back(entry - 1);
    if (!seeding)
    {
      if (isColor)
      {
        value.colorValue = CoreRegistry::getColor(object, propertyKey);
      }
      else
      {
        value.doubleValue = CoreRegistry::getDouble(object, propertyKey);
      }
    }
  }
  return value;
}

void BlendAccumulator::seedDouble(Core* object, int propertyKey, float value)
{
  this->value(object, propertyKey, false, true).doubleValue = value;
}

void BlendAccumulator::seedColor(Core* object, int propertyKey, ColorInt value)
{
  this->value(object, propertyKey, true, true).colorValue = value;
}

void BlendAccumulator::applyDouble(
    Core* object,
    int propertyKey,
    float mix,
    float value)
{
  Value& current = this->value(object, propertyKey, false, false);
  if (mix == 1.0f)
  {
    current.doubleValue = value;
  }
  else
  {
    float mixi = 1.0f - mix;
    current.doubleValue = current.doubleValue * mixi + value * mix;
  }
}

void BlendAccumulator::applyColor(
    Core* object,
    int propertyKey,
    float mix,
    ColorInt value)
{
  Value& current = this->value(object, propertyKey, true, false);
  current.colorValue = mix == 1.0f ? value
                                   : colorLerp(current.colorValue, value, mix);
}

void BlendAccumulator::flush()
{
  for (uint32_t written : m_written)
  {
    const Value& value = m_values[written];
    if (value.isColor)
    {
      CoreRegistry::setColor(value.object, value.propertyKey, value.colorValue);
    }
    else
    {
      CoreRegistry::setDouble(
          value.object,
          value.propertyKey,
          value.doubleValue);
    }
  }
  m_written.clear();
  // Wrapping back to a frame some value still carries would skip loading
  // it, so start the count over with every value marked unwritten.
  if (++m_frame == 0)
  {
    for (Value& value : m_values)
    {
      value.frame = 0;
    }
    m_frame = 1;
  }
}