fvb, functionvalue, vector (#77)

Co-authored-by: Pheenoh <pheenoh@gmail.com>
2026-09-08 02:26:34 -04:00 · 2021-01-18 11:27:25 -08:00
parent e35c282900
commit c48c35f4db
49 changed files with 3454 additions and 2902 deletions
@@ -1 +1,18 @@
-// ok
+#include "JSystem/JGadget/vector.h"
+
+extern "C" {
+void extend_default__Q27JGadget6vectorFUlUlUl();
+}
+
+namespace JGadget {
+namespace vector {
+
+u32 extend_default(u32 arg1, u32 arg2, u32 arg3) {
+    return arg2 * 2;
+}
+
+// TVector_pointer_void::TVector_pointer_void(const TAllocator<void*>& allocator) : TVector<void*,
+// TAllocator>(allocator)
+
+}  // namespace vector
+}  // namespace JGadget
@@ -1 +1,554 @@
-// ok
+#include "JSystem/JStudio/functionvalue.h"
+
+namespace JStudio {
+
+DoubleFunc TFunctionValue::toFunction_outside(int arg1) {
+    DoubleFunc fallback = NULL;
+    DoubleFunc result;
+
+    result = JGadget::toValueFromIndex<DoubleFunc>(arg1, lbl_8039A9F0, 4, fallback);
+
+    if (result == NULL) {
+        JUTWarn w;
+        w << "unknown outside : " << arg1;
+
+        return lbl_8039A9F0[0];
+    }
+
+    return result;
+}
+
+TFunctionValue::TFunctionValue() {}
+
+TFunctionValue::~TFunctionValue() {}
+
+void TFunctionValueAttribute_refer::refer_initialize() {
+    clear();
+}
+
+namespace functionvalue {
+
+#ifdef NONMATCHING  // impossible regalloc
+f64 interpolateValue_hermite(f64 c0, f64 c1, f64 x, f64 c2, f64 x2, f64 c3, f64 x3) {
+    f64 a;
+    f64 d;
+    f64 c;
+    f64 b;
+
+    a = c0 - c1;
+    b = a * (lbl_80455408 / (x2 - c1));               // (a - b) * 1.0 / (c - d)
+    c = b - lbl_80455408;                             // 1.0
+    d = (lbl_80455410 + lbl_80455418 * b) * (b * b);  // 3.0 - 2.0 * b
+    return (a * b * c * x3) + ((lbl_80455408 - d) * x + (d * c3)) + (a * (c * c) * c2);
+}
+#else
+asm f64 interpolateValue_hermite(f64 c0, f64 c1, f64 x, f64 c2, f64 x2, f64 c3, f64 x3) {
+    nofralloc
+#include "JSystem/JStudio/asm/interpolateValue_hermite__Q27JStudio13functionvalueFddddddd.s"
+}
+#endif
+
+#ifdef NONMATCHING  // really minor regalloc
+f64 interpolateValue_BSpline_uniform(f64 f1, f64 f2, f64 f3, f64 f4, f64 f5) {
+    // pow3(1.0 - f1)
+    f64 f6 = (lbl_80455408 - f1);
+    f64 temp = f6;
+    temp *= f6 * f6;
+
+    f64 f0 = f1 * f1;
+    f64 f8 = f0 * f1;
+
+    return ((lbl_80455420 * f8 - f0) + lbl_80455430) * f3 + (temp * f2 + f8 * f5) * lbl_80455428 +
+           f4 * (lbl_80455428 + lbl_80455420 * ((f1 + f0) - f8));
+}
+#else
+asm f64 interpolateValue_BSpline_uniform(f64 a1, f64 a2, f64 a3, f64 a4, f64 a5) {
+    nofralloc
+#include "JSystem/JStudio/asm/interpolateValue_BSpline_uniform__Q27JStudio13functionvalueFddddd.s"
+}
+#endif
+
+asm f64 interpolateValue_BSpline_nonuniform(f64 a1, const f64* a2, const f64* a3) {
+    nofralloc
+#include "JSystem/JStudio/asm/interpolateValue_BSpline_nonuniform__Q27JStudio13functionvalueFdPCdPCd.s"
+}
+
+inline f64 interpolateValue_linear(double a1, double a2, double a3, double a4, double a5) {
+    return a3 + ((a5 - a3) * (a1 - a2)) / (a4 - a2);
+}
+
+inline f64 interpolateValue_linear_1(f64 a1, f64 a2, f64 a3, f64 a4) {
+    return a3 + (a4 - a3) * (a1 - a2);
+}
+
+inline f64 interpolateValue_plateau(f64 a1, f64 a2, f64 a3, f64 a4, f64 a5) {
+    return interpolateValue_hermite(a1, a2, a3, *(f64*)&lbl_80455400, a4, a5, lbl_80455400);
+}
+
+}  // namespace functionvalue
+
+void TFunctionValueAttribute_range::range_initialize() {
+    fBegin_ = lbl_80450AE0[0];  // NaN
+    fEnd_ = fBegin_;
+    fDifference_ = fBegin_;
+
+    range_setProgress(TFunctionValue::PROG_INIT);
+    range_setAdjust(TFunctionValue::ADJ_INIT);
+    range_setOutside(TFunctionValue::OUT_INIT);
+}
+
+void TFunctionValueAttribute_range::range_prepare() {
+    TFunctionValue::TEProgress progress = range_getProgress();
+
+    switch (progress) {
+    default:
+        JUTWarn w;
+        w << "unknown progress : " << progress;
+    case 0:
+        _20 = lbl_80455400;  // 0.0
+        _28 = lbl_80455408;  // 1.0
+        break;
+    case 1:
+        _20 = lbl_80455400;  // 0.0
+        _28 = lbl_80455440;  // -1.0
+        break;
+    case 2:
+        _20 = fBegin_;
+        _28 = lbl_80455440;  // -1.0
+        break;
+    case 3:
+        _20 = fEnd_;
+        _28 = lbl_80455440;  // -1.0
+        break;
+    case 4:
+        _20 = lbl_80455428 * (fBegin_ + fEnd_);  // 0.5
+        _28 = lbl_80455440;                      // -1.0
+        break;
+    }
+}
+
+void TFunctionValueAttribute_range::range_set(f64 begin, f64 end) {
+    fBegin_ = begin;
+    fEnd_ = end;
+    fDifference_ = end - begin;
+
+    JUT_ASSERT(fDifference_ >=
+               lbl_80455400);  // 0.0 -- supposed to be "fDifference_ >= TValue(0)" (???)
+}
+
+#ifdef NONMATCHING  // control flow blocks inverted
+f64 TFunctionValueAttribute_range::range_getParameter(f64 arg1, f64 arg2, f64 arg3) const {
+    f64 progress = range_getParameter_progress(arg1);
+    TFunctionValue::TEAdjust adjust = range_getAdjust();
+
+    f64 result;
+
+    switch (adjust) {
+    default:
+        JUTWarn w;
+        w << "unknown adjust : " << adjust;
+    case 0:
+        result = range_getParameter_outside(progress);
+        break;
+    case 1:
+        result = range_getParameter_outside(progress + fBegin_);
+        break;
+    case 2:
+        result = range_getParameter_outside(progress + fEnd_);
+        break;
+    case 3:
+        result = range_getParameter_outside(progress + lbl_80455428 * (fBegin_ + fEnd_));
+        break;
+    case 4:
+        f64 temp = range_getParameter_outside(progress);
+        result = arg2 + ((temp - fBegin_) * (arg3 - arg2)) / fDifference_;
+        break;
+    }
+    return result;
+}
+#else
+asm f64 TFunctionValueAttribute_range::range_getParameter(f64 arg1, f64 arg2, f64 arg3) const {
+    nofralloc
+#include "JSystem/JStudio/asm/range_getParameter__Q27JStudio29TFunctionValueAttribute_rangeCFddd.s"
+}
+#endif
+
+TFunctionValueAttribute_range::TFunctionValueAttribute_range()
+    : fBegin_(lbl_80450AE0[0]), fEnd_(fBegin_), fDifference_(fBegin_),
+      mProgress(TFunctionValue::PROG_INIT), mAdjust(TFunctionValue::ADJ_INIT), _20(fBegin_),
+      _28(fBegin_), mBegin(TFunctionValue::OUT_INIT), mEnd(TFunctionValue::OUT_INIT) {}
+
+// TFunctionValue_composite::TFunctionValue_composite() : data((void*)NULL) {}
+asm TFunctionValue_composite::TFunctionValue_composite()
+    : data((void*)NULL){nofralloc
+#include "JSystem/JGadget/asm/__ct__Q27JStudio24TFunctionValue_compositeFv.s"
+      }
+
+      u32 TFunctionValue_composite::getType() const {
+    return 1;
+}
+
+TFunctionValueAttributeSet TFunctionValue_composite::getAttributeSet() {
+    return TFunctionValueAttributeSet(this, NULL, NULL);
+}
+
+// TFunctionValueAttributeSet TFunctionValue_constant::getAttributeSet() {
+//     return TFunctionValueAttributeSet(NULL, NULL, NULL);
+// }
+
+void TFunctionValue_composite::initialize() {
+    refer_initialize();
+    pfn_ = NULL;
+    data = TData((void*)NULL);
+}
+
+void TFunctionValue_composite::prepare() {}
+
+f64 TFunctionValue_composite::getValue(f64 arg1) {
+    const TFunctionValueAttribute_refer* container = refer_getContainer();
+    JUT_ASSERT(!refer_isReferring(this));
+    JUT_ASSERT(pfn_ != NULL);
+
+    return pfn_(arg1, container, data_getData());
+}
+
+asm f64 TFunctionValue_composite::composite_raw(const JGadget::TVector_pointer<TFunctionValue*>& pv,
+                                                const TData& data, f64 d) {
+    nofralloc
+#include "JSystem/JStudio/asm/composite_raw__Q27JStudio24TFunctionValue_compositeFRCQ27JGadget44TVector_pointer.s"
+}
+
+asm f64
+TFunctionValue_composite::composite_index(const JGadget::TVector_pointer<TFunctionValue*>& pv,
+                                          const TData& data, f64 d) {
+    nofralloc
+#include "JSystem/JStudio/asm/composite_index__Q27JStudio24TFunctionValue_compositeFRCQ27JGadget44TVector_pointer.s"
+}
+
+asm f64
+TFunctionValue_composite::composite_parameter(const JGadget::TVector_pointer<TFunctionValue*>& pv,
+                                              const TData& data, f64 d) {
+    nofralloc
+#include "JSystem/JStudio/asm/composite_parameter__Q27JStudio24TFunctionValue_compositeFRCQ27JGadget44TVector_pointer.s"
+}
+
+asm f64 TFunctionValue_composite::composite_add(const JGadget::TVector_pointer<TFunctionValue*>& pv,
+                                                const TData& data, f64 d) {
+    nofralloc
+#include "JSystem/JStudio/asm/composite_add__Q27JStudio24TFunctionValue_compositeFRCQ27JGadget44TVector_pointer.s"
+}
+
+asm f64
+TFunctionValue_composite::composite_subtract(const JGadget::TVector_pointer<TFunctionValue*>& pv,
+                                             const TData& data, f64 d) {
+    nofralloc
+#include "JSystem/JStudio/asm/composite_subtract__Q27JStudio24TFunctionValue_compositeFRCQ27JGadget44TVector_pointer.s"
+}
+
+asm f64
+TFunctionValue_composite::composite_multiply(const JGadget::TVector_pointer<TFunctionValue*>& pv,
+                                             const TData& data, f64 d) {
+    nofralloc
+#include "JSystem/JStudio/asm/composite_multiply__Q27JStudio24TFunctionValue_compositeFRCQ27JGadget44TVector_pointer.s"
+}
+
+asm f64
+TFunctionValue_composite::composite_divide(const JGadget::TVector_pointer<TFunctionValue*>& pv,
+                                           const TData& data, f64 d){nofralloc
+#include "JSystem/JStudio/asm/composite_divide__Q27JStudio24TFunctionValue_compositeFRCQ27JGadget44TVector_pointer.s"
+}
+
+TFunctionValue_constant::TFunctionValue_constant()
+    : _0(lbl_80450AE0[0]) {
+}
+
+u32 TFunctionValue_constant::getType() const {
+    return 2;
+}
+
+TFunctionValueAttributeSet TFunctionValue_constant::getAttributeSet() {
+    return TFunctionValueAttributeSet(NULL, NULL, NULL);
+}
+
+void TFunctionValue_constant::initialize() {
+    _0 = lbl_80450AE0[0];
+}
+
+void TFunctionValue_constant::prepare() {}
+
+f64 TFunctionValue_constant::getValue(f64 arg1) {
+    return _0;
+}
+
+TFunctionValue_transition::TFunctionValue_transition() : _48(lbl_80450AE0[0]), _50(_48) {}
+
+u32 TFunctionValue_transition::getType() const {
+    return 3;
+}
+
+TFunctionValueAttributeSet TFunctionValue_transition::getAttributeSet() {
+    return TFunctionValueAttributeSet(NULL, this, this);
+}
+
+void TFunctionValue_transition::initialize() {
+    range_initialize();
+    interpolate_initialize();
+
+    _48 = lbl_80450AE0[0];
+    _50 = _48;
+}
+
+void TFunctionValue_transition::prepare() {
+    range_prepare();
+    interpolate_prepare();
+}
+
+asm f64 TFunctionValue_transition::getValue(f64 arg1){nofralloc
+#include "JSystem/JStudio/asm/getValue__Q27JStudio25TFunctionValue_transitionFd.s"
+}
+
+TFunctionValue_list::TFunctionValue_list()
+    : _44(NULL), _48(0), _50(lbl_80450AE0[0]), _58(NULL) {
+}
+
+u32 TFunctionValue_list::getType() const {
+    return 4;
+}
+
+TFunctionValueAttributeSet TFunctionValue_list::getAttributeSet() {
+    return TFunctionValueAttributeSet(NULL, this, this);
+}
+
+void TFunctionValue_list::initialize() {
+    range_initialize();
+    interpolate_initialize();
+
+    _44 = NULL;
+    _48 = 0;
+    _50 = lbl_80450AE0[0];
+    _58 = NULL;
+}
+
+void TFunctionValue_list::prepare() {
+    range_prepare();
+    interpolate_prepare();
+
+    u32 interp = interpolate_get();
+
+    switch (interp) {
+    default:
+        JUTWarn w;
+        w << "unknown interpolation : " << interp;
+    case 0:
+        _58 = update_INTERPOLATE_NONE_;
+        break;
+    case 1:
+        _58 = update_INTERPOLATE_LINEAR_;
+        break;
+    case 2:
+        _58 = update_INTERPOLATE_PLATEAU_;
+        break;
+    case 3:
+        _58 = update_INTERPOLATE_BSPLINE_dataMore3_;
+        if (_48 == 2)
+            _58 = update_INTERPOLATE_LINEAR_;
+        break;
+    }
+}
+
+asm f64 TFunctionValue_list::getValue(f64 arg1){nofralloc
+#include "JSystem/JStudio/asm/getValue__Q27JStudio19TFunctionValue_listFd.s"
+}
+
+f64 TFunctionValue_list::update_INTERPOLATE_NONE_(const TFunctionValue_list& rThis,
+                                                  const TIndexData_& data) {
+    return rThis._44[data._10];
+}
+
+f64 TFunctionValue_list::update_INTERPOLATE_LINEAR_(const TFunctionValue_list& rThis,
+                                                    const TIndexData_& data) {
+    return functionvalue::interpolateValue_linear_1(data._0, data._8, rThis._44[data._10],
+                                                    rThis._44[data._10 + 1]);
+}
+
+f64 TFunctionValue_list::update_INTERPOLATE_PLATEAU_(const TFunctionValue_list& rThis,
+                                                     const TIndexData_& data) {
+    const f32* arr = rThis._44;
+
+    return functionvalue::interpolateValue_plateau(data._0, data._8, arr[data._10],
+                                                   lbl_80455408 + data._8, arr[data._10 + 1]);
+}
+
+asm f64 TFunctionValue_list::update_INTERPOLATE_BSPLINE_dataMore3_(const TFunctionValue_list& rThis,
+                                                                   const TIndexData_& data){
+    nofralloc
+#include "JSystem/JStudio/asm/update_INTERPOLATE_BSPLINE_dataMore3___Q27JStudio19TFunctionValue_listFRCQ27JStudio19TFunctionValue_listRCQ37JStudio19TFunctionValue_list11TIndexData_.s"
+}
+
+TFunctionValue_list_parameter::TFunctionValue_list_parameter()
+    : _44(NULL), _48(0), dat1(NULL), dat2(dat1), dat3(dat1), _58(NULL) {
+}
+
+u32 TFunctionValue_list_parameter::getType() const {
+    return 5;
+}
+
+TFunctionValueAttributeSet TFunctionValue_list_parameter::getAttributeSet() {
+    return TFunctionValueAttributeSet(NULL, this, this);
+}
+
+void TFunctionValue_list_parameter::data_set(const f32* pf, u32 u) {
+    JUT_ASSERT((pf != NULL) || (u == 0));
+
+    _44 = pf;
+    _48 = u;
+
+    dat1.set(_44);
+    dat2.set(&_44[_48 * 2]);
+    dat3 = dat1;
+}
+
+void TFunctionValue_list_parameter::initialize() {
+    range_initialize();
+    interpolate_initialize();
+
+    _44 = NULL;
+    _48 = 0;
+
+    TIterator_data_ iter(NULL);
+
+    dat1 = iter;
+    dat2 = dat1;
+    dat3 = dat1;
+    _58 = NULL;
+}
+
+void TFunctionValue_list_parameter::prepare() {
+    range_prepare();
+    interpolate_prepare();
+
+    u32 interp = interpolate_get();
+    switch (interp) {
+    default:
+        JUTWarn w;
+        w << "unknown interpolation : " << interp;
+    case 0:
+        _58 = update_INTERPOLATE_NONE_;
+        break;
+    case 1:
+        _58 = update_INTERPOLATE_LINEAR_;
+        break;
+    case 2:
+        _58 = update_INTERPOLATE_PLATEAU_;
+        break;
+    case 3:
+        _58 = update_INTERPOLATE_BSPLINE_dataMore3_;
+        if (_48 != 2)
+            return;
+        _58 = update_INTERPOLATE_LINEAR_;
+        break;
+    }
+}
+
+asm f64 TFunctionValue_list_parameter::getValue(f64 arg1){nofralloc
+#include "JSystem/JStudio/asm/getValue__Q27JStudio29TFunctionValue_list_parameterFd.s"
+}
+
+f64 TFunctionValue_list_parameter::update_INTERPOLATE_NONE_(
+    const TFunctionValue_list_parameter& rThis, f64 d) {
+    return rThis.dat3.get()[-1];
+}
+
+f64 TFunctionValue_list_parameter::update_INTERPOLATE_LINEAR_(
+    const TFunctionValue_list_parameter& rThis, f64 d) {
+    const f32* a = rThis.dat3.get();
+    return functionvalue::interpolateValue_linear(d, a[-2], a[-1], a[0], a[1]);
+}
+
+f64 TFunctionValue_list_parameter::update_INTERPOLATE_PLATEAU_(
+    const TFunctionValue_list_parameter& rThis, f64 d) {
+    const f32* a = rThis.dat3.get();
+    return functionvalue::interpolateValue_plateau(d, a[-2], a[-1], a[0], a[1]);
+}
+
+asm f64 TFunctionValue_list_parameter::update_INTERPOLATE_BSPLINE_dataMore3_(
+    const TFunctionValue_list_parameter& rThis, f64 d){nofralloc
+#include "JSystem/JStudio/asm/update_INTERPOLATE_BSPLINE_dataMore3___Q27JStudio29TFunctionValue_list_parameterFRCQ27JStudio29TFunctionValue_list_parameterd.s"
+}
+
+TFunctionValue_hermite::TFunctionValue_hermite()
+    : pf_(NULL), u_(0), uSize_(0), dat1(*this, NULL), dat2(dat1), dat3(dat1) {
+}
+
+u32 TFunctionValue_hermite::getType() const {
+    return 6;
+}
+
+TFunctionValueAttributeSet TFunctionValue_hermite::getAttributeSet() {
+    return TFunctionValueAttributeSet(NULL, this, NULL);
+}
+
+// data_set__Q27JStudio22TFunctionValue_hermiteFPCfUlUl
+void TFunctionValue_hermite::data_set(const f32* pf, u32 u, u32 uSize) {
+    JUT_ASSERT((pf != NULL) || (u == 0));
+    JUT_ASSERT((uSize == 3) || (uSize == 4));
+
+    pf_ = pf;
+    u_ = u;
+    uSize_ = uSize;
+
+    dat1.set(pf_, uSize_);
+    dat2.set(&pf_[u_ * uSize_], uSize_);
+    dat3 = dat1;
+}
+
+void TFunctionValue_hermite::initialize() {
+    range_initialize();
+
+    pf_ = NULL;
+    u_ = 0;
+    uSize_ = 0;
+
+    TIterator_data_ data(*this, NULL);
+    dat1 = data;
+    dat2 = dat1;
+    dat3 = dat1;
+}
+
+void TFunctionValue_hermite::prepare() {
+    range_prepare();
+}
+
+asm f64 TFunctionValue_hermite::getValue(f64 a1) {
+    nofralloc
+#include "JSystem/JStudio/asm/getValue__Q27JStudio22TFunctionValue_hermiteFd.s"
+}
+
+namespace functionvalue {
+
+f64 extrapolateParameter_raw(f64 a1, f64 a2) {
+    return a1;
+}
+
+f64 extrapolateParameter_repeat(f64 a1, f64 a2) {
+    f64 t = func_8036C760(a1, a2);
+
+    if (t < lbl_80455400)
+        t += a2;
+
+    return t;
+}
+
+f64 extrapolateParameter_clamp(f64 value, f64 max) {
+    if (value <= lbl_80455400)
+        return lbl_80455400;
+
+    if (max <= value)  // obtuse..
+        value = max;
+
+    return value;
+}
+
+}  // namespace functionvalue
+
+}  // namespace JStudio
@@ -1 +1,218 @@
-// ok
+#include "JSystem/JStudio/fvb.h"
+
+extern void (*lbl_803C49C0)();  // vtbl
+
+extern "C" {
+extern void getObject_index__Q37JStudio3fvb8TControlFUl();
+extern void JGadget_NS_TVector_pointer_void_NS_insert();
+extern void getObject__Q37JStudio3fvb8TControlFPCvUl();
+extern void JStudio_NS_fvb_NS_data_NS_TParse_TParagraph_NS_getData();
+extern void range_set__Q27JStudio29TFunctionValueAttribute_rangeFdd();
+void __ct__Q27JStudio24TFunctionValue_compositeFv();
+extern void getCompositeOperation___Q27JStudio3fvbFQ47JStudio3fvb4data11TEComposite();
+extern void __ct__Q27JStudio23TFunctionValue_constantFv();
+extern void __ct__Q27JStudio25TFunctionValue_transitionFv();
+extern void __ct__Q27JStudio19TFunctionValue_listFv();
+extern void __ct__Q27JStudio29TFunctionValue_list_parameterFv();
+extern void __ct__Q27JStudio22TFunctionValue_hermiteFv();
+}
+
+extern u32 lbl_803C4AB0;
+extern u32 lbl_803C4AA0;
+extern u32 lbl_803C4A90;
+extern u32 lbl_803C4A80;
+extern u32 lbl_803C4A70;
+extern u32 lbl_803C4A60;
+extern u32 lbl_803C4A50;
+
+extern JStudio::fvb::data::CompositeOperation lbl_8039AA00[];
+
+namespace JStudio {
+namespace fvb {
+
+TObject::~TObject() {}
+
+asm void TObject::prepare(const data::TParse_TBlock& block, TControl* control){nofralloc
+#include "JSystem/JStudio/asm/prepare__Q37JStudio3fvb7TObjectFRCQ47JStudio3fvb4data13TParse_TBlockPQ37JStudio3fvb8TControl.s"
+}
+
+//! @todo: FORCEACTIVE will not work with anonymous namespaces.
+//! recreate symbol when this is properly referenced
+
+// namespace {
+
+TFunctionValue_composite::TData getCompositeData_raw_(const void* arg1) {
+    return TFunctionValue_composite::TData(*(const void**)arg1);
+}
+
+TFunctionValue_composite::TData getCompositeData_index_(const void* arg1) {
+    return TFunctionValue_composite::TData(*(u32*)arg1);
+}
+
+TFunctionValue_composite::TData getCompositeData_parameter_(const void* arg1) {
+    return TFunctionValue_composite::TData(*(f32*)arg1);
+}
+
+TFunctionValue_composite::TData getCompositeData_add_(const void* arg1) {
+    return TFunctionValue_composite::TData(*(f32*)arg1);
+}
+
+TFunctionValue_composite::TData getCompositeData_subtract_(const void* arg1) {
+    return TFunctionValue_composite::TData(*(f32*)arg1);
+}
+
+TFunctionValue_composite::TData getCompositeData_multiply_(const void* arg1) {
+    return TFunctionValue_composite::TData(*(f32*)arg1);
+}
+
+TFunctionValue_composite::TData getCompositeData_divide_(const void* arg1) {
+    return TFunctionValue_composite::TData(*(f32*)arg1);
+}
+
+data::CompositeOperation* getCompositeOperation_(data::TEComposite comp) {
+    return &lbl_8039AA00[comp * 2];
+}
+
+//}  // namespace
+
+// need an extra temp
+asm TObject_composite::TObject_composite(const data::TParse_TBlock& block)
+    : TObject(block, &fnValue) {
+    nofralloc
+#include "JSystem/JStudio/asm/__ct__Q37JStudio3fvb17TObject_compositeFRCQ47JStudio3fvb4data13TParse_TBlock.s"
+}
+
+#ifdef NONMATCHING  // incomplete
+void TObject_composite::prepare_data_(const TParse_TParagraph::TData& rData, TControl* control) {
+    JUT_ASSERT(rData.u32Type == data::PARAGRAPH_DATA);
+
+    u32 u32Size = rData.u32Size;
+    JUT_EXPECT(u32Size == 8);
+
+    const TFunctionValue_composite* pContent =
+        static_cast<const TFunctionValue_composite*>(rData.pContent);
+    JUT_ASSERT(pContent != NULL);
+
+    data::CompositeOperation* ops = getCompositeOperation_(*(data::TEComposite*)pContent);
+    data::CompositeOperation pfn = ops[1];
+
+    JUT_ASSERT(pfn != NULL);
+
+    pfn(comp->data);
+}
+#else
+asm void TObject_composite::prepare_data_(const data::TParse_TParagraph::TData& rData,
+                                          TControl* control) {
+    nofralloc
+#include "JSystem/JStudio/asm/prepare_data___Q37JStudio3fvb17TObject_compositeFRCQ57JStudio3fvb4data17TParse_TParagraph5TDataPQ37JStudio3fvb8TControl.s"
+}
+#endif
+
+// need an extra temp
+asm TObject_constant::TObject_constant(const data::TParse_TBlock& block)
+    : TObject(block, &fnValue) {
+    nofralloc
+#include "JSystem/JStudio/asm/__ct__Q37JStudio3fvb16TObject_constantFRCQ47JStudio3fvb4data13TParse_TBlock.s"
+}
+
+void TObject_constant::prepare_data_(const data::TParse_TParagraph::TData& rData,
+                                     TControl* control) {
+    JUT_ASSERT(rData.u32Type == data::PARAGRAPH_DATA);
+
+    u32 u32Size = rData.u32Size;
+    JUT_EXPECT(u32Size == 4);
+
+    const f32* pContent = static_cast<const f32*>(rData.pContent);
+    JUT_ASSERT(pContent != NULL);
+
+    fnValue.data_set(pContent[0]);
+}
+
+// need an extra temp
+asm TObject_transition::TObject_transition(const data::TParse_TBlock& block)
+    : TObject(block, &fnValue) {
+    nofralloc
+#include "JSystem/JStudio/asm/__ct__Q37JStudio3fvb18TObject_transitionFRCQ47JStudio3fvb4data13TParse_TBlock.s"
+}
+
+void TObject_transition::prepare_data_(const data::TParse_TParagraph::TData& rData,
+                                       TControl* control) {
+    JUT_ASSERT(rData.u32Type == data::PARAGRAPH_DATA);
+
+    u32 u32Size = rData.u32Size;
+    JUT_EXPECT(u32size == 8);
+
+    const f32* pContent = static_cast<const f32*>(rData.pContent);
+    JUT_ASSERT(pContent != NULL);
+
+    fnValue.data_set(pContent[0], pContent[1]);
+}
+
+asm TObject_list::TObject_list(const data::TParse_TBlock& block) : TObject(block, &fnValue) {
+    nofralloc
+#include "JSystem/JStudio/asm/__ct__Q37JStudio3fvb12TObject_listFRCQ47JStudio3fvb4data13TParse_TBlock.s"
+}
+
+void TObject_list::prepare_data_(const data::TParse_TParagraph::TData& rData, TControl* control) {
+    JUT_ASSERT(rData.u32Type == data::PARAGRAPH_DATA);
+
+    u32 u32Size = rData.u32Size;
+    JUT_EXPECT(u32size >= 8);
+
+    const ListData* pContent = static_cast<const ListData*>(rData.pContent);
+    JUT_ASSERT(pContent != NULL);
+
+    fnValue.data_setInterval(pContent->_0);
+    fnValue.data_set(pContent->_8, pContent->_4);
+}
+
+asm TObject_list_parameter::TObject_list_parameter(const data::TParse_TBlock& block)
+    : TObject(block, &fnValue) {
+    nofralloc
+#include "JSystem/JStudio/asm/__ct__Q37JStudio3fvb22TObject_list_parameterFRCQ47JStudio3fvb4data13TParse_TBlock.s"
+}
+
+void TObject_list_parameter::prepare_data_(const data::TParse_TParagraph::TData& rData,
+                                           TControl* control) {
+    JUT_ASSERT(rData.u32Type == data::PARAGRAPH_DATA);
+
+    u32 u32Size = rData.u32Size;
+    JUT_EXPECT(u32size >= 8);
+
+    const ListData* pContent = static_cast<const ListData*>(rData.pContent);
+    JUT_ASSERT(pContent != NULL);
+
+    fnValue.data_set(pContent->_4, pContent->_0);
+}
+
+asm TObject_hermite::TObject_hermite(const data::TParse_TBlock& block) : TObject(block, &fnValue) {
+    nofralloc
+#include "JSystem/JStudio/asm/__ct__Q37JStudio3fvb15TObject_hermiteFRCQ47JStudio3fvb4data13TParse_TBlock.s"
+}
+
+void TObject_hermite::prepare_data_(const data::TParse_TParagraph::TData& rData,
+                                    TControl* control) {
+    JUT_ASSERT(rData.u32Type == data::PARAGRAPH_DATA);
+
+    u32 u32Size = rData.u32Size;
+    JUT_EXPECT(u32size >= 8);
+
+    const ListData* pContent = static_cast<const ListData*>(rData.pContent);
+    JUT_ASSERT(pContent != NULL);
+
+    fnValue.data_set(pContent->_4, pContent->_0 & 0xFFFFFFF, pContent->_0 >> 0x1C);
+}
+
+TControl::TControl() : _4(0) {}
+
+TControl::~TControl() {
+    JUT_EXPECT(ocObject_.empty());
+}
+
+// TObject::TObject(void const* id, u32 id_size, TFunctionValue* value)
+//     : object::TObject_ID(id, id_size), pfv_(value) {
+//     JUT_ASSERT(pfv_ != NULL);
+// }
+
+}  // namespace fvb
+}  // namespace JStudio
@@ -22,9 +22,9 @@ extern const char** lbl_804554D8;  // "STB"\0
 namespace JStudio {
 namespace stb {

-TObject::TObject(u32 arg1, const void* arg2, u32 arg3)
-    : TObject_ID(arg2, arg3), pControl(NULL), _18(arg1), mFlag(0), bSequence_(0), _20(0), _24(NULL),
-      _28(NULL), u32Wait_(0), mStatus(0) {}
+TObject::TObject(u32 arg1, const void* id, u32 id_size)
+    : TObject_ID(id, id_size), pControl(NULL), _18(arg1), mFlag(0), bSequence_(0), _20(0),
+      _24(NULL), _28(NULL), u32Wait_(0), mStatus(0) {}

 TObject::TObject(const data::TParse_TBlock_object& object)
    : TObject_ID(object.get_ID(), object.get_IDSize()), pControl(NULL), _18(object.get_type()),