Various JSystem work (#2383)

* JKernel and JStudio cleanup

* JMessage cleanup

* JAudio cleanup

* JASBNKParser work

* functionvalue work

* fvb work

* J2D and J3D cleanup

* steal from tww

* J2DPictureEx mostly done

* fix build

include/JSystem/JStudio/JStudio/functionvalue.h

@@ -1,9 +1,11 @@
 #ifndef FUNCTIONVALUE_H
 #define FUNCTIONVALUE_H
 
-#include "JSystem/JGadget/search.h"
-#include "JSystem/JGadget/vector.h"
-#include "global.h"
+#include "JSystem/JGadget/std-vector.h"
+#include "dolphin/os.h"
+#include <iterator.h>
+
+extern u8 lit_569;
 
 namespace JStudio {
 
@@ -66,20 +68,19 @@ public:
         : TFunctionValueAttributeSet_const(refer, range, interp) {}
 
     TFunctionValueAttribute_refer* refer_get() const {
-        return static_cast<const TFunctionValueAttributeSet_const*>(this)->refer_get();
+        return TFunctionValueAttributeSet_const::refer_get();
     }
     TFunctionValueAttribute_range* range_get() const {
-        return static_cast<const TFunctionValueAttributeSet_const*>(this)->range_get();
+        return TFunctionValueAttributeSet_const::range_get();
     }
     TFunctionValueAttribute_interpolate* interpolate_get() const {
-        return static_cast<const TFunctionValueAttributeSet_const*>(this)->interpolate_get();
+        return TFunctionValueAttributeSet_const::interpolate_get();
     }
 };
 
 class TFunctionValueAttribute_refer : public JGadget::TVector_pointer<TFunctionValue*> {
 public:
-    TFunctionValueAttribute_refer() :
-    JGadget::TVector_pointer<TFunctionValue*>(JGadget::TAllocator<void*>()) {}
+    inline TFunctionValueAttribute_refer();
     ~TFunctionValueAttribute_refer() {}
 
     /* 802816E8 */ void refer_initialize();
@@ -191,7 +192,7 @@ public:
     };
     typedef f64 (*UnkFunc)(f64, const TFunctionValueAttribute_refer*,
                            const TFunctionValue_composite::TData*);
-    typedef f64 (*CompositeFunc)(const JGadget::TVector_pointer<TFunctionValue>&,
+    typedef f64 (*CompositeFunc)(const JGadget::TVector_pointer<TFunctionValue*>&,
                                  const TFunctionValue_composite::TData&, f64);
 
     /* 80281D5C */ TFunctionValue_composite();
@@ -227,7 +228,7 @@ public:
     TData data;
 };
 
-class TFunctionValue_transition : TFunctionValue,
+class TFunctionValue_transition : public TFunctionValue,
                                   TFunctionValueAttribute_range,
                                   TFunctionValueAttribute_interpolate {
 public:
@@ -252,7 +253,7 @@ private:
     /* 0x50 */ f64 _50;
 };
 
-class TFunctionValue_list : TFunctionValue,
+class TFunctionValue_list : public TFunctionValue,
                             TFunctionValueAttribute_range,
                             TFunctionValueAttribute_interpolate {
 public:
@@ -303,25 +304,44 @@ private:
     /* 0x58 */ update_INTERPOLATE pfnUpdate_;
 };
 
-class TFunctionValue_list_parameter : TFunctionValue,
+class TFunctionValue_list_parameter : public TFunctionValue,
                                       TFunctionValueAttribute_range,
                                       TFunctionValueAttribute_interpolate {
 public:
     struct TIterator_data_ {
         TIterator_data_(const f32* value) : value_(value) {}
-        TIterator_data_(const TIterator_data_& other) : value_(other.value_) {}
-
-        void operator=(const TIterator_data_& rhs) { value_ = rhs.value_; }
         TIterator_data_& operator--() {
             value_ -= 2;
             return *this;
         }
+        TIterator_data_& operator-=(s32 n) {
+            value_ -= n * 2;
+            return *this;
+        }
+        s32 operator-(const TIterator_data_& other) {
+            return (u32)(value_ - other.value_) >> 1;
+        }
+        TIterator_data_& operator++() {
+            value_ += 2;
+            return *this;
+        }
+        TIterator_data_& operator+=(s32 n) {
+            value_ += n * 2;
+            return *this;
+        }
         friend bool operator==(const TIterator_data_& lhs, const TIterator_data_& rhs) { return lhs.value_ == rhs.value_; }
+        f32 operator*() { return *value_; }
 
         const f32* get() const { return value_; }
         void set(const f32* value) { value_ = value; }
 
         const f32* value_;
+
+        typedef s32 difference_type;
+        typedef f32 value_type;
+        typedef const f32* pointer;
+        typedef const f32& reference;
+        typedef std::random_access_iterator_tag iterator_category;
     };
     typedef f64 (*update_INTERPOLATE)(const TFunctionValue_list_parameter&, f64);
 
@@ -358,7 +378,7 @@ private:
     /* 0x58 */ update_INTERPOLATE pfnUpdate_;
 };
 
-class TFunctionValue_hermite : TFunctionValue, TFunctionValueAttribute_range {
+class TFunctionValue_hermite : public TFunctionValue, TFunctionValueAttribute_range {
 public:
     struct TIterator_data_ {
         TIterator_data_(const TFunctionValue_hermite& rParent, const f32* value) {
@@ -374,14 +394,36 @@ public:
         }
    
         friend bool operator==(const TIterator_data_& lhs, const TIterator_data_& rhs) { return lhs.value_ == rhs.value_; }
+        f32 operator*() { return *value_; }
 
         TIterator_data_& operator--() {
             value_ -= size_;
             return *this;
         }
+        TIterator_data_& operator-=(s32 n) {
+            value_ -= size_ * n;
+            return *this;
+        }
+        s32 operator-(const TIterator_data_& other) {
+            return (value_ - other.value_) / size_;
+        }
+        TIterator_data_& operator++() {
+            value_ += size_;
+            return *this;
+        }
+        TIterator_data_& operator+=(s32 n) {
+            value_ += size_ * n;
+            return *this;
+        }
 
         /* 0x00 */ const f32* value_;
         /* 0x04 */ u32 size_;
+
+        typedef s32 difference_type;
+        typedef f32 value_type;
+        typedef const f32* pointer;
+        typedef const f32& reference;
+        typedef std::random_access_iterator_tag iterator_category;
     };
 
     /* 802832C4 */ TFunctionValue_hermite();