nn/ui2d: Improve Pane implementation

CMakeLists.txt

@@ -177,14 +177,17 @@ add_library(NintendoSDK OBJECT
   include/nn/util/util_BinTypes.h
   include/nn/util/util_BitPack.h
   include/nn/util/util_BytePtr.h
+  include/nn/util/util_IntrusiveList.h
   include/nn/util/util_BitUtil.h
   include/nn/util/util_ResDic.h
   include/nn/util/util_StringView.h
   include/nn/ui2d/detail/TexCoordArray.h
   include/nn/ui2d/Layout.h
-  include/nn/ui2d/Parts.h
-  include/nn/ui2d/Pane.h
   include/nn/ui2d/Material.h
+  include/nn/ui2d/Pane.h
+  include/nn/ui2d/Parts.h
+  include/nn/ui2d/Types.h
+  include/nn/ui2d/Util.h
   include/nn/g3d/BindFuncTable.h
   include/nn/g3d/ModelObj.h
   include/nn/g3d/ResMaterialAnim.h

include/nn/gfx/gfx_Device.h

@@ -5,9 +5,20 @@
 #include <nn/util.h>
 
 namespace nn::gfx {
-
 class DeviceInfo;
 
+template <typename TTarget>
+class TCommandBuffer;
+
+template <typename TType, typename TVersion>
+class ApiVariation;
+
+template <int T>
+class ApiType;
+
+template <int T>
+class ApiVersion;
+
 template <class TTarget>
 class TDevice : public detail::DeviceImpl<TTarget>,
                 private detail::RequiredMemory<detail::DeviceImpl<TTarget>> {
@@ -26,4 +37,7 @@ class TDevice : public detail::DeviceImpl<TTarget>,
     const void* GetUserPtr() const;
 };
 
-}  // namespace nn::gfx
+typedef TDevice<ApiVariation<ApiType<4>, ApiVersion<8>>> Device;
+typedef TCommandBuffer<gfx::ApiVariation<gfx::ApiType<4>, gfx::ApiVersion<8>>> CommandBuffer;
+
+}  // namespace nn::gfx

include/nn/ui2d/Layout.h

@@ -33,10 +33,15 @@ class Layout {
     static void AllocateMemory(size_t);
     static void FreeMemory(void* src);
 
+    Pane* GetPane() const { return mPane; }
+
+private:
+    u64 _8;
     u64 _10;
-    u64 _18;
+    Pane* mPane;
     u64 _20;
-    u64 _28;
+    f32 _28;
+    f32 _2c;
     u64 _30;
 
     u64 _40;

include/nn/ui2d/Pane.h

@@ -6,73 +6,183 @@
 #pragma once
 
 #include <nn/font/font_Util.h>
+#include <nn/gfx/gfx_Device.h>
 #include <nn/types.h>
+#include <nn/ui2d/Types.h>
+#include <nn/util.h>
+#include <nn/util/MathTypes.h>
+#include <nn/util/util_IntrusiveList.h>
+
+namespace nn::util {
+struct Unorm8x4;
+}
+
+namespace nn::ui2d ::detail {
+
+class PaneBase {
+    NN_NO_COPY(PaneBase);
+
+public:
+    PaneBase();
+    virtual ~PaneBase();
+
+    util::IntrusiveListNode m_Link;
+};
+
+}  // namespace nn::ui2d::detail
 
 namespace nn::ui2d {
 class AnimTransform;
 class Layout;
+class DrawInfo;
+class ResPane;
+struct BuildArgSet;
+class Material;
+struct ResExtUserDataList;
 
-class Pane {
+class Pane : public detail::PaneBase {
 public:
     NN_RUNTIME_TYPEINFO_BASE();
 
+    struct CalculateContext;
+
+    typedef util::IntrusiveList<Pane, util::IntrusiveListMemberNodeTraits<
+                                          detail::PaneBase, &detail::PaneBase::m_Link, Pane>>
+        PaneList;
+
     Pane();
+    Pane(const ResPane*, const BuildArgSet&);
     Pane(const Pane&);
 
     virtual ~Pane();
-
+    virtual void Finalize(gfx::Device*);
     virtual s32 GetVertexColor(s32);
+    virtual void SetVertexColor(s32, util::Unorm8x4 const&);
     virtual u8 GetColorElement(s32);
     virtual void SetColorElement(u32, u8);
     virtual u8 GetVertexColorElement(s32);
     virtual void SetVertexColorElement(u32, u8);
     virtual u32 GetMaterialCount() const;
-    virtual u64* GetMaterial(s32) const;
-
+    virtual Material* GetMaterial(s32) const;
+    virtual Pane* FindPaneByName(char const*, bool);
+    virtual const Pane* FindPaneByName(char const*, bool) const;
+    virtual Material* FindMaterialByName(char const*, bool);
+    virtual const Material* FindMaterialByName(char const*, bool) const;
     virtual void BindAnimation(AnimTransform*, bool, bool);
     virtual void UnbindAnimation(AnimTransform*, bool);
+    virtual void UnbindAnimationSelf(AnimTransform*);
+    virtual void Calculate(DrawInfo&, CalculateContext&, bool);
+    virtual void Draw(DrawInfo&, gfx::CommandBuffer&);
+    virtual void DrawSelf(DrawInfo&, gfx::CommandBuffer&);
 
-    void Initialize();
     void SetName(const char*);
     void SetUserData(const char*);
+    Material* GetMaterial() const;
     void AppendChild(Pane*);
     void PrependChild(Pane*);
     void InsertChild(Pane*, Pane*);
     void RemoveChild(Pane*);
-    void GetVertexPos() const;
+
+    void Show() { SetVisible(true); }
+    void Hide() { SetVisible(false); }
+
+    bool IsVisible() const { return detail::TestBit(mFlags, PaneFlag_Visible); }
+    bool IsInfluencedAlpha() const { return detail::TestBit(mFlags, PaneFlag_InfluencedAlpha); }
+    bool IsLocationAdjust() const { return detail::TestBit(mFlags, PaneFlag_LocationAdjust); }
+    bool IsUserAllocated() const { return detail::TestBit(mFlags, PaneFlag_UserAllocated); }
+    bool IsGlobalMatrixDirty() const {
+        return detail::TestBit(mFlags, PaneFlag_IsGlobalMatrixDirty);
+    }
+    bool IsUserMatrix() const { return detail::TestBit(mFlags, PaneFlag_UserMatrix); }
+    bool IsUserGlobalMatrix() const { return detail::TestBit(mFlags, PaneFlag_UserGlobalMatrix); }
+    bool IsConstantBufferReady() const {
+        return detail::TestBit(mFlags, PaneFlag_IsConstantBufferReady);
+    }
+    bool IsMaxPanelFlag() const { return detail::TestBit(mFlags, PaneFlag_MaxPaneFlag); }
+
+    const util::Float3& GetPosition() const { return mPosition; }
+    void SetPosition(const util::Float3& position) {
+        mPosition = position;
+        SetGlobalMatrixDirty(true);
+    }
+
+    const util::Float3& GetRotation() const { return mRotation; }
+    void SetRotation(const util::Float3& rotation) {
+        mRotation = rotation;
+        SetGlobalMatrixDirty(true);
+    }
+
+    const util::Float2& GetScale() const { return mScale; }
+    void SetScale(const util::Float2& scale) {
+        mScale = scale;
+        SetGlobalMatrixDirty(true);
+    }
+
+    const Size& GetSize() const { return mSize; }
+    void SetSize(const Size& size) {
+        mSize.Set(size.width, size.height);
+        SetGlobalMatrixDirty(true);
+    }
+
+    void SetAlpha(u8 alpha) { mAlpha = alpha; }
+
+    u8 GetGlobalAlpha() const { return mGlobalAlpha; }
+
+    const util::MatrixT4x3fType& GetMtx() const { return mMtx; }
+
+protected:
+    virtual void LoadMtx(DrawInfo&);
+    virtual Pane* FindPaneByNameRecursive(const char*);
+    virtual const Pane* FindPaneByNameRecursive(const char*) const;
+    virtual Material* FindMaterialByNameRecursive(const char*);
+    virtual const Material* FindMaterialByNameRecursive(const char*) const;
+
+    const util::Float2& GetVertexPos() const;
+
+    void SetVisible(bool state) { detail::SetBit(&mFlags, PaneFlag_Visible, state); }
+    void SetInfluencedAlpha(bool state) {
+        detail::SetBit(&mFlags, PaneFlag_InfluencedAlpha, state);
+    }
+    void SetLocationAdjus(bool state) { detail::SetBit(&mFlags, PaneFlag_LocationAdjust, state); }
+    void SetUserAllocated(bool state) { detail::SetBit(&mFlags, PaneFlag_UserAllocated, state); }
+    void SetGlobalMatrixDirty(bool state) {
+        detail::SetBit(&mFlags, PaneFlag_IsGlobalMatrixDirty, state);
+    }
+    void SetUserMatrix(bool state) { detail::SetBit(&mFlags, PaneFlag_UserMatrix, state); }
+    void SetUserGlobalMatrix(bool state) {
+        detail::SetBit(&mFlags, PaneFlag_UserGlobalMatrix, state);
+    }
+    void setConstantBufferReady(bool state) {
+        detail::SetBit(&mFlags, PaneFlag_IsConstantBufferReady, state);
+    }
+    void setMaxPanelFlag(bool state) { detail::SetBit(&mFlags, PaneFlag_MaxPaneFlag, state); }
+
+private:
+    void Initialize();
+    const Pane& operator=(const Pane&);
+    void CalculateScaleFromPartsRoot(util::Float2*, Pane*) const;
+    void AllocateAndCopyAnimatedExtUserData(const ResExtUserDataList*);
+    void CalculateGlobalMatrixSelf(CalculateContext&);
 
     Pane* mParent;
-    u64 _10;
-    u64 _18;
-    u64 _20;
-    u64 _28;
-    float mPositionX;
-    float mPositionY;
-    float mPositionZ;
-    float mRotationX;
-    float mRotationY;
-    float mRotationZ;
-    float mScaleX;
-    float mScaleY;
-    float mSizeX;
-    float mSizeY;
+    PaneList mChildList;
+    util::Float3 mPosition;
+    util::Float3 mRotation;
+    util::Float2 mScale;
+    Size mSize;
     u8 mFlags;
     u8 mAlpha;
-    u8 mAlphaInfluence;
-    u8 mOriginFlags;
-    u32 _5C;
-    u64 _60;
+    u8 mGlobalAlpha;
+    u8 mBasePosition;
+    u8 mFlagEx;
+    u32 mSystemDataFlags;
     Layout* mLayout;
-    u128 _70;
-    u128 _80;
-    u128 _90;
-    u64 _A0;
-    u64 _A8;
+    util::MatrixT4x3fType mMtx;
+    const util::MatrixT4x3fType* mUserMtx;
+    const ResExtUserDataList* mExtUserDataList;
     void* mAnimExtUserData;
-    char mPanelName[0x18];
-    u8 _D0;
-    char mUserData[8];
-    u8 _D9;
+    char mPanelName[25];
+    char mUserData[9];
     u16 _DA;
     u32 _DC;
 };

include/nn/ui2d/Types.h

@@ -0,0 +1,55 @@
+
+namespace nn::ui2d {
+
+enum PaneFlag {
+    PaneFlag_Visible,
+    PaneFlag_InfluencedAlpha,
+    PaneFlag_LocationAdjust,
+    PaneFlag_UserAllocated,
+    PaneFlag_IsGlobalMatrixDirty,
+    PaneFlag_UserMatrix,
+    PaneFlag_UserGlobalMatrix,
+    PaneFlag_IsConstantBufferReady,
+    PaneFlag_MaxPaneFlag
+};
+
+enum PaneFlagEx {
+    PaneFlagEx_IgnorePartsMagnify,
+    PaneFlagEx_PartsMagnifyAdjustToPartsBound,
+    PaneFlagEx_ExtUserDataAnimationEnabled,
+    PaneFlagEx_ViewerInvisible,
+    PaneFlagEx_IsConstantBufferReadySelf,
+    PaneFlagEx_IsCalculationFinishedSelf,
+    PaneFlagEx_DynamicExtUserDataEnabled,
+    PaneFlagEx_MaxPaneFlagEx
+};
+
+struct Size {
+    static Size Create(f32, f32);
+
+    void Set(f32 aWidth, f32 aHeight) {
+        width = aWidth;
+        height = aHeight;
+    }
+
+    f32 width;
+    f32 height;
+};
+}  // namespace nn::ui2d
+
+namespace nn::ui2d::detail {
+
+template <typename T>
+void SetBit(T* pBits, s32 pos, bool val) {
+    const T mask = static_cast<T>(1 << pos);
+    *pBits &= ~mask;
+    *pBits |= mask * val;
+}
+
+template <typename T>
+bool TestBit(T bits, s32 pos) {
+    const T mask = static_cast<T>(1 << pos);
+    return bits & mask;
+}
+
+}  // namespace nn::ui2d::detail

include/nn/ui2d/Util.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <nn/gfx/gfx_Device.h>
+#include <nn/util/MathTypes.h>
+
+namespace nn::gfx {
+class MemoryPool;
+}  // namespace nn::gfx
+
+namespace nn::ui2d {
+
+class AnimTransform;
+class DrawInfo;
+class Group;
+class Layout;
+class Pane;
+class Material;
+struct ResHermiteKey;
+class ResourceTextureInfo;
+class ShaderInfo;
+struct ResExtUserDataList;
+class ResExtUserData;
+
+bool LoadTexture(ResourceTextureInfo*, gfx::Device*, const void*);
+void LoadArchiveShader(ShaderInfo*, gfx::Device*, void*, const void*, gfx::MemoryPool*, s64, u64);
+void FreeArchiveShader(gfx::Device*, ShaderInfo*);
+void ConvertBlendsToArchiveShaderName(char*, s32, s32);
+bool ConvertArchiveShaderNameToBlends(s32*, s32*, const char*);
+s32 SearchShaderVariationIndexFromTable(const void*, s32, s32);
+void BindAnimation(AnimTransform*, Group*, bool);
+void UnbindAnimation(AnimTransform*, Group*);
+bool IsContain(const Pane*, const util::Float2&);
+Pane* FindHitPane(Pane*, const util::Float2&);
+const Pane* FindHitPane(const Pane*, const util::Float2&);
+Pane* FindHitPane(Layout*, const util::Float2&);
+const Pane* FindHitPane(const Layout*, const util::Float2&);
+Pane* GetNextPane(Pane*);
+Pane* ClonePaneTree(const Pane*, gfx::Device*);
+Pane* ClonePaneTreeWithPartsLayout(const Pane*, Layout*, gfx::Device*, Layout*);
+bool ComparePaneTreeTest(const Pane*, const Pane*);
+void DrawNullAndBoundingPane(gfx::CommandBuffer&, DrawInfo&, Material&, const Pane*,
+                             const util::Unorm8x4&, const util::Unorm8x4&);
+float GetHermiteCurveValue(float, const ResHermiteKey*, s32);
+const ResExtUserData* GetExtUserData(const ResExtUserDataList*, const char*);
+u64 GetAlignedBufferSize(gfx::Device*, gfx::GpuAccess, u64);
+void SetDefaultShaderId(Material*, s32);
+
+}  // namespace nn::ui2d