diff --git a/CMakeLists.txt b/CMakeLists.txt index 7c57178..34d5fd9 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -171,20 +171,38 @@ add_library(NintendoSDK OBJECT include/nn/oe.h include/nn/util.h include/nn/image.h + include/nn/ui2d/ui2d_Animation.h + include/nn/ui2d/ui2d_Animator.h + include/nn/ui2d/ui2d_Bounding.h + include/nn/ui2d/ui2d_Common.h + include/nn/ui2d/ui2d_ControlCreator.h + include/nn/ui2d/ui2d_DrawInfo.h + include/nn/ui2d/ui2d_GraphicsResource.h + include/nn/ui2d/ui2d_Group.h + include/nn/ui2d/ui2d_Layout.h + include/nn/ui2d/ui2d_Material.h + include/nn/ui2d/ui2d_Pane.h + include/nn/ui2d/ui2d_Parts.h + include/nn/ui2d/ui2d_Picture.h + include/nn/ui2d/ui2d_ResourceAccessor.h + include/nn/ui2d/ui2d_Resources.h + include/nn/ui2d/ui2d_ShaderInfo.h + include/nn/ui2d/ui2d_TextBox.h + include/nn/ui2d/ui2d_TextSearcher.h + include/nn/ui2d/ui2d_Types.h + include/nn/ui2d/ui2d_Util.h + include/nn/ui2d/ui2d_Window.h + include/nn/ui2d/ui2d_WindowFoundation.h include/nn/util/AccessorBase.h - include/nn/util/MathTypes.h include/nn/util/util_Arithmetic.h include/nn/util/util_BinTypes.h include/nn/util/util_BitPack.h include/nn/util/util_BytePtr.h include/nn/util/util_BitUtil.h + include/nn/util/util_IntrusiveList.h + include/nn/util/util_MathTypes.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/g3d/BindFuncTable.h include/nn/g3d/ModelObj.h include/nn/g3d/ResMaterialAnim.h @@ -231,11 +249,103 @@ add_library(NintendoSDK OBJECT include/nn/nex/buffer.h include/nn/nex/system.h include/nn/nex/hash.h + include/nn/nn_Allocator.h include/nn/time.h include/nn/diag.h include/nn/init.h include/nn/crypto.h include/nn/ssl.h + include/nn/font/font_TagProcessorBase.h + include/nn/font/font_Types.h + include/nn/font/font_Util.h + include/nn/gfx/detail/gfx_Buffer-api.nvn.8.h + include/nn/gfx/detail/gfx_CommandBuffer-api.nvn.8.h + include/nn/gfx/detail/gfx_Common-api.nvn.h + include/nn/gfx/detail/gfx_DataContainer.h + include/nn/gfx/detail/gfx_DescriptorPool-api.nvn.8.h + include/nn/gfx/detail/gfx_Device-api.nvn.8.h + include/nn/gfx/detail/gfx_Fwd.h + include/nn/gfx/detail/gfx_MemoryPool-api.nvn.8.h + include/nn/gfx/detail/gfx_Misc.h + include/nn/gfx/detail/gfx_Pipeline-api.nvn.8.h + include/nn/gfx/detail/gfx_Queue-api.nvn.8.h + include/nn/gfx/detail/gfx_RequiredMemory.h + include/nn/gfx/detail/gfx_ResShaderImpl.h + include/nn/gfx/detail/gfx_RootSignature-api.common.h + include/nn/gfx/detail/gfx_RootSignature-api.nvn.8.h + include/nn/gfx/detail/gfx_Sampler-api.nvn.8.h + include/nn/gfx/detail/gfx_Shader-api.nvn.8.h + include/nn/gfx/detail/gfx_State-api.nvn.8.h + include/nn/gfx/detail/gfx_SwapChain-api.nvn.8.h + include/nn/gfx/detail/gfx_Sync-api.nvn.8.h + include/nn/gfx/detail/gfx_Texture-api.nvn.8.h + include/nn/gfx/util/gfx_PrimitiveShape.h + include/nn/gfx/gfx_Buffer.h + include/nn/gfx/gfx_BufferData-api.nvn.8.h + include/nn/gfx/gfx_BufferInfo.h + include/nn/gfx/gfx_BufferInfoData.h + include/nn/gfx/gfx_CommandBuffer.h + include/nn/gfx/gfx_CommandBufferData-api.nvn.8.h + include/nn/gfx/gfx_CommandBufferInfo.h + include/nn/gfx/gfx_CommandBufferInfoData.h + include/nn/gfx/gfx_Common.h + include/nn/gfx/gfx_DescriptorPool.h + include/nn/gfx/gfx_DescriptorPoolData-api.nvn.8.h + include/nn/gfx/gfx_DescriptorPoolInfo.h + include/nn/gfx/gfx_DescriptorPoolInfoData.h + include/nn/gfx/gfx_DescriptorSlot.h + include/nn/gfx/gfx_Device.h + include/nn/gfx/gfx_DeviceData-api.nvn.8.h + include/nn/gfx/gfx_DeviceInfo.h + include/nn/gfx/gfx_DeviceInfoData.h + include/nn/gfx/gfx_Enum.h + include/nn/gfx/gfx_GpuAddress.h + include/nn/gfx/gfx_Interoperation-api.nvn.8.h + include/nn/gfx/gfx_MemoryPool.h + include/nn/gfx/gfx_MemoryPoolData-api.nvn.8.h + include/nn/gfx/gfx_MemoryPoolInfo.h + include/nn/gfx/gfx_MemoryPoolInfoData.h + include/nn/gfx/gfx_PipelineData-api.nvn.8.h + include/nn/gfx/gfx_Queue.h + include/nn/gfx/gfx_QueueData-api.nvn.8.h + include/nn/gfx/gfx_QueueInfo.h + include/nn/gfx/gfx_QueueInfoData.h + include/nn/gfx/gfx_ResShader.h + include/nn/gfx/gfx_ResShaderData-api.nvn.h + include/nn/gfx/gfx_ResShaderData.h + include/nn/gfx/gfx_ResTexture.h + include/nn/gfx/gfx_ResTextureData.h + include/nn/gfx/gfx_ResUserData.h + include/nn/gfx/gfx_ResUserDataData.h + include/nn/gfx/gfx_RootSignatureData-api.common.h + include/nn/gfx/gfx_RootSignatureInfo.h + include/nn/gfx/gfx_RootSignatureInfoData.h + include/nn/gfx/gfx_Sampler.h + include/nn/gfx/gfx_SamplerData-api.nvn.8.h + include/nn/gfx/gfx_SamplerInfo.h + include/nn/gfx/gfx_SamplerInfoData.h + include/nn/gfx/gfx_Shader.h + include/nn/gfx/gfx_ShaderData-api.nvn.8.h + include/nn/gfx/gfx_ShaderInfo.h + include/nn/gfx/gfx_ShaderInfoData.h + include/nn/gfx/gfx_State.h + include/nn/gfx/gfx_StateData-api.nvn.8.h + include/nn/gfx/gfx_StateInfo.h + include/nn/gfx/gfx_StateInfoData.h + include/nn/gfx/gfx_SwapChain.h + include/nn/gfx/gfx_SwapChainData-api.nvn.8.h + include/nn/gfx/gfx_SwapChainInfo.h + include/nn/gfx/gfx_SwapChainInfoData.h + include/nn/gfx/gfx_Sync.h + include/nn/gfx/gfx_SyncData-api.nvn.8.h + include/nn/gfx/gfx_SyncInfo.h + include/nn/gfx/gfx_SyncInfoData.h + include/nn/gfx/gfx_Texture.h + include/nn/gfx/gfx_TextureData-api.nvn.8.h + include/nn/gfx/gfx_TextureInfo.h + include/nn/gfx/gfx_TextureInfoData.h + include/nn/gfx/gfx_Types.h + include/nn/gfx/gfx_VariationBase.h include/nn/fs/fs_bcat.h include/nn/fs/fs_directories.h include/nn/fs/fs_files.h @@ -295,6 +405,15 @@ add_library(NintendoSDK OBJECT src/NintendoSDK/nvn/nvn_FuncPtrImpl.h src/NintendoSDK/nvn/nvn_Impl.cpp src/NintendoSDK/nnSdk/util.cpp + src/NintendoWare/ui2d/ui2d_Animation.cpp + src/NintendoWare/ui2d/ui2d_Bounding.cpp + src/NintendoWare/ui2d/ui2d_ControlCreator.cpp + src/NintendoWare/ui2d/ui2d_Group.cpp + src/NintendoWare/ui2d/ui2d_GraphicsResource.cpp + src/NintendoWare/ui2d/ui2d_Layout.cpp + src/NintendoWare/ui2d/ui2d_Pane.cpp + src/NintendoWare/ui2d/ui2d_ShaderInfo.cpp + src/NintendoWare/ui2d/ui2d_Util.cpp ) target_include_directories(NintendoSDK PUBLIC include/) diff --git a/include/nn/font/detail/font_FreeList.h b/include/nn/font/detail/font_FreeList.h new file mode 100644 index 0000000..d057277 --- /dev/null +++ b/include/nn/font/detail/font_FreeList.h @@ -0,0 +1,24 @@ +#pragma once + +namespace nn { +namespace font { +namespace detail { + +// reorder +class FreeList { + void* m_pFree; + void* m_pWork; + +public: + FreeList(); + void Initialize(void*, int, int); + void* Get(); + void Put(void*); + void* GetWork() const; + void Cleanup(); + bool IsEmpty() const; +}; + +} // namespace detail +} // namespace font +} // namespace nn diff --git a/include/nn/font/font_DispStringBuffer.h b/include/nn/font/font_DispStringBuffer.h new file mode 100644 index 0000000..5e84ebb --- /dev/null +++ b/include/nn/font/font_DispStringBuffer.h @@ -0,0 +1,274 @@ +#pragma once + +#include +#include +#include +#include + +namespace nn { +namespace font { + +class GpuBuffer; +class TextureObject; + +namespace detail { + +static const int UseTextureCountMax = 8; +static const int VertexCountByLetter = 4; + +enum BitFlags { BitFlags_ColorBlackWhiteInterpolationEnabled = 1, BitFlags_BorderEffectEnabled }; + +struct TextureUseInfo { + const TextureObject* pTexObj; + uint32_t useCount; + uint32_t bitFlags; +}; + +struct Vertex { + util::Float3 xyz; + util::Unorm8x4 color; + util::Float3 uvw; + + void Set(float, float, float, const util::Unorm8x4&, float, float, float); +}; + +struct VertexShaderCharAttribute { + util::Float4 posAndSize; + util::Float4 texCoord; + util::Unorm8x4 color[2]; + int32_t sheetIndex; + float italicOffset; + util::Float4 translate; + + void Set(const float, const float, const float, const float, const util::Float4&, + const util::Unorm8x4&, const util::Unorm8x4&, const int32_t, const float, const float); +}; + +struct VertexShaderCharAttributeWithTransform { + util::Float4 posAndSize; + util::Float4 texCoord; + util::Unorm8x4 color[2]; + int32_t sheetIndex; + float italicOffset; + util::Float4 translate; + util::Float4 rotateMatrixAndCenterX; + util::Float4 rotateMatrixAndCenterY; + + void Set(const float, const float, const float, const float, const util::Float4&, + const util::Unorm8x4&, const util::Unorm8x4&, const int32_t, const float, const float, + const util::Float4&, const util::Float4&, const util::Float4&); +}; +} // namespace detail + +class CharAttribute { +public: + enum Flags { Flags_BorderEffect = 1 }; + + util::Float4 pos; + util::Unorm8x4 color[2]; + util::Float4 tex; + +private: + uintptr_t m_pTexObjAndFlags; + +public: + int16_t italicOffset; + uint8_t sheetIndex; + uint8_t shadowAlpha; + + void SetTexObjAndFlags(const TextureObject*, uint8_t); + const TextureObject* GetTexObj() const; + uint8_t GetFlags() const; +}; + +struct ShadowParameter { + util::Unorm8x4 shadowUpperColor; + util::Unorm8x4 shadowLowerColor; + util::Float2 shadowOffset; + util::Float2 shadowScale; + float shadowItalicOffset; +}; + +class PerCharacterTransformInfo { +public: + float Scale[2]; + float RotationCos[3]; + float RotationSin[3]; + float Translation[3]; + uint8_t LT[4]; + uint8_t LB[4]; + + PerCharacterTransformInfo(); +}; + +class ConstantBufferAdditionalContent { +public: + enum Flags { + Flags_InvisibleBorder = 1, + Flags_ShadowEnabled, + Flags_PerCharacterTransformEnabled = 4 + }; + + enum PerCharacterTransformCenter { + PerCharacterTransformCenter_Center, + PerCharacterTransformCenter_Bottom, + PerCharacterTransformCenter_Count + }; + +public: + ConstantBufferAdditionalContent(); + ConstantBufferAdditionalContent& SetViewMatrix(const util::MatrixT4x3fType*); + ConstantBufferAdditionalContent& SetLocalMatrix(const util::MatrixT4x3fType*); + ConstantBufferAdditionalContent& SetInterpolateBlack(const util::Unorm8x4&); + ConstantBufferAdditionalContent& SetInterpolateBlack(const util::Float4&); + ConstantBufferAdditionalContent& SetInterpolateWhite(const util::Unorm8x4&); + ConstantBufferAdditionalContent& SetInterpolateWhite(const util::Float4&); + ConstantBufferAdditionalContent& SetInterpolateAlpha(uint8_t); + ConstantBufferAdditionalContent& SetShadowInterpolateBlack(const util::Unorm8x4&); + ConstantBufferAdditionalContent& SetShadowInterpolateBlack(const util::Float4&); + ConstantBufferAdditionalContent& SetShadowInterpolateWhite(const util::Unorm8x4&); + ConstantBufferAdditionalContent& SetShadowInterpolateWhite(const util::Float4&); + ConstantBufferAdditionalContent& SetShadowInterpolateAlpha(uint8_t); + const util::Unorm8x4 GetInterpolateBlack() const; + const util::Unorm8x4 GetInterpolateWhite() const; + uint8_t GetInterpolateAlpha() const; + const util::Float4& GetInterpolateBlackFloat() const; + const util::Float4& GetInterpolateWhiteFloat() const; + const util::Unorm8x4 GetShadowInterpolateBlack() const; + const util::Unorm8x4 GetShadowInterpolateWhite() const; + uint8_t GetShadowInterpolateAlpha() const; + const util::Float4& GetShadowInterpolateBlackFloat() const; + const util::Float4& GetShadowInterpolateWhiteFloat() const; + ConstantBufferAdditionalContent& SetBorderVisibility(bool); + ConstantBufferAdditionalContent& SetShadowParam(const ShadowParameter*); + ConstantBufferAdditionalContent& + SetPerCharacterTransformInfos(const PerCharacterTransformInfo*); + ConstantBufferAdditionalContent& SetPerCharacterTransformCenter(PerCharacterTransformCenter); + ConstantBufferAdditionalContent& SetPerCharacterTransformCenterOffset(float); + +private: + const ShadowParameter* m_pShadowParam; + const PerCharacterTransformInfo* m_pPerCharacterTransformInfos; + PerCharacterTransformCenter m_PerCharacterTransformCenter; + float m_PerCharacterTransformCenterOffset; + const util::MatrixT4x3fType* m_pViewMatrix; + const util::MatrixT4x3fType* m_pLocalMatrix; + util::Float4 m_InterpolateBlackColor; + util::Float4 m_InterpolateWhiteColor; + uint8_t m_InterpolateWhiteAlpha; + util::Float4 m_ShadowInterpolateBlackColor; + util::Float4 m_ShadowInterpolateWhiteColor; + uint8_t m_ShadowInterpolateWhiteAlpha; + uint32_t m_Flags; +}; + +class DispStringBuffer { +public: + struct ShaderParam { + float m_Mtx[4][4]; + float m_InterpolateWidth[4]; + float m_InterpolateOffset[4]; + float m_ShadowInterpolateWidth[4]; + float m_ShadowInterpolateOffset[4]; + }; + + class InitializeArg { + public: + InitializeArg(); + InitializeArg& SetCharCountMax(int); + InitializeArg& SetShadowEnabled(bool); + InitializeArg& SetPerCharacterTransformEnabled(bool); + InitializeArg& SetPerCharacterTransformAutoShadowAlpha(bool); + InitializeArg& SetDoubleDrawnBorder(bool); + InitializeArg& SetDrawBuffer(void*); + InitializeArg& SetConstantBuffer(GpuBuffer*); + + private: + int GetCharCountMax() const; + void* GetDrawBuffer() const; + + void* m_pDrawBuffer; + GpuBuffer* m_pConstantBuffer; + int m_CharCountMax; + bool m_ShadowEnabled; + bool m_DoubleDrawnBorder; + bool m_PerCharacterTransformEnabled; + bool m_PerCharacterTransformAutoShadowAlpha; + }; + + DispStringBuffer(); + ~DispStringBuffer(); + static size_t GetRequiredDrawBufferSize(const InitializeArg&); + static size_t GetRequiredConstantBufferSize(gfx::Device*, const InitializeArg&); + bool Initialize(gfx::Device*, const InitializeArg&); + bool IsInitialized() const; + void Finalize(gfx::Device*); + int GetCharCountMax() const; + int GetCharCount() const; + void SetCharCount(int); + CharAttribute* GetCharAttributes() const; + void SetCharAttributes(CharAttribute*); + void* GetDrawBuffer() const; + void SetConstantBuffer(GpuBuffer*); + void GetConstantBufferGpuAddress(gfx::GpuAddress*) const; + void BuildConstantBuffer(const util::MatrixT4x4fType&, const ConstantBufferAdditionalContent*, + bool, bool); + void BuildConstantBuffer(const util::MatrixT4x4fType&, const ConstantBufferAdditionalContent*, + bool); + void BuildConstantBuffer(const util::MatrixT4x4fType&, const ConstantBufferAdditionalContent*); + void BuildConstantBuffer(const util::MatrixT4x4fType&); + void SetFontHeight(float); + bool CompareCopiedInstanceTest(const DispStringBuffer&) const; + void SetDoubleDrawnBorderEnabled(bool); + bool IsDoubleDrawnBorderEnabled() const; + +protected: + void BuildTextureUseInfos(bool); + +private: + void BuildCommonConstantBufferData(ShaderParam&, const util::MatrixT4x4fType&, + const ConstantBufferAdditionalContent&) const; + void BuildPerCharacterAttributeConstantBuffer(const ConstantBufferAdditionalContent&, bool, + bool); + void BuildPerCharacterParams(ptrdiff_t, const PerCharacterTransformInfo*, + const ConstantBufferAdditionalContent::PerCharacterTransformCenter, + const float, const ShadowParameter*, bool, bool); + void BuildShadowBufferPerCharacterParams( + ptrdiff_t, const PerCharacterTransformInfo*, + const ConstantBufferAdditionalContent::PerCharacterTransformCenter, const float, + const ShadowParameter*, const uint32_t*, util::BytePtr, uint32_t, uint32_t*, int, bool); + void BuildCharacterBufferPerCharacterParams( + ptrdiff_t, const PerCharacterTransformInfo*, + const ConstantBufferAdditionalContent::PerCharacterTransformCenter, const float, + const uint32_t*, util::BytePtr, uint32_t, uint32_t*, int, bool); + void CalculatePerCharacterTransform( + util::Float4&, util::Float4&, util::Float4&, const float, const float, const float, + const float, const float, const float, const PerCharacterTransformInfo&, + const ConstantBufferAdditionalContent::PerCharacterTransformCenter, const float) const; + + friend class RectDrawer; + + class VertexBufferData { + public: + detail::TextureUseInfo textureUseInfos[8]; + int textureUseInfoPos; + }; + + uint32_t m_ConstantBufferOffset; + uint32_t m_PerCharacterParamOffset; + uint32_t m_DrawContentFlags; + VertexBufferData m_VertexBufferData; + int32_t m_CharCountMax; + int32_t m_CharCount; + CharAttribute* m_pCharAttrs; + uint8_t* m_pCharUseTextureIndices; + GpuBuffer* m_pConstantBuffer; + bool m_ShadowEnabled; + bool m_DoubleDrawnBorder; + bool m_PerCharacterTransformEnabled; + bool m_PerCharacterTransformAutoShadowAlpha; + float m_FontHeight; +}; + +} // namespace font +} // namespace nn diff --git a/include/nn/font/font_Font.h b/include/nn/font/font_Font.h new file mode 100644 index 0000000..01751b5 --- /dev/null +++ b/include/nn/font/font_Font.h @@ -0,0 +1,99 @@ +#pragma once + +#include +#include +#include +#include +#include +#include +#include + +namespace nn { +namespace font { + +namespace detail { +inline size_t GetIndexBufferAlignment(gfx::Device* pDevice) { + gfx::BufferInfo info{}; + info.SetDefault(); + + info.SetGpuAccessFlags(gfx::GpuAccess_IndexBuffer); + + return gfx::Buffer::GetBufferAlignment(pDevice, info); +} + +/* +size_t GetVertexBufferAlignment(gfx::Device* pDevice) { + gfx::BufferInfo info; +} + +size_t GetMemoryPoolAlignment(gfx::Device* pDevice) { + gfx::MemoryPoolInfo info; +} +*/ + +inline size_t GetPoolMemorySizeGranularity(gfx::Device* pDevice) { + gfx::MemoryPoolInfo info{}; + info.SetDefault(); + + info.SetMemoryPoolProperty(gfx::MemoryPoolProperty_GpuCached | + gfx::MemoryPoolProperty_CpuUncached); + + return gfx::MemoryPool::GetPoolMemorySizeGranularity(pDevice, info); +} + +} // namespace detail + +typedef uint16_t TexFmt; + +union TextureSize { + struct { + uint16_t height; + uint16_t width; + }; + uint32_t size; +}; + +// reorder +class TextureObject { + static const uint64_t InvalidDescriptorSlotValue; + uintptr_t m_pImage; + TextureSize m_Size; + uint16_t m_Format; + uint8_t m_SheetCount; + bool m_ColorBlackWhiteInterpolationEnabled; + bool m_isInitialized; + gfx::DescriptorSlot m_DescriptorSlotForTexture; + +public: + TextureObject(); + virtual ~TextureObject(); + void Set(const void*, TexFmt, uint16_t, uint16_t, uint8_t, bool); + void Reset(); + bool IsInitialized() const; + uintptr_t GetImage() const; + uint16_t GetFormat() const; + uint16_t GetFormatAttribute() const; + uint8_t GetSheetCount() const; + const TextureSize GetSize() const; + bool IsColorBlackWhiteInterpolationEnabled() const; + void SetColorBlackWhiteInterpolationEnabled(bool); + virtual const gfx::TextureView* GetTextureView() const; + virtual gfx::TextureView* GetTextureView(); + const gfx::DescriptorSlot& GetDescriptorSlotForTexture() const; + gfx::DescriptorSlot& GetDescriptorSlotForTexture(); + bool IsDescriptorSlotForTextureReady() const; + +protected: + uintptr_t GetImagePtr() const; +}; + +class PlacementTextureObject : public TextureObject { +public: + PlacementTextureObject(); + virtual ~PlacementTextureObject(); + virtual const gfx::TextureView* GetTextureView() const; + virtual gfx::TextureView* GetTextureView(); +}; + +} // namespace font +} // namespace nn diff --git a/include/nn/font/font_GlyphTreeMap.h b/include/nn/font/font_GlyphTreeMap.h new file mode 100644 index 0000000..d2e9c81 --- /dev/null +++ b/include/nn/font/font_GlyphTreeMap.h @@ -0,0 +1,162 @@ +#pragma once + +#include +#include +#include +#include + +namespace nn { +namespace font { + +class GlyphNode { +public: + union KeyType { + uint64_t raw; + struct { + uint32_t code; + uint16_t fontFace; + uint16_t fontSize; + } detail; + }; + + enum FlagMask { + FlagMask_Requested = 1, + FlagMask_Plotting, + FlagMask_Used = 4, + FlagMask_Erased = 8, + FlagMask_Kept = 16, + FlagMask_SystemReserved = 32, + FlagMask_NotInFont = 64 + }; + + util::IntrusiveListNode m_Link; + util::IntrusiveListNode m_LineLink; + +private: + static const uint8_t Red; + static const uint8_t Black; + GlyphNode* m_pLeftNode; + GlyphNode* m_pRightNode; + KeyType m_Key; + util::BitPack8 m_Flag; + uint8_t m_Color; + uint8_t m_LineKind; + uint8_t m_LineNo; + util::BitPack32 m_LockGroup; + uint16_t m_CachePosX; + uint16_t m_CachePosY; + uint16_t m_CacheWidth; + uint16_t m_CacheHeight; + uint16_t m_GlyphWidth; + uint16_t m_GlyphHeight; + uint16_t m_AdvanceX; + int16_t m_LeftOffset; + int16_t m_BaselineOffset; + +public: + GlyphNode(uint32_t, uint16_t, uint16_t); + uint32_t GetCode() const; + uint16_t GetSize() const; + uint16_t GetFace() const; + void SetRequested(bool); + bool IsRequested() const; + void SetPlotting(bool); + bool IsPlotting() const; + void SetUsed(bool); + bool IsUsed() const; + void SetErased(bool); + bool IsErased() const; + void SetKeeped(bool); + bool IsKeeped() const; + void SetSystemReserved(bool); + bool IsSystemReserved() const; + void SetNotInFont(bool); + bool IsNotInFont() const; + bool IsPlottingOrNotInFont() const; + bool IsRequestedOrKeeped() const; + uint16_t GetCachePosX() const; + uint16_t GetCachePosY() const; + uint16_t GetCacheWidth() const; + uint16_t GetCacheHeight() const; + uint16_t GetGlyphWidth() const; + uint16_t GetGlyphHeight() const; + uint16_t GetAdvanceX() const; + int16_t GetLeftOffset() const; + int16_t GetBaselineOffset() const; + void SetCachePosX(uint16_t); + void SetCachePosY(uint16_t); + void SetCacheWidth(uint16_t); + void SetCacheHeight(uint16_t); + void SetGlyphWidth(uint16_t); + void SetGlyphHeight(uint16_t); + void SetAdvanceX(uint16_t); + void SetLeftOffset(int16_t); + void SetBaselineOffset(int16_t); + util::BitPack32& GetLockGroup(); + const util::BitPack32& GetLockGroup() const; + uint8_t GetLineNo() const; + void SetLineNo(uint8_t); + uint8_t GetLineKind() const; + void SetLineKind(uint8_t); + bool IsErasable() const; + bool IsUsable() const; + static uint8_t CalculateLineKind(uint16_t); + static uint32_t CalculateLineHeight(uint8_t); +}; + +typedef util::IntrusiveList< + GlyphNode, util::IntrusiveListMemberNodeTraits> + GlyphList; +typedef util::IntrusiveList< + GlyphNode, util::IntrusiveListMemberNodeTraits> + GlyphLineList; + +// todo: reorder +class GlyphTreeMap { + GlyphNode* m_pRootNode; + detail::FreeList m_FreeList; + uint32_t m_NodeCountMax; + +public: + GlyphTreeMap(); + void Initialize(AlignedAllocateFunctionWithUserData, void*, uint32_t); + void Finalize(FreeFunctionWithUserData, void*); + GlyphNode* Find(uint32_t, uint16_t, uint16_t) const; + +private: + GlyphNode* Find(GlyphNode*, uint64_t) const; + +public: + GlyphNode* Insert(uint32_t, uint16_t, uint16_t); + +private: + GlyphNode* Insert(GlyphNode*, GlyphNode*); + +public: + void Erase(uint32_t, uint16_t, uint16_t); + +private: + GlyphNode* Erase(GlyphNode*, uint64_t); + +public: + void UpdateFlagsForCompleteTextureCache(); + void ClearLockGroup(uint32_t); + void Dump() const; + void Reset(); + +private: + static GlyphNode* RotateLeft(GlyphNode*); + static GlyphNode* RotateRight(GlyphNode*); + static void FlipColors(GlyphNode*); + static bool IsRed(GlyphNode*); + static GlyphNode* FixUp(GlyphNode*); + static GlyphNode* MoveRedLeft(GlyphNode*); + static GlyphNode* MoveRedRight(GlyphNode*); + static GlyphNode* EraseMin(GlyphNode*); + static GlyphNode* GetMin(GlyphNode*); + static void UpdateFlagsForCompleteTextureCacheRecursive(GlyphNode*); + static void ClearLockGroupRecursive(GlyphNode*, uint32_t); + static uint32_t DumpRecursive(GlyphNode*, uint32_t); +}; +} // namespace font +} // namespace nn diff --git a/include/nn/font/font_RectDrawer.h b/include/nn/font/font_RectDrawer.h new file mode 100644 index 0000000..c305582 --- /dev/null +++ b/include/nn/font/font_RectDrawer.h @@ -0,0 +1,81 @@ +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace nn { +namespace font { + +class RectDrawer { +public: + static const int IndexCountByLetter = 6; + static const int VertexAttributeCount = 3; + + static size_t GetWorkBufferSize(gfx::Device*, uint32_t); + static size_t CalculateMemoryPoolSize(gfx::Device*, uint32_t); + static size_t CalculateMemoryPoolAlignment(gfx::Device*); + static size_t GetWorkBufferAlignment(); + + RectDrawer(); + virtual ~RectDrawer(); + bool Initialize(gfx::Device*, void*, uint32_t); + virtual bool Initialize(gfx::Device*, void*, uint32_t, gfx::MemoryPool*, ptrdiff_t, size_t); + bool IsInitialized() const; + virtual void Finalize(gfx::Device*); + void RegisterSamplerToDescriptorPool(RegisterSamplerSlot, void*); + void UnregisterSamplerFromDescriptorPool(UnregisterSamplerSlot, void*); + virtual void Draw(gfx::CommandBuffer&, const DispStringBuffer&) const; + void* GetBuffer() const; + +protected: + void LoadTexture(const TextureObject*); + static void CreateIndices(uint16_t*, uint32_t); + +private: + enum ShaderVariation { + ShaderVariation_NormalShader, + ShaderVariation_BorderShader, + ShaderVariation_InvisibleBorderShader, + ShaderVariation_NormalShaderWithPerCharacterTransform, + ShaderVariation_BorderShaderWithPerCharacterTransform, + ShaderVariation_InvisibleBorderShaderWithPerCharacterTransform, + ShaderVariation_ShaderQuantity, + ShaderVariation_Invalid + }; + + struct ShaderParamBlackWhiteInterpolation { + int32_t flags; + }; + + void AddDrawCommand(gfx::CommandBuffer&, const DispStringBuffer::VertexBufferData&, + const uint32_t, const gfx::GpuAddress&, const gfx::GpuAddress&) const; + gfx::Shader* GetVertexShader(int) const; + gfx::Shader* GetPixelShader(int) const; + + gfx::ResShaderFile* m_pResShaderFile; + gfx::ShaderCodeType m_CodeType; + int m_VertexShaderSlots[6]; + int m_VertexShaderPerCharacterParamsSlots[6]; + int m_PixelShaderSlots[6]; + int m_BlackWhiteInterpolationSlots[6]; + int m_TextureSlots[6]; + int32_t m_CharCountMax; + gfx::VertexState m_VertexStates[6]; + gfx::MemoryPool m_MemoryPoolForBuffers; + gfx::Buffer m_VertexBuffer; + gfx::Buffer m_IndexBuffer; + gfx::Buffer m_ShaderParamBlackWhiteInterpolationEnabledBuffer; + gfx::Buffer m_ShaderParamBlackWhiteInterpolationDisabledBuffer; + gfx::Sampler m_Sampler; + gfx::DescriptorSlot m_DescriptorSlotForSampler; + void* m_WorkMemory; +}; +} // namespace font +} // namespace nn diff --git a/include/nn/font/font_ResourceFormat.h b/include/nn/font/font_ResourceFormat.h new file mode 100644 index 0000000..49369ef --- /dev/null +++ b/include/nn/font/font_ResourceFormat.h @@ -0,0 +1,79 @@ +#pragma once + +#include + +namespace nn { +namespace font { +namespace detail { + +typedef union { + uint32_t UInt32; + int32_t SInt32; + float Float32; +} Type32; + +struct BinaryFileHeader { + uint32_t signature; + uint16_t byteOrder; + uint16_t headerSize; + uint32_t version; + uint32_t fileSize; + uint16_t dataBlocks; + uint16_t reserved; +}; + +struct BinaryBlockHeader { + uint32_t kind; + uint32_t size; +}; + +inline bool IsValidBinaryFile(const BinaryFileHeader* pHeader, uint32_t signature, + uint32_t version = 0, uint16_t minBlocks = 0) { + NN_UNUSED(version); + NN_UNUSED(minBlocks); + + if (pHeader->signature != signature) { + char s[256]; + util::SNPrintf(s, sizeof(s), "Signature check failed ('%c%c%c%c' must be '%c%c%c%c').", + (pHeader->signature >> 24) & 0xff, (pHeader->signature >> 16) & 0xff, + (pHeader->signature >> 8) & 0xff, pHeader->signature & 0xff, + (signature >> 24) & 0xff, (signature >> 16) & 0xff, (signature >> 8) & 0xff, + signature & 0xff); + + return false; + } + + return true; +} +} // namespace detail + +/* +406 : nn::font::FontType; +417 : nn::font::CharacterCode; +431 : nn::font::FontMapMethod; +445 : nn::font::FontSheetFormat; +485 : nn::font::CharWidths; +498 : nn::font::CMapScanEntry; +511 : nn::font::CMapInfoScan; +523 : nn::font::KerningFirstTableElem; +533 : nn::font::KerningSecondTableElem; +544 : nn::font::KerningSecondTable; +594 : nn::font::FontTextureGlyph; +616 : nn::font::FontWidth; +631 : nn::font::FontCodeMap; +647 : nn::font::FontKerningTable; +667 : nn::font::FontInformation; +687 : nn::font::ResSubFontType; +695 : nn::font::ResCharCodeRange; +702 : nn::font::ResCharCodeRangeSet; +710 : nn::font::ResBitmapFont; +718 : nn::font::ResScalableFontDescription; +726 : nn::font::ResScalableFontDescription::Bits; +743 : nn::font::ResScalableFontDescriptionOld; +754 : nn::font::ResMultiScalableFont; +769 : nn::font::ResMultiScalableFontOld; +779 : nn::font::ResPairFont; +787 : nn::font::ResComplexFontDescription; +*/ +} // namespace font +} // namespace nn diff --git a/include/nn/font/font_TagProcessorBase.h b/include/nn/font/font_TagProcessorBase.h new file mode 100644 index 0000000..553c1f2 --- /dev/null +++ b/include/nn/font/font_TagProcessorBase.h @@ -0,0 +1,70 @@ +#pragma once + +#include +#include + +namespace nn { +namespace font { + +template +class TextWriterBase; + +class Rectangle; + +template +class PrintContext { +public: + TextWriterBase* writer; + const CharType* str; + const CharType* strEnd; + const float xOrigin; + const float yOrigin; + const float hScale; + const float vScale; + uint32_t flags; + uint32_t prevCode; + + PrintContext(TextWriterBase*, const CharType*, const CharType*, const float, + const float, const float, const float, uint32_t); + +private: + const PrintContext& operator=(const PrintContext&); +}; + +template +class TagProcessorBase { +public: + NN_RUNTIME_TYPEINFO_BASE(); + + typedef PrintContext ContextType; + + enum Operation { + Operation_Default, + Operation_NoCharSpace, + Operation_CharSpace, + Operation_NextLine, + Operation_EndDraw, + Operation_MaxOperation + }; + + TagProcessorBase(); + virtual ~TagProcessorBase(); + virtual Operation Process(uint32_t, ContextType*); + virtual Operation CalculateRect(Rectangle*, ContextType*, uint32_t); + virtual void BeginPrint(ContextType*); + virtual void EndPrint(ContextType*); + virtual void BeginCalculateRect(ContextType*); + virtual void EndCalculateRect(ContextType*); + virtual void BeginCalculateRectWhole(const TextWriterBase*, const CharType*, + const CharType*); + virtual void EndCalculateRectWhole(const TextWriterBase*, const CharType*, + const CharType*); + virtual const CharType* AcquireNextPrintableChar(bool*, const CharType*); + +private: + void ProcessLinefeed(ContextType*) const; + void ProcessTab(ContextType*) const; +}; + +} // namespace font +} // namespace nn diff --git a/include/nn/font/font_TextureCache.h b/include/nn/font/font_TextureCache.h new file mode 100644 index 0000000..c8d0ad4 --- /dev/null +++ b/include/nn/font/font_TextureCache.h @@ -0,0 +1,167 @@ +#pragma once + +#include +#include +#include +#include +#include +#include + +namespace nn { + +namespace fontll { +class ScalableFontEngine; +class OtfKerningTable; +} // namespace fontll + +namespace font { + +class FontMetrics; + +// todo: reorder +class TextureCache { + struct LineInfo { + GlyphLineList list; + uint16_t y; + uint16_t currentX; + uint8_t kind; + uint8_t no; + uint8_t dummy[2]; + }; + + class LineHeight; + + enum NoSpaceError { + NoSpaceError_NoError, + NoSpaceError_LackOfGlyphNodeSpace, + NoSpaceError_TextureCacheLineIsOverMax, + NoSpaceError_LackOfTextureCacheSpace + }; + +public: + static const int FontFaceCountMax; + static const int MultiScalableFontCountMax; + static const int CharCodeRangeCountMax; + +private: + static const int FontNameLengthMax; + static const int WorkMemorySizeDefault; + static const int WorkMemorySizeNoPlotDefault; + static const int GlyphNodeCountMaxDefault; + static const int TextureCacheLineCountMax; + static const int GlyphPadding; + static const int CoreCountMax; + fontll::ScalableFontEngine* m_pFontEngine; + fontll::ScalableFontEngine* m_pFontEngineNoPlot; + char* m_pFontNameBuffers; + uint8_t* m_pTextureBitmap; + uint32_t m_TextureCacheWidth; + uint32_t m_TextureCacheHeight; + GlyphTreeMap m_GlyphTreeMap; + GlyphList m_NeedPlotGlyphList; + GlyphList m_NeedEraseGlyphList; + GlyphList m_NotInFontGlyphList; + LineInfo m_LineInfos[256]; + uint32_t m_LineCurrentPos; + uint32_t m_FontCount; + uint8_t m_FontListCount[32]; + uint8_t* m_InnerFontFaceHeadTable[32]; + uint8_t m_InnerFontFaceTable[512]; + uint32_t m_CurrentFontFace; + uint32_t m_CurrentFontFacesNoPlot[8]; + NoSpaceError m_NoSpaceError; + bool m_IsWorkMemoryExhausted; + bool m_IsDrawMultiCore; + int m_CoreCount; + + int (*m_pGetCoreNumberFunction)(); + uint8_t (*m_pCalculateLineKindFunction)(uint16_t); + uint32_t (*m_pCalculateLineHeightFunction)(uint8_t); + + FontMetrics* m_pFontMetrics; + int32_t* m_pBoldWeights; + uint8_t* m_pBorderWidths; + bool* m_pDeleteBearingX; + int16_t* m_pBearingOffsetX; + int* m_pCharCodeRangeCount; + + uint32_t (*m_pCharCodeRangeFirst)[16]; + uint32_t (*m_pCharCodeRangeLast)[16]; + + fontll::OtfKerningTable** m_pOtfKerningTable; + bool m_IsExactWidthReturnedAfterPlot; + gfx::Texture m_Texture; + gfx::TextureView m_TextureView; + gfx::MemoryPool m_MemoryPoolForTexture; + gfx::MemoryPool* m_pActiveMemoryPoolForTexture; + ptrdiff_t m_OffsetOfMemoryPoolForTexture; + PlacementTextureObject m_TexObj; + +public: + TextureCache(); + virtual ~TextureCache(); + + struct InitializeArg; + + static void SetMemoryPoolInfo(gfx::MemoryPoolInfo*); + static size_t CalculateMemoryPoolAlignment(gfx::Device*, int, int); + static size_t CalculateMemoryPoolSize(gfx::Device*, int, int); + void Initialize(gfx::Device*, const InitializeArg&); + void Initialize(gfx::Device*, const InitializeArg&, gfx::MemoryPool*, ptrdiff_t, size_t); + void Finalize(gfx::Device*, FreeFunctionWithUserData, void*); + void RegisterTextureViewToDescriptorPool(RegisterTextureViewSlot, void*); + void UnregisterTextureViewFromDescriptorPool(UnregisterTextureViewSlot, void*); + bool RegisterGlyph(uint32_t, uint32_t, uint16_t, int); + bool RegisterGlyph(uint32_t, uint32_t, uint16_t, int, bool); + uint32_t RegisterGlyphsWithLength(const uint16_t*, uint32_t, uint32_t, uint16_t, int); + uint32_t RegisterGlyphsWithLength(const uint16_t*, uint32_t, uint32_t, uint16_t, int, bool); + uint32_t RegisterGlyphsWithLengthUtf8(const char*, uint32_t, uint32_t, uint16_t, int); + uint32_t RegisterGlyphsWithLengthUtf8(const char*, uint32_t, uint32_t, uint16_t, int, bool); + void UpdateTextureCache(); + void CompleteTextureCache(); + void ClearLockAllGlyphs(int); + void ClearLockGlyphsWithLength(const uint16_t*, uint32_t, uint32_t, uint16_t, int); + void ClearLockGlyphsWithLength(const uint16_t*, uint32_t, uint32_t, uint16_t, int, bool); + void ClearLockGlyphsWithLengthUtf8(const char*, uint32_t, uint32_t, uint16_t, int); + void ClearLockGlyphsWithLengthUtf8(const char*, uint32_t, uint32_t, uint16_t, int, bool); + void ResetTextureCache(); + bool CreateNewLine(LineHeight); + void ChangeFontListOrder(uint32_t, uint32_t*); + TextureObject* GetTextureObject(); + const TextureObject* GetTextureObject() const; + uint32_t GetTextureCacheWidth() const; + uint32_t GetTextureCacheHeight() const; + bool IsBorderEffectEnabled(uint16_t) const; + uint32_t CountPlottingGlyph(const uint16_t*, uint32_t, uint32_t, uint16_t); + void DumpGlyphTreeMap() const; + bool IsGlyphExistInFont(uint32_t, uint16_t); + bool IsDrawMultiCore() const; + NoSpaceError GetNoSpaceError() const; + void ClearNoSpaceError(); + bool GetWorkMemoryExhausted() const; + void ClearWorkMemoryExhausted(); + const FontMetrics& GetFontMetrics(uint16_t) const; + int CalculateCharWidth(uint32_t, uint32_t, uint16_t); + int CalculateKerning(uint32_t, uint32_t, uint32_t, uint16_t); + GlyphNode* FindGlyphNode(uint32_t, uint32_t, uint16_t); + const void* GetTextureCacheBitMap() const; + uint32_t CountUnusableGlyph(const uint16_t*, uint32_t, uint32_t, uint16_t); + +private: + LineInfo* CreateNewLineImpl(uint8_t); + GlyphNode* FindAndReserveEraseGlyph(uint8_t, uint16_t); + void SetFontFace(uint32_t); + void SetFontFaceNoPlot(uint32_t, uint32_t); + void AssertFsError(const char*) const; + void AssertFsErrorNoPlot(const char*, uint32_t) const; + uint32_t EraseNotInFontGlyphs(); + char* GetFontNameBuf(uint32_t) const; + uint32_t GetFontEngineNoPlotCount() const; + uint32_t GetCoreId() const; + int InitializeFontFaceTable(const InitializeArg&); + bool GetInnerFontFace(uint32_t*, uint32_t, uint32_t); + bool CheckCharCodeRange(uint32_t, uint32_t) const; + bool IsInternalMemoryPoolUsed() const; +}; +} // namespace font +} // namespace nn diff --git a/include/nn/font/font_Types.h b/include/nn/font/font_Types.h new file mode 100644 index 0000000..d48c12c --- /dev/null +++ b/include/nn/font/font_Types.h @@ -0,0 +1,47 @@ +#pragma once + +#include +#include + +namespace nn { +namespace font { + +typedef bool (*RegisterTextureViewSlot)(gfx::DescriptorSlot*, const gfx::TextureView&, void*); +typedef bool (*RegisterSamplerSlot)(gfx::DescriptorSlot*, const gfx::Sampler&, void*); +typedef void (*UnregisterTextureViewSlot)(gfx::DescriptorSlot*, const gfx::TextureView&, void*); +typedef void (*UnregisterSamplerSlot)(gfx::DescriptorSlot*, const gfx::Sampler&, void*); + +class Rectangle { +public: + float left; + float top; + float right; + float bottom; + + Rectangle(); + + Rectangle(float l, float t, float r, float b) : left(l), top(t), right(r), bottom(b) {} + + Rectangle(const Rectangle&); + ~Rectangle(); + float GetWidth() const; + float GetHeight() const; + float GetX() const; + float GetY() const; + void SetWidth(float); + void SetHeight(float); + void MoveTo(float, float); + void Move(float, float); + void SetEdge(float, float, float, float); + void SetOriginAndSize(float, float, float, float); + void SetCenterAndSize(float, float, float, float); + void Normalize(); +}; + +namespace detail { + +enum TextColor { TextColor_Start, TextColor_End, TextColor_MaxTextColor }; + +} +} // namespace font +} // namespace nn diff --git a/include/nn/font/font_Util.h b/include/nn/font/font_Util.h index e98eda9..da9488e 100644 --- a/include/nn/font/font_Util.h +++ b/include/nn/font/font_Util.h @@ -1,16 +1,50 @@ #pragma once -namespace nn::font::detail { +#include + +namespace nn::font { + +namespace detail { class RuntimeTypeInfo { public: const RuntimeTypeInfo* m_ParentTypeInfo; explicit RuntimeTypeInfo(const RuntimeTypeInfo* parent) : m_ParentTypeInfo(parent) {} - bool IsDerivedFrom(const RuntimeTypeInfo*) const; + bool IsDerivedFrom(const RuntimeTypeInfo* s_TypeInfo) const { + const RuntimeTypeInfo* self = this; + + while (self) { + if (self == s_TypeInfo) { + return true; + } + + self = self->m_ParentTypeInfo; + } + + return false; + } }; -} // namespace nn::font::detail +} // namespace detail + +template +TToPtr DynamicCast(TFrom* obj) { + const detail::RuntimeTypeInfo* typeInfoU = + std::remove_pointer::type::GetRuntimeTypeInfoStatic(); + if (obj && obj->GetRuntimeTypeInfo()->IsDerivedFrom(typeInfoU)) { + return static_cast(obj); + } + return nullptr; +} + +template +bool IsDerivedFrom(const From* instance) { + const detail::RuntimeTypeInfo* typeInfoU = To::GetRuntimeTypeInfoStatic(); + return (instance && instance->GetRuntimeTypeInfo()->IsDerivedFrom(typeInfoU)); +} + +} // namespace nn::font // todo: figure out where to put this #define NN_RUNTIME_TYPEINFO_BASE() \ diff --git a/include/nn/g3d/ResSkeleton.h b/include/nn/g3d/ResSkeleton.h index a830a1e..355c597 100644 --- a/include/nn/g3d/ResSkeleton.h +++ b/include/nn/g3d/ResSkeleton.h @@ -1,11 +1,11 @@ #pragma once +#include #include #include #include +#include #include -#include "nn/gfx/gfx_ResUserData.h" -#include "nn/util/MathTypes.h" namespace nn::g3d { diff --git a/include/nn/gfx/detail/gfx_Buffer-api.nvn.8.h b/include/nn/gfx/detail/gfx_Buffer-api.nvn.8.h index 2862714..261c7cd 100644 --- a/include/nn/gfx/detail/gfx_Buffer-api.nvn.8.h +++ b/include/nn/gfx/detail/gfx_Buffer-api.nvn.8.h @@ -55,4 +55,4 @@ class BufferTextureViewImpl } // namespace detail -} // namespace nn::gfx \ No newline at end of file +} // namespace nn::gfx diff --git a/include/nn/gfx/gfx_Buffer.h b/include/nn/gfx/gfx_Buffer.h index 7918215..4fb383c 100644 --- a/include/nn/gfx/gfx_Buffer.h +++ b/include/nn/gfx/gfx_Buffer.h @@ -14,7 +14,9 @@ class TBuffer : public detail::BufferImpl { static const bool IsMemoryPoolRequired = true; - static size_t GetBufferAlignment(TDevice*, const InfoType&); + static size_t GetBufferAlignment(TDevice* pDevice, const InfoType& info) { + return detail::BufferImpl::GetBufferAlignment(pDevice, info); + } TBuffer(); void Initialize(TDevice*, const InfoType&, TMemoryPool*, ptrdiff_t, size_t); @@ -29,4 +31,4 @@ class TBuffer : public detail::BufferImpl { const void* GetUserPtr() const; }; -} // namespace nn::gfx \ No newline at end of file +} // namespace nn::gfx diff --git a/include/nn/gfx/gfx_Common.h b/include/nn/gfx/gfx_Common.h index be2fef3..2d193ef 100644 --- a/include/nn/gfx/gfx_Common.h +++ b/include/nn/gfx/gfx_Common.h @@ -23,4 +23,9 @@ union ClearColorValue { uint32_t valueUint[4]; }; -} // namespace nn::gfx \ No newline at end of file +template typename TObject> +bool IsInitialized(const TObject& obj) { + return obj.ToData()->state != obj.DataType::State_NotInitialized; +} + +} // namespace nn::gfx diff --git a/include/nn/gfx/gfx_DescriptorSlot.h b/include/nn/gfx/gfx_DescriptorSlot.h index a07bf5c..ab6c009 100644 --- a/include/nn/gfx/gfx_DescriptorSlot.h +++ b/include/nn/gfx/gfx_DescriptorSlot.h @@ -13,12 +13,11 @@ class DescriptorSlot : public detail::DataContainer { static const uint64_t InvalidValue = 0xFFFFFFFFFFFFFFFF; public: - DescriptorSlot(); + DescriptorSlot() { Invalidate(); } void Offset(ptrdiff_t offset) { value += offset; } - - bool IsValid() const; - void Invalidate(); + bool IsValid() const { return this->value == InvalidValue; } + void Invalidate() { this->value = InvalidValue; } }; -} // namespace nn::gfx \ No newline at end of file +} // namespace nn::gfx diff --git a/include/nn/gfx/gfx_MemoryPool.h b/include/nn/gfx/gfx_MemoryPool.h index 0ce29f2..52ef89e 100644 --- a/include/nn/gfx/gfx_MemoryPool.h +++ b/include/nn/gfx/gfx_MemoryPool.h @@ -13,7 +13,10 @@ class TMemoryPool : public detail::MemoryPoolImpl { typedef MemoryPoolInfo InfoType; static size_t GetPoolMemoryAlignment(TDevice*, const InfoType&); - static size_t GetPoolMemorySizeGranularity(TDevice*, const InfoType&); + + static size_t GetPoolMemorySizeGranularity(TDevice* pDevice, const InfoType& info) { + return detail::MemoryPoolImpl::GetPoolMemorySizeGranularity(pDevice, info); + } TMemoryPool(); diff --git a/include/nn/gfx/gfx_ResShader.h b/include/nn/gfx/gfx_ResShader.h index d72261d..a45d3e9 100644 --- a/include/nn/gfx/gfx_ResShader.h +++ b/include/nn/gfx/gfx_ResShader.h @@ -25,9 +25,17 @@ class ResShaderProgram : public nn::util::AccessorBase { ShaderInfo* GetShaderInfo() { return DataToAccessor(info); } const ShaderInfo* GetShaderInfo() const { return DataToAccessor(info); } - detail::Caster GetShader(); - detail::Caster GetShader() const; + detail::Caster GetShader() { return detail::Caster(pObj.Get()); } + detail::Caster GetShader() const { return detail::Caster(pObj.Get()); } const nngfxToolShaderCompilerShaderReflection* GetShaderCompilerReflection() const; + + template + ShaderInitializeResult Initialize(TDevice* pDevice) { + return static_cast>(pObj.Get())->Initialize(pDevice, DataToAccessor(info)); + } + + template + void Finalize(TDevice*); }; class ResShaderVariation : public nn::util::AccessorBase { @@ -79,6 +87,16 @@ class ResShaderContainer : public nn::util::AccessorBase static const ResShaderContainer& ToAccessor(const value_type&); + template + void Initialize(TDevice* pDevice); + + template + void Initialize(TDevice* pDevice, TMemoryPool* pMemoryPool, + ptrdiff_t memoryPoolOffset, size_t memoryPoolSize); + + template + void Finalize(TDevice*); + ResShaderProgram* GetResShaderProgram(int); const ResShaderProgram* GetResShaderProgram(int) const; @@ -124,4 +142,4 @@ class ResShaderFile : public nn::util::AccessorBase { nn::util::BinaryFileHeader* GetBinaryFileHeader() { return &fileHeader; } const nn::util::BinaryFileHeader* GetBinaryFileHeader() const { return &fileHeader; } }; -} // namespace nn::gfx \ No newline at end of file +} // namespace nn::gfx diff --git a/include/nn/gfx/gfx_ResTexture.h b/include/nn/gfx/gfx_ResTexture.h index 0b2e4bb..723e1d3 100644 --- a/include/nn/gfx/gfx_ResTexture.h +++ b/include/nn/gfx/gfx_ResTexture.h @@ -14,24 +14,40 @@ class ResTexture : public nn::util::AccessorBase { public: static const int Signature = 0x49545242; - static ResTexture* ToAccessor(value_type*); - static ResTexture& ToAccessor(value_type&); - static const ResTexture* ToAccessor(const value_type*); - static const ResTexture& ToAccessor(const value_type&); - - TextureInfo* GetTextureInfo(); - const TextureInfo* GetTextureInfo() const; - detail::Caster GetTexture(); - detail::Caster GetTexture() const; - detail::Caster GetTextureView(); - detail::Caster GetTextureView() const; + static ResTexture* ToAccessor(ResTextureData*); + static ResTexture& ToAccessor(ResTextureData&); + static const ResTexture* ToAccessor(const ResTextureData*); + static const ResTexture& ToAccessor(const ResTextureData&); + + TextureInfo* GetTextureInfo() { return gfx::DataToAccessor(this->textureInfoData); } + const TextureInfo* GetTextureInfo() const { return gfx::DataToAccessor(this->textureInfoData); } + + detail::Caster GetTexture() { return detail::Caster(this->pTexture.Get()); } + + detail::Caster GetTexture() const { + return detail::Caster(this->pTexture.Get()); + } + + detail::Caster GetTextureView() { return detail::Caster(this->pTextureView.Get()); } + + detail::Caster GetTextureView() const { + return detail::Caster(this->pTextureView.Get()); + } + const char* GetName() const; size_t GetDataSize() const; ResUserData* GetUserData(int); const ResUserData* GetUserData(int) const; const nn::util::ResDic* GetUserDataDic() const; - void SetUserDescriptorSlot(const DescriptorSlot&); + + void SetUserDescriptorSlot(const DescriptorSlot& value) { + this->userDescriptorSlot = value.ToData(); + } + void GetUserDescriptorSlot(DescriptorSlot*) const; + + template + void Finalize(TDevice* pDevice); }; class ResTextureFile : public nn::util::AccessorBase { @@ -74,4 +90,10 @@ class ResTextureFile : public nn::util::AccessorBase { void Finalize(TDevice*); }; -} // namespace nn::gfx \ No newline at end of file +template +void ResTexture::Finalize(TDevice* pDevice) { + static_cast*>(this->pTexture.Get())->Finalize(pDevice); + static_cast*>(this->pTextureView.Get())->Finalize(pDevice); +} + +} // namespace nn::gfx diff --git a/include/nn/gfx/gfx_Shader.h b/include/nn/gfx/gfx_Shader.h index 2fd651b..dfdc954 100644 --- a/include/nn/gfx/gfx_Shader.h +++ b/include/nn/gfx/gfx_Shader.h @@ -14,13 +14,22 @@ class TShader : public detail::ShaderImpl { static size_t GetBinaryCodeAlignment(TDevice*); TShader(); - ShaderInitializeResult Initialize(TDevice*, const InfoType&); + + ShaderInitializeResult Initialize(TDevice* pDevice, const InfoType& info) { + return detail::ShaderImpl::Initialize(pDevice, info); + } + void Finalize(TDevice*); - int GetInterfaceSlot(ShaderStage, ShaderInterfaceType, const char*) const; + + int GetInterfaceSlot(ShaderStage stage, ShaderInterfaceType shaderInterfaceType, + const char* pName) const { + return detail::ShaderImpl::GetInterfaceSlot(stage, shaderInterfaceType, pName); + } + void GetWorkGroupSize(int*, int*, int*) const; void SetUserPtr(void*); void* GetUserPtr(); const void* GetUserPtr() const; }; -} // namespace nn::gfx \ No newline at end of file +} // namespace nn::gfx diff --git a/include/nn/gfx/gfx_Types.h b/include/nn/gfx/gfx_Types.h index 3ece3fa..d94a832 100644 --- a/include/nn/gfx/gfx_Types.h +++ b/include/nn/gfx/gfx_Types.h @@ -28,4 +28,4 @@ typedef TTextureView TextureView; typedef TColorTargetView ColorTargetView; typedef TDepthStencilView DepthStencilView; -} // namespace nn::gfx \ No newline at end of file +} // namespace nn::gfx diff --git a/include/nn/nn_Allocator.h b/include/nn/nn_Allocator.h new file mode 100644 index 0000000..d5abfed --- /dev/null +++ b/include/nn/nn_Allocator.h @@ -0,0 +1,10 @@ +#pragma once + +#include + +namespace nn { + +typedef void* (*AlignedAllocateFunctionWithUserData)(size_t, size_t, void*); +typedef void (*FreeFunctionWithUserData)(void*, void*); + +} // namespace nn diff --git a/include/nn/ui2d/Layout.h b/include/nn/ui2d/Layout.h deleted file mode 100644 index 5acabf6..0000000 --- a/include/nn/ui2d/Layout.h +++ /dev/null @@ -1,52 +0,0 @@ -/** - * @file Layout.h - * @brief UI Layout implementation. - */ - -#pragma once - -#include - -namespace nn { -namespace ui2d { -class AnimTransform; -class Pane; - -class Layout { -public: - Layout(); - - virtual ~Layout(); - - virtual void DeleteAnimTransform(nn::ui2d::AnimTransform*); - virtual void BindAnimation(nn::ui2d::AnimTransform*); - virtual void UnbindAnimation(nn::ui2d::AnimTransform*); - virtual void UnbindAnimation(nn::ui2d::Pane*); - virtual void UnbindAllAnimation(); - - virtual void Animate(); - virtual void UpdateAnimFrame(f32 frame); - virtual void AnimateAndUpdateAnimFrame(f32 frame); - - static void SetAllocator(void* (*)(size_t, size_t, void*), void (*)(void*, void*), void*); - static void AllocateMemory(size_t, size_t); - static void AllocateMemory(size_t); - static void FreeMemory(void* src); - - u64 _10; - u64 _18; - u64 _20; - u64 _28; - u64 _30; - - u64 _40; - u64 _48; - u64 _50; - u64 _58; - u64 _60; - - static void* g_pAllocateFunction; - static void* g_pFreeFunction; -}; -} // namespace ui2d -} // namespace nn diff --git a/include/nn/ui2d/Material.h b/include/nn/ui2d/Material.h deleted file mode 100644 index c642c26..0000000 --- a/include/nn/ui2d/Material.h +++ /dev/null @@ -1,29 +0,0 @@ -/** - * @file Material.h - * @brief UI Material implementation. - */ - -#pragma once - -#include - -namespace nn { -namespace ui2d { -class AnimTransform; -class BuildResultInformation; -struct UserShaderInformation; - -class Material { -public: - Material(); - - void Initialize(); - void ReserveMem(s32, s32, s32, s32, bool, s32, bool, s32, bool, bool); - void SetupUserShaderConstantBufferInformation(nn::ui2d::UserShaderInformation const&); - - virtual ~Material(); - virtual void BindAnimation(nn::ui2d::AnimTransform*); - virtual void UnbindAnimation(nn::ui2d::AnimTransform*); -}; -} // namespace ui2d -} // namespace nn diff --git a/include/nn/ui2d/Pane.h b/include/nn/ui2d/Pane.h deleted file mode 100644 index 5e7aa95..0000000 --- a/include/nn/ui2d/Pane.h +++ /dev/null @@ -1,79 +0,0 @@ -/** - * @file Pane.h - * @brief Base UI panel. - */ - -#pragma once - -#include -#include - -namespace nn::ui2d { -class AnimTransform; -class Layout; - -class Pane { -public: - NN_RUNTIME_TYPEINFO_BASE(); - - Pane(); - Pane(const Pane&); - - virtual ~Pane(); - - virtual s32 GetVertexColor(s32); - 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 void BindAnimation(AnimTransform*, bool, bool); - virtual void UnbindAnimation(AnimTransform*, bool); - - void Initialize(); - void SetName(const char*); - void SetUserData(const char*); - void AppendChild(Pane*); - void PrependChild(Pane*); - void InsertChild(Pane*, Pane*); - void RemoveChild(Pane*); - void GetVertexPos() const; - - 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; - u8 mFlags; - u8 mAlpha; - u8 mAlphaInfluence; - u8 mOriginFlags; - u32 _5C; - u64 _60; - Layout* mLayout; - u128 _70; - u128 _80; - u128 _90; - u64 _A0; - u64 _A8; - void* mAnimExtUserData; - char mPanelName[0x18]; - u8 _D0; - char mUserData[8]; - u8 _D9; - u16 _DA; - u32 _DC; -}; -} // namespace nn::ui2d diff --git a/include/nn/ui2d/Parts.h b/include/nn/ui2d/Parts.h deleted file mode 100644 index 589a6a6..0000000 --- a/include/nn/ui2d/Parts.h +++ /dev/null @@ -1,30 +0,0 @@ -/** - * @file Parts.h - * @brief Layout parts. - */ - -#pragma once - -#include - -namespace nn { -namespace ui2d { -struct BuildArgSet; -struct ResParts; - -class Parts : nn::ui2d::Pane { -public: - NN_RUNTIME_TYPEINFO(nn::ui2d::Pane); - - Parts(); - Parts(nn::ui2d::ResParts const*, nn::ui2d::ResParts const*, nn::ui2d::BuildArgSet const&); - Parts(nn::ui2d::Parts const&); - - virtual ~Parts(); - - u64 _E0; - u64 _E8; - u32 _F0; -}; -} // namespace ui2d -} // namespace nn diff --git a/include/nn/ui2d/detail/TexCoordArray.h b/include/nn/ui2d/detail/TexCoordArray.h deleted file mode 100644 index cff39eb..0000000 --- a/include/nn/ui2d/detail/TexCoordArray.h +++ /dev/null @@ -1,38 +0,0 @@ -/** - * @file TexCoordArray.h - * @brief Texture coordinate array implementation. - */ - -#pragma once - -#include - -namespace nn { - -namespace util { -struct Float2; -} - -namespace ui2d { -class Layout; - -namespace detail { -class TexCoordArray { -public: - void Initialize(); - void Free(); - void Reserve(s32); - void SetSize(s32 size); - void GetCoord(nn::util::Float2*, s32) const; - void SetCoord(s32, nn::util::Float2 const*); - void Copy(void const*, s32); - bool CompareCopiedInstanceTest(nn::ui2d::detail::TexCoordArray const&) const; - - u16 _0; - u16 _2; - u32 _4; // padding? - nn::ui2d::Layout* mLayout; // _8 -}; -} // namespace detail -} // namespace ui2d -} // namespace nn diff --git a/include/nn/ui2d/ui2d_Animation.h b/include/nn/ui2d/ui2d_Animation.h new file mode 100644 index 0000000..784ac79 --- /dev/null +++ b/include/nn/ui2d/ui2d_Animation.h @@ -0,0 +1,188 @@ +#pragma once + +#include +#include +#include + +namespace nn { + +namespace font { +namespace detail { + +struct BinaryFileHeader; + +} +} // namespace font + +namespace ui2d { + +struct ResAnimationContent; +struct ResAnimationBlock; +struct ResAnimationTagBlock; +struct ResAnimationShareBlock; +class TextureInfo; +class Pane; +class Layout; +class Material; +class ResourceAccessor; +struct ResAnimationBlock; +class Group; +class ResExtUserData; +struct ResAnimationGroupRef; +struct ResExtUserDataList; +struct ResAnimationShareInfo; + +class AnimTransform { +public: + NN_RUNTIME_TYPEINFO_BASE(); + + class BindPair { + public: + void* target; + const ResAnimationContent* animCont; + + BindPair() : target(nullptr), animCont(nullptr) {} + }; + + AnimTransform(); + virtual ~AnimTransform(); + + float GetFrame() const { return m_Frame; } + void SetFrame(float); + + uint16_t GetFrameSize() const; + + float GetFrameMax() const; + + virtual void UpdateFrame(float progressFrame); + + const ResAnimationBlock* GetAnimResource() const { return m_pRes; } + bool IsEnabled() const { return m_IsEnabled; } + + virtual void SetEnabled(bool bEnable); + bool IsLoopData() const; + bool IsWaitData() const; + + virtual void Animate() = 0; + virtual void AnimatePane(Pane*) = 0; + virtual void AnimateMaterial(Material*) = 0; + virtual void SetResource(gfx::Device*, ResourceAccessor*, const ResAnimationBlock*) = 0; + virtual void SetResource(gfx::Device*, ResourceAccessor*, const ResAnimationBlock*, + uint16_t) = 0; + virtual void BindPane(Pane*, bool) = 0; + virtual void BindGroup(Group*) = 0; + virtual void BindMaterial(Material*) = 0; + virtual void ForceBindPane(Pane*, const Pane*) = 0; + virtual void UnbindPane(const Pane*) = 0; + virtual void UnbindGroup(const Group*) = 0; + virtual void UnbindMaterial(const Material*) = 0; + virtual void UnbindAll() = 0; + + util::IntrusiveListNode m_Link; + +protected: + void SetAnimResource(const ResAnimationBlock* pRes) { m_pRes = pRes; } + +private: + const ResAnimationBlock* m_pRes; + float m_Frame; + bool m_IsEnabled; +}; + +class AnimTransformBasic : public AnimTransform { +public: + NN_RUNTIME_TYPEINFO(AnimTransform); + + AnimTransformBasic(); + virtual ~AnimTransformBasic(); + virtual void Animate(); + virtual void AnimatePane(Pane*); + virtual void AnimateMaterial(Material*); + virtual void SetResource(gfx::Device*, ResourceAccessor*, const ResAnimationBlock*); + virtual void SetResource(gfx::Device*, ResourceAccessor*, const ResAnimationBlock*, uint16_t); + virtual void BindPane(Pane*, bool); + virtual void BindGroup(Group*); + virtual void BindMaterial(Material*); + virtual void ForceBindPane(Pane*, const Pane*); + virtual void UnbindPane(const Pane*); + virtual void UnbindGroup(const Group*); + virtual void UnbindMaterial(const Material*); + virtual void UnbindAll(); + bool BindPaneImpl(Pane*, const ResAnimationContent*); + bool BindMaterialImpl(Material*, const ResAnimationContent*); + bool BindExtUserDataImpl(ResExtUserData*, const ResAnimationContent*); + +protected: + virtual void AnimatePaneImpl(Pane*, const ResAnimationContent*); + virtual void AnimateMaterialImpl(Material*, const ResAnimationContent*); + virtual void AnimateExtUserDataImpl(ResExtUserData*, const ResAnimationContent*); + bool BindExtUserDataToPane(Pane*, const ResAnimationContent&); + bool CheckBindAnimationDoubly(const void*, const ResAnimationContent*) const; + void EraseBindPair(int); + + const TextureInfo** m_pTextures; + AnimTransform::BindPair* m_pBindPairs; + uint16_t m_BindPairCount; + uint16_t m_BindPairCountMax; +}; + +class AnimResource { +public: + AnimResource(); + + explicit AnimResource(const void* pAnimResBuf) { Set(pAnimResBuf); } + + void Set(const void*); + const font::detail::BinaryFileHeader* GetFileHeader() const; + const ResAnimationBlock* GetResourceBlock() const { return m_pResBlock; } + const ResAnimationTagBlock* GetTagBlock() const; + uint16_t GetTagOrder() const; + const char* GetTagName() const; + uint16_t GetGroupCount() const; + const ResAnimationGroupRef* GetGroupArray() const; + const ResExtUserDataList* GetExtUserDataList() const; + bool IsDescendingBind() const; + uint16_t GetAnimationShareInfoCount() const; + const ResAnimationShareInfo* GetAnimationShareInfoArray() const; + uint16_t CalculateAnimationCount(Pane*, bool) const; + uint16_t CalculateAnimationCount(Material*) const; + uint16_t CalculateAnimationCount(Group*, bool) const; + +private: + void Initialize(); + bool CheckResource() const; + + const font::detail::BinaryFileHeader* m_pFileHeader; + const ResAnimationBlock* m_pResBlock; + const ResAnimationTagBlock* m_pTagBlock; + const ResAnimationShareBlock* m_pShareBlock; +}; + +namespace detail { + +class AnimPaneTree { +public: + AnimPaneTree(); + AnimPaneTree(Pane*, const AnimResource&); + void Set(Pane*, const AnimResource&); + AnimTransform* Bind(gfx::Device*, Layout*, Pane*, ResourceAccessor*) const; + + bool IsEnabled() const { return m_LinkCount != 0; } + const AnimResource& GetAnimResource() const { return m_AnimRes; } + +private: + static const ResAnimationContent* FindAnimContent(const ResAnimationBlock*, const char*, + uint8_t); + void Initialize(); + + static const int MaterialCountMax = 9; + AnimResource m_AnimRes; + const ResAnimationContent* m_pPaneAnimContent; + const ResAnimationContent* m_pMatAnimContents[MaterialCountMax]; + uint16_t m_LinkCount; + uint8_t m_AnimMatCnt; +}; + +} // namespace detail +} // namespace ui2d +} // namespace nn diff --git a/include/nn/ui2d/ui2d_Animator.h b/include/nn/ui2d/ui2d_Animator.h new file mode 100644 index 0000000..cf4183d --- /dev/null +++ b/include/nn/ui2d/ui2d_Animator.h @@ -0,0 +1,105 @@ +#pragma once + +#include +#include + +namespace nn { +namespace ui2d { + +class Animator : public AnimTransformBasic { +public: + NN_RUNTIME_TYPEINFO(AnimTransformBasic); + + enum PlayType { PlayType_OneShot, PlayType_Loop, PlayType_RoundTrip }; + + Animator(); + virtual ~Animator(); + virtual void Play(PlayType, float); + virtual void PlayAuto(float); + virtual void PlayFromCurrent(PlayType, float); + virtual void StopAt(float); + virtual void StopAtCurrentFrame(); + virtual void StopAtStartFrame(); + virtual void StopAtEndFrame(); + virtual void UpdateFrame(float); + + float GetSpeed() const { return m_Speed; } + + bool IsPlaying() const; + bool IsMinFrame() const; + bool IsStartFrame() const; + bool IsMaxFrame() const; + bool IsEndFrame() const; + bool IsFrameMidway() const; + + PlayType GetPlayType() const { return m_PlayType; } + + bool IsTurnedMaxTrigger() const; + bool IsTurnedMinTrigger() const; + bool IsEndTrigger() const; + + // newer + // virtual void Unbind(); + + enum FlagMask { + FlagMask_PlayStatusEnd = 1, + FlagMask_PlayStatusTurnedMax = 2, + FlagMask_PlayStatusTurnedMin = 4 + }; + +protected: + void ClearPlayStatusFlag(); + +private: + float m_Speed; + PlayType m_PlayType; + util::BitPack32 m_Flag; +}; + +class PaneAnimator : public Animator { +public: + NN_RUNTIME_TYPEINFO(Animator); + + PaneAnimator() = default; + void Setup(Pane*, bool); + virtual void Unbind(); + + Pane* GetPane() const { return m_pPane; } + +private: + Pane* m_pPane = nullptr; +}; + +class GroupAnimator : public Animator { +public: + NN_RUNTIME_TYPEINFO(Animator); + + GroupAnimator() = default; + void Setup(Group*, bool); + void Setup(const AnimResource&, GroupContainer*, int, bool); + virtual void Unbind(); + + Group* GetGroup() const { return m_pGroup; } + +private: + Group* m_pGroup = nullptr; +}; + +class GroupArrayAnimator : public Animator { +public: + NN_RUNTIME_TYPEINFO(Animator); + + GroupArrayAnimator() = default; + void Setup(const AnimResource&, GroupContainer*, Group**, bool); + virtual void Unbind(); + + Group** GetGroups() const { return m_pGroupArray; } + int GetGroupCount() const { return m_GroupCount; } + +private: + Group** m_pGroupArray = nullptr; + int32_t m_GroupCount = 0; +}; + +} // namespace ui2d +} // namespace nn diff --git a/include/nn/ui2d/ui2d_Bounding.h b/include/nn/ui2d/ui2d_Bounding.h new file mode 100644 index 0000000..b210ae7 --- /dev/null +++ b/include/nn/ui2d/ui2d_Bounding.h @@ -0,0 +1,30 @@ +#pragma once + +#include + +namespace nn { +namespace ui2d { + +struct ResBounding; + +class Bounding : public Pane { +public: + NN_RUNTIME_TYPEINFO(Pane); + + Bounding(); + Bounding(const Size&); + Bounding(const ResBounding*, const ResBounding*, const BuildArgSet&); + Bounding(const Bounding&); + virtual ~Bounding(); + + bool CompareCopiedInstanceTest(const Bounding&) const; + +protected: + virtual void DrawSelf(DrawInfo&, gfx::CommandBuffer&); + +private: + const Bounding& operator=(const Bounding&) = delete; +}; + +} // namespace ui2d +} // namespace nn diff --git a/include/nn/ui2d/ui2d_Common.h b/include/nn/ui2d/ui2d_Common.h new file mode 100644 index 0000000..6399fd8 --- /dev/null +++ b/include/nn/ui2d/ui2d_Common.h @@ -0,0 +1,260 @@ +/** + * @file TexCoordArray.h + * @brief Texture coordinate array implementation. + */ + +#pragma once + +#include +#include + +namespace nn { +namespace ui2d { + +class Layout; +struct ResExtUserDataList; +struct ResTextureList; +struct ResFontList; +struct ResMaterialList; +struct ResShapeInfoList; +struct ResCaptureTextureList; +class ResourceAccessor; +class ControlCreator; +class TextSearcher; +struct ResPartsPaneBasicInfo; +class Pane; + +struct UserShaderInformation { + char userShaderName[6]; + uint32_t vertexShaderConstantBufferExtendSize; + uint32_t geometryShaderConstantBufferExtendSize; + uint32_t pixelShaderConstantBufferExtendSize; + + void SetDefault(); + bool SetShaderName(const char*); +}; + +typedef bool (*GetUserShaderInformationFromUserData)(UserShaderInformation&, + const ResExtUserDataList*, void*); + +struct BuildResSet { + const ResTextureList* pTextureList; + const ResFontList* pFontList; + const ResMaterialList* pMaterialList; + // smo + // const ResShapeInfoList* pShapeInfoList; + + // newer + // const ResCaptureTextureList* pCaptureTextureList; + + ResourceAccessor* pResAccessor; + Layout* pLayout; + + // smo + // bool isFlytOlderThanBinary8200; + // newer + // bool isDetailedCombinerWithVariationVariable; +}; + +typedef RenderTargetTextureLifetime (*CreateRenderTargetTextureCallback)( + gfx::Texture**, gfx::TextureView**, gfx::DescriptorSlot**, const gfx::TextureInfo&, void*, + RenderTargetTextureLifetime); + +typedef void (*DestroyRenderTargetTextureCallback)(gfx::Texture*, gfx::TextureView*, + gfx::DescriptorSlot*, void*, + RenderTargetTextureLifetime); + +typedef RenderTargetTextureLifetime (*CreateRenderTargetTextureResourceCallback)( + gfx::Texture**, gfx::TextureView**, gfx::DescriptorSlot**, const Layout*, + const gfx::TextureInfo&, void*, RenderTargetTextureLifetime); + +typedef void (*DestroyRenderTargetTextureResourceCallback)(gfx::Texture*, gfx::TextureView*, + gfx::DescriptorSlot*, const Layout*, + void*, RenderTargetTextureLifetime); + +struct BuildArgSet { + util::Float2 magnify; + util::Float2 partsSize; + ControlCreator* pControlCreator; + TextSearcher* pTextSearcher; + Layout* pLayout; + Layout* pBodyLayout; + const BuildResSet* pCurrentBuildResSet; + const BuildResSet* pOverrideBuildResSet; + uint16_t overrideUsageFlag; + uint16_t overrideBasicUsageFlag; + uint16_t overrideMaterialUsageFlag; + const ResPartsPaneBasicInfo* pOverridePartsPaneBasicInfo; + /* newer + const char* pCaptureTexturePrefixStack[8]; + int captureTexturePrefixStackPosition; + int captureTextureOverridePosition; + */ + Pane* pParentPane; + GetUserShaderInformationFromUserData pGetUserShaderInformationFromUserDataCallback; + // smo + // void* pGetUserShaderInformationFromUserDataCallbackUserData; + const ResExtUserDataList* pExtUserDataList; + bool isRootPaneParts; + bool isUtf8; + // smo + // uint32_t resourceVersion; + // newer + // bool isViewerInvisibleByParent; +}; + +struct BuildResultInformation { + size_t requiredUi2dConstantBufferSize; + size_t requiredFontConstantBufferSize; + + void SetDefault(); +}; + +// should probably have this has a util function +#define FLAG(bit) 0x1 << bit + +namespace detail { +enum FrameSpecFlag { + FrameSpecFlag_VertexEffectTexcoordEnabled = FLAG(0), + FrameSpecFlag_VertexEffectFrame = FLAG(1), + FrameSpecFlag_VertexEffectTexcoordAlignRight = FLAG(2), + FrameSpecFlag_VertexEffectTexcoordAlignBottom = FLAG(3), + FrameSpecFlag_VertexEffectDotByDotU = FLAG(4), + FrameSpecFlag_VertexEffectDotByDotV = FLAG(5), + + FrameSpecFlag_VertexEffectFrameIdShift = 8, + FrameSpecFlag_VertexEffectFrameIdMask = 0xF << FrameSpecFlag_VertexEffectFrameIdShift, + + FrameSpecFlag_VertexEffectTexCoordSwap = FLAG(16), + FrameSpecFlag_VertexEffectTexCoordHFlip = FLAG(17), + FrameSpecFlag_VertexEffectTexCoordVFlip = FLAG(18), + FrameSpecFlag_VertexEffectConstColor = FLAG(19), + + FrameSpecFlag_FrameIdLt = 0 << FrameSpecFlag_VertexEffectFrameIdShift, + FrameSpecFlag_FrameIdRt = 1 << FrameSpecFlag_VertexEffectFrameIdShift, + FrameSpecFlag_FrameIdLb = 2 << FrameSpecFlag_VertexEffectFrameIdShift, + FrameSpecFlag_FrameIdRb = 3 << FrameSpecFlag_VertexEffectFrameIdShift, + FrameSpecFlag_FrameIdL = 4 << FrameSpecFlag_VertexEffectFrameIdShift, + FrameSpecFlag_FrameIdR = 5 << FrameSpecFlag_VertexEffectFrameIdShift, + FrameSpecFlag_FrameIdT = 6 << FrameSpecFlag_VertexEffectFrameIdShift, + FrameSpecFlag_FrameIdB = 7 << FrameSpecFlag_VertexEffectFrameIdShift, + FrameSpecFlag_Frame4IdLt = 8 << FrameSpecFlag_VertexEffectFrameIdShift, + FrameSpecFlag_Frame4IdRt = 9 << FrameSpecFlag_VertexEffectFrameIdShift, + FrameSpecFlag_Frame4IdLb = 0xA << FrameSpecFlag_VertexEffectFrameIdShift, + FrameSpecFlag_Frame4IdRb = 0xB << FrameSpecFlag_VertexEffectFrameIdShift, + FrameSpecFlag_Frame2IdL = 0xC << FrameSpecFlag_VertexEffectFrameIdShift, + FrameSpecFlag_Frame2IdC = 0xD << FrameSpecFlag_VertexEffectFrameIdShift, + + FrameSpecFlag_Content = FrameSpecFlag_Frame2IdC, + FrameSpecFlag_FrameHorizontalL = FrameSpecFlag_FrameIdL | FrameSpecFlag_VertexEffectFrame | + FrameSpecFlag_VertexEffectTexcoordEnabled, + FrameSpecFlag_FrameHorizontalR = FrameSpecFlag_FrameIdR | FrameSpecFlag_VertexEffectFrame | + FrameSpecFlag_VertexEffectTexcoordEnabled, + FrameSpecFlag_FrameHorizontalNoContentL = 0xC13, + FrameSpecFlag_FrameHorizontalNoContentR = 0x503, + + FrameSpecFlag_FrameLt = FrameSpecFlag_FrameIdLt | FrameSpecFlag_VertexEffectFrame | + FrameSpecFlag_VertexEffectTexcoordEnabled, + FrameSpecFlag_FrameRt = FrameSpecFlag_FrameIdRt | FrameSpecFlag_VertexEffectFrame | + FrameSpecFlag_VertexEffectTexcoordEnabled, + + FrameSpecFlag_FrameLb = FrameSpecFlag_FrameIdLb | FrameSpecFlag_VertexEffectFrame | + FrameSpecFlag_VertexEffectTexcoordEnabled, + FrameSpecFlag_FrameRb = FrameSpecFlag_FrameIdRb | FrameSpecFlag_VertexEffectFrame | + FrameSpecFlag_VertexEffectTexcoordEnabled, + + FrameSpecFlag_FrameL = FrameSpecFlag_FrameIdL | FrameSpecFlag_VertexEffectFrame | + FrameSpecFlag_VertexEffectTexcoordEnabled | + FrameSpecFlag_VertexEffectDotByDotV | + FrameSpecFlag_VertexEffectTexcoordAlignBottom, + FrameSpecFlag_FrameR = FrameSpecFlag_FrameIdR | FrameSpecFlag_VertexEffectFrame | + FrameSpecFlag_VertexEffectTexcoordEnabled | + FrameSpecFlag_VertexEffectDotByDotV, + + FrameSpecFlag_FrameT = FrameSpecFlag_FrameIdT | FrameSpecFlag_VertexEffectFrame | + FrameSpecFlag_VertexEffectTexcoordEnabled | + FrameSpecFlag_VertexEffectDotByDotU, + FrameSpecFlag_FrameB = FrameSpecFlag_FrameIdB | FrameSpecFlag_VertexEffectFrame | + FrameSpecFlag_VertexEffectTexcoordEnabled | + FrameSpecFlag_VertexEffectDotByDotU | + FrameSpecFlag_VertexEffectTexcoordAlignRight, + + FrameSpecFlag_Frame4Lt = FrameSpecFlag_Frame4IdLt | FrameSpecFlag_VertexEffectFrame | + FrameSpecFlag_VertexEffectTexcoordEnabled | + FrameSpecFlag_VertexEffectDotByDotU, + FrameSpecFlag_Frame4Rt = FrameSpecFlag_Frame4IdRt | FrameSpecFlag_VertexEffectFrame | + FrameSpecFlag_VertexEffectTexcoordEnabled | + FrameSpecFlag_VertexEffectDotByDotV, + + FrameSpecFlag_Frame4Lb = FrameSpecFlag_Frame4IdLb | FrameSpecFlag_VertexEffectFrame | + FrameSpecFlag_VertexEffectTexcoordEnabled | + FrameSpecFlag_VertexEffectDotByDotV | + FrameSpecFlag_VertexEffectTexcoordAlignBottom, + FrameSpecFlag_Frame4Rb = FrameSpecFlag_Frame4IdRb | FrameSpecFlag_VertexEffectFrame | + FrameSpecFlag_VertexEffectTexcoordEnabled | + FrameSpecFlag_VertexEffectDotByDotU | + FrameSpecFlag_VertexEffectTexcoordAlignRight, + + FrameSpecFlag_FlipHFlip = FrameSpecFlag_VertexEffectTexCoordHFlip, + FrameSpecFlag_FlipVFlip = FrameSpecFlag_VertexEffectTexCoordVFlip, + FrameSpecFlag_FlipR90 = FrameSpecFlag_FlipHFlip | FrameSpecFlag_VertexEffectTexCoordSwap, + FrameSpecFlag_FlipR180 = FrameSpecFlag_FlipHFlip | FrameSpecFlag_FlipVFlip, + FrameSpecFlag_FlipR270 = FrameSpecFlag_FlipVFlip | FrameSpecFlag_VertexEffectTexCoordSwap, + + FrameSpecFlag_Normal = 0x0 +}; + +template +bool EqualsName(const char* pName1, const char* pName2) { + for (int i = 0; i < StrMax; ++i) { + if (pName1[i] != pName2[i]) { + return false; + } else if (pName1[i] == '\0') { + return true; + } + } + return true; +} + +inline bool EqualsResName(const char* pName1, const char* pName2) { + return EqualsName(pName1, pName2); +} + +inline bool EqualsGroupName(const char* pName1, const char* pName2) { + return EqualsName(pName1, pName2); +} + +inline bool EqualsMaterialName(const char* pName1, const char* pName2) { + return EqualsName<28>(pName1, pName2); +} + +inline const char* GetStrTableStr(const void* pStrTable, int index) { + auto pOffsets = static_cast(pStrTable); + auto pStringPool = static_cast(pStrTable); + return &pStringPool[pOffsets[index]]; +} + +class TexCoordArray { +public: + void Initialize(); + bool IsEmpty() const; + void Free(); + void Reserve(int); + int GetSize() const; + void SetSize(int); + const TexCoordQuad* GetArray() const; + void GetCoord(util::Float2*, int) const; + void SetCoord(int, const util::Float2*); + void Copy(const void*, int); + bool CompareCopiedInstanceTest(const TexCoordArray&) const; + +private: + uint8_t m_Cap; + uint8_t m_Count; + + util::Float2 (*m_pData)[4]; +}; + +} // namespace detail +} // namespace ui2d +} // namespace nn diff --git a/include/nn/ui2d/ui2d_ControlCreator.h b/include/nn/ui2d/ui2d_ControlCreator.h new file mode 100644 index 0000000..9e46c1e --- /dev/null +++ b/include/nn/ui2d/ui2d_ControlCreator.h @@ -0,0 +1,57 @@ +#pragma once + +#include +#include + +namespace nn { +namespace ui2d { + +class ResExtUserData; +struct ResExtUserDataList; +class Layout; + +class ControlSrc { +public: + ControlSrc(); + + ControlSrc(const void* pData, const ResExtUserDataList* pUserDataBlock) { + Initialize(pData, pUserDataBlock); + } + + void Initialize(const void*, const ResExtUserDataList*); + const char* GetControlName() const; + const char* GetControlUserName() const; + + int GetFunctionalPaneCount() const { return m_FunctionalPaneCount; } + int GetFunctionalAnimCount() const { return m_FunctionalAnimCount; } + + const char* GetFunctionalAnimParameterName(int) const; + const char* GetFunctionalPaneName(int) const; + const char* FindFunctionalPaneName(const char*) const; + const char* GetFunctionalAnimName(int) const; + const char* FindFunctionalAnimName(const char*) const; + uint16_t GetExtUserDataCount() const; + const ResExtUserData* GetExtUserDataArray() const; + const ResExtUserData* FindExtUserDataByName(const char*) const; + +private: + const char* m_pControlName; + const char* m_pControlUserName; + uint16_t m_FunctionalPaneCount; + uint16_t m_FunctionalAnimCount; + const char* m_pFunctionalPaneNames; + const void* m_pControlFunctionalAnimNameOffests; + const void* m_pControlFunctionalPaneParameterNameOffsets; + const void* m_pControlFunctionalAnimParameterNameOffsets; + const ResExtUserDataList* m_pExtUserDataList; +}; + +class ControlCreator { +public: + virtual ~ControlCreator() = default; + + virtual void CreateControl(gfx::Device*, Layout*, const ControlSrc&) = 0; +}; + +} // namespace ui2d +} // namespace nn diff --git a/include/nn/ui2d/ui2d_DrawInfo.h b/include/nn/ui2d/ui2d_DrawInfo.h new file mode 100644 index 0000000..0b56d80 --- /dev/null +++ b/include/nn/ui2d/ui2d_DrawInfo.h @@ -0,0 +1,167 @@ +#pragma once + +#include +#include +#include + +namespace nn { + +namespace font { + +class GpuBuffer; + +} + +namespace ui2d { + +class DrawInfo; +class GraphicsResource; +class Pane; +class ShaderInfo; + +typedef void (*UpdateUserShaderCallback)(const DrawInfo&, Pane*, void*); +/* newer +typedef bool (*ApplyCaptureTextureFilterCallback)(gfx::CommandBuffer&, const gfx::ColorTargetView*, + const gfx::DescriptorSlot&, + const gfx::DescriptorSlot&, + const gfx::ViewportScissorState&, Pane*, void*); +*/ + +class DrawInfo { +public: + NN_RUNTIME_TYPEINFO_BASE(); + + DrawInfo(); + DrawInfo(const DrawInfo&); + virtual ~DrawInfo(); + DrawInfo& operator=(const DrawInfo&); + void Set(const DrawInfo&); + void ConfigureBeforeDrawing(Layout*); + void ConfigureAfterDrawing(); + const util::MatrixT4x3fType& GetViewMtx() const { return m_ViewMtx; } + void SetViewMtx(const util::MatrixT4x3fType&); + + bool IsLocationAdjustEnabled() const { return m_Flag.isLocationAdjustEnabled; } + + void SetLocationAdjustEnabled(bool); + const util::Float2& GetLocationAdjustScale() const { return m_LocationAdjustScale; } + void SetLocationAdjustScale(const util::Float2&); + bool IsInvisiblePaneCalculated() const { return m_Flag.invisiblePaneCalculateMtx; } + void SetInvisiblePaneCalculated(bool); + bool IsAlphaZeroPaneCalculated() const { return m_Flag.alphaZeroPaneCalculateMtx; } + void SetAlphaZeroPaneCalculated(bool); + bool IsLeftTopWindowOrigin() const; + void SetLeftTopWindowOrigin(bool); + GraphicsResource* GetGraphicsResource() const { return m_pGraphicsResource; } + void SetGraphicsResource(GraphicsResource*); + void SetProjectionMtx(const util::MatrixT4x4fType&); + void SetUi2dConstantBuffer(font::GpuBuffer*); + font::GpuBuffer* GetUi2dConstantBuffer() const; + void SetFontConstantBuffer(font::GpuBuffer*); + font::GpuBuffer* GetFontConstantBuffer() const; + void SetUpdateUserShaderCallback(UpdateUserShaderCallback, void*); + UpdateUserShaderCallback GetUpdateUserShaderCallback() const; + void* GetUpdateUserShaderCallbackUserData() const; + + /* + void SetApplyCaptureTextureFilterCallback(ApplyCaptureTextureFilterCallback, void*); + ApplyCaptureTextureFilterCallback GetApplyCaptureTextureFilterCallback() const; + void* GetApplyCaptureTextureFilterCallbackUserData() const; + */ + + void ResetDrawState(); + void Map(int); + void Unmap(); + void SetGpuAccessBufferIndex(int); + + /* newer + void SetFramebufferTexture(gfx::Texture*, int, int); + const gfx::Texture* GetFramebufferTexture() const; + int GetFramebufferWidth() const; + int GetFramebufferHeight() const; + void SetDefaultViewportScissorInfo(const gfx::ViewportStateInfo&, const gfx::ScissorStateInfo&); + const gfx::ViewportStateInfo& GetDefaultViewportInfo() const; + const gfx::ScissorStateInfo& GetDeafultScissorInfo() const; + const gfx::ScissorStateInfo& GetDefaultScissorInfo() const; + bool IsValidDefaultViewportInfoSet() const; + bool IsValidDefaultScissorInfoSet() const; + */ + + Layout* GetLayout() { return m_pLayout; } + const Layout* GetLayout() const { return m_pLayout; } + void SetLayout(Layout* pLayout) { m_pLayout = pLayout; } + + const util::MatrixT4x4fType& GetProjectionMtx() const; + void LoadProjectionMtx(float (*)[4]); + + const util::MatrixT4x3fType& GetModelViewMtx() const { return m_ModelViewMtx; } + + void SetModelViewMtx(const util::MatrixT4x3fType& m) { + m_ModelViewMtx = m; + m_ModelViewMtxLoaded = false; + } + + int GetTexCoordSrc(int) const; + void SetTexCoordSrc(int, int); + void LoadMtxModelView(float (*)[4]); + void SetupProgram(gfx::CommandBuffer*); + + void ResetVertexBufferState() { m_FirstDraw = true; } + + bool RecordCurrentShader(const ShaderInfo*, uint8_t); + // smo + // void ResetCurrentShader(); + void SetAllowableTextureQuantity(int); + int GetAllowableTextureQuantity() const; + void ResetModelViewMtxLoaded(); + +private: + util::MatrixT4x4fType m_ProjMtx; + util::MatrixT4x3fType m_ViewMtx; + util::MatrixT4x3fType m_ModelViewMtx; + util::Float2 m_LocationAdjustScale; + GraphicsResource* m_pGraphicsResource; + Layout* m_pLayout; + font::GpuBuffer* m_pUi2dConstantBuffer; + font::GpuBuffer* m_pFontConstantBuffer; + + /* newer + gfx::Texture* m_pFramebufferTexture; + uint32_t m_FramebufferWidth; + uint32_t m_FramebufferHeight; + gfx::ViewportStateInfo m_DefaultViewportInfo; + gfx::ScissorStateInfo m_DefaultScissorInfo; + */ + + UpdateUserShaderCallback m_pUpdateUserShaderCallback; + void* m_pUpdateUserShaderCallbackUserData; + + /* newer + ApplyCaptureTextureFilterCallback m_pApplyCaptureTextureFilterCallback; + void* m_pApplyCaptureTextureFilterCallbackUserData; + */ + + int8_t m_TexCoordSrc[3]; + +public: + char filler[3]; + +private: + bool m_ModelViewMtxLoaded; + bool m_FirstDraw; + int8_t m_AllowableTextureQuantity; + + struct Flag { + uint8_t isLocationAdjustEnabled : 1; + uint8_t invisiblePaneCalculateMtx : 1; + uint8_t alphaZeroPaneCalculateMtx : 1; + uint8_t isLeftTopWindowOrigin : 1; + }; + + Flag m_Flag; + const ShaderInfo* m_pCurrentShaderInfo; + uint8_t m_CurrentShaderVariation; +}; + +} // namespace ui2d +} // namespace nn diff --git a/include/nn/ui2d/ui2d_GraphicsResource.h b/include/nn/ui2d/ui2d_GraphicsResource.h new file mode 100644 index 0000000..b74008d --- /dev/null +++ b/include/nn/ui2d/ui2d_GraphicsResource.h @@ -0,0 +1,128 @@ +#pragma once + +#include + +#include +#include +#include +#include +#include +#include +#include + +namespace nn { + +namespace gfx { +class BlendTargetStateInfo; +} // namespace gfx + +namespace ui2d { + +class ResBlendMode; + +enum ShaderId { + ShaderId_Undefined = -1, + ShaderId_NullTexture, + ShaderId_SingleTexture, + ShaderId_DoubleTexture1, + ShaderId_DoubleTexture2, + ShaderId_DoubleTexture3, + ShaderId_DoubleTexture4, + ShaderId_DoubleTexture5, + ShaderId_DoubleTexture6, + ShaderId_DoubleTexture7, + ShaderId_DoubleTexture8, + ShaderId_DoubleTexture9, + ShaderId_DoubleTexture10, + ShaderId_DoubleTexture11, + ShaderId_DoubleIndirectTexture, + ShaderId_MaxShaderId, + ShaderId_ArchiveShader, + ShaderId_DoubleTextureBaseIdx = 2 +}; + +enum PresetBlendStateId { + PresetBlendStateId_Default, + PresetBlendStateId_OpaqueOrAlphaTest, + PresetBlendStateId_Addition, + PresetBlendStateId_Subtraction, + PresetBlendStateId_Multiplication, + PresetBlendStateId_SemitransparencyMaxAlpha, + PresetBlendStateId_MaxPresetBlendStateId, + PresetBlendStateId_None +}; + +enum ArchiveShaderId { + ArchiveShaderId_DetailedCombinerNonSource = 100, + ArchiveShaderId_DetailedCombinerSingleSource, + ArchiveShaderId_DetailedCombinerDoubleSource, + ArchiveShaderId_DetailedCombinerTripleSource, + ArchiveShaderId_DetailedCombinerBaseIdx = 100 +}; + +class GraphicsResource { + NN_NO_COPY(GraphicsResource); + +public: + static const int VertexBufferIndexCount = 6; + static const int VertexAttributeCount = 1; + + GraphicsResource(); + + static size_t CalculateMemoryPoolSize(gfx::Device*, uint32_t); + static size_t CalculateMemoryPoolAlignment(gfx::Device*); + ~GraphicsResource(); + void Setup(gfx::Device*, int); + void Setup(gfx::Device*, int, gfx::MemoryPool*, ptrdiff_t, size_t); + void Setup(gfx::Device*, int, gfx::MemoryPool*, ptrdiff_t, size_t, font::RectDrawer*); + void Setup(gfx::Device*, int, gfx::MemoryPool*, ptrdiff_t, size_t, font::RectDrawer*, float); + void Finalize(gfx::Device*); + bool Initialized() const; + void RegisterCommonSamplerSlot(RegisterSamplerSlot, void*); + void UnregisterCommonSamplerSlot(UnregisterSamplerSlot, void*); + gfx::DescriptorSlot& GetSamplerDescriptorSlot(TexWrap, TexWrap, TexFilter, TexFilter) const; + font::RectDrawer& GetFontDrawer() { return m_pFontDrawer; } + const ShaderInfo* GetCommonShaderInfo() const; + const gfx::Buffer* GetIndexBuffer() const; + const gfx::GpuAddress* GetIndexBufferGpuAddress() const; + size_t GetConstantBufferAlignment() const; + size_t GetVertexBufferAlignment() const; + size_t GetIndexBufferAlignment() const; + gfx::BlendState* GetPresetBlendState(PresetBlendStateId); + static PresetBlendStateId GetPresetBlendStateId(const ResBlendMode*, const ResBlendMode*); + static size_t SetupBlendStateInfo(gfx::BlendState::InfoType*, gfx::BlendTargetStateInfo*, + const ResBlendMode*, const ResBlendMode*); + +private: + void InitializeVertexBuffer(gfx::Device*, gfx::MemoryPool*, ptrdiff_t, size_t); + void ActivateVertexBuffer(gfx::CommandBuffer*) const; + static void GetPresetBlendModeArray(const ResBlendMode**, const ResBlendMode**); + + ShaderInfo m_CommonShaderInfo; + void* m_pUi2dBuildinShader; + void** m_pConstantBufferMemories; + void* m_pBufferMemory; + // removed in smo + void* _unk; + + void* m_pRectShaderBinary; + int32_t m_RectShaderBinarySize; + size_t m_ConstantBufferAlignment; + /* added in smo + size_t m_VertexBufferAlignment; + size_t m_IndexBufferAlignment; + */ + font::RectDrawer m_pFontDrawer; + gfx::MemoryPool m_MemoryPoolForBuffers; + gfx::Buffer m_VertexBuffer; + gfx::GpuAddress m_VertexBufferGpuAddress; + gfx::Buffer m_IndexBuffer; + gfx::GpuAddress m_IndexBufferGpuAddress; + gfx::Sampler* m_pSamplerTable; + gfx::DescriptorSlot* m_pSamplerDescriptorSlotTable; + gfx::BlendState m_PresetBlendState[6]; + bool m_Initialized; + bool m_IsDefaultRectDrawerUsed; +}; +} // namespace ui2d +} // namespace nn diff --git a/include/nn/ui2d/ui2d_Group.h b/include/nn/ui2d/ui2d_Group.h new file mode 100644 index 0000000..59c476b --- /dev/null +++ b/include/nn/ui2d/ui2d_Group.h @@ -0,0 +1,70 @@ +#pragma once + +#include + +namespace nn { +namespace ui2d { + +struct ResGroup; +class Pane; + +struct PaneLink { + util::IntrusiveListNode link; + Pane* pTarget; +}; + +typedef util::IntrusiveList> + PaneLinkList; + +class Group { +public: + Group(); + Group(const char*); + Group(const ResGroup*, Pane*); + Group(const Group&, Pane*); + virtual ~Group(); + + const char* GetName() const { return m_pName; } + PaneLinkList& GetPaneList() { return m_PaneLinkList; } + + void AppendPane(Pane*); + + bool IsUserAllocated() const { return m_UserAllocated != 0; } + void SetUserAllocated(); + + bool CompareCopiedInstanceTest(const Group&) const; + + util::IntrusiveListNode m_Link; + +private: + PaneLinkList m_PaneLinkList; + const char* m_pName; + uint8_t m_UserAllocated; + uint8_t m_Padding[3]; + + const Group& operator=(const Group&); +}; + +typedef util::IntrusiveList> + GroupList; + +class GroupContainer { + NN_NO_COPY(GroupContainer); + +public: + GroupContainer() = default; + ~GroupContainer(); + void AppendGroup(Group*); + + GroupList& GetGroupList() { return m_GroupList; } + + Group* FindGroupByName(const char*); + const Group* FindGroupByName(const char*) const; + +private: + GroupList m_GroupList; +}; + +} // namespace ui2d +} // namespace nn diff --git a/include/nn/ui2d/ui2d_Layout.h b/include/nn/ui2d/ui2d_Layout.h new file mode 100644 index 0000000..34093e7 --- /dev/null +++ b/include/nn/ui2d/ui2d_Layout.h @@ -0,0 +1,414 @@ +/** + * @file Layout.h + * @brief UI Layout implementation. + */ + +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace nn { +namespace ui2d { + +class Animator; +class Pane; +class PaneAnimator; +class Group; +class GroupContainer; +class GroupAnimator; +class GroupArrayAnimator; +class DrawInfo; +struct ResPane; +class ShaderInfo; +class CaptureTexture; +struct ResParts; +struct ResPartsProperty; +struct ResVec2; +struct ResPicture; +class ResCaptureTexture; +class ResCaptureTextureOld; + +typedef util::IntrusiveList< + AnimTransform, util::IntrusiveListMemberNodeTraits> + AnimTransformList; + +typedef util::IntrusiveList> + PartsPaneList; + +class Layout { +public: + NN_RUNTIME_TYPEINFO_BASE(); + + static const int LayoutNameLengthMax = 64; + static const size_t DefaultAligment = 4; + static const size_t AlignmentForPaneInstance = 16; + + static AlignedAllocateFunctionWithUserData GetAllocateFunction(); + static FreeFunctionWithUserData GetFreeFunction(); + static void* GetUserDataForAllocator(); + static void SetAllocator(AlignedAllocateFunctionWithUserData, FreeFunctionWithUserData, void*); + static void* AllocateMemory(size_t size, size_t alignment = DefaultAligment); + + // smo + // static void* AllocateMemory(size_t size); + static void FreeMemory(void*); + + Layout(); + Layout(gfx::Device*, const Layout&, Layout*, const char*); + Layout(gfx::Device*, const Layout&, Layout*, const char*, const char*); + Layout(gfx::Device*, const Layout&, Layout*); + Layout(gfx::Device*, const Layout&); + + virtual ~Layout(); + void Finalize(gfx::Device*); + + struct BuildOption { + bool isRootPaneParts; + GetUserShaderInformationFromUserData pGetUserShaderInformationFromUserDataCallback; + void* pGetUserShaderInformationFromUserDataCallbackUserData; + + void SetDefault(); + }; + + /* newer + struct LayoutBuildContext { + BuildResSet buildResSet; + BuildArgSet buildArgSet; + int index; + const void* pData; + const ResExtUserDataList* pResExtUserDataList; + uint32_t kind; + int indexNext; + const void* pDataNext; + Pane* pLastBuiltPane; + int groupNestLevel; + }; + + static void FindResPaneByName(const ResPane**, const ResExtUserDataList**, const void*, + const char*, const ResPane*); + */ + bool Build(BuildResultInformation*, gfx::Device*, ResourceAccessor*, ControlCreator*, + TextSearcher*, const void*, const BuildOption&, bool); + bool Build(BuildResultInformation*, gfx::Device*, ResourceAccessor*, ControlCreator*, + TextSearcher*, const void*, const BuildOption&); + bool Build(BuildResultInformation*, gfx::Device*, ResourceAccessor*, ControlCreator*, + const void*); + bool Build(BuildResultInformation*, gfx::Device*, ResourceAccessor*, const void*); + bool BuildWithName(BuildResultInformation*, gfx::Device*, ResourceAccessor*, ControlCreator*, + TextSearcher*, const BuildOption&, const char*, bool); + bool BuildWithName(BuildResultInformation*, gfx::Device*, ResourceAccessor*, ControlCreator*, + TextSearcher*, const BuildOption&, const char*); + bool BuildWithName(BuildResultInformation*, gfx::Device*, ResourceAccessor*, const char*); + void CalculateGlobalMatrix(DrawInfo&); + void CalculateGlobalMatrix(DrawInfo&, bool); + + template // 594 + T* CreateAnimTransform() { + T* const pAnimTrans = AllocateAndConstruct(); + if (pAnimTrans) { + m_AnimTransList.push_back(*pAnimTrans); + } + return pAnimTrans; + } + + template // 625 + T* CreateAnimTransform(gfx::Device* pDevice, const void* pAnimResource) { + return CreateAnimTransform(pDevice, AnimResource(pAnimResource)); + } + + template // 649 + T* CreateAnimTransform(gfx::Device* pDevice, const AnimResource& animRes) { + const ResAnimationBlock* const pAnimBlock = animRes.GetResourceBlock(); + if (!pAnimBlock) { + return nullptr; + } + + T* const pAnimTrans = CreateAnimTransform(); + if (pAnimTrans) { + pAnimTrans->SetResource(pDevice, m_pResourceAccessor, pAnimBlock); + } + return pAnimTrans; + } + + template // 688 + T* CreateAnimTransform(gfx::Device* pDevice, const char* pTagName) { + const void* pPtr = GetAnimResourceData(pTagName); + return CreateAnimTransform(pDevice, pPtr); + } + + AnimTransformBasic* CreateAnimTransformBasic(); + AnimTransformBasic* CreateAnimTransformBasic(gfx::Device*, const void*); + AnimTransformBasic* CreateAnimTransformBasic(gfx::Device*, const AnimResource&); + AnimTransformBasic* CreateAnimTransformBasic(gfx::Device*, const char*); + PaneAnimator* CreatePaneAnimator(gfx::Device*, const char*, Pane*, bool); + PaneAnimator* CreatePaneAnimator(gfx::Device*, const char*, Pane*); + PaneAnimator* CreatePaneAnimator(gfx::Device*, const char*, const char*, bool); + PaneAnimator* CreatePaneAnimator(gfx::Device*, const char*, const char*); + GroupAnimator* CreateGroupAnimator(gfx::Device*, const char*, Group*, bool); + GroupAnimator* CreateGroupAnimator(gfx::Device*, const char*, Group*); + GroupAnimator* CreateGroupAnimator(gfx::Device*, const char*, const char*, bool); + GroupAnimator* CreateGroupAnimator(gfx::Device*, const char*, const char*); + GroupAnimator* CreateGroupAnimator(gfx::Device*, const char*, bool); + GroupAnimator* CreateGroupAnimator(gfx::Device*, const char*); + GroupAnimator* CreateGroupAnimatorWithIndex(gfx::Device*, const char*, int, bool); + GroupAnimator* CreateGroupAnimatorWithIndex(gfx::Device*, const char*, int); + GroupArrayAnimator* CreateGroupArrayAnimator(gfx::Device*, const char*, bool); + GroupArrayAnimator* CreateGroupArrayAnimator(gfx::Device*, const char*); + Animator* CreateGroupAnimatorAuto(gfx::Device*, const char*, bool); + Animator* CreateGroupAnimatorAuto(gfx::Device*, const char*); + virtual void DeleteAnimTransform(AnimTransform*); + virtual void BindAnimation(AnimTransform*); + virtual void UnbindAnimation(AnimTransform*); + virtual void UnbindAnimation(Pane*); + virtual void UnbindAllAnimation(); + virtual bool BindAnimationAuto(gfx::Device*, const AnimResource&); + virtual void Animate(); + virtual void UpdateAnimFrame(float); + virtual void AnimateAndUpdateAnimFrame(float); + const void* GetAnimResourceData(const char*) const; + + // removed in smo + virtual void CalculateMtx(DrawInfo& info, bool b) { CalculateImpl(info, b); } + + void Calculate(DrawInfo&); + void Calculate(DrawInfo&, bool); + virtual void Draw(DrawInfo&, gfx::CommandBuffer&); + void DrawCaptureTexture(gfx::Device*, DrawInfo&, gfx::CommandBuffer&); + bool IsPartsLayout() const; + + Pane* GetRootPane() const { return m_pRootPane; } + GroupContainer* GetGroupContainer() const { return m_pGroupContainer; } + + const Size& GetLayoutSize() const; + const ResourceAccessor* GetResourceAccessor() const; + ResourceAccessor* GetResourceAccessor(); + const font::Rectangle GetLayoutRect() const; + const char* GetName() const; + virtual void SetTagProcessor(TextBox::TagProcessor*); + + const AnimTransformList& GetAnimTransformList() const { return m_AnimTransList; } + AnimTransformList& GetAnimTransformList() { return m_AnimTransList; } + + const PartsPaneList& GetPartsPaneList() const; + PartsPaneList& GetPartsPaneList(); + const ResExtUserDataList* GetExtUserDataList() const; + const void* GetLayoutResource() const; + const ShaderInfo* AcquireArchiveShader(gfx::Device*, const char*) const; + int GetCaptureTextureCount() const; + Parts* FindPartsPaneByName(const char*); + const Parts* FindPartsPaneByName(const char*) const; + const CaptureTexture* FindCaptureTextureByPanePtr(const Pane*) const; + void ResetFirstFrameCaptureUpdatdFlag(); + void SetGetUserShaderInformationCallback(GetUserShaderInformationFromUserData, void*); + + void SetGetUserShaderInformationCallback(GetUserShaderInformationFromUserData pGet) { + m_pGetUserShaderInformationFromUserDataCallback = pGet; + } + + static void SetRenderTargetTextureManagementCallback(CreateRenderTargetTextureCallback, + DestroyRenderTargetTextureCallback, void*); + static void + SetRenderTargetTextureResourceManagementCallback(CreateRenderTargetTextureResourceCallback, + DestroyRenderTargetTextureResourceCallback, + void*); + static CreateRenderTargetTextureCallback GetCreateRenderTargetTextureCallback(); + static DestroyRenderTargetTextureCallback GetDestroyRenderTargetTextureCallback(); + static CreateRenderTargetTextureResourceCallback GetCreateRenderTargetTextureResourceCallback(); + static DestroyRenderTargetTextureResourceCallback + GetDestroyRenderTargetTextureResourceCallback(); + static void* GetRenderTargetTextureCallbackUserData(); + bool CompareCopiedInstanceTest(const Layout&) const; + + template + static T* AllocateAndConstruct(Params... params) { + if (void* pMem = AllocateMemory(sizeof(T))) { + return new (pMem) T(params...); + } + return nullptr; + } + + template + static T* AllocateAndConstructAligned(size_t alignment, Params... params) { + if (void* pMem = AllocateMemory(sizeof(T), alignment)) { + return new (pMem) T(params...); + } + return nullptr; + } + + template // 2159 + static T* NewArray(int count) { + if (void* pMem = AllocateMemory(sizeof(T) * count)) { + auto objAry = static_cast(pMem); + + for (int i = 0; i < count; ++i) { + new (&objAry[i]) T(); + } + + return objAry; + } + + return nullptr; + } + + template // 2184 + static void DeleteObj(T* pObj) { + if (pObj) { + pObj->~T(); + FreeMemory(pObj); + } + } + + template // 2201 + static void DeleteArray(T*, int); + + template // 2220 + static void DeletePrimArray(T* objAry) { + if (objAry) { + FreeMemory(objAry); + } + } + + /* newer + class PartsBuildDataAccessor { + public: + PartsBuildDataAccessor(const ResParts*); + const ResPartsProperty* FindPartsPropertyFromName(const char*) const; + const void* GetPropertyResBlock(const ResPartsProperty*) const; + const ResExtUserDataList* GetExtUserDataListResBlock(bool*, const ResPartsProperty*) const; + const ResPartsPaneBasicInfo* GetPartsPaneBasicInfoResBlock(const ResPartsProperty*) const; + bool IsOverwriting() const; + + private: + int32_t m_PropertyCount; + const ResPartsProperty* m_pPropertyTable; + const ResParts* m_pResParts; + }; + */ + + class PartsBuildDataSet { + public: + PartsBuildDataSet(Parts*, const ResParts*, const BuildResSet*, const ResVec2*); + + Parts* GetPartsPane() const { return m_pPartsPane; } + + const util::Float2& GetMagnify() const { return m_Magnify; } + const BuildResSet* GetPropertyBuildResSet() const { return m_pPropertyBuildResSet; } + const ResPartsProperty* FindPartsPropertyFromName(const char*) const; + const void* GetPropertyResBlock(const ResPartsProperty*) const; + const ResExtUserDataList* GetExtUserDataListResBlock(bool*, const ResPartsProperty*) const; + const ResPartsPaneBasicInfo* GetPartsPaneBasicInfoResBlock(const ResPartsProperty*) const; + // newer + // bool IsOverwriting() const; + + private: + // newer + // PartsBuildDataAccessor m_PartsBuildDataAccessor; + int32_t m_PropertyCount; + const ResPartsProperty* m_pPropertyTable; + Parts* m_pPartsPane; + const ResParts* m_pResParts; + const BuildResSet* m_pPropertyBuildResSet; + util::Float2 m_Magnify; + }; + +protected: + virtual bool BuildImpl(BuildResultInformation*, gfx::Device*, const void*, ResourceAccessor*, + const BuildArgSet&, const PartsBuildDataSet*); + /*newer + void PrepareBuildArgSet(BuildArgSet&, const BuildArgSet&, const PartsBuildDataSet*); + void SetByResLayout(LayoutBuildContext&); + void BuildControl(LayoutBuildContext&, gfx::Device*); + void BuildPaneByResPane(LayoutBuildContext&, BuildResultInformation*, gfx::Device*, + const PartsBuildDataSet*); + void BuildGroup(LayoutBuildContext&); + void BuildAlignment(LayoutBuildContext&); + */ + + virtual Pane* BuildPartsImpl(BuildResultInformation*, gfx::Device*, const void*, + const PartsBuildDataSet*, BuildArgSet&, BuildResSet&, + const uint32_t); + void CopyLayoutInstanceImpl(gfx::Device*, const Layout&, Layout*, const char*); + // newer + // void CopyLayoutInstanceImpl(gfx::Device*, const Layout&, Layout*, const char*, const char*); + virtual Pane* BuildPaneObj(BuildResultInformation*, gfx::Device*, uint32_t, const void*, + const void*, const BuildArgSet&); + virtual Layout* BuildPartsLayout(BuildResultInformation*, gfx::Device*, const char*, + const PartsBuildDataSet&, const BuildArgSet&); + + void SetRootPane(Pane* pPane) { m_pRootPane = pPane; } + void SetGroupContainer(GroupContainer* pGroupContainer) { m_pGroupContainer = pGroupContainer; } + + void SetLayoutSize(const Size&); + void SetName(const char* pName) { m_Name = pName; } + void SetResourceAccessor(ResourceAccessor*); + const void* GetLayoutResourceData(const char*) const; + GroupArrayAnimator* CreateGroupArrayAnimator(gfx::Device*, const AnimResource&, bool); + virtual void CalculateImpl(DrawInfo&, bool); + +private: + /* newer + template // 2493 + void AllocateCaptureTexture(const ResCaptureTextureList*, ResourceAccessor*, const char*); + + template // 2495 + void InitializeCaptureTextureList(gfx::Device*, const ResCaptureTextureList*, + const PartsBuildDataSet*); + */ + + const char* GetCaptureTextureName(const ResCaptureTextureList*, const ResCaptureTexture*); + const char* GetCaptureTextureName(const ResCaptureTextureList*, const ResCaptureTextureOld*); + const char* GetCaptureTextureReferencedPaneName(const ResCaptureTextureList*, + const ResCaptureTexture*); + const char* GetCaptureTextureReferencedPaneName(const ResCaptureTextureList*, + const ResCaptureTextureOld*); + + static AlignedAllocateFunctionWithUserData g_pAllocateFunction; + static FreeFunctionWithUserData g_pFreeFunction; + static void* g_pUserDataForAllocator; + + /* newer + static CreateRenderTargetTextureCallback g_pCreateRenderTargetTextureCallback; + static DestroyRenderTargetTextureCallback g_pDestroyRenderTargetTextureCallback; + static CreateRenderTargetTextureResourceCallback g_pCreateRenderTargetTextureResourceCallback; + static DestroyRenderTargetTextureResourceCallback g_pDestroyRenderTargetTextureResourceCallback; + static void* g_pRenderTargetTextureCallbackUserData; + static size_t g_CosntantBufferReservedSize; + */ + + AnimTransformList m_AnimTransList; + Pane* m_pRootPane; + GroupContainer* m_pGroupContainer; + Size m_LayoutSize; + const char* m_Name; + const ResExtUserDataList* m_pResExtUserDataList; + ResourceAccessor* m_pResourceAccessor; + PartsPaneList m_PartsPaneList; + + GetUserShaderInformationFromUserData m_pGetUserShaderInformationFromUserDataCallback; + + /* smo + void* m_pGetUserShaderInformationFromUserDataCallbackUserData; + */ + + /* later version + struct CaptureTextureList { + int count; + CaptureTexture* pCaptureTextures; + }; + + CaptureTextureList* m_pCaptureTextureList; + */ + const Layout& operator=(const Layout&); +}; +} // namespace ui2d +} // namespace nn diff --git a/include/nn/ui2d/ui2d_Material.h b/include/nn/ui2d/ui2d_Material.h new file mode 100644 index 0000000..ccc8a5f --- /dev/null +++ b/include/nn/ui2d/ui2d_Material.h @@ -0,0 +1,563 @@ +/** + * @file Material.h + * @brief UI Material implementation. + */ + +#pragma once + +#include +#include +#include +#include +#include + +namespace nn { +namespace ui2d { + +class AnimTransform; +struct BuildResultInformation; +struct UserShaderInformation; +class ResourceAcessor; +struct ResMaterial; +class TexMap; + +struct MaterialCopyContext { + gfx::Device* pDevice; + const CaptureTextureCopyInfo* pCaptureTextureCopyInfo; + ResourceAccessor* pResAccessor; + const char* pNewRootName; +}; + +namespace detail { + +struct MatMemCount { + uint32_t texMap : 2; + uint32_t texSrt : 2; + uint32_t texCoordGen : 2; + uint32_t tevStage : 3; + uint32_t alpComp : 1; + uint32_t blendMode : 2; + uint32_t indirectParameter : 1; + uint32_t projectionTexGen : 2; + uint32_t fontShadowParameter : 1; + uint32_t detailedCombinerParameter : 1; + uint32_t combinerUserShaderParameter : 1; + + /* remove before merge, cheatsheet + texMap = 0x3, + texSrt = 0xC, + texCoordGen = 0x30, + tevStage = 0x1C0, + alpComp = 0x200, + blendMode = 0xC00, + indirectParameter = 0x1000, + projectionTexGen = 0x6000, + fontShadowParameter = 0x8000, + detailedCombinerParameter = 0x10000, + combinerUserShaderParameter = 0x20000, + */ +}; + +// todo: confirm this math + +// 16 * (v17 & 3) +inline int CalculateOffsetTexSrtArray(const MatMemCount& bitCount) { + return bitCount.texMap * sizeof(TexMap); +} + +// 20 * ((m_MemCap >> 2) & 3) +inline int CalculateOffsetTexCoordGenArray(const MatMemCount& bitCount) { + return CalculateOffsetTexSrtArray(bitCount) + (bitCount.texSrt * sizeof(ResTexSrt)); +} + +// (m_MemCap & 0x30) +inline int CalculateOffsetAlphaCompare(const MatMemCount& bitCount) { + return CalculateOffsetTexCoordGenArray(bitCount) + + (bitCount.texCoordGen * sizeof(ResTexCoordGen)); +} + +// (m_MemCap >> 6) & 8 +inline int CalculateOffsetBlendMode(const MatMemCount& bitCount) { + return CalculateOffsetAlphaCompare(bitCount) + (bitCount.alpComp * sizeof(ResAlphaCompare)); +} + +// (m_MemCap >> 8) & 0xC +inline int CalculateOffsetIndirectParameter(const MatMemCount& bitCount) { + return CalculateOffsetBlendMode(bitCount) + (bitCount.blendMode * sizeof(ResBlendMode)); +} + +// -((m_MemCap >> 12) & 1) & 0xC +inline int CalculateOffsetTevStageArray(const MatMemCount& bitCount) { + return CalculateOffsetIndirectParameter(bitCount) + + (bitCount.indirectParameter * sizeof(ResIndirectParameter)); +} + +// (m_MemCap >> 4) & 0x1C +inline int CalculateOffsetProjectionTexGen(const MatMemCount& bitCount) { + return CalculateOffsetTevStageArray(bitCount) + (bitCount.tevStage * sizeof(ResTevStage)); +} + +// 20 * ((m_MemCap >> 2) & 3) +inline int CalculateOffsetFontShadowParameter(const MatMemCount& bitCount) { + return CalculateOffsetProjectionTexGen(bitCount) + + (bitCount.projectionTexGen * sizeof(ResProjectionTexGenParameters)); +} + +inline int CalculateOffsetDetailedCombinerStageInfo(const MatMemCount& bitCount) { + return CalculateOffsetFontShadowParameter(bitCount) + + (bitCount.fontShadowParameter * sizeof(ResFontShadowParameter)); +} + +inline int CalculateOffsetDetailedCombinerStage(const MatMemCount& bitCount) { + return CalculateOffsetDetailedCombinerStageInfo(bitCount); +} + +inline int CaluculateOffsetCombinerUserShader(const MatMemCount& bitCount) { + return CalculateOffsetDetailedCombinerStage(bitCount); +} + +} // namespace detail + +class Material { + enum Flags { + Flags_UserAllocated, + Flags_TextureOnly, + Flags_ThresholdingAlphaInterpolation, + Flags_BlackColorFloat, + Flags_WhiteColorFloat, + Flags_DynamicAllocatedColorData, + Flags_Use2ForShaderVariationCountPerBlend, + Flags_UseDetailedCombinerWithVariationVariable, + Flags_MaxFlags + }; + +public: + Material(); + Material(BuildResultInformation*, gfx::Device*, const ResMaterial*, const ResMaterial*, + const BuildArgSet&); + Material(BuildResultInformation*, gfx::Device*, const ResMaterial*, const ResMaterial*, + const BuildArgSet&, CaptureTextureCopyInfo*); + Material(const Material&, gfx::Device*); + Material(const Material&, MaterialCopyContext&); + + void CopyMaterialImpl(const Material&, MaterialCopyContext&); + virtual ~Material(); + void Finalize(gfx::Device*); + + bool ReserveMem(int, int, int, int, bool, int, bool, int, bool, bool, bool); + bool ReserveMem(int, int, int, int, bool, int, bool, int, bool, bool); + bool ReserveMem(int, int, int, int, bool, int, bool, int, bool); + bool ReserveMem(int, int, int, int, bool, int, bool, int); + bool ReserveMem(int, int, int, int, bool, int, bool); + bool ReserveMem(int, int, int, int, bool, int); + bool ReserveMem(int, int, int, int, bool); + bool ReserveMem(int, int, int, int); + bool ReserveMem(int, int, int); + uint8_t GetTexMapCap() const { return m_MemCap.texMap; } + uint8_t GetTexSrtCap() const { return m_MemCap.texSrt; } + uint8_t GetTexCoordGenCap() const; + uint8_t GetTevStageCap() const; + bool IsAlphaCompareCap() const { return m_MemCap.alpComp; } + bool IsBlendModeCap() const; + bool IsBlendModeAlphaCap() const; + bool IsIndirectParameterCap() const { return m_MemCap.indirectParameter; } + bool IsFontShadowParameterCap() const { return m_MemCap.fontShadowParameter; } + bool UseDetailedCombinerCap() const { return m_MemCap.detailedCombinerParameter; } + + bool UseCombinerUserShaderCap() const; + bool IsWhiteColorFloat() const; + bool IsInterpolateColorFloat(InterpolateColor type) const; + + const char* GetName() const { return m_pName; } + + void SetName(const char*); + bool GetTextureOnly() const; + void SetTextureOnly(bool); + bool GetThresholdingAlphaInterpolation() const; + void SetThresholdingAlphaInterpolation(bool); + ShaderId GetShaderId() const; + void SetShaderId(ShaderId); + bool IsUserShaderAssigned() const; + + uint8_t GetTexMapCount() const { return m_MemCount.texMap; } + + void SetTexMapCount(uint8_t); + uint8_t GetTexCoordGenCount() const; + void SetTexCoordGenCount(uint8_t); + uint8_t GetTexSrtCount() const; + void SetTexSrtCount(uint8_t); + static void CalculateTextureMtx(float (*)[3], const ResTexSrt&, const TexMap&); + static void CalculateIndirectMtx(float (*)[3], const float, const ResVec2&); + + const TexMap& GetTexMap(int) const; + void AppendTexMap(const TextureInfo&); + + void SetTexMap(int idx, const TextureInfo* pTexInfo) { + GetTexMapArray()[idx].SetTextureInfo(pTexInfo); + } + + void SetTexMapWrapMode(int, TexWrap, TexWrap); + void SetTexMapFilter(int, TexFilter, TexFilter); + + const ResTexSrt& GetTexSrt(int) const; + void SetTexSrt(int, const ResTexSrt&); + const ResTexCoordGen& GetTexCoordGen(int) const; + void SetTexCoordGen(int, const ResTexCoordGen&); + uint8_t GetProjectionTexGenCount() const; + void SetProjectionTexGenCount(uint8_t); + float GetTexSrtElement(int, int) const; + + void SetTexSrtElement(int idx, int elementIdx, float value) { + auto const srtAny = util::BytePtr(GetTexSrtArray(), idx * sizeof(ResTexSrt)).Get(); + srtAny[elementIdx] = value; + } + + uint8_t GetTevStageCount() const; + void SetTevStageCount(uint8_t); + const util::Unorm8x4& GetColor(int) const; + const util::Float4& GetColorAsFloat(int) const; + void GetColorWithFloatConversion(util::Float4&, int) const; + void SetColor(int, const util::Unorm8x4&); + void SetColor(int, const util::Float4&); + int GetColorElement(int) const; + float GetColorElementFloat(int) const; + + void SetColorElement(int colorType, int value) { + if (colorType >= AnimTargetMatColor_MaxAnimTargetMatColor) { + return; + } + + uint32_t idx = colorType / 4; + if (idx < 2) { + switch (colorType % 4) { + case 0: + m_Colors.byteColor[idx].v[0] = value; + break; + case 1: + m_Colors.byteColor[idx].v[1] = value; + break; + case 2: + m_Colors.byteColor[idx].v[2] = value; + break; + case 3: + m_Colors.byteColor[idx].v[3] = value; + break; + } + } else if (idx < 7) { + if (UseDetailedCombinerCap()) { + ResDetailedCombinerStageInfo* pInfo = GetDetailedCombinerStageInfoPtr(); + + idx -= 2; + ResColor color = pInfo->GetConstantColor(idx); + + switch (colorType % 4) { + case 0: + color.r = value; + break; + case 1: + color.g = value; + break; + case 2: + color.b = value; + break; + case 3: + color.a = value; + break; + } + + pInfo->SetConstantColor(idx, color); + } + } + } + + void SetColorElementFloat(int colorType, float value) { + colorType -= AnimTargetMatColor_MaxAnimTargetMatColor; + + uint32_t idx = colorType / 4; + if (idx < 2) { + switch (colorType % 4) { + case 0: + m_Colors.pFloatColor[idx].v[0] = value; + break; + case 1: + m_Colors.pFloatColor[idx].v[1] = value; + break; + case 2: + m_Colors.pFloatColor[idx].v[2] = value; + break; + case 3: + m_Colors.pFloatColor[idx].v[3] = value; + break; + default: + break; + } + } + } + + void SetIndirectSrtElement(int eleIdx, float value) { + auto const srtAny = util::BytePtr(GetIndirectParameterPtr()).Get(); + srtAny[eleIdx] = value; + } + + const ResTevStage& GetTevStage(int) const; + void SetTevStage(int, const ResTevStage&); + const ResDetailedCombinerStage& GetDetailedCombinerStage(int) const; + void SetDetailedCombinerStage(int, const ResDetailedCombinerStage&); + const ResColor GetConstantColor(int) const; + void SetConstantColor(int, util::Unorm8x4); + ResDetailedCombinerStage::ConstColorSelect GetBufferColorSelectRgb() const; + void SetBufferColorSelectRgb(ResDetailedCombinerStage::ConstColorSelect); + ResDetailedCombinerStage::ConstColorSelect GetBufferColorSelAlpha() const; + void SetBufferColorSelAlpha(ResDetailedCombinerStage::ConstColorSelect); + + const ResAlphaCompare& GetAlphaCompare() const { return *GetAlphaComparePtr(); } + void SetAlphaCompare(const ResAlphaCompare& value) { *GetAlphaComparePtr() = value; } + + const ResBlendMode& GetBlendMode() const; + void SetBlendMode(ResBlendMode); + const ResBlendMode& GetBlendModeAlpha() const; + void SetBlendModeAlpha(ResBlendMode); + void InitializeBlendInformation(gfx::Device*); + void FinalizeBlendInformation(gfx::Device*); + const ResIndirectParameter& GetIndirectParameter() const; + void SetIndirectParameter(const ResIndirectParameter&); + void SetProjectionTexGenParameters(int, const ResProjectionTexGenParameters&); + void SetProjectionTexGenParamaters(int, const ResProjectionTexGenParameters&); + const ResProjectionTexGenParameters& GetProjectionTexGenParameters(int) const; + const ResProjectionTexGenParameters& GetProjectionTexGenParamaters(int) const; + void SetFontShadowParameterCount(uint8_t); + const ResFontShadowParameter& GetFontShadowParameter() const; + void SetFontShadowParameter(const ResFontShadowParameter&); + + void SetFontShadowParameterElement(int eleIdx, uint8_t value) { + auto const elements = util::BytePtr(GetFontShadowParameterPtr()).Get(); + elements[eleIdx] = value; + } + + virtual void BindAnimation(AnimTransform*); + virtual void UnbindAnimation(AnimTransform*); + bool IsUserAllocated() const; + void SetUserAllocated(); + virtual void SetupGraphics(DrawInfo&, uint8_t, ShaderVariation, bool, + const util::MatrixT4x3fType&, const Size*, const ResExtUserData*, + uint16_t); + void SetupSubmaterialOf_TextureMatrix(DrawInfo&, const util::MatrixT4x3fType&, const Size*); + void SetupSubmaterialOf_TextureMatrix(DrawInfo&, const util::MatrixT4x3fType&); + void SetupSubmaterialOf_TextureProjectionMatrix(DrawInfo&, const util::MatrixT4x3fType&, + const Size*, + const ResProjectionTexGenParameters&, + int) const; + void SetRcpTexSize(const DrawInfo&) const; + void SetupSubmaterialOf_Texture(DrawInfo&, gfx::CommandBuffer&) const; + void SetupSubmaterialOf_Tev(DrawInfo&, const ResExtUserData*, uint16_t, const Size*) const; + void SetupSubmaterialOf_DetailedCombiner(DrawInfo&) const; + void SetupSubmaterialOf_CombinerUserShader(DrawInfo&, const ResExtUserData*, uint16_t, + const Size*) const; + void SetAllowableTextureQuantity(const DrawInfo&); + + struct ConstantBufferForVertexShader { + float projection[4][4]; + float modelView[3][4]; + float texMtx0XZ[4]; + float texMtx0YW[4]; + float texMtx1XZ[4]; + float texMtx1YW[4]; + float texMtx2XZ[4]; + float texMtx2YW[4]; + float color[4]; + float vertexTexCoord0[4][4]; + float vertexTexCoord1[4][4]; + float vertexTexCoord2[4][4]; + float frameSize[4]; + float paneSize[2]; + float padding0[2]; + float rcpTexSize0[4]; + float vertexColor[4][4]; + float transform[4]; + int generatingTexCoord[3]; + int frameSpec; + }; + + struct ConstantBufferForPixelShader { + float interpolateWidth[4]; + float interpolateOffset[4]; + float indirectMtx0[4]; + float indirectMtx1[4]; + float vertexColor[4][4]; + int textureMode; + int colorEffectMode; + float padding0[2]; + }; + + struct ConstantBufferForDetailedCombinerPixelShader { + int stageCountMax; + float padding1[3]; + float constantColor[7][4]; + int stage_bit[6][4]; + }; + + struct ConstantBufferForCombinerUserShaderPixelShader { + float fixedZero; + float paneWidth; + float paneHeight; + int padding[1]; + float constantColor[7][4]; + float modelViewMatrix[3][4]; + float modelMatrix[3][4]; + float viewMatrix[3][4]; + float cameraPosition[3]; + float padding2[1]; + int userData_int[4]; + int userData_ivec2[4][4]; + int userData_rgba[4][4]; + float userData_float[4]; + float userData_vec2[4][4]; + float userData_vec3[4][4]; + }; + + void AllocateConstantBuffer(DrawInfo&); + void SetupBlendState(const DrawInfo*); + void* GetConstantBufferForUserVertexShader(const DrawInfo&) const; + void* GetConstantBufferForUserPixelShader(const DrawInfo&) const; + void* GetConstantBufferForUserGeometryShader(const DrawInfo&) const; + ConstantBufferForDetailedCombinerPixelShader* + GetConstantBufferForDetailedCombinerPixelShader(const DrawInfo&) const; + ConstantBufferForCombinerUserShaderPixelShader* + GetConstantBufferForCombinerUserShaderPixelShader(const DrawInfo&) const; + ConstantBufferForVertexShader* GetConstantBufferForVertexShader(const DrawInfo&) const; + ConstantBufferForPixelShader* GetConstantBufferForPixelShader(const DrawInfo&) const; + void SetCommandBuffer(gfx::CommandBuffer&, DrawInfo&) const; + void ApplyVertexShaderConstantBuffer(gfx::CommandBuffer&, DrawInfo&) const; + void ApplyGeometryShaderConstantBuffer(gfx::CommandBuffer&, DrawInfo&) const; + void ApplyPixelShaderConstantBuffer(gfx::CommandBuffer&, DrawInfo&) const; + void ApplyPixelShaderConstantBufferDefault(gfx::CommandBuffer&, DrawInfo&) const; + void ApplyPixelShaderDetailedCombinerConstantBuffer(gfx::CommandBuffer&, DrawInfo&) const; + void ApplyPixelShaderCombinerUserShaderConstantBuffer(gfx::CommandBuffer&, DrawInfo&) const; + void SetCommandBufferOnlyBlend(gfx::CommandBuffer&) const; + void SetShader(gfx::CommandBuffer&) const; + void EnableAlphaTest(gfx::CommandBuffer&) const; + void DisableAlphaTest() const; + int GetConstantBufferSlotForVertexShader() const; + bool CompareCopiedInstanceTest(const Material&) const; + const ShaderInfo* GetShaderInfo() const; + uint8_t GetShaderVariation() const; + +protected: + const TexMap* GetTexMapArray() const; + + TexMap* GetTexMapArray() { return util::BytePtr(m_pMem).Get(); } + + const ResTexSrt* GetTexSrtArray() const; + + ResTexSrt* GetTexSrtArray() { + return util::BytePtr(m_pMem, detail::CalculateOffsetTexSrtArray(m_MemCap)).Get(); + } + + const ResTexCoordGen* GetTexCoordGenArray() const; + ResTexCoordGen* GetTexCoordGenArray(); + + const ResAlphaCompare* GetAlphaComparePtr() const { + return util::ConstBytePtr(m_pMem, detail::CalculateOffsetAlphaCompare(m_MemCap)) + .Get(); + } + + ResAlphaCompare* GetAlphaComparePtr() { + return util::BytePtr(m_pMem, detail::CalculateOffsetAlphaCompare(m_MemCap)) + .Get(); + } + + const ResBlendMode* GetBlendModePtr() const; + ResBlendMode* GetBlendModePtr(); + const ResBlendMode* GetBlendModeAlphaPtr() const; + ResBlendMode* GetBlendModeAlphaPtr(); + const ResIndirectParameter* GetIndirectParameterPtr() const; + + ResIndirectParameter* GetIndirectParameterPtr() { + return util::BytePtr(m_pMem, detail::CalculateOffsetIndirectParameter(m_MemCap)) + .Get(); + } + + ResDetailedCombinerStageInfo* GetDetailedCombinerStageInfoParameterPtr(); + ResDetailedCombinerStage* GetDetailedCombinerStageParameterPtr(); + const ResProjectionTexGenParameters* GetProjectionTexGenArray() const; + ResProjectionTexGenParameters* GetProjectionTexGenArray(); + const ResTevStage* GetTevStageArray() const; + ResTevStage* GetTevStageArray(); + const ResFontShadowParameter* GetFontShadowParameterPtr() const; + + ResFontShadowParameter* GetFontShadowParameterPtr() { + return util::BytePtr(m_pMem, detail::CalculateOffsetFontShadowParameter(m_MemCap)) + .Get(); + } + + int GetProjectionTexGenParametersIdxFromTexCoordGenIdx(int) const; + int GetProjectionTexGenParamatersIdxFromTexCoordGenIdx(int) const; + + const ResDetailedCombinerStageInfo* GetDetailedCombinerStageInfoPtr() const; + + ResDetailedCombinerStageInfo* GetDetailedCombinerStageInfoPtr() { + return util::BytePtr(m_pMem, detail::CalculateOffsetDetailedCombinerStageInfo(m_MemCap)) + .Get(); + } + + const ResDetailedCombinerStage* GetDetailedCombinerStageAry() const; + ResDetailedCombinerStage* GetDetailedCombinerStageAry(); + ResCombinerUserShader* GetCombinerUserShaderPtr(); + const ResCombinerUserShader* GetCombinerUserShaderPtr() const; + +private: + struct UserShaderConstantBufferInformation { + uint32_t m_ConstantBufferExtendAreaSizeForVertexShader; + uint32_t m_ConstantBufferExtendAreaSizeForPixelShader; + uint32_t m_ConstantBufferExtendAreaSizeForGeometryShader; + uint32_t m_GeometryShaderConstantBufferOffset; + + void SetDefault(); + }; + + void Initialize(); + void InitializeMaterialImpl(BuildResultInformation*, gfx::Device*, const ResMaterial*, + const ResMaterial*, const BuildArgSet&, CaptureTextureCopyInfo*); + void InitializeMatMemCount(detail::MatMemCount*) const; + void GetShaderBlend(int*, int*) const; + void GetShaderForDetailedCombiner(int*, int*) const; + void SetupShader(gfx::Device*, const BuildArgSet&, const BuildResSet*); + bool IsIndirectBlendUsed() const; + bool IsPerspectiveTextureProjectionUsed() const; + void SetupUserShaderConstantBufferInformation(const UserShaderInformation&); + void CopyUserShaderConstantBufferInformation(const Material&); + void CollectConstantBufferSize(BuildResultInformation*, gfx::Device*) const; + void InitializeBlendInformationImpl(gfx::Device*); + void FinalizeBlendInformationImpl(gfx::Device*); + PresetBlendStateId GetBlendStateId() const; + size_t GetVertexShaderConstantBufferSize() const; + size_t GetGeometryShaderConstantBufferSize() const; + size_t GetPixelShaderConstantBufferSize() const; + size_t GetPixelShaderDetailedCombinerConstantBufferSize() const; + size_t GetPixelShaderCombinerUserShaderConstantBufferSize() const; + size_t CalculateReserveMemSize(int, int, int, int, int, int, int, int, int, int, int); + size_t CalculateReserveMemSize(detail::MatMemCount&); + void ResParameterToMemory(int, int, int, int, int, int, int, int, int, int, int); + const Material& operator=(const Material&); + + union { + util::Unorm8x4 byteColor[2]; + util::Float4* pFloatColor; + } m_Colors; + detail::MatMemCount m_MemCap; + detail::MatMemCount m_MemCount; + void* m_pMem; + const ShaderInfo* m_pShaderInfo; + const char* m_pName; + uint32_t m_VertexShaderConstantBufferOffset; + uint32_t m_PixelShaderConstantBufferOffset; + UserShaderConstantBufferInformation* m_pUserShaderConstantBufferInformation; + gfx::BlendState* m_pBlendState; + int8_t m_AllowableTextureQuantity; + uint8_t m_ShaderId; + uint8_t m_Flag; + uint8_t m_ShaderVariation; +}; + +} // namespace ui2d +} // namespace nn diff --git a/include/nn/ui2d/ui2d_Pane.h b/include/nn/ui2d/ui2d_Pane.h new file mode 100644 index 0000000..046f145 --- /dev/null +++ b/include/nn/ui2d/ui2d_Pane.h @@ -0,0 +1,304 @@ +/** + * @file Pane.h + * @brief Base UI panel. + */ + +#pragma once + +#include +#include +#include +#include +#include + +namespace nn { + +namespace font { +class Rectangle; +} // namespace font + +namespace ui2d { +class AnimTransform; +struct BuildArgSet; +struct BuildResultInformation; +class Layout; +class Material; +class DrawInfo; +class Pane; +class ResourceAccessor; +class ResExtUserData; +struct ResExtUserDataList; +struct ResPane; +struct SystemDataMaskTexture; +struct SystemDataAlignmentExInfo; + +namespace detail { + +class PaneBase { + NN_NO_COPY(PaneBase); + +public: + PaneBase(); + virtual ~PaneBase(); + + util::IntrusiveListNode m_Link; +}; + +} // namespace detail + +typedef util::IntrusiveList< + Pane, util::IntrusiveListMemberNodeTraits> + PaneList; + +class Pane : public detail::PaneBase { +public: + NN_RUNTIME_TYPEINFO_BASE(); + + Pane(); + Pane(const ResPane*, const BuildArgSet&); + Pane(const Pane&); + /* newer + Pane(BuildResultInformation*, gfx::Device*, const ResPane*, const BuildArgSet&); + Pane(const Pane&, gfx::Device*, ResourceAccessor*, const char*); + */ + + virtual ~Pane(); + virtual void Finalize(gfx::Device*); + + const char* GetName() const { return m_Name; } + + void SetName(const char* pName); + const char* GetUserData() const; + void SetUserData(const char*); + + bool IsInfluencedAlpha() const { return detail::TestBit(m_Flag, PaneFlag_InfluencedAlpha); } + + void SetInfluencedAlpha(bool); + bool IsLocationAdjust() const; + void SetLocationAdjust(bool); + const util::Float3& GetTranslate() const; + + void SetTranslate(const util::Float3&); + void SetTranslate(const util::Float2&); + const util::Float3& GetRotate() const; + void SetRotate(const util::Float3&); + const util::Float2& GetScale() const; + void SetScale(const util::Float2&); + + const Size& GetSize() const { return m_Size; } + + void SetSize(const Size&); + uint8_t GetBasePositionX() const { return m_BasePosition & 3; } + void SetBasePositionX(uint8_t); + uint8_t GetBasePositionY() const { return (m_BasePosition >> 2) & 3; } + void SetBasePositionY(uint8_t); + uint8_t GetParentRelativePositionX() const; + void SetParentRelativePositionX(uint8_t); + uint8_t GetParentRelativePositionY() const; + void SetParentRelativePositionY(uint8_t); + const util::MatrixT4x3fType* GetMtx() const; + void SetMtx(const util::MatrixT4x3fType*); + + bool IsUserMtx() const { return detail::TestBit(m_Flag, PaneFlag_UserMatrix); } + + void ResetMtx(); + const util::MatrixT4x3fType& GetGlobalMtx() const { return m_GlbMtx; } + void SetGlobalMtx(const util::MatrixT4x3fType&); + + bool IsUserGlobalMtx() const { return detail::TestBit(m_Flag, PaneFlag_UserGlobalMatrix); } + + void ResetGlobalMtx(); + const font::Rectangle GetPaneRect() const; + virtual const util::Unorm8x4 GetVertexColor(int) const; + virtual void SetVertexColor(int, const util::Unorm8x4&); + uint8_t GetAlpha() const; + void SetAlpha(uint8_t); + uint8_t GetGlobalAlpha() const; + void SetGlobalAlpha(uint8_t); + + float GetSrtElement(int) const; + + void SetSrtElement(int idx, float value) { + auto pSrts = util::BytePtr(&m_Translate).Get(); + pSrts[idx] = value; + + SetGlbMtxDirty(); + } + + virtual uint8_t GetColorElement(int) const; + virtual void SetColorElement(int, uint8_t); + virtual uint8_t GetVertexColorElement(int) const; + virtual void SetVertexColorElement(int, uint8_t); + float GetMaskTexSrtElement(int) const; + void SetMaskTexSrtElement(int, float); + Material* GetMaterial() const; + virtual uint8_t GetMaterialCount() const; + virtual Material* GetMaterial(int) const; + uint16_t GetExtUserDataCount() const; + const ResExtUserData* GetExtUserDataArray() const; + const ResExtUserData* FindExtUserDataByName(const char*) const; + ResExtUserData* GetExtUserDataArrayForAnimation() const; + ResExtUserData* FindExtUserDataByNameForAnimation(const char*) const; + + Pane* GetParent() { return m_pParent; } + const Pane* GetParent() const { return m_pParent; } + const PaneList& GetChildList() const; + + PaneList& GetChildList() { return m_ChildList; } + + void AppendChild(Pane*); + void PrependChild(Pane*); + void InsertChild(Pane*, Pane*); + void InsertChild(PaneList::iterator, Pane*); + void RemoveChild(Pane*); + virtual Pane* FindPaneByName(const char*, bool); + virtual const Pane* FindPaneByName(const char*, bool) const; + virtual Material* FindMaterialByName(const char*, bool); + virtual const Material* FindMaterialByName(const char*, bool) const; + virtual void BindAnimation(AnimTransform*, bool, bool); + virtual void UnbindAnimation(AnimTransform*, bool); + virtual void UnbindAnimationSelf(AnimTransform*); + + bool IsVisible() const { return detail::TestBit(m_Flag, PaneFlag_Visible); } + void SetVisible(bool bVisible) { detail::SetBit(&m_Flag, PaneFlag_Visible, bVisible); } + + bool IsViewerInvisible() const; + + struct CalculateContext { + font::RectDrawer* pRectDrawer; + const util::MatrixT4x3fType* pViewMtx; + util::Float2 locationAdjustScale; + float influenceAlpha; + bool isLocationAdjust; + bool isInvisiblePaneCalculateMtx; + bool isAlphaZeroPaneCalculateMtx; + bool isInfluenceAlpha; + const Layout* pLayout; + + void SetDefault(); + void Set(const DrawInfo&, const Layout*); + }; + + typedef CalculateContext CalculateMtxContext; + + // gone in smo + virtual void CalculateMtx(DrawInfo&, CalculateMtxContext&, bool); + + virtual void Calculate(DrawInfo&, CalculateMtxContext&, bool); + + bool IsUserAllocated() const { return detail::TestBit(m_Flag, PaneFlag_UserAllocated); } + void SetUserAllocated(); + + void SetExtUserDataList(const ResExtUserDataList* pBlock); + /* newer + void AddDynamicSystemExtUserData(SystemDataType, void*, int); + */ + virtual void Draw(DrawInfo&, gfx::CommandBuffer&); + void DrawChildren(DrawInfo&, gfx::CommandBuffer&); + virtual void DrawSelf(DrawInfo&, gfx::CommandBuffer&); + + bool IsDrawTreeReady() const { return IsVisible() && IsConstantBufferReady(); } + + bool IsDrawSelfReady() const; + + bool IsGlbMtxDirty() const { return detail::TestBit(m_Flag, PaneFlag_IsGlobalMatrixDirty); } + + uint8_t* GetFlagPtr(); + uint8_t* GetAlphaPtr(); + void CalculateGlobalMatrix(CalculateMtxContext&); + void CalculateGlobalMatrix(CalculateMtxContext&, bool); + bool IsMaskEnabled() const; + bool CompareCopiedInstanceTest(const Pane&) const; + /* newer + bool IsAlignmentIgnore(); + bool IsAlignmentMarginEnabled(); + bool IsAlignmentNullPane(); + float GetAlignmentMargin(); + */ + +protected: + /* newer + void CopyImpl(const Pane&, gfx::Device*, ResourceAccessor*, const char*); + void InitializeByResourceBlock(BuildResultInformation*, gfx::Device*, const ResPane*, + const BuildArgSet&); + */ + virtual void LoadMtx(DrawInfo&); + const util::Float2 GetVertexPos() const; + + void SetGlbMtxDirty() { detail::SetBit(&m_Flag, PaneFlag_IsGlobalMatrixDirty, true); } + + void CleanGlbMtx(); + + void SetConstantBufferReady(bool flag) { + detail::SetBit(&m_Flag, PaneFlag_IsConstantBufferReady, flag); + } + bool IsConstantBufferReady() const { + return detail::TestBit(m_Flag, PaneFlag_IsConstantBufferReady); + } + + void SetConstantBufferReadySelf(bool); + bool IsConstantBufferReadySelf() const; + void SetCalculationFinishedSelf(bool); + bool IsCalculationFinishedSelf() const; + virtual Pane* FindPaneByNameRecursive(const char*); + virtual const Pane* FindPaneByNameRecursive(const char*) const; + virtual Material* FindMaterialByNameRecursive(const char*); + virtual const Material* FindMaterialByNameRecursive(const char*) const; + + uint32_t GetSystemExtDataFlag() const { return m_SystemDataFlags; } + + uint32_t GetSystemExtDataCount() const; + const void* GetSystemExtData(int) const; + const void* GetSystemExtData(SystemDataType) const; + + /* newer + void UpdateSystemExtDataFlag(const ResExtUserDataList*); + bool CheckInvisibleAndUpdateConstantBufferReady(); + void InitializeMaskFunction(BuildResultInformation*, gfx::Device*, const SystemDataMaskTexture*, + const BuildArgSet&); + void CalculateMaskConstantBuffer(DrawInfo&); + void DrawMaskedImage(DrawInfo&, gfx::CommandBuffer&); + void CalculateCaptureRootMatrix(util::MatrixT4x3fType&, const DrawInfo&) const; + void CalculateCaptureProjectionMatrix(util::MatrixT4x4fType&) const; + void UpdateMaterialConstantBufferForEffectCapture(const DrawInfo&); + int GetMaskShaderSecondBlend(const SystemDataMaskTexture*); + */ + +private: + Pane* m_pParent; + PaneList m_ChildList; + util::Float3 m_Translate; + util::Float3 m_Rotate; + util::Float2 m_Scale; + Size m_Size; + uint8_t m_Flag; + uint8_t m_Alpha; + uint8_t m_GlbAlpha; + uint8_t m_BasePosition; + uint8_t m_FlagEx; + uint32_t m_SystemDataFlags; + util::MatrixT4x3fType m_GlbMtx; + const util::MatrixT4x3fType* m_pUserMtx; + const ResExtUserDataList* m_pExtUserDataList; + ResExtUserDataList* + m_pAnimatedExtUserDataList; // removed in newer, GetExtUserDataArrayForAnimation + char m_Name[25]; + char m_UserData[9]; + + // renamed to InitailizeParams in newer + void Initialize(); + /* newer + void AddDynamicSystemExtUserDataAllNewImpl(SystemDataType, void*, int); + void AddDynamicSystemExtUserDataPartialImpl(SystemDataType, void*, int); + */ + const Pane& operator=(const Pane&); + void CalculateScaleFromPartsRoot(util::Float2*, Pane*) const; + void AllocateAndCopyAnimatedExtUserData(const ResExtUserDataList*); + void CalculateGlobalMatrixSelf(CalculateMtxContext&); + /* newer + const SystemDataAlignmentExInfo* GetAlignmentExInfo() const; + */ +}; + +} // namespace ui2d +} // namespace nn diff --git a/include/nn/ui2d/ui2d_Parts.h b/include/nn/ui2d/ui2d_Parts.h new file mode 100644 index 0000000..990622d --- /dev/null +++ b/include/nn/ui2d/ui2d_Parts.h @@ -0,0 +1,47 @@ +/** + * @file Parts.h + * @brief Layout parts. + */ + +#pragma once + +#include +#include + +namespace nn { +namespace ui2d { + +struct BuildArgSet; +struct ResParts; +class Layout; +class Material; + +class Parts : public Pane { +public: + NN_RUNTIME_TYPEINFO(Pane); + + Parts(); + Parts(const ResParts*, const ResParts*, const BuildArgSet&); + Parts(const Parts&); + + virtual ~Parts(); + + Layout* GetLayout() const { return m_pLayout; } + void SetLayout(Layout* pLayout) { m_pLayout = pLayout; } + + virtual Pane* FindPaneByNameRecursive(const char*); + virtual const Pane* FindPaneByNameRecursive(const char*) const; + virtual Material* FindMaterialByNameRecursive(const char*); + virtual const Material* FindMaterialByNameRecursive(const char*) const; + bool CompareCopiedInstanceTest(const Parts&) const; + + util::IntrusiveListNode m_Link; + +private: + const Parts& operator=(const Parts&); + + Layout* m_pLayout; +}; + +} // namespace ui2d +} // namespace nn diff --git a/include/nn/ui2d/ui2d_Picture.h b/include/nn/ui2d/ui2d_Picture.h new file mode 100644 index 0000000..6573710 --- /dev/null +++ b/include/nn/ui2d/ui2d_Picture.h @@ -0,0 +1,92 @@ +#pragma once + +#include +#include +#include + +namespace nn { +namespace ui2d { + +class Material; + +class Picture : public Pane { +public: + NN_RUNTIME_TYPEINFO(Pane); + + Picture(int); + Picture(const TextureInfo&); + Picture(BuildResultInformation*, gfx::Device*, const ResPicture*, const ResPicture*, + const BuildArgSet&); + Picture(const Picture&, gfx::Device*); + Picture(const Picture&, gfx::Device*, ResourceAccessor*, const char*); + + virtual ~Picture(); + virtual void Finalize(gfx::Device*); + virtual void Append(const TextureInfo&); + virtual const util::Unorm8x4 GetVertexColor(int) const; + virtual void SetVertexColor(int, const util::Unorm8x4&); + virtual uint8_t GetVertexColorElement(int) const; + virtual void SetVertexColorElement(int, uint8_t); + void ReserveTexCoord(int); + int GetTexCoordCount() const; + void SetTexCoordCount(int); + void GetTexCoord(util::Float2*, int) const; + void SetTexCoord(int, const util::Float2*); + virtual uint8_t GetMaterialCount() const; + virtual Material* GetMaterial(int) const; + void SetMaterial(Material*); + virtual void Calculate(DrawInfo&, Pane::CalculateContext&, bool); + bool CompareCopiedInstanceTest(const Picture&) const; + +protected: + virtual void DrawSelf(DrawInfo&, gfx::CommandBuffer&); + virtual void LoadMtx(DrawInfo&); + void CopyImpl(const Picture&, gfx::Device*, ResourceAccessor*, const char*); + + struct ShapeDrawInfo { + uint16_t m_ShapeType; + uint8_t padding[2]; + size_t vertexBufferGpuMemoryOffset; + size_t indexBufferGpuMemoryOffset; + gfx::util::PrimitiveShape* pShape; + }; + + struct ShapeDrawInfoAccessor { + uint8_t unionTypeFlag; + uint8_t padding; + ShapeDrawInfo* pShapeDrawInfo; + }; + +private: + static const gfx::util::PrimitiveShapeFormat VertexFormat_PUv; + + void Initialize(int); + void InitializeMaterial(int); + void InitializeShape(BuildResultInformation*, gfx::Device*, const ResPicture*, + const BuildArgSet&, uint32_t); + void CopyShapeInfo(const Picture&); + void CopyShapeVertexData(DrawInfo&); + bool CheckAdditionalInfoFlag(const ResPicture*, PicturePaneFlag) const; + bool IsTexCoordArrayEnabled() const; + + Material* m_pMaterial; + util::Unorm8x4 m_VertexColors[4]; + + union SharedMemory { + enum { UnionType_ShapeDrawInfo = 4, UnionType_Max }; + + uint8_t m_UnionTypeFlag; + detail::TexCoordArray m_TexCoordArray; + ShapeDrawInfoAccessor m_ShapeDrawInfoAccessor; + + public: + SharedMemory(); + ~SharedMemory(); + }; + + SharedMemory m_SharedMemory; + + const Picture& operator=(const Picture&) = delete; +}; +} // namespace ui2d +} // namespace nn diff --git a/include/nn/ui2d/ui2d_ResourceAccessor.h b/include/nn/ui2d/ui2d_ResourceAccessor.h new file mode 100644 index 0000000..e0ad80e --- /dev/null +++ b/include/nn/ui2d/ui2d_ResourceAccessor.h @@ -0,0 +1,68 @@ +#pragma once + +#include +#include + +namespace nn { +namespace font { +class Font; +} + +namespace ui2d { + +class ResourceAccessor { +public: + typedef void (*FindResourceByTypeCallback)(const void*, size_t, const char*, void*); + + static const char* ArchiveShaderPrefix; + static const char* ArchiveShaderSuffix; + + static void GetArchiveShaderResourceName(char* pBuffer, const char* pShaderName, + int bufferSize); + +protected: + ResourceAccessor(); + +public: + NN_RUNTIME_TYPEINFO_BASE(); + + virtual ~ResourceAccessor(); + virtual void RegisterTextureViewToDescriptorPool(RegisterTextureViewSlot, void*) = 0; + virtual void UnregisterTextureViewFromDescriptorPool(UnregisterTextureViewSlot, void*) = 0; + + /* newer + virtual RenderTargetTextureInfo* RegisterRenderTargetTexture(const char*); + virtual void UnregisterRenderTargetTexture(TextureInfo*); + */ + + virtual void Finalize(gfx::Device*); + virtual void* FindResourceByName(size_t*, ResType, const char*) = 0; + + virtual const void* FindResourceByName(size_t* pSize, ResType resType, + const char* pName) const { + return const_cast(this)->FindResourceByName(pSize, resType, pName); + } + + virtual void* FindResourceByName(ResType resType, const char* pName) { + return FindResourceByName(nullptr, resType, pName); + } + + virtual const void* FindResourceByName(ResType resType, const char* pName) const { + return FindResourceByName(nullptr, resType, pName); + } + + // smo + // virtual void FindResourceByType(ResType, FindResourceByTypeCallback, void*) const = 0; + + virtual font::Font* AcquireFont(gfx::Device*, const char*) = 0; + virtual const TextureInfo* AcquireTexture(gfx::Device*, const char*) = 0; + virtual const ShaderInfo* AcquireShader(gfx::Device*, const char*) = 0; + +protected: + virtual bool LoadTexture(ResourceTextureInfo*, gfx::Device*, const char*) = 0; + virtual font::Font* LoadFont(gfx::Device*, const char*); + virtual bool LoadShader(ShaderInfo*, gfx::Device*, const char*) = 0; +}; + +} // namespace ui2d +} // namespace nn diff --git a/include/nn/ui2d/ui2d_Resources.h b/include/nn/ui2d/ui2d_Resources.h new file mode 100644 index 0000000..c6c9ddc --- /dev/null +++ b/include/nn/ui2d/ui2d_Resources.h @@ -0,0 +1,711 @@ +#pragma once + +#include +#include +#include +#include + +namespace nn { +namespace ui2d { + +template +constexpr uint32_t MakeSig(const char (&s)[N]) { + static_assert(N == 5, "signature must have exactly 4 characters"); + return s[0] | (s[1] << 8) | (s[2] << 16) | (s[3] << 24); +} + +const uint32_t BinaryFileFormatVersion = 0x8060000; +const uint32_t BinaryCpxFileFormatVersion = 0x9030000; +const uint32_t FileSignatureFlyt = MakeSig("FLYT"); +const uint32_t DataBlockKindLyt = MakeSig("lyt1"); +const uint32_t DataBlockKindControl = MakeSig("cnt1"); +const uint32_t DataBlockKindTextureList = MakeSig("txl1"); +const uint32_t DataBlockKindFontList = MakeSig("fnl1"); +const uint32_t DataBlockKindMateriaList = MakeSig("mat1"); +const uint32_t DataBlockKindPane = MakeSig("pan1"); +const uint32_t DataBlockKindPicture = MakeSig("pic1"); +const uint32_t DataBlockKindTextBox = MakeSig("txt1"); +const uint32_t DataBlockKindWindow = MakeSig("wnd1"); +const uint32_t DataBlockKindBounding = MakeSig("bnd1"); +const uint32_t DataBlockKindParts = MakeSig("prt1"); +const uint32_t DataBlockKindGroup = MakeSig("grp1"); +const uint32_t DataBlockKindCapture = MakeSig("cpt1"); +const uint32_t DataBlockKindUserDataList = MakeSig("usd1"); +const uint32_t DataBlockKindPaneStart = MakeSig("pas1"); +const uint32_t DataBlockKindPaneEnd = MakeSig("pae1"); +const uint32_t DataBlockKindGroupStart = MakeSig("grs1"); +const uint32_t DataBlockKindGroupEnd = MakeSig("gre1"); +const uint32_t FileSignatureFlan = MakeSig("FLAN"); +const uint32_t BinFileSignatureFcpx = MakeSig("FCPX"); + +const uint32_t DataBlockKindAnimTag = MakeSig("pat1"); +const uint32_t DataBlockKindAnimShare = MakeSig("pah1"); +const uint32_t DataBlockKindAnim = MakeSig("pai1"); + +const uint32_t ResourceTypeLayout = 'blyt'; +const uint32_t ResourceTypeAnimation = 'anim'; +const uint32_t ResourceTypeTexture = 'timg'; +const uint32_t ResourceTypeFont = 'font'; +const uint32_t ResourceTypeShader = 'bgsh'; +const uint32_t ResourceTypeScalableFont = 'scft'; + +struct ResVec2 { + void Set(float, float); + operator util::Float2() const; + + float x; + float y; +}; + +struct ResVec3 { + void Set(float, float, float); + operator util::Vector3fType() const; + + float x; + float y; + float z; +}; + +struct ResTexSrt { + ResVec2 translate; + float rotate; + ResVec2 scale; +}; + +struct ResProjectionTexGenParameters { + ResVec2 translate; + ResVec2 scale; + uint8_t flag; + uint8_t reserve[3]; +}; + +class ResTexCoordGen { +public: + ResTexCoordGen(); + ResTexCoordGen(TexGenType, TexGenSrc); + void Set(TexGenType, TexGenSrc); + TexGenType GetTexGenType() const; + TexGenSrc GetTexGenSrc() const; + bool IsProjection() const; + bool IsPerspectiveProjection() const; + void SetProjectionTexGenParameters(const ResProjectionTexGenParameters*); + void SetProjectionTexGenParamaters(const ResProjectionTexGenParameters*); + +private: + uint8_t m_TexGenType; + uint8_t m_TexGenSrc; + char padding[2]; + uint64_t m_AddressOfProjectionTexGenParams; +}; + +class ResTevStage { +public: + ResTevStage(); + void Set(TevMode, TevMode); + void SetCombineRgb(TevMode); + void SetCombineAlpha(TevMode); + TevMode GetCombineRgb() const; + TevMode GetCombineAlpha() const; + +private: + uint8_t m_CombineRgb; + uint8_t m_CombineAlpha; + char padding[2]; +}; + +class ResAlphaCompare { +public: + ResAlphaCompare(); + ResAlphaCompare(AlphaTest aFunc, float aRef) { + m_AlphaCompareFunc = aFunc; + m_AlphaRef = aRef; + } + + void Set(AlphaTest, float); + void SetRef(float); + AlphaTest GetFunc() const { return (AlphaTest)m_AlphaCompareFunc; } + float GetRef() const; + +private: + uint8_t m_AlphaCompareFunc; + float m_AlphaRef; +}; + +class ResBlendMode { +public: + ResBlendMode(); + ResBlendMode(BlendOp, BlendFactor, BlendFactor, LogicOp); + void Set(BlendOp, BlendFactor, BlendFactor, LogicOp); + bool IsBlendOpDisable() const; + BlendOp GetBlendOp() const; + gfx::BlendFunction GetGfxBlendOp() const; + BlendFactor GetSrcFactor() const; + gfx::BlendFactor GetGfxSrcFactor() const; + BlendFactor GetDstFactor() const; + gfx::BlendFactor GetGfxDstFactor() const; + bool IsLogicOpDisable() const; + LogicOp GetLogicOp() const; + gfx::LogicOperation GetGfxLogicOp() const; + bool Equals(const ResBlendMode*) const; + +private: + gfx::BlendFactor ConvertBlendFactor(BlendFactor) const; + + uint8_t m_BlendOperation; + uint8_t m_SrcBlendFactor; + uint8_t m_DestBlendFactor; + uint8_t m_LogicOp; +}; + +class ResIndirectParameter { +public: + float rotate; + ResVec2 scale; + + ResIndirectParameter(); +}; + +class ResFontShadowParameter { +public: + uint8_t blackInterporateColor[3]; + uint8_t whiteInterporateColor[4]; + uint8_t reserve; + + ResFontShadowParameter(); +}; + +struct ResWindowInflation { + int16_t left; + int16_t right; + int16_t top; + int16_t bottom; +}; + +struct ResWindowFrameSize { + uint16_t left; + uint16_t right; + uint16_t top; + uint16_t bottom; +}; + +// 955: nn::ui2d::ResSystemExtUserData; + +class ResExtUserData { +public: + ResExtUserData(uint32_t, uint32_t, uint16_t, uint8_t); + + const char* GetName() const { + if (GetNameOffset() != 0) { + return util::ConstBytePtr(this, GetNameOffset()).Get(); + } + + return nullptr; + } + + ExtUserDataType GetType() const { return static_cast(m_Type); } + uint16_t GetCount() const; + const char* GetString() const; + const int32_t* GetIntArray() const; + const float* GetFloatArray() const; + int GetSystemDataVersion() const; + int GetSystemDataCount() const; + const void* GetSystemData(int) const; + + void WriteIntValue(int32_t value, int index) { + auto pValues = util::BytePtr(this, GetDataOffset()).Get(); + pValues[index] = value; + } + + void WriteFloatValue(float value, int index) { + auto pValues = util::BytePtr(this, GetDataOffset()).Get(); + pValues[index] = value; + } + + uint32_t GetDataOffset() const { return m_DataOffset; } + uint32_t GetNameOffset() const { return m_NameStrOffset; } + +private: + uint32_t m_NameStrOffset; + uint32_t m_DataOffset; + uint16_t m_Count; + uint8_t m_Type; + char m_Padding1; +}; + +struct ResAnimationGroupRef { + char name[33]; + uint8_t flag; + char padding[2]; + + void SetDefault(); + + const char* GetName() const { return name; } +}; + +struct ResAnimationShareInfo { + char srcPaneName[25]; + char targetGroupName[25]; + char padding[2]; + + void SetDefault(); + + const char* GetSrcPaneName() const { return srcPaneName; } + const char* GetTargetGroupName() const { return targetGroupName; } +}; + +struct ResLayout { + font::detail::BinaryBlockHeader blockHeader; + uint8_t originType; + char padding[3]; + ResVec2 layoutSize; + ResVec2 partsSize; +}; + +struct ResControl { + font::detail::BinaryBlockHeader blockHeader; + uint32_t controlUserNameOffset; + uint32_t controlFunctionalPaneNamesOffset; + uint16_t controlFunctionalPaneCount; + uint16_t controlFunctionalAnimCount; + uint32_t controlFunctionalPaneParameterNameOffsetsOffset; + uint32_t controlFunctionalAnimParameterNameOffsetsOffset; +}; + +/* +1424: nn::ui2d::ResFont; +1448: nn::ui2d::ResFontList; +1471: nn::ui2d::ResTexture; +1495: nn::ui2d::ResTextureList; +*/ +struct ResTexMap { + uint16_t texIdx; + uint8_t wrapSflt; + uint8_t wrapTflt; + + void SetDefault(); + TexWrap GetWarpModeS() const; + TexWrap GetWarpModeT() const; + TexFilter GetMinFilter() const; + TexFilter GetMagFilter() const; + void SetWarpModeS(uint8_t); + void SetWarpModeT(uint8_t); + void SetMinFilter(uint8_t); + void SetMagFilter(uint8_t); +}; + +/* +1627: nn::ui2d::ResTexMapAdditionalInfo; +1631: nn::ui2d::ResTexMapAdditionalInfo::InfoType; +1648: nn::ui2d::ResMaterialResourceCount; +*/ + +struct ResColor { + uint8_t r; + uint8_t g; + uint8_t b; + uint8_t a; + + operator util::Unorm8x4() const; +}; + +/* +2012: nn::ui2d::ResMaterial; +2054: nn::ui2d::ResMaterialList; +2074: nn::ui2d::ResShapeInfoGfxPrimitiveRoundRect; +2085: nn::ui2d::ResShapeInfoGfxPrimitiveCircle; +2095: nn::ui2d::ResShapeInfo; +2134: nn::ui2d::ResShapeInfoList; +2155: nn::ui2d::ResCaptureTextureOld; +2182: nn::ui2d::ResCaptureTexture; +2214: nn::ui2d::ResCaptureTextureFilter; +2243: nn::ui2d::ResCaptureTextureList; +*/ + +struct ResPane { + font::detail::BinaryBlockHeader blockHeader; + uint8_t flag; + uint8_t basePosition; + uint8_t alpha; + uint8_t flagEx; + char name[24]; + char userData[8]; + ResVec3 translate; + ResVec3 rotate; + ResVec2 scale; + ResVec2 size; +}; + +struct ResPicture : public ResPane { + ResColor vtxCols[4]; + uint16_t materialIdx; + uint8_t texCoordCount; + uint8_t flags; +}; + +// not sure where to place this and seems to downcast in nn::ui2d::Bounding +struct ResBounding : public ResPane {}; + +struct ResPerCharacterTransform { + float evalTimeOffset; + float evalTimeWidth; + uint8_t loopType; + uint8_t originV; + uint8_t hasAnimationInfo; + char padding[1]; +}; + +/* +2413: nn::ui2d::ResPerCharacterTransformExtended; +*/ + +struct ResTextBox : public ResPane { + uint16_t textBufBytes; + uint16_t textStrBytes; + uint16_t materialIdx; + uint16_t fontIdx; + uint8_t textPosition; + uint8_t textAlignment; + uint16_t textBoxFlag; + float italicRatio; + uint32_t textStrOffset; + ResColor textCols[2]; + ResVec2 fontSize; + float charSpace; + float lineSpace; + uint32_t textIdOffset; + ResVec2 shadowOffset; + ResVec2 shadowScale; + ResColor shadowCols[2]; + float shadowItalicRatio; + uint32_t lineWidthOffsetOffset; + uint32_t perCharacterTransformOffset; +}; + +/* +2508: nn::ui2d::ResWindowFrame; +2529: nn::ui2d::ResWindowContent; +*/ + +struct ResWindow : public ResPane { + ResWindowInflation inflation; + ResWindowFrameSize frameSize; + uint8_t frameCount; + uint8_t windowFlags; + char padding[2]; + uint32_t contentOffset; + uint32_t frameOffsetTableOffset; +}; + +struct ResPartsPaneBasicInfo { + char userData[8]; + ResVec3 translate; + ResVec3 rotate; + ResVec2 scale; + ResVec2 size; + uint8_t alpha; + char padding[3]; +}; + +struct ResPartsProperty { + char name[24]; + uint8_t usageFlag; + uint8_t basicUsageFlag; + uint8_t materialUsageFlag; + char padding[1]; + uint32_t propertyOffset; + uint32_t extUserDataOffset; + uint32_t paneBasicInfoOffset; +}; + +struct ResParts : public ResPane { + uint32_t propertyCount; + ResVec2 magnify; +}; + +struct ResExtUserDataList { + font::detail::BinaryBlockHeader blockHeader; + uint16_t count; + char padding[2]; +}; + +/* +2740: nn::ui2d::ResCapture; +2751: nn::ui2d::ResAlignment; +*/ + +struct ResGroup { + font::detail::BinaryBlockHeader blockHeader; + char name[33]; + char padding[1]; + uint16_t paneCount; +}; + +struct ResDetailedCombinerStage { + enum Src { + Src_Texture0 = 3, + Src_Texture1 = 4, + Src_Texture2 = 5, + Src_Texture3 = 6, + Src_Constant = 14, + Src_Primary = 0, + Src_Previous = 15, + Src_PreviousBuffer = 13, + Src_Num = 8 + }; + + enum OperandRgb { + OperandRgb_Rgb, + OperandRgb_InverseRgb, + OperandRgb_Alpha, + OperandRgb_InverseAlpha, + OperandRgb_Rrr, + OperandRgb_InverseRrr, + OperandRgb_Ggg = 8, + OperandRgb_InverseGgg, + OperandRgb_Bbb = 12, + OperandRgb_InverseBbb, + OperandRgb_Num = 10 + }; + + enum OperandAlpha { + OperandAlpha_Alpha, + OperandAlpha_InverseAlpha, + OperandAlpha_R, + OperandAlpha_InverseR, + OperandAlpha_G, + OperandAlpha_InverseG, + OperandAlpha_B, + OperandAlpha_InverseB, + OperandAlpha_Num + }; + + enum Combine { + Combine_Replace, + Combine_Modulate, + Combine_Add, + Combine_AddSigned, + Combine_Interpolate, + Combine_Subtract, + Combine_Dot3Rgb, + Combine_Dot3Rgba, + Combine_AddMult, + Combine_MultAdd, + Combine_Num + }; + + enum ConstColorSelect { + ConstColorSelect_Black, + ConstColorSelect_White, + ConstColorSelect_C0, + ConstColorSelect_C1, + ConstColorSelect_C2, + ConstColorSelect_C3, + ConstColorSelect_C4, + ConstColorSelect_C5, + ConstColorSelect_Max + }; + + enum Scale { Scale_1, Scale_2, Scale_4, Scale_NUM }; + + void Set(Combine, Combine, Src, Src, Src, Src, Src, Src, OperandRgb, OperandRgb, OperandRgb, + OperandAlpha, OperandAlpha, OperandAlpha, Scale, Scale, ConstColorSelect, + ConstColorSelect, bool, bool); + void SetCombineRgb(Combine); + void SetCombineAlpha(Combine); + void SetSrcRgb0(Src); + void SetSrcRgb1(Src); + void SetSrcRgb2(Src); + void SetSrcAlpha0(Src); + void SetSrcAlpha1(Src); + void SetSrcAlpha2(Src); + void SetOperandRgb0(OperandRgb); + void SetOperandRgb1(OperandRgb); + void SetOperandRgb2(OperandRgb); + void SetOperandAlpha0(OperandAlpha); + void SetOperandAlpha1(OperandAlpha); + void SetOperandAlpha2(OperandAlpha); + void SetScaleRgb(Scale); + void SetScaleAlpha(Scale); + void SetConstColorSelectRgb(ConstColorSelect); + void SetConstColorSelectAlpha(ConstColorSelect); + void SetSavePrevRgb(bool); + void SetSavePrevAlpha(bool); + void SetCombineRgbSourceCount(Combine); + void SetCombineAlphaSourceCount(Combine); + Combine GetCombineRgb() const; + Combine GetCombineAlpha() const; + Src GetSrcRgb0() const; + Src GetSrcRgb1() const; + Src GetSrcRgb2() const; + Src GetSrcAlpha0() const; + Src GetSrcAlpha1() const; + Src GetSrcAlpha2() const; + OperandRgb GetOperandRgb0() const; + OperandRgb GetOperandRgb1() const; + OperandRgb GetOperandRgb2() const; + OperandAlpha GetOperandAlpha0() const; + OperandAlpha GetOperandAlpha1() const; + OperandAlpha GetOperandAlpha2() const; + Scale GetScaleRgb() const; + Scale GetScaleAlpha() const; + ConstColorSelect GetConstColorSelectRgb() const; + ConstColorSelect GetConstColSelAlpha() const; + bool GetSavePrevRgb() const; + bool GetSavePrevAlpha() const; + uint32_t GetCombineRgbSourceCount() const; + uint32_t GetCombineAlphaSourceCount() const; + void SetDefault(); + + Bit32 bits0; + Bit32 bits1; + Bit32 bits2; + Bit32 bits3; + + enum Bits { + Bits_CombineRgb = 4, + Bits_CombineAlpha = 4, + Bits_SrcRgb = 4, + Bits_SrcAlpha = 4, + Bits_OperandRgb = 4, + Bits_OperandAlpha = 4, + Bits_Scale = 2, + Bits_ConstColorSelect = 4, + Bits_SavePrev = 1, + Bits_CombineRgb_Count = 4, + Bits_CombineAlpha_Count = 4 + }; + + enum Pos3 { Pos3_Rgb_Count = 0, Pos3_Alpha_Count = 4, Field3_Size = 8 }; +}; + +struct ResDetailedCombinerStageInfo { +public: + void SetDefault(); + + void SetConstantColor(uint32_t idx, ResColor color) { m_ConstColor[idx] = color; } + + ResColor GetConstantColor(uint32_t idx) const { return m_ConstColor[idx % 5]; } + + void SetBufferColorSelectRgb(ResDetailedCombinerStage::ConstColorSelect); + ResDetailedCombinerStage::ConstColorSelect GetBufferColorSelectRgb() const; + void SetBufferColorSelectAlpha(ResDetailedCombinerStage::ConstColorSelect); + ResDetailedCombinerStage::ConstColorSelect GetBufferColorSelectAlpha() const; + +private: + Bit32 m_Bits; + ResColor m_ConstColor[6]; +}; + +/* +3743: nn::ui2d::ResConstantColor; +*/ + +struct ResCombinerUserShader { +public: + void SetConstantColor(uint32_t, ResColor); + ResColor GetConstantColor(uint32_t) const; + const uint32_t* GetKeyCode() const; + void SetKeyCode(uint32_t*, size_t); + +private: + uint32_t m_KeyCode[24]; + ResColor m_ConstColor[5]; +}; + +struct ResAnimationTagBlock { + font::detail::BinaryBlockHeader blockHeader; + uint16_t tagOrder; + uint16_t groupCount; + uint32_t nameOffset; + uint32_t groupsOffset; + uint32_t userDataListOffset; + int16_t startFrame; + int16_t endFrame; + uint8_t flag; + char padding[3]; +}; + +struct ResAnimationShareBlock { + font::detail::BinaryBlockHeader blockHeader; + uint32_t animShareInfoOffset; + uint16_t shareCount; + char padding[2]; +}; + +struct ResAnimationBlock { + font::detail::BinaryBlockHeader blockHeader; + uint16_t frameSize; + uint8_t loop; + char padding[1]; + uint16_t fileCount; + uint16_t animContCount; + uint32_t animContOffsetsOffset; +}; + +struct ResAnimationContent { + char name[28]; + uint8_t count; + uint8_t type; + char padding[2]; + + /* + uint32_t animInfoOffsets; + uint32_t fileNameOffsets; + */ +}; + +struct ResAnimationInfo { + uint32_t kind; + uint8_t count; + char padding[3]; +}; + +struct ResAnimationTarget { + uint8_t id; + uint8_t target; + uint8_t curveType; + char padding[1]; + uint16_t keyCount; + char padding2[2]; + uint32_t keysOffset; +}; + +struct ResHermiteKey { + float frame; + float value; + float slope; +}; + +struct ResStepKey { + float frame; + uint16_t value; + uint16_t padding[1]; +}; + +struct ResParameterizedAnim { + uint16_t parameterizedAnimCount; + char padding[2]; +}; + +/* +4202: nn::ui2d::ResParameterizedAnimParameter; +4222: nn::ui2d::SystemDataSimpleAABB; +4240: nn::ui2d::SystemDataSimpleOBB; +4260: nn::ui2d::SystemDataAlignmentExInfo; +4264: nn::ui2d::SystemDataAlignmentExInfo::AlignmentFlags; +4289: nn::ui2d::SystemDataMaskTexture; +*/ + +struct CaptureTextureCopyInfo { + uint8_t useFlags; + uint8_t targetId; + uint8_t padding[2]; + char names[3][64]; +}; + +/* +4338: nn::ui2d::SystemDataCopyCaptureTextureInfo; +4355: nn::ui2d::SystemDataMaskTextureRuntimeInfo; +*/ +} // namespace ui2d +} // namespace nn diff --git a/include/nn/ui2d/ui2d_ShaderInfo.h b/include/nn/ui2d/ui2d_ShaderInfo.h new file mode 100644 index 0000000..1102ebb --- /dev/null +++ b/include/nn/ui2d/ui2d_ShaderInfo.h @@ -0,0 +1,53 @@ +#pragma once + +#include +#include +#include + +namespace nn { + +namespace gfx { + +class ResShaderFile; + +} + +namespace ui2d { + +class ShaderInfo { + NN_NO_COPY(ShaderInfo); + +public: + ShaderInfo(); + + void Initialize(gfx::Device*, void*); + void InitializeWithVariationTable(gfx::Device*, void*, const void*); + void InitializeWithVariationTable(gfx::Device*, void*, const void*, gfx::MemoryPool*, ptrdiff_t, + size_t); + void Finalize(gfx::Device*, bool); + void SetShader(gfx::CommandBuffer&, int) const; + int GetVertexShaderSlot(int) const; + int GetGeometryShaderSlot(int) const; + int GetPixelShaderSlot(int) const; + int GetTextureSlot(int, int) const; + const void* GetVariationTable() const; + +private: + gfx::Shader* GetVertexShader(int) const; + gfx::Shader* GetGeometryShader(int) const; + gfx::Shader* GetPixelShader(int) const; + int GetVariationCount() const; + void InitializeVertexStates(gfx::Device*); + + gfx::ResShaderFile* m_pResShaderFile; + gfx::ShaderCodeType m_CodeType; + gfx::VertexState* m_pVertexStates; + int* m_pVertexShaderSlots; + int* m_pGeometryShaderSlots; + int* m_pPixelShaderSlots; + int (*m_pTextureSlots)[3]; + const void* m_pVariationTable; +}; + +} // namespace ui2d +} // namespace nn diff --git a/include/nn/ui2d/ui2d_TexMap.h b/include/nn/ui2d/ui2d_TexMap.h new file mode 100644 index 0000000..a5fe3bf --- /dev/null +++ b/include/nn/ui2d/ui2d_TexMap.h @@ -0,0 +1,45 @@ +#pragma once + +#include + +namespace nn { +namespace ui2d { + +class TexMap { +public: + TexMap(); + TexMap(const TextureInfo*); + ~TexMap(); + + void Finalize(); + TexWrap GetWrapModeS() const; + TexWrap GetWrapModeT() const; + void SetWrapMode(TexWrap, TexWrap); + TexFilter GetMinFilter() const; + TexFilter GetMagFilter() const; + void SetFilter(TexFilter, TexFilter); + void Set(const TextureInfo*); + + const TextureInfo* GetTextureInfo() const { return m_pTextureInfo; } + void SetTextureInfo(const TextureInfo* pTextureInfo) { m_pTextureInfo = pTextureInfo; } + + void CopySamplerSettings(const TexMap&); + +private: + void ResetSamplerSettings(); + + struct Bits { + uint32_t wrapS : 2; + uint32_t wrapT : 2; + uint32_t minFilter : 3; + uint32_t magFilter : 1; + }; + + Bits m_Bits; + const TextureInfo* m_pTextureInfo; + + NN_NO_COPY(TexMap); +}; + +} // namespace ui2d +} // namespace nn diff --git a/include/nn/ui2d/ui2d_TextBox.h b/include/nn/ui2d/ui2d_TextBox.h new file mode 100644 index 0000000..fdf5880 --- /dev/null +++ b/include/nn/ui2d/ui2d_TextBox.h @@ -0,0 +1,298 @@ +#pragma once + +#include +#include +#include + +namespace nn { + +namespace font { +class DispStringBuffer; +class Font; +class TextWriter; +class WideTextWriter; +class PerCharacterTransformInfo; +class ConstantBufferAdditionalContent; +} // namespace font + +namespace ui2d { + +class Material; +struct ResAnimationTarget; +struct ResTextBox; +struct ResAnimationInfo; + +class TextBox : public Pane { +public: + NN_RUNTIME_TYPEINFO(Pane); + + typedef font::TagProcessorBase TagProcessor; + typedef font::TagProcessorBase TagProcessorUtf8; + + TextBox(); + TextBox(bool); + + struct InitializeStringParam { + int textBoxFlag; + Layout* pResourceLayout; + const uint16_t* pBlockText; + size_t allocStrBufLen; + int resStrLen; + }; + + TextBox(BuildResultInformation*, gfx::Device*, InitializeStringParam*, const ResTextBox*, + const ResTextBox*, const BuildArgSet&); + TextBox(const TextBox&, gfx::Device*); + TextBox(const TextBox&, gfx::Device*, ResourceAccessor*, const char*); + TextBox(const TextBox&, gfx::Device*, uint16_t); + TextBox(const TextBox&, gfx::Device*, uint16_t, ResourceAccessor*, const char*); + virtual void InitializeString(BuildResultInformation*, gfx::Device*, const BuildArgSet&, + const InitializeStringParam&); + virtual ~TextBox(); + virtual void Finalize(gfx::Device*); + const uint16_t* GetString() const; + const char* GetStringUtf8() const; + const uint16_t* GetStringBuffer() const; + const char* GetStringBufferUtf8() const; + uint16_t GetStringLength() const; + uint16_t GetStringBufferLength() const; + uint16_t GetDrawStringBufferLength() const; + virtual void AllocateStringBuffer(gfx::Device*, uint16_t); + virtual void AllocateStringBuffer(gfx::Device*, uint16_t, uint16_t); + virtual void FreeStringBuffer(gfx::Device*); + virtual uint16_t SetString(const uint16_t*, uint16_t); + virtual uint16_t SetString(const uint16_t*, uint16_t, uint16_t); + virtual uint16_t SetStringUtf8(const char*, uint16_t); + virtual uint16_t SetStringUtf8(const char*, uint16_t, uint16_t); + const util::Unorm8x4& GetTextColor(int) const; + void SetTextColor(int, const util::Unorm8x4&); + void SetTextColor(const util::Unorm8x4&, const util::Unorm8x4&); + const font::Font* GetFont() const; + void SetFont(const font::Font*); + const Size& GetFontSize() const; + void SetFontSize(const Size&); + float GetLineSpace() const; + void SetLineSpace(float); + float GetCharSpace() const; + void SetCharSpace(float); + HorizontalPosition GetTextPositionX() const; + void SetTextPositionX(HorizontalPosition); + VerticalPosition GetTextPositionY() const; + void SetTextPositionY(VerticalPosition); + TextAlignment GetTextAlignment() const; + void SetTextAlignment(TextAlignment); + TagProcessor* GetTagProcessor() const; + TagProcessorUtf8* GetTagProcessorUtf8() const; + + void SetTagProcessor(TagProcessor* pTagProcessor) { + if (UpdatePTDirty(m_pTagProcessor.utf16 != pTagProcessor)) { + m_pTagProcessor.utf16 = pTagProcessor; + } + } + + void SetTagProcessorUtf8(TagProcessorUtf8*); + virtual const util::Unorm8x4 GetVertexColor(int) const; + virtual void SetVertexColor(int, const util::Unorm8x4&); + virtual uint8_t GetVertexColorElement(int) const; + virtual void SetVertexColorElement(int, uint8_t); + const font::Rectangle GetTextDrawRect() const; + virtual uint8_t GetMaterialCount() const; + virtual Material* GetMaterial(int) const; + void SetMaterial(Material*); + void UnsetMaterial(); + const char* GetTextId() const; + bool IsWidthLimitEnabled() const; + void SetWidthLimitEnabled(bool); + float GetItalicRatio() const; + void SetItalicRatio(float); + float GetAngleFromItalicRatio() const; + void SetAngleToItalicRatio(float); + const util::Float2& GetShadowOffset() const; + void SetShadowOffset(const util::Float2&); + const util::Float2& GetShadowScale() const; + void SetShadowScale(const util::Float2&); + const util::Unorm8x4& GetShadowTopColor() const; + void SetShadowTopColor(const util::Unorm8x4&); + const util::Unorm8x4& GetShadowBottomColor() const; + void SetShadowBottomColor(const util::Unorm8x4&); + void SetShadowColor(const util::Unorm8x4&, const util::Unorm8x4&); + float GetShadowItalicRatio() const; + void SetShadowItalicRatio(float); + float GetAngleFromShadowItalicRatio() const; + void SetAngleToShadowItalicRatio(float); + void SetDirtyFlag(bool); + void ClearDirtyFlag(); + bool GetDirtyFlag() const; + virtual void SetupTextWriter(font::WideTextWriter*); + virtual void SetupTextWriterUtf8(font::TextWriter*); + + // function exists but I'm using it as a helper for AnimatePaneImpl + void SetPerCharacterTransformOffset(float value) { + m_pPerCharacterTransform->Offset = value; + UpdatePTDirty(true); + } + + // seems to move to the cpp in smo + void SetPerCharacterTransform(int idx, float value); /*{ + switch (idx) { + case AnimTargetPerCharacterTransform_EvalTypeOffset: + m_pPerCharacterTransform->Offset = value; + break; + case AnimTargetPerCharacterTransform_EvalTypeWidth: + m_pPerCharacterTransform->Width = value; + break; + + default: + break; + } + + UpdatePTDirty(true); + }*/ + + float GetPerCharacterTransform(int) const; + bool GetUtf8() const; + void SetInvisibleBorderEnabled(bool); + bool IsInvisibleBorderEnabled() const; + void SetDoubleDrawnBorderEnabled(bool); + bool IsDoubleDrawnBorderEnabled() const; + void SetCenterCeilingEnabled(bool); + bool IsCenterCeilingEnabled() const; + void SetDrawFromRightToLeftEnabled(bool); + bool IsDrawFromRightToLeftEnabled() const; + font::DispStringBuffer* GetDispStringBuffer() const; + void GetTextGlobalMtx(util::MatrixT4x3fType*, const DrawInfo&) const; + virtual void Calculate(DrawInfo&, CalculateContext&, bool); + bool CompareCopiedInstanceTest(const TextBox&) const; + +protected: + virtual void DrawSelf(DrawInfo&, gfx::CommandBuffer&); + virtual void LoadMtx(DrawInfo&); + virtual bool InitializeStringWithTextSearcherInfo(gfx::Device*, const BuildArgSet&, + const TextSearcher::TextInfo&); + virtual bool InitializeStringWithTextSearcherInfoUtf8(gfx::Device*, const BuildArgSet&, + const TextSearcher::TextInfoUtf8&); + void InitializePerCharacterTransformCurves(const ResAnimationInfo*); + void CopyImpl(const TextBox&, gfx::Device*, ResourceAccessor*, const char*); + void CopyImpl(const TextBox&, gfx::Device*, uint16_t, ResourceAccessor*, const char*); + void CopyCommonImpl(const TextBox&); + +private: + void SetFontInfo(font::WideTextWriter*) const; + void SetFontInfoUtf8(font::TextWriter*) const; + void SetTextPos(font::WideTextWriter*) const; + void SetTextPosUtf8(font::TextWriter*) const; + util::Float2 AdjustTextPos(const Size&, bool) const; + void Initialize(); + void InitializeMaterial(); + void CopyLineWidthOffset(const TextBox&); + void CopyPerCharacterTransform(const TextBox&); + void SetupConstantBufferAdditionalContent(font::ConstantBufferAdditionalContent&) const; + void BuildConstantBuffer(DrawInfo&) const; + uint16_t SetStringImpl(const uint16_t*, uint16_t, int); + uint16_t SetStringImplUtf8(const char*, uint16_t, int); + + bool UpdatePTDirty(bool isChanged) { + m_Bits.isPTDirty |= isChanged; + return isChanged; + } + + bool UpdatePTDirty(const util::Unorm8x4&, const util::Unorm8x4&); + const TextBox& operator=(const TextBox&); + float GetLoopFrame(float, float, float) const; + + template + void UpdatePerCharacterTransform(font::TagProcessorBase*); + + template + float CalculateStep(font::TagProcessorBase*); + + template + const void* AcquireNextPrintableChar(uint32_t*, font::TagProcessorBase*, const void*); + + bool ValidateNextPrintableChar(const char*, const char*); + bool ValidateNextPrintableChar(const uint16_t*, const uint16_t*); + uint32_t GetCharFromPointer(const char*); + uint32_t GetCharFromPointer(const uint16_t*); + void ApplyPerCharacterTransformCurve(font::PerCharacterTransformInfo*, float); + + union { + uint16_t* utf16; + char* utf8; + void* neutral; + } m_TextBuf; + + const char* m_pTextId; + util::Unorm8x4 m_TextColors[2]; + const font::Font* m_pFont; + Size m_FontSize; + float m_LineSpace; + float m_CharSpace; + + union { + TagProcessor* utf16; + TagProcessorUtf8* utf8; + void* neutral; + } m_pTagProcessor; + + uint16_t m_TextBufLen; + uint16_t m_TextLen; + + struct Bits { + uint8_t textAlignment : 2; + uint8_t isPTDirty : 1; + bool shadowEnabled : 1; + bool invisibleBorderEnabled : 1; + bool doubleDrawnBorderEnabled : 1; + bool widthLimitEnabled : 1; + bool perCharacterTransformEnabled : 1; + /* Bits is 1 byte in botw and smo + bool centerCeilingEnabled : 1; + bool perCharacterTransformSplitByCharWidth : 1; + bool perCharacterTransformAutoShadowAlpha : 1; + bool drawFromRightToLeft : 1; + bool perCharacterTransformOriginToCenter : 1; + */ + }; + + Bits m_Bits; + uint8_t _11d; + uint8_t m_TextPosition; + bool m_IsUtf8; + float m_ItalicRatio; + util::Float2 m_ShadowOffset; + util::Float2 m_ShadowScale; + util::Unorm8x4 m_ShadowTopColor; + util::Unorm8x4 m_ShadowBottomColor; + float m_ShadowItalicRatio; + + struct LineWidthOffset { + float* pLineWidth; + float* pLineOffset; + }; + + LineWidthOffset* m_pLineWidthOffset; + Material* m_pMaterial; + font::DispStringBuffer* m_pDispStringBuf; + + struct CurveInfo { + const ResAnimationTarget* pCurve; + AnimTargetPerCharacterTransformCurve CurveType; + }; + + struct PerCharacterTransform { + float Offset; + float Width; + font::PerCharacterTransformInfo* pPerCharacterTransformInfos; + uint8_t LoopType; + uint8_t OriginV; + uint8_t CurveNumber; + uint8_t Dummy; + float OriginVOffset; + CurveInfo CurveInfos[1]; + }; + + PerCharacterTransform* m_pPerCharacterTransform; +}; + +} // namespace ui2d +} // namespace nn diff --git a/include/nn/ui2d/ui2d_TextSearcher.h b/include/nn/ui2d/ui2d_TextSearcher.h new file mode 100644 index 0000000..24db804 --- /dev/null +++ b/include/nn/ui2d/ui2d_TextSearcher.h @@ -0,0 +1,30 @@ +#pragma once + +#include + +namespace nn { +namespace ui2d { + +class TextSearcher { +public: + struct TextInfo { + const uint16_t* pText; + int32_t textLength; + int32_t bufferLength; + int32_t forceAssignedTextLength; + + void SetDefault(); + }; + + struct TextInfoUtf8 { + const char* pText; + int32_t textLength; + int32_t bufferLength; + int32_t forceAssignedTextLength; + + void SetDefault(); + }; +}; + +} // namespace ui2d +} // namespace nn diff --git a/include/nn/ui2d/ui2d_Types.h b/include/nn/ui2d/ui2d_Types.h new file mode 100644 index 0000000..731527e --- /dev/null +++ b/include/nn/ui2d/ui2d_Types.h @@ -0,0 +1,769 @@ +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace nn { +namespace ui2d { + +class Layout; + +const int ResourceNameStrMax = 24; +const int TexMapMax = 3; +const int TevStageMax = 6; +const int MatColorMax = 2; +const int TexImageNameMax = 128; +const int ShaderNameMax = 8; +const int ArchiveShaderNameMax = 6; +const int GroupNameStrMax = 32; +const int ConstantBufferCount = 2; +const int DetailedCombinerConstantColor = 5; +const int ShaderVariationCountPerBlend = 3; +const int TextBoxLineWidthOffsetCount = 16; +const int CombinerUserShaderConstantColor = 5; +const size_t CaptureTexturePathMax = 64; +const size_t CaptureTexturePartsLayerMax = 8; +const char CaptureTexturePathSeparator = '%'; + +static const char* ArchiveShaderFileName; +static const char* ArchiveShaderRegistrationName; +static const char* ArchiveShaderRegistrationNameWithDetailedCombiner; +static const char* ArchiveShaderRegistrationNameWithCombinerUserShader; +static const char* ArchiveShaderVariationTableFileName; +static const char* IndividualArchiveShaderVariationTableBaseName; +static const char* IndividualArchiveShaderVariationTableExtensionName; + +const int IndividualArchiveShaderVariationTableFirstBlendWithDetailedCombiner = 110; +const int IndividualArchiveShaderVariationTableFirstBlendWithCombinerUserShader = 111; +const int IndividualArchiveShaderVariationTableFirstBlendWithMaskShader = 120; +const int PerspectiveTextureProjectionDefaultShader = 250; +const int PerspectiveTextureProjectionBlendShaderOffset = 200; +const int DetailedCombinerStageBitsCountWithVariationTable = 24; + +static const char* pCombinerUserShaderExtUserData_Vec3[4]; +static const char* pCombinerUserShaderExtUserData_Vec2[4]; +static const char* pCombinerUserShaderExtUserData_Rgba[4]; +static const char* pCombinerUserShaderExtUserData_IVec2[4]; +static const char* pCombinerUserShaderExtUserData_Int[4]; +static const char* pCombinerUserShaderExtUserData_Float[4]; + +namespace detail { + +template +void SetBit(T* pBits, int pos, bool val) { + const T mask = static_cast(1 << pos); + *pBits &= ~mask; + *pBits |= mask * val; +} + +template +bool TestBit(T bits, int pos) { + const T mask = static_cast(1 << pos); + return bits & mask; +} + +} // namespace detail + +template +TToPtr DynamicCast(TFrom* obj) { + return font::DynamicCast(obj); +} + +template +bool IsDerivedFrom(const From* instance) { + return font::IsDerivedFrom(instance); +} + +typedef bool (*RegisterTextureViewSlot)(gfx::DescriptorSlot*, const gfx::TextureView&, void*); +typedef bool (*RegisterSamplerSlot)(gfx::DescriptorSlot*, const gfx::Sampler&, void*); +typedef void (*UnregisterTextureViewSlot)(gfx::DescriptorSlot*, const gfx::TextureView&, void*); +typedef void (*UnregisterSamplerSlot)(gfx::DescriptorSlot*, const gfx::Sampler&, void*); + +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 +}; + +enum SystemDataType { + SystemDataType_SimpleAABBMesh, + SystemDataType_SimpleOBBMesh, + SystemDataType_AlignmentExInfo, + SystemDataType_MaskTexture, + SystemDataType_CaptureTextureRuntimeCopyInfo = 16, + SystemDataType_MaskTextureRuntimeInfo, + SystemDataType_Max +}; + +enum HorizontalPosition { + HorizontalPosition_Center, + HorizontalPosition_Left, + HorizontalPosition_Right, + HorizontalPosition_MaxHorizontalPosition +}; + +enum VerticalPosition { + VerticalPosition_Center, + VerticalPosition_Top, + VerticalPosition_Bottom, + VerticalPosition_MaxVerticalPosition +}; + +enum TexWrap { TexWrap_Clamp, TexWrap_Repeat, TexWrap_Mirror, TexWrap_MaxTexWrap }; + +typedef gfx::ImageFormat TexFormat; + +enum TexFilter { TexFilter_Near, TexFilter_Linear, TexFilter_MaxTexFilter }; + +enum TexProjectionFlag { + TexProjectionFlag_FittingLayoutSize, + TexProjectionFlag_FittingPaneSizeEnabled, + TexProjectionFlag_AdjustProjectionScaleRotateEnabled, + TexProjectionFlag_MaxTexProjectionFlag +}; + +enum TevMode { + TevMode_Replace, + TevMode_Modulate, + TevMode_Add, + TevMode_AddSigned, + TevMode_Interpolate, + TevMode_Subtract, + TevMode_AddMultiply, + TevMode_MultiplyAdd, + TevMode_Overlay, + TevMode_Lighten, + TevMode_Darken, + TevMode_Indirect, + TevMode_BlendIndirect, + TevMode_EachIndirect, + TevMode_MaxTevMode +}; + +enum AlphaTest { + AlphaTest_Never, + AlphaTest_Less, + AlphaTest_LessEqual, + AlphaTest_Equal, + AlphaTest_NotEqual, + AlphaTest_GreaterEqual, + AlphaTest_Greater, + AlphaTest_Always, + AlphaTest_MaxAlphaTest +}; + +enum BlendFactor { + BlendFactor_0, + BlendFactor_1, + BlendFactor_DstColor, + BlendFactor_InvDstColor, + BlendFactor_SrcAlpha, + BlendFactor_InvSrcAlpha, + BlendFactor_DstAlpha, + BlendFactor_InvDstAlpha, + BlendFactor_SrcColor, + BlendFactor_InvSrcColor, + BlendFactor_MaxBlendFactor +}; + +enum BlendOp { + BlendOp_Disable, + BlendOp_Add, + BlendOp_Subtract, + BlendOp_ReverseSubtract, + BlendOp_SelectMin, + BlendOp_SelectMax, + BlendOp_MaxBlendOp +}; + +enum LogicOp { + LogicOp_Disable, + LogicOp_Noop, + LogicOp_Clear, + LogicOp_Set, + LogicOp_Copy, + LogicOp_InvCopy, + LogicOp_Inv, + LogicOp_And, + LogicOp_Nand, + LogicOp_Or, + LogicOp_Nor, + LogicOp_Xor, + LogicOp_Equiv, + LogicOp_RevAnd, + LogicOp_InvAnd, + LogicOp_RevOr, + LogicOp_InvOr, + LogicOp_MaxLogicOp +}; + +enum TexGenType { TexGenType_Mtx2x4, TexGenType_MaxTexGenType }; + +enum TexGenSrc { + TexGenSrc_Tex0, + TexGenSrc_Tex1, + TexGenSrc_Tex2, + TexGenSrc_OrthoProjection, + TexGenSrc_PaneBaseOrthoProjection, + TexGenSrc_PerspectiveProjection, + TexGenSrc_PaneBasePerspectiveProjection, + TexGenSrc_MaxTexGenSrc +}; + +enum TextureFlip { + TextureFlip_None, + TextureFlip_FlipU, + TextureFlip_FlipV, + TextureFlip_Rotate90, + TextureFlip_Rotate180, + TextureFlip_Rotate270, + TextureFlip_MaxTextureFlip +}; + +enum TextBoxFlag { + TextBoxFlag_ShadowEnabled, + TextBoxFlag_ForceAssignTextLength, + TextBoxFlag_InvisibleBorderEnabled, + TextBoxFlag_DoubleDrawnBorderEnabled, + TextBoxFlag_PerCharacterTransformEnabled, + TextBoxFlag_CenterCeilingEnabled, + TextBoxFlag_LineWidthOffsetEnabled, + TextBoxFlag_ExtendedTagEnabled, + TextBoxFlag_PerCharacterTransformSplitByCharWidth, + TextBoxFlag_PerCharacterTransformAutoShadowAlpha, + TextBoxFlag_DrawFromRightToLeft, + TextBoxFlag_PerCharacterTransformOriginToCenter, + TextBoxFlag_MaxTextBoxFlag +}; + +enum TextBoxOverrideUsageFlag { + TextBoxOverrideUsageFlag_TextEnabled, + TextBoxOverrideUsageFlag_MaxTextBoxOverrideUsageFlag +}; + +enum BasicOverrideUsageFlag { + BasicOverrideUsageFlag_VisibleEnabled, + BasicOverrideUsageFlag_VisibleValue, + BasicOverrideUsageFlag_BasicUserDataEnabled, + BasicOverrideUsageFlag_TranslateEnabled, + BasicOverrideUsageFlag_SizeEnabled, + BasicOverrideUsageFlag_ScaleEnabled, + BasicOverrideUsageFlag_RotateEnabled, + BasicOverrideUsageFlag_AlphaEnabled, + BasicOverrideUsageFlag_MaxBasicOverrideUsageFlag +}; + +enum MaterialOverrideUsageFlag { + MaterialOverrideUsageFlag_InterpolateColorEnabled, + MaterialOverrideUsageFlag_TextureEnabled, + MaterialOverrideUsageFlag_OverrideCaptureTextureResources, + MaterialOverrideUsageFlag_MaxMaterialOverrideUsageFlag +}; + +enum ExtUserDataOverrideOffset { + ExtUserDataOverrideOffset_NoOverride, + ExtUserDataOverrideOffset_NoData +}; + +enum TextAlignment { + TextAlignment_Synchronous, + TextAlignment_Left, + TextAlignment_Center, + TextAlignment_Right, + TextAlignment_MaxTextAlignment +}; + +enum VertexColor { + VertexColor_LeftTop, + VertexColor_RightTop, + VertexColor_LeftBottom, + VertexColor_RightBottom, + VertexColor_MaxVertexColor +}; + +enum WindowFlag { + WindowFlag_UseOneMaterialForAll, + WindowFlag_UseVertexColorAll, + WindowFlag_WindowKind0, + WindowFlag_WindowKind1, + WindowFlag_NotDrawContent, + WindowFlag_MaxWindowFlag, + WindowFlag_WindowKindLength = 2 +}; + +enum WindowFrame { + WindowFrame_LeftTop, + WindowFrame_RightTop, + WindowFrame_LeftBottom, + WindowFrame_RightBottom, + WindowFrame_Left, + WindowFrame_Right, + WindowFrame_Top, + WindowFrame_Bottom, + WindowFrame_MaxWindowFrame +}; + +enum WindowInflationFixedPoint { + WindowInflationFixedPoint_FractionalBit = 4, + WindowInflationFixedPoint_IntegerBit = 11, + WindowInflationFixedPoint_SignBit = 1, + WindowInflationFixedPoint_ScalingFactor = 16 +}; + +enum TextColor { TextColor_Top, TextColor_Bottom, TextColor_MaxTextColor }; + +enum InterpolateColor { + InterpolateColor_Black, + InterpolateColor_White, + InterpolateColor_MaxInterpolateColor +}; + +enum PicturePaneFlag { PicturePaneFlag_ShapeBinaryIndex, PicturePaneFlag_Max }; + +enum ExtUserDataType { + ExtUserDataType_String, + ExtUserDataType_Int, + ExtUserDataType_Float, + ExtUserDataType_SystemData, + ExtUserDataType_MaxExtUserDataType +}; + +enum AnimContentType { + AnimContentType_Pane, + AnimContentType_Material, + AnimContentType_ExtUserData, + AnimContentType_MaxAnimContentType +}; + +enum AnimTagFlag { AnimTagFlag_DescendingBind, AnimTagFlag_MaxAnimTagFlag }; + +enum AnimTargetPane { + AnimTargetPane_TranslateX, + AnimTargetPane_TranslateY, + AnimTargetPane_TranslateZ, + AnimTargetPane_RotateX, + AnimTargetPane_RotateY, + AnimTargetPane_RotateZ, + AnimTargetPane_ScaleX, + AnimTargetPane_ScaleY, + AnimTargetPane_SizeWidth, + AnimTargetPane_SizeHeight, + AnimTargetPane_MaxAnimTargetPane +}; + +enum AnimTargetVisibility { + AnimTargetVisibility_Visibility, + AnimTargetVisibility_MaxAnimTargetVisibility +}; + +enum AnimTargetPaneColor { + AnimTargetPaneColor_VertexLtR, + AnimTargetPaneColor_VertexLtG, + AnimTargetPaneColor_VertexLtB, + AnimTargetPaneColor_VertexLtA, + AnimTargetPaneColor_VertexRtR, + AnimTargetPaneColor_VertexRtG, + AnimTargetPaneColor_VertexRtB, + AnimTargetPaneColor_VertexRtA, + AnimTargetPaneColor_VertexLbR, + AnimTargetPaneColor_VertexLbG, + AnimTargetPaneColor_VertexLbB, + AnimTargetPaneColor_VertexLbA, + AnimTargetPaneColor_VertexRbR, + AnimTargetPaneColor_VertexRbG, + AnimTargetPaneColor_VertexRbB, + AnimTargetPaneColor_VertexRbA, + AnimTargetPaneColor_PaneAlpha, + AnimTargetPaneColor_MaxVertex = AnimTargetPaneColor_PaneAlpha, + AnimTargetPaneColor_MaxAnimTargetPaneColor +}; + +enum AnimTargetMatColor { + AnimTargetMatColor_BufferR, + AnimTargetMatColor_BufferG, + AnimTargetMatColor_BufferB, + AnimTargetMatColor_BufferA, + AnimTargetMatColor_Konst0R, + AnimTargetMatColor_Konst0G, + AnimTargetMatColor_Konst0B, + AnimTargetMatColor_Konst0A, + AnimTargetMatColor_C0_R, + AnimTargetMatColor_C0_G, + AnimTargetMatColor_C0_B, + AnimTargetMatColor_C0_A, + AnimTargetMatColor_C1_R, + AnimTargetMatColor_C1_G, + AnimTargetMatColor_C1_B, + AnimTargetMatColor_C1_A, + AnimTargetMatColor_C2_R, + AnimTargetMatColor_C2_G, + AnimTargetMatColor_C2_B, + AnimTargetMatColor_C2_A, + AnimTargetMatColor_C3_R, + AnimTargetMatColor_C3_G, + AnimTargetMatColor_C3_B, + AnimTargetMatColor_C3_A, + AnimTargetMatColor_C4_R, + AnimTargetMatColor_C4_G, + AnimTargetMatColor_C4_B, + AnimTargetMatColor_C4_A, + AnimTargetMatColor_MaxAnimTargetMatColor +}; + +enum AnimTargetMatColorFloat { + AnimTargetMatColorFloat_BufferR = AnimTargetMatColor_MaxAnimTargetMatColor, + AnimTargetMatColorFloat_BufferG, + AnimTargetMatColorFloat_BufferB, + AnimTargetMatColorFloat_BufferA, + AnimTargetMatColorFloat_Konst0R, + AnimTargetMatColorFloat_Konst0G, + AnimTargetMatColorFloat_Konst0B, + AnimTargetMatColorFloat_Konst0A, + AnimTargetMatColorFloat_C0_R, + AnimTargetMatColorFloat_C0_G, + AnimTargetMatColorFloat_C0_B, + AnimTargetMatColorFloat_C0_A, + AnimTargetMatColorFloat_C1_R, + AnimTargetMatColorFloat_C1_G, + AnimTargetMatColorFloat_C1_B, + AnimTargetMatColorFloat_C1_A, + AnimTargetMatColorFloat_C2_R, + AnimTargetMatColorFloat_C2_G, + AnimTargetMatColorFloat_C2_B, + AnimTargetMatColorFloat_C2_A, + AnimTargetMatColorFloat_C3_R, + AnimTargetMatColorFloat_C3_G, + AnimTargetMatColorFloat_C3_B, + AnimTargetMatColorFloat_C3_A, + AnimTargetMatColorFloat_C4_R, + AnimTargetMatColorFloat_C4_G, + AnimTargetMatColorFloat_C4_B, + AnimTargetMatColorFloat_C4_A, + AnimTargetMatColorFloat_MaxAnimTargetMatColor +}; + +enum AnimTargetTexSrt { + AnimTargetTexSrt_TranslateS, + AnimTargetTexSrt_TranslateT, + AnimTargetTexSrt_Rotate, + AnimTargetTexSrt_ScaleS, + AnimTargetTexSrt_ScaleT, + AnimTargetTexSrt_MaxAnimTargetTexSrt +}; + +enum AnimTargetTexPattern { + AnimTargetTexPattern_Image, + AnimTargetTexPattern_MaxAnimTargetTexPattern +}; + +enum AnimTargetIndirectSrt { + AnimTargetIndirectSrt_Rotate, + AnimTargetIndirectSrt_ScaleS, + AnimTargetIndirectSrt_ScaleT, + AnimTargetIndirectSrt_MaxAnimTargetIndirectSrt +}; + +enum AnimTargetFontShadow { + AnimTargetFontShadow_BlackInterporateColorR, + AnimTargetFontShadow_BlackInterporateColorG, + AnimTargetFontShadow_BlackInterporateColorB, + AnimTargetFontShadow_WhiteInterporateColorR, + AnimTargetFontShadow_WhiteInterporateColorG, + AnimTargetFontShadow_WhiteInterporateColorB, + AnimTargetFontShadow_WhiteInterporateColorA, + AnimTargetFontShadow_MaxAnimTargetFontShadow +}; + +enum AnimTargetPerCharacterTransform { + AnimTargetPerCharacterTransform_EvalTypeOffset, + AnimTargetPerCharacterTransform_EvalTypeWidth, + AnimTargetPerCharacterTransform_MaxAnimTargetPerCharacterTransform +}; + +enum AnimTargetPerCharacterTransformCurve { + AnimTargetPerCharacterTransformCurve_TranslateX, + AnimTargetPerCharacterTransformCurve_TranslateY, + AnimTargetPerCharacterTransformCurve_TranslateZ, + AnimTargetPerCharacterTransformCurve_RotateX, + AnimTargetPerCharacterTransformCurve_RotateY, + AnimTargetPerCharacterTransformCurve_RotateZ, + AnimTargetPerCharacterTransformCurve_LeftTopR, + AnimTargetPerCharacterTransformCurve_LeftTopG, + AnimTargetPerCharacterTransformCurve_LeftTopB, + AnimTargetPerCharacterTransformCurve_LeftTopA, + AnimTargetPerCharacterTransformCurve_LeftBottomR, + AnimTargetPerCharacterTransformCurve_LeftBottomG, + AnimTargetPerCharacterTransformCurve_LeftBottomB, + AnimTargetPerCharacterTransformCurve_LeftBottomA, + AnimTargetPerCharacterTransformCurve_ScaleX, + AnimTargetPerCharacterTransformCurve_ScaleY, + AnimTargetPerCharacterTransformCurve_MaxAnimTargetPerCharacterTransformCurve +}; + +enum AnimTargetWindow { + AnimTargetWindow_FrameTop, + AnimTargetWindow_FrameBottom, + AnimTargetWindow_FrameLeft, + AnimTargetWindow_FrameRight, + AnimTargetWindow_MaxAnimTargetWindow +}; + +enum PerCharacterTransformLoopType { + PerCharacterTransformLoopType_OneTime, + PerCharacterTransformLoopType_Loop, + PerCharacterTransformLoopType_MaxPerCharacterTransformLoopType +}; + +enum AnimTargetAlphaCompare { + AnimTargetAlphaCompare_Ref, + AnimTargetAlphaCompare_MaxAnimTargetAlphaCompare +}; + +enum AnimTargetMaskTexMtxSrt { + AnimTargetMaskTexSrt_TranslateX, + AnimTargetMaskTexSrt_TranslateY, + AnimTargetMaskTexSrt_Rotate, + AnimTargetMaskTexSrt_ScaleX, + AnimTargetMaskTexSrt_ScaleY, + AnimTargetMaskTexSrt_MaxAnimTargetMask +}; + +enum AnimCurve { + AnimCurve_Constant, + AnimCurve_Step, + AnimCurve_Hermite, + AnimCurve_ParameterizedAnim, + AnimCurve_MaxAnimCurve +}; + +enum ShaderVariation { + ShaderVariation_Standard, + ShaderVariation_WithoutVertexColor, + ShaderVariation_GfxPrimitive, + ShaderVariation_MaxShaderVariation +}; + +enum RenderTargetTextureLifetime { + RenderTargetTextureLifetime_Layout, + RenderTargetTextureLifetime_OneFrame, + RenderTargetTextureLifetime_Max, + RenderTargetTextureLifetime_Invalid = -1 +}; + +struct WindowFrameSize { + float left; + float right; + float top; + float bottom; +}; + +struct Size { + static Size Create(float, float); + + void Set(float aWidth, float aHeight) { + width = aWidth; + height = aHeight; + } + + float width; + float height; +}; + +class TexSize { +public: + TexSize() : width(0), height(0) {} + TexSize(uint16_t aWidth, uint16_t aHeight) : width(aWidth), height(aHeight) {} + TexSize(const TexSize& other) : width(other.width), height(other.height) {} + + uint16_t width; + uint16_t height; +}; + +class TextureInfo { + NN_NO_COPY(TextureInfo); + +public: + NN_RUNTIME_TYPEINFO_BASE(); + + static const uint64_t InvalidSlot = 0xFFFFFFFFFFFFFFFF; + + TextureInfo() { ResetTextureDescriptorSlot(); } + + virtual ~TextureInfo() = default; + virtual void Finalize(gfx::Device*) = 0; + + void ResetTextureDescriptorSlot() { m_DescriptorSlot.ToData()->value = InvalidSlot; } + + void Set(const TextureInfo& value); + virtual const TexSize GetSize() const = 0; + + virtual TexFormat GetFormat() const { return gfx::ImageFormat_Undefined; } + + virtual bool IsValid() const = 0; + + bool IsTextureDescriptorSlotReady() const { + return m_DescriptorSlot.ToData()->value != InvalidSlot; + } + + virtual const gfx::TextureView* GetTextureView() const = 0; + virtual gfx::TextureView* GetTextureView() = 0; + + const gfx::DescriptorSlot* GetTextureDescriptorSlot() const { return &m_DescriptorSlot; } + gfx::DescriptorSlot* GetTextureDescriptorSlot() { return &m_DescriptorSlot; } + +private: + static bool IsPowerOfTwo(int); + + gfx::DescriptorSlot m_DescriptorSlot; +}; + +class PlacementTextureInfo : public TextureInfo { + NN_NO_COPY(PlacementTextureInfo); + +public: + NN_RUNTIME_TYPEINFO(TextureInfo); + + PlacementTextureInfo() {} + + virtual ~PlacementTextureInfo() = default; + virtual void Finalize(gfx::Device* pDevice) { NN_UNUSED(pDevice); } + + void SetSize(int width, int height) { + m_Size.width = width; + m_Size.height = height; + } + + virtual const TexSize GetSize() const { return m_Size; } + + virtual bool IsValid() const { return IsTextureDescriptorSlotReady(); } + + virtual const gfx::TextureView* GetTextureView() const { return nullptr; } + virtual gfx::TextureView* GetTextureView() { return nullptr; } + +private: + TexSize m_Size; +}; + +class ResourceTextureInfo : public TextureInfo { + NN_NO_COPY(ResourceTextureInfo); + +public: + NN_RUNTIME_TYPEINFO(TextureInfo); + + ResourceTextureInfo() : m_pResTexture(nullptr) {} + + virtual ~ResourceTextureInfo() = default; + + virtual bool IsValid() const { + const TexSize size = GetSize(); + return size.width != 0 && size.height != 0; + } + + virtual const TexSize GetSize() const { + gfx::TextureInfo* pTextureInfo = m_pResTexture->GetTextureInfo(); + return TexSize(pTextureInfo->GetWidth(), pTextureInfo->GetHeight()); + } + + const gfx::Texture* GetTexture() const { return m_pResTexture->GetTexture(); } + gfx::Texture* GetTexture() { return m_pResTexture->GetTexture(); } + + virtual const gfx::TextureView* GetTextureView() const { + return m_pResTexture->GetTextureView(); + } + + virtual gfx::TextureView* GetTextureView() { return m_pResTexture->GetTextureView(); } + + const gfx::ResTexture* GetResTexture() const { return m_pResTexture; } + + virtual TexFormat GetFormat() const { + return m_pResTexture->GetTextureInfo()->GetImageFormat(); + } + + void InitializeFromResource(gfx::Device* pDevice, gfx::ResTexture* pResTexture); + + virtual void Finalize(gfx::Device* pDevice) { + if (m_pResTexture) { + gfx::Texture* pTexture = m_pResTexture->GetTexture(); + if (pTexture && gfx::IsInitialized(*pTexture)) { + m_pResTexture->Finalize(pDevice); + m_pResTexture = nullptr; + } + } + } + +private: + gfx::ResTexture* m_pResTexture; +}; + +class RenderTargetTextureInfo : public PlacementTextureInfo { + NN_NO_COPY(RenderTargetTextureInfo); + +public: + NN_RUNTIME_TYPEINFO(PlacementTextureInfo); + + RenderTargetTextureInfo(); + + virtual ~RenderTargetTextureInfo(); + virtual bool IsValid() const; + const gfx::Texture* GetTexture() const; + gfx::Texture* GetTexture(); + virtual const gfx::TextureView* GetTextureView() const; + virtual gfx::TextureView* GetTextureView(); + gfx::ColorTargetView* GetColorTargetView(); + const gfx::ColorTargetView* GetColorTargetView() const; + gfx::ViewportScissorState* GetViewportScissorState(); + const gfx::ViewportScissorState* GetViewportScissorState() const; + virtual TexFormat GetFormat() const; + RenderTargetTextureLifetime GetLifetime() const; + void Initialize(gfx::Device*, const gfx::TextureInfo&, RenderTargetTextureLifetime); + void Initialize(gfx::Device*, const Layout*, const gfx::TextureInfo&, + RenderTargetTextureLifetime); + virtual void Finalize(gfx::Device*); + +private: + gfx::Texture* m_pTexture; + gfx::TextureView* m_pTextureView; + gfx::DescriptorSlot* m_pTextureSlot; + const Layout* m_pOwnerLayout; + gfx::ColorTargetView m_ColorTargetView; + gfx::ViewportScissorState m_ViewportScissorState; + TexFormat m_Format; + RenderTargetTextureLifetime m_LifeTime; +}; + +typedef util::Float2 TexCoordQuad[4]; +typedef const void* FontKey; +typedef uint32_t ResType; + +enum HorizontalAlignment { + HorizontalAlignment_Left, + HorizontalAlignment_Center, + HorizontalAlignment_Right, + HorizontalAlignment_Max +}; + +} // namespace ui2d +} // namespace nn diff --git a/include/nn/ui2d/ui2d_Util.h b/include/nn/ui2d/ui2d_Util.h new file mode 100644 index 0000000..df8acbf --- /dev/null +++ b/include/nn/ui2d/ui2d_Util.h @@ -0,0 +1,112 @@ +#pragma once + +#include +#include +#include +#include +#include + +namespace nn { + +namespace font { +class Font; +} + +namespace gfx { +class ResShaderContainer; +class ResShaderProgram; +class ResShaderVariation; +} // namespace gfx + +namespace ui2d { + +class AnimTransform; +class DrawInfo; +class Group; +class Layout; +class Pane; +class Material; +class ResourceAccessor; +struct ResHermiteKey; +struct ResParameterizedAnim; +class ResParameterizedAnimParameter; +class ResourceTextureInfo; +class ShaderInfo; +struct ResExtUserDataList; +class ResExtUserData; +struct BuildArgSet; + +bool LoadTexture(ResourceTextureInfo*, gfx::Device*, const void*); +void LoadArchiveShader(ShaderInfo*, gfx::Device*, void*, const void*, gfx::MemoryPool*, long, + unsigned long); +void FreeArchiveShader(gfx::Device*, ShaderInfo*); +void ConvertBlendsToArchiveShaderName(char*, int, int); +void ConvertStageBitsToArchiveShaderDetailedCombinerName(char*, int, int, int, int*); +bool ConvertArchiveShaderNameToBlends(int*, int*, const char*); +void ConvertArchiveShaderDetailedCombinerNameToStageBits(int*, const char*); +int SearchShaderVariationIndexFromTable(const void*, int, int); +int SearchShaderVariationDetailedCombinerIndexFromTable(const void*, int*); +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* ClonePaneTree(const Pane*, gfx::Device*, ResourceAccessor*, const char*); +Pane* ClonePaneTreeWithPartsLayout(const Pane*, Layout*, gfx::Device*, Layout*); +Pane* ClonePaneTreeWithPartsLayout(const Pane*, Layout*, gfx::Device*, Layout*, ResourceAccessor*, + const char*); +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*, int); + +float GetParameterizedAnimValue(float, float, const ResParameterizedAnim*); +float GetParameterizedAnimValueAtFrame(float, const ResParameterizedAnimParameter*); +const ResExtUserData* GetExtUserData(const ResExtUserDataList*, const char*); +size_t GetAlignedBufferSize(gfx::Device*, gfx::GpuAccess, unsigned long); +void SetDefaultShaderId(Material*, int); +bool IsResShaderContainerInitialized(gfx::ResShaderContainer*); +bool IsResShaderProgramInitialized(gfx::ResShaderProgram*); +void MakeCaptureTextureName(char*, unsigned long, const char*, const char*); +size_t CalcCaptureTexturePrefixLength(const BuildArgSet&, int); +void ConcatCaptureTexturePrefixString(char*, unsigned long, const BuildArgSet&, int); +const TextureInfo* AcquireCaptureTextureWithResolvePrefix(char*, int, const BuildArgSet&, bool, + gfx::Device*, ResourceAccessor*, + const char*); +const TextureInfo* AcquireCaptureTexture(char*, int, gfx::Device*, ResourceAccessor*, const char*, + const char*); +gfx::ShaderCodeType TryInitializeAndGetShaderCodeType(gfx::Device*, gfx::ResShaderVariation*); + +class ComplexFontHelper { + typedef void* (*AcquireFontFunction)(size_t*, const char*, ResType, void*); + +public: + static int SetupTextureCacheArg(font::TextureCache::InitializeArg*, AcquireFontFunction, void*, + const void*); + static font::Font* InitializeComplexFontTree(gfx::Device*, font::RegisterTextureViewSlot, void*, + font::TextureCache*, int, AcquireFontFunction, + void*, const void*); + static void FinalizeComplexFontTree(gfx::Device*, font::Font*, font::UnregisterTextureViewSlot, + void*); + +private: + static bool CheckExt(const char*, const char*); + static void DestroyFontTree(gfx::Device*, font::Font*, font::UnregisterTextureViewSlot, void*); + + template + static void BuildTextureCacheArg(const void*, int*, font::TextureCache::InitializeArg*, + AcquireFontFunction, void*, uint32_t); + + template + static font::Font* BuildFontTree(gfx::Device*, font::RegisterTextureViewSlot, void*, + const void*, int*, font::TextureCache*, AcquireFontFunction, + void*, uint32_t); +}; + +} // namespace ui2d +} // namespace nn diff --git a/include/nn/ui2d/ui2d_Window.h b/include/nn/ui2d/ui2d_Window.h new file mode 100644 index 0000000..6e1d70d --- /dev/null +++ b/include/nn/ui2d/ui2d_Window.h @@ -0,0 +1,143 @@ +#pragma once + +#include + +#include + +namespace nn { +namespace ui2d { + +class Material; + +class Window : public Pane { + class Frame { + public: + uint8_t textureFlip; + Material* pMaterial; + + Frame(); + ~Frame(); + TextureFlip GetTextureFlip() const; + }; + +public: + NN_RUNTIME_TYPEINFO(Pane); + + Window(int, int); + Window(int, int, int, int, int); + Window(int, int, int, int, int, int, int, int, int); + Window(BuildResultInformation*, gfx::Device*, const ResWindow*, const ResWindow*, + const BuildArgSet&); + Window(const Window&, gfx::Device*); + Window(const Window&, gfx::Device*, ResourceAccessor*, const char*); + + virtual ~Window(); + virtual void Finalize(gfx::Device*); + virtual const util::Unorm8x4 GetVertexColor(int) const; + virtual void SetVertexColor(int, const util::Unorm8x4&); + virtual uint8_t GetVertexColorElement(int) const; + virtual void SetVertexColorElement(int, uint8_t); + virtual uint8_t GetMaterialCount() const; + virtual Material* GetMaterial(int) const; + Material* GetContentMaterial() const; + void SetContentMaterial(Material*); + Material* GetFrameMaterial(WindowFrame) const; + void SetFrameMaterial(WindowFrame, Material*); + void ReserveTexCoord(int); + uint8_t GetTexCoordCount() const; + void SetTexCoordCount(int); + void GetTexCoord(util::Float2*, int) const; + void SetTexCoord(int, const util::Float2*); + uint8_t GetFrameCount() const; + void CalculateFrameSize(WindowFrameSize*); + + void SetWindowFrameSize(int index, int newSize) { + switch (index) { + case AnimTargetWindow_FrameTop: + m_WindowSize.frameSize.top = newSize; + break; + case AnimTargetWindow_FrameBottom: + m_WindowSize.frameSize.bottom = newSize; + break; + case AnimTargetWindow_FrameLeft: + m_WindowSize.frameSize.left = newSize; + break; + case AnimTargetWindow_FrameRight: + m_WindowSize.frameSize.right = newSize; + break; + default: + break; + } + } + + WindowFrameMode GetWindowFrameMode() const; + virtual Material* FindMaterialByName(const char*, bool); + virtual const Material* FindMaterialByName(const char*, bool) const; + virtual void Calculate(DrawInfo&, Pane::CalculateContext&, bool); + bool CompareCopiedInstanceTest(const Window&) const; + +protected: + virtual void DrawSelf(DrawInfo&, gfx::CommandBuffer&); + void CopyImpl(const Window&, gfx::Device*, ResourceAccessor*, const char*); + +private: + void InitializeTexCount(int, int*, int); + void InitializeUseLeftTopMaterialEmulation(BuildResultInformation*, gfx::Device*); + void InitializeSize(const ResWindow*); + void InitializeContent(int); + void InitializeFrame(int); + void CalculateAroundFrameWindow(DrawInfo&); + void CalculateHorizontalFrameWindow(DrawInfo&); + void CalculateHorizontalFrameNocontentWindow(DrawInfo&); + void CalculateContent(DrawInfo&, const util::Float2&, const WindowFrameSize&, uint8_t); + void CalculateFrame(DrawInfo&, const util::Float2&, const Frame&, const WindowFrameSize&, + uint8_t); + void CalculateHorizontalFrame(DrawInfo&, const util::Float2&, const Frame&, + const WindowFrameSize&, uint8_t); + void CalculateHorizontalNocontentFrame(DrawInfo&, const util::Float2&, const Frame&, + const WindowFrameSize&, uint8_t); + void CalculateHorizontalFrame2(DrawInfo&, const util::Float2&, const Frame*, + const WindowFrameSize&, uint8_t); + void CalculateHorizontalNocontentFrame2(DrawInfo&, const util::Float2&, const Frame*, + const WindowFrameSize&, uint8_t); + void CalculateFrame4(DrawInfo&, const util::Float2&, const Frame*, const WindowFrameSize&, + uint8_t); + void CalculateFrame8(DrawInfo&, const util::Float2&, const Frame*, const WindowFrameSize&, + uint8_t); + + const Window& operator=(const Window&) = delete; + + void Initialize(); + + enum WindowFlags { + WindowFlags_OverallVertexColorEnabled = 1, + WindowFlags_OneMaterialForAllFrameEnabled = 2, + WindowFlags_NotDrawContentEnabled = 4, + WindowFlags_ContentInflationEnabled = 8 + }; + + enum CaptureTextureCopyTarget { + CaptureTextureCopyTarget_Content, + CaptureTextureCopyTarget_Frame0, + CaptureTextureCopyTarget_Frame1, + CaptureTextureCopyTarget_Frame2, + CaptureTextureCopyTarget_Frame3, + CaptureTextureCopyTarget_Frame4, + CaptureTextureCopyTarget_Frame5, + CaptureTextureCopyTarget_Frame6, + CaptureTextureCopyTarget_Frame7, + CaptureTextureCopyTarget_Max + }; + + WindowSize m_WindowSize; + WindowContent m_Content; + uint8_t m_FrameMode; + int8_t m_FrameCount; + uint8_t m_WindowFlags; + Frame* m_pFrames; + Material* m_pMaterial; + uint32_t* m_pUseLeftTopEmulationConstantBuffersOffset; + uint32_t m_UseLeftTopEmulationConstantBufferCount; +}; +} // namespace ui2d +} // namespace nn diff --git a/include/nn/ui2d/ui2d_WindowFoundation.h b/include/nn/ui2d/ui2d_WindowFoundation.h new file mode 100644 index 0000000..fea2d26 --- /dev/null +++ b/include/nn/ui2d/ui2d_WindowFoundation.h @@ -0,0 +1,52 @@ +#pragma once + +#include +#include + +namespace nn { + +namespace ui2d { + +struct Size; + +enum WindowFrameMode { + WindowFrameMode_Around, + WindowFrameMode_Horizontal, + WindowFrameMode_HorizontalNoContent, + WindowFrameMode_MaxWindowFrameMode +}; + +struct WindowContent { + util::Unorm8x4 vtxColors[4]; + detail::TexCoordArray texCoordArray; +}; + +struct WindowFrameSizeInternal { + uint16_t left; + uint16_t right; + uint16_t top; + uint16_t bottom; +}; + +struct WindowSize { + int16_t left; + int16_t right; + int16_t top; + int16_t bottom; + WindowFrameSizeInternal frameSize; +}; + +namespace detail { +struct Rect { + float x; + float y; + float w; + float h; + + const util::Float2 Position() const; + const Size Size() const; +}; + +} // namespace detail +} // namespace ui2d +} // namespace nn diff --git a/include/nn/util.h b/include/nn/util.h index 3e2bc5f..ba3ff6c 100644 --- a/include/nn/util.h +++ b/include/nn/util.h @@ -59,6 +59,8 @@ void ReferSymbol(const void*); static const char var[] __attribute__((section(".api_info"))) = "SDK MW+" company "+" name // todo: move/rename with more info +#define NN_UNUSED(x) (void)(x) + #define NN_NO_COPY(CLASS) \ CLASS(const CLASS&) = delete; \ CLASS& operator=(const CLASS&) = delete diff --git a/include/nn/util/MathTypes.h b/include/nn/util/MathTypes.h deleted file mode 100644 index 92e320e..0000000 --- a/include/nn/util/MathTypes.h +++ /dev/null @@ -1,54 +0,0 @@ -#pragma once - -#include - -namespace nn::util { - -typedef uint32_t AngleIndex; - -struct Float2 { - union { - float v[2]; - struct { - float x; - float y; - }; - }; -}; - -struct Float3 { - union { - float v[3]; - struct { - float x; - float y; - float z; - }; - }; -}; - -struct Float4 { - union { - float v[4]; - struct { - float x; - float y; - float z; - float w; - }; - }; -}; - -struct FloatColumnMajor4x3 { - float m[3][4]; -}; - -struct Unorm8x4 { - union { - uint8_t v[4]; - }; -}; - -typedef Unorm8x4 Color4u8Type; - -} // namespace nn::util diff --git a/include/nn/util/detail/util_ArithmeticImpl.h b/include/nn/util/detail/util_ArithmeticImpl.h index 47632d9..8eafed9 100644 --- a/include/nn/util/detail/util_ArithmeticImpl.h +++ b/include/nn/util/detail/util_ArithmeticImpl.h @@ -1,6 +1,6 @@ #pragma once -#include +#include namespace nn::util::detail { // todo: figure out where to put these @@ -33,4 +33,4 @@ inline float ModPi(float x) { } */ -}; // namespace nn::util::detail \ No newline at end of file +}; // namespace nn::util::detail diff --git a/include/nn/util/detail/util_MathTypes.neon.h b/include/nn/util/detail/util_MathTypes.neon.h new file mode 100644 index 0000000..37a9836 --- /dev/null +++ b/include/nn/util/detail/util_MathTypes.neon.h @@ -0,0 +1,35 @@ +#pragma once + +#include + +namespace nn { +namespace util { +namespace neon { + +struct alignas(16) Vector3fType { + float32x4_t _v; +}; + +struct alignas(16) Vector4fType { + float32x4_t _v; +}; + +struct alignas(16) MatrixRowMajor4x3fType { + float32x4x4_t _m; +}; + +struct alignas(16) MatrixRowMajor4x4fType { + float32x4x4_t _m; +}; + +struct alignas(16) MatrixColumnMajor4x3fType { + float32x4x3_t _m; +}; + +struct alignas(16) MatrixColumnMajor4x4fType { + float32x4x4_t _m; +}; + +} // namespace neon +} // namespace util +} // namespace nn diff --git a/include/nn/util/detail/util_MatrixApi.neon.h b/include/nn/util/detail/util_MatrixApi.neon.h new file mode 100644 index 0000000..d1ee679 --- /dev/null +++ b/include/nn/util/detail/util_MatrixApi.neon.h @@ -0,0 +1,25 @@ +#pragma once + +#include +#include + +namespace nn { +namespace util { +namespace neon { + +void MatrixIdentity(MatrixColumnMajor4x3fType* pOutValue) { + pOutValue->_m = {{ + {1.0f, 0.0f, 0.0f, 0.0f}, + {0.0f, 1.0f, 0.0f, 0.0f}, + {0.0f, 0.0f, 1.0f, 0.0f}, + }}; +} + +void MatrixMultiply(MatrixColumnMajor4x3fType* pOutValue, const MatrixColumnMajor4x3fType& matrix1, + const MatrixColumnMajor4x3fType& matrix2) { + pOutValue->_m = detail::MatrixColumnMajor4x3fMultiply(matrix1._m, matrix2._m); +} + +} // namespace neon +} // namespace util +} // namespace nn diff --git a/include/nn/util/detail/util_MatrixApiDetailImpl.neon.h b/include/nn/util/detail/util_MatrixApiDetailImpl.neon.h new file mode 100644 index 0000000..5514c13 --- /dev/null +++ b/include/nn/util/detail/util_MatrixApiDetailImpl.neon.h @@ -0,0 +1,28 @@ +#pragma once + +namespace nn { +namespace util { +namespace neon { +namespace detail { + +// todo: complicated neon code +float32x4x3_t MatrixColumnMajor4x3fMultiply(float32x4x3_t matrix1, float32x4x3_t matrix2) { + float32x2_t vLow, vHigh; + float32x4_t vTmp; + float32x4x3_t vResult; + float32x4_t vZero; + + NN_UNUSED(matrix1); + NN_UNUSED(matrix2); + NN_UNUSED(vLow); + NN_UNUSED(vHigh); + NN_UNUSED(vTmp); + NN_UNUSED(vZero); + + return vResult; +} + +} // namespace detail +} // namespace neon +} // namespace util +} // namespace nn diff --git a/include/nn/util/detail/util_TypeTraits.h b/include/nn/util/detail/util_TypeTraits.h index cc0aff2..0f13308 100644 --- a/include/nn/util/detail/util_TypeTraits.h +++ b/include/nn/util/detail/util_TypeTraits.h @@ -7,6 +7,11 @@ namespace nn::util::detail { template struct SizedInt; +template <> +struct SizedInt<4> { + typedef uint32_t Unsigned; +}; + template <> struct SizedInt<8> { typedef uint64_t Unsigned; @@ -22,4 +27,4 @@ struct MakeUnsigned { typedef typename ChangeSign::Unsigned Type; }; -} // namespace nn::util::detail \ No newline at end of file +} // namespace nn::util::detail diff --git a/include/nn/util/util_Arithmetic.h b/include/nn/util/util_Arithmetic.h index 6e26c52..e11f8ce 100644 --- a/include/nn/util/util_Arithmetic.h +++ b/include/nn/util/util_Arithmetic.h @@ -1,7 +1,7 @@ #pragma once -#include #include +#include namespace nn::util { @@ -27,4 +27,4 @@ inline float CosTable(AngleIndex angleIndex) { return table->cosValue + table->cosDelta * rest; } -} // namespace nn::util \ No newline at end of file +} // namespace nn::util diff --git a/include/nn/util/util_BytePtr.h b/include/nn/util/util_BytePtr.h index 500c598..64b2f6f 100644 --- a/include/nn/util/util_BytePtr.h +++ b/include/nn/util/util_BytePtr.h @@ -58,7 +58,7 @@ class BytePtr { class ConstBytePtr { public: explicit ConstBytePtr(const void* ptr) : m_Ptr(ptr) {} - ConstBytePtr(const BytePtr&); + ConstBytePtr(const BytePtr& ptr) : ConstBytePtr(ptr.Get()) {} ConstBytePtr(const void* ptr, ptrdiff_t offset) : ConstBytePtr(ptr) { Advance(offset); } void Reset(const void*); diff --git a/include/nn/util/util_IntrusiveList.h b/include/nn/util/util_IntrusiveList.h new file mode 100644 index 0000000..e4dc846 --- /dev/null +++ b/include/nn/util/util_IntrusiveList.h @@ -0,0 +1,356 @@ +#pragma once + +#include +#include + +namespace nn { +namespace util { + +namespace detail { + +class IntrusiveListImplementation; + +} + +class IntrusiveListNode { + NN_NO_COPY(IntrusiveListNode); + +public: + IntrusiveListNode() : m_Prev(this), m_Next(this) {} + + bool IsLinked() const { return m_Next != this; } + +private: + friend class detail::IntrusiveListImplementation; + + IntrusiveListNode* GetPrev() { return m_Prev; } + const IntrusiveListNode* GetPrev() const { return m_Prev; } + IntrusiveListNode* GetNext() { return m_Next; } + const IntrusiveListNode* GetNext() const { return m_Next; } + + void LinkPrev(IntrusiveListNode* node) { LinkPrev(node, node); } + + void LinkPrev(IntrusiveListNode* first, IntrusiveListNode* last) { + IntrusiveListNode* node = last->m_Prev; + first->m_Prev = m_Prev; + node->m_Next = this; + m_Prev->m_Next = first; + m_Prev = node; + } + + void LinkNext(IntrusiveListNode*); + void LinkNext(IntrusiveListNode*, IntrusiveListNode*); + + void Unlink() { Unlink(m_Next); } + + void Unlink(IntrusiveListNode* last) { + IntrusiveListNode* node = last->m_Prev; + m_Prev->m_Next = last; + last->m_Prev = m_Prev; + node->m_Next = this; + m_Prev = node; + } + + IntrusiveListNode* m_Prev; + IntrusiveListNode* m_Next; +}; + +namespace detail { + +class IntrusiveListImplementation { + NN_NO_COPY(IntrusiveListImplementation); + +public: + typedef IntrusiveListNode value_type; + typedef int difference_type; + typedef value_type& reference; + typedef const value_type& const_reference; + typedef int size_type; + + class const_iterator { + public: + typedef const value_type value_type; + typedef difference_type difference_type; + typedef value_type* pointer; + typedef value_type& reference; + + const_iterator(pointer p) : m_Node(p) {} + + reference operator*() const { return *m_Node; } + + pointer operator->() const; + const_iterator& operator++(); + const_iterator operator++(int); + const_iterator& operator--(); + const_iterator operator--(int); + bool operator==(const const_iterator&) const; + bool operator!=(const const_iterator& ci) const { return m_Node != ci.m_Node; } + + private: + pointer m_Node; + }; + + class iterator { + public: + typedef value_type value_type; + typedef value_type* pointer; + typedef value_type& reference; + + iterator(pointer p) : m_Node(p) {} + + operator const_iterator() const { return m_Node; } + + reference operator*() const { return *m_Node; } + pointer operator->() const { return m_Node; } + + iterator& operator++() { + m_Node = m_Node->GetNext(); + return *this; + } + + iterator operator++(int) { + iterator temporary(*this); + ++(*this); + return temporary; + } + + iterator& operator--(); + iterator operator--(int); + bool operator==(const iterator&) const; + + bool operator!=(const iterator& i) const { return m_Node != i.m_Node; } + + private: + pointer m_Node; + }; + + IntrusiveListImplementation() : m_Root() {} + + void push_back(reference node) { m_Root.LinkPrev(&node); } + + void push_front(reference); + void pop_back(); + + void pop_front() { m_Root.GetNext()->Unlink(); } + + reference back(); + reference back() const; + reference front(); + reference front() const; + + iterator begin() { return m_Root.GetNext(); } + const_iterator begin() const { return m_Root.GetNext(); } + + iterator end() { return &m_Root; } + const_iterator end() const { return &m_Root; } + + iterator iterator_to(reference value) { return iterator(&value); } + const_iterator iterator_to(reference value) const { return iterator(&value); } + + size_type size() const; + + bool empty() const { return !m_Root.IsLinked(); } + + iterator erase(const_iterator position) { + iterator temporary(ToMutable(position)); + if (temporary != end()) { + (temporary++)->Unlink(); + } + return temporary; + } + + void clear() { + while (!empty()) { + pop_front(); + } + } + + iterator insert(const_iterator position, reference node) { + ToMutable(position)->LinkPrev(&node); + return iterator(&node); + } + + void splice(const_iterator, IntrusiveListImplementation&); + void splice(const_iterator, IntrusiveListImplementation&, const_iterator); + void splice(const_iterator, IntrusiveListImplementation&, const_iterator, const_iterator); + +private: + void SpliceImplementation(const_iterator, const_iterator, const_iterator); + + iterator ToMutable(const_iterator i) const { return const_cast(&*i); } + + value_type m_Root; +}; + +} // namespace detail + +template +class IntrusiveList { + NN_NO_COPY(IntrusiveList); + +public: + class iterator; + class const_iterator; + + typedef T value_type; + typedef value_type& reference; + typedef const value_type& const_reference; + typedef std::reverse_iterator reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; + typedef int size_type; + + class const_iterator { + public: + typedef T value_type; + typedef value_type* pointer; + typedef value_type& reference; + + reference operator*() const; + pointer operator->() const; + const_iterator& operator++(); + const_iterator operator++(int); + const_iterator& operator--(); + const_iterator operator--(int); + bool operator==(const const_iterator&) const; + bool operator!=(const const_iterator&) const; + + private: + friend class IntrusiveList; + + const_iterator(detail::IntrusiveListImplementation::const_iterator ci) : m_Iterator(ci) {} + + detail::IntrusiveListImplementation::const_iterator GetImplementationIterator() const { + return m_Iterator; + } + + detail::IntrusiveListImplementation::const_iterator m_Iterator; + }; + + class iterator { + public: + typedef T value_type; + typedef value_type* pointer; + typedef value_type& reference; + + operator const_iterator() const { + return static_cast(m_Iterator); + } + + reference operator*() const { return NodeTraits::GetItem(*m_Iterator); } + + pointer operator->() const { return &NodeTraits::GetItem(*m_Iterator); } + + iterator& operator++() { + ++m_Iterator; + return *this; + } + + iterator operator++(int) { + iterator temporary(*this); + ++m_Iterator; + return temporary; + } + + iterator& operator--(); + iterator operator--(int); + bool operator==(const iterator&) const; + + bool operator!=(const iterator& i) const { return m_Iterator != i.m_Iterator; } + + private: + friend class IntrusiveList; + + iterator(detail::IntrusiveListImplementation::iterator iter) : m_Iterator(iter) {} + + detail::IntrusiveListImplementation::iterator GetImplementationIterator() const; + + detail::IntrusiveListImplementation::iterator m_Iterator; + }; + + IntrusiveList() : m_Implementation() {} + + void push_back(reference value) { m_Implementation.push_back(ToNode(value)); } + + void push_front(reference); + void pop_back(); + void pop_front(); + reference front(); + reference front() const; + reference back(); + reference back() const; + + iterator begin() { return m_Implementation.begin(); } + const_iterator begin() const { return m_Implementation.begin(); } + + const_iterator cbegin() const; + + iterator end() { return m_Implementation.end(); } + const_iterator end() const { return m_Implementation.end(); } + + const_iterator cend() const; + reverse_iterator rbegin(); + const_reverse_iterator rbegin() const; + const_reverse_iterator crbegin() const; + reverse_iterator rend(); + const_reverse_iterator rend() const; + const_reverse_iterator crend() const; + + iterator iterator_to(reference value) { return m_Implementation.iterator_to(ToNode(value)); } + const_iterator iterator_to(const_reference value) const { + return m_Implementation.iterator_to(ToNode(value)); + } + + size_type size() const; + bool empty() const; + + iterator erase(const_iterator position) { + detail::IntrusiveListImplementation::iterator result = + m_Implementation.erase(position.GetImplementationIterator()); + return result; + } + + void clear() { m_Implementation.clear(); } + + iterator insert(const_iterator position, reference value) { + detail::IntrusiveListImplementation::iterator result = + m_Implementation.insert(position.GetImplementationIterator(), ToNode(value)); + return result; + } + + void splice(const_iterator, IntrusiveList&); + void splice(const_iterator, IntrusiveList&, const_iterator); + void splice(const_iterator, IntrusiveList&, const_iterator, const_iterator); + +private: + IntrusiveListNode& ToNode(reference ref) const { return NodeTraits::GetNode(ref); } + + const IntrusiveListNode& ToNode(const_reference) const; + reference ToReference(IntrusiveListNode&) const; + const_reference ToReference(const IntrusiveListNode&) const; + + detail::IntrusiveListImplementation m_Implementation; +}; + +template +class IntrusiveListMemberNodeTraits { + friend class IntrusiveList; + + static IntrusiveListNode& GetNode(T& ref) { return ref.*Member; } + + static const IntrusiveListNode& GetNode(const T& ref) { return ref.*Member; } + + static T& GetItem(IntrusiveListNode& node) { + return *reinterpret_cast(reinterpret_cast(&node) - GetOffset()); + } + + static const T& GetItem(const IntrusiveListNode& node) { + return *reinterpret_cast(reinterpret_cast(&node) - GetOffset()); + } + + static uintptr_t GetOffset() { + return reinterpret_cast(&(reinterpret_cast(0)->*Member)); + } +}; + +} // namespace util +} // namespace nn diff --git a/include/nn/util/util_MathTypes.h b/include/nn/util/util_MathTypes.h new file mode 100644 index 0000000..8ba9787 --- /dev/null +++ b/include/nn/util/util_MathTypes.h @@ -0,0 +1,149 @@ +#pragma once + +#include +#include + +namespace nn::util { + +typedef uint32_t AngleIndex; + +struct Unorm8x4 { + uint8_t v[4]; +}; + +struct Float2 { + union { + float v[2]; + struct { + float x; + float y; + }; + }; +}; + +struct Float3 { + union { + float v[3]; + struct { + float x; + float y; + float z; + }; + }; +}; + +struct Float4 { + union { + float v[4]; + struct { + float x; + float y; + float z; + float w; + }; + }; +}; + +struct FloatRowMajor4x3 { + union { + float m[4][3]; + struct { + float m00; + float m01; + float m02; + float m10; + float m11; + float m12; + float m20; + float m21; + float m22; + float m30; + float m31; + float m32; + }; + }; +}; + +struct FloatColumnMajor4x3 { + union { + float m[3][4]; + struct { + float m00; + float m10; + float m20; + float m30; + float m01; + float m11; + float m21; + float m31; + float m02; + float m12; + float m22; + float m32; + }; + }; +}; + +struct FloatRowMajor4x4 { + union { + float m[4][4]; + struct { + float m00; + float m01; + float m02; + float m03; + float m10; + float m11; + float m12; + float m13; + float m20; + float m21; + float m22; + float m23; + float m30; + float m31; + float m32; + float m33; + }; + }; +}; + +struct FloatColumnMajor4x4 { + union { + float m[4][4]; + struct { + float m00; + float m10; + float m20; + float m30; + float m01; + float m11; + float m21; + float m31; + float m02; + float m12; + float m22; + float m32; + float m03; + float m13; + float m23; + float m33; + }; + }; +}; + +typedef Unorm8x4 Color4u8Type; +typedef FloatRowMajor4x3 Float4x3; +typedef FloatRowMajor4x4 Float4x4; +typedef FloatColumnMajor4x3 FloatT4x3; +typedef FloatColumnMajor4x4 FloatT4x4; + +// dwarf says a using statement for neon is used? +using namespace neon; + +typedef MatrixRowMajor4x3fType Matrix4x3fType; +typedef MatrixRowMajor4x4fType Matrix4x4fType; +typedef MatrixColumnMajor4x3fType MatrixT4x3fType; +typedef MatrixColumnMajor4x4fType MatrixT4x4fType; + +} // namespace nn::util diff --git a/include/nn/util/util_MatrixApi.h b/include/nn/util/util_MatrixApi.h new file mode 100644 index 0000000..f705da2 --- /dev/null +++ b/include/nn/util/util_MatrixApi.h @@ -0,0 +1,12 @@ +#pragma once + +#include + +// dwarf imported module, is this equivalent? +namespace nn { +namespace util { + +using namespace neon; + +} +} // namespace nn diff --git a/include/nn/util/util_StringUtil.h b/include/nn/util/util_StringUtil.h new file mode 100644 index 0000000..dd3fb9e --- /dev/null +++ b/include/nn/util/util_StringUtil.h @@ -0,0 +1,24 @@ +#pragma once + +namespace nn { +namespace util { + +template +int Strlcpy(T* pOutDst, const T* pSrc, int count) { + int length = 0; + + while (--count && *pSrc) { + *pOutDst++ = *pSrc++; + ++length; + } + *pOutDst = '\0'; + + while (*pSrc++) { + ++length; + } + + return length; +} + +} // namespace util +} // namespace nn diff --git a/src/NintendoSDK/gfx/detail/gfx_DescriptorPool-api.nvn.8.cpp b/src/NintendoSDK/gfx/detail/gfx_DescriptorPool-api.nvn.8.cpp index 8a22991..e9d6172 100644 --- a/src/NintendoSDK/gfx/detail/gfx_DescriptorPool-api.nvn.8.cpp +++ b/src/NintendoSDK/gfx/detail/gfx_DescriptorPool-api.nvn.8.cpp @@ -223,4 +223,4 @@ int DescriptorPoolImpl::GetDescriptorSlotIndex( return descriptorSlot.ToData()->value; } -} // namespace nn::gfx::detail \ No newline at end of file +} // namespace nn::gfx::detail diff --git a/src/NintendoSDK/gfx/util/gfx_PrimitiveShape.cpp b/src/NintendoSDK/gfx/util/gfx_PrimitiveShape.cpp index a008e97..00d2426 100644 --- a/src/NintendoSDK/gfx/util/gfx_PrimitiveShape.cpp +++ b/src/NintendoSDK/gfx/util/gfx_PrimitiveShape.cpp @@ -1,8 +1,8 @@ #include #include -#include #include +#include // todo: most of these functions are still non-matching // matching should be done using odyssey 1.2 as a base @@ -570,4 +570,4 @@ void ConeShape::CalculateImpl(void* pVertexMemory, size_t vertexSize, void* pInd size_t indexSize); */ -} // namespace nn::gfx::util \ No newline at end of file +} // namespace nn::gfx::util diff --git a/src/NintendoWare/ui2d/.gitkeep b/src/NintendoWare/ui2d/.gitkeep deleted file mode 100644 index e69de29..0000000 diff --git a/src/NintendoWare/ui2d/ui2d_Animation.cpp b/src/NintendoWare/ui2d/ui2d_Animation.cpp new file mode 100644 index 0000000..c631f67 --- /dev/null +++ b/src/NintendoWare/ui2d/ui2d_Animation.cpp @@ -0,0 +1,1123 @@ +#include + +#include +#include +#include +#include +#include +#include +#include + +namespace nn { +namespace ui2d { + +#define SIG(name) const uint32_t name = MakeSig(#name) + +SIG(FLPA); +SIG(FLVI); +SIG(FLVC); +SIG(FLCT); +// SIG(FLWN); added in smo + +SIG(FLTS); +SIG(FLTP); +SIG(FLFS); +SIG(FLIM); +SIG(FLAC); +SIG(FLMC); + +namespace { +bool RIsSame(float a, float b, float tolerance = 0.001f) { + float c = a - b; + return c > -tolerance && c < tolerance; +} + +uint16_t GetStepCurveValue(float frame, const ResStepKey* pKeys, uint32_t keySize) { + // doesn't match with using ikeyL and ikeyR + if (keySize == 1 || frame <= pKeys[0].frame) { + return pKeys[0].value; + } else if (frame >= pKeys[keySize - 1].frame) { + return pKeys[keySize - 1].value; + } + + int ikeyL = 0; + int ikeyR = keySize - 1; + + while (ikeyL != ikeyR && ikeyL != ikeyR - 1) { + int ikeyCenter = (ikeyL + ikeyR) / 2; + const ResStepKey& centerKey = pKeys[ikeyCenter]; + + if (frame < centerKey.frame) { + ikeyR = ikeyCenter; + } else { + ikeyL = ikeyCenter; + } + } + + if (RIsSame(frame, pKeys[ikeyR].frame)) { + return pKeys[ikeyR].value; + } + + return pKeys[ikeyL].value; +} + +void AnimatePaneSrt(Pane* pPane, const ResAnimationInfo* pAnimInfo, + const uint32_t* pAnimTargetOffsets, float frame) { + for (int i = 0; i < pAnimInfo->count; ++i) { + auto pAnimTarget = + util::ConstBytePtr(pAnimInfo, pAnimTargetOffsets[i]).Get(); + auto pKeys = util::ConstBytePtr(pAnimTarget, pAnimTarget->keysOffset).Get(); + + pPane->SetSrtElement(pAnimTarget->target, + GetHermiteCurveValue(frame, pKeys, pAnimTarget->keyCount)); + } +} + +void AnimateVisibility(Pane* pPane, const ResAnimationInfo* pAnimInfo, + const uint32_t* pAnimTargetOffsets, float frame) { + for (int i = 0; i < pAnimInfo->count; ++i) { + auto pAnimTarget = + util::ConstBytePtr(pAnimInfo, pAnimTargetOffsets[i]).Get(); + auto pKeys = util::ConstBytePtr(pAnimTarget, pAnimTarget->keysOffset).Get(); + + pPane->SetVisible(GetStepCurveValue(frame, pKeys, pAnimTarget->keyCount)); + } +} + +void AnimateVertexColor(Pane* pPane, const ResAnimationInfo* pAnimInfo, + const uint32_t* pAnimTargetOffsets, float frame) { + for (int i = 0; i < pAnimInfo->count; ++i) { + auto pAnimTarget = + util::ConstBytePtr(pAnimInfo, pAnimTargetOffsets[i]).Get(); + auto pKeys = util::ConstBytePtr(pAnimTarget, pAnimTarget->keysOffset).Get(); + + float value = GetHermiteCurveValue(frame, pKeys, pAnimTarget->keyCount); + uint8_t u8Val = std::min(std::max(value + 0.5f, 0.0f), 255.0f); + pPane->SetColorElement(pAnimTarget->target, u8Val); + } +} + +void AnimatePerCharacterTransform(Pane* pPane, const ResAnimationInfo* pAnimInfo, + const uint32_t* pAnimTargetOffsets, float frame) { + for (int i = 0; i < pAnimInfo->count; ++i) { + auto pAnimTarget = + util::ConstBytePtr(pAnimInfo, pAnimTargetOffsets[i]).Get(); + auto pKeys = util::ConstBytePtr(pAnimTarget, pAnimTarget->keysOffset).Get(); + + float value = GetHermiteCurveValue(frame, pKeys, pAnimTarget->keyCount); + static_cast(pPane)->SetPerCharacterTransformOffset(value); + // smo: static_cast(pPane)->SetPerCharacterTransform(pAnimTarget->target, value); + } +} + +/* added in smo +void AnimateWindow(Pane* pPane, const ResAnimationInfo* pAnimInfo, + const uint32_t* pAnimTargetOffsets, float frame) { + for (int i = 0; i < pAnimInfo->count; ++i) { + auto pAnimTarget = + util::ConstBytePtr(pAnimInfo, pAnimTargetOffsets[i]).Get(); + auto pKeys = util::ConstBytePtr(pAnimTarget, pAnimTarget->keysOffset).Get(); + + float value = GetHermiteCurveValue(frame, pKeys, pAnimTarget->keysOffset); + static_cast(pPane)->SetWindowFrameSize(pAnimTarget->target, value); + } +} + +added after smo +void AnimateMaskTexSrt(Pane* pPane, const ResAnimationInfo* pAnimInfo, + const uint32_t* pAnimTargetOffsets, float frame) { + for (int i = 0; i < pAnimInfo->count; ++i) { + auto pAnimTarget = + util::ConstBytePtr(pAnimInfo, pAnimTargetOffsets[i]).Get(); + auto pKeys = util::ConstBytePtr(pAnimTarget, pAnimTarget->keysOffset).Get(); + } +} +*/ + +void AnimateMaterialColor(Material* pMaterial, const ResAnimationInfo* pAnimInfo, + const uint32_t* pAnimTargetOffsets, float frame) { + for (int i = 0; i < pAnimInfo->count; ++i) { + auto pAnimTarget = + util::ConstBytePtr(pAnimInfo, pAnimTargetOffsets[i]).Get(); + auto pKeys = util::ConstBytePtr(pAnimTarget, pAnimTarget->keysOffset).Get(); + float value = GetHermiteCurveValue(frame, pKeys, pAnimTarget->keyCount); + + if (pAnimTarget->target <= AnimTargetMatColor_MaxAnimTargetMatColor) { + value += 0.5f; + uint8_t val = std::min(std::max(value, 0.0f), 255.0f); + pMaterial->SetColorElement(pAnimTarget->target, val); + } else { + pMaterial->SetColorElementFloat(pAnimTarget->target, value); + } + } +} + +void AnimateTextureSrt(Material* pMaterial, const ResAnimationInfo* pAnimInfo, + const uint32_t* pAnimTargetOffsets, float frame) { + for (int i = 0; i < pAnimInfo->count; ++i) { + auto pAnimTarget = + util::ConstBytePtr(pAnimInfo, pAnimTargetOffsets[i]).Get(); + auto pKeys = util::ConstBytePtr(pAnimTarget, pAnimTarget->keysOffset).Get(); + + pMaterial->SetTexSrtElement(pAnimTarget->id, pAnimTarget->target, + GetHermiteCurveValue(frame, pKeys, pAnimTarget->keyCount)); + } +} + +void AnimateTexturePattern(Material* pMaterial, const ResAnimationInfo* pAnimInfo, + const uint32_t* pAnimTargetOffsets, float frame, + const TextureInfo** texInfos) { + for (int j = 0; j < pAnimInfo->count; ++j) { + auto pAnimTarget = + util::ConstBytePtr(pAnimInfo, pAnimTargetOffsets[j]).Get(); + auto pKeys = util::ConstBytePtr(pAnimTarget, pAnimTarget->keysOffset).Get(); + const uint16_t fileIdx = GetStepCurveValue(frame, pKeys, pAnimTarget->keyCount); + + if (texInfos[fileIdx]->IsValid()) + pMaterial->SetTexMap(pAnimTarget->id, texInfos[fileIdx]); + } +} + +void AnimateIndirectSrt(Material* pMaterial, const ResAnimationInfo* pAnimInfo, + const uint32_t* pAnimTargetOffsets, float frame) { + for (int i = 0; i < pAnimInfo->count; ++i) { + auto pAnimTarget = + util::ConstBytePtr(pAnimInfo, pAnimTargetOffsets[i]).Get(); + auto pKeys = util::ConstBytePtr(pAnimTarget, pAnimTarget->keysOffset).Get(); + + pMaterial->SetIndirectSrtElement(pAnimTarget->target, + GetHermiteCurveValue(frame, pKeys, pAnimTarget->keyCount)); + } +} + +void AnimateAlphaCompare(Material* pMaterial, const ResAnimationInfo* pAnimInfo, + const uint32_t* pAnimTargetOffsets, float frame) { + for (int i = 0; i < pAnimInfo->count; ++i) { + auto pAnimTarget = + util::ConstBytePtr(pAnimInfo, pAnimTargetOffsets[i]).Get(); + auto pKeys = util::ConstBytePtr(pAnimTarget, pAnimTarget->keysOffset).Get(); + float value = GetHermiteCurveValue(frame, pKeys, pAnimTarget->keyCount); + float val = std::min(std::max(value, 0.0f), 1.0f); + + ResAlphaCompare compare(pMaterial->GetAlphaCompare().GetFunc(), val); + pMaterial->SetAlphaCompare(compare); + } +} + +void AnimateFontShadow(Material* pMaterial, const ResAnimationInfo* pAnimInfo, + const uint32_t* pAnimTargetOffsets, float frame) { + for (int i = 0; i < pAnimInfo->count; ++i) { + auto pAnimTarget = + util::ConstBytePtr(pAnimInfo, pAnimTargetOffsets[i]).Get(); + auto pKeys = util::ConstBytePtr(pAnimTarget, pAnimTarget->keysOffset).Get(); + float value = GetHermiteCurveValue(frame, pKeys, pAnimTarget->keyCount); + + uint8_t value8 = std::min(std::max(value + 0.5f, 0.0f), 255.0f); + pMaterial->SetFontShadowParameterElement(pAnimTarget->target, value8); + } +} + +void AnimateExtUserData(ResExtUserData* pExtUserData, const ResAnimationInfo* pAnimInfo, + const uint32_t* pAnimTargetOffsets, float frame) { + for (int i = 0; i < pAnimInfo->count; ++i) { + auto pAnimTarget = + util::ConstBytePtr(pAnimInfo, pAnimTargetOffsets[i]).Get(); + auto pKeys = util::ConstBytePtr(pAnimTarget, pAnimTarget->keysOffset).Get(); + + switch (pExtUserData->GetType()) { + case ExtUserDataType_Int: + pExtUserData->WriteIntValue(GetHermiteCurveValue(frame, pKeys, pAnimTarget->keyCount), + pAnimTarget->id); + break; + case ExtUserDataType_Float: + pExtUserData->WriteFloatValue(GetHermiteCurveValue(frame, pKeys, pAnimTarget->keyCount), + pAnimTarget->id); + break; + default: + break; + } + } +} + +// 427 +const uint32_t* GetAnimInfoOffsets(const ResAnimationContent& animContent) { + if (animContent.type == AnimContentType_ExtUserData) { + const uint32_t* tableOffsets = + util::ConstBytePtr(&animContent, sizeof(ResAnimationContent)).Get(); + return util::ConstBytePtr(&animContent, tableOffsets[0]).Get(); + } + + return util::ConstBytePtr(&animContent, sizeof(ResAnimationContent)).Get(); +} + +// 443 +const char* GetExtUserDataTargetName(const ResAnimationContent& animContent) { + if (animContent.type == AnimContentType_ExtUserData) { + const uint32_t* tableOffsets = + util::ConstBytePtr(&animContent, sizeof(ResAnimationContent)).Get(); + const uint32_t* fileNameOffsets = + util::ConstBytePtr(&animContent, tableOffsets[1]).Get(); + return detail::GetStrTableStr(fileNameOffsets, 0); + } + + return nullptr; +} + +} // namespace + +AnimTransform::AnimTransform() : m_pRes(nullptr), m_Frame(0.0f), m_IsEnabled(true) {} + +AnimTransform::~AnimTransform() {} + +uint16_t AnimTransform::GetFrameSize() const { + return m_pRes->frameSize; +} + +void AnimTransform::UpdateFrame(float progressFrame) { + NN_UNUSED(progressFrame); +} + +void AnimTransform::SetEnabled(bool bEnable) { + m_IsEnabled = bEnable; +} + +bool AnimTransform::IsLoopData() const { + return m_pRes->loop; +} + +bool AnimTransform::IsWaitData() const { + return m_pRes->frameSize == 0; +} + +AnimTransformBasic::AnimTransformBasic() + : AnimTransform(), m_pTextures(nullptr), m_pBindPairs(nullptr), m_BindPairCount(0), + m_BindPairCountMax(0) {} + +AnimTransformBasic::~AnimTransformBasic() { + Layout::DeletePrimArray(m_pBindPairs); + Layout::DeletePrimArray(m_pTextures); +} + +void AnimTransformBasic::SetResource(gfx::Device* pDevice, ResourceAccessor* pResAccessor, + const ResAnimationBlock* pRes) { + SetResource(pDevice, pResAccessor, pRes, pRes->animContCount); +} + +void AnimTransformBasic::SetResource(gfx::Device* pDevice, ResourceAccessor* pResAccessor, + const ResAnimationBlock* pRes, uint16_t animNum) { + SetAnimResource(pRes); + m_pTextures = nullptr; + + if (pRes->fileCount) { + m_pTextures = Layout::NewArray(pRes->fileCount); + if (m_pTextures) { + auto fileNameOffsets = + util::ConstBytePtr(pRes, sizeof(ResAnimationBlock)).Get(); + for (int i = 0; i < pRes->fileCount; ++i) { + const char* const fileName = detail::GetStrTableStr(fileNameOffsets, i); + m_pTextures[i] = pResAccessor->AcquireTexture(pDevice, fileName); + } + } + } + + m_pBindPairs = Layout::NewArray(animNum); + if (m_pBindPairs) { + m_BindPairCountMax = animNum; + } +} + +void AnimTransformBasic::BindPane(Pane* pPane, bool bRecursive) { + auto pRes = GetAnimResource(); + const uint32_t* const pAnimContentOffsets = + util::ConstBytePtr(pRes, pRes->animContOffsetsOffset).Get(); + + for (uint16_t i = 0; i < pRes->animContCount; ++i) { + auto& animContent = + *util::ConstBytePtr(pRes, pAnimContentOffsets[i]).Get(); + + switch (animContent.type) { + case AnimContentType_Pane: { + Pane* const pFindPane = pPane->FindPaneByName(animContent.name, bRecursive); + if (pFindPane) { + // CheckBindAnimationDoubly(); + BindPaneImpl(pFindPane, &animContent); + } + } break; + + case AnimContentType_Material: { + Material* const pFindMat = pPane->FindMaterialByName(animContent.name, bRecursive); + if (pFindMat) { + // CheckBindAnimationDoubly(); + BindMaterialImpl(pFindMat, &animContent); + } + } break; + + case AnimContentType_ExtUserData: { + Pane* const pFindPane = pPane->FindPaneByName(animContent.name, bRecursive); + if (pFindPane) { + BindExtUserDataToPane(pFindPane, animContent); + } + } break; + + default: + break; + } + } +} + +void AnimTransformBasic::BindGroup(Group* pGroup) { + auto pRes = GetAnimResource(); + const uint32_t* const pAnimContentOffsets = + util::ConstBytePtr(pRes, pRes->animContOffsetsOffset).Get(); + + for (uint16_t i = 0; i < pRes->animContCount; ++i) { + auto& animContent = + *util::ConstBytePtr(pRes, pAnimContentOffsets[i]).Get(); + + switch (animContent.type) { + case AnimContentType_Pane: { + auto paneEnd = pGroup->GetPaneList().end(); + Pane* targetPane = nullptr; + for (auto iter = pGroup->GetPaneList().begin(); iter != paneEnd; ++iter) { + if (detail::EqualsResName(animContent.name, iter->pTarget->GetName())) { + targetPane = iter->pTarget; + break; + } + } + + if (targetPane) { + // CheckBindAnimationDoubly + BindPaneImpl(targetPane, &animContent); + } + } break; + + case AnimContentType_Material: { + auto& paneList = pGroup->GetPaneList(); + auto paneEnd = paneList.end(); + Material* pFindMat = nullptr; + for (auto iter = paneList.begin(); iter != paneEnd; ++iter) { + pFindMat = iter->pTarget->FindMaterialByName(animContent.name, false); + if (pFindMat) { + BindMaterialImpl(pFindMat, &animContent); + break; + } + } + } break; + + case AnimContentType_ExtUserData: { + auto paneEnd = pGroup->GetPaneList().end(); + Pane* targetPane = nullptr; + for (auto iter = pGroup->GetPaneList().begin(); iter != paneEnd; ++iter) { + if (detail::EqualsResName(animContent.name, iter->pTarget->GetName())) { + targetPane = iter->pTarget; + break; + } + } + + if (targetPane) { + // CheckBindAnimationDoubly + BindExtUserDataToPane(targetPane, animContent); + } + } break; + + default: + break; + } + } +} + +void AnimTransformBasic::BindMaterial(Material* pMaterial) { + auto pRes = GetAnimResource(); + const uint32_t* const pAnimContentOffsets = + util::ConstBytePtr(pRes, pRes->animContOffsetsOffset).Get(); + + for (uint32_t i = 0; i < pRes->animContCount; ++i) { + auto& animContent = + *util::ConstBytePtr(pRes, pAnimContentOffsets[i]).Get(); + + if (animContent.type == AnimContentType_Material && + detail::EqualsMaterialName(pMaterial->GetName(), animContent.name)) { + // CheckBindAnimationDoubly() + if (!BindMaterialImpl(pMaterial, &animContent)) { + return; + } + } + } +} + +void AnimTransformBasic::ForceBindPane(Pane* pDstPane, const Pane* pSrcPane) { + auto pRes = GetAnimResource(); + const uint32_t* const pAnimContentOffsets = + util::ConstBytePtr(pRes, pRes->animContOffsetsOffset).Get(); + + for (uint16_t i = 0; i < pRes->animContCount; ++i) { + auto& animContent = + *util::ConstBytePtr(pRes, pAnimContentOffsets[i]).Get(); + + switch (animContent.type) { + case AnimContentType_Pane: + if (detail::EqualsResName(pSrcPane->GetName(), animContent.name)) { + // CheckBindAnimationDoubly + if (!BindPaneImpl(pDstPane, &animContent)) { + return; + } + } + break; + + case AnimContentType_Material: { + uint32_t nbMaterial = pSrcPane->GetMaterialCount(); + for (uint32_t idx = 0; idx < nbMaterial; ++idx) { + auto pSrcMaterial = pSrcPane->GetMaterial(idx); + if (pSrcMaterial && + detail::EqualsMaterialName(pSrcMaterial->GetName(), animContent.name)) { + Material* pDstMaterial = pDstPane->GetMaterial(idx); + if (pDstMaterial && !BindMaterialImpl(pDstMaterial, &animContent)) { + return; + } + } + } + } break; + + case AnimContentType_ExtUserData: + if (detail::EqualsResName(pSrcPane->GetName(), animContent.name)) { + if (!BindExtUserDataToPane(pDstPane, animContent)) { + return; + } + } + break; + + default: + break; + } + } +} + +bool AnimTransformBasic::BindExtUserDataToPane(Pane* pPane, + const ResAnimationContent& animContent) { + if (pPane) { + const char* const pExtUserDataName = GetExtUserDataTargetName(animContent); + auto pUserData = pPane->FindExtUserDataByName(pExtUserDataName); + if (pUserData) { + // CheckBindAnimationDoubly(); + return BindExtUserDataImpl(const_cast(pUserData), &animContent); + } + } + + return true; +} + +void AnimTransformBasic::UnbindPane(const Pane* pPane) { + int end = m_BindPairCount; + for (int i = 0; i < end; ++i) { + BindPair* pPair = &m_pBindPairs[i]; + + if (pPair->target == pPane) { + EraseBindPair(i); + break; + } + + uint32_t nbExtUserData = pPane->GetExtUserDataCount(); + for (uint32_t extUserDataIndex = 0; extUserDataIndex < nbExtUserData; ++extUserDataIndex) { + const ResExtUserData* pUserData = &(pPane->GetExtUserDataArray()[extUserDataIndex]); + if (pPair->target == pUserData) { + EraseBindPair(i); + break; + } + } + } + + uint32_t nbMaterial = pPane->GetMaterialCount(); + for (uint32_t idx = 0; idx < nbMaterial; ++idx) { + Material* pMaterial = pPane->GetMaterial(idx); + if (pMaterial) { + UnbindMaterial(pMaterial); + } + } +} + +void AnimTransformBasic::UnbindGroup(const Group* pGroup) { + PaneLinkList& paneList = const_cast(pGroup)->GetPaneList(); + auto endIter = paneList.end(); + for (auto it = paneList.begin(); it != endIter; ++it) { + UnbindPane(it->pTarget); + } +} + +void AnimTransformBasic::UnbindMaterial(const Material* pMaterial) { + int end = m_BindPairCount; + for (int i = 0; i < end; ++i) { + BindPair* pPair = &m_pBindPairs[i]; + if (pPair->target == pMaterial) { + EraseBindPair(i); + break; + } + } +} + +void AnimTransformBasic::UnbindAll() { + m_BindPairCount = 0; +} + +bool AnimTransformBasic::BindPaneImpl(Pane* pTarget, const ResAnimationContent* pAnimContent) { + if (m_BindPairCount >= m_BindPairCountMax) { + return false; + } + + BindPair* pPair = &m_pBindPairs[m_BindPairCount++]; + pPair->target = pTarget; + pPair->animCont = pAnimContent; + return true; +} + +#define IFTEST(statement, ...) \ + if (statement) { \ + isBinding = false; \ + __VA_ARGS__ \ + } + +bool AnimTransformBasic::BindMaterialImpl(Material* pTarget, + const ResAnimationContent* pAnimContent) { + if (m_BindPairCount >= m_BindPairCountMax) { + return false; + } + + const uint32_t* animInfoOffsets = GetAnimInfoOffsets(*pAnimContent); + + bool isBinding = true; + if (pAnimContent) { + for (int j = 0; j < pAnimContent->count; ++j) { + const ResAnimationInfo* animInfo = + util::ConstBytePtr(pAnimContent, animInfoOffsets[j]).Get(); + const uint32_t* pAnimTargetOffsets = + util::ConstBytePtr(animInfo, sizeof(ResAnimationInfo)).Get(); + + for (int k = 0; k < animInfo->count; ++k) { + const ResAnimationTarget* pAnimTarget = + util::ConstBytePtr(animInfo, pAnimTargetOffsets[k]).Get(); + + switch (animInfo->kind) { + case FLTS: + IFTEST(pAnimTarget->id >= TexMapMax) + IFTEST(pTarget->GetTexSrtCap() <= pAnimTarget->id) + IFTEST(pAnimTarget->target >= AnimTargetTexSrt_MaxAnimTargetTexSrt) + IFTEST(pAnimTarget->curveType != AnimCurve_Hermite) + break; + + case FLTP: { + IFTEST(!m_pTextures) + IFTEST(pTarget->GetTexMapCount() <= pAnimTarget->id) + IFTEST(pAnimTarget->curveType != AnimCurve_Step) + IFTEST(pAnimTarget->target >= AnimTargetTexPattern_MaxAnimTargetTexPattern) + + for (int fileIdx = 0; fileIdx < GetAnimResource()->fileCount; ++fileIdx) { + IFTEST(!m_pTextures[fileIdx]->IsValid(), break;) + } + } break; + + case FLFS: + IFTEST(!pTarget->IsFontShadowParameterCap()) + IFTEST(AnimTargetFontShadow_MaxAnimTargetFontShadow <= pAnimTarget->target) + IFTEST(pAnimTarget->curveType != AnimCurve_Hermite) + break; + + case FLIM: + IFTEST(!pTarget->IsIndirectParameterCap()) + IFTEST(pAnimTarget->target >= AnimTargetIndirectSrt_MaxAnimTargetIndirectSrt) + IFTEST(pAnimTarget->curveType != AnimCurve_Hermite) + break; + + case FLAC: + IFTEST(!pTarget->IsAlphaCompareCap()) + IFTEST(pAnimTarget->target >= AnimTargetAlphaCompare_MaxAnimTargetAlphaCompare) + IFTEST(pAnimTarget->curveType != AnimCurve_Hermite) + break; + + case FLMC: + IFTEST(pAnimTarget->target >= AnimTargetMatColorFloat_MaxAnimTargetMatColor) + IFTEST(pAnimTarget->curveType != AnimCurve_Hermite) + break; + + default: + break; + } + } + } + } + + if (isBinding) { + BindPair* pPair = &m_pBindPairs[m_BindPairCount]; + m_BindPairCount++; + pPair->target = pTarget; + pPair->animCont = pAnimContent; + } + + return true; +} + +bool AnimTransformBasic::BindExtUserDataImpl(ResExtUserData* pTarget, + const ResAnimationContent* pAnimContent) { + if (m_BindPairCount >= m_BindPairCountMax) { + return false; + } + + BindPair* pPair = &m_pBindPairs[m_BindPairCount++]; + pPair->target = pTarget; + pPair->animCont = pAnimContent; + return true; +} + +void AnimTransformBasic::Animate() { + if (IsEnabled()) { + int end = m_BindPairCount; + for (int i = 0; i < end; ++i) { + BindPair* pPair = &m_pBindPairs[i]; + + switch (pPair->animCont->type) { + case AnimContentType_Pane: + AnimatePaneImpl(static_cast(pPair->target), pPair->animCont); + break; + case AnimContentType_Material: + AnimateMaterialImpl(static_cast(pPair->target), pPair->animCont); + break; + case AnimContentType_ExtUserData: + AnimateExtUserDataImpl(static_cast(pPair->target), + pPair->animCont); + break; + } + } + } +} + +void AnimTransformBasic::AnimatePane(Pane* pPane) { + if (IsEnabled()) { + int end = m_BindPairCount; + for (int i = 0; i < end; ++i) { + BindPair* pPair = &m_pBindPairs[i]; + + if (pPair->target == pPane) { + AnimatePaneImpl(pPane, pPair->animCont); + + uint32_t nbMaterial = pPane->GetMaterialCount(); + for (uint32_t idx = 0; idx < nbMaterial; ++idx) { + Material* pMaterial = pPane->GetMaterial(idx); + if (pMaterial) { + AnimateMaterial(pMaterial); + } + } + break; + } + } + } +} + +void AnimTransformBasic::AnimateMaterial(Material* pMaterial) { + if (IsEnabled()) { + int end = m_BindPairCount; + for (int i = 0; i < end; ++i) { + BindPair* pPair = &m_pBindPairs[i]; + + if (pPair->target == pMaterial) { + AnimateMaterialImpl(pMaterial, pPair->animCont); + break; + } + } + } +} + +void AnimTransformBasic::AnimatePaneImpl(Pane* pPane, const ResAnimationContent* pAnimContent) { + const uint32_t* animInfoOffsets = GetAnimInfoOffsets(*pAnimContent); + + for (int i = 0; i < pAnimContent->count; ++i) { + const ResAnimationInfo* pAnimInfo = + util::ConstBytePtr(pAnimContent, animInfoOffsets[i]).Get(); + const uint32_t* pAnimTargetOffsets = + util::ConstBytePtr(pAnimInfo, sizeof(ResAnimationInfo)).Get(); + + switch (pAnimInfo->kind) { + case FLPA: + AnimatePaneSrt(pPane, pAnimInfo, pAnimTargetOffsets, GetFrame()); + break; + + case FLVI: + AnimateVisibility(pPane, pAnimInfo, pAnimTargetOffsets, GetFrame()); + break; + + case FLVC: + AnimateVertexColor(pPane, pAnimInfo, pAnimTargetOffsets, GetFrame()); + break; + + case FLCT: + AnimatePerCharacterTransform(pPane, pAnimInfo, pAnimTargetOffsets, GetFrame()); + break; + + /* added in smo + case FLWN: + AnimateWindow(pPane, pAnimInfo, pAnimTargetOffsets, GetFrame()); + break; + */ + + /* added after smo + case FL: + AnimateMaskTexSrt(pPane, pAnimInfo, pAnimTargetOffsets, GetFrame()); + break; + */ + + default: + break; + } + } +} + +void AnimTransformBasic::AnimateMaterialImpl(Material* pMaterial, + const ResAnimationContent* pAnimContent) { + const uint32_t* animInfoOffsets = GetAnimInfoOffsets(*pAnimContent); + + for (int i = 0; i < pAnimContent->count; ++i) { + const ResAnimationInfo* pAnimInfo = + util::ConstBytePtr(pAnimContent, animInfoOffsets[i]).Get(); + const uint32_t* pAnimTargetOffsets = + util::ConstBytePtr(pAnimInfo, sizeof(ResAnimationInfo)).Get(); + + switch (pAnimInfo->kind) { + case FLMC: + AnimateMaterialColor(pMaterial, pAnimInfo, pAnimTargetOffsets, GetFrame()); + break; + + case FLTS: + AnimateTextureSrt(pMaterial, pAnimInfo, pAnimTargetOffsets, GetFrame()); + break; + + case FLTP: + AnimateTexturePattern(pMaterial, pAnimInfo, pAnimTargetOffsets, GetFrame(), + m_pTextures); + break; + + case FLIM: + AnimateIndirectSrt(pMaterial, pAnimInfo, pAnimTargetOffsets, GetFrame()); + break; + + case FLAC: + AnimateAlphaCompare(pMaterial, pAnimInfo, pAnimTargetOffsets, GetFrame()); + break; + + case FLFS: + AnimateFontShadow(pMaterial, pAnimInfo, pAnimTargetOffsets, GetFrame()); + break; + + default: + break; + } + } +} + +void AnimTransformBasic::AnimateExtUserDataImpl(ResExtUserData* pExtUserData, + const ResAnimationContent* pAnimContent) { + const uint32_t* animInfoOffsets = GetAnimInfoOffsets(*pAnimContent); + + for (int i = 0; i < pAnimContent->count; ++i) { + const ResAnimationInfo* pAnimInfo = + util::ConstBytePtr(pAnimContent, animInfoOffsets[i]).Get(); + const uint32_t* pAnimTargetOffsets = + util::ConstBytePtr(pAnimInfo, sizeof(ResAnimationInfo)).Get(); + + AnimateExtUserData(pExtUserData, pAnimInfo, pAnimTargetOffsets, GetFrame()); + } +} + +bool AnimTransformBasic::CheckBindAnimationDoubly(const void* target, + const ResAnimationContent* pAnimContent) const { + NN_UNUSED(target); + NN_UNUSED(pAnimContent); + // loop here, optimized out? + return false; +} + +void AnimTransformBasic::EraseBindPair(int pos) { + if (pos + 1 < m_BindPairCount) { + m_pBindPairs[pos] = m_pBindPairs[m_BindPairCount - 1]; + } + m_BindPairCount -= 1; +} + +AnimResource::AnimResource() { + Initialize(); +} + +bool AnimResource::CheckResource() const { + return m_pResBlock; +} + +void AnimResource::Set(const void* pAnimResBuf) { + Initialize(); + + auto pFileHeader = static_cast(pAnimResBuf); + font::detail::IsValidBinaryFile(pFileHeader, FileSignatureFlan, 0, 0); + m_pFileHeader = pFileHeader; + + auto pDataBlockHead = util::ConstBytePtr(pFileHeader, pFileHeader->headerSize) + .Get(); + for (int i = 0; i < m_pFileHeader->dataBlocks; ++i) { + uint32_t kind = pDataBlockHead->kind; + + switch (kind) { + case DataBlockKindAnimTag: + m_pTagBlock = reinterpret_cast(pDataBlockHead); + break; + + case DataBlockKindAnimShare: + m_pShareBlock = reinterpret_cast(pDataBlockHead); + break; + + case DataBlockKindAnim: + m_pResBlock = reinterpret_cast(pDataBlockHead); + break; + + default: + break; + } + + pDataBlockHead = util::ConstBytePtr(pDataBlockHead, pDataBlockHead->size) + .Get(); + } +} + +void AnimResource::Initialize() { + m_pTagBlock = nullptr; + m_pShareBlock = nullptr; + m_pFileHeader = nullptr; + m_pResBlock = nullptr; +} + +uint16_t AnimResource::GetTagOrder() const { + if (!m_pTagBlock) { + return -1; + } + + return m_pTagBlock->tagOrder; +} + +const char* AnimResource::GetTagName() const { + if (!m_pTagBlock) { + return nullptr; + } + + return util::ConstBytePtr(m_pTagBlock, m_pTagBlock->nameOffset).Get(); +} + +uint16_t AnimResource::GetGroupCount() const { + if (!m_pTagBlock) { + return 0; + } + + return m_pTagBlock->groupCount; +} + +const ResAnimationGroupRef* AnimResource::GetGroupArray() const { + if (!m_pTagBlock) { + return nullptr; + } + + const ResAnimationGroupRef* const groups = + util::ConstBytePtr(m_pTagBlock, m_pTagBlock->groupsOffset).Get(); + return groups; +} + +const ResExtUserDataList* AnimResource::GetExtUserDataList() const { + if (!m_pTagBlock) { + return nullptr; + } + + if (m_pTagBlock->userDataListOffset == 0) { + return nullptr; + } + + const ResExtUserDataList* const list = + util::ConstBytePtr(m_pTagBlock, m_pTagBlock->userDataListOffset).Get(); + return list; +} + +bool AnimResource::IsDescendingBind() const { + if (!m_pTagBlock) { + return false; + } + + return detail::TestBit(m_pTagBlock->flag, AnimTagFlag_DescendingBind); +} + +uint16_t AnimResource::GetAnimationShareInfoCount() const { + if (!m_pShareBlock) { + return 0; + } + + return m_pShareBlock->shareCount; +} + +const ResAnimationShareInfo* AnimResource::GetAnimationShareInfoArray() const { + if (!m_pShareBlock) { + return nullptr; + } + + return util::ConstBytePtr(m_pShareBlock, m_pShareBlock->animShareInfoOffset) + .Get(); +} + +uint16_t AnimResource::CalculateAnimationCount(Pane* pPane, bool bRecursive) const { + if (!CheckResource()) { + return 0; + } + + uint16_t linkNum = 0; + + const uint32_t* const pAnimContentOffsets = + util::ConstBytePtr(m_pResBlock, m_pResBlock->animContOffsetsOffset).Get(); + + for (uint16_t i = 0; i < m_pResBlock->animContCount; ++i) { + const ResAnimationContent& animContent = + *util::ConstBytePtr(m_pResBlock, pAnimContentOffsets[i]).Get(); + + if (animContent.type == AnimContentType_Pane) { + if (pPane->FindPaneByName(animContent.name, bRecursive)) + ++linkNum; + } else { + if (pPane->FindMaterialByName(animContent.name, bRecursive)) + ++linkNum; + } + } + + return linkNum; +} + +uint16_t AnimResource::CalculateAnimationCount(Material* pMaterial) const { + if (!CheckResource()) { + return 0; + } + + uint16_t linkNum = 0; + + auto const pAnimContentOffsets = + util::ConstBytePtr(m_pResBlock, m_pResBlock->animContOffsetsOffset).Get(); + + for (uint16_t i = 0; i < m_pResBlock->animContCount; ++i) { + auto& animContent = + *util::ConstBytePtr(m_pResBlock, pAnimContentOffsets[i]).Get(); + + if (animContent.type == AnimContentType_Material) { + if (detail::EqualsMaterialName(pMaterial->GetName(), animContent.name)) { + linkNum = 1; // bug? + } + } + } + + return linkNum; +} + +uint16_t AnimResource::CalculateAnimationCount(Group* pGroup, bool bRecursive) const { + uint16_t linkNum = 0; + auto& paneList = pGroup->GetPaneList(); + + auto enditer = paneList.end(); + for (auto iter = paneList.begin(); iter != enditer; ++iter) { + linkNum += CalculateAnimationCount(iter->pTarget, bRecursive); + } + + return linkNum; +} + +namespace detail { + +AnimPaneTree::AnimPaneTree() { + Initialize(); +} + +AnimPaneTree::AnimPaneTree(Pane* pTargetPane, const AnimResource& animRes) { + Initialize(); + Set(pTargetPane, animRes); +} + +const ResAnimationContent* AnimPaneTree::FindAnimContent(const ResAnimationBlock* pAnimBlock, + const char* pAnimContentName, + uint8_t animContentType) { + const uint32_t* const pAnimContentOffsets = + util::ConstBytePtr(pAnimBlock, pAnimBlock->animContOffsetsOffset).Get(); + + for (uint16_t i = 0; i < pAnimBlock->animContCount; ++i) { + const ResAnimationContent* const pAnimCont = + util::ConstBytePtr(pAnimBlock, pAnimContentOffsets[i]).Get(); + + if (pAnimCont->type == animContentType && + EqualsMaterialName(pAnimCont->name, pAnimContentName)) { + return pAnimCont; + } + } + + return nullptr; +} + +void AnimPaneTree::Initialize() { + m_pPaneAnimContent = nullptr; + + for (uint8_t i = 0; i < MaterialCountMax; ++i) { + m_pMatAnimContents[i] = nullptr; + } + + m_LinkCount = 0; + m_AnimMatCnt = 0; +} + +void AnimPaneTree::Set(Pane* pTargetPane, const AnimResource& animRes) { + uint16_t linkNum = 0; + const ResAnimationBlock* pAnimBlock = animRes.GetResourceBlock(); + const ResAnimationContent* pAnimContent = + FindAnimContent(pAnimBlock, pTargetPane->GetName(), AnimContentType_Pane); + + if (pAnimContent) { + ++linkNum; + } + + const uint8_t animMatCnt = pTargetPane->GetMaterialCount(); + const ResAnimationContent* animMatIdxs[MaterialCountMax]; + + for (uint8_t i = 0; i < animMatCnt; ++i) { + animMatIdxs[i] = FindAnimContent(pAnimBlock, pTargetPane->GetMaterial(i)->GetName(), + AnimContentType_Material); + if (animMatIdxs[i]) { + ++linkNum; + } + } + + if (linkNum == 0) { + return; + } + + m_AnimRes = animRes; + m_pPaneAnimContent = pAnimContent; + m_AnimMatCnt = animMatCnt; + for (uint8_t i = 0; i < animMatCnt; ++i) { + m_pMatAnimContents[i] = animMatIdxs[i]; + } + m_LinkCount = linkNum; +} + +AnimTransform* AnimPaneTree::Bind(gfx::Device* pDevice, Layout* pLayout, Pane* pTargetPane, + ResourceAccessor* pResAccessor) const { + AnimTransformBasic* const pAnimTrans = pLayout->CreateAnimTransformBasic(); + pAnimTrans->SetResource(pDevice, pResAccessor, m_AnimRes.GetResourceBlock(), m_LinkCount); + + if (m_pPaneAnimContent) { + pAnimTrans->BindPaneImpl(pTargetPane, m_pPaneAnimContent); + } + + const uint32_t animMatMax = std::min(m_AnimMatCnt, pTargetPane->GetMaterialCount()); + for (uint32_t i = 0; i < animMatMax; ++i) { + if (m_pMatAnimContents[i]) { + Material* const pMaterial = pTargetPane->GetMaterial(i); + pAnimTrans->BindMaterialImpl(pMaterial, m_pMatAnimContents[i]); + } + } + + return pAnimTrans; +} + +} // namespace detail +} // namespace ui2d +} // namespace nn diff --git a/src/NintendoWare/ui2d/ui2d_Bounding.cpp b/src/NintendoWare/ui2d/ui2d_Bounding.cpp new file mode 100644 index 0000000..7837325 --- /dev/null +++ b/src/NintendoWare/ui2d/ui2d_Bounding.cpp @@ -0,0 +1,29 @@ +#include + +#include + +namespace nn { +namespace ui2d { + +Bounding::Bounding(const ResBounding* pBaseBlock, const ResBounding* pOverrideBlock, + const BuildArgSet& buildArgSet) + : Pane(pBaseBlock, buildArgSet) { + NN_UNUSED(pOverrideBlock); +} + +Bounding::Bounding(const Bounding& bounding) : Pane(bounding) {} + +Bounding::~Bounding() {} + +void Bounding::DrawSelf(DrawInfo& drawInfo, gfx::CommandBuffer& commandBuffer) { + NN_UNUSED(drawInfo); + NN_UNUSED(commandBuffer); +} + +bool Bounding::CompareCopiedInstanceTest(const Bounding& target) const { + NN_UNUSED(target); + return true; +} + +} // namespace ui2d +} // namespace nn diff --git a/src/NintendoWare/ui2d/ui2d_ControlCreator.cpp b/src/NintendoWare/ui2d/ui2d_ControlCreator.cpp new file mode 100644 index 0000000..8a65882 --- /dev/null +++ b/src/NintendoWare/ui2d/ui2d_ControlCreator.cpp @@ -0,0 +1,124 @@ +#include + +#include + +namespace nn { +namespace ui2d { + +ControlSrc::ControlSrc() + : m_pControlName(nullptr), m_pControlUserName(nullptr), m_FunctionalPaneCount(0), + m_FunctionalAnimCount(0), m_pFunctionalPaneNames(nullptr), + m_pControlFunctionalAnimNameOffests(nullptr), + m_pControlFunctionalPaneParameterNameOffsets(nullptr), + m_pControlFunctionalAnimParameterNameOffsets(nullptr), m_pExtUserDataList(nullptr) {} + +void ControlSrc::Initialize(const void* pData, const ResExtUserDataList* pUserDataBlock) { + auto pResControl = static_cast(pData); + m_pControlName = util::ConstBytePtr(pResControl, sizeof(ResControl)).Get(); + m_pControlUserName = + util::ConstBytePtr(pResControl, pResControl->controlUserNameOffset).Get(); + m_FunctionalPaneCount = pResControl->controlFunctionalPaneCount; + m_FunctionalAnimCount = pResControl->controlFunctionalAnimCount; + m_pFunctionalPaneNames = + util::ConstBytePtr(pResControl, pResControl->controlFunctionalPaneNamesOffset).Get(); + m_pControlFunctionalAnimNameOffests = + util::ConstBytePtr(pResControl, pResControl->controlFunctionalPaneNamesOffset + + 24 * m_FunctionalPaneCount) + .Get(); + m_pControlFunctionalPaneParameterNameOffsets = + util::ConstBytePtr(pResControl, + pResControl->controlFunctionalPaneParameterNameOffsetsOffset) + .Get(); + m_pControlFunctionalAnimParameterNameOffsets = + util::ConstBytePtr(pResControl, + pResControl->controlFunctionalAnimParameterNameOffsetsOffset) + .Get(); + m_pExtUserDataList = pUserDataBlock; +} + +const char* ControlSrc::GetFunctionalPaneName(int index) const { + if (index < GetFunctionalPaneCount()) { + return &m_pFunctionalPaneNames[24 * index]; + } + + return nullptr; +} + +const char* ControlSrc::FindFunctionalPaneName(const char* pParameterName) const { + for (uint32_t i = 0; i < m_FunctionalPaneCount; ++i) { + const char* pName = util::ConstBytePtr(m_pControlFunctionalPaneParameterNameOffsets, + static_cast( + m_pControlFunctionalPaneParameterNameOffsets)[i]) + .Get(); + + if (strcmp(pName, pParameterName) == 0) { + return &m_pFunctionalPaneNames[24 * i]; + } + } + + return nullptr; +} + +const char* ControlSrc::GetFunctionalAnimName(int index) const { + if (index < GetFunctionalAnimCount()) { + return util::ConstBytePtr( + m_pControlFunctionalAnimNameOffests, + static_cast(m_pControlFunctionalAnimNameOffests)[index]) + .Get(); + } + + return nullptr; +} + +const char* ControlSrc::FindFunctionalAnimName(const char* pParameterName) const { + for (uint32_t i = 0; i < m_FunctionalAnimCount; ++i) { + const char* pName = util::ConstBytePtr(m_pControlFunctionalAnimParameterNameOffsets, + static_cast( + m_pControlFunctionalAnimParameterNameOffsets)[i]) + .Get(); + + if (strcmp(pName, pParameterName) == 0) { + return util::ConstBytePtr( + m_pControlFunctionalAnimNameOffests, + static_cast(m_pControlFunctionalAnimNameOffests)[i]) + .Get(); + } + } + + return nullptr; +} + +uint16_t ControlSrc::GetExtUserDataCount() const { + if (m_pExtUserDataList) { + return m_pExtUserDataList->count; + } + + return 0; +} + +const ResExtUserData* ControlSrc::GetExtUserDataArray() const { + if (m_pExtUserDataList) { + return util::ConstBytePtr(m_pExtUserDataList, sizeof(ResExtUserDataList)) + .Get(); + } + + return 0; +} + +const ResExtUserData* ControlSrc::FindExtUserDataByName(const char* pName) const { + const ResExtUserData* pExtUserData = GetExtUserDataArray(); + if (!pExtUserData) { + return nullptr; + } + + for (int i = 0; i < m_pExtUserDataList->count; ++i, ++pExtUserData) { + if (strcmp(pName, pExtUserData->GetName()) == 0) { + return pExtUserData; + } + } + + return nullptr; +} + +} // namespace ui2d +} // namespace nn diff --git a/src/NintendoWare/ui2d/ui2d_GraphicsResource.cpp b/src/NintendoWare/ui2d/ui2d_GraphicsResource.cpp new file mode 100644 index 0000000..96bcb62 --- /dev/null +++ b/src/NintendoWare/ui2d/ui2d_GraphicsResource.cpp @@ -0,0 +1,61 @@ +#include + +#include +#include + +namespace nn { +namespace ui2d { + +namespace { +size_t GetSizeOfGraphicsResourceBuffers_(gfx::Device* pDevice) { + const size_t IndexBufferAlignment = font::detail::GetIndexBufferAlignment(pDevice); + + const size_t PaddingSizeForIndexBuffer = util::align_up(32, IndexBufferAlignment) - 32; + const size_t TotalMemoryPoolSize = util::align_up( + 44 + PaddingSizeForIndexBuffer, font::detail::GetPoolMemorySizeGranularity(pDevice)); + return TotalMemoryPoolSize; +} + +} // namespace + +size_t GraphicsResource::CalculateMemoryPoolSize(gfx::Device* pDevice, uint32_t charMax) { + size_t sizeOfRectDrawerPool = font::RectDrawer::CalculateMemoryPoolSize(pDevice, charMax); + + return GetSizeOfGraphicsResourceBuffers_(pDevice) + sizeOfRectDrawerPool; +} + +size_t GraphicsResource::CalculateMemoryPoolAlignment(gfx::Device* pDevice) { + return font::RectDrawer::CalculateMemoryPoolAlignment(pDevice); +} + +/* +void GraphicsResource::Setup(gfx::Device*, int, gfx::MemoryPool*, ptrdiff_t, size_t, + font::RectDrawer*, float); +gfx::BlendState* GraphicsResource::GetPresetBlendState(PresetBlendStateId); +PresetBlendStateId GraphicsResource::GetPresetBlendStateId(const ResBlendMode*, + const ResBlendMode*); +size_t GraphicsResource::SetupBlendStateInfo(gfx::BlendStateInfo*, gfx::BlendTargetStateInfo*, + const ResBlendMode*, const ResBlendMode*); + */ + +void GraphicsResource::InitializeVertexBuffer(gfx::Device*, gfx::MemoryPool*, ptrdiff_t, size_t) {} +/* +void GraphicsResource::ActivateVertexBuffer(gfx::CommandBuffer*) const; +void GraphicsResource::GetPresetBlendModeArray(const ResBlendMode**, const ResBlendMode**); +GraphicsResource::GraphicsResource(); +GraphicsResource::~GraphicsResource(); +void GraphicsResource::Finalize(gfx::Device*); +*/ + +void GraphicsResource::RegisterCommonSamplerSlot(RegisterSamplerSlot pRegisterSamplerSlot, + void* pUserData) { + m_pFontDrawer.RegisterSamplerToDescriptorPool(pRegisterSamplerSlot, pUserData); +} + +/* +void GraphicsResource::UnregisterCommonSamplerSlot(UnregisterSamplerSlot, void*); +gfx::DescriptorSlot& GraphicsResource::GetSamplerDescriptorSlot(TexWrap, TexWrap, TexFilter, + TexFilter) const; +*/ +} // namespace ui2d +} // namespace nn diff --git a/src/NintendoWare/ui2d/ui2d_Group.cpp b/src/NintendoWare/ui2d/ui2d_Group.cpp new file mode 100644 index 0000000..da59471 --- /dev/null +++ b/src/NintendoWare/ui2d/ui2d_Group.cpp @@ -0,0 +1,91 @@ +#include + +#include +#include +#include + +namespace nn { +namespace ui2d { + +Group::Group() : m_pName(""), m_UserAllocated(false) {} + +Group::Group(const char* pName) : m_pName(pName), m_UserAllocated(false) {} + +Group::Group(const ResGroup* pResGroup, Pane* pRootPane) + : m_pName(pResGroup->name), m_UserAllocated(false) { + const char* const pPaneNameBase = util::ConstBytePtr(pResGroup, sizeof(ResGroup)).Get(); + + for (int i = 0; i < pResGroup->paneCount; ++i) { + if (Pane* pFindPane = + pRootPane->FindPaneByName(pPaneNameBase + i * ResourceNameStrMax, true)) { + AppendPane(pFindPane); + } + } +} + +Group::Group(const Group& group, Pane* pRootPane) : m_pName(group.m_pName), m_UserAllocated(false) { + const PaneLinkList& list = group.m_PaneLinkList; + if (pRootPane) { + for (PaneLinkList::const_iterator iter = list.begin(), endIter = list.end(); + iter != endIter; ++iter) { + AppendPane(pRootPane->FindPaneByName(iter->pTarget->GetName(), true)); + } + } else { + for (PaneLinkList::const_iterator iter = list.begin(), endIter = list.end(); + iter != endIter; ++iter) { + AppendPane(iter->pTarget); + } + } +} + +Group::~Group() { + for (PaneLinkList::iterator iter = m_PaneLinkList.begin(); iter != m_PaneLinkList.end();) { + PaneLinkList::iterator currIter = iter++; + m_PaneLinkList.erase(currIter); + Layout::DeleteObj(&*currIter); + } +} + +void Group::AppendPane(Pane* pPane) { + if (PaneLink* pPaneLink = Layout::AllocateAndConstruct()) { + pPaneLink->pTarget = pPane; + m_PaneLinkList.push_back(*pPaneLink); + } +} + +bool Group::CompareCopiedInstanceTest(const Group& target) const { + NN_UNUSED(target); + return true; +} + +GroupContainer::~GroupContainer() { + for (GroupList::iterator it = m_GroupList.begin(); it != m_GroupList.end();) { + GroupList::iterator currIt = it++; + m_GroupList.erase(currIt); + if (!currIt->IsUserAllocated()) { + Layout::DeleteObj(&*currIt); + } + } +} + +void GroupContainer::AppendGroup(Group* pGroup) { + m_GroupList.push_back(*pGroup); +} + +Group* GroupContainer::FindGroupByName(const char* pFindName) { + GroupList::iterator endIter = m_GroupList.end(); + for (GroupList::iterator iter = m_GroupList.begin(); iter != endIter; ++iter) { + if (detail::EqualsGroupName(iter->GetName(), pFindName)) { + return &*iter; + } + } + + return nullptr; +} + +const Group* GroupContainer::FindGroupByName(const char* pFindName) const { + return const_cast(this)->FindGroupByName(pFindName); +} + +} // namespace ui2d +} // namespace nn diff --git a/src/NintendoWare/ui2d/ui2d_Layout.cpp b/src/NintendoWare/ui2d/ui2d_Layout.cpp new file mode 100644 index 0000000..6306382 --- /dev/null +++ b/src/NintendoWare/ui2d/ui2d_Layout.cpp @@ -0,0 +1,973 @@ +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace nn { +namespace ui2d { + +AlignedAllocateFunctionWithUserData Layout::g_pAllocateFunction = nullptr; +FreeFunctionWithUserData Layout::g_pFreeFunction = nullptr; +void* Layout::g_pUserDataForAllocator = nullptr; +/* newer +static CreateRenderTargetTextureCallback Layout::g_pCreateRenderTargetTextureCallback; +static DestroyRenderTargetTextureCallback Layout::g_pDestroyRenderTargetTextureCallback; +static CreateRenderTargetTextureResourceCallback + Layout::g_pCreateRenderTargetTextureResourceCallback; +static DestroyRenderTargetTextureResourceCallback + Layout::g_pDestroyRenderTargetTextureResourceCallback; +static void* Layout::g_pRenderTargetTextureCallbackUserData; +static size_t Layout::g_CosntantBufferReservedSize; +*/ + +namespace { +void SetTagProcessorImpl(Pane* pPane, TextBox::TagProcessor* pTagProcessor) { + if (TextBox* pTextBox = DynamicCast(pPane)) { + pTextBox->SetTagProcessor(pTagProcessor); + } + + PaneList::iterator endIter = pPane->GetChildList().end(); + for (PaneList::iterator iter = pPane->GetChildList().begin(); iter != endIter; ++iter) { + SetTagProcessorImpl(&*iter, pTagProcessor); + } +} + +bool IsIncludeAnimationGroupRef(GroupContainer* pGroupContainer, + const ResAnimationGroupRef* pGroupRefs, uint16_t bindGroupNum, + bool bDescendingBind, Pane* pTargetPane) { + for (uint16_t groupIndex = 0; groupIndex < bindGroupNum; ++groupIndex) { + Group* const pGroup = pGroupContainer->FindGroupByName(pGroupRefs[groupIndex].GetName()); + PaneLinkList& paneList = pGroup->GetPaneList(); + + auto endIter = paneList.end(); + for (auto iter = paneList.begin(); iter != endIter; ++iter) { + if (iter->pTarget == pTargetPane) { + return true; + } + + if (bDescendingBind) { + for (Pane* pParentPane = pTargetPane->GetParent(); pParentPane; + pParentPane = pParentPane->GetParent()) { + if (iter->pTarget == pParentPane) { + return true; + } + } + } + } + } + + return false; +} + +const ResExtUserDataList* +TryReadNextBlockUserDataIfExist(const font::detail::BinaryFileHeader* const pFileHead, int* pIndex, + const void** ppDataPtr, + const font::detail::BinaryBlockHeader** ppDataBlockHead) { + if (*pIndex + 1 < pFileHead->dataBlocks) { + auto pNextDataBlockHead = util::ConstBytePtr(*ppDataPtr, (*ppDataBlockHead)->size) + .Get(); + if (pNextDataBlockHead->kind == DataBlockKindUserDataList) { + *pIndex += 1; + *ppDataPtr = pNextDataBlockHead; + *ppDataBlockHead = pNextDataBlockHead; + + return static_cast(*ppDataPtr); + } + } + + return nullptr; +} + +} // namespace + +void Layout::SetAllocator(AlignedAllocateFunctionWithUserData pAllocateFunction, + FreeFunctionWithUserData pFreeFunction, void* pUserData) { + g_pAllocateFunction = pAllocateFunction; + g_pFreeFunction = pFreeFunction; + g_pUserDataForAllocator = pUserData; +} + +void* Layout::AllocateMemory(size_t size, size_t alignment) { + return g_pAllocateFunction(size, alignment, g_pUserDataForAllocator); +} + +/* smo function +void* Layout::AllocateMemory(size_t size) { + return g_pAllocateFunction(size, DefaultAligment, g_pUserDataForAllocator); +} +*/ + +void Layout::FreeMemory(void* pMemory) { + g_pFreeFunction(pMemory, g_pUserDataForAllocator); +} + +Layout::Layout() + : m_pRootPane(nullptr), m_pGroupContainer(nullptr), m_Name(nullptr), + m_pResourceAccessor(nullptr), m_pGetUserShaderInformationFromUserDataCallback(nullptr) { + m_LayoutSize.Set(0.0f, 0.0f); +} + +Layout::~Layout() { + ; // hack to force vtable store +} + +void Layout::Finalize(gfx::Device* pDevice) { + m_PartsPaneList.clear(); + + DeleteObj(m_pGroupContainer); + m_pGroupContainer = nullptr; + + if (m_pRootPane && !m_pRootPane->IsUserAllocated()) { + m_pRootPane->Finalize(pDevice); + DeleteObj(m_pRootPane); + m_pRootPane = nullptr; + } + + for (AnimTransformList::iterator iter = m_AnimTransList.begin(); + iter != m_AnimTransList.end();) { + AnimTransformList::iterator currIter = iter++; + m_AnimTransList.erase(currIter); + DeleteObj(&*currIter); + } + + m_pResExtUserDataList = nullptr; + m_pResourceAccessor = nullptr; + m_LayoutSize.Set(0.0f, 0.0f); + m_Name = nullptr; + m_pGetUserShaderInformationFromUserDataCallback = nullptr; +} + +bool Layout::Build(BuildResultInformation* pOutBuildResultInformation, gfx::Device* pDevice, + ResourceAccessor* pResAcsr, ControlCreator* pControlCreator, + TextSearcher* pTextSearcher, const void* pLayoutResource, + const Layout::BuildOption& buildOption, bool utf8) { + ui2d::BuildArgSet buildArgSet; + buildArgSet.magnify.x = 1.0f; + buildArgSet.magnify.y = 1.0f; + buildArgSet.partsSize.x = 0.0f; + buildArgSet.partsSize.y = 0.0f; + buildArgSet.pControlCreator = pControlCreator; + buildArgSet.pTextSearcher = pTextSearcher; + buildArgSet.pLayout = nullptr; + buildArgSet.pBodyLayout = this; + buildArgSet.isRootPaneParts = buildOption.isRootPaneParts; + buildArgSet.isUtf8 = utf8; + buildArgSet.pGetUserShaderInformationFromUserDataCallback = + m_pGetUserShaderInformationFromUserDataCallback; + + return BuildImpl(pOutBuildResultInformation, pDevice, pLayoutResource, pResAcsr, buildArgSet, + nullptr); +} + +bool Layout::BuildWithName(BuildResultInformation* pOutBuildResultInformation, gfx::Device* pDevice, + ResourceAccessor* pResAcsr, ControlCreator* pControlCreator, + TextSearcher* pTextSearcher, const Layout::BuildOption& buildOption, + const char* pLayoutFileName, bool utf8) { + const void* pLayoutResource = pResAcsr->FindResourceByName(ResourceTypeLayout, pLayoutFileName); + if (pLayoutResource) { + return Build(pOutBuildResultInformation, pDevice, pResAcsr, pControlCreator, pTextSearcher, + pLayoutResource, buildOption, utf8); + } + + return false; +} + +Pane* Layout::BuildPartsImpl(BuildResultInformation* pOutBuildResultInformation, + gfx::Device* pDevice, const void* pData, + const PartsBuildDataSet* pPartsBuildDataSet, BuildArgSet& buildArgSet, + BuildResSet& buildResSet, const uint32_t kind) { + Pane* pPane = nullptr; + const void* pResBlock = pData; + const void* pOverrideResBlock = nullptr; + + buildArgSet.overrideUsageFlag = 0; + buildArgSet.overrideBasicUsageFlag = 0; + buildArgSet.overrideMaterialUsageFlag = 0; + buildArgSet.pOverridePartsPaneBasicInfo = nullptr; + + if (pPartsBuildDataSet) { + if (!GetRootPane()) { + pPane = pPartsBuildDataSet->GetPartsPane(); + } else { + const ResPane* pResPane = static_cast(pResBlock); + const ResPartsProperty* pResPartsProperty = + pPartsBuildDataSet->FindPartsPropertyFromName(pResPane->name); + + if (pResPartsProperty) { + pOverrideResBlock = pPartsBuildDataSet->GetPropertyResBlock(pResPartsProperty); + buildArgSet.overrideUsageFlag = pResPartsProperty->usageFlag; + buildArgSet.overrideBasicUsageFlag = pResPartsProperty->basicUsageFlag; + buildArgSet.overrideMaterialUsageFlag = pResPartsProperty->materialUsageFlag; + buildArgSet.pOverridePartsPaneBasicInfo = + pPartsBuildDataSet->GetPartsPaneBasicInfoResBlock(pResPartsProperty); + + bool isOverrideExtUserData = false; + const ResExtUserDataList* pUserDataList = + pPartsBuildDataSet->GetExtUserDataListResBlock(&isOverrideExtUserData, + pResPartsProperty); + if (isOverrideExtUserData) { + buildArgSet.pExtUserDataList = pUserDataList; + } + } + } + } else if (!GetRootPane() && buildArgSet.isRootPaneParts) { + ResParts resParts; + *static_cast(&resParts) = *static_cast(pResBlock); + resParts.blockHeader.kind = DataBlockKindParts; + resParts.propertyCount = 0; + resParts.magnify.x = 1.0f; + resParts.magnify.y = 1.0f; + pPane = BuildPaneObj(pOutBuildResultInformation, pDevice, DataBlockKindParts, &resParts, + pOverrideResBlock, buildArgSet); + static_cast(pPane)->SetLayout(this); + } + + if (!pPane) { + pPane = BuildPaneObj(pOutBuildResultInformation, pDevice, kind, pResBlock, + pOverrideResBlock, buildArgSet); + } + + if (pPane) { + if (!GetRootPane()) { + SetRootPane(pPane); + } + + if (buildArgSet.pParentPane) { + buildArgSet.pParentPane->AppendChild(pPane); + } + + if (kind == DataBlockKindParts) { + Parts* pPartsPane = static_cast(pPane); + const void* pLocalResBlock; + const BuildResSet* pLocalBuildResSet; + if (pOverrideResBlock) { + pLocalResBlock = pOverrideResBlock; + pLocalBuildResSet = buildArgSet.pOverrideBuildResSet; + } else { + pLocalResBlock = pData; + pLocalBuildResSet = &buildResSet; + } + + const ResParts* pResParts = static_cast(pLocalResBlock); + PartsBuildDataSet localPartsBuildDataSet( + pPartsPane, pResParts, pLocalBuildResSet, + &static_cast(pResBlock)->size); + + Layout* pLayout = BuildPartsLayout( + pOutBuildResultInformation, pDevice, + util::ConstBytePtr(pResParts, sizeof(ResParts) + sizeof(ResPartsProperty) * + pResParts->propertyCount) + .Get(), + localPartsBuildDataSet, buildArgSet); + if (pLayout) { + pPartsPane->SetLayout(pLayout); + m_PartsPaneList.push_back(*pPartsPane); + } + } + + return pPane; + } + + return nullptr; +} + +/* smo +bool IsFlytOlderThanBinary8200(const font::detail::BinaryFileHeader* pFileHead) { + const uint32_t BinaryFileFormatVersion8000 = 0x8000000; + const uint32_t BinaryFileFormatVersion8100 = 0x8010000; + + return pFileHead->version == BinaryFileFormatVersion8000 || + pFileHead->version == BinaryFileFormatVersion8100; +} +*/ + +/* newer +void Layout::FindResPaneByName(const ResPane**, const ResExtUserDataList**, const void*, const +char*, const ResPane*); +void Layout::PrepareBuildArgSet(BuildArgSet& buildArgSet, const BuildArgSet& parentBuildArgSet, +const Layout::PartsBuildDataSet* pPartsBuildDataSet); void +Layout::SetByResLayout(Layout::LayoutBuildContext&); void +Layout::BuildControl(Layout::LayoutBuildContext&, gfx::Device*); void +Layout::BuildPaneByResPane(Layout::LayoutBuildContext&, BuildResultInformation*, gfx::Device*, +const Layout::PartsBuildDataSet*); void Layout::BuildGroup(Layout::LayoutBuildContext&); +*/ + +bool Layout::BuildImpl(BuildResultInformation* pOutBuildResultInformation, gfx::Device* pDevice, + const void* pLayoutResource, ResourceAccessor* pResAcsr, + const BuildArgSet& parentBuildArgSet, + const PartsBuildDataSet* pPartsBuildDataSet) { + m_pResourceAccessor = pResAcsr; + + auto const pFileHead = static_cast(pLayoutResource); + font::detail::IsValidBinaryFile(pFileHead, FileSignatureFlyt); + + BuildResSet buildResSet{}; + buildResSet.pResAccessor = pResAcsr; + buildResSet.pLayout = this; + // smo + // buildResSet.isFlytOlderThanBinary8200 = IsFlytOlderThanBinary8200(pFileHead); + + BuildArgSet buildArgSet; + + if (pPartsBuildDataSet) { + buildArgSet.magnify = pPartsBuildDataSet->GetMagnify(); + buildArgSet.pOverrideBuildResSet = pPartsBuildDataSet->GetPropertyBuildResSet(); + } else { + buildArgSet.magnify.x = 1.0f; + buildArgSet.magnify.y = 1.0f; + buildArgSet.pOverrideBuildResSet = nullptr; + } + + buildArgSet.pControlCreator = parentBuildArgSet.pControlCreator; + buildArgSet.pTextSearcher = parentBuildArgSet.pTextSearcher; + buildArgSet.pLayout = this; + buildArgSet.pBodyLayout = parentBuildArgSet.pBodyLayout; + buildArgSet.pCurrentBuildResSet = &buildResSet; + buildArgSet.overrideUsageFlag = 0; + buildArgSet.overrideMaterialUsageFlag = 0; + buildArgSet.pParentPane = nullptr; + buildArgSet.isRootPaneParts = parentBuildArgSet.isRootPaneParts; + buildArgSet.isUtf8 = parentBuildArgSet.isUtf8; + buildArgSet.pGetUserShaderInformationFromUserDataCallback = + m_pGetUserShaderInformationFromUserDataCallback; + /* smo + buildArgSet.pGetUserShaderInformationFromUserDataCallbackUserData = + m_pGetUserShaderInformationFromUserDataCallbackData; + buildArgSet.resourceVersion = version; + */ + buildArgSet.partsSize.x = 0.0f; + buildArgSet.partsSize.y = 0.0f; + + Pane* pLastBuiltPane = nullptr; + bool firstGroup = false; + int groupNestLevel = 0; + + auto pData = util::ConstBytePtr(pLayoutResource, pFileHead->headerSize).Get(); + for (int i = 0; i < pFileHead->dataBlocks; ++i) { + auto pBlock = static_cast(pData); + uint32_t kind = pBlock->kind; + + switch (kind) { + case DataBlockKindLyt: { + auto pResLyt = static_cast(pData); + m_LayoutSize.width = pResLyt->layoutSize.x; + m_LayoutSize.height = pResLyt->layoutSize.y; + SetName(util::ConstBytePtr(pResLyt, sizeof(ResLayout)).Get()); + buildArgSet.partsSize.x = pResLyt->partsSize.x; + buildArgSet.partsSize.y = pResLyt->partsSize.y; + + m_pResExtUserDataList = TryReadNextBlockUserDataIfExist(pFileHead, &i, &pData, &pBlock); + } break; + + case DataBlockKindControl: + if (buildArgSet.pControlCreator) { + auto pControlData = pData; + auto pExtUserDataList = + TryReadNextBlockUserDataIfExist(pFileHead, &i, &pData, &pBlock); + + ControlSrc src(pControlData, pExtUserDataList); + buildArgSet.pControlCreator->CreateControl(pDevice, this, src); + } + break; + + case DataBlockKindTextureList: + buildResSet.pTextureList = static_cast(pData); + break; + + case DataBlockKindFontList: + buildResSet.pFontList = static_cast(pData); + break; + + case DataBlockKindMateriaList: + buildResSet.pMaterialList = static_cast(pData); + break; + + /* smo + case MakeSig("spi1"): + buildResSet.pShapeInfoList = static_cast(pData); + break; + */ + + case DataBlockKindPane: + case DataBlockKindPicture: + case DataBlockKindTextBox: + case DataBlockKindWindow: + case DataBlockKindBounding: + case DataBlockKindParts: { + auto pPartsData = pData; + + buildArgSet.pExtUserDataList = + TryReadNextBlockUserDataIfExist(pFileHead, &i, &pData, &pBlock); + + if (auto pane = BuildPartsImpl(pOutBuildResultInformation, pDevice, pPartsData, + pPartsBuildDataSet, buildArgSet, buildResSet, kind)) + pLastBuiltPane = pane; + } break; + + case DataBlockKindPaneStart: + buildArgSet.pParentPane = pLastBuiltPane; + break; + + case DataBlockKindPaneEnd: + pLastBuiltPane = buildArgSet.pParentPane; + buildArgSet.pParentPane = pLastBuiltPane->GetParent(); + break; + + case DataBlockKindGroup: + if (!firstGroup) { + firstGroup = true; + SetGroupContainer(AllocateAndConstruct()); + } else if (GetGroupContainer() && groupNestLevel == 1) { + if (auto group = AllocateAndConstruct(static_cast(pData), + GetRootPane())) { + GetGroupContainer()->AppendGroup(group); + } + } + break; + + case DataBlockKindGroupStart: + groupNestLevel++; + break; + + case DataBlockKindGroupEnd: + groupNestLevel--; + break; + + default: + break; + } + + pData = static_cast(pData) + pBlock->size; + } + + return true; +} + +/* newer +template // 2493 +void AllocateCaptureTexture(const ResCaptureTextureList*, ResourceAccessor*, const char*); + +template // 2495 +void InitializeCaptureTextureList(gfx::Device*, const ResCaptureTextureList*, const +Layout::PartsBuildDataSet*); +*/ + +void Layout::CopyLayoutInstanceImpl(gfx::Device* pDevice, const Layout& src, Layout* pParentLayout, + const char* pRootPaneName) { + m_pRootPane = nullptr; + m_pGroupContainer = nullptr; + m_LayoutSize = src.m_LayoutSize; + m_Name = src.m_Name; + m_pResExtUserDataList = nullptr; + m_pResourceAccessor = src.m_pResourceAccessor; + m_pGetUserShaderInformationFromUserDataCallback = nullptr; + // smo + // m_pGetUserShaderInformationFromUserDataCallbackData = nullptr; + + m_pRootPane = ClonePaneTreeWithPartsLayout( + src.m_pRootPane, src.m_pRootPane->GetParent() ? this : nullptr, pDevice, this); + + if (pRootPaneName) { + m_pRootPane->SetName(pRootPaneName); + } + + m_pGroupContainer = AllocateAndConstruct(); + const GroupList& src_groups = src.GetGroupContainer()->GetGroupList(); + for (GroupList::const_iterator iter = src_groups.begin(), endIter = src_groups.end(); + iter != endIter; ++iter) { + m_pGroupContainer->AppendGroup(AllocateAndConstruct(std::ref(*iter), m_pRootPane)); + } + + if (pParentLayout) { + Parts* pParts = DynamicCast(m_pRootPane); + if (pParts) { + pParentLayout->GetPartsPaneList().push_back(*pParts); + } + } +} + +void Layout::CalculateGlobalMatrix(DrawInfo& drawInfo, bool forceGlobalMatrixDirty) { + if (!GetRootPane()) { + return; + } + + Pane::CalculateContext context; + context.Set(drawInfo, this); + GetRootPane()->CalculateGlobalMatrix(context, forceGlobalMatrixDirty); +} + +AnimTransformBasic* Layout::CreateAnimTransformBasic() { + return CreateAnimTransform(); +} + +void Layout::DeleteAnimTransform(AnimTransform* pAnimTransform) { + m_AnimTransList.erase(m_AnimTransList.iterator_to(*pAnimTransform)); + DeleteObj(pAnimTransform); +} + +AnimTransformBasic* Layout::CreateAnimTransformBasic(gfx::Device* pDevice, + const void* pAnimResource) { + return CreateAnimTransform(pDevice, pAnimResource); +} + +AnimTransformBasic* Layout::CreateAnimTransformBasic(gfx::Device* pDevice, + const AnimResource& animRes) { + return CreateAnimTransform(pDevice, animRes); +} + +AnimTransformBasic* Layout::CreateAnimTransformBasic(gfx::Device* pDevice, const char* pTagName) { + return CreateAnimTransform(pDevice, pTagName); +} + +PaneAnimator* Layout::CreatePaneAnimator(gfx::Device* pDevice, const char* pTagName, Pane* pPane, + bool enabled) { + const void* pResData = GetAnimResourceData(pTagName); + PaneAnimator* pAnimator = CreateAnimTransform(pDevice, pResData); + pAnimator->Setup(pPane, enabled); + return pAnimator; +} + +GroupAnimator* Layout::CreateGroupAnimator(gfx::Device* pDevice, const char* pTagName, + Group* pGroup, bool enabled) { + const void* pResData = GetAnimResourceData(pTagName); + GroupAnimator* pAnimator = CreateAnimTransform(pDevice, pResData); + pAnimator->Setup(pGroup, enabled); + return pAnimator; +} + +GroupAnimator* Layout::CreateGroupAnimatorWithIndex(gfx::Device* pDevice, const char* pTagName, + int groupIndex, bool enabled) { + const void* pResData = GetAnimResourceData(pTagName); + AnimResource animRes(pResData); + GroupAnimator* pAnimator = CreateAnimTransform(pDevice, animRes); + pAnimator->Setup(animRes, m_pGroupContainer, groupIndex, enabled); + return pAnimator; +} + +GroupArrayAnimator* Layout::CreateGroupArrayAnimator(gfx::Device* pDevice, + const AnimResource& animRes, bool enabled) { + const ResAnimationBlock* const pAnimBlock = animRes.GetResourceBlock(); + if (!pAnimBlock) { + return nullptr; + } + + void* pPtr = AllocateMemory(88 + animRes.GetGroupCount() * 8); + if (!pPtr) { + return nullptr; + } + + GroupArrayAnimator* pAnimator = new (pPtr) GroupArrayAnimator(); + pAnimator->SetResource(pDevice, m_pResourceAccessor, pAnimBlock); + + GetAnimTransformList().push_back(*pAnimator); + + pAnimator->Setup(animRes, m_pGroupContainer, + util::BytePtr(pAnimator, sizeof(GroupArrayAnimator)).Get(), enabled); + return pAnimator; +} + +GroupArrayAnimator* Layout::CreateGroupArrayAnimator(gfx::Device* pDevice, const char* pTagName, + bool enabled) { + const void* pResData = GetAnimResourceData(pTagName); + AnimResource animRes(pResData); + return CreateGroupArrayAnimator(pDevice, animRes, enabled); +} + +Animator* Layout::CreateGroupAnimatorAuto(gfx::Device* pDevice, const char* pTagName, + bool enabled) { + const void* pResData = GetAnimResourceData(pTagName); + AnimResource animRes(pResData); + + if (animRes.GetGroupCount() > 1) { + return CreateGroupArrayAnimator(pDevice, animRes, enabled); + } else { + GroupAnimator* pAnimator = CreateAnimTransform(pDevice, animRes); + pAnimator->Setup(animRes, m_pGroupContainer, 0, enabled); + return pAnimator; + } + + return nullptr; +} + +void Layout::BindAnimation(AnimTransform* pAnimTrans) { + if (GetRootPane()) { + pAnimTrans->BindPane(GetRootPane(), true); + } +} + +void Layout::UnbindAnimation(AnimTransform* pAnimTrans) { + pAnimTrans->UnbindAll(); +} + +void Layout::UnbindAnimation(Pane* pPane) { + auto endIter = m_AnimTransList.end(); + for (auto iter = m_AnimTransList.begin(); iter != endIter; ++iter) { + iter->UnbindPane(pPane); + } +} + +void Layout::UnbindAllAnimation() { + auto endIter = m_AnimTransList.end(); + for (auto iter = m_AnimTransList.begin(); iter != endIter; ++iter) { + iter->UnbindAll(); + } +} + +bool Layout::BindAnimationAuto(gfx::Device* pDevice, const AnimResource& animRes) { + if (!GetRootPane() || !animRes.GetResourceBlock()) { + return false; + } + + auto pAnimTrans = CreateAnimTransformBasic(); + if (!pAnimTrans) { + return false; + } + + bool bResult = true; + + const uint16_t bindGroupNum = animRes.GetGroupCount(); + uint16_t animNum = 0; + + if (bindGroupNum == 0) { + animNum = animRes.GetResourceBlock()->animContCount; + pAnimTrans->SetResource(pDevice, m_pResourceAccessor, animRes.GetResourceBlock(), animNum); + const bool bRecursive = true; + GetRootPane()->BindAnimation(pAnimTrans, bRecursive, false); + } else { + const ResAnimationGroupRef* const pGroupRefs = animRes.GetGroupArray(); + + for (int groupIndex = 0; groupIndex < bindGroupNum; ++groupIndex) { + Group* const pGroup = + GetGroupContainer()->FindGroupByName(pGroupRefs[groupIndex].GetName()); + if (pGroup) { + animNum += animRes.CalculateAnimationCount(pGroup, animRes.IsDescendingBind()); + } else { + bResult = false; + } + } + + pAnimTrans->SetResource(pDevice, m_pResourceAccessor, animRes.GetResourceBlock(), animNum); + + for (int groupIndex = 0; groupIndex < bindGroupNum; ++groupIndex) { + Group* const pGroup = + GetGroupContainer()->FindGroupByName(pGroupRefs[groupIndex].GetName()); + if (pGroup) { + ui2d::BindAnimation(pAnimTrans, pGroup, false); + } + } + } + + const uint16_t animShareInfoNum = animRes.GetAnimationShareInfoCount(); + + if (animShareInfoNum != 0) { + const ResAnimationShareInfo* const pAnimShareInfos = animRes.GetAnimationShareInfoArray(); + + for (int i = 0; i < animShareInfoNum; ++i) { + Pane* const pSrcPane = + GetRootPane()->FindPaneByName(pAnimShareInfos[i].GetSrcPaneName(), true); + if (!pSrcPane) { + bResult = false; + continue; + } + + detail::AnimPaneTree animPaneTree(pSrcPane, animRes); + if (!animPaneTree.IsEnabled()) { + continue; + } + + Group* const pGroup = + GetGroupContainer()->FindGroupByName(pAnimShareInfos[i].GetTargetGroupName()); + if (!pGroup) { + bResult = false; + continue; + } + + PaneLinkList& paneList = pGroup->GetPaneList(); + for (auto iter = paneList.begin(); iter != paneList.end(); ++iter) { + if (iter->pTarget != pSrcPane) { + if (bindGroupNum != 0) { + const bool bInclude = IsIncludeAnimationGroupRef( + GetGroupContainer(), animRes.GetGroupArray(), bindGroupNum, + animRes.IsDescendingBind(), iter->pTarget); + + if (!bInclude) { + continue; + } + } + + animPaneTree.Bind(pDevice, this, iter->pTarget, m_pResourceAccessor); + } + } + } + } + + return bResult; +} + +void Layout::CalculateImpl(DrawInfo& drawInfo, bool forceGlbMtxDirty) { + if (!GetRootPane()) { + return; + } + + Pane::CalculateContext context; + context.Set(drawInfo, this); + + drawInfo.SetLayout(this); + GetRootPane()->Calculate(drawInfo, context, forceGlbMtxDirty); + drawInfo.SetLayout(nullptr); +} + +// newer +// void Layout::DrawCaptureTexture(gfx::Device*, DrawInfo&, gfx::CommandBuffer&); + +void Layout::Draw(DrawInfo& drawInfo, gfx::CommandBuffer& commandBuffer) { + if (!GetRootPane()) { + return; + } + + drawInfo.ResetVertexBufferState(); + // todo: throw in DrawInfo header + drawInfo.filler[0] = 6; + drawInfo.filler[1] = 0; + drawInfo.filler[2] = 0; + // smo + // drawInfo.ResetCurrentShader(); + + drawInfo.SetLayout(this); + GetRootPane()->Draw(drawInfo, commandBuffer); + drawInfo.SetLayout(nullptr); +} + +void Layout::Animate() { + for (auto iter = m_AnimTransList.begin(), endIter = m_AnimTransList.end(); iter != endIter; + ++iter) { + iter->Animate(); + } + + for (auto iter = m_PartsPaneList.begin(), endIter = m_PartsPaneList.end(); iter != endIter; + ++iter) { + iter->GetLayout()->Animate(); + } +} + +void Layout::UpdateAnimFrame(float progressFrame) { + for (auto iter = m_AnimTransList.begin(), endIter = m_AnimTransList.end(); iter != endIter; + ++iter) { + iter->UpdateFrame(progressFrame); + } + + for (auto iter = m_PartsPaneList.begin(), endIter = m_PartsPaneList.end(); iter != endIter; + ++iter) { + iter->GetLayout()->UpdateAnimFrame(progressFrame); + } +} + +void Layout::AnimateAndUpdateAnimFrame(float progressFrame) { + for (auto iter = m_AnimTransList.begin(), endIter = m_AnimTransList.end(); iter != endIter; + ++iter) { + iter->Animate(); + iter->UpdateFrame(progressFrame); + } + + for (auto iter = m_PartsPaneList.begin(), endIter = m_PartsPaneList.end(); iter != endIter; + ++iter) { + iter->GetLayout()->AnimateAndUpdateAnimFrame(progressFrame); + } +} + +const font::Rectangle Layout::GetLayoutRect() const { + return font::Rectangle(m_LayoutSize.width * -0.5f, m_LayoutSize.height * 0.5f, + m_LayoutSize.width * 0.5f, m_LayoutSize.height * -0.5f); +} + +void Layout::SetTagProcessor(TextBox::TagProcessor* pTagProcessor) { + SetTagProcessorImpl(GetRootPane(), pTagProcessor); +} + +Parts* Layout::FindPartsPaneByName(const char* pFindName) { + for (auto iter = m_PartsPaneList.begin(), endIter = m_PartsPaneList.end(); iter != endIter; + ++iter) { + if (detail::EqualsResName(pFindName, iter->GetName())) { + return &*iter; + } + } + + return nullptr; +} + +/* newer +const CaptureTexture* Layout::FindCaptureTextureByPanePtr(const Pane*) const; +void Layout::ResetFirstFrameCaptureUpdatdFlag(); +*/ + +const Parts* Layout::FindPartsPaneByName(const char* pFindName) const { + return const_cast(this)->FindPartsPaneByName(pFindName); +} + +// bool Layout::CompareCopiedInstanceTest(const Layout&) const; + +const ShaderInfo* Layout::AcquireArchiveShader(gfx::Device* pDevice, const char* pName) const { + return m_pResourceAccessor->AcquireShader(pDevice, pName); +} + +Pane* Layout::BuildPaneObj(BuildResultInformation* pOutBuildResultInformation, gfx::Device* pDevice, + uint32_t kind, const void* pBlock, const void* pOverrideBlock, + const BuildArgSet& buildArgSet) { + switch (kind) { + case DataBlockKindPane: { + auto pResPane = static_cast(pBlock); + return AllocateAndConstructAligned(16, pResPane, std::ref(buildArgSet)); + } + + case DataBlockKindPicture: { + auto pResPic = static_cast(pBlock); + auto pResPicOverride = static_cast(pOverrideBlock); + return AllocateAndConstructAligned(16, pOutBuildResultInformation, pDevice, + pResPic, pResPicOverride, + std::ref(buildArgSet)); + } + + case DataBlockKindTextBox: { + auto pResTextBox = static_cast(pBlock); + auto pResTextBoxOverride = static_cast(pOverrideBlock); + TextBox::InitializeStringParam initStringParam; + TextBox* textBox = AllocateAndConstructAligned( + 16, pOutBuildResultInformation, pDevice, &initStringParam, pResTextBox, + pResTextBoxOverride, std::ref(buildArgSet)); + textBox->InitializeString(pOutBuildResultInformation, pDevice, buildArgSet, + initStringParam); + return textBox; + } + + case DataBlockKindWindow: { + auto pResWindow = static_cast(pBlock); + auto pResWindowOverride = static_cast(pOverrideBlock); + return AllocateAndConstructAligned(16, pOutBuildResultInformation, pDevice, + pResWindow, pResWindowOverride, + std::ref(buildArgSet)); + } + + case DataBlockKindBounding: { + auto pResBounding = static_cast(pBlock); + auto pResBoundingOverride = static_cast(pOverrideBlock); + return AllocateAndConstructAligned(16, pResBounding, pResBoundingOverride, + std::ref(buildArgSet)); + } + + case DataBlockKindParts: { + auto pResParts = static_cast(pBlock); + auto pResPartsOverride = static_cast(pOverrideBlock); + return AllocateAndConstructAligned(16, pResParts, pResPartsOverride, + std::ref(buildArgSet)); + } + + default: + break; + } + + return nullptr; +} + +Layout* Layout::BuildPartsLayout(BuildResultInformation* pOutBuildResultInformation, + gfx::Device* pDevice, const char* pName, + const PartsBuildDataSet& partsBuildDataSet, + const BuildArgSet& buildArgSet) { + const void* pResPtr = GetLayoutResourceData(pName); + + auto pLayout = AllocateAndConstruct(); + // auto pLayout = new (AllocateMemory(sizeof(Layout))) Layout(); + + pLayout->SetGetUserShaderInformationCallback(m_pGetUserShaderInformationFromUserDataCallback); + // pLayout->m_pGetUserShaderInformationFromUserDataCallback = + // m_pGetUserShaderInformationFromUserDataCallback; + /* smo + pLayout->m_pGetUserShaderInformationFromUserDataCallbackData = + m_pGetUserShaderInformationFromUserDataCallbackData; + */ + pLayout->BuildImpl(pOutBuildResultInformation, pDevice, pResPtr, m_pResourceAccessor, + buildArgSet, &partsBuildDataSet); + return pLayout; +} + +const void* Layout::GetAnimResourceData(const char* pTagName) const { + char brlanPath[136]; + util::SNPrintf(brlanPath, sizeof(brlanPath), "%s_%s.bflan", m_Name, pTagName); + return m_pResourceAccessor->FindResourceByName(ResourceTypeAnimation, brlanPath); +} + +const void* Layout::GetLayoutResourceData(const char* pLayoutName) const { + char bclytPath[72]; + util::SNPrintf(bclytPath, sizeof(bclytPath), "%s.bflyt", pLayoutName); + return m_pResourceAccessor->FindResourceByName(ResourceTypeLayout, bclytPath); +} + +Layout::PartsBuildDataSet::PartsBuildDataSet(Parts* pPartsPane, const ResParts* pResParts, + const BuildResSet* pBuildResSet, + const ResVec2* pOriginalSize) + : m_PropertyCount(pResParts->propertyCount), + m_pPropertyTable(util::ConstBytePtr(pResParts, sizeof(ResParts)).Get()), + m_pPartsPane(pPartsPane), m_pResParts(pResParts), m_pPropertyBuildResSet(pBuildResSet) { + m_Magnify.x = (pPartsPane->GetSize().width / pOriginalSize->x) * pResParts->magnify.x; + m_Magnify.y = (pPartsPane->GetSize().height / pOriginalSize->y) * pResParts->magnify.y; +} + +const ResPartsProperty* +Layout::PartsBuildDataSet::FindPartsPropertyFromName(const char* pName) const { + for (int32_t i = 0; i < m_PropertyCount; ++i) { + if (detail::EqualsResName(pName, m_pPropertyTable[i].name)) { + return &m_pPropertyTable[i]; + } + } + + return nullptr; +} + +/* newer +bool Layout::PartsBuildDataSet::IsOverwriting() const; +*/ + +const void* +Layout::PartsBuildDataSet::GetPropertyResBlock(const ResPartsProperty* pResPartsProperty) const { + if (pResPartsProperty->propertyOffset != 0) { + return util::ConstBytePtr(m_pResParts, pResPartsProperty->propertyOffset).Get(); + } + + return nullptr; +} + +const ResExtUserDataList* Layout::PartsBuildDataSet::GetExtUserDataListResBlock( + bool* pIsOverride, const ResPartsProperty* pResPartsProperty) const { + if (pResPartsProperty->extUserDataOffset == ExtUserDataOverrideOffset_NoOverride) { + *pIsOverride = false; + return nullptr; + } else if (pResPartsProperty->extUserDataOffset == ExtUserDataOverrideOffset_NoData) { + *pIsOverride = true; + return nullptr; + } else { + *pIsOverride = true; + return util::ConstBytePtr(m_pResParts, pResPartsProperty->extUserDataOffset) + .Get(); + } +} + +const ResPartsPaneBasicInfo* Layout::PartsBuildDataSet::GetPartsPaneBasicInfoResBlock( + const ResPartsProperty* pResPartsProperty) const { + if (pResPartsProperty->paneBasicInfoOffset != 0) { + return util::ConstBytePtr(m_pResParts, pResPartsProperty->paneBasicInfoOffset) + .Get(); + } + + return nullptr; +} + +} // namespace ui2d +} // namespace nn diff --git a/src/NintendoWare/ui2d/ui2d_Pane.cpp b/src/NintendoWare/ui2d/ui2d_Pane.cpp new file mode 100644 index 0000000..5e9d2fe --- /dev/null +++ b/src/NintendoWare/ui2d/ui2d_Pane.cpp @@ -0,0 +1,440 @@ +#include + +#include +#include +#include +#include +#include +#include + +namespace nn { +namespace ui2d { + +namespace detail { + +PaneBase::PaneBase() {} +PaneBase::~PaneBase() {} + +} // namespace detail + +Pane::Pane() { + Initialize(); + + m_Translate.x = 0.0f; + m_Translate.y = 0.0f; + m_Translate.z = 0.0f; + m_Rotate.x = 0.0f; + m_Rotate.y = 0.0f; + m_Rotate.z = 0.0f; + m_BasePosition = 0; + memset(m_UserData, 0, sizeof(m_UserData)); + memset(m_Name, 0, sizeof(m_Name)); + m_Scale.x = 0.0f; + m_Scale.y = 0.0f; + m_GlbAlpha = -1; + m_Alpha = -1; + + m_Size.Set(0.0f, 0.0f); + SetGlbMtxDirty(); + SetVisible(true); +} + +Pane::Pane(const ResPane* pBlock, const BuildArgSet& buildArgSet) : detail::PaneBase() { + Initialize(); + + const ResVec3* translate = &pBlock->translate; + + if (buildArgSet.pOverridePartsPaneBasicInfo) { + if (detail::TestBit(buildArgSet.overrideBasicUsageFlag, + BasicOverrideUsageFlag_TranslateEnabled)) + translate = &buildArgSet.pOverridePartsPaneBasicInfo->translate; + } +} + +// Pane::Pane(const Pane&); + +void Pane::Initialize() { + m_pExtUserDataList = nullptr; + m_pAnimatedExtUserDataList = nullptr; + m_pParent = nullptr; + m_Flag = 0; + m_FlagEx = 0; + nn::util::MatrixIdentity(&m_GlbMtx); + m_pUserMtx = nullptr; +} + +Pane::~Pane() {} + +void Pane::Finalize(gfx::Device* pDevice) { + for (auto it = m_ChildList.begin(); it != m_ChildList.end();) { + auto currIt = it++; + m_ChildList.erase(currIt); + if (!(*currIt).IsUserAllocated()) { + Parts* pParts = DynamicCast(&(*currIt)); + if (pParts && pParts->GetLayout()) { + Layout* pLayout = pParts->GetLayout(); + pLayout->Finalize(pDevice); + Layout::DeleteObj(pLayout); + } else { + (*currIt).Finalize(pDevice); + Layout::DeleteObj(&(*currIt)); + } + } + } + + if (detail::TestBit(m_FlagEx, PaneFlagEx_ExtUserDataAnimationEnabled)) { + Layout::FreeMemory(m_pAnimatedExtUserDataList); + } +} + +void Pane::SetName(const char* pName) { + util::Strlcpy(m_Name, pName, sizeof(m_Name)); +} + +void Pane::SetUserData(const char* pUserData) { + util::Strlcpy(m_UserData, pUserData, sizeof(m_UserData)); +} + +void Pane::AppendChild(Pane* pChild) { + InsertChild(m_ChildList.end(), pChild); +} + +void Pane::PrependChild(Pane* pChild) { + InsertChild(m_ChildList.begin(), pChild); +} + +void Pane::InsertChild(Pane* pNext, Pane* pChild) { + InsertChild(m_ChildList.iterator_to(*pNext), pChild); +} + +void Pane::InsertChild(PaneList::iterator next, Pane* pChild) { + m_ChildList.insert(next, *pChild); + pChild->m_pParent = this; + pChild->SetGlbMtxDirty(); +} + +void Pane::RemoveChild(Pane* pChild) { + m_ChildList.erase(m_ChildList.iterator_to(*pChild)); + pChild->m_pParent = nullptr; +} +/* +const font::Rectangle Pane::GetPaneRect() const; +*/ + +const util::Unorm8x4 Pane::GetVertexColor(int idx) const { + NN_UNUSED(idx); + const util::Unorm8x4 result = {{0xFF, 0xFF, 0xFF, 0xFF}}; + return result; +} + +void Pane::SetVertexColor(int idx, const util::Unorm8x4& value) { + NN_UNUSED(idx); + NN_UNUSED(value); +} + +uint8_t Pane::GetColorElement(int idx) const { + if (idx == AnimTargetPaneColor_PaneAlpha) { + return m_Alpha; + } else { + return GetVertexColorElement(idx); + } +} + +void Pane::SetColorElement(int idx, uint8_t value) { + if (idx == AnimTargetPaneColor_PaneAlpha) { + m_Alpha = value; + } else { + SetVertexColorElement(idx, value); + } +} + +uint8_t Pane::GetVertexColorElement(int idx) const { + NN_UNUSED(idx); + return 0xFF; +} + +void Pane::SetVertexColorElement(int idx, uint8_t value) { + NN_UNUSED(idx); + NN_UNUSED(value); +} + +Pane* Pane::FindPaneByName(const char* pFindName, bool bRecursive) { + if (detail::EqualsResName(m_Name, pFindName)) { + return this; + } + + if (bRecursive) { + PaneList::iterator endIter = m_ChildList.end(); + for (PaneList::iterator iter = m_ChildList.begin(); iter != endIter; ++iter) { + Pane* pPane = iter->FindPaneByNameRecursive(pFindName); + if (pPane) + return pPane; + } + } + + return nullptr; +} + +const Pane* Pane::FindPaneByName(const char* pFindName, bool bRecursive) const { + return const_cast(this)->FindPaneByName(pFindName, bRecursive); +} + +Material* Pane::FindMaterialByName(const char* pFindName, bool bRecursive) { + int nbMaterial = GetMaterialCount(); + for (int idx = 0; idx < nbMaterial; ++idx) { + Material* pMaterial = GetMaterial(idx); + if (pMaterial) { + if (detail::EqualsMaterialName(pMaterial->GetName(), pFindName)) { + return pMaterial; + } + } + } + + if (bRecursive) { + PaneList::iterator endIter = m_ChildList.end(); + for (PaneList::iterator iter = m_ChildList.begin(); iter != endIter; ++iter) { + Material* pMat = iter->FindMaterialByNameRecursive(pFindName); + if (pMat) + return pMat; + } + } + + return nullptr; +} + +const Material* Pane::FindMaterialByName(const char* pFindName, bool bRecursive) const { + return const_cast(this)->FindMaterialByName(pFindName, bRecursive); +} + +/* +void Pane::Calculate(DrawInfo& drawInfo, Pane::CalculateContext& context, bool isDirtyParentMtx) { + if (!IsVisible() && !context.isInvisiblePaneCalculateMtx) { + if (isDirtyParentMtx) { + SetGlbMtxDirty(); + } + + SetConstantBufferReady(false); + return; + } + + if (context.isInfluenceAlpha && m_pParent) { + m_GlbAlpha = m_Alpha * context.influenceAlpha; + } else { + m_GlbAlpha = m_Alpha; + } + + if (m_GlbAlpha == 0 && IsInfluencedAlpha() && !context.isAlphaZeroPaneCalculateMtx) { + if (isDirtyParentMtx) { + SetGlbMtxDirty(); + } + + SetConstantBufferReady(false); + return; + } + + bool isGlbMtxDirty = IsGlbMtxDirty() || isDirtyParentMtx; + if (IsUserGlobalMtx()) { + isGlbMtxDirty = true; + } else if (IsUserMtx()) { + nn::util::MatrixMultiply() + } +} +*/ + +void Pane::Draw(DrawInfo& drawInfo, gfx::CommandBuffer& commandBuffer) { + if (IsDrawTreeReady()) { + if (detail::TestBit(m_FlagEx, PaneFlagEx_IsConstantBufferReadySelf)) { + if (m_GlbAlpha) { + DrawSelf(drawInfo, commandBuffer); + } + } + + if (!IsInfluencedAlpha() || m_GlbAlpha) { + PaneList::iterator endIter = m_ChildList.end(); + for (PaneList::iterator iter = m_ChildList.begin(); iter != endIter; ++iter) { + iter->Draw(drawInfo, commandBuffer); + } + } + } +} + +void Pane::DrawSelf(DrawInfo& drawInfo, gfx::CommandBuffer& commandBuffer) { + NN_UNUSED(drawInfo); + NN_UNUSED(commandBuffer); +} + +void Pane::BindAnimation(AnimTransform* pAnimTrans, bool bRecursive, bool bEnable) { + pAnimTrans->BindPane(this, bRecursive); + pAnimTrans->SetEnabled(bEnable); +} + +// bool Pane::CompareCopiedInstanceTest(const Pane&) const; + +void Pane::UnbindAnimation(AnimTransform* pAnimTrans, bool bRecursive) { + UnbindAnimationSelf(pAnimTrans); + + if (bRecursive) { + PaneList::iterator endIter = m_ChildList.end(); + for (PaneList::iterator iter = m_ChildList.begin(); iter != endIter; ++iter) { + iter->UnbindAnimation(pAnimTrans, bRecursive); + } + } +} + +void Pane::UnbindAnimationSelf(AnimTransform* pAnimTrans) { + int nbMaterial = GetMaterialCount(); + for (int idx = 0; idx < nbMaterial; ++idx) { + Material* pMaterial = GetMaterial(idx); + if (pMaterial) { + pAnimTrans->UnbindMaterial(pMaterial); + } + } + + pAnimTrans->UnbindPane(this); +} + +void Pane::LoadMtx(DrawInfo& drawInfo) { + drawInfo.SetModelViewMtx(GetGlobalMtx()); +} + +/* +void Pane::CalculateGlobalMatrix(Pane::CalculateContext&, bool); +*/ + +const util::Float2 Pane::GetVertexPos() const { + // todo: figure out magic numbers + util::Float2 basePt{}; + switch (GetBasePositionX()) { + default: + basePt.x = 0.0f; + break; + case 0: + basePt.x = -m_Size.width * .5f; + break; + case 2: + basePt.x = -m_Size.width; + break; + } + + switch (GetBasePositionY()) { + default: + basePt.y = 0.0f; + break; + case 0: + basePt.y = m_Size.height * .5f; + break; + case 2: + basePt.y = m_Size.height; + break; + } + return basePt; +} + +Material* Pane::GetMaterial() const { + if (GetMaterialCount() != 0) { + return GetMaterial(0); + } + + return nullptr; +} + +uint8_t Pane::GetMaterialCount() const { + return 0; +} + +Material* Pane::GetMaterial(int idx) const { + NN_UNUSED(idx); + GetMaterialCount(); // leftover from assert? + return nullptr; +} + +uint16_t Pane::GetExtUserDataCount() const { + if (m_pExtUserDataList) { + return m_pExtUserDataList->count; + } + + return 0; +} + +const ResExtUserData* Pane::GetExtUserDataArray() const { + if (detail::TestBit(m_FlagEx, PaneFlagEx_ExtUserDataAnimationEnabled)) { + if (m_pAnimatedExtUserDataList) { + return util::ConstBytePtr(m_pAnimatedExtUserDataList, sizeof(ResExtUserDataList)) + .Get(); + } + } else { + if (m_pExtUserDataList) { + return util::ConstBytePtr(m_pExtUserDataList, sizeof(ResExtUserDataList)) + .Get(); + } + } + + return nullptr; +} + +// const ResExtUserData* Pane::FindExtUserDataByName(const char*) const; + +ResExtUserData* Pane::GetExtUserDataArrayForAnimation() const { + if (m_pAnimatedExtUserDataList) { + return util::BytePtr(m_pAnimatedExtUserDataList, sizeof(ResExtUserDataList)) + .Get(); + } + + return nullptr; +} + +/* +ResExtUserData* Pane::FindExtUserDataByNameForAnimation(const char*) const; +Pane* Pane::FindPaneByNameRecursive(const char*); +const Pane* Pane::FindPaneByNameRecursive(const char*) const; +Material* Pane::FindMaterialByNameRecursive(const char*); +const Material* Pane::FindMaterialByNameRecursive(const char*) const; +*/ + +void Pane::CalculateScaleFromPartsRoot(util::Float2* scale, Pane* pane) const { + scale->x = 1.0f; + scale->y = 1.0f; + + while (pane && !IsDerivedFrom(pane)) { + scale->x = scale->x * pane->m_Scale.x; + scale->y = scale->y * pane->m_Scale.y; + pane = pane->GetParent(); + } +} + +void Pane::CalculateContext::SetDefault() { + pRectDrawer = nullptr; + pViewMtx = nullptr; + locationAdjustScale.x = 1.0f; + locationAdjustScale.y = 1.0f; + influenceAlpha = 1.0f; + isLocationAdjust = false; + isInvisiblePaneCalculateMtx = false; + isAlphaZeroPaneCalculateMtx = false; + isInfluenceAlpha = false; + pLayout = nullptr; +} + +void Pane::CalculateContext::Set(const DrawInfo& drawInfo, const Layout* pLayoutData) { + pRectDrawer = &drawInfo.GetGraphicsResource()->GetFontDrawer(); + pViewMtx = &drawInfo.GetViewMtx(); + locationAdjustScale = drawInfo.GetLocationAdjustScale(); + influenceAlpha = 1.0f; + isLocationAdjust = drawInfo.IsLocationAdjustEnabled(); + isInvisiblePaneCalculateMtx = drawInfo.IsInvisiblePaneCalculated(); + isAlphaZeroPaneCalculateMtx = drawInfo.IsAlphaZeroPaneCalculated(); + isInfluenceAlpha = false; + pLayout = pLayoutData; +} + +void Pane::AllocateAndCopyAnimatedExtUserData(const ResExtUserDataList* pExtUserDataList) { + auto pDstExtUserDataList = static_cast( + Layout::AllocateMemory(pExtUserDataList->blockHeader.size)); + m_pAnimatedExtUserDataList = pDstExtUserDataList; + memcpy(m_pAnimatedExtUserDataList, pExtUserDataList, pExtUserDataList->blockHeader.size); +} + +// void Pane::CalculateGlobalMatrixSelf(Pane::CalculateContext&); + +} // namespace ui2d +} // namespace nn diff --git a/src/NintendoWare/ui2d/ui2d_ShaderInfo.cpp b/src/NintendoWare/ui2d/ui2d_ShaderInfo.cpp new file mode 100644 index 0000000..d9ba80c --- /dev/null +++ b/src/NintendoWare/ui2d/ui2d_ShaderInfo.cpp @@ -0,0 +1,164 @@ +#include + +#include +#include +#include +#include + +namespace nn { +namespace ui2d { + +void ShaderInfo::Initialize(gfx::Device* pDevice, void* pShader) { + InitializeWithVariationTable(pDevice, pShader, nullptr, nullptr, 0, 0); +} + +/* +void ShaderInfo::InitializeWithVariationTable(gfx::Device* pDevice, void* pShader, +const void* pVariationTable, +gfx::MemoryPool* pMemoryPool, +ptrdiff_t memoryPoolOffset, size_t memoryPoolSize) { +// unused with being inlined into Initialize, need to investigate for smo +NN_UNUSED(pVariationTable); +NN_UNUSED(pMemoryPool); +NN_UNUSED(memoryPoolOffset); +NN_UNUSED(memoryPoolSize); + +m_pResShaderFile = gfx::ResShaderFile::ResCast(pShader); + +// { there should be a scope here but I can't see what is causing it +gfx::ResShaderContainer* pContainer = m_pResShaderFile->GetShaderContainer(); +if (!pContainer || ) { +pContainer->Initialize(pDevice); + +/ figure this out with smo +util::BytePtr resShaderFileTop; +pContainer->Initialize(pDevice, pMemoryPool, memoryPoolOffset, memoryPoolSize); +resShaderFileTop.Distance(pContainer); +/ +} +{ ResShaderVariation* pVariation = pContainer->GetResShaderVariation(0); } + +for (int i = 1, variationCount = GetVariationCount(); i < variationCount; ++i) { +gfx::ResShaderVariation* pVariation = pContainer->GetResShaderVariation(i); +const bool isShaderInitialize = pVariation->GetResShaderProgram(gfx::ShaderCodeType_Binary); +gfx::ShaderInitializeResult shaderResult = +pVariation->GetResShaderProgram(gfx::ShaderCodeType_Binary)->Initialize(); +} +//} + +{ +int variationCount = GetVariationCount(); +Layout::NewArray(variationCount); +} + +for (int i = 0, variationCount = GetVariationCount(); i < variationCount; ++i) { +gfx::Shader* pVertexShader = GetVertexShader(i); +gfx::Shader* pGeometryShader = GetVertexShader(i); +gfx::Shader* pPixelShader = GetVertexShader(i); +pVertexShader->GetInterfaceSlot(gfx::ShaderStage_Vertex, +gfx::ShaderInterfaceType_ConstantBuffer, ""); +pGeometryShader->GetInterfaceSlot(gfx::ShaderStage_Geometry, +gfx::ShaderInterfaceType_ConstantBuffer, ""); +pPixelShader->GetInterfaceSlot(gfx::ShaderStage_Pixel, +gfx::ShaderInterfaceType_ConstantBuffer, ""); +pPixelShader->GetInterfaceSlot(gfx::ShaderStage_Pixel, gfx::ShaderInterfaceType_Sampler, +""); +pPixelShader->GetInterfaceSlot(gfx::ShaderStage_Pixel, gfx::ShaderInterfaceType_Sampler, +""); +pPixelShader->GetInterfaceSlot(gfx::ShaderStage_Pixel, gfx::ShaderInterfaceType_Sampler, +""); +} +} +*/ + +void ShaderInfo::InitializeVertexStates(gfx::Device* pDevice) { + for (int i = 0, variationCount = GetVariationCount(); i < variationCount; ++i) { + gfx::Shader* pVertexShader = GetVertexShader(i); + gfx::VertexStateInfo info; + info.SetDefault(); + + gfx::VertexAttributeStateInfo attribs[3]; + int attribCount = 0; + int stride = 0; + + if (pVertexShader->GetInterfaceSlot(gfx::ShaderStage_Vertex, gfx::ShaderInterfaceType_Input, + "aVertexIndex") >= 0) { + attribs[attribCount].SetDefault(); + attribs[attribCount].SetNamePtr("aVertexIndex"); + attribs[attribCount].SetBufferIndex(0); + attribs[attribCount].SetOffset(stride); + attribs[attribCount].SetFormat(gfx::AttributeFormat_32_32_Float); + + ++attribCount; + stride += 8; + } + + if (pVertexShader->GetInterfaceSlot(gfx::ShaderStage_Vertex, gfx::ShaderInterfaceType_Input, + "aPosition") >= 0) { + attribs[attribCount].SetDefault(); + attribs[attribCount].SetNamePtr("aPosition"); + attribs[attribCount].SetBufferIndex(0); + attribs[attribCount].SetOffset(stride); + attribs[attribCount].SetFormat(gfx::AttributeFormat_32_32_32_Float); + + ++attribCount; + stride += 12; + } + + if (pVertexShader->GetInterfaceSlot(gfx::ShaderStage_Vertex, gfx::ShaderInterfaceType_Input, + "aTexCoord") >= 0) { + attribs[attribCount].SetDefault(); + attribs[attribCount].SetNamePtr("aTexCoord"); + attribs[attribCount].SetBufferIndex(0); + attribs[attribCount].SetOffset(stride); + attribs[attribCount].SetFormat(gfx::AttributeFormat_32_32_Float); + + ++attribCount; + stride += 8; + } + + gfx::VertexBufferStateInfo buffer[1]; + buffer[0].SetDefault(); + buffer[0].SetStride(stride); + buffer[0].SetDivisor(0); + + info.SetVertexAttributeStateInfoArray(attribs, attribCount); + info.SetVertexBufferStateInfoArray(buffer, 1); + + size_t size = gfx::VertexState::GetRequiredMemorySize(info); + m_pVertexStates[i].SetMemory(Layout::AllocateMemory(size, 8), size); + m_pVertexStates[i].Initialize(pDevice, info, pVertexShader); + } +} +/* +void ShaderInfo::Finalize(gfx::Device*, bool); +void ShaderInfo::SetShader(gfx::CommandBuffer&, int) const; +*/ + +gfx::Shader* ShaderInfo::GetVertexShader(int variation) const { + return m_pResShaderFile->GetShaderContainer() + ->GetResShaderVariation(variation) + ->GetResShaderProgram(m_CodeType) + ->GetShader(); +} + +gfx::Shader* ShaderInfo::GetGeometryShader(int variation) const { + return m_pResShaderFile->GetShaderContainer() + ->GetResShaderVariation(variation) + ->GetResShaderProgram(m_CodeType) + ->GetShader(); +} + +gfx::Shader* ShaderInfo::GetPixelShader(int variation) const { + return m_pResShaderFile->GetShaderContainer() + ->GetResShaderVariation(variation) + ->GetResShaderProgram(m_CodeType) + ->GetShader(); +} + +int ShaderInfo::GetVariationCount() const { + return m_pResShaderFile->GetShaderContainer()->GetShaderVariationCount(); +} + +} // namespace ui2d +} // namespace nn diff --git a/src/NintendoWare/ui2d/ui2d_Util.cpp b/src/NintendoWare/ui2d/ui2d_Util.cpp new file mode 100644 index 0000000..7049994 --- /dev/null +++ b/src/NintendoWare/ui2d/ui2d_Util.cpp @@ -0,0 +1,93 @@ +#include + +namespace nn { +namespace ui2d { + +/* +bool LoadTexture(ResourceTextureInfo*, gfx::Device*, const void*); +void LoadArchiveShader(ShaderInfo*, gfx::Device*, void*, const void*, gfx::MemoryPool*, long, + unsigned long); +void FreeArchiveShader(gfx::Device*, ShaderInfo*); +void ConvertBlendsToArchiveShaderName(char*, int, int); +void ConvertStageBitsToArchiveShaderDetailedCombinerName(char*, int, int, int, int*); +bool ConvertArchiveShaderNameToBlends(int*, int*, const char*); +void ConvertArchiveShaderDetailedCombinerNameToStageBits(int*, const char*); +int SearchShaderVariationIndexFromTable(const void*, int, int); +int SearchShaderVariationDetailedCombinerIndexFromTable(const void*, int*); + +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* ClonePaneTree(const Pane*, gfx::Device*, ResourceAccessor*, const char*); +Pane* ClonePaneTreeWithPartsLayout(const Pane*, Layout*, gfx::Device*, Layout*); +Pane* ClonePaneTreeWithPartsLayout(const Pane*, Layout*, gfx::Device*, Layout*, ResourceAccessor*, + const char*); +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*, int); +float GetParameterizedAnimValue(float, float, const ResParameterizedAnim*); +float GetParameterizedAnimValueAtFrame(float, const ResParameterizedAnimParameter*); +const ResExtUserData* GetExtUserData(const ResExtUserDataList*, const char*); +size_t GetAlignedBufferSize(gfx::Device*, gfx::GpuAccess, unsigned long); +void SetDefaultShaderId(Material*, int); +bool IsResShaderContainerInitialized(gfx::ResShaderContainer*); +bool IsResShaderProgramInitialized(gfx::ResShaderProgram*); +void MakeCaptureTextureName(char*, unsigned long, const char*, const char*); +size_t CalcCaptureTexturePrefixLength(const BuildArgSet&, int); +void ConcatCaptureTexturePrefixString(char*, unsigned long, const BuildArgSet&, int); +const TextureInfo* AcquireCaptureTextureWithResolvePrefix(char*, int, const BuildArgSet&, bool, + gfx::Device*, ResourceAccessor*, + const char*); +const TextureInfo* AcquireCaptureTexture(char*, int, gfx::Device*, ResourceAccessor*, const char*, + const char*); +gfx::ShaderCodeType TryInitializeAndGetShaderCodeType(gfx::Device*, gfx::ResShaderVariation*); + +int ComplexFontHelper::SetupTextureCacheArg(font::TextureCache::InitializeArg*, AcquireFontFunction, + void*, const void*); +font::Font* ComplexFontHelper::InitializeComplexFontTree(gfx::Device*, + font::RegisterTextureViewSlot, void*, + font::TextureCache*, int, + AcquireFontFunction, void*, const void*); +void ComplexFontHelper::FinalizeComplexFontTree(gfx::Device*, font::Font*, + font::UnregisterTextureViewSlot, void*); +bool ComplexFontHelper::CheckExt(const char*, const char*); + +template +void ComplexFontHelper::BuildTextureCacheArg(const void*, int*, font::TextureCache::InitializeArg*, + AcquireFontFunction, void*, unsigned int); + +template +font::Font* ComplexFontHelper::BuildFontTree(gfx::Device*, font::RegisterTextureViewSlot, void*, + const void*, int*, font::TextureCache*, + AcquireFontFunction, void*, unsigned int); + +void ComplexFontHelper::DestroyFontTree(gfx::Device*, font::Font*, font::UnregisterTextureViewSlot, + void*); +*/ + +/* smo +void RoundRectShape::RoundRectShape(gfx::util::PrimitiveShapeFormat, gfx::PrimitiveTopology, float, + float, unsigned int); +void RoundRectShape::RoundRectShape(gfx::util::PrimitiveShapeFormat, gfx::PrimitiveTopology); +void RoundRectShape::~RoundRectShape(); +void RoundRectShape::CopyParams(const RoundRectShape&); +int RoundRectShape::CalculateVertexCount(); +int RoundRectShape::CalculateIndexCount(); +void* RoundRectShape::CalculateVertexBuffer(); +void RoundRectShape::CalculateIndexBuffer(); +void RoundRectShape::CalculateIndexBuffer(); +void RoundRectShape::CalculateIndexBuffer(); +void RoundRectShape::CalculateImpl(void*, unsigned long, void*, unsigned long); +void Ui2dCircleShape::CopyParams(const Ui2dCircleShape&); +*/ + +} // namespace ui2d +} // namespace nn