AITrafficManager progress, lots of header work again

Author: dbalatoni13

src/Speed/Indep/Libs/Support/Utility/UCOM.h

@@ -1,11 +1,21 @@
 #ifndef SUPPORT_UTILITY_UCOM_H
 #define SUPPORT_UTILITY_UCOM_H
 
-#include "Speed/Indep/bWare/Inc/bMemory.hpp"
 #ifdef EA_PRAGMA_ONCE_SUPPORTED
 #pragma once
 #endif
 
+#include "Speed/Indep/Libs/Support/Utility/UStandard.h"
+#include "Speed/Indep/bWare/Inc/bMemory.hpp"
+
+typedef void *HINTERFACE;
+
+struct _type_UComObject {
+    const char *name() {
+        return "UComObject";
+    }
+};
+
 namespace UTL {
 namespace COM {
 
@@ -23,43 +33,53 @@ class Object {
         // bool operator<(const _IPair &rhs) {}
     };
 
-    struct _IList // : public std::vector<_IPair, _type_UComObject>
-    {
-        int pad;
-        void *_M_start;
-        void *_M_finish;
-        void *_M_end_of_storage;
-
-        // _IList(unsigned int icount) {}
-
-        // ~_IList() {}
-
-        // void Add(void *handle, IUnknown *ref) {}
-
-        // IUnknown *Find(void *handle) {}
-
-        // void *Find(const IUnknown *pUnk) const {}
-
-        // void Remove(IUnknown *pUnk) {}
+    class _IList : public UTL::Std::vector<_IPair, _type_UComObject> {
+        // int pad;
+        // void *_M_start;
+        // void *_M_finish;
+        // void *_M_end_of_storage;
+
+      public:
+        _IList(unsigned int icount);
+        ~_IList();
+        void Add(HINTERFACE handle, IUnknown *ref);
+        IUnknown *Find(HINTERFACE handle);
+        void *Find(const IUnknown *pUnk) const;
+        void Remove(IUnknown *pUnk);
     };
 
+  public:
     // total size: 0x10
     _IList _mInterfaces; // offset 0x0, size 0x10
 
   protected:
     void *operator new(std::size_t size) {
         return gFastMem.Alloc(size, nullptr);
     }
+
+    Object(unsigned int icount) : _mInterfaces(icount) {}
+
+    ~Object() {}
 };
 
 class IUnknown {
+  public:
     // total size: 0x8
     Object *_mCOMObject; // offset 0x0, size 0x4
 
+    template <typename T> bool QueryInterface(T **out) {
+        HINTERFACE handle = T::_IHandle();
+
+        *out = (T *)_mCOMObject->_mInterfaces.Find(handle);
+        return *out != nullptr;
+    }
+
   protected:
     IUnknown(Object *owner, void *handle) {}
 
-    virtual ~IUnknown() {}
+    virtual ~IUnknown() {
+        this->_mCOMObject->_mInterfaces.Remove(this);
+    }
 };
 
 template <typename T, typename U, typename V> class Factory {

src/Speed/Indep/Libs/Support/Utility/UCollections.h

@@ -17,6 +17,7 @@ struct _KeyedNode {
 };
 
 template <typename T, std::size_t Size> class _Storage : public FixedVector<T, Size, 16> {
+  public:
     _Storage() {}
 
     ~_Storage() {}
@@ -25,7 +26,7 @@ template <typename T, std::size_t Size> class _Storage : public FixedVector<T, S
 template <typename T> class Singleton {
   protected:
     Singleton() {}
-    virtual ~Singleton() {}
+    ~Singleton() {}
 
   public:
     // static T *Get() {}

src/Speed/Indep/Libs/Support/Utility/UListable.h

@@ -7,53 +7,113 @@
 
 #include <cstddef>
 
+#include "UTLVector.h"
+
 namespace UTL {
 namespace Collections {
 
 template <typename T, std::size_t U> class Listable {
-    struct List {};
+  public:
+    typedef T value_type;
+    typedef value_type *pointer;
+    typedef const value_type *const_pointer;
+    typedef pointer *iterator;
+    typedef const pointer *const_iterator;
 
-    static List _mTable;
+    class List : public FixedVector<pointer, U> {
+      public:
+        List(const List &);
+        List();
+        virtual ~List();
 
-    typedef void (*ForEachFunc_t)(T *);
+        // List &operator=(List &);
+    };
 
-  public:
+    typedef void (*ForEachFunc)(pointer);
+
+  protected:
     Listable() {}
 
     ~Listable() {}
 
     void Unlist() {}
 
-    ForEachFunc_t ForEach(ForEachFunc_t f) {}
+  public:
+    ForEachFunc ForEach(ForEachFunc f) {}
 
-    const List &GetList() {}
+    static const List &GetList() {
+        return _mTable;
+    }
+
+  private:
+    static List _mTable;
 };
 
-template <typename T, std::size_t Tsize, typename U, std::size_t Usize> class ListableSet {
-    struct List {};
+template <typename T, std::size_t ListSize, typename Enum, std::size_t EnumMax> class ListableSet {
+  public:
+    typedef T value_type;
+    typedef value_type *pointer;
+    typedef const value_type *const_pointer;
+    typedef pointer *iterator;
+    typedef const pointer *const_iterator;
 
-    typedef void (*ForEachFunc_t)(T *);
+    class List : public FixedVector<pointer, ListSize> {
+      public:
+        List(const List &);
+        List();
+        virtual ~List();
 
-  public:
-    T *First(U idx);
-    T *Last(U idx);
+        // List &operator=(List &);
+    };
+
+    typedef void (*ForEachFunc_t)(pointer);
+
+    static int Count(Enum idx);
+
+    T *First(Enum idx);
+    T *Last(Enum idx);
 
     ~ListableSet() {}
 
     void UnList() {}
 
-    T *Next(U idx) {}
+    T *Next(Enum idx) {}
 
-    ForEachFunc_t ForEach(U idx, ForEachFunc_t f) {}
+    ForEachFunc_t ForEach(Enum idx, ForEachFunc_t f) {}
+
+    void AddToList(Enum to) {}
+
+    static const List &GetList(Enum idx) {
+        return _mLists._buckets[idx];
+    }
 
-    void AddToList(U to) {}
+  private:
+    class _ListSet {
+      public:
+        // how to access _buckets without making it public?
+        List _buckets[EnumMax];
 
-    const List &GetList(U idx) {}
+        void _add(T *, unsigned int);
+
+        void _remove(T *, unsigned int);
+
+        _ListSet();
+        // _ListSet(_ListSet &);
+        ~_ListSet();
+
+        // _ListSet &operator=(const _ListSet &);
+    };
+
+    static _ListSet _mLists;
 };
 
 template <typename T> class Countable {
     static int _mCount;
 
+  protected:
+    Countable() {}
+    ~Countable() {}
+
   public:
     static int Count() {
         return _mCount;

src/Speed/Indep/Libs/Support/Utility/UMath.h

@@ -117,6 +117,14 @@ const Matrix4 Matrix4::kIdentity = {{1.0f, 0.0f, 0.0f, 0.0f}, {0.0f, 1.0f, 0.0f,
 
 void BuildRotate(Matrix4 &m, float r, float x, float y, float z);
 
+inline float DistanceSquarexz(const Vector3 &a, const Vector3 &b) {
+    return VU0_v3distancesquare(a, b);
+}
+
+inline Vector3 &Vector4To3(Vector4 &c4) {
+    return *reinterpret_cast<Vector3 *>(&c4);
+}
+
 inline void RotateTranslate(const Vector3 &a, const Matrix4 &m, Vector3 &r) {
     VU0_MATRIX4_vect3mult(a, m, r);
 }

src/Speed/Indep/Libs/Support/Utility/USpline.h

@@ -5,9 +5,11 @@
 #pragma once
 #endif
 
+#include <list>
+
 #include "Speed/Indep/Libs/Support/Utility/UMath.h"
 
-class SplinePointList /* : public STLlist<UMath::Vector4, _STL::allocator<UMath::Vector4> >*/ {};
+class SplinePointList : public std::list<UMath::Vector4> {};
 
 class USpline {
     enum SplineType {

src/Speed/Indep/Libs/Support/Utility/UTLVector.h

@@ -8,12 +8,13 @@
 #include <cstddef>
 
 namespace UTL {
-template <typename T, int Alignment> class Vector {
-    // total size: 0x10
-    T *mBegin;             // offset 0x0, size 0x4
-    std::size_t mCapacity; // offset 0x4, size 0x4
-    std::size_t mSize;     // offset 0x8, size 0x4
-                           // _vptr; // offset 0xC, size 0x4
+template <typename T, int Alignment = 16> class Vector {
+  public:
+    typedef T value_type;
+    typedef value_type *pointer;
+    typedef const value_type *const_pointer;
+    typedef value_type *iterator;
+    typedef const value_type *const_iterator;
 
   public:
     void Init() {}
@@ -36,15 +37,27 @@ template <typename T, int Alignment> class Vector {
 
     void clear() {}
 
-    T *const *begin() const {}
+    const_iterator begin() const {
+        return mBegin;
+    }
+
+    iterator begin() {
+        return mBegin;
+    }
 
-    T *const *end() const {}
+    const_iterator end() const {
+        return mBegin + mSize;
+    }
+
+    iterator end() {
+        return mBegin + mSize;
+    }
 
     virtual std::size_t GetGrowSize(std::size_t minSize) const {}
 
     virtual void OnGrowRequest(std::size_t newSize) {}
 
-    virtual T **VectorAllocVectorSpace(unsigned int num, std::size_t alignment) {}
+    virtual T **VectorAllocVectorSpace(std::size_t num, unsigned int alignment) {}
 
     virtual void FreeVectorSpace(T **buffer, unsigned int num) {}
 
@@ -55,9 +68,15 @@ template <typename T, int Alignment> class Vector {
     std::size_t indexof(T **pos) {}
 
     T **erase(T **begIt, T **endIt) {}
+
+  private:
+    // total size: 0x10
+    T *mBegin;             // offset 0x0, size 0x4
+    std::size_t mCapacity; // offset 0x4, size 0x4
+    std::size_t mSize;     // offset 0x8, size 0x4
 };
 
-template <typename T, std::size_t Size, int Alignment> class FixedVector : public Vector<T, Alignment> {
+template <typename T, std::size_t Size, int Alignment = 16> class FixedVector : public Vector<T, Alignment> {
     // TODO speed considerations for 64 bit
     int mVectorSpace[(sizeof(T) * Size) / sizeof(int)];
 
@@ -68,9 +87,9 @@ template <typename T, std::size_t Size, int Alignment> class FixedVector : publi
 
     virtual std::size_t GetGrowSize(std::size_t minSize) const {}
 
-    virtual T **AllocVectorSpace(unsigned int num, std::size_t alignment) {}
+    virtual T **AllocVectorSpace(std::size_t num, unsigned int alignment) {}
 
-    virtual void FreeVectorSpace(T **buffer, unsigned int num) {}
+    virtual void FreeVectorSpace(T **buffer, std::size_t) {}
 
     virtual std::size_t GetMaxCapacity() const {}
 };

src/Speed/Indep/Libs/Support/Utility/UVectorMath.h

@@ -15,9 +15,13 @@ struct Matrix4;
 } // namespace UMath
 
 void VU0_v3scale(const UMath::Vector3 &a, const float scaleby, UMath::Vector3 &result);
-void VU0_v4subxyz(const UMath::Vector4 &a, const UMath::Vector4 &b, UMath::Vector4 &result);
 void VU0_v3scale(const UMath::Vector3 &a, const UMath::Vector3 &b, UMath::Vector3 &result);
+float VU0_v3distancesquare(const UMath::Vector3 &p1, const UMath::Vector3 &p2);
+float VU0_v3distancesquarexz(const UMath::Vector3 &p1, const UMath::Vector3 &p2);
+
+void VU0_v4subxyz(const UMath::Vector4 &a, const UMath::Vector4 &b, UMath::Vector4 &result);
 void VU0_v4scale(const UMath::Vector4 &a, const float scaleby, UMath::Vector4 &result);
+float VU0_v4distancesquarexyz(const UMath::Vector4 &p1, const UMath::Vector4 &p2);
 
 void VU0_MATRIX4_vect3mult(const UMath::Vector3 &v, const UMath::Matrix4 &m, UMath::Vector3 &result);
 void VU0_MATRIX4_vect4mult(const UMath::Vector4 &v, const UMath::Matrix4 &m, UMath::Vector4 &result);