├── .gitmodules
├── generator
    ├── cimguizmo_template.cpp
    ├── cimguizmo_template.h
    ├── generator.bat
    ├── generator.sh
    ├── generator.lua
    └── output
    │   ├── structs_and_enums.lua
    │   ├── structs_and_enums.json
    │   ├── definitions.json
    │   └── definitions.lua
├── README.md
├── LICENSE
├── cimguizmo.h
└── cimguizmo.cpp


/.gitmodules:
--------------------------------------------------------------------------------
1 | [submodule "ImGuizmo"]
2 | 	path = ImGuizmo
3 | 	url = https://github.com/CedricGuillemet/ImGuizmo
4 | 


--------------------------------------------------------------------------------
/generator/cimguizmo_template.cpp:
--------------------------------------------------------------------------------
 1 | #include "imgui.h"
 2 | #include "imgui_internal.h"
 3 | #include "./ImGuizmo/ImGuizmo.h"
 4 | #include "cimguizmo.h"
 5 | 
 6 | 
 7 | 
 8 | #include "auto_funcs.cpp"
 9 | 
10 | 
11 | 


--------------------------------------------------------------------------------
/generator/cimguizmo_template.h:
--------------------------------------------------------------------------------
 1 | #ifndef CIMGUIZMO_INCLUDED
 2 | #define CIMGUIZMO_INCLUDED
 3 | 
 4 | #include "cimgui.h"
 5 | 
 6 | #ifdef CIMGUI_DEFINE_ENUMS_AND_STRUCTS
 7 | #include "imgui_structs.h"
 8 | #else
 9 | #endif // CIMGUI_DEFINE_ENUMS_AND_STRUCTS
10 | 
11 | PLACE_STRUCTS_C
12 | 
13 | #include "auto_funcs.h"
14 | 
15 | 
16 | #endif //CIMGUIZMO_INCLUDED
17 | 
18 | 
19 | 
20 | 
21 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # cimguizmo
2 | 
3 | This is a c-api wrapper for ImGuizmo (https://github.com/CedricGuillemet/ImGuizmo)  which is a guizmo for Dear ImGui (https://github.com/ocornut/imgui)
4 | 
5 | ImGuizmo is a submodule of this repo. To do generation again in case ImGuizmo is changed, you should update ImGuizmo, make sure that cimgui repository is a sibling folder to this repository folder and execute generator/generator.bat(.sh)
6 | 


--------------------------------------------------------------------------------
/generator/generator.bat:
--------------------------------------------------------------------------------
 1 | :: this script must be executed in this directory
 2 | :: all the output goes to generator/output folder
 3 | :: .cpp and .h files:
 4 | :: cimplot.h and cimplot.cpp with gcc preprocess
 5 | :: lua and json files:
 6 | :: definitions.lua for function definitions
 7 | :: structs_and_enums.lua with struct and enum information-definitions
 8 | :: impl_definitions.lua for implementation function definitions
 9 | 
10 | :: set your PATH if necessary for LuaJIT or Lua5.1 or luajit with: (for example)
11 | set PATH=%PATH%;C:\anima;C:\mingws\i686-7.2.0-release-posix-dwarf-rt_v5-rev1\mingw32\bin;
12 | :: set PATH=%PATH%;C:\luaGL;C:\i686-7.2.0-release-posix-dwarf-rt_v5-rev1\mingw32\bin;
13 | :: set PATH=%PATH%;C:\luaGL\sources\luajit-master\luajit-master\bin\mingw32;C:\mingw32\bin;
14 | ::process  files
15 | :: arg[1] compiler name g++, gcc, clang or cl
16 | :: arg[2] "" or "comments"
17 | luajit ./generator.lua g++ ""
18 | 
19 | ::leave console open
20 | cmd /k
21 | 
22 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2020 Victor Bombí
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 
23 | 


--------------------------------------------------------------------------------
/generator/generator.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # this script must be executed in this directory
 4 | # all the output goes to generator/output folder
 5 | # .cpp and .h files:
 6 | # cimgui.h and cimgui.cpp with gcc preprocess
 7 | # cimgui_nopreprocess.h and cimgui_nopreprocess.cpp generated without preprocess
 8 | # cimgui_impl.h with implementation function cdefs
 9 | # lua and json files:
10 | # definitions.lua for function definitions
11 | # structs_and_enums.lua with struct and enum information-definitions
12 | # impl_definitions.lua for implementation function definitions
13 | 
14 | #process  files
15 | # arg[1] compiler name gcc, clang, or cl
16 | # arg[2] "" or "comments"
17 | #
18 | 
19 | # parse command line arguments
20 | # ref: https://stackoverflow.com/questions/192249/how-do-i-parse-command-line-arguments-in-bash
21 | POSITIONAL_ARGS=()
22 | 
23 | TARGETS=""
24 | 
25 | help() {
26 |         cat <<EOF
27 | Usage of generator.sh:
28 |    -t --target    specify which imgui features should be generated
29 |                   (default: \"$TARGETS\")
30 |    -h --help      show this message and exit
31 | EOF
32 | }
33 | 
34 | while [[ $# -gt 0 ]]; do
35 |   case $1 in
36 |     -t|--target)
37 |       TARGETS="$2"
38 |       shift # past argument
39 |       shift # past value
40 |       ;;
41 |     -h|--help)
42 |       help
43 |       exit 0
44 |       ;;
45 |     -*|--*)
46 |       echo "Unknown option $1"
47 |       help
48 |       exit 1
49 |       ;;
50 |     *)
51 |       POSITIONAL_ARGS+=("$1") # save positional arg
52 |       shift # past argument
53 |       ;;
54 |   esac
55 | done
56 | 
57 | set -- "${POSITIONAL_ARGS[@]}" # restore positional parameters
58 | 
59 | echo "TARGETS: " $TARGETS
60 | 
61 | luajit$suffix ./generator.lua gcc "$TARGETS"
62 | 


--------------------------------------------------------------------------------
/cimguizmo.h:
--------------------------------------------------------------------------------
  1 | //This file is automatically generated by generator.lua from https://github.com/cimgui/cimguizmo
  2 | //based on ImGuizmo.h file version 1.91.3 WIP from https://github.com/CedricGuillemet/ImGuizmo
  3 | #ifndef CIMGUIZMO_INCLUDED
  4 | #define CIMGUIZMO_INCLUDED
  5 | 
  6 | #include "cimgui.h"
  7 | 
  8 | #ifdef CIMGUI_DEFINE_ENUMS_AND_STRUCTS
  9 | 
 10 | typedef struct ImGuiWindow ImGuiWindow;
 11 | struct ImGuiWindow;
 12 | typedef enum {
 13 |       TRANSLATE_X = (1u << 0),
 14 |       TRANSLATE_Y = (1u << 1),
 15 |       TRANSLATE_Z = (1u << 2),
 16 |       ROTATE_X = (1u << 3),
 17 |       ROTATE_Y = (1u << 4),
 18 |       ROTATE_Z = (1u << 5),
 19 |       ROTATE_SCREEN = (1u << 6),
 20 |       SCALE_X = (1u << 7),
 21 |       SCALE_Y = (1u << 8),
 22 |       SCALE_Z = (1u << 9),
 23 |       BOUNDS = (1u << 10),
 24 |       SCALE_XU = (1u << 11),
 25 |       SCALE_YU = (1u << 12),
 26 |       SCALE_ZU = (1u << 13),
 27 |       TRANSLATE = TRANSLATE_X | TRANSLATE_Y | TRANSLATE_Z,
 28 |       ROTATE = ROTATE_X | ROTATE_Y | ROTATE_Z | ROTATE_SCREEN,
 29 |       SCALE = SCALE_X | SCALE_Y | SCALE_Z,
 30 |       SCALEU = SCALE_XU | SCALE_YU | SCALE_ZU,
 31 |       UNIVERSAL = TRANSLATE | ROTATE | SCALEU
 32 |    }OPERATION;
 33 | typedef enum {
 34 |       LOCAL,
 35 |       WORLD
 36 |    }MODE;
 37 | typedef enum {
 38 |       DIRECTION_X,
 39 |       DIRECTION_Y,
 40 |       DIRECTION_Z,
 41 |       PLANE_X,
 42 |       PLANE_Y,
 43 |       PLANE_Z,
 44 |       SELECTION,
 45 |       INACTIVE,
 46 |       TRANSLATION_LINE,
 47 |       SCALE_LINE,
 48 |       ROTATION_USING_BORDER,
 49 |       ROTATION_USING_FILL,
 50 |       HATCHED_AXIS_LINES,
 51 |       TEXT,
 52 |       TEXT_SHADOW,
 53 |       COUNT
 54 |    }COLOR;
 55 | typedef struct Style Style;
 56 | struct Style
 57 | {
 58 |       float TranslationLineThickness;
 59 |       float TranslationLineArrowSize;
 60 |       float RotationLineThickness;
 61 |       float RotationOuterLineThickness;
 62 |       float ScaleLineThickness;
 63 |       float ScaleLineCircleSize;
 64 |       float HatchedAxisLineThickness;
 65 |       float CenterCircleSize;
 66 |       ImVec4 Colors[COUNT];
 67 | };
 68 | #else
 69 | #endif // CIMGUI_DEFINE_ENUMS_AND_STRUCTS
 70 | 
 71 | 
 72 | 
 73 | 
 74 | 
 75 | #ifndef CIMGUI_DEFINE_ENUMS_AND_STRUCTS
 76 | typedef ImGuizmo::Style Style;
 77 | typedef ImGuizmo::COLOR COLOR;
 78 | typedef ImGuizmo::MODE MODE;
 79 | typedef ImGuizmo::OPERATION OPERATION;
 80 | #endif //CIMGUI_DEFINE_ENUMS_AND_STRUCTS
 81 | CIMGUI_API void ImGuizmo_SetDrawlist(ImDrawList* drawlist);
 82 | CIMGUI_API void ImGuizmo_BeginFrame(void);
 83 | CIMGUI_API void ImGuizmo_SetImGuiContext(ImGuiContext* ctx);
 84 | CIMGUI_API bool ImGuizmo_IsOver_Nil(void);
 85 | CIMGUI_API bool ImGuizmo_IsUsing(void);
 86 | CIMGUI_API bool ImGuizmo_IsUsingViewManipulate(void);
 87 | CIMGUI_API bool ImGuizmo_IsViewManipulateHovered(void);
 88 | CIMGUI_API bool ImGuizmo_IsUsingAny(void);
 89 | CIMGUI_API void ImGuizmo_Enable(bool enable);
 90 | CIMGUI_API void ImGuizmo_DecomposeMatrixToComponents(const float* matrix,float* translation,float* rotation,float* scale);
 91 | CIMGUI_API void ImGuizmo_RecomposeMatrixFromComponents(const float* translation,const float* rotation,const float* scale,float* matrix);
 92 | CIMGUI_API void ImGuizmo_SetRect(float x,float y,float width,float height);
 93 | CIMGUI_API void ImGuizmo_SetOrthographic(bool isOrthographic);
 94 | CIMGUI_API void ImGuizmo_DrawCubes(const float* view,const float* projection,const float* matrices,int matrixCount);
 95 | CIMGUI_API void ImGuizmo_DrawGrid(const float* view,const float* projection,const float* matrix,const float gridSize);
 96 | CIMGUI_API bool ImGuizmo_Manipulate(const float* view,const float* projection,OPERATION operation,MODE mode,float* matrix,float* deltaMatrix,const float* snap,const float* localBounds,const float* boundsSnap);
 97 | CIMGUI_API void ImGuizmo_ViewManipulate_Float(float* view,float length,ImVec2_c position,ImVec2_c size,ImU32 backgroundColor);
 98 | CIMGUI_API void ImGuizmo_ViewManipulate_FloatPtr(float* view,const float* projection,OPERATION operation,MODE mode,float* matrix,float length,ImVec2_c position,ImVec2_c size,ImU32 backgroundColor);
 99 | CIMGUI_API void ImGuizmo_SetAlternativeWindow(ImGuiWindow* window);
100 | CIMGUI_API void ImGuizmo_SetID(int id);
101 | CIMGUI_API void ImGuizmo_PushID_Str(const char* str_id);
102 | CIMGUI_API void ImGuizmo_PushID_StrStr(const char* str_id_begin,const char* str_id_end);
103 | CIMGUI_API void ImGuizmo_PushID_Ptr(const void* ptr_id);
104 | CIMGUI_API void ImGuizmo_PushID_Int(int int_id);
105 | CIMGUI_API void ImGuizmo_PopID(void);
106 | CIMGUI_API ImGuiID ImGuizmo_GetID_Str(const char* str_id);
107 | CIMGUI_API ImGuiID ImGuizmo_GetID_StrStr(const char* str_id_begin,const char* str_id_end);
108 | CIMGUI_API ImGuiID ImGuizmo_GetID_Ptr(const void* ptr_id);
109 | CIMGUI_API bool ImGuizmo_IsOver_OPERATION(OPERATION op);
110 | CIMGUI_API void ImGuizmo_SetGizmoSizeClipSpace(float value);
111 | CIMGUI_API void ImGuizmo_AllowAxisFlip(bool value);
112 | CIMGUI_API void ImGuizmo_SetAxisLimit(float value);
113 | CIMGUI_API void ImGuizmo_SetAxisMask(bool x,bool y,bool z);
114 | CIMGUI_API void ImGuizmo_SetPlaneLimit(float value);
115 | CIMGUI_API bool ImGuizmo_IsOver_FloatPtr(float* position,float pixelRadius);
116 | CIMGUI_API Style* Style_Style(void);
117 | CIMGUI_API void Style_destroy(Style* self);
118 | CIMGUI_API Style* ImGuizmo_GetStyle(void);
119 | 
120 | 
121 | 
122 | #endif //CIMGUIZMO_INCLUDED
123 | 
124 | 
125 | 
126 | 
127 | 


--------------------------------------------------------------------------------
/cimguizmo.cpp:
--------------------------------------------------------------------------------
  1 | //This file is automatically generated by generator.lua from https://github.com/cimgui/cimguizmo
  2 | //based on ImGuizmo.h file version 1.91.3 WIP from https://github.com/CedricGuillemet/ImGuizmo
  3 | #include "imgui.h"
  4 | #include "imgui_internal.h"
  5 | #include "./ImGuizmo/ImGuizmo.h"
  6 | #include "cimguizmo.h"
  7 | 
  8 | 
  9 | 
 10 | static inline ImVec2 ConvertToCPP_ImVec2(const ImVec2_c& src)
 11 | {
 12 |     ImVec2 dest;
 13 |     dest.x = src.x;
 14 |     dest.y = src.y;
 15 |     return dest;
 16 | }
 17 | static inline ImVec2_c ConvertFromCPP_ImVec2(const ImVec2& src)
 18 | {
 19 |     ImVec2_c dest;
 20 |     dest.x = src.x;
 21 |     dest.y = src.y;
 22 |     return dest;
 23 | }CIMGUI_API void ImGuizmo_SetDrawlist(ImDrawList* drawlist)
 24 | {
 25 |     return ImGuizmo::SetDrawlist(drawlist);
 26 | }
 27 | CIMGUI_API void ImGuizmo_BeginFrame()
 28 | {
 29 |     return ImGuizmo::BeginFrame();
 30 | }
 31 | CIMGUI_API void ImGuizmo_SetImGuiContext(ImGuiContext* ctx)
 32 | {
 33 |     return ImGuizmo::SetImGuiContext(ctx);
 34 | }
 35 | CIMGUI_API bool ImGuizmo_IsOver_Nil()
 36 | {
 37 |     return ImGuizmo::IsOver();
 38 | }
 39 | CIMGUI_API bool ImGuizmo_IsUsing()
 40 | {
 41 |     return ImGuizmo::IsUsing();
 42 | }
 43 | CIMGUI_API bool ImGuizmo_IsUsingViewManipulate()
 44 | {
 45 |     return ImGuizmo::IsUsingViewManipulate();
 46 | }
 47 | CIMGUI_API bool ImGuizmo_IsViewManipulateHovered()
 48 | {
 49 |     return ImGuizmo::IsViewManipulateHovered();
 50 | }
 51 | CIMGUI_API bool ImGuizmo_IsUsingAny()
 52 | {
 53 |     return ImGuizmo::IsUsingAny();
 54 | }
 55 | CIMGUI_API void ImGuizmo_Enable(bool enable)
 56 | {
 57 |     return ImGuizmo::Enable(enable);
 58 | }
 59 | CIMGUI_API void ImGuizmo_DecomposeMatrixToComponents(const float* matrix,float* translation,float* rotation,float* scale)
 60 | {
 61 |     return ImGuizmo::DecomposeMatrixToComponents(matrix,translation,rotation,scale);
 62 | }
 63 | CIMGUI_API void ImGuizmo_RecomposeMatrixFromComponents(const float* translation,const float* rotation,const float* scale,float* matrix)
 64 | {
 65 |     return ImGuizmo::RecomposeMatrixFromComponents(translation,rotation,scale,matrix);
 66 | }
 67 | CIMGUI_API void ImGuizmo_SetRect(float x,float y,float width,float height)
 68 | {
 69 |     return ImGuizmo::SetRect(x,y,width,height);
 70 | }
 71 | CIMGUI_API void ImGuizmo_SetOrthographic(bool isOrthographic)
 72 | {
 73 |     return ImGuizmo::SetOrthographic(isOrthographic);
 74 | }
 75 | CIMGUI_API void ImGuizmo_DrawCubes(const float* view,const float* projection,const float* matrices,int matrixCount)
 76 | {
 77 |     return ImGuizmo::DrawCubes(view,projection,matrices,matrixCount);
 78 | }
 79 | CIMGUI_API void ImGuizmo_DrawGrid(const float* view,const float* projection,const float* matrix,const float gridSize)
 80 | {
 81 |     return ImGuizmo::DrawGrid(view,projection,matrix,gridSize);
 82 | }
 83 | CIMGUI_API bool ImGuizmo_Manipulate(const float* view,const float* projection,OPERATION operation,MODE mode,float* matrix,float* deltaMatrix,const float* snap,const float* localBounds,const float* boundsSnap)
 84 | {
 85 |     return ImGuizmo::Manipulate(view,projection,operation,mode,matrix,deltaMatrix,snap,localBounds,boundsSnap);
 86 | }
 87 | CIMGUI_API void ImGuizmo_ViewManipulate_Float(float* view,float length,ImVec2_c position,ImVec2_c size,ImU32 backgroundColor)
 88 | {
 89 |     return ImGuizmo::ViewManipulate(view,length,ConvertToCPP_ImVec2(position),ConvertToCPP_ImVec2(size),backgroundColor);
 90 | }
 91 | CIMGUI_API void ImGuizmo_ViewManipulate_FloatPtr(float* view,const float* projection,OPERATION operation,MODE mode,float* matrix,float length,ImVec2_c position,ImVec2_c size,ImU32 backgroundColor)
 92 | {
 93 |     return ImGuizmo::ViewManipulate(view,projection,operation,mode,matrix,length,ConvertToCPP_ImVec2(position),ConvertToCPP_ImVec2(size),backgroundColor);
 94 | }
 95 | CIMGUI_API void ImGuizmo_SetAlternativeWindow(ImGuiWindow* window)
 96 | {
 97 |     return ImGuizmo::SetAlternativeWindow(window);
 98 | }
 99 | CIMGUI_API void ImGuizmo_SetID(int id)
100 | {
101 |     return ImGuizmo::SetID(id);
102 | }
103 | CIMGUI_API void ImGuizmo_PushID_Str(const char* str_id)
104 | {
105 |     return ImGuizmo::PushID(str_id);
106 | }
107 | CIMGUI_API void ImGuizmo_PushID_StrStr(const char* str_id_begin,const char* str_id_end)
108 | {
109 |     return ImGuizmo::PushID(str_id_begin,str_id_end);
110 | }
111 | CIMGUI_API void ImGuizmo_PushID_Ptr(const void* ptr_id)
112 | {
113 |     return ImGuizmo::PushID(ptr_id);
114 | }
115 | CIMGUI_API void ImGuizmo_PushID_Int(int int_id)
116 | {
117 |     return ImGuizmo::PushID(int_id);
118 | }
119 | CIMGUI_API void ImGuizmo_PopID()
120 | {
121 |     return ImGuizmo::PopID();
122 | }
123 | CIMGUI_API ImGuiID ImGuizmo_GetID_Str(const char* str_id)
124 | {
125 |     return ImGuizmo::GetID(str_id);
126 | }
127 | CIMGUI_API ImGuiID ImGuizmo_GetID_StrStr(const char* str_id_begin,const char* str_id_end)
128 | {
129 |     return ImGuizmo::GetID(str_id_begin,str_id_end);
130 | }
131 | CIMGUI_API ImGuiID ImGuizmo_GetID_Ptr(const void* ptr_id)
132 | {
133 |     return ImGuizmo::GetID(ptr_id);
134 | }
135 | CIMGUI_API bool ImGuizmo_IsOver_OPERATION(OPERATION op)
136 | {
137 |     return ImGuizmo::IsOver(op);
138 | }
139 | CIMGUI_API void ImGuizmo_SetGizmoSizeClipSpace(float value)
140 | {
141 |     return ImGuizmo::SetGizmoSizeClipSpace(value);
142 | }
143 | CIMGUI_API void ImGuizmo_AllowAxisFlip(bool value)
144 | {
145 |     return ImGuizmo::AllowAxisFlip(value);
146 | }
147 | CIMGUI_API void ImGuizmo_SetAxisLimit(float value)
148 | {
149 |     return ImGuizmo::SetAxisLimit(value);
150 | }
151 | CIMGUI_API void ImGuizmo_SetAxisMask(bool x,bool y,bool z)
152 | {
153 |     return ImGuizmo::SetAxisMask(x,y,z);
154 | }
155 | CIMGUI_API void ImGuizmo_SetPlaneLimit(float value)
156 | {
157 |     return ImGuizmo::SetPlaneLimit(value);
158 | }
159 | CIMGUI_API bool ImGuizmo_IsOver_FloatPtr(float* position,float pixelRadius)
160 | {
161 |     return ImGuizmo::IsOver(position,pixelRadius);
162 | }
163 | CIMGUI_API Style* Style_Style(void)
164 | {
165 |     return IM_NEW(Style)();
166 | }
167 | CIMGUI_API void Style_destroy(Style* self)
168 | {
169 |     IM_DELETE(self);
170 | }
171 | CIMGUI_API Style* ImGuizmo_GetStyle()
172 | {
173 |     return &ImGuizmo::GetStyle();
174 | }
175 | 
176 | 
177 | 
178 | 


--------------------------------------------------------------------------------
/generator/generator.lua:
--------------------------------------------------------------------------------
  1 | --------------------------------------------------------------------------
  2 | --script for auto_funcs.h and auto_funcs.cpp generation
  3 | --expects LuaJIT
  4 | --------------------------------------------------------------------------
  5 | assert(_VERSION=='Lua 5.1',"Must use LuaJIT")
  6 | assert(bit,"Must use LuaJIT")
  7 | local script_args = {...}
  8 | local COMPILER = script_args[1]
  9 | local COMMENTS_GENERATION = script_args[2]:match("comments") and true or false
 10 | local CPRE,CTEST
 11 | if COMPILER == "gcc" or COMPILER == "g++" or COMPILER == "clang" then
 12 |     CPRE = COMPILER..[[ -E -DIMGUI_DISABLE_OBSOLETE_FUNCTIONS -DIMGUI_API="" -DIMGUI_IMPL_API="" ]]
 13 |     CTEST = COMPILER.." --version"
 14 | elseif COMPILER == "cl" then
 15 |     CPRE = COMPILER..[[ /E /DIMGUI_DISABLE_OBSOLETE_FUNCTIONS /DIMGUI_API="" /DIMGUI_IMPL_API="" ]]
 16 |     CTEST = COMPILER
 17 | else
 18 |     print("Working without compiler ")
 19 | 	error("cant work with "..COMPILER.." compiler")
 20 | end
 21 | --test compiler present
 22 | local HAVE_COMPILER = false
 23 | 
 24 | local pipe,err = io.popen(CTEST,"r")
 25 | if pipe then
 26 |     local str = pipe:read"*a"
 27 |     print(str)
 28 |     pipe:close()
 29 |     if str=="" then
 30 |         HAVE_COMPILER = false
 31 |     else
 32 |         HAVE_COMPILER = true
 33 |     end
 34 | else
 35 |     HAVE_COMPILER = false
 36 |     print(err)
 37 | end
 38 | assert(HAVE_COMPILER,"gcc, clang or cl needed to run script")
 39 | 
 40 | 
 41 | print("HAVE_COMPILER",HAVE_COMPILER)
 42 | print("COMMENTS_GENERATION",COMMENTS_GENERATION)
 43 | --------------------------------------------------------------------------
 44 | --this table has the functions to be skipped in generation
 45 | --------------------------------------------------------------------------
 46 | local cimgui_manuals = {
 47 |     -- igLogText = true,
 48 |     -- ImGuiTextBuffer_appendf = true,
 49 | }
 50 | --------------------------------------------------------------------------
 51 | --this table is a dictionary to force a naming of function overloading (instead of algorythmic generated)
 52 | --first level is cimguiname without postfix, second level is the signature of the function, value is the
 53 | --desired name
 54 | ---------------------------------------------------------------------------
 55 | local cimgui_overloads = {
 56 |     --igPushID = {
 57 |         --["(const char*)"] =           "igPushIDStr",
 58 |         --["(const char*,const char*)"] = "igPushIDRange",
 59 |         --["(const void*)"] =           "igPushIDPtr",
 60 |         --["(int)"] =                   "igPushIDInt"
 61 |     --},
 62 | }
 63 | 
 64 | --------------------------header definitions
 65 | local cimgui_header = 
 66 | [[//This file is automatically generated by generator.lua from https://github.com/cimgui/cimguizmo
 67 | //based on ImGuizmo.h file version XXX from https://github.com/CedricGuillemet/ImGuizmo
 68 | ]]
 69 | --------------------------------------------------------------------------
 70 | --helper functions
 71 | --------------------------------functions for C generation
 72 | --load parser module
 73 | package.path = package.path..";../../cimgui/generator/?.lua"
 74 | local cpp2ffi = require"cpp2ffi"
 75 | local read_data = cpp2ffi.read_data
 76 | local save_data = cpp2ffi.save_data
 77 | local copyfile = cpp2ffi.copyfile
 78 | local serializeTableF = cpp2ffi.serializeTableF
 79 | 
 80 | local func_header_generate = cpp2ffi.func_header_generate
 81 | local func_implementation = cpp2ffi.func_implementation
 82 | 
 83 | 
 84 | --generate cimgui.cpp cimgui.h 
 85 | local function cimgui_generation(parser,name)
 86 | 
 87 |     local hstrfile = read_data("./"..name.."_template.h")
 88 | 
 89 | 	local outpre,outpost = parser.structs_and_enums[1], parser.structs_and_enums[2]
 90 | 
 91 | 	local cstructsstr = outpre..outpost 
 92 | 
 93 |     hstrfile = hstrfile:gsub([[#include "imgui_structs%.h"]],cstructsstr)
 94 | 	hstrfile = hstrfile:gsub([[PLACE_STRUCTS_C]],parser:gen_structs_c())
 95 |     local cfuncsstr = func_header_generate(parser)
 96 |     hstrfile = hstrfile:gsub([[#include "auto_funcs%.h"]],cfuncsstr)
 97 |     save_data("./output/"..name..".h",cimgui_header,hstrfile)
 98 |     
 99 |     --merge it in cimplot_template.cpp to cimplot.cpp
100 |     local cimplem = func_implementation(parser)
101 | 
102 |     local hstrfile = read_data("./"..name.."_template.cpp")
103 | 
104 |     hstrfile = hstrfile:gsub([[#include "auto_funcs%.cpp"]],cimplem)
105 |     save_data("./output/"..name..".cpp",cimgui_header,hstrfile)
106 | 
107 | end
108 | --------------------------------------------------------
109 | -----------------------------do it----------------------
110 | --------------------------------------------------------
111 | --get implot.h version--------------------------
112 | local pipe,err = io.open("../ImGuizmo/ImGuizmo.h","r")
113 | if not pipe then
114 |     error("could not open file:"..err)
115 | end
116 | local implot_version
117 | while true do
118 |     local line = pipe:read"*l"
119 |     implot_version = line:match([[%s+v(.+)]])
120 |     if implot_version then break end
121 | end
122 | pipe:close()
123 | cimgui_header = cimgui_header:gsub("XXX",implot_version)
124 | print("IMGUIZMO_VERSION",implot_version)
125 | 
126 | 
127 | -------------funtion for parsing implot headers
128 | local function parseImGuiHeader(header,names)
129 | 	--prepare parser
130 | 	local parser = cpp2ffi.Parser()
131 | 	parser.getCname = function(stname,funcname,namespace)
132 | 		--local pre = (stname == "") and "ImPlot_" or stname.."_"
133 | 		local pre = (stname == "") and (namespace and (namespace=="ImGui" and "ig" or namespace.."_") or "ig") or stname.."_"
134 | 		return pre..funcname
135 | 	end
136 | 	parser.cname_overloads = cimgui_overloads
137 | 	parser.manuals = cimgui_manuals
138 | 	parser.UDTs = {"ImVec2","ImVec4","ImColor","ImRect"}--,"ImPlotPoint","ImPlotLimits"}
139 | 	parser.cimgui_inherited =  dofile([[../../cimgui/generator/output/structs_and_enums.lua]])
140 | 	--ParseItems cleaning of c++ attributes
141 | 	parser.str_subst = {["%[%[[^%[%]]+%]%]"] = ""}
142 | 	parser.COMMENTS_GENERATION = COMMENTS_GENERATION
143 | 	local include_cmd = COMPILER=="cl" and [[ /I ]] or [[ -I ]]
144 | 	local extra_includes = include_cmd.." ../../cimgui/imgui "
145 | 
146 | 	parser:take_lines(CPRE..extra_includes..header, names, COMPILER)
147 | 	
148 | 	return parser
149 | end
150 | --generation
151 | print("------------------generation with "..COMPILER.."------------------------")
152 | local modulename = "cimguizmo"
153 | 
154 | local headerst = [[#include "../ImGuizmo/ImGuizmo.h"
155 | ]]
156 | --headerst = headerst .. [[#include "../ImGuizmo/GraphEditor.h"
157 | --]]
158 | save_data("headers.h",headerst)
159 | local parser1 = parseImGuiHeader([[headers.h]],{[[ImGuizmo]],[[GraphEditor]]})
160 | os.remove("headers.h")
161 | 
162 | parser1:do_parse()
163 | 
164 | save_data("./output/overloads.txt",parser1.overloadstxt)
165 | cimgui_generation(parser1,modulename)
166 | save_data("./output/definitions.lua",serializeTableF(parser1.defsT))
167 | local structs_and_enums_table = parser1.structs_and_enums_table
168 | save_data("./output/structs_and_enums.lua",serializeTableF(structs_and_enums_table))
169 | save_data("./output/typedefs_dict.lua",serializeTableF(parser1.typedefs_dict))
170 | 
171 | -------------------------------json saving
172 | --avoid mixed tables (with string and integer keys)
173 | local function json_prepare(defs)
174 |     --delete signatures in function
175 |     for k,def in pairs(defs) do
176 |         for k2,v in pairs(def) do
177 |             if type(k2)=="string" then
178 |                 def[k2] = nil
179 |             end
180 |         end
181 |     end
182 |     return defs
183 | end
184 | ---[[
185 | local json = require"json"
186 | local json_opts = {dict_on_empty={defaults=true}}
187 | save_data("./output/definitions.json",json.encode(json_prepare(parser1.defsT),json_opts))
188 | save_data("./output/structs_and_enums.json",json.encode(structs_and_enums_table))
189 | save_data("./output/typedefs_dict.json",json.encode(parser1.typedefs_dict))
190 | --]]
191 | -------------------copy C files to repo root
192 | copyfile("./output/"..modulename..".h", "../"..modulename..".h")
193 | copyfile("./output/"..modulename..".cpp", "../"..modulename..".cpp")
194 | os.remove("./output/"..modulename..".h")
195 | os.remove("./output/"..modulename..".cpp")
196 | print"all done!!"
197 | 


--------------------------------------------------------------------------------
/generator/output/structs_and_enums.lua:
--------------------------------------------------------------------------------
  1 | local t={
  2 |   enums={
  3 |     COLOR={
  4 |       [1]={
  5 |         calc_value=0,
  6 |         name="DIRECTION_X",
  7 |         value="0"},
  8 |       [2]={
  9 |         calc_value=1,
 10 |         name="DIRECTION_Y",
 11 |         value="1"},
 12 |       [3]={
 13 |         calc_value=2,
 14 |         name="DIRECTION_Z",
 15 |         value="2"},
 16 |       [4]={
 17 |         calc_value=3,
 18 |         name="PLANE_X",
 19 |         value="3"},
 20 |       [5]={
 21 |         calc_value=4,
 22 |         name="PLANE_Y",
 23 |         value="4"},
 24 |       [6]={
 25 |         calc_value=5,
 26 |         name="PLANE_Z",
 27 |         value="5"},
 28 |       [7]={
 29 |         calc_value=6,
 30 |         name="SELECTION",
 31 |         value="6"},
 32 |       [8]={
 33 |         calc_value=7,
 34 |         name="INACTIVE",
 35 |         value="7"},
 36 |       [9]={
 37 |         calc_value=8,
 38 |         name="TRANSLATION_LINE",
 39 |         value="8"},
 40 |       [10]={
 41 |         calc_value=9,
 42 |         name="SCALE_LINE",
 43 |         value="9"},
 44 |       [11]={
 45 |         calc_value=10,
 46 |         name="ROTATION_USING_BORDER",
 47 |         value="10"},
 48 |       [12]={
 49 |         calc_value=11,
 50 |         name="ROTATION_USING_FILL",
 51 |         value="11"},
 52 |       [13]={
 53 |         calc_value=12,
 54 |         name="HATCHED_AXIS_LINES",
 55 |         value="12"},
 56 |       [14]={
 57 |         calc_value=13,
 58 |         name="TEXT",
 59 |         value="13"},
 60 |       [15]={
 61 |         calc_value=14,
 62 |         name="TEXT_SHADOW",
 63 |         value="14"},
 64 |       [16]={
 65 |         calc_value=15,
 66 |         name="COUNT",
 67 |         value="15"}},
 68 |     MODE={
 69 |       [1]={
 70 |         calc_value=0,
 71 |         name="LOCAL",
 72 |         value="0"},
 73 |       [2]={
 74 |         calc_value=1,
 75 |         name="WORLD",
 76 |         value="1"}},
 77 |     OPERATION={
 78 |       [1]={
 79 |         calc_value=1,
 80 |         name="TRANSLATE_X",
 81 |         value="(1u << 0)"},
 82 |       [2]={
 83 |         calc_value=2,
 84 |         name="TRANSLATE_Y",
 85 |         value="(1u << 1)"},
 86 |       [3]={
 87 |         calc_value=4,
 88 |         name="TRANSLATE_Z",
 89 |         value="(1u << 2)"},
 90 |       [4]={
 91 |         calc_value=8,
 92 |         name="ROTATE_X",
 93 |         value="(1u << 3)"},
 94 |       [5]={
 95 |         calc_value=16,
 96 |         name="ROTATE_Y",
 97 |         value="(1u << 4)"},
 98 |       [6]={
 99 |         calc_value=32,
100 |         name="ROTATE_Z",
101 |         value="(1u << 5)"},
102 |       [7]={
103 |         calc_value=64,
104 |         name="ROTATE_SCREEN",
105 |         value="(1u << 6)"},
106 |       [8]={
107 |         calc_value=128,
108 |         name="SCALE_X",
109 |         value="(1u << 7)"},
110 |       [9]={
111 |         calc_value=256,
112 |         name="SCALE_Y",
113 |         value="(1u << 8)"},
114 |       [10]={
115 |         calc_value=512,
116 |         name="SCALE_Z",
117 |         value="(1u << 9)"},
118 |       [11]={
119 |         calc_value=1024,
120 |         name="BOUNDS",
121 |         value="(1u << 10)"},
122 |       [12]={
123 |         calc_value=2048,
124 |         name="SCALE_XU",
125 |         value="(1u << 11)"},
126 |       [13]={
127 |         calc_value=4096,
128 |         name="SCALE_YU",
129 |         value="(1u << 12)"},
130 |       [14]={
131 |         calc_value=8192,
132 |         name="SCALE_ZU",
133 |         value="(1u << 13)"},
134 |       [15]={
135 |         calc_value=7,
136 |         name="TRANSLATE",
137 |         value="TRANSLATE_X | TRANSLATE_Y | TRANSLATE_Z"},
138 |       [16]={
139 |         calc_value=120,
140 |         name="ROTATE",
141 |         value="ROTATE_X | ROTATE_Y | ROTATE_Z | ROTATE_SCREEN"},
142 |       [17]={
143 |         calc_value=896,
144 |         name="SCALE",
145 |         value="SCALE_X | SCALE_Y | SCALE_Z"},
146 |       [18]={
147 |         calc_value=14336,
148 |         name="SCALEU",
149 |         value="SCALE_XU | SCALE_YU | SCALE_ZU"},
150 |       [19]={
151 |         calc_value=14463,
152 |         name="UNIVERSAL",
153 |         value="TRANSLATE | ROTATE | SCALEU"}}},
154 |   enumtypes={},
155 |   locations={
156 |     COLOR="ImGuizmo:269",
157 |     MODE="ImGuizmo:209",
158 |     OPERATION="ImGuizmo:180",
159 |     Style="ImGuizmo:289"},
160 |   nonPOD={
161 |     ImBitArray="inherited",
162 |     ImColor="inherited",
163 |     ImDrawCmd="inherited",
164 |     ImDrawData="inherited",
165 |     ImDrawDataBuilder="inherited",
166 |     ImDrawList="inherited",
167 |     ImDrawListSharedData="inherited",
168 |     ImDrawListSplitter="inherited",
169 |     ImFont="inherited",
170 |     ImFontAtlas="inherited",
171 |     ImFontAtlasBuilder="inherited",
172 |     ImFontAtlasRect="inherited",
173 |     ImFontBaked="inherited",
174 |     ImFontConfig="inherited",
175 |     ImFontGlyph="inherited",
176 |     ImFontGlyphRangesBuilder="inherited",
177 |     ImFontLoader="inherited",
178 |     ImGuiBoxSelectState="inherited",
179 |     ImGuiComboPreviewData="inherited",
180 |     ImGuiContext="inherited",
181 |     ImGuiContextHook="inherited",
182 |     ImGuiDebugAllocInfo="inherited",
183 |     ImGuiDebugItemPathQuery="inherited",
184 |     ImGuiDockContext="inherited",
185 |     ImGuiDockNode="inherited",
186 |     ImGuiErrorRecoveryState="inherited",
187 |     ImGuiIDStackTool="inherited",
188 |     ImGuiIO="inherited",
189 |     ImGuiInputEvent="inherited",
190 |     ImGuiInputTextCallbackData="inherited",
191 |     ImGuiInputTextDeactivatedState="inherited",
192 |     ImGuiInputTextState="inherited",
193 |     ImGuiKeyOwnerData="inherited",
194 |     ImGuiKeyRoutingData="inherited",
195 |     ImGuiKeyRoutingTable="inherited",
196 |     ImGuiLastItemData="inherited",
197 |     ImGuiListClipper="inherited",
198 |     ImGuiListClipperData="inherited",
199 |     ImGuiMenuColumns="inherited",
200 |     ImGuiMultiSelectState="inherited",
201 |     ImGuiMultiSelectTempData="inherited",
202 |     ImGuiNavItemData="inherited",
203 |     ImGuiNextItemData="inherited",
204 |     ImGuiNextWindowData="inherited",
205 |     ImGuiOldColumnData="inherited",
206 |     ImGuiOldColumns="inherited",
207 |     ImGuiOnceUponAFrame="inherited",
208 |     ImGuiPayload="inherited",
209 |     ImGuiPlatformIO="inherited",
210 |     ImGuiPlatformImeData="inherited",
211 |     ImGuiPlatformMonitor="inherited",
212 |     ImGuiPopupData="inherited",
213 |     ImGuiPtrOrIndex="inherited",
214 |     ImGuiSelectionBasicStorage="inherited",
215 |     ImGuiSelectionExternalStorage="inherited",
216 |     ImGuiSettingsHandler="inherited",
217 |     ImGuiStackLevelInfo="inherited",
218 |     ImGuiStoragePair="inherited",
219 |     ImGuiStyle="inherited",
220 |     ImGuiStyleMod="inherited",
221 |     ImGuiTabBar="inherited",
222 |     ImGuiTabItem="inherited",
223 |     ImGuiTable="inherited",
224 |     ImGuiTableColumn="inherited",
225 |     ImGuiTableColumnSettings="inherited",
226 |     ImGuiTableColumnSortSpecs="inherited",
227 |     ImGuiTableInstanceData="inherited",
228 |     ImGuiTableSettings="inherited",
229 |     ImGuiTableSortSpecs="inherited",
230 |     ImGuiTableTempData="inherited",
231 |     ImGuiTextBuffer="inherited",
232 |     ImGuiTextFilter="inherited",
233 |     ImGuiTextRange="inherited",
234 |     ImGuiTypingSelectState="inherited",
235 |     ImGuiViewport="inherited",
236 |     ImGuiViewportP="inherited",
237 |     ImGuiWindow="inherited",
238 |     ImGuiWindowClass="inherited",
239 |     ImGuiWindowSettings="inherited",
240 |     ImPool="inherited",
241 |     ImRect="inherited",
242 |     ImSpan="inherited",
243 |     ImSpanAllocator="inherited",
244 |     ImStableVector="inherited",
245 |     ImTextureData="inherited",
246 |     ImTextureRef="inherited",
247 |     ImVec1="inherited",
248 |     ImVec2="inherited",
249 |     ImVec2i="inherited",
250 |     ImVec2ih="inherited",
251 |     ImVec4="inherited",
252 |     ImVector="inherited",
253 |     Style=true},
254 |   nonPOD_used={
255 |     ImVec2="inherited"},
256 |   structs={
257 |     Style={
258 |       [1]={
259 |         name="TranslationLineThickness",
260 |         type="float"},
261 |       [2]={
262 |         name="TranslationLineArrowSize",
263 |         type="float"},
264 |       [3]={
265 |         name="RotationLineThickness",
266 |         type="float"},
267 |       [4]={
268 |         name="RotationOuterLineThickness",
269 |         type="float"},
270 |       [5]={
271 |         name="ScaleLineThickness",
272 |         type="float"},
273 |       [6]={
274 |         name="ScaleLineCircleSize",
275 |         type="float"},
276 |       [7]={
277 |         name="HatchedAxisLineThickness",
278 |         type="float"},
279 |       [8]={
280 |         name="CenterCircleSize",
281 |         type="float"},
282 |       [9]={
283 |         name="Colors[COUNT]",
284 |         size=15,
285 |         type="ImVec4"}}}}
286 |  return t


--------------------------------------------------------------------------------
/generator/output/structs_and_enums.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "enums": {
  3 |     "COLOR": [
  4 |       {
  5 |         "calc_value": 0,
  6 |         "name": "DIRECTION_X",
  7 |         "value": "0"
  8 |       },
  9 |       {
 10 |         "calc_value": 1,
 11 |         "name": "DIRECTION_Y",
 12 |         "value": "1"
 13 |       },
 14 |       {
 15 |         "calc_value": 2,
 16 |         "name": "DIRECTION_Z",
 17 |         "value": "2"
 18 |       },
 19 |       {
 20 |         "calc_value": 3,
 21 |         "name": "PLANE_X",
 22 |         "value": "3"
 23 |       },
 24 |       {
 25 |         "calc_value": 4,
 26 |         "name": "PLANE_Y",
 27 |         "value": "4"
 28 |       },
 29 |       {
 30 |         "calc_value": 5,
 31 |         "name": "PLANE_Z",
 32 |         "value": "5"
 33 |       },
 34 |       {
 35 |         "calc_value": 6,
 36 |         "name": "SELECTION",
 37 |         "value": "6"
 38 |       },
 39 |       {
 40 |         "calc_value": 7,
 41 |         "name": "INACTIVE",
 42 |         "value": "7"
 43 |       },
 44 |       {
 45 |         "calc_value": 8,
 46 |         "name": "TRANSLATION_LINE",
 47 |         "value": "8"
 48 |       },
 49 |       {
 50 |         "calc_value": 9,
 51 |         "name": "SCALE_LINE",
 52 |         "value": "9"
 53 |       },
 54 |       {
 55 |         "calc_value": 10,
 56 |         "name": "ROTATION_USING_BORDER",
 57 |         "value": "10"
 58 |       },
 59 |       {
 60 |         "calc_value": 11,
 61 |         "name": "ROTATION_USING_FILL",
 62 |         "value": "11"
 63 |       },
 64 |       {
 65 |         "calc_value": 12,
 66 |         "name": "HATCHED_AXIS_LINES",
 67 |         "value": "12"
 68 |       },
 69 |       {
 70 |         "calc_value": 13,
 71 |         "name": "TEXT",
 72 |         "value": "13"
 73 |       },
 74 |       {
 75 |         "calc_value": 14,
 76 |         "name": "TEXT_SHADOW",
 77 |         "value": "14"
 78 |       },
 79 |       {
 80 |         "calc_value": 15,
 81 |         "name": "COUNT",
 82 |         "value": "15"
 83 |       }
 84 |     ],
 85 |     "MODE": [
 86 |       {
 87 |         "calc_value": 0,
 88 |         "name": "LOCAL",
 89 |         "value": "0"
 90 |       },
 91 |       {
 92 |         "calc_value": 1,
 93 |         "name": "WORLD",
 94 |         "value": "1"
 95 |       }
 96 |     ],
 97 |     "OPERATION": [
 98 |       {
 99 |         "calc_value": 1,
100 |         "name": "TRANSLATE_X",
101 |         "value": "(1u << 0)"
102 |       },
103 |       {
104 |         "calc_value": 2,
105 |         "name": "TRANSLATE_Y",
106 |         "value": "(1u << 1)"
107 |       },
108 |       {
109 |         "calc_value": 4,
110 |         "name": "TRANSLATE_Z",
111 |         "value": "(1u << 2)"
112 |       },
113 |       {
114 |         "calc_value": 8,
115 |         "name": "ROTATE_X",
116 |         "value": "(1u << 3)"
117 |       },
118 |       {
119 |         "calc_value": 16,
120 |         "name": "ROTATE_Y",
121 |         "value": "(1u << 4)"
122 |       },
123 |       {
124 |         "calc_value": 32,
125 |         "name": "ROTATE_Z",
126 |         "value": "(1u << 5)"
127 |       },
128 |       {
129 |         "calc_value": 64,
130 |         "name": "ROTATE_SCREEN",
131 |         "value": "(1u << 6)"
132 |       },
133 |       {
134 |         "calc_value": 128,
135 |         "name": "SCALE_X",
136 |         "value": "(1u << 7)"
137 |       },
138 |       {
139 |         "calc_value": 256,
140 |         "name": "SCALE_Y",
141 |         "value": "(1u << 8)"
142 |       },
143 |       {
144 |         "calc_value": 512,
145 |         "name": "SCALE_Z",
146 |         "value": "(1u << 9)"
147 |       },
148 |       {
149 |         "calc_value": 1024,
150 |         "name": "BOUNDS",
151 |         "value": "(1u << 10)"
152 |       },
153 |       {
154 |         "calc_value": 2048,
155 |         "name": "SCALE_XU",
156 |         "value": "(1u << 11)"
157 |       },
158 |       {
159 |         "calc_value": 4096,
160 |         "name": "SCALE_YU",
161 |         "value": "(1u << 12)"
162 |       },
163 |       {
164 |         "calc_value": 8192,
165 |         "name": "SCALE_ZU",
166 |         "value": "(1u << 13)"
167 |       },
168 |       {
169 |         "calc_value": 7,
170 |         "name": "TRANSLATE",
171 |         "value": "TRANSLATE_X | TRANSLATE_Y | TRANSLATE_Z"
172 |       },
173 |       {
174 |         "calc_value": 120,
175 |         "name": "ROTATE",
176 |         "value": "ROTATE_X | ROTATE_Y | ROTATE_Z | ROTATE_SCREEN"
177 |       },
178 |       {
179 |         "calc_value": 896,
180 |         "name": "SCALE",
181 |         "value": "SCALE_X | SCALE_Y | SCALE_Z"
182 |       },
183 |       {
184 |         "calc_value": 14336,
185 |         "name": "SCALEU",
186 |         "value": "SCALE_XU | SCALE_YU | SCALE_ZU"
187 |       },
188 |       {
189 |         "calc_value": 14463,
190 |         "name": "UNIVERSAL",
191 |         "value": "TRANSLATE | ROTATE | SCALEU"
192 |       }
193 |     ]
194 |   },
195 |   "enumtypes": [],
196 |   "locations": {
197 |     "COLOR": "ImGuizmo:269",
198 |     "MODE": "ImGuizmo:209",
199 |     "OPERATION": "ImGuizmo:180",
200 |     "Style": "ImGuizmo:289"
201 |   },
202 |   "nonPOD": {
203 |     "ImBitArray": "inherited",
204 |     "ImColor": "inherited",
205 |     "ImDrawCmd": "inherited",
206 |     "ImDrawData": "inherited",
207 |     "ImDrawDataBuilder": "inherited",
208 |     "ImDrawList": "inherited",
209 |     "ImDrawListSharedData": "inherited",
210 |     "ImDrawListSplitter": "inherited",
211 |     "ImFont": "inherited",
212 |     "ImFontAtlas": "inherited",
213 |     "ImFontAtlasBuilder": "inherited",
214 |     "ImFontAtlasRect": "inherited",
215 |     "ImFontBaked": "inherited",
216 |     "ImFontConfig": "inherited",
217 |     "ImFontGlyph": "inherited",
218 |     "ImFontGlyphRangesBuilder": "inherited",
219 |     "ImFontLoader": "inherited",
220 |     "ImGuiBoxSelectState": "inherited",
221 |     "ImGuiComboPreviewData": "inherited",
222 |     "ImGuiContext": "inherited",
223 |     "ImGuiContextHook": "inherited",
224 |     "ImGuiDebugAllocInfo": "inherited",
225 |     "ImGuiDebugItemPathQuery": "inherited",
226 |     "ImGuiDockContext": "inherited",
227 |     "ImGuiDockNode": "inherited",
228 |     "ImGuiErrorRecoveryState": "inherited",
229 |     "ImGuiIDStackTool": "inherited",
230 |     "ImGuiIO": "inherited",
231 |     "ImGuiInputEvent": "inherited",
232 |     "ImGuiInputTextCallbackData": "inherited",
233 |     "ImGuiInputTextDeactivatedState": "inherited",
234 |     "ImGuiInputTextState": "inherited",
235 |     "ImGuiKeyOwnerData": "inherited",
236 |     "ImGuiKeyRoutingData": "inherited",
237 |     "ImGuiKeyRoutingTable": "inherited",
238 |     "ImGuiLastItemData": "inherited",
239 |     "ImGuiListClipper": "inherited",
240 |     "ImGuiListClipperData": "inherited",
241 |     "ImGuiMenuColumns": "inherited",
242 |     "ImGuiMultiSelectState": "inherited",
243 |     "ImGuiMultiSelectTempData": "inherited",
244 |     "ImGuiNavItemData": "inherited",
245 |     "ImGuiNextItemData": "inherited",
246 |     "ImGuiNextWindowData": "inherited",
247 |     "ImGuiOldColumnData": "inherited",
248 |     "ImGuiOldColumns": "inherited",
249 |     "ImGuiOnceUponAFrame": "inherited",
250 |     "ImGuiPayload": "inherited",
251 |     "ImGuiPlatformIO": "inherited",
252 |     "ImGuiPlatformImeData": "inherited",
253 |     "ImGuiPlatformMonitor": "inherited",
254 |     "ImGuiPopupData": "inherited",
255 |     "ImGuiPtrOrIndex": "inherited",
256 |     "ImGuiSelectionBasicStorage": "inherited",
257 |     "ImGuiSelectionExternalStorage": "inherited",
258 |     "ImGuiSettingsHandler": "inherited",
259 |     "ImGuiStackLevelInfo": "inherited",
260 |     "ImGuiStoragePair": "inherited",
261 |     "ImGuiStyle": "inherited",
262 |     "ImGuiStyleMod": "inherited",
263 |     "ImGuiTabBar": "inherited",
264 |     "ImGuiTabItem": "inherited",
265 |     "ImGuiTable": "inherited",
266 |     "ImGuiTableColumn": "inherited",
267 |     "ImGuiTableColumnSettings": "inherited",
268 |     "ImGuiTableColumnSortSpecs": "inherited",
269 |     "ImGuiTableInstanceData": "inherited",
270 |     "ImGuiTableSettings": "inherited",
271 |     "ImGuiTableSortSpecs": "inherited",
272 |     "ImGuiTableTempData": "inherited",
273 |     "ImGuiTextBuffer": "inherited",
274 |     "ImGuiTextFilter": "inherited",
275 |     "ImGuiTextRange": "inherited",
276 |     "ImGuiTypingSelectState": "inherited",
277 |     "ImGuiViewport": "inherited",
278 |     "ImGuiViewportP": "inherited",
279 |     "ImGuiWindow": "inherited",
280 |     "ImGuiWindowClass": "inherited",
281 |     "ImGuiWindowSettings": "inherited",
282 |     "ImPool": "inherited",
283 |     "ImRect": "inherited",
284 |     "ImSpan": "inherited",
285 |     "ImSpanAllocator": "inherited",
286 |     "ImStableVector": "inherited",
287 |     "ImTextureData": "inherited",
288 |     "ImTextureRef": "inherited",
289 |     "ImVec1": "inherited",
290 |     "ImVec2": "inherited",
291 |     "ImVec2i": "inherited",
292 |     "ImVec2ih": "inherited",
293 |     "ImVec4": "inherited",
294 |     "ImVector": "inherited",
295 |     "Style": true
296 |   },
297 |   "nonPOD_used": {
298 |     "ImVec2": "inherited"
299 |   },
300 |   "structs": {
301 |     "Style": [
302 |       {
303 |         "name": "TranslationLineThickness",
304 |         "type": "float"
305 |       },
306 |       {
307 |         "name": "TranslationLineArrowSize",
308 |         "type": "float"
309 |       },
310 |       {
311 |         "name": "RotationLineThickness",
312 |         "type": "float"
313 |       },
314 |       {
315 |         "name": "RotationOuterLineThickness",
316 |         "type": "float"
317 |       },
318 |       {
319 |         "name": "ScaleLineThickness",
320 |         "type": "float"
321 |       },
322 |       {
323 |         "name": "ScaleLineCircleSize",
324 |         "type": "float"
325 |       },
326 |       {
327 |         "name": "HatchedAxisLineThickness",
328 |         "type": "float"
329 |       },
330 |       {
331 |         "name": "CenterCircleSize",
332 |         "type": "float"
333 |       },
334 |       {
335 |         "name": "Colors[COUNT]",
336 |         "size": 15,
337 |         "type": "ImVec4"
338 |       }
339 |     ]
340 |   }
341 | }


--------------------------------------------------------------------------------
/generator/output/definitions.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "ImGuizmo_AllowAxisFlip": [
  3 |     {
  4 |       "args": "(bool value)",
  5 |       "argsT": [
  6 |         {
  7 |           "name": "value",
  8 |           "type": "bool"
  9 |         }
 10 |       ],
 11 |       "argsoriginal": "(bool value)",
 12 |       "call_args": "(value)",
 13 |       "call_args_old": "(value)",
 14 |       "cimguiname": "ImGuizmo_AllowAxisFlip",
 15 |       "defaults": {},
 16 |       "funcname": "AllowAxisFlip",
 17 |       "location": "ImGuizmo:258",
 18 |       "namespace": "ImGuizmo",
 19 |       "ov_cimguiname": "ImGuizmo_AllowAxisFlip",
 20 |       "ret": "void",
 21 |       "signature": "(bool)",
 22 |       "stname": ""
 23 |     }
 24 |   ],
 25 |   "ImGuizmo_BeginFrame": [
 26 |     {
 27 |       "args": "()",
 28 |       "argsT": [],
 29 |       "argsoriginal": "()",
 30 |       "call_args": "()",
 31 |       "call_args_old": "()",
 32 |       "cimguiname": "ImGuizmo_BeginFrame",
 33 |       "defaults": {},
 34 |       "funcname": "BeginFrame",
 35 |       "location": "ImGuizmo:127",
 36 |       "namespace": "ImGuizmo",
 37 |       "ov_cimguiname": "ImGuizmo_BeginFrame",
 38 |       "ret": "void",
 39 |       "signature": "()",
 40 |       "stname": ""
 41 |     }
 42 |   ],
 43 |   "ImGuizmo_DecomposeMatrixToComponents": [
 44 |     {
 45 |       "args": "(const float* matrix,float* translation,float* rotation,float* scale)",
 46 |       "argsT": [
 47 |         {
 48 |           "name": "matrix",
 49 |           "type": "const float*"
 50 |         },
 51 |         {
 52 |           "name": "translation",
 53 |           "type": "float*"
 54 |         },
 55 |         {
 56 |           "name": "rotation",
 57 |           "type": "float*"
 58 |         },
 59 |         {
 60 |           "name": "scale",
 61 |           "type": "float*"
 62 |         }
 63 |       ],
 64 |       "argsoriginal": "(const float* matrix,float* translation,float* rotation,float* scale)",
 65 |       "call_args": "(matrix,translation,rotation,scale)",
 66 |       "call_args_old": "(matrix,translation,rotation,scale)",
 67 |       "cimguiname": "ImGuizmo_DecomposeMatrixToComponents",
 68 |       "defaults": {},
 69 |       "funcname": "DecomposeMatrixToComponents",
 70 |       "location": "ImGuizmo:165",
 71 |       "namespace": "ImGuizmo",
 72 |       "ov_cimguiname": "ImGuizmo_DecomposeMatrixToComponents",
 73 |       "ret": "void",
 74 |       "signature": "(const float*,float*,float*,float*)",
 75 |       "stname": ""
 76 |     }
 77 |   ],
 78 |   "ImGuizmo_DrawCubes": [
 79 |     {
 80 |       "args": "(const float* view,const float* projection,const float* matrices,int matrixCount)",
 81 |       "argsT": [
 82 |         {
 83 |           "name": "view",
 84 |           "type": "const float*"
 85 |         },
 86 |         {
 87 |           "name": "projection",
 88 |           "type": "const float*"
 89 |         },
 90 |         {
 91 |           "name": "matrices",
 92 |           "type": "const float*"
 93 |         },
 94 |         {
 95 |           "name": "matrixCount",
 96 |           "type": "int"
 97 |         }
 98 |       ],
 99 |       "argsoriginal": "(const float* view,const float* projection,const float* matrices,int matrixCount)",
100 |       "call_args": "(view,projection,matrices,matrixCount)",
101 |       "call_args_old": "(view,projection,matrices,matrixCount)",
102 |       "cimguiname": "ImGuizmo_DrawCubes",
103 |       "defaults": {},
104 |       "funcname": "DrawCubes",
105 |       "location": "ImGuizmo:173",
106 |       "namespace": "ImGuizmo",
107 |       "ov_cimguiname": "ImGuizmo_DrawCubes",
108 |       "ret": "void",
109 |       "signature": "(const float*,const float*,const float*,int)",
110 |       "stname": ""
111 |     }
112 |   ],
113 |   "ImGuizmo_DrawGrid": [
114 |     {
115 |       "args": "(const float* view,const float* projection,const float* matrix,const float gridSize)",
116 |       "argsT": [
117 |         {
118 |           "name": "view",
119 |           "type": "const float*"
120 |         },
121 |         {
122 |           "name": "projection",
123 |           "type": "const float*"
124 |         },
125 |         {
126 |           "name": "matrix",
127 |           "type": "const float*"
128 |         },
129 |         {
130 |           "name": "gridSize",
131 |           "type": "const float"
132 |         }
133 |       ],
134 |       "argsoriginal": "(const float* view,const float* projection,const float* matrix,const float gridSize)",
135 |       "call_args": "(view,projection,matrix,gridSize)",
136 |       "call_args_old": "(view,projection,matrix,gridSize)",
137 |       "cimguiname": "ImGuizmo_DrawGrid",
138 |       "defaults": {},
139 |       "funcname": "DrawGrid",
140 |       "location": "ImGuizmo:174",
141 |       "namespace": "ImGuizmo",
142 |       "ov_cimguiname": "ImGuizmo_DrawGrid",
143 |       "ret": "void",
144 |       "signature": "(const float*,const float*,const float*,const float)",
145 |       "stname": ""
146 |     }
147 |   ],
148 |   "ImGuizmo_Enable": [
149 |     {
150 |       "args": "(bool enable)",
151 |       "argsT": [
152 |         {
153 |           "name": "enable",
154 |           "type": "bool"
155 |         }
156 |       ],
157 |       "argsoriginal": "(bool enable)",
158 |       "call_args": "(enable)",
159 |       "call_args_old": "(enable)",
160 |       "cimguiname": "ImGuizmo_Enable",
161 |       "defaults": {},
162 |       "funcname": "Enable",
163 |       "location": "ImGuizmo:151",
164 |       "namespace": "ImGuizmo",
165 |       "ov_cimguiname": "ImGuizmo_Enable",
166 |       "ret": "void",
167 |       "signature": "(bool)",
168 |       "stname": ""
169 |     }
170 |   ],
171 |   "ImGuizmo_GetID": [
172 |     {
173 |       "args": "(const char* str_id)",
174 |       "argsT": [
175 |         {
176 |           "name": "str_id",
177 |           "type": "const char*"
178 |         }
179 |       ],
180 |       "argsoriginal": "(const char* str_id)",
181 |       "call_args": "(str_id)",
182 |       "call_args_old": "(str_id)",
183 |       "cimguiname": "ImGuizmo_GetID",
184 |       "defaults": {},
185 |       "funcname": "GetID",
186 |       "location": "ImGuizmo:247",
187 |       "namespace": "ImGuizmo",
188 |       "ov_cimguiname": "ImGuizmo_GetID_Str",
189 |       "ret": "ImGuiID",
190 |       "signature": "(const char*)",
191 |       "stname": ""
192 |     },
193 |     {
194 |       "args": "(const char* str_id_begin,const char* str_id_end)",
195 |       "argsT": [
196 |         {
197 |           "name": "str_id_begin",
198 |           "type": "const char*"
199 |         },
200 |         {
201 |           "name": "str_id_end",
202 |           "type": "const char*"
203 |         }
204 |       ],
205 |       "argsoriginal": "(const char* str_id_begin,const char* str_id_end)",
206 |       "call_args": "(str_id_begin,str_id_end)",
207 |       "call_args_old": "(str_id_begin,str_id_end)",
208 |       "cimguiname": "ImGuizmo_GetID",
209 |       "defaults": {},
210 |       "funcname": "GetID",
211 |       "location": "ImGuizmo:248",
212 |       "namespace": "ImGuizmo",
213 |       "ov_cimguiname": "ImGuizmo_GetID_StrStr",
214 |       "ret": "ImGuiID",
215 |       "signature": "(const char*,const char*)",
216 |       "stname": ""
217 |     },
218 |     {
219 |       "args": "(const void* ptr_id)",
220 |       "argsT": [
221 |         {
222 |           "name": "ptr_id",
223 |           "type": "const void*"
224 |         }
225 |       ],
226 |       "argsoriginal": "(const void* ptr_id)",
227 |       "call_args": "(ptr_id)",
228 |       "call_args_old": "(ptr_id)",
229 |       "cimguiname": "ImGuizmo_GetID",
230 |       "defaults": {},
231 |       "funcname": "GetID",
232 |       "location": "ImGuizmo:249",
233 |       "namespace": "ImGuizmo",
234 |       "ov_cimguiname": "ImGuizmo_GetID_Ptr",
235 |       "ret": "ImGuiID",
236 |       "signature": "(const void*)",
237 |       "stname": ""
238 |     }
239 |   ],
240 |   "ImGuizmo_GetStyle": [
241 |     {
242 |       "args": "()",
243 |       "argsT": [],
244 |       "argsoriginal": "()",
245 |       "call_args": "()",
246 |       "call_args_old": "()",
247 |       "cimguiname": "ImGuizmo_GetStyle",
248 |       "defaults": {},
249 |       "funcname": "GetStyle",
250 |       "location": "ImGuizmo:305",
251 |       "namespace": "ImGuizmo",
252 |       "ov_cimguiname": "ImGuizmo_GetStyle",
253 |       "ret": "Style*",
254 |       "retref": "&",
255 |       "signature": "()",
256 |       "stname": ""
257 |     }
258 |   ],
259 |   "ImGuizmo_IsOver": [
260 |     {
261 |       "args": "()",
262 |       "argsT": [],
263 |       "argsoriginal": "()",
264 |       "call_args": "()",
265 |       "call_args_old": "()",
266 |       "cimguiname": "ImGuizmo_IsOver",
267 |       "defaults": {},
268 |       "funcname": "IsOver",
269 |       "location": "ImGuizmo:136",
270 |       "namespace": "ImGuizmo",
271 |       "ov_cimguiname": "ImGuizmo_IsOver_Nil",
272 |       "ret": "bool",
273 |       "signature": "()",
274 |       "stname": ""
275 |     },
276 |     {
277 |       "args": "(OPERATION op)",
278 |       "argsT": [
279 |         {
280 |           "name": "op",
281 |           "type": "OPERATION"
282 |         }
283 |       ],
284 |       "argsoriginal": "(OPERATION op)",
285 |       "call_args": "(op)",
286 |       "call_args_old": "(op)",
287 |       "cimguiname": "ImGuizmo_IsOver",
288 |       "defaults": {},
289 |       "funcname": "IsOver",
290 |       "location": "ImGuizmo:252",
291 |       "namespace": "ImGuizmo",
292 |       "ov_cimguiname": "ImGuizmo_IsOver_OPERATION",
293 |       "ret": "bool",
294 |       "signature": "(OPERATION)",
295 |       "stname": ""
296 |     },
297 |     {
298 |       "args": "(float* position,float pixelRadius)",
299 |       "argsT": [
300 |         {
301 |           "name": "position",
302 |           "type": "float*"
303 |         },
304 |         {
305 |           "name": "pixelRadius",
306 |           "type": "float"
307 |         }
308 |       ],
309 |       "argsoriginal": "(float* position,float pixelRadius)",
310 |       "call_args": "(position,pixelRadius)",
311 |       "call_args_old": "(position,pixelRadius)",
312 |       "cimguiname": "ImGuizmo_IsOver",
313 |       "defaults": {},
314 |       "funcname": "IsOver",
315 |       "location": "ImGuizmo:267",
316 |       "namespace": "ImGuizmo",
317 |       "ov_cimguiname": "ImGuizmo_IsOver_FloatPtr",
318 |       "ret": "bool",
319 |       "signature": "(float*,float)",
320 |       "stname": ""
321 |     }
322 |   ],
323 |   "ImGuizmo_IsUsing": [
324 |     {
325 |       "args": "()",
326 |       "argsT": [],
327 |       "argsoriginal": "()",
328 |       "call_args": "()",
329 |       "call_args_old": "()",
330 |       "cimguiname": "ImGuizmo_IsUsing",
331 |       "defaults": {},
332 |       "funcname": "IsUsing",
333 |       "location": "ImGuizmo:139",
334 |       "namespace": "ImGuizmo",
335 |       "ov_cimguiname": "ImGuizmo_IsUsing",
336 |       "ret": "bool",
337 |       "signature": "()",
338 |       "stname": ""
339 |     }
340 |   ],
341 |   "ImGuizmo_IsUsingAny": [
342 |     {
343 |       "args": "()",
344 |       "argsT": [],
345 |       "argsoriginal": "()",
346 |       "call_args": "()",
347 |       "call_args_old": "()",
348 |       "cimguiname": "ImGuizmo_IsUsingAny",
349 |       "defaults": {},
350 |       "funcname": "IsUsingAny",
351 |       "location": "ImGuizmo:147",
352 |       "namespace": "ImGuizmo",
353 |       "ov_cimguiname": "ImGuizmo_IsUsingAny",
354 |       "ret": "bool",
355 |       "signature": "()",
356 |       "stname": ""
357 |     }
358 |   ],
359 |   "ImGuizmo_IsUsingViewManipulate": [
360 |     {
361 |       "args": "()",
362 |       "argsT": [],
363 |       "argsoriginal": "()",
364 |       "call_args": "()",
365 |       "call_args_old": "()",
366 |       "cimguiname": "ImGuizmo_IsUsingViewManipulate",
367 |       "defaults": {},
368 |       "funcname": "IsUsingViewManipulate",
369 |       "location": "ImGuizmo:142",
370 |       "namespace": "ImGuizmo",
371 |       "ov_cimguiname": "ImGuizmo_IsUsingViewManipulate",
372 |       "ret": "bool",
373 |       "signature": "()",
374 |       "stname": ""
375 |     }
376 |   ],
377 |   "ImGuizmo_IsViewManipulateHovered": [
378 |     {
379 |       "args": "()",
380 |       "argsT": [],
381 |       "argsoriginal": "()",
382 |       "call_args": "()",
383 |       "call_args_old": "()",
384 |       "cimguiname": "ImGuizmo_IsViewManipulateHovered",
385 |       "defaults": {},
386 |       "funcname": "IsViewManipulateHovered",
387 |       "location": "ImGuizmo:144",
388 |       "namespace": "ImGuizmo",
389 |       "ov_cimguiname": "ImGuizmo_IsViewManipulateHovered",
390 |       "ret": "bool",
391 |       "signature": "()",
392 |       "stname": ""
393 |     }
394 |   ],
395 |   "ImGuizmo_Manipulate": [
396 |     {
397 |       "args": "(const float* view,const float* projection,OPERATION operation,MODE mode,float* matrix,float* deltaMatrix,const float* snap,const float* localBounds,const float* boundsSnap)",
398 |       "argsT": [
399 |         {
400 |           "name": "view",
401 |           "type": "const float*"
402 |         },
403 |         {
404 |           "name": "projection",
405 |           "type": "const float*"
406 |         },
407 |         {
408 |           "name": "operation",
409 |           "type": "OPERATION"
410 |         },
411 |         {
412 |           "name": "mode",
413 |           "type": "MODE"
414 |         },
415 |         {
416 |           "name": "matrix",
417 |           "type": "float*"
418 |         },
419 |         {
420 |           "name": "deltaMatrix",
421 |           "type": "float*"
422 |         },
423 |         {
424 |           "name": "snap",
425 |           "type": "const float*"
426 |         },
427 |         {
428 |           "name": "localBounds",
429 |           "type": "const float*"
430 |         },
431 |         {
432 |           "name": "boundsSnap",
433 |           "type": "const float*"
434 |         }
435 |       ],
436 |       "argsoriginal": "(const float* view,const float* projection,OPERATION operation,MODE mode,float* matrix,float* deltaMatrix=NULL,const float* snap=NULL,const float* localBounds=NULL,const float* boundsSnap=NULL)",
437 |       "call_args": "(view,projection,operation,mode,matrix,deltaMatrix,snap,localBounds,boundsSnap)",
438 |       "call_args_old": "(view,projection,operation,mode,matrix,deltaMatrix,snap,localBounds,boundsSnap)",
439 |       "cimguiname": "ImGuizmo_Manipulate",
440 |       "defaults": {
441 |         "boundsSnap": "NULL",
442 |         "deltaMatrix": "NULL",
443 |         "localBounds": "NULL",
444 |         "snap": "NULL"
445 |       },
446 |       "funcname": "Manipulate",
447 |       "location": "ImGuizmo:215",
448 |       "namespace": "ImGuizmo",
449 |       "ov_cimguiname": "ImGuizmo_Manipulate",
450 |       "ret": "bool",
451 |       "signature": "(const float*,const float*,OPERATION,MODE,float*,float*,const float*,const float*,const float*)",
452 |       "stname": ""
453 |     }
454 |   ],
455 |   "ImGuizmo_PopID": [
456 |     {
457 |       "args": "()",
458 |       "argsT": [],
459 |       "argsoriginal": "()",
460 |       "call_args": "()",
461 |       "call_args_old": "()",
462 |       "cimguiname": "ImGuizmo_PopID",
463 |       "defaults": {},
464 |       "funcname": "PopID",
465 |       "location": "ImGuizmo:246",
466 |       "namespace": "ImGuizmo",
467 |       "ov_cimguiname": "ImGuizmo_PopID",
468 |       "ret": "void",
469 |       "signature": "()",
470 |       "stname": ""
471 |     }
472 |   ],
473 |   "ImGuizmo_PushID": [
474 |     {
475 |       "args": "(const char* str_id)",
476 |       "argsT": [
477 |         {
478 |           "name": "str_id",
479 |           "type": "const char*"
480 |         }
481 |       ],
482 |       "argsoriginal": "(const char* str_id)",
483 |       "call_args": "(str_id)",
484 |       "call_args_old": "(str_id)",
485 |       "cimguiname": "ImGuizmo_PushID",
486 |       "defaults": {},
487 |       "funcname": "PushID",
488 |       "location": "ImGuizmo:242",
489 |       "namespace": "ImGuizmo",
490 |       "ov_cimguiname": "ImGuizmo_PushID_Str",
491 |       "ret": "void",
492 |       "signature": "(const char*)",
493 |       "stname": ""
494 |     },
495 |     {
496 |       "args": "(const char* str_id_begin,const char* str_id_end)",
497 |       "argsT": [
498 |         {
499 |           "name": "str_id_begin",
500 |           "type": "const char*"
501 |         },
502 |         {
503 |           "name": "str_id_end",
504 |           "type": "const char*"
505 |         }
506 |       ],
507 |       "argsoriginal": "(const char* str_id_begin,const char* str_id_end)",
508 |       "call_args": "(str_id_begin,str_id_end)",
509 |       "call_args_old": "(str_id_begin,str_id_end)",
510 |       "cimguiname": "ImGuizmo_PushID",
511 |       "defaults": {},
512 |       "funcname": "PushID",
513 |       "location": "ImGuizmo:243",
514 |       "namespace": "ImGuizmo",
515 |       "ov_cimguiname": "ImGuizmo_PushID_StrStr",
516 |       "ret": "void",
517 |       "signature": "(const char*,const char*)",
518 |       "stname": ""
519 |     },
520 |     {
521 |       "args": "(const void* ptr_id)",
522 |       "argsT": [
523 |         {
524 |           "name": "ptr_id",
525 |           "type": "const void*"
526 |         }
527 |       ],
528 |       "argsoriginal": "(const void* ptr_id)",
529 |       "call_args": "(ptr_id)",
530 |       "call_args_old": "(ptr_id)",
531 |       "cimguiname": "ImGuizmo_PushID",
532 |       "defaults": {},
533 |       "funcname": "PushID",
534 |       "location": "ImGuizmo:244",
535 |       "namespace": "ImGuizmo",
536 |       "ov_cimguiname": "ImGuizmo_PushID_Ptr",
537 |       "ret": "void",
538 |       "signature": "(const void*)",
539 |       "stname": ""
540 |     },
541 |     {
542 |       "args": "(int int_id)",
543 |       "argsT": [
544 |         {
545 |           "name": "int_id",
546 |           "type": "int"
547 |         }
548 |       ],
549 |       "argsoriginal": "(int int_id)",
550 |       "call_args": "(int_id)",
551 |       "call_args_old": "(int_id)",
552 |       "cimguiname": "ImGuizmo_PushID",
553 |       "defaults": {},
554 |       "funcname": "PushID",
555 |       "location": "ImGuizmo:245",
556 |       "namespace": "ImGuizmo",
557 |       "ov_cimguiname": "ImGuizmo_PushID_Int",
558 |       "ret": "void",
559 |       "signature": "(int)",
560 |       "stname": ""
561 |     }
562 |   ],
563 |   "ImGuizmo_RecomposeMatrixFromComponents": [
564 |     {
565 |       "args": "(const float* translation,const float* rotation,const float* scale,float* matrix)",
566 |       "argsT": [
567 |         {
568 |           "name": "translation",
569 |           "type": "const float*"
570 |         },
571 |         {
572 |           "name": "rotation",
573 |           "type": "const float*"
574 |         },
575 |         {
576 |           "name": "scale",
577 |           "type": "const float*"
578 |         },
579 |         {
580 |           "name": "matrix",
581 |           "type": "float*"
582 |         }
583 |       ],
584 |       "argsoriginal": "(const float* translation,const float* rotation,const float* scale,float* matrix)",
585 |       "call_args": "(translation,rotation,scale,matrix)",
586 |       "call_args_old": "(translation,rotation,scale,matrix)",
587 |       "cimguiname": "ImGuizmo_RecomposeMatrixFromComponents",
588 |       "defaults": {},
589 |       "funcname": "RecomposeMatrixFromComponents",
590 |       "location": "ImGuizmo:166",
591 |       "namespace": "ImGuizmo",
592 |       "ov_cimguiname": "ImGuizmo_RecomposeMatrixFromComponents",
593 |       "ret": "void",
594 |       "signature": "(const float*,const float*,const float*,float*)",
595 |       "stname": ""
596 |     }
597 |   ],
598 |   "ImGuizmo_SetAlternativeWindow": [
599 |     {
600 |       "args": "(ImGuiWindow* window)",
601 |       "argsT": [
602 |         {
603 |           "name": "window",
604 |           "type": "ImGuiWindow*"
605 |         }
606 |       ],
607 |       "argsoriginal": "(ImGuiWindow* window)",
608 |       "call_args": "(window)",
609 |       "call_args_old": "(window)",
610 |       "cimguiname": "ImGuizmo_SetAlternativeWindow",
611 |       "defaults": {},
612 |       "funcname": "SetAlternativeWindow",
613 |       "location": "ImGuizmo:226",
614 |       "namespace": "ImGuizmo",
615 |       "ov_cimguiname": "ImGuizmo_SetAlternativeWindow",
616 |       "ret": "void",
617 |       "signature": "(ImGuiWindow*)",
618 |       "stname": ""
619 |     }
620 |   ],
621 |   "ImGuizmo_SetAxisLimit": [
622 |     {
623 |       "args": "(float value)",
624 |       "argsT": [
625 |         {
626 |           "name": "value",
627 |           "type": "float"
628 |         }
629 |       ],
630 |       "argsoriginal": "(float value)",
631 |       "call_args": "(value)",
632 |       "call_args_old": "(value)",
633 |       "cimguiname": "ImGuizmo_SetAxisLimit",
634 |       "defaults": {},
635 |       "funcname": "SetAxisLimit",
636 |       "location": "ImGuizmo:261",
637 |       "namespace": "ImGuizmo",
638 |       "ov_cimguiname": "ImGuizmo_SetAxisLimit",
639 |       "ret": "void",
640 |       "signature": "(float)",
641 |       "stname": ""
642 |     }
643 |   ],
644 |   "ImGuizmo_SetAxisMask": [
645 |     {
646 |       "args": "(bool x,bool y,bool z)",
647 |       "argsT": [
648 |         {
649 |           "name": "x",
650 |           "type": "bool"
651 |         },
652 |         {
653 |           "name": "y",
654 |           "type": "bool"
655 |         },
656 |         {
657 |           "name": "z",
658 |           "type": "bool"
659 |         }
660 |       ],
661 |       "argsoriginal": "(bool x,bool y,bool z)",
662 |       "call_args": "(x,y,z)",
663 |       "call_args_old": "(x,y,z)",
664 |       "cimguiname": "ImGuizmo_SetAxisMask",
665 |       "defaults": {},
666 |       "funcname": "SetAxisMask",
667 |       "location": "ImGuizmo:263",
668 |       "namespace": "ImGuizmo",
669 |       "ov_cimguiname": "ImGuizmo_SetAxisMask",
670 |       "ret": "void",
671 |       "signature": "(bool,bool,bool)",
672 |       "stname": ""
673 |     }
674 |   ],
675 |   "ImGuizmo_SetDrawlist": [
676 |     {
677 |       "args": "(ImDrawList* drawlist)",
678 |       "argsT": [
679 |         {
680 |           "name": "drawlist",
681 |           "type": "ImDrawList*"
682 |         }
683 |       ],
684 |       "argsoriginal": "(ImDrawList* drawlist=nullptr)",
685 |       "call_args": "(drawlist)",
686 |       "call_args_old": "(drawlist)",
687 |       "cimguiname": "ImGuizmo_SetDrawlist",
688 |       "defaults": {
689 |         "drawlist": "nullptr"
690 |       },
691 |       "funcname": "SetDrawlist",
692 |       "location": "ImGuizmo:124",
693 |       "namespace": "ImGuizmo",
694 |       "ov_cimguiname": "ImGuizmo_SetDrawlist",
695 |       "ret": "void",
696 |       "signature": "(ImDrawList*)",
697 |       "stname": ""
698 |     }
699 |   ],
700 |   "ImGuizmo_SetGizmoSizeClipSpace": [
701 |     {
702 |       "args": "(float value)",
703 |       "argsT": [
704 |         {
705 |           "name": "value",
706 |           "type": "float"
707 |         }
708 |       ],
709 |       "argsoriginal": "(float value)",
710 |       "call_args": "(value)",
711 |       "call_args_old": "(value)",
712 |       "cimguiname": "ImGuizmo_SetGizmoSizeClipSpace",
713 |       "defaults": {},
714 |       "funcname": "SetGizmoSizeClipSpace",
715 |       "location": "ImGuizmo:253",
716 |       "namespace": "ImGuizmo",
717 |       "ov_cimguiname": "ImGuizmo_SetGizmoSizeClipSpace",
718 |       "ret": "void",
719 |       "signature": "(float)",
720 |       "stname": ""
721 |     }
722 |   ],
723 |   "ImGuizmo_SetID": [
724 |     {
725 |       "args": "(int id)",
726 |       "argsT": [
727 |         {
728 |           "name": "id",
729 |           "type": "int"
730 |         }
731 |       ],
732 |       "argsoriginal": "(int id)",
733 |       "call_args": "(id)",
734 |       "call_args_old": "(id)",
735 |       "cimguiname": "ImGuizmo_SetID",
736 |       "defaults": {},
737 |       "funcname": "SetID",
738 |       "location": "ImGuizmo:229",
739 |       "namespace": "ImGuizmo",
740 |       "ov_cimguiname": "ImGuizmo_SetID",
741 |       "ret": "void",
742 |       "signature": "(int)",
743 |       "stname": ""
744 |     }
745 |   ],
746 |   "ImGuizmo_SetImGuiContext": [
747 |     {
748 |       "args": "(ImGuiContext* ctx)",
749 |       "argsT": [
750 |         {
751 |           "name": "ctx",
752 |           "type": "ImGuiContext*"
753 |         }
754 |       ],
755 |       "argsoriginal": "(ImGuiContext* ctx)",
756 |       "call_args": "(ctx)",
757 |       "call_args_old": "(ctx)",
758 |       "cimguiname": "ImGuizmo_SetImGuiContext",
759 |       "defaults": {},
760 |       "funcname": "SetImGuiContext",
761 |       "location": "ImGuizmo:133",
762 |       "namespace": "ImGuizmo",
763 |       "ov_cimguiname": "ImGuizmo_SetImGuiContext",
764 |       "ret": "void",
765 |       "signature": "(ImGuiContext*)",
766 |       "stname": ""
767 |     }
768 |   ],
769 |   "ImGuizmo_SetOrthographic": [
770 |     {
771 |       "args": "(bool isOrthographic)",
772 |       "argsT": [
773 |         {
774 |           "name": "isOrthographic",
775 |           "type": "bool"
776 |         }
777 |       ],
778 |       "argsoriginal": "(bool isOrthographic)",
779 |       "call_args": "(isOrthographic)",
780 |       "call_args_old": "(isOrthographic)",
781 |       "cimguiname": "ImGuizmo_SetOrthographic",
782 |       "defaults": {},
783 |       "funcname": "SetOrthographic",
784 |       "location": "ImGuizmo:170",
785 |       "namespace": "ImGuizmo",
786 |       "ov_cimguiname": "ImGuizmo_SetOrthographic",
787 |       "ret": "void",
788 |       "signature": "(bool)",
789 |       "stname": ""
790 |     }
791 |   ],
792 |   "ImGuizmo_SetPlaneLimit": [
793 |     {
794 |       "args": "(float value)",
795 |       "argsT": [
796 |         {
797 |           "name": "value",
798 |           "type": "float"
799 |         }
800 |       ],
801 |       "argsoriginal": "(float value)",
802 |       "call_args": "(value)",
803 |       "call_args_old": "(value)",
804 |       "cimguiname": "ImGuizmo_SetPlaneLimit",
805 |       "defaults": {},
806 |       "funcname": "SetPlaneLimit",
807 |       "location": "ImGuizmo:265",
808 |       "namespace": "ImGuizmo",
809 |       "ov_cimguiname": "ImGuizmo_SetPlaneLimit",
810 |       "ret": "void",
811 |       "signature": "(float)",
812 |       "stname": ""
813 |     }
814 |   ],
815 |   "ImGuizmo_SetRect": [
816 |     {
817 |       "args": "(float x,float y,float width,float height)",
818 |       "argsT": [
819 |         {
820 |           "name": "x",
821 |           "type": "float"
822 |         },
823 |         {
824 |           "name": "y",
825 |           "type": "float"
826 |         },
827 |         {
828 |           "name": "width",
829 |           "type": "float"
830 |         },
831 |         {
832 |           "name": "height",
833 |           "type": "float"
834 |         }
835 |       ],
836 |       "argsoriginal": "(float x,float y,float width,float height)",
837 |       "call_args": "(x,y,width,height)",
838 |       "call_args_old": "(x,y,width,height)",
839 |       "cimguiname": "ImGuizmo_SetRect",
840 |       "defaults": {},
841 |       "funcname": "SetRect",
842 |       "location": "ImGuizmo:168",
843 |       "namespace": "ImGuizmo",
844 |       "ov_cimguiname": "ImGuizmo_SetRect",
845 |       "ret": "void",
846 |       "signature": "(float,float,float,float)",
847 |       "stname": ""
848 |     }
849 |   ],
850 |   "ImGuizmo_ViewManipulate": [
851 |     {
852 |       "args": "(float* view,float length,ImVec2_c position,ImVec2_c size,ImU32 backgroundColor)",
853 |       "argsT": [
854 |         {
855 |           "name": "view",
856 |           "type": "float*"
857 |         },
858 |         {
859 |           "name": "length",
860 |           "type": "float"
861 |         },
862 |         {
863 |           "name": "position",
864 |           "type": "ImVec2"
865 |         },
866 |         {
867 |           "name": "size",
868 |           "type": "ImVec2"
869 |         },
870 |         {
871 |           "name": "backgroundColor",
872 |           "type": "ImU32"
873 |         }
874 |       ],
875 |       "argsoriginal": "(float* view,float length,ImVec2 position,ImVec2 size,ImU32 backgroundColor)",
876 |       "call_args": "(view,length,ConvertToCPP_ImVec2(position),ConvertToCPP_ImVec2(size),backgroundColor)",
877 |       "call_args_old": "(view,length,position,size,backgroundColor)",
878 |       "cimguiname": "ImGuizmo_ViewManipulate",
879 |       "defaults": {},
880 |       "funcname": "ViewManipulate",
881 |       "location": "ImGuizmo:221",
882 |       "namespace": "ImGuizmo",
883 |       "ov_cimguiname": "ImGuizmo_ViewManipulate_Float",
884 |       "ret": "void",
885 |       "signature": "(float*,float,ImVec2,ImVec2,ImU32)",
886 |       "stname": ""
887 |     },
888 |     {
889 |       "args": "(float* view,const float* projection,OPERATION operation,MODE mode,float* matrix,float length,ImVec2_c position,ImVec2_c size,ImU32 backgroundColor)",
890 |       "argsT": [
891 |         {
892 |           "name": "view",
893 |           "type": "float*"
894 |         },
895 |         {
896 |           "name": "projection",
897 |           "type": "const float*"
898 |         },
899 |         {
900 |           "name": "operation",
901 |           "type": "OPERATION"
902 |         },
903 |         {
904 |           "name": "mode",
905 |           "type": "MODE"
906 |         },
907 |         {
908 |           "name": "matrix",
909 |           "type": "float*"
910 |         },
911 |         {
912 |           "name": "length",
913 |           "type": "float"
914 |         },
915 |         {
916 |           "name": "position",
917 |           "type": "ImVec2"
918 |         },
919 |         {
920 |           "name": "size",
921 |           "type": "ImVec2"
922 |         },
923 |         {
924 |           "name": "backgroundColor",
925 |           "type": "ImU32"
926 |         }
927 |       ],
928 |       "argsoriginal": "(float* view,const float* projection,OPERATION operation,MODE mode,float* matrix,float length,ImVec2 position,ImVec2 size,ImU32 backgroundColor)",
929 |       "call_args": "(view,projection,operation,mode,matrix,length,ConvertToCPP_ImVec2(position),ConvertToCPP_ImVec2(size),backgroundColor)",
930 |       "call_args_old": "(view,projection,operation,mode,matrix,length,position,size,backgroundColor)",
931 |       "cimguiname": "ImGuizmo_ViewManipulate",
932 |       "defaults": {},
933 |       "funcname": "ViewManipulate",
934 |       "location": "ImGuizmo:224",
935 |       "namespace": "ImGuizmo",
936 |       "ov_cimguiname": "ImGuizmo_ViewManipulate_FloatPtr",
937 |       "ret": "void",
938 |       "signature": "(float*,const float*,OPERATION,MODE,float*,float,ImVec2,ImVec2,ImU32)",
939 |       "stname": ""
940 |     }
941 |   ],
942 |   "Style_Style": [
943 |     {
944 |       "args": "()",
945 |       "argsT": [],
946 |       "argsoriginal": "()",
947 |       "call_args": "()",
948 |       "call_args_old": "()",
949 |       "cimguiname": "Style_Style",
950 |       "constructor": true,
951 |       "defaults": {},
952 |       "funcname": "Style",
953 |       "location": "ImGuizmo:291",
954 |       "ov_cimguiname": "Style_Style",
955 |       "signature": "()",
956 |       "stname": "Style"
957 |     }
958 |   ],
959 |   "Style_destroy": [
960 |     {
961 |       "args": "(Style* self)",
962 |       "argsT": [
963 |         {
964 |           "name": "self",
965 |           "type": "Style*"
966 |         }
967 |       ],
968 |       "call_args": "(self)",
969 |       "cimguiname": "Style_destroy",
970 |       "defaults": {},
971 |       "destructor": true,
972 |       "location": "ImGuizmo:291",
973 |       "ov_cimguiname": "Style_destroy",
974 |       "ret": "void",
975 |       "signature": "(Style*)",
976 |       "stname": "Style"
977 |     }
978 |   ]
979 | }


--------------------------------------------------------------------------------
/generator/output/definitions.lua:
--------------------------------------------------------------------------------
  1 | local t={
  2 |   ImGuizmo_AllowAxisFlip={
  3 |     [1]={
  4 |       args="(bool value)",
  5 |       argsT={
  6 |         [1]={
  7 |           name="value",
  8 |           type="bool"}},
  9 |       argsoriginal="(bool value)",
 10 |       call_args="(value)",
 11 |       call_args_old="(value)",
 12 |       cimguiname="ImGuizmo_AllowAxisFlip",
 13 |       defaults={},
 14 |       funcname="AllowAxisFlip",
 15 |       location="ImGuizmo:258",
 16 |       namespace="ImGuizmo",
 17 |       ov_cimguiname="ImGuizmo_AllowAxisFlip",
 18 |       ret="void",
 19 |       signature="(bool)",
 20 |       stname=""},
 21 |     ["(bool)"]=nil},
 22 |   ImGuizmo_BeginFrame={
 23 |     [1]={
 24 |       args="()",
 25 |       argsT={},
 26 |       argsoriginal="()",
 27 |       call_args="()",
 28 |       call_args_old="()",
 29 |       cimguiname="ImGuizmo_BeginFrame",
 30 |       defaults={},
 31 |       funcname="BeginFrame",
 32 |       location="ImGuizmo:127",
 33 |       namespace="ImGuizmo",
 34 |       ov_cimguiname="ImGuizmo_BeginFrame",
 35 |       ret="void",
 36 |       signature="()",
 37 |       stname=""},
 38 |     ["()"]=nil},
 39 |   ImGuizmo_DecomposeMatrixToComponents={
 40 |     [1]={
 41 |       args="(const float* matrix,float* translation,float* rotation,float* scale)",
 42 |       argsT={
 43 |         [1]={
 44 |           name="matrix",
 45 |           type="const float*"},
 46 |         [2]={
 47 |           name="translation",
 48 |           type="float*"},
 49 |         [3]={
 50 |           name="rotation",
 51 |           type="float*"},
 52 |         [4]={
 53 |           name="scale",
 54 |           type="float*"}},
 55 |       argsoriginal="(const float* matrix,float* translation,float* rotation,float* scale)",
 56 |       call_args="(matrix,translation,rotation,scale)",
 57 |       call_args_old="(matrix,translation,rotation,scale)",
 58 |       cimguiname="ImGuizmo_DecomposeMatrixToComponents",
 59 |       defaults={},
 60 |       funcname="DecomposeMatrixToComponents",
 61 |       location="ImGuizmo:165",
 62 |       namespace="ImGuizmo",
 63 |       ov_cimguiname="ImGuizmo_DecomposeMatrixToComponents",
 64 |       ret="void",
 65 |       signature="(const float*,float*,float*,float*)",
 66 |       stname=""},
 67 |     ["(const float*,float*,float*,float*)"]=nil},
 68 |   ImGuizmo_DrawCubes={
 69 |     [1]={
 70 |       args="(const float* view,const float* projection,const float* matrices,int matrixCount)",
 71 |       argsT={
 72 |         [1]={
 73 |           name="view",
 74 |           type="const float*"},
 75 |         [2]={
 76 |           name="projection",
 77 |           type="const float*"},
 78 |         [3]={
 79 |           name="matrices",
 80 |           type="const float*"},
 81 |         [4]={
 82 |           name="matrixCount",
 83 |           type="int"}},
 84 |       argsoriginal="(const float* view,const float* projection,const float* matrices,int matrixCount)",
 85 |       call_args="(view,projection,matrices,matrixCount)",
 86 |       call_args_old="(view,projection,matrices,matrixCount)",
 87 |       cimguiname="ImGuizmo_DrawCubes",
 88 |       defaults={},
 89 |       funcname="DrawCubes",
 90 |       location="ImGuizmo:173",
 91 |       namespace="ImGuizmo",
 92 |       ov_cimguiname="ImGuizmo_DrawCubes",
 93 |       ret="void",
 94 |       signature="(const float*,const float*,const float*,int)",
 95 |       stname=""},
 96 |     ["(const float*,const float*,const float*,int)"]=nil},
 97 |   ImGuizmo_DrawGrid={
 98 |     [1]={
 99 |       args="(const float* view,const float* projection,const float* matrix,const float gridSize)",
100 |       argsT={
101 |         [1]={
102 |           name="view",
103 |           type="const float*"},
104 |         [2]={
105 |           name="projection",
106 |           type="const float*"},
107 |         [3]={
108 |           name="matrix",
109 |           type="const float*"},
110 |         [4]={
111 |           name="gridSize",
112 |           type="const float"}},
113 |       argsoriginal="(const float* view,const float* projection,const float* matrix,const float gridSize)",
114 |       call_args="(view,projection,matrix,gridSize)",
115 |       call_args_old="(view,projection,matrix,gridSize)",
116 |       cimguiname="ImGuizmo_DrawGrid",
117 |       defaults={},
118 |       funcname="DrawGrid",
119 |       location="ImGuizmo:174",
120 |       namespace="ImGuizmo",
121 |       ov_cimguiname="ImGuizmo_DrawGrid",
122 |       ret="void",
123 |       signature="(const float*,const float*,const float*,const float)",
124 |       stname=""},
125 |     ["(const float*,const float*,const float*,const float)"]=nil},
126 |   ImGuizmo_Enable={
127 |     [1]={
128 |       args="(bool enable)",
129 |       argsT={
130 |         [1]={
131 |           name="enable",
132 |           type="bool"}},
133 |       argsoriginal="(bool enable)",
134 |       call_args="(enable)",
135 |       call_args_old="(enable)",
136 |       cimguiname="ImGuizmo_Enable",
137 |       defaults={},
138 |       funcname="Enable",
139 |       location="ImGuizmo:151",
140 |       namespace="ImGuizmo",
141 |       ov_cimguiname="ImGuizmo_Enable",
142 |       ret="void",
143 |       signature="(bool)",
144 |       stname=""},
145 |     ["(bool)"]=nil},
146 |   ImGuizmo_GetID={
147 |     [1]={
148 |       args="(const char* str_id)",
149 |       argsT={
150 |         [1]={
151 |           name="str_id",
152 |           type="const char*"}},
153 |       argsoriginal="(const char* str_id)",
154 |       call_args="(str_id)",
155 |       call_args_old="(str_id)",
156 |       cimguiname="ImGuizmo_GetID",
157 |       defaults={},
158 |       funcname="GetID",
159 |       location="ImGuizmo:247",
160 |       namespace="ImGuizmo",
161 |       ov_cimguiname="ImGuizmo_GetID_Str",
162 |       ret="ImGuiID",
163 |       signature="(const char*)",
164 |       stname=""},
165 |     [2]={
166 |       args="(const char* str_id_begin,const char* str_id_end)",
167 |       argsT={
168 |         [1]={
169 |           name="str_id_begin",
170 |           type="const char*"},
171 |         [2]={
172 |           name="str_id_end",
173 |           type="const char*"}},
174 |       argsoriginal="(const char* str_id_begin,const char* str_id_end)",
175 |       call_args="(str_id_begin,str_id_end)",
176 |       call_args_old="(str_id_begin,str_id_end)",
177 |       cimguiname="ImGuizmo_GetID",
178 |       defaults={},
179 |       funcname="GetID",
180 |       location="ImGuizmo:248",
181 |       namespace="ImGuizmo",
182 |       ov_cimguiname="ImGuizmo_GetID_StrStr",
183 |       ret="ImGuiID",
184 |       signature="(const char*,const char*)",
185 |       stname=""},
186 |     [3]={
187 |       args="(const void* ptr_id)",
188 |       argsT={
189 |         [1]={
190 |           name="ptr_id",
191 |           type="const void*"}},
192 |       argsoriginal="(const void* ptr_id)",
193 |       call_args="(ptr_id)",
194 |       call_args_old="(ptr_id)",
195 |       cimguiname="ImGuizmo_GetID",
196 |       defaults={},
197 |       funcname="GetID",
198 |       location="ImGuizmo:249",
199 |       namespace="ImGuizmo",
200 |       ov_cimguiname="ImGuizmo_GetID_Ptr",
201 |       ret="ImGuiID",
202 |       signature="(const void*)",
203 |       stname=""},
204 |     ["(const char*)"]=nil,
205 |     ["(const char*,const char*)"]=nil,
206 |     ["(const void*)"]=nil},
207 |   ImGuizmo_GetStyle={
208 |     [1]={
209 |       args="()",
210 |       argsT={},
211 |       argsoriginal="()",
212 |       call_args="()",
213 |       call_args_old="()",
214 |       cimguiname="ImGuizmo_GetStyle",
215 |       defaults={},
216 |       funcname="GetStyle",
217 |       location="ImGuizmo:305",
218 |       namespace="ImGuizmo",
219 |       ov_cimguiname="ImGuizmo_GetStyle",
220 |       ret="Style*",
221 |       retref="&",
222 |       signature="()",
223 |       stname=""},
224 |     ["()"]=nil},
225 |   ImGuizmo_IsOver={
226 |     [1]={
227 |       args="()",
228 |       argsT={},
229 |       argsoriginal="()",
230 |       call_args="()",
231 |       call_args_old="()",
232 |       cimguiname="ImGuizmo_IsOver",
233 |       defaults={},
234 |       funcname="IsOver",
235 |       location="ImGuizmo:136",
236 |       namespace="ImGuizmo",
237 |       ov_cimguiname="ImGuizmo_IsOver_Nil",
238 |       ret="bool",
239 |       signature="()",
240 |       stname=""},
241 |     [2]={
242 |       args="(OPERATION op)",
243 |       argsT={
244 |         [1]={
245 |           name="op",
246 |           type="OPERATION"}},
247 |       argsoriginal="(OPERATION op)",
248 |       call_args="(op)",
249 |       call_args_old="(op)",
250 |       cimguiname="ImGuizmo_IsOver",
251 |       defaults={},
252 |       funcname="IsOver",
253 |       location="ImGuizmo:252",
254 |       namespace="ImGuizmo",
255 |       ov_cimguiname="ImGuizmo_IsOver_OPERATION",
256 |       ret="bool",
257 |       signature="(OPERATION)",
258 |       stname=""},
259 |     [3]={
260 |       args="(float* position,float pixelRadius)",
261 |       argsT={
262 |         [1]={
263 |           name="position",
264 |           type="float*"},
265 |         [2]={
266 |           name="pixelRadius",
267 |           type="float"}},
268 |       argsoriginal="(float* position,float pixelRadius)",
269 |       call_args="(position,pixelRadius)",
270 |       call_args_old="(position,pixelRadius)",
271 |       cimguiname="ImGuizmo_IsOver",
272 |       defaults={},
273 |       funcname="IsOver",
274 |       location="ImGuizmo:267",
275 |       namespace="ImGuizmo",
276 |       ov_cimguiname="ImGuizmo_IsOver_FloatPtr",
277 |       ret="bool",
278 |       signature="(float*,float)",
279 |       stname=""},
280 |     ["()"]=nil,
281 |     ["(OPERATION)"]=nil,
282 |     ["(float*,float)"]=nil},
283 |   ImGuizmo_IsUsing={
284 |     [1]={
285 |       args="()",
286 |       argsT={},
287 |       argsoriginal="()",
288 |       call_args="()",
289 |       call_args_old="()",
290 |       cimguiname="ImGuizmo_IsUsing",
291 |       defaults={},
292 |       funcname="IsUsing",
293 |       location="ImGuizmo:139",
294 |       namespace="ImGuizmo",
295 |       ov_cimguiname="ImGuizmo_IsUsing",
296 |       ret="bool",
297 |       signature="()",
298 |       stname=""},
299 |     ["()"]=nil},
300 |   ImGuizmo_IsUsingAny={
301 |     [1]={
302 |       args="()",
303 |       argsT={},
304 |       argsoriginal="()",
305 |       call_args="()",
306 |       call_args_old="()",
307 |       cimguiname="ImGuizmo_IsUsingAny",
308 |       defaults={},
309 |       funcname="IsUsingAny",
310 |       location="ImGuizmo:147",
311 |       namespace="ImGuizmo",
312 |       ov_cimguiname="ImGuizmo_IsUsingAny",
313 |       ret="bool",
314 |       signature="()",
315 |       stname=""},
316 |     ["()"]=nil},
317 |   ImGuizmo_IsUsingViewManipulate={
318 |     [1]={
319 |       args="()",
320 |       argsT={},
321 |       argsoriginal="()",
322 |       call_args="()",
323 |       call_args_old="()",
324 |       cimguiname="ImGuizmo_IsUsingViewManipulate",
325 |       defaults={},
326 |       funcname="IsUsingViewManipulate",
327 |       location="ImGuizmo:142",
328 |       namespace="ImGuizmo",
329 |       ov_cimguiname="ImGuizmo_IsUsingViewManipulate",
330 |       ret="bool",
331 |       signature="()",
332 |       stname=""},
333 |     ["()"]=nil},
334 |   ImGuizmo_IsViewManipulateHovered={
335 |     [1]={
336 |       args="()",
337 |       argsT={},
338 |       argsoriginal="()",
339 |       call_args="()",
340 |       call_args_old="()",
341 |       cimguiname="ImGuizmo_IsViewManipulateHovered",
342 |       defaults={},
343 |       funcname="IsViewManipulateHovered",
344 |       location="ImGuizmo:144",
345 |       namespace="ImGuizmo",
346 |       ov_cimguiname="ImGuizmo_IsViewManipulateHovered",
347 |       ret="bool",
348 |       signature="()",
349 |       stname=""},
350 |     ["()"]=nil},
351 |   ImGuizmo_Manipulate={
352 |     [1]={
353 |       args="(const float* view,const float* projection,OPERATION operation,MODE mode,float* matrix,float* deltaMatrix,const float* snap,const float* localBounds,const float* boundsSnap)",
354 |       argsT={
355 |         [1]={
356 |           name="view",
357 |           type="const float*"},
358 |         [2]={
359 |           name="projection",
360 |           type="const float*"},
361 |         [3]={
362 |           name="operation",
363 |           type="OPERATION"},
364 |         [4]={
365 |           name="mode",
366 |           type="MODE"},
367 |         [5]={
368 |           name="matrix",
369 |           type="float*"},
370 |         [6]={
371 |           name="deltaMatrix",
372 |           type="float*"},
373 |         [7]={
374 |           name="snap",
375 |           type="const float*"},
376 |         [8]={
377 |           name="localBounds",
378 |           type="const float*"},
379 |         [9]={
380 |           name="boundsSnap",
381 |           type="const float*"}},
382 |       argsoriginal="(const float* view,const float* projection,OPERATION operation,MODE mode,float* matrix,float* deltaMatrix=NULL,const float* snap=NULL,const float* localBounds=NULL,const float* boundsSnap=NULL)",
383 |       call_args="(view,projection,operation,mode,matrix,deltaMatrix,snap,localBounds,boundsSnap)",
384 |       call_args_old="(view,projection,operation,mode,matrix,deltaMatrix,snap,localBounds,boundsSnap)",
385 |       cimguiname="ImGuizmo_Manipulate",
386 |       defaults={
387 |         boundsSnap="NULL",
388 |         deltaMatrix="NULL",
389 |         localBounds="NULL",
390 |         snap="NULL"},
391 |       funcname="Manipulate",
392 |       location="ImGuizmo:215",
393 |       namespace="ImGuizmo",
394 |       ov_cimguiname="ImGuizmo_Manipulate",
395 |       ret="bool",
396 |       signature="(const float*,const float*,OPERATION,MODE,float*,float*,const float*,const float*,const float*)",
397 |       stname=""},
398 |     ["(const float*,const float*,OPERATION,MODE,float*,float*,const float*,const float*,const float*)"]=nil},
399 |   ImGuizmo_PopID={
400 |     [1]={
401 |       args="()",
402 |       argsT={},
403 |       argsoriginal="()",
404 |       call_args="()",
405 |       call_args_old="()",
406 |       cimguiname="ImGuizmo_PopID",
407 |       defaults={},
408 |       funcname="PopID",
409 |       location="ImGuizmo:246",
410 |       namespace="ImGuizmo",
411 |       ov_cimguiname="ImGuizmo_PopID",
412 |       ret="void",
413 |       signature="()",
414 |       stname=""},
415 |     ["()"]=nil},
416 |   ImGuizmo_PushID={
417 |     [1]={
418 |       args="(const char* str_id)",
419 |       argsT={
420 |         [1]={
421 |           name="str_id",
422 |           type="const char*"}},
423 |       argsoriginal="(const char* str_id)",
424 |       call_args="(str_id)",
425 |       call_args_old="(str_id)",
426 |       cimguiname="ImGuizmo_PushID",
427 |       defaults={},
428 |       funcname="PushID",
429 |       location="ImGuizmo:242",
430 |       namespace="ImGuizmo",
431 |       ov_cimguiname="ImGuizmo_PushID_Str",
432 |       ret="void",
433 |       signature="(const char*)",
434 |       stname=""},
435 |     [2]={
436 |       args="(const char* str_id_begin,const char* str_id_end)",
437 |       argsT={
438 |         [1]={
439 |           name="str_id_begin",
440 |           type="const char*"},
441 |         [2]={
442 |           name="str_id_end",
443 |           type="const char*"}},
444 |       argsoriginal="(const char* str_id_begin,const char* str_id_end)",
445 |       call_args="(str_id_begin,str_id_end)",
446 |       call_args_old="(str_id_begin,str_id_end)",
447 |       cimguiname="ImGuizmo_PushID",
448 |       defaults={},
449 |       funcname="PushID",
450 |       location="ImGuizmo:243",
451 |       namespace="ImGuizmo",
452 |       ov_cimguiname="ImGuizmo_PushID_StrStr",
453 |       ret="void",
454 |       signature="(const char*,const char*)",
455 |       stname=""},
456 |     [3]={
457 |       args="(const void* ptr_id)",
458 |       argsT={
459 |         [1]={
460 |           name="ptr_id",
461 |           type="const void*"}},
462 |       argsoriginal="(const void* ptr_id)",
463 |       call_args="(ptr_id)",
464 |       call_args_old="(ptr_id)",
465 |       cimguiname="ImGuizmo_PushID",
466 |       defaults={},
467 |       funcname="PushID",
468 |       location="ImGuizmo:244",
469 |       namespace="ImGuizmo",
470 |       ov_cimguiname="ImGuizmo_PushID_Ptr",
471 |       ret="void",
472 |       signature="(const void*)",
473 |       stname=""},
474 |     [4]={
475 |       args="(int int_id)",
476 |       argsT={
477 |         [1]={
478 |           name="int_id",
479 |           type="int"}},
480 |       argsoriginal="(int int_id)",
481 |       call_args="(int_id)",
482 |       call_args_old="(int_id)",
483 |       cimguiname="ImGuizmo_PushID",
484 |       defaults={},
485 |       funcname="PushID",
486 |       location="ImGuizmo:245",
487 |       namespace="ImGuizmo",
488 |       ov_cimguiname="ImGuizmo_PushID_Int",
489 |       ret="void",
490 |       signature="(int)",
491 |       stname=""},
492 |     ["(const char*)"]=nil,
493 |     ["(const char*,const char*)"]=nil,
494 |     ["(const void*)"]=nil,
495 |     ["(int)"]=nil},
496 |   ImGuizmo_RecomposeMatrixFromComponents={
497 |     [1]={
498 |       args="(const float* translation,const float* rotation,const float* scale,float* matrix)",
499 |       argsT={
500 |         [1]={
501 |           name="translation",
502 |           type="const float*"},
503 |         [2]={
504 |           name="rotation",
505 |           type="const float*"},
506 |         [3]={
507 |           name="scale",
508 |           type="const float*"},
509 |         [4]={
510 |           name="matrix",
511 |           type="float*"}},
512 |       argsoriginal="(const float* translation,const float* rotation,const float* scale,float* matrix)",
513 |       call_args="(translation,rotation,scale,matrix)",
514 |       call_args_old="(translation,rotation,scale,matrix)",
515 |       cimguiname="ImGuizmo_RecomposeMatrixFromComponents",
516 |       defaults={},
517 |       funcname="RecomposeMatrixFromComponents",
518 |       location="ImGuizmo:166",
519 |       namespace="ImGuizmo",
520 |       ov_cimguiname="ImGuizmo_RecomposeMatrixFromComponents",
521 |       ret="void",
522 |       signature="(const float*,const float*,const float*,float*)",
523 |       stname=""},
524 |     ["(const float*,const float*,const float*,float*)"]=nil},
525 |   ImGuizmo_SetAlternativeWindow={
526 |     [1]={
527 |       args="(ImGuiWindow* window)",
528 |       argsT={
529 |         [1]={
530 |           name="window",
531 |           type="ImGuiWindow*"}},
532 |       argsoriginal="(ImGuiWindow* window)",
533 |       call_args="(window)",
534 |       call_args_old="(window)",
535 |       cimguiname="ImGuizmo_SetAlternativeWindow",
536 |       defaults={},
537 |       funcname="SetAlternativeWindow",
538 |       location="ImGuizmo:226",
539 |       namespace="ImGuizmo",
540 |       ov_cimguiname="ImGuizmo_SetAlternativeWindow",
541 |       ret="void",
542 |       signature="(ImGuiWindow*)",
543 |       stname=""},
544 |     ["(ImGuiWindow*)"]=nil},
545 |   ImGuizmo_SetAxisLimit={
546 |     [1]={
547 |       args="(float value)",
548 |       argsT={
549 |         [1]={
550 |           name="value",
551 |           type="float"}},
552 |       argsoriginal="(float value)",
553 |       call_args="(value)",
554 |       call_args_old="(value)",
555 |       cimguiname="ImGuizmo_SetAxisLimit",
556 |       defaults={},
557 |       funcname="SetAxisLimit",
558 |       location="ImGuizmo:261",
559 |       namespace="ImGuizmo",
560 |       ov_cimguiname="ImGuizmo_SetAxisLimit",
561 |       ret="void",
562 |       signature="(float)",
563 |       stname=""},
564 |     ["(float)"]=nil},
565 |   ImGuizmo_SetAxisMask={
566 |     [1]={
567 |       args="(bool x,bool y,bool z)",
568 |       argsT={
569 |         [1]={
570 |           name="x",
571 |           type="bool"},
572 |         [2]={
573 |           name="y",
574 |           type="bool"},
575 |         [3]={
576 |           name="z",
577 |           type="bool"}},
578 |       argsoriginal="(bool x,bool y,bool z)",
579 |       call_args="(x,y,z)",
580 |       call_args_old="(x,y,z)",
581 |       cimguiname="ImGuizmo_SetAxisMask",
582 |       defaults={},
583 |       funcname="SetAxisMask",
584 |       location="ImGuizmo:263",
585 |       namespace="ImGuizmo",
586 |       ov_cimguiname="ImGuizmo_SetAxisMask",
587 |       ret="void",
588 |       signature="(bool,bool,bool)",
589 |       stname=""},
590 |     ["(bool,bool,bool)"]=nil},
591 |   ImGuizmo_SetDrawlist={
592 |     [1]={
593 |       args="(ImDrawList* drawlist)",
594 |       argsT={
595 |         [1]={
596 |           name="drawlist",
597 |           type="ImDrawList*"}},
598 |       argsoriginal="(ImDrawList* drawlist=nullptr)",
599 |       call_args="(drawlist)",
600 |       call_args_old="(drawlist)",
601 |       cimguiname="ImGuizmo_SetDrawlist",
602 |       defaults={
603 |         drawlist="nullptr"},
604 |       funcname="SetDrawlist",
605 |       location="ImGuizmo:124",
606 |       namespace="ImGuizmo",
607 |       ov_cimguiname="ImGuizmo_SetDrawlist",
608 |       ret="void",
609 |       signature="(ImDrawList*)",
610 |       stname=""},
611 |     ["(ImDrawList*)"]=nil},
612 |   ImGuizmo_SetGizmoSizeClipSpace={
613 |     [1]={
614 |       args="(float value)",
615 |       argsT={
616 |         [1]={
617 |           name="value",
618 |           type="float"}},
619 |       argsoriginal="(float value)",
620 |       call_args="(value)",
621 |       call_args_old="(value)",
622 |       cimguiname="ImGuizmo_SetGizmoSizeClipSpace",
623 |       defaults={},
624 |       funcname="SetGizmoSizeClipSpace",
625 |       location="ImGuizmo:253",
626 |       namespace="ImGuizmo",
627 |       ov_cimguiname="ImGuizmo_SetGizmoSizeClipSpace",
628 |       ret="void",
629 |       signature="(float)",
630 |       stname=""},
631 |     ["(float)"]=nil},
632 |   ImGuizmo_SetID={
633 |     [1]={
634 |       args="(int id)",
635 |       argsT={
636 |         [1]={
637 |           name="id",
638 |           type="int"}},
639 |       argsoriginal="(int id)",
640 |       call_args="(id)",
641 |       call_args_old="(id)",
642 |       cimguiname="ImGuizmo_SetID",
643 |       defaults={},
644 |       funcname="SetID",
645 |       location="ImGuizmo:229",
646 |       namespace="ImGuizmo",
647 |       ov_cimguiname="ImGuizmo_SetID",
648 |       ret="void",
649 |       signature="(int)",
650 |       stname=""},
651 |     ["(int)"]=nil},
652 |   ImGuizmo_SetImGuiContext={
653 |     [1]={
654 |       args="(ImGuiContext* ctx)",
655 |       argsT={
656 |         [1]={
657 |           name="ctx",
658 |           type="ImGuiContext*"}},
659 |       argsoriginal="(ImGuiContext* ctx)",
660 |       call_args="(ctx)",
661 |       call_args_old="(ctx)",
662 |       cimguiname="ImGuizmo_SetImGuiContext",
663 |       defaults={},
664 |       funcname="SetImGuiContext",
665 |       location="ImGuizmo:133",
666 |       namespace="ImGuizmo",
667 |       ov_cimguiname="ImGuizmo_SetImGuiContext",
668 |       ret="void",
669 |       signature="(ImGuiContext*)",
670 |       stname=""},
671 |     ["(ImGuiContext*)"]=nil},
672 |   ImGuizmo_SetOrthographic={
673 |     [1]={
674 |       args="(bool isOrthographic)",
675 |       argsT={
676 |         [1]={
677 |           name="isOrthographic",
678 |           type="bool"}},
679 |       argsoriginal="(bool isOrthographic)",
680 |       call_args="(isOrthographic)",
681 |       call_args_old="(isOrthographic)",
682 |       cimguiname="ImGuizmo_SetOrthographic",
683 |       defaults={},
684 |       funcname="SetOrthographic",
685 |       location="ImGuizmo:170",
686 |       namespace="ImGuizmo",
687 |       ov_cimguiname="ImGuizmo_SetOrthographic",
688 |       ret="void",
689 |       signature="(bool)",
690 |       stname=""},
691 |     ["(bool)"]=nil},
692 |   ImGuizmo_SetPlaneLimit={
693 |     [1]={
694 |       args="(float value)",
695 |       argsT={
696 |         [1]={
697 |           name="value",
698 |           type="float"}},
699 |       argsoriginal="(float value)",
700 |       call_args="(value)",
701 |       call_args_old="(value)",
702 |       cimguiname="ImGuizmo_SetPlaneLimit",
703 |       defaults={},
704 |       funcname="SetPlaneLimit",
705 |       location="ImGuizmo:265",
706 |       namespace="ImGuizmo",
707 |       ov_cimguiname="ImGuizmo_SetPlaneLimit",
708 |       ret="void",
709 |       signature="(float)",
710 |       stname=""},
711 |     ["(float)"]=nil},
712 |   ImGuizmo_SetRect={
713 |     [1]={
714 |       args="(float x,float y,float width,float height)",
715 |       argsT={
716 |         [1]={
717 |           name="x",
718 |           type="float"},
719 |         [2]={
720 |           name="y",
721 |           type="float"},
722 |         [3]={
723 |           name="width",
724 |           type="float"},
725 |         [4]={
726 |           name="height",
727 |           type="float"}},
728 |       argsoriginal="(float x,float y,float width,float height)",
729 |       call_args="(x,y,width,height)",
730 |       call_args_old="(x,y,width,height)",
731 |       cimguiname="ImGuizmo_SetRect",
732 |       defaults={},
733 |       funcname="SetRect",
734 |       location="ImGuizmo:168",
735 |       namespace="ImGuizmo",
736 |       ov_cimguiname="ImGuizmo_SetRect",
737 |       ret="void",
738 |       signature="(float,float,float,float)",
739 |       stname=""},
740 |     ["(float,float,float,float)"]=nil},
741 |   ImGuizmo_ViewManipulate={
742 |     [1]={
743 |       args="(float* view,float length,ImVec2_c position,ImVec2_c size,ImU32 backgroundColor)",
744 |       argsT={
745 |         [1]={
746 |           name="view",
747 |           type="float*"},
748 |         [2]={
749 |           name="length",
750 |           type="float"},
751 |         [3]={
752 |           name="position",
753 |           type="ImVec2"},
754 |         [4]={
755 |           name="size",
756 |           type="ImVec2"},
757 |         [5]={
758 |           name="backgroundColor",
759 |           type="ImU32"}},
760 |       argsoriginal="(float* view,float length,ImVec2 position,ImVec2 size,ImU32 backgroundColor)",
761 |       call_args="(view,length,ConvertToCPP_ImVec2(position),ConvertToCPP_ImVec2(size),backgroundColor)",
762 |       call_args_old="(view,length,position,size,backgroundColor)",
763 |       cimguiname="ImGuizmo_ViewManipulate",
764 |       defaults={},
765 |       funcname="ViewManipulate",
766 |       location="ImGuizmo:221",
767 |       namespace="ImGuizmo",
768 |       ov_cimguiname="ImGuizmo_ViewManipulate_Float",
769 |       ret="void",
770 |       signature="(float*,float,ImVec2,ImVec2,ImU32)",
771 |       stname=""},
772 |     [2]={
773 |       args="(float* view,const float* projection,OPERATION operation,MODE mode,float* matrix,float length,ImVec2_c position,ImVec2_c size,ImU32 backgroundColor)",
774 |       argsT={
775 |         [1]={
776 |           name="view",
777 |           type="float*"},
778 |         [2]={
779 |           name="projection",
780 |           type="const float*"},
781 |         [3]={
782 |           name="operation",
783 |           type="OPERATION"},
784 |         [4]={
785 |           name="mode",
786 |           type="MODE"},
787 |         [5]={
788 |           name="matrix",
789 |           type="float*"},
790 |         [6]={
791 |           name="length",
792 |           type="float"},
793 |         [7]={
794 |           name="position",
795 |           type="ImVec2"},
796 |         [8]={
797 |           name="size",
798 |           type="ImVec2"},
799 |         [9]={
800 |           name="backgroundColor",
801 |           type="ImU32"}},
802 |       argsoriginal="(float* view,const float* projection,OPERATION operation,MODE mode,float* matrix,float length,ImVec2 position,ImVec2 size,ImU32 backgroundColor)",
803 |       call_args="(view,projection,operation,mode,matrix,length,ConvertToCPP_ImVec2(position),ConvertToCPP_ImVec2(size),backgroundColor)",
804 |       call_args_old="(view,projection,operation,mode,matrix,length,position,size,backgroundColor)",
805 |       cimguiname="ImGuizmo_ViewManipulate",
806 |       defaults={},
807 |       funcname="ViewManipulate",
808 |       location="ImGuizmo:224",
809 |       namespace="ImGuizmo",
810 |       ov_cimguiname="ImGuizmo_ViewManipulate_FloatPtr",
811 |       ret="void",
812 |       signature="(float*,const float*,OPERATION,MODE,float*,float,ImVec2,ImVec2,ImU32)",
813 |       stname=""},
814 |     ["(float*,const float*,OPERATION,MODE,float*,float,ImVec2,ImVec2,ImU32)"]=nil,
815 |     ["(float*,float,ImVec2,ImVec2,ImU32)"]=nil},
816 |   Style_Style={
817 |     [1]={
818 |       args="()",
819 |       argsT={},
820 |       argsoriginal="()",
821 |       call_args="()",
822 |       call_args_old="()",
823 |       cimguiname="Style_Style",
824 |       constructor=true,
825 |       defaults={},
826 |       funcname="Style",
827 |       location="ImGuizmo:291",
828 |       ov_cimguiname="Style_Style",
829 |       signature="()",
830 |       stname="Style"},
831 |     ["()"]=nil},
832 |   Style_destroy={
833 |     [1]={
834 |       args="(Style* self)",
835 |       argsT={
836 |         [1]={
837 |           name="self",
838 |           type="Style*"}},
839 |       call_args="(self)",
840 |       cimguiname="Style_destroy",
841 |       defaults={},
842 |       destructor=true,
843 |       location="ImGuizmo:291",
844 |       ov_cimguiname="Style_destroy",
845 |       ret="void",
846 |       signature="(Style*)",
847 |       stname="Style"},
848 |     ["(Style*)"]=nil}}
849 | t.ImGuizmo_AllowAxisFlip["(bool)"]=t.ImGuizmo_AllowAxisFlip[1]
850 | t.ImGuizmo_BeginFrame["()"]=t.ImGuizmo_BeginFrame[1]
851 | t.ImGuizmo_DecomposeMatrixToComponents["(const float*,float*,float*,float*)"]=t.ImGuizmo_DecomposeMatrixToComponents[1]
852 | t.ImGuizmo_DrawCubes["(const float*,const float*,const float*,int)"]=t.ImGuizmo_DrawCubes[1]
853 | t.ImGuizmo_DrawGrid["(const float*,const float*,const float*,const float)"]=t.ImGuizmo_DrawGrid[1]
854 | t.ImGuizmo_Enable["(bool)"]=t.ImGuizmo_Enable[1]
855 | t.ImGuizmo_GetID["(const char*)"]=t.ImGuizmo_GetID[1]
856 | t.ImGuizmo_GetID["(const char*,const char*)"]=t.ImGuizmo_GetID[2]
857 | t.ImGuizmo_GetID["(const void*)"]=t.ImGuizmo_GetID[3]
858 | t.ImGuizmo_GetStyle["()"]=t.ImGuizmo_GetStyle[1]
859 | t.ImGuizmo_IsOver["()"]=t.ImGuizmo_IsOver[1]
860 | t.ImGuizmo_IsOver["(OPERATION)"]=t.ImGuizmo_IsOver[2]
861 | t.ImGuizmo_IsOver["(float*,float)"]=t.ImGuizmo_IsOver[3]
862 | t.ImGuizmo_IsUsing["()"]=t.ImGuizmo_IsUsing[1]
863 | t.ImGuizmo_IsUsingAny["()"]=t.ImGuizmo_IsUsingAny[1]
864 | t.ImGuizmo_IsUsingViewManipulate["()"]=t.ImGuizmo_IsUsingViewManipulate[1]
865 | t.ImGuizmo_IsViewManipulateHovered["()"]=t.ImGuizmo_IsViewManipulateHovered[1]
866 | t.ImGuizmo_Manipulate["(const float*,const float*,OPERATION,MODE,float*,float*,const float*,const float*,const float*)"]=t.ImGuizmo_Manipulate[1]
867 | t.ImGuizmo_PopID["()"]=t.ImGuizmo_PopID[1]
868 | t.ImGuizmo_PushID["(const char*)"]=t.ImGuizmo_PushID[1]
869 | t.ImGuizmo_PushID["(const char*,const char*)"]=t.ImGuizmo_PushID[2]
870 | t.ImGuizmo_PushID["(const void*)"]=t.ImGuizmo_PushID[3]
871 | t.ImGuizmo_PushID["(int)"]=t.ImGuizmo_PushID[4]
872 | t.ImGuizmo_RecomposeMatrixFromComponents["(const float*,const float*,const float*,float*)"]=t.ImGuizmo_RecomposeMatrixFromComponents[1]
873 | t.ImGuizmo_SetAlternativeWindow["(ImGuiWindow*)"]=t.ImGuizmo_SetAlternativeWindow[1]
874 | t.ImGuizmo_SetAxisLimit["(float)"]=t.ImGuizmo_SetAxisLimit[1]
875 | t.ImGuizmo_SetAxisMask["(bool,bool,bool)"]=t.ImGuizmo_SetAxisMask[1]
876 | t.ImGuizmo_SetDrawlist["(ImDrawList*)"]=t.ImGuizmo_SetDrawlist[1]
877 | t.ImGuizmo_SetGizmoSizeClipSpace["(float)"]=t.ImGuizmo_SetGizmoSizeClipSpace[1]
878 | t.ImGuizmo_SetID["(int)"]=t.ImGuizmo_SetID[1]
879 | t.ImGuizmo_SetImGuiContext["(ImGuiContext*)"]=t.ImGuizmo_SetImGuiContext[1]
880 | t.ImGuizmo_SetOrthographic["(bool)"]=t.ImGuizmo_SetOrthographic[1]
881 | t.ImGuizmo_SetPlaneLimit["(float)"]=t.ImGuizmo_SetPlaneLimit[1]
882 | t.ImGuizmo_SetRect["(float,float,float,float)"]=t.ImGuizmo_SetRect[1]
883 | t.ImGuizmo_ViewManipulate["(float*,const float*,OPERATION,MODE,float*,float,ImVec2,ImVec2,ImU32)"]=t.ImGuizmo_ViewManipulate[2]
884 | t.ImGuizmo_ViewManipulate["(float*,float,ImVec2,ImVec2,ImU32)"]=t.ImGuizmo_ViewManipulate[1]
885 | t.Style_Style["()"]=t.Style_Style[1]
886 | t.Style_destroy["(Style*)"]=t.Style_destroy[1]
887 |  return t


--------------------------------------------------------------------------------