Add Nee Backend Structure

Use TexAddress instead of Texture::Ref in Cmds Add a .clang-format??
Add MacOS support as well as OpenGL 3.3 support
2026-01-25 00:04:40 +01:00 · 2026-01-24 23:08:03 +01:00 · 2026-01-24 11:58:41 +01:00 · 2026-01-24 09:27:21 +01:00 · 2026-01-23 16:11:09 +01:00 · 2026-01-23 15:45:25 +01:00
42 changed files with 1431 additions and 241 deletions
@@ -0,0 +1,334 @@
+---
+Language:        Cpp
+AccessModifierOffset: -1
+AlignAfterOpenBracket: Align
+AlignArrayOfStructures: None
+AlignConsecutiveAssignments:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  AlignFunctionDeclarations: false
+  AlignFunctionPointers: false
+  PadOperators:    true
+AlignConsecutiveBitFields:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  AlignFunctionDeclarations: false
+  AlignFunctionPointers: false
+  PadOperators:    false
+AlignConsecutiveDeclarations:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  AlignFunctionDeclarations: true
+  AlignFunctionPointers: false
+  PadOperators:    false
+AlignConsecutiveMacros:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  AlignFunctionDeclarations: false
+  AlignFunctionPointers: false
+  PadOperators:    false
+AlignConsecutiveShortCaseStatements:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCaseArrows: false
+  AlignCaseColons: false
+AlignConsecutiveTableGenBreakingDAGArgColons:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  AlignFunctionDeclarations: false
+  AlignFunctionPointers: false
+  PadOperators:    false
+AlignConsecutiveTableGenCondOperatorColons:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  AlignFunctionDeclarations: false
+  AlignFunctionPointers: false
+  PadOperators:    false
+AlignConsecutiveTableGenDefinitionColons:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  AlignFunctionDeclarations: false
+  AlignFunctionPointers: false
+  PadOperators:    false
+AlignEscapedNewlines: Left
+AlignOperands:   Align
+AlignTrailingComments:
+  Kind:            Always
+  OverEmptyLines:  0
+AllowAllArgumentsOnNextLine: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowBreakBeforeNoexceptSpecifier: Never
+AllowShortBlocksOnASingleLine: Never
+AllowShortCaseExpressionOnASingleLine: true
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortCompoundRequirementOnASingleLine: true
+AllowShortEnumsOnASingleLine: true
+AllowShortFunctionsOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: WithoutElse
+AllowShortLambdasOnASingleLine: All
+AllowShortLoopsOnASingleLine: true
+AllowShortNamespacesOnASingleLine: false
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakBeforeMultilineStrings: true
+AttributeMacros:
+  - __capability
+  - absl_nonnull
+  - absl_nullable
+  - absl_nullability_unknown
+BinPackArguments: true
+BinPackLongBracedList: true
+BinPackParameters: BinPack
+BitFieldColonSpacing: Both
+BracedInitializerIndentWidth: -1
+BraceWrapping:
+  AfterCaseLabel:  false
+  AfterClass:      false
+  AfterControlStatement: Never
+  AfterEnum:       false
+  AfterExternBlock: false
+  AfterFunction:   false
+  AfterNamespace:  false
+  AfterObjCDeclaration: false
+  AfterStruct:     false
+  AfterUnion:      false
+  BeforeCatch:     false
+  BeforeElse:      false
+  BeforeLambdaBody: false
+  BeforeWhile:     false
+  IndentBraces:    false
+  SplitEmptyFunction: true
+  SplitEmptyRecord: true
+  SplitEmptyNamespace: true
+BreakAdjacentStringLiterals: true
+BreakAfterAttributes: Leave
+BreakAfterJavaFieldAnnotations: false
+BreakAfterReturnType: None
+BreakArrays:     true
+BreakBeforeBinaryOperators: None
+BreakBeforeConceptDeclarations: Always
+BreakBeforeBraces: Attach
+BreakBeforeInlineASMColon: OnlyMultiline
+BreakBeforeTemplateCloser: false
+BreakBeforeTernaryOperators: true
+BreakBinaryOperations: Never
+BreakConstructorInitializers: BeforeColon
+BreakFunctionDefinitionParameters: false
+BreakInheritanceList: BeforeColon
+BreakStringLiterals: true
+BreakTemplateDeclarations: Yes
+ColumnLimit:     80
+CommentPragmas:  '^ IWYU pragma:'
+CompactNamespaces: false
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+DerivePointerAlignment: false
+DisableFormat:   false
+EmptyLineAfterAccessModifier: Never
+EmptyLineBeforeAccessModifier: LogicalBlock
+EnumTrailingComma: Leave
+ExperimentalAutoDetectBinPacking: false
+FixNamespaceComments: true
+ForEachMacros:
+  - foreach
+  - Q_FOREACH
+  - BOOST_FOREACH
+IfMacros:
+  - KJ_IF_MAYBE
+IncludeBlocks:   Regroup
+IncludeCategories:
+  - Regex:           '^<ext/.*\.h>'
+    Priority:        2
+    SortPriority:    0
+    CaseSensitive:   false
+  - Regex:           '^<.*\.h>'
+    Priority:        1
+    SortPriority:    0
+    CaseSensitive:   false
+  - Regex:           '^<.*'
+    Priority:        2
+    SortPriority:    0
+    CaseSensitive:   false
+  - Regex:           '.*'
+    Priority:        3
+    SortPriority:    0
+    CaseSensitive:   false
+IncludeIsMainRegex: '([-_](test|unittest))?$'
+IncludeIsMainSourceRegex: ''
+IndentAccessModifiers: false
+IndentCaseBlocks: false
+IndentCaseLabels: true
+IndentExportBlock: true
+IndentExternBlock: AfterExternBlock
+IndentGotoLabels: true
+IndentPPDirectives: None
+IndentRequiresClause: true
+IndentWidth:     2
+IndentWrappedFunctionNames: false
+InsertBraces:    false
+InsertNewlineAtEOF: false
+InsertTrailingCommas: None
+IntegerLiteralSeparator:
+  Binary:          0
+  BinaryMinDigits: 0
+  Decimal:         0
+  DecimalMinDigits: 0
+  Hex:             0
+  HexMinDigits:    0
+JavaScriptQuotes: Leave
+JavaScriptWrapImports: true
+KeepEmptyLines:
+  AtEndOfFile:     false
+  AtStartOfBlock:  false
+  AtStartOfFile:   true
+KeepFormFeed:    false
+LambdaBodyIndentation: Signature
+LineEnding:      DeriveLF
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MainIncludeChar: Quote
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCBinPackProtocolList: Never
+ObjCBlockIndentWidth: 2
+ObjCBreakBeforeNestedBlockParam: true
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+OneLineFormatOffRegex: ''
+PackConstructorInitializers: NextLine
+PenaltyBreakAssignment: 2
+PenaltyBreakBeforeFirstCallParameter: 1
+PenaltyBreakBeforeMemberAccess: 150
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakOpenParenthesis: 0
+PenaltyBreakScopeResolution: 500
+PenaltyBreakString: 1000
+PenaltyBreakTemplateDeclaration: 10
+PenaltyExcessCharacter: 1000000
+PenaltyIndentedWhitespace: 0
+PenaltyReturnTypeOnItsOwnLine: 200
+PointerAlignment: Left
+PPIndentWidth:   -1
+QualifierAlignment: Leave
+RawStringFormats:
+  - Language:        Cpp
+    Delimiters:
+      - cc
+      - CC
+      - cpp
+      - Cpp
+      - CPP
+      - 'c++'
+      - 'C++'
+    CanonicalDelimiter: ''
+    BasedOnStyle:    google
+  - Language:        TextProto
+    Delimiters:
+      - pb
+      - PB
+      - proto
+      - PROTO
+    EnclosingFunctions:
+      - EqualsProto
+      - EquivToProto
+      - PARSE_PARTIAL_TEXT_PROTO
+      - PARSE_TEST_PROTO
+      - PARSE_TEXT_PROTO
+      - ParseTextOrDie
+      - ParseTextProtoOrDie
+      - ParseTestProto
+      - ParsePartialTestProto
+    CanonicalDelimiter: pb
+    BasedOnStyle:    google
+ReferenceAlignment: Pointer
+ReflowComments:  Always
+RemoveBracesLLVM: false
+RemoveEmptyLinesInUnwrappedLines: false
+RemoveParentheses: Leave
+RemoveSemicolon: false
+RequiresClausePosition: OwnLine
+RequiresExpressionIndentation: OuterScope
+SeparateDefinitionBlocks: Leave
+ShortNamespaceLines: 1
+SkipMacroDefinitionBody: false
+SortIncludes:
+  Enabled:         true
+  IgnoreCase:      false
+SortJavaStaticImport: Before
+SortUsingDeclarations: LexicographicNumeric
+SpaceAfterCStyleCast: false
+SpaceAfterLogicalNot: false
+SpaceAfterOperatorKeyword: false
+SpaceAfterTemplateKeyword: true
+SpaceAroundPointerQualifiers: Default
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCaseColon: false
+SpaceBeforeCpp11BracedList: false
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeJsonColon: false
+SpaceBeforeParens: ControlStatements
+SpaceBeforeParensOptions:
+  AfterControlStatements: true
+  AfterForeachMacros: true
+  AfterFunctionDefinitionName: false
+  AfterFunctionDeclarationName: false
+  AfterIfMacros:   true
+  AfterNot:        false
+  AfterOverloadedOperator: false
+  AfterPlacementOperator: true
+  AfterRequiresInClause: false
+  AfterRequiresInExpression: false
+  BeforeNonEmptyParentheses: false
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceBeforeSquareBrackets: false
+SpaceInEmptyBlock: false
+SpacesBeforeTrailingComments: 2
+SpacesInAngles:  Never
+SpacesInContainerLiterals: true
+SpacesInLineCommentPrefix:
+  Minimum:         1
+  Maximum:         -1
+SpacesInParens:  Never
+SpacesInParensOptions:
+  ExceptDoubleParentheses: false
+  InCStyleCasts:   false
+  InConditionalStatements: false
+  InEmptyParentheses: false
+  Other:           false
+SpacesInSquareBrackets: false
+Standard:        Auto
+StatementAttributeLikeMacros:
+  - Q_EMIT
+StatementMacros:
+  - Q_UNUSED
+  - QT_REQUIRE_VERSION
+TableGenBreakInsideDAGArg: DontBreak
+TabWidth:        8
+UseTab:          Never
+VerilogBreakBetweenInstancePorts: true
+WhitespaceSensitiveMacros:
+  - BOOST_PP_STRINGIZE
+  - CF_SWIFT_NAME
+  - NS_SWIFT_NAME
+  - PP_STRINGIZE
+  - STRINGIZE
+WrapNamespaceBodyWithEmptyLines: Leave
+...
+
@@ -42,13 +42,13 @@ class GfxC3D : public GfxDriver {
  void Deinit() override;
  void NewFrame() override;
  void BindTex(PD::Li::TexAddress addr) override;
-  void RenderDrawData(
-      const std::vector<PD::Li::Command::Ref>& Commands) override;
+  void RenderDrawData(const PD::Li::CmdPool& Commands) override;
  PD::Li::Texture::Ref LoadTex(
      const std::vector<PD::u8>& pixels, int w, int h,
      PD::Li::Texture::Type type = PD::Li::Texture::Type::RGBA32,
      PD::Li::Texture::Filter filter =
          PD::Li::Texture::Filter::LINEAR) override;
+  void DestroyTex(PD::Li::Texture::Ref tex) override;

  std::vector<Li::Vertex, LinearAllocator<Li::Vertex>> VertexBuffer;
  std::vector<u16, LinearAllocator<u16>> IndexBuffer;
@@ -95,6 +95,11 @@ void FragCfg(GPU_TEXCOLOR clr) {
      C3D_TexEnvFunc(env, C3D_RGB, GPU_REPLACE);
      C3D_TexEnvFunc(env, C3D_Alpha, GPU_MODULATE);
      break;
+    case GPU_RGB565:
+      C3D_TexEnvSrc(env, C3D_Alpha, GPU_TEXTURE0);
+      C3D_TexEnvFunc(env, C3D_RGB, GPU_MODULATE);
+      C3D_TexEnvFunc(env, C3D_Alpha, GPU_REPLACE);
+      break;

    default:
      C3D_TexEnvSrc(env, C3D_Both, GPU_TEXTURE0);
@@ -142,7 +147,7 @@ void GfxC3D::BindTex(PD::Li::TexAddress addr) {
  C3D_TexBind(0, reinterpret_cast<C3D_Tex*>(addr));
 }

-void GfxC3D::RenderDrawData(const std::vector<PD::Li::Command::Ref>& Commands) {
+void GfxC3D::RenderDrawData(const PD::Li::CmdPool& Commands) {
  shaderProgramUse(&Shader);
  C3D_SetAttrInfo(&ShaderInfo);
  C3D_Mtx proj;
@@ -151,20 +156,20 @@ void GfxC3D::RenderDrawData(const std::vector<PD::Li::Command::Ref>& Commands) {
  // Mat4 proj = Mat4::Ortho(0.f, ViewPort.x, ViewPort.y, 0.f, 1.f, -1.f);
  // C3D_FVUnifMtx4x4(GPU_VERTEX_SHADER, pLocProjection, (C3D_Mtx*)&proj);
  size_t index = 0;
-  while (index < Commands.size()) {
-    PD::Li::Texture::Ref Tex = Commands[index]->Tex;
+  while (index < Commands.Size()) {
+    PD::Li::Texture::Ref Tex = Commands.GetCmd(index)->Tex;
    if (!Tex) {
      index++;
      continue;
    }
-    bool ScissorEnabled = Commands[index]->ScissorOn;
-    ivec4 ScissorRect = Commands[index]->ScissorRect;
+    bool ScissorEnabled = Commands.GetCmd(index)->ScissorOn;
+    ivec4 ScissorRect = Commands.GetCmd(index)->ScissorRect;
    size_t StartIndex = CurrentIndex;

-    while (index < Commands.size() && Commands[index]->Tex == Tex &&
-           Commands[index]->ScissorOn == ScissorEnabled &&
-           Commands[index]->ScissorRect == ScissorRect) {
-      auto c = Commands[index].get();
+    while (index < Commands.Size() && Commands.GetCmd(index)->Tex == Tex &&
+           Commands.GetCmd(index)->ScissorOn == ScissorEnabled &&
+           Commands.GetCmd(index)->ScissorRect == ScissorRect) {
+      auto c = Commands.GetCmd(index);
      for (size_t i = 0; i < c->IndexBuffer.size(); i++) {
        IndexBuffer[CurrentIndex++] = CurrentVertex + c->IndexBuffer.at(i);
      }
@@ -255,4 +260,11 @@ PD::Li::Texture::Ref GfxC3D::LoadTex(const std::vector<PD::u8>& pixels, int w,
            << std::endl;
  return res;
 }
+
+void GfxC3D::DestroyTex(PD::Li::Texture::Ref tex) {
+  C3D_Tex* t = reinterpret_cast<C3D_Tex*>(tex->Address);
+  C3D_TexDelete(t);
+  delete t;
+  tex->Address = 0;
+}
 }  // namespace PD
@@ -2,6 +2,14 @@ cmake_minimum_required(VERSION 3.22)

 project(pd-desktop LANGUAGES CXX VERSION 0.5.0)

+set(PD_GL_VERSION 21 CACHE STRING "OpenGL Version (2.1 -> 21, 3.3 -> 33)")
+
+if(APPLE)
+set(PD_GL_VERSION 33 CACHE STRING "33" FORCE)
+endif()
+
+message("Using OpenGL: " ${PD_GL_VERSION})
+
 add_subdirectory(glad)
 add_subdirectory(glfw)

@@ -14,3 +22,7 @@ set(SRC
 pd_add_lib(pd-desktop SRC_FILES ${SRC})
 target_include_directories(pd-desktop PUBLIC include)
 target_link_libraries(pd-desktop PUBLIC palladium glad glfw)
+
+target_compile_definitions(pd-desktop
+    PRIVATE PD_OPENGL=${PD_GL_VERSION}
+)
@@ -44,8 +44,7 @@ class GfxGL2 : public GfxDriver {
  void Deinit() override;
  void NewFrame() override;
  void BindTex(PD::Li::TexAddress addr) override;
-  void RenderDrawData(
-      const std::vector<PD::Li::Command::Ref>& Commands) override;
+  void RenderDrawData(const Li::CmdPool& Commands) override;
  PD::Li::Texture::Ref LoadTex(
      const std::vector<PD::u8>& pixels, int w, int h,
      PD::Li::Texture::Type type = PD::Li::Texture::Type::RGBA32,
@@ -57,6 +56,35 @@ class GfxGL2 : public GfxDriver {
  GLuint Shader;
  GLuint pLocProjection;
  GLuint pLocTex;
-  GLuint VBO, IBO;
+  GLuint pLocAlfa;
+  GLuint VBO, IBO, VAO;  // vao is only used in > 3.3
+};
+
+class GfxGL3 : public GfxDriver2 {
+ public:
+  GfxGL3() : GfxDriver2("OpenGL3") {}
+  ~GfxGL3() = default;
+
+  PD_SHARED(GfxGL3);
+
+  void Init() override;
+  void Deinit() override;
+  // void NewFrame() override;
+  void TexBind(PD::Li::TexAddress addr) override;
+  void Draw(const Li::CmdPool& pool) override;
+  PD::Li::TexAddress TexLoad(
+      const std::vector<PD::u8>& pixels, int w, int h,
+      PD::Li::Texture::Type type = PD::Li::Texture::Type::RGBA32,
+      PD::Li::Texture::Filter filter =
+          PD::Li::Texture::Filter::LINEAR) override;
+  void TexDelete(PD::Li::TexAddress tex) override;
+
+  std::vector<Li::Vertex> VertexBuffer;
+  std::vector<PD::u16> IndexBuffer;
+  GLuint Shader;
+  GLuint pLocProjection;
+  GLuint pLocTex;
+  GLuint pLocAlfa;
+  GLuint VBO, IBO, VAO;  // vao is only used in > 3.3
 };
 }  // namespace PD
@@ -64,6 +64,7 @@ class HidGLFW : public HidDriver {
  GLFWwindow* Window;
  int PrevState;
  std::unordered_map<int, int> PrevStates;
+  static GLFWcharfun pOldTextCB;
  static std::string* pText;
  bool pInTextMode = false;
  PD::u64 pLastUpdate = 0;
@@ -25,6 +25,7 @@ SOFTWARE.
 #include <pd-desktop/bknd-gfx.hpp>

 namespace PD {
+#if PD_OPENGL >= 21 && PD_OPENGL < 33
 const char* vertex_shader = R"(
  #version 120
  
@@ -53,12 +54,62 @@ const char* frag_shader = R"(
  varying vec4 oColor;
  
  uniform sampler2D tex;
+  uniform bool alfa;
      
  void main() {
-      vec4 tc = texture2D(tex, oUV);
-      gl_FragColor = tc*oColor;
+    vec4 tc = texture2D(tex, oUV);
+    if (alfa) {
+      gl_FragColor = vec4(oColor.rgb, tc.a * oColor.a);
+    } else {
+      gl_FragColor = tc * oColor;
+    }
  }
  )";
+#elif PD_OPENGL >= 33
+const char* vertex_shader = R"(
+  #version 330 core
+  
+  layout(location = 0) in vec2 pos;
+  layout(location = 1) in vec2 uv;
+  layout(location = 2) in vec4 color;
+  
+  out vec2 oUV;
+  out vec4 oColor;
+  
+  // Probably forgot about this matrix and
+  // searched hours for why the rendering isn't working :/
+  uniform mat4 projection;
+  
+  void main() {
+      gl_Position = projection*vec4(pos, 0.0, 1.0);
+      oUV = uv;
+      oColor = color;
+  }
+  )";
+
+const char* frag_shader = R"(
+  #version 330 core
+      
+  in vec2 oUV;
+  in vec4 oColor;
+  
+  uniform sampler2D tex;
+  uniform bool alfa;
+
+  out vec4 FragColor;
+      
+  void main() {
+    vec4 tc = texture(tex, oUV);
+    if (alfa) {
+      FragColor = vec4(oColor.rgb, tc.a * oColor.a);
+    } else {
+      FragColor = tc * oColor;
+    }
+  }
+  )";
+#else
+// Need to show error
+#endif

 GLuint compileShader(const std::string& source, GLenum type) {
  GLuint shader = glCreateShader(type);
@@ -128,25 +179,47 @@ void GfxGL2::Init() {
  Shader = createShaderProgram(vertex_shader, frag_shader);
  glUseProgram(Shader);

+#if PD_OPENGL >= 33
+  glGenVertexArrays(1, &VAO);
+  glBindVertexArray(VAO);
+#endif
+
  glGenBuffers(1, &VBO);
  glBindBuffer(GL_ARRAY_BUFFER, VBO);

-  // Attribs Setup
-  SetupShaderAttribs(Shader);
-
+#if PD_OPENGL < 33
+  SetupShaderAttribs(Shader);  // GL 2.1
+#else
+  glEnableVertexAttribArray(0);
+  glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(PD::Li::Vertex),
+                        (void*)offsetof(PD::Li::Vertex, Pos));
+  glEnableVertexAttribArray(1);
+  glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(PD::Li::Vertex),
+                        (void*)offsetof(PD::Li::Vertex, UV));
+  glEnableVertexAttribArray(2);
+  glVertexAttribPointer(2, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(PD::Li::Vertex),
+                        (void*)offsetof(PD::Li::Vertex, Color));
+#endif
  glGenBuffers(1, &IBO);
  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO);

  pLocTex = glGetUniformLocation(Shader, "tex");
+  pLocAlfa = glGetUniformLocation(Shader, "alfa");
  pLocProjection = glGetUniformLocation(Shader, "projection");

  glBindBuffer(GL_ARRAY_BUFFER, 0);
  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+#if PD_OPENGL >= 33
+  glBindVertexArray(0);
+#endif
 }

 void GfxGL2::Deinit() {
  glDeleteBuffers(1, &VBO);
  glDeleteBuffers(1, &IBO);
+#if PD_OPENGL >= 33
+  glDeleteBuffers(1, &VAO);
+#endif
 }

 void GfxGL2::NewFrame() {
@@ -172,24 +245,27 @@ void GfxGL2::BindTex(PD::Li::TexAddress addr) {
  glActiveTexture(GL_TEXTURE0);
  glBindTexture(GL_TEXTURE_2D, (GLuint)addr);
  glUniform1i(pLocTex, 0);
+  GLint fmt = 0;
+  glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_INTERNAL_FORMAT, &fmt);
+  glUniform1i(pLocAlfa, fmt == GL_ALPHA);
 }

-void GfxGL2::RenderDrawData(const std::vector<PD::Li::Command::Ref>& Commands) {
+void GfxGL2::RenderDrawData(const Li::CmdPool& Commands) {
  size_t index = 0;
-  while (index < Commands.size()) {
-    PD::Li::Texture::Ref Tex = Commands[index]->Tex;
+  while (index < Commands.Size()) {
+    PD::Li::TexAddress Tex = Commands.GetCmd(index)->Tex;
    if (!Tex) {
      index++;
      continue;
    }
    size_t StartIndex = CurrentIndex;
-    bool ScissorOn = Commands[index]->ScissorOn;
-    ivec4 ScissorRect = Commands[index]->ScissorRect;
+    bool ScissorOn = Commands.GetCmd(index)->ScissorOn;
+    ivec4 ScissorRect = Commands.GetCmd(index)->ScissorRect;

-    while (index < Commands.size() && Commands[index]->Tex == Tex &&
-           Commands[index]->ScissorOn == ScissorOn &&
-           Commands[index]->ScissorRect == ScissorRect) {
-      auto c = Commands[index].get();
+    while (index < Commands.Size() && Commands.GetCmd(index)->Tex == Tex &&
+           Commands.GetCmd(index)->ScissorOn == ScissorOn &&
+           Commands.GetCmd(index)->ScissorRect == ScissorRect) {
+      auto c = Commands.GetCmd(index);
      for (size_t i = 0; i < c->IndexBuffer.size(); i++) {
        IndexBuffer[CurrentIndex++] = CurrentVertex + c->IndexBuffer.at(i);
      }
@@ -205,13 +281,21 @@ void GfxGL2::RenderDrawData(const std::vector<PD::Li::Command::Ref>& Commands) {
    } else {
      glDisable(GL_SCISSOR_TEST);
    }
-    BindTex(Tex->Address);
+    BindTex(Tex);
+
+#if PD_OPENGL >= 33
+    glBindVertexArray(VAO);
+#endif
+
    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glBufferData(GL_ARRAY_BUFFER, CurrentVertex * sizeof(PD::Li::Vertex),
                 &VertexBuffer[0], GL_DYNAMIC_DRAW);
+
+#if PD_OPENGL < 33
    // For some reason we need to set these every frame for every buffer
    // Found that out when creating My 3d Engine
    SetupShaderAttribs(Shader);
+#endif

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, CurrentIndex * sizeof(PD::u16),
@@ -223,6 +307,9 @@ void GfxGL2::RenderDrawData(const std::vector<PD::Li::Command::Ref>& Commands) {
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
    BindTex(0);
+#if PD_OPENGL >= 33
+    glBindVertexArray(0);
+#endif
  }
 }

@@ -253,4 +340,161 @@ PD::Li::Texture::Ref GfxGL2::LoadTex(const std::vector<PD::u8>& pixels, int w,
  auto res = PD::Li::Texture::New(texID, PD::ivec2(w, h));
  return res;
 }
+
+void GfxGL3::Init() {
+  VertexBuffer.resize(4 * 8192);
+  IndexBuffer.resize(6 * 8192);
+  Shader = createShaderProgram(vertex_shader, frag_shader);
+  glUseProgram(Shader);
+
+#if PD_OPENGL >= 33
+  glGenVertexArrays(1, &VAO);
+  glBindVertexArray(VAO);
+#endif
+
+  glGenBuffers(1, &VBO);
+  glBindBuffer(GL_ARRAY_BUFFER, VBO);
+
+#if PD_OPENGL < 33
+  SetupShaderAttribs(Shader);  // GL 2.1
+#else
+  glEnableVertexAttribArray(0);
+  glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(PD::Li::Vertex),
+                        (void*)offsetof(PD::Li::Vertex, Pos));
+  glEnableVertexAttribArray(1);
+  glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(PD::Li::Vertex),
+                        (void*)offsetof(PD::Li::Vertex, UV));
+  glEnableVertexAttribArray(2);
+  glVertexAttribPointer(2, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(PD::Li::Vertex),
+                        (void*)offsetof(PD::Li::Vertex, Color));
+#endif
+  glGenBuffers(1, &IBO);
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO);
+
+  pLocTex = glGetUniformLocation(Shader, "tex");
+  pLocAlfa = glGetUniformLocation(Shader, "alfa");
+  pLocProjection = glGetUniformLocation(Shader, "projection");
+
+  glBindBuffer(GL_ARRAY_BUFFER, 0);
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+#if PD_OPENGL >= 33
+  glBindVertexArray(0);
+#endif
+}
+
+void GfxGL3::Deinit() {
+  glDeleteBuffers(1, &VBO);
+  glDeleteBuffers(1, &IBO);
+#if PD_OPENGL >= 33
+  glDeleteBuffers(1, &VAO);
+#endif
+}
+
+// void NewFrame()  {
+//}
+
+void GfxGL3::TexBind(PD::Li::TexAddress addr) {
+  glActiveTexture(GL_TEXTURE0);
+  glBindTexture(GL_TEXTURE_2D, (GLuint)addr);
+  glUniform1i(pLocTex, 0);
+  GLint fmt = 0;
+  glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_INTERNAL_FORMAT, &fmt);
+  glUniform1i(pLocAlfa, fmt == GL_ALPHA);
+}
+
+void GfxGL3::Draw(const Li::CmdPool& pool) {
+  size_t index = 0;
+  while (index < pool.Size()) {
+    PD::Li::TexAddress Tex = pool.GetCmd(index)->Tex;
+    if (Tex == 0) {
+      index++;
+      continue;
+    }
+    size_t StartIndex = CurrentIndex;
+    bool ScissorOn = pool.GetCmd(index)->ScissorOn;
+    ivec4 ScissorRect = pool.GetCmd(index)->ScissorRect;
+
+    while (index < pool.Size() && pool.GetCmd(index)->Tex == Tex &&
+           pool.GetCmd(index)->ScissorOn == ScissorOn &&
+           pool.GetCmd(index)->ScissorRect == ScissorRect) {
+      auto c = pool.GetCmd(index);
+      for (size_t i = 0; i < c->IndexBuffer.size(); i++) {
+        IndexBuffer[CurrentIndex++] = CurrentVertex + c->IndexBuffer.at(i);
+      }
+      for (size_t i = 0; i < c->VertexBuffer.size(); i++) {
+        VertexBuffer[CurrentVertex++] = c->VertexBuffer.at(i);
+      }
+      index++;
+    }
+    if (ScissorOn) {
+      glScissor(ScissorRect.x, ViewPort.y - (ScissorRect.y + ScissorRect.w),
+                ScissorRect.z, ScissorRect.w);
+      glEnable(GL_SCISSOR_TEST);
+    } else {
+      glDisable(GL_SCISSOR_TEST);
+    }
+    TexBind(Tex);
+
+#if PD_OPENGL >= 33
+    glBindVertexArray(VAO);
+#endif
+
+    glBindBuffer(GL_ARRAY_BUFFER, VBO);
+    glBufferData(GL_ARRAY_BUFFER, CurrentVertex * sizeof(PD::Li::Vertex),
+                 &VertexBuffer[0], GL_DYNAMIC_DRAW);
+
+#if PD_OPENGL < 33
+    // For some reason we need to set these every frame for every buffer
+    // Found that out when creating My 3d Engine
+    SetupShaderAttribs(Shader);
+#endif
+
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO);
+    glBufferData(GL_ELEMENT_ARRAY_BUFFER, CurrentIndex * sizeof(PD::u16),
+                 &IndexBuffer[0], GL_DYNAMIC_DRAW);
+
+    glDrawElements(GL_TRIANGLES, CurrentIndex - StartIndex, GL_UNSIGNED_SHORT,
+                   (void*)(StartIndex * sizeof(PD::u16)));
+
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+    TexBind(0);
+#if PD_OPENGL >= 33
+    glBindVertexArray(0);
+#endif
+  }
+}
+
+PD::Li::TexAddress GfxGL3::TexLoad(const std::vector<PD::u8>& pixels, int w,
+                                   int h, PD::Li::Texture::Type type,
+                                   PD::Li::Texture::Filter filter) {
+  GLuint texID;
+  glGenTextures(1, &texID);
+  glBindTexture(GL_TEXTURE_2D, texID);
+
+  // Set base format (Always using RGBA as base)
+  GLenum fmt = GL_RGBA;
+  if (type == PD::Li::Texture::Type::RGB24) {
+    fmt = GL_RGB;
+  } else if (type == PD::Li::Texture::Type::A8) {
+    fmt = GL_ALPHA;
+  }
+  glTexImage2D(GL_TEXTURE_2D, 0, fmt, w, h, 0, fmt, GL_UNSIGNED_BYTE,
+               pixels.data());
+  if (filter == PD::Li::Texture::Filter::LINEAR) {
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+  } else if (filter == PD::Li::Texture::Filter::NEAREST) {
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+  }
+  glBindTexture(GL_TEXTURE_2D, 0);
+  return texID;
+}
+
+void GfxGL3::TexDelete(PD::Li::TexAddress tex) {
+  GLuint tex_ = tex;
+  glDeleteTextures(1, &tex_);
+}
+
 }  // namespace PD
@@ -24,11 +24,21 @@ SOFTWARE.

 #include <pd-desktop/bknd-hid.hpp>
 namespace PD {
-std::string* HidGLFW::pText;
+std::string* HidGLFW::pText = nullptr;
+GLFWcharfun HidGLFW::pOldTextCB = nullptr;
 // Default Call back (If no Text input is requsted)
-void NullTextCB(GLFWwindow* win, unsigned int c) {}
+void NullTextCB(GLFWwindow* win, unsigned int c) {
+  // Chain
+  if (HidGLFW::pOldTextCB) {
+    HidGLFW::pOldTextCB(win, c);
+  }
+}
 // Text callback if requested
 void TextCB(GLFWwindow* win, unsigned int c) {
+  // Chain
+  if (HidGLFW::pOldTextCB) {
+    HidGLFW::pOldTextCB(win, c);
+  }
  if (!HidGLFW::pText) {
    return;
  }
@@ -36,7 +46,7 @@ void TextCB(GLFWwindow* win, unsigned int c) {
 }
 HidGLFW::HidGLFW(GLFWwindow* win) : HidDriver("HidGLFW") {
  Window = win;
-  glfwSetCharCallback(Window, NullTextCB);
+  HidGLFW::pOldTextCB = glfwSetCharCallback(Window, NullTextCB);
  Flags |= Flags_HasKeyboard;
  Flags |= Flags_HasMouse;
  pBinds[GLFW_MOUSE_BUTTON_LEFT] = Touch;
@@ -53,6 +53,16 @@ SOFTWARE.
    return std::make_shared<x>(std::forward<Args>(args)...); \
  }

+#define PD_RAW(x)                           \
+  using Ref = x*;                           \
+  template <typename... Args>               \
+  static Ref New(Args&&... args) {          \
+    x* v = new x;                           \
+    new (v) x(std::forward<Args>(args)...); \
+    return v;                               \
+  }                                         \
+  static void Delete(Ref ref) { delete ref; }
+
 #define PD_UNIQUE(x)                                         \
  using Ref = std::unique_ptr<x>;                            \
  template <typename... Args>                                \
@@ -34,6 +34,31 @@ enum LiBackendFlags_ {
 };

 namespace PD {
+// The backend api nobody asked for
+class GfxDriver2 {
+ public:
+  GfxDriver2(const std::string& name = "NullGfx") : pName(name) {};
+  ~GfxDriver2() = default;
+
+  virtual void Init() {}
+  virtual void Deinit() {}
+  virtual void Draw(const PD::Li::CmdPool& pool) {}
+  virtual void TexBind(PD::Li::TexAddress addr) {}
+  virtual PD::Li::TexAddress TexLoad(
+      const std::vector<PD::u8>& pixels, int w, int h,
+      PD::Li::Texture::Type type = PD::Li::Texture::Type::RGBA32,
+      PD::Li::Texture::Filter filter = PD::Li::Texture::Filter::LINEAR) {
+    return 0;
+  }
+  virtual void TexDelete(PD::Li::TexAddress tex) {}
+
+ protected:
+  const std::string pName;
+  LiBackendFlags pFlags = 0;
+  size_t CurrentIndex = 0;
+  size_t CurrentVertex = 0;
+  ivec2 ViewPort;
+};
 class GfxDriver {
 public:
  GfxDriver(const std::string& name = "NullGfx") : pName(name) {};
@@ -49,7 +74,7 @@ class GfxDriver {

  virtual void BindTex(Li::TexAddress addr) {}

-  virtual void RenderDrawData(const std::vector<Li::Command::Ref>& Commands) {}
+  virtual void RenderDrawData(const Li::CmdPool& Commands) {}

  void SetViewPort(const ivec2& vp) { ViewPort = vp; }

@@ -61,6 +86,8 @@ class GfxDriver {
    return nullptr;
  }

+  virtual void DestroyTex(PD::Li::Texture::Ref tex) {}
+
  Li::Texture::Ref GetSolidTex() { return pSolid; }

  const std::string pName = "NullGfx";
@@ -96,7 +123,7 @@ class Gfx {
  static void SetViewPort(const ivec2& vp) { pGfx->SetViewPort(vp); }
  static void SetViewPort(int w, int h) { pGfx->SetViewPort(PD::ivec2(w, h)); }

-  static void RenderDrawData(const std::vector<Li::Command::Ref>& Commands) {
+  static void RenderDrawData(const Li::CmdPool& Commands) {
    pGfx->RenderDrawData(Commands);
  }

@@ -108,6 +135,8 @@ class Gfx {
    return pGfx->LoadTex(pixels, w, h, type, filter);
  }

+  static void DestroyTex(Li::Texture::Ref tex) { pGfx->DestroyTex(tex); }
+
  static Li::Texture::Ref GetSolidTex() { return pGfx->GetSolidTex(); }

  static GfxDriver::Ref pGfx;
@@ -57,6 +57,7 @@ class PD_IMAGE_API Image {

  int Width() const { return pWidth; }
  int Height() const { return pHeight; }
+  ivec2 Size() const { return ivec2(pWidth, pHeight); }
  Format Fmt() const { return pFmt; }

  void FlipVertical();
@@ -24,6 +24,7 @@ SOFTWARE.
 */

 #include <pd/core/core.hpp>
+#include <pd/lithium/pd_p_api.hpp>
 #include <pd/lithium/texture.hpp>
 #include <pd/lithium/vertex.hpp>

@@ -34,7 +35,7 @@ class Command {
  Command() = default;
  ~Command() = default;

-  PD_UNIQUE(Command);
+  PD_RAW(Command);

  Command& AddIdx(const u16& idx) {
    IndexBuffer.push_back(VertexBuffer.size() + idx);
@@ -52,13 +53,51 @@ class Command {
    return *this;
  }

+  void Clear() {
+    VertexBuffer.clear();
+    IndexBuffer.clear();
+    Index = 0;
+    Layer = 0;
+    Tex = 0;
+    ScissorOn = false;
+    ScissorRect = ivec4();
+  }
+
  std::vector<Vertex> VertexBuffer;
  std::vector<u16> IndexBuffer;
  ivec4 ScissorRect;
  bool ScissorOn = false;
-  int Layer;
-  int Index;
-  Texture::Ref Tex;
+  int Layer = 0;
+  int Index = 0;
+  TexAddress Tex;
+};
+
+class PD_LITHIUM_API CmdPool {
+ public:
+  CmdPool() {}
+  ~CmdPool() {}
+
+  Command::Ref NewCmd();
+  void Init(size_t initial_size);
+  void Deinit();
+  void Resize(size_t nulen);
+  void Reset();
+  Command::Ref GetCmd(size_t idx) const;
+  Command::Ref GetCmd(size_t idx);
+  size_t Size() const;
+  size_t Cap() const;
+  void Merge(CmdPool& p);
+  void Copy(CmdPool& p);
+  void Sort();
+
+ private:
+  static bool pTheOrder(const Command::Ref& a, const Command::Ref& b);
+  friend class DrawList;
+  Command::Ref* begin() { return &pPool[0]; }
+  Command::Ref* end() { return &pPool[pPoolIdx - 1]; }
+  std::vector<Command::Ref> pPool;
+  u32 pPoolIdx = 0;
+  int Layer = 0;
 };
 }  // namespace Li
 }  // namespace PD
@@ -48,8 +48,8 @@ namespace PD {
 namespace Li {
 class PD_LITHIUM_API DrawList {
 public:
-  DrawList() { DrawSolid(); }
-  ~DrawList() { pDrawList.clear(); }
+  DrawList(int initial_size = 64);
+  ~DrawList();

  /** Require Copy and Move Constructors */

@@ -81,13 +81,12 @@ class PD_LITHIUM_API DrawList {
   */
  void Optimize();

-  Command::Ref PreGenerateCmd();
-  void AddCommand(Command::Ref v);
+  Command::Ref GetNewCmd();
  void Clear();
-  void Layer(int l) { this->pLayer = l; }
-  int Layer() { return this->pLayer; }
-  void LayerUp() { this->pLayer++; }
-  void LayerDown() { this->pLayer--; }
+  void Layer(int l) { this->pPool.Layer = l; }
+  int Layer() { return this->pPool.Layer; }
+  void LayerUp() { this->pPool.Layer++; }
+  void LayerDown() { this->pPool.Layer--; }

  void SetFont(Font::Ref font) { pCurrentFont = font; }
  void SetFontScale(float scale) { pFontScale = scale; }
@@ -206,18 +205,17 @@ class PD_LITHIUM_API DrawList {
    }
    pClipRects.pop();
  }
-  const std::vector<Command::Ref>& Data() const { return pDrawList; }
+  const CmdPool& Data() const { return pPool; }
  /** One linear Clip rect Setup */
  void pClipCmd(Command* cmd);

  /** Data Section */

  std::stack<fvec4> pClipRects;
-  int pLayer;
  float pFontScale = 0.7f;
  Font::Ref pCurrentFont;
  Texture::Ref CurrentTex;
-  std::vector<Command::Ref> pDrawList;
+  CmdPool pPool;
  std::vector<fvec2> pPath;
  u32 pNumIndices = 0;
  u32 pNumVertices = 0;
@@ -93,8 +93,8 @@ class PD_LITHIUM_API Font {
  /**
   * Extended Draw Text Function that vreates a Command List
   */
-  void CmdTextEx(std::vector<Command::Ref>& cmds, const fvec2& pos, u32 color,
-                 float scale, const std::string& text, LiTextFlags flags = 0,
+  void CmdTextEx(CmdPool& cmds, const fvec2& pos, u32 color, float scale,
+                 const std::string& text, LiTextFlags flags = 0,
                 const fvec2& box = 0);

  /**
@@ -131,6 +131,8 @@ class Rect {
    return *this;
  }

+  bool operator==(Rect& r) { return Top == r.Top && Bot == r.Bot; }
+
  void SwapVec2XY() {
    Top.SwapXY();
    Top.SwapZW();
@@ -38,6 +38,8 @@ class Vertex {
  }
  ~Vertex() {}

+  PD_RAW(Vertex);
+
  // private:

  /** Open Access Data Section */
@@ -39,13 +39,15 @@ class PD_UI7_API Image : public Container {
   */
  Image(Li::Texture::Ref img, fvec2 size = 0.f, Li::Rect uv = fvec4(0.f)) {
    this->img = img;
-    this->newsize = size;
-    this->cuv = uv;
-    if (size.x != 0 || size.y != 0) {
-      this->SetSize(size);
-    } else {
-      this->SetSize(fvec2(img->GetSize().x, img->GetSize().y));
+    if (size == fvec2(0.f)) {
+      size = img->GetSize();
    }
+    if (uv == Li::Rect(fvec4(0.f))) {
+      uv = img->GetUV();
+    }
+    this->cuv = uv;
+    this->newsize = size;
+    SetSize(size);
  }
  ~Image() = default;

@@ -0,0 +1,91 @@
+#pragma once
+
+/*
+MIT License
+Copyright (c) 2024 - 2025 René Amthor (tobid7)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */
+
+#include <pd/ui7/container/container.hpp>
+#include <pd/ui7/io.hpp>
+
+namespace PD {
+namespace UI7 {
+/**
+ * Slider Object can take a datatype or a list
+ * and modifys these by moving left or right when dragging
+ */
+template <typename T>
+class PD_UI7_API Slider : public Container {
+ public:
+  /**
+   * Constructor
+   * @param label Label of the Button
+   * @param data Data reference (Supported types can be seen in Slider.cpp)
+   * @param num_elms Number of Array elements (for exaple with use ofvec4)
+   * @param io IO Reference
+   * @param min minimum number using Minimum limit
+   * @param max Maximum number set by max limit by default
+   * @param step To set the modifier for drag movement
+   * @param precision for float and double to set precision
+   */
+  Slider(const std::string& label, T* data, UI7::IO::Ref io,
+         T min = std::numeric_limits<T>::min(),
+         T max = std::numeric_limits<T>::max(), int precision = 1) {
+    // PD::Assert(data != nullptr, "Input Data Address is null!");
+    this->label = label;
+    this->data = data;
+    this->min = min;
+    this->max = max;
+    this->precision = precision;
+    this->width = io->CurrentViewPort.z * 0.3f;
+    this->tdim = io->Font->GetTextBounds(label, io->FontScale);
+  }
+  ~Slider() = default;
+
+  /** Als ob das funktioniert... */
+  PD_SHARED(Slider<T>);
+  /**
+   * Override for the Input Handler
+   * @note This function is usally called by Menu::Update
+   */
+  void HandleInput() override;
+  /**
+   * Override for the Rendering Handler
+   * @note This function is usally called by Menu::Update
+   * */
+  void Draw() override;
+
+  /** Function to Update Size if framepadding changes */
+  void Update() override;
+
+ private:
+  fvec2 tdim;         ///< Text size
+  float width;        ///< Size
+  std::string label;  ///< Label of the Button
+  T* data;
+  T min;
+  T max;
+  int precision = 1;
+  float slw = 0.f;  // silider drag width (calculated in update)
+  float slp = 0.f;  // silider drag pos (calculated in update)
+};
+}  // namespace UI7
+}  // namespace PD
@@ -30,3 +30,4 @@ SOFTWARE.
 #include <pd/ui7/container/dynobj.hpp>
 #include <pd/ui7/container/image.hpp>
 #include <pd/ui7/container/label.hpp>
+#include <pd/ui7/container/slider.hpp>
@@ -47,8 +47,9 @@ enum UI7MenuFlags_ {
  UI7MenuFlags_NoClose = 1 << 9,       ///< Disable Close Button
  UI7MenuFlags_NoScrollbar = 1 << 10,  ///< Hide the Scrollbar
  // POC
-  UI7MenuFlags_Maximize = 1 << 11,  ///< Add a Maximize Button
-  UI7MenuFlags_Minimize = 1 << 12,  ///< Add a Minimize Button
+  UI7MenuFlags_Maximize = 1 << 11,        ///< Add a Maximize Button
+  UI7MenuFlags_Minimize = 1 << 12,        ///< Add a Minimize Button
+  UI7MenuFlags_AlwaysAutoSize = 1 << 13,  ///< Always Auto Resize Menu
  // Enable Horizontal and Vertical Scrolling
  UI7MenuFlags_Scrolling = UI7MenuFlags_HzScrolling | UI7MenuFlags_VtScrolling,
 };
@@ -38,6 +38,7 @@ class ID {
   */
  ID(const std::string& text) {
    pID = PD::Strings::FastHash(text);
+    // pStrName = text;
    pName = text;
  }
  /**
@@ -56,7 +57,7 @@ class ID {
  ~ID() = default;

  /** Get The ID Initial Name */
-  constexpr const std::string_view& GetNameView() const { return pName; }
+  // constexpr const std::string_view& GetNameView() const { return pName; }
  const std::string GetName() const { return std::string(pName); }

  /** Getter for the raw 32bit int id */
@@ -65,8 +66,9 @@ class ID {
  /** Return the ID when casting to u32 */
  constexpr operator u32() const { return pID; }

-  u32 pID;                 ///< Hash of the name
-  std::string_view pName;  ///< Name
+  u32 pID;            ///< Hash of the name
+  std::string pName;  ///< Name
+  // std::string pStrName;    ///< Keep this stringview alive
 };
 }  // namespace UI7
 }  // namespace PD
@@ -73,6 +73,8 @@ class PD_UI7_API IO {
  UI7::Theme::Ref Theme;
  fvec2 MenuPadding = 5.f;
  fvec2 FramePadding = 5.f;
+  float ItemRowHeight = 0.f;
+  float FrameRounding = 0.f;
  fvec2 ItemSpace = vec2(5.f, 2.f);
  fvec2 MinSliderDragSize = 10.f;  // Min height (Vt) and Min Width (Hz)
  bool ShowMenuBorder = true;
@@ -26,6 +26,8 @@ SOFTWARE.

 #include <pd/core/core.hpp>
 #include <pd/ui7/container/container.hpp>
+#include <pd/ui7/container/dragdata.hpp>
+#include <pd/ui7/container/slider.hpp>
 #include <pd/ui7/flags.hpp>
 #include <pd/ui7/input_api.hpp>
 #include <pd/ui7/pd_p_api.hpp>
@@ -35,7 +37,7 @@ namespace PD {
 namespace UI7 {
 class PD_UI7_API Layout {
 public:
-  Layout(const ID& id, IO::Ref io) : ID(id) {
+  Layout(const ID &id, IO::Ref io) : ID(id) {
    this->IO = io;
    DrawList = Li::DrawList::New();
    DrawList->SetFont(IO->Font);
@@ -44,29 +46,93 @@ class PD_UI7_API Layout {
    Scrolling[1] = false;
    CursorInit();
    Pos = fvec2(io->CurrentViewPort.x, io->CurrentViewPort.y);
-    Size = fvec2(io->CurrentViewPort.z - io->CurrentViewPort.x,
-                 io->CurrentViewPort.w - io->CurrentViewPort.y);
+    Size = 0;
    WorkRect = fvec4(IO->MenuPadding, Size - (fvec2(2) * IO->MenuPadding));
  }
  ~Layout() = default;

  PD_SHARED(Layout);

-  const std::string GetName() const { return ID.GetName(); }
-  const UI7::ID& GetID() const { return this->ID; }
+  /** SECTION CONTAINERS */
+  /**
+   * Render a Simple Label
+   * @param label The text to draw
+   */
+  void Label(const std::string &label);
+  template <typename... Args>
+  void Label(std::format_string<Args...> s, Args &&...args) {
+    Label(std::format(s, std::forward<Args>(args)...));
+  }
+  /**
+   * Render a Button
+   * @param label The buttons text
+   * @return if the button was pressed
+   */
+  bool Button(const std::string &label);
+  /**
+   * Render a Checkbox
+   * @param label Label of the Checkbox
+   * @param v A value to update
+   */
+  void Checkbox(const std::string &label, bool &v);
+  /**
+   * Render an Image
+   * @param img Texture reference of the image
+   * @param size a Custom Size if needed
+   */
+  void Image(Li::Texture::Ref img, fvec2 size = 0.f, Li::Rect uv = fvec4(0));
+  /**
+   * Render a Drag Object witth any supported type:
+   * [`int`, `float`, `double`, `u8`, `u16`, `u32`]
+   * @param label Name of the Drag
+   * @param data Reference to Data Object (can be multiple as well)
+   * @param num_elements Defien the number of Elements in the Data addr
+   * @param precission Difine the Format string len for float/double
+   */
+  template <typename T>
+  void DragData(const std::string &label, T *data, size_t num_elms = 1,
+                T min = std::numeric_limits<T>::min(),
+                T max = std::numeric_limits<T>::max(), T step = 1,
+                int precision = 1) {
+    u32 id = Strings::FastHash("drd" + label + std::to_string((uintptr_t)data));
+    Container::Ref r = FindObject(id);
+    if (!r) {
+      r = UI7::DragData<T>::New(label, data, num_elms, this->IO, min, max, step,
+                                precision);
+      r->SetID(id);
+    }
+    AddObject(r);
+  }
+  template <typename T>
+  void Slider(const std::string &label, T *data,
+              T min = std::numeric_limits<T>::min(),
+              T max = std::numeric_limits<T>::max(), int precision = 1) {
+    u32 id = Strings::FastHash("drd" + label + std::to_string((uintptr_t)data));
+    Container::Ref r = FindObject(id);
+    if (!r) {
+      r = UI7::Slider<T>::New(label, data, this->IO, min, max, precision);
+      r->SetID(id);
+    }
+    AddObject(r);
+  }

-  const fvec2& GetPosition() const { return Pos; }
-  void SetPosition(const fvec2& v) { Pos = v; }
-  const fvec2& GetSize() const { return Size; }
-  void SetSize(const fvec2& v) { Size = v; }
+  /** SECTION OTHERSTUFF */
+
+  const std::string GetName() const { return ID.GetName(); }
+  const UI7::ID &GetID() const { return this->ID; }
+
+  const fvec2 &GetPosition() const { return Pos; }
+  void SetPosition(const fvec2 &v) { Pos = v; }
+  const fvec2 &GetSize() const { return Size; }
+  void SetSize(const fvec2 &v) { Size = v; }

  Li::DrawList::Ref GetDrawList() { return DrawList; }

  void CursorInit();
  void SameLine();
-  void CursorMove(const fvec2& size);
+  void CursorMove(const fvec2 &size);

-  bool ObjectWorkPos(fvec2& movpos);
+  bool ObjectWorkPos(fvec2 &movpos);

  /**
   * Extended Object Add Func to Add Object in Front or disable
@@ -25,6 +25,7 @@ SOFTWARE.
 */

 #include <pd/core/core.hpp>
+#include <pd/ui7/containers.hpp>
 #include <pd/ui7/io.hpp>
 #include <pd/ui7/layout.hpp>
 #include <pd/ui7/pd_p_api.hpp>
@@ -92,6 +93,19 @@ class PD_UI7_API Menu {
    }
    pLayout->AddObject(r);
  }
+  template <typename T>
+  void Slider(const std::string &label, T *data,
+              T min = std::numeric_limits<T>::min(),
+              T max = std::numeric_limits<T>::max(), int precision = 1) {
+    u32 id = Strings::FastHash("drd" + label + std::to_string((uintptr_t)data));
+    Container::Ref r = pLayout->FindObject(id);
+    if (!r) {
+      r = UI7::Slider<T>::New(label, data, pIO, min, max, precision);
+      r->SetID(id);
+    }
+    pLayout->AddObject(r);
+  }
+  void ColorEdit(const std::string &label, u32 &clr);
  void SameLine() { pLayout->SameLine(); }
  void Separator();
  void SeparatorText(const std::string &label);
@@ -107,6 +121,7 @@ class PD_UI7_API Menu {
  void AddObjectEx(PD::UI7::Container::Ref obj, PD::u32 flags) {
    pLayout->AddObjectEx(obj, flags);
  }
+  Container::Ref FindObject(u32 id) { return pLayout->FindObject(id); }

  void Update();

@@ -59,7 +59,8 @@ class PD_UI7_API Context {
  void AddViewPort(const ID& id, const ivec4& vp);
  void UseViewPort(const ID& id);
  void Update();
-  bool BeginMenu(const ID& id, UI7MenuFlags flags = 0, bool* pShow = nullptr);
+  Menu::Ref BeginMenu(const ID& id, UI7MenuFlags flags = 0,
+                      bool* pShow = nullptr);
  Menu::Ref CurrentMenu() { return pCurrent; }
  void EndMenu();
  void AboutMenu(bool* show = nullptr);
@@ -5,6 +5,7 @@ project(pd-lithium LANGUAGES CXX VERSION 0.6.0)
 option(PD_LI_INCLUDE_FONTS "Include Fonts" OFF)

 set(SRC
+    source/command.cpp
    source/drawlist.cpp
    source/font.cpp
    source/fonts.cpp
@@ -0,0 +1,81 @@
+#include <pd/lithium/command.hpp>
+
+PD_LITHIUM_API PD::Li::Command::Ref PD::Li::CmdPool::NewCmd() {
+  if (pPoolIdx >= pPool.size()) {
+    Resize(pPool.size() + 128);
+  }
+  Command::Ref nu = pPool[pPoolIdx++];
+  nu->Layer = Layer;
+  nu->Index = pPoolIdx - 1;
+  return nu;
+}
+
+PD_LITHIUM_API void PD::Li::CmdPool::Init(size_t initial_size) {
+  Resize(initial_size);
+}
+
+PD_LITHIUM_API void PD::Li::CmdPool::Deinit() {
+  for (auto it : pPool) {
+    Command::Delete(it);
+  }
+  pPool.clear();
+}
+
+PD_LITHIUM_API void PD::Li::CmdPool::Resize(size_t nulen) {
+  if (nulen <= pPool.size()) {
+    return;  // no idea yet
+  }
+  size_t oldlen = pPool.size();
+  pPool.resize(nulen);
+  for (size_t i = oldlen; i < pPool.size(); i++) {
+    pPool[i] = Command::New();
+  }
+}
+
+PD_LITHIUM_API void PD::Li::CmdPool::Reset() {
+  for (u32 i = 0; i < pPoolIdx; i++) {
+    pPool[i]->Clear();
+  }
+  pPoolIdx = 0;
+}
+
+PD::Li::Command::Ref PD::Li::CmdPool::GetCmd(size_t idx) const {
+  return pPool[idx];
+}
+PD::Li::Command::Ref PD::Li::CmdPool::GetCmd(size_t idx) { return pPool[idx]; }
+
+size_t PD::Li::CmdPool::Size() const { return pPoolIdx; }
+size_t PD::Li::CmdPool::Cap() const { return pPool.size(); }
+
+PD_LITHIUM_API void PD::Li::CmdPool::Merge(CmdPool& p) {
+  Copy(p);
+  p.Reset();
+}
+
+PD_LITHIUM_API void PD::Li::CmdPool::Copy(CmdPool& p) {
+  if (pPoolIdx + p.Size() > pPool.size()) {
+    Resize(pPoolIdx + p.Size());
+  }
+  for (size_t i = 0; i < p.Size(); i++) {
+    size_t idx = pPoolIdx++;
+    *pPool[idx] = *p.GetCmd(i);
+    pPool[idx]->Index = idx;
+    pPool[idx]->Layer += Layer;
+  }
+}
+
+PD_LITHIUM_API void PD::Li::CmdPool::Sort() {
+  if (pPoolIdx < 2) return;
+  std::sort(begin(), end(), pTheOrder);
+}
+
+PD_LITHIUM_API bool PD::Li::CmdPool::pTheOrder(const Command::Ref& a,
+                                               const Command::Ref& b) {
+  if (a->Layer == b->Layer) {
+    if (a->Tex == b->Tex) {
+      return a->Index < b->Index;
+    }
+    return a->Tex < b->Tex;
+  }
+  return a->Layer < b->Layer;
+}
@@ -31,12 +31,22 @@ SOFTWARE.

 namespace PD {
 namespace Li {
+PD_LITHIUM_API DrawList::DrawList(int initial_size) {
+  DrawSolid();
+  pPool.Init(initial_size);
+}
+
+PD_LITHIUM_API DrawList::~DrawList() {
+  Clear();
+  pPool.Deinit();
+}
+
 PD_LITHIUM_API void DrawList::DrawSolid() { CurrentTex = Gfx::GetSolidTex(); }

 PD_LITHIUM_API void DrawList::Clear() {
  pNumIndices = 0;
  pNumVertices = 0;
-  pDrawList.clear();
+  pPool.Reset();
  pPath.clear();
  if (pCurrentFont) {
    pCurrentFont->CleanupTMS();
@@ -46,27 +56,27 @@ PD_LITHIUM_API void DrawList::Clear() {
  }
 }

-PD_LITHIUM_API void DrawList::AddCommand(Command::Ref v) {
-  pNumIndices += v->IndexBuffer.size();
-  pNumVertices += v->VertexBuffer.size();
-  pDrawList.push_back(std::move(v));
-}
-
 PD_LITHIUM_API void DrawList::Merge(DrawList::Ref list) {
-  for (size_t i = 0; i < list->pDrawList.size(); i++) {
+  pPool.Merge(list->pPool);
+  /*for (size_t i = 0; i < list->pDrawList.size(); i++) {
    pNumIndices += list->pDrawList[i]->IndexBuffer.size();
    pNumVertices += list->pDrawList[i]->VertexBuffer.size();
-    pDrawList.push_back(std::move(list->pDrawList[i]));
-  }
+    auto cmd = pPool.NewCmd();
+    pDrawList.push_back(list->pDrawList[i]);
+  }*/
  /** Make sure The list gets cleared */
  list->Clear();
 }

+PD_LITHIUM_API void DrawList::Copy(DrawList::Ref list) {
+  pPool.Copy(list->pPool);
+}
+
 PD_LITHIUM_API void DrawList::Optimize() {
 #ifndef NDEBUG
  PD::TT::Scope s("Optimize");
 #endif
-  std::sort(pDrawList.begin(), pDrawList.end(),
+  /*std::sort(pDrawList.begin(), pDrawList.end(),
            [](const PD::Li::Command::Ref &a, const PD::Li::Command::Ref &b) {
              if (a->Layer == b->Layer) {  // Same layer
                if (a->Tex == b->Tex) {    // same tex
@@ -75,26 +85,25 @@ PD_LITHIUM_API void DrawList::Optimize() {
                return a->Tex < b->Tex;  // order by address
              }
              return a->Layer < b->Layer;  // Order by layer
-            });
+            });*/
 }

-PD_LITHIUM_API Command::Ref DrawList::PreGenerateCmd() {
-  Command::Ref cmd = Command::New();
-  cmd->Layer = pLayer;
-  cmd->Index = pDrawList.size();
-  cmd->Tex = CurrentTex;
-  pClipCmd(cmd.get());
+PD_LITHIUM_API Command::Ref DrawList::GetNewCmd() {
+  Command::Ref cmd = pPool.NewCmd();
+  cmd->Index = pPool.Size() - 1;
+  cmd->Tex = CurrentTex->Address;
+  pClipCmd(cmd);
  return cmd;
 }

-PD_LITHIUM_API void DrawList::pClipCmd(Command *cmd) {
+PD_LITHIUM_API void DrawList::pClipCmd(Command::Ref cmd) {
  if (!pClipRects.empty()) {
    cmd->ScissorOn = true;
    cmd->ScissorRect = ivec4(pClipRects.top());
  }
 }

-PD_LITHIUM_API void DrawList::PathArcToN(const fvec2 &c, float radius,
+PD_LITHIUM_API void DrawList::PathArcToN(const fvec2& c, float radius,
                                         float a_min, float a_max,
                                         int segments) {
  // Path.push_back(c);
@@ -105,7 +114,7 @@ PD_LITHIUM_API void DrawList::PathArcToN(const fvec2 &c, float radius,
  }
 }

-PD_LITHIUM_API void DrawList::PathFastArcToN(const fvec2 &c, float r,
+PD_LITHIUM_API void DrawList::PathFastArcToN(const fvec2& c, float r,
                                             float amin, float amax, int s) {
  /**
   * Funcion with less division overhead
@@ -201,19 +210,19 @@ PD_LITHIUM_API void DrawList::PathRectEx(fvec2 a, fvec2 b, float rounding,
  }
 }

-PD_LITHIUM_API void DrawList::DrawRect(const fvec2 &pos, const fvec2 &size,
+PD_LITHIUM_API void DrawList::DrawRect(const fvec2& pos, const fvec2& size,
                                       u32 color, int thickness) {
  PathRect(pos, pos + size);
  // Flags is currently hardcoded (1 = close)
  PathStroke(color, thickness, 1);
 }
-void DrawList::DrawRectFilled(const fvec2 &pos, const fvec2 &size, u32 color) {
+void DrawList::DrawRectFilled(const fvec2& pos, const fvec2& size, u32 color) {
  PathRect(pos, pos + size);
  PathFill(color);
 }

-PD_LITHIUM_API void DrawList::DrawTriangle(const fvec2 &a, const fvec2 &b,
-                                           const fvec2 &c, u32 color,
+PD_LITHIUM_API void DrawList::DrawTriangle(const fvec2& a, const fvec2& b,
+                                           const fvec2& c, u32 color,
                                           int thickness) {
  PathAdd(a);
  PathAdd(b);
@@ -221,15 +230,15 @@ PD_LITHIUM_API void DrawList::DrawTriangle(const fvec2 &a, const fvec2 &b,
  PathStroke(color, thickness, 1);
 }

-PD_LITHIUM_API void DrawList::DrawTriangleFilled(const fvec2 &a, const fvec2 &b,
-                                                 const fvec2 &c, u32 color) {
+PD_LITHIUM_API void DrawList::DrawTriangleFilled(const fvec2& a, const fvec2& b,
+                                                 const fvec2& c, u32 color) {
  PathAdd(a);
  PathAdd(b);
  PathAdd(c);
  PathFill(color);
 }

-PD_LITHIUM_API void DrawList::DrawCircle(const fvec2 &center, float rad,
+PD_LITHIUM_API void DrawList::DrawCircle(const fvec2& center, float rad,
                                         u32 color, int num_segments,
                                         int thickness) {
  if (num_segments <= 0) {
@@ -242,7 +251,7 @@ PD_LITHIUM_API void DrawList::DrawCircle(const fvec2 &center, float rad,
  PathStroke(color, thickness, (1 << 0));
 }

-PD_LITHIUM_API void DrawList::DrawCircleFilled(const fvec2 &center, float rad,
+PD_LITHIUM_API void DrawList::DrawCircleFilled(const fvec2& center, float rad,
                                               u32 color, int num_segments) {
  if (num_segments <= 0) {
    // Auto Segment
@@ -254,13 +263,13 @@ PD_LITHIUM_API void DrawList::DrawCircleFilled(const fvec2 &center, float rad,
 }

 // TODO: Don't render OOS
-PD_LITHIUM_API void DrawList::DrawPolyLine(const std::vector<fvec2> &points,
+PD_LITHIUM_API void DrawList::DrawPolyLine(const std::vector<fvec2>& points,
                                           u32 clr, u32 flags, int thickness) {
  if (points.size() < 2) {
    return;
  }
  DrawSolid();
-  auto cmd = PreGenerateCmd();
+  auto cmd = GetNewCmd();
  bool close = (flags & (1 << 0));
  int num_points = close ? (int)points.size() : (int)points.size() - 1;
  if (flags & (1 << 1)) {
@@ -270,52 +279,38 @@ PD_LITHIUM_API void DrawList::DrawPolyLine(const std::vector<fvec2> &points,
    for (int i = 0; i < num_points; i++) {
      int j = (i + 1) == (int)points.size() ? 0 : (i + 1);
      auto line = Renderer::PrimLine(points[i], points[j], thickness);
-      Renderer::CmdQuad(cmd.get(), line, vec4(0.f, 1.f, 1.f, 0.f), clr);
+      Renderer::CmdQuad(cmd, line, vec4(0.f, 1.f, 1.f, 0.f), clr);
    }
  }
-  AddCommand(std::move(cmd));
 }

 PD_LITHIUM_API void DrawList::DrawConvexPolyFilled(
-    const std::vector<fvec2> &points, u32 clr) {
+    const std::vector<fvec2>& points, u32 clr) {
  if (points.size() < 3) {
    return;  // Need at least three points
  }
-  auto cmd = PreGenerateCmd();
-  Renderer::CmdConvexPolyFilled(cmd.get(), points, clr, CurrentTex);
-  AddCommand(std::move(cmd));
+  auto cmd = GetNewCmd();
+  Renderer::CmdConvexPolyFilled(cmd, points, clr, CurrentTex);
 }

-PD_LITHIUM_API void DrawList::DrawText(const fvec2 &pos,
-                                       const std::string &text, u32 color) {
+PD_LITHIUM_API void DrawList::DrawText(const fvec2& pos,
+                                       const std::string& text, u32 color) {
  if (!pCurrentFont) {
    return;
  }
-  std::vector<Command::Ref> cmds;
-  pCurrentFont->CmdTextEx(cmds, pos, color, pFontScale, text);
-  for (size_t i = 0; i < cmds.size(); i++) {
-    cmds[i]->Index = pDrawList.size() + i;
-    cmds[i]->Layer = pLayer;
-    AddCommand(std::move(cmds[i]));
-  }
+  pCurrentFont->CmdTextEx(pPool, pos, color, pFontScale, text);
 }

-PD_LITHIUM_API void DrawList::DrawTextEx(const fvec2 &p,
-                                         const std::string &text, u32 color,
-                                         LiTextFlags flags, const fvec2 &box) {
+PD_LITHIUM_API void DrawList::DrawTextEx(const fvec2& p,
+                                         const std::string& text, u32 color,
+                                         LiTextFlags flags, const fvec2& box) {
  if (!pCurrentFont) {
    return;
  }
-  std::vector<Command::Ref> cmds;
-  pCurrentFont->CmdTextEx(cmds, p, color, pFontScale, text, flags, box);
-  for (size_t i = 0; i < cmds.size(); i++) {
-    cmds[i]->Index = pDrawList.size() + i;
-    cmds[i]->Layer = pLayer;
-    AddCommand(std::move(cmds[i]));
-  }
+  pCurrentFont->CmdTextEx(pPool, p, color, pFontScale, text, flags, box);
 }

-PD_LITHIUM_API void DrawList::DrawLine(const fvec2 &a, const fvec2 &b,
+PD_LITHIUM_API void DrawList::DrawLine(const fvec2& a, const fvec2& b,
                                       u32 color, int t) {
  PathAdd(a);
  PathAdd(b);
@@ -49,7 +49,7 @@ PD_LITHIUM_API void Font::LoadDefaultFont(int id, int pixel_height) {
 #endif
 }

-PD_LITHIUM_API void Font::LoadTTF(const std::string &path, int height) {
+PD_LITHIUM_API void Font::LoadTTF(const std::string& path, int height) {
  /**
   * Just use LoadFile2Mem which looks way cleaner
   * and helps not having the font loading code twice
@@ -60,7 +60,7 @@ PD_LITHIUM_API void Font::LoadTTF(const std::string &path, int height) {
  LoadTTF(font, height);
 }

-PD_LITHIUM_API void Font::pMakeAtlas(bool final, std::vector<u8> &font_tex,
+PD_LITHIUM_API void Font::pMakeAtlas(bool final, std::vector<u8>& font_tex,
                                     int texszs, PD::Li::Texture::Ref tex) {
  auto t =
      Gfx::LoadTex(font_tex, texszs, texszs, Texture::RGBA32, Texture::LINEAR);
@@ -68,7 +68,7 @@ PD_LITHIUM_API void Font::pMakeAtlas(bool final, std::vector<u8> &font_tex,
  Textures.push_back(tex);
 }

-PD_LITHIUM_API void Font::LoadTTF(const std::vector<u8> &data, int height) {
+PD_LITHIUM_API void Font::LoadTTF(const std::vector<u8>& data, int height) {
  /**
   * Some additional Info:
   * Removed the stbtt get bitmapbox as we dont need to place
@@ -107,7 +107,7 @@ PD_LITHIUM_API void Font::LoadTTF(const std::vector<u8> &data, int height) {
    if (stbtt_IsGlyphEmpty(&inf, gi)) continue;

    int w = 0, h = 0, xo = 0, yo = 0;
-    unsigned char *bitmap =
+    unsigned char* bitmap =
        stbtt_GetCodepointBitmap(&inf, scale, scale, ii, &w, &h, &xo, &yo);
    if (!bitmap || w <= 0 || h <= 0) {
      if (bitmap) free(bitmap);
@@ -184,7 +184,7 @@ PD_LITHIUM_API void Font::LoadTTF(const std::vector<u8> &data, int height) {
  }
 }

-PD_LITHIUM_API Font::Codepoint &Font::GetCodepoint(u32 cp) {
+PD_LITHIUM_API Font::Codepoint& Font::GetCodepoint(u32 cp) {
  // Check if codepoijt exist or return a static invalid one
  auto res = CodeMap.find(cp);
  if (res == CodeMap.end()) {
@@ -195,7 +195,7 @@ PD_LITHIUM_API Font::Codepoint &Font::GetCodepoint(u32 cp) {
  return res->second;
 }

-PD_LITHIUM_API fvec2 Font::GetTextBounds(const std::string &text, float scale) {
+PD_LITHIUM_API fvec2 Font::GetTextBounds(const std::string& text, float scale) {
  u32 id = PD::FNV1A32(text);
  if (pTMS.find(id) != pTMS.end()) {
    pTMS[id].TimeStamp = PD::OS::GetTime();
@@ -210,7 +210,7 @@ PD_LITHIUM_API fvec2 Font::GetTextBounds(const std::string &text, float scale) {
  float cfs = (DefaultPixelHeight * scale) / (float)PixelHeight;
  float lh = (float)PixelHeight * cfs;
  size_t index = 0;
-  for (auto &it : wtext) {
+  for (auto& it : wtext) {
    if (it == L'\0') {
      break;
    }
@@ -248,10 +248,9 @@ PD_LITHIUM_API fvec2 Font::GetTextBounds(const std::string &text, float scale) {
  return res;
 }

-PD_LITHIUM_API void Font::CmdTextEx(std::vector<Command::Ref> &cmds,
-                                    const fvec2 &pos, u32 color, float scale,
-                                    const std::string &text, LiTextFlags flags,
-                                    const fvec2 &box) {
+PD_LITHIUM_API void Font::CmdTextEx(CmdPool& cmds, const fvec2& pos, u32 color,
+                                    float scale, const std::string& text,
+                                    LiTextFlags flags, const fvec2& box) {
  fvec2 off;
  float cfs = (DefaultPixelHeight * scale) / (float)PixelHeight;
  float lh = (float)PixelHeight * cfs;
@@ -279,7 +278,7 @@ PD_LITHIUM_API void Font::CmdTextEx(std::vector<Command::Ref> &cmds,
    lines.push_back(tmp);
  }

-  for (auto &it : lines) {
+  for (auto& it : lines) {
    if (flags & LiTextFlags_NoOOS) {
      if (rpos.y + off.y + lh < 0) {
        off.y += lh;
@@ -294,20 +293,23 @@ PD_LITHIUM_API void Font::CmdTextEx(std::vector<Command::Ref> &cmds,
      it = pShortText(it, scale, box - pos, tmp_dim);
    }
    auto wline = Strings::MakeWstring(it);
-    auto cmd = Command::New();
+    auto cmd = cmds.NewCmd();
    auto Tex = GetCodepoint(wline[0]).Tex;
-    cmd->Tex = Tex;
-    for (auto &jt : wline) {
+    if (Tex) {
+      cmd->Tex = Tex->Address;
+    }
+    for (auto& jt : wline) {
      auto cp = GetCodepoint(jt);
      if ((cp.pInvalid && jt != L' ' && jt != L'\n' && jt != L'\t') &&
          jt != L'\r') {
        continue;
      }
      if (Tex != cp.Tex) {
-        cmds.push_back(std::move(cmd));
-        cmd = Command::New();
+        cmd = cmds.NewCmd();
        Tex = cp.Tex;
-        cmd->Tex = Tex;
+        if (Tex) {
+          cmd->Tex = Tex->Address;
+        }
      }
      if (jt == L'\t') {
        off.x += 16 * cfs;
@@ -316,29 +318,28 @@ PD_LITHIUM_API void Font::CmdTextEx(std::vector<Command::Ref> &cmds,
          if (flags & LiTextFlags_Shaddow) {
            // Draw
            Rect rec = Renderer::PrimRect(
-                rpos + vec2(off.x + 1, off.y + (cp.Offset * cfs)) + 1,
+                rpos + fvec2(off.x + 1, off.y + (cp.Offset * cfs)) + 1,
                cp.Size * cfs, 0.f);
-            Renderer::CmdQuad(cmd.get(), rec, cp.SimpleUV, 0xff111111);
+            Renderer::CmdQuad(cmd, rec, cp.SimpleUV, 0xff111111);
          }
          // Draw
          Rect rec = Renderer::PrimRect(
              rpos + off + fvec2(0, (cp.Offset * cfs)), cp.Size * cfs, 0.f);
-          Renderer::CmdQuad(cmd.get(), rec, cp.SimpleUV, color);
+          Renderer::CmdQuad(cmd, rec, cp.SimpleUV, color);
          off.x += cp.Size.x * cfs + 2 * cfs;
        } else {
          off.x += 4 * cfs;
        }
      }
    }
-    cmds.push_back(std::move(cmd));
    off.y += lh;
    off.x = 0;
  }
 }

-PD_LITHIUM_API std::string Font::pWrapText(const std::string &txt, float scale,
-                                           const PD::fvec2 &max,
-                                           PD::fvec2 &dim) {
+PD_LITHIUM_API std::string Font::pWrapText(const std::string& txt, float scale,
+                                           const PD::fvec2& max,
+                                           PD::fvec2& dim) {
  u32 id = PD::FNV1A32(txt);
  if (pTMS.find(id) != pTMS.end()) {
    if (pTMS[id].Text.size()) {
@@ -373,9 +374,9 @@ PD_LITHIUM_API std::string Font::pWrapText(const std::string &txt, float scale,
  return ret;
 }

-PD_LITHIUM_API std::string Font::pShortText(const std::string &txt, float scale,
-                                            const PD::fvec2 &max,
-                                            PD::fvec2 &dim) {
+PD_LITHIUM_API std::string Font::pShortText(const std::string& txt, float scale,
+                                            const PD::fvec2& max,
+                                            PD::fvec2& dim) {
  u32 id = PD::FNV1A32(txt);
  if (pTMS.find(id) != pTMS.end()) {
    if (pTMS[id].Text.size()) {
@@ -401,7 +402,7 @@ PD_LITHIUM_API std::string Font::pShortText(const std::string &txt, float scale,
  maxlen -= GetTextBounds(ext, scale).x;
  maxlen -= GetTextBounds(ph, scale).x;

-  for (auto &it : tmp) {
+  for (auto& it : tmp) {
    if (GetTextBounds(ret, scale).x > maxlen) {
      ret += ph;
      ret += ext;
@@ -88,7 +88,7 @@ PD_LITHIUM_API Rect Renderer::PrimLine(const fvec2& a, const fvec2& b,
  return Rect(a + off, b + off, a - off, b - off);
 }

-PD_LITHIUM_API void Renderer::CmdQuad(Command* cmd, const Rect& quad,
+PD_LITHIUM_API void Renderer::CmdQuad(Command::Ref cmd, const Rect& quad,
                                      const Rect& uv, u32 color) {
  cmd->AddIdx(0).AddIdx(1).AddIdx(2);
  cmd->AddIdx(0).AddIdx(2).AddIdx(3);
@@ -98,7 +98,7 @@ PD_LITHIUM_API void Renderer::CmdQuad(Command* cmd, const Rect& quad,
  cmd->AddVtx(Vertex(quad.BotLeft(), uv.BotLeft(), color));
 }

-PD_LITHIUM_API void Renderer::CmdTriangle(Command* cmd, const fvec2 a,
+PD_LITHIUM_API void Renderer::CmdTriangle(Command::Ref cmd, const fvec2 a,
                                          const fvec2 b, const fvec2 c,
                                          u32 clr) {
  cmd->AddIdx(2).AddIdx(1).AddIdx(0);
@@ -111,7 +111,8 @@ PD_LITHIUM_API void Renderer::CmdTriangle(Command* cmd, const fvec2 a,
 // would probably be faster to render out of screen than checking if
 // it could be skipped)
 PD_LITHIUM_API void Renderer::CmdConvexPolyFilled(
-    Command* cmd, const std::vector<fvec2>& points, u32 clr, Texture::Ref tex) {
+    Command::Ref cmd, const std::vector<fvec2>& points, u32 clr,
+    Texture::Ref tex) {
  if (points.size() < 3 || tex == nullptr) {
    return;  // Need at least three points
  }
@@ -17,6 +17,7 @@ set(SRC
    source/container/dynobj.cpp
    source/container/image.cpp
    source/container/label.cpp
+    source/container/slider.cpp
 )

 if(PD_BUILD_SHARED)
@@ -25,4 +26,4 @@ else()
    pd_add_lib(pd-ui7 SRC_FILES ${SRC})
 endif()

-target_link_libraries(pd-ui7 PUBLIC pd-lithium pd-core)
+target_link_libraries(pd-ui7 PUBLIC pd-lithium pd-core)
@@ -49,11 +49,12 @@ PD_UI7_API void Button::HandleInput() {
 PD_UI7_API void Button::Draw() {
  // Assert(io.get() && list.get(), "Did you run Container::Init correctly?");
  // io->Ren->OnScreen(screen);
-  list->DrawRectFilled(FinalPos(), size, io->Theme->Get(color));
-  list->pLayer++;
+  list->PathRect(FinalPos(), FinalPos() + size, io->FrameRounding);
+  list->PathFill(io->Theme->Get(color));
+  list->LayerUp();
  list->DrawText(FinalPos() + size * 0.5 - tdim * 0.5, label,
                 io->Theme->Get(UI7Color_Text));
-  list->pLayer--;
+  list->LayerDown();
 }

 PD_UI7_API void Button::Update() {
@@ -48,10 +48,11 @@ PD_UI7_API void Checkbox::HandleInput() {
 PD_UI7_API void Checkbox::Draw() {
  // Assert(list.get() && io.get(), "Did you run Container::Init correctly?");
  // io->Ren->OnScreen(screen);
-  list->DrawRectFilled(FinalPos(), cbs, io->Theme->Get(color));
+  list->PathRect(FinalPos(), FinalPos() + cbs, io->FrameRounding);
+  list->PathFill(io->Theme->Get(color));
  if (usr_ref) {
-    list->DrawRectFilled(FinalPos() + 2, cbs - 4,
-                         io->Theme->Get(UI7Color_Checkmark));
+    list->PathRect(FinalPos() + 2, FinalPos() + cbs - 2, io->FrameRounding);
+    list->PathFill(io->Theme->Get(UI7Color_Checkmark));
  }
  list->DrawText(
      FinalPos() + fvec2(cbs.x + io->ItemSpace.x, cbs.y * 0.5 - tdim.y * 0.5),
@@ -60,6 +61,7 @@ PD_UI7_API void Checkbox::Draw() {

 PD_UI7_API void Checkbox::Update() {
  // Assert(io.get(), "Did you run Container::Init correctly?");
+  cbs = io->ItemRowHeight;
  this->SetSize(cbs + fvec2(tdim.x + io->ItemSpace.x, 0));
 }
 }  // namespace UI7
@@ -22,7 +22,7 @@ SOFTWARE.
 */

 #include <pd/ui7/container/coloredit.hpp>
-#include <pd/ui7/container/label.hpp>
+#include <pd/ui7/containers.hpp>

 namespace PD {
 namespace UI7 {
@@ -33,8 +33,9 @@ PD_UI7_API void ColorEdit::HandleInput() {
  }
  // Assert(screen.get(), "Screen is not set up!");
  // if (screen->ScreenType() == Screen::Bottom) {
-  if (io->InputHandler->DragObject(this->GetID(), fvec4(FinalPos(), size))) {
-    if (io->InputHandler->DragReleased) {
+  if (io->InputHandler->DragObject(this->GetID() + 2,
+                                   fvec4(FinalPos(), size))) {
+    if (io->InputHandler->DragReleasedAW) {
      is_shown = !is_shown;
    }
  }
@@ -44,22 +45,55 @@ PD_UI7_API void ColorEdit::HandleInput() {
 PD_UI7_API void ColorEdit::Draw() {
  // Assert(io.get() && list.get(), "Did you run Container::Init correctly?");
  // io->Ren->OnScreen(screen);
-  list->DrawRectFilled(FinalPos(), fvec2(20, 20), *color_ref);
-  list->DrawText(FinalPos() + fvec2(io->ItemSpace.x + 20, 0), label,
-                 io->Theme->Get(UI7Color_Text));
+  list->PathRect(FinalPos(), FinalPos() + io->ItemRowHeight, io->FrameRounding);
+  list->PathFill(*color_ref);
+  list->DrawText(FinalPos() + fvec2(io->ItemSpace.x + io->ItemRowHeight, 0),
+                 label, io->Theme->Get(UI7Color_Text));
  if (is_shown) {
    if (!layout) {
      layout = Layout::New(GetID(), io);
    }
-    layout->AddObject(Label::New("Hello World!", io));
+    layout->SetPosition(FinalPos());
+    layout->AddObjectEx(
+        DynObj::New(
+            [=, this](UI7::IO::Ref io, Li::DrawList::Ref l, Container* thiz) {
+              thiz->SetSize(layout->GetSize());
+              l->Layer(30);
+              l->PathRect(thiz->GetPos(), thiz->GetPos() + thiz->GetSize(),
+                          io->FrameRounding);
+              l->PathFill(io->Theme->Get(UI7Color_FrameBackground));
+            }),
+        UI7LytAdd_Front | UI7LytAdd_NoCursorUpdate | UI7LytAdd_NoScrollHandle);
+    auto obj = DynObj::New(
+        [=, this](UI7::IO::Ref io, Li::DrawList::Ref l, Container* thiz) {
+          l->PathRect(thiz->FinalPos(), thiz->FinalPos() + io->ItemRowHeight,
+                      io->FrameRounding);
+          l->PathFill(*color_ref);
+          l->DrawText(
+              thiz->FinalPos() + fvec2(io->ItemSpace.x + io->ItemRowHeight, 0),
+              label, io->Theme->Get(UI7Color_Text));
+        });
+    obj->SetSize(PD::fvec2(200, io->ItemRowHeight));
+    layout->AddObject(obj);
+    layout->Label("RGBA: ({}, {}, {}, {})", *((u8*)color_ref),
+                  *(((u8*)color_ref) + 1), *(((u8*)color_ref) + 2),
+                  *(((u8*)color_ref) + 3));
+    layout->Label("Hex: {}", PD::Color(*color_ref).Hex(true));
+
+    layout->Slider<u8>("R", ((u8*)color_ref));
+    layout->Slider<u8>("G", ((u8*)color_ref) + 1);
+    layout->Slider<u8>("B", ((u8*)color_ref) + 2);
+    layout->Slider<u8>("A", ((u8*)color_ref) + 3);
    layout->Update();
-    io->RegisterDrawList(GetID(), layout->GetDrawList());
+    list->Merge(layout->GetDrawList());
+    // io->RegisterDrawList(GetID(), layout->GetDrawList());
  }
 }

 PD_UI7_API void ColorEdit::Update() {
  // Assert(io.get(), "Did you run Container::Init correctly?");
-  this->SetSize(fvec2(tdim.x + io->ItemSpace.x + 20, 20));
+  this->SetSize(
+      fvec2(tdim.x + io->ItemSpace.x + io->ItemRowHeight, io->ItemRowHeight));
 }
 }  // namespace UI7
 }  // namespace PD
@@ -81,13 +81,15 @@ PD_UI7_API void DragData<T>::Draw() {
      p = std::format("{}", data[i]);
    }
    vec2 td = io->Font->GetTextBounds(p, io->FontScale);
-    list->DrawRectFilled(FinalPos() + fvec2(off_x, 0), td + io->FramePadding,
-                         io->Theme->Get(UI7Color_Button));
-    list->pLayer++;
+    list->PathRect(FinalPos() + fvec2(off_x, 0),
+                   FinalPos() + fvec2(off_x, 0) + td + io->FramePadding,
+                   io->FrameRounding);
+    list->PathFill(io->Theme->Get(UI7Color_Button));
+    list->LayerUp();
    list->DrawTextEx(FinalPos() + fvec2(off_x, 0), p,
                     io->Theme->Get(UI7Color_Text), LiTextFlags_AlignMid,
                     td + io->FramePadding);
-    list->pLayer--;
+    list->LayerDown();
    off_x += td.x + io->ItemSpace.x + io->FramePadding.x;
  }
  list->DrawText(FinalPos() + fvec2(off_x, io->FramePadding.y * 0.5), label,
@@ -29,11 +29,11 @@ PD_UI7_API void Image::Draw() {
  // Assert(io.get() && list.get(), "Did you run Container::Init correctly?");
  // Assert(img.get(), "Image is nullptr!");
  // io->Ren->OnScreen(screen);
-  list->pLayer++;
+  list->LayerUp();
  list->DrawTexture(img);
  list->DrawRectFilled(FinalPos(), newsize, 0xffffffff);
  list->DrawSolid();
-  list->pLayer--;
+  list->LayerDown();
 }
 }  // namespace UI7
 }  // namespace PD
@@ -0,0 +1,107 @@
+/*
+MIT License
+Copyright (c) 2024 - 2025 René Amthor (tobid7)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */
+
+#include <pd/ui7/container/label.hpp>
+#include <pd/ui7/container/slider.hpp>
+#include <type_traits>
+
+namespace PD {
+namespace UI7 {
+// Setup Supported Datatypes (Probably making this Object
+// header only to not care about datatype support)
+template class PD_UI7_API Slider<float>;
+template class PD_UI7_API Slider<int>;
+template class PD_UI7_API Slider<double>;
+template class PD_UI7_API Slider<u8>;
+template class PD_UI7_API Slider<u16>;
+template class PD_UI7_API Slider<u32>;
+template class PD_UI7_API Slider<u64>;
+template <typename T>
+PD_UI7_API void Slider<T>::HandleInput() {
+  /// Ensure to only check input once
+  if (inp_done) {
+    return;
+  }
+  // Assert(screen.get(), "Screen is not set up!");
+  std::string p;
+  if constexpr (std::is_floating_point_v<T>) {
+    p = std::format("{:.{}f}", *data, precision);
+  } else {
+    p = std::format("{}", *data);
+  }
+  // Unsafe but is the fastest solution
+  float xps = FinalPos().x;
+  if (io->InputHandler->DragObject(
+          this->GetID(),
+          fvec4(FinalPos() + fvec2(2, 0), fvec2(width, GetSize().y)))) {
+    if (!io->InputHandler->DragReleasedAW) {
+      *data = std::clamp(
+          T(max * (std::clamp(io->InputHandler->DragLastPosition.x - xps, 0.f,
+                              width) /
+                   width)),
+          this->min, this->max);
+    }
+  }
+  inp_done = true;
+}
+
+template <typename T>
+PD_UI7_API void Slider<T>::Draw() {
+  // Assert(io.get() && list.get(), "Did you run Container::Init correctly?");
+  // io->Ren->OnScreen(screen);
+  std::string p;
+  if constexpr (std::is_floating_point_v<T>) {
+    p = std::format("{:.{}f}", *data, precision);
+  } else {
+    p = std::format("{}", *data);
+  }
+  fvec2 td = io->Font->GetTextBounds(p, io->FontScale);
+  list->PathRect(FinalPos(), FinalPos() + fvec2(width, td.y) + io->FramePadding,
+                 io->FrameRounding);
+  list->PathFill(io->Theme->Get(UI7Color_Button));
+  list->PathRect(FinalPos() + 2 + PD::fvec2(slp, 0),
+                 FinalPos() + fvec2(slp + slw - 2, td.y - 2) + io->FramePadding,
+                 io->FrameRounding);
+  list->PathFill(io->Theme->Get(UI7Color_ButtonActive));
+  list->LayerUp();
+  list->DrawTextEx(FinalPos(), p, io->Theme->Get(UI7Color_Text),
+                   LiTextFlags_AlignMid, fvec2(width, td.y) + io->FramePadding);
+  list->LayerDown();
+  list->DrawText(FinalPos() + fvec2(width + io->FramePadding.x * 2.f,
+                                    io->FramePadding.y * 0.5),
+                 label, io->Theme->Get(UI7Color_Text));
+}
+
+template <typename T>
+PD_UI7_API void Slider<T>::Update() {
+  // Assert(io.get(), "Did you run Container::Init correctly?");
+  //  Probably need to find a faster solution (caching sizes calculated here)
+  slw = std::clamp(static_cast<float>(width / max), 3.f, width);
+  slp = static_cast<float>((float)*data / (float)max) * (width - slw);
+  fvec2 tdim = io->Font->GetTextBounds(label, io->FontScale);
+
+  this->SetSize(
+      fvec2(width + tdim.x + io->ItemSpace.x * 2, tdim.y + io->FramePadding.y));
+}
+}  // namespace UI7
+}  // namespace PD
@@ -36,6 +36,7 @@ PD_UI7_API void UI7::IO::Update() {
  Framerate = 1000.f / Delta;
  DrawListRegestry.clear();
  DrawListRegestry.push_front(std::make_pair("CtxBackList", Back));
+  if (Font) ItemRowHeight = FontScale * Font->PixelHeight;
  // RegisterDrawList("CtxBackList", Back);
  NumIndices = FDL->pNumIndices;
  NumVertices = FDL->pNumVertices;
@@ -21,6 +21,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */

+#include <pd/ui7/containers.hpp>
 #include <pd/ui7/layout.hpp>

 namespace PD {
@@ -113,6 +114,9 @@ PD_UI7_API fvec2 Layout::AlignPosition(fvec2 pos, fvec2 size, fvec4 area,
 }

 PD_UI7_API void Layout::Update() {
+  if (Size == fvec2(0.f)) {
+    Size = fvec2(MaxPosition) + IO->MenuPadding * 2;
+  }
  for (auto& it : Objects) {
    if (it->GetID() != 0 && !FindObject(it->GetID())) {
      IDObjects.push_back(it);
@@ -137,5 +141,45 @@ PD_UI7_API void Layout::Update() {
  WorkRect = fvec4(fvec2(WorkRect.x, WorkRect.y), Size - IO->MenuPadding);
  CursorInit();
 }
+
+/** SECTION CONTAINERS (STOLEN FROM FORMER MENU) */
+
+PD_UI7_API void Layout::Label(const std::string& label) {
+  // Layout API
+  auto r = Label::New(label, IO);
+  r->SetClipRect(fvec4(GetPosition(), GetPosition() + GetSize()));
+  AddObject(r);
+}
+
+PD_UI7_API bool Layout::Button(const std::string& label) {
+  bool ret = false;
+  u32 id = Strings::FastHash("btn" + label + std::to_string(Objects.size()));
+  Container::Ref r = FindObject(id);
+  if (!r) {
+    r = Button::New(label, IO);
+    r->SetID(id);
+  }
+  AddObject(r);
+  if (!r->Skippable()) {
+    ret = std::static_pointer_cast<UI7::Button>(r)->IsPressed();
+  }
+  return ret;
+}
+
+PD_UI7_API void Layout::Checkbox(const std::string& label, bool& v) {
+  u32 id = Strings::FastHash("cbx" + label + std::to_string(Objects.size()));
+  Container::Ref r = FindObject(id);
+  if (!r) {
+    r = Checkbox::New(label, v, IO);
+    r->SetID(id);
+  }
+  AddObject(r);
+}
+
+PD_UI7_API void Layout::Image(Li::Texture::Ref img, fvec2 size, Li::Rect uv) {
+  Container::Ref r = Image::New(img, size, uv);
+  AddObject(r);
+}
+
 }  // namespace UI7
 }  // namespace PD
@@ -29,7 +29,7 @@ namespace PD {
 namespace UI7 {
 Menu::Menu(const ID& id, IO::Ref io) : pIO(io), pID(id) {
  pLayout = Layout::New(id, io);
-  TitleBarHeight = io->FontScale * 30.f;
+  TitleBarHeight = pIO->FontScale * pIO->Font->PixelHeight + pIO->MenuPadding.y;
  pLayout->WorkRect.y += TitleBarHeight;
  pLayout->CursorInit();
 }
@@ -37,7 +37,8 @@ Menu::Menu(const ID& id, IO::Ref io) : pIO(io), pID(id) {
 PD_UI7_API void Menu::Label(const std::string& label) {
  // Layout API
  auto r = Label::New(label, pIO);
-  r->SetClipRect(fvec4(pLayout->GetPosition(), pLayout->GetSize()));
+  r->SetClipRect(fvec4(pLayout->GetPosition(),
+                       pLayout->GetPosition() + pLayout->GetSize()));
  pLayout->AddObject(r);
 }

@@ -73,6 +74,16 @@ PD_UI7_API void Menu::Image(Li::Texture::Ref img, fvec2 size, Li::Rect uv) {
  pLayout->AddObject(r);
 }

+PD_UI7_API void Menu::ColorEdit(const std::string& label, u32& clr) {
+  u32 id = Strings::FastHash("drd" + label);
+  Container::Ref r = pLayout->FindObject(id);
+  if (!r) {
+    r = UI7::ColorEdit::New(label, &clr, pIO);
+    r->SetID(id);
+  }
+  pLayout->AddObject(r);
+}
+
 PD_UI7_API void Menu::Separator() {
  // Dynamic Objects are very simple...
  Container::Ref r = DynObj::New(
@@ -242,7 +253,7 @@ PD_UI7_API void Menu::DrawBaseLayout() {
    if (!(Flags & UI7MenuFlags_NoResize)) {
      Container::Ref r = DynObj::New(
          [](IO::Ref io, Li::DrawList::Ref l, UI7::Container* self) {
-            l->pLayer = 1;
+            l->Layer(1);
            l->PathAdd(self->FinalPos() + self->GetSize() - fvec2(0, 20));
            l->PathAdd(self->FinalPos() + self->GetSize());
            l->PathAdd(self->FinalPos() + self->GetSize() - fvec2(20, 0));
@@ -258,7 +269,7 @@ PD_UI7_API void Menu::DrawBaseLayout() {
    /** Background */
    Container::Ref r = DynObj::New([](IO::Ref io, Li::DrawList::Ref l,
                                      UI7::Container* self) {
-      l->pLayer = 0;
+      l->Layer(0);
      l->PathRectEx(self->FinalPos(), self->FinalPos() + self->GetSize(), 10.f,
                    LiPathRectFlags_KeepTop | LiPathRectFlags_KeepBot);
      l->PathFill(io->Theme->Get(UI7Color_Background));
@@ -275,11 +286,11 @@ PD_UI7_API void Menu::DrawBaseLayout() {
  if (!(Flags & UI7MenuFlags_NoTitlebar)) {
    Container::Ref r = DynObj::New(
        [=, this](UI7::IO::Ref io, Li::DrawList::Ref l, UI7::Container* self) {
-          l->pLayer = 20;
+          l->Layer(20);
          /** Header Bar */
          l->DrawRectFilled(self->FinalPos(), self->GetSize(),
                            io->Theme->Get(UI7Color_Header));
-          l->pLayer = 21;
+          l->Layer(21);
          /** Inline if statement to shift the Text if collapse sym is shown */
          /** What the hell is this code btw (didn't found a better way) */
          l->DrawText(self->FinalPos() + fvec2((Flags & UI7MenuFlags_NoCollapse)
@@ -300,7 +311,7 @@ PD_UI7_API void Menu::DrawBaseLayout() {
      r = DynObj::New([=, this](UI7::IO::Ref io, Li::DrawList::Ref l,
                                UI7::Container* self) {
        /** This sym actually requires layer 21 (i dont know why) */
-        l->pLayer = 21;
+        l->Layer(21);
        /**
         * Symbol (Position Swapping set by pIsOpen ? openpos : closepos;)
         */
@@ -339,8 +350,12 @@ PD_UI7_API void Menu::DrawBaseLayout() {

 PD_UI7_API void Menu::Update() {
  HandleFocus();
+  if (pLayout->Size == fvec2(0.f) || Flags & UI7MenuFlags_AlwaysAutoSize) {
+    pLayout->Size = fvec2(pLayout->MaxPosition) + pIO->MenuPadding * 2;
+  }
  if (!(Flags & UI7MenuFlags_NoTitlebar)) {
-    TitleBarHeight = pIO->FontScale * 30.f;
+    TitleBarHeight =
+        pIO->FontScale * pIO->Font->PixelHeight + pIO->MenuPadding.y;
    pLayout->WorkRect.y = 5.f + TitleBarHeight;
    HandleTitlebarActions();
  } else {
@@ -51,25 +51,25 @@ PD_UI7_API void Context::UseViewPort(const ID &id) {
  pIO->CurrentViewPort = pIO->ViewPorts[id]->GetSize();
 }

-PD_UI7_API bool Context::BeginMenu(const ID &id, UI7MenuFlags flags,
-                                   bool *pShow) {
+PD_UI7_API Menu::Ref Context::BeginMenu(const ID &id, UI7MenuFlags flags,
+                                        bool *pShow) {
  if (pCurrent) {
    std::cout << "[UI7] Error: You are already in " << pCurrent->pID.GetName()
              << " Menu" << std::endl;
-    return false;
+    return nullptr;
  }
  if (std::find(pCurrentMenus.begin(), pCurrentMenus.end(), (u32)id) !=
      pCurrentMenus.end()) {
    std::cout << "[UI7] Error: Menu " << id.GetName() << " already exists!"
              << std::endl;
-    return false;
+    return nullptr;
  }
  pCurrent = pGetOrCreateMenu(id);
  this->pCurrent->pIsShown = pShow;
  if (pCurrent->pIsShown != nullptr) {
    if (!*pCurrent->pIsShown) {
      pCurrent = nullptr;
-      return false;
+      return nullptr;
    }
  }
  /** Probably we dont even need Input Handling in this stage */
@@ -79,7 +79,7 @@ PD_UI7_API bool Context::BeginMenu(const ID &id, UI7MenuFlags flags,
  if (!pCurrent->pIsOpen) {
    pCurrent = nullptr;
  }
-  return pCurrent != nullptr;
+  return pCurrent;
 }

 PD_UI7_API void Context::EndMenu() {
@@ -151,11 +151,11 @@ PD_UI7_API void Context::Update() {
  }
  pCurrentMenus.clear();
  pIO->Update();
+  pIO->FDL->pPool.Sort();
 }

 PD_UI7_API void Context::AboutMenu(bool *show) {
-  if (BeginMenu("About UI7", UI7MenuFlags_Scrolling, show)) {
-    auto m = pCurrent;
+  if (auto m = BeginMenu("About UI7", UI7MenuFlags_Scrolling, show)) {
    m->Label("Palladium UI7 " + GetVersion());
    m->Separator();
    m->Label("(c) 2023-2025 René Amthor");
@@ -177,8 +177,7 @@ PD_UI7_API void Context::AboutMenu(bool *show) {
 }

 PD_UI7_API void Context::MetricsMenu(bool *show) {
-  if (BeginMenu("UI7 Metrics", UI7MenuFlags_Scrolling, show)) {
-    auto m = pCurrent;
+  if (auto m = BeginMenu("UI7 Metrics", UI7MenuFlags_Scrolling, show)) {
    m->Label("Palladium - UI7 " + GetVersion());
    m->Separator();
    m->Label(
@@ -209,7 +208,7 @@ PD_UI7_API void Context::MetricsMenu(bool *show) {
    }
    m->SeparatorText("Palladium Info");
    m->Label("Renderer: " + PD::Gfx::pGfx->pName);
-    if (m->BeginTreeNode("Input: " + PD::Hid::pHid->pName)) {
+    if (m->BeginTreeNode(std::string("Input: " + PD::Hid::pHid->pName))) {
      if (PD::Hid::GetFlags() & PD::HidDriver::Flags_HasKeyboard) {
        m->Label("- Keyboard Supported");
      }
@@ -303,9 +302,7 @@ PD_UI7_API void Context::MetricsMenu(bool *show) {
 }

 PD_UI7_API void UI7::Context::StyleEditor(bool *show) {
-  if (this->BeginMenu("UI7 Style Editor", UI7MenuFlags_Scrolling, show)) {
-    auto m = pCurrent;
-
+  if (auto m = BeginMenu("UI7 Style Editor", UI7MenuFlags_Scrolling, show)) {
    m->Label("Palladium - UI7 " + GetVersion() + " Style Editor");
    m->Separator();
    m->DragData("MenuPadding", (float *)&pIO->MenuPadding, 2, 0.f, 100.f);
@@ -326,27 +323,27 @@ PD_UI7_API void UI7::Context::StyleEditor(bool *show) {
      UI7::Theme::Flashbang(*pIO->Theme.get());
    }
    /// Small trick to print without prefix
-#define ts(x) m->ColorEdit(std::string(#x).substr(9), &pIO->Theme->GetRef(x));
+#define ts(x) m->ColorEdit(std::string(#x).substr(9), pIO->Theme->GetRef(x));
 #define ts2(x)                                                            \
  m->DragData(std::string(#x).substr(9), (u8 *)&pIO->Theme->GetRef(x), 4, \
              (u8)0, (u8)255);
-    ts2(UI7Color_Background);
-    ts2(UI7Color_Border);
-    ts2(UI7Color_Button);
-    ts2(UI7Color_ButtonDead);
-    ts2(UI7Color_ButtonActive);
-    ts2(UI7Color_ButtonHovered);
-    ts2(UI7Color_Text);
-    ts2(UI7Color_TextDead);
-    ts2(UI7Color_Header);
-    ts2(UI7Color_HeaderDead);
-    ts2(UI7Color_Selector);
-    ts2(UI7Color_Checkmark);
-    ts2(UI7Color_FrameBackground);
-    ts2(UI7Color_FrameBackgroundHovered);
-    ts2(UI7Color_Progressbar);
-    ts2(UI7Color_ListEven);
-    ts2(UI7Color_ListOdd);
+    ts(UI7Color_Background);
+    ts(UI7Color_Border);
+    ts(UI7Color_Button);
+    ts(UI7Color_ButtonDead);
+    ts(UI7Color_ButtonActive);
+    ts(UI7Color_ButtonHovered);
+    ts(UI7Color_Text);
+    ts(UI7Color_TextDead);
+    ts(UI7Color_Header);
+    ts(UI7Color_HeaderDead);
+    ts(UI7Color_Selector);
+    ts(UI7Color_Checkmark);
+    ts(UI7Color_FrameBackground);
+    ts(UI7Color_FrameBackgroundHovered);
+    ts(UI7Color_Progressbar);
+    ts(UI7Color_ListEven);
+    ts(UI7Color_ListOdd);
    this->EndMenu();
  }
 }
@@ -21,12 +21,18 @@ int TheScale = 1;
 bool AboutOderSo = true;

 int main() {
-  void *PD_INIT_DATA = nullptr;
+  void* PD_INIT_DATA = nullptr;
 #ifndef __3DS__
  /** Setup Window and Context */
  glfwInit();
  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+#ifdef __APPLE__
+  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
+  glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+  glfwWindowHint(GLFW_COCOA_RETINA_FRAMEBUFFER, 0);
+#else
  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1);
+#endif
  glfwWindowHint(GLFW_SAMPLES, 8);
  auto win = glfwCreateWindow(1280, 720, "Test", nullptr, nullptr);
  glfwMakeContextCurrent(win);
@@ -36,9 +42,9 @@ int main() {
  osSetSpeedupEnable(true);
  gfxInitDefault();
  C3D_Init(C3D_DEFAULT_CMDBUF_SIZE * 2);
-  C3D_RenderTarget *Top =
+  C3D_RenderTarget* Top =
      C3D_RenderTargetCreate(240, 400, GPU_RB_RGBA8, GPU_RB_DEPTH24_STENCIL8);
-  C3D_RenderTarget *Bottom =
+  C3D_RenderTarget* Bottom =
      C3D_RenderTargetCreate(240, 320, GPU_RB_RGBA8, GPU_RB_DEPTH24_STENCIL8);
  C3D_RenderTargetSetOutput(Top, GFX_TOP, GFX_LEFT, DisplayTransferFlags);
  C3D_RenderTargetSetOutput(Bottom, GFX_BOTTOM, GFX_LEFT, DisplayTransferFlags);
@@ -80,8 +86,9 @@ int main() {
    int wx, wy;
    glfwGetWindowSize(win, &wx, &wy);
    PD::Gfx::pGfx->ViewPort = PD::ivec2(wx, wy);
+    ui7->GetIO()->CurrentViewPort = PD::ivec4(0, 0, wx, wy);
    glViewport(0, 0, wx, wy);
-    glClearColor(0, 0, 0, 0);
+    glClearColor(0.1, 0.1, 0.1, 1);
    glClear(GL_COLOR_BUFFER_BIT);
    // ui7->pIO->GetViewPort(VpTop)->pSize = PD::ivec4(0, 0, wx, wy);
 #endif
@@ -102,15 +109,14 @@ int main() {
    /** Draw text */
    List->DrawText(
        20,
-        "Test String oder So\nPalladium 0.5.0\n" +
+        "Test String oder So\nPalladium 0.6.0\n" +
            std::format("{}\nMousePos: {}",
                        PD::Strings::FormatNanos(
                            PD::OS::GetTraceRef("REN")->GetLastDiff()),
                        PD::Hid::MousePos()) +
            "\nUI7 Version: " + PD::UI7::GetVersion(),
        0xff000000);
-    if (ui7->BeginMenu("Test")) {
-      auto menu = ui7->pCurrent;
+    if (auto menu = ui7->BeginMenu("Test")) {
      menu->Label("Hello");
      menu->Label("World!");
      menu->Checkbox("About Menu", AboutOderSo);
@@ -125,17 +131,16 @@ int main() {
      menu->Label(
          std::format("Left: {}", PD::Hid::IsHeld(PD::Hid::Key::Touch)));
      menu->DragData("Value", &v, 1);
+      menu->Slider("Value 2", &v);
      ui7->EndMenu();
    }
-    if (ui7->BeginMenu("Yet another Window")) {
-      auto menu = ui7->pCurrent;
+    if (auto menu = ui7->BeginMenu("Yet another Window")) {
      menu->Label(std::format("this->Pos: {}", menu->pLayout->GetPosition()));
      menu->Label(std::format("Vertices: {}", PD::Gfx::pGfx->VertexCounter));
      menu->Label(std::format("Indices: {}", PD::Gfx::pGfx->IndexCounter));
      ui7->EndMenu();
    }
-    if (ui7->BeginMenu("#Debug (UI7)")) {
-      auto menu = ui7->pCurrent;
+    if (auto menu = ui7->BeginMenu("#Debug (UI7)")) {
      menu->Label(std::format("Framerate: {:.1f} [{:.2f}]", ui7->pIO->Framerate,
                              ui7->pIO->Delta));
      menu->SeparatorText("Input");
@@ -144,13 +149,12 @@ int main() {
      menu->Label(std::format("FocusedMenuRect: {}",
                              ui7->pIO->InputHandler->FocusedMenuRect));
      menu->SeparatorText("Menu Order");
-      for (auto &it : ui7->pDFO) {
+      for (auto& it : ui7->pDFO) {
        menu->Label(std::format("{}", ui7->pMenus[it]->pID.GetName()));
      }
      ui7->EndMenu();
    }
-    if (ui7->BeginMenu("NoDebug")) {
-      auto m = ui7->pCurrent;
+    if (auto m = ui7->BeginMenu("NoDebug")) {
      if (m->BeginTreeNode("Test")) {
        m->Label("Hello World!");
        if (m->BeginTreeNode("AnotherNode")) {
@@ -176,8 +180,8 @@ int main() {
 #endif
    PD::TT::Beg("REN");
    PD::Gfx::NewFrame();
-    PD::Gfx::RenderDrawData(List->pDrawList);
-    PD::Gfx::RenderDrawData(ui7->GetDrawData()->pDrawList);
+    PD::Gfx::RenderDrawData(List->Data());
+    PD::Gfx::RenderDrawData(ui7->GetDrawData()->Data());
    /** Clear The List */
    List->Clear();
    PD::TT::End("REN");
Author	SHA1	Message	Date
tobid7	d2806b2061	Add Nee Backend Structure Use TexAddress instead of Texture::Ref in Cmds Add a .clang-format??	2026-01-25 00:04:40 +01:00
tobid7	da79db223f	Add MacOS support as well as OpenGL 3.3 support	2026-01-24 23:08:03 +01:00
tobid7	b2c7c1fdbf	UI7 Add Containers to Layout - Hotfix in CommandPool - Add UI7 ItemRowHeight (Universal Item Size/Height) - Add Containers to Layout - Add ColorEdit to Menu - Switch Back to COlorEdit in UI7::StyleEditor - Add DrawList Layer Sorting to UI7 (Not working as expected) - STart Work at ColorEdit container	2026-01-24 11:58:41 +01:00
tobid7	4a73e8c8da	UI7 hotfix - Fix Image has No Size - Fix DragData PathRect Positioning	2026-01-24 09:27:21 +01:00
tobid7	641fc27e55	Auto Menu Sizing	2026-01-23 16:11:09 +01:00
tobid7	b8c25d6901	Add a Drag Slider to UI7	2026-01-23 15:45:25 +01:00
tobid7	931e02aefb	Move CmdPool code to a source file	2026-01-22 19:25:01 +01:00
tobid7	0db4953125	Reimplement list sorting and Fix UI7 Layers	2026-01-22 16:34:46 +01:00
tobid7	2b7d25cf06	Update - Added DestroyTex to 3ds backend - Added Size() -> ivec2 to PD::Image - Added CmdPool Copy as well as DrawList Copy (Static rendering) - Added == ooperator for Rect - Added UI7 Frame Rounding - Fix UI7 Image usage withour size or uv - Added New way to use BeginMenu	2026-01-18 19:25:50 +01:00
tobid7	0ef6d34435	Refactor the Command / DrawList System Use Command Pool instead of always allocating. This gives us e big performance diffrence on the 3ds Fixed IDS of ui7 for now	2026-01-16 12:13:48 +01:00
tobid7	eb5d5f9974	backend updates pd-3ds: Add support for RGB565 textures pd-desktop: Add support for A8 textures Add glfw callback chain to not break other libs using the same callback	2026-01-05 14:37:57 +01:00