From dc59810566e640b68bbb8ee7111dc58d19853ec0 Mon Sep 17 00:00:00 2001 From: SpaiR Date: Wed, 18 Dec 2019 22:45:37 +0300 Subject: [PATCH] Add rendering implementation for LWJGL --- .editorconfig | 11 + build.gradle | 22 +- buildSrc/build.gradle | 19 + .../groovy/imgui/generate/GenerateLibs.groovy | 43 + gradle.properties | 1 + gradle/wrapper/gradle-wrapper.properties | 2 +- imgui-binding/build.gradle | 10 + .../src/main/java/imgui/DrawData.java | 38 + .../src/main/java/imgui/ImDrawList.java | 128 + imgui-binding/src/main/java/imgui/ImGui.java | 1553 ++++++++++++ .../src/main/java/imgui/ImGuiBoolean.java | 27 + .../src/main/java/imgui/ImGuiDouble.java | 27 + .../src/main/java/imgui/ImGuiEx.java | 103 + .../src/main/java/imgui/ImGuiFloat.java | 27 + .../src/main/java/imgui/ImGuiIO.java | 35 + .../main/java/imgui/ImGuiInputTextData.java | 8 + .../src/main/java/imgui/ImGuiInt.java | 27 + .../src/main/java/imgui/ImGuiString.java | 42 + .../src/main/java/imgui/ImGuiStyle.java | 7 + imgui-binding/src/main/java/imgui/ImVec2.java | 15 + imgui-binding/src/main/java/imgui/ImVec4.java | 8 + imgui-binding/src/main/java/imgui/Native.java | 2126 +++++++++++++++++ .../main/java/imgui/NativeCustomWidget.java | 168 ++ .../src/main/java/imgui/NativeInternal.java | 28 + .../src/main/java/imgui/TexDataRGBA32.java | 18 + .../java/imgui/enums/ImDrawCornerFlags.java | 28 + .../java/imgui/enums/ImGuiBackendFlags.java | 26 + .../src/main/java/imgui/enums/ImGuiCol.java | 89 + .../java/imgui/enums/ImGuiColorEditFlags.java | 47 + .../java/imgui/enums/ImGuiComboFlags.java | 31 + .../src/main/java/imgui/enums/ImGuiCond.java | 28 + .../java/imgui/enums/ImGuiConfigFlags.java | 32 + .../main/java/imgui/enums/ImGuiDataType.java | 28 + .../src/main/java/imgui/enums/ImGuiDir.java | 20 + .../java/imgui/enums/ImGuiDockNodeFlags.java | 25 + .../java/imgui/enums/ImGuiDragDropFlags.java | 37 + .../java/imgui/enums/ImGuiFocusedFlags.java | 27 + .../java/imgui/enums/ImGuiHoveredFlags.java | 35 + .../java/imgui/enums/ImGuiInputTextFlags.java | 99 + .../src/main/java/imgui/enums/ImGuiKey.java | 39 + .../java/imgui/enums/ImGuiMouseCursor.java | 28 + .../main/java/imgui/enums/ImGuiNavInput.java | 36 + .../imgui/enums/ImGuiSelectableFlags.java | 27 + .../main/java/imgui/enums/ImGuiStyleVar.java | 38 + .../java/imgui/enums/ImGuiTabBarFlags.java | 33 + .../java/imgui/enums/ImGuiTabItemFlags.java | 27 + .../java/imgui/enums/ImGuiTreeNodeFlags.java | 38 + .../java/imgui/enums/ImGuiWindowFlags.java | 47 + .../src/main/java/imgui/enums/ImLayout.java | 6 + .../src/main/native/imgui_layout_widget.cpp | 512 ++++ .../src/main/native/imgui_layout_widget.h | 182 ++ imgui-lwjgl3/build.gradle | 33 + imgui-lwjgl3/src/main/java/InputHandler.java | 125 + imgui-lwjgl3/src/main/java/Main.java | 156 ++ .../src/main/java/imgui/gl3/ImGuiImplGl3.java | 341 +++ imgui-lwjgl3/src/main/resources/default.frag | 14 + imgui-lwjgl3/src/main/resources/default.vert | 15 + libs/imgui-java.dll | Bin 0 -> 2285445 bytes settings.gradle | 2 + 59 files changed, 6728 insertions(+), 16 deletions(-) create mode 100644 .editorconfig create mode 100644 buildSrc/build.gradle create mode 100644 buildSrc/src/main/groovy/imgui/generate/GenerateLibs.groovy create mode 100644 gradle.properties create mode 100644 imgui-binding/build.gradle create mode 100644 imgui-binding/src/main/java/imgui/DrawData.java create mode 100644 imgui-binding/src/main/java/imgui/ImDrawList.java create mode 100644 imgui-binding/src/main/java/imgui/ImGui.java create mode 100644 imgui-binding/src/main/java/imgui/ImGuiBoolean.java create mode 100644 imgui-binding/src/main/java/imgui/ImGuiDouble.java create mode 100644 imgui-binding/src/main/java/imgui/ImGuiEx.java create mode 100644 imgui-binding/src/main/java/imgui/ImGuiFloat.java create mode 100644 imgui-binding/src/main/java/imgui/ImGuiIO.java create mode 100644 imgui-binding/src/main/java/imgui/ImGuiInputTextData.java create mode 100644 imgui-binding/src/main/java/imgui/ImGuiInt.java create mode 100644 imgui-binding/src/main/java/imgui/ImGuiString.java create mode 100644 imgui-binding/src/main/java/imgui/ImGuiStyle.java create mode 100644 imgui-binding/src/main/java/imgui/ImVec2.java create mode 100644 imgui-binding/src/main/java/imgui/ImVec4.java create mode 100644 imgui-binding/src/main/java/imgui/Native.java create mode 100644 imgui-binding/src/main/java/imgui/NativeCustomWidget.java create mode 100644 imgui-binding/src/main/java/imgui/NativeInternal.java create mode 100644 imgui-binding/src/main/java/imgui/TexDataRGBA32.java create mode 100644 imgui-binding/src/main/java/imgui/enums/ImDrawCornerFlags.java create mode 100644 imgui-binding/src/main/java/imgui/enums/ImGuiBackendFlags.java create mode 100644 imgui-binding/src/main/java/imgui/enums/ImGuiCol.java create mode 100644 imgui-binding/src/main/java/imgui/enums/ImGuiColorEditFlags.java create mode 100644 imgui-binding/src/main/java/imgui/enums/ImGuiComboFlags.java create mode 100644 imgui-binding/src/main/java/imgui/enums/ImGuiCond.java create mode 100644 imgui-binding/src/main/java/imgui/enums/ImGuiConfigFlags.java create mode 100644 imgui-binding/src/main/java/imgui/enums/ImGuiDataType.java create mode 100644 imgui-binding/src/main/java/imgui/enums/ImGuiDir.java create mode 100644 imgui-binding/src/main/java/imgui/enums/ImGuiDockNodeFlags.java create mode 100644 imgui-binding/src/main/java/imgui/enums/ImGuiDragDropFlags.java create mode 100644 imgui-binding/src/main/java/imgui/enums/ImGuiFocusedFlags.java create mode 100644 imgui-binding/src/main/java/imgui/enums/ImGuiHoveredFlags.java create mode 100644 imgui-binding/src/main/java/imgui/enums/ImGuiInputTextFlags.java create mode 100644 imgui-binding/src/main/java/imgui/enums/ImGuiKey.java create mode 100644 imgui-binding/src/main/java/imgui/enums/ImGuiMouseCursor.java create mode 100644 imgui-binding/src/main/java/imgui/enums/ImGuiNavInput.java create mode 100644 imgui-binding/src/main/java/imgui/enums/ImGuiSelectableFlags.java create mode 100644 imgui-binding/src/main/java/imgui/enums/ImGuiStyleVar.java create mode 100644 imgui-binding/src/main/java/imgui/enums/ImGuiTabBarFlags.java create mode 100644 imgui-binding/src/main/java/imgui/enums/ImGuiTabItemFlags.java create mode 100644 imgui-binding/src/main/java/imgui/enums/ImGuiTreeNodeFlags.java create mode 100644 imgui-binding/src/main/java/imgui/enums/ImGuiWindowFlags.java create mode 100644 imgui-binding/src/main/java/imgui/enums/ImLayout.java create mode 100644 imgui-binding/src/main/native/imgui_layout_widget.cpp create mode 100644 imgui-binding/src/main/native/imgui_layout_widget.h create mode 100644 imgui-lwjgl3/build.gradle create mode 100644 imgui-lwjgl3/src/main/java/InputHandler.java create mode 100644 imgui-lwjgl3/src/main/java/Main.java create mode 100644 imgui-lwjgl3/src/main/java/imgui/gl3/ImGuiImplGl3.java create mode 100644 imgui-lwjgl3/src/main/resources/default.frag create mode 100644 imgui-lwjgl3/src/main/resources/default.vert create mode 100644 libs/imgui-java.dll diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 0000000..1a86e85 --- /dev/null +++ b/.editorconfig @@ -0,0 +1,11 @@ +root = true + +[*] +end_of_line = lf +indent_style = space +insert_final_newline = true + +[*.{groovy,java}] +indent_size = 4 +max_line_length = 160 +trim_trailing_whitespace = true diff --git a/build.gradle b/build.gradle index a25963a..6cd5d2b 100644 --- a/build.gradle +++ b/build.gradle @@ -1,16 +1,8 @@ -plugins { - id 'java' -} - -group 'imgui' -version '1.0' - -sourceCompatibility = 1.8 - -repositories { - jcenter() - mavenCentral() -} - -dependencies { +allprojects { + group 'imgui-java' + version property('version') + repositories { + jcenter() + mavenCentral() + } } diff --git a/buildSrc/build.gradle b/buildSrc/build.gradle new file mode 100644 index 0000000..4484164 --- /dev/null +++ b/buildSrc/build.gradle @@ -0,0 +1,19 @@ +plugins { + id 'groovy' +} + +repositories { + jcenter() + mavenCentral() +} + +ext { + jnigenVersion = '1.9.10' +} + +dependencies { + implementation gradleApi() + implementation localGroovy() + + implementation "com.badlogicgames.gdx:gdx-jnigen:$jnigenVersion" +} diff --git a/buildSrc/src/main/groovy/imgui/generate/GenerateLibs.groovy b/buildSrc/src/main/groovy/imgui/generate/GenerateLibs.groovy new file mode 100644 index 0000000..a35236b --- /dev/null +++ b/buildSrc/src/main/groovy/imgui/generate/GenerateLibs.groovy @@ -0,0 +1,43 @@ +package imgui.generate + +import com.badlogic.gdx.jnigen.* +import groovy.transform.CompileStatic +import org.gradle.api.DefaultTask +import org.gradle.api.file.CopySpec +import org.gradle.api.tasks.TaskAction + +@CompileStatic +class GenerateLibs extends DefaultTask { + String description = 'Generates native libraries using classes under ":imgui-binding" and Dear-ImGui itself from "imgui" submodule.' + + private final String sourceDir = project.file('src/main/java') + private final String classpath = project.file('build/classes/java/main') + private final String jniDir = project.buildDir.path + '/jni' + private final String tmpFolder = project.buildDir.path + '/tmp' + private final String libsFolder = 'libsNative' + + @TaskAction + void generate() { + // Generate h/cpp files for JNI + new NativeCodeGenerator().generate(sourceDir, classpath, jniDir) + + // Copy ImGui h/cpp files + project.copy { CopySpec spec -> + spec.from(project.rootProject.file('imgui')) { CopySpec it -> it.include('*.h', '*.cpp') } + spec.from(project.file('src/main/native')) + spec.into(jniDir) + } + + // Generate platform dependant ant configs and header files + def buildConfig = new BuildConfig('imgui-java', tmpFolder, libsFolder, jniDir) + def win64 = BuildTarget.newDefaultTarget(BuildTarget.TargetOs.Windows, true) + new AntScriptGenerator().generate(buildConfig, win64) + + // Generate native libraries + BuildExecutor.executeAnt(jniDir + '/build-windows64.xml', '-v', '-Dhas-compiler=true', '-Drelease=true', 'clean', 'postcompile') + BuildExecutor.executeAnt(jniDir + '/build.xml', '-v', 'pack-natives') + + // Ant creates this folder in the root of the project. Since it will be empty we delete it + project.rootProject.file(libsFolder).deleteDir() + } +} diff --git a/gradle.properties b/gradle.properties new file mode 100644 index 0000000..9759e31 --- /dev/null +++ b/gradle.properties @@ -0,0 +1 @@ +version=0.0.1 \ No newline at end of file diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties index 9a094fa..ae7cf7e 100644 --- a/gradle/wrapper/gradle-wrapper.properties +++ b/gradle/wrapper/gradle-wrapper.properties @@ -1,4 +1,4 @@ -#Sat Dec 14 21:13:09 MSK 2019 +#Sat Dec 14 22:33:02 MSK 2019 distributionUrl=https\://services.gradle.org/distributions/gradle-6.0.1-all.zip distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists diff --git a/imgui-binding/build.gradle b/imgui-binding/build.gradle new file mode 100644 index 0000000..137166c --- /dev/null +++ b/imgui-binding/build.gradle @@ -0,0 +1,10 @@ +import imgui.generate.GenerateLibs + +plugins { + id 'java' +} + +sourceCompatibility = 1.8 + +assemble.dependsOn clean +task generateLibs(type: GenerateLibs, dependsOn: assemble) diff --git a/imgui-binding/src/main/java/imgui/DrawData.java b/imgui-binding/src/main/java/imgui/DrawData.java new file mode 100644 index 0000000..fc17376 --- /dev/null +++ b/imgui-binding/src/main/java/imgui/DrawData.java @@ -0,0 +1,38 @@ +package imgui; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; + +public final class DrawData { + public final static int vBufferSize = (4 + 1) * 4; + public final static int iBufferSize = 2; + public final static int cmdBufferSize = (1 + 4 + 1) * 4; + public int cmdListsCount; // Number of ImDrawList* to render + public int totalIdxCount; // For convenience, sum of all ImDrawList's IdxBuffer.Size + public int totalVtxCount; + public int totalCmdCount; + public float displayPosX; + public float displayPosY; + public float displaySizeX; + public float displaySizeY; + public float framebufferScaleX; + public float framebufferScaleY; + public ByteBuffer vByteBuffer; + public ByteBuffer iByteBuffer; + public ByteBuffer cmdByteBuffer; + + public DrawData(ByteBuffer vByteBuffer, ByteBuffer iByteBuffer, ByteBuffer cmdByteBuffer) { + this.vByteBuffer = vByteBuffer; + this.iByteBuffer = iByteBuffer; + this.cmdByteBuffer = cmdByteBuffer; + } + + public DrawData(int maxVertice, int maxIndices, int maxCmd) { + this.vByteBuffer = ByteBuffer.allocateDirect(maxVertice * vBufferSize); + this.iByteBuffer = ByteBuffer.allocateDirect(maxIndices * iBufferSize); + this.cmdByteBuffer = ByteBuffer.allocateDirect(maxCmd * cmdBufferSize); + vByteBuffer.order(ByteOrder.nativeOrder()); + iByteBuffer.order(ByteOrder.nativeOrder()); + cmdByteBuffer.order(ByteOrder.nativeOrder()); + } +} diff --git a/imgui-binding/src/main/java/imgui/ImDrawList.java b/imgui-binding/src/main/java/imgui/ImDrawList.java new file mode 100644 index 0000000..f508d46 --- /dev/null +++ b/imgui-binding/src/main/java/imgui/ImDrawList.java @@ -0,0 +1,128 @@ +package imgui; + +import imgui.enums.ImDrawCornerFlags; + +public class ImDrawList { + + public final static int TYPE_DEFAULT = 0; + public final static int TYPE_BACKGROUND = 1; + public final static int TYPE_FOREGROUND = 2; + + private int type = TYPE_DEFAULT; + + public ImDrawList(int type) { + this.type = type; + } + + public void AddLine(float a_x, float a_y, float b_x, float b_y, int col) { + Native.AddLine(type, a_x, a_y, b_x, b_y, col); + } + + public void AddLine(float a_x, float a_y, float b_x, float b_y, int col, float thinkness) { + Native.AddLine(type, a_x, a_y, b_x, b_y, col, thinkness); + } + + public void AddRect(float a_x, float a_y, float b_x, float b_y, int col) { + Native.AddRect(type, a_x, a_y, b_x, b_y, col); + } + + public void AddRect(float a_x, float a_y, float b_x, float b_y, int col, float rounding) { + Native.AddRect(type, a_x, a_y, b_x, b_y, col, rounding); + } + + public void AddRect(float a_x, float a_y, float b_x, float b_y, int col, float rounding, ImDrawCornerFlags rounding_corners_flags) { + Native.AddRect(type, a_x, a_y, b_x, b_y, col, rounding, rounding_corners_flags.getValue()); + } + + public void AddRect(float a_x, float a_y, float b_x, float b_y, int col, float rounding, ImDrawCornerFlags rounding_corners_flags, float thickness) { + Native.AddRect(type, a_x, a_y, b_x, b_y, col, rounding, rounding_corners_flags.getValue(), thickness); + } + + public void AddRectFilled(float a_x, float a_y, float b_x, float b_y, int col) { + Native.AddRectFilled(type, a_x, a_y, b_x, b_y, col); + } + + public void AddRectFilled(float a_x, float a_y, float b_x, float b_y, int col, float rounding) { + Native.AddRectFilled(type, a_x, a_y, b_x, b_y, col, rounding); + } + + public void AddRectFilled(float a_x, float a_y, float b_x, float b_y, int col, float rounding, ImDrawCornerFlags rounding_corners_flags) { + Native.AddRectFilled(type, a_x, a_y, b_x, b_y, col, rounding, rounding_corners_flags.getValue()); + } + + public void AddRectFilledMultiColor(float a_x, float a_y, float b_x, float b_y, int col_upr_left, float col_upr_right, int col_bot_right, int col_bot_left) { + Native.AddRectFilledMultiColor(type, a_x, a_y, b_x, b_y, col_upr_left, col_upr_right, col_bot_right, col_bot_left); + } + + public void AddQuad(float a_x, float a_y, float b_x, float b_y, float c_x, float c_y, float d_x, float d_y, int col) { + Native.AddQuad(type, a_x, a_y, b_x, b_y, c_x, c_y, d_x, d_y, col); + } + + public void AddQuad(float a_x, float a_y, float b_x, float b_y, float c_x, float c_y, float d_x, float d_y, int col, float thickness) { + Native.AddQuad(type, a_x, a_y, b_x, b_y, c_x, c_y, d_x, d_y, col, thickness); + } + + public void AddQuadFilled(float a_x, float a_y, float b_x, float b_y, float c_x, float c_y, float d_x, float d_y, int col) { + Native.AddQuadFilled(type, a_x, a_y, b_x, b_y, c_x, c_y, d_x, d_y, col); + } + + public void AddTriangle(float a_x, float a_y, float b_x, float b_y, float c_x, float c_y, int col) { + Native.AddTriangle(type, a_x, a_y, b_x, b_y, c_x, c_y, col); + } + + public void AddTriangle(float a_x, float a_y, float b_x, float b_y, float c_x, float c_y, int col, float thickness) { + Native.AddTriangle(type, a_x, a_y, b_x, b_y, c_x, c_y, col, thickness); + } + + public void AddTriangleFilled(float a_x, float a_y, float b_x, float b_y, float c_x, float c_y, int col) { + Native.AddTriangleFilled(type, a_x, a_y, b_x, b_y, c_x, c_y, col); + } + + public void AddCircle(float centre_x, float centre_y, float radius, float col, int num_segments, float thickness) { + Native.AddCircle(type, centre_x, centre_y, radius, col, num_segments, thickness); + } + + public void AddCircleFilled(float centre_x, float centre_y, float radius, float col) { + Native.AddCircleFilled(type, centre_x, centre_y, radius, col); + } + + public void AddCircleFilled(float centre_x, float centre_y, float radius, float col, int num_segments) { + Native.AddCircleFilled(type, centre_x, centre_y, radius, col, num_segments); + } + + public void AddText(float pos_x, float pos_y, int col, String text_begin) { + Native.AddText(type, pos_x, pos_y, col, text_begin); + } + + public void AddText(float pos_x, float pos_y, int col, String text_begin, String text_end) { + Native.AddText(type, pos_x, pos_y, col, text_begin, text_end); + } + + // TODO AddText + + public void AddImage(int textureID, float a_x, float a_y, float b_x, float b_y) { + Native.AddImage(type, textureID, a_x, a_y, b_x, b_y); + } + + public void AddImage(int textureID, float a_x, float a_y, float b_x, float b_y, float uv_a_x, float uv_a_y, float uv_b_x, float uv_b_y) { + Native.AddImage(type, textureID, a_x, a_y, b_x, b_y, uv_a_x, uv_a_y, uv_b_x, uv_b_y); + } + + //TODO AddImageQuad, AddImageRounded, AddPolyline, AddConvexPolyFilled + + public void AddBezierCurve(float pos0_x, float pos0_y, float cp0_x, float cp0_y, float cp1_x, float cp1_y, float pos1_x, float pos1_y, float col, float thickness) { + Native.AddBezierCurve(type, pos0_x, pos0_y, cp0_x, cp0_y, cp1_x, cp1_y, pos1_x, pos1_y, col, thickness); + } + + public void ChannelsSplit(int count) { + Native.ChannelsSplit(type, count); + } + + public void ChannelsMerge() { + Native.ChannelsMerge(type); + } + + public void ChannelsSetCurrent(int n) { + Native.ChannelsSetCurrent(type, n); + } +} diff --git a/imgui-binding/src/main/java/imgui/ImGui.java b/imgui-binding/src/main/java/imgui/ImGui.java new file mode 100644 index 0000000..e19a150 --- /dev/null +++ b/imgui-binding/src/main/java/imgui/ImGui.java @@ -0,0 +1,1553 @@ +package imgui; + +import imgui.enums.*; + +import java.nio.Buffer; +import java.nio.ByteBuffer; + +//import com.badlogic.gdx.jnigen.JniGenSharedLibraryLoader; + +public class ImGui { + private static final String LIB_NAME_PROP = "imgui.library.name"; + private static final String LIB_NAME_DEFAULT = "imgui-java"; + + public static boolean enableLogging = true; + public static String TAG = "ImGui"; + private static boolean IMGUIINIT = false; + private static DrawData drawData = new DrawData(100000, 100000, 1000); + private static ImGuiIO imguiIO = new ImGuiIO(); + private static ImGuiStyle imguiStyle = new ImGuiStyle(); + private static ImVec2 imVec2 = new ImVec2(); + private static ImVec4 imVec4 = new ImVec4(); + private static ImDrawList imDrawList = new ImDrawList(ImDrawList.TYPE_DEFAULT); + private static ImDrawList imDrawListBackground = new ImDrawList(ImDrawList.TYPE_BACKGROUND); + private static ImDrawList imDrawListForeground = new ImDrawList(ImDrawList.TYPE_FOREGROUND); + + protected ImGui() { + } + + public static void init() { + init(true); + } + + public static void init(boolean logging) { + if (ImGui.IMGUIINIT) + return; + System.loadLibrary(System.getProperty(LIB_NAME_PROP, LIB_NAME_DEFAULT)); + ImGui.IMGUIINIT = true; + ImGui.enableLogging = logging; + + Native.init(); + Native.CreateContext(); + } + + public static ImGuiIO GetIO() { + return imguiIO; + } + + public static ImGuiStyle GetStyle() { + return imguiStyle; + } + + public static void ShowStyleEditor() { + Native.ShowStyleEditor(); + } + + public static void ShowDemoWindow() { + Native.ShowDemoWindow(); + } + + public static void ShowDemoWindow(boolean open) { + Native.ShowDemoWindow(open); + } + + public static void ShowMetricsWindow() { + Native.ShowMetricsWindow(); + } + + public static void ShowMetricsWindow(boolean open) { + Native.ShowMetricsWindow(open); + } + + public static void UpdateDisplayAndInputAndFrame(float deltaTime, float w, float h, float backBufferWidth, float backBufferHeight, + int mouseX, int mouseY, boolean mouseDown0, boolean mouseDown1, boolean mouseDown2) { + Native.UpdateDisplayAndInputAndFrame(imguiIO, imguiStyle, deltaTime, w, h, backBufferWidth, backBufferHeight, + mouseX, mouseY, mouseDown0, mouseDown1, mouseDown2, false, false, false); + } + + public static void initKeyMap(int[] keys) { + Native.initKeyMap(keys); + } + + public static void UpdateKey(int key, boolean pressed, boolean released, boolean ctrlKey, boolean shiftKey, boolean altKey, boolean superKey) { + Native.updateKey(key, pressed, released, ctrlKey, shiftKey, altKey, superKey); + } + + public static void UpdateScroll(float amountX, float amountY) { + Native.updateScroll(amountX, amountY); + } + + public static void UpdateKeyTyped(int c) { + Native.updateKeyTyped(c); + } + + public static void Render() { + Native.Render(); + } + + public static DrawData GetDrawData() { + ByteBuffer cmdByteBuffer = drawData.cmdByteBuffer; + ByteBuffer vByteBuffer = drawData.vByteBuffer; + ByteBuffer iByteBuffer = drawData.iByteBuffer; + vByteBuffer.position(0); + iByteBuffer.position(0); + cmdByteBuffer.position(0); + Native.GetDrawData(drawData, iByteBuffer, vByteBuffer, cmdByteBuffer); + return drawData; + } + + public static void GetTexDataAsRGBA32(TexDataRGBA32 jTexData, Buffer pixelBuffer) { + Native.GetTexDataAsRGBA32(jTexData, pixelBuffer); + } + + public static void SetFontTexID(int id) { + Native.SetFontTexID(id); + } + + public static void StyleColorsDark() { + Native.StyleColorsDark(); + } + + public static void StyleColorsClassic() { + Native.StyleColorsClassic(); + } + + public static void StyleColorsLight() { + Native.StyleColorsLight(); + } + + public static boolean Begin(String title) { + return Native.Begin(title); + } + + public static boolean Begin(String title, ImGuiBoolean p_open, ImGuiWindowFlags flags) { + return Native.Begin(title, p_open.data, flags.getValue()); + } + + public static void End() { + Native.End(); + } + + // Child Windows + // - Use child windows to begin into a self-contained independent scrolling/clipping regions within a host window. Child windows can embed their own child. + // - For each independent axis of 'size': ==0.0f: use remaining host window size / >0.0f: fixed size / <0.0f: use remaining window size minus abs(size) / Each axis can use a different mode, e.g. ImVec2(0,400). + // - BeginChild() returns false to indicate the window is collapsed or fully clipped, so you may early out and omit submitting anything to the window. + // Always call a matching EndChild() for each BeginChild() call, regardless of its return value [this is due to legacy reason and is inconsistent with most other functions such as BeginMenu/EndMenu, BeginPopup/EndPopup, etc. where the EndXXX call should only be called if the corresponding BeginXXX function returned true.] + + + public static boolean BeginChild(String str_id) { + return Native.BeginChild(str_id); + } + + public static boolean BeginChild(String str_id, float width, float height) { + return Native.BeginChild(str_id, width, height); + } + + public static boolean BeginChild(String str_id, float width, float height, boolean border) { + return Native.BeginChild(str_id, width, height, border); + } + + public static boolean BeginChild(String str_id, float width, float height, boolean border, ImGuiWindowFlags flags) { + return Native.BeginChild(str_id, width, height, border, flags.getValue()); + } + + public static boolean BeginChild(int imGuiID) { + return Native.BeginChild(imGuiID); + } + + public static boolean BeginChild(int imGuiID, float width, float height, boolean border) { + return Native.BeginChild(imGuiID, width, height, border); + } + + public static boolean BeginChild(int imGuiID, float width, float height, boolean border, ImGuiWindowFlags flags) { + return Native.BeginChild(imGuiID, width, height, border, flags.getValue()); + } + + public static void EndChild() { + Native.EndChild(); + } + + // Windows Utilities + // - "current window" = the window we are appending into while inside a Begin()/End() block. "next window" = next window we will Begin() into. + + public static boolean IsWindowAppearing() { + return Native.IsWindowAppearing(); + } + + public static boolean IsWindowCollapsed() { + return Native.IsWindowCollapsed(); + } + + public static boolean IsWindowFocused() { + return Native.IsWindowFocused(); + } + + public static boolean IsWindowFocused(ImGuiFocusedFlags flags) { + return Native.IsWindowFocused(flags.getValue()); + } + + public static boolean IsWindowHovered() { + return Native.IsWindowHovered(); + } + + public static boolean IsWindowHovered(ImGuiHoveredFlags flags) { + return Native.IsWindowHovered(flags.getValue()); + } + + public static ImDrawList GetWindowDrawList() { + return imDrawList; + } + + public static ImDrawList GetBackgroundDrawList() { + return imDrawListBackground; + } + + public static ImDrawList GetForegroundDrawList() { + return imDrawListForeground; + } + + public static ImVec2 GetWindowPos() { + Native.GetWindowPos(imVec2); + return imVec2; + } + + public static float GetWindowPosX() { + return Native.GetWindowPosX(); + } + + public static float GetWindowPosY() { + return Native.GetWindowPosY(); + } + + public static ImVec2 GetWindowSize() { + Native.GetWindowSize(imVec2); + return imVec2; + } + + public static float GetWindowWidth() { + return Native.GetWindowWidth(); + } + + public static float GetWindowHeight() { + return Native.GetWindowHeight(); + } + + // Prefer using SetNextXXX functions (before Begin) rather that SetXXX functions (after Begin). + + public static void SetNextWindowPos(float x, float y) { + Native.SetNextWindowPos(x, y); + } + + public static void SetNextWindowPos(float x, float y, ImGuiCond cond, float pivotX, float pivotY) { + Native.SetNextWindowPos(x, y, cond.getValue(), pivotX, pivotY); + } + + public static void SetNextWindowSize(int width, int height) { + Native.SetNextWindowSize(width, height); + } + + public static void SetNextWindowSize(int width, int height, ImGuiCond cond) { + Native.SetNextWindowSize(width, height, cond.getValue()); + } + + public static void SetNextWindowSizeConstraints(float minWidth, float minHeight, float maxWidth, float maxHeight) { + Native.SetNextWindowSizeConstraints(minWidth, minHeight, maxWidth, maxHeight); + } + + public static void SetNextWindowContentSize(float sizeX, float sizeY) { + Native.SetNextWindowContentSize(sizeX, sizeY); + } + + public static void SetNextWindowCollapsed(boolean flag) { + Native.SetNextWindowCollapsed(flag); + } + + public static void SetNextWindowFocus() { + Native.SetNextWindowFocus(); + } + + public static void SetNextWindowBgAlpha(float alpha) { + Native.SetNextWindowBgAlpha(alpha); + } + + //TODO add more methods + + public static void SetWindowFocus() { + Native.SetWindowFocus(); + } + + public static void SetWindowFocus(String name) { + if (name == null) + Native.RemoveWindowFocus(); + else + Native.SetWindowFocus(name); + } + + // Content region + // - Those functions are bound to be redesigned soon (they are confusing, incomplete and return values in local window coordinates which increases confusion) + + public static ImVec2 GetContentRegionMax() { + Native.GetContentRegionMax(imVec2); + return imVec2; + } + + public static ImVec2 GetContentRegionAvail() { + Native.GetContentRegionAvail(imVec2); + return imVec2; + } + + public static float GetContentRegionAvailWidth() { + return Native.GetContentRegionAvailWidth(); + } + + public static ImVec2 GetWindowContentRegionMin() { + Native.GetWindowContentRegionMin(imVec2); + return imVec2; + } + + public static ImVec2 GetWindowContentRegionMax() { + Native.GetWindowContentRegionMax(imVec2); + return imVec2; + } + + public static float GetWindowContentRegionWidth() { + return Native.GetWindowContentRegionWidth(); + } + + // Windows Scrolling + + public static float GetScrollX() { + return Native.GetScrollX(); + } + + public static float GetScrollY() { + return Native.GetScrollY(); + } + + public static float GetScrollMaxX() { + return Native.GetScrollMaxX(); + } + + public static float GetScrollMaxY() { + return Native.GetScrollMaxY(); + } + + public static void SetScrollX(float scroll_x) { + Native.SetScrollX(scroll_x); + } + + public static void SetScrollY(float scroll_y) { + Native.SetScrollY(scroll_y); + } + + public static void SetScrollHereY() { + Native.SetScrollHereY(); + } + + public static void SetScrollHereY(float center_y_ratio) { + Native.SetScrollHereY(center_y_ratio); + } + + public static void SetScrollFromPosY(float local_y) { + Native.SetScrollFromPosY(local_y); + } + + public static void SetScrollFromPosY(float local_y, float center_y_ratio) { + Native.SetScrollFromPosY(local_y, center_y_ratio); + } + + // Parameters stacks (shared) + + public static void PushStyleColor(ImGuiCol idx, int col) { + Native.PushStyleColor(idx.getValue(), col); + } + + public static void PushStyleColor(ImGuiCol idx, float r, float g, float b, float a) { + Native.PushStyleColor(idx.getValue(), r, g, b, a); + } + + public static void PopStyleColor() { + Native.PopStyleColor(); + } + + public static void PopStyleColor(int count) { + Native.PopStyleColor(count); + } + + public static void PushStyleVar(ImGuiStyleVar idx, float val) { + Native.PushStyleVar(idx.getValue(), val); + } + + public static void PushStyleVar(ImGuiStyleVar idx, float valX, float valY) { + Native.PushStyleVar(idx.getValue(), valX, valY); + } + + public static void PopStyleVar() { + Native.PopStyleVar(); + } + + public static void PopStyleVar(int count) { + Native.PopStyleVar(count); + } + + // Parameters stacks (current window) + + public static void PushItemWidth(float item_width) { + Native.PushItemWidth(item_width); + } + + public static void PopItemWidth() { + Native.PopItemWidth(); + } + + public static void SetNextItemWidth(float item_width) { + Native.SetNextItemWidth(item_width); + } + + public static float CalcItemWidth() { + return Native.CalcItemWidth(); + } + + public static void PushTextWrapPos() { + Native.PushTextWrapPos(); + } + + public static void PushTextWrapPos(float wrap_local_pos_x) { + Native.PushTextWrapPos(wrap_local_pos_x); + } + + public static void PopTextWrapPos() { + Native.PopTextWrapPos(); + } + + public static void PushAllowKeyboardFocus(boolean allow_keyboard_focus) { + Native.PushAllowKeyboardFocus(allow_keyboard_focus); + } + + public static void PushButtonRepeat() { + Native.PopAllowKeyboardFocus(); + } + + public static void PushButtonRepeat(boolean repeat) { + Native.PushButtonRepeat(repeat); + } + + public static void PopButtonRepeat() { + Native.PopButtonRepeat(); + } + + // Cursor / Layout + // - By "cursor" we mean the current output position. + // - The typical widget behavior is to output themselves at the current cursor position, then move the cursor one line down. + + public static void Separator() { + Native.Separator(); + } + + public static void SameLine() { + Native.SameLine(); + } + + public static void SameLine(float offsetFromStartX) { + Native.SameLine(offsetFromStartX); + } + + public static void SameLine(float offsetFromStartX, float spacing) { + Native.SameLine(offsetFromStartX, spacing); + } + + public static void NewLine() { + Native.NewLine(); + } + + public static void Spacing() { + Native.Spacing(); + } + + public static void Dummy(float width, float height) { + Native.Dummy(width, height); + } + + public static void Indent() { + Native.Indent(); + } + + public static void Indent(float indentW) { + Native.Indent(indentW); + } + + public static void Unindent() { + Native.Unindent(); + } + + public static void Unindent(float indentW) { + Native.Unindent(indentW); + } + + public static void BeginGroup() { + Native.BeginGroup(); + } + + public static void EndGroup() { + Native.EndGroup(); + } + + public static void GetCursorPos() { + //TODO impl + } + + public static float GetCursorPosX() { + return Native.GetCursorPosX(); + } + + public static float GetCursorPosY() { + return Native.GetCursorPosY(); + } + + public static void SetCursorPos(float x, float y) { + Native.SetCursorPos(x, y); + } + + public static void SetCursorPosX(float x) { + Native.SetCursorPosX(x); + } + + public static void SetCursorPosY(float y) { + Native.SetCursorPosY(y); + } + + public static ImVec2 GetCursorStartPos() { + Native.GetCursorStartPos(imVec2); + return imVec2; + } + + public static ImVec2 GetCursorScreenPos() { + Native.GetCursorScreenPos(imVec2); + return imVec2; + } + + public static void SetCursorScreenPos(float x, float y) { + Native.SetCursorScreenPos(x, y); + } + + public static void AlignTextToFramePadding() { + Native.AlignTextToFramePadding(); + } + + public static float GetTextLineHeight() { + return Native.GetTextLineHeight(); + } + + public static float GetTextLineHeightWithSpacing() { + return Native.GetTextLineHeightWithSpacing(); + } + + public static float GetFrameHeight() { + return Native.GetFrameHeight(); + } + + public static float GetFrameHeightWithSpacing() { + return Native.GetFrameHeightWithSpacing(); + } + + // ID stack/scopes + // - Read the FAQ for more details about how ID are handled in dear imgui. If you are creating widgets in a loop you most + // likely want to push a unique identifier (e.g. object pointer, loop index) to uniquely differentiate them. + // - The resulting ID are hashes of the entire stack. + // - You can also use the "Label##foobar" syntax within widget label to distinguish them from each others. + // - In this header file we use the "label"/"name" terminology to denote a string that will be displayed and used as an ID, + // whereas "str_id" denote a string that is only used as an ID and not normally displayed. + + public static void PushID(String str_id) { + Native.PushID(str_id); + } + + public static void PushID(String str_id_begin, String str_id_end) { + Native.PushID(str_id_begin, str_id_end); + } + + public static void PushID(int int_id) { + Native.PushID(int_id); + } + + public static void PopID() { + Native.PopID(); + } + + public static int GetID(String str_id) { + return Native.GetID(str_id); + } + + public static int GetID(String str_id_begin, String str_id_end) { + return Native.GetID(str_id_begin, str_id_end); + } + + // TODO GetID ptr_id + + // Widgets: Text + + public static void TextUnformatted(String text) { + Native.TextUnformatted(text); + } + + public static void TextUnformatted(String text, String text_end) { + Native.TextUnformatted(text, text_end); + } + + public static void Text(String text) { + Native.Text(text); + } + + public static void TextColored(float r, float g, float b, float a, String text) { + Native.TextColored(r, g, b, a, text); + } + + public static void TextDisabled(String text) { + Native.TextDisabled(text); + } + + public static void TextWrapped(String text) { + Native.TextWrapped(text); + } + + public static void LabelText(String label, String text) { + Native.LabelText(label, text); + } + + public static void BulletText(String text) { + Native.BulletText(text); + } + + // Widgets: Main + // - Most widgets return true when the value has been changed or when pressed/selected + + /** + * button + */ + public static boolean Button(String label) { + return Native.Button(label); + } + + /** + * button + */ + public static boolean Button(String label, float width, float height) { + return Native.Button(label, width, height); + } + + /** + * button with FramePadding=(0,0) to easily embed within text + */ + public static boolean SmallButton(String label) { + return Native.SmallButton(label); + } + + /** + * button behavior without the visuals, frequently useful to build custom behaviors using the public api (along with IsItemActive, IsItemHovered, etc.) + */ + public static boolean InvisibleButton(String strId, float width, float height) { + return Native.InvisibleButton(strId, width, height); + } + + /** + * square button with an arrow shape + */ + public static boolean ArrowButton(String strId, ImGuiDir dir) { + return Native.ArrowButton(strId, dir.toInt()); + } + + public static void Image(int textureID, float sizeX, float sizeY) { + Native.Image(textureID, sizeX, sizeY); + } + + public static void Image(int textureID, float sizeX, float sizeY, float uv0_x, float uv0_y, float uv1_x, float uv1_y) { + Native.Image(textureID, sizeX, sizeY, uv0_x, uv0_y, uv1_x, uv1_y); + } + + public static boolean ImageButton(int textureID, float sizeX, float sizeY) { + return Native.ImageButton(textureID, sizeX, sizeY); + } + + public static boolean ImageButton(int textureID, float sizeX, float sizeY, float uv0_x, float uv0_y, float uv1_x, float uv1_y, int frame_padding) { + return Native.ImageButton(textureID, sizeX, sizeY, uv0_x, uv0_y, uv1_x, uv1_y, frame_padding); + } + + public static boolean Checkbox(String label, ImGuiBoolean value) { + return Native.Checkbox(label, value.data); + } + + public static boolean CheckboxFlags(String label, ImGuiInt flags, ImGuiTabBarFlags flagsValues) { + return Native.CheckboxFlags(label, flags.data, flagsValues.getValue()); + } + + public static boolean RadioButton(String label, boolean active) { + return Native.RadioButton(label, active); + } + + public static boolean RadioButton(String label, ImGuiInt value, int v_button) { + return Native.RadioButton(label, value.data, v_button); + } + + public static void ProgressBar(float fraction) { + Native.ProgressBar(fraction); + } + + public static void ProgressBar(float fraction, float size_arg_x, float size_arg_y) { + Native.ProgressBar(fraction, size_arg_x, size_arg_y); + } + + public static void Bullet() { + Native.Bullet(); + } + + // Widgets: Combo Box + // - The new BeginCombo()/EndCombo() api allows you to manage your contents and selection state however you want it, by creating e.g. Selectable() items. + // - The old Combo() api are helpers over BeginCombo()/EndCombo() which are kept available for convenience purpose. + + public static boolean BeginCombo(String label, String preview_value) { + return Native.BeginCombo(label, preview_value); + } + + public static boolean BeginCombo(String label, String preview_value, ImGuiComboFlags flags) { + return Native.BeginCombo(label, preview_value, flags.getValue()); + } + + public static void EndCombo() { + Native.EndCombo(); + } + + public static boolean Combo(String label, ImGuiInt current_item, String[] items, int items_count) { + return Native.Combo(label, current_item.data, items, items_count); + } + + public static boolean Combo(String label, ImGuiInt current_item, String[] items, int items_count, int popup_max_height_in_items) { + return Native.Combo(label, current_item.data, items, items_count, popup_max_height_in_items); + } + + public static boolean Combo(String label, ImGuiInt current_item, String items_separated_by_zeros) { + return Native.Combo(label, current_item.data, items_separated_by_zeros); + } + + public static boolean Combo(String label, ImGuiInt current_item, String items_separated_by_zeros, int popup_max_height_in_items) { + return Native.Combo(label, current_item.data, items_separated_by_zeros, popup_max_height_in_items); + } + + // Widgets: Drags + // - CTRL+Click on any drag box to turn them into an input box. Manually input values aren't clamped and can go off-bounds. + // - For all the Float2/Float3/Float4/Int2/Int3/Int4 versions of every functions, note that a 'float v[X]' function argument is the same as 'float* v', the array syntax is just a way to document the number of elements that are expected to be accessible. You can pass address of your first element out of a contiguous set, e.g. &myvector.x + // - Adjust format string to decorate the value with a prefix, a suffix, or adapt the editing and display precision e.g. "%.3f" -> 1.234; "%5.2f secs" -> 01.23 secs; "Biscuit: %.0f" -> Biscuit: 1; etc. + // - Speed are per-pixel of mouse movement (v_speed=0.2f: mouse needs to move by 5 pixels to increase value by 1). For gamepad/keyboard navigation, minimum speed is Max(v_speed, minimum_step_at_given_precision). + + public static boolean DragFloat(String label, ImGuiFloat v) { + return Native.DragFloat(label, v.data); + } + + public static boolean DragFloat(String label, ImGuiFloat v, float v_speed) { + return Native.DragFloat(label, v.data, v_speed); + } + + public static boolean DragFloat(String label, ImGuiFloat v, float v_speed, float v_min, float v_max, String format) { + return Native.DragFloat(label, v.data, v_speed, v_min, v_max, format); + } + + public static boolean DragFloat(String label, ImGuiFloat v, float v_speed, float v_min, float v_max, String format, float power) { + return Native.DragFloat(label, v.data, v_speed, v_min, v_max, format, power); + } + + public static boolean DragFloat2(String label, float[] v) { + return Native.DragFloat2(label, v); + } + + public static boolean DragFloat2(String label, float[] v, float v_speed, float v_min, float v_max, String format, float power) { + return Native.DragFloat2(label, v, v_speed, v_min, v_max, format, power); + } + + public static boolean DragFloat3(String label, float[] v) { + return Native.DragFloat3(label, v); + } + + public static boolean DragFloat3(String label, float[] v, float v_speed, float v_min, float v_max, String format, float power) { + return Native.DragFloat3(label, v, v_speed, v_min, v_max, format, power); + } + + public static boolean DragFloat4(String label, float[] v) { + return Native.DragFloat4(label, v); + } + + public static boolean DragFloat4(String label, float[] v, float v_speed, float v_min, float v_max, String format, float power) { + return Native.DragFloat4(label, v, v_speed, v_min, v_max, format, power); + } + + public static boolean DragFloatRange2(String label, ImGuiFloat v_current_min, ImGuiFloat v_current_max) { + return Native.DragFloatRange2(label, v_current_min.data, v_current_max.data); + } + + public static boolean DragFloatRange2(String label, ImGuiFloat v_current_min, ImGuiFloat v_current_max, float v_speed, float v_min, float v_max, String format, String format_max, float power) { + return Native.DragFloatRange2(label, v_current_min.data, v_current_max.data, v_speed, v_min, v_max, format, format_max, power); + } + + public static boolean DragInt(String label, ImGuiInt v) { + return Native.DragInt(label, v.data); + } + + public static boolean DragInt(String label, ImGuiInt v, float v_speed) { + return Native.DragInt(label, v.data, v_speed); + } + + public static boolean DragInt(String label, ImGuiInt v, float v_speed, float v_min, float v_max, String format) { + return Native.DragInt(label, v.data, v_speed, v_min, v_max, format); + } + + public static boolean DragInt2(String label, int[] v) { + return Native.DragInt2(label, v); + } + + public static boolean DragInt2(String label, int[] v, float v_speed, float v_min, float v_max, String format) { + return Native.DragInt2(label, v, v_speed, v_min, v_max, format); + } + + public static boolean DragInt3(String label, int[] v) { + return Native.DragInt3(label, v); + } + + public static boolean DragInt3(String label, int[] v, float v_speed, float v_min, float v_max, String format) { + return Native.DragInt3(label, v, v_speed, v_min, v_max, format); + } + + public static boolean DragInt4(String label, int[] v) { + return Native.DragInt4(label, v); + } + + public static boolean DragInt4(String label, int[] v, float v_speed, float v_min, float v_max, String format) { + return Native.DragInt4(label, v, v_speed, v_min, v_max, format); + } + + public static boolean DragIntRange2(String label, ImGuiInt v_current_min, ImGuiInt v_current_max) { + return Native.DragIntRange2(label, v_current_min.data, v_current_max.data); + } + + public static boolean DragIntRange2(String label, ImGuiInt v_current_min, ImGuiInt v_current_max, float v_speed, float v_min, float v_max, String format, String format_max) { + return Native.DragIntRange2(label, v_current_min.data, v_current_max.data, v_speed, v_min, v_max, format, format_max); + } + + //TODO impl +// public static boolean DragScalar(String label, ImGuiDataType_ data_type, ImGuiInt v, ImGuiInt v_current_max, float v_speed, float v_min, float v_max, String format, String format_max) { +// return ImGuiNative.DragScalar(label, data_type.getValue(), v.data, v_current_max.data, v_speed, v_min, v_max, format, format_max); +// } + + + // Widgets: Sliders + // - CTRL+Click on any slider to turn them into an input box. Manually input values aren't clamped and can go off-bounds. + // - Adjust format string to decorate the value with a prefix, a suffix, or adapt the editing and display precision e.g. "%.3f" -> 1.234; "%5.2f secs" -> 01.23 secs; "Biscuit: %.0f" -> Biscuit: 1; etc. + + public static boolean SliderFloat(String label, ImGuiFloat v, float v_min, float v_max) { + return Native.SliderFloat(label, v.data, v_min, v_max); + } + + public static boolean SliderFloat(String label, ImGuiFloat v, float v_min, float v_max, String format) { + return Native.SliderFloat(label, v.data, v_min, v_max, format); + } + + public static boolean SliderFloat(String label, ImGuiFloat v, float v_min, float v_max, String format, float power) { + return Native.SliderFloat(label, v.data, v_min, v_max, format, power); + } + + public static boolean SliderFloat2(String label, float[] v, float v_min, float v_max) { + return Native.SliderFloat2(label, v, v_min, v_max); + } + + public static boolean SliderFloat2(String label, float[] v, float v_min, float v_max, String format, float power) { + return Native.SliderFloat2(label, v, v_min, v_max, format, power); + } + + public static boolean SliderFloat3(String label, float[] v, float v_min, float v_max) { + return Native.SliderFloat3(label, v, v_min, v_max); + } + + public static boolean SliderFloat3(String label, float[] v, float v_min, float v_max, String format, float power) { + return Native.SliderFloat3(label, v, v_min, v_max, format, power); + } + + public static boolean SliderFloat4(String label, float[] v, float v_min, float v_max) { + return Native.SliderFloat4(label, v, v_min, v_max); + } + + public static boolean SliderFloat4(String label, float[] v, float v_min, float v_max, String format, float power) { + return Native.SliderFloat4(label, v, v_min, v_max, format, power); + } + + public static boolean SliderAngle(String label, ImGuiFloat v) { + return Native.SliderAngle(label, v.data); + } + + public static boolean SliderAngle(String label, ImGuiFloat v, float v_degrees_min, float v_degrees_max, String format) { + return Native.SliderAngle(label, v.data, v_degrees_min, v_degrees_max, format); + } + + public static boolean SliderInt(String label, ImGuiInt v, int v_min, int v_max) { + return Native.SliderInt(label, v.data, v_min, v_max); + } + + public static boolean SliderInt(String label, ImGuiInt v, int v_min, int v_max, String format) { + return Native.SliderInt(label, v.data, v_min, v_max, format); + } + + public static boolean SliderInt2(String label, int[] v, int v_min, int v_max) { + return Native.SliderInt2(label, v, v_min, v_max); + } + + public static boolean SliderInt2(String label, int[] v, int v_min, int v_max, String format) { + return Native.SliderInt2(label, v, v_min, v_max, format); + } + + public static boolean SliderInt3(String label, int[] v, int v_min, int v_max) { + return Native.SliderInt3(label, v, v_min, v_max); + } + + public static boolean SliderInt3(String label, int[] v, int v_min, int v_max, String format) { + return Native.SliderInt3(label, v, v_min, v_max, format); + } + + public static boolean SliderInt4(String label, int[] v, int v_min, int v_max) { + return Native.SliderInt4(label, v, v_min, v_max); + } + + public static boolean SliderInt4(String label, int[] v, int v_min, int v_max, String format) { + return Native.SliderInt4(label, v, v_min, v_max, format); + } + + public static boolean SliderScalar(String label, ImGuiDataType data_type, ImGuiInt v, int v_min, int v_max) { + return Native.SliderScalar(label, data_type.getValue(), v.data, v_min, v_max); + } + + public static boolean SliderScalar(String label, ImGuiDataType data_type, ImGuiInt v, int v_min, int v_max, String format, float power) { + return Native.SliderScalar(label, data_type.getValue(), v.data, v_min, v_max, format, power); + } + + public static boolean SliderScalar(String label, ImGuiDataType data_type, ImGuiFloat v, float v_min, float v_max) { + return Native.SliderScalar(label, data_type.getValue(), v.data, v_min, v_max); + } + + public static boolean SliderScalar(String label, ImGuiDataType data_type, ImGuiFloat v, float v_min, float v_max, String format, float power) { + return Native.SliderScalar(label, data_type.getValue(), v.data, v_min, v_max, format, power); + } + + public static boolean VSliderFloat(String label, float sizeX, float sizeY, ImGuiFloat v, float v_min, float v_max) { + return Native.VSliderFloat(label, sizeX, sizeY, v.data, v_min, v_max); + } + + public static boolean VSliderFloat(String label, float sizeX, float sizeY, ImGuiFloat v, float v_min, float v_max, String format, float power) { + return Native.VSliderFloat(label, sizeX, sizeY, v.data, v_min, v_max, format, power); + } + + public static boolean VSliderInt(String label, float sizeX, float sizeY, ImGuiInt v, int v_min, int v_max) { + return Native.VSliderInt(label, sizeX, sizeY, v.data, v_min, v_max); + } + + public static boolean VSliderInt(String label, float sizeX, float sizeY, ImGuiInt v, int v_min, int v_max, String format) { + return Native.VSliderInt(label, sizeX, sizeY, v.data, v_min, v_max, format); + } + + public static boolean VSliderScalar(String label, float sizeX, float sizeY, ImGuiDataType data_type, ImGuiFloat v, float v_min, float v_max) { + return Native.VSliderScalar(label, sizeX, sizeY, data_type.getValue(), v.data, v_min, v_max); + } + + public static boolean VSliderScalar(String label, float sizeX, float sizeY, ImGuiDataType data_type, ImGuiFloat v, float v_min, float v_max, String format, float power) { + return Native.VSliderScalar(label, sizeX, sizeY, data_type.getValue(), v.data, v_min, v_max, format, power); + } + + public static boolean VSliderScalar(String label, float sizeX, float sizeY, ImGuiDataType data_type, ImGuiInt v, int v_min, int v_max) { + return Native.VSliderScalar(label, sizeX, sizeY, data_type.getValue(), v.data, v_min, v_max); + } + + public static boolean VSliderScalar(String label, float sizeX, float sizeY, ImGuiDataType data_type, ImGuiInt v, int v_min, int v_max, String format, float power) { + return Native.VSliderScalar(label, sizeX, sizeY, data_type.getValue(), v.data, v_min, v_max, format, power); + } + + // Widgets: Input with Keyboard + // - If you want to use InputText() with a dynamic string type such as std::string or your own, see misc/cpp/imgui_stdlib.h + // - Most of the ImGuiInputTextFlags flags are only useful for InputText() and not for InputFloatX, InputIntX, InputDouble etc. + + public static boolean InputText(String label, ImGuiString text) { + return Native.InputText(label, text.data, text.data.length, 0, text.inputData, text.inputData.maxChar, text.inputData.allowedChar, text.inputData.allowedChar.length()); + } + + public static boolean InputText(String label, ImGuiString text, ImGuiInputTextFlags flags) { + return Native.InputText(label, text.data, text.data.length, flags.getValue(), text.inputData, text.inputData.maxChar, text.inputData.allowedChar, text.inputData.allowedChar.length()); + } + + public static boolean InputFloat(String label, ImGuiFloat v) { + return Native.InputFloat(label, v.data); + } + + public static boolean InputFloat(String label, ImGuiFloat v, float step, float step_fast, String format) { + return Native.InputFloat(label, v.data, step, step_fast, format); + } + + public static boolean InputFloat(String label, ImGuiFloat v, float step, float step_fast, String format, ImGuiInputTextFlags flags) { + return Native.InputFloat(label, v.data, step, step_fast, format, flags.getValue()); + } + + public static boolean InputInt(String label, ImGuiInt v) { + return Native.InputInt(label, v.data); + } + + public static boolean InputInt(String label, ImGuiInt v, float step, float step_fast) { + return Native.InputInt(label, v.data, step, step_fast); + } + + public static boolean InputInt(String label, ImGuiInt v, float step, float step_fast, ImGuiInputTextFlags flags) { + return Native.InputInt(label, v.data, step, step_fast, flags.getValue()); + } + + public static boolean InputDouble(String label, ImGuiDouble v) { + return Native.InputDouble(label, v.data); + } + + public static boolean InputDouble(String label, ImGuiDouble v, float step, float step_fast, String format) { + return Native.InputDouble(label, v.data, step, step_fast, format); + } + + public static boolean InputDouble(String label, ImGuiDouble v, float step, float step_fast, String format, ImGuiInputTextFlags flags) { + return Native.InputDouble(label, v.data, step, step_fast, format, flags.getValue()); + } + + // Widgets: Trees + // - TreeNode functions return true when the node is open, in which case you need to also call TreePop() when you are finished displaying the tree node contents. + + public static boolean TreeNode(String label) { + return Native.TreeNode(label); + } + + public static boolean TreeNode(String str_id, String label) { + return Native.TreeNode(str_id, label); + } + + public static boolean TreeNode(int ptr_id, String label) { + return Native.TreeNode(ptr_id, label); + } + + public static boolean TreeNodeEx(String label) { + return Native.TreeNodeEx(label); + } + + public static boolean TreeNodeEx(String label, ImGuiTreeNodeFlags flags) { + return Native.TreeNodeEx(label, flags.getValue()); + } + + public static boolean TreeNodeEx(String str_id, ImGuiTreeNodeFlags flags, String label) { + return Native.TreeNodeEx(str_id, flags.getValue(), label); + } + + public static boolean TreeNodeEx(int ptr_id, ImGuiTreeNodeFlags flags, String label) { + return Native.TreeNodeEx(ptr_id, flags.getValue(), label); + } + + public static void TreePush() { + Native.TreePush(); + } + + public static void TreePush(String str_id) { + Native.TreePush(str_id); + } + + public static void TreePush(int ptr_id) { + Native.TreePush(ptr_id); + } + + public static void TreePop() { + Native.TreePop(); + } + + public static void TreeAdvanceToLabelPos() { + Native.TreeAdvanceToLabelPos(); + } + + public static float GetTreeNodeToLabelSpacing() { + return Native.GetTreeNodeToLabelSpacing(); + } + + public static void SetNextTreeNodeOpen(boolean is_open) { + Native.SetNextTreeNodeOpen(is_open); + } + + public static void SetNextTreeNodeOpen(boolean is_open, ImGuiCond cond) { + Native.SetNextTreeNodeOpen(is_open, cond.getValue()); + } + + public static boolean CollapsingHeader(String label) { + return Native.CollapsingHeader(label); + } + + public static boolean CollapsingHeader(String label, ImGuiTreeNodeFlags flags) { + return Native.CollapsingHeader(label, flags.getValue()); + } + + public static boolean CollapsingHeader(String label, ImGuiBoolean p_open) { + return Native.CollapsingHeader(label, p_open.data); + } + + public static boolean CollapsingHeader(String label, ImGuiBoolean p_open, ImGuiTreeNodeFlags flags) { + return Native.CollapsingHeader(label, p_open.data, flags.getValue()); + } + + + // Widgets: Selectables + // - A selectable highlights when hovered, and can display another color when selected. + // - Neighbors selectable extend their highlight bounds in order to leave no gap between them. + + public static boolean Selectable(String label) { + return Native.Selectable(label); + } + + public static boolean Selectable(String label, boolean selected) { + return Native.Selectable(label, selected); + } + + public static boolean Selectable(String label, boolean selected, int flags, float sizeX, float sizeY) { + return Native.Selectable(label, selected, flags, sizeX, sizeY); + } + + public static boolean Selectable(String label, ImGuiBoolean selected) { + return Native.Selectable(label, selected.data); + } + + public static boolean Selectable(String label, ImGuiBoolean selected, int flags, float sizeX, float sizeY) { + return Native.Selectable(label, selected.data, flags, sizeX, sizeY); + } + + // Widgets: List Boxes + // - FIXME: To be consistent with all the newer API, ListBoxHeader/ListBoxFooter should in reality be called BeginListBox/EndListBox. Will rename them. + + public static void ListBox(String label, ImGuiInt current_item, String[] items, int items_count) { + Native.ListBox(label, current_item.data, items, items_count); + } + + public static void ListBoxHeader(String label) { + Native.ListBoxHeader(label); + } + + public static void ListBoxHeader(String label, float sizeX, float sizeY) { + Native.ListBoxHeader(label, sizeX, sizeY); + } + + public static void ListBoxHeader(String label, int items_count) { + Native.ListBoxHeader(label, items_count); + } + + public static void ListBoxHeader(String label, int items_count, int height_in_items) { + Native.ListBoxHeader(label, items_count, height_in_items); + } + + // Widgets: Menus + + public static boolean BeginMainMenuBar() { + return Native.BeginMainMenuBar(); + } + + public static void EndMainMenuBar() { + Native.EndMainMenuBar(); + } + + public static boolean BeginMenuBar() { + return Native.BeginMenuBar(); + } + + public static void EndMenuBar() { + Native.EndMenuBar(); + } + + public static boolean BeginMenu(String label) { + return Native.BeginMenu(label); + } + + public static boolean BeginMenu(String label, boolean enabled) { + return Native.BeginMenu(label, enabled); + } + + public static void EndMenu() { + Native.EndMenu(); + } + + public static boolean MenuItem(String label) { + return Native.MenuItem(label); + } + + public static boolean MenuItem(String label, String shortcut, boolean selected, boolean enabled) { + return Native.MenuItem(label, shortcut, selected, enabled); + } + + public static boolean MenuItem(String label, String shortcut, ImGuiBoolean p_selected) { + return Native.MenuItem(label, shortcut, p_selected.data); + } + + public static boolean MenuItem(String label, String shortcut, ImGuiBoolean p_selected, boolean enabled) { + return Native.MenuItem(label, shortcut, p_selected.data, enabled); + } + + // Tooltips + + public static void BeginTooltip() { + Native.BeginTooltip(); + } + + public static void EndTooltip() { + Native.EndTooltip(); + } + + public static void SetTooltip(String text) { + Native.SetTooltip(text); + } + + // Popups, Modals + // The properties of popups windows are: + // - They block normal mouse hovering detection outside them. (*) + // - Unless modal, they can be closed by clicking anywhere outside them, or by pressing ESCAPE. + // - Their visibility state (~bool) is held internally by imgui instead of being held by the programmer as we are used to with regular Begin() calls. + // User can manipulate the visibility state by calling OpenPopup(). + // (*) One can use IsItemHovered(ImGuiHoveredFlags_AllowWhenBlockedByPopup) to bypass it and detect hovering even when normally blocked by a popup. + // Those three properties are connected. The library needs to hold their visibility state because it can close popups at any time. + + public static void OpenPopup(String str_id) { + Native.OpenPopup(str_id); + } + + public static boolean BeginPopup(String str_id) { + return Native.BeginPopup(str_id); + } + + public static boolean BeginPopup(String str_id, ImGuiWindowFlags flags) { + return Native.BeginPopup(str_id, flags.getValue()); + } + + public static boolean BeginPopupContextItem() { + return Native.BeginPopupContextItem(); + } + + public static boolean BeginPopupContextItem(String str_id, int mouse_button) { + return Native.BeginPopupContextItem(str_id, mouse_button); + } + + public static boolean BeginPopupContextWindow() { + return Native.BeginPopupContextWindow(); + } + + public static boolean BeginPopupContextWindow(String str_id, int mouse_button, boolean also_over_items) { + return Native.BeginPopupContextWindow(str_id, mouse_button, also_over_items); + } + + public static boolean BeginPopupContextVoid() { + return Native.BeginPopupContextVoid(); + } + + public static boolean BeginPopupContextVoid(String str_id, int mouse_button) { + return Native.BeginPopupContextVoid(str_id, mouse_button); + } + + public static boolean BeginPopupModal(String name) { + return Native.BeginPopupModal(name); + } + + public static boolean BeginPopupModal(String name, ImGuiBoolean p_open, ImGuiWindowFlags flags) { + return Native.BeginPopupModal(name, p_open.data, flags.getValue()); + } + + public static void EndPopup() { + Native.EndPopup(); + } + + public static boolean OpenPopupOnItemClick() { + return Native.OpenPopupOnItemClick(); + } + + public static boolean OpenPopupOnItemClick(String str_id, int mouse_button) { + return Native.OpenPopupOnItemClick(str_id, mouse_button); + } + + public static boolean IsPopupOpen(String str_id) { + return Native.IsPopupOpen(str_id); + } + + public static void CloseCurrentPopup() { + Native.CloseCurrentPopup(); + } + + // Columns + // - You can also use SameLine(pos_x) to mimic simplified columns. + // - The columns API is work-in-progress and rather lacking (columns are arguably the worst part of dear imgui at the moment!) + + public static void Columns() { + Native.Columns(); + } + + public static void Columns(int count) { + Native.Columns(count); + } + + public static void Columns(int count, String id) { + Native.Columns(count, id); + } + + public static void Columns(int count, String id, boolean border) { + Native.Columns(count, id, border); + } + + public static void NextColumn() { + Native.NextColumn(); + } + + public static int GetColumnIndex() { + return Native.GetColumnIndex(); + } + + public static float GetColumnWidth() { + return Native.GetColumnWidth(); + } + + public static float GetColumnWidth(int column_index) { + return Native.GetColumnWidth(column_index); + } + + public static void SetColumnWidth(int column_index, float width) { + Native.SetColumnWidth(column_index, width); + } + + public static float GetColumnOffset() { + return Native.GetColumnOffset(); + } + + public static float GetColumnOffset(int column_index) { + return Native.GetColumnOffset(column_index); + } + + public static void SetColumnOffset(int column_index, float offset_x) { + Native.SetColumnOffset(column_index, offset_x); + } + + public static int GetColumnsCount() { + return Native.GetColumnsCount(); + } + + // Tab Bars, Tabs + // [BETA API] API may evolve! + + public static boolean BeginTabBar(String str_id) { + return Native.BeginTabBar(str_id); + } + + public static boolean BeginTabBar(String str_id, ImGuiTabBarFlags flags) { + return Native.BeginTabBar(str_id, flags.getValue()); + } + + public static void EndTabBar() { + Native.EndTabBar(); + } + + public static boolean BeginTabItem(String label) { + return Native.BeginTabItem(label); + } + + public static boolean BeginTabItem(String label, ImGuiBoolean p_open, ImGuiTabItemFlags flags) { + return Native.BeginTabItem(label, p_open.data, flags.getValue()); + } + + public static void EndTabItem() { + Native.EndTabItem(); + } + + public static void SetTabItemClosed(String tab_or_docked_window_label) { + Native.SetTabItemClosed(tab_or_docked_window_label); + } + + // Docking + // [BETA API] Enable with io.ConfigFlags |= ImGuiConfigFlags_DockingEnable. + // Note: you DO NOT need to call DockSpace() to use most Docking facilities! + // To dock windows: if io.ConfigDockingWithShift == false: drag window from their title bar. + // To dock windows: if io.ConfigDockingWithShift == true: hold SHIFT anywhere while moving windows. + // Use DockSpace() to create an explicit dock node _within_ an existing window. See Docking demo for details. + + // TODO: Available after docking comes from BETA +// public static void DockSpace(int id) { +// Native.DockSpace(id); +// } + + // TODO: Available after docking comes from BETA +// public static void DockSpace(int id, float sizeX, float sizeY) { +// Native.DockSpace(id, sizeX, sizeY); +// } + + // TODO: Available after docking comes from BETA +// public static void DockSpace(int id, float sizeX, float sizeY, ImGuiDockNodeFlags flags) { +// Native.DockSpace(id, sizeX, sizeY, flags.getValue()); +// } + + // Focus, Activation + // - Prefer using "SetItemDefaultFocus()" over "if (IsWindowAppearing()) SetScrollHereY()" when applicable to signify "this is the default item" + + public static void SetItemDefaultFocus() { + Native.SetItemDefaultFocus(); + } + + public static void SetKeyboardFocusHere() { + Native.SetKeyboardFocusHere(); + } + + public static void SetKeyboardFocusHere(int offset) { + Native.SetKeyboardFocusHere(offset); + } + + // Item/Widgets Utilities + // - Most of the functions are referring to the last/previous item we submitted. + // - See Demo Window under "Widgets->Querying Status" for an interactive visualization of most of those functions. + + public static boolean IsItemHovered() { + return Native.IsItemHovered(); + } + + public static boolean IsItemHovered(ImGuiHoveredFlags flags) { + return Native.IsItemHovered(flags.getValue()); + } + + public static boolean IsItemActive() { + return Native.IsItemActive(); + } + + public static boolean IsItemFocused() { + return Native.IsItemFocused(); + } + + public static boolean IsItemClicked() { + return Native.IsItemClicked(); + } + + public static boolean IsItemClicked(int mouse_button) { + return Native.IsItemClicked(mouse_button); + } + + public static boolean IsItemVisible() { + return Native.IsItemVisible(); + } + + public static boolean IsItemEdited() { + return Native.IsItemEdited(); + } + + public static boolean IsItemActivated() { + return Native.IsItemActivated(); + } + + public static boolean IsItemDeactivated() { + return Native.IsItemDeactivated(); + } + + public static boolean IsItemDeactivatedAfterEdit() { + return Native.IsItemDeactivatedAfterEdit(); + } + + public static boolean IsAnyItemHovered() { + return Native.IsAnyItemHovered(); + } + + public static boolean IsAnyItemActive() { + return Native.IsAnyItemActive(); + } + + public static boolean IsAnyItemFocused() { + return Native.IsAnyItemFocused(); + } + + public static ImVec2 GetItemRectMin() { + Native.GetItemRectMin(imVec2); + return imVec2; + } + + public static ImVec2 GetItemRectMax() { + Native.GetItemRectMax(imVec2); + return imVec2; + } + + public static ImVec2 GetItemRectSize() { + Native.GetItemRectSize(imVec2); + return imVec2; + } + + public static void SetItemAllowOverlap() { + Native.SetItemAllowOverlap(); + } + + // Miscellaneous Utilities + + public static boolean BeginChildFrame(int id, float width, float height) { + return Native.BeginChildFrame(id, width, height); + } + + public static boolean BeginChildFrame(int id, float width, float height, ImGuiWindowFlags flags) { + return Native.BeginChildFrame(id, width, height, flags.getValue()); + } + + public static void EndChildFrame() { + Native.EndChildFrame(); + } + + // Inputs Utilities + + public static boolean IsMouseDown(int button) { + return Native.IsMouseDown(button); + } + + public static boolean IsMouseClicked(int button) { + return Native.IsMouseClicked(button); + } + + public static boolean IsMouseClicked(int button, boolean repeat) { + return Native.IsMouseClicked(button, repeat); + } + + public static boolean IsMouseReleased(int button) { + return Native.IsMouseReleased(button); + } + + public static boolean IsMouseDragging() { + return Native.IsMouseDragging(); + } + + public static boolean IsMouseDragging(int button) { + return Native.IsMouseDragging(button); + } + + public static boolean IsMouseDragging(int button, float lock_threshold) { + return Native.IsMouseDragging(button, lock_threshold); + } + + public static boolean IsMouseHoveringRect(float minX, float minY, float maxX, float maxY) { + return Native.IsMouseHoveringRect(minX, minY, maxX, maxY); + } + + public static boolean IsMouseHoveringRect(float minX, float minY, float maxX, float maxY, boolean clip) { + return Native.IsMouseHoveringRect(minX, minY, maxX, maxY, clip); + } + + // Internal methods + + public static void PushMultiItemsWidths(int components, float w_full) { + NativeInternal.PushMultiItemsWidths(components, w_full); + } + + public static void ItemAdd(float x1, float y1, float x2, float y2, String id) { + NativeInternal.ItemAdd(x1, y1, x2, y2, id); + } + + public static void ItemSize(float x1, float y1, float x2, float y2, float text_offset_y) { + NativeInternal.ItemSize(x1, y1, x2, y2, text_offset_y); + } +} diff --git a/imgui-binding/src/main/java/imgui/ImGuiBoolean.java b/imgui-binding/src/main/java/imgui/ImGuiBoolean.java new file mode 100644 index 0000000..72d405a --- /dev/null +++ b/imgui-binding/src/main/java/imgui/ImGuiBoolean.java @@ -0,0 +1,27 @@ +package imgui; + +public class ImGuiBoolean { + public static ImGuiBoolean TMP = new ImGuiBoolean(); + + boolean[] data = new boolean[]{false}; + + public ImGuiBoolean() { + } + + public ImGuiBoolean(boolean value) { + setValue(value); + } + + public boolean getValue() { + return this.data[0]; + } + + public void setValue(boolean value) { + this.data[0] = value; + } + + @Override + public String toString() { + return String.valueOf(getValue()); + } +} diff --git a/imgui-binding/src/main/java/imgui/ImGuiDouble.java b/imgui-binding/src/main/java/imgui/ImGuiDouble.java new file mode 100644 index 0000000..ede7da2 --- /dev/null +++ b/imgui-binding/src/main/java/imgui/ImGuiDouble.java @@ -0,0 +1,27 @@ +package imgui; + +public class ImGuiDouble { + public static ImGuiDouble TMP = new ImGuiDouble(); + + double[] data = new double[]{0.0d}; + + public ImGuiDouble() { + } + + public ImGuiDouble(double value) { + setValue(value); + } + + public double getValue() { + return this.data[0]; + } + + public void setValue(double value) { + this.data[0] = value; + } + + @Override + public String toString() { + return String.valueOf(getValue()); + } +} diff --git a/imgui-binding/src/main/java/imgui/ImGuiEx.java b/imgui-binding/src/main/java/imgui/ImGuiEx.java new file mode 100644 index 0000000..5d89842 --- /dev/null +++ b/imgui-binding/src/main/java/imgui/ImGuiEx.java @@ -0,0 +1,103 @@ +package imgui; + +import imgui.NativeCustomWidget.ImGuiCollapseLayoutOptions; + +public class ImGuiEx { + + protected ImGuiEx() { + } + + public static void ShowLayoutDebug() { + NativeCustomWidget.ShowLayoutDebug(); + } + + public static void BeginLayout(String id, float sizeX, float sizeY) { + NativeCustomWidget.BeginLayout(id, sizeX, sizeY); + } + + public static void BeginLayout(String id, float sizeX, float sizeY, float paddingLeft, float paddingRight, float paddingTop, float paddingBottom) { + NativeCustomWidget.BeginLayout(id, sizeX, sizeY, paddingLeft, paddingRight, paddingTop, paddingBottom); + } + + public static void EndLayout() { + NativeCustomWidget.EndLayout(); + } + + public static boolean BeginCollapseLayoutEx(String title, float sizeX, float sizeY) { + return NativeCustomWidget.BeginCollapseLayoutEx2(title, sizeX, sizeY, NativeCustomWidget.defaultOptions); + } + + public static boolean BeginCollapseLayoutEx(String title, float sizeX, float sizeY, ImGuiCollapseLayoutOptions options) { + return NativeCustomWidget.BeginCollapseLayoutEx2(title, sizeX, sizeY, options); + } + + public static void BeginCollapseLayoutEx(ImGuiBoolean isOpen, String title, float sizeX, float sizeY) { + NativeCustomWidget.BeginCollapseLayoutEx(isOpen.data, title, sizeX, sizeY, NativeCustomWidget.defaultOptions); + } + + public static void BeginCollapseLayoutEx(ImGuiBoolean isOpen, String title, float sizeX, float sizeY, ImGuiCollapseLayoutOptions options) { + NativeCustomWidget.BeginCollapseLayoutEx(isOpen.data, title, sizeX, sizeY, options); + } + + public static boolean BeginCollapseLayout(String title, float sizeX, float sizeY) { + return NativeCustomWidget.BeginCollapseLayout2(title, sizeX, sizeY, NativeCustomWidget.defaultOptions); + } + + public static boolean BeginCollapseLayout(String title, float sizeX, float sizeY, ImGuiCollapseLayoutOptions options) { + return NativeCustomWidget.BeginCollapseLayout2(title, sizeX, sizeY, options); + } + + public static void BeginCollapseLayout(ImGuiBoolean isOpen, String title, float sizeX, float sizeY) { + NativeCustomWidget.BeginCollapseLayout(isOpen.data, title, sizeX, sizeY, NativeCustomWidget.defaultOptions); + } + + public static void BeginCollapseLayout(ImGuiBoolean isOpen, String title, float sizeX, float sizeY, ImGuiCollapseLayoutOptions options) { + NativeCustomWidget.BeginCollapseLayout(isOpen.data, title, sizeX, sizeY, options); + } + + public static void EndCollapseFrameLayout() { + NativeCustomWidget.EndCollapseFrameLayout(); + } + + public static void EndCollapseLayout() { + NativeCustomWidget.EndCollapseLayout(); + } + + public static void BeginAlign(String id, float sizeX, float sizeY, float alignX, float alignY) { + NativeCustomWidget.BeginAlign(id, sizeX, sizeY, alignX, alignY); + } + + public static void BeginAlign(String id, float sizeX, float sizeY, float alignX, float alignY, float offsetX, float offsetY) { + NativeCustomWidget.BeginAlign(id, sizeX, sizeY, alignX, alignY, offsetX, offsetY); + } + + public static void EndAlign() { + NativeCustomWidget.EndAlign(); + } + + public static void AlignLayout(float alignX, float alignY) { + NativeCustomWidget.AlignLayout(alignX, alignY); + } + + public static void AlignLayout(float alignX, float alignY, float offsetX, float offsetY) { + NativeCustomWidget.AlignLayout(alignX, alignY, offsetX, offsetY); + } + + + // Helper methods + + /** + * Packs the color components into a 32-bit integer with the format ABGR. Note that no range checking is performed for higher + * performance. + * + * @param r the red component, 0 - 255 + * @param g the green component, 0 - 255 + * @param b the blue component, 0 - 255 + * @param a the alpha component, 0 - 255 + * @return the packed color as a 32-bit int + */ + public static int colorToIntBits(int r, int g, int b, int a) { + return (a << 24) | (b << 16) | (g << 8) | r; + } + +} diff --git a/imgui-binding/src/main/java/imgui/ImGuiFloat.java b/imgui-binding/src/main/java/imgui/ImGuiFloat.java new file mode 100644 index 0000000..36a25a5 --- /dev/null +++ b/imgui-binding/src/main/java/imgui/ImGuiFloat.java @@ -0,0 +1,27 @@ +package imgui; + +public class ImGuiFloat { + public static ImGuiFloat TMP = new ImGuiFloat(); + + float[] data = new float[]{0.0f}; + + public ImGuiFloat() { + } + + public ImGuiFloat(float value) { + setValue(value); + } + + public float getValue() { + return this.data[0]; + } + + public void setValue(float value) { + this.data[0] = value; + } + + @Override + public String toString() { + return String.valueOf(getValue()); + } +} diff --git a/imgui-binding/src/main/java/imgui/ImGuiIO.java b/imgui-binding/src/main/java/imgui/ImGuiIO.java new file mode 100644 index 0000000..c0de172 --- /dev/null +++ b/imgui-binding/src/main/java/imgui/ImGuiIO.java @@ -0,0 +1,35 @@ +package imgui; + +import imgui.enums.ImGuiConfigFlags; + +public class ImGuiIO { + + //------------------------------------------------------------------ + // Output - Retrieve after calling NewFrame() + //------------------------------------------------------------------ + + public boolean WantCaptureMouse; // When io.WantCaptureMouse is true, imgui will use the mouse inputs, do not dispatch them to your main game/application (in both cases, always pass on mouse inputs to imgui). (e.g. unclicked mouse is hovering over an imgui window, widget is active, mouse was clicked over an imgui window, etc.). + public boolean WantCaptureKeyboard; // When io.WantCaptureKeyboard is true, imgui will use the keyboard inputs, do not dispatch them to your main game/application (in both cases, always pass keyboard inputs to imgui). (e.g. InputText active, or an imgui window is focused and navigation is enabled, etc.). + public boolean WantTextInput; // Mobile/console: when io.WantTextInput is true, you may display an on-screen keyboard. This is set by ImGui when it wants textual keyboard input to happen (e.g. when a InputText widget is active). + public boolean WantSetMousePos; // MousePos has been altered, back-end should reposition mouse on next frame. Set only when ImGuiConfigFlags_NavEnableSetMousePos flag is enabled. + public boolean WantSaveIniSettings; // When manual .ini load/save is active (io.IniFilename == NULL), this will be set to notify your application that you can call SaveIniSettingsToMemory() and save yourself. IMPORTANT: You need to clear io.WantSaveIniSettings yourself. + public boolean NavActive; // Directional navigation is currently allowed (will handle ImGuiKey_NavXXX events) = a window is focused and it doesn't use the ImGuiWindowFlags_NoNavInputs flag. + public boolean NavVisible; // Directional navigation is visible and allowed (will handle ImGuiKey_NavXXX events). + public float Framerate; // Application framerate estimation, in frame per second. Solely for convenience. Rolling average estimation based on IO.DeltaTime over 120 frames + public int MetricsRenderVertices; // Vertices output during last call to Render() + public int MetricsRenderIndices; // Indices output during last call to Render() = number of triangles * 3 + public int MetricsRenderWindows; // Number of visible windows + public int MetricsActiveWindows; // Number of active windows + public int MetricsActiveAllocations; // Number of active allocations, updated by MemAlloc/MemFree based on current context. May be off if you have multiple imgui contexts. + public float MouseDeltaX; // Mouse delta. Note that this is zero if either current or previous position are invalid (-FLT_MAX,-FLT_MAX), so a disappearing/reappearing mouse won't have a huge delta. + public float MouseDeltaY; + + public void SetConfigFlags(ImGuiConfigFlags flags) { + Native.SetConfigFlags(flags.getValue()); + } + + // TODO: Available after docking comes from BETA +// public void SetDockingFlags(boolean ConfigDockingNoSplit, boolean ConfigDockingWithShift, boolean ConfigDockingAlwaysTabBar, boolean ConfigDockingTransparentPayload) { +// Native.SetDockingFlags(ConfigDockingNoSplit, ConfigDockingWithShift, ConfigDockingAlwaysTabBar, ConfigDockingTransparentPayload); +// } +} diff --git a/imgui-binding/src/main/java/imgui/ImGuiInputTextData.java b/imgui-binding/src/main/java/imgui/ImGuiInputTextData.java new file mode 100644 index 0000000..97f7f21 --- /dev/null +++ b/imgui-binding/src/main/java/imgui/ImGuiInputTextData.java @@ -0,0 +1,8 @@ +package imgui; + +public class ImGuiInputTextData { + public int size; + public int maxChar = -1; + public String allowedChar = ""; + boolean isDirty; +} diff --git a/imgui-binding/src/main/java/imgui/ImGuiInt.java b/imgui-binding/src/main/java/imgui/ImGuiInt.java new file mode 100644 index 0000000..40e1e0f --- /dev/null +++ b/imgui-binding/src/main/java/imgui/ImGuiInt.java @@ -0,0 +1,27 @@ +package imgui; + +public class ImGuiInt { + public static ImGuiInt TMP = new ImGuiInt(); + + int[] data = new int[]{0}; + + public ImGuiInt() { + } + + public ImGuiInt(int value) { + setValue(value); + } + + public int getValue() { + return this.data[0]; + } + + public void setValue(int value) { + this.data[0] = value; + } + + @Override + public String toString() { + return String.valueOf(getValue()); + } +} diff --git a/imgui-binding/src/main/java/imgui/ImGuiString.java b/imgui-binding/src/main/java/imgui/ImGuiString.java new file mode 100644 index 0000000..faff22e --- /dev/null +++ b/imgui-binding/src/main/java/imgui/ImGuiString.java @@ -0,0 +1,42 @@ +package imgui; + +public class ImGuiString { + public static ImGuiString TMP = new ImGuiString(); + final ImGuiInputTextData inputData = new ImGuiInputTextData(); + byte[] data; + private String text; + + public ImGuiString() { + this(100); + } + + public ImGuiString(int size) { + data = new byte[size]; + } + + public ImGuiString(String text) { + this(100); + setValue(text); + } + + public String getValue() { + if (inputData.isDirty) { + inputData.isDirty = false; + text = new String(data, 0, inputData.size); + } + return text; + } + + public void setValue(String value) { + inputData.size = value.length(); + text = value; + for (int i = 0; i < inputData.size; i++) { + data[i] = (byte) value.charAt(i); + } + } + + @Override + public String toString() { + return getValue(); + } +} diff --git a/imgui-binding/src/main/java/imgui/ImGuiStyle.java b/imgui-binding/src/main/java/imgui/ImGuiStyle.java new file mode 100644 index 0000000..f66466d --- /dev/null +++ b/imgui-binding/src/main/java/imgui/ImGuiStyle.java @@ -0,0 +1,7 @@ +package imgui; + +public class ImGuiStyle { + + public float ItemInnerSpacingX; + public float ItemInnerSpacingY; +} diff --git a/imgui-binding/src/main/java/imgui/ImVec2.java b/imgui-binding/src/main/java/imgui/ImVec2.java new file mode 100644 index 0000000..fb3b049 --- /dev/null +++ b/imgui-binding/src/main/java/imgui/ImVec2.java @@ -0,0 +1,15 @@ +package imgui; + +public class ImVec2 { + public static ImVec2 TMP = new ImVec2(); + public float x; + public float y; + + public ImVec2() { + } + + public ImVec2(float x, float y) { + this.x = x; + this.y = y; + } +} diff --git a/imgui-binding/src/main/java/imgui/ImVec4.java b/imgui-binding/src/main/java/imgui/ImVec4.java new file mode 100644 index 0000000..ad156aa --- /dev/null +++ b/imgui-binding/src/main/java/imgui/ImVec4.java @@ -0,0 +1,8 @@ +package imgui; + +public class ImVec4 extends ImVec2 { + public static ImVec4 TMP = new ImVec4(); + + public float z; + public float w; +} diff --git a/imgui-binding/src/main/java/imgui/Native.java b/imgui-binding/src/main/java/imgui/Native.java new file mode 100644 index 0000000..7ea9aff --- /dev/null +++ b/imgui-binding/src/main/java/imgui/Native.java @@ -0,0 +1,2126 @@ +package imgui; + +import java.nio.Buffer; + +/** + * The bridge between Java and native APIs. + * Class itself used by "gdx-jnigen" util to generate JNI headers. + */ +class Native { + // @formatter:off + + /*JNI + #include + #include + + jfieldID totalVtxCountID; + jfieldID totalIdxCountID; + jfieldID totalCmdCountID; + jfieldID CmdListsCountID; + jfieldID displayPosXID; + jfieldID displayPosYID; + jfieldID displaySizeXID; + jfieldID displaySizeYID; + jfieldID framebufferScaleXID; + jfieldID framebufferScaleYID; + + // ImGuiIO + + jfieldID WantCaptureMouseID; + jfieldID WantCaptureKeyboardID; + jfieldID WantTextInputID; + jfieldID WantSetMousePosID; + jfieldID WantSaveIniSettingsID; + jfieldID NavActiveID; + jfieldID NavVisibleID; + jfieldID FramerateID; + jfieldID MetricsRenderVerticesID; + jfieldID MetricsRenderIndicesID; + jfieldID MetricsRenderWindowsID; + jfieldID MetricsActiveWindowsID; + jfieldID MetricsActiveAllocationsID; + jfieldID MouseDeltaXID; + jfieldID MouseDeltaYID; + + // ImGuiStyle + + jfieldID ItemInnerSpacingXID; + jfieldID ItemInnerSpacingYID; + + jfieldID imVec2XID; + jfieldID imVec2YID; + jfieldID imVec4ZID; + jfieldID imVec4WID; + + jfieldID imTextInputDataSizeID; + jfieldID imTextInputDataIsDirtyID; + + static int DRAWLIST_TYPE_DEFAULT = 0; + static int DRAWLIST_TYPE_BACKGROUND = 1; + static int DRAWLIST_TYPE_FOREGROUND = 2; + */ + + private Native() {} + + static native void init() /*-{ }-*/; /* + jclass jDrawDataClass = env->FindClass("imgui/DrawData"); + jclass jImGuiIOClass = env->FindClass("imgui/ImGuiIO"); + jclass jImGuiStyleClass = env->FindClass("imgui/ImGuiStyle"); + jclass jImVec2Class = env->FindClass("imgui/ImVec2"); + jclass jImVec4Class = env->FindClass("imgui/ImVec4"); + jclass jImInputTextDataClass = env->FindClass("imgui/ImGuiInputTextData"); + + // DrawData Prepare IDs + totalVtxCountID = env->GetFieldID(jDrawDataClass, "totalVtxCount", "I"); + totalIdxCountID = env->GetFieldID(jDrawDataClass, "totalIdxCount", "I"); + totalCmdCountID = env->GetFieldID(jDrawDataClass, "totalCmdCount", "I"); + CmdListsCountID = env->GetFieldID(jDrawDataClass, "cmdListsCount", "I"); + displayPosXID = env->GetFieldID(jDrawDataClass, "displayPosX", "F"); + displayPosYID = env->GetFieldID(jDrawDataClass, "displayPosY", "F"); + displaySizeXID = env->GetFieldID(jDrawDataClass, "displaySizeX", "F"); + displaySizeYID = env->GetFieldID(jDrawDataClass, "displaySizeY", "F"); + framebufferScaleXID = env->GetFieldID(jDrawDataClass, "framebufferScaleX", "F"); + framebufferScaleYID = env->GetFieldID(jDrawDataClass, "framebufferScaleY", "F"); + + // ImGuiIO Prepare IDs + + WantCaptureMouseID = env->GetFieldID(jImGuiIOClass, "WantCaptureMouse", "Z"); + WantCaptureKeyboardID = env->GetFieldID(jImGuiIOClass, "WantCaptureKeyboard", "Z"); + WantTextInputID = env->GetFieldID(jImGuiIOClass, "WantTextInput", "Z"); + WantSetMousePosID = env->GetFieldID(jImGuiIOClass, "WantSetMousePos", "Z"); + WantSaveIniSettingsID = env->GetFieldID(jImGuiIOClass, "WantSaveIniSettings", "Z"); + NavActiveID = env->GetFieldID(jImGuiIOClass, "NavActive", "Z"); + NavVisibleID = env->GetFieldID(jImGuiIOClass, "NavVisible", "Z"); + FramerateID = env->GetFieldID(jImGuiIOClass, "Framerate", "F"); + MetricsRenderVerticesID = env->GetFieldID(jImGuiIOClass, "MetricsRenderVertices", "I"); + MetricsRenderIndicesID = env->GetFieldID(jImGuiIOClass, "MetricsRenderIndices", "I"); + MetricsRenderWindowsID = env->GetFieldID(jImGuiIOClass, "MetricsRenderWindows", "I"); + MetricsActiveWindowsID = env->GetFieldID(jImGuiIOClass, "MetricsActiveWindows", "I"); + MetricsActiveAllocationsID = env->GetFieldID(jImGuiIOClass, "MetricsActiveAllocations", "I"); + MouseDeltaXID = env->GetFieldID(jImGuiIOClass, "MouseDeltaX", "F"); + MouseDeltaYID = env->GetFieldID(jImGuiIOClass, "MouseDeltaY", "F"); + + // ImGuiStyle Prepare IDs + + ItemInnerSpacingXID = env->GetFieldID(jImGuiStyleClass, "ItemInnerSpacingX", "F"); + ItemInnerSpacingYID = env->GetFieldID(jImGuiStyleClass, "ItemInnerSpacingY", "F"); + + //ImVec2 Prepare IDs + + imVec2XID = env->GetFieldID(jImVec2Class, "x", "F"); + imVec2YID = env->GetFieldID(jImVec2Class, "y", "F"); + + //ImVec4 Prepare IDs + + imVec4ZID = env->GetFieldID(jImVec4Class, "z", "F"); + imVec4WID = env->GetFieldID(jImVec4Class, "w", "F"); + + imTextInputDataSizeID = env->GetFieldID(jImInputTextDataClass, "size", "I"); + imTextInputDataIsDirtyID = env->GetFieldID(jImInputTextDataClass, "isDirty", "Z"); + */ + + static native void CreateContext() /*-{ }-*/; /* + ImGui::CreateContext(); + ImGui::GetIO().IniFilename = NULL; + ImGui::GetIO().BackendFlags |= ImGuiBackendFlags_HasMouseCursors; + */ + + static native void initKeyMap(int [] keys) /*-{ }-*/; /* + ImGuiIO& io = ImGui::GetIO(); + + for(int i = 0; i < ImGuiKey_COUNT; i++) { + io.KeyMap[i] = keys[i]; + } + */ + + static native void SetConfigFlags(int flag) /*-{ }-*/; /* + ImGuiIO& io = ImGui::GetIO(); + io.ConfigFlags = flag; + */ + + // TODO: Available after docking comes from BETA +// static native void SetDockingFlags(boolean ConfigDockingNoSplit, boolean ConfigDockingWithShift, boolean ConfigDockingAlwaysTabBar, boolean ConfigDockingTransparentPayload) /*-{ }-*/; /* +// ImGuiIO& io = ImGui::GetIO(); +// io.ConfigDockingNoSplit = ConfigDockingNoSplit; +// io.ConfigDockingWithShift = ConfigDockingWithShift; +// io.ConfigDockingAlwaysTabBar = ConfigDockingAlwaysTabBar; +// io.ConfigDockingTransparentPayload = ConfigDockingTransparentPayload; +// */ + + static native void UpdateDisplayAndInputAndFrame(ImGuiIO jImguiIO, ImGuiStyle jImguiStyle, float deltaTime, float w, float h, float display_w, float display_h, + float mouseX, float mouseY, boolean mouseDown0, boolean mouseDown1, boolean mouseDown2, boolean mouseDown3, boolean mouseDown4, boolean mouseDown5) /*-{ }-*/; /* + ImGuiIO& io = ImGui::GetIO(); + + io.DisplaySize = ImVec2(w, h); + if (w > 0 && h > 0) + io.DisplayFramebufferScale = ImVec2((float)display_w / w, (float)display_h / h); + io.DeltaTime = deltaTime; + + bool m0 = mouseDown0; + bool m1 = mouseDown1; + bool m2 = mouseDown2; + bool m3 = mouseDown3; + bool m4 = mouseDown4; + bool m5 = mouseDown5; + + io.MouseDown[0] = m0; + io.MouseDown[1] = m1; + io.MouseDown[2] = m2; + io.MouseDown[3] = m3; + io.MouseDown[4] = m4; + io.MouseDown[5] = m5; + + if (io.WantSetMousePos) { + } + else { + io.MousePos = ImVec2(mouseX, mouseY); + } + + ImGui::NewFrame(); + + // Update ImGuiIO + env->SetBooleanField (jImguiIO, WantCaptureMouseID, io.WantCaptureMouse); + env->SetBooleanField (jImguiIO, WantCaptureKeyboardID, io.WantCaptureKeyboard); + env->SetBooleanField (jImguiIO, WantTextInputID, io.WantTextInput); + env->SetBooleanField (jImguiIO, WantSetMousePosID, io.WantSetMousePos); + env->SetBooleanField (jImguiIO, WantSaveIniSettingsID, io.WantSaveIniSettings); + env->SetBooleanField (jImguiIO, NavActiveID, io.NavActive); + env->SetBooleanField (jImguiIO, NavVisibleID, io.NavVisible); + env->SetBooleanField (jImguiIO, FramerateID, io.Framerate); + env->SetBooleanField (jImguiIO, MetricsRenderVerticesID, io.MetricsRenderVertices); + env->SetBooleanField (jImguiIO, MetricsRenderIndicesID, io.MetricsRenderIndices); + env->SetBooleanField (jImguiIO, MetricsRenderWindowsID, io.MetricsRenderWindows); + env->SetBooleanField (jImguiIO, MetricsActiveWindowsID, io.MetricsActiveWindows); + env->SetBooleanField (jImguiIO, MetricsActiveAllocationsID, io.MetricsActiveAllocations); + env->SetBooleanField (jImguiIO, MouseDeltaXID, io.MouseDelta.x); + + // Update ImGuiStyle + + ImGuiStyle & style = ImGui::GetStyle(); + + env->SetFloatField (jImguiStyle, ItemInnerSpacingXID, style.ItemInnerSpacing.x); + env->SetFloatField (jImguiStyle, ItemInnerSpacingYID, style.ItemInnerSpacing.y); + */ + + static native void updateKey(int key, boolean pressed, boolean released, boolean ctrlKey, boolean shiftKey, boolean altKey, boolean superKey) /*-{ }-*/; /* + ImGuiIO& io = ImGui::GetIO(); + if (pressed) + io.KeysDown[key] = true; + if (released) + io.KeysDown[key] = false; + io.KeyCtrl = ctrlKey; + io.KeyShift = shiftKey; + io.KeyAlt = altKey; + io.KeySuper = superKey; + */ + + static native void updateScroll(float amountX, float amountY) /*-{ }-*/; /* + ImGuiIO& io = ImGui::GetIO(); + io.MouseWheelH -= amountX; + io.MouseWheel -= amountY; + */ + + static native void updateKeyTyped(int c) /*-{ }-*/; /* + ImGuiIO& io = ImGui::GetIO(); + if (c > 0 && c < 0x10000) + io.AddInputCharacter((unsigned short)c); + */ + + static native void Render() /*-{ }-*/; /* + ImGui::Render(); + */ + + static native void ShowStyleEditor() /*-{ }-*/; /* + ImGui::ShowStyleEditor(); + */ + + static native void ShowDemoWindow() /*-{ }-*/; /* + ImGui::ShowDemoWindow(); + */ + + static native void ShowDemoWindow(boolean open) /*-{ }-*/; /* + bool toOpen = open; + ImGui::ShowDemoWindow(&toOpen); + */ + + static native void ShowMetricsWindow() /*-{ }-*/; /* + ImGui::ShowMetricsWindow(); + */ + + static native void ShowMetricsWindow(boolean open) /*-{ }-*/; /* + bool toOpen = open; + ImGui::ShowMetricsWindow(&toOpen); + */ + + static native void GetTexDataAsRGBA32(TexDataRGBA32 jTexData, Buffer pixelBuffer) /*-{ }-*/; /* + jclass jTexDataClass = env->GetObjectClass(jTexData); + if(jTexDataClass == NULL) + return; + + jfieldID widthID = env->GetFieldID(jTexDataClass, "width", "I"); + jfieldID heightID = env->GetFieldID(jTexDataClass, "height", "I"); + + unsigned char* pixels; + int width, height; + + ImGuiIO& io = ImGui::GetIO(); + io.Fonts->GetTexDataAsRGBA32(&pixels, &width, &height); + + env->SetIntField (jTexData, widthID, width); + env->SetIntField (jTexData, heightID, height); + + memcpy(pixelBuffer, pixels, width * height * 4); + */ + + static native void SetFontTexID(int id) /*-{ }-*/; /* + ImGuiIO& io = ImGui::GetIO(); + io.Fonts->TexID = (ImTextureID)id; + */ + + static native void GetDrawData(DrawData jDrawData, Buffer indexBuffer, Buffer vertexBuffer, Buffer cmdBuffer) /*-{ }-*/; /* + ImDrawData * drawData = ImGui::GetDrawData(); + + if(drawData != NULL) { + int cmdListsCount = drawData->CmdListsCount; + + // Set values + env->SetIntField (jDrawData, totalVtxCountID, drawData->TotalVtxCount); + env->SetIntField (jDrawData, totalIdxCountID, drawData->TotalIdxCount); + env->SetIntField (jDrawData, CmdListsCountID, cmdListsCount); + + env->SetFloatField (jDrawData, displayPosXID, drawData->DisplayPos.x); + env->SetFloatField (jDrawData, displayPosYID, drawData->DisplayPos.y); + + env->SetFloatField (jDrawData, displaySizeXID, drawData->DisplaySize.x); + env->SetFloatField (jDrawData, displaySizeYID, drawData->DisplaySize.y); + + env->SetFloatField (jDrawData, framebufferScaleXID, drawData->FramebufferScale.x); + env->SetFloatField (jDrawData, framebufferScaleYID, drawData->FramebufferScale.y); + + ImDrawList** drawLists = drawData->CmdLists; + + int verticeOffset = 0; + int indicesOffset = 0; + int cmdOffset = 0; + int cmdCount = 0; + + for(int i = 0; i < cmdListsCount; i++) { + ImDrawList & drawList = *drawLists[i]; + ImVector & imDrawCmdList = drawList.CmdBuffer; + ImVector & idxBuffer = drawList.IdxBuffer; + ImVector & vtxBuffer = drawList.VtxBuffer; + + int verticeSize = sizeof(ImDrawVert); + int indicesSize = sizeof(ImDrawIdx); + + float * vertexArraySource = (float *)vtxBuffer.Data; + short * indexArraySource = (short *)idxBuffer.Data; + float * vertexArrayDest = (float *)vertexBuffer; + short * indexArrayDest = (short *)indexBuffer; + + int colorSize = 1; + + int verticeItemSize = (4 + colorSize); + + vertexArrayDest[verticeOffset++] = vtxBuffer.Size; + // copy vertices to Destination buffer + for(int j = 0; j < vtxBuffer.Size; j++) { + ImDrawVert v = vtxBuffer[j]; + float posX = v.pos.x; + float posY = v.pos.y; + float uvX = v.uv.x; + float uvY = v.uv.y; + + int byteIndex = (j * verticeItemSize) + verticeOffset; + + float color = 0; + memcpy(&color, &v.col, 4); // move unsigned int color to float + + vertexArrayDest[byteIndex + 0] = posX; + vertexArrayDest[byteIndex + 1] = posY; + vertexArrayDest[byteIndex + 2] = uvX; + vertexArrayDest[byteIndex + 3] = uvY; + vertexArrayDest[byteIndex + 4] = color; + } + verticeOffset += vtxBuffer.Size * verticeItemSize; + + // copy index to destination buffer + indexArrayDest[indicesOffset++] = idxBuffer.Size; + for(int j = 0; j < idxBuffer.Size; j++) { + + indexArrayDest[j + indicesOffset] = idxBuffer[j]; + } + indicesOffset += idxBuffer.Size; + + float * cmdArrayDest = (float *)cmdBuffer; + + cmdArrayDest[cmdOffset++] = imDrawCmdList.Size; + int bytesOffset = 0; + int imDrawCmdSize = 1 + 4 + 1; + for (int cmd_i = 0; cmd_i < imDrawCmdList.Size; cmd_i++) { + const ImDrawCmd * pcmd = &imDrawCmdList[cmd_i]; + + float textureID = (float)(intptr_t)pcmd->TextureId; + float tempArray [6] = { + pcmd->ElemCount, + pcmd->ClipRect.x, + pcmd->ClipRect.y, + pcmd->ClipRect.z, + pcmd->ClipRect.w, + textureID + }; + + memcpy((cmdArrayDest + (cmd_i * imDrawCmdSize) + cmdOffset), tempArray, imDrawCmdSize * 4); + bytesOffset = bytesOffset + imDrawCmdSize; + } + cmdOffset += imDrawCmdList.Size * imDrawCmdSize; + cmdCount += imDrawCmdList.Size; + } + + env->SetIntField (jDrawData, totalCmdCountID, cmdCount); + } + */ + + static native void StyleColorsDark() /*-{ }-*/; /* + ImGui::StyleColorsDark(); + */ + + static native void StyleColorsClassic() /*-{ }-*/; /* + ImGui::StyleColorsClassic(); + */ + + static native void StyleColorsLight() /*-{ }-*/; /* + ImGui::StyleColorsLight(); + */ + + static native boolean Begin(String title) /*-{ }-*/; /* + return ImGui::Begin(title); + */ + + static native boolean Begin(String title, boolean [] p_open, int imGuiWindowFlags) /*-{ }-*/; /* + return ImGui::Begin(title, &p_open[0], imGuiWindowFlags); + */ + + static native void End() /*-{ }-*/; /* + ImGui::End(); + */ + + static native boolean BeginChild(String str_id) /*-{ }-*/; /* + return ImGui::BeginChild(str_id); + */ + + static native boolean BeginChild(String str_id, float width, float height) /*-{ }-*/; /* + return ImGui::BeginChild(str_id, ImVec2(width, height)); + */ + + static native boolean BeginChild(String str_id, float width, float height, boolean border) /*-{ }-*/; /* + return ImGui::BeginChild(str_id, ImVec2(width, height), border); + */ + + static native boolean BeginChild(String str_id, float width, float height, boolean border, int flags) /*-{ }-*/; /* + return ImGui::BeginChild(str_id, ImVec2(width, height), border, flags); + */ + + static native boolean BeginChild(int imGuiID) /*-{ }-*/; /* + return ImGui::BeginChild(imGuiID); + */ + + static native boolean BeginChild(int imGuiID, float width, float height, boolean border) /*-{ }-*/; /* + return ImGui::BeginChild(imGuiID, ImVec2(width, height), border); + */ + + static native boolean BeginChild(int imGuiID, float width, float height, boolean border, int flags) /*-{ }-*/; /* + return ImGui::BeginChild(imGuiID, ImVec2(width, height), border, flags); + */ + + static native void EndChild() /*-{ }-*/; /* + ImGui::EndChild(); + */ + + static native boolean IsWindowAppearing() /*-{ }-*/; /* + return ImGui::IsWindowAppearing(); + */ + + static native boolean IsWindowCollapsed() /*-{ }-*/; /* + return ImGui::IsWindowCollapsed(); + */ + + static native boolean IsWindowFocused() /*-{ }-*/; /* + return ImGui::IsWindowFocused(); + */ + + static native boolean IsWindowFocused(int flags) /*-{ }-*/; /* + return ImGui::IsWindowFocused(flags); + */ + + static native boolean IsWindowHovered() /*-{ }-*/; /* + return ImGui::IsWindowHovered(); + */ + + // DrawList + + /*JNI + ImDrawList * getDrawList(int type) { + ImDrawList* drawList = NULL; + if(type == DRAWLIST_TYPE_DEFAULT) + drawList = ImGui::GetWindowDrawList(); + else if(type == DRAWLIST_TYPE_BACKGROUND) + drawList = ImGui::GetBackgroundDrawList(); + else if(type == DRAWLIST_TYPE_FOREGROUND) + drawList = ImGui::GetForegroundDrawList(); + return drawList; + } + + */ + + static native boolean IsWindowHovered(int flags) /*-{ }-*/; /* + return ImGui::IsWindowHovered(flags); + */ + + static native boolean AddLine(int type, float a_x, float a_y, float b_x, float b_y, int col) /*-{ }-*/; /* + ImDrawList* drawList = getDrawList(type); + drawList->AddLine(ImVec2(a_x, a_y), ImVec2(b_x, b_y), col); + */ + + static native boolean AddLine(int type, float a_x, float a_y, float b_x, float b_y, int col, float thinkness) /*-{ }-*/; /* + ImDrawList* drawList = getDrawList(type); + drawList->AddLine(ImVec2(a_x, a_y), ImVec2(b_x, b_y), col, thinkness); + */ + + static native boolean AddRect(int type, float a_x, float a_y, float b_x, float b_y, int col) /*-{ }-*/; /* + ImDrawList* drawList = getDrawList(type); + drawList->AddRect(ImVec2(a_x, a_y), ImVec2(b_x, b_y), col); + */ + + static native boolean AddRect(int type, float a_x, float a_y, float b_x, float b_y, int col, float rounding) /*-{ }-*/; /* + ImDrawList* drawList = getDrawList(type); + drawList->AddRect(ImVec2(a_x, a_y), ImVec2(b_x, b_y), col, rounding); + */ + + static native boolean AddRect(int type, float a_x, float a_y, float b_x, float b_y, int col, float rounding, int rounding_corners_flags) /*-{ }-*/; /* + ImDrawList* drawList = getDrawList(type); + drawList->AddRect(ImVec2(a_x, a_y), ImVec2(b_x, b_y), col, rounding, rounding_corners_flags); + */ + + static native boolean AddRect(int type, float a_x, float a_y, float b_x, float b_y, int col, float rounding, int rounding_corners_flags, float thickness) /*-{ }-*/; /* + ImDrawList* drawList = getDrawList(type); + drawList->AddRect(ImVec2(a_x, a_y), ImVec2(b_x, b_y), col, rounding, rounding_corners_flags, thickness); + */ + + static native boolean AddRectFilled(int type, float a_x, float a_y, float b_x, float b_y, int col) /*-{ }-*/; /* + ImDrawList* drawList = getDrawList(type); + drawList->AddRectFilled(ImVec2(a_x, a_y), ImVec2(b_x, b_y), col); + */ + + static native boolean AddRectFilled(int type, float a_x, float a_y, float b_x, float b_y, int col, float rounding) /*-{ }-*/; /* + ImDrawList* drawList = getDrawList(type); + drawList->AddRectFilled(ImVec2(a_x, a_y), ImVec2(b_x, b_y), col, rounding); + */ + + static native boolean AddRectFilled(int type, float a_x, float a_y, float b_x, float b_y, int col, float rounding, int rounding_corners_flags) /*-{ }-*/; /* + ImDrawList* drawList = getDrawList(type); + drawList->AddRectFilled(ImVec2(a_x, a_y), ImVec2(b_x, b_y), col, rounding, rounding_corners_flags); + */ + + static native boolean AddRectFilledMultiColor(int type, float a_x, float a_y, float b_x, float b_y, int col_upr_left, float col_upr_right, int col_bot_right, int col_bot_left) /*-{ }-*/; /* + ImDrawList* drawList = getDrawList(type); + drawList->AddRectFilledMultiColor(ImVec2(a_x, a_y), ImVec2(b_x, b_y), col_upr_left, col_upr_right, col_bot_right, col_bot_left); + */ + + static native boolean AddQuad(int type, float a_x, float a_y, float b_x, float b_y, float c_x, float c_y, float d_x, float d_y, int col) /*-{ }-*/; /* + ImDrawList* drawList = getDrawList(type); + drawList->AddQuad(ImVec2(a_x, a_y), ImVec2(b_x, b_y), ImVec2(c_x, c_y), ImVec2(d_x, d_y), col); + */ + + static native boolean AddQuad(int type, float a_x, float a_y, float b_x, float b_y, float c_x, float c_y, float d_x, float d_y, int col, float thickness) /*-{ }-*/; /* + ImDrawList* drawList = getDrawList(type); + drawList->AddQuad(ImVec2(a_x, a_y), ImVec2(b_x, b_y), ImVec2(c_x, c_y), ImVec2(d_x, d_y), col, thickness); + */ + + static native boolean AddQuadFilled(int type, float a_x, float a_y, float b_x, float b_y, float c_x, float c_y, float d_x, float d_y, int col) /*-{ }-*/; /* + ImDrawList* drawList = getDrawList(type); + drawList->AddQuadFilled(ImVec2(a_x, a_y), ImVec2(b_x, b_y), ImVec2(c_x, c_y), ImVec2(d_x, d_y), col); + */ + + static native boolean AddTriangle(int type, float a_x, float a_y, float b_x, float b_y, float c_x, float c_y, int col) /*-{ }-*/; /* + ImDrawList* drawList = getDrawList(type); + drawList->AddTriangle(ImVec2(a_x, a_y), ImVec2(b_x, b_y), ImVec2(c_x, c_y), col); + */ + + static native boolean AddTriangle(int type, float a_x, float a_y, float b_x, float b_y, float c_x, float c_y, int col, float thickness) /*-{ }-*/; /* + ImDrawList* drawList = getDrawList(type); + drawList->AddTriangle(ImVec2(a_x, a_y), ImVec2(b_x, b_y), ImVec2(c_x, c_y), col, thickness); + */ + + static native boolean AddTriangleFilled(int type, float a_x, float a_y, float b_x, float b_y, float c_x, float c_y, int col) /*-{ }-*/; /* + ImDrawList* drawList = getDrawList(type); + drawList->AddTriangleFilled(ImVec2(a_x, a_y), ImVec2(b_x, b_y), ImVec2(c_x, c_y), col); + */ + + static native boolean AddCircle(int type, float centre_x, float centre_y, float radius, float col) /*-{ }-*/; /* + ImDrawList* drawList = getDrawList(type); + drawList->AddCircle(ImVec2(centre_x, centre_y), radius, col); + */ + + static native boolean AddCircle(int type, float centre_x, float centre_y, float radius, float col, int num_segments, float thickness) /*-{ }-*/; /* + ImDrawList* drawList = getDrawList(type); + drawList->AddCircle(ImVec2(centre_x, centre_y), radius, col, num_segments, thickness); + */ + + static native boolean AddCircleFilled(int type, float centre_x, float centre_y, float radius, float col) /*-{ }-*/; /* + ImDrawList* drawList = getDrawList(type); + drawList->AddCircleFilled(ImVec2(centre_x, centre_y), radius, col); + */ + + static native boolean AddCircleFilled(int type, float centre_x, float centre_y, float radius, float col, int num_segments) /*-{ }-*/; /* + ImDrawList* drawList = getDrawList(type); + drawList->AddCircleFilled(ImVec2(centre_x, centre_y), radius, col, num_segments); + */ + + static native boolean AddText(int type, float pos_x, float pos_y, int col, String text_begin) /*-{ }-*/; /* + ImDrawList* drawList = getDrawList(type); + drawList->AddText(ImVec2(pos_x, pos_y), col, text_begin); + */ + + // TODO AddText + + static native boolean AddText(int type, float pos_x, float pos_y, int col, String text_begin, String text_end) /*-{ }-*/; /* + ImDrawList* drawList = getDrawList(type); + drawList->AddText(ImVec2(pos_x, pos_y), col, text_begin, text_end); + */ + + static native boolean AddImage(int type, int textureID, float a_x, float a_y, float b_x, float b_y) /*-{ }-*/; /* + ImDrawList* drawList = getDrawList(type); + drawList->AddImage((void *)textureID, ImVec2(a_x, a_y), ImVec2(b_x, b_y)); + */ + + //TODO AddImageQuad, AddImageRounded, AddPolyline, AddConvexPolyFilled + + static native boolean AddImage(int type, int textureID, float a_x, float a_y, float b_x, float b_y, float uv_a_x, float uv_a_y, float uv_b_x, float uv_b_y) /*-{ }-*/; /* + ImDrawList* drawList = getDrawList(type); + drawList->AddImage((void *)textureID, ImVec2(a_x, a_y), ImVec2(b_x, b_y), ImVec2(uv_a_x, uv_a_y), ImVec2(uv_b_x, uv_b_y)); + */ + + static native boolean AddBezierCurve(int type, float pos0_x, float pos0_y, float cp0_x, float cp0_y, float cp1_x, float cp1_y, float pos1_x, float pos1_y, float col, float thickness) /*-{ }-*/; /* + ImDrawList* drawList = getDrawList(type); + drawList->AddBezierCurve(ImVec2(pos0_x, pos0_y), ImVec2(cp0_x, cp0_y), ImVec2(cp1_x, cp1_y), ImVec2(pos1_x, pos1_y), col, thickness); + */ + + static native boolean AddBezierCurve(int type, float pos0_x, float pos0_y, float cp0_x, float cp0_y, float cp1_x, float cp1_y, float pos1_x, float pos1_y, float col, float thickness, int num_segments) /*-{ }-*/; /* + ImDrawList* drawList = getDrawList(type); + drawList->AddBezierCurve(ImVec2(pos0_x, pos0_y), ImVec2(cp0_x, cp0_y), ImVec2(cp1_x, cp1_y), ImVec2(pos1_x, pos1_y), col, thickness, num_segments); + */ + + static native void ChannelsSplit(int type, int count) /*-{ }-*/; /* + ImDrawList* drawList = getDrawList(type); + drawList->ChannelsSplit(count); + */ + + static native void ChannelsMerge(int type) /*-{ }-*/; /* + ImDrawList* drawList = getDrawList(type); + drawList->ChannelsMerge(); + */ + + static native void ChannelsSetCurrent(int type, int n) /*-{ }-*/; /* + ImDrawList* drawList = getDrawList(type); + drawList->ChannelsSetCurrent(n); + */ + + static native void GetWindowPos(ImVec2 jImVec2) /*-{ }-*/; /* + ImVec2 vec = ImGui::GetWindowPos(); + env->SetFloatField (jImVec2, imVec2XID, vec.x); + env->SetFloatField (jImVec2, imVec2YID, vec.y); + */ + + static native float GetWindowPosX() /*-{ }-*/; /* + return ImGui::GetWindowPos().x; + */ + + static native float GetWindowPosY() /*-{ }-*/; /* + return ImGui::GetWindowPos().y; + */ + + static native void GetWindowSize(ImVec2 jImVec2) /*-{ }-*/; /* + ImVec2 vec = ImGui::GetWindowSize(); + env->SetFloatField (jImVec2, imVec2XID, vec.x); + env->SetFloatField (jImVec2, imVec2YID, vec.y); + */ + + static native float GetWindowWidth() /*-{ }-*/; /* + return ImGui::GetWindowWidth(); + */ + + // Prefer using SetNextXXX functions (before Begin) rather that SetXXX functions (after Begin). + + public static native float GetWindowHeight() /*-{ }-*/; /* + return ImGui::GetWindowHeight(); + */ + + static native void SetNextWindowPos(float x, float y) /*-{ }-*/; /* + ImGui::SetNextWindowPos(ImVec2(x, y)); + */ + + static native void SetNextWindowPos(float x, float y, int cond, float pivot_x, float pivot_y) /*-{ }-*/; /* + ImGui::SetNextWindowPos(ImVec2(x, y), cond, ImVec2(pivot_x, pivot_y)); + */ + + static native void SetNextWindowSize(float width, float height) /*-{ }-*/; /* + ImGui::SetNextWindowSize(ImVec2(width, height)); + */ + + static native void SetNextWindowSize(float width, float height, int cond) /*-{ }-*/; /* + ImGui::SetNextWindowSize(ImVec2(width, height), cond); + */ + + static native void SetNextWindowSizeConstraints(float min_width, float min_height, float max_width, float max_height) /*-{ }-*/; /* + ImGui::SetNextWindowSizeConstraints(ImVec2(min_width, min_height), ImVec2(max_width, max_height)); + */ + + static native void SetNextWindowContentSize(float width, float height) /*-{ }-*/; /* + ImGui::SetNextWindowContentSize(ImVec2(width, height)); + */ + + static native void SetNextWindowCollapsed(boolean collapsed) /*-{ }-*/; /* + ImGui::SetNextWindowCollapsed(collapsed); + */ + + static native void SetNextWindowCollapsed(boolean collapsed, int cond) /*-{ }-*/; /* + ImGui::SetNextWindowCollapsed(collapsed, cond); + */ + + static native void SetNextWindowFocus() /*-{ }-*/; /* + ImGui::SetNextWindowFocus(); + */ + + static native void SetNextWindowBgAlpha(float alpha) /*-{ }-*/; /* + ImGui::SetNextWindowBgAlpha(alpha); + */ + + static native void SetWindowPos(float x, float y) /*-{ }-*/; /* + ImGui::SetWindowPos(ImVec2(x, y)); + */ + + static native void SetWindowPos(float x, float y, int cond) /*-{ }-*/; /* + ImGui::SetWindowPos(ImVec2(x, y), cond); + */ + + static native void SetWindowSize(float width, float height) /*-{ }-*/; /* + ImGui::SetWindowSize(ImVec2(width, height)); + */ + + static native void SetWindowSize(float width, float height, int cond) /*-{ }-*/; /* + ImGui::SetWindowSize(ImVec2(width, height), cond); + */ + + static native void SetWindowCollapsed(boolean collapsed, int cond) /*-{ }-*/; /* + ImGui::SetWindowCollapsed(collapsed, cond); + */ + + static native void SetWindowFocus() /*-{ }-*/; /* + ImGui::SetWindowFocus(); + */ + + static native void SetWindowFocus(float scale) /*-{ }-*/; /* + ImGui::SetWindowFontScale(scale); + */ + + static native void SetWindowPos(String name, float x, float y) /*-{ }-*/; /* + ImGui::SetWindowPos(name, ImVec2(x, y)); + */ + + static native void SetWindowPos(String name, float x, float y, int cond) /*-{ }-*/; /* + ImGui::SetWindowPos(name, ImVec2(x, y), cond); + */ + + static native void SetWindowCollapsed(String name, boolean collapsed) /*-{ }-*/; /* + bool flag = collapsed; + ImGui::SetWindowCollapsed(name, flag); + */ + + static native void SetWindowCollapsed(String name, boolean collapsed, int cond) /*-{ }-*/; /* + ImGui::SetWindowCollapsed(name, collapsed, cond); + */ + + static native void SetWindowFocus(String name) /*-{ }-*/; /* + ImGui::SetWindowFocus(name); + */ + + // Content region + // - Those functions are bound to be redesigned soon (they are confusing, incomplete and return values in local window coordinates which increases confusion) + + static native void RemoveWindowFocus() /*-{ }-*/; /* + ImGui::SetWindowFocus(NULL); + */ + + static native void GetContentRegionMax(ImVec2 jImVec2) /*-{ }-*/; /* + ImVec2 vec = ImGui::GetContentRegionMax(); + env->SetFloatField (jImVec2, imVec2XID, vec.x); + env->SetFloatField (jImVec2, imVec2YID, vec.y); + */ + + static native void GetContentRegionAvail(ImVec2 jImVec2) /*-{ }-*/; /* + ImVec2 vec = ImGui::GetContentRegionAvail(); + env->SetFloatField (jImVec2, imVec2XID, vec.x); + env->SetFloatField (jImVec2, imVec2YID, vec.y); + */ + + static native float GetContentRegionAvailWidth() /*-{ }-*/; /* + return ImGui::GetContentRegionAvailWidth(); + */ + + static native void GetWindowContentRegionMin(ImVec2 jImVec2) /*-{ }-*/; /* + ImVec2 vec = ImGui::GetWindowContentRegionMin(); + env->SetFloatField (jImVec2, imVec2XID, vec.x); + env->SetFloatField (jImVec2, imVec2YID, vec.y); + */ + + static native void GetWindowContentRegionMax(ImVec2 jImVec2) /*-{ }-*/; /* + ImVec2 vec = ImGui::GetWindowContentRegionMax(); + env->SetFloatField (jImVec2, imVec2XID, vec.x); + env->SetFloatField (jImVec2, imVec2YID, vec.y); + */ + + // Windows Scrolling + + static native float GetWindowContentRegionWidth() /*-{ }-*/; /* + return ImGui::GetWindowContentRegionWidth(); + */ + + static native float GetScrollX() /*-{ }-*/; /* + return ImGui::GetScrollX(); + */ + + static native float GetScrollY() /*-{ }-*/; /* + return ImGui::GetScrollY(); + */ + + static native float GetScrollMaxX() /*-{ }-*/; /* + return ImGui::GetScrollMaxX(); + */ + + static native float GetScrollMaxY() /*-{ }-*/; /* + return ImGui::GetScrollMaxY(); + */ + + static native void SetScrollX(float scroll_x) /*-{ }-*/; /* + ImGui::SetScrollX(scroll_x); + */ + + static native void SetScrollY(float scroll_y) /*-{ }-*/; /* + ImGui::SetScrollY(scroll_y); + */ + + static native void SetScrollHereY() /*-{ }-*/; /* + ImGui::SetScrollHereY(); + */ + + static native void SetScrollHereY(float center_y_ratio) /*-{ }-*/; /* + ImGui::SetScrollHereY(center_y_ratio); + */ + + static native void SetScrollFromPosY(float local_y) /*-{ }-*/; /* + ImGui::SetScrollFromPosY(local_y); + */ + + // Parameters stacks (shared) + + static native void SetScrollFromPosY(float local_y, float center_y_ratio) /*-{ }-*/; /* + ImGui::SetScrollFromPosY(local_y, center_y_ratio); + */ + + //TODO impl + static native void PushFont(int index) /*-{ }-*/; /* + ImGuiIO& io = ImGui::GetIO(); + ImFontAtlas* atlas = io.Fonts; + ImFont* font = atlas->Fonts[index]; + ImGui::PushFont(font); + */ + + static native void PopFont() /*-{ }-*/; /* + ImGui::PopFont(); + */ + + static native void PushStyleColor(int idx, int col) /*-{ }-*/; /* + ImGui::PushStyleColor(idx, col); + */ + + static native void PushStyleColor(int idx, float r, float g, float b, float a) /*-{ }-*/; /* + ImGui::PushStyleColor(idx, ImVec4(r, g, b, a)); + */ + + static native void PopStyleColor() /*-{ }-*/; /* + ImGui::PopStyleColor(); + */ + + static native void PopStyleColor(int count) /*-{ }-*/; /* + ImGui::PopStyleColor(count); + */ + + static native void PushStyleVar(int idx, float val) /*-{ }-*/; /* + ImGui::PushStyleVar(idx, val); + */ + + static native void PushStyleVar(int idx, float val_x, float val_y) /*-{ }-*/; /* + ImGui::PushStyleVar(idx, ImVec2(val_x, val_y)); + */ + + static native void PopStyleVar() /*-{ }-*/; /* + ImGui::PopStyleVar(); + */ + + static native void PopStyleVar(int count) /*-{ }-*/; /* + ImGui::PopStyleVar(count); + */ + + static native void GetStyleColorVec4(int idx, float [] value) /*-{ }-*/; /* + ImVec4 val = ImGui::GetStyleColorVec4(idx); + value[0] = val.x; + value[1] = val.y; + value[2] = val.z; + value[3] = val.w; + */ + + //TODO impl + static native void GetFont() /*-{ }-*/; /* + ImFont * font = ImGui::GetFont(); + */ + + static native int GetFontSize() /*-{ }-*/; /* + return ImGui::GetFontSize(); + */ + + static native void GetFontTexUvWhitePixel(float [] value) /*-{ }-*/; /* + ImVec2 val = ImGui::GetFontTexUvWhitePixel(); + value[0] = val.x; + value[1] = val.y; + */ + + static native int GetColorU32(int idx) /*-{ }-*/; /* + return ImGui::GetColorU32((ImGuiCol)idx); + */ + + static native int GetColorU32(int idx, float alpha_mul) /*-{ }-*/; /* + return ImGui::GetColorU32(idx, alpha_mul); + */ + + // Parameters stacks (current window) + + static native int GetColorU32(float col_x, float col_y, float col_z, float col_w) /*-{ }-*/; /* + return ImGui::GetColorU32(ImVec4(col_x, col_y, col_z, col_w)); + */ + + static native void PushItemWidth(float item_width) /*-{ }-*/; /* + ImGui::PushItemWidth(item_width); + */ + + static native void PopItemWidth() /*-{ }-*/; /* + ImGui::PopItemWidth(); + */ + + static native void SetNextItemWidth(float item_width) /*-{ }-*/; /* + ImGui::SetNextItemWidth(item_width); + */ + + static native float CalcItemWidth() /*-{ }-*/; /* + return ImGui::CalcItemWidth(); + */ + + static native void PushTextWrapPos(float wrap_local_pos_x) /*-{ }-*/; /* + ImGui::PushTextWrapPos(wrap_local_pos_x); + */ + + static native void PushTextWrapPos() /*-{ }-*/; /* + ImGui::PushTextWrapPos(); + */ + + static native void PopTextWrapPos() /*-{ }-*/; /* + ImGui::PopTextWrapPos(); + */ + + static native void PushAllowKeyboardFocus(boolean allow_keyboard_focus) /*-{ }-*/; /* + ImGui::PushAllowKeyboardFocus(allow_keyboard_focus); + */ + + static native void PopAllowKeyboardFocus() /*-{ }-*/; /* + ImGui::PopAllowKeyboardFocus(); + */ + + static native void PushButtonRepeat(boolean repeat) /*-{ }-*/; /* + ImGui::PushButtonRepeat(repeat); + */ + + // Cursor / Layout + // - By "cursor" we mean the current output position. + // - The typical widget behavior is to output themselves at the current cursor position, then move the cursor one line down. + + static native void PopButtonRepeat() /*-{ }-*/; /* + ImGui::PopButtonRepeat(); + */ + + static native void Separator() /*-{ }-*/; /* + ImGui::Separator(); + */ + + static native void SameLine() /*-{ }-*/; /* + ImGui::SameLine(); + */ + + static native void SameLine(float offsetFromStartX) /*-{ }-*/; /* + ImGui::SameLine(offsetFromStartX); + */ + + static native void SameLine(float offsetFromStartX, float spacing) /*-{ }-*/; /* + ImGui::SameLine(offsetFromStartX, spacing); + */ + + static native void NewLine() /*-{ }-*/; /* + ImGui::NewLine(); + */ + + static native void Spacing() /*-{ }-*/; /* + ImGui::Spacing(); + */ + + static native void Dummy(float width, float height) /*-{ }-*/; /* + ImGui::Dummy(ImVec2(width, height)); + */ + + static native void Indent() /*-{ }-*/; /* + ImGui::Indent(); + */ + + static native void Indent(float indentW) /*-{ }-*/; /* + ImGui::Indent(indentW); + */ + + static native void Unindent() /*-{ }-*/; /* + ImGui::Unindent(); + */ + + static native void Unindent(float indentW) /*-{ }-*/; /* + ImGui::Unindent(indentW); + */ + + static native void BeginGroup() /*-{ }-*/; /* + ImGui::BeginGroup(); + */ + + static native void EndGroup() /*-{ }-*/; /* + ImGui::EndGroup(); + */ + + static native void GetCursorPos(float [] vec2) /*-{ }-*/; /* + ImVec2 vec = ImGui::GetCursorPos(); + vec2[0] = vec.x; + vec2[1] = vec.y; + */ + + static native float GetCursorPosX() /*-{ }-*/; /* + return ImGui::GetCursorPosX(); + */ + + static native float GetCursorPosY() /*-{ }-*/; /* + return ImGui::GetCursorPosY(); + */ + + static native void SetCursorPos(float x, float y) /*-{ }-*/; /* + ImGui::SetCursorPos(ImVec2(x, y)); + */ + + static native void SetCursorPosX(float x) /*-{ }-*/; /* + ImGui::SetCursorPosX(x); + */ + + static native void SetCursorPosY(float y) /*-{ }-*/; /* + ImGui::SetCursorPosY(y); + */ + + static native void GetCursorStartPos(ImVec2 jImVec2) /*-{ }-*/; /* + ImVec2 vec = ImGui::GetCursorStartPos(); + env->SetFloatField (jImVec2, imVec2XID, vec.x); + env->SetFloatField (jImVec2, imVec2YID, vec.y); + */ + + static native void GetCursorScreenPos(ImVec2 jImVec2) /*-{ }-*/; /* + ImVec2 vec = ImGui::GetCursorScreenPos(); + env->SetFloatField (jImVec2, imVec2XID, vec.x); + env->SetFloatField (jImVec2, imVec2YID, vec.y); + */ + + static native void SetCursorScreenPos(float x, float y) /*-{ }-*/; /* + ImGui::SetCursorScreenPos(ImVec2(x, y)); + */ + + static native void AlignTextToFramePadding() /*-{ }-*/; /* + ImGui::AlignTextToFramePadding(); + */ + + static native float GetTextLineHeight() /*-{ }-*/; /* + return ImGui::GetTextLineHeight(); + */ + + static native float GetTextLineHeightWithSpacing() /*-{ }-*/; /* + return ImGui::GetTextLineHeightWithSpacing(); + */ + + static native float GetFrameHeight() /*-{ }-*/; /* + return ImGui::GetFrameHeight(); + */ + + // ID stack/scopes + // - Read the FAQ for more details about how ID are handled in dear imgui. If you are creating widgets in a loop you most + // likely want to push a unique identifier (e.g. object pointer, loop index) to uniquely differentiate them. + // - The resulting ID are hashes of the entire stack. + // - You can also use the "Label##foobar" syntax within widget label to distinguish them from each others. + // - In this header file we use the "label"/"name" terminology to denote a string that will be displayed and used as an ID, + // whereas "str_id" denote a string that is only used as an ID and not normally displayed. + + static native float GetFrameHeightWithSpacing() /*-{ }-*/; /* + return ImGui::GetFrameHeightWithSpacing(); + */ + + static native void PushID(String str_id) /*-{ }-*/; /* + ImGui::PushID(str_id); + */ + + static native void PushID(String str_id_begin, String str_id_end) /*-{ }-*/; /* + ImGui::PushID(str_id_begin, str_id_end); + */ + + static native void PushID(int int_id) /*-{ }-*/; /* + ImGui::PushID(int_id); + */ + + static native void PopID() /*-{ }-*/; /* + ImGui::PopID(); + */ + + static native int GetID(String str_id) /*-{ }-*/; /* + return ImGui::GetID(str_id); + */ + + // Widgets: Text + + static native int GetID(String str_id_begin, String str_id_end) /*-{ }-*/; /* + return ImGui::GetID(str_id_begin, str_id_end); + */ + + static native void TextUnformatted(String text) /*-{ }-*/; /* + ImGui::TextUnformatted(text); + */ + + static native void TextUnformatted(String text, String text_end) /*-{ }-*/; /* + ImGui::TextUnformatted(text, text_end); + */ + + static native void Text(String text) /*-{ }-*/; /* + ImGui::Text(text); + */ + + static native void TextColored(float r, float g, float b, float a, String text) /*-{ }-*/; /* + ImGui::TextColored(ImVec4(r, g, b, a), text); + */ + + static native void TextDisabled(String text) /*-{ }-*/; /* + ImGui::TextDisabled(text); + */ + + static native void TextWrapped(String text) /*-{ }-*/; /* + ImGui::TextWrapped(text); + */ + + static native void LabelText(String label, String text) /*-{ }-*/; /* + ImGui::LabelText(label, text); + */ + + // Widgets: Main + // - Most widgets return true when the value has been changed or when pressed/selected + + static native void BulletText(String text) /*-{ }-*/; /* + ImGui::BulletText(text); + */ + + static native boolean Button(String label) /*-{ }-*/; /* + return ImGui::Button(label); + */ + + static native boolean Button(String label, float width, float height) /*-{ }-*/; /* + return ImGui::Button(label, ImVec2(width, height)); + */ + + static native boolean SmallButton(String label) /*-{ }-*/; /* + return ImGui::SmallButton(label); + */ + + static native boolean InvisibleButton(String strId, float width, float height) /*-{ }-*/; /* + return ImGui::InvisibleButton(strId, ImVec2(width, height)); + */ + + static native boolean ArrowButton(String strId, int dir) /*-{ }-*/; /* + return ImGui::ArrowButton(strId, dir); + */ + + static native void Image(int textureID, float sizeX, float sizeY) /*-{ }-*/; /* + ImGui::Image((ImTextureID)textureID, ImVec2(sizeX, sizeY)); + */ + + static native void Image(int textureID, float sizeX, float sizeY, float uv0_x, float uv0_y, float uv1_x, float uv1_y) /*-{ }-*/; /* + ImGui::Image((ImTextureID)textureID, ImVec2(sizeX, sizeY), ImVec2(uv0_x, uv0_y), ImVec2(uv1_x, uv1_y)); + */ + + static native void Image(int textureID, float sizeX, float sizeY, float uv0_x, float uv0_y, float uv1_x, float uv1_y, float tint_color_r, float tint_color_g, float tint_color_b, float tint_color_a, float border_col_r, float border_col_g, float border_col_b, float border_col_a) /*-{ }-*/; /* + ImGui::Image((ImTextureID)textureID, ImVec2(sizeX, sizeY), ImVec2(uv0_x, uv0_y), ImVec2(uv1_x, uv1_y), ImVec4(tint_color_r, tint_color_g, tint_color_b, tint_color_a), ImVec4(border_col_r, border_col_g, border_col_b, border_col_a)); + */ + + static native boolean ImageButton(int textureID, float sizeX, float sizeY) /*-{ }-*/; /* + return ImGui::ImageButton((ImTextureID)textureID, ImVec2(sizeX, sizeY)); + */ + + static native boolean ImageButton(int textureID, float sizeX, float sizeY, float uv0_x, float uv0_y, float uv1_x, float uv1_y, int frame_padding) /*-{ }-*/; /* + return ImGui::ImageButton((ImTextureID)textureID, ImVec2(sizeX, sizeY), ImVec2(uv0_x, uv0_y), ImVec2(uv1_x, uv1_y), frame_padding); + */ + + static native boolean ImageButton(int textureID, float sizeX, float sizeY, float uv0_x, float uv0_y, float uv1_x, float uv1_y, int frame_padding, float bg_color_r, float bg_color_g, float bg_color_b, float bg_color_a, float tint_col_r, float tint_col_g, float tint_col_b, float tint_col_a) /*-{ }-*/; /* + return ImGui::ImageButton((ImTextureID)textureID, ImVec2(sizeX, sizeY), ImVec2(uv0_x, uv0_y), ImVec2(uv1_x, uv1_y), frame_padding, ImVec4(bg_color_r, bg_color_g, bg_color_b, bg_color_a), ImVec4(tint_col_r, tint_col_g, tint_col_b, tint_col_a)); + */ + + static native boolean Checkbox(String label, boolean [] data) /*-{ }-*/; /* + return ImGui::Checkbox(label, &data[0]); + */ + + //TODO check if its working + static native boolean CheckboxFlags(String label, int [] data, int flagsValue) /*-{ }-*/; /* + return ImGui::CheckboxFlags(label, (unsigned int*)&data[0], flagsValue); + */ + + static native boolean RadioButton(String label, boolean active) /*-{ }-*/; /* + return ImGui::RadioButton(label, active); + */ + + static native boolean RadioButton(String label, int [] data, int v_button) /*-{ }-*/; /* + return ImGui::RadioButton(label, &data[0], v_button); + */ + + static native void ProgressBar(float fraction) /*-{ }-*/; /* + ImGui::ProgressBar(fraction); + */ + + static native void ProgressBar(float fraction, float size_arg_x, float size_arg_y) /*-{ }-*/; /* + ImGui::ProgressBar(fraction, ImVec2(size_arg_x, size_arg_y)); + */ + + // Widgets: Combo Box + // - The new BeginCombo()/EndCombo() api allows you to manage your contents and selection state however you want it, by creating e.g. Selectable() items. + // - The old Combo() api are helpers over BeginCombo()/EndCombo() which are kept available for convenience purpose. + + static native void Bullet() /*-{ }-*/; /* + ImGui::Bullet(); + */ + + static native boolean BeginCombo(String label, String preview_value) /*-{ }-*/; /* + return ImGui::BeginCombo(label, preview_value); + */ + + static native boolean BeginCombo(String label, String preview_value, int flags) /*-{ }-*/; /* + return ImGui::BeginCombo(label, preview_value, flags); + */ + + static native void EndCombo() /*-{ }-*/; /* + ImGui::EndCombo(); + */ + + static native boolean Combo(String label, int [] current_item, String [] items, int items_count) /*-{ }-*/; /* + const char* listbox_items[items_count]; + for(int i = 0; i < items_count; i++) { + jstring string = (jstring) (env->GetObjectArrayElement(items, i)); + const char *rawString = env->GetStringUTFChars(string, 0); + listbox_items[i] = rawString; + } + return ImGui::Combo(label, ¤t_item[0], listbox_items, items_count); + */ + + static native boolean Combo(String label, int [] current_item, String [] items, int items_count, int popup_max_height_in_items) /*-{ }-*/; /* + const char* listbox_items[items_count]; + for(int i = 0; i < items_count; i++) { + jstring string = (jstring) (env->GetObjectArrayElement(items, i)); + const char *rawString = env->GetStringUTFChars(string, 0); + listbox_items[i] = rawString; + } + return ImGui::Combo(label, ¤t_item[0], listbox_items, items_count, popup_max_height_in_items); + */ + + static native boolean Combo(String label, int [] current_item, String items_separated_by_zeros) /*-{ }-*/; /* + return ImGui::Combo(label, ¤t_item[0], items_separated_by_zeros); + */ + + // Widgets: Drags + // - CTRL+Click on any drag box to turn them into an input box. Manually input values aren't clamped and can go off-bounds. + // - For all the Float2/Float3/Float4/Int2/Int3/Int4 versions of every functions, note that a 'float v[X]' function argument is the same as 'float* v', the array syntax is just a way to document the number of elements that are expected to be accessible. You can pass address of your first element out of a contiguous set, e.g. &myvector.x + // - Adjust format string to decorate the value with a prefix, a suffix, or adapt the editing and display precision e.g. "%.3f" -> 1.234; "%5.2f secs" -> 01.23 secs; "Biscuit: %.0f" -> Biscuit: 1; etc. + // - Speed are per-pixel of mouse movement (v_speed=0.2f: mouse needs to move by 5 pixels to increase value by 1). For gamepad/keyboard navigation, minimum speed is Max(v_speed, minimum_step_at_given_precision). + + static native boolean Combo(String label, int [] current_item, String items_separated_by_zeros, int popup_max_height_in_items) /*-{ }-*/; /* + return ImGui::Combo(label, ¤t_item[0], items_separated_by_zeros, popup_max_height_in_items); + */ + + static native boolean DragFloat(String label, float [] v) /*-{ }-*/; /* + return ImGui::DragFloat(label, &v[0]); + */ + + static native boolean DragFloat(String label, float [] v, float v_speed) /*-{ }-*/; /* + return ImGui::DragFloat(label, &v[0], v_speed); + */ + + static native boolean DragFloat(String label, float [] v, float v_speed, float v_min, float v_max, String format) /*-{ }-*/; /* + return ImGui::DragFloat(label, &v[0], v_speed, v_min, v_max, format); + */ + + static native boolean DragFloat(String label, float [] v, float v_speed, float v_min, float v_max, String format, float power) /*-{ }-*/; /* + return ImGui::DragFloat(label, &v[0], v_speed, v_min, v_max, format, power); + */ + + static native boolean DragFloat2(String label, float [] v) /*-{ }-*/; /* + return ImGui::DragFloat2(label, v); + */ + + static native boolean DragFloat2(String label, float [] v, float v_speed, float v_min, float v_max, String format, float power) /*-{ }-*/; /* + return ImGui::DragFloat2(label, v, v_speed, v_min, v_max, format, power); + */ + + static native boolean DragFloat3(String label, float [] v) /*-{ }-*/; /* + return ImGui::DragFloat3(label, v); + */ + + static native boolean DragFloat3(String label, float [] v, float v_speed, float v_min, float v_max, String format, float power) /*-{ }-*/; /* + return ImGui::DragFloat3(label, v, v_speed, v_min, v_max, format, power); + */ + + static native boolean DragFloat4(String label, float [] v) /*-{ }-*/; /* + return ImGui::DragFloat4(label, v); + */ + + static native boolean DragFloat4(String label, float [] v, float v_speed, float v_min, float v_max, String format, float power) /*-{ }-*/; /* + return ImGui::DragFloat4(label, v, v_speed, v_min, v_max, format, power); + */ + + static native boolean DragFloatRange2(String label, float [] v_current_min, float [] v_current_max) /*-{ }-*/; /* + return ImGui::DragFloatRange2(label, &v_current_min[0], &v_current_max[0]); + */ + + static native boolean DragFloatRange2(String label, float [] v_current_min, float [] v_current_max, float v_speed, float v_min, float v_max, String format, String format_max, float power) /*-{ }-*/; /* + return ImGui::DragFloatRange2(label, &v_current_min[0], &v_current_max[0], v_speed, v_min, v_max, format, format_max, power); + */ + + static native boolean DragInt(String label, int [] v) /*-{ }-*/; /* + return ImGui::DragInt(label, &v[0]); + */ + + static native boolean DragInt(String label, int [] v, float v_speed) /*-{ }-*/; /* + return ImGui::DragInt(label, &v[0], v_speed); + */ + + static native boolean DragInt(String label, int [] v, float v_speed, float v_min, float v_max, String format) /*-{ }-*/; /* + return ImGui::DragInt(label, &v[0], v_speed, v_min, v_max, format); + */ + + static native boolean DragInt2(String label, int [] v) /*-{ }-*/; /* + return ImGui::DragInt2(label, v); + */ + + static native boolean DragInt2(String label, int [] v, float v_speed, float v_min, float v_max, String format) /*-{ }-*/; /* + return ImGui::DragInt2(label, v, v_speed, v_min, v_max, format); + */ + + static native boolean DragInt3(String label, int [] v) /*-{ }-*/; /* + return ImGui::DragInt2(label, v); + */ + + static native boolean DragInt3(String label, int [] v, float v_speed, float v_min, float v_max, String format) /*-{ }-*/; /* + return ImGui::DragInt2(label, v, v_speed, v_min, v_max, format); + */ + + static native boolean DragInt4(String label, int [] v) /*-{ }-*/; /* + return ImGui::DragInt4(label, v); + */ + + static native boolean DragInt4(String label, int [] v, float v_speed, float v_min, float v_max, String format) /*-{ }-*/; /* + return ImGui::DragInt4(label, v, v_speed, v_min, v_max, format); + */ + + static native boolean DragIntRange2(String label, int [] v_current_min, int [] v_current_max) /*-{ }-*/; /* + return ImGui::DragIntRange2(label, &v_current_min[0], &v_current_max[0]); + */ + + static native boolean DragIntRange2(String label, int [] v_current_min, int [] v_current_max, float v_speed, float v_min, float v_max, String format, String format_max) /*-{ }-*/; /* + return ImGui::DragIntRange2(label, &v_current_min[0], &v_current_max[0], v_speed, v_min, v_max, format, format_max); + */ + + //TODO impl other types + static native boolean DragScalar(String label, int data_type, int[] v, float v_speed) /*-{ }-*/; /* + return ImGui::DragScalar(label, data_type, &v[0], v_speed); + */ + + // Widgets: Sliders + // - CTRL+Click on any slider to turn them into an input box. Manually input values aren't clamped and can go off-bounds. + // - Adjust format string to decorate the value with a prefix, a suffix, or adapt the editing and display precision e.g. "%.3f" -> 1.234; "%5.2f secs" -> 01.23 secs; "Biscuit: %.0f" -> Biscuit: 1; etc. + + //TODO impl other types + static native boolean DragScalar(String label, int data_type, int[] v, float v_speed, float v_min, float v_max, String format, float power) /*-{ }-*/; /* + return ImGui::DragScalar(label, data_type, &v[0], v_speed, &v_min, &v_max, format, power); + */ + + static native boolean SliderFloat(String label, float [] v, float v_min, float v_max) /*-{ }-*/; /* + return ImGui::SliderFloat(label, &v[0],v_min, v_max); + */ + + static native boolean SliderFloat(String label, float [] v, float v_min, float v_max, String format) /*-{ }-*/; /* + return ImGui::SliderFloat(label, &v[0], v_min, v_max, format); + */ + + static native boolean SliderFloat(String label, float [] v, float v_min, float v_max, String format, float power) /*-{ }-*/; /* + return ImGui::SliderFloat(label, &v[0], v_min, v_max, format, power); + */ + + static native boolean SliderFloat2(String label, float [] v, float v_min, float v_max) /*-{ }-*/; /* + return ImGui::SliderFloat2(label, v, v_min, v_max); + */ + + static native boolean SliderFloat2(String label, float [] v, float v_min, float v_max, String format, float power) /*-{ }-*/; /* + return ImGui::SliderFloat2(label, v, v_min, v_max, format, power); + */ + + static native boolean SliderFloat3(String label, float [] v, float v_min, float v_max) /*-{ }-*/; /* + return ImGui::SliderFloat3(label, v, v_min, v_max); + */ + + static native boolean SliderFloat3(String label, float [] v, float v_min, float v_max, String format, float power) /*-{ }-*/; /* + return ImGui::SliderFloat3(label, v, v_min, v_max, format, power); + */ + + static native boolean SliderFloat4(String label, float [] v, float v_min, float v_max) /*-{ }-*/; /* + return ImGui::SliderFloat4(label, v, v_min, v_max); + */ + + static native boolean SliderFloat4(String label, float [] v, float v_min, float v_max, String format, float power) /*-{ }-*/; /* + return ImGui::SliderFloat4(label, v, v_min, v_max, format, power); + */ + + static native boolean SliderAngle(String label, float [] v_rad) /*-{ }-*/; /* + return ImGui::SliderAngle(label, &v_rad[0]); + */ + + static native boolean SliderAngle(String label, float [] v_rad, float v_degrees_min, float v_degrees_max, String format) /*-{ }-*/; /* + return ImGui::SliderAngle(label, &v_rad[0], v_degrees_min, v_degrees_max, format); + */ + + static native boolean SliderInt(String label, int [] v, int v_min, int v_max) /*-{ }-*/; /* + return ImGui::SliderInt(label, &v[0], v_min, v_max); + */ + + static native boolean SliderInt(String label, int [] v, int v_min, int v_max, String format) /*-{ }-*/; /* + return ImGui::SliderInt(label, &v[0], v_min, v_max, format); + */ + + static native boolean SliderInt2(String label, int [] v, int v_min, int v_max) /*-{ }-*/; /* + return ImGui::SliderInt2(label, v, v_min, v_max); + */ + + static native boolean SliderInt2(String label, int [] v, int v_min, int v_max, String format) /*-{ }-*/; /* + return ImGui::SliderInt2(label, v, v_min, v_max, format); + */ + + static native boolean SliderInt3(String label, int [] v, int v_min, int v_max) /*-{ }-*/; /* + return ImGui::SliderInt3(label, v, v_min, v_max); + */ + + static native boolean SliderInt3(String label, int [] v, int v_min, int v_max, String format) /*-{ }-*/; /* + return ImGui::SliderInt3(label, v, v_min, v_max, format); + */ + + static native boolean SliderInt4(String label, int [] v, int v_min, int v_max) /*-{ }-*/; /* + return ImGui::SliderInt4(label, v, v_min, v_max); + */ + + static native boolean SliderInt4(String label, int [] v, int v_min, int v_max, String format) /*-{ }-*/; /* + return ImGui::SliderInt4(label, v, v_min, v_max, format); + */ + + //TODO impl other types + static native boolean SliderScalar(String label, int data_type, int[] v, int v_min, int v_max) /*-{ }-*/; /* + return ImGui::SliderScalar(label, data_type, &v[0], &v_min, &v_max); + */ + + static native boolean SliderScalar(String label, int data_type, int[] v, float v_min, float v_max, String format, float power) /*-{ }-*/; /* + return ImGui::SliderScalar(label, data_type, &v[0], &v_min, &v_max, format, power); + */ + + static native boolean SliderScalar(String label, int data_type, float[] v, float v_min, float v_max) /*-{ }-*/; /* + return ImGui::SliderScalar(label, data_type, &v[0], &v_min, &v_max); + */ + + static native boolean SliderScalar(String label, int data_type, float[] v, float v_min, float v_max, String format, float power) /*-{ }-*/; /* + return ImGui::SliderScalar(label, data_type, &v[0], &v_min, &v_max, format, power); + */ + + static native boolean VSliderFloat(String label, float sizeX, float sizeY, float [] v, float v_min, float v_max) /*-{ }-*/; /* + return ImGui::VSliderFloat(label, ImVec2(sizeX, sizeY), &v[0], v_min, v_max); + */ + + static native boolean VSliderFloat(String label, float sizeX, float sizeY, float [] v, float v_min, float v_max, String format, float power) /*-{ }-*/; /* + return ImGui::VSliderFloat(label, ImVec2(sizeX, sizeY), &v[0], v_min, v_max, format, power); + */ + + static native boolean VSliderInt(String label, float sizeX, float sizeY, int [] v, int v_min, int v_max) /*-{ }-*/; /* + return ImGui::VSliderInt(label, ImVec2(sizeX, sizeY), &v[0], v_min, v_max); + */ + + static native boolean VSliderInt(String label, float sizeX, float sizeY, int [] v, int v_min, int v_max, String format) /*-{ }-*/; /* + return ImGui::VSliderInt(label, ImVec2(sizeX, sizeY), &v[0], v_min, v_max, format); + */ + + //TODO impl other types + static native boolean VSliderScalar(String label, float sizeX, float sizeY, int data_type, int [] v, int v_min, int v_max) /*-{ }-*/; /* + return ImGui::VSliderScalar(label, ImVec2(sizeX, sizeY), data_type, &v[0], &v_min, &v_max); + */ + + static native boolean VSliderScalar(String label, float sizeX, float sizeY, int data_type, int [] v, int v_min, int v_max, String format, float power) /*-{ }-*/; /* + return ImGui::VSliderScalar(label, ImVec2(sizeX, sizeY), data_type, &v[0], &v_min, &v_max, format, power); + */ + + static native boolean VSliderScalar(String label, float sizeX, float sizeY, int data_type, float [] v, float v_min, float v_max) /*-{ }-*/; /* + return ImGui::VSliderScalar(label, ImVec2(sizeX, sizeY), data_type, &v[0], &v_min, &v_max); + */ + + // Widgets: Input with Keyboard + // - If you want to use InputText() with a dynamic string type such as std::string or your own, see misc/cpp/imgui_stdlib.h + // - Most of the ImGuiInputTextFlags flags are only useful for InputText() and not for InputFloatX, InputIntX, InputDouble etc. + + /*JNI + + struct InputTextCallback_UserData { + jobject* textInputData; + JNIEnv* env; + int maxChar; + char * allowedChar; + int allowedCharLength; + int maxSize; + int curSize; + }; + + static int TextEditCallbackStub(ImGuiInputTextCallbackData* data) { + InputTextCallback_UserData* userData = (InputTextCallback_UserData*)data->UserData; + + if (data->EventFlag == ImGuiInputTextFlags_CallbackCharFilter) { + if(userData->allowedCharLength > 0) { + bool found = false; + for(int i = 0; i < userData->allowedCharLength; i++) { + if(userData->allowedChar[i] == data->EventChar) { + found = true; + break; + } + } + return found ? 0 : 1; + } + } + return 0; + } + */ + + static native boolean VSliderScalar(String label, float sizeX, float sizeY, int data_type, float [] v, float v_min, float v_max, String format, float power) /*-{ }-*/; /* + return ImGui::VSliderScalar(label, ImVec2(sizeX, sizeY), data_type, &v[0], &v_min, &v_max, format, power); + */ + + static native boolean InputText(String label, byte [] buff, int maxSize, int flags, ImGuiInputTextData textInputData, int maxChar, String allowedChar, int allowedCharLength) /*-{ }-*/; /* + + int size = (int)strlen(buff); + InputTextCallback_UserData cb_user_data; + cb_user_data.textInputData = &textInputData; + cb_user_data.env = env; + cb_user_data.curSize = size; + cb_user_data.maxSize = maxSize; + cb_user_data.maxChar = maxChar; + cb_user_data.allowedChar = allowedChar; + cb_user_data.allowedCharLength = allowedCharLength; + + char tempArray [maxSize]; + memset(tempArray, 0, sizeof(tempArray)); + memcpy(tempArray, buff, size); + if(maxChar >= 0 && maxChar < maxSize) + maxSize = maxChar; + bool flag = ImGui::InputText(label, tempArray, maxSize, flags | ImGuiInputTextFlags_CallbackCharFilter, &TextEditCallbackStub, &cb_user_data); + if(flag) { + size = (int)strlen(tempArray); + env->SetIntField (textInputData, imTextInputDataSizeID, size); + env->SetBooleanField (textInputData, imTextInputDataIsDirtyID, true); + memset(buff, 0, maxSize); + memcpy(buff, tempArray, size); + } + return flag; + */ + + static native boolean InputFloat(String label, float [] v) /*-{ }-*/; /* + ImGui::InputFloat(label, &v[0]); + */ + + static native boolean InputFloat(String label, float [] v, float step, float step_fast, String format) /*-{ }-*/; /* + ImGui::InputFloat(label, &v[0], step, step_fast, format); + */ + + static native boolean InputFloat(String label, float [] v, float step, float step_fast, String format, int flags) /*-{ }-*/; /* + ImGui::InputFloat(label, &v[0], step, step_fast, format, flags); + */ + + static native boolean InputInt(String label, int [] v) /*-{ }-*/; /* + ImGui::InputInt(label, &v[0]); + */ + + static native boolean InputInt(String label, int [] v, float step, float step_fast) /*-{ }-*/; /* + ImGui::InputInt(label, &v[0], step, step_fast); + */ + + static native boolean InputInt(String label, int [] v, float step, float step_fast, int flags) /*-{ }-*/; /* + ImGui::InputInt(label, &v[0], step, step_fast, flags); + */ + + static native boolean InputDouble(String label, double [] v) /*-{ }-*/; /* + ImGui::InputDouble(label, &v[0]); + */ + + static native boolean InputDouble(String label, double [] v, float step, float step_fast, String format) /*-{ }-*/; /* + ImGui::InputDouble(label, &v[0], step, step_fast, format); + */ + + + // Widgets: Trees + // - TreeNode functions return true when the node is open, in which case you need to also call TreePop() when you are finished displaying the tree node contents. + + static native boolean InputDouble(String label, double [] v, float step, float step_fast, String format, int flags) /*-{ }-*/; /* + ImGui::InputDouble(label, &v[0], step, step_fast, format, flags); + */ + + static native boolean TreeNode(String label) /*-{ }-*/; /* + return ImGui::TreeNode(label); + */ + + static native boolean TreeNode(String str_id, String label) /*-{ }-*/; /* + return ImGui::TreeNode(str_id, label); + */ + + static native boolean TreeNode(int ptr_id, String label) /*-{ }-*/; /* + return ImGui::TreeNode((void*)(intptr_t)ptr_id, label); + */ + + static native boolean TreeNodeEx(String label) /*-{ }-*/; /* + return ImGui::TreeNodeEx(label); + */ + + static native boolean TreeNodeEx(String label, int flags) /*-{ }-*/; /* + return ImGui::TreeNodeEx(label, flags); + */ + + static native boolean TreeNodeEx(String str_id, int flags, String label) /*-{ }-*/; /* + return ImGui::TreeNodeEx(str_id, flags, label); + */ + + static native boolean TreeNodeEx(int ptr_id, int flags, String label) /*-{ }-*/; /* + return ImGui::TreeNodeEx((void*)(intptr_t)ptr_id, flags, label); + */ + + static native void TreePush() /*-{ }-*/; /* + ImGui::TreePush(); + */ + + static native void TreePush(String str_id) /*-{ }-*/; /* + ImGui::TreePush(str_id); + */ + + static native void TreePush(int ptr_id) /*-{ }-*/; /* + ImGui::TreePush((void*)(intptr_t)ptr_id); + */ + + static native void TreePop() /*-{ }-*/; /* + ImGui::TreePop(); + */ + + static native void TreeAdvanceToLabelPos() /*-{ }-*/; /* + ImGui::TreeAdvanceToLabelPos(); + */ + + static native float GetTreeNodeToLabelSpacing() /*-{ }-*/; /* + return ImGui::GetTreeNodeToLabelSpacing(); + */ + + static native void SetNextTreeNodeOpen(boolean is_open) /*-{ }-*/; /* + ImGui::SetNextTreeNodeOpen(is_open); + */ + + static native void SetNextTreeNodeOpen(boolean is_open, int cond) /*-{ }-*/; /* + ImGui::SetNextTreeNodeOpen(is_open, cond); + */ + + static native boolean CollapsingHeader(String label) /*-{ }-*/; /* + return ImGui::CollapsingHeader(label); + */ + + static native boolean CollapsingHeader(String label, int flags) /*-{ }-*/; /* + return ImGui::CollapsingHeader(label, flags); + */ + + static native boolean CollapsingHeader(String label, boolean [] p_open) /*-{ }-*/; /* + return ImGui::CollapsingHeader(label, p_open); + */ + + // Widgets: Selectables + // - A selectable highlights when hovered, and can display another color when selected. + // - Neighbors selectable extend their highlight bounds in order to leave no gap between them. + + static native boolean CollapsingHeader(String label, boolean [] p_open, int flags) /*-{ }-*/; /* + return ImGui::CollapsingHeader(label, p_open, flags); + */ + + static native boolean Selectable(String label) /*-{ }-*/; /* + return ImGui::Selectable(label); + */ + + static native boolean Selectable(String label, boolean selected) /*-{ }-*/; /* + return ImGui::Selectable(label, selected); + */ + + static native boolean Selectable(String label, boolean selected, int flags, float sizeX, float sizeY) /*-{ }-*/; /* + return ImGui::Selectable(label, selected, flags, ImVec2(sizeX, sizeY)); + */ + + static native boolean Selectable(String label, boolean [] selected) /*-{ }-*/; /* + return ImGui::Selectable(label, &selected[0]); + */ + + // Widgets: List Boxes + // - FIXME: To be consistent with all the newer API, ListBoxHeader/ListBoxFooter should in reality be called BeginListBox/EndListBox. Will rename them. + + static native boolean Selectable(String label, boolean [] selected, int flags, float sizeX, float sizeY) /*-{ }-*/; /* + return ImGui::Selectable(label, &selected[0], flags, ImVec2(sizeX, sizeY)); + */ + + static native boolean ListBox(String label, int [] current_item, String [] items, int items_count) /*-{ }-*/; /* + const char* listbox_items[items_count]; + for(int i = 0; i < items_count; i++) { + jstring string = (jstring) (env->GetObjectArrayElement(items, i)); + const char *rawString = env->GetStringUTFChars(string, 0); + listbox_items[i] = rawString; + } + return ImGui::ListBox(label, ¤t_item[0], listbox_items, items_count); + */ + + static native boolean ListBoxHeader(String label) /*-{ }-*/; /* + return ImGui::ListBoxHeader(label); + */ + + static native boolean ListBoxHeader(String label, float sizeX, float sizeY) /*-{ }-*/; /* + return ImGui::ListBoxHeader(label, ImVec2(sizeX, sizeY)); + */ + + static native boolean ListBoxHeader(String label, int items_count) /*-{ }-*/; /* + return ImGui::ListBoxHeader(label, items_count); + */ + + static native boolean ListBoxHeader(String label, int items_count, int height_in_items) /*-{ }-*/; /* + return ImGui::ListBoxHeader(label, items_count, height_in_items); + */ + + // Widgets: Menus + + static native void ListBoxFooter() /*-{ }-*/; /* + ImGui::ListBoxFooter(); + */ + + static native boolean BeginMainMenuBar() /*-{ }-*/; /* + return ImGui::BeginMainMenuBar(); + */ + + static native void EndMainMenuBar() /*-{ }-*/; /* + ImGui::EndMainMenuBar(); + */ + + static native boolean BeginMenuBar() /*-{ }-*/; /* + return ImGui::BeginMenuBar(); + */ + + static native void EndMenuBar() /*-{ }-*/; /* + ImGui::EndMenuBar(); + */ + + static native boolean BeginMenu(String label) /*-{ }-*/; /* + return ImGui::BeginMenu(label); + */ + + static native boolean BeginMenu(String label, boolean enabled) /*-{ }-*/; /* + return ImGui::BeginMenu(label, enabled); + */ + + static native void EndMenu() /*-{ }-*/; /* + ImGui::EndMenu(); + */ + + static native boolean MenuItem(String label) /*-{ }-*/; /* + return ImGui::MenuItem(label); + */ + + static native boolean MenuItem(String label, String shortcut, boolean selected, boolean enabled) /*-{ }-*/; /* + return ImGui::MenuItem(label, shortcut, selected, enabled); + */ + + static native boolean MenuItem(String label, String shortcut, boolean [] p_selected) /*-{ }-*/; /* + return ImGui::MenuItem(label, shortcut, &p_selected[0]); + */ + + // Tooltips + + static native boolean MenuItem(String label, String shortcut, boolean [] p_selected, boolean enabled) /*-{ }-*/; /* + return ImGui::MenuItem(label, shortcut, &p_selected[0], enabled); + */ + + static native void BeginTooltip() /*-{ }-*/; /* + ImGui::BeginTooltip(); + */ + + static native void EndTooltip() /*-{ }-*/; /* + ImGui::EndTooltip(); + */ + + // Popups, Modals + // The properties of popups windows are: + // - They block normal mouse hovering detection outside them. (*) + // - Unless modal, they can be closed by clicking anywhere outside them, or by pressing ESCAPE. + // - Their visibility state (~bool) is held internally by imgui instead of being held by the programmer as we are used to with regular Begin() calls. + // User can manipulate the visibility state by calling OpenPopup(). + // (*) One can use IsItemHovered(ImGuiHoveredFlags_AllowWhenBlockedByPopup) to bypass it and detect hovering even when normally blocked by a popup. + // Those three properties are connected. The library needs to hold their visibility state because it can close popups at any time. + + static native void SetTooltip(String text) /*-{ }-*/; /* + ImGui::SetTooltip(text); + */ + + static native void OpenPopup(String str_id) /*-{ }-*/; /* + ImGui::OpenPopup(str_id); + */ + + static native boolean BeginPopup(String str_id) /*-{ }-*/; /* + return ImGui::BeginPopup(str_id); + */ + + static native boolean BeginPopup(String str_id, int flags) /*-{ }-*/; /* + return ImGui::BeginPopup(str_id, flags); + */ + + static native boolean BeginPopupContextItem() /*-{ }-*/; /* + return ImGui::BeginPopupContextItem(); + */ + + static native boolean BeginPopupContextItem(String str_id, int mouse_button) /*-{ }-*/; /* + return ImGui::BeginPopupContextItem(str_id, mouse_button); + */ + + static native boolean BeginPopupContextWindow() /*-{ }-*/; /* + return ImGui::BeginPopupContextWindow(); + */ + + static native boolean BeginPopupContextWindow(String str_id, int mouse_button, boolean also_over_items) /*-{ }-*/; /* + return ImGui::BeginPopupContextWindow(str_id, mouse_button, also_over_items); + */ + + static native boolean BeginPopupContextVoid() /*-{ }-*/; /* + return ImGui::BeginPopupContextVoid(); + */ + + static native boolean BeginPopupContextVoid(String str_id, int mouse_button) /*-{ }-*/; /* + return ImGui::BeginPopupContextVoid(str_id, mouse_button); + */ + + static native boolean BeginPopupModal(String name) /*-{ }-*/; /* + return ImGui::BeginPopupModal(name); + */ + + static native boolean BeginPopupModal(String name, boolean [] p_open, int flags) /*-{ }-*/; /* + return ImGui::BeginPopupModal(name, &p_open[0], flags); + */ + + static native void EndPopup() /*-{ }-*/; /* + ImGui::EndPopup(); + */ + + static native boolean OpenPopupOnItemClick() /*-{ }-*/; /* + return ImGui::OpenPopupOnItemClick(); + */ + + static native boolean OpenPopupOnItemClick(String str_id, int mouse_button) /*-{ }-*/; /* + return ImGui::OpenPopupOnItemClick(str_id, mouse_button); + */ + + static native boolean IsPopupOpen(String str_id) /*-{ }-*/; /* + return ImGui::IsPopupOpen(str_id); + */ + + // Columns + // - You can also use SameLine(pos_x) to mimic simplified columns. + // - The columns API is work-in-progress and rather lacking (columns are arguably the worst part of dear imgui at the moment!) + + static native void CloseCurrentPopup() /*-{ }-*/; /* + ImGui::CloseCurrentPopup(); + */ + + static native void Columns() /*-{ }-*/; /* + ImGui::Columns(); + */ + + static native void Columns(int count) /*-{ }-*/; /* + ImGui::Columns(count); + */ + + static native void Columns(int count, String id) /*-{ }-*/; /* + ImGui::Columns(count, id); + */ + + static native void Columns(int count, String id, boolean border) /*-{ }-*/; /* + ImGui::Columns(count, id, border); + */ + + static native void NextColumn() /*-{ }-*/; /* + ImGui::NextColumn(); + */ + + static native int GetColumnIndex() /*-{ }-*/; /* + return ImGui::GetColumnIndex(); + */ + + static native float GetColumnWidth() /*-{ }-*/; /* + return ImGui::GetColumnWidth(); + */ + + static native float GetColumnWidth(int column_index) /*-{ }-*/; /* + return ImGui::GetColumnWidth(column_index); + */ + + static native void SetColumnWidth(int column_index, float width) /*-{ }-*/; /* + ImGui::SetColumnWidth(column_index, width); + */ + + static native float GetColumnOffset() /*-{ }-*/; /* + return ImGui::GetColumnOffset(); + */ + + static native float GetColumnOffset(int column_index) /*-{ }-*/; /* + return ImGui::GetColumnOffset(column_index); + */ + + static native void SetColumnOffset(int column_index, float offset_x) /*-{ }-*/; /* + ImGui::SetColumnOffset(column_index, offset_x); + */ + + // Tab Bars, Tabs + // [BETA API] API may evolve! + + static native int GetColumnsCount() /*-{ }-*/; /* + return ImGui::GetColumnsCount(); + */ + + static native boolean BeginTabBar(String str_id) /*-{ }-*/; /* + return ImGui::BeginTabBar(str_id); + */ + + static native boolean BeginTabBar(String str_id, int flags) /*-{ }-*/; /* + return ImGui::BeginTabBar(str_id, flags); + */ + + static native void EndTabBar() /*-{ }-*/; /* + ImGui::EndTabBar(); + */ + + static native boolean BeginTabItem(String label) /*-{ }-*/; /* + return ImGui::BeginTabItem(label); + */ + + static native boolean BeginTabItem(String label, boolean [] p_open, int flags) /*-{ }-*/; /* + return ImGui::BeginTabItem(label, &p_open[0], flags); + */ + + static native void EndTabItem() /*-{ }-*/; /* + ImGui::EndTabItem(); + */ + + // Docking + // [BETA API] Enable with io.ConfigFlags |= ImGuiConfigFlags_DockingEnable. + // Note: you DO NOT need to call DockSpace() to use most Docking facilities! + // To dock windows: if io.ConfigDockingWithShift == false: drag window from their title bar. + // To dock windows: if io.ConfigDockingWithShift == true: hold SHIFT anywhere while moving windows. + // Use DockSpace() to create an explicit dock node _within_ an existing window. See Docking demo for details. + + static native void SetTabItemClosed(String tab_or_docked_window_label) /*-{ }-*/; /* + ImGui::SetTabItemClosed(tab_or_docked_window_label); + */ + + // TODO: Available after docking comes from BETA +// static native void DockSpace(int id) /*-{ }-*/; /* +// ImGui::DockSpace(id); +// */ + + // TODO: Available after docking comes from BETA +// static native void DockSpace(int id, float sizeX, float sizeY) /*-{ }-*/; /* +// ImGui::DockSpace(id, ImVec2(sizeX, sizeY)); +// */ + + // Focus, Activation + // - Prefer using "SetItemDefaultFocus()" over "if (IsWindowAppearing()) SetScrollHereY()" when applicable to signify "this is the default item" + + // TODO: Available after docking comes from BETA +// static native void DockSpace(int id, float sizeX, float sizeY, int flags) /*-{ }-*/; /* +// ImGui::DockSpace(id, ImVec2(sizeX, sizeY), flags); +// */ + + static native void SetItemDefaultFocus() /*-{ }-*/; /* + ImGui::SetItemDefaultFocus(); + */ + + static native boolean SetKeyboardFocusHere() /*-{ }-*/; /* + ImGui::SetKeyboardFocusHere(); + */ + + // Item/Widgets Utilities + // - Most of the functions are referring to the last/previous item we submitted. + // - See Demo Window under "Widgets->Querying Status" for an interactive visualization of most of those functions. + + static native boolean SetKeyboardFocusHere(int offset) /*-{ }-*/; /* + ImGui::SetKeyboardFocusHere(offset); + */ + + static native boolean IsItemHovered() /*-{ }-*/; /* + return ImGui::IsItemHovered(); + */ + + static native boolean IsItemHovered(int flags) /*-{ }-*/; /* + return ImGui::IsItemHovered(flags); + */ + + static native boolean IsItemActive() /*-{ }-*/; /* + return ImGui::IsItemActive(); + */ + + static native boolean IsItemFocused() /*-{ }-*/; /* + return ImGui::IsItemFocused(); + */ + + static native boolean IsItemClicked() /*-{ }-*/; /* + return ImGui::IsItemClicked(); + */ + + static native boolean IsItemClicked(int mouse_button) /*-{ }-*/; /* + return ImGui::IsItemClicked(mouse_button); + */ + + static native boolean IsItemVisible() /*-{ }-*/; /* + return ImGui::IsItemVisible(); + */ + + static native boolean IsItemEdited() /*-{ }-*/; /* + return ImGui::IsItemEdited(); + */ + + static native boolean IsItemActivated() /*-{ }-*/; /* + return ImGui::IsItemActivated(); + */ + + static native boolean IsItemDeactivated() /*-{ }-*/; /* + return ImGui::IsItemDeactivated(); + */ + + static native boolean IsItemDeactivatedAfterEdit() /*-{ }-*/; /* + return ImGui::IsItemDeactivatedAfterEdit(); + */ + + static native boolean IsAnyItemHovered() /*-{ }-*/; /* + return ImGui::IsAnyItemHovered(); + */ + + static native boolean IsAnyItemActive() /*-{ }-*/; /* + return ImGui::IsAnyItemActive(); + */ + + static native boolean IsAnyItemFocused() /*-{ }-*/; /* + return ImGui::IsAnyItemFocused(); + */ + + static native void GetItemRectMin(ImVec2 jImVec2) /*-{ }-*/; /* + ImVec2 vec = ImGui::GetItemRectMin(); + env->SetFloatField (jImVec2, imVec2XID, vec.x); + env->SetFloatField (jImVec2, imVec2YID, vec.y); + */ + + static native void GetItemRectMax(ImVec2 jImVec2) /*-{ }-*/; /* + ImVec2 vec = ImGui::GetItemRectMax(); + env->SetFloatField (jImVec2, imVec2XID, vec.x); + env->SetFloatField (jImVec2, imVec2YID, vec.y); + */ + + static native void GetItemRectSize(ImVec2 jImVec2) /*-{ }-*/; /* + ImVec2 vec = ImGui::GetItemRectSize(); + env->SetFloatField (jImVec2, imVec2XID, vec.x); + env->SetFloatField (jImVec2, imVec2YID, vec.y); + */ + + // Miscellaneous Utilities + + static native void SetItemAllowOverlap() /*-{ }-*/; /* + ImGui::SetItemAllowOverlap(); + */ + + static native boolean BeginChildFrame(int id, float width, float height) /*-{ }-*/; /* + return ImGui::BeginChildFrame(id, ImVec2(width, height)); + */ + + static native boolean BeginChildFrame(int id, float width, float height, int flags) /*-{ }-*/; /* + return ImGui::BeginChildFrame(id, ImVec2(width, height), flags); + */ + + // Inputs Utilities + + static native void EndChildFrame() /*-{ }-*/; /* + ImGui::EndChildFrame(); + */ + + static native boolean IsMouseDown(int button) /*-{ }-*/; /* + return ImGui::IsMouseDown(button); + */ + + static native boolean IsMouseClicked(int button) /*-{ }-*/; /* + return ImGui::IsMouseClicked(button); + */ + + static native boolean IsMouseClicked(int button, boolean repeat) /*-{ }-*/; /* + return ImGui::IsMouseClicked(button, repeat); + */ + + static native boolean IsMouseReleased(int button) /*-{ }-*/; /* + return ImGui::IsMouseReleased(button); + */ + + static native boolean IsMouseDragging() /*-{ }-*/; /* + return ImGui::IsMouseDragging(); + */ + + static native boolean IsMouseDragging(int button) /*-{ }-*/; /* + return ImGui::IsMouseDragging(button); + */ + + static native boolean IsMouseDragging(int button, float lock_threshold) /*-{ }-*/; /* + return ImGui::IsMouseDragging(button, lock_threshold); + */ + + static native boolean IsMouseHoveringRect(float minX, float minY, float maxX, float maxY) /*-{ }-*/; /* + return ImGui::IsMouseHoveringRect(ImVec2(minX, minY), ImVec2(maxX, maxY)); + */ + + static native boolean IsMouseHoveringRect(float minX, float minY, float maxX, float maxY, boolean clip) /*-{ }-*/; /* + return ImGui::IsMouseHoveringRect(ImVec2(minX, minY), ImVec2(maxX, maxY), clip); + */ + + // @formatter:on +} diff --git a/imgui-binding/src/main/java/imgui/NativeCustomWidget.java b/imgui-binding/src/main/java/imgui/NativeCustomWidget.java new file mode 100644 index 0000000..60fb6cb --- /dev/null +++ b/imgui-binding/src/main/java/imgui/NativeCustomWidget.java @@ -0,0 +1,168 @@ +package imgui; + +import imgui.enums.ImDrawCornerFlags; + +class NativeCustomWidget { + public static ImGuiCollapseLayoutOptions defaultOptions = new ImGuiCollapseLayoutOptions(); + + // @formatter:off + + /*JNI + #include + + jfieldID paddingLeftID; + jfieldID paddingRightID; + jfieldID paddingTopID; + jfieldID paddingBottomID; + jfieldID arrowColorID; + jfieldID arrowBackgroundHoveredColorID; + jfieldID arrowBackgroundClickedColorID; + jfieldID frameColorID; + jfieldID borderColorID; + jfieldID borderRoundID; + jfieldID roundingCornersID; + */ + + static native void init() /*-{ }-*/; /* + jclass jLayoutOptionsClass = env->FindClass("imgui/NativeCustomWidget"); + paddingLeftID = env->GetFieldID(jLayoutOptionsClass, "paddingLeft", "F"); + paddingRightID = env->GetFieldID(jLayoutOptionsClass, "paddingRight", "F"); + paddingTopID = env->GetFieldID(jLayoutOptionsClass, "paddingTop", "F"); + paddingBottomID = env->GetFieldID(jLayoutOptionsClass, "paddingBottom", "F"); + arrowColorID = env->GetFieldID(jLayoutOptionsClass, "arrowColor", "I"); + arrowBackgroundHoveredColorID = env->GetFieldID(jLayoutOptionsClass, "arrowBackgroundHoveredColor", "I"); + arrowBackgroundClickedColorID = env->GetFieldID(jLayoutOptionsClass, "arrowBackgroundClickedColor", "I"); + frameColorID = env->GetFieldID(jLayoutOptionsClass, "frameColor", "I"); + borderColorID = env->GetFieldID(jLayoutOptionsClass, "borderColor", "I"); + borderRoundID = env->GetFieldID(jLayoutOptionsClass, "borderRound", "I"); + roundingCornersID = env->GetFieldID(jLayoutOptionsClass, "roundingCorners", "I"); + */ + + static { + init(); + } + + static native void ShowLayoutDebug() /*-{ }-*/; /* + ImGuiEx::ShowLayoutDebug(); + */ + + static native void BeginLayout(String id, float sizeX, float sizeY); /*-{ }-*/; /* + ImGuiEx::BeginLayout(id, sizeX, sizeY); + */ + + static native void BeginLayout(String id, float sizeX, float sizeY, float paddingLeft, float paddingRight, float paddingTop, float paddingBottom); /*-{ }-*/; /* + ImGuiEx::BeginLayout(id, sizeX, sizeY, paddingLeft, paddingRight, paddingTop, paddingBottom); + */ + + static native void EndLayout(); /*-{ }-*/; /* + ImGuiEx::EndLayout(); + */ + + static native boolean BeginCollapseLayoutEx2(String title, float sizeX, float sizeY, ImGuiCollapseLayoutOptions jOptions); /*-{ }-*/; /* + ImGuiCollapseLayoutOptions options; + options.paddingLeft = env->GetFloatField (jOptions, paddingLeftID); + options.paddingRight = env->GetFloatField (jOptions, paddingRightID); + options.paddingTop = env->GetFloatField (jOptions, paddingTopID); + options.paddingBottom = env->GetFloatField (jOptions, paddingBottomID); + options.arrowColor = env->GetIntField (jOptions, arrowColorID); + options.arrowBackgroundHoveredColor = env->GetIntField (jOptions, arrowBackgroundHoveredColorID); + options.arrowBackgroundClickedColor = env->GetIntField (jOptions, arrowBackgroundClickedColorID); + options.frameColor = env->GetIntField (jOptions, frameColorID); + options.borderColor = env->GetIntField (jOptions, borderColorID); + options.borderRound = env->GetIntField (jOptions, borderRoundID); + options.roundingCorners = env->GetIntField (jOptions, roundingCornersID); + return ImGuiEx::BeginCollapseLayoutEx(title, sizeX, sizeY, options); + */ + + static native void BeginCollapseLayoutEx(boolean [] isOpen, String title, float sizeX, float sizeY, ImGuiCollapseLayoutOptions jOptions); /*-{ }-*/; /* + ImGuiCollapseLayoutOptions options; + options.paddingLeft = env->GetFloatField (jOptions, paddingLeftID); + options.paddingRight = env->GetFloatField (jOptions, paddingRightID); + options.paddingTop = env->GetFloatField (jOptions, paddingTopID); + options.paddingBottom = env->GetFloatField (jOptions, paddingBottomID); + options.arrowColor = env->GetIntField (jOptions, arrowColorID); + options.arrowBackgroundHoveredColor = env->GetIntField (jOptions, arrowBackgroundHoveredColorID); + options.arrowBackgroundClickedColor = env->GetIntField (jOptions, arrowBackgroundClickedColorID); + options.frameColor = env->GetIntField (jOptions, frameColorID); + options.borderColor = env->GetIntField (jOptions, borderColorID); + options.borderRound = env->GetIntField (jOptions, borderRoundID); + options.roundingCorners = env->GetIntField (jOptions, roundingCornersID); + ImGuiEx::BeginCollapseLayoutEx(&isOpen[0], title, sizeX, sizeY, options); + */ + + static native boolean BeginCollapseLayout2(String title, float sizeX, float sizeY, ImGuiCollapseLayoutOptions jOptions); /*-{ }-*/; /* + ImGuiCollapseLayoutOptions options; + options.paddingLeft = env->GetFloatField (jOptions, paddingLeftID); + options.paddingRight = env->GetFloatField (jOptions, paddingRightID); + options.paddingTop = env->GetFloatField (jOptions, paddingTopID); + options.paddingBottom = env->GetFloatField (jOptions, paddingBottomID); + options.arrowColor = env->GetIntField (jOptions, arrowColorID); + options.arrowBackgroundHoveredColor = env->GetIntField (jOptions, arrowBackgroundHoveredColorID); + options.arrowBackgroundClickedColor = env->GetIntField (jOptions, arrowBackgroundClickedColorID); + options.frameColor = env->GetIntField (jOptions, frameColorID); + options.borderColor = env->GetIntField (jOptions, borderColorID); + options.borderRound = env->GetIntField (jOptions, borderRoundID); + options.roundingCorners = env->GetIntField (jOptions, roundingCornersID); + return ImGuiEx::BeginCollapseLayout(title, sizeX, sizeY, options); + */ + + static native void BeginCollapseLayout(boolean [] isOpen, String title, float sizeX, float sizeY, ImGuiCollapseLayoutOptions jOptions); /*-{ }-*/; /* + ImGuiCollapseLayoutOptions options; + options.paddingLeft = env->GetFloatField (jOptions, paddingLeftID); + options.paddingRight = env->GetFloatField (jOptions, paddingRightID); + options.paddingTop = env->GetFloatField (jOptions, paddingTopID); + options.paddingBottom = env->GetFloatField (jOptions, paddingBottomID); + options.arrowColor = env->GetIntField (jOptions, arrowColorID); + options.arrowBackgroundHoveredColor = env->GetIntField (jOptions, arrowBackgroundHoveredColorID); + options.arrowBackgroundClickedColor = env->GetIntField (jOptions, arrowBackgroundClickedColorID); + options.frameColor = env->GetIntField (jOptions, frameColorID); + options.borderColor = env->GetIntField (jOptions, borderColorID); + options.borderRound = env->GetIntField (jOptions, borderRoundID); + options.roundingCorners = env->GetIntField (jOptions, roundingCornersID); + ImGuiEx::BeginCollapseLayout(&isOpen[0], title, sizeX, sizeY, options); + */ + + static native void EndCollapseFrameLayout(); /*-{ }-*/; /* + ImGuiEx::EndCollapseFrameLayout(); + */ + + static native void EndCollapseLayout(); /*-{ }-*/; /* + ImGuiEx::EndCollapseLayout(); + */ + + static native void BeginAlign(String id, float sizeX, float sizeY, float alignX, float alignY) /*-{ }-*/; /* + ImGuiEx::BeginAlign(id, sizeX, sizeY, alignX, alignY); + */ + + static native void BeginAlign(String id, float sizeX, float sizeY, float alignX, float alignY, float offsetX, float offsetY) /*-{ }-*/; /* + ImGuiEx::BeginAlign(id, sizeX, sizeY, alignX, alignY, offsetX, offsetY); + */ + + static native void EndAlign() /*-{ }-*/; /* + ImGuiEx::EndAlign(); + */ + + static native void AlignLayout(float alignX, float alignY) /*-{ }-*/; /* + ImGuiEx::AlignLayout(alignX, alignY); + */ + + static native void AlignLayout(float alignX, float alignY, float offsetX, float offsetY) /*-{ }-*/; /* + ImGuiEx::AlignLayout(alignX, alignY, offsetX, offsetY); + */ + + // @formatter:on + + public static class ImGuiCollapseLayoutOptions { + public float paddingLeft = 2; + public float paddingRight = 2; + public float paddingTop = 2; + public float paddingBottom = 2; + public int arrowColor = ImGuiEx.colorToIntBits(0xFF, 0xFF, 0xFF, 0xFF); + public int arrowBackgroundHoveredColor = ImGuiEx.colorToIntBits(0x77, 0x77, 0x77, 0xFF); + public int arrowBackgroundClickedColor = ImGuiEx.colorToIntBits(0x55, 0x55, 0x55, 0xFF); + public int frameColor = ImGuiEx.colorToIntBits(0x24, 0x24, 0x24, 0xFF); + public int borderColor = ImGuiEx.colorToIntBits(0x40, 0x40, 0x49, 0xFF); + public int borderRound = 4; + public int roundingCorners = ImDrawCornerFlags.TopLeft.or(ImDrawCornerFlags.TopRight).getValue(); + } +} diff --git a/imgui-binding/src/main/java/imgui/NativeInternal.java b/imgui-binding/src/main/java/imgui/NativeInternal.java new file mode 100644 index 0000000..278c973 --- /dev/null +++ b/imgui-binding/src/main/java/imgui/NativeInternal.java @@ -0,0 +1,28 @@ +package imgui; + +/** + * Same as {@link Native} but "imgui_internal.h" API. + */ +class NativeInternal { + // @formatter:off + + /*JNI + #include + #include + */ + + public static native void PushMultiItemsWidths(int components, float w_full) /*-{ }-*/; /* + ImGui::PushMultiItemsWidths(components, w_full); + */ + + public static native boolean ItemAdd(float x1, float y1, float x2, float y2, String id) /*-{ }-*/; /* + ImGuiID imGuiID = ImGui::GetID(id); + return ImGui::ItemAdd(ImRect(x1, y1, x2, y2), imGuiID); + */ + + public static native void ItemSize(float x1, float y1, float x2, float y2, float text_offset_y) /*-{ }-*/; /* + ImGui::ItemSize(ImRect(x1, y1, x2, y2), text_offset_y); + */ + + // @formatter:on +} diff --git a/imgui-binding/src/main/java/imgui/TexDataRGBA32.java b/imgui-binding/src/main/java/imgui/TexDataRGBA32.java new file mode 100644 index 0000000..63c15ae --- /dev/null +++ b/imgui-binding/src/main/java/imgui/TexDataRGBA32.java @@ -0,0 +1,18 @@ +package imgui; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; + +public class TexDataRGBA32 { + public int width; + public int height; + + public ByteBuffer pixelBuffer; + + public TexDataRGBA32() { + int pixelMax = 131072; + ByteBuffer buffer = ByteBuffer.allocateDirect(pixelMax); + buffer.order(ByteOrder.nativeOrder()); + pixelBuffer = buffer; + } +} diff --git a/imgui-binding/src/main/java/imgui/enums/ImDrawCornerFlags.java b/imgui-binding/src/main/java/imgui/enums/ImDrawCornerFlags.java new file mode 100644 index 0000000..3fb772a --- /dev/null +++ b/imgui-binding/src/main/java/imgui/enums/ImDrawCornerFlags.java @@ -0,0 +1,28 @@ +package imgui.enums; + +public class ImDrawCornerFlags { + public static ImDrawCornerFlags TopLeft = new ImDrawCornerFlags(1 << 0); + public static ImDrawCornerFlags TopRight = new ImDrawCornerFlags(1 << 1); + public static ImDrawCornerFlags BotLeft = new ImDrawCornerFlags(1 << 2); + public static ImDrawCornerFlags BotRight = new ImDrawCornerFlags(1 << 3); + public static ImDrawCornerFlags Top = new ImDrawCornerFlags(TopLeft.getValue() | TopRight.getValue()); + public static ImDrawCornerFlags Bot = new ImDrawCornerFlags(BotLeft.getValue() | BotRight.getValue()); + public static ImDrawCornerFlags Left = new ImDrawCornerFlags(TopLeft.getValue() | BotLeft.getValue()); + public static ImDrawCornerFlags Right = new ImDrawCornerFlags(TopRight.getValue() | BotRight.getValue()); + public static ImDrawCornerFlags All = new ImDrawCornerFlags(0xF); + private static ImDrawCornerFlags Custom = new ImDrawCornerFlags(0); + int value; + + private ImDrawCornerFlags(int code) { + value = code; + } + + public ImDrawCornerFlags or(ImDrawCornerFlags otherEnum) { + ImDrawCornerFlags.Custom.value = value | otherEnum.value; + return ImDrawCornerFlags.Custom; + } + + public int getValue() { + return value; + } +} diff --git a/imgui-binding/src/main/java/imgui/enums/ImGuiBackendFlags.java b/imgui-binding/src/main/java/imgui/enums/ImGuiBackendFlags.java new file mode 100644 index 0000000..0941c14 --- /dev/null +++ b/imgui-binding/src/main/java/imgui/enums/ImGuiBackendFlags.java @@ -0,0 +1,26 @@ +package imgui.enums; + +/** + * Back-end capabilities flags stored in io.BackendFlags. Set by imgui_impl_xxx or custom back-end. + */ +public class ImGuiBackendFlags { + public static ImGuiBackendFlags None = new ImGuiBackendFlags(0); + public static ImGuiBackendFlags HasGamepad = new ImGuiBackendFlags(1 << 0); + public static ImGuiBackendFlags HasMouseCursors = new ImGuiBackendFlags(1 << 1); + public static ImGuiBackendFlags HasSetMousePos = new ImGuiBackendFlags(1 << 2); + private static ImGuiBackendFlags Custom = new ImGuiBackendFlags(0); + int value; + + private ImGuiBackendFlags(int code) { + value = code; + } + + public ImGuiBackendFlags or(ImGuiBackendFlags otherEnum) { + ImGuiBackendFlags.Custom.value = value | otherEnum.value; + return ImGuiBackendFlags.Custom; + } + + public int getValue() { + return value; + } +} diff --git a/imgui-binding/src/main/java/imgui/enums/ImGuiCol.java b/imgui-binding/src/main/java/imgui/enums/ImGuiCol.java new file mode 100644 index 0000000..2c18d1e --- /dev/null +++ b/imgui-binding/src/main/java/imgui/enums/ImGuiCol.java @@ -0,0 +1,89 @@ +package imgui.enums; + +public enum ImGuiCol { + Text(0), + TextDisabled(1), + /** + * Background of normal windows + */ + WindowBg(2), + /** + * Background of child windows + */ + ChildBg(3), + /** + * Background of popups, menus, tooltips windows + */ + PopupBg(4), + Border(5), + BorderShadow(6), + /** + * Background of checkbox, radio button, plot, slider, text input + */ + FrameBg(7), + FrameBgHovered(8), + FrameBgActive(9), + TitleBg(10), + TitleBgActive(11), + TitleBgCollapsed(12), + MenuBarBg(13), + ScrollbarBg(14), + ScrollbarGrab(15), + ScrollbarGrabHovered(16), + ScrollbarGrabActive(17), + CheckMark(18), + SliderGrab(19), + SliderGrabActive(20), + Button(21), + ButtonHovered(22), + ButtonActive(23), + Header(24), + HeaderHovered(25), + HeaderActive(26), + Separator(27), + SeparatorHovered(28), + SeparatorActive(29), + ResizeGrip(30), + ResizeGripHovered(31), + ResizeGripActive(32), + Tab(33), + TabHovered(34), + TabActive(35), + TabUnfocused(36), + TabUnfocusedActive(37), + DockingPrevie(38), + DockingEmptyBg(39), + PlotLines(40), + PlotLinesHovered(41), + PlotHistogram(42), + PlotHistogramHovered(43), + TextSelectedBg(44), + DragDropTarget(45), + /** + * Gamepad/keyboard: current highlighted item + */ + NavHighlight(46), + /** + * Highlight window when using CTRL+TAB + */ + NavWindowingHighlight(47), + /** + * Darken/colorize entire screen behind the CTRL+TAB window list, when active + */ + NavWindowingDimBg(48), + /** + * Darken/colorize entire screen behind a modal window, when one is active + */ + ModalWindowDimBg(49), + COUNT(48); + + int value; + + ImGuiCol(int code) { + value = code; + } + + public int getValue() { + return value; + } +} diff --git a/imgui-binding/src/main/java/imgui/enums/ImGuiColorEditFlags.java b/imgui-binding/src/main/java/imgui/enums/ImGuiColorEditFlags.java new file mode 100644 index 0000000..5c7b8d7 --- /dev/null +++ b/imgui-binding/src/main/java/imgui/enums/ImGuiColorEditFlags.java @@ -0,0 +1,47 @@ +package imgui.enums; + +/** + * Enumeration for GetMouseCursor() + * User code may request binding to display given cursor by calling SetMouseCursor(), which is why we have some cursors that are marked unused here + */ +public class ImGuiColorEditFlags { + public static ImGuiColorEditFlags None = new ImGuiColorEditFlags(0); + public static ImGuiColorEditFlags NoAlpha = new ImGuiColorEditFlags(1 << 1); + public static ImGuiColorEditFlags NoPicker = new ImGuiColorEditFlags(1 << 2); + public static ImGuiColorEditFlags NoOptions = new ImGuiColorEditFlags(1 << 3); + public static ImGuiColorEditFlags NoSmallPreview = new ImGuiColorEditFlags(1 << 4); + public static ImGuiColorEditFlags NoInputs = new ImGuiColorEditFlags(1 << 5); + public static ImGuiColorEditFlags NoTooltip = new ImGuiColorEditFlags(1 << 6); + public static ImGuiColorEditFlags NoLabel = new ImGuiColorEditFlags(1 << 7); + public static ImGuiColorEditFlags NoSidePreview = new ImGuiColorEditFlags(1 << 8); + public static ImGuiColorEditFlags NoDragDrop = new ImGuiColorEditFlags(1 << 9); + public static ImGuiColorEditFlags AlphaBar = new ImGuiColorEditFlags(1 << 16); + public static ImGuiColorEditFlags AlphaPreview = new ImGuiColorEditFlags(1 << 17); + public static ImGuiColorEditFlags AlphaPreviewHalf = new ImGuiColorEditFlags(1 << 18); + public static ImGuiColorEditFlags HDR = new ImGuiColorEditFlags(1 << 19); + public static ImGuiColorEditFlags DisplayRGB = new ImGuiColorEditFlags(1 << 20); + public static ImGuiColorEditFlags DisplayHSV = new ImGuiColorEditFlags(1 << 21); + public static ImGuiColorEditFlags DisplayHex = new ImGuiColorEditFlags(1 << 22); + public static ImGuiColorEditFlags Uint8 = new ImGuiColorEditFlags(1 << 23); + public static ImGuiColorEditFlags Float = new ImGuiColorEditFlags(1 << 24); + public static ImGuiColorEditFlags PickerHueBar = new ImGuiColorEditFlags(1 << 25); + public static ImGuiColorEditFlags PickerHueWheel = new ImGuiColorEditFlags(1 << 26); + public static ImGuiColorEditFlags InputRGB = new ImGuiColorEditFlags(1 << 27); + public static ImGuiColorEditFlags InputHSV = new ImGuiColorEditFlags(1 << 28); + public static ImGuiColorEditFlags OptionsDefault = new ImGuiColorEditFlags(Uint8.getValue() | DisplayRGB.getValue() | InputRGB.getValue() | PickerHueBar.getValue()); + private static ImGuiColorEditFlags Custom = new ImGuiColorEditFlags(0); + int value; + + private ImGuiColorEditFlags(int code) { + value = code; + } + + public ImGuiColorEditFlags or(ImGuiColorEditFlags otherEnum) { + ImGuiColorEditFlags.Custom.value = value | otherEnum.value; + return ImGuiColorEditFlags.Custom; + } + + public int getValue() { + return value; + } +} diff --git a/imgui-binding/src/main/java/imgui/enums/ImGuiComboFlags.java b/imgui-binding/src/main/java/imgui/enums/ImGuiComboFlags.java new file mode 100644 index 0000000..be97ac5 --- /dev/null +++ b/imgui-binding/src/main/java/imgui/enums/ImGuiComboFlags.java @@ -0,0 +1,31 @@ +package imgui.enums; + +/** + * Flags for ImGui::BeginCombo() + */ +public class ImGuiComboFlags { + public static ImGuiComboFlags None = new ImGuiComboFlags(0); + public static ImGuiComboFlags PopupAlignLeft = new ImGuiComboFlags(1 << 0); + public static ImGuiComboFlags HeightSmall = new ImGuiComboFlags(1 << 1); + public static ImGuiComboFlags HeightRegular = new ImGuiComboFlags(1 << 2); + public static ImGuiComboFlags HeightLarge = new ImGuiComboFlags(1 << 3); + public static ImGuiComboFlags HeightLargest = new ImGuiComboFlags(1 << 4); + public static ImGuiComboFlags NoArrowButton = new ImGuiComboFlags(1 << 5); + public static ImGuiComboFlags NoPreview = new ImGuiComboFlags(1 << 6); + public static ImGuiComboFlags HeightMask = new ImGuiComboFlags(HeightSmall.getValue() | HeightRegular.getValue() | HeightLarge.getValue() | HeightLargest.getValue()); + private static ImGuiComboFlags Custom = new ImGuiComboFlags(0); + int value; + + private ImGuiComboFlags(int code) { + value = code; + } + + public ImGuiComboFlags or(ImGuiComboFlags otherEnum) { + ImGuiComboFlags.Custom.value = value | otherEnum.value; + return ImGuiComboFlags.Custom; + } + + public int getValue() { + return value; + } +} diff --git a/imgui-binding/src/main/java/imgui/enums/ImGuiCond.java b/imgui-binding/src/main/java/imgui/enums/ImGuiCond.java new file mode 100644 index 0000000..85d6405 --- /dev/null +++ b/imgui-binding/src/main/java/imgui/enums/ImGuiCond.java @@ -0,0 +1,28 @@ +package imgui.enums; + +/** + * Enumateration for ImGui::SetWindow***(), SetNextWindow***(), SetNextTreeNode***() functions + * Represent a condition. + * Important: Treat as a regular enum! Do NOT combine multiple values using binary operators! All the functions above treat 0 as a shortcut to ImGuiCond_Always. + */ +public class ImGuiCond { + public static ImGuiCond Always = new ImGuiCond(1 << 0); + public static ImGuiCond Once = new ImGuiCond(1 << 1); + public static ImGuiCond FirstUseEver = new ImGuiCond(1 << 2); + public static ImGuiCond Appearing = new ImGuiCond(1 << 3); + private static ImGuiCond Custom = new ImGuiCond(0); + int value; + + private ImGuiCond(int code) { + value = code; + } + + public ImGuiCond or(ImGuiCond otherEnum) { + ImGuiCond.Custom.value = value | otherEnum.value; + return ImGuiCond.Custom; + } + + public int getValue() { + return value; + } +} diff --git a/imgui-binding/src/main/java/imgui/enums/ImGuiConfigFlags.java b/imgui-binding/src/main/java/imgui/enums/ImGuiConfigFlags.java new file mode 100644 index 0000000..0796c2d --- /dev/null +++ b/imgui-binding/src/main/java/imgui/enums/ImGuiConfigFlags.java @@ -0,0 +1,32 @@ +package imgui.enums; + +/** + * Configuration flags stored in io.ConfigFlags. Set by user/application. + */ +public class ImGuiConfigFlags { + public static ImGuiConfigFlags None = new ImGuiConfigFlags(0); + public static ImGuiConfigFlags NavEnableKeyboard = new ImGuiConfigFlags(1 << 0); + public static ImGuiConfigFlags NavEnableGamepad = new ImGuiConfigFlags(1 << 1); + public static ImGuiConfigFlags NavEnableSetMousePos = new ImGuiConfigFlags(1 << 2); + public static ImGuiConfigFlags NavNoCaptureKeyboard = new ImGuiConfigFlags(1 << 3); + public static ImGuiConfigFlags NoMouse = new ImGuiConfigFlags(1 << 4); + public static ImGuiConfigFlags NoMouseCursorChange = new ImGuiConfigFlags(1 << 5); + public static ImGuiConfigFlags DockingEnable = new ImGuiConfigFlags(1 << 6); + public static ImGuiConfigFlags IsSRGB = new ImGuiConfigFlags(1 << 20); + public static ImGuiConfigFlags IsTouchScreen = new ImGuiConfigFlags(1 << 21); + private static ImGuiConfigFlags Custom = new ImGuiConfigFlags(0); + int value; + + private ImGuiConfigFlags(int code) { + value = code; + } + + public ImGuiConfigFlags or(ImGuiConfigFlags otherEnum) { + ImGuiConfigFlags.Custom.value = value | otherEnum.value; + return ImGuiConfigFlags.Custom; + } + + public int getValue() { + return value; + } +} diff --git a/imgui-binding/src/main/java/imgui/enums/ImGuiDataType.java b/imgui-binding/src/main/java/imgui/enums/ImGuiDataType.java new file mode 100644 index 0000000..f4083e3 --- /dev/null +++ b/imgui-binding/src/main/java/imgui/enums/ImGuiDataType.java @@ -0,0 +1,28 @@ +package imgui.enums; + +/** + * A primary data type + */ +public enum ImGuiDataType { + S8(0), + U8(1), + S16(2), + U16(3), + S32(4), + U32(5), + S64(6), + U64(7), + Float(8), + Double(9), + COUNT(10); + + int value; + + ImGuiDataType(int code) { + value = code; + } + + public int getValue() { + return value; + } +} diff --git a/imgui-binding/src/main/java/imgui/enums/ImGuiDir.java b/imgui-binding/src/main/java/imgui/enums/ImGuiDir.java new file mode 100644 index 0000000..d639acf --- /dev/null +++ b/imgui-binding/src/main/java/imgui/enums/ImGuiDir.java @@ -0,0 +1,20 @@ +package imgui.enums; + +public enum ImGuiDir { + None(-1), + Left(0), + Right(1), + Up(2), + Down(3), + COUNT(4); + + private final int code; + + ImGuiDir(int code) { + this.code = code; + } + + public int toInt() { + return code; + } +} diff --git a/imgui-binding/src/main/java/imgui/enums/ImGuiDockNodeFlags.java b/imgui-binding/src/main/java/imgui/enums/ImGuiDockNodeFlags.java new file mode 100644 index 0000000..c14384f --- /dev/null +++ b/imgui-binding/src/main/java/imgui/enums/ImGuiDockNodeFlags.java @@ -0,0 +1,25 @@ +package imgui.enums; + +public class ImGuiDockNodeFlags { + public static ImGuiDockNodeFlags KeepAliveOnly = new ImGuiDockNodeFlags(1 << 0); + public static ImGuiDockNodeFlags NoDockingInCentralNode = new ImGuiDockNodeFlags(1 << 2); + public static ImGuiDockNodeFlags PassthruCentralNode = new ImGuiDockNodeFlags(1 << 3); + public static ImGuiDockNodeFlags NoSplit = new ImGuiDockNodeFlags(1 << 4); + public static ImGuiDockNodeFlags NoResize = new ImGuiDockNodeFlags(1 << 5); + public static ImGuiDockNodeFlags AutoHideTabBar = new ImGuiDockNodeFlags(1 << 6); + private static ImGuiDockNodeFlags Custom = new ImGuiDockNodeFlags(0); + int value; + + private ImGuiDockNodeFlags(int code) { + value = code; + } + + public ImGuiDockNodeFlags or(ImGuiDockNodeFlags otherEnum) { + ImGuiDockNodeFlags.Custom.value = value | otherEnum.value; + return ImGuiDockNodeFlags.Custom; + } + + public int getValue() { + return value; + } +} diff --git a/imgui-binding/src/main/java/imgui/enums/ImGuiDragDropFlags.java b/imgui-binding/src/main/java/imgui/enums/ImGuiDragDropFlags.java new file mode 100644 index 0000000..fb797af --- /dev/null +++ b/imgui-binding/src/main/java/imgui/enums/ImGuiDragDropFlags.java @@ -0,0 +1,37 @@ +package imgui.enums; + +/** + * Flags for ImGui::IsItemHovered(), ImGui::IsWindowHovered() + * Note: if you are trying to check whether your mouse should be dispatched to imgui or to your app, you should use the 'io.WantCaptureMouse' boolean for that. Please read the FAQ! + * Note: windows with the ImGuiWindowFlags_NoInputs flag are ignored by IsWindowHovered() calls. + */ +public class ImGuiDragDropFlags { + public static ImGuiDragDropFlags None = new ImGuiDragDropFlags(0); + // BeginDragDropSource() flags + public static ImGuiDragDropFlags SourceNoPreviewTooltip = new ImGuiDragDropFlags(1 << 0); + public static ImGuiDragDropFlags SourceNoDisableHover = new ImGuiDragDropFlags(1 << 1); + public static ImGuiDragDropFlags SourceNoHoldToOpenOthers = new ImGuiDragDropFlags(1 << 2); + public static ImGuiDragDropFlags SourceAllowNullID = new ImGuiDragDropFlags(1 << 3); + public static ImGuiDragDropFlags SourceExtern = new ImGuiDragDropFlags(1 << 4); + public static ImGuiDragDropFlags SourceAutoExpirePayload = new ImGuiDragDropFlags(1 << 5); + // AcceptDragDropPayload() flags + public static ImGuiDragDropFlags AcceptBeforeDelivery = new ImGuiDragDropFlags(1 << 10); + public static ImGuiDragDropFlags AcceptNoDrawDefaultRect = new ImGuiDragDropFlags(1 << 11); + public static ImGuiDragDropFlags AcceptNoPreviewTooltip = new ImGuiDragDropFlags(1 << 12); + public static ImGuiDragDropFlags AcceptPeekOnly = new ImGuiDragDropFlags(AcceptBeforeDelivery.getValue() | AcceptNoDrawDefaultRect.getValue()); + private static ImGuiDragDropFlags Custom = new ImGuiDragDropFlags(0); + int value; + + private ImGuiDragDropFlags(int code) { + value = code; + } + + public ImGuiDragDropFlags or(ImGuiDragDropFlags otherEnum) { + ImGuiDragDropFlags.Custom.value = value | otherEnum.value; + return ImGuiDragDropFlags.Custom; + } + + public int getValue() { + return value; + } +} diff --git a/imgui-binding/src/main/java/imgui/enums/ImGuiFocusedFlags.java b/imgui-binding/src/main/java/imgui/enums/ImGuiFocusedFlags.java new file mode 100644 index 0000000..101e498 --- /dev/null +++ b/imgui-binding/src/main/java/imgui/enums/ImGuiFocusedFlags.java @@ -0,0 +1,27 @@ +package imgui.enums; + +/** + * Flags for ImGui::IsWindowFocused() + */ +public class ImGuiFocusedFlags { + public static ImGuiFocusedFlags None = new ImGuiFocusedFlags(0); + public static ImGuiFocusedFlags ChildWindows = new ImGuiFocusedFlags(1 << 0); + public static ImGuiFocusedFlags RootWindow = new ImGuiFocusedFlags(1 << 1); + public static ImGuiFocusedFlags AnyWindow = new ImGuiFocusedFlags(1 << 2); + public static ImGuiFocusedFlags RootAndChildWindows = new ImGuiFocusedFlags(RootWindow.getValue() | ChildWindows.getValue()); + private static ImGuiFocusedFlags Custom = new ImGuiFocusedFlags(0); + int value; + + private ImGuiFocusedFlags(int code) { + value = code; + } + + public ImGuiFocusedFlags or(ImGuiFocusedFlags otherEnum) { + ImGuiFocusedFlags.Custom.value = value | otherEnum.value; + return ImGuiFocusedFlags.Custom; + } + + public int getValue() { + return value; + } +} diff --git a/imgui-binding/src/main/java/imgui/enums/ImGuiHoveredFlags.java b/imgui-binding/src/main/java/imgui/enums/ImGuiHoveredFlags.java new file mode 100644 index 0000000..27f4b15 --- /dev/null +++ b/imgui-binding/src/main/java/imgui/enums/ImGuiHoveredFlags.java @@ -0,0 +1,35 @@ +package imgui.enums; + +/** + * Flags for ImGui::IsItemHovered(), ImGui::IsWindowHovered() + * Note: if you are trying to check whether your mouse should be dispatched to imgui or to your app, you should use the 'io.WantCaptureMouse' boolean for that. Please read the FAQ! + * Note: windows with the ImGuiWindowFlags_NoInputs flag are ignored by IsWindowHovered() calls. + */ +public class ImGuiHoveredFlags { + public static ImGuiHoveredFlags None = new ImGuiHoveredFlags(0); + public static ImGuiHoveredFlags ChildWindows = new ImGuiHoveredFlags(1 << 0); + public static ImGuiHoveredFlags RootWindow = new ImGuiHoveredFlags(1 << 1); + public static ImGuiHoveredFlags AnyWindow = new ImGuiHoveredFlags(1 << 2); + public static ImGuiHoveredFlags AllowWhenBlockedByPopup = new ImGuiHoveredFlags(1 << 3); + // public static ImGuiHoveredFlags AllowWhenBlockedByModal = new ImGuiHoveredFlags(1 << 4); + public static ImGuiHoveredFlags AllowWhenBlockedByActiveItem = new ImGuiHoveredFlags(1 << 5); + public static ImGuiHoveredFlags AllowWhenOverlapped = new ImGuiHoveredFlags(1 << 6); + public static ImGuiHoveredFlags AllowWhenDisabled = new ImGuiHoveredFlags(1 << 7); + public static ImGuiHoveredFlags RectOnly = new ImGuiHoveredFlags(AllowWhenBlockedByPopup.getValue() | AllowWhenBlockedByActiveItem.getValue() | AllowWhenOverlapped.getValue()); + public static ImGuiHoveredFlags RootAndChildWindows = new ImGuiHoveredFlags(RootWindow.getValue() | ChildWindows.getValue()); + private static ImGuiHoveredFlags Custom = new ImGuiHoveredFlags(0); + int value; + + private ImGuiHoveredFlags(int code) { + value = code; + } + + public ImGuiHoveredFlags or(ImGuiHoveredFlags otherEnum) { + ImGuiHoveredFlags.Custom.value = value | otherEnum.value; + return ImGuiHoveredFlags.Custom; + } + + public int getValue() { + return value; + } +} diff --git a/imgui-binding/src/main/java/imgui/enums/ImGuiInputTextFlags.java b/imgui-binding/src/main/java/imgui/enums/ImGuiInputTextFlags.java new file mode 100644 index 0000000..18c04bd --- /dev/null +++ b/imgui-binding/src/main/java/imgui/enums/ImGuiInputTextFlags.java @@ -0,0 +1,99 @@ +package imgui.enums; + +/** + * Flags for ImGui::InputText() + */ +public class ImGuiInputTextFlags { + public static ImGuiInputTextFlags None = new ImGuiInputTextFlags(0); + /** + * Allow 0123456789.+-* + */ + public static ImGuiInputTextFlags CharsDecimal = new ImGuiInputTextFlags(1 << 0); + /** + * Allow 0123456789ABCDEFabcdef + */ + public static ImGuiInputTextFlags CharsHexadecimal = new ImGuiInputTextFlags(1 << 1); + /** + * Turn a..z into A..Z + */ + public static ImGuiInputTextFlags CharsUppercase = new ImGuiInputTextFlags(1 << 2); + /** + * Filter out spaces, tabs + */ + public static ImGuiInputTextFlags CharsNoBlank = new ImGuiInputTextFlags(1 << 3); + /** + * Select entire text when first taking mouse focus + */ + public static ImGuiInputTextFlags AutoSelectAll = new ImGuiInputTextFlags(1 << 4); + /** + * Return 'true' when Enter is pressed (as opposed to every time the value was modified). Consider looking at the IsItemDeactivatedAfterEdit() function. + */ + public static ImGuiInputTextFlags EnterReturnsTrue = new ImGuiInputTextFlags(1 << 5); + /** + * Callback on pressing TAB (for completion handling) + */ + public static ImGuiInputTextFlags CallbackCompletion = new ImGuiInputTextFlags(1 << 6); + /** + * Callback on pressing Up/Down arrows (for history handling) + */ + public static ImGuiInputTextFlags CallbackHistory = new ImGuiInputTextFlags(1 << 7); + /** + * Callback on each iteration. User code may query cursor position, modify text buffer. + */ + public static ImGuiInputTextFlags CallbackAlways = new ImGuiInputTextFlags(1 << 8); + /** + * Callback on character inputs to replace or discard them. Modify 'EventChar' to replace or discard, or return 1 in callback to discard. + */ + public static ImGuiInputTextFlags CallbackCharFilter = new ImGuiInputTextFlags(1 << 9); + /** + * Pressing TAB input a '\t' character into the text field + */ + public static ImGuiInputTextFlags AllowTabInput = new ImGuiInputTextFlags(1 << 10); + /** + * In multi-line mode, unfocus with Enter, add new line with Ctrl+Enter (default is opposite: unfocus with Ctrl+Enter, add line with Enter). + */ + public static ImGuiInputTextFlags CtrlEnterForNewLine = new ImGuiInputTextFlags(1 << 11); + /** + * Disable following the cursor horizontally + */ + public static ImGuiInputTextFlags NoHorizontalScroll = new ImGuiInputTextFlags(1 << 12); + /** + * Insert mode + */ + public static ImGuiInputTextFlags AlwaysInsertMode = new ImGuiInputTextFlags(1 << 13); + /** + * Read-only mode + */ + public static ImGuiInputTextFlags ReadOnly = new ImGuiInputTextFlags(1 << 14); + /** + * Password mode, display all characters as '*' + */ + public static ImGuiInputTextFlags Password = new ImGuiInputTextFlags(1 << 15); + /** + * Disable undo/redo. Note that input text owns the text data while active, if you want to provide your own undo/redo stack you need e.g. to call ClearActiveID(). + */ + public static ImGuiInputTextFlags NoUndoRedo = new ImGuiInputTextFlags(1 << 16); + /** + * Allow 0123456789.+-*\\/eE (Scientific notation input) + */ + public static ImGuiInputTextFlags CharsScientific = new ImGuiInputTextFlags(1 << 17); + /** + * Callback on buffer capacity changes request (beyond 'buf_size' parameter value), allowing the string to grow. Notify when the string wants to be resized (for string types which hold a cache of their Size). You will be provided a new BufSize in the callback and NEED to honor it. (see misc/cpp/imgui_stdlib.h for an example of using this) + */ + public static ImGuiInputTextFlags CallbackResize = new ImGuiInputTextFlags(1 << 18); + private static ImGuiInputTextFlags Custom = new ImGuiInputTextFlags(0); + public int data; + + private ImGuiInputTextFlags(int code) { + data = code; + } + + public ImGuiInputTextFlags or(ImGuiInputTextFlags otherEnum) { + ImGuiInputTextFlags.Custom.data = data | otherEnum.data; + return ImGuiInputTextFlags.Custom; + } + + public int getValue() { + return data; + } +} diff --git a/imgui-binding/src/main/java/imgui/enums/ImGuiKey.java b/imgui-binding/src/main/java/imgui/enums/ImGuiKey.java new file mode 100644 index 0000000..06b43d9 --- /dev/null +++ b/imgui-binding/src/main/java/imgui/enums/ImGuiKey.java @@ -0,0 +1,39 @@ +package imgui.enums; + +/** + * User fill ImGuiIO.KeyMap[] array with indices into the ImGuiIO.KeysDown[512] array + */ +public enum ImGuiKey { + Tab(0), + LeftArrow(1), + RightArrow(2), + UpArrow(3), + DownArrow(4), + PageUp(5), + PageDown(6), + Home(7), + End(8), + Insert(9), + Delete(10), + Backspace(11), + Space(12), + Enter(13), + Escape(14), + A(15), + C(16), + V(17), + X(18), + Y(19), + Z(20), + COUNT(21); + + private final int code; + + ImGuiKey(int code) { + this.code = code; + } + + public int getValue() { + return code; + } +} diff --git a/imgui-binding/src/main/java/imgui/enums/ImGuiMouseCursor.java b/imgui-binding/src/main/java/imgui/enums/ImGuiMouseCursor.java new file mode 100644 index 0000000..0c94608 --- /dev/null +++ b/imgui-binding/src/main/java/imgui/enums/ImGuiMouseCursor.java @@ -0,0 +1,28 @@ +package imgui.enums; + +/** + * Enumeration for GetMouseCursor() + * User code may request binding to display given cursor by calling SetMouseCursor(), which is why we have some cursors that are marked unused here + */ +public enum ImGuiMouseCursor { + None(-1), + Arrow(0), + TextInput(1), + ResizeAll(2), + ResizeNS(3), + ResizeEW(4), + ResizeNESW(5), + ResizeNWSE(6), + Hand(7), + COUNT(8); + + int value; + + ImGuiMouseCursor(int code) { + value = code; + } + + public int getValue() { + return value; + } +} diff --git a/imgui-binding/src/main/java/imgui/enums/ImGuiNavInput.java b/imgui-binding/src/main/java/imgui/enums/ImGuiNavInput.java new file mode 100644 index 0000000..d60b8f5 --- /dev/null +++ b/imgui-binding/src/main/java/imgui/enums/ImGuiNavInput.java @@ -0,0 +1,36 @@ +package imgui.enums; + +/** + * Gamepad/Keyboard directional navigation + * Keyboard: Set io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard to enable. NewFrame() will automatically fill io.NavInputs[] based on your io.KeysDown[] + io.KeyMap[] arrays. + * Gamepad: Set io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad to enable. Back-end: set ImGuiBackendFlags_HasGamepad and fill the io.NavInputs[] fields before calling NewFrame(). Note that io.NavInputs[] is cleared by EndFrame(). + * Read instructions in imgui.cpp for more details. Download PNG/PSD at http://goo.gl/9LgVZW. + **/ +public enum ImGuiNavInput { + Activate(0), + Cancel(1), + Input(2), + Menu(3), + DpadLeft(4), + DpadRight(5), + DpadUp(6), + DpadDown(7), + LStickLeft(8), + LStickRight(9), + LStickUp(10), + LStickDown(11), + FocusPrev(12), + FocusNext(13), + TweakSlow(14), + TweakFast(15); + + private final int code; + + ImGuiNavInput(int code) { + this.code = code; + } + + public int toInt() { + return code; + } +} diff --git a/imgui-binding/src/main/java/imgui/enums/ImGuiSelectableFlags.java b/imgui-binding/src/main/java/imgui/enums/ImGuiSelectableFlags.java new file mode 100644 index 0000000..2e3623a --- /dev/null +++ b/imgui-binding/src/main/java/imgui/enums/ImGuiSelectableFlags.java @@ -0,0 +1,27 @@ +package imgui.enums; + +/** + * Flags for ImGui::Selectable() + */ +public class ImGuiSelectableFlags { + public static ImGuiSelectableFlags None = new ImGuiSelectableFlags(0); + public static ImGuiSelectableFlags DontClosePopups = new ImGuiSelectableFlags(1 << 0); + public static ImGuiSelectableFlags SpanAllColumns = new ImGuiSelectableFlags(1 << 1); + public static ImGuiSelectableFlags AllowDoubleClick = new ImGuiSelectableFlags(1 << 2); + public static ImGuiSelectableFlags Disabled = new ImGuiSelectableFlags(1 << 3); + private static ImGuiSelectableFlags Custom = new ImGuiSelectableFlags(0); + int value; + + private ImGuiSelectableFlags(int code) { + value = code; + } + + public ImGuiSelectableFlags or(ImGuiSelectableFlags otherEnum) { + ImGuiSelectableFlags.Custom.value = value | otherEnum.value; + return ImGuiSelectableFlags.Custom; + } + + public int getValue() { + return value; + } +} diff --git a/imgui-binding/src/main/java/imgui/enums/ImGuiStyleVar.java b/imgui-binding/src/main/java/imgui/enums/ImGuiStyleVar.java new file mode 100644 index 0000000..4f60eb1 --- /dev/null +++ b/imgui-binding/src/main/java/imgui/enums/ImGuiStyleVar.java @@ -0,0 +1,38 @@ +package imgui.enums; + +public enum ImGuiStyleVar { + Alpha(0), + WindowPadding(1), + WindowRounding(2), + WindowBorderSize(3), + WindowMinSize(4), + WindowTitleAlign(5), + ChildRounding(6), + ChildBorderSize(7), + PopupRounding(8), + PopupBorderSize(9), + FramePadding(10), + FrameRounding(11), + ImGuiStyleVar_FrameBorderSize(12), + ItemSpacing(13), + ItemInnerSpacing(14), + IndentSpacing(15), + ScrollbarSize(16), + ScrollbarRounding(17), + GrabMinSize(18), + GrabRounding(19), + TabRounding(20), + ButtonTextAlign(21), + SelectableTextAlign(22), + COUNT(23); + + int value; + + ImGuiStyleVar(int code) { + value = code; + } + + public int getValue() { + return value; + } +} diff --git a/imgui-binding/src/main/java/imgui/enums/ImGuiTabBarFlags.java b/imgui-binding/src/main/java/imgui/enums/ImGuiTabBarFlags.java new file mode 100644 index 0000000..4ccd908 --- /dev/null +++ b/imgui-binding/src/main/java/imgui/enums/ImGuiTabBarFlags.java @@ -0,0 +1,33 @@ +package imgui.enums; + +/** + * Flags for ImGui::BeginTabBar() + */ +public class ImGuiTabBarFlags { + public static ImGuiTabBarFlags None = new ImGuiTabBarFlags(0); + public static ImGuiTabBarFlags Reorderable = new ImGuiTabBarFlags(1 << 0); + public static ImGuiTabBarFlags AutoSelectNewTabs = new ImGuiTabBarFlags(1 << 1); + public static ImGuiTabBarFlags TabListPopupButton = new ImGuiTabBarFlags(1 << 2); + public static ImGuiTabBarFlags NoCloseWithMiddleMouseButton = new ImGuiTabBarFlags(1 << 3); + public static ImGuiTabBarFlags NoTabListScrollingButtons = new ImGuiTabBarFlags(1 << 4); + public static ImGuiTabBarFlags NoTooltip = new ImGuiTabBarFlags(1 << 5); + public static ImGuiTabBarFlags FittingPolicyResizeDown = new ImGuiTabBarFlags(1 << 6); + public static ImGuiTabBarFlags FittingPolicyScroll = new ImGuiTabBarFlags(1 << 7); + public static ImGuiTabBarFlags FittingPolicyMask = new ImGuiTabBarFlags(FittingPolicyResizeDown.getValue() | FittingPolicyScroll.getValue()); + public static ImGuiTabBarFlags FittingPolicyDefault = new ImGuiTabBarFlags(FittingPolicyResizeDown.getValue()); + private static ImGuiTabBarFlags Custom = new ImGuiTabBarFlags(0); + int value; + + private ImGuiTabBarFlags(int code) { + value = code; + } + + public ImGuiTabBarFlags or(ImGuiTabBarFlags otherEnum) { + ImGuiTabBarFlags.Custom.value = value | otherEnum.value; + return ImGuiTabBarFlags.Custom; + } + + public int getValue() { + return value; + } +} diff --git a/imgui-binding/src/main/java/imgui/enums/ImGuiTabItemFlags.java b/imgui-binding/src/main/java/imgui/enums/ImGuiTabItemFlags.java new file mode 100644 index 0000000..c9fe2cd --- /dev/null +++ b/imgui-binding/src/main/java/imgui/enums/ImGuiTabItemFlags.java @@ -0,0 +1,27 @@ +package imgui.enums; + +/** + * Flags for ImGui::BeginTabItem() + */ +public class ImGuiTabItemFlags { + public static ImGuiTabItemFlags None = new ImGuiTabItemFlags(0); + public static ImGuiTabItemFlags UnsavedDocument = new ImGuiTabItemFlags(1 << 0); + public static ImGuiTabItemFlags SetSelected = new ImGuiTabItemFlags(1 << 1); + public static ImGuiTabItemFlags NoCloseWithMiddleMouseButton = new ImGuiTabItemFlags(1 << 2); + public static ImGuiTabItemFlags NoPushId = new ImGuiTabItemFlags(1 << 3); + private static ImGuiTabItemFlags Custom = new ImGuiTabItemFlags(0); + int value; + + private ImGuiTabItemFlags(int code) { + value = code; + } + + public ImGuiTabItemFlags or(ImGuiTabItemFlags otherEnum) { + ImGuiTabItemFlags.Custom.value = value | otherEnum.value; + return ImGuiTabItemFlags.Custom; + } + + public int getValue() { + return value; + } +} diff --git a/imgui-binding/src/main/java/imgui/enums/ImGuiTreeNodeFlags.java b/imgui-binding/src/main/java/imgui/enums/ImGuiTreeNodeFlags.java new file mode 100644 index 0000000..7695ae4 --- /dev/null +++ b/imgui-binding/src/main/java/imgui/enums/ImGuiTreeNodeFlags.java @@ -0,0 +1,38 @@ +package imgui.enums; + +/** + * Flags for ImGui::TreeNodeEx(), ImGui::CollapsingHeader*() + */ +public class ImGuiTreeNodeFlags { + public static ImGuiTreeNodeFlags None = new ImGuiTreeNodeFlags(0); + public static ImGuiTreeNodeFlags Selected = new ImGuiTreeNodeFlags(1 << 0); + public static ImGuiTreeNodeFlags Framed = new ImGuiTreeNodeFlags(1 << 1); + public static ImGuiTreeNodeFlags AllowItemOverlap = new ImGuiTreeNodeFlags(1 << 2); + public static ImGuiTreeNodeFlags NoTreePushOnOpen = new ImGuiTreeNodeFlags(1 << 3); + public static ImGuiTreeNodeFlags NoAutoOpenOnLog = new ImGuiTreeNodeFlags(1 << 4); + public static ImGuiTreeNodeFlags DefaultOpen = new ImGuiTreeNodeFlags(1 << 5); + public static ImGuiTreeNodeFlags OpenOnDoubleClick = new ImGuiTreeNodeFlags(1 << 6); + public static ImGuiTreeNodeFlags OpenOnArrow = new ImGuiTreeNodeFlags(1 << 7); + public static ImGuiTreeNodeFlags Leaf = new ImGuiTreeNodeFlags(1 << 8); + public static ImGuiTreeNodeFlags Bullet = new ImGuiTreeNodeFlags(1 << 9); + public static ImGuiTreeNodeFlags FramePadding = new ImGuiTreeNodeFlags(1 << 10); + // public static ImGuiTreeNodeFlags SpanAllAvailWidth = new ImGuiTreeNodeFlags(1 << 11); +// public static ImGuiTreeNodeFlags NoScrollOnOpen = new ImGuiTreeNodeFlags(1 << 12); + public static ImGuiTreeNodeFlags NavLeftJumpsBackHere = new ImGuiTreeNodeFlags(1 << 13); + public static ImGuiTreeNodeFlags CollapsingHeader = new ImGuiTreeNodeFlags(Framed.getValue() | NoTreePushOnOpen.getValue() | NoAutoOpenOnLog.getValue()); + private static ImGuiTreeNodeFlags Custom = new ImGuiTreeNodeFlags(0); + int value; + + private ImGuiTreeNodeFlags(int value) { + this.value = value; + } + + public int getValue() { + return value; + } + + public ImGuiTreeNodeFlags or(ImGuiTreeNodeFlags otherEnum) { + ImGuiTreeNodeFlags.Custom.value = value | otherEnum.value; + return ImGuiTreeNodeFlags.Custom; + } +} diff --git a/imgui-binding/src/main/java/imgui/enums/ImGuiWindowFlags.java b/imgui-binding/src/main/java/imgui/enums/ImGuiWindowFlags.java new file mode 100644 index 0000000..fca7312 --- /dev/null +++ b/imgui-binding/src/main/java/imgui/enums/ImGuiWindowFlags.java @@ -0,0 +1,47 @@ +package imgui.enums; + +/** + * Flags for ImGui::Begin() + */ +public class ImGuiWindowFlags { + public static ImGuiWindowFlags None = new ImGuiWindowFlags(0); + public static ImGuiWindowFlags NoTitleBar = new ImGuiWindowFlags(1 << 0); + public static ImGuiWindowFlags NoResize = new ImGuiWindowFlags(1 << 1); + public static ImGuiWindowFlags NoMove = new ImGuiWindowFlags(1 << 2); + public static ImGuiWindowFlags NoScrollbar = new ImGuiWindowFlags(1 << 3); + public static ImGuiWindowFlags NoScrollWithMouse = new ImGuiWindowFlags(1 << 4); + public static ImGuiWindowFlags NoCollapse = new ImGuiWindowFlags(1 << 5); + public static ImGuiWindowFlags AlwaysAutoResize = new ImGuiWindowFlags(1 << 6); + public static ImGuiWindowFlags NoBackground = new ImGuiWindowFlags(1 << 7); + public static ImGuiWindowFlags NoSavedSettings = new ImGuiWindowFlags(1 << 8); + public static ImGuiWindowFlags NoMouseInputs = new ImGuiWindowFlags(1 << 9); + public static ImGuiWindowFlags MenuBar = new ImGuiWindowFlags(1 << 10); + public static ImGuiWindowFlags HorizontalScrollbar = new ImGuiWindowFlags(1 << 11); + public static ImGuiWindowFlags NoFocusOnAppearing = new ImGuiWindowFlags(1 << 12); + public static ImGuiWindowFlags NoBringToFrontOnFocus = new ImGuiWindowFlags(1 << 13); + public static ImGuiWindowFlags AlwaysVerticalScrollbar = new ImGuiWindowFlags(1 << 14); + public static ImGuiWindowFlags AlwaysHorizontalScrollbar = new ImGuiWindowFlags(1 << 15); + public static ImGuiWindowFlags AlwaysUseWindowPadding = new ImGuiWindowFlags(1 << 16); + public static ImGuiWindowFlags NoNavInputs = new ImGuiWindowFlags(1 << 18); + public static ImGuiWindowFlags NoNavFocus = new ImGuiWindowFlags(1 << 19); + public static ImGuiWindowFlags UnsavedDocument = new ImGuiWindowFlags(1 << 20); + public static ImGuiWindowFlags NoDocking = new ImGuiWindowFlags(1 << 21); + public static ImGuiWindowFlags NoNav = new ImGuiWindowFlags(NoNavInputs.getValue() | NoNavFocus.getValue()); + public static ImGuiWindowFlags NoDecoration = new ImGuiWindowFlags(NoTitleBar.getValue() | NoResize.getValue() | NoScrollbar.getValue() | NoCollapse.getValue()); + public static ImGuiWindowFlags NoInputs = new ImGuiWindowFlags(NoMouseInputs.getValue() | NoNavInputs.getValue() | NoNavFocus.getValue()); + private static ImGuiWindowFlags Custom = new ImGuiWindowFlags(0); + int value; + + private ImGuiWindowFlags(int code) { + value = code; + } + + public ImGuiWindowFlags or(ImGuiWindowFlags otherEnum) { + ImGuiWindowFlags.Custom.value = value | otherEnum.value; + return ImGuiWindowFlags.Custom; + } + + public int getValue() { + return value; + } +} diff --git a/imgui-binding/src/main/java/imgui/enums/ImLayout.java b/imgui-binding/src/main/java/imgui/enums/ImLayout.java new file mode 100644 index 0000000..a787fbf --- /dev/null +++ b/imgui-binding/src/main/java/imgui/enums/ImLayout.java @@ -0,0 +1,6 @@ +package imgui.enums; + +public class ImLayout { + public static float MATCH_PARENT = -0.1f; + public static float WRAP_PARENT = 0.0f; +} diff --git a/imgui-binding/src/main/native/imgui_layout_widget.cpp b/imgui-binding/src/main/native/imgui_layout_widget.cpp new file mode 100644 index 0000000..c5d9532 --- /dev/null +++ b/imgui-binding/src/main/native/imgui_layout_widget.cpp @@ -0,0 +1,512 @@ +#include "imgui.h" +#include "imgui_internal.h" +#include "imgui_layout_widget.h" + +static ImVector layoutStack; + +static ImGuiLayout *createOrFind(const char *id) +{ + ImGuiContext &g = *GImGui; + ImGuiLayout *childLayout = NULL; + ImGuiID hashID = ImHashStr(id); + childLayout = (ImGuiLayout *)g.WindowsById.GetVoidPtr(hashID); + if (childLayout == NULL) + { + childLayout = IM_NEW(ImGuiLayout)(id); + g.WindowsById.SetVoidPtr(childLayout->id, childLayout); + } + return childLayout; +} + +static ImGuiLayout *pushLayout(const char *id) +{ + ImGuiLayout *parentLayout = NULL; + if (!layoutStack.empty()) + parentLayout = layoutStack.back(); + ImGuiLayout *childLayout = createOrFind(id); + childLayout->parentLayout = parentLayout; + layoutStack.push_back(childLayout); + return childLayout; +} + +ImGuiLayout *ImGuiEx::GetCurrentLayout() +{ + if (layoutStack.empty()) + return NULL; + return layoutStack.back(); +} + +static void popLayout() +{ + layoutStack.pop_back(); +} + +void ImGuiEx::ShowLayoutDebug() +{ + ImGuiLayout *curLayout = ImGuiEx::GetCurrentLayout(); + if (curLayout != NULL) + { + curLayout->debug = true; + } +} + +void ImGuiEx::BeginLayoutEx(const char *strID) +{ + ImGuiLayout *parentLayout = ImGuiEx::GetCurrentLayout(); + ImGuiID id = ImHashStr(strID); + char title[256]; + if (parentLayout) + ImFormatString(title, IM_ARRAYSIZE(title), "%s/%s_%08X", parentLayout->idStr, strID, id); + else + ImFormatString(title, IM_ARRAYSIZE(title), "%s/%08X", strID, id); + + pushLayout(title); +} + +bool ImGuiEx::PrepareLayout(float sizeX, float sizeY, float paddingLeft, float paddingRight, float paddingTop, float paddingBottom) +{ + ImGuiContext &g = *GImGui; + ImGuiWindow *window = g.CurrentWindow; + + ImGuiLayout *curLayout = ImGuiEx::GetCurrentLayout(); + bool ret = true; + // Update layout + + // Backup windows data + curLayout->DC = window->DC; + curLayout->WorkRect = window->WorkRect; + curLayout->skipping = window->SkipItems; + curLayout->AutoFitChildAxises = window->AutoFitChildAxises; + curLayout->Pos = window->Pos; + curLayout->ContentRegionRect = window->ContentRegionRect; + // ******** End Backup windows data + + curLayout->sizeParam.x = sizeX; + curLayout->sizeParam.y = sizeY; + + curLayout->paddingLeft = paddingLeft; + curLayout->paddingRight = paddingRight; + curLayout->paddingTop = paddingTop; + curLayout->paddingBottom = paddingBottom; + + curLayout->position = window->DC.CursorPos; + + ImVec2 contentPosition = curLayout->getPositionPadding(); + + curLayout->positionContents = curLayout->position; + + const ImVec2 content_avail = ImGui::GetContentRegionAvail(); + + ImVec2 sizeItem = ImFloor(curLayout->sizeParam); + + if (curLayout->sizeParam.x < 0.0f) + { + float sizeX = ImMax(content_avail.x + sizeItem.x, 4.0f); + curLayout->size.x = sizeX; + } + if (curLayout->sizeParam.y < 0.0f) + { + float sizeY = ImMax(content_avail.y + sizeItem.y, 4.0f); + curLayout->size.y = sizeY; + } + + // ***** End Update Layout + + // Write to window object + + window->Pos.x = contentPosition.x; + window->Pos.y = contentPosition.y; + window->DC.Indent.x = 0; + + //window->DC.CursorMaxPos.x = contentPosition.x + curLayout->size.x - curLayout->paddingLeft - curLayout->paddingRight; + //window->DC.CursorMaxPos.y = contentPosition.y + curLayout->size.y - curLayout->paddingTop - curLayout->paddingBottom; + window->DC.CursorMaxPos.x = contentPosition.x; + window->DC.CursorMaxPos.y = contentPosition.y; + + window->DC.CursorStartPos.x = contentPosition.x; + window->DC.CursorStartPos.y = contentPosition.y; + + window->DC.CurrLineSize.y = 0; // necessary to keep position inside layout + window->DC.CurrLineTextBaseOffset = 0; + + window->DC.CursorPos.x = contentPosition.x; + window->DC.CursorPos.y = contentPosition.y; + + window->WorkRect.Min.x = contentPosition.x; + window->WorkRect.Min.y = contentPosition.y; + window->WorkRect.Max.x = contentPosition.x + curLayout->size.x - curLayout->paddingLeft - curLayout->paddingRight; + window->WorkRect.Max.y = contentPosition.y + curLayout->size.y - curLayout->paddingTop - curLayout->paddingBottom; + + window->ContentRegionRect.Min.x = contentPosition.x; + window->ContentRegionRect.Min.y = contentPosition.y; + window->ContentRegionRect.Max.x = contentPosition.x + curLayout->size.x - curLayout->paddingLeft - curLayout->paddingRight; + window->ContentRegionRect.Max.y = contentPosition.y + curLayout->size.y - curLayout->paddingTop - curLayout->paddingBottom; + + // ***** End Write to window object + + if (curLayout->clipping) + { + ImVec2 min = curLayout->getPositionPadding(); + ImVec2 max = curLayout->getAbsoluteSizePadding(); + //ImGui::drawBoundingBox(min, max, 255, 0, 0); + ImGui::PushClipRect(min, max, true); + } + + bool skip_items = false; + if (window->Collapsed || !window->Active || window->Hidden) + /* if (window->AutoFitFramesX <= 0 && window->AutoFitFramesY <= 0 && window->HiddenFramesCannotSkipItems <= 0)*/ + skip_items = true; + window->SkipItems = skip_items; + ret = !skip_items; + return true; +} + +bool ImGuiEx::BeginLayout(const char *strID, float sizeX, float sizeY, float paddingLeft, float paddingRight, float paddingTop, float paddingBottom) +{ + BeginLayoutEx(strID); + return PrepareLayout(sizeX, sizeY, paddingLeft, paddingRight, paddingTop, paddingBottom); +} + +void ImGuiEx::EndLayout() +{ + ImGuiContext &g = *GImGui; + ImGuiWindow *window = g.CurrentWindow; + ImGuiLayout *curLayout = ImGuiEx::GetCurrentLayout(); + if (curLayout == NULL) + return; + + if (curLayout->clipping) + ImGui::PopClipRect(); + + float x = window->DC.CursorPos.x; + float y = window->DC.CursorPos.y; + + curLayout->sizeContents.x = window->DC.CursorMaxPos.x - x; + //curLayout->sizeContents.y = y - curLayout->position.y - g.Style.ItemSpacing.y; + + //curLayout->sizeContents.x = window->DC.CursorMaxPos.x - curLayout->positionContents.x; + curLayout->sizeContents.y = y - curLayout->positionContents.y - g.Style.ItemSpacing.y; + + // Restore windows data + window->DC = curLayout->DC; + window->WorkRect = curLayout->WorkRect; + window->SkipItems = curLayout->skipping; + window->AutoFitChildAxises = curLayout->AutoFitChildAxises; + window->Pos = curLayout->Pos; + window->ContentRegionRect = curLayout->ContentRegionRect; + // ******************** + + //const ImVec2 content_avail = GetContentRegionAvail(); + ImVec2 sizeItem = curLayout->sizeParam; + + if (sizeItem.x < 0.0f) + { + sizeItem.x = curLayout->size.x; + if (curLayout->size.x < curLayout->sizeContents.x || curLayout->size.x > curLayout->sizeContents.x) + { + //special case where dev used MATCH_CONTENT and WRAP_CONTENT wrong. The parent have a WRAP_CONTENT y size and the child have MATCH_CONTENT y size. + /* curLayout->error = true; + sizeItem.x = 10;*/ + } + } + else if (sizeItem.x == 0.0f) + sizeItem.x = curLayout->sizeContents.x + curLayout->paddingLeft + curLayout->paddingRight; + + if (sizeItem.y < 0.0f) + { + sizeItem.y = curLayout->size.y; + if (curLayout->size.y < curLayout->sizeContents.y) + { + //special case where dev used MATCH_CONTENT and WRAP_CONTENT wrong. The parent have a WRAP_CONTENT y size and the child have MATCH_CONTENT y size. + //curLayout->error = true; + //sizeItem.y = curLayout->sizeContents.y; + } + } + else if (sizeItem.y == 0.0f) + sizeItem.y = curLayout->sizeContents.y + curLayout->paddingBottom; + + curLayout->size = sizeItem; + + ImGui::ItemSize(sizeItem); + + if (curLayout->debug) + { + curLayout->drawContentDebug(); + curLayout->drawPaddingAreaDebug(); + curLayout->drawSizeDebug(); + curLayout->debug = false; + } + + if (curLayout->error) + { + curLayout->error = false; + curLayout->drawError(); + } + + popLayout(); +} + +static bool renderFrameArrow(bool *value, int arrowColor, int arrowBackgroundHoveredColor, int arrowBackgroundClickedColor) +{ + ImGuiContext &g = *GImGui; + ImGuiWindow *window = g.CurrentWindow; + + ImDrawList *drawList = ImGui::GetWindowDrawList(); + float getFrameHeight = ImGui::GetFrameHeight(); + float removedSize = 5.5f; // reduce few pixels + float halfSize = (getFrameHeight) / 2.0f - removedSize; + + ImVec2 vec = ImGui::GetCursorScreenPos(); + + float screenPosX = vec.x; + float screenPosY = vec.y; + float arrowPaddingLeft = 6; + + float x = screenPosX + halfSize + arrowPaddingLeft; + float y = screenPosY + getFrameHeight / 2.0f; + + bool hovered = ImGui::IsMouseHoveringRect(ImVec2(x - halfSize - removedSize, y - halfSize - removedSize), ImVec2(x + halfSize + removedSize, y + halfSize + removedSize)); + ImU32 hoveredColor = arrowBackgroundHoveredColor; + bool isWindowHovered = ImGui::IsWindowHovered(); + + if (isWindowHovered) + { + if (hovered) + { + if (ImGui::IsMouseDown(0)) + hoveredColor = arrowBackgroundClickedColor; + if (ImGui::IsMouseReleased(0)) + *value = !*value; + } + + if (hovered) + drawList->AddCircleFilled(ImVec2(x, y), halfSize * 2, hoveredColor); + } + + float triA_X = 0; + float triA_Y = 0; + float triB_X = 0; + float triB_Y = 0; + float triC_X = 0; + float triC_Y = 0; + + if (*value) + { + // arrow down + float offset = -0.5f; + triA_X = x - halfSize + offset; + triA_Y = y - halfSize; + triB_X = x + halfSize + offset; + triB_Y = y - halfSize; + triC_X = x + offset; + triC_Y = y + halfSize; + } + else + { + // arrow right + triA_X = x - halfSize; + triA_Y = y - halfSize; + triB_X = x + halfSize; + triB_Y = y; + triC_X = x - halfSize; + triC_Y = y + halfSize; + } + + drawList->AddTriangleFilled(ImVec2(triA_X, triA_Y), ImVec2(triB_X, triB_Y), ImVec2(triC_X, triC_Y), arrowColor); + + float bk = g.Style.ItemSpacing.y; + g.Style.ItemSpacing.y = 0; + ImGui::ItemSize(ImVec2(halfSize * 2 + 3, getFrameHeight)); + g.Style.ItemSpacing.y = bk; + + return *value; +} + +static int OPEN_KEY = 13213; + +bool ImGuiEx::PrepareCollapseLayout(const char *title, float sizeX, float sizeY, ImGuiCollapseLayoutOptions options) +{ + ImGuiContext &g = *GImGui; + ImGuiWindow *window = g.CurrentWindow; + ImDrawList *drawList = window->DrawList; + ImGuiLayout *rootLayout = ImGuiEx::GetCurrentLayout(); + + float frameHeight = ImGui::GetFrameHeight(); + + bool flag = rootLayout->map.GetBool(OPEN_KEY, false); + bool *isOpen = &flag; + + sizeY = *isOpen ? sizeY : ImLayout::WRAP_PARENT; + + ImGuiEx::PrepareLayout(sizeX, sizeY, 1, 1, 1, 1); + + rootLayout->map.SetFloat(120, options.paddingLeft); + rootLayout->map.SetFloat(121, options.paddingRight); + rootLayout->map.SetFloat(122, options.paddingTop); + rootLayout->map.SetFloat(123, options.paddingBottom); + + ImGuiEx::BeginLayout("frame", ImLayout::MATCH_PARENT, frameHeight, 0, 0, 0, 0); + ImGuiLayout *frameLayout = ImGuiEx::GetCurrentLayout(); + + ImVec2 mousePos = ImGui::GetMousePos(); + + drawList->AddRectFilled(rootLayout->position, ImVec2(rootLayout->getAbsoluteSize().x, frameLayout->getAbsoluteSize().y), options.frameColor, options.borderRound, options.roundingCorners); + + renderFrameArrow(isOpen, options.arrowColor, options.arrowBackgroundHoveredColor, options.arrowBackgroundClickedColor); + + rootLayout->map.SetBool(OPEN_KEY, *isOpen); + + ImGui::SameLine(); + + ImGuiEx::BeginAlign("align", ImLayout::WRAP_PARENT, ImLayout::MATCH_PARENT, 0, 0.5f, 0, 0); + + ImGui::Text(title); + + ImGuiEx::EndAlign(); + + ImGui::SameLine(); + + return *isOpen; +} + +void ImGuiEx::BeginCollapseLayoutEx(bool *isOpen, const char *title, float sizeX, float sizeY, ImGuiCollapseLayoutOptions options) +{ + ImGuiEx::BeginLayoutEx(title); + ImGuiLayout *rootLayout = ImGuiEx::GetCurrentLayout(); + rootLayout->map.SetBool(OPEN_KEY, *isOpen); + bool flag = ImGuiEx::PrepareCollapseLayout(title, sizeX, sizeY, options); + *isOpen = flag; +} + +bool ImGuiEx::BeginCollapseLayoutEx(const char *title, float sizeX, float sizeY, ImGuiCollapseLayoutOptions options) +{ + ImGuiEx::BeginLayoutEx(title); + return ImGuiEx::PrepareCollapseLayout(title, sizeX, sizeY, options); +} + +bool ImGuiEx::BeginCollapseLayout(const char *title, float sizeX, float sizeY, ImGuiCollapseLayoutOptions options) +{ + bool flag = ImGuiEx::BeginCollapseLayoutEx(title, sizeX, sizeY, options); + ImGuiEx::EndCollapseFrameLayout(); + return flag; +} + +void ImGuiEx::BeginCollapseLayout(bool *isOpen, const char *title, float sizeX, float sizeY, ImGuiCollapseLayoutOptions options) +{ + ImGuiEx::BeginCollapseLayoutEx(isOpen, title, sizeX, sizeY, options); + ImGuiEx::EndCollapseFrameLayout(); +} + +void ImGuiEx::EndCollapseFrameLayout() +{ + ImGuiContext &g = *GImGui; + float bk = g.Style.ItemSpacing.y; + + g.Style.ItemSpacing.y = 0; + ImGuiEx::EndLayout(); // end frame + g.Style.ItemSpacing.y = bk; + ImGuiLayout *rootLayout = ImGuiEx::GetCurrentLayout(); + + float paddingLeft = rootLayout->map.GetFloat(120, 0.0f); + float paddingRight = rootLayout->map.GetFloat(121, 0.0f); + float paddingTop = rootLayout->map.GetFloat(122, 0.0f); + float paddingBottom = rootLayout->map.GetFloat(123, 0.0f); + + ImGuiEx::BeginLayout("content", ImLayout::MATCH_PARENT, ImLayout::WRAP_PARENT, paddingLeft, paddingRight, paddingTop, paddingBottom); + ImGuiLayout *collapseLayout = ImGuiEx::GetCurrentLayout(); +} + +void ImGuiEx::EndCollapseLayout() +{ + ImGuiContext &g = *GImGui; + ImGuiWindow *window = g.CurrentWindow; + ImDrawList *drawList = window->DrawList; + + ImU32 borderColor = ImGui::GetColorU32(ImVec4(0x40 / 255.0f, 0x40 / 255.0f, 0x49 / 255.0f, 255 / 255.0f)); + int borderRound = 4; + int roundingCorners = ImDrawCornerFlags_TopLeft | ImDrawCornerFlags_TopRight; + + ImGuiEx::EndLayout(); // end content + + ImGuiLayout *rootLayout = ImGuiEx::GetCurrentLayout(); + + ImGuiEx::EndLayout(); // end root + + ImVec2 borderPosition = rootLayout->position; + ImVec2 borderSize = rootLayout->getAbsoluteSize(); + + drawList->AddRect(borderPosition, borderSize, borderColor, borderRound, roundingCorners, 1.0f); +} + +void ImGuiEx::BeginAlign(const char *strID, float sizeX, float sizeY, float alignX, float alignY, float offsetX, float offsetY) +{ + ImGuiEx::BeginLayout(strID, sizeX, sizeY); + ImGuiEx::AlignLayout(alignX, alignY, offsetX, offsetY); +} + +void ImGuiEx::AlignLayout(float alignX, float alignY, float offsetX, float offsetY) +{ + ImGuiContext &g = *GImGui; + ImGuiWindow *window = g.CurrentWindow; + ImGuiLayout *curLayout = ImGuiEx::GetCurrentLayout(); + if (curLayout == NULL) + return; + + ImVec2 regionAvail = ImGui::GetContentRegionAvail(); + float totalX = regionAvail.x; + float totalY = regionAvail.y; + + ImVec2 posPad = curLayout->getPositionPadding(); + ImVec2 absSizePad = curLayout->getAbsoluteSizePadding(); + + if (alignX >= 0.0f && curLayout->sizeParam.x != ImLayout::WRAP_PARENT) + { + + float addX = ImFloor((totalX - curLayout->sizeContents.x) * alignX); + float newX = posPad.x + addX + offsetX; + if (newX < posPad.x) + { + curLayout->error = true; + newX = posPad.x; + } + else if (newX + curLayout->sizeContents.x > absSizePad.x) + { + curLayout->error = true; + newX = absSizePad.x - curLayout->sizeContents.x; + } + curLayout->positionContents.x = newX; + } + + if (alignY >= 0.0f && curLayout->sizeParam.y != ImLayout::WRAP_PARENT) + { + float addY = ImFloor((totalY - curLayout->sizeContents.y) * alignY); + float newY = posPad.y + addY + offsetY; + if (newY < posPad.y) + { + curLayout->error = true; + newY = posPad.y; + } + else if (newY + curLayout->sizeContents.y > absSizePad.y) + { + curLayout->error = true; + newY = absSizePad.y - curLayout->sizeContents.y; + } + curLayout->positionContents.y = newY; + } + window->DC.CursorMaxPos.x = curLayout->positionContents.x; + window->DC.CursorMaxPos.y = curLayout->positionContents.y; + + window->DC.CursorStartPos.x = curLayout->positionContents.x; + window->DC.CursorStartPos.y = curLayout->positionContents.y; + + window->Pos.x = curLayout->positionContents.x; + window->Pos.y = curLayout->positionContents.y; + + window->DC.CursorPos.x = curLayout->positionContents.x; + window->DC.CursorPos.y = curLayout->positionContents.y; +} + +void ImGuiEx::EndAlign() +{ + ImGuiEx::EndLayout(); +} \ No newline at end of file diff --git a/imgui-binding/src/main/native/imgui_layout_widget.h b/imgui-binding/src/main/native/imgui_layout_widget.h new file mode 100644 index 0000000..3a449b7 --- /dev/null +++ b/imgui-binding/src/main/native/imgui_layout_widget.h @@ -0,0 +1,182 @@ +#pragma once + +#include "imgui.h" +#include "imgui_internal.h" + +namespace ImGuiEx +{ +inline void drawBoundingBox(float x1, float y1, float x2, float y2, int r, int g, int b, bool clipping = false) +{ + ImDrawList *drawList = clipping ? ImGui::GetWindowDrawList() : ImGui::GetForegroundDrawList(); + + float rounding = 0; + int color = ImGui::GetColorU32(ImVec4(r / 255.0f, g / 255.0f, b / 255.0f, 205.0f / 255.0f)); + drawList->AddRect(ImVec2(x1, y1), ImVec2(x2, y2), color, rounding); +} + +inline void drawBoundingBox(ImVec2 min, ImVec2 max, int r, int g, int b, bool clipping = false) +{ + ImGuiEx::drawBoundingBox(min.x, min.y, max.x, max.y, r, g, b, clipping); +} +}; // namespace ImGuiEx + +struct ImGuiLayout +{ + +public: + char *idStr; + ImGuiID id; + ImGuiLayout *parentLayout; + + bool clipping; + bool debug; + + ImGuiStorage map; + + ImVec2 position; // Position of the layout + ImVec2 size; // Size of the layout + ImVec2 sizeParam; // Size parameter used when calling beginLayout + float paddingLeft; + float paddingRight; + float paddingTop; + float paddingBottom; + ImVec2 positionContents; // Position of contents. + ImVec2 sizeContents; // Size of contents. calculated after the first frame + + bool error; + + // Window Backup data + ImGuiWindowTempData DC; + ImRect WorkRect; + bool skipping; + int AutoFitChildAxises; + ImVec2 Pos; + ImRect ContentRegionRect; + + ImGuiLayout(const char *idStr) + { + this->idStr = ImStrdup(idStr); + this->id = ImHashStr(idStr); + paddingLeft = 0; + paddingRight = 0; + paddingTop = 0; + paddingBottom = 0; + clipping = true; + debug = false; + error = false; + skipping = false; + } + + bool haveParent() { return parentLayout != NULL; } + + ImVec2 getAbsoluteSize() + { + return ImVec2(position.x + size.x, position.y + size.y); + } + + ImVec2 getContentSize() + { + return ImVec2(position.x + sizeContents.x, position.y + sizeContents.y); + } + + ImVec2 getAbsoluteSizePadding() + { + return ImVec2(position.x + size.x - paddingRight, position.y + size.y - paddingBottom); + } + + ImVec2 getContentSizePadding() + { + return ImVec2(position.x + sizeContents.x + paddingLeft, position.y + sizeContents.y); + } + + ImVec2 getPositionPadding() + { + return ImVec2(position.x + paddingLeft, position.y + paddingTop); + } + + void drawSizeDebug() + { + // Render layout space + //Green + ImGuiEx::drawBoundingBox(position, getAbsoluteSize(), 0, 255, 0); + } + + inline void drawContentDebug() + { + // Render content space + // Blue + ImVec2 max = ImVec2(positionContents.x + sizeContents.x, positionContents.y + sizeContents.y); + ImGuiEx::drawBoundingBox(positionContents, max, 0, 0, 255); + } + + void drawPaddingAreaDebug() + { + // Render size with padding + ImGuiEx::drawBoundingBox(getPositionPadding(), getAbsoluteSizePadding(), 255, 255, 255); + } + + void drawError() + { + ImGuiEx::drawBoundingBox(position, getAbsoluteSize(), 255, 0, 0, true); + } +}; + +struct ImGuiCollapseLayoutOptions +{ +public: + float paddingLeft; + float paddingRight; + float paddingTop; + float paddingBottom; + ImU32 arrowColor; + ImU32 arrowBackgroundHoveredColor; + ImU32 arrowBackgroundClickedColor; + ImU32 frameColor; + ImU32 borderColor; + int borderRound; + int roundingCorners; + + ImGuiCollapseLayoutOptions() + { + paddingLeft = 2; + paddingRight = 2; + paddingTop = 2; + paddingBottom = 2; + arrowColor = ImGui::GetColorU32(ImVec4(0xFF / 255.0f, 0xFF / 255.0f, 0xFF / 255.0f, 0xFF / 255.0f)); + arrowBackgroundHoveredColor = ImGui::GetColorU32(ImVec4(0x77 / 255.0f, 0x77 / 255.0f, 0x77 / 255.0f, 0xFF / 255.0f)); + arrowBackgroundClickedColor = ImGui::GetColorU32(ImVec4(0x55 / 255.0f, 0x55 / 255.0f, 0x55 / 255.0f, 0xFF / 255.0f)); + frameColor = ImGui::GetColorU32(ImVec4(0x24 / 255.0f, 0x24 / 255.0f, 0x24 / 255.0f, 255 / 255.0f)); + borderColor = ImGui::GetColorU32(ImVec4(0x40 / 255.0f, 0x40 / 255.0f, 0x49 / 255.0f, 255 / 255.0f)); + borderRound = 4; + roundingCorners = ImDrawCornerFlags_TopLeft | ImDrawCornerFlags_TopRight; + } +}; + +namespace ImGuiEx +{ +void ShowLayoutDebug(); + +void BeginLayoutEx(const char *id); +bool PrepareLayout(float sizeX, float sizeY, float paddingLeft = 0, float paddingRight = 0, float paddingTop = 0, float paddingBottom = 0); +bool BeginLayout(const char *id, float sizeX, float sizeY, float paddingLeft = 0, float paddingRight = 0, float paddingTop = 0, float paddingBottom = 0); +void EndLayout(); +ImGuiLayout *GetCurrentLayout(); + +bool BeginCollapseLayoutEx(const char *title, float sizeX, float sizeY, ImGuiCollapseLayoutOptions options = ImGuiCollapseLayoutOptions()); +void BeginCollapseLayoutEx(bool *isOpen, const char *title, float sizeX, float sizeY, ImGuiCollapseLayoutOptions options = ImGuiCollapseLayoutOptions()); +bool PrepareCollapseLayout(const char *title, float sizeX, float sizeY, ImGuiCollapseLayoutOptions options = ImGuiCollapseLayoutOptions()); +bool BeginCollapseLayout(const char *title, float sizeX, float sizeY, ImGuiCollapseLayoutOptions options = ImGuiCollapseLayoutOptions()); +void BeginCollapseLayout(bool *isOpen, const char *title, float sizeX, float sizeY, ImGuiCollapseLayoutOptions options = ImGuiCollapseLayoutOptions()); +void EndCollapseFrameLayout(); +void EndCollapseLayout(); + +void BeginAlign(const char *id, float sizeX, float sizeY, float alignX = 0.0f, float alignY = 0.0f, float offsetX = 0, float offsetY = 0); +void AlignLayout(float alignX = 0.0f, float alignY = 0.0f, float offsetX = 0, float offsetY = 0); +void EndAlign(); +}; // namespace ImGuiEx + +namespace ImLayout +{ +static float WRAP_PARENT = 0; +static float MATCH_PARENT = -0.1f; +} // namespace ImLayout \ No newline at end of file diff --git a/imgui-lwjgl3/build.gradle b/imgui-lwjgl3/build.gradle new file mode 100644 index 0000000..ff98a83 --- /dev/null +++ b/imgui-lwjgl3/build.gradle @@ -0,0 +1,33 @@ +import org.gradle.internal.os.OperatingSystem + +plugins { + id 'java' +} + +sourceCompatibility = 1.8 + +ext { + lwjglVersion = '3.2.3' +} + +switch (OperatingSystem.current()) { + case OperatingSystem.LINUX: + project.ext.lwjglNatives = 'natives-linux' + break + case OperatingSystem.WINDOWS: + project.ext.lwjglNatives = System.getProperty('os.arch').contains('64') ? 'natives-windows' : 'natives-windows-x86' + break +} + +dependencies { + implementation platform("org.lwjgl:lwjgl-bom:$lwjglVersion") + + implementation 'org.lwjgl:lwjgl' + implementation 'org.lwjgl:lwjgl-glfw' + implementation 'org.lwjgl:lwjgl-opengl' + runtimeOnly "org.lwjgl:lwjgl::$lwjglNatives" + runtimeOnly "org.lwjgl:lwjgl-glfw::$lwjglNatives" + runtimeOnly "org.lwjgl:lwjgl-opengl::$lwjglNatives" + + implementation project(':imgui-binding') +} diff --git a/imgui-lwjgl3/src/main/java/InputHandler.java b/imgui-lwjgl3/src/main/java/InputHandler.java new file mode 100644 index 0000000..b6e8c76 --- /dev/null +++ b/imgui-lwjgl3/src/main/java/InputHandler.java @@ -0,0 +1,125 @@ +import org.lwjgl.glfw.GLFWKeyCallback; +import org.lwjgl.glfw.GLFWMouseButtonCallback; + +import static org.lwjgl.glfw.GLFW.*; + +public class InputHandler { + private static long window; + private static final int KEYBOARD_SIZE = 512; + private static final int MOUSE_SIZE = 16; + + private static int[] keyStates = new int[KEYBOARD_SIZE]; + private static boolean[] activeKeys = new boolean[KEYBOARD_SIZE]; + + private static int[] mouseButtonStates = new int[MOUSE_SIZE]; + private static boolean[] activeMouseButtons = new boolean[MOUSE_SIZE]; + private static long lastMouseNS = 0; + private static long mouseDoubleClickPeriodNS = 1000000000 / 5; //5th of a second for double click. + + private static int NO_STATE = -1; + + protected static GLFWKeyCallback keyboard = new GLFWKeyCallback() + { + @Override + public void invoke(long window, int key, int scancode, int action, int mods) + { + activeKeys[key] = action != GLFW_RELEASE; + keyStates[key] = action; + } + }; + + protected static GLFWMouseButtonCallback mouse = new GLFWMouseButtonCallback() + { + @Override + public void invoke(long window, int button, int action, int mods) + { + activeMouseButtons[button] = action != GLFW_RELEASE; + mouseButtonStates[button] = action; + } + }; + + protected static void init(long window) + { + InputHandler.window = window; + resetKeyboard(); + resetMouse(); + } + + protected static void update() + { + resetKeyboard(); + resetMouse(); + } + + private static void resetKeyboard() + { + for (int i = 0; i < keyStates.length; i++) + { + keyStates[i] = NO_STATE; + } + } + + private static void resetMouse() + { + for (int i = 0; i < mouseButtonStates.length; i++) + { + mouseButtonStates[i] = NO_STATE; + } + + long now = System.nanoTime(); + + if (now - lastMouseNS > mouseDoubleClickPeriodNS) + lastMouseNS = 0; + } + + public static boolean keyDown(int key) + { + return activeKeys[key]; + } + + public static boolean keyPressed(int key) + { + return keyStates[key] == GLFW_PRESS; + } + + public static boolean keyReleased(int key) + { + return keyStates[key] == GLFW_RELEASE; + } + + public static boolean mouseButtonDown(int button) + { + return activeMouseButtons[button]; + } + + public static boolean mouseButtonPressed(int button) + { + return mouseButtonStates[button] == GLFW_RELEASE; + } + + public static boolean mouseButtonReleased(int button) + { + boolean flag = mouseButtonStates[button] == GLFW_RELEASE; + + if (flag) + lastMouseNS = System.nanoTime(); + + return flag; + } + + public static boolean mouseButtonDoubleClicked(int button) + { + long last = lastMouseNS; + boolean flag = mouseButtonReleased(button); + + long now = System.nanoTime(); + + if (flag && now - last < mouseDoubleClickPeriodNS) + { + lastMouseNS = 0; + return true; + } + + return false; + } +} diff --git a/imgui-lwjgl3/src/main/java/Main.java b/imgui-lwjgl3/src/main/java/Main.java new file mode 100644 index 0000000..8b0142c --- /dev/null +++ b/imgui-lwjgl3/src/main/java/Main.java @@ -0,0 +1,156 @@ +import imgui.DrawData; +import imgui.ImGui; +import imgui.gl3.ImGuiImplGl3; +import org.lwjgl.BufferUtils; +import org.lwjgl.Version; +import org.lwjgl.glfw.GLFWErrorCallback; +import org.lwjgl.glfw.GLFWVidMode; +import org.lwjgl.opengl.GL; +import org.lwjgl.system.MemoryStack; + +import java.nio.DoubleBuffer; +import java.nio.IntBuffer; + +import static org.lwjgl.glfw.Callbacks.glfwFreeCallbacks; +import static org.lwjgl.glfw.GLFW.*; +import static org.lwjgl.opengl.GL11.*; +import static org.lwjgl.system.MemoryStack.stackPush; +import static org.lwjgl.system.MemoryUtil.NULL; + +public class Main { + // The window handle + private long window; + private ImGuiImplGl3 imGuiGl = new ImGuiImplGl3(); + + public void run() { + System.out.println("Hello LWJGL " + Version.getVersion() + "!"); + + init(); + loop(); + + // Free the window callbacks and destroy the window + glfwFreeCallbacks(window); + glfwDestroyWindow(window); + + // Terminate GLFW and free the error callback + glfwTerminate(); + glfwSetErrorCallback(null).free(); + } + + private void init() { + // Setup an error callback. The default implementation + // will print the error message in System.err. + GLFWErrorCallback.createPrint(System.err).set(); + + // Initialize GLFW. Most GLFW functions will not work before doing this. + if (!glfwInit()) + throw new IllegalStateException("Unable to initialize GLFW"); + + // Configure GLFW + glfwDefaultWindowHints(); // optional, the current window hints are already the default + glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE); // the window will stay hidden after creation + glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE); // the window will be resizable + + // Create the window + window = glfwCreateWindow(1024, 768, "Hello World!", NULL, NULL); + if (window == NULL) + throw new RuntimeException("Failed to create the GLFW window"); + + // Setup a key callback. It will be called every time a key is pressed, repeated or released. + glfwSetKeyCallback(window, (window, key, scancode, action, mods) -> { + if (key == GLFW_KEY_ESCAPE && action == GLFW_RELEASE) + glfwSetWindowShouldClose(window, true); // We will detect this in the rendering loop + }); + + glfwSetMouseButtonCallback(window, InputHandler.mouse); + + // Get the thread stack and push a new frame + try (MemoryStack stack = stackPush()) { + IntBuffer pWidth = stack.mallocInt(1); // int* + IntBuffer pHeight = stack.mallocInt(1); // int* + + // Get the window size passed to glfwCreateWindow + glfwGetWindowSize(window, pWidth, pHeight); + + // Get the resolution of the primary monitor + GLFWVidMode vidmode = glfwGetVideoMode(glfwGetPrimaryMonitor()); + + // Center the window + glfwSetWindowPos( + window, + (vidmode.width() - pWidth.get(0)) / 2, + (vidmode.height() - pHeight.get(0)) / 2 + ); + } // the stack frame is popped automatically + + // Make the OpenGL context current + glfwMakeContextCurrent(window); + // Enable v-sync + glfwSwapInterval(1); + InputHandler.init(window); + // Make the window visible + glfwShowWindow(window); + } + + long lastFrame = System.nanoTime(); + + public float getDelta() { + long time = System.nanoTime(); + int delta_time = (int) ((time - lastFrame) / 1000000); + lastFrame = time; + return delta_time; + } + + private void loop() { + // This line is critical for LWJGL's interoperation with GLFW's + // OpenGL context, or any context that is managed externally. + // LWJGL detects the context that is current in the current thread, + // creates the GLCapabilities instance and makes the OpenGL + // bindings available for use. + GL.createCapabilities(); + + ImGui.init(); + imGuiGl.init(); + + // Set the clear color + glClearColor(.5f, 0.0f, 0f, 0.0f); + + int[] win_width = new int[1], win_height = new int[1]; + int[] width = new int[1], height = new int[1]; + DoubleBuffer xBuffer = BufferUtils.createDoubleBuffer(1); + DoubleBuffer yBuffer = BufferUtils.createDoubleBuffer(1); + + // Run the rendering loop until the user has attempted to close + // the window or has pressed the ESCAPE key. + while (!glfwWindowShouldClose(window)) { + xBuffer.clear(); + yBuffer.clear(); + + InputHandler.update(); + + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // clear the framebuffer + + glfwGetWindowSize(window, win_width, win_height); + glfwGetFramebufferSize(window, width, height); + glfwGetCursorPos(window, xBuffer, yBuffer); + + int mX = (int) xBuffer.get(); + int mY = (int) yBuffer.get(); + + ImGui.UpdateDisplayAndInputAndFrame(getDelta(), win_width[0], win_height[0], width[0], height[0], mX, mY, InputHandler.mouseButtonDown(0), false, false); + ImGui.ShowDemoWindow(); + ImGui.Render(); + imGuiGl.render(ImGui.GetDrawData()); + + glfwSwapBuffers(window); // swap the color buffers + + // Poll for window events. The key callback above will only be + // invoked during this call. + glfwPollEvents(); + } + } + + public static void main(String[] args) { + new Main().run(); + } +} diff --git a/imgui-lwjgl3/src/main/java/imgui/gl3/ImGuiImplGl3.java b/imgui-lwjgl3/src/main/java/imgui/gl3/ImGuiImplGl3.java new file mode 100644 index 0000000..730d7da --- /dev/null +++ b/imgui-lwjgl3/src/main/java/imgui/gl3/ImGuiImplGl3.java @@ -0,0 +1,341 @@ +package imgui.gl3; + +import imgui.DrawData; +import imgui.ImGui; +import imgui.TexDataRGBA32; + +import java.io.*; +import java.util.Objects; + +import static org.lwjgl.opengl.GL30.*; + +/** + * This class mostly a straightforward port of the https://raw.githubusercontent.com/ocornut/imgui/v1.74/examples/imgui_impl_opengl3.cpp adapted to Java and LWJGL realms. + *

+ * It do support a backup of the current GL state before rendering and restoring of its initial state after. + * But some specific state variables may be missed (all which are hidden under '#ifdef' macros in the original imgui file). + *

+ * By default this implementation uses shaders with 130 version of GLSL (OpenGL 3.0). + * You can provide your own shaders into the {@link ImGuiImplGl3#init(CharSequence, CharSequence)} method. + */ +public class ImGuiImplGl3 { + private int vBufferHandle = 0; + private int iBufferHandle = 0; + + private boolean isFontInitialized = false; + + // Shader stuff + private int programId = 0; + private int fragmentShaderId = 0; + private int vertexShaderId = 0; + + // Texture used by fonts + private int gFontTexture = 0; + + // Projection matrix for ImGui + private final float[] projMatrix = new float[4 * 4]; + + // Variables used to backup GL state before and after rendering of ImGui + private final int[] lastActiveTexture = new int[1]; + private final int[] lastProgram = new int[1]; + private final int[] lastTexture = new int[1]; + private final int[] lastArrayBuffer = new int[1]; + private final int[] lastViewport = new int[4]; + private final int[] lastScissorBox = new int[4]; + private final int[] lastBlendSrcRgb = new int[1]; + private final int[] lastBlendDstRgb = new int[1]; + private final int[] lastBlendSrcAlpha = new int[1]; + private final int[] lastBlendDstAlpha = new int[1]; + private final int[] lastBlendEquationRgb = new int[1]; + private final int[] lastBlendEquationAlpha = new int[1]; + private boolean lastEnableBlend = false; + private boolean lastEnableCullFace = false; + private boolean lastEnableDepthTest = false; + private boolean lastEnableScissorTest = false; + + /** + * This method SHOULD be called before calling of {@link ImGuiImplGl3#render(DrawData)} method. + * By using this method shaders with 130 version of GLSL will be used for render. + */ + public void init() { + final CharSequence fragShaderSource = readFromResources("default.frag"); + final CharSequence vertShaderSource = readFromResources("default.vert"); + prepareShader(fragShaderSource, vertShaderSource); + prepareFont(); + } + + /** + * This method SHOULD be called before calling of {@link ImGuiImplGl3#render(DrawData)} method. + * + * @param fragShaderSource fragment shader to use for render + * @param vertShaderSource vertex shader to use for render + */ + public void init(final CharSequence fragShaderSource, final CharSequence vertShaderSource) { + prepareShader(fragShaderSource, vertShaderSource); + prepareFont(); + } + + /** + * Method which renders {@link DrawData} from ImGui. + * + * @param drawData data used to draw ImGui interface to your current OpenGL context + */ + public void render(final DrawData drawData) { + if (drawData.cmdListsCount <= 0) { + return; + } + + // Avoid rendering when minimized, scale coordinates for retina displays (screen coordinates != framebuffer coordinates) + int fbWidth = (int) (drawData.displaySizeX * drawData.framebufferScaleX); + int fbHeight = (int) (drawData.displaySizeY * drawData.framebufferScaleY); + + if (fbWidth <= 0 || fbHeight <= 0) { + return; + } + + if (!isFontInitialized) { + isFontInitialized = true; + vBufferHandle = glGenBuffers(); + iBufferHandle = glGenBuffers(); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, iBufferHandle); + glBufferData(GL_ELEMENT_ARRAY_BUFFER, drawData.iByteBuffer.capacity(), GL_STATIC_DRAW); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); + } + + backupGlState(); + bind(drawData); + + int verticesOffset = 0; + int indexOffset = 0; + + for (int i = 0; i < drawData.cmdListsCount; i++) { + drawData.vByteBuffer.limit(verticesOffset + 4); + final int verticesSize = (int) drawData.vByteBuffer.getFloat(verticesOffset); + + drawData.iByteBuffer.limit(indexOffset + 2); + final short indexSize = drawData.iByteBuffer.getShort(indexOffset); + final int cmdSize = (int) drawData.cmdByteBuffer.getFloat(); + + final int verticesStartOffset = verticesOffset + 4; + final int indexStartOffset = indexOffset + 2; + + drawData.vByteBuffer.position(verticesStartOffset); + drawData.iByteBuffer.position(indexStartOffset); + + final int newVlimit = verticesStartOffset + verticesSize * DrawData.vBufferSize; + final int newIlimit = indexStartOffset + indexSize * DrawData.iBufferSize; + + drawData.vByteBuffer.limit(newVlimit); + drawData.iByteBuffer.limit(newIlimit); + + glBufferData(GL_ARRAY_BUFFER, drawData.vByteBuffer, GL_STATIC_DRAW); + glBufferData(GL_ELEMENT_ARRAY_BUFFER, drawData.iByteBuffer, GL_STATIC_DRAW); + + verticesOffset += ((verticesSize) * DrawData.vBufferSize) + 4; + indexOffset += ((indexSize) * DrawData.iBufferSize) + 2; + + final float clipOffX = drawData.displayPosX; // (0,0) unless using multi-viewports + final float clipOffY = drawData.displayPosY; + final float clipScaleX = drawData.framebufferScaleX; // (1,1) unless using retina display which are often (2,2) + final float clipScaleY = drawData.framebufferScaleY; + + int idxBufferOffset = 0; + + for (int j = 0; j < cmdSize; j++) { + final int elemCount = (int) drawData.cmdByteBuffer.getFloat(); + float clipRectX = drawData.cmdByteBuffer.getFloat(); + float clipRectY = drawData.cmdByteBuffer.getFloat(); + float clipRectZ = drawData.cmdByteBuffer.getFloat(); + float clipRectW = drawData.cmdByteBuffer.getFloat(); + final int textureID = (int) drawData.cmdByteBuffer.getFloat(); + + clipRectX = (clipRectX - clipOffX) * clipScaleX; + clipRectY = (clipRectY - clipOffY) * clipScaleY; + clipRectZ = (clipRectZ - clipOffX) * clipScaleX; + clipRectW = (clipRectW - clipOffY) * clipScaleY; + + if (clipRectX < fbWidth && clipRectY < fbHeight && clipRectZ >= 0.0f && clipRectW >= 0.0f) { + glScissor((int) clipRectX, (int) (fbHeight - clipRectW), (int) (clipRectZ - clipRectX), (int) (clipRectW - clipRectY)); + glBindTexture(GL_TEXTURE_2D, textureID); + glDrawElements(GL_TRIANGLES, elemCount, GL_UNSIGNED_SHORT, idxBufferOffset); + } + + idxBufferOffset += elemCount * 2; + } + } + + unbind(); + restoreModifiedGlState(); + } + + /** + * Call this method in the end of your app working state to clear used resources. + */ + public void dispose() { + glDeleteTextures(gFontTexture); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); + glDeleteBuffers(iBufferHandle); + glDeleteBuffers(vBufferHandle); + glDetachShader(programId, vertexShaderId); + glDetachShader(programId, fragmentShaderId); + glDeleteProgram(programId); + } + + private void prepareShader(final CharSequence fragShaderSource, final CharSequence vertShaderSource) { + fragmentShaderId = loadAndCompileShader(GL_FRAGMENT_SHADER, fragShaderSource); + vertexShaderId = loadAndCompileShader(GL_VERTEX_SHADER, vertShaderSource); + + programId = glCreateProgram(); + glAttachShader(programId, fragmentShaderId); + glAttachShader(programId, vertexShaderId); + glLinkProgram(programId); + + if (glGetProgrami(programId, GL_LINK_STATUS) != GL_TRUE) { + throw new IllegalStateException(glGetProgramInfoLog(programId)); + } + } + + private void prepareFont() { + TexDataRGBA32 texData = new TexDataRGBA32(); + ImGui.GetTexDataAsRGBA32(texData, texData.pixelBuffer); + + gFontTexture = glGenTextures(); + + glBindTexture(GL_TEXTURE_2D, gFontTexture); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, texData.width, texData.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, texData.pixelBuffer); + + ImGui.SetFontTexID(gFontTexture); + } + + private void backupGlState() { + glGetIntegerv(GL_ACTIVE_TEXTURE, lastActiveTexture); + glGetIntegerv(GL_CURRENT_PROGRAM, lastProgram); + glGetIntegerv(GL_TEXTURE_BINDING_2D, lastTexture); + // int[] last_sampler; glGetIntegerv(GL_SAMPLER_BINDING, &last_sampler); // do it by yourself if needed + glGetIntegerv(GL_ARRAY_BUFFER_BINDING, lastArrayBuffer); + // int[] last_vertex_array_object; glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &last_vertex_array_object); // do it by yourself if needed + // int[] last_polygon_mode; glGetIntegerv(GL_POLYGON_MODE, last_polygon_mode); // do it by yourself if needed + glGetIntegerv(GL_VIEWPORT, lastViewport); + glGetIntegerv(GL_SCISSOR_BOX, lastScissorBox); + glGetIntegerv(GL_BLEND_SRC_RGB, lastBlendSrcRgb); + glGetIntegerv(GL_BLEND_DST_RGB, lastBlendDstRgb); + glGetIntegerv(GL_BLEND_SRC_ALPHA, lastBlendSrcAlpha); + glGetIntegerv(GL_BLEND_DST_ALPHA, lastBlendDstAlpha); + glGetIntegerv(GL_BLEND_EQUATION_RGB, lastBlendEquationRgb); + glGetIntegerv(GL_BLEND_EQUATION_ALPHA, lastBlendEquationAlpha); + lastEnableBlend = glIsEnabled(GL_BLEND); + lastEnableCullFace = glIsEnabled(GL_CULL_FACE); + lastEnableDepthTest = glIsEnabled(GL_DEPTH_TEST); + lastEnableScissorTest = glIsEnabled(GL_SCISSOR_TEST); + } + + private void restoreModifiedGlState() { + glUseProgram(lastProgram[0]); + glBindTexture(GL_TEXTURE_2D, lastTexture[0]); + glActiveTexture(lastActiveTexture[0]); + glBindBuffer(GL_ARRAY_BUFFER, lastArrayBuffer[0]); + glBlendEquationSeparate(lastBlendEquationRgb[0], lastBlendEquationAlpha[0]); + glBlendFuncSeparate(lastBlendSrcRgb[0], lastBlendDstRgb[0], lastBlendSrcAlpha[0], lastBlendDstAlpha[0]); + // @formatter:off + if (lastEnableBlend) glEnable(GL_BLEND); else glDisable(GL_BLEND); + if (lastEnableCullFace) glEnable(GL_CULL_FACE); else glDisable(GL_CULL_FACE); + if (lastEnableDepthTest) glEnable(GL_DEPTH_TEST); else glDisable(GL_DEPTH_TEST); + if (lastEnableScissorTest) glEnable(GL_SCISSOR_TEST); else glDisable(GL_SCISSOR_TEST); + // @formatter:on + glViewport(lastViewport[0], lastViewport[1], lastViewport[2], lastViewport[3]); + glScissor(lastScissorBox[0], lastScissorBox[1], lastScissorBox[2], lastScissorBox[3]); + } + + private void bind(final DrawData drawData) { + glViewport(0, 0, (int) drawData.displaySizeX, (int) drawData.displaySizeY); + glActiveTexture(GL_TEXTURE0); + glEnable(GL_BLEND); + glBlendEquation(GL_FUNC_ADD); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + glDisable(GL_CULL_FACE); + glDisable(GL_DEPTH_TEST); + glEnable(GL_SCISSOR_TEST); + + final float L = drawData.displayPosX; + final float R = drawData.displayPosX + drawData.displaySizeX; + final float T = drawData.displayPosY; + final float B = drawData.displayPosY + drawData.displaySizeY; + + // Orthographic matrix projection + projMatrix[0] = 2.0f / (R - L); + projMatrix[5] = 2.0f / (T - B); + projMatrix[10] = -1.0f; + projMatrix[12] = (R + L) / (L - R); + projMatrix[13] = (T + B) / (B - T); + projMatrix[15] = 1.0f; + + // Bind vertices + glBindBuffer(GL_ARRAY_BUFFER, vBufferHandle); + + int location = glGetAttribLocation(programId, "Position"); + glEnableVertexAttribArray(location); + glVertexAttribPointer(location, 2, GL_FLOAT, false, 20, 0); + + location = glGetAttribLocation(programId, "UV"); + glEnableVertexAttribArray(location); + glVertexAttribPointer(location, 2, GL_FLOAT, false, 20, 8); + + location = glGetAttribLocation(programId, "Color"); + glEnableVertexAttribArray(location); + glVertexAttribPointer(location, 4, GL_UNSIGNED_BYTE, true, 20, 16); + + //Bind index + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, iBufferHandle); + + // Bind shader + glUseProgram(programId); + glUniformMatrix4fv(glGetUniformLocation(programId, "ProjMtx"), false, projMatrix); + glUniform1i(glGetUniformLocation(programId, "Texture"), 0); + } + + private void unbind() { + // Unbind vertices + glBindBuffer(GL_ARRAY_BUFFER, 0); + + glDisableVertexAttribArray(glGetAttribLocation(programId, "Position")); + glDisableVertexAttribArray(glGetAttribLocation(programId, "UV")); + glDisableVertexAttribArray(glGetAttribLocation(programId, "Color")); + + // Unbind index + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); + glFlush(); + + // Unbind shader + glUseProgram(0); + } + + private int loadAndCompileShader(final int type, final CharSequence source) { + int id = glCreateShader(type); + glShaderSource(id, source); + glCompileShader(id); + if (glGetShaderi(id, GL_COMPILE_STATUS) != GL_TRUE) { + throw new IllegalStateException(glGetShaderInfoLog(id)); + } + return id; + } + + private CharSequence readFromResources(final String path) { + StringBuilder builder = new StringBuilder(); + + try (InputStream in = getClass().getClassLoader().getResourceAsStream(path); + BufferedReader reader = new BufferedReader(new InputStreamReader(Objects.requireNonNull(in)))) { + String line; + while ((line = reader.readLine()) != null) { + builder.append(line).append('\n'); + } + } catch (IOException ex) { + throw new UncheckedIOException("Failed to read from resources!", ex); + } + + return builder.toString(); + } +} diff --git a/imgui-lwjgl3/src/main/resources/default.frag b/imgui-lwjgl3/src/main/resources/default.frag new file mode 100644 index 0000000..a0da87a --- /dev/null +++ b/imgui-lwjgl3/src/main/resources/default.frag @@ -0,0 +1,14 @@ +#version 130 + +#ifdef GL_ES +precision mediump float; +#endif + +uniform sampler2D Texture; +in vec2 Frag_UV; +in vec4 Frag_Color; + +void main() +{ + gl_FragColor = Frag_Color * texture2D(Texture, Frag_UV.st); +} diff --git a/imgui-lwjgl3/src/main/resources/default.vert b/imgui-lwjgl3/src/main/resources/default.vert new file mode 100644 index 0000000..7d7b8a8 --- /dev/null +++ b/imgui-lwjgl3/src/main/resources/default.vert @@ -0,0 +1,15 @@ +#version 130 + +uniform mat4 ProjMtx; +in vec2 Position; +in vec2 UV; +in vec4 Color; +out vec2 Frag_UV; +out vec4 Frag_Color; + +void main() +{ + Frag_UV = UV; + Frag_Color = Color; + gl_Position = ProjMtx * vec4(Position.xy, 0, 1); +} diff --git a/libs/imgui-java.dll b/libs/imgui-java.dll new file mode 100644 index 0000000000000000000000000000000000000000..e2efa052e1c8ba16b6a5a91d5a0bf7016e96e0e7 GIT binary patch literal 2285445 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

=b# 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 z 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%0A%%=mAy*;9+`~8lgD>IvH$qg4K1T%BVAtU=nr=af z=!S&Upnn#dkjj`Z`6~Ob+|X&EeGj{fr0M=C5Jak-*&8Req4&t$zQh%1&V^^QiScn& z`e0+;!AaiwGRC0NyCb>+_X;&118qK8sDFiw2umBIKV!y3J2*l&5s@XP+n0c7Pf(#R zx8&h;+&7<+3u!@LXI!I#uAy&(a6`SG_z`T|I1nvY6gCLbI{PdW$2fyALxa9P*9^c;D0kLQJSrm{>0VP*>?E4OmB!m z^l0Jw!<2{-%7haG)_oPuMMMmDW2M^6F161*iV!j59m*AVpiu+umF77obX`G-k-sy$ zU&;eLkzpDLz<-kfxFrFV*l<0Cv)8b*E?mPT5Z#n+;%Y1Z#hH}VImilmq-SjoB?4zU znsf?LMLpK(J(218IqRqzAAEhl>BcO9T`S(4dJ==xZ%+U1Hh03Z}Rq9H(aXov1 zu8lzCB5HyWc)Z6l3(r7K=^^1@d4NwRf`)zo7vKDfrta5zFkVPPsayLYwDdU5WXU?H zTtbwId(YvSOqP$pI=cb(9D`|3rqlbE6#J@#2@We#09il@KW7S5PiULw~B|;WjXUK zXD`c{V>z!;&VbfUxhk}-kox7 zICPO&VH^4&wEZ7kVUD&IYkug$ta+TD5Y(CzygxaGKiV3^1+)PED%PxoQ?aH@IV-dk zxhk}0d8_5T*>aAuoFgqKjV&sRA(rzx%Q?Vux-F;6a^_i1>H`W{j^(_@a$apYudkCD@DD;F4eylB+y*Ap(DzUPWL9hWW=KVU^u>m1110B0v^kM>_EQc-TcueAugaj zfWO?gFpt4WKlG^ameXT7@3)-yTF!CGS)m;yS3vUuKcm#OA~?l|moi6gr)=eXNM%@4 z#g+0Z=5vH%K12}}n}6ZbYCq8j^C2;2o`fEZ!I+^BSCCS+>w@b6w%a&!NYSK%D2q59Mml4N(2o> zOh6lqzg%2@ayzQ@fYz7VqGV(r<*d-0b?tQ zDhxMY!wH6MppQRwW=}wuN$9J&i=rQFwV*2`^l}M3iJ+g7&>hdQX2&bkXaI_qt>9Cz2z&J@d;Y&p-goDD2zqUE$%&Qs_DDz}rC^O)uQ-EtnW zoQEtYjl~K>&~pB0Irmx4J(hEq<=kO8w^`1wE$1f7`K9GtXE|3}&Q+Fkh2>msIX}0Y zi!J8@%lWD0{K#_t%W}SJIp4CJuUpPnEayv>bDrh=r{#Rwaz3e?71~qe5>F3W*{wUAfDoU^ zsGU42aa5)e^{kAd@mZznZA3l9QK`3aPfGsaT7qZ>g)tD`EK}WS<#mWQ&M7KSrn;99 z`jZ9kr>j(#$W+v(R9-<&H4MoC2cQVS{%+`0TNwD;{Qs4CE@1(6LJRjW>n5fMc(Y8(X`)I5_?RMI>A*~Ma-=_^H zFE%X?0J=4B@r0k;ixQkiiGA8taECTyz-Y}GM#0x-P9Dl{jr_6Kxo5g5FctFR~ zfbxMd1r*!~0CCf>2YR7)N0UDG&`GlPobek92X#^=-SkjYPDO>1<*t88O%garyZAQ}kgwBi zpbUGvyr1twjKhly!SR|xj@(Ul>sl{Bi1T2_ixT}XizqrSmUsFSTB*XuWYU2~8&N1x!7neHpfybtf!d|}kmGZ=4CEOui*bw>>qR2CtUu3Nk zYnjl)VC*omg(yEvw174q1<;;5Ert|K{$a$(Mfg*F*kLcrIaXXc?Nuk} z#gyM>&lw;(w7P_750!}_n#Ja`#2+7l&1WO1pd=I&4Kc15?2z_YXm|Uo=mruzGI*}1 zyDx$CLQTELY=zKKkqSL*JjCvK2(=-`o&X;p3s8KpVh*ePF&@kMx0fY^N;wbGhi9S< z7BPODcU$fBo#~nEwb{_{?nR)}mxgBNxxv>c*YBv#)f2qOZPbFHH=)e&Ksc#V4^dV+ zT|7eiSn(rm>4J#<$XD9$qTQs2Co=RUc=HAA(O%Xl^cK$-hmmur$Sl4rf6evy=7Xli@C(fj$7Q%~G%o~9T;tNKL`>#HXxDP4% z{)K`PqspxPeBNa>?FVuR5!yTB4YMD(kuy-a+EuQ7RIa-}h*lTW#g9##qvFS{R>2}n zENbD$(=x5tz!ewEkFCkX>jZ(J2W-auZw6&G+fxjMWx1>alOLBy^5Y6ZZ*Jew*kK3OMV*d zi2I_PBdWy6NSr3Va;_T_->ngNX0ng*Oi_56N<3zIZ)Ez6i1c|@`fe)y7L2?oTOIX% zA7eDyKkf0?e>~_S(~1qW{~c4`3mF;i`;jz+v$zg=_BIY1pT4#b*QdVUkZHv=Rt`h+suTz0SJn3ikX=-LZ{dh4aaSZxv%Z=};wy~6^9=jAzI_VM z1rm>$eoG_bhDpyA5$T6o>HDel``+QQ@yKnOfqltH%*h`W5gGqMOuQVQ{MuYIdl4i( zgfTO||CljS$y&vjbcaL|ECU?NkIGN_i>UmT#pD-B&r31!20cX_L+lX4!|7=iOV4nX zf0m-hrTlGU>4`0WBt4JUN>8Ch&zj%D_%j=;sqpp={uuec0yyGNwxVYa`6Kh28k1jS z{HU0CgFm?zJ=x*({5dOzo^w_HO%y#1mET5w1K(f^U&GGS=#^yjek{HYD*fJ0$STbG zsjG7=>^j!<)>k_HlXJYM8rUD754mv$7Hieh>_sc!_TOW3kH!1pL1)?CL@^$?^Zof` z9_7+Yr9Fbn8??FDVkr)fxu-Y+ImeI=?&GlE^gUGyck$+_nOGLnvWo=qvhNe!KHq9Y z^z$X!`ss;@y?nX0q+WV%ViKWnWpDI+=adk%O1|5f{Z--ZqWn=TD)gU1+80Sk>MZ*) z(Wx&bEc$z;6yQ(13WESYLCVjUEBV#uNcXO`6+2q#j&x5}Z(KWbe!$Tc36KKs{zRsL zJV{x+3X_CP0>N2gfAYmsu&&$M6A4fVtf1(9r#B(r-h!6x>&4i6wbFZ~dop?#?Jv9} z(96OO*|EL2b2gGfTx=h_5sU>w8zC$rgn?c%8*ELNi=G6BiE7Ck;e(*E7ql;EeG7CJ z(~sLc$$ZFyP52;>7m=)rg&Gz!$Hk?zW#ZR{VS!koWs!~p*?n?8tsJxo_=u_0^!(aY zw1V^}Z|5x&?KynJtum&yj5$xH*-bHhWsFzG6!A`q)*By@DPwqj>Q8=Grn!sqIY-6} zkZBIfn2#yuPtrp9x+K4OMqKqbPCw28ERF-6jzv%(5lxM;yCoi_duhHgVz|C_m|Z7d zO1a+2kw`km08mM*DAtWwtWa0cew9DD0K4I0GFJHrIzm+VlTXrWtw07Xr^5J?KP=srY$8T6J664(zD-6#lkfBl*03S`#IErXV}2)q`7)TRnvGuo80 z_j3A%V`=jx%(JlAX_m{zR!8t+B3a(FL>M+pXrVQGDSA8Wf?WFZD@4p{&K53%4y%i?Bh> z;M?vD`KG{|G&af1piI-3142Qh-L1S7?3QdeCcU zpnGjbjIDYLYGzOyR8T-W2OrKRpfxp|5Iyn!Hy$U4=@srP(c;YrZQpsE>KHyM)$f+` zh;oX9P`(1in}Rl6x*Vc3y7o3c0qsZprE)S2$rKaNHq&jU_`&&=;ba@+Vk!a{jCSU>=MC z%u8m3Hch6QYlH-}IhONr*VTMvJap17AR!g1OGuTdlc~%T6;A>IuKW(wPasFYi=Y8Xw58V6U%v);nX$KF^RQk z=OE}c8WXOS`M(_G{BK1Qku14KW~DlkF<+E~juMma?{sGS^(sWqa*j-n)f z?H@lRu)6pL^6FX=K1|0%;sNRzA4NyD;bc1OL`OjDXa;J@GR65uNI+|2Ia?{GSO_hZ zg9ky-(1McqwSD`UhSa9y)wPu^6b;vtKcJxPRt>G&G#GeqI?V@63qzh2P8+x z349dge^}1nlv7;FN;U0vWbIhWEb%8_kM4u~Unc~5>s|Oj{Q+Zxop6a$8dqBzTqFhT ze_A~)l~Varzob;Ke?xqM-db>AvJIaK?OOsyqHXlW56-VG=O)YfrQy`I0QKK@>0FIJ zc`P-csWSf_zsMbXj4!gWK65VTI{@Lp+t_G!&=(>e)N2}oDzrF?0KiFvDjJSi&fhKP z5yPo#Av8)P*-niXKhaW>a{v(HP$F3%S7@b-7w^;~{{lVvBY45WGJt?5BP4B2C2g|^ z6hD;c9f}WVGmQ{w@4}G*ZMqf8osW{}+5?p9b1gafV}KBM69q8b8AWPYaK88;QIOi7 zwTaqjfPjMSY4p+NAP)ImNT7typWKJy16qa=642UO&hsp1OT(#a%_!IAOo5h;U=Z~R zaY)xb0c}3*{hidszb9^`W5zD^q(_6ijmXO7{n6y2X^eP<_C^}41*`f4d(AX{6h(?H`J$!Tm zcTBGn(|@Ev8Sh^o7h8XVDwC9XwD~J&wZgJ9WISk`!ZG@^t1G$e=lHmLLn`!^ChDob zfn3rrn(b{L0uU3C7>HP&?Mkoiq|3AmD|_xT)Bxu*|0HnlBvpee|Z=zt<6 z;yleUsONS|wHw`i^4s-vl|`j+Ti{F*vRZs10S1qb9MXlT!y|6J)L@y@Kc`f34u8Qw z443ptrw?GHq_5WR#!6rAPvHCjRvyO~5PJ+kx6Y4(suR)y$6-h;alt9jpc>4s?L6;Ad1kRbQ|& zoC3KXl82VV&X0a}oGRZY4(_3xqVyYL+g{mt?tMC}C(A+^_@d6E-lp)qSR=ki6}~pL zVf3XceEBuvyGr5vYHoe$TSe;^l=rXQHI?@#&ZSCBi^W%S{mt|k^{3XGer+u0 zVD9JM$|z}5jr0gJ*(dk^RbEYHUS|3WBGYF?q|dX`cT?%NJjG=<>LZ$es=UcHmiG@1 ztrAa29AV8>oxkB-$?*E%^%wZ}#dkIF?=6L|NA38c==0Ee4*2e_5#J38-=Qb#TfglT zzScG3YoPGG9E-2!`h9akO#PN0C5p}ZE#i!f`hAmqT)*?!StTx)d71U=jZB{#k-or6 zKT@Utbq<$Z(npuBAa6R$HkZ45^6PhF-IL?&?9`npPG9m5shHaXIat5J>N6)DnKS4Vh{Wq5?!r_D#A%u?J?(U>+@Qf9g1?@{qBa6*sv zbo{NaK|W4>80N#)SCKQ2gOleNaP(na;m(1)i|GNQPWj>zIK>zD(_obRO(-EQkVE4k zAd>*dvsDCvfgCl|=43KhAg8PP=Fk^q!+%#?#q?Pmj4>*xRaaMA?Y-2g49B>?ukLa>0 zgGSvH#?RHSsjOan++r;cd#ZnNOF|j!MK7bdp>NDRJ3el4M{0;Y)6t@}EAB)w0zJ8d zIrW|?i=Z^YN~Wiijv@5zYo1@n9XZPyBf{O&ZT7Vg@Ld6XnWY6KM*Qra+>z;&w)a>I zk3bf??%*s`|LTb@r+rO9dQWtBk~s4-Ai39)rSobs7Cmy9(0ElMz{M9`WzOb zIrJF0vv0+8mMlmz2p*z_YW|G+uCYD#zzvMlw%>|v+eMYK^|bOwRzNtu8rtJQT=Ga5 zhs0vMOkrF*I~=2duh#ZBPhm`m#kgm?q;XOhMgw1s?*4h6`7(e&F zVwF|vu&lUEMd?2!v0;m#$oOkx;w8O)EyE;7oXdGBedf1!8I;Q=j81i&c86dOS@jL^ z*sleZe=qqX^XnXwUu67QG4TdHzcEr`kI;daR#PmTyJP8Dqw>F5(X&|j2gTBJN=DVn zpYLMg4SH5`4AXObYZyJB-x&p&Ccnt|$7A9RdI~v)>A54E zo{q8fxK#cQMNhW!XOZ8)cdLaj+fGu4QU7A^R!mgfdS`xOlb zr56us<&hW8h%-%DkN{-=Woud3cWx2yU(IikxM{hT)0;A$c^IQJdFNciQT@o>&dE`< zcqH$F?i_Uix%>9vC^~K4VZec7l=R@vgP; zT`tXTgpz#p1(B5x9FDuZg!;t$#1Z5CUHU-L1ndb9sbam! zaU*o2_!kuIIiga;%_PkzPDYfAR0M_gfnM3Zea~@z`W*UXZ5BttN%OKq#ToetD_=Gm zC>eFzi-uF%8v9r&5_^v)*`K(9{QjvqF8xoZ?=GlG4;G${_m6OMIh_~4elYH1X=bDC zh$_*D?S~&j_tTIO zNbG)+_rxjBez(6MCwLcCt?vWbDG%Cgd$43+loBjNIr>`&OQ+#+>L!_p9%F6ze{K0;5gc89%8bfCqvrDejA*|$j`geN==)z@eq(-4!)ohS?qj0B0|D4_>X~*=j$7BWeJS9c)mW22|8@P zc3f%A*IRQqikcb?`UPFA`T9f;j`}Z}uO)rc7k^KUT29xk>(LaL3sC@$fw@Dc)BfzH!vWJj4!zKR5hRB6)?8)G$BK;)qHyW~wi zzv_Wth$rYAx*rbnD{j@V7HwgTQbP0T+qKQ7_8*8t+UoC(`4n9@Vn$WtfgBxZo~!?i zx+Qi-9Z1=M=fkF0Gm1H%dZBd!E!{y2??okq&8iqod^DK+2XsWwsS)FsUFNxZFXf3F zVIfaoRt*;^kn_C%FlVtTc24b28G-{tA2c{%m7mV^q5Mn>sv)ZUYC&a;r1h?c=<*x$ z>DQ+ARxGBRjrHz<5s^bGNP0)AUW0Q0NAu}(%0EN-jrfl#sTD6b86wy7%Vg48_a9!0 zi8tsi;uxO)C$9>lw|gwT!xepl07vw=l;1)ANP6yx$uBa#e@whV&lMcQ^aNLi(ewWB z82&X>`IiBX=sCVy?jLc2!i^(rC{*+7_#y^9e{T##e3=gNLRV+P=RsLCuo_CbL zZ7e-s#^e`C&j&H_20e2*hUr;T9>$;9!(#YzhsysIz!86jEB_qj*Oh+|B}M#X>6c7k zdBK=DNXHKU_bZF1vQ~MHjBo=S(gInQKde3Tt1Rj_$taf);J+eGkU+vw~*Ly6du#02H-nbk(o_yQ} zbmx|O_Z;??Hp|sFJIa1eB&^==?Y0#-SPHFJvlPdyCZ2tvMSw(}fJk77Jq=`hZd{^c zmd&$2^sGTFzLH)S=*@F7wIFys5E$z#wO|b%K1CKR2$KTi@)m3XqRgyrTZc&_ZNRnOf8%ny$PzsDCDmdV_xA_ccfu z#_#xA_`R^%z=Ga7GyEILaOb9D;XIEbJC^717S9QpLvP~wKJ@PhrpJ2~(--FEBmu&P zYI&0Bw)ow*4t~ei%mN|i5b*{vVXRF|HL#)$7BEmB;8X0$!W4Hr)_p+;}w84F1@_4 zy{WHq;Z9KiPOf(0B8dF#O^#Vpsy#nbD%)ze4Y!wuprATgT{u9kKXPVeI{lMuz3mHH zrSvY^X@8v5SPnqZ9ZB{DI|)r5T3^GwS%Z^ogdK!>4)*mYVv{apW0WVWJ&X7-3{CxHcmAz*ALsy&~x*_GViK>ooUvwWMPjEDTL`1}s*T$@4z z{O*?VQQW@Xte*n9;d)X$Slbxtez<*=IcrZQ>?XF=#o<2A!p0Xp3ABg5S z?lZ>D6LCC`aSk(aPIWs_{CePv;Q111>PGj61o_1&@VmR>_grQ*|A{y+rhnIGdd=0O@L%dCCv1i+mmh_(v zqS+|s{8oXzvo;J_O+4#}JtcW4TnJhHz_J4S4Qr0rSFE-nIQ1$7d(KU`o8&fP;;4bDv-C^_e(7Qkoac6RE5+$-1Y4DPC&c;?PdSHZVC_`ssdUnIp!eT|}Zm{Bv>y4I!`C{^Ro-gjlryMQ# zK>O*}r2ZR?yb#YPXb+u2q|}B?M;JD}laGH2Yk`$RY4f0P7yQEsB%t-jhkjym4n|48 zcFQLaYyHXV01cz&D-bK5xPcMe4jEniItaY-Ypo3Ys*8gj#-}G=hZxWU`7cNg^^3SK zKhy2+vbA?Y96yTS*8gzoTk+G{ z;2>Y2abZJOFE`JsaTCM^?Q%bw?0Yv}K+Rziy54c|XFfFtD06o3SW_Y1L!?_j!X$`i zGT^B>mwnhag{lgZCEj3F;Qs(PE&nD0X>bZH?@J=y)ASy2y8Ywm5p8Z@ke=7#>}$Th zQgms2s+uL)!hW;^<#WQ|qhlkt&y$j${iFTyJXD3RcbZc_)b1k`7*GE=>~jOXi*Sq9 zJc_y@olH}5;6#{bq%+Vb1z@n+Lbs+nmJ)i3qdDiMgLQ=&!j(jum7bQ^6{2M(sUGZX z8k31fQS3$E0gKcfnH|_M%3-|cfUCY?mitnEhaaae-%EMO{U)bx;bF#g)L!I5ElrVih>t)IYl?AR- zY3xOhAg|zd{ITTuqi*o(3&pD!k+;+Lh2#~OeLgruS{ZqN5^H9P_b^P;ielyzy;v!E zMT*hKn*cX>^_PL)saWF#Yn)(>-Af9goLNwUf{R2RGtw!*Cr}vN#Og`h0D~G2E6XY< z=YnSt-3$Ij`G=lV@|=CaLh=V;PK`3{s-XS}w&3VoYB|S6632&Y ze}fmIicx2sM{=Fni^q~AKwGWh49#IxqH6u1wH;^`-7r53JdTG^i;qWpS_&t+7bQ*@ zCcOR9ZAW{xvK8itM=%D8PAW?0s`m~+Y@b#(Pe+l9;W&5z8)YOiTm=t0o_M*TG!lR7 zc8sAtksgtuA4ON`5-9)+Z8JtH`K@Pv{_J<7Kj*6^649T}LABS?pYK9cE;=+_l|_%N zaE~5dcaNS3_SDg%-v*YNdNkE%u5SRcTBCaO_o!;L#kY{azK|;(9dzm=_JyZHDRTUz zeu7e%P%$+81C%LHRup62dF`57H}8?aL0@293dL&$ai@ zCAdTF@AOZVOL+gJS5AZU9-)z+TbKP)mHZ%;e<61P?r!%}yI%NL2#=u^5pU26Xc=3;sRszK*CQ_eF=FX$=V?h_yH`f3>*qvc= zFasmOx9AwAzUK)!n5?lE6%&1y&IhAyf&S;0(d81nU!^a+KRPXs zL>0xH(i(<>`;ZoW`F>3P!4_a8+y!vU_7OyvsunYmnbBXb5&v{iK9T+Pe6bn5OJJj& zI-PiTT$e9}&bzl{l(LpDFG~67JDr7T|z{<;BoqLN^p~p%1CYlKdl| z1^R^SX#A;DR@3er-p$b*U(je!hOp*OK-u&pumB$V#64m13DS2ZIr&m?{~1V+^?)h5 z@PJ^&-_oF#c$NQUGXI@xjr`}Z%_-%7LkaRfoAb}dY>k1=Pj*goveelfv`hX%xa0jyZT$r?k-C zt7|g@6fp;IlO*j4BssdCZGUM++l{}L^C=^~;mqRKBYDiP(7z0Nn_NqEL-Yn70ll~M zXMTadqPZKxSxypi$76RST*|SM{>t-2Ii#0^*z?um6jZpl2&jpvuug|v1sk+vbRp!l zJ1-`a_6Cv*7PfSW9$mI~CEn6SjeW&>9l9)a$P7@hhX#8{6-e`0UvgH7UAGt;?}~&P z^M4D5SW)@EPN&3V{=pmJjLd%l-q1zR1*Yru~UH`heZPv@ERNPUU^ zCEunX9><74OyGre6JST7cbJ)!P$qX-nZW#>Gr1j^D0bIe-&X-`6u+;y+~oJUV`Ivf z2Lh4x0E%IL7gN@U(W_PYRyk$X2glS@z6MtLlr@)=8=$^naXPiXw|Y_PaN4Ye2e73W1+RwK05Oqk^@?!9+s&h9ij07Rn|fk z37sRX30*;;XhJo%pKU#3`1^I1S%%?6PGtM}u@&?82_}@<^KC?D2{&TyPq!&z{G)5) z?^{S-S9|UgOHZyvPls4~hDv%yoAmrX9rVOm^lYWU2+a9wR890Wx9G9z8|y5LH(cKf z9kRaLKx5~i#a@tk3yepq2VzwPO>w2@84u-f>ie+oXJ+9F$}6a*>DFDU=qyxpHO4}H zidE5vZYCzvZOy5-62Sw|A*iBpeeJQ(I&1j)M@#T)xvJ+gRZ%Xhu_$f=l|u!0DbwB| zo!+|g@i_!67#$Uu%)1RrvwJJhpzRCJ#EZI_ET8)txL|NbHkV_ZHXPBht#W2pOq;~w z7M|`y-^SHRg-$xq!xv3=_y(^v*{0z!xjtAx^vRsiZB~-g+lST;fbg!u7jIByubAMJ zdkzT9-uS>r$dayLS|kk?)kA3Iuo|;3fE^8Tza65VXK4xI9TnJY!?a)lk=zfX6hIU% zmxT063%w2T1N0$KFY_d#Jg-v}+prmf3%+6e;6qQa+u3IF!vTK$0)FJ$7bayLEPxiL z+LIf65g}pgKk#R};tyT=gM-z!txg-P2D7)=pLi0mSlXbeffR>c#yAQ`;Q=&oYgC%E z!xrbJli2XKOOO0U?D*g*SZZ&n=rz@Fdke(#LyIy1+jv}lYP!^d1(`# zCmJP%ug35Y`@xEdl*;p7jZBn84h+31`37RC{)35-$inz#&F7z7i=sjPdC!>72aTrI z%k%leXuMCNUDh(bOhnSC@w>2-IleTkju~HOrpfV}VtD+1V=8jUH}OcEcBcTZ0PJ@YZ`s!r*_h(+Veiz8~H zXCac;Mb8bf^b8K8r&kO;1&W?rgPz_re56?P{J%^5>m_ zG4y#V~(TiJs}SK9KU&5Jk_!!)xNtvq-M^W3{)QAOf6z@83pyyLmWaXL*~j zpAYOtd&@){riY4QkLp?kjlxv00B2-+82}_P3)Ooc$v9=!UrkgNxaZE5qS~74@ls`EhVA%XcVIy zL(hSBaifY^9J~n~RdKfu7ZC5?4zmO))rZx5#!EtC5UkN-8PwoS$)FyoCWC&XAiRjK zIHW~#Xclp3AtsEt0`IA651zRMBxXfpb1Pm9=F>!i7CcIMR)jRfKiUO~A;dM!f6gi1&sW)!e@DvQP=-S4gvhiJ7=kfQeJD2;R#qsT6(S4V5b9 zT+D^567e?>bCi7#H5Xi=&$Vxp3)r27-KI~0&I0z$y?UXB?8`QaUk?ApO^ywJgPBLj zS1E3W9#;?$`q>Kon!*cceN1UEbs?F3;YRW0 zF6vcfJh=ti?mks5W=k~Y2%NP!cn63G_dkb3raw5ZDlE37B)Idtuvnviq;vnExh}fQ zUAfFHsLZ+cW#AbvsN`fDY$FROCLWF{@MiHn-mi(>pN7`cNpHDh>%BL1{T03K%dkt~ z&gdcEAQSU;|3y31J>r%m0=wr@(m-R@4DAEI9?(S|%{uDHuJE+ZSzrs6 z0^I1|2*m!CO7C2LT%|xO#N_>lyTb`*_BN+|zzL_f+Gc$` z8?GR@;!>x*_X)Rt0svxbDpm9`r|pz8K@KxcoPD%=_fysj;@sIkPE4cGVLI&^716tr zd?+A@%A}{p3#&jEGt6GR4nfxa<5Wys1!a>(g#{;Wz#L$6>-|y)Q}HJN&f4row#ZXJ4xQ$0;vDH0HclG%&mI2s9o zDO5(O1m>~eH3*hGxRwAAT!vuc1?qiDO0YA^19h{_lZy@{JXcYTKa|nldmeP27_}#S2P5RK z=>1}s{#7on?d%9eF88Wjy&O$U^{pOjc-Oc`+#>E7b?&hk4``r zx6`jpR&_!4xQveWq9*}UP~uvIJ#&tr7duG0b#=f3YPGY&M%eMVvP<3e0oa2&hR*a2 ziccF=E%A)7Q{O1}0}HyP6;5H{7&ZhR9D`Z~afj0^t))koPRO-;@-2-XkrF{i&IEL#$-_jh)Dt<2L4fJHX$B z@Q*t!{^w2n8^;0vPAXQt@Ne1-{EbhGe~F2IJmH^GZ~QX||NDn%YOf!EQV4&`dgFHx zf83|X|A4{&kM08grCsaGpDLpNz%Qqxe}svDAmJZbZ~Qi*fA(qdw=nS^#vKmgB+VlA zs^5=^{*I@`zr$njr-bm&t2h3e3IFu&Gn-KnSr^P?Q#J}+l;NMAO zM!on`wh8zfpB8@$6aRR^Kc(LI?<4&0A2=Oy5uH;dh@F|MMpPk8TJ4 zr8L~ti$9w-0{?-~>F6I};vY!(N7ftvD};ac-@t$PAHaVSQ%L>jA4K>&o)-VrCjBLZ ze_p-u+X(-9y2`rF@vVi4Ka=oxt2h3SVV)w!ofiL&2}b+bSOEMxF)7xMKQ|Np#;3*q zyorB2;h$1({7ne|`@z%k=Rp&H3gK^AZ~SFn0>AsT_(z!dKe`S0mtIz1{@h3S4~Wyz z-@?Q{knoSJH~zMSfA(qd_cie!z7_aSX4RMeO&fr}<7x4qY2q&-{PXIKe+J=S|I_LC zv-WB{%T4^B-30ul z7f14EI^pkDD}Ec{Kd`3``YrrJ2>+NU{ON>$=lQkO@5ifve|BB?UpDFgovs6li^5-u zvz||pB^UuE`&cP3V$5oU)r`d z{*F9T-)-Xe5dP^=_;U#V$@JRj zZ%g>!|E>=HEI09|68`ik{CjW_oS0WD{!Qh;@2(5~G!y@4BY?jYQ(-uNrW5{dwc?*a z_z&!=gZ>Xq{6h%;m?-?|gnuWLJf`$x=&xA5$|C%;>%xDpiU0TEz#kWdzZ4hDi7B<> z-@5|%JJyB&QWO8vgnvG!!f^hKA^a_C#XpDeum83V{v5)BPqxo4gg++=e;naodR_#7 zl>QJe!}8r%xL#i0B$ih}t4$|Bs<6)}TzuaL>2urDZLU(arH&T7_$lqn8gbxzjri`3 zz;}E@c$!Fj`SrrrCIa6(b>RE!lkmJiAH?mhQoAsVjVbX*+)fCTB`eA6W<2hZAB+=W zP8rW;oHeCyAD$kn0AE9}&7I&7j)nu%BDZ&;>7{t*SiHpR!lAvvNlB3aGX9Uv28Om# z7-G_=M5gziNCHS$5sr*Jr8Av(O%LX1%uuC}oqu z4gZ#YkIq9J+e~dZ{5(WxnHY;Z#HfCJXS-qR8~hrktwc|a?Ww`x@b)?RtMEFGY)>yP z3XcQ6i1StHbnB`96?9Mbq6(rHZNK~%;0}~QyHf33f-wB1_i#aF0?Q~@_Ex7oZ?)K# z2DN1IK^Kk>-RAT)hccEl9oGqH$D1EU0&K3V@-=tr zztbsDsHoBEDqv(0k+5*E+h>EW-T|$;J9}S&-aF2-HlK7v(5@X9v(XuG2B9#?4K+g> z&_P;Q)0WI}6ApGoa$w#PT;beO^dc*&`{v_>FNli+Ne0~9ryVLh*9k`GYeWgHO zx(9AmiKspE0vw!3tL4I~P(WP1kvj;VJk;9u)YBL*3P0A z-3>(cJmo^515sb2pV9v^5KVs5zA%&N-{jT1YyJ-*`6*9dJCw?jJV)r$Tw z24Q^~o_i*0)OY~vAJ`DCbL$m8*rKkPbg?fr(LPEVT-a#y?;_Ey8c06M5FLCFNgustcZvpGZWZjfP?{xgyt3r zb=Ak=pCjtyl?g^RVfFEX4}p>O(ePn{;0cejTzIk@az8qRjhDGw;*Z$IJIqlIZ$) z?y4i$;9~YTtc%He$&WM&F!0iE5+9b`HP861gDV(pKS$U32}xXNYjXbvVZ|kzW*Q9SqEWn;m-cS z?kBS#b-s#CTq@yr`SK0hKzp$?6CRq9uOD~&^3q%#f^VyZM&VeU82QL zH2H6LCP?EAX(X`?sEO1CarW86!4a~nxiYJ?q5hL!s6;Mb>!sb{eb z1)bDRm@FFgNeAJuQJDne%+Or2M|i0zS0L40m_ZKAnm~{EI2G(EK4>p4KmmY@O*cZH zP=9*{Gi~rbWI-OCJR_CoA@WQ?0$72PeGaO+Ay+w!QjTODEG#$xjh%blvzjM=Q?jrc_>Zmt>vJ;`Q&!vKwzh^d2Zj1s6};)FA--W+KY(ja8T z;UFcXDM!jISe&XpS}x8^mxic6OPegyW)lq?W~8B4jB|G_Mf%wwGwR%3cQFD&l+aX^ z{#}F=bAf1uq6J4Ve|i28jZ|5^oxr8@DDAl{g_VmcaG3aa2VzVv{7;u({yWwKqN0ZN z!1VzZKx!NxH{h0LH9r0d7}?lH_I0!dte467vXYI& zmf^N)7a0oD@jOEE#c@#0EUi=1-(R;VBC?iu)8byyABj|wDc;H*v zXS)48F@kQw$ofD#a|CT^*lST2$hMjzeps}EkcLsuZNm^1 zK7i6vhlaB3zw9%Y!p(htIUEL=Ok~kb;00zV@EI0nYEVs8gK9S$-?v%x6o#hYgZM-8 z7Taf{OAo~H&HJUXSOXT?rk>3!no2R^IHp|c^#g^p&4h`VFCol2tY<}HrktVVAUvT< z*Z^#QBo8FfNOeE0H@d?^q!-@+2jwpfu=**OQGnr+HKPDEnuQiAlQCR!TP98>Q<;0m zxf5>3K$%YiWp50Wmx#-_<71G;bW|l?pG3K0kljHxp5@{Kq9!ILgD_D+kSvDgyt2&qknoEK>l29GY=km~a zDW<55e{IjBPQ>~)M@kbetl=r&Y%p&x z_MxSbWxUI~3ik2=8;;F;PLTz@-TN}N%t$MGd(lh;;t&DmhF)nC3SniR>C8U#a8I`0 ze}Td`!Ox;m@+(b4p7v~zJM`Nr>zZusIPx{rNPen1qmW!JxGf=nnLRd8ZK<(u&71K+_ zEJchtTN&%C*!lY3FRFG^&-pqJbwcxXJk8hgtXF{^Hf{-c~4sRIG5QsHi!-jTqJ#BZC|!%0)kTh$H3g&{0QGy5ac4 z@{fvn2Qel`{-@91|BvlIe7Zb#exC7vvG*qMkyTax_-iCAfwtQP1r>drCUin4l}<0v zgx<1sCy;bPlHL#um8zGdNTsT%SJg=nwV8&W_Vl#NxI2#H=j|7OC!Oo*Ic&}(rI+2t(xt^nA3N_p#E$zZ9v@-StA2x?@4oTh zlw7?54orl8?S)b76*R;CRd8SG*^9aRADCVC19^7izSNKNXj84hyY~K-u?ELSLDy!rQ|yZ-?DXNvO7`3Kg-AYZqB#U%may-wWsDWcuUzK& z27HU3-@)PXHiNRXA2sdh-Jk`#-^n7ClBdB^qhhjIC$Xg_^0*yU5M)84UZqp z{v!SF2fv2VV*5GJgSvG!LSm#>k7RA~j_j=mKwb`lp7MgiMiQy}k775=WrcOKFXe7` zCY(Smcsutg(nGUV&E9tmA@lI;IW<^!Kar(&%j`Q%Es6}gg9{29XRl;#UikPS_CBfVTRzsp0 z)c?v`%HLOhtNi_%iuaBO%F}PFct7QP<>|?a_uGC@p5F0f`TLPSD}TS-yodG!dyn1U zdLdSVbNgi<;$wDX2`>$iFU{S)>oQ5%^%s2Lvy64->B@6YKXfkr3-Nd2-u@(#moa)z z|M;H%w1{;hDw-E=ucqU_qrC%QCZh5v-V!+O!0it_Z|;NqCek;~ALa40(0hun$GThf zM(8d0l<|9Ck9GUGmy}h8{4ySKm%;-+K1#cwhaLbvk~a2eDJ}Q~eh`P5yV^2{+*8dYAYwx~zZ*L78nEfim|30iyZ8uKAb3=vVWf zE6M?)*wJSp|0g7Wus&x80fU}>?VpDd@PYfk`qfW=;rgzZyrOIGG28-oo&-!U_Vw(+ zzNuJ@!-C?|-ob}D_MJWNihHMPJNBIO(C+bL=5^yZestHKbM8id?Cj5K2?Nj8FLV2C zt-t4~yJzplN33*|rGK?Q^0DW_iL-Aa5U($F2;S_Towu`U_5=JP*4}gOn4SMvgm+~v zp}wFW>vQ(?EWfw?SIB!azGOAqm3Z^_;q~H@PfJeF_bh>3wlj^?R-DgaaMZcx zz7txWKLY)`2NY)+zE>8_%dpVPGo-y^NL%Zo_;PMPv1RJDd(W){Le$|9Q)s3~;SGDv z<#pgX@V8yNZ|M)eZ*^PUfd)VatH1atB%dx2=BfK3WpO3fo`o!Ppc*-5uT*V$VBfN@ z>hfVwo-=RB9}l=q?`HU({3`_04m|uFA@+)&U0-?E4_CjF|JOrqaYxrPPwuU{V+UvE zzOGxIIvNmb1AV&g3Q&bFyqr{_xMR=5dr!WSS@!dTbO*ccySZyo)o(%YKr`!*c@H!H zRx$%cZ%BiLXil8#B<~$0jza8%g?;>N$B7ulF!Db2)a-UlcK}z#_kC5@u#6ecRc{K$ zbJ>B96N^~afg?DqcX#Zae=Pe}f6Jb4-tts6T=(HyMf>Le?sD|$S1*$RBs%t1{dha_ zl=rFzEp%eMaH}={c4lwZA-J>8PLLKGc$F9WIq6#2P!`V4fR4|;Ps(g?p8DzR9-K&m z;Xt0(`fPNIMPp}PHP1P4%1Mg4c(3RCD}#6JX1BM_gCD~A&FC{-5gv~Q`L(`X7&_2; z{z>meXMd!f{n6|>XgC0C)$Gqf$!Cv=bReK-3$CL_w8Y-3N48<&;0|rqnNDHE3}xT^ zEuR92_ni=X62Fgg;QF#6>s+zt2`O<{4zSip@nG5N|^S=Xq zc>i6FTWcE5}=%3k9 z_tcZ-zUJPle|Q@vY)|Vh_!Hj4;JzI<~l-en9J9uObB`+N3$n+|X`fRN+B z`793JzuMn%N*7wgGDAEAc=qs#q6qdg*n@or=2zHh(W{|TT}2MMx{Q{36t0&$QdaD%wF>XIQ@U`PE1 z4Q{~1%s=o+tnZ=uij#Y*&YLrRWtiSlnO?t(^ueT~?QYo?tCqjZ_>X>g8`jFc`Cmjc z;I}@*)_(tEJ?)^s`>IaT{7=7A@&kX7dH(t;+(!YrAiSsMX^x=oz=mg@J4jF4ABDrm z1>5eWNAABxaDUY+JKQ%=QH}8{~PoCC7%1MevW^^I55Wv2Q;PX$L9G1 zea?Rr&;3;o;$P<6Uv&>c#0ZwTOY@v?r#`E`VV<|(xxeZL{L7sCtFA=|M*``|7c|ca z|D@0P|ESNZEAiZ4^>_G}Irmq67$FD)O1`$ue4eH=44g0HZ(NHU3C7}-?^fd|fhjC9J-?b9A3vvIf zq4oQ#{z*d5hWV~S=q`zScPn7Ais1!y1l7yte*T~{k>LQJYlbSz8%l~RhQvk$GJ{gc#EdYpOF+_ zQa+D9PfF4_l_yGDsj-vx6i*S0^bBYUXBHX`z@N3U-A%Umf^VWs?Hy(*>fW`T6 zbFqITF_3`Sc#PyAG>m|;_M2vvFD+eoPWy7r=HyNrsMZ-BoTG?Y<%T`ci|aU)(IN`e#cb{L+UDpfB)5I z4uXiT+;`+_I?jCJZLdaGHlp%J;YWVK_Ks8P*uNv6`lcDfn~rZj2#;+#f{s0zSC+c( zvitjvJPWnFPwV7`h+-(KY)Fz?X! zlLk%tLIjXrAH2Kz{^6kfyS03M@b2pSnZf%qeZTWuQ{T-9puWoTsUZJ_n*XHWeWAYp zV^IF%EMF-<+O_tiAbp|MU-@3ypYEXk4O;(~gYuu(^4-Dv27TWVy!Y$-0df|E-xCO6 zJeB451o?Mq{xgI3W%_<+Q2u6?uN)8gJ?x>Y&Xqm(tZ63A=zUJMx_Txfyw{NpiGufu`vnAv4t2kQV{ylVE33_&`uum6~* zUJpX@(xYczp^1eb!a{D@(Ou6x*0l&K+O}uKNhM6t&}kFMRaGN4#`%B;wFuScY}a<4^K@ zpdE);{JPqgEX(+v|nn2@Nx`10Jl=YoS_r9oG*B@ z$UILo&sFBR-aO|ljL2@2-e;cM&GSv>IclD1^DLO>jCt-d&!GOw`6L{fcGtIh)&)<5 z*E1i|B<>?0K56}m6<4nt9UaAU1=2Jx^K<-UF*(SC_(Qq1O#jG-KfLa9n|`n^fX~zM z_bhjw``w1gpZ;MjvW0Y!b6D|v+rhU%&VjRz0M5Cl4OF;Q@Ix?X*ZPgD!2H-ZwrR$( z{tZ`5$UFPMwsUdcpUUQw&C6E=MgFX3(`nW25RjtZ%M?<@Nq6J2WgD@Q#~NIJJex0! z$1_PRntZo6aUCyrkRS+rPcNYt!nsYBy4k zc29BM^HXCPcQhTJLJp~KGJa7upDN6t57lmWrr@Q6u{8t%x3_nDgUiN(QTOfi@*Vlq zPOsX{<+BOT_p^E5twS$^YWr8Ylc_{L8_y@kQw1+kDCWKTSoLX5)zxW|h?eSO*=aX1 znVU|GkF6eYz4$Z?Q0&h_z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6 zz(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6 zz(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6;7@`8oMOxi|1-WI#HoS)L*E7B z1Ob&vxT4aZeDKPjeDt%kpZ-`yeCf5Toi(8u=VrLBl3GiN^rukfe7?!JM@K7>3`w5BTk^d9tVybowr^dYt6oVcgvd@VSZg+I-PBB;UXcOTogq9AAG*3 z{{{sHe3LLhzaIKewP8dG2U)Zl38tHu(j^=ga-`91$c$p3!;4 z=QNxNM2zDZ%*{(9c~>F)?LQnm_)Yk$m@9n)(r>-#;K7^WWn-@NkH2qN-CUSDZ@zIz z-gD-;;n(H;weJ=l236$opT!5K`GPY1yKvE;_g-1P^8K*&9j5*0SZ&xsz(T-6z(T-6 zz(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6 zz(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6 zz(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6 zz(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6 zz(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6 zz(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6 zz(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6 zz(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6 zz(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6 zz(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6 zz(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(T-6z(U}E z76dkI+mej-D0kD2viE434O<9U2v`VM2v`VM2v`VM2v`VM2v`VM2v`VM2v`VM2v`VM z2v`VM2v`VM2v`VM2pk>)SN!z+GJVU174ILfct3oN|Ft<@HLLx5jd{M_JQthi67yVY zo=xVt!aUC~&$G;Py?M5qXHagFd9UpKXU+JpG0(4>=k4bCZS(xDc|K;IKQYf=nCI`! z^N;3vlxZ(0_tF<=zp_9774HY}i`G;59!>k77M}M%twXjy76KLm76KLm76KLm76KLm z|7i&PSMs9^O>d6*6MMD%6OT83cxfr~T^G3bj^1C+FPBnn=>K&Hq$bCTsiuy6e5xZ} zh&%e)J-Mlv>h6oa4Hjn7UKp{}ODvDRtPEdRFq115hP>&5)Y$D5vW0khYhk)QTg(*n ztveZgYoAPNT4FNUlky9`zHM}pDLg?UC?~AUv45#0wMnvcnn8$0xm!;^?TC zA56s4NUn_8;hg7ei)RY$@m!&p_j`Kai$y}Fm+OXM=D>Kai&tq!niZ;rN+h!POM2VB{uG)+%+y?@6^Utj5@VR zJeQ5SNpB2+(?_vom@Pb zL2y2sd_FtXo=s=-8f=RvCdTqWyku8)r$6Wj%U~UU;g43>pt`8Pp^B=yBDszY}c-J zjPGbUe_J*`aejY3dy$tY_~*-j8!w9QjGN#HrWbXcKT=GkljmQQNojm6k;^&D{uAXR zQ!^F=LMq0frJ;D900tJXtxYx5rW{V631Y12c+U5dYcZ4j)lCWZHLly3j*t27rEa7y z6It(`>I%is79`^^8bqK_@G@Rfi9;-vNoi;}ogIr6rVFh9-Dm&$U;%$4`0K~tC-CQ_ zfTRAfqMEzTT?UL|Uj90iBn%ef`GUJ{t-H)U^;FkHc4m?iB?DqPC(>Ch?quRShe1-j zyt|f#FTK<)i)nUJNp}%aOm@_u>#aM<0!T!O@;IqvECv!f){)QV3fJa9 zo7C6R0%pUYeJOc8CVSCX46H~Y6;ETHlWYw!0cX;ajVD2dm8K|S$Tl=Q;mw3Zv=p;O z8v`da+}^ik^AJmbnaDHyFfiVm4hvO8V=c)-tusJFr}|>3$M48aW$N9g01HnmPpGeV z4z0Qr^B=F(aYl;Z3^HMV&Fh>sD#tWeM@uQ_Y30m1rP?!G;b%CD2RaA4&+8OGPnqqr zMDsUh^Vl34*Y(Fqyv#lj;)yegS?Bce*|@IT*SV{!mxRW3!qrChL?UUh4Ki%zPL}D` zcs`s!r5Ei$GGIr4(H{?T0KG=j*?7U-8PBJ{7rOwFhQYnMDc{XxLC`c0=)#ND(>=)* zewd0h6KW!FE&pKmj-#yrKikF}*#YtF&*q9bJllj1GmpXXIM`w3tC1%Bb=#QPV1rk) z3lF6VX%CsqvphEBb-;sXif!>cG7cv4;DAQT!<+K)kx~lZg4V+9j5M{kk9&!U-gth( z8BC|ZK5FSOXmYg)UOM^+s?#@VT8##;BiH6 z%BONpDHvof#hBbf7%%>UbOcKYTQZ~B1eSf0Il>o{-k;7EdQur2Yr;@a2_w3&e`d#U zAd=+pEyzNQ81&L$lf5M70`yimD#Nd0(R6|RPsHD*UcTz^@P9fxqh?`t`x9@b@A7y#s&K_#4OHcKmhWZ#Dkv@OL8qj=|rv5B~b# zEdCzC-yQh79)DNi??d=|2mYq$>G9}>=1xY+K=ZofY}<>mWEho-W1OsjXYqockjoJ?ag_L(U|&^p>< zn{W=wffG+m#JtH|VFpBs+iQ#C@)xo;LI-R87I#Ulzr?Ktt5TS5;L|Wq62{TrciOiM z40LWD>e=D8_V;&g?&#jUNebhiZSi~tbKT-%^2mSb2uPn&nYbLfWA4y6UIQK~AYCIK zvxC%PF?q>F4oTn$y6o2G8o4KGtXU5W=-{1l_-DT4( zgTrEO066N_)vmQxVsO}Q;6HdzWYfsJdV94T z?NypWMhNrQnx2Z!_^ri4Ru{dqIg6zvA`Zweva->IZ-bC;Bm*A8RjN!<>FTm_l|H); zIOcRAl`}b9XNR-h*}SEv2T*8nO+Y4JW_p9bF_>4JLR;ATX7;|By&nXjs)!O+CsSZb zG%xFr6IBbV#DJ0LSN<1^)ia+`YN>bmXj83#5C2H0-VNz^3yU+q5;RU%6K69 z#$^|jfj0tt))CFMW^*>d5pz+vpdn87Ua0fV;a{*u%TiCTUk_gGGL&I8Yc2NlgK)(vJ?@^X#LC{X~HSYc&oV2aC+CAs(vSl(oeNAn@cQ979%k_HhBpitAVWn5`05zn|Io(rydG7FKwisf!% z9IO}^m%Q($vzf8r`0dom?h>;1tco$iK4}?5RP_`nX(o)RbXF{7LiDowaGw?+fz%|2 zm6WqM_vsLTlGc|=c#w_iC{w?;jsns45xWu6FGeYN zG^Y_g1&jwcR{7Oc;ACl80NTwmm31}b0l1_fFvRhv5D0t=j&oX$1Ij3B;W*aa(S)Vg-Qi~Q?oi(IHbcnQ z!~kO5Ku&{GQ?#7yK*EGIp=Jq0vkE*8$4Mwg<)GSGym;|{LSF&F5QdnEr=b%PoEag1 z1mp+B%Yg!WTx&=PLfO$#V%AEgGrY#diWUjB1J*$lY7l>PaDD^Wbayy!to1M8U$v?) zk`1-VYNNl?X! zsAn|NAb@U7b8M^?c!rZYIEP^!N~A*|-;2u6a*Bt-2n|On5iZ98`Hj{?*hV87*BL6k zxV@)uu+ursdEvS@XH_Z^&ztRkaeH4+PisGl)%s1f{xCUe3G%sku|a%9FHbs)6?Z$Q zIp>ZqI}8M-9N03aPH?r}sp|#n;!g6!0Er6Tw`2+w$bd^MlU5Rxht7hm9q^ zPC>H+A?RjrN@howj?Bc1(0yP~K==bfis_Vf)Fl53l-->^=`)F-zOzB_h)E-#9Ys%Y z3=Vn{&AJ{G{lC3^8Gp1@-M5N~aW)V5g*-oYHnWR|c+a&RO{XFQahxCS1CV_=u~;ma z2T?bN$|TN=#0+Nhg^0q3@(6Wy4@gDB^Z@W>d-VrBWyz(r-?8bbT>l znUf!JrbJH&_(GH{`s^WW(?$ZS+PKn6l|ss|ZT2w9aUPc;72oNB#z7U%qS!?7Lwyy+ zD(eEQQ3HAr&8c-)VC8^E;Q~kZ_B1|pUcq^q^@Z)V zwUCahoR>Q2N}WV18Q(Nnbl!5iNrY#usfLq&F(o z{y)S6U^!Dg{z9W zS_4iHzrp%~h6M{n&L%Jxk&~M) zCk49c)QcCQoyVVDNDV>)Jj2nwH=cWA<^oPoW3vugHBctL@+2q=48;zsppqHIQZP+i zz(ZF7Vy`?u0i} zFZ3wr2>U5;L_@+(ZSS|rvxHSt*Ze-&WnpF2sxz*)GSOM?Hf|WuxtkNh-oy; zl_Bb(ze-^g{8#CTRyrL3S;R6%%~6tkIsE`BxQ@YgS@5tnD!4gVB4GoM zIbxF}2n1p91lN8NhHYbGUVf3&!O-HxhJBZwEE0f#eWlEiGCYVhJuegM_Ce7gl=sMe zy8>)8f9`4BMsj|dN#J&lx^XZQXu8H=&FL$G%VV9T5P=H4f+Ln>k|ZHU%NuQ;Bmi*) zY=8=o`^j?vhk|TIQX&mOMhST-jIabvLHb}YH|DAAZqjd(-BJa=?#BK>;e>0&;z8^) zM0RI%36w#W#P-OE*SM$$%qc=-lI~75&a00kllTUR>QydQ^k42v!;7{t&c@=$`^${(<=D2@&B< zs1g=;jzQn(h=RD1NKi)#j64L{n?eyi#O{y|Cm`}}<%ZX%S}KZIQBKb|@KBu@)@%}Fh6Jubr*r@zzaIi0bp|p9twcLcQW^@~19@gmtzRRE zC(`eFQReufICA@G6`9Ampl-c6eNrBeW0;&p$lG@J4tI36ZP_&3HqhC64%oiQI27n} zQmt5ZsKV2{%N-6l(@`t~6n`wK@{NArkH|Vdm+I zg!?0TE{uf7BjI!;oQs5c&MePG$qQw{N#{^Bd=9{b^wZks&% zUBA63x9ZBoflt0a`LX5ic;u!3aQ*jZUVq?$C*JY!y&qiKbKS9DyYvfhJ-YGwpT6hh zo8FyV_@$Gdc0Yen*TrA{&10=MUjCN*zxSG_e)Q<%x!2zR+x=JEw|nb{(yzGrs)^(! z&yD>1zuxKnW#9SpUionPs6=Azg6DrX|CoJuxS6xwv@q54qt*)_$X`76iF`TSMau1bICi*4V%^M*$@JonYl{xJQ}^5XfAcYbI7cfY@5?LD9Q z?6QYXZE+quch|WO-tnsV-8WtP+iMmrzU}I*AAbK=zO&%UuU-GK>yM~A<{eeTUwruZ z+fO-g+!x+{X}0NQJ>%Oyb8`HawT+|Ky}R}MJCC~fk$GQr@BPqe3m^F9o-4j^@f)ta z?x-t&bkpChxc~auPuzL*^vdU)1@FA-*bkiep_l&PhWQu0t#R$-F&|7P-!t$0#7};E z?!?4MJpH2Cbq3BS4YzQ6K%?*GH~_!oP>eeSg_1?Q`ud~(?h_qSg8_}LG>|Dm;$ zx83s(fB5Zp@4M(gs{P*{&aB+{jt6Dad%sXPbJGJq`{${9|MrAa zA31XOtG@5Q{J6vqFFz~!zI7K(&cEusi!M3tJ1_mw-yS^ny-PmlRDa=PN57@xy$gPI z?+DCz zvX6iHx#xa)<2&1L{L-r*c<1LYoc-i?zx&qr-t+gjef^=;15ZER_v^76?it(m)&KqI zQP-|N=kzajeQ)Xfhk9OH{m;KY`z5Dec*&8ixBl|N$G1E_cGWN6nQ5N6F}3lpu8x26 zHM>W@`tf_SwWmKhKJfmj8v$-g=E>BPT&^ph7AtKU0$#6KQ&>_^w1{?eze z7&|)uifvBSUz~l@`(Js<^-q3o=@;I-`nA^`|2OZv_pj&Q_`r|9^vmyGy6Evoj=TTf z`~FwkllTAn*{dHN&+Pu*8}545jhDUg)Gz=32UDNVPHp86InLYKVbg!(F+X1O`pP_%f6Ye!GHzJ~yz=n;O4(0sjzoHlV$Ak1Xh3zhZ@tzZHnPKGk8b^S*^eA4m@{ceJ4o$m2Y5 z@Zc}^JI=4#-f+cI)NyIVmv4m*DSq#Q&%J!e?igj7Qh?r;t zecE4%_z@=rp3~#PmNw7|Je3(w!FHVT9I)X`02roVLlV>k&IhtX$n_ySfME#^G+?!I zqR*%GksJ^ybMRqaSW1JGDC>KuwSXzY)tM{+)eCk5W>0DKjmMh_X9#*A&NM6rX=jHC znw%MiEQ}11wBWQ}T!h_9aT1K+7)+lu2dwrGHaP~1BaIa5nC}X2*cTgKf|B-a;MPUdDCog1PQuUy$T9~W zX>~Ek0McH8Q?CIMF&x!U7Tp6*#*2m2Xff?_Dh!7XDOXYoC1cfMh6i|vg$zWNp`;Vi zF-+^C>T0J$Sbtb90sIhvVj8G>clyqOc^*s`(jlTu(teY4B*2_z!3U=!q-wx-ZxWP| zLOo2@L@x*y9oJDDKW79#CxM@n z#Lw~Y13*L)>$D~zUodDaeT{T=Iq~KN`Zef5eh6zs;x!3@Eaf;vY-7bV!cQFfGV@0%6jHd-Na26`2lkOB`G>c$X z4yrmd(6h8xI-}rZw_dPUJPiUa&DbdhxAb=oxK3-&kn0R~b#KIjbs>iL@HkbVa3F86 z(~}?&5`vwUYS*o)5hGFllT_^oR#w`DS%&8`d3t)<x2Kiq+ zF9onQ%*aBGVGH9VqjT3DbQ_l%5)F;sbfTWvz>xzT_y8Q1%jSV-4In`S@sR{n;p4>1 z2EsaxtC2WZ^KvZA&2Zi~Qd##@S7e7UaV@`1n`b25N!MM0$pm#Cxlf07V+j2FD<68>^4Tt?AypwY8_aW1Wcv z9VozhwIVBwGBPdB2*h!)H(aI?AU~)_h!N~6nI6{Hr9B52Q!E;bv2Wzz=C^ev? zQ)pUSQkz&JRV`b&y&mQX$qUe-<)e{&VVg{h#3zeNAVvJ3@-kvI2%=BZNvzuHi9m** z(96oWg%QVE;;$>4=B-g?PXH|FAPeA+Dg_n%mlc8t5Eo6yoGqB+q1Lu0S*=SE;^vi@ zK^>?7_S|FRr3$zw(Hske-b*L_nA7YmcUCwn-8w|OKI~QNomGw?uTtIw1XG9mnX-TpU)EuAWHFyGrcMNf<8de3+ym$Ly9c+oF zv?P;LP1sk}NC(pcTXIahtYu9j!@_whC1^bM5XjHV5@Zl=uUdzS-BZ{gc6sUa3pc1X z!m`xr8|H30nx$H+4hR7SYg*QUA z%@mimvYf#vW`iwL}3`ja#B^~i{lg2`!Rbqg2#$h& zeRUmq*~p}VImaagt|i=?tCY)t`(QeaGEpcJl6x{-N_U=btDHBQc8Z< z@isQsH)2>+_Xs?b7!cd;U_@qZn#Pp!A z6P}lI&B=hw?%~|OTZEAaQ=_#!qcES>epWA$KPhwTB8hUlnBFkV`HATes=#BDbNdn_InV>I;(D}ZQ&vJhg=6nHexrCu+G z?H^HK6|lKc4nld1Tf>D{#Ts|XI!NwghV@LnMi zBPUYPB9@Y_5iSv~5T~=V6B_}fAf`*Ap2SjHyjTpCpfGPA>h9a@K!K})p3beE1Ff4n ztJ}7mciy(Xfeu++Ae?$J7c$v`8@`D27R$;bNL-wD9(2{*lcr)d;gi-_)4kSdf%g!b;Q`r||E-4`o8&ng+J`M{)?Jh}X0J|D^ z%1EbcxMNBEq(z`Zm^HuD5z;-GM$8pQq+1H~w?h9+(U@~ipW6nCP}0-M1h2V>v>Avo$gr&R4WustNEt;|O#4`s!!v|lN_lKcRG7_!tS z*dWjfKu=NM(rCdLsA}in5E%hJ&C7CO#Y4aX*3l6WEm?q1`DgLs<>tA<>4i;Ls!^t& zEw?y*8Lt|<3dDdgKvMZvHOzt1upsH{XEpLz?!Xp1VYVJ;^|I;J%bZoqra}FcRKQwE zc9ZZ;11!(0F+q30N&#>hv)mMA?}FSb5Q57CAQt*2`NE`?B_#yrjN2-B7bPfN;Qe=) zB^ShPglMrp>oXeQQFf1^xH|^(;!FvL0%}3&Da^6NqzQHtFa(|^Qeuv<&5)7=(!3Eb z5hr2LI=MCb;1nqk^TGY?A(C{Mk0J-8;by&RUUU?K|D3aY zRW0Z)RT<712pU&hkbXI=8y9Thyos1Yu6GVNZ=V~^jGhzDbI|2jwUO|WsMM5=q$XH= zB8Uh0u%ssA!k6Gk4h#f;1;#E_zzQk|qX%lB#$hdy2|-U-cOjc=8WC4xO;Dp0npCwQ zR{#lXtsV=MHlbXn6ghyrDJN}KE=L8C1Bof=Hxx=Z0$|Qrzc8AHQA=a9#lYGOaxgh^ zh%uHeHVdK*hd7QeIi%4y}-)XW0G3fKMd`w}er&0tUB7A9J;SbqRw? zc_Y)pRTK}_#5lVk_O|epMSmh(a9}EM;{?8(QqV{Ngu;F(M3grw)vJBL3KA(BK)(Z< z_GBE4B)y`b=16sZ&P$|5xzUJKBf5YymZ()gvkf$PJkyrUiDw%#0j)N&zv0<@fsT0iE@P<4<#4+p`G@KLhG8!Zl$aas5PGyE$LJpo%7 zr6%R`6{9o(2rH6m?A7`|cr>(L`UjHLVm|nzvR95%W;}hAoj}LO;e($N78-k$>Zx!r z0!K~SM`kP#y-2Uy`?oZTvMV);%^!F~8$iR0Q70~ZN6hU5lBrzFRGG{YzY_4wDJspN z&ZW5j<_rCTASi*I5)>gs5n>LJRfTS_WORq{=Fj+~)tEnEi85i#2T?7K_^HX%C2R;( zejE!P#tkYq2KJ-pO`H0+nA)^AAkhvNo@{ka9bg0{GnWdbz4bsBvA&QM?lwdF3|&w) zm%ED#;}`;@_o@OcvB&6OE$A3do@Au-eBR@(`58!Lcn~%g%}s&8i>ts?!dtVKW7tuP8WVoH-669_&Mj`=k(~$>BZ0K)1L$09d;g& zk3j$%Okj-|f7C#pqf&g-4<<;ce@4hM#1S%2X77Y@I<53o3d)^6RtvW>-3>ZFAe3;j zr`#DAB)wnB%`CcYj8!`+>gkkg6pY_8*g4QrEs#@1C%{0aO~uauCXPDX(uw4;YEh_i zD{GRijN`xxOu82pCvzsXm4HlUi`c1*aYCsQtQ(VSdxKQfu8*yPHKN@y>E~&}4(NB2 z*(Tim$i}L1pP;qBQzw`w1Q6W*fxb-xt-ZY*1Glx{EXvg(TcYT+hR}C&?-V^40TZd` zakv6Vq|)S(uxNRd4equ~;kJnz7FCW7!t)szH9&p^@N$*V&Nc>afFd+M(FC`q>N^&q z;$%8C5*sf~ByKt3=v)_2QIJg8(R8A)p@Z{KFLi;<4t7uBJe3h49}<~3w+`A9@K%rk z>TDty>Th_w1kVSjnB(NN6ExreHb5)kE^Roip@~E^Q-tSUIiTuMIR?##7aNPYZ=@X1 zy#Urcf+b5%TfT(1Z-hGnHxKUJN1o-(1J2ZQmo{=X{Ne}@4n{Wtc8Lhk^i44VbY%6Y zi2*so*ixgASk-!AzqLi_k73+6ho!u9*CuO$Y8vTmO|!RjHTYoDuNrh+e>LSDS>cdq zVMsK?RZ0<(GIpQZK)u`)i>!kt>i)SBM`5+&<(qtw1WM*ubw?DvkwAS>3?&w} z&C600veqVRYc*1#Bz==3JlHb`bV+efA9b;%`{G(n`u!sHn_OB}mc20&3d&20TL(qb zP7n7&Vk<|36tN)}3J+|A!#NVa9;r2u|BD0Z#31oH8%7Qov!7>!d92O3(9=yjC+91sZv5bHn zCBVU@cBYavHo;2Bf#Fg1IXd0dW+2PKh7MVFz!5NLykF_KI|z=saCZxBFc3PyM}oRgs3pl zpaq@^ws?F9xJaJXh1Z)T(+*-L1c724A#UW?q@>dSQpo_^fU+jRa~RERbP^D&Hg)jU zB}@YVC%&s8!8&wXpmCYp&JN_QXq7S#CDwgN?aQdejgiOBk*;e|S|@(09JVYUZX0Gq zA0x~mGvW6F`8HyQjb<}S4%zw@9#}}CK;3SxU}rN>9+3fBt%9QF*p#`J2=as8PS16 z-c^PKtWsH04!mfAix9uEsO8mt@OMCg822&C#K5Z&LwF)_TFnt)BvMOxd0Iw5A49<( zY-6|`^9TUEOSfIMWuMO%DKhsVe34bd z{GC|JuuheI2NEcH(4SEqH*7O9V?`K`LB7TAV`g!J0gP~LB~67_$=tZxY_$6dmvsD+ z8L(I&pFFFLWwYSR;dvaV07R4u;bjuYLVC!9h*3~c^Z?2^?ZNyI5H^N);NnA1Pr}kE z2q5(U<3EB^FqB-`Y2ov*lEHn+0VL=MM04f+T^{zAmWKSfFeH;72!l(bL;f0Qc*tMO zg;c}*U^zExeld5<{1%OypR;9XW8-Q;4MCOmv(GWJK@pfp$w6Jka0pDD?o&YODF{*M z8ViUcRE-J92fyZUg;?-hR#O6iP-=ju9SG|hKLKz-l1%a{G37|G`tyc{Hi9#RM{QNh z0m^IuY&*#M9CZzF2ZZsm-?XuB^Uxsu#0!66?pPTz=yatp=V1F=+#g=H_lKA5`{8Bp z`r&2o`Qc^nb?YYL6RC;fgg23`cg~4tE}~ZbCm+1>Cm;Rn?5975i`l7hIOsx}LP)kH zkU63jAXR2>Y4&F!^s>tKMo8e}Tj+EJ9&w$+yJWykJ#=O`oFa zpgDNV6R`*FbLA>CDz61!LCJM6PeOa-6sDV%=nq?|)DTG@4!Kz2l*n?42EwNVELM!i z3>u0P$YRmN)dbNhK?l|X$HdCoH)mxVY*T5>p{eL4M-T3Ur$Jmrm*;Y~4qS@pFyN&| z<3NhBAIE2ccNo0|8arqv4#sIR2Qjr}E-_&>uXd^O5F$1E^kepiux=^gdg#erpX>F{!4cmfR z)#2)JX)ehQbNRvTeXJDC6)LR~+bOf+;TiVsTx94UR6pe1L>4AW0I1&30Trs3JKDxY zT8a|Y(J8h9bg7#M$fyo25-aoa-*#FTJm4Jt7aiMUZk_C_7(0=il^~5 z3@~LBX=&yr7(*cSc&KzCYRpw`*`K zdJ}*hR|0~3utDUnEVE?XNU>4iDl1xG)MQp>Mr+jx#z19qI7Y)vV4$54gek$=oE4l0 z%0g-!8u`e55`{Lz5+a>yDv;O&@Nx&GEN}$#$E(!D@H)}gaG0Oq1G*M z@7>|HZy6lw>viExuy4Ta?`}T_SA@284|Tb%o88vl*7M-i-R*Df=^PsBT!gi43L8X4 zggH-=r4(;z%o7QkR`F$vo)sG%K2~ll?>=D>?JD#h5jj|k&Z#WRNKn?e%*-GadS&Yv z$_Q7gKvxjfpbXcc`CL=bcX6Zw&uFgfVnk65z<0a^XiF@+0WO^xhED1tMg<&+tjoy3 zgVibG1k!i)n-Qp>$u(=GxVGXo2$RCO2O`MTKkhn^r-`zS>jjt0N*5wQr=|il1bzpEto(eS&U)07F16Dqr=p1;c$96%_cTL_INfC|};)W__ebG2%VB7%iuQ0E61+OGV0pp~iei1jQr9~~w0{NK) zF}tXR-dac(#4dH@zUg0&mj)@Gs7*rW33kO42;S(O(j9^%1?~ZWmM{u$r}IRfO{qZ< z>Pmln^moHwtHFGL1Qr0ghUptTLm*@ywMuhFMdq(otypojQw#GXU*G)Z z(@k^`@K-E1F+spTeWi&(035LBeN^l9rsbi25!;4zaY>FA{Yykl8tSWX3zn8%$T0<< zbQ}OSW>{Tdq$EV3BarQ4^E3)9nLX3*P`}v>u_`|SWO{DI9O%I^xPZpIBN^Y~Gv7`M zwR`?*P{edP(6bfIYi%)z0R+l(RJ;QokUQd&rm8LE>p1qo=zCcM<=KlB+4&yL4%kZV zwcV$$OonwLvaAifM++4rg=8vC-xwb)$MC+(xzyxwKeMqMa>d0a=Xkc|omm<)&j5dg$G^Ph}+yTn-K2>@~7#Mg5&5O#O;#OQ3t810} z8%=T*+DkT>>m4rdZ*XvwLO}`0j})4RNOROQ3t!U-EV>jEHj3#(H^od+P(qPN39bOl z%`p|L1zcP=gtnrGq_#B-NISaHRo!3j@PZF7OR2p!cTx0DHD44k1U6DsR6tBX13q3e zBfo&DDtBc=NUEZB`}XZ1U*@t)%;_HL>}_$i_Yw?*_3{#qSF@FkS~5h&UV1kWsEAl$ z+KNC!YYkyy`eL-;f|2D>ynih`AGNrZ8ut#dZV^FMVx@hErn8F0e<_42B#A@`=I0`R|%mTIHl0XOWBRzI?>FPt_l=% zx#6pO^tn4Mc@-~xW3^5%3DE(TM@PRH;fE9OB6%(yE;(;~q5Ox>(VCgjHcSP^*pVV@Ka-(tgO)Nu^shd`vBaUPBEO%Ov1wPRRN+NncJPKoIWj=x-0 zB2C6{CQ%8haC#t~DB{~!onvDVw1H=8r&Sg1Bhp4b>$JK9aUR#)9+&_?A%H%p-F*j^ z6$BmyTnP{bK#Lp1zsq`R`bKax6mfu~k;B`dKDNQdmDcFe!LEaE z@8G*_ZYt*&Cn4{__6#Nm{0NR#F!X??41|a~2CfaIaxjzS*l>3eiInFiVSSk@`Z#@J z!XPTg!8DUd;maiSBm#XAq`@>!qlAi8!_qcBmWhMgNx>kHo*#H>m44Edm;9vDfp|`} zwrZXuw2J%sdW_FW;V?!57kK02XJLv)#SFnO#5=s9%?X8}>^PKbV48-ZdX@lrRXW2j z0oBNqAp(MN7Ft3M=<_Jp>CaR7fSYuHC))$QCng}5!iU1>#79{gdI#GX=ZxTR4y$YA7>sL<$Y39mv&KZ`-D(jhnzQLS#YnLJ=WM zk$G-|>Wnvfg`G61+TsxSoVilLW&>d$kk_$d64hv3AXg6cV74{caXz*1+#uvOe*9`m6Qmy4*$nrlJ-{EZkgM8bY z+MBkr2Rzh()Rk1kO>+Fo(dHUrI_lNJn*huX2seSILWFn7WdJkIKtlf?vxDD){!|#X zn|eiq61t$ul)Rjo+h1_fK-X||G9|J&lLMoWk6m!Eal;W}_VujFsWtpGk_F-dZUmV< zk_&D|eYm}%=8FQn%8F=g%PY7!^3M%0L8CQC#N`Ycg6mHf=0y!Yd5obT93&QBT;-W3 zxNm5{4)Vo(#!jY`D4)G;g~XCySA!%`P7#n^2f^S73{#Z8Nkq0|9U09(52=xiTp{@s zl#>u;^G*M-b+{L5#%(K>4-Z$yoxZXxZqw#1?Zd;Y83v4`)4tzTzGvId}Z z#BH~B(eAN>LbSMvXab|OW4-Z2-{AH(4>pM@szbtr@GPw*+OR=R1oIbW+9q3oua+RR z>Fk8jL8KCsPVo*?g{Q)XuKG@=)L4)Y_9uBLpXDkkEi&?Q52G1((b1%Ve+4MJ;(iD* zgk_-GW#4fTQ3kwVf)F2mW*dV-EO)`@Mwl;a+}DNN{u<181>$8Xi-TWAZLP2 zNRy-GUZ76$=%lw{nQ&m*Ce!7EE^}n6mgNtv3e2-1cZ}yJAUEQDZD&m}GXWdX3@<7- zg2jd*Z{!xd03Ea%I_O|B=C&1%RX4&!n-^!m-NxnHWFU3&X);w>0m?vC9I5C0G8yDe z#-~6jUC0~Fk{VsHFW%UCuJSU6+8GOp42+GDzq|a(8wP}(mB$U~AI?q%HxD+PI^81kJ0}yCW3&kivk$`s?4n=}3xI(lG3JR$O(q(QE+kC2w?o}h&%iCpKFPBZwy8-mB!>wbUbF&h)mL;qlBaQiSr$t=ycMgJj^aG;DQ3-<$ksWKS1#jh5x-%QsfY3dDMrPlCG>I~n)PKGh;X!wE#!mz?g zh;1wFV?`0*i2aG!Rg3u;t(S-$ly|C>6}~-WzHm+s-7F}^Rix`HrLGVKNJO)k~~A4TW${_OaIqBPdQo2We=G^{=bxEPMhRKh0NiPmOQg;!D{q#(E&5Ts~^d z^eZ0qtY9eX;-F@}?u!?G0oYl*7+fe$Df-15Zp<{3;UxlGYL{*qqgc~P`0S5ECxR)* zw;Ub#bK$pJx+9i;ayV|OjvTcCHR(8Ntgr!;Xk&M9$l06s+Voy&nb8S)tY8QNjuI#( zg@h8%1K3?&gp3ED>2QnB^wG)YjTUDHaT5O<2c^)fvdh~qO?Qm3+A;& z#5nLr0?)-ceAf$Qlxj1<0$ANKdUU|xsm;ew}WJOz((*8Sk7>2%-`lL zOgX|^52j|qLj_rD}E2LK>`&T>ju1Y)z-R&-)NX%chX0 zM+){;Nw`pN^C4kt z1d>6{*3;QK;BxG0H4i4*j>VbE)n3sECHEdcLg&-TUm!KBmU9Zjh0`SrRV;apgC?|~*KXXp8fY%k@+pOM4ICWTNDcUax$?e%{eU=V z4ytw*yZE0Ijw2L4>MQ1b__{0J*2v3Ju2HbCu+)WZV2fafQ@cXEfL8~Oa|jrw>jx66 zVQ4WLlbT8&NN<7_>Ua}27u-lB@|4&#NE)#0VXcgrn5GUoEF|9qh8siiKa`|kPV5EI znq-Z+IA>w@rLaXNB%LvO>;oAsr1V4+b`><%h8Z#aOgv9_sCmm@JOv7hOAV~!^3noml zr!>GpS#}i4Vt;eeILyFM5%bnNQ@Z^K8-z)@>l((&rnQ(FCm)hau>C3VU?KS51Fg&d zPx?6*ossWHI{a?zvgYNu6M6a>tIsSA7x$2G9EblM4^|LZcledjHQM3AU>`PhS!C+^==9Fu^_S-pAyH~i_e7+WZ| zSny0(S5O1$eDIo_?o(o^PP$~)QRulAUtJN$j=0?~C(&xzselUf+%+Eh+y!$M@rI(t zv1AO|wZ~Y6aODK*7-(xnpDQ%b5Hgum`~$rrwmnc@^8p-GEQB}?$4wwrU@cgRG6?Y^ zB1`}l><}Wi7-_hEJ6X&Q$>K7Ls4keN4qOo>Ago2v|MdUWMzNi5d#WxPy+t`ymBQ#^S(=?Tmd9d zmFHo7DrrCjFiDc3j^<(fq}#gCmZ*Ne;Oiy%iDgIBKNFIs!h6 zRTZ+;dbU;0&p;1+y?Rs?9G#Mn9no+Z+jZO>#k~k&xZ%Pj7jrg?3vTvFm@Ef}ZCP5N zM~onw8zLFD0PuSdQ+Y{{c8&#PTZV*@swd+tudkZO5;lW@L^KRlA^TiM-%$;qfjkE2 zn@L#-XM(HX`p6^&uc|X|!Tmz;!oE8wK7O!AfW4T+H3;$XKL~qV=wDECy#u#X)A)lo zUAog<2H(2+9`?SVTeHp*=Z-&&+mK~d=`V77)xsP5x&ei(8!sc@h#{NC$uJvRWF;EX z%rha#GuD-GUgovh9I}kon5&Oip`R+Rt}DB%6JF2>NJa3qAn=4jI)tSRuT!hewv@Ie z1(iOO$LkEJAREawa;K1hv_#nkfT*!1tO=Bh5^F^%4hA}o6-=`c#XVkY2#~~JV{@#! z7wR&}4|vI_SOb}FJr^w38ziuq;GJ>f!vR@wi2=B6wAY7g7k-*K9r!<}^|0+W|7q=- ztFrXoK*Jn-G`u#6Pt^s{B55R^Nc*O7O2x#5M@FvyNJ&sq9-&;?>tUxVu_rhMPiBL) zq|#p1tm1+f_%~(R%lGxlZSPPbKPNQ`5#383LaEBp5i)0UU8Y3L6acU>(d&;Ym_Tx9 z&;yq~bXe;2!smP{folvU#?R*h1%sZ>;x;^w!dOx{r?stb%aA*SV~R_&Xm$C555S4{ zEF&71jW)cR&ECkq8s{xPUdh#k0(W`&IF2DQ4Z7z4vYLS#Z4s(BnTLwD=Oa0iJ3kz6s4 zRqA1mL+!MF(3>OSEmTNKOFjtQOYtsBC9In#Pp$7|5WFarF=f>j(3V zF3e0G*c3E-*m{g2RI3>SiOE6i!THr%w!lqg0AB5ix!%PkCQ@tB`_o0b{>r=Da%hJS zmoL!FntTKF01eSNO#2cOjgabb>*t=!sR{ZkCLB6h*;x2RwKra1qXIq%e|g zs-G9|4nxCh8i)8#=8G&N`kH+Z+qpbV5&PUT3E^u*yE<)P?F^S)tNl0sj zn+s)5;F9Dfn1Y}|h7FKF*MSdV5Hoor3@2mQCPIip5hsZ$w;F55@iD5!jiVv`t=g@Lk9duAGMicD)dG?Ls&!6A)xG!i>sd3yx;HB`!yOwZPDEtoA&+>$YS7Cu&(QfL8~2LK z3DVZ%vwVurfGbhpVXh}IK-@Yvc`QTer0_-7k;nK}Ugd`-2hcVIyGEnPSCiAM zgRW)=CYZRmIRcr2T<*V;hw`9KgWk5M>_xzQ7FL{L_`sib!h79u?1Cc7Z&_iYFccJ= zZ!=+NhWysK4_S(?Km6JS?aU)L?+7U!`bN#|8Iwm_btCL+N(zydzV=|tUr_Fe?La&5 zGNi)o0VQbf@%a~J2v=Gx0pnn=28T@I6DTuv*a#tGKe5xC;vm2)*`JL39KL=GIFHj` z?64>S9JG}(#M^^W`~E{8c(9B-zodr=CrbK8j^cmZUS@++c<4Ao7%tGqfp*C%=50m? zyF#F&3VQIH(;4Uxh>z^e0O%X~sD$^2?hrwEf1VOi>czur7h$7-ysznD!v+AsO3D=$ zj9??;Zr@6<>BNI-SHkxp0wSV9u=85pLh8Ds;6q`ThA-tku+*Zbl&g@dKD z0EinIB~^K{60>2T#1nP~@))ynM_vUD0|=}QA92@QG5<$=IVKnr@ZA)P2fs7C=K$Fx z10{l7y}w5j-q3{)cPehJ@=||Az-XJ0Rk*PSyiy)9hNnj{@?90o9deFrk2vA6b-)|n zFJ@M%?FB4UWUUw$(C$}CD#ig+DLdELHtb;G8-y6; zB?QXL%pR8mRQKfq6*Is;2t)>t(Zl*DJX@Akb`i-n_L;{y4_R=-x%gs4R0CxTKYzy{ zf4JCrP_6KqEM2RhW5JFO=sE5+C`%d20-mam59EhnEo1^48ZRJX+WpO|%IjAjb0Emt zy--MbYp8I4kEaS(W*_fJ&n^M)|B8!H5V!$V@rCjX3b`bYt2~KS@vt2L9DTUHZ4Jm| zUFNnH2=i2oo`C&bg*pP-HXJb!`WWXA_wIX36d^r=?>K*G#ue&BM{zZ0v?nbeyEJ8U?yRQZ{LB;&cnXruLc*}gXzWy*M%X#>KeDa zjJVCTMran5LG?Mmfknf<;8oTgfA+H%8`ubgRlgY)HDFQv$qq3-_(TG(lHMD+-z!Z4 zRp0qP{_LygaNN)T=70aQul@!cVL0A~<8S_NB(MBGLKP?GFFfKl|$Rzx>%(|H+?_1IzxM|LM=Z`oI1d+JobB+h!X@GkWZv6Qeh0lykkh3U*c;szBH-;;NeSz4;P~^Rac{ei`Ix& zAph$<<$nK|gRMR(ZcvIViO@9E)G7*iYv$#`fakBqKk(LpZAC>nf%4xJyu{^!iM#4I zA2(PrWAr5=1P@ZIJ70EST7s04G;({B{{#JBc3_GEtGbBk*NTEHZhZv!hrJkv$|!6G z^01iHQzNlP(Qte23VVNNuo{XX7-aEh!Vsbs3cQ;9n+WLDWJMOQCSTx%Ww!?51p%Nu z4?O6g7YGlMB!*whc=!ok2PUg9Upy+>f>1j|nGtW*Z1_kWUb}C(s=sjGT&4P4R(?~C z&3zFfPf5bh4Dls5;5CpeU=sLjd(Kp z$ps(A>A){X1TQx7@}@fieKr4qBac~_q&#~B{R3WA2m$3(pJQ_eQF$94%sZZ-kDg$9 z1o6+|AxC^jn`~4lT~vYgh3ek0@{0fkCFp;h&Kh4Zv+t`I*uumYBSXx)N2?Ddh-m`* z4^NG(pJW05U(SND24>~>BgM6NJmPbjLuhL@RMhWk#4S97ir4@k2XQAi(2(J(gv?Q? zV7^NBhm`!=-D3eH;YmLM-KpMomz45wf7?aEpGKmk61<5+4p-0M2l%(OZPe<-@X$20 zuqA=K&wei^!l+>Q^6gHbBnOJ{E{|xSESEZ^NUakNlmZ=akJ0dftyP|Lc!CEm{B#i9 z;ilNAn#xD1pyV`XE%AaN9t&da>?ndB?)CW{YrqoU2j1gY6K`Wt)$8jqv5nw z(r%Buk$f00373_J0|hTx>3_lvv=X=GRkt$0P@;g!<51EQl7V55j8&=jH$wgr7FIj) zfE#lY^xo5cQ-n(?O~OsG6hYu=Z2p%8WuAP&CK(cF{%3ymuj-RXjCSQW-T za1+>_a_F*R_;AEV5C;GGlLXWy{B?)&8Uk=ZUds9<0M)9)e$Y8W_#@Jui5&M0q9E$fN=91rPbii{Q zUE#Zf*dsmnZmo1wd^tbz?rG=6G!=Q;7?fVII($hLC!rE9u5xA60Nx4hBG_Qr0OuWc>~rQx+qhtcZ5-rv!-nOXb|JmJ4OenbM7i z-*kGR`bzcMv)7+}`0S%+{4@2l>9g6h-+A_5KKqBye(%}u{P_R*G5GaR;=>p17pnJv z>wR*kdai%tkA<%U|L^|x?|xI8FQ+|Iy{3AudUpGJ4bE>u3ZCCqy`g$b^)6h!rg{hd z-d0L}2fp7`t}&gIeg@^?hn7g0ca-#RL3xDr2Bg1#OL<-OG2A~_ za^AVse+DgKxz|;n!TBB4d+`0flJae+^(Lge4(GQ3&YMu`+fe^CNcjl9UxVwnlvK=r zU-cnee;aW5K!Nra+&@=fd;)2&!PN)w{U+4;w(9$k^FEy4g)71fqzzkq9pJqS-v|?F zLR|4oD104iBmB1j%XgtY0^<#UgryMMdrd6!Cj23f5DVlD;m&(XnQuWmZ$k> zP!4&4CEtQGLV63@eGOnCHi!vw>UF5|Hsm}99y|lQ2nB?v*aAW(G+`~I_(SE4X|F?D zDA70I8{0tHld^Zoq69Dnu^{yk@-wJMu)CLj2IY`01{=GQ0Km{ z`X03OJrxgmAHf+ZKssIrIzNCbtoNP*6|eB`1AvV(LS00;p?pzNuK`~8jWm4*DM&N& z5p{&5Vr|5iwEvM(8e2h{@Eak20BsU|M6E@cex|^B4bE>v?q|S*_Wea2quSbpf%^!GRbM?%t_KeMW7=+MhzZ*ej6xZ$sI;R^DZY zZKCbMGnOG-AuSLbo&&6RRKEfFq?aL|K8JFzfrJnu(SV;oDZ~Z;5EAkUb>}?=>ih8h zrc&a$O0ASY+)$?pb#Fqs_ds*rfLhO??6=_W3#jouDDe#R0q+U!q=yp;{s_vG{*Sg4 zdpODqzlrT5TJyGo0p=imcR8b0BRyy@5w{QF@4Jxl9$cgLV~Z#^gsR69m)ai zCgy(vI)D}(?cR4mvOfUMAm>rXzYqB#xFdRna0u2YKctdK8Z9AGjipcuC?moHwBBz6 zmIOLt@dL<5eIQm4X-6p_CY+Lrcc>TdD0d&gH{$;Z(1U#v;UP6d)?~CoZaiu^@(XEx z51>2)jl?>LHOdJ!n_z<9IEK9s>7ws}y4AlH*&<64tM@_W2hzX7$ z$P>i;9msb>%4=X}o~t}6AAFXZ>UiQdC+fKKY61de{6 z+**GNGzO)I`p&`mnPOux1ts|gw25*+&b$VTte*fZSu86fWC-htx- zrQ8oehCc=zS*2f+9*wX*gSsCn974_`{m2)RPqds^4%AuFlTmX~^HEFQRcgEr9xw8V zXvn*ej+{k3L`e~E4n0TAK@R|}4RYmsaP{9n&q3>nvV9*8v}x%1;0W+0@Dg#rT+-@~ zz!!NNN)WFDX~z~3E}l`35X;v9#&;nVy)*0w9|LUcou9$|4;7qHlJ9|y_z+Ui3L<3) z6MF$l3b~FFcptP9+x$MXL3}dw1F+Y>3p{%d`Ud)~Z$hae)W9+E6VS5vpv0#t8O}RZ z7W5YJdj|afSXG8rk(zHqjdxWhsQJ0-w^jcL&SWe>4Ddi5e+wYK06LKKs3&iM%u(K` z3u%CZ9vHDgs2Qli$k(4JvP6BwHj$sGcW4u_T_Rni6s3w~uxF6og!G}#A^!*$QBRSx z=-r__K7%{N1lxHXC`3x0gA{)P-#8mVeEylDZy!Rd-%^>O9G1Q75vhkV!TN{;xk9{& zH6$%Q2Tr}G`YF`KzKBwI10?XFN&|QA!-0P48>)W~^cj6tf+6~V*!SNAt`Xbxo~jCU zvG-zcBcnN)zaY)TmLjES_XyqC1MnKTg?vB_AUq*ZkP^(hj|Z5FG{2$9_=8GdDG>~?JPlGrD@1sXTKFc=#X;IqN zZ3bW5p<3)lld}jYUs`z#tZp;EL2Br-`M*xeKwPs1e8q{6l)sZX@Q{ zI^v3b3GK|s(C)jSl}ICM-Mgyag7#2G$T95G$hS{{VjQPX^N^oNMF8-|a;T-G+Ra72pwc*Kxz@YfU-f2e-Fyx_<`d&(Fig+p|pwbjMx$SaAZR5LO6&C+HGtfdox|aPP>63SA@Auf3@Ae+CL<$H#qzx>G zx{5qS-6h^4_HpFXy(WP`EFa-B*2BJmb@7avPtu4EqwZrKu1+8%v|-=9$rQ_B?R!h4 zCeA^S10O3R5thJwGRw!&o_J;V{zdeW)I{jWU$in{KgWPL$r_7A*Js93Na$m#dNGmtTNFmVmlBjp$NZG3U>)%DXc>vqOU;si}!@D z2!~h)Y#(bQN6?<%F~Au=X#u%{KG7W-;Roshw)YIY76R`Br8XJO&=w%UYy)lH2@Q}_I(EEOHoBt6VL%Tw3Ey@b@g76z{GVzoNXOUteC9(>Ge8X`Id3WbE z!a=Fw8F@~$@;T@f>7j@*(vS2JO3)G#PGjr1j)}E#mDCF*i3Vb6gib6Xj!1+Xq$iV> z35V`FKzv-}7*d8(A@&OG6OjtSM-LF!V~BR5>SMS< z3yO0{T5Xt6gUbw2@a5RToo1EHf={sPYEkK$?o>J`$9-aEE}`t%7LNCoy)0Y9(n~R6CCmGoI))@dxjPVXEipMzaxK;W;}C{PG-T6v=MC4ejwIF*AY5eHr!`H z3ys=^ehtbH*PNe2D;B_m^b4{Yhjb(CAA<~W9SPSQu|?!Q`qdm*a>U|$Pzp;TrN}ib zOY9*+MeZUj(qD;2BCpVjVmag)YB%}|xTcC%SO>3gjTh+>75WK*F2`{-IZgm=Fv}uSRZQ3c(Wf81;axXpw$`JR#H|A8=iO z@Edm%(ZeRPK(7bK29zi60iX_GPr&s|tc`g@I;eH%GvoRV@&{MNKU7*m38T&E2cj=0kLI&ctoB|ZSD z{tz&D4^}W($a?|n28au4GV$_>+;HA#f|}?nexkIFtGj4xegJg^Nc{}Hr%JCtp9*^@ z@(%g+Tp25{P2BGzy$yQ>;*aYG{~@Hk0q_wn(I|wD>%@N(+WA+v9F)zYe28T3vbt*( zYQiH_gpJ%GxkOVDBa%Yy$vBN^1iK%?`3u$GhMGhogxiD%B<*Q?clg-*9{V(bfD*am zixvcR16Ol!6hTktzP3;L)N4R3$`Y;5bA^i^fUQKGe_QqU;f%BsEKqZ>XX70n*o(;( zfr0IzULkC>-dF~?Med$bbze~+T8%J}JE*CIM#3w+!_kV2pXl|F9TJ=?KU3yhIAY*h zHm>1)3VLM$41NFywuGgyKUyIdaUdM~d#dlehL{r{1+m0liait|e+IoB@xD`uaztFv zqrCf}NHezl9zgsKK%c=imcx?wE5Zr1_}EVfZ0vu8Pe>Q>WUxPyvSds{=^(!`_XjtK zr0oxszI888#vtr%-vP{VSA$sSw?KnF1)fA9=jRGsLOJ=qYX^=)cNuAb7UY%@#<9CJ zF&DW&Btm8uuS0LZI@l7ynD7WK1@aq5%;zeDY6#b81NdjSuKpi9Bl5iaYb0jOG8zX))!+Xw{x!M7Htj7n z{LCLe(~4nt;Pi0SRO={8zjV@6-sYt!YjbTec?Uu%-W9xFN46pf_o}tv;U)x#)RrTo+x_b~jN?JKXZrR9Y6bW8pw=YL;W$`+e zcXY-@8)gN4tmZ89^Fh_L)mJq;pRil4%b|p89xn!F(P~;OXclFE$P)4NM4JlNO(%KgZ|~Df$I&yW?x4nH zH1X2W;JlJA6~mKAYMm(BBWZ`Xp&%){Kt|~+Ye}DvdcE9CF9KB6zf6f4u4$m`1-Zjg z7j2Y@A7hR*Rg=3JR@BAPmfXZ8xYu$dGd*9uLgkPa(}q3Z5;u)X>8@szOvekMZe}r_ ztbYr8CEnESbKKgLpRIu{e=r8b=D zxoe?xDpJv8)N)3j(eyn`-nO0fgxW+((C&1B)m4Vc5$)#fF;{2-%}=8)7wztNYJ6WT z6d4AUJ)H}lP7!0pd1ePSmNKmpx1dR2O)?Ym3W z=vv=!W~Y4UYND5!$R^Vssi{!3?)N8L!E9c0C|nxH#c=JdT?Ijg6Q)vLUz8k#dX;Lev^)_5wc_3!drCeNEYIe8kfNCj~h z$Q3VngT9*bHFV9ZPe{7v`BF6i{U?>=J9Q}|IQ40}#i+tj{%IQWLtu(4}}1N}u= zliV$2?fO#l`z`ja)qC++ro2P!#zKYiHJ%$4y4Li3v*d^6>b241y~WZ#x7a6V)oa&U zwnr&(qM7eE)7Ydtm^hck(m7JsM=BkA+>&=R8_ZyRb|v%mhIJ<{?G5;8sxzKVG_pZo z%$?~ihxG2y^0#Dn(%vsoc>h&t2du7RqEO@sHEKg8*AWR*)# zz(CnkQ$EHVW{I&}+!VFx6q*d$W7ValZ8spgIt7M0HB%IQwFF|4xJc>a#h}L{aEXyV zUpmHof~aX{1WQogNO#QjWj?(UvcJ(qWrH@RK>RfQp6vkd{b+f7gy31YKG>e>8 z>C)g3^$ER_ry)4(<;c1=Sw_~zl+a&CvfarkdgKR;#}!z0@(2GM9w$$*nVPF*pyn1T zYP7f}OG$|3x0B0szmqu6vNIO?76(_(g8rTC0!3}We9QcCq)iW|>_n~~le%=|2u5|v zUAeS}4i$w)gUPj|e#1)@eIN=Z&+a&LJ9=S#VRbp2*>47EbHHxX>o>BGn%V)RwYjV6 zGvVxlG1_Kxm)2?QakETf*cUb@Nz7?3y0evvBa6@q#AK3B|}Z;GC$(+APg5 zT^JH#9;uLC#f)sW>pgCyeyCMqY28|sH(9UAaoC!NN5N_;GnF*8vvcA2cA}*k4kq4A zxn-tjiU^Z^wURdbO&(!kG9BfXg{CN5b;L>KWGEGB4k4t*CE?<1H6eD8YnFMtI7vd0 z0^*l5!>BQvRar_iZHL){Z@#r_^(U6%138MSm8AhaF4n6;(qZig;cau`xD2u^l@_MP z>>#-u2%7WuVz`#UdS~;|RHo+7C%D8Wx3#bPx_nu$Pv_Z2c#+DfYwl{XBJ(!sR9Ujr z0Ea;SV63s%6t24o+Z&;@r7iDs~m?2AD z9cP;qvQB*KW6e-gZ%bVlvkjV|+9Z}yn;AYQtxH3zY>$ls;0yV+OwxQZIr;k7J34kp zF7=p7tt3_(4$%n<_=Bl^t925Z9*5(2JQ&4Y9~8tiF;C?8_77p_c%{1dFhKr)pn=dqyPG{X5i7hRhpNTGJf$W6ZHYo}X zz@jt`#(NWxQT)Q}*lfi>QBjXg?;K1MD}#R&%1O1Ba}iB2)1@?>Wc`Ifa9R}n`995P zSDtAuEKf8{N?NY@%V2EQbK$B$i_3y<-CT#_!l;&oU)dy=Q>R#{M;SA>wHR*t`$XS3^*ideOBYbQdFril=kjd1}-b*lZ{1 z;7%)@=ssSXe&%vWF4%s#Wa=7D>9c(@p>|vSY%a=H8#i6L#Dg_d-e2e0G}LJGtK39hF0}s$W%$ znp}Cdv)f!PeJ0)UPUZe}JfK(et}g3hnW|~kZA_hdbs2uZ=IkYzR?0DTmIl$*sRRAj zp{u0KX;H(mhHx{~Yb70%t)yE7sx5~11(*Uob_?Fd@xZkgYmd|~zSS9C6ZQEQCm)oj<@wEBFbOP$v^U#c!N2kbtfsvRY`jim0o*QqsFu8kD()V5Unhiq>dD#ag#r zxn2Yuv;=LxGLi1tEd=X2H6!?Php}eqV?t(emF7MAw85FY#yFq7I*l_Mt_MOfObnUe zb(7^|arZFYT8mm{=by)YW3hZlnqrd!YjF!Bi=9m^wPU^B;qUgfKCv{)bl9L&JowJ8 zc4@zGjj8%MxmdCny5$wL3m?b3i%y$#+-a(t@VIf}T&uKCsx?c z)tb**?MM@Kk6*DVDd(m7t5r3WUMyIuROp6u)}eQzj=GLIi__m(N-@24YB`sO49hsI z24|%f=JLbprY=P3;IVvJjYo8SCvy^?tJe6OukFum%mBBW20n+Y!G^x*)mj+uxTdRA z&-x3O3U}q4HPMf|_N9t`A3&%+y+=u)S8nyFl%^b5~E)xVx9U2nd# z&e%BVRD#*Nv1Fa7Px9F*+0Er`NuI>DRCKb9bDfRRE*WxDDYd%hlM)pNbS-|nP4bsk zY<_A91@+eKc@y+7oRym9I>W(RD@ZYUT#s=E}0r>vb)o zkLp(H&E#HVX4%8CFqUT(7~@+$Ps&`pc$&25R0#Ua*M&v$_eK+UgLBiAC9byVyd%TB zWaD5uzGK9!$7d?GP8uE*t|BEl-l&eXnl@=#rLEkq84I!2dAAhtt+>%48p{;Y>bY(_ zZotaZRdNa5iRGwqh7vh_GvC|V^$w2WjfdXGei6i7raW9E)yEKUGT3%qW9PML?}$cn z@XOzU>=$Rz%%XH2(JO|^pYuhj>{pu_T64-7NTsc_Lqn3Z!&F{fwRw|FNOq?p-mW;* z@WHOImcour%3a>J26T;vNoHDVz^K~X4;Q=AWGNU1r&#*T`Ct^U7^Vu?Q zFmVQn({;6Np-(wGO|yrcpFw>LA-#z^JKHWHoCsERK}*CYITsBV zpj%&j!m&OU2kM@)*P1hZkzM=TWA=!+XYU)ru{Z;BiHo4Ipzshf@y znNp@~J8_0BNQSAEw~m$-M&fB#>Ub)3Q0385%#?};n6UK*(UUpIE%U{beq|G~yU|K2 zX*Ur;pbb6!qIH@(B9}wV%bZ6A&Gg(3Mz{I7GsRKGr0x(DII6|Nz&vr7_N9xUSu=jU z%k0?ilTqE0+EtkB{umsEY3so9sagn@Ur-Ow-b=WCW362FIzVWh-T7ZE_A`=4eu2{K2^pp2+)d{KCcqsd;LC7^U3$YpSGC2Xz@o z&D>h-2S(G8+fGUqUOo#)xp|#*7*D#hv-jFppS|24dMQR4)Tw&I=h1bm!|O@k8^N-p zO4Q5mr3S2eC#Gu& zhB`Y6*`77p$TEkheP_>H`Yg3QmXprj4p#k&OPj=qVX)qjkk<|Kdgx$EGh30jC7?QkSxiODU~_H3Te*jJLb*nBX1abKsS{2;-%TFDl;Z4zD zpMnLBP#Y&(v|L8vsLs)jZ${mzM%H$En#^9V3dU`$!Ld}6nA@f-&aoX9R|7(P6f+d&KAhGR;*3my{}+Y2ClumY+}tO+t33#gtIJP zsnOL~e5{yG`Q)5bxxxZ=GhZ7p`Q+JQ68Ugn6I4&&EA1GjHPd7|u+a=ys&6=Za`Vx? zMNeXEvKAf-UaojNm+e-Ab?Kl3(etEUfPui>?%O2aoZ30^HA^wg6|xk2kd2A7hzr=| zz}#dqwuTfHu6kCI`DAr*{rXj>DJ~6DnXkeE@o*Dlv-(or$v4{9;831}y;{#)99I*& zG$m<`v9NPN*UQyIe=Th$Q``R9Ff|-4WvtrQDgw@HpYuoTq3E@Oh&?!CLqxGfa1Ni4$jZ zcBZnoI1U@^tS#&wZ>3>8ZP!n<$7L?#NNV<}UT$z?ecUM+8m-#%HRI@{)NWnKnlc|e z)(IP1CHtCYvA(mXT&02>3mwt|O}mPWv+m#911ZCHyWaw-`>AecAL*G?HRZG#5^e2@ zJI}giAJf=s-NH~y%R=$&^otv#V@)3ntl0ssFEkS@?liQyx=9v8@?}(M_8MF|pO|Oe zc2`ZPxmfKmEuT+RyL^a6LXK)=(5&&7gq;G3M-B6eX4HUbRsL*F3IlD@8d&b3R{+aw zl6;N?IAxh-rE7LIQuL^f4(gN0Y1j%?$19tp<9l*|_D7KWI#W;dF1Q>ks0%KgSr z+m5Efnv&mT3)p-4P%|YB1^#S{CFrZOr?!U~44Kbss}x+U$>XhpX= zPLgc1UdR*gYwF2ODyie=Ov)4Qro^)&KAG%-i5a-q`Ew8^P9C-4wAi02tf)47__ndT z(d6df!@GMKo^RWEj%wi6j5SvC+fOZEVzF&8JIv;QWxvGRtR*y&Bg@vAHs;NNQPgZ7 z_G=5Bs6NlBD>v-Ac9VX-z(lJ$6YrC=o&!@HfO*a2ICv@e=D3uuo?wKU8_Qw7X{OVB ztDG>&HFIH`%J^M+YRrxGY-e?3qw3l)>UJD0>U>YsEK2ev&+(;F&>>#q9Bfo2wG(;g zz-d+d)W~HFt&?+V7fYguYdo-{GUrQnFtkTpk6722ZsK3XEB3s=)*yD9v8S7cJcg4t zzC3_)d`jeH!RpTV)R|yWozG}G37wBso47=pkusxp0tRojF~o7q^V_ z=$u-2#mQwG+0#L9UgtXSA&ORa59j$RLC%3gjk=M4x!u6xxh?wW!ZRoQEG*_Y;g%Y!G%~eS?k3!t|13A|Et(3 zyTop;?B^S>UToPLttP+otm6t|an4;RgIjPdatU>GoMfp$9lrE>wO3epRvt}loua)S zHAuB(NHAV82Hr>ycAP1?X>0b!dmKc7=1e=5@bI-QQEYc0IqnI%`yEL^s-; zNAUDxQ+ezR+t_~Q(r^fkFtu(w;;@akx5ivtYslKTOMO*};yPS}3kPa6wl}NZaU0keM9}2B$V)Y1*%ggDCGa z3j-TbUlMXX>Nm-pA=9U|+q0WDi72@H} z3T1qur76&uXc^0_v@Mz4Yk_6rOy3<1&rNCfH11&|Q@2STt?9m|SE_jgDSyqV7e*M> zjDz-^aU9&TI}|Vhs<2M?%H0uY{|A_ zsVlc~sQcjk*AM5E`O>ZzgwQaraVGX|o<6Z^*i7}wj>5zY)3os{vTe^2j;xegm*%=w z+!xmD?OfWG17W2Mk@kWW2HS*7-0E$e^95GfE3nQ+F*R_qu9fw^%v)GVpVK<0axn${ zsLZr1jw6?F?kDLP7nS`zr=c#K0!_1n)A8s23TC2Z#w`>J(QfJJv|3DsPNhO`{mrcu zt~3KWpApvKqE)a+r6HQ7z*MlYjw38yET=8jSlq_aJ8x-b%xdDe86iu}PL2`N-g8?} zt9RLwCTb1s4Bh&O(b7TN%xU)<5;b>5ThbcR%XBc8*Hq@-;vwuVTaxj*v!4b;+XZcwpS0t(q+8czKcHgexqeIF+3IG$#_vuX~yZm!Gd zW%sBybNU;OkZ9j{{QR~y3}p2gIWH}9OKm)t&G)2BSn{-E%Un+?r4q)_e0m6#igGf| z>8nexP~>+P<}lX#87gRV>C1N5rD*hL?d+g!TD$wx+^W1tU%brGt>#vdN`&Lq-Re5I z@6qj2>Rhu1y{=BL7)b%2r6Y zAJY3L2MU|ZsAf+ne?H})GDP?Q+b~D6tkNBINR0k zLfxv6U5lPT(rWX1XC|O6ZVNbB>#pl_B+Pz4XRxqalU}a$G$jGX{h8U7c9hTHgJkU9 zzGjrTOq`*Rdf@i1Vdu=9h>cvGj(D8T8%sBH;j0VNb+xtR{Rt}J(1l^5XcuxGQRq19 z$yTrEulQ`55U(C)!K$C6p*7FgLmQ#r6$b7M zZ`=E4Ti8a}r`#*amQNg~8VY7W+2C%bmF<^sL`dwVRFhk2!{MTQNwIp-Csdd+tnD~= zsmzJ)z&t=$Z0(tzvTl~orRuw;-r)D@_IMxJ)N`_*o!`-9i;%{ zQ}gFlQZlG@IeWybKF-4o=!9^j#;GRLJ$v$!J37uRCX@Ci(eD9bl0JW=qpUNf5%`Rr z(;Cm|pzg%0g`QX`mo-###7qLPMppDzmjRR7RqT1;p(Uvv>>7vu6t!;IZ9sC?s zxYn8tcSE(?tZOCh$yL?TwY5%*gU2GkAji)m3$3%CG^E=*K?<)r4WD7N%o#(DVvmhC zhwOmfZ1UxKD{>ub%#Acm+hbJ|M&b+#9WVtJ}S9W{xI zn#;$WU4P<|9oyNKamE!5#-KKG)@OPH%29NATrgx$I<|6Gv#8X~j%!NS)Y}4cyOT2p zS3<`asgHX`?S|c0rdxX|)5-JMWn$wmGOl@LxHfP`cV%ETc}`t(dn2rk+{ALWO7S^s z>m2RiF8I=*{iV$_cf(NR4R|KkDn|drjYEu3TCgdnV4%154$g8-*R-T2=C8S{p5| z*-k=?9;8|kPVV?tXZDZUj&jhL)bUNwx5~^$m!ed)txWr4XuIJGMPos-c>LR5DRoqPJq&9E3v}LcC+$^N*TZ6RQ7nR z0r>>$dX=%!?2z=^%EqV}2z;+@v`HIxH+d-b7lO_R5A%5q&TP4N;LT2{;Q$sF$5Cn2 z_Y4G=x0t)wMcZ_3UUePq+G5S`#a*#!aFrM~Kk#UarNXtw?To?9!pv$$CzFenb~JnS z=Bd2BT^eg`Zhpu#DyzAvAD%%RQrWcDTB;nKn}x$M^+dO4v_2i}_nkH;>#;a8^)j76 zzN~RiyCWf%u&aI9lqnz%?eIj3?~=C$ivF-{-c$B*aWPri1g$pgFkf*3hJ9-vs z(S9s#k1qL)+Z={xDq;6aG{Vj=XlDFIE9X46rM8%5TY-LNj zW&uX4XhD;*!m3}lUln|o%&5cK9=_Jy#a^Id$wAsybDhW+FZM*SZ7MBfW>erP*GVif z*c!B{3ANHM_ zoaBYPJn6NTlDoD^1lj4;Q!?fT;a-q+#p7Bb5Z(Lul_TD$sH3T(lnh;5#jwZLZ0o~~ zvfPc7!{b&gwv4gf3$2cd`u5ta-7h!VaL{EvBu!x45EG>g_OI zWnJAqdL_d8-<}aW-_v8-fZ<&y0D*a4_G{#H9Syd%+{@ugu!J?^e1~;nvNIk zdAHgMPkdZ-uIeTLgBVlNP+j9hLk&HYmYOE4T54I2X{l|$uBDFarIxzV@W?M~bm=IK zC#|EzL{~?d%6lDU>x%;Ax-{d|EPo78tF|FX?dHKCbvl<|PfeHxDb7KMC~d?RqV)NA z2qD=(-ZAqNFsVv2rs8Bs)q;|cwlj>MjW@_Wtd#F)N@=!-9 zX{EYayF^(|34vOfgC?pNY)Vw#;FqXbQ{$j!*|kI&GbK4cu!Zt8YWPR~`Ka;}t# zqM4e5>W8!>OoYHG*K zGZ!^9&%<7|Ws$CjVU6n4wXC|}@2zL$fYr|jtigb>l?w))*JUsi@|Z$lxt0z^%Ewt~ z%o-*p?wIlAVkJxH*ZLB6qeZAIIu?;hTN|Ypm&z=fECpF>>fg!NM%Q)=CaIC&vOd>! z`)hx>>^p&4%JqcvdJcQ2`!n)S&!Q;2xPOEi`6wwhOnuCI@j^+s6}^|d*LY4o7DOcw#Tr7WiCE|fERyg5iLXUa3gqL7F zLHS8ZQkh`_`p_k>4SHG{qL_yLx}2BiH? z*F(asX^`yKk{(MEdKIZF+(ZZj99%t6_Df*h3o48!H@B8avkLqNSPyAR3IZbkP#a<0 zfqgTqTjiHd_m&?Te&E2@QXXL`jC}<5jj*sZV*UUNZ||_~sShcSpk81PLQ)?8;pzd{ zH^IVus05$;31L6Lx&Z^}D9n8V3SePP(ma89zd_u;0oFbHUWJ?=^z%k9fPj|2u9;Z( zY5gaFzY!KP;ZD$vJh*>Cm%>~~Qm8=oK78&L;Q`G@SlGgiQ^+C04TVzD!i_xu`>DLJ zWd)sYv?NcdLX;oC65NoCmtftXzI?(G_m9$oLYIQZJ()=4vGqq-3V)C;{Jae7HZ0uf zQrPqa7D4s~>nRgSD^GwabU|^_0vLVe1Gqi#@Q&vV7P);2>xLgWJrUT~VUZ4i9LGZU z78Lpvjku>^LrTI8@*Sza@Qh^%)e3PpHGKuvjq(TGzE`=Ut>8e+)eZVfwo6GPWgdA5 zu$1Zq*qw^Iwm#8q0_+Y-;lN8weU;}oF5R(wlq7+5L-DRb(DEJnO|kCvsa-aoA$axk^QTE)ef8CEJ-t_{er|^Y>iryINd5c|{z2^DhwI-` zVm!tF5Yb?|$L90Os`7*TUzm?5JCwFNN0a=RUfRWcbt zfDeeUtiqr~5bNLwp=&xA6y<*L!u?{?pDS?)j#UzY<3`%A23LuT1wbHJb9(kdKpj=7{1i;&Lwi}4msa9i1iT-Ka>5m{5rGm*{r#`f4 zRKphrK-6>$2pa@>7_$bWDLkZpc~4crB3dCU z%eDJOoivbGrF&OiDSuO?L+7l!HGts)J7=JZ1jA9{{a~b(hp>$bmiKIGw(3nrs^+z& zYQAWx_^VpQzfgll7{&~9Lsz9iP)3DFh|AI$j+VzBa%}~HD3q*QL8Y7t1`84x;+1mu z03_nV<0N)RjrE||9UDm7Z8yn zNCbR7=U?V^Vhv&5uoO{>5CmmKT;mXU1>#aF0iFKB3hC4G2mz|sBQ=rFU$K4AhwXBN z!Il4V5CI5Mc`5b!3aS7GqqZWB$dp@WR~V&qY+`dr(3RN`_}n`jFixft8b zRei0165!<_j?t5_R^L?a7TM@l3PMqV!Fz%g^81c#2h~)(N$4imr^0!qoT5b_<6Bv% z36XqzgW2)Rz}Fg8B!_}mx;g@d&nxZS6bsAoXp14f4U820E9KNGjC}oNXFa-fj-VGf zo?w*4TQH_?&IH}&94;dCMDQ@D5p{l720+GG$oP3uGSfTDy)PlMmSP!^e;Lr*7ck^O z@I{C(hJ?FM2# zs*b%r1}qi4g%Mb%(Y`R+fuxRT<`mOTM#+bAk5&b(+!vYA2m-%DSn2-g1@>TwJbaG` z7(~|!ngQNHJU)z!9a#_W_n&|92w3hBa1eeoaSK}bm|5+ukHA!jrw5FH=*@Q@MsrgW zkSm66CXu(m%e+N$#t2wSNN3_}-clct2Ypx#iBkkjxyvF9F&;6}7t~%2!O)FIds1Ih zUN6?0%UTJmtWkpe9!RW3g{6qgFJV56t=MfqY0d=WU(MfDqS-@mJ%|^)B>pbQP4Hq+ z>RW(l7=u8zAd|0WxL*L%4_NYmX8-PdE5(rYN}R^Z>@e#u6<-E2h(e&(^)wTO0uL%Y zl>$7S36v?ZcllerM;?;_^^5fEu<9KLQ&5eUR05u+eWDKNerj+oa&PBW`(6bjEQ1>T z>iVWuz4#eQ;MHY9^F(iK66XV3*kSp*Z^S$3BPU3SNPfTd7IMMFiM3K9)%R8&&bQL(Tn$Hb&W zn-Ucbbu>&(tf>%zu>HTkbG~PHcGwXl>-GA-ehhr}{W;I)o_p?{d+*#kBjqV;i^|_& z89$W2dlt7<9cRW+d#28b&YWjWre}Fm`*=e&8^^UJ{YUWwrV~mAj52I+wRLQcnV*0( z=Z+p`#!NhqU-oV?{*zAXH*g^E5YKY7Fao@hNk(=Eb^&R zfUoUQM@uDaVj2+S2#@ceSGP|C(y?GV-+UeVyA0E8DdGMg^%@3lrga;GuQM|qR zyGT|{xQsKf){RWIc%sTPXO-H0-k>_{b zzvGXy!^7GhJFbj~vT*HRw^+pBL9K4Q}CD3){}@t!&mf^ONVSknDzSOz*xYoqF1-r<~TmZ~pXIEw|s8eV194AZNBrD6BT-_e=B>>ly#9{D>a^LJwA?|GTOw2=Sx;>M|&Gl_hBMbqC< zzO8&;`FG_<%8zr>`MMis`}ydbX!0H%iM(jrU#MK9T&(Qnm&08aHbWLSLl!tg7CA!} zIztvaLl!(kt~_cz`S@#1e_r{L@^$5(m48)k&q>#7okI?O`Iy1AhhH`5OF#X6@v5i4 zaq2Hly=LIjCtm75cf$$&%EH(Bdo^-_qM9T5>gvYqLFk}?x1Y4*;OOEPy=3DZJLbvn z;$1$+f;{;?K-;nsKz_Gdfs{3_S4bjcj3QiI^(4+2zmx=Ai{Ox1;g>s z5EprZ%jgSaEV<@=<`o44i4O#bYv%W5Nl&2l!(`0KA3@o#NOr)O7}v!k0pf<nu1jFM9i;&?Dd`84&c{}p93 z$A{#}ymGJiQ!nX@hw%-RLywz!W`KTEU*HLwJALN#>BmaFLu@!TT;_@OZT?2GLaFBF zzm29HUVmGV0l#B&MI>@M^$wM}cJRx04LR!M*9Ipaz3>TirhKOG+=i}vZt$oq3$ODN z8JP0}mMMuZqpp9W%O%d%`-VmH8w-qCJzPGExO(eH%?Xr7=7W!#B^-p=@(4ddyie0@ z8}@Hm*^HXTvWljrL4(TV2es{+W<^z*{P=oV6<12_d1u~yjWum@&Z@2FaK65Z>c*AL z;5uuWT!rH2lk2^j+6Fl>w^v5;<>RETwxV1vka^R&%3M{M-B~G zTvndE{cO`q1~=bww^^R!^XJ>I`b_4hp{r$dCYIII*3D)(xK7UkSIywEBj>bgWUMkj zDJ_e(_JZBb^HC73Ld(%&Bxy2Qnfk_ZVKFo4byZvhVg*j;PXpKHDhCa!YO1IT%b42W zwDQWb)+ni^^_6#A_H%hN?N4uPXsoNsnoX_k4LAH6_E>kd%dKDe5$c*5g9ep1=n8ic z6>|J;=Rj-JY|f6Va$*_Zin=O>Gbg^Pj>(x5$4qsDR^Hf@lQ^q}-;~eohGx&n$|cuX zGiq`pGZ%7lBI~L$mkb$(w#y>Dmcz@s#)<~7rm?y@YolqKGdq-1NqyrqYS1Ch&X<{W zdFyv;qHPH~UdD8(+|_)`v|Y_jXbS30xM1q8=B3}<)!cweQBT60R+n%AbN0!-Do^e; z&-CJ*f1Le0sMkdLwDd1Ko4^15&gRtCoz004b~Y#9YnAs`;!t*6zrVE&OWF$Jo<{xC zZPQ8#OTE#Y`0V?P!0}`v2thbI^oc&F_xi z)w~|vkGc~cIC@ueH?(ckuI87~2>jmG&)XYzHg`n+XLmOHP$JQ)CBNO-{B@Ka7ynJ$ zu%tza^CW(K+q4K_skijkZR4}+t9Y96dunI%qsT+iU$y3y`0TtH|0H?P9`W=eloS6n zankZM%zO5Ww_e_m=I{<%)=g39okxommmCro2YtUJNXJppg#PBZ01@Spg(XzTkQHTOY6r;;qc z89y~Eycl1d6<&_-lNBC}&n~};aCZ5%gtNRVB>jn zXO=hgK5mfbWqRHECv!Y02e6qF1=D&!Tft`wWNS&68xuIym{CuW1!F;``BL|Xo?Dx2LL@#w#a$U25HBRlO$p*@+YZ_;p8Fl61%w0-+{%}Im6n|eX z(+xc3)Z)|1r&Ux|O>Yek9X5Q#$WiTPa!IY3&1infxRhRx;rEk;L-}1p>w?O0%Hhh9 z%Av~fE$JgOHH>Y^XTxV{c=WhZF6Wn;p=a|ah{mDeXe1hn#!Gl)sTnJA@GO{lwLS98 z9CHpGXM%K$U2pk3Gp;s+Qa*H);N+^x8tY1DGR-AwRNXAW#B$DAGN!RcN*Rhsc0)$V zBN@zDYBP>n&T6cw;!pKFGqiC=BQumwYM6)9ScelT z8ft~(xvMJ^F`}x%8fujqsi01(l1iiwsY1$2NhxJ0z%TX8<~KTe@#`M)cOGNVi}f>z zzvD80<(OO6)HwbIGk+&?3{yk?@=We=rZy{7nmN9yZ%LiZ5l$uPRUGTM5~cj2Pb2%^ z)|gR*X0@bGq~?Z94p+jqXlPy9GOT%f6lH6du+(VyZ4{};FbAXtW6pv#q?8jcOE!vr z$ezD7W?Uw%g7UJA;Y@ki!X#cwoJC&gy>-=@xS_<&K=qk6CXyP)RWXj!_$%j46HEm$ zwJqWC_&IHIj389eCdT&F_0je~>ax9ZJ#qbzc z@f=B9w!(x(lF#{lrPR~77v-y0%1S#@{xKx^Bu?n+lz7)y$t#ldTxG{QpIc7iU7S$D zPI0ZXY;?(lVM9yGOz-lV+M0QCmtf{dFtb19!>`a)+nWP93KN$2b5yzMpC&Bze46~( zdH1!fRG&b^YIyPt?Watq22E=?n?1a1sdn_xOm|o zuHN2U-q=vf)Hadpw>R&L=3mEWEO~Sjbx7J)xO}noJz%x^+;W?Vmo^vQz~`JOQx^8P z5s!W;%xO#V=f=74Zu0MoB!6x`S4VbQ58BGjC*gU~?aje!KfMm#k1}OhZS}yvPWwMZ z(*6bTQ1#jUdF3XX{5^V9UH&(iJ9!*1T* z{B@Q?biDe*;V$~}7IJC%_*?R<(tJ0<(fd#)yRL)U$zRq^Ty~j!{#BNzdKTNXsi-!U z97Q&mOB>Av<uNX~ahWeJpHuD)ujWYIRyl*CG){gbyWD@2X{NMfBIhjJ zQ00!(TchW4Ak9&CPD))BcWPx$n>myV*Vb_a=pAEhshP7XD><>?x_-Gf*-%$rQ!l4D z3`#|HZH=}n3zsLUj6+M$lnt$@;8?zld!jhr>*JYPdLlOgwHVKobAnTEW;Gda5W`h9 z*E1X@a*n~3W4%u?bNMPW3S4upZLH(8%y8kMS_a$eZFoY-G|Ze;Z@$en^x4Ol8P&DZ z%B$u4+g^mOt*iGgshYik@ZR`nqg=z zunTU^=q>yI`44Pw{_85M1@|)#A7Vd@`o!^s`-tviTM_*jFItHg-HR99gBRV67p=gH z?!u$govo_I=hNo3e14BydI^5_FSj>$g=>Go=ltloM=kq6(W*z#!+3Zy?147Z_qFH& zblFe0H`l0E{e-;eWOOLn{22Ms^3~{ZJX*eHd-La?z{BM~gQA~rZ@%$C`hk|;VfBOG zZ*N|R!e}ZQgP8L2Hq8w2=G0bmcFNTsyZX$r#~OQysL3<(2nMJ1OjNe+;|+Hn&EZ~` z+B&;FUZMWiKYOjB-mZUSoL*%NvOVF&62EzS^QCANT8lQIlGpa^#|Div)WMw1oZ{=} zglrA1PS5@2144V~(&j>NC-2XnadkHr6}C zR>LivTsPq20eJYLtIt)DDbL5Hu7_Fmx!8TH(B;l7 zW$Pa~Pm|aEAK3c~I@#bJVU2D0LFwUU`Ye zAEMzV4Uf`rZaFz0mDdwF^(8fI@A5OI<41NmK4-IY7H3~Rjd%URG7+n?8DiXGWjd3%<-m@LxoHZ((BDh$Mb8` zm2*XZEEI9w5dJU z%%{>?Gk?BePcYwvOUwyFOt_jyDZ-RL<9NeEf+rBDC&0}sb$k{%#MDhRXVAU63R73b z^|h)xZjsetshiD}le&7+d6z$@yt~H*nly)#?r=1sP zD?5@$G+x8!C_8BUL=9i?p)Kd~pYcx{J})c3l$oO8?06}2fyQ5?>_VL6pOGj2VvV1z zl&iK<&y|0-?KWw=>(93}e7Vx~KceBQvf?G}Y7H+^x_YkH@Qq5@&L#gc4gXLn+mDo4 zsp0#Tl2`PAhU3a2jbEeTpDSIvSL<^9Qsbo#NlR$>shs$yHN0Nw>Umbf&*$V%YWRhm z{4Z(vm7MsYx_*~vzodTY(`L>0hSK$OgyvtJm0!xdsrj}jWq&O3?`rscrR)EEE&o@I zm;Iu&u}i}r=j1oL?0o2?bp0vRa2KVk{}2ryniGGRhPx?UJzvyt_WG5&j@0-bN{N#) zU(@i{m4(E~GWXW-30e82%t;!~ZddB*tMLPr5+^!E!>1{wZqX182b6AkhiiCLPW)I6 zmnfxfDKlQf=j7xs)$rt;{O4yt?`mq z+Nja+r8)T$w_}cC;WnjWxdHOJ1p;cuWGt$ zKRYbxf7Wz2AF{)ezE#uhr>y2d$A@3ku+%N{ zd~dI>X?{0;*499Wrw9qzpVD8t=#bGn(mIXbHh^Rzxf)c?Ys4p8=k1??l?F% zytlqh)ADZovcqyLGDFj4F3Kx+KGtfwJ3q-Df9dl)O+P$Sx@}nI>;iosck?4Ryf~-+ z-0%-_(sRQxO?UG*H+;XQyXDUg%N&erx_Eizh9A#K&kg@d)7|{Z4aeV`SZQmvf5&kX z!Q2z)o-)9zYpiLQ#VtH?8!$ID46;iww6c;b9`#Wt!#RyrT}`+Q{Z|^WtGRHU`>Yl z-G}_)`l`mtTCTsy{YIIqd)!UXP|L$sp1XIYSLI1=+&`(@G_F0$=><>Uwd8mGibcyZ z@(L>F0E^ro++H*9+w1nSw%!=y83?m zkFl3JFAUet%?j?IjJ$SGMqX)GE|LkFw2Rk#HkQAd?!t0Eeu7)O-WY0QQct=Rz28gg zaj~uJfc+wJ$20EuNVd1`NcIu3Z_cQfBku*Wy$K~wDDz0t|ieQ@)Ry<0ytAD5+tWBXrnD&6OyM?m$80LlQ4}#*QC_#+IIM#t$9u z3T3h6H@DvGUDxs4(7IlY@7t0ZXxt|Us#js?pb&7#3uPR%@{BQa%s<FU@YZXIUZdsuk|JO>@E;oU=9`}k&-&uwc%R)1aE+CXbr z7njTNTIXSKF`7@A!RU8qe$?C*O57^El$#Gr&|ygG-h4)D{deFcUv`_$OT1f8j;t#A zY;m4kkS#d-qvnMrpR7vKbG5fJ`1}>d6D<3^(h?&zSw>{lm?W?}oNa zd2@JR@ncP2dFY4{!N0xr(v~luJ>q*Wj_drpbYukeW?pNr-E{LKe^@@a|Gg_;JZAgY z(}vu;ZN$f)zq{XUH!uEOm!DnGYk2Ld%HEyV%d~0#rR{&Irtq=H)_i}|hda-FuhWF$ zas9sH-#KRPmERovME!!-CLGb&eqoMt>>aN5##fVdGpiPu%~9(d?&Xu?WIoNv>`~c^ z*Ykk@cPH~5VSIrWkLfj-GHz_oiIOUY*3D?-`*|9;(leXy#?d?9dykkfZs^$Y$F(N& zJ~E@Rn)?nK=6Ss*jvY-}<~4zHh0OB++$AuBd!XfkORx8Y^G2RKs${}scIoAOl?R{5 zSJ!gV!{-lj*=W{uzT87@uC@_rzf26<=4o17v{v-|tX0!A8)$#0KMjG>XKAiI&WB=5vgX#Nf2Q#d> zqp5$Tz&y68$n<`st9k9ZZl-X^(dMmZ2AX#YCY#@ESZw0I|C5<_d$_}K;nI$G9{O~r zXD>gp^Xwa5Kd89tj?dqH%S%VTcK7qgU3uo+!^_^TpZ#XfBOj(Knb-gC{h#%gz20A^ zyi9quGOApzbj$6y+nylFF2CKEoMD~f>y;BUfvmKQ&B@^9q~|o3IUmc;(y^1-ql?+;x#hFd#DC`LITgl^u*d7J-MlM8 zGvtn^E9V%z_JT_Bsp~DxV#|=mr#0TE@vfX><`Jx*3x%ynjJoGf5KTrOE#)p&% zWl$MbCY8C(#56vhC*9NK3MhTL+@8{}@j<0u;{(dv_Hx5sce}nK%8)YkB^#g8a6*|| zK4mwS&-!us654(|rys6f*Nv1eU*vAvZb0eA&C%rxX??+*dR={+ zoN>#SXZ`oq_2am&>wk~>^Q<3Nuj9V1pFOt!JoUe;{de5g`uEuW^NhdS?j84a{P$SD zpYiswNBw#F@8*r;zV<&j#%>Q@Kg+a+0~$7tI=@{0NKXEQhQmkOdfc>h^_l)QK3{r3 z(__cAUp}&z^u%7$%>Y}kPscB}e*sPR=Sh!fdNNP{5}KaMlWqpu_CtN!U%tRz(j$4& z-TFvqx*P9Qp8RgP9fM=FKc`sA@rB6kAKdYV+n;yzxssNyyidzZtQ-?~x}2SKgSEN$ z{Oihl`&r&CuV2gOj;|Y^fTp`}(1msR`7z|o`;GKamf6$o*e!psXY2T6FNN!W8`%8hEpfD zt~aUErAIa0JE{HjxTeQ?wV$5cOL}@Q>AqrHZ@&8dnx1bwf|{OhJR_Q(cYmbmdG|-B z+5Uxep6{_fG~FHFxb$4M%zw=<>9YL?KIQhG*x&N{eq{#P<#FrZ({R4=3ut;Q&+47}+J*MfQJn0Ed zkK{>DX?iRtJ?O@NaL)K^ICp-#`~gjO;Yd#TgoYz0+j`x&yX8%3dLmD{8KULe@}#FUJ(VZj1a$fH?B6|?o^N~GOL}N8>5)9?ZaE#@ z{xhceC0_O!ZoRqvM_@0?+vx-`TD=N@}a$y&$s+;dkAZJ zFVFEnMAJig(xaLl%aa~+_2-!{@x7!c_L6Rfee(7i*h_k3FX;(Q&)pu~{x_-VZoN9X z`I*W}Z*P8jdR&)pex&!ayj#C!_$QB#FHgGbzo+T>=4V=uSMv2gw4dc&|6_Uj=h9Pq zN%uzB<8Fxc9`?`tQX0=mOt0nR z-cNkBEq_|3{wh9WZ~cPYPp+X&`F`}Ze%7bzLfi6vc`keQr>fxi@qPQb@4P7+U)Hx@ z-|R2jZTV*5ybG~sdHYRi_AANuqkKR8#hd#q znY%6aSmL(RIlKITeBa>x33X(bKc#K?>~F%(Tf_K?4X4;I+#HzsD$d-Dq!;t(c;-97 zPt{xbv-7mQ`=9%cTkf5-%Q?|KNUe*_I`zwU>Sewxgey7{u8=^c1sk5tmu$?-4QFm& z9a~W{&EIAcN%>6vmh`@#lsCE!<%iaU! zB+K&lv%jpDzdScymDNr!%PeMl<+Jxt?WFhrr0+LxKfios#3$``a!a*_SsvQUF5li3 z-i)OvFLaMkF{^c-ApOfppSx#z zHQzkL9=M%7iY?zJz0Dp)(ldLumP3uU6F}1Wg3Qc4lI=|Z(g(JDjSFAG!nZ7csx7F! z@}Fh^rF`rB-E#oiOV1tvN#`qDGj9&<4Pblex#i{EC3AbKTLBb0O*d!8qb&3NeSFzZ zy93j@s@o2{hNS)6`el6Dt-rm2+t>Q#R@?0U>(=y{^*^irO#j=fe?R-*@}=JGOi+f3 z!>X1wTv5(16K22Xwws={f+bzQvRi)6J9Dpb_KG5%lb)923$~)R4YZ%$+JK~g(svX~ zdh78~%NlAq49c6Xhe7S9w;o32O>Zq}%(sur@o&rNPG&U_c5e@v0n84|01|dP2bbOw z)^xY~-LC0p~H4qP$FQ_e+GzU6!CU0gOvx2L1~xrMYTzaJ~GrTl)bz&7RgV+B$^Gyi0lDdQqx zIa`-&a}wS$&R%ESag<(f>|r@Y8BvZIujxuDE3YOE$CR5~`UIPQ(r`+jHZPd#rLnQrq(mA)U^aPn5IPnp}_J;GnN^TV(8d&=kxTTe{6zx8`s ze^BcUD3e-m>OZVM;Oali_BS=wGV*zQA8_M@!Hr^a% z8SbX}w7eU~khX6o*mk4iEt7q0{?tj9iT;++fyxsstG z%GevW-iR)TDYfY#rI~2M;Xm1Yehqt*Y`jmyNzEVEaMYF8_7mEET-%K(y|>S6x$n@8 zReMZn`LvcxD19?+KiVtPChi#BekN;vrMHje-RFS*bL{@sQ@S?%T7PV|O^+z!*L?Ew z<=+1ta{bJCe!|_yo!0xnT|Q6m%XiODxckE$UA~y+%YA+#=XTbX`(AUOKXL6k#Gr0vH(wCzWfE_+1N1OK+^p3lh^{q6@#O*ddbcba?8C8arZgKruf4sA;KcY;o z(DKTdmP_7g;}gn|GN??ucJ8+M{L0`xHXPBgYd@&%`-*J)DQ$mW*H2i>2erJX^xb0H zbM53~)Gfc3izxTC{kZFY7w!M2ET44!*Ycj@KF+VSmJe&WkTSB5%kQ2$@%6I(PxjP# z@IN~KbI-NJhuL<+%K!H9Un*xp1oi&qbcyXpQ0bm?a__G$UqIhi{Yv-zpQFoX^!d1S z&iim~`(bzg^c35EXtHH)`z~Kd>kH;--{tePeP7OVdV3sSX#2U(H@f9^boY-3w7z`L zH|}wKq4noJU+A7|b9DEk@9p_QxBA?D$jOy9}Mb!f`Ny%p15W2oaYl= zzKAY=IA>g4zjEsjYyIJ$*?Lotw_m@@7t?y9dFszSK6TGS-9flmn-&bOTUhvqsy1l`jR>Iy83eKH~Rcq^mn#iqjdE; zx_stsd%T~{Q@?A+(|VJ?*M2L#`}KY9K7Ak2a8ko*WkBOoE}yGd8PNIzFWCBh%FrrX zZ&1s}lp$qQ8Gpd$i)c8fdK1$6eJ|Sj6B{if5885G+%o;JWp4S1>)*?^T>2%;@FSXk zwWaST?U#>f`IMGVDg%1`%W;3Nf5ct?HramplzZF0-Ez9;kfN{K@*!pJ`F;G4Ha)3K zYdh}zKJu!z|C*({z7f~+f1j2MXxO!%(*FD3w&jd6_xwKimQ4>UBYOVt&hO2eHa+gn z_w~9!P{T1zPicAAep=g4{#pC2jC{wQ|Av%Nr7P#?JKi4u2i~>ieag@xTRxx+D_uE9 zzn1s^#g;cp|Fv3P8PW1_Whzg7u3pEW*6(e#^{3yr3|(jI4=dx^PD<(1cvnw8hPD2< z)*n%NQ60ac;m29baW^jn=!`GV-Wp?B|x=la`^MSmvug zuJtEfy~@CApIpw>m(=p1zuNx!mC4k;l~23&wOmZOuiLNh1UvuY+id$$rR$$x)6KtZ zdTN)YOAl(gZ?~pvzI{Eu4{Q0L(d$b}SASH~V+A%ntaRydO;2llLg_7Ue}C%AIVQDy zva_u}=BU>(e0m+>zjgg1t?ehe*!H8!|JC&mUmson2ix`|%Kz2%55Kk_>#FNl`M46?L-BY^x6V>!^Pn#Z8y7ahPzCJcRqIBsgP4}H-(^Dr}y7%?} z7G3-9xv8MG?qsq_f_&uWaN2b{N z{mOkkevfJS@HcIFPr0wh?+Gm*xbg-XgODZK z3uwA`y-iPFr|oD4_grgG(*w$V{d_#^+ShV1WujTP|BpX;IigxVwAl8`uk?Mzex4OL z%F-=QF5_B0t>qHR*w?hYGPj%yC$)U!2HSp68SQ7w`;{*L9@OvOifg%;W6u3U5e-L` zd|6A*Kd*!Pmz&aFIAj7HKk45Tv**9I`6rpye+zx++b zr<9#C;6xtD?%$7}Vw$;cZON*!?Hwq8VEhiup99;^f&IsU{pW%Aj|1eT@MYxTQ?O4jV|wEK@NqOi^24Xm7|9R&9?Ll31MpEaRr0{0-!P^cAA~QV`S=t( zq_;7P@jf^jEs;F%TC^M=g-g*2d<@==R^sFEF|-PwfX|>fJ_$FW)%X;A2d%-U;g|X4 z`n7lu_C^W3AKr=9;p6Z)ezSdp#KT9>MtlN}J%O>s2Zd-0J_YOhFxL18+=aH`&56cb zfp+7gu-i$-6bz$X_z3EXPr#c_CJi5j)BTJ&J`7Ll%Q)lxa6RgSPr}-MjJf22roSYDy;-NXkmIjK8g>+NyWx2 z!-wFQ)A%had=Sn>EAbKdBNWHS;4^3qJ_&mdVw~}QI1FvT2jO(I5g&%@(PqgHUqtWX zQ}AuH6`zL3p3ZNv;r*}y?Z8LioyZKQ&u}B^f=|I?2J>6Wcs~rH?s#Dt^6()TMm_Pu zM${W0fs0Tdd=x%{{P+aif{O8Jc=!;uTf7HHpfUI$451)iScOXQVc3MG;3M#TG!>tQ zp)=SgNPf5)HQ*Dl$C<_~#Cxz3Ey0K3Tol7c;3l*JpMu2!#vdPm=c2Xv5L|=S;S;d? zQ1%;m5B5Tv@qRcErSJhb5^cc;;Ux4fJ_M`KR(u#Xp)@`M7olzVD7+2rz{lW9v>P9X z31mjl2ly;1z$f7shq1o!9_)p>;r;M*)EysySD+sFD7+Q*#K+)D)Egg%KSzD=3HToJ z!+*=%JZ-;R&c3?}sx`7$1gB z88IgCYBZntC|rgj_!zt!EyTy+8ng(Xfa}p>d=kEhqWBd204>3%;fH7$o*Np?=g@Mz z4<3PHcn|hMEAW08Kr8XWAXV*)Aj=URuh&2_Jz6O=26s``|RR7$1f^ z(Q-UD)tci`9Pfuy(HeXRR-uIChkr-wB>!Y%u0fmdQMeRs#mC^!r!Y_O3Ha*yGACGG zc*i$c@Ax>ZzkqEYAAvomvhMJH_%f=L{P5Qo(r0`U{^BB;L(~Z?%b0WcFuX9ty1<8E zK{<09?}HzsckyN#>kyeSvVfCTBBluwR5R!3W@oE7%tBLHOk>ne%uL_PmPs zX1pJES;#!W`{38EW^PL!_&!>JPm8~X`79p3@g24qdOQ@HNzB9QomKOIde#Kb((x<0J5(A265jJ~#`N z;KOh(nksqVIuybu;U-j#Pr@4;Rug7?ES(L#Ix2GJtC@D{WfAA?)b za(o&#EMs}`5qQuo%ul=zhS5g6@D;QLpMn?O%JSkva0e$tI$Gx7&f9s_z1ijEyhRTQWV9<;N55mJ`Q)I zWq9)=j^)rwdrQ8#=5 zE=1k&QMeKH#HZkKck!Mm`QdyNz(?R>6qNjMGb)w*@E@oWZ&q-Ojb`FQuo^Yt!*DH{ zk59m^cT*SM2X8^k@iBNeisR#OEm|%4Vb^gI9r{RZaJ>J~Uz8`JChu|8t37>%7SF!H!9_)qE zct5-VZIk@)2DBR=g-cPvIrI&#L|yQ4_%qZMpMXi^!wWZ|Zuk`Z8|scvL-PRZ6fZmk zd3YZ@7xl!4;Qgo%J`Sfo#Br3w!zwfeABKNHCHORaJkE0B6Yyyi#wX$RkFrkjQFz5q zSa;&#*^jdf_#hm*mN66$C!x*w5UfHed>9`73&slX!S~QMd>Vd;x}M9j{F1qWe0UF@ zin`$g@NCo_AA}#E9{4mo=?Rt*?}sDN0LcR%N5%LA?2=&F@jmzl3gA=lO*8_ZhL`+` zF~Nu7p--{jko@pY6vD^hCF>Xy$pahFe0&66jUxCc9Q!o$93O<6o@H+1Q*iL}%pZIJ zevo8*@M+lX56lg`2QS;mGESsU`1DI`kN6~<_zKI24?+KCgcoi`#rPC_^);47JY4oV zea6S&zu%zGc#~ob(K37xK8#l46YvAH7N3TL-ek_>1MnQQ5g&qAqD}ZHd<<>IC*WIX z3qB3kzQr-8#KYl#G7KVZ!FtpMAAwJ!uJ|M@+`{tWeQ*@&DfwZ?w^??Hhex13cn|hR zetZDlj*9UycsCk>kHg2%7<>Z0^$v3zpN2nqm-hvUhr`}u|BnyCf1xJ4`3vo%g?K-l z@jmk$ABOLsW%x84x|RJBJ_t)bV80|D{t2y+Jn+)LF}C;!+=$lTQ}AnPwh_DsPe<$V z0eCsuAo<~)D2b25-hZb&-VaBk&G;aE25rG7;mCh5<`NGVqOJHSocT}oMffnBxs7!( z2@kiS0=)T#-+~Xr)jOHT_yk4joJ!?}w|=T6_Wy>)64p!w2D{P94k!dA%%?qIgzBk)>e&Z9r@*QfxWgzup)_%!TY)WLMc`(YIM zBtLw$O9#^(pMuj5>R@`}!|;-WDI*>(Kz@7#zKsUp)3Dni9ZWIagJaQPd=UN-1@I}@ z<8vKMQ1Zb3s1hH5w;kHS%*4mwUA_*ScQRJ+_`^Dw`FKB^iWcKT@We0BZ;6Mep%^{@ z*P#{oBz&zKCV{VeejP*b}%W)1IxeM!ED8c;U7_#$;89NR~a9? zu%Zvkjt|2}PwZf-B_96aB>E}&;oW}viI2k<&Wz=U8&My86n;I(IOF~BnRBQYpM(p}?O;kIKm6K6mJ#p4 zW>kqcrIbC7^@8`qu9G{Mg?JzQ?iA(>J_c`{%A64oUq}tRFr|1u{2>bAWAL{XY&-ZQ{8=U2j^u|0RUJ$O?}J}Oi}4;j2}SXK zI20|x2Vpr{h7ZG~XgNLxe}`iDB=n{;pYg)kXr<(bKSFWI51&P=B|m&0t;MI|Av4&P z@IE*Yt-}Z4B(xqMf>)po_$Yh_CGlx^$V|2oybqp_Hc5Us2W`ej;15s=AA@hAE%-Dn zoW=UW`{1c)D?R|jXd7PmKH4q$;Zqkgb{Eipcy=}G5g&wqoXzs%Q}BZt))zhvi)vY4 zcpoeZvki)e>*|=F_$0itp7!uj__>A-rb+U^(;L}u-~+H}4(kXXfp5)a{PAg+Y+}EG z7yfP@V=ErkeT(sw{4k2vGC*XbGW(*}BPMgnI;lps{WsHx+ z!*?%dOz>&=(E`R{D%)42gZcgyY~%PC{K{3#VY~-_w2*y~#KX70!*+^K!@i4{xA*{T zzLqh;o9jB5Gp=V2OFW#7s_|jC5QXtkxB@lcO-9o~cWXd^xXr^Z+Z z_z*n)4z@A8AHHxW+Z{dyzi=1tBNtH?4!MW>Jf55b#|4!Y@!{KN(J_sXd4PMyz0^=hdKDLo@z$f6O7a0e92p;?j`vJTU{tWd9kq2J; z8gmgJg-@Ykd=l+e%u;^Eq@%wc>2zJXE_4~x<)7v2Z^pdENWyb0~b zN8#$fvrfw?3!nNY>kglUA8exxJ`JDykY$v3c=L9a6CZ>1|6)7AN8p6r9G~EWa1mO8 zk3#Qb`ivKzf!5#y@FKJpAA-yN&9dNQ@YN0-&3b$a78Z0g8}UAP1WMsOcmdji55a=M zj%KUmfzP9D_#|9d)RE7Z=mUHdb;Bp%Ur~2_8umY^qv?SUz|#-zXa5)Tt-i{yuMC(%#I12<0Y zXm;aM@EcP)nywYBBRBG+@ z-02-n7$1S}qWSnV{MU?*W)a@Z>}dL;W%vMm8O87^c@1X*G8g|;<(R9K4;4!Ex-VcW(A3g{xP&a%SUWK~jqp-`ztarQ*9)kws{ct!6 z;DhkW4xP*h$q(;9Gx2fwCaT7#;o?I&nFh%N|BMz%Jp9~Ioj5M0es~<(fcL|Hq9oq* z=wvP))5)apVOVu%C(~ml9-j6{Clka6;MI?IGAr;=c*^6Q%w~y)k3QGQbe+Xqf^R(E z$&}zz@Ru7qnNo>|BVO!eD)B)$;wAbl9xmJ3$wcrmxS(f&*@Tb4n^Ey4#KV!j3d~@9 z5Z;SM;N!62*a9;KAA#?nQhXX-`i%lJRpQ|vP$fPEC-*Ke)%Xyca6IMlL3m-G0<%!! z;Xlx7yg9MJ)T0DG0xv(Qz-$l?x1x>sG>rQTObRdD-M7G`@upvac^ws0(=L3ae}U;H z9*!DOU_5*fersfb3E?Af+F1IA55s%W3Va+sbXI{`DIUHsslcqlr{JCE(GQ7-cYm|M z><|yXG_}C^W;4&>E#(EKCq4$(RWgS7B>WIn;!PF(K{N3|IA}(J3F8B>UqgXeEFPB6 zW!dpz`0?c|R}Ezs6qw7dDKK5}5%}>9EThEVSYVF2slfEWdvNr3S&#T2{Ok8vclb1X z{`&R$ z-Xs~nKQIpX7<}~w=CI^}|J=wNmOL*OnBQ+=UP(NB^R)ug=Thp2557)6@o^a0!nosw z9p7Ot;eGHP6qh{k$L|%GHR56VedaA*xcaZmpE{NoUi`NL(;FX#pHI^k-Un~`2V;eg z!uQc&d>THnoj%|b@PUt5m-smR@=oRt-h)T}n{^~!*v$Cgqj0V%G^_CucxcB$lfe7n zgPjUF=cXRmSWswEk_Qg%Txinx0Gx{o>WPPMpf30nJhQ0K`0xSv;lYKbJKh{ZI+}|2 z!R{!8_h4^SiTA@t&`f*+p3=3@RO1713<~3ea0+U`hu}=qgb%~7f3DEX$NS;WP!ykl z_xK9U3Va-%e^{Yeiw{BH;Vds+7)I;y!tH1y-h83Z+<bwShX}^lpWw8$Jw= z|6(Eg2HJ&Pjw&=kybm6UX5u|~`d3&Md;m5bU1%2LBk&`d;K z@gcb5GR8{cFQ;GMDKsPS33&D*#snXPzyE%riQrRk*izP)#KRFkpk49s!)2@^yt$>& zJcM@Ru7&ag1X{J{I*OjL~z!xU=33-7ptw(xQI7+Q=^z)fh07!2H<0`<0|UK z``{C3CO!eTp(ea}pwNs)3-LjCJBs3C@FTQL@;u0RqvhfsDm0VgEIU2~UwN42!l&TJ zkFbs;&!dH=9Bsyj;i0Qp7Q7EOJx1I32z=#vj{a?-DZvNf1!z7# z1lOYoJ_&cA#dz~oE3olPHn5dIDoOMZA`L1!}^Y&POOI1p{Z2Ve?qmi%z_S2~+_@d@}o zO5@Y8(^osQZ(`ZuFOj*NJaC2A*>uIn;gHFlO;3CPJ~ySasl+GYh39uR^YJ10)eAeD zMR*Thb5Uor3Lk~*MUo$ODeG*Kcpn^tHsOQtd6beoaD0fqNj!WWnFYkd&zE;LKD-Z3 zK;7{{coXvQQMeWL#;0N9w9dwlkHB}(V2OtlDmt4H_#nIqmEfcB>y@2NDc%n|%w!qy zJ~)0>XR}=L!=V>5{^H>e&{}*9{u!;ur-hfWF7QcMIEUrJ`(PRB8ey#9Bd8lb0Y}cI z|M(!Bi~RTqya5&CqwoPV7$1lIn&>}10B4|5d>CGars5;;HWb3g;3M;xWB3HzjGFK% z_@!^L?(iOLL=k)h{$YM+vsm)LK?^#Y1U>-YN1O3!SQ}v-;luEe>pGj=_yp{CJ^j3b z{P0dR0w0IH7BkLxKU|7R@iF)mnu<@tw@?V5h8=HU{P8~cLo`$J!z5~w{BZS+^dFyq z-?@pohmXR$(PDfYe)W5uO%(6JZ!BRu!u#QOmNGvjKYSgn#i!t;A9ObB@F6(hX4=CC zVE|~qgYTn_ z_%!_eL!HeQdcQyrA(H49fb;Bp&l!uv<_z+x)`rza6!JpD+@o?$mtS@{FK8>32 zNqFkdm`nHoybvwHhv2_{&US=1Yncyd6W$LmdV+04^1v0yw~+ebMe7+udke3$W&czF1Ggz+9+yp?wGQP}Vg_80gFe11FY=xX{8 zm+oX4@iADii+1ro_@F5=L3|v(*0IPe#;4$UU5d;KdN_F1qOYjMJ!&i#Ta(ootaAJ{JBOcy@cHm=h>G&eETRc2uLXjE#9hM#X z&nYq^@WPt&XagUHXJ1fcn(#q*D_V|^!MD%~d>VeYyvVGQczAFHj(iWVLy5J*l1M=aMut!yq>5li{4CLX%@bKwHrnkhya#Sqwa0{yL{spcp z7MXrCicAAO0MDOE|M4OC6SN4QfQx4#d=$>Pq{uA8N8o#C1wIWYRTr5!J_PSWtMPHT z6RpLY*+pg+T89tA`_Kl-0~gg4nT_};^wly?@WOhu6(52BMrphW7nvu~ZhR7+Tvuee z9{B~%ff@gL#sMFMTjv&;p7=DJbVZRFfDgfvD_M7v2R@F1_ypX%sK`vkr(orE%o%(b zuDG$tMDTIAaY>PhN**|ODQWl!Jn{!DJKlrco-Z;9@o*g4gb%`_UZM?&hwr_@vf$IO zdUKH}_%dz5>Nn`Wc=+cxS$Fs}eDE#S9X<|!_b0Xmd=j4Y4)Y)Hhmm*bGhTQvib#G~ z`X1wp55ajTDtX{TXqn`JNB*VA#PA+G2Cc&T;Q$oJ2jB>_8XtrYqc!*h{9r5V6rY9% zr&(US4~|4>$q(ab2VS@V6&ywX;Sc}Le8$J%5C6fki-+fKW7+W`Sn?s;8$Jj>-p)P& zZ$2tAvr!2?4F86v;?wY^9gHJB3cs94RcgfQqoCLDNRSiq#~V?lnQf9 zL{!R2(MVB$&qIuk>r#EbkH`1-&+pgc@#^*7v*(_B?z!ilduMhWrpsAA0R=hFi!f8J z@YGj~RV?R4m=nvn^;P2|C;28Ul*_ypi{&~Ww!wLqv-~=i$>FvBp)Xd(a=s5Wxys4c zZ7)afi}iAbzlbnYANV44$|e3ay5uVV8AIh7@A8K0T~6~M7$Il*ER2+k{7a0It2{Qe zg)y-XUxRUSnO{Oy4lQkA8%&f_d>V3cf#+e0T;jWsmn*yk-Ex(GkLhxapF=^e^Gld1 zhdyng9kb*l?}XWMiVsIo&hk;1E9dxgm?!6XT5DS<$pyX_i{vVIC-f1LPu;dHtdR3OZ?I#ROMK)I$1CT!efzf1`Y!G8en`q0 zo`=D5iO25Xc;zgohqi^0a&%=_TNour58Tc1%1Pb^6Xg`|hDotLUyPhw;_Zf;SFuhs zy5;ESQIPBW-rda~Im4%qXbW@X0&m!(Ei913yNw?f$$9?Xp5~}r;(uagtTVDL{26QI z8sEK_W0xyDWpBs6lWqB+v~wV*-rE-5KdLQs$r&EBpYtv!`DBcU_4!-xGZu1z4|=~b ziuL)Am>}2qy9YRSxyZ#2IL?@P`azCMF7WpbG1hX4Pd>CQER^%S(+AtaVmZYvV;z^A z-{$0BF=RE(4hJmgdQFQ@p^)68Kx z$2**6Tw*!5f7P6nll(z+%UQkv)8!(s>2|*4I{*4>=A>NZJ6xPIj3?zV>S8PA>DX`Ocl3<^!*F zymE$Tq9Pahm)ALWa+Pnt-no-2ykvoEGnVr@tdheI+rq0@6Y~viVLmpm>c*?aVr}+!dS(m=;{PJOccYVoOPW{8ZAiied=QkKzxz4pd z?VioG$=`2p55v?iabc_Wkp7PT^WYuY!+hl_p0caoDbMqt_h=7QxyHNh(;iai=>tEr zf4k2`YM<90&>mLVw$85~*d8XyVN83t6BF#W!qY#{9_Gje9&=E8ST1LH#KHEhewr&8 zZQ57#eTVp2uJV~5Y!6BMD)K91+e1zcA8HQ=9;S{l$?(@Pc(L~R+n9Nm`g|E?$t9j} zxP8kx?i#1xcRF7F0Pd1AybfLJgb%leMOdP|!jHwDVYa{9#Oyv)nqqJq(qTyadbCukv3pPpzHc4 z;fVHd62{AUegtE+U*o4@zEGR|Ph`KRezrYqkI{09kHh++G2v-wRbJpnF;T8@pHH-h zHR>dJ9E!@bd}jPvF7l6&kt@9Ck=nQ4G=Co>%DRbMrP4N+!tWK8i!NNGNc<*D)H|IUg2VhoTYZQM3OMk6CAB&mFbNqQMQJ&{J zvDkd5@ZYdduJeaKZ7#`Kz8_2FDnE{Sa*g+%WIkB`(>&rct{3HL{vK*_iGO>Xb8YRd zars2YE=PBt|IuZ-!6BGUWw+4ol*;ya7w&wqG#6utLuA3@nn1{2CU-I#bOrl;tEJjf$M( zvoJW;=XqFTza_pNsRxWX--%&zg?|&X`c+HD{72Mdo4f|C%ImxitCWXRlwrD@q zSJbs%=VMPbc5;qC`W4&DS>An`^JJXU`~qsq!)eACYhwOtd)NvaVw-#r=F1sA5{u*< zPeG^pc|HSea)D=Jo;pRIi!S9Qz82Z592YOb((9aSUV_xcj**|ih}ZO=cRAf$eO*8K z2N))ocp*l~WnPW3a-DbSwy#*9e}E9{^FkzJeO`=|T;U~HU|&^!6+`9lwf3+N3hHFI zf~m1SFT-@X$^*ad9LY&O6qDpE--mIr4zI*SxyHMlVZ7utABkD^m5XJVDChZftW~GL z=bBd=3au?QbaK89REK#20#5Wv&tiwZ5kyAVsRXNXJM@}yA zEKHM&JO>lx63@q4?U(td$Sbe#G8E)0FGo?X@mAl|e>ue^tdye{Vy#@})z~1{c|F?X z@GWy2ljS52#)f!Y{2okFo{mPbkNX8rMo^yTZY1RbufZZ?Sm(nE>dRSv8cSk1pLnKz z%Xxkp^I|!lHN#lTMg9S%YO}<5qf4&v?=VcR@fu8*>-;LZ<#3i`L8qML?J!eL@d!+G zUr6(jSSsiE6pVgafB0KS%LTp^U2=(kj^*x6RsJJJDzEXgXqD@{9^LAMnZ^~<KAz~@^XoPh$(WJAI4g_#(mGWX39w(f~j(f-;YjhX7~sU zU1MK-9J=HjpN{qF6!;pfi|zAIkyNL`zrq@Is=NZT<9=fqX32H#e~$jEpXA*U$lE*JS$bgr^reiE&6o&Sk~I^kUB5p`{*cyG*m$iDbs%#kyE z47%kUpM}xOw9l8LsJz5CV2WJk#aQW?r@~9ILay@Dn59mg`_Iw`Imz2&s+{5vBCGu@ zPsDQD=J<117N4W|BIML5@y{_)uJRvHRj0=PKwg{S+wEZx3RU~!ozN|(`2Cn9XZW+o zXeZBK$28>y{tm{=MV^bg_Dj3~YvnROfT`+K`Dsj+>--9`a`=wdYnY<_G>^s_+h+K~ zsL5IW3cA%P@HNQGW&R0PsZ-%cF+rO(egYewvoCHtPv7JukH9)P&6lBVtv>T&tXE#) zX|v5q~-txy1WngPh?HVU?Waqp?=b@rj6E%$w)auwHqAFUK6Y#MffJI%U2M zi{%R6kCI&F-(!JX*V9rSpLKa*98NxpI!DVUAqj)kt|Jtn(!$V<(q5ah3k8wqJffCOl=V zcoOC>(GGtW^W;2VfQ53AFG5K!@n3P*Hs%a}@M>$joaKoq$T_|hdAY(%F;%Yej@OuP za*D^ycZ_m|e}(z64)1xbW0BK*JZf^Dr(>mD;16EsoXT0g0ITF8KZHd;b&hz;AL`pr zj1^aI@LEZZeh@2PQHLMFD!In1QJ3rdGSZUgLQI_zl`

%X^d#LPSX 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 XJS8Yu;wu@&UcagE`%JeWA{F@m!3ZQj literal 0 HcmV?d00001 diff --git a/settings.gradle b/settings.gradle index d992339..d000615 100644 --- a/settings.gradle +++ b/settings.gradle @@ -1,2 +1,4 @@ rootProject.name = 'imgui-java' +include 'imgui-binding' +include 'imgui-lwjgl3'