diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..a86bd53 --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +*~ +*.o +*.so diff --git a/api/raygui_api.json b/api/raygui_api.json new file mode 100755 index 0000000..99161f5 --- /dev/null +++ b/api/raygui_api.json @@ -0,0 +1,1409 @@ +{ + "defines": [ + { + "name": "SCROLLBAR_LEFT_SIDE", + "type": "INT", + "value": 0, + "description": "" + }, + { + "name": "SCROLLBAR_RIGHT_SID", + "type": "INT", + "value": 1, + "description": "" + } + ], + "structs": [ + { + "name": "GuiStyleProp", + "fields": [ + { + "type": "unsigned short", + "name": "controlId", + "description": "Control identifier" + }, + { + "type": "unsigned short", + "name": "propertyId", + "description": "Property identifier" + }, + { + "type": "int", + "name": "propertyValue", + "description": "Property value" + } + ] + } + ], + "enums": [ + { + "name": "GuiState", + "values": [ + { + "name": "STATE_NORMAL", + "value": 0 + }, + { + "name": "STATE_FOCUSED", + "value": 1 + }, + { + "name": "STATE_PRESSED", + "value": 2 + }, + { + "name": "STATE_DISABLED", + "value": 3 + } + ] + }, + { + "name": "GuiTextAlignment", + "values": [ + { + "name": "TEXT_ALIGN_LEFT", + "value": 0 + }, + { + "name": "TEXT_ALIGN_CENTER", + "value": 1 + }, + { + "name": "TEXT_ALIGN_RIGHT", + "value": 2 + } + ] + }, + { + "name": "GuiTextAlignmentVerticalt", + "values": [ + { + "name": "TEXT_ALIGN_TOP", + "value": 0 + }, + { + "name": "TEXT_ALIGN_MIDDLE", + "value": 1 + }, + { + "name": "TEXT_ALIGN_BOTTOM", + "value": 2 + } + ] + }, + { + "name": "GuiTextWrapMode", + "values": [ + { + "name": "TEXT_WRAP_NONE", + "value": 0 + }, + { + "name": "TEXT_WRAP_CHAR", + "value": 1 + }, + { + "name": "TEXT_WRAP_WORD", + "value": 2 + } + ] + }, + { + "name": "GuiControl", + "values": [ + { + "name": "DEFAULT", + "value": 0 + }, + { + "name": "LABEL", + "value": 1 + }, + { + "name": "BUTTON", + "value": 2 + }, + { + "name": "TOGGLE", + "value": 3 + }, + { + "name": "SLIDER", + "value": 4 + }, + { + "name": "PROGRESSBAR", + "value": 5 + }, + { + "name": "CHECKBOX", + "value": 6 + }, + { + "name": "COMBOBOX", + "value": 7 + }, + { + "name": "DROPDOWNBOX", + "value": 8 + }, + { + "name": "TEXTBOX", + "value": 9 + }, + { + "name": "VALUEBOX", + "value": 10 + }, + { + "name": "SPINNER", + "value": 11 + }, + { + "name": "LISTVIEW", + "value": 12 + }, + { + "name": "COLORPICKER", + "value": 13 + }, + { + "name": "SCROLLBAR", + "value": 14 + }, + { + "name": "STATUSBAR", + "value": 15 + } + ] + }, + { + "name": "GuiControlProperty", + "values": [ + { + "name": "BORDER_COLOR_NORMAL", + "value": 0 + }, + { + "name": "BASE_COLOR_NORMAL", + "value": 1 + }, + { + "name": "TEXT_COLOR_NORMAL", + "value": 2 + }, + { + "name": "BORDER_COLOR_FOCUSED", + "value": 3 + }, + { + "name": "BASE_COLOR_FOCUSED", + "value": 4 + }, + { + "name": "TEXT_COLOR_FOCUSED", + "value": 5 + }, + { + "name": "BORDER_COLOR_PRESSED", + "value": 6 + }, + { + "name": "BASE_COLOR_PRESSED", + "value": 7 + }, + { + "name": "TEXT_COLOR_PRESSED", + "value": 8 + }, + { + "name": "BORDER_COLOR_DISABLED", + "value": 9 + }, + { + "name": "BASE_COLOR_DISABLED", + "value": 10 + }, + { + "name": "TEXT_COLOR_DISABLED", + "value": 11 + }, + { + "name": "BORDER_WIDTH", + "value": 12 + }, + { + "name": "TEXT_PADDING", + "value": 13 + }, + { + "name": "TEXT_ALIGNMENT", + "value": 14 + } + ] + }, + { + "name": "GuiDefaultProperty", + "values": [ + { + "name": "TEXT_SIZE", + "value": 16 + }, + { + "name": "TEXT_SPACING", + "value": 17 + }, + { + "name": "LINE_COLOR", + "value": 18 + }, + { + "name": "BACKGROUND_COLOR", + "value": 19 + }, + { + "name": "TEXT_LINE_SPACING", + "value": 20 + }, + { + "name": "TEXT_ALIGNMENT_VERTICAL", + "value": 21 + }, + { + "name": "TEXT_WRAP_MODE", + "value": 22 + } + ] + }, + { + "name": "GuiToggleProperty", + "values": [ + { + "name": "GROUP_PADDING", + "value": 16 + } + ] + }, + { + "name": "GuiSliderProperty", + "values": [ + { + "name": "SLIDER_WIDTH", + "value": 16 + }, + { + "name": "SLIDER_PADDING", + "value": 17 + } + ] + }, + { + "name": "GuiProgressBarProperty", + "values": [ + { + "name": "PROGRESS_PADDING", + "value": 16 + } + ] + }, + { + "name": "GuiScrollBarProperty", + "values": [ + { + "name": "ARROWS_SIZE", + "value": 16 + }, + { + "name": "ARROWS_VISIBLE", + "value": 17 + }, + { + "name": "SCROLL_SLIDER_PADDING", + "value": 18 + }, + { + "name": "SCROLL_SLIDER_SIZE", + "value": 19 + }, + { + "name": "SCROLL_PADDING", + "value": 20 + }, + { + "name": "SCROLL_SPEED", + "value": 21 + } + ] + }, + { + "name": "GuiCheckBoxProperty", + "values": [ + { + "name": "CHECK_PADDING", + "value": 16 + } + ] + }, + { + "name": "GuiComboBoxProperty", + "values": [ + { + "name": "COMBO_BUTTON_WIDTH", + "value": 16 + }, + { + "name": "COMBO_BUTTON_SPACING", + "value": 17 + } + ] + }, + { + "name": "GuiDropdownBoxProperty", + "values": [ + { + "name": "ARROW_PADDING", + "value": 16 + }, + { + "name": "DROPDOWN_ITEMS_SPACING", + "value": 17 + }, + { + "name": "DROPDOWN_ARROW_HIDDEN", + "value": 18 + }, + { + "name": "DROPDOWN_ROLL_UP", + "value": 19 + } + ] + }, + { + "name": "GuiTextBoxProperty", + "values": [ + { + "name": "TEXT_READONLY", + "value": 16 + } + ] + }, + { + "name": "GuiSpinnerProperty", + "values": [ + { + "name": "SPIN_BUTTON_WIDTH", + "value": 16 + }, + { + "name": "SPIN_BUTTON_SPACING", + "value": 17 + } + ] + }, + { + "name": "GuiListViewProperty", + "values": [ + { + "name": "LIST_ITEMS_HEIGHT", + "value": 16 + }, + { + "name": "LIST_ITEMS_SPACING", + "value": 17 + }, + { + "name": "SCROLLBAR_WIDTH", + "value": 18 + }, + { + "name": "SCROLLBAR_SIDE", + "value": 19 + }, + { + "name": "LIST_ITEMS_BORDER_WIDTH", + "value": 20 + } + ] + }, + { + "name": "GuiColorPickerProperty", + "values": [ + { + "name": "COLOR_SELECTOR_SIZE", + "value": 16 + }, + { + "name": "HUEBAR_WIDTH", + "value": 17 + }, + { + "name": "HUEBAR_PADDING", + "value": 18 + }, + { + "name": "HUEBAR_SELECTOR_HEIGHT", + "value": 19 + }, + { + "name": "HUEBAR_SELECTOR_OVERFLOW", + "value": 20 + } + ] + } + + + ], + "aliases": [], + "callbacks": [], + + "functions": [ + { + "name": "GuiEnable", + "returnType": "void", + "params": [ + + ] + }, + { + "name": "GuiDisable", + "returnType": "void", + "params": [ + + ] + }, + { + "name": "GuiLock", + "returnType": "void", + "params": [ + + ] + }, + { + "name": "GuiUnlock", + "returnType": "void", + "params": [ + + ] + }, + { + "name": "GuiIsLocked", + "returnType": "bool", + "params": [ + + ] + }, + { + "name": "GuiSetAlpha", + "returnType": "void", + "params": [ + { + "type": "float", + "name": "alpha" + } + ] + }, + { + "name": "GuiSetState", + "returnType": "void", + "params": [ + { + "type": "int", + "name": "state" + } + ] + }, + { + "name": "GuiGetState", + "returnType": "int", + "params": [ + + ] + }, + { + "name": "GuiSetFont", + "returnType": "void", + "params": [ + { + "type": "Font", + "name": "font" + } + ] + }, + { + "name": "GuiGetFont", + "returnType": "Font", + "params": [ + + ] + }, + { + "name": "GuiSetStyle", + "returnType": "void", + "params": [ + { + "type": "int", + "name": "control" + }, + { + "type": "int", + "name": "property" + }, + { + "type": "int", + "name": "value" + } + ] + }, + { + "name": "GuiGetStyle", + "returnType": "int", + "params": [ + { + "type": "int", + "name": "control" + }, + { + "type": "int", + "name": "property" + } + ] + }, + { + "name": "GuiLoadStyle", + "returnType": "void", + "params": [ + { + "type": "const char *", + "name": "fileName" + } + ] + }, + { + "name": "GuiLoadStyleDefault", + "returnType": "void", + "params": [ + + ] + }, + { + "name": "GuiEnableTooltip", + "returnType": "void", + "params": [ + + ] + }, + { + "name": "GuiDisableTooltip", + "returnType": "void", + "params": [ + + ] + }, + { + "name": "GuiSetTooltip", + "returnType": "void", + "params": [ + { + "type": "const char *", + "name": "tooltip" + } + ] + }, + { + "name": "GuiIconText", + "returnType": "const char *", + "params": [ + { + "type": "int", + "name": "iconId" + }, + { + "type": "const char *", + "name": "text" + } + ] + }, + { + "name": "GuiSetIconScale", + "returnType": "void", + "params": [ + { + "type": "int", + "name": "scale" + } + ] + }, + { + "name": "GuiLoadIcons", + "returnType": "void", + "params": [ + { + "type": "const char *", + "name": "fileName" + }, + { + "type": "bool", + "name": "loadIconsName" + } + ] + }, + { + "name": "GuiDrawIcon", + "returnType": "void", + "params": [ + { + "type": "int", + "name": "iconId" + }, + { + "type": "int", + "name": "posX" + }, + { + "type": "int", + "name": "posY" + }, + { + "type": "int", + "name": "pixelSize" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "GuiWindowBox", + "returnType": "int", + "params": [ + { + "type": "Rectangle", + "name": "bounds" + }, + { + "type": "const char *", + "name": "title" + } + ] + }, + { + "name": "GuiGroupBox", + "returnType": "int", + "params": [ + { + "type": "Rectangle", + "name": "bounds" + }, + { + "type": "const char *", + "name": "text" + } + ] + }, + { + "name": "GuiLine", + "returnType": "int", + "params": [ + { + "type": "Rectangle", + "name": "bounds" + }, + { + "type": "const char *", + "name": "text" + } + ] + }, + { + "name": "GuiPanel", + "returnType": "int", + "params": [ + { + "type": "Rectangle", + "name": "bounds" + }, + { + "type": "const char *", + "name": "text" + } + ] + }, + { + "name": "GuiTabBar", + "returnType": "int", + "params": [ + { + "type": "Rectangle", + "name": "bounds" + }, + { + "type": "const char **", + "name": "text" + }, + { + "type": "int", + "name": "count" + }, + { + "type": "int *", + "name": "active" + } + ] + }, + { + "name": "GuiScrollPanel", + "returnType": "int", + "params": [ + { + "type": "Rectangle", + "name": "bounds" + }, + { + "type": "const char *", + "name": "text" + }, + { + "type": "Rectangle", + "name": "content" + }, + { + "type": "Vector2 *", + "name": "scroll" + }, + { + "type": "Rectangle *", + "name": "view" + } + ] + }, + { + "name": "GuiLabel", + "returnType": "int", + "params": [ + { + "type": "Rectangle", + "name": "bounds" + }, + { + "type": "const char *", + "name": "text" + } + ] + }, + { + "name": "GuiButton", + "returnType": "int", + "params": [ + { + "type": "Rectangle", + "name": "bounds" + }, + { + "type": "const char *", + "name": "text" + } + ] + }, + { + + "name": "GuiLabelButton", + "returnType": "int", + "params": [ + { + "type": "Rectangle", + "name": "bounds" + }, + { + "type": "const char *", + "name": "text" + } + ] + }, + { + + "name": "GuiToggle", + "returnType": "int", + "params": [ + { + "type": "Rectangle", + "name": "bounds" + }, + { + "type": "const char *", + "name": "text" + }, + { + "type": "bool *", + "name": "active" + } + ] + }, + { + + "name": "GuiToggleGroup", + "returnType": "int", + "params": [ + { + "type": "Rectangle", + "name": "bounds" + }, + { + "type": "const char *", + "name": "text" + }, + { + "type": "int *", + "name": "active" + } + ] + }, + { + + "name": "GuiToggleSlider", + "returnType": "int", + "params": [ + { + "type": "Rectangle", + "name": "bounds" + }, + { + "type": "const char *", + "name": "text" + }, + { + "type": "int *", + "name": "active" + } + ] + }, + { + "name": "GuiCheckBox", + "returnType": "int", + "params": [ + { + "type": "Rectangle", + "name": "bounds" + }, + { + "type": "const char *", + "name": "text" + }, + { + "type": "bool *", + "name": "checked" + } + ] + }, + { + + "name": "GuiComboBox", + "returnType": "int", + "params": [ + { + "type": "Rectangle", + "name": "bounds" + }, + { + "type": "const char *", + "name": "text" + }, + { + "type": "int *", + "name": "active" + } + ] + }, + { + + "name": "GuiDropdownBox", + "returnType": "int", + "params": [ + { + "type": "Rectangle", + "name": "bounds" + }, + { + "type": "const char *", + "name": "text" + }, + { + "type": "int *", + "name": "active" + }, + { + "type": "bool", + "name": "editMode" + } + ] + }, + { + "name": "GuiSpinner", + "returnType": "int", + "params": [ + { + "type": "Rectangle", + "name": "bounds" + }, + { + "type": "const char *", + "name": "text" + }, + { + "type": "int *", + "name": "value" + }, + { + "type": "int", + "name": "minValue" + }, + { + "type": "int", + "name": "maxValue" + }, + { + "type": "bool", + "name": "editMode" + } + ] + }, + { + "name": "GuiValueBox", + "returnType": "int", + "params": [ + { + "type": "Rectangle", + "name": "bounds" + }, + { + "type": "const char *", + "name": "text" + }, + { + "type": "int *", + "name": "value" + }, + { + "type": "int", + "name": "minValue" + }, + { + "type": "int", + "name": "maxValue" + }, + { + "type": "bool", + "name": "editMode" + } + ] + }, + { + "name": "GuiValueBoxFloat", + "returnType": "int", + "params": [ + { + "type": "Rectangle", + "name": "bounds" + }, + { + "type": "const char *", + "name": "text" + }, + { + "type": "char *", + "name": "textValue" + }, + { + "type": "float *", + "name": "value" + }, + { + "type": "bool", + "name": "editMode" + } + ] + }, + { + "name": "GuiTextBox", + "returnType": "int", + "params": [ + { + "type": "Rectangle", + "name": "bounds" + }, + { + "type": "char *", + "name": "text" + }, + { + "type": "int", + "name": "textSize" + }, + { + "type": "bool", + "name": "editMode" + } + ] + }, + { + "name": "GuiSlider", + "returnType": "int", + "params": [ + { + "type": "Rectangle", + "name": "bounds" + }, + { + "type": "const char *", + "name": "textLeft" + }, + { + "type": "const char *", + "name": "textRight" + }, + { + "type": "float *", + "name": "value" + }, + { + "type": "float", + "name": "minValue" + }, + { + "type": "float", + "name": "maxValue" + } + ] + }, + { + "name": "GuiSliderBar", + "returnType": "int", + "params": [ + { + "type": "Rectangle", + "name": "bounds" + }, + { + "type": "const char *", + "name": "textLeft" + }, + { + "type": "const char *", + "name": "textRight" + }, + { + "type": "float *", + "name": "value" + }, + { + "type": "float", + "name": "minValue" + }, + { + "type": "float", + "name": "maxValue" + } + ] + }, + { + "name": "GuiProgressBar", + "returnType": "int", + "params": [ + { + "type": "Rectangle", + "name": "bounds" + }, + { + "type": "const char *", + "name": "textLeft" + }, + { + "type": "const char *", + "name": "textRight" + }, + { + "type": "float *", + "name": "value" + }, + { + "type": "float", + "name": "minValue" + }, + { + "type": "float", + "name": "maxValue" + } + ] + }, + { + "name": "GuiStatusBar", + "returnType": "int", + "params": [ + { + "type": "Rectangle", + "name": "bounds" + }, + { + "type": "const char *", + "name": "text" + } + ] + }, + { + "name": "GuiDummyRec", + "returnType": "int", + "params": [ + { + "type": "Rectangle", + "name": "bounds" + }, + { + "type": "const char *", + "name": "text" + } + ] + }, + { + "name": "GuiGrid", + "returnType": "int", + "params": [ + { + "type": "Rectangle", + "name": "bounds" + }, + { + "type": "const char *", + "name": "text" + }, + { + "type": "float", + "name": "spacing" + }, + { + "type": "int", + "name": "subdivs" + }, + { + "type": "Vector2 *", + "name": "mouseCell" + } + ] + }, + { + "name": "GuiListView", + "returnType": "int", + "params": [ + { + "type": "Rectangle", + "name": "bounds" + }, + { + "type": "const char *", + "name": "text" + }, + { + "type": "int *", + "name": "scrollIndex" + }, + { + "type": "int *", + "name": "active" + } + ] + }, + { + "name": "GuiListViewEx", + "returnType": "int", + "params": [ + { + "type": "Rectangle", + "name": "bounds" + }, + { + "type": "const char **", + "name": "text" + }, + { + "type": "int", + "name": "count" + }, + { + "type": "int *", + "name": "scrollIndex" + }, + { + "type": "int *", + "name": "active" + }, + { + "type": "int *", + "name": "focus" + } + ] + }, + { + "name": "GuiMessageBox", + "returnType": "int", + "params": [ + { + "type": "Rectangle", + "name": "bounds" + }, + { + "type": "const char *", + "name": "title" + }, + { + "type": "const char *", + "name": "message" + }, + { + "type": "const char *", + "name": "buttons" + } + ] + }, + { + "name": "GuiTextInputBox", + "returnType": "int", + "params": [ + { + "type": "Rectangle", + "name": "bounds" + }, + { + "type": "const char *", + "name": "title" + }, + { + "type": "const char *", + "name": "message" + }, + { + "type": "const char *", + "name": "buttons" + }, + { + "type": "char *", + "name": "text" + }, + { + "type": "int", + "name": "textMaxSize" + }, + { + "type": "bool *", + "name": "secretViewActive" + } + ] + }, + { + "name": "GuiColorPicker", + "returnType": "int", + "params": [ + { + "type": "Rectangle", + "name": "bounds" + }, + { + "type": "const char *", + "name": "text" + }, + { + "type": "Color *", + "name": "color" + } + ] + }, + { + "name": "GuiColorPanel", + "returnType": "int", + "params": [ + { + "type": "Rectangle", + "name": "bounds" + }, + { + "type": "const char *", + "name": "text" + }, + { + "type": "Color *", + "name": "color" + } + ] + }, + { + "name": "GuiColorBarAlpha", + "returnType": "int", + "params": [ + { + "type": "Rectangle", + "name": "bounds" + }, + { + "type": "const char *", + "name": "text" + }, + { + "type": "float *", + "name": "alpha" + } + ] + }, + { + "name": "GuiColorBarHue", + "returnType": "int", + "params": [ + { + "type": "Rectangle", + "name": "bounds" + }, + { + "type": "const char *", + "name": "text" + }, + { + "type": "float *", + "name": "value" + } + ] + }, + { + "name": "GuiColorPickerHSV", + "returnType": "int", + "params": [ + { + "type": "Rectangle", + "name": "bounds" + }, + { + "type": "const char *", + "name": "text" + }, + { + "type": "Vector3 *", + "name": "colorHsv" + } + ] + }, + { + "name": "GuiColorPanelHSV", + "returnType": "int", + "params": [ + { + "type": "Rectangle", + "name": "bounds" + }, + { + "type": "const char *", + "name": "text" + }, + { + "type": "Vector3 *", + "name": "colorHsv" + } + ] + } + ] +} diff --git a/api/raylib_api.json b/api/raylib_api.json new file mode 100755 index 0000000..e6e4ed2 --- /dev/null +++ b/api/raylib_api.json @@ -0,0 +1,11606 @@ +{ + "defines": [ + { + "name": "RAYLIB_H", + "type": "GUARD", + "value": "", + "description": "" + }, + { + "name": "RAYLIB_VERSION_MAJOR", + "type": "INT", + "value": 5, + "description": "" + }, + { + "name": "RAYLIB_VERSION_MINOR", + "type": "INT", + "value": 1, + "description": "" + }, + { + "name": "RAYLIB_VERSION_PATCH", + "type": "INT", + "value": 0, + "description": "" + }, + { + "name": "RAYLIB_VERSION", + "type": "STRING", + "value": "5.1-dev", + "description": "" + }, + { + "name": "__declspec(x)", + "type": "MACRO", + "value": "__attribute__((x))", + "description": "" + }, + { + "name": "RLAPI", + "type": "UNKNOWN", + "value": "__declspec(dllexport)", + "description": "We are building the library as a Win32 shared library (.dll)" + }, + { + "name": "PI", + "type": "FLOAT", + "value": 3.14159265358979323846, + "description": "" + }, + { + "name": "DEG2RAD", + "type": "FLOAT_MATH", + "value": "(PI/180.0f)", + "description": "" + }, + { + "name": "RAD2DEG", + "type": "FLOAT_MATH", + "value": "(180.0f/PI)", + "description": "" + }, + { + "name": "RL_MALLOC(sz)", + "type": "MACRO", + "value": "malloc(sz)", + "description": "" + }, + { + "name": "RL_CALLOC(n,sz)", + "type": "MACRO", + "value": "calloc(n,sz)", + "description": "" + }, + { + "name": "RL_REALLOC(ptr,sz)", + "type": "MACRO", + "value": "realloc(ptr,sz)", + "description": "" + }, + { + "name": "RL_FREE(ptr)", + "type": "MACRO", + "value": "free(ptr)", + "description": "" + }, + { + "name": "CLITERAL(type)", + "type": "MACRO", + "value": "type", + "description": "" + }, + { + "name": "RL_COLOR_TYPE", + "type": "GUARD", + "value": "", + "description": "" + }, + { + "name": "RL_RECTANGLE_TYPE", + "type": "GUARD", + "value": "", + "description": "" + }, + { + "name": "RL_VECTOR2_TYPE", + "type": "GUARD", + "value": "", + "description": "" + }, + { + "name": "RL_VECTOR3_TYPE", + "type": "GUARD", + "value": "", + "description": "" + }, + { + "name": "RL_VECTOR4_TYPE", + "type": "GUARD", + "value": "", + "description": "" + }, + { + "name": "RL_QUATERNION_TYPE", + "type": "GUARD", + "value": "", + "description": "" + }, + { + "name": "RL_MATRIX_TYPE", + "type": "GUARD", + "value": "", + "description": "" + }, + { + "name": "LIGHTGRAY", + "type": "COLOR", + "value": "CLITERAL(Color){ 200, 200, 200, 255 }", + "description": "Light Gray" + }, + { + "name": "GRAY", + "type": "COLOR", + "value": "CLITERAL(Color){ 130, 130, 130, 255 }", + "description": "Gray" + }, + { + "name": "DARKGRAY", + "type": "COLOR", + "value": "CLITERAL(Color){ 80, 80, 80, 255 }", + "description": "Dark Gray" + }, + { + "name": "YELLOW", + "type": "COLOR", + "value": "CLITERAL(Color){ 253, 249, 0, 255 }", + "description": "Yellow" + }, + { + "name": "GOLD", + "type": "COLOR", + "value": "CLITERAL(Color){ 255, 203, 0, 255 }", + "description": "Gold" + }, + { + "name": "ORANGE", + "type": "COLOR", + "value": "CLITERAL(Color){ 255, 161, 0, 255 }", + "description": "Orange" + }, + { + "name": "PINK", + "type": "COLOR", + "value": "CLITERAL(Color){ 255, 109, 194, 255 }", + "description": "Pink" + }, + { + "name": "RED", + "type": "COLOR", + "value": "CLITERAL(Color){ 230, 41, 55, 255 }", + "description": "Red" + }, + { + "name": "MAROON", + "type": "COLOR", + "value": "CLITERAL(Color){ 190, 33, 55, 255 }", + "description": "Maroon" + }, + { + "name": "GREEN", + "type": "COLOR", + "value": "CLITERAL(Color){ 0, 228, 48, 255 }", + "description": "Green" + }, + { + "name": "LIME", + "type": "COLOR", + "value": "CLITERAL(Color){ 0, 158, 47, 255 }", + "description": "Lime" + }, + { + "name": "DARKGREEN", + "type": "COLOR", + "value": "CLITERAL(Color){ 0, 117, 44, 255 }", + "description": "Dark Green" + }, + { + "name": "SKYBLUE", + "type": "COLOR", + "value": "CLITERAL(Color){ 102, 191, 255, 255 }", + "description": "Sky Blue" + }, + { + "name": "BLUE", + "type": "COLOR", + "value": "CLITERAL(Color){ 0, 121, 241, 255 }", + "description": "Blue" + }, + { + "name": "DARKBLUE", + "type": "COLOR", + "value": "CLITERAL(Color){ 0, 82, 172, 255 }", + "description": "Dark Blue" + }, + { + "name": "PURPLE", + "type": "COLOR", + "value": "CLITERAL(Color){ 200, 122, 255, 255 }", + "description": "Purple" + }, + { + "name": "VIOLET", + "type": "COLOR", + "value": "CLITERAL(Color){ 135, 60, 190, 255 }", + "description": "Violet" + }, + { + "name": "DARKPURPLE", + "type": "COLOR", + "value": "CLITERAL(Color){ 112, 31, 126, 255 }", + "description": "Dark Purple" + }, + { + "name": "BEIGE", + "type": "COLOR", + "value": "CLITERAL(Color){ 211, 176, 131, 255 }", + "description": "Beige" + }, + { + "name": "BROWN", + "type": "COLOR", + "value": "CLITERAL(Color){ 127, 106, 79, 255 }", + "description": "Brown" + }, + { + "name": "DARKBROWN", + "type": "COLOR", + "value": "CLITERAL(Color){ 76, 63, 47, 255 }", + "description": "Dark Brown" + }, + { + "name": "WHITE", + "type": "COLOR", + "value": "CLITERAL(Color){ 255, 255, 255, 255 }", + "description": "White" + }, + { + "name": "BLACK", + "type": "COLOR", + "value": "CLITERAL(Color){ 0, 0, 0, 255 }", + "description": "Black" + }, + { + "name": "BLANK", + "type": "COLOR", + "value": "CLITERAL(Color){ 0, 0, 0, 0 }", + "description": "Blank (Transparent)" + }, + { + "name": "MAGENTA", + "type": "COLOR", + "value": "CLITERAL(Color){ 255, 0, 255, 255 }", + "description": "Magenta" + }, + { + "name": "RAYWHITE", + "type": "COLOR", + "value": "CLITERAL(Color){ 245, 245, 245, 255 }", + "description": "My own White (raylib logo)" + }, + { + "name": "RL_BOOL_TYPE", + "type": "GUARD", + "value": "", + "description": "" + }, + { + "name": "MOUSE_LEFT_BUTTON", + "type": "UNKNOWN", + "value": "MOUSE_BUTTON_LEFT", + "description": "" + }, + { + "name": "MOUSE_RIGHT_BUTTON", + "type": "UNKNOWN", + "value": "MOUSE_BUTTON_RIGHT", + "description": "" + }, + { + "name": "MOUSE_MIDDLE_BUTTON", + "type": "UNKNOWN", + "value": "MOUSE_BUTTON_MIDDLE", + "description": "" + }, + { + "name": "MATERIAL_MAP_DIFFUSE", + "type": "UNKNOWN", + "value": "MATERIAL_MAP_ALBEDO", + "description": "" + }, + { + "name": "MATERIAL_MAP_SPECULAR", + "type": "UNKNOWN", + "value": "MATERIAL_MAP_METALNESS", + "description": "" + }, + { + "name": "SHADER_LOC_MAP_DIFFUSE", + "type": "UNKNOWN", + "value": "SHADER_LOC_MAP_ALBEDO", + "description": "" + }, + { + "name": "SHADER_LOC_MAP_SPECULAR", + "type": "UNKNOWN", + "value": "SHADER_LOC_MAP_METALNESS", + "description": "" + } + ], + "structs": [ + { + "name": "Vector2", + "description": "Vector2, 2 components", + "fields": [ + { + "type": "float", + "name": "x", + "description": "Vector x component" + }, + { + "type": "float", + "name": "y", + "description": "Vector y component" + } + ] + }, + { + "name": "Vector3", + "description": "Vector3, 3 components", + "fields": [ + { + "type": "float", + "name": "x", + "description": "Vector x component" + }, + { + "type": "float", + "name": "y", + "description": "Vector y component" + }, + { + "type": "float", + "name": "z", + "description": "Vector z component" + } + ] + }, + { + "name": "Vector4", + "description": "Vector4, 4 components", + "fields": [ + { + "type": "float", + "name": "x", + "description": "Vector x component" + }, + { + "type": "float", + "name": "y", + "description": "Vector y component" + }, + { + "type": "float", + "name": "z", + "description": "Vector z component" + }, + { + "type": "float", + "name": "w", + "description": "Vector w component" + } + ] + }, + { + "name": "Matrix", + "description": "Matrix, 4x4 components, column major, OpenGL style, right-handed", + "fields": [ + { + "type": "float", + "name": "m0", + "description": "Matrix first row (4 components)" + }, + { + "type": "float", + "name": "m4", + "description": "Matrix first row (4 components)" + }, + { + "type": "float", + "name": "m8", + "description": "Matrix first row (4 components)" + }, + { + "type": "float", + "name": "m12", + "description": "Matrix first row (4 components)" + }, + { + "type": "float", + "name": "m1", + "description": "Matrix second row (4 components)" + }, + { + "type": "float", + "name": "m5", + "description": "Matrix second row (4 components)" + }, + { + "type": "float", + "name": "m9", + "description": "Matrix second row (4 components)" + }, + { + "type": "float", + "name": "m13", + "description": "Matrix second row (4 components)" + }, + { + "type": "float", + "name": "m2", + "description": "Matrix third row (4 components)" + }, + { + "type": "float", + "name": "m6", + "description": "Matrix third row (4 components)" + }, + { + "type": "float", + "name": "m10", + "description": "Matrix third row (4 components)" + }, + { + "type": "float", + "name": "m14", + "description": "Matrix third row (4 components)" + }, + { + "type": "float", + "name": "m3", + "description": "Matrix fourth row (4 components)" + }, + { + "type": "float", + "name": "m7", + "description": "Matrix fourth row (4 components)" + }, + { + "type": "float", + "name": "m11", + "description": "Matrix fourth row (4 components)" + }, + { + "type": "float", + "name": "m15", + "description": "Matrix fourth row (4 components)" + } + ] + }, + { + "name": "Color", + "description": "Color, 4 components, R8G8B8A8 (32bit)", + "fields": [ + { + "type": "unsigned char", + "name": "r", + "description": "Color red value" + }, + { + "type": "unsigned char", + "name": "g", + "description": "Color green value" + }, + { + "type": "unsigned char", + "name": "b", + "description": "Color blue value" + }, + { + "type": "unsigned char", + "name": "a", + "description": "Color alpha value" + } + ] + }, + { + "name": "Rectangle", + "description": "Rectangle, 4 components", + "fields": [ + { + "type": "float", + "name": "x", + "description": "Rectangle top-left corner position x" + }, + { + "type": "float", + "name": "y", + "description": "Rectangle top-left corner position y" + }, + { + "type": "float", + "name": "width", + "description": "Rectangle width" + }, + { + "type": "float", + "name": "height", + "description": "Rectangle height" + } + ] + }, + { + "name": "Image", + "description": "Image, pixel data stored in CPU memory (RAM)", + "fields": [ + { + "type": "void *", + "name": "data", + "description": "Image raw data" + }, + { + "type": "int", + "name": "width", + "description": "Image base width" + }, + { + "type": "int", + "name": "height", + "description": "Image base height" + }, + { + "type": "int", + "name": "mipmaps", + "description": "Mipmap levels, 1 by default" + }, + { + "type": "int", + "name": "format", + "description": "Data format (PixelFormat type)" + } + ] + }, + { + "name": "Texture", + "description": "Texture, tex data stored in GPU memory (VRAM)", + "fields": [ + { + "type": "unsigned int", + "name": "id", + "description": "OpenGL texture id" + }, + { + "type": "int", + "name": "width", + "description": "Texture base width" + }, + { + "type": "int", + "name": "height", + "description": "Texture base height" + }, + { + "type": "int", + "name": "mipmaps", + "description": "Mipmap levels, 1 by default" + }, + { + "type": "int", + "name": "format", + "description": "Data format (PixelFormat type)" + } + ] + }, + { + "name": "RenderTexture", + "description": "RenderTexture, fbo for texture rendering", + "fields": [ + { + "type": "unsigned int", + "name": "id", + "description": "OpenGL framebuffer object id" + }, + { + "type": "Texture", + "name": "texture", + "description": "Color buffer attachment texture" + }, + { + "type": "Texture", + "name": "depth", + "description": "Depth buffer attachment texture" + } + ] + }, + { + "name": "NPatchInfo", + "description": "NPatchInfo, n-patch layout info", + "fields": [ + { + "type": "Rectangle", + "name": "source", + "description": "Texture source rectangle" + }, + { + "type": "int", + "name": "left", + "description": "Left border offset" + }, + { + "type": "int", + "name": "top", + "description": "Top border offset" + }, + { + "type": "int", + "name": "right", + "description": "Right border offset" + }, + { + "type": "int", + "name": "bottom", + "description": "Bottom border offset" + }, + { + "type": "int", + "name": "layout", + "description": "Layout of the n-patch: 3x3, 1x3 or 3x1" + } + ] + }, + { + "name": "GlyphInfo", + "description": "GlyphInfo, font characters glyphs info", + "fields": [ + { + "type": "int", + "name": "value", + "description": "Character value (Unicode)" + }, + { + "type": "int", + "name": "offsetX", + "description": "Character offset X when drawing" + }, + { + "type": "int", + "name": "offsetY", + "description": "Character offset Y when drawing" + }, + { + "type": "int", + "name": "advanceX", + "description": "Character advance position X" + }, + { + "type": "Image", + "name": "image", + "description": "Character image data" + } + ] + }, + { + "name": "Font", + "description": "Font, font texture and GlyphInfo array data", + "fields": [ + { + "type": "int", + "name": "baseSize", + "description": "Base size (default chars height)" + }, + { + "type": "int", + "name": "glyphCount", + "description": "Number of glyph characters" + }, + { + "type": "int", + "name": "glyphPadding", + "description": "Padding around the glyph characters" + }, + { + "type": "Texture2D", + "name": "texture", + "description": "Texture atlas containing the glyphs" + }, + { + "type": "Rectangle *", + "name": "recs", + "description": "Rectangles in texture for the glyphs" + }, + { + "type": "GlyphInfo *", + "name": "glyphs", + "description": "Glyphs info data" + } + ] + }, + { + "name": "Camera3D", + "description": "Camera, defines position/orientation in 3d space", + "fields": [ + { + "type": "Vector3", + "name": "position", + "description": "Camera position" + }, + { + "type": "Vector3", + "name": "target", + "description": "Camera target it looks-at" + }, + { + "type": "Vector3", + "name": "up", + "description": "Camera up vector (rotation over its axis)" + }, + { + "type": "float", + "name": "fovy", + "description": "Camera field-of-view aperture in Y (degrees) in perspective, used as near plane width in orthographic" + }, + { + "type": "int", + "name": "projection", + "description": "Camera projection: CAMERA_PERSPECTIVE or CAMERA_ORTHOGRAPHIC" + } + ] + }, + { + "name": "Camera2D", + "description": "Camera2D, defines position/orientation in 2d space", + "fields": [ + { + "type": "Vector2", + "name": "offset", + "description": "Camera offset (displacement from target)" + }, + { + "type": "Vector2", + "name": "target", + "description": "Camera target (rotation and zoom origin)" + }, + { + "type": "float", + "name": "rotation", + "description": "Camera rotation in degrees" + }, + { + "type": "float", + "name": "zoom", + "description": "Camera zoom (scaling), should be 1.0f by default" + } + ] + }, + { + "name": "Mesh", + "description": "Mesh, vertex data and vao/vbo", + "fields": [ + { + "type": "int", + "name": "vertexCount", + "description": "Number of vertices stored in arrays" + }, + { + "type": "int", + "name": "triangleCount", + "description": "Number of triangles stored (indexed or not)" + }, + { + "type": "float *", + "name": "vertices", + "description": "Vertex position (XYZ - 3 components per vertex) (shader-location = 0)" + }, + { + "type": "float *", + "name": "texcoords", + "description": "Vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1)" + }, + { + "type": "float *", + "name": "texcoords2", + "description": "Vertex texture second coordinates (UV - 2 components per vertex) (shader-location = 5)" + }, + { + "type": "float *", + "name": "normals", + "description": "Vertex normals (XYZ - 3 components per vertex) (shader-location = 2)" + }, + { + "type": "float *", + "name": "tangents", + "description": "Vertex tangents (XYZW - 4 components per vertex) (shader-location = 4)" + }, + { + "type": "unsigned char *", + "name": "colors", + "description": "Vertex colors (RGBA - 4 components per vertex) (shader-location = 3)" + }, + { + "type": "unsigned short *", + "name": "indices", + "description": "Vertex indices (in case vertex data comes indexed)" + }, + { + "type": "float *", + "name": "animVertices", + "description": "Animated vertex positions (after bones transformations)" + }, + { + "type": "float *", + "name": "animNormals", + "description": "Animated normals (after bones transformations)" + }, + { + "type": "unsigned char *", + "name": "boneIds", + "description": "Vertex bone ids, max 255 bone ids, up to 4 bones influence by vertex (skinning)" + }, + { + "type": "float *", + "name": "boneWeights", + "description": "Vertex bone weight, up to 4 bones influence by vertex (skinning)" + }, + { + "type": "unsigned int", + "name": "vaoId", + "description": "OpenGL Vertex Array Object id" + }, + { + "type": "unsigned int *", + "name": "vboId", + "description": "OpenGL Vertex Buffer Objects id (default vertex data)" + } + ] + }, + { + "name": "Shader", + "description": "Shader", + "fields": [ + { + "type": "unsigned int", + "name": "id", + "description": "Shader program id" + }, + { + "type": "int *", + "name": "locs", + "description": "Shader locations array (RL_MAX_SHADER_LOCATIONS)" + } + ] + }, + { + "name": "MaterialMap", + "description": "MaterialMap", + "fields": [ + { + "type": "Texture2D", + "name": "texture", + "description": "Material map texture" + }, + { + "type": "Color", + "name": "color", + "description": "Material map color" + }, + { + "type": "float", + "name": "value", + "description": "Material map value" + } + ] + }, + { + "name": "Material", + "description": "Material, includes shader and maps", + "fields": [ + { + "type": "Shader", + "name": "shader", + "description": "Material shader" + }, + { + "type": "MaterialMap *", + "name": "maps", + "description": "Material maps array (MAX_MATERIAL_MAPS)" + }, + { + "type": "float[4]", + "name": "params", + "description": "Material generic parameters (if required)" + } + ] + }, + { + "name": "Transform", + "description": "Transform, vertex transformation data", + "fields": [ + { + "type": "Vector3", + "name": "translation", + "description": "Translation" + }, + { + "type": "Quaternion", + "name": "rotation", + "description": "Rotation" + }, + { + "type": "Vector3", + "name": "scale", + "description": "Scale" + } + ] + }, + { + "name": "BoneInfo", + "description": "Bone, skeletal animation bone", + "fields": [ + { + "type": "char[32]", + "name": "name", + "description": "Bone name" + }, + { + "type": "int", + "name": "parent", + "description": "Bone parent" + } + ] + }, + { + "name": "Model", + "description": "Model, meshes, materials and animation data", + "fields": [ + { + "type": "Matrix", + "name": "transform", + "description": "Local transform matrix" + }, + { + "type": "int", + "name": "meshCount", + "description": "Number of meshes" + }, + { + "type": "int", + "name": "materialCount", + "description": "Number of materials" + }, + { + "type": "Mesh *", + "name": "meshes", + "description": "Meshes array" + }, + { + "type": "Material *", + "name": "materials", + "description": "Materials array" + }, + { + "type": "int *", + "name": "meshMaterial", + "description": "Mesh material number" + }, + { + "type": "int", + "name": "boneCount", + "description": "Number of bones" + }, + { + "type": "BoneInfo *", + "name": "bones", + "description": "Bones information (skeleton)" + }, + { + "type": "Transform *", + "name": "bindPose", + "description": "Bones base transformation (pose)" + } + ] + }, + { + "name": "ModelAnimation", + "description": "ModelAnimation", + "fields": [ + { + "type": "int", + "name": "boneCount", + "description": "Number of bones" + }, + { + "type": "int", + "name": "frameCount", + "description": "Number of animation frames" + }, + { + "type": "BoneInfo *", + "name": "bones", + "description": "Bones information (skeleton)" + }, + { + "type": "Transform **", + "name": "framePoses", + "description": "Poses array by frame" + }, + { + "type": "char[32]", + "name": "name", + "description": "Animation name" + } + ] + }, + { + "name": "Ray", + "description": "Ray, ray for raycasting", + "fields": [ + { + "type": "Vector3", + "name": "position", + "description": "Ray position (origin)" + }, + { + "type": "Vector3", + "name": "direction", + "description": "Ray direction" + } + ] + }, + { + "name": "RayCollision", + "description": "RayCollision, ray hit information", + "fields": [ + { + "type": "bool", + "name": "hit", + "description": "Did the ray hit something?" + }, + { + "type": "float", + "name": "distance", + "description": "Distance to the nearest hit" + }, + { + "type": "Vector3", + "name": "point", + "description": "Point of the nearest hit" + }, + { + "type": "Vector3", + "name": "normal", + "description": "Surface normal of hit" + } + ] + }, + { + "name": "BoundingBox", + "description": "BoundingBox", + "fields": [ + { + "type": "Vector3", + "name": "min", + "description": "Minimum vertex box-corner" + }, + { + "type": "Vector3", + "name": "max", + "description": "Maximum vertex box-corner" + } + ] + }, + { + "name": "Wave", + "description": "Wave, audio wave data", + "fields": [ + { + "type": "unsigned int", + "name": "frameCount", + "description": "Total number of frames (considering channels)" + }, + { + "type": "unsigned int", + "name": "sampleRate", + "description": "Frequency (samples per second)" + }, + { + "type": "unsigned int", + "name": "sampleSize", + "description": "Bit depth (bits per sample): 8, 16, 32 (24 not supported)" + }, + { + "type": "unsigned int", + "name": "channels", + "description": "Number of channels (1-mono, 2-stereo, ...)" + }, + { + "type": "void *", + "name": "data", + "description": "Buffer data pointer" + } + ] + }, + { + "name": "AudioStream", + "description": "AudioStream, custom audio stream", + "fields": [ + { + "type": "rAudioBuffer *", + "name": "buffer", + "description": "Pointer to internal data used by the audio system" + }, + { + "type": "rAudioProcessor *", + "name": "processor", + "description": "Pointer to internal data processor, useful for audio effects" + }, + { + "type": "unsigned int", + "name": "sampleRate", + "description": "Frequency (samples per second)" + }, + { + "type": "unsigned int", + "name": "sampleSize", + "description": "Bit depth (bits per sample): 8, 16, 32 (24 not supported)" + }, + { + "type": "unsigned int", + "name": "channels", + "description": "Number of channels (1-mono, 2-stereo, ...)" + } + ] + }, + { + "name": "Sound", + "description": "Sound", + "fields": [ + { + "type": "AudioStream", + "name": "stream", + "description": "Audio stream" + }, + { + "type": "unsigned int", + "name": "frameCount", + "description": "Total number of frames (considering channels)" + } + ] + }, + { + "name": "Music", + "description": "Music, audio stream, anything longer than ~10 seconds should be streamed", + "fields": [ + { + "type": "AudioStream", + "name": "stream", + "description": "Audio stream" + }, + { + "type": "unsigned int", + "name": "frameCount", + "description": "Total number of frames (considering channels)" + }, + { + "type": "bool", + "name": "looping", + "description": "Music looping enable" + }, + { + "type": "int", + "name": "ctxType", + "description": "Type of music context (audio filetype)" + }, + { + "type": "void *", + "name": "ctxData", + "description": "Audio context data, depends on type" + } + ] + }, + { + "name": "VrDeviceInfo", + "description": "VrDeviceInfo, Head-Mounted-Display device parameters", + "fields": [ + { + "type": "int", + "name": "hResolution", + "description": "Horizontal resolution in pixels" + }, + { + "type": "int", + "name": "vResolution", + "description": "Vertical resolution in pixels" + }, + { + "type": "float", + "name": "hScreenSize", + "description": "Horizontal size in meters" + }, + { + "type": "float", + "name": "vScreenSize", + "description": "Vertical size in meters" + }, + { + "type": "float", + "name": "vScreenCenter", + "description": "Screen center in meters" + }, + { + "type": "float", + "name": "eyeToScreenDistance", + "description": "Distance between eye and display in meters" + }, + { + "type": "float", + "name": "lensSeparationDistance", + "description": "Lens separation distance in meters" + }, + { + "type": "float", + "name": "interpupillaryDistance", + "description": "IPD (distance between pupils) in meters" + }, + { + "type": "float[4]", + "name": "lensDistortionValues", + "description": "Lens distortion constant parameters" + }, + { + "type": "float[4]", + "name": "chromaAbCorrection", + "description": "Chromatic aberration correction parameters" + } + ] + }, + { + "name": "VrStereoConfig", + "description": "VrStereoConfig, VR stereo rendering configuration for simulator", + "fields": [ + { + "type": "Matrix[2]", + "name": "projection", + "description": "VR projection matrices (per eye)" + }, + { + "type": "Matrix[2]", + "name": "viewOffset", + "description": "VR view offset matrices (per eye)" + }, + { + "type": "float[2]", + "name": "leftLensCenter", + "description": "VR left lens center" + }, + { + "type": "float[2]", + "name": "rightLensCenter", + "description": "VR right lens center" + }, + { + "type": "float[2]", + "name": "leftScreenCenter", + "description": "VR left screen center" + }, + { + "type": "float[2]", + "name": "rightScreenCenter", + "description": "VR right screen center" + }, + { + "type": "float[2]", + "name": "scale", + "description": "VR distortion scale" + }, + { + "type": "float[2]", + "name": "scaleIn", + "description": "VR distortion scale in" + } + ] + }, + { + "name": "FilePathList", + "description": "File path list", + "fields": [ + { + "type": "unsigned int", + "name": "capacity", + "description": "Filepaths max entries" + }, + { + "type": "unsigned int", + "name": "count", + "description": "Filepaths entries count" + }, + { + "type": "char **", + "name": "paths", + "description": "Filepaths entries" + } + ] + }, + { + "name": "AutomationEvent", + "description": "Automation event", + "fields": [ + { + "type": "unsigned int", + "name": "frame", + "description": "Event frame" + }, + { + "type": "unsigned int", + "name": "type", + "description": "Event type (AutomationEventType)" + }, + { + "type": "int[4]", + "name": "params", + "description": "Event parameters (if required)" + } + ] + }, + { + "name": "AutomationEventList", + "description": "Automation event list", + "fields": [ + { + "type": "unsigned int", + "name": "capacity", + "description": "Events max entries (MAX_AUTOMATION_EVENTS)" + }, + { + "type": "unsigned int", + "name": "count", + "description": "Events entries count" + }, + { + "type": "AutomationEvent *", + "name": "events", + "description": "Events entries" + } + ] + } + ], + "aliases": [ + { + "type": "Vector4", + "name": "Quaternion", + "description": "Quaternion, 4 components (Vector4 alias)" + }, + { + "type": "Texture", + "name": "Texture2D", + "description": "Texture2D, same as Texture" + }, + { + "type": "Texture", + "name": "TextureCubemap", + "description": "TextureCubemap, same as Texture" + }, + { + "type": "RenderTexture", + "name": "RenderTexture2D", + "description": "RenderTexture2D, same as RenderTexture" + }, + { + "type": "Camera3D", + "name": "Camera", + "description": "Camera type fallback, defaults to Camera3D" + } + ], + "enums": [ + { + "name": "ConfigFlags", + "description": "System/Window config flags", + "values": [ + { + "name": "FLAG_VSYNC_HINT", + "value": 64, + "description": "Set to try enabling V-Sync on GPU" + }, + { + "name": "FLAG_FULLSCREEN_MODE", + "value": 2, + "description": "Set to run program in fullscreen" + }, + { + "name": "FLAG_WINDOW_RESIZABLE", + "value": 4, + "description": "Set to allow resizable window" + }, + { + "name": "FLAG_WINDOW_UNDECORATED", + "value": 8, + "description": "Set to disable window decoration (frame and buttons)" + }, + { + "name": "FLAG_WINDOW_HIDDEN", + "value": 128, + "description": "Set to hide window" + }, + { + "name": "FLAG_WINDOW_MINIMIZED", + "value": 512, + "description": "Set to minimize window (iconify)" + }, + { + "name": "FLAG_WINDOW_MAXIMIZED", + "value": 1024, + "description": "Set to maximize window (expanded to monitor)" + }, + { + "name": "FLAG_WINDOW_UNFOCUSED", + "value": 2048, + "description": "Set to window non focused" + }, + { + "name": "FLAG_WINDOW_TOPMOST", + "value": 4096, + "description": "Set to window always on top" + }, + { + "name": "FLAG_WINDOW_ALWAYS_RUN", + "value": 256, + "description": "Set to allow windows running while minimized" + }, + { + "name": "FLAG_WINDOW_TRANSPARENT", + "value": 16, + "description": "Set to allow transparent framebuffer" + }, + { + "name": "FLAG_WINDOW_HIGHDPI", + "value": 8192, + "description": "Set to support HighDPI" + }, + { + "name": "FLAG_WINDOW_MOUSE_PASSTHROUGH", + "value": 16384, + "description": "Set to support mouse passthrough, only supported when FLAG_WINDOW_UNDECORATED" + }, + { + "name": "FLAG_BORDERLESS_WINDOWED_MODE", + "value": 32768, + "description": "Set to run program in borderless windowed mode" + }, + { + "name": "FLAG_MSAA_4X_HINT", + "value": 32, + "description": "Set to try enabling MSAA 4X" + }, + { + "name": "FLAG_INTERLACED_HINT", + "value": 65536, + "description": "Set to try enabling interlaced video format (for V3D)" + } + ] + }, + { + "name": "TraceLogLevel", + "description": "Trace log level", + "values": [ + { + "name": "LOG_ALL", + "value": 0, + "description": "Display all logs" + }, + { + "name": "LOG_TRACE", + "value": 1, + "description": "Trace logging, intended for internal use only" + }, + { + "name": "LOG_DEBUG", + "value": 2, + "description": "Debug logging, used for internal debugging, it should be disabled on release builds" + }, + { + "name": "LOG_INFO", + "value": 3, + "description": "Info logging, used for program execution info" + }, + { + "name": "LOG_WARNING", + "value": 4, + "description": "Warning logging, used on recoverable failures" + }, + { + "name": "LOG_ERROR", + "value": 5, + "description": "Error logging, used on unrecoverable failures" + }, + { + "name": "LOG_FATAL", + "value": 6, + "description": "Fatal logging, used to abort program: exit(EXIT_FAILURE)" + }, + { + "name": "LOG_NONE", + "value": 7, + "description": "Disable logging" + } + ] + }, + { + "name": "KeyboardKey", + "description": "Keyboard keys (US keyboard layout)", + "values": [ + { + "name": "KEY_NULL", + "value": 0, + "description": "Key: NULL, used for no key pressed" + }, + { + "name": "KEY_APOSTROPHE", + "value": 39, + "description": "Key: '" + }, + { + "name": "KEY_COMMA", + "value": 44, + "description": "Key: ," + }, + { + "name": "KEY_MINUS", + "value": 45, + "description": "Key: -" + }, + { + "name": "KEY_PERIOD", + "value": 46, + "description": "Key: ." + }, + { + "name": "KEY_SLASH", + "value": 47, + "description": "Key: /" + }, + { + "name": "KEY_ZERO", + "value": 48, + "description": "Key: 0" + }, + { + "name": "KEY_ONE", + "value": 49, + "description": "Key: 1" + }, + { + "name": "KEY_TWO", + "value": 50, + "description": "Key: 2" + }, + { + "name": "KEY_THREE", + "value": 51, + "description": "Key: 3" + }, + { + "name": "KEY_FOUR", + "value": 52, + "description": "Key: 4" + }, + { + "name": "KEY_FIVE", + "value": 53, + "description": "Key: 5" + }, + { + "name": "KEY_SIX", + "value": 54, + "description": "Key: 6" + }, + { + "name": "KEY_SEVEN", + "value": 55, + "description": "Key: 7" + }, + { + "name": "KEY_EIGHT", + "value": 56, + "description": "Key: 8" + }, + { + "name": "KEY_NINE", + "value": 57, + "description": "Key: 9" + }, + { + "name": "KEY_SEMICOLON", + "value": 59, + "description": "Key: ;" + }, + { + "name": "KEY_EQUAL", + "value": 61, + "description": "Key: =" + }, + { + "name": "KEY_A", + "value": 65, + "description": "Key: A | a" + }, + { + "name": "KEY_B", + "value": 66, + "description": "Key: B | b" + }, + { + "name": "KEY_C", + "value": 67, + "description": "Key: C | c" + }, + { + "name": "KEY_D", + "value": 68, + "description": "Key: D | d" + }, + { + "name": "KEY_E", + "value": 69, + "description": "Key: E | e" + }, + { + "name": "KEY_F", + "value": 70, + "description": "Key: F | f" + }, + { + "name": "KEY_G", + "value": 71, + "description": "Key: G | g" + }, + { + "name": "KEY_H", + "value": 72, + "description": "Key: H | h" + }, + { + "name": "KEY_I", + "value": 73, + "description": "Key: I | i" + }, + { + "name": "KEY_J", + "value": 74, + "description": "Key: J | j" + }, + { + "name": "KEY_K", + "value": 75, + "description": "Key: K | k" + }, + { + "name": "KEY_L", + "value": 76, + "description": "Key: L | l" + }, + { + "name": "KEY_M", + "value": 77, + "description": "Key: M | m" + }, + { + "name": "KEY_N", + "value": 78, + "description": "Key: N | n" + }, + { + "name": "KEY_O", + "value": 79, + "description": "Key: O | o" + }, + { + "name": "KEY_P", + "value": 80, + "description": "Key: P | p" + }, + { + "name": "KEY_Q", + "value": 81, + "description": "Key: Q | q" + }, + { + "name": "KEY_R", + "value": 82, + "description": "Key: R | r" + }, + { + "name": "KEY_S", + "value": 83, + "description": "Key: S | s" + }, + { + "name": "KEY_T", + "value": 84, + "description": "Key: T | t" + }, + { + "name": "KEY_U", + "value": 85, + "description": "Key: U | u" + }, + { + "name": "KEY_V", + "value": 86, + "description": "Key: V | v" + }, + { + "name": "KEY_W", + "value": 87, + "description": "Key: W | w" + }, + { + "name": "KEY_X", + "value": 88, + "description": "Key: X | x" + }, + { + "name": "KEY_Y", + "value": 89, + "description": "Key: Y | y" + }, + { + "name": "KEY_Z", + "value": 90, + "description": "Key: Z | z" + }, + { + "name": "KEY_LEFT_BRACKET", + "value": 91, + "description": "Key: [" + }, + { + "name": "KEY_BACKSLASH", + "value": 92, + "description": "Key: '\\'" + }, + { + "name": "KEY_RIGHT_BRACKET", + "value": 93, + "description": "Key: ]" + }, + { + "name": "KEY_GRAVE", + "value": 96, + "description": "Key: `" + }, + { + "name": "KEY_SPACE", + "value": 32, + "description": "Key: Space" + }, + { + "name": "KEY_ESCAPE", + "value": 256, + "description": "Key: Esc" + }, + { + "name": "KEY_ENTER", + "value": 257, + "description": "Key: Enter" + }, + { + "name": "KEY_TAB", + "value": 258, + "description": "Key: Tab" + }, + { + "name": "KEY_BACKSPACE", + "value": 259, + "description": "Key: Backspace" + }, + { + "name": "KEY_INSERT", + "value": 260, + "description": "Key: Ins" + }, + { + "name": "KEY_DELETE", + "value": 261, + "description": "Key: Del" + }, + { + "name": "KEY_RIGHT", + "value": 262, + "description": "Key: Cursor right" + }, + { + "name": "KEY_LEFT", + "value": 263, + "description": "Key: Cursor left" + }, + { + "name": "KEY_DOWN", + "value": 264, + "description": "Key: Cursor down" + }, + { + "name": "KEY_UP", + "value": 265, + "description": "Key: Cursor up" + }, + { + "name": "KEY_PAGE_UP", + "value": 266, + "description": "Key: Page up" + }, + { + "name": "KEY_PAGE_DOWN", + "value": 267, + "description": "Key: Page down" + }, + { + "name": "KEY_HOME", + "value": 268, + "description": "Key: Home" + }, + { + "name": "KEY_END", + "value": 269, + "description": "Key: End" + }, + { + "name": "KEY_CAPS_LOCK", + "value": 280, + "description": "Key: Caps lock" + }, + { + "name": "KEY_SCROLL_LOCK", + "value": 281, + "description": "Key: Scroll down" + }, + { + "name": "KEY_NUM_LOCK", + "value": 282, + "description": "Key: Num lock" + }, + { + "name": "KEY_PRINT_SCREEN", + "value": 283, + "description": "Key: Print screen" + }, + { + "name": "KEY_PAUSE", + "value": 284, + "description": "Key: Pause" + }, + { + "name": "KEY_F1", + "value": 290, + "description": "Key: F1" + }, + { + "name": "KEY_F2", + "value": 291, + "description": "Key: F2" + }, + { + "name": "KEY_F3", + "value": 292, + "description": "Key: F3" + }, + { + "name": "KEY_F4", + "value": 293, + "description": "Key: F4" + }, + { + "name": "KEY_F5", + "value": 294, + "description": "Key: F5" + }, + { + "name": "KEY_F6", + "value": 295, + "description": "Key: F6" + }, + { + "name": "KEY_F7", + "value": 296, + "description": "Key: F7" + }, + { + "name": "KEY_F8", + "value": 297, + "description": "Key: F8" + }, + { + "name": "KEY_F9", + "value": 298, + "description": "Key: F9" + }, + { + "name": "KEY_F10", + "value": 299, + "description": "Key: F10" + }, + { + "name": "KEY_F11", + "value": 300, + "description": "Key: F11" + }, + { + "name": "KEY_F12", + "value": 301, + "description": "Key: F12" + }, + { + "name": "KEY_LEFT_SHIFT", + "value": 340, + "description": "Key: Shift left" + }, + { + "name": "KEY_LEFT_CONTROL", + "value": 341, + "description": "Key: Control left" + }, + { + "name": "KEY_LEFT_ALT", + "value": 342, + "description": "Key: Alt left" + }, + { + "name": "KEY_LEFT_SUPER", + "value": 343, + "description": "Key: Super left" + }, + { + "name": "KEY_RIGHT_SHIFT", + "value": 344, + "description": "Key: Shift right" + }, + { + "name": "KEY_RIGHT_CONTROL", + "value": 345, + "description": "Key: Control right" + }, + { + "name": "KEY_RIGHT_ALT", + "value": 346, + "description": "Key: Alt right" + }, + { + "name": "KEY_RIGHT_SUPER", + "value": 347, + "description": "Key: Super right" + }, + { + "name": "KEY_KB_MENU", + "value": 348, + "description": "Key: KB menu" + }, + { + "name": "KEY_KP_0", + "value": 320, + "description": "Key: Keypad 0" + }, + { + "name": "KEY_KP_1", + "value": 321, + "description": "Key: Keypad 1" + }, + { + "name": "KEY_KP_2", + "value": 322, + "description": "Key: Keypad 2" + }, + { + "name": "KEY_KP_3", + "value": 323, + "description": "Key: Keypad 3" + }, + { + "name": "KEY_KP_4", + "value": 324, + "description": "Key: Keypad 4" + }, + { + "name": "KEY_KP_5", + "value": 325, + "description": "Key: Keypad 5" + }, + { + "name": "KEY_KP_6", + "value": 326, + "description": "Key: Keypad 6" + }, + { + "name": "KEY_KP_7", + "value": 327, + "description": "Key: Keypad 7" + }, + { + "name": "KEY_KP_8", + "value": 328, + "description": "Key: Keypad 8" + }, + { + "name": "KEY_KP_9", + "value": 329, + "description": "Key: Keypad 9" + }, + { + "name": "KEY_KP_DECIMAL", + "value": 330, + "description": "Key: Keypad ." + }, + { + "name": "KEY_KP_DIVIDE", + "value": 331, + "description": "Key: Keypad /" + }, + { + "name": "KEY_KP_MULTIPLY", + "value": 332, + "description": "Key: Keypad *" + }, + { + "name": "KEY_KP_SUBTRACT", + "value": 333, + "description": "Key: Keypad -" + }, + { + "name": "KEY_KP_ADD", + "value": 334, + "description": "Key: Keypad +" + }, + { + "name": "KEY_KP_ENTER", + "value": 335, + "description": "Key: Keypad Enter" + }, + { + "name": "KEY_KP_EQUAL", + "value": 336, + "description": "Key: Keypad =" + }, + { + "name": "KEY_BACK", + "value": 4, + "description": "Key: Android back button" + }, + { + "name": "KEY_MENU", + "value": 82, + "description": "Key: Android menu button" + }, + { + "name": "KEY_VOLUME_UP", + "value": 24, + "description": "Key: Android volume up button" + }, + { + "name": "KEY_VOLUME_DOWN", + "value": 25, + "description": "Key: Android volume down button" + } + ] + }, + { + "name": "MouseButton", + "description": "Mouse buttons", + "values": [ + { + "name": "MOUSE_BUTTON_LEFT", + "value": 0, + "description": "Mouse button left" + }, + { + "name": "MOUSE_BUTTON_RIGHT", + "value": 1, + "description": "Mouse button right" + }, + { + "name": "MOUSE_BUTTON_MIDDLE", + "value": 2, + "description": "Mouse button middle (pressed wheel)" + }, + { + "name": "MOUSE_BUTTON_SIDE", + "value": 3, + "description": "Mouse button side (advanced mouse device)" + }, + { + "name": "MOUSE_BUTTON_EXTRA", + "value": 4, + "description": "Mouse button extra (advanced mouse device)" + }, + { + "name": "MOUSE_BUTTON_FORWARD", + "value": 5, + "description": "Mouse button forward (advanced mouse device)" + }, + { + "name": "MOUSE_BUTTON_BACK", + "value": 6, + "description": "Mouse button back (advanced mouse device)" + } + ] + }, + { + "name": "MouseCursor", + "description": "Mouse cursor", + "values": [ + { + "name": "MOUSE_CURSOR_DEFAULT", + "value": 0, + "description": "Default pointer shape" + }, + { + "name": "MOUSE_CURSOR_ARROW", + "value": 1, + "description": "Arrow shape" + }, + { + "name": "MOUSE_CURSOR_IBEAM", + "value": 2, + "description": "Text writing cursor shape" + }, + { + "name": "MOUSE_CURSOR_CROSSHAIR", + "value": 3, + "description": "Cross shape" + }, + { + "name": "MOUSE_CURSOR_POINTING_HAND", + "value": 4, + "description": "Pointing hand cursor" + }, + { + "name": "MOUSE_CURSOR_RESIZE_EW", + "value": 5, + "description": "Horizontal resize/move arrow shape" + }, + { + "name": "MOUSE_CURSOR_RESIZE_NS", + "value": 6, + "description": "Vertical resize/move arrow shape" + }, + { + "name": "MOUSE_CURSOR_RESIZE_NWSE", + "value": 7, + "description": "Top-left to bottom-right diagonal resize/move arrow shape" + }, + { + "name": "MOUSE_CURSOR_RESIZE_NESW", + "value": 8, + "description": "The top-right to bottom-left diagonal resize/move arrow shape" + }, + { + "name": "MOUSE_CURSOR_RESIZE_ALL", + "value": 9, + "description": "The omnidirectional resize/move cursor shape" + }, + { + "name": "MOUSE_CURSOR_NOT_ALLOWED", + "value": 10, + "description": "The operation-not-allowed shape" + } + ] + }, + { + "name": "GamepadButton", + "description": "Gamepad buttons", + "values": [ + { + "name": "GAMEPAD_BUTTON_UNKNOWN", + "value": 0, + "description": "Unknown button, just for error checking" + }, + { + "name": "GAMEPAD_BUTTON_LEFT_FACE_UP", + "value": 1, + "description": "Gamepad left DPAD up button" + }, + { + "name": "GAMEPAD_BUTTON_LEFT_FACE_RIGHT", + "value": 2, + "description": "Gamepad left DPAD right button" + }, + { + "name": "GAMEPAD_BUTTON_LEFT_FACE_DOWN", + "value": 3, + "description": "Gamepad left DPAD down button" + }, + { + "name": "GAMEPAD_BUTTON_LEFT_FACE_LEFT", + "value": 4, + "description": "Gamepad left DPAD left button" + }, + { + "name": "GAMEPAD_BUTTON_RIGHT_FACE_UP", + "value": 5, + "description": "Gamepad right button up (i.e. PS3: Triangle, Xbox: Y)" + }, + { + "name": "GAMEPAD_BUTTON_RIGHT_FACE_RIGHT", + "value": 6, + "description": "Gamepad right button right (i.e. PS3: Square, Xbox: X)" + }, + { + "name": "GAMEPAD_BUTTON_RIGHT_FACE_DOWN", + "value": 7, + "description": "Gamepad right button down (i.e. PS3: Cross, Xbox: A)" + }, + { + "name": "GAMEPAD_BUTTON_RIGHT_FACE_LEFT", + "value": 8, + "description": "Gamepad right button left (i.e. PS3: Circle, Xbox: B)" + }, + { + "name": "GAMEPAD_BUTTON_LEFT_TRIGGER_1", + "value": 9, + "description": "Gamepad top/back trigger left (first), it could be a trailing button" + }, + { + "name": "GAMEPAD_BUTTON_LEFT_TRIGGER_2", + "value": 10, + "description": "Gamepad top/back trigger left (second), it could be a trailing button" + }, + { + "name": "GAMEPAD_BUTTON_RIGHT_TRIGGER_1", + "value": 11, + "description": "Gamepad top/back trigger right (one), it could be a trailing button" + }, + { + "name": "GAMEPAD_BUTTON_RIGHT_TRIGGER_2", + "value": 12, + "description": "Gamepad top/back trigger right (second), it could be a trailing button" + }, + { + "name": "GAMEPAD_BUTTON_MIDDLE_LEFT", + "value": 13, + "description": "Gamepad center buttons, left one (i.e. PS3: Select)" + }, + { + "name": "GAMEPAD_BUTTON_MIDDLE", + "value": 14, + "description": "Gamepad center buttons, middle one (i.e. PS3: PS, Xbox: XBOX)" + }, + { + "name": "GAMEPAD_BUTTON_MIDDLE_RIGHT", + "value": 15, + "description": "Gamepad center buttons, right one (i.e. PS3: Start)" + }, + { + "name": "GAMEPAD_BUTTON_LEFT_THUMB", + "value": 16, + "description": "Gamepad joystick pressed button left" + }, + { + "name": "GAMEPAD_BUTTON_RIGHT_THUMB", + "value": 17, + "description": "Gamepad joystick pressed button right" + } + ] + }, + { + "name": "GamepadAxis", + "description": "Gamepad axis", + "values": [ + { + "name": "GAMEPAD_AXIS_LEFT_X", + "value": 0, + "description": "Gamepad left stick X axis" + }, + { + "name": "GAMEPAD_AXIS_LEFT_Y", + "value": 1, + "description": "Gamepad left stick Y axis" + }, + { + "name": "GAMEPAD_AXIS_RIGHT_X", + "value": 2, + "description": "Gamepad right stick X axis" + }, + { + "name": "GAMEPAD_AXIS_RIGHT_Y", + "value": 3, + "description": "Gamepad right stick Y axis" + }, + { + "name": "GAMEPAD_AXIS_LEFT_TRIGGER", + "value": 4, + "description": "Gamepad back trigger left, pressure level: [1..-1]" + }, + { + "name": "GAMEPAD_AXIS_RIGHT_TRIGGER", + "value": 5, + "description": "Gamepad back trigger right, pressure level: [1..-1]" + } + ] + }, + { + "name": "MaterialMapIndex", + "description": "Material map index", + "values": [ + { + "name": "MATERIAL_MAP_ALBEDO", + "value": 0, + "description": "Albedo material (same as: MATERIAL_MAP_DIFFUSE)" + }, + { + "name": "MATERIAL_MAP_METALNESS", + "value": 1, + "description": "Metalness material (same as: MATERIAL_MAP_SPECULAR)" + }, + { + "name": "MATERIAL_MAP_NORMAL", + "value": 2, + "description": "Normal material" + }, + { + "name": "MATERIAL_MAP_ROUGHNESS", + "value": 3, + "description": "Roughness material" + }, + { + "name": "MATERIAL_MAP_OCCLUSION", + "value": 4, + "description": "Ambient occlusion material" + }, + { + "name": "MATERIAL_MAP_EMISSION", + "value": 5, + "description": "Emission material" + }, + { + "name": "MATERIAL_MAP_HEIGHT", + "value": 6, + "description": "Heightmap material" + }, + { + "name": "MATERIAL_MAP_CUBEMAP", + "value": 7, + "description": "Cubemap material (NOTE: Uses GL_TEXTURE_CUBE_MAP)" + }, + { + "name": "MATERIAL_MAP_IRRADIANCE", + "value": 8, + "description": "Irradiance material (NOTE: Uses GL_TEXTURE_CUBE_MAP)" + }, + { + "name": "MATERIAL_MAP_PREFILTER", + "value": 9, + "description": "Prefilter material (NOTE: Uses GL_TEXTURE_CUBE_MAP)" + }, + { + "name": "MATERIAL_MAP_BRDF", + "value": 10, + "description": "Brdf material" + } + ] + }, + { + "name": "ShaderLocationIndex", + "description": "Shader location index", + "values": [ + { + "name": "SHADER_LOC_VERTEX_POSITION", + "value": 0, + "description": "Shader location: vertex attribute: position" + }, + { + "name": "SHADER_LOC_VERTEX_TEXCOORD01", + "value": 1, + "description": "Shader location: vertex attribute: texcoord01" + }, + { + "name": "SHADER_LOC_VERTEX_TEXCOORD02", + "value": 2, + "description": "Shader location: vertex attribute: texcoord02" + }, + { + "name": "SHADER_LOC_VERTEX_NORMAL", + "value": 3, + "description": "Shader location: vertex attribute: normal" + }, + { + "name": "SHADER_LOC_VERTEX_TANGENT", + "value": 4, + "description": "Shader location: vertex attribute: tangent" + }, + { + "name": "SHADER_LOC_VERTEX_COLOR", + "value": 5, + "description": "Shader location: vertex attribute: color" + }, + { + "name": "SHADER_LOC_MATRIX_MVP", + "value": 6, + "description": "Shader location: matrix uniform: model-view-projection" + }, + { + "name": "SHADER_LOC_MATRIX_VIEW", + "value": 7, + "description": "Shader location: matrix uniform: view (camera transform)" + }, + { + "name": "SHADER_LOC_MATRIX_PROJECTION", + "value": 8, + "description": "Shader location: matrix uniform: projection" + }, + { + "name": "SHADER_LOC_MATRIX_MODEL", + "value": 9, + "description": "Shader location: matrix uniform: model (transform)" + }, + { + "name": "SHADER_LOC_MATRIX_NORMAL", + "value": 10, + "description": "Shader location: matrix uniform: normal" + }, + { + "name": "SHADER_LOC_VECTOR_VIEW", + "value": 11, + "description": "Shader location: vector uniform: view" + }, + { + "name": "SHADER_LOC_COLOR_DIFFUSE", + "value": 12, + "description": "Shader location: vector uniform: diffuse color" + }, + { + "name": "SHADER_LOC_COLOR_SPECULAR", + "value": 13, + "description": "Shader location: vector uniform: specular color" + }, + { + "name": "SHADER_LOC_COLOR_AMBIENT", + "value": 14, + "description": "Shader location: vector uniform: ambient color" + }, + { + "name": "SHADER_LOC_MAP_ALBEDO", + "value": 15, + "description": "Shader location: sampler2d texture: albedo (same as: SHADER_LOC_MAP_DIFFUSE)" + }, + { + "name": "SHADER_LOC_MAP_METALNESS", + "value": 16, + "description": "Shader location: sampler2d texture: metalness (same as: SHADER_LOC_MAP_SPECULAR)" + }, + { + "name": "SHADER_LOC_MAP_NORMAL", + "value": 17, + "description": "Shader location: sampler2d texture: normal" + }, + { + "name": "SHADER_LOC_MAP_ROUGHNESS", + "value": 18, + "description": "Shader location: sampler2d texture: roughness" + }, + { + "name": "SHADER_LOC_MAP_OCCLUSION", + "value": 19, + "description": "Shader location: sampler2d texture: occlusion" + }, + { + "name": "SHADER_LOC_MAP_EMISSION", + "value": 20, + "description": "Shader location: sampler2d texture: emission" + }, + { + "name": "SHADER_LOC_MAP_HEIGHT", + "value": 21, + "description": "Shader location: sampler2d texture: height" + }, + { + "name": "SHADER_LOC_MAP_CUBEMAP", + "value": 22, + "description": "Shader location: samplerCube texture: cubemap" + }, + { + "name": "SHADER_LOC_MAP_IRRADIANCE", + "value": 23, + "description": "Shader location: samplerCube texture: irradiance" + }, + { + "name": "SHADER_LOC_MAP_PREFILTER", + "value": 24, + "description": "Shader location: samplerCube texture: prefilter" + }, + { + "name": "SHADER_LOC_MAP_BRDF", + "value": 25, + "description": "Shader location: sampler2d texture: brdf" + } + ] + }, + { + "name": "ShaderUniformDataType", + "description": "Shader uniform data type", + "values": [ + { + "name": "SHADER_UNIFORM_FLOAT", + "value": 0, + "description": "Shader uniform type: float" + }, + { + "name": "SHADER_UNIFORM_VEC2", + "value": 1, + "description": "Shader uniform type: vec2 (2 float)" + }, + { + "name": "SHADER_UNIFORM_VEC3", + "value": 2, + "description": "Shader uniform type: vec3 (3 float)" + }, + { + "name": "SHADER_UNIFORM_VEC4", + "value": 3, + "description": "Shader uniform type: vec4 (4 float)" + }, + { + "name": "SHADER_UNIFORM_INT", + "value": 4, + "description": "Shader uniform type: int" + }, + { + "name": "SHADER_UNIFORM_IVEC2", + "value": 5, + "description": "Shader uniform type: ivec2 (2 int)" + }, + { + "name": "SHADER_UNIFORM_IVEC3", + "value": 6, + "description": "Shader uniform type: ivec3 (3 int)" + }, + { + "name": "SHADER_UNIFORM_IVEC4", + "value": 7, + "description": "Shader uniform type: ivec4 (4 int)" + }, + { + "name": "SHADER_UNIFORM_SAMPLER2D", + "value": 8, + "description": "Shader uniform type: sampler2d" + } + ] + }, + { + "name": "ShaderAttributeDataType", + "description": "Shader attribute data types", + "values": [ + { + "name": "SHADER_ATTRIB_FLOAT", + "value": 0, + "description": "Shader attribute type: float" + }, + { + "name": "SHADER_ATTRIB_VEC2", + "value": 1, + "description": "Shader attribute type: vec2 (2 float)" + }, + { + "name": "SHADER_ATTRIB_VEC3", + "value": 2, + "description": "Shader attribute type: vec3 (3 float)" + }, + { + "name": "SHADER_ATTRIB_VEC4", + "value": 3, + "description": "Shader attribute type: vec4 (4 float)" + } + ] + }, + { + "name": "PixelFormat", + "description": "Pixel formats", + "values": [ + { + "name": "PIXELFORMAT_UNCOMPRESSED_GRAYSCALE", + "value": 1, + "description": "8 bit per pixel (no alpha)" + }, + { + "name": "PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA", + "value": 2, + "description": "8*2 bpp (2 channels)" + }, + { + "name": "PIXELFORMAT_UNCOMPRESSED_R5G6B5", + "value": 3, + "description": "16 bpp" + }, + { + "name": "PIXELFORMAT_UNCOMPRESSED_R8G8B8", + "value": 4, + "description": "24 bpp" + }, + { + "name": "PIXELFORMAT_UNCOMPRESSED_R5G5B5A1", + "value": 5, + "description": "16 bpp (1 bit alpha)" + }, + { + "name": "PIXELFORMAT_UNCOMPRESSED_R4G4B4A4", + "value": 6, + "description": "16 bpp (4 bit alpha)" + }, + { + "name": "PIXELFORMAT_UNCOMPRESSED_R8G8B8A8", + "value": 7, + "description": "32 bpp" + }, + { + "name": "PIXELFORMAT_UNCOMPRESSED_R32", + "value": 8, + "description": "32 bpp (1 channel - float)" + }, + { + "name": "PIXELFORMAT_UNCOMPRESSED_R32G32B32", + "value": 9, + "description": "32*3 bpp (3 channels - float)" + }, + { + "name": "PIXELFORMAT_UNCOMPRESSED_R32G32B32A32", + "value": 10, + "description": "32*4 bpp (4 channels - float)" + }, + { + "name": "PIXELFORMAT_UNCOMPRESSED_R16", + "value": 11, + "description": "16 bpp (1 channel - half float)" + }, + { + "name": "PIXELFORMAT_UNCOMPRESSED_R16G16B16", + "value": 12, + "description": "16*3 bpp (3 channels - half float)" + }, + { + "name": "PIXELFORMAT_UNCOMPRESSED_R16G16B16A16", + "value": 13, + "description": "16*4 bpp (4 channels - half float)" + }, + { + "name": "PIXELFORMAT_COMPRESSED_DXT1_RGB", + "value": 14, + "description": "4 bpp (no alpha)" + }, + { + "name": "PIXELFORMAT_COMPRESSED_DXT1_RGBA", + "value": 15, + "description": "4 bpp (1 bit alpha)" + }, + { + "name": "PIXELFORMAT_COMPRESSED_DXT3_RGBA", + "value": 16, + "description": "8 bpp" + }, + { + "name": "PIXELFORMAT_COMPRESSED_DXT5_RGBA", + "value": 17, + "description": "8 bpp" + }, + { + "name": "PIXELFORMAT_COMPRESSED_ETC1_RGB", + "value": 18, + "description": "4 bpp" + }, + { + "name": "PIXELFORMAT_COMPRESSED_ETC2_RGB", + "value": 19, + "description": "4 bpp" + }, + { + "name": "PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA", + "value": 20, + "description": "8 bpp" + }, + { + "name": "PIXELFORMAT_COMPRESSED_PVRT_RGB", + "value": 21, + "description": "4 bpp" + }, + { + "name": "PIXELFORMAT_COMPRESSED_PVRT_RGBA", + "value": 22, + "description": "4 bpp" + }, + { + "name": "PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA", + "value": 23, + "description": "8 bpp" + }, + { + "name": "PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA", + "value": 24, + "description": "2 bpp" + } + ] + }, + { + "name": "TextureFilter", + "description": "Texture parameters: filter mode", + "values": [ + { + "name": "TEXTURE_FILTER_POINT", + "value": 0, + "description": "No filter, just pixel approximation" + }, + { + "name": "TEXTURE_FILTER_BILINEAR", + "value": 1, + "description": "Linear filtering" + }, + { + "name": "TEXTURE_FILTER_TRILINEAR", + "value": 2, + "description": "Trilinear filtering (linear with mipmaps)" + }, + { + "name": "TEXTURE_FILTER_ANISOTROPIC_4X", + "value": 3, + "description": "Anisotropic filtering 4x" + }, + { + "name": "TEXTURE_FILTER_ANISOTROPIC_8X", + "value": 4, + "description": "Anisotropic filtering 8x" + }, + { + "name": "TEXTURE_FILTER_ANISOTROPIC_16X", + "value": 5, + "description": "Anisotropic filtering 16x" + } + ] + }, + { + "name": "TextureWrap", + "description": "Texture parameters: wrap mode", + "values": [ + { + "name": "TEXTURE_WRAP_REPEAT", + "value": 0, + "description": "Repeats texture in tiled mode" + }, + { + "name": "TEXTURE_WRAP_CLAMP", + "value": 1, + "description": "Clamps texture to edge pixel in tiled mode" + }, + { + "name": "TEXTURE_WRAP_MIRROR_REPEAT", + "value": 2, + "description": "Mirrors and repeats the texture in tiled mode" + }, + { + "name": "TEXTURE_WRAP_MIRROR_CLAMP", + "value": 3, + "description": "Mirrors and clamps to border the texture in tiled mode" + } + ] + }, + { + "name": "CubemapLayout", + "description": "Cubemap layouts", + "values": [ + { + "name": "CUBEMAP_LAYOUT_AUTO_DETECT", + "value": 0, + "description": "Automatically detect layout type" + }, + { + "name": "CUBEMAP_LAYOUT_LINE_VERTICAL", + "value": 1, + "description": "Layout is defined by a vertical line with faces" + }, + { + "name": "CUBEMAP_LAYOUT_LINE_HORIZONTAL", + "value": 2, + "description": "Layout is defined by a horizontal line with faces" + }, + { + "name": "CUBEMAP_LAYOUT_CROSS_THREE_BY_FOUR", + "value": 3, + "description": "Layout is defined by a 3x4 cross with cubemap faces" + }, + { + "name": "CUBEMAP_LAYOUT_CROSS_FOUR_BY_THREE", + "value": 4, + "description": "Layout is defined by a 4x3 cross with cubemap faces" + }, + { + "name": "CUBEMAP_LAYOUT_PANORAMA", + "value": 5, + "description": "Layout is defined by a panorama image (equirrectangular map)" + } + ] + }, + { + "name": "FontType", + "description": "Font type, defines generation method", + "values": [ + { + "name": "FONT_DEFAULT", + "value": 0, + "description": "Default font generation, anti-aliased" + }, + { + "name": "FONT_BITMAP", + "value": 1, + "description": "Bitmap font generation, no anti-aliasing" + }, + { + "name": "FONT_SDF", + "value": 2, + "description": "SDF font generation, requires external shader" + } + ] + }, + { + "name": "BlendMode", + "description": "Color blending modes (pre-defined)", + "values": [ + { + "name": "BLEND_ALPHA", + "value": 0, + "description": "Blend textures considering alpha (default)" + }, + { + "name": "BLEND_ADDITIVE", + "value": 1, + "description": "Blend textures adding colors" + }, + { + "name": "BLEND_MULTIPLIED", + "value": 2, + "description": "Blend textures multiplying colors" + }, + { + "name": "BLEND_ADD_COLORS", + "value": 3, + "description": "Blend textures adding colors (alternative)" + }, + { + "name": "BLEND_SUBTRACT_COLORS", + "value": 4, + "description": "Blend textures subtracting colors (alternative)" + }, + { + "name": "BLEND_ALPHA_PREMULTIPLY", + "value": 5, + "description": "Blend premultiplied textures considering alpha" + }, + { + "name": "BLEND_CUSTOM", + "value": 6, + "description": "Blend textures using custom src/dst factors (use rlSetBlendFactors())" + }, + { + "name": "BLEND_CUSTOM_SEPARATE", + "value": 7, + "description": "Blend textures using custom rgb/alpha separate src/dst factors (use rlSetBlendFactorsSeparate())" + } + ] + }, + { + "name": "Gesture", + "description": "Gesture", + "values": [ + { + "name": "GESTURE_NONE", + "value": 0, + "description": "No gesture" + }, + { + "name": "GESTURE_TAP", + "value": 1, + "description": "Tap gesture" + }, + { + "name": "GESTURE_DOUBLETAP", + "value": 2, + "description": "Double tap gesture" + }, + { + "name": "GESTURE_HOLD", + "value": 4, + "description": "Hold gesture" + }, + { + "name": "GESTURE_DRAG", + "value": 8, + "description": "Drag gesture" + }, + { + "name": "GESTURE_SWIPE_RIGHT", + "value": 16, + "description": "Swipe right gesture" + }, + { + "name": "GESTURE_SWIPE_LEFT", + "value": 32, + "description": "Swipe left gesture" + }, + { + "name": "GESTURE_SWIPE_UP", + "value": 64, + "description": "Swipe up gesture" + }, + { + "name": "GESTURE_SWIPE_DOWN", + "value": 128, + "description": "Swipe down gesture" + }, + { + "name": "GESTURE_PINCH_IN", + "value": 256, + "description": "Pinch in gesture" + }, + { + "name": "GESTURE_PINCH_OUT", + "value": 512, + "description": "Pinch out gesture" + } + ] + }, + { + "name": "CameraMode", + "description": "Camera system modes", + "values": [ + { + "name": "CAMERA_CUSTOM", + "value": 0, + "description": "Custom camera" + }, + { + "name": "CAMERA_FREE", + "value": 1, + "description": "Free camera" + }, + { + "name": "CAMERA_ORBITAL", + "value": 2, + "description": "Orbital camera" + }, + { + "name": "CAMERA_FIRST_PERSON", + "value": 3, + "description": "First person camera" + }, + { + "name": "CAMERA_THIRD_PERSON", + "value": 4, + "description": "Third person camera" + } + ] + }, + { + "name": "CameraProjection", + "description": "Camera projection", + "values": [ + { + "name": "CAMERA_PERSPECTIVE", + "value": 0, + "description": "Perspective projection" + }, + { + "name": "CAMERA_ORTHOGRAPHIC", + "value": 1, + "description": "Orthographic projection" + } + ] + }, + { + "name": "NPatchLayout", + "description": "N-patch layout", + "values": [ + { + "name": "NPATCH_NINE_PATCH", + "value": 0, + "description": "Npatch layout: 3x3 tiles" + }, + { + "name": "NPATCH_THREE_PATCH_VERTICAL", + "value": 1, + "description": "Npatch layout: 1x3 tiles" + }, + { + "name": "NPATCH_THREE_PATCH_HORIZONTAL", + "value": 2, + "description": "Npatch layout: 3x1 tiles" + } + ] + } + ], + "callbacks": [ + { + "name": "TraceLogCallback", + "description": "Logging: Redirect trace log messages", + "returnType": "void", + "params": [ + { + "type": "int", + "name": "logLevel" + }, + { + "type": "const char *", + "name": "text" + }, + { + "type": "va_list", + "name": "args" + } + ] + }, + { + "name": "LoadFileDataCallback", + "description": "FileIO: Load binary data", + "returnType": "unsigned char *", + "params": [ + { + "type": "const char *", + "name": "fileName" + }, + { + "type": "int *", + "name": "dataSize" + } + ] + }, + { + "name": "SaveFileDataCallback", + "description": "FileIO: Save binary data", + "returnType": "bool", + "params": [ + { + "type": "const char *", + "name": "fileName" + }, + { + "type": "void *", + "name": "data" + }, + { + "type": "int", + "name": "dataSize" + } + ] + }, + { + "name": "LoadFileTextCallback", + "description": "FileIO: Load text data", + "returnType": "char *", + "params": [ + { + "type": "const char *", + "name": "fileName" + } + ] + }, + { + "name": "SaveFileTextCallback", + "description": "FileIO: Save text data", + "returnType": "bool", + "params": [ + { + "type": "const char *", + "name": "fileName" + }, + { + "type": "char *", + "name": "text" + } + ] + }, + { + "name": "AudioCallback", + "description": "", + "returnType": "void", + "params": [ + { + "type": "void *", + "name": "bufferData" + }, + { + "type": "unsigned int", + "name": "frames" + } + ] + } + ], + "functions": [ + { + "name": "InitWindow", + "description": "Initialize window and OpenGL context", + "returnType": "void", + "params": [ + { + "type": "int", + "name": "width" + }, + { + "type": "int", + "name": "height" + }, + { + "type": "const char *", + "name": "title" + } + ] + }, + { + "name": "CloseWindow", + "description": "Close window and unload OpenGL context", + "returnType": "void" + }, + { + "name": "WindowShouldClose", + "description": "Check if application should close (KEY_ESCAPE pressed or windows close icon clicked)", + "returnType": "bool" + }, + { + "name": "IsWindowReady", + "description": "Check if window has been initialized successfully", + "returnType": "bool" + }, + { + "name": "IsWindowFullscreen", + "description": "Check if window is currently fullscreen", + "returnType": "bool" + }, + { + "name": "IsWindowHidden", + "description": "Check if window is currently hidden (only PLATFORM_DESKTOP)", + "returnType": "bool" + }, + { + "name": "IsWindowMinimized", + "description": "Check if window is currently minimized (only PLATFORM_DESKTOP)", + "returnType": "bool" + }, + { + "name": "IsWindowMaximized", + "description": "Check if window is currently maximized (only PLATFORM_DESKTOP)", + "returnType": "bool" + }, + { + "name": "IsWindowFocused", + "description": "Check if window is currently focused (only PLATFORM_DESKTOP)", + "returnType": "bool" + }, + { + "name": "IsWindowResized", + "description": "Check if window has been resized last frame", + "returnType": "bool" + }, + { + "name": "IsWindowState", + "description": "Check if one specific window flag is enabled", + "returnType": "bool", + "params": [ + { + "type": "unsigned int", + "name": "flag" + } + ] + }, + { + "name": "SetWindowState", + "description": "Set window configuration state using flags (only PLATFORM_DESKTOP)", + "returnType": "void", + "params": [ + { + "type": "unsigned int", + "name": "flags" + } + ] + }, + { + "name": "ClearWindowState", + "description": "Clear window configuration state flags", + "returnType": "void", + "params": [ + { + "type": "unsigned int", + "name": "flags" + } + ] + }, + { + "name": "ToggleFullscreen", + "description": "Toggle window state: fullscreen/windowed (only PLATFORM_DESKTOP)", + "returnType": "void" + }, + { + "name": "ToggleBorderlessWindowed", + "description": "Toggle window state: borderless windowed (only PLATFORM_DESKTOP)", + "returnType": "void" + }, + { + "name": "MaximizeWindow", + "description": "Set window state: maximized, if resizable (only PLATFORM_DESKTOP)", + "returnType": "void" + }, + { + "name": "MinimizeWindow", + "description": "Set window state: minimized, if resizable (only PLATFORM_DESKTOP)", + "returnType": "void" + }, + { + "name": "RestoreWindow", + "description": "Set window state: not minimized/maximized (only PLATFORM_DESKTOP)", + "returnType": "void" + }, + { + "name": "SetWindowIcon", + "description": "Set icon for window (single image, RGBA 32bit, only PLATFORM_DESKTOP)", + "returnType": "void", + "params": [ + { + "type": "Image", + "name": "image" + } + ] + }, + { + "name": "SetWindowIcons", + "description": "Set icon for window (multiple images, RGBA 32bit, only PLATFORM_DESKTOP)", + "returnType": "void", + "params": [ + { + "type": "Image *", + "name": "images" + }, + { + "type": "int", + "name": "count" + } + ] + }, + { + "name": "SetWindowTitle", + "description": "Set title for window (only PLATFORM_DESKTOP and PLATFORM_WEB)", + "returnType": "void", + "params": [ + { + "type": "const char *", + "name": "title" + } + ] + }, + { + "name": "SetWindowPosition", + "description": "Set window position on screen (only PLATFORM_DESKTOP)", + "returnType": "void", + "params": [ + { + "type": "int", + "name": "x" + }, + { + "type": "int", + "name": "y" + } + ] + }, + { + "name": "SetWindowMonitor", + "description": "Set monitor for the current window", + "returnType": "void", + "params": [ + { + "type": "int", + "name": "monitor" + } + ] + }, + { + "name": "SetWindowMinSize", + "description": "Set window minimum dimensions (for FLAG_WINDOW_RESIZABLE)", + "returnType": "void", + "params": [ + { + "type": "int", + "name": "width" + }, + { + "type": "int", + "name": "height" + } + ] + }, + { + "name": "SetWindowMaxSize", + "description": "Set window maximum dimensions (for FLAG_WINDOW_RESIZABLE)", + "returnType": "void", + "params": [ + { + "type": "int", + "name": "width" + }, + { + "type": "int", + "name": "height" + } + ] + }, + { + "name": "SetWindowSize", + "description": "Set window dimensions", + "returnType": "void", + "params": [ + { + "type": "int", + "name": "width" + }, + { + "type": "int", + "name": "height" + } + ] + }, + { + "name": "SetWindowOpacity", + "description": "Set window opacity [0.0f..1.0f] (only PLATFORM_DESKTOP)", + "returnType": "void", + "params": [ + { + "type": "float", + "name": "opacity" + } + ] + }, + { + "name": "SetWindowFocused", + "description": "Set window focused (only PLATFORM_DESKTOP)", + "returnType": "void" + }, + { + "name": "GetWindowHandle", + "description": "Get native window handle", + "returnType": "void *" + }, + { + "name": "GetScreenWidth", + "description": "Get current screen width", + "returnType": "int" + }, + { + "name": "GetScreenHeight", + "description": "Get current screen height", + "returnType": "int" + }, + { + "name": "GetRenderWidth", + "description": "Get current render width (it considers HiDPI)", + "returnType": "int" + }, + { + "name": "GetRenderHeight", + "description": "Get current render height (it considers HiDPI)", + "returnType": "int" + }, + { + "name": "GetMonitorCount", + "description": "Get number of connected monitors", + "returnType": "int" + }, + { + "name": "GetCurrentMonitor", + "description": "Get current connected monitor", + "returnType": "int" + }, + { + "name": "GetMonitorPosition", + "description": "Get specified monitor position", + "returnType": "Vector2", + "params": [ + { + "type": "int", + "name": "monitor" + } + ] + }, + { + "name": "GetMonitorWidth", + "description": "Get specified monitor width (current video mode used by monitor)", + "returnType": "int", + "params": [ + { + "type": "int", + "name": "monitor" + } + ] + }, + { + "name": "GetMonitorHeight", + "description": "Get specified monitor height (current video mode used by monitor)", + "returnType": "int", + "params": [ + { + "type": "int", + "name": "monitor" + } + ] + }, + { + "name": "GetMonitorPhysicalWidth", + "description": "Get specified monitor physical width in millimetres", + "returnType": "int", + "params": [ + { + "type": "int", + "name": "monitor" + } + ] + }, + { + "name": "GetMonitorPhysicalHeight", + "description": "Get specified monitor physical height in millimetres", + "returnType": "int", + "params": [ + { + "type": "int", + "name": "monitor" + } + ] + }, + { + "name": "GetMonitorRefreshRate", + "description": "Get specified monitor refresh rate", + "returnType": "int", + "params": [ + { + "type": "int", + "name": "monitor" + } + ] + }, + { + "name": "GetWindowPosition", + "description": "Get window position XY on monitor", + "returnType": "Vector2" + }, + { + "name": "GetWindowScaleDPI", + "description": "Get window scale DPI factor", + "returnType": "Vector2" + }, + { + "name": "GetMonitorName", + "description": "Get the human-readable, UTF-8 encoded name of the specified monitor", + "returnType": "const char *", + "params": [ + { + "type": "int", + "name": "monitor" + } + ] + }, + { + "name": "SetClipboardText", + "description": "Set clipboard text content", + "returnType": "void", + "params": [ + { + "type": "const char *", + "name": "text" + } + ] + }, + { + "name": "GetClipboardText", + "description": "Get clipboard text content", + "returnType": "const char *" + }, + { + "name": "EnableEventWaiting", + "description": "Enable waiting for events on EndDrawing(), no automatic event polling", + "returnType": "void" + }, + { + "name": "DisableEventWaiting", + "description": "Disable waiting for events on EndDrawing(), automatic events polling", + "returnType": "void" + }, + { + "name": "ShowCursor", + "description": "Shows cursor", + "returnType": "void" + }, + { + "name": "HideCursor", + "description": "Hides cursor", + "returnType": "void" + }, + { + "name": "IsCursorHidden", + "description": "Check if cursor is not visible", + "returnType": "bool" + }, + { + "name": "EnableCursor", + "description": "Enables cursor (unlock cursor)", + "returnType": "void" + }, + { + "name": "DisableCursor", + "description": "Disables cursor (lock cursor)", + "returnType": "void" + }, + { + "name": "IsCursorOnScreen", + "description": "Check if cursor is on the screen", + "returnType": "bool" + }, + { + "name": "ClearBackground", + "description": "Set background color (framebuffer clear color)", + "returnType": "void", + "params": [ + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "BeginDrawing", + "description": "Setup canvas (framebuffer) to start drawing", + "returnType": "void" + }, + { + "name": "EndDrawing", + "description": "End canvas drawing and swap buffers (double buffering)", + "returnType": "void" + }, + { + "name": "BeginMode2D", + "description": "Begin 2D mode with custom camera (2D)", + "returnType": "void", + "params": [ + { + "type": "Camera2D", + "name": "camera" + } + ] + }, + { + "name": "EndMode2D", + "description": "Ends 2D mode with custom camera", + "returnType": "void" + }, + { + "name": "BeginMode3D", + "description": "Begin 3D mode with custom camera (3D)", + "returnType": "void", + "params": [ + { + "type": "Camera3D", + "name": "camera" + } + ] + }, + { + "name": "EndMode3D", + "description": "Ends 3D mode and returns to default 2D orthographic mode", + "returnType": "void" + }, + { + "name": "BeginTextureMode", + "description": "Begin drawing to render texture", + "returnType": "void", + "params": [ + { + "type": "RenderTexture2D", + "name": "target" + } + ] + }, + { + "name": "EndTextureMode", + "description": "Ends drawing to render texture", + "returnType": "void" + }, + { + "name": "BeginShaderMode", + "description": "Begin custom shader drawing", + "returnType": "void", + "params": [ + { + "type": "Shader", + "name": "shader" + } + ] + }, + { + "name": "EndShaderMode", + "description": "End custom shader drawing (use default shader)", + "returnType": "void" + }, + { + "name": "BeginBlendMode", + "description": "Begin blending mode (alpha, additive, multiplied, subtract, custom)", + "returnType": "void", + "params": [ + { + "type": "int", + "name": "mode" + } + ] + }, + { + "name": "EndBlendMode", + "description": "End blending mode (reset to default: alpha blending)", + "returnType": "void" + }, + { + "name": "BeginScissorMode", + "description": "Begin scissor mode (define screen area for following drawing)", + "returnType": "void", + "params": [ + { + "type": "int", + "name": "x" + }, + { + "type": "int", + "name": "y" + }, + { + "type": "int", + "name": "width" + }, + { + "type": "int", + "name": "height" + } + ] + }, + { + "name": "EndScissorMode", + "description": "End scissor mode", + "returnType": "void" + }, + { + "name": "BeginVrStereoMode", + "description": "Begin stereo rendering (requires VR simulator)", + "returnType": "void", + "params": [ + { + "type": "VrStereoConfig", + "name": "config" + } + ] + }, + { + "name": "EndVrStereoMode", + "description": "End stereo rendering (requires VR simulator)", + "returnType": "void" + }, + { + "name": "LoadVrStereoConfig", + "description": "Load VR stereo config for VR simulator device parameters", + "returnType": "VrStereoConfig", + "params": [ + { + "type": "VrDeviceInfo", + "name": "device" + } + ] + }, + { + "name": "UnloadVrStereoConfig", + "description": "Unload VR stereo config", + "returnType": "void", + "params": [ + { + "type": "VrStereoConfig", + "name": "config" + } + ] + }, + { + "name": "LoadShader", + "description": "Load shader from files and bind default locations", + "returnType": "Shader", + "params": [ + { + "type": "const char *", + "name": "vsFileName" + }, + { + "type": "const char *", + "name": "fsFileName" + } + ] + }, + { + "name": "LoadShaderFromMemory", + "description": "Load shader from code strings and bind default locations", + "returnType": "Shader", + "params": [ + { + "type": "const char *", + "name": "vsCode" + }, + { + "type": "const char *", + "name": "fsCode" + } + ] + }, + { + "name": "IsShaderReady", + "description": "Check if a shader is ready", + "returnType": "bool", + "params": [ + { + "type": "Shader", + "name": "shader" + } + ] + }, + { + "name": "GetShaderLocation", + "description": "Get shader uniform location", + "returnType": "int", + "params": [ + { + "type": "Shader", + "name": "shader" + }, + { + "type": "const char *", + "name": "uniformName" + } + ] + }, + { + "name": "GetShaderLocationAttrib", + "description": "Get shader attribute location", + "returnType": "int", + "params": [ + { + "type": "Shader", + "name": "shader" + }, + { + "type": "const char *", + "name": "attribName" + } + ] + }, + { + "name": "SetShaderValue", + "description": "Set shader uniform value", + "returnType": "void", + "params": [ + { + "type": "Shader", + "name": "shader" + }, + { + "type": "int", + "name": "locIndex" + }, + { + "type": "const void *", + "name": "value" + }, + { + "type": "int", + "name": "uniformType" + } + ] + }, + { + "name": "SetShaderValueV", + "description": "Set shader uniform value vector", + "returnType": "void", + "params": [ + { + "type": "Shader", + "name": "shader" + }, + { + "type": "int", + "name": "locIndex" + }, + { + "type": "const void *", + "name": "value" + }, + { + "type": "int", + "name": "uniformType" + }, + { + "type": "int", + "name": "count" + } + ] + }, + { + "name": "SetShaderValueMatrix", + "description": "Set shader uniform value (matrix 4x4)", + "returnType": "void", + "params": [ + { + "type": "Shader", + "name": "shader" + }, + { + "type": "int", + "name": "locIndex" + }, + { + "type": "Matrix", + "name": "mat" + } + ] + }, + { + "name": "SetShaderValueTexture", + "description": "Set shader uniform value for texture (sampler2d)", + "returnType": "void", + "params": [ + { + "type": "Shader", + "name": "shader" + }, + { + "type": "int", + "name": "locIndex" + }, + { + "type": "Texture2D", + "name": "texture" + } + ] + }, + { + "name": "UnloadShader", + "description": "Unload shader from GPU memory (VRAM)", + "returnType": "void", + "params": [ + { + "type": "Shader", + "name": "shader" + } + ] + }, + { + "name": "GetMouseRay", + "description": "Get a ray trace from mouse position", + "returnType": "Ray", + "params": [ + { + "type": "Vector2", + "name": "mousePosition" + }, + { + "type": "Camera", + "name": "camera" + } + ] + }, + { + "name": "GetCameraMatrix", + "description": "Get camera transform matrix (view matrix)", + "returnType": "Matrix", + "params": [ + { + "type": "Camera", + "name": "camera" + } + ] + }, + { + "name": "GetCameraMatrix2D", + "description": "Get camera 2d transform matrix", + "returnType": "Matrix", + "params": [ + { + "type": "Camera2D", + "name": "camera" + } + ] + }, + { + "name": "GetWorldToScreen", + "description": "Get the screen space position for a 3d world space position", + "returnType": "Vector2", + "params": [ + { + "type": "Vector3", + "name": "position" + }, + { + "type": "Camera", + "name": "camera" + } + ] + }, + { + "name": "GetScreenToWorld2D", + "description": "Get the world space position for a 2d camera screen space position", + "returnType": "Vector2", + "params": [ + { + "type": "Vector2", + "name": "position" + }, + { + "type": "Camera2D", + "name": "camera" + } + ] + }, + { + "name": "GetWorldToScreenEx", + "description": "Get size position for a 3d world space position", + "returnType": "Vector2", + "params": [ + { + "type": "Vector3", + "name": "position" + }, + { + "type": "Camera", + "name": "camera" + }, + { + "type": "int", + "name": "width" + }, + { + "type": "int", + "name": "height" + } + ] + }, + { + "name": "GetWorldToScreen2D", + "description": "Get the screen space position for a 2d camera world space position", + "returnType": "Vector2", + "params": [ + { + "type": "Vector2", + "name": "position" + }, + { + "type": "Camera2D", + "name": "camera" + } + ] + }, + { + "name": "SetTargetFPS", + "description": "Set target FPS (maximum)", + "returnType": "void", + "params": [ + { + "type": "int", + "name": "fps" + } + ] + }, + { + "name": "GetFrameTime", + "description": "Get time in seconds for last frame drawn (delta time)", + "returnType": "float" + }, + { + "name": "GetTime", + "description": "Get elapsed time in seconds since InitWindow()", + "returnType": "double" + }, + { + "name": "GetFPS", + "description": "Get current FPS", + "returnType": "int" + }, + { + "name": "SwapScreenBuffer", + "description": "Swap back buffer with front buffer (screen drawing)", + "returnType": "void" + }, + { + "name": "PollInputEvents", + "description": "Register all input events", + "returnType": "void" + }, + { + "name": "WaitTime", + "description": "Wait for some time (halt program execution)", + "returnType": "void", + "params": [ + { + "type": "double", + "name": "seconds" + } + ] + }, + { + "name": "SetRandomSeed", + "description": "Set the seed for the random number generator", + "returnType": "void", + "params": [ + { + "type": "unsigned int", + "name": "seed" + } + ] + }, + { + "name": "GetRandomValue", + "description": "Get a random value between min and max (both included)", + "returnType": "int", + "params": [ + { + "type": "int", + "name": "min" + }, + { + "type": "int", + "name": "max" + } + ] + }, + { + "name": "LoadRandomSequence", + "description": "Load random values sequence, no values repeated", + "returnType": "int *", + "params": [ + { + "type": "unsigned int", + "name": "count" + }, + { + "type": "int", + "name": "min" + }, + { + "type": "int", + "name": "max" + } + ] + }, + { + "name": "UnloadRandomSequence", + "description": "Unload random values sequence", + "returnType": "void", + "params": [ + { + "type": "int *", + "name": "sequence" + } + ] + }, + { + "name": "TakeScreenshot", + "description": "Takes a screenshot of current screen (filename extension defines format)", + "returnType": "void", + "params": [ + { + "type": "const char *", + "name": "fileName" + } + ] + }, + { + "name": "SetConfigFlags", + "description": "Setup init configuration flags (view FLAGS)", + "returnType": "void", + "params": [ + { + "type": "unsigned int", + "name": "flags" + } + ] + }, + { + "name": "OpenURL", + "description": "Open URL with default system browser (if available)", + "returnType": "void", + "params": [ + { + "type": "const char *", + "name": "url" + } + ] + }, + { + "name": "TraceLog", + "description": "Show trace log messages (LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERROR...)", + "returnType": "void", + "params": [ + { + "type": "int", + "name": "logLevel" + }, + { + "type": "const char *", + "name": "text" + }, + { + "type": "...", + "name": "args" + } + ] + }, + { + "name": "SetTraceLogLevel", + "description": "Set the current threshold (minimum) log level", + "returnType": "void", + "params": [ + { + "type": "int", + "name": "logLevel" + } + ] + }, + { + "name": "MemAlloc", + "description": "Internal memory allocator", + "returnType": "void *", + "params": [ + { + "type": "unsigned int", + "name": "size" + } + ] + }, + { + "name": "MemRealloc", + "description": "Internal memory reallocator", + "returnType": "void *", + "params": [ + { + "type": "void *", + "name": "ptr" + }, + { + "type": "unsigned int", + "name": "size" + } + ] + }, + { + "name": "MemFree", + "description": "Internal memory free", + "returnType": "void", + "params": [ + { + "type": "void *", + "name": "ptr" + } + ] + }, + { + "name": "SetTraceLogCallback", + "description": "Set custom trace log", + "returnType": "void", + "params": [ + { + "type": "TraceLogCallback", + "name": "callback" + } + ] + }, + { + "name": "SetLoadFileDataCallback", + "description": "Set custom file binary data loader", + "returnType": "void", + "params": [ + { + "type": "LoadFileDataCallback", + "name": "callback" + } + ] + }, + { + "name": "SetSaveFileDataCallback", + "description": "Set custom file binary data saver", + "returnType": "void", + "params": [ + { + "type": "SaveFileDataCallback", + "name": "callback" + } + ] + }, + { + "name": "SetLoadFileTextCallback", + "description": "Set custom file text data loader", + "returnType": "void", + "params": [ + { + "type": "LoadFileTextCallback", + "name": "callback" + } + ] + }, + { + "name": "SetSaveFileTextCallback", + "description": "Set custom file text data saver", + "returnType": "void", + "params": [ + { + "type": "SaveFileTextCallback", + "name": "callback" + } + ] + }, + { + "name": "LoadFileData", + "description": "Load file data as byte array (read)", + "returnType": "unsigned char *", + "params": [ + { + "type": "const char *", + "name": "fileName" + }, + { + "type": "int *", + "name": "dataSize" + } + ] + }, + { + "name": "UnloadFileData", + "description": "Unload file data allocated by LoadFileData()", + "returnType": "void", + "params": [ + { + "type": "unsigned char *", + "name": "data" + } + ] + }, + { + "name": "SaveFileData", + "description": "Save data to file from byte array (write), returns true on success", + "returnType": "bool", + "params": [ + { + "type": "const char *", + "name": "fileName" + }, + { + "type": "void *", + "name": "data" + }, + { + "type": "int", + "name": "dataSize" + } + ] + }, + { + "name": "ExportDataAsCode", + "description": "Export data to code (.h), returns true on success", + "returnType": "bool", + "params": [ + { + "type": "const unsigned char *", + "name": "data" + }, + { + "type": "int", + "name": "dataSize" + }, + { + "type": "const char *", + "name": "fileName" + } + ] + }, + { + "name": "LoadFileText", + "description": "Load text data from file (read), returns a '\\0' terminated string", + "returnType": "char *", + "params": [ + { + "type": "const char *", + "name": "fileName" + } + ] + }, + { + "name": "UnloadFileText", + "description": "Unload file text data allocated by LoadFileText()", + "returnType": "void", + "params": [ + { + "type": "char *", + "name": "text" + } + ] + }, + { + "name": "SaveFileText", + "description": "Save text data to file (write), string must be '\\0' terminated, returns true on success", + "returnType": "bool", + "params": [ + { + "type": "const char *", + "name": "fileName" + }, + { + "type": "char *", + "name": "text" + } + ] + }, + { + "name": "FileExists", + "description": "Check if file exists", + "returnType": "bool", + "params": [ + { + "type": "const char *", + "name": "fileName" + } + ] + }, + { + "name": "DirectoryExists", + "description": "Check if a directory path exists", + "returnType": "bool", + "params": [ + { + "type": "const char *", + "name": "dirPath" + } + ] + }, + { + "name": "IsFileExtension", + "description": "Check file extension (including point: .png, .wav)", + "returnType": "bool", + "params": [ + { + "type": "const char *", + "name": "fileName" + }, + { + "type": "const char *", + "name": "ext" + } + ] + }, + { + "name": "GetFileLength", + "description": "Get file length in bytes (NOTE: GetFileSize() conflicts with windows.h)", + "returnType": "int", + "params": [ + { + "type": "const char *", + "name": "fileName" + } + ] + }, + { + "name": "GetFileExtension", + "description": "Get pointer to extension for a filename string (includes dot: '.png')", + "returnType": "const char *", + "params": [ + { + "type": "const char *", + "name": "fileName" + } + ] + }, + { + "name": "GetFileName", + "description": "Get pointer to filename for a path string", + "returnType": "const char *", + "params": [ + { + "type": "const char *", + "name": "filePath" + } + ] + }, + { + "name": "GetFileNameWithoutExt", + "description": "Get filename string without extension (uses static string)", + "returnType": "const char *", + "params": [ + { + "type": "const char *", + "name": "filePath" + } + ] + }, + { + "name": "GetDirectoryPath", + "description": "Get full path for a given fileName with path (uses static string)", + "returnType": "const char *", + "params": [ + { + "type": "const char *", + "name": "filePath" + } + ] + }, + { + "name": "GetPrevDirectoryPath", + "description": "Get previous directory path for a given path (uses static string)", + "returnType": "const char *", + "params": [ + { + "type": "const char *", + "name": "dirPath" + } + ] + }, + { + "name": "GetWorkingDirectory", + "description": "Get current working directory (uses static string)", + "returnType": "const char *" + }, + { + "name": "GetApplicationDirectory", + "description": "Get the directory of the running application (uses static string)", + "returnType": "const char *" + }, + { + "name": "ChangeDirectory", + "description": "Change working directory, return true on success", + "returnType": "bool", + "params": [ + { + "type": "const char *", + "name": "dir" + } + ] + }, + { + "name": "IsPathFile", + "description": "Check if a given path is a file or a directory", + "returnType": "bool", + "params": [ + { + "type": "const char *", + "name": "path" + } + ] + }, + { + "name": "LoadDirectoryFiles", + "description": "Load directory filepaths", + "returnType": "FilePathList", + "params": [ + { + "type": "const char *", + "name": "dirPath" + } + ] + }, + { + "name": "LoadDirectoryFilesEx", + "description": "Load directory filepaths with extension filtering and recursive directory scan", + "returnType": "FilePathList", + "params": [ + { + "type": "const char *", + "name": "basePath" + }, + { + "type": "const char *", + "name": "filter" + }, + { + "type": "bool", + "name": "scanSubdirs" + } + ] + }, + { + "name": "UnloadDirectoryFiles", + "description": "Unload filepaths", + "returnType": "void", + "params": [ + { + "type": "FilePathList", + "name": "files" + } + ] + }, + { + "name": "IsFileDropped", + "description": "Check if a file has been dropped into window", + "returnType": "bool" + }, + { + "name": "LoadDroppedFiles", + "description": "Load dropped filepaths", + "returnType": "FilePathList" + }, + { + "name": "UnloadDroppedFiles", + "description": "Unload dropped filepaths", + "returnType": "void", + "params": [ + { + "type": "FilePathList", + "name": "files" + } + ] + }, + { + "name": "GetFileModTime", + "description": "Get file modification time (last write time)", + "returnType": "long", + "params": [ + { + "type": "const char *", + "name": "fileName" + } + ] + }, + { + "name": "CompressData", + "description": "Compress data (DEFLATE algorithm), memory must be MemFree()", + "returnType": "unsigned char *", + "params": [ + { + "type": "const unsigned char *", + "name": "data" + }, + { + "type": "int", + "name": "dataSize" + }, + { + "type": "int *", + "name": "compDataSize" + } + ] + }, + { + "name": "DecompressData", + "description": "Decompress data (DEFLATE algorithm), memory must be MemFree()", + "returnType": "unsigned char *", + "params": [ + { + "type": "const unsigned char *", + "name": "compData" + }, + { + "type": "int", + "name": "compDataSize" + }, + { + "type": "int *", + "name": "dataSize" + } + ] + }, + { + "name": "EncodeDataBase64", + "description": "Encode data to Base64 string, memory must be MemFree()", + "returnType": "char *", + "params": [ + { + "type": "const unsigned char *", + "name": "data" + }, + { + "type": "int", + "name": "dataSize" + }, + { + "type": "int *", + "name": "outputSize" + } + ] + }, + { + "name": "DecodeDataBase64", + "description": "Decode Base64 string data, memory must be MemFree()", + "returnType": "unsigned char *", + "params": [ + { + "type": "const unsigned char *", + "name": "data" + }, + { + "type": "int *", + "name": "outputSize" + } + ] + }, + { + "name": "LoadAutomationEventList", + "description": "Load automation events list from file, NULL for empty list, capacity = MAX_AUTOMATION_EVENTS", + "returnType": "AutomationEventList", + "params": [ + { + "type": "const char *", + "name": "fileName" + } + ] + }, + { + "name": "UnloadAutomationEventList", + "description": "Unload automation events list from file", + "returnType": "void", + "params": [ + { + "type": "AutomationEventList *", + "name": "list" + } + ] + }, + { + "name": "ExportAutomationEventList", + "description": "Export automation events list as text file", + "returnType": "bool", + "params": [ + { + "type": "AutomationEventList", + "name": "list" + }, + { + "type": "const char *", + "name": "fileName" + } + ] + }, + { + "name": "SetAutomationEventList", + "description": "Set automation event list to record to", + "returnType": "void", + "params": [ + { + "type": "AutomationEventList *", + "name": "list" + } + ] + }, + { + "name": "SetAutomationEventBaseFrame", + "description": "Set automation event internal base frame to start recording", + "returnType": "void", + "params": [ + { + "type": "int", + "name": "frame" + } + ] + }, + { + "name": "StartAutomationEventRecording", + "description": "Start recording automation events (AutomationEventList must be set)", + "returnType": "void" + }, + { + "name": "StopAutomationEventRecording", + "description": "Stop recording automation events", + "returnType": "void" + }, + { + "name": "PlayAutomationEvent", + "description": "Play a recorded automation event", + "returnType": "void", + "params": [ + { + "type": "AutomationEvent", + "name": "event" + } + ] + }, + { + "name": "IsKeyPressed", + "description": "Check if a key has been pressed once", + "returnType": "bool", + "params": [ + { + "type": "int", + "name": "key" + } + ] + }, + { + "name": "IsKeyPressedRepeat", + "description": "Check if a key has been pressed again (Only PLATFORM_DESKTOP)", + "returnType": "bool", + "params": [ + { + "type": "int", + "name": "key" + } + ] + }, + { + "name": "IsKeyDown", + "description": "Check if a key is being pressed", + "returnType": "bool", + "params": [ + { + "type": "int", + "name": "key" + } + ] + }, + { + "name": "IsKeyReleased", + "description": "Check if a key has been released once", + "returnType": "bool", + "params": [ + { + "type": "int", + "name": "key" + } + ] + }, + { + "name": "IsKeyUp", + "description": "Check if a key is NOT being pressed", + "returnType": "bool", + "params": [ + { + "type": "int", + "name": "key" + } + ] + }, + { + "name": "GetKeyPressed", + "description": "Get key pressed (keycode), call it multiple times for keys queued, returns 0 when the queue is empty", + "returnType": "int" + }, + { + "name": "GetCharPressed", + "description": "Get char pressed (unicode), call it multiple times for chars queued, returns 0 when the queue is empty", + "returnType": "int" + }, + { + "name": "SetExitKey", + "description": "Set a custom key to exit program (default is ESC)", + "returnType": "void", + "params": [ + { + "type": "int", + "name": "key" + } + ] + }, + { + "name": "IsGamepadAvailable", + "description": "Check if a gamepad is available", + "returnType": "bool", + "params": [ + { + "type": "int", + "name": "gamepad" + } + ] + }, + { + "name": "GetGamepadName", + "description": "Get gamepad internal name id", + "returnType": "const char *", + "params": [ + { + "type": "int", + "name": "gamepad" + } + ] + }, + { + "name": "IsGamepadButtonPressed", + "description": "Check if a gamepad button has been pressed once", + "returnType": "bool", + "params": [ + { + "type": "int", + "name": "gamepad" + }, + { + "type": "int", + "name": "button" + } + ] + }, + { + "name": "IsGamepadButtonDown", + "description": "Check if a gamepad button is being pressed", + "returnType": "bool", + "params": [ + { + "type": "int", + "name": "gamepad" + }, + { + "type": "int", + "name": "button" + } + ] + }, + { + "name": "IsGamepadButtonReleased", + "description": "Check if a gamepad button has been released once", + "returnType": "bool", + "params": [ + { + "type": "int", + "name": "gamepad" + }, + { + "type": "int", + "name": "button" + } + ] + }, + { + "name": "IsGamepadButtonUp", + "description": "Check if a gamepad button is NOT being pressed", + "returnType": "bool", + "params": [ + { + "type": "int", + "name": "gamepad" + }, + { + "type": "int", + "name": "button" + } + ] + }, + { + "name": "GetGamepadButtonPressed", + "description": "Get the last gamepad button pressed", + "returnType": "int" + }, + { + "name": "GetGamepadAxisCount", + "description": "Get gamepad axis count for a gamepad", + "returnType": "int", + "params": [ + { + "type": "int", + "name": "gamepad" + } + ] + }, + { + "name": "GetGamepadAxisMovement", + "description": "Get axis movement value for a gamepad axis", + "returnType": "float", + "params": [ + { + "type": "int", + "name": "gamepad" + }, + { + "type": "int", + "name": "axis" + } + ] + }, + { + "name": "SetGamepadMappings", + "description": "Set internal gamepad mappings (SDL_GameControllerDB)", + "returnType": "int", + "params": [ + { + "type": "const char *", + "name": "mappings" + } + ] + }, + { + "name": "IsMouseButtonPressed", + "description": "Check if a mouse button has been pressed once", + "returnType": "bool", + "params": [ + { + "type": "int", + "name": "button" + } + ] + }, + { + "name": "IsMouseButtonDown", + "description": "Check if a mouse button is being pressed", + "returnType": "bool", + "params": [ + { + "type": "int", + "name": "button" + } + ] + }, + { + "name": "IsMouseButtonReleased", + "description": "Check if a mouse button has been released once", + "returnType": "bool", + "params": [ + { + "type": "int", + "name": "button" + } + ] + }, + { + "name": "IsMouseButtonUp", + "description": "Check if a mouse button is NOT being pressed", + "returnType": "bool", + "params": [ + { + "type": "int", + "name": "button" + } + ] + }, + { + "name": "GetMouseX", + "description": "Get mouse position X", + "returnType": "int" + }, + { + "name": "GetMouseY", + "description": "Get mouse position Y", + "returnType": "int" + }, + { + "name": "GetMousePosition", + "description": "Get mouse position XY", + "returnType": "Vector2" + }, + { + "name": "GetMouseDelta", + "description": "Get mouse delta between frames", + "returnType": "Vector2" + }, + { + "name": "SetMousePosition", + "description": "Set mouse position XY", + "returnType": "void", + "params": [ + { + "type": "int", + "name": "x" + }, + { + "type": "int", + "name": "y" + } + ] + }, + { + "name": "SetMouseOffset", + "description": "Set mouse offset", + "returnType": "void", + "params": [ + { + "type": "int", + "name": "offsetX" + }, + { + "type": "int", + "name": "offsetY" + } + ] + }, + { + "name": "SetMouseScale", + "description": "Set mouse scaling", + "returnType": "void", + "params": [ + { + "type": "float", + "name": "scaleX" + }, + { + "type": "float", + "name": "scaleY" + } + ] + }, + { + "name": "GetMouseWheelMove", + "description": "Get mouse wheel movement for X or Y, whichever is larger", + "returnType": "float" + }, + { + "name": "GetMouseWheelMoveV", + "description": "Get mouse wheel movement for both X and Y", + "returnType": "Vector2" + }, + { + "name": "SetMouseCursor", + "description": "Set mouse cursor", + "returnType": "void", + "params": [ + { + "type": "int", + "name": "cursor" + } + ] + }, + { + "name": "GetTouchX", + "description": "Get touch position X for touch point 0 (relative to screen size)", + "returnType": "int" + }, + { + "name": "GetTouchY", + "description": "Get touch position Y for touch point 0 (relative to screen size)", + "returnType": "int" + }, + { + "name": "GetTouchPosition", + "description": "Get touch position XY for a touch point index (relative to screen size)", + "returnType": "Vector2", + "params": [ + { + "type": "int", + "name": "index" + } + ] + }, + { + "name": "GetTouchPointId", + "description": "Get touch point identifier for given index", + "returnType": "int", + "params": [ + { + "type": "int", + "name": "index" + } + ] + }, + { + "name": "GetTouchPointCount", + "description": "Get number of touch points", + "returnType": "int" + }, + { + "name": "SetGesturesEnabled", + "description": "Enable a set of gestures using flags", + "returnType": "void", + "params": [ + { + "type": "unsigned int", + "name": "flags" + } + ] + }, + { + "name": "IsGestureDetected", + "description": "Check if a gesture have been detected", + "returnType": "bool", + "params": [ + { + "type": "unsigned int", + "name": "gesture" + } + ] + }, + { + "name": "GetGestureDetected", + "description": "Get latest detected gesture", + "returnType": "int" + }, + { + "name": "GetGestureHoldDuration", + "description": "Get gesture hold time in milliseconds", + "returnType": "float" + }, + { + "name": "GetGestureDragVector", + "description": "Get gesture drag vector", + "returnType": "Vector2" + }, + { + "name": "GetGestureDragAngle", + "description": "Get gesture drag angle", + "returnType": "float" + }, + { + "name": "GetGesturePinchVector", + "description": "Get gesture pinch delta", + "returnType": "Vector2" + }, + { + "name": "GetGesturePinchAngle", + "description": "Get gesture pinch angle", + "returnType": "float" + }, + { + "name": "UpdateCamera", + "description": "Update camera position for selected mode", + "returnType": "void", + "params": [ + { + "type": "Camera *", + "name": "camera" + }, + { + "type": "int", + "name": "mode" + } + ] + }, + { + "name": "UpdateCameraPro", + "description": "Update camera movement/rotation", + "returnType": "void", + "params": [ + { + "type": "Camera *", + "name": "camera" + }, + { + "type": "Vector3", + "name": "movement" + }, + { + "type": "Vector3", + "name": "rotation" + }, + { + "type": "float", + "name": "zoom" + } + ] + }, + { + "name": "SetShapesTexture", + "description": "Set texture and rectangle to be used on shapes drawing", + "returnType": "void", + "params": [ + { + "type": "Texture2D", + "name": "texture" + }, + { + "type": "Rectangle", + "name": "source" + } + ] + }, + { + "name": "DrawPixel", + "description": "Draw a pixel", + "returnType": "void", + "params": [ + { + "type": "int", + "name": "posX" + }, + { + "type": "int", + "name": "posY" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawPixelV", + "description": "Draw a pixel (Vector version)", + "returnType": "void", + "params": [ + { + "type": "Vector2", + "name": "position" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawLine", + "description": "Draw a line", + "returnType": "void", + "params": [ + { + "type": "int", + "name": "startPosX" + }, + { + "type": "int", + "name": "startPosY" + }, + { + "type": "int", + "name": "endPosX" + }, + { + "type": "int", + "name": "endPosY" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawLineV", + "description": "Draw a line (using gl lines)", + "returnType": "void", + "params": [ + { + "type": "Vector2", + "name": "startPos" + }, + { + "type": "Vector2", + "name": "endPos" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawLineEx", + "description": "Draw a line (using triangles/quads)", + "returnType": "void", + "params": [ + { + "type": "Vector2", + "name": "startPos" + }, + { + "type": "Vector2", + "name": "endPos" + }, + { + "type": "float", + "name": "thick" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawLineStrip", + "description": "Draw lines sequence (using gl lines)", + "returnType": "void", + "params": [ + { + "type": "Vector2[]", + "name": "points" + }, + { + "type": "int", + "name": "pointCount" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawLineBezier", + "description": "Draw line segment cubic-bezier in-out interpolation", + "returnType": "void", + "params": [ + { + "type": "Vector2", + "name": "startPos" + }, + { + "type": "Vector2", + "name": "endPos" + }, + { + "type": "float", + "name": "thick" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawCircle", + "description": "Draw a color-filled circle", + "returnType": "void", + "params": [ + { + "type": "int", + "name": "centerX" + }, + { + "type": "int", + "name": "centerY" + }, + { + "type": "float", + "name": "radius" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawCircleSector", + "description": "Draw a piece of a circle", + "returnType": "void", + "params": [ + { + "type": "Vector2", + "name": "center" + }, + { + "type": "float", + "name": "radius" + }, + { + "type": "float", + "name": "startAngle" + }, + { + "type": "float", + "name": "endAngle" + }, + { + "type": "int", + "name": "segments" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawCircleSectorLines", + "description": "Draw circle sector outline", + "returnType": "void", + "params": [ + { + "type": "Vector2", + "name": "center" + }, + { + "type": "float", + "name": "radius" + }, + { + "type": "float", + "name": "startAngle" + }, + { + "type": "float", + "name": "endAngle" + }, + { + "type": "int", + "name": "segments" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawCircleGradient", + "description": "Draw a gradient-filled circle", + "returnType": "void", + "params": [ + { + "type": "int", + "name": "centerX" + }, + { + "type": "int", + "name": "centerY" + }, + { + "type": "float", + "name": "radius" + }, + { + "type": "Color", + "name": "color1" + }, + { + "type": "Color", + "name": "color2" + } + ] + }, + { + "name": "DrawCircleV", + "description": "Draw a color-filled circle (Vector version)", + "returnType": "void", + "params": [ + { + "type": "Vector2", + "name": "center" + }, + { + "type": "float", + "name": "radius" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawCircleLines", + "description": "Draw circle outline", + "returnType": "void", + "params": [ + { + "type": "int", + "name": "centerX" + }, + { + "type": "int", + "name": "centerY" + }, + { + "type": "float", + "name": "radius" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawCircleLinesV", + "description": "Draw circle outline (Vector version)", + "returnType": "void", + "params": [ + { + "type": "Vector2", + "name": "center" + }, + { + "type": "float", + "name": "radius" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawEllipse", + "description": "Draw ellipse", + "returnType": "void", + "params": [ + { + "type": "int", + "name": "centerX" + }, + { + "type": "int", + "name": "centerY" + }, + { + "type": "float", + "name": "radiusH" + }, + { + "type": "float", + "name": "radiusV" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawEllipseLines", + "description": "Draw ellipse outline", + "returnType": "void", + "params": [ + { + "type": "int", + "name": "centerX" + }, + { + "type": "int", + "name": "centerY" + }, + { + "type": "float", + "name": "radiusH" + }, + { + "type": "float", + "name": "radiusV" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawRing", + "description": "Draw ring", + "returnType": "void", + "params": [ + { + "type": "Vector2", + "name": "center" + }, + { + "type": "float", + "name": "innerRadius" + }, + { + "type": "float", + "name": "outerRadius" + }, + { + "type": "float", + "name": "startAngle" + }, + { + "type": "float", + "name": "endAngle" + }, + { + "type": "int", + "name": "segments" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawRingLines", + "description": "Draw ring outline", + "returnType": "void", + "params": [ + { + "type": "Vector2", + "name": "center" + }, + { + "type": "float", + "name": "innerRadius" + }, + { + "type": "float", + "name": "outerRadius" + }, + { + "type": "float", + "name": "startAngle" + }, + { + "type": "float", + "name": "endAngle" + }, + { + "type": "int", + "name": "segments" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawRectangle", + "description": "Draw a color-filled rectangle", + "returnType": "void", + "params": [ + { + "type": "int", + "name": "posX" + }, + { + "type": "int", + "name": "posY" + }, + { + "type": "int", + "name": "width" + }, + { + "type": "int", + "name": "height" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawRectangleV", + "description": "Draw a color-filled rectangle (Vector version)", + "returnType": "void", + "params": [ + { + "type": "Vector2", + "name": "position" + }, + { + "type": "Vector2", + "name": "size" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawRectangleRec", + "description": "Draw a color-filled rectangle", + "returnType": "void", + "params": [ + { + "type": "Rectangle", + "name": "rec" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawRectanglePro", + "description": "Draw a color-filled rectangle with pro parameters", + "returnType": "void", + "params": [ + { + "type": "Rectangle", + "name": "rec" + }, + { + "type": "Vector2", + "name": "origin" + }, + { + "type": "float", + "name": "rotation" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawRectangleGradientV", + "description": "Draw a vertical-gradient-filled rectangle", + "returnType": "void", + "params": [ + { + "type": "int", + "name": "posX" + }, + { + "type": "int", + "name": "posY" + }, + { + "type": "int", + "name": "width" + }, + { + "type": "int", + "name": "height" + }, + { + "type": "Color", + "name": "color1" + }, + { + "type": "Color", + "name": "color2" + } + ] + }, + { + "name": "DrawRectangleGradientH", + "description": "Draw a horizontal-gradient-filled rectangle", + "returnType": "void", + "params": [ + { + "type": "int", + "name": "posX" + }, + { + "type": "int", + "name": "posY" + }, + { + "type": "int", + "name": "width" + }, + { + "type": "int", + "name": "height" + }, + { + "type": "Color", + "name": "color1" + }, + { + "type": "Color", + "name": "color2" + } + ] + }, + { + "name": "DrawRectangleGradientEx", + "description": "Draw a gradient-filled rectangle with custom vertex colors", + "returnType": "void", + "params": [ + { + "type": "Rectangle", + "name": "rec" + }, + { + "type": "Color", + "name": "col1" + }, + { + "type": "Color", + "name": "col2" + }, + { + "type": "Color", + "name": "col3" + }, + { + "type": "Color", + "name": "col4" + } + ] + }, + { + "name": "DrawRectangleLines", + "description": "Draw rectangle outline", + "returnType": "void", + "params": [ + { + "type": "int", + "name": "posX" + }, + { + "type": "int", + "name": "posY" + }, + { + "type": "int", + "name": "width" + }, + { + "type": "int", + "name": "height" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawRectangleLinesEx", + "description": "Draw rectangle outline with extended parameters", + "returnType": "void", + "params": [ + { + "type": "Rectangle", + "name": "rec" + }, + { + "type": "float", + "name": "lineThick" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawRectangleRounded", + "description": "Draw rectangle with rounded edges", + "returnType": "void", + "params": [ + { + "type": "Rectangle", + "name": "rec" + }, + { + "type": "float", + "name": "roundness" + }, + { + "type": "int", + "name": "segments" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawRectangleRoundedLines", + "description": "Draw rectangle with rounded edges outline", + "returnType": "void", + "params": [ + { + "type": "Rectangle", + "name": "rec" + }, + { + "type": "float", + "name": "roundness" + }, + { + "type": "int", + "name": "segments" + }, + { + "type": "float", + "name": "lineThick" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawTriangle", + "description": "Draw a color-filled triangle (vertex in counter-clockwise order!)", + "returnType": "void", + "params": [ + { + "type": "Vector2", + "name": "v1" + }, + { + "type": "Vector2", + "name": "v2" + }, + { + "type": "Vector2", + "name": "v3" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawTriangleLines", + "description": "Draw triangle outline (vertex in counter-clockwise order!)", + "returnType": "void", + "params": [ + { + "type": "Vector2", + "name": "v1" + }, + { + "type": "Vector2", + "name": "v2" + }, + { + "type": "Vector2", + "name": "v3" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawTriangleFan", + "description": "Draw a triangle fan defined by points (first vertex is the center)", + "returnType": "void", + "params": [ + { + "type": "Vector2[]", + "name": "points" + }, + { + "type": "int", + "name": "pointCount" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawTriangleStrip", + "description": "Draw a triangle strip defined by points", + "returnType": "void", + "params": [ + { + "type": "Vector2[]", + "name": "points" + }, + { + "type": "int", + "name": "pointCount" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawPoly", + "description": "Draw a regular polygon (Vector version)", + "returnType": "void", + "params": [ + { + "type": "Vector2", + "name": "center" + }, + { + "type": "int", + "name": "sides" + }, + { + "type": "float", + "name": "radius" + }, + { + "type": "float", + "name": "rotation" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawPolyLines", + "description": "Draw a polygon outline of n sides", + "returnType": "void", + "params": [ + { + "type": "Vector2", + "name": "center" + }, + { + "type": "int", + "name": "sides" + }, + { + "type": "float", + "name": "radius" + }, + { + "type": "float", + "name": "rotation" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawPolyLinesEx", + "description": "Draw a polygon outline of n sides with extended parameters", + "returnType": "void", + "params": [ + { + "type": "Vector2", + "name": "center" + }, + { + "type": "int", + "name": "sides" + }, + { + "type": "float", + "name": "radius" + }, + { + "type": "float", + "name": "rotation" + }, + { + "type": "float", + "name": "lineThick" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawSplineLinear", + "description": "Draw spline: Linear, minimum 2 points", + "returnType": "void", + "params": [ + { + "type": "Vector2[]", + "name": "points" + }, + { + "type": "int", + "name": "pointCount" + }, + { + "type": "float", + "name": "thick" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawSplineBasis", + "description": "Draw spline: B-Spline, minimum 4 points", + "returnType": "void", + "params": [ + { + "type": "Vector2[]", + "name": "points" + }, + { + "type": "int", + "name": "pointCount" + }, + { + "type": "float", + "name": "thick" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawSplineCatmullRom", + "description": "Draw spline: Catmull-Rom, minimum 4 points", + "returnType": "void", + "params": [ + { + "type": "Vector2[]", + "name": "points" + }, + { + "type": "int", + "name": "pointCount" + }, + { + "type": "float", + "name": "thick" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawSplineBezierQuadratic", + "description": "Draw spline: Quadratic Bezier, minimum 3 points (1 control point): [p1, c2, p3, c4...]", + "returnType": "void", + "params": [ + { + "type": "Vector2[]", + "name": "points" + }, + { + "type": "int", + "name": "pointCount" + }, + { + "type": "float", + "name": "thick" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawSplineBezierCubic", + "description": "Draw spline: Cubic Bezier, minimum 4 points (2 control points): [p1, c2, c3, p4, c5, c6...]", + "returnType": "void", + "params": [ + { + "type": "Vector2[]", + "name": "points" + }, + { + "type": "int", + "name": "pointCount" + }, + { + "type": "float", + "name": "thick" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawSplineSegmentLinear", + "description": "Draw spline segment: Linear, 2 points", + "returnType": "void", + "params": [ + { + "type": "Vector2", + "name": "p1" + }, + { + "type": "Vector2", + "name": "p2" + }, + { + "type": "float", + "name": "thick" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawSplineSegmentBasis", + "description": "Draw spline segment: B-Spline, 4 points", + "returnType": "void", + "params": [ + { + "type": "Vector2", + "name": "p1" + }, + { + "type": "Vector2", + "name": "p2" + }, + { + "type": "Vector2", + "name": "p3" + }, + { + "type": "Vector2", + "name": "p4" + }, + { + "type": "float", + "name": "thick" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawSplineSegmentCatmullRom", + "description": "Draw spline segment: Catmull-Rom, 4 points", + "returnType": "void", + "params": [ + { + "type": "Vector2", + "name": "p1" + }, + { + "type": "Vector2", + "name": "p2" + }, + { + "type": "Vector2", + "name": "p3" + }, + { + "type": "Vector2", + "name": "p4" + }, + { + "type": "float", + "name": "thick" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawSplineSegmentBezierQuadratic", + "description": "Draw spline segment: Quadratic Bezier, 2 points, 1 control point", + "returnType": "void", + "params": [ + { + "type": "Vector2", + "name": "p1" + }, + { + "type": "Vector2", + "name": "c2" + }, + { + "type": "Vector2", + "name": "p3" + }, + { + "type": "float", + "name": "thick" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawSplineSegmentBezierCubic", + "description": "Draw spline segment: Cubic Bezier, 2 points, 2 control points", + "returnType": "void", + "params": [ + { + "type": "Vector2", + "name": "p1" + }, + { + "type": "Vector2", + "name": "c2" + }, + { + "type": "Vector2", + "name": "c3" + }, + { + "type": "Vector2", + "name": "p4" + }, + { + "type": "float", + "name": "thick" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "GetSplinePointLinear", + "description": "Get (evaluate) spline point: Linear", + "returnType": "Vector2", + "params": [ + { + "type": "Vector2", + "name": "startPos" + }, + { + "type": "Vector2", + "name": "endPos" + }, + { + "type": "float", + "name": "t" + } + ] + }, + { + "name": "GetSplinePointBasis", + "description": "Get (evaluate) spline point: B-Spline", + "returnType": "Vector2", + "params": [ + { + "type": "Vector2", + "name": "p1" + }, + { + "type": "Vector2", + "name": "p2" + }, + { + "type": "Vector2", + "name": "p3" + }, + { + "type": "Vector2", + "name": "p4" + }, + { + "type": "float", + "name": "t" + } + ] + }, + { + "name": "GetSplinePointCatmullRom", + "description": "Get (evaluate) spline point: Catmull-Rom", + "returnType": "Vector2", + "params": [ + { + "type": "Vector2", + "name": "p1" + }, + { + "type": "Vector2", + "name": "p2" + }, + { + "type": "Vector2", + "name": "p3" + }, + { + "type": "Vector2", + "name": "p4" + }, + { + "type": "float", + "name": "t" + } + ] + }, + { + "name": "GetSplinePointBezierQuad", + "description": "Get (evaluate) spline point: Quadratic Bezier", + "returnType": "Vector2", + "params": [ + { + "type": "Vector2", + "name": "p1" + }, + { + "type": "Vector2", + "name": "c2" + }, + { + "type": "Vector2", + "name": "p3" + }, + { + "type": "float", + "name": "t" + } + ] + }, + { + "name": "GetSplinePointBezierCubic", + "description": "Get (evaluate) spline point: Cubic Bezier", + "returnType": "Vector2", + "params": [ + { + "type": "Vector2", + "name": "p1" + }, + { + "type": "Vector2", + "name": "c2" + }, + { + "type": "Vector2", + "name": "c3" + }, + { + "type": "Vector2", + "name": "p4" + }, + { + "type": "float", + "name": "t" + } + ] + }, + { + "name": "CheckCollisionRecs", + "description": "Check collision between two rectangles", + "returnType": "bool", + "params": [ + { + "type": "Rectangle", + "name": "rec1" + }, + { + "type": "Rectangle", + "name": "rec2" + } + ] + }, + { + "name": "CheckCollisionCircles", + "description": "Check collision between two circles", + "returnType": "bool", + "params": [ + { + "type": "Vector2", + "name": "center1" + }, + { + "type": "float", + "name": "radius1" + }, + { + "type": "Vector2", + "name": "center2" + }, + { + "type": "float", + "name": "radius2" + } + ] + }, + { + "name": "CheckCollisionCircleRec", + "description": "Check collision between circle and rectangle", + "returnType": "bool", + "params": [ + { + "type": "Vector2", + "name": "center" + }, + { + "type": "float", + "name": "radius" + }, + { + "type": "Rectangle", + "name": "rec" + } + ] + }, + { + "name": "CheckCollisionPointRec", + "description": "Check if point is inside rectangle", + "returnType": "bool", + "params": [ + { + "type": "Vector2", + "name": "point" + }, + { + "type": "Rectangle", + "name": "rec" + } + ] + }, + { + "name": "CheckCollisionPointCircle", + "description": "Check if point is inside circle", + "returnType": "bool", + "params": [ + { + "type": "Vector2", + "name": "point" + }, + { + "type": "Vector2", + "name": "center" + }, + { + "type": "float", + "name": "radius" + } + ] + }, + { + "name": "CheckCollisionPointTriangle", + "description": "Check if point is inside a triangle", + "returnType": "bool", + "params": [ + { + "type": "Vector2", + "name": "point" + }, + { + "type": "Vector2", + "name": "p1" + }, + { + "type": "Vector2", + "name": "p2" + }, + { + "type": "Vector2", + "name": "p3" + } + ] + }, + { + "name": "CheckCollisionPointPoly", + "description": "Check if point is within a polygon described by array of vertices", + "returnType": "bool", + "params": [ + { + "type": "Vector2", + "name": "point" + }, + { + "type": "Vector2[]", + "name": "points" + }, + { + "type": "int", + "name": "pointCount" + } + ] + }, + { + "name": "CheckCollisionLines", + "description": "Check the collision between two lines defined by two points each, returns collision point by reference", + "returnType": "bool", + "params": [ + { + "type": "Vector2", + "name": "startPos1" + }, + { + "type": "Vector2", + "name": "endPos1" + }, + { + "type": "Vector2", + "name": "startPos2" + }, + { + "type": "Vector2", + "name": "endPos2" + }, + { + "type": "Vector2 *", + "name": "collisionPoint" + } + ] + }, + { + "name": "CheckCollisionPointLine", + "description": "Check if point belongs to line created between two points [p1] and [p2] with defined margin in pixels [threshold]", + "returnType": "bool", + "params": [ + { + "type": "Vector2", + "name": "point" + }, + { + "type": "Vector2", + "name": "p1" + }, + { + "type": "Vector2", + "name": "p2" + }, + { + "type": "int", + "name": "threshold" + } + ] + }, + { + "name": "GetCollisionRec", + "description": "Get collision rectangle for two rectangles collision", + "returnType": "Rectangle", + "params": [ + { + "type": "Rectangle", + "name": "rec1" + }, + { + "type": "Rectangle", + "name": "rec2" + } + ] + }, + { + "name": "LoadImage", + "description": "Load image from file into CPU memory (RAM)", + "returnType": "Image", + "params": [ + { + "type": "const char *", + "name": "fileName" + } + ] + }, + { + "name": "LoadImageRaw", + "description": "Load image from RAW file data", + "returnType": "Image", + "params": [ + { + "type": "const char *", + "name": "fileName" + }, + { + "type": "int", + "name": "width" + }, + { + "type": "int", + "name": "height" + }, + { + "type": "int", + "name": "format" + }, + { + "type": "int", + "name": "headerSize" + } + ] + }, + { + "name": "LoadImageSvg", + "description": "Load image from SVG file data or string with specified size", + "returnType": "Image", + "params": [ + { + "type": "const char *", + "name": "fileNameOrString" + }, + { + "type": "int", + "name": "width" + }, + { + "type": "int", + "name": "height" + } + ] + }, + { + "name": "LoadImageAnim", + "description": "Load image sequence from file (frames appended to image.data)", + "returnType": "Image", + "params": [ + { + "type": "const char *", + "name": "fileName" + }, + { + "type": "int *", + "name": "frames" + } + ] + }, + { + "name": "LoadImageFromMemory", + "description": "Load image from memory buffer, fileType refers to extension: i.e. '.png'", + "returnType": "Image", + "params": [ + { + "type": "const char *", + "name": "fileType" + }, + { + "type": "const unsigned char *", + "name": "fileData" + }, + { + "type": "int", + "name": "dataSize" + } + ] + }, + { + "name": "LoadImageFromTexture", + "description": "Load image from GPU texture data", + "returnType": "Image", + "params": [ + { + "type": "Texture2D", + "name": "texture" + } + ] + }, + { + "name": "LoadImageFromScreen", + "description": "Load image from screen buffer and (screenshot)", + "returnType": "Image" + }, + { + "name": "IsImageReady", + "description": "Check if an image is ready", + "returnType": "bool", + "params": [ + { + "type": "Image", + "name": "image" + } + ] + }, + { + "name": "UnloadImage", + "description": "Unload image from CPU memory (RAM)", + "returnType": "void", + "params": [ + { + "type": "Image", + "name": "image" + } + ] + }, + { + "name": "ExportImage", + "description": "Export image data to file, returns true on success", + "returnType": "bool", + "params": [ + { + "type": "Image", + "name": "image" + }, + { + "type": "const char *", + "name": "fileName" + } + ] + }, + { + "name": "ExportImageToMemory", + "description": "Export image to memory buffer", + "returnType": "unsigned char *", + "params": [ + { + "type": "Image", + "name": "image" + }, + { + "type": "const char *", + "name": "fileType" + }, + { + "type": "int *", + "name": "fileSize" + } + ] + }, + { + "name": "ExportImageAsCode", + "description": "Export image as code file defining an array of bytes, returns true on success", + "returnType": "bool", + "params": [ + { + "type": "Image", + "name": "image" + }, + { + "type": "const char *", + "name": "fileName" + } + ] + }, + { + "name": "GenImageColor", + "description": "Generate image: plain color", + "returnType": "Image", + "params": [ + { + "type": "int", + "name": "width" + }, + { + "type": "int", + "name": "height" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "GenImageGradientLinear", + "description": "Generate image: linear gradient, direction in degrees [0..360], 0=Vertical gradient", + "returnType": "Image", + "params": [ + { + "type": "int", + "name": "width" + }, + { + "type": "int", + "name": "height" + }, + { + "type": "int", + "name": "direction" + }, + { + "type": "Color", + "name": "start" + }, + { + "type": "Color", + "name": "end" + } + ] + }, + { + "name": "GenImageGradientRadial", + "description": "Generate image: radial gradient", + "returnType": "Image", + "params": [ + { + "type": "int", + "name": "width" + }, + { + "type": "int", + "name": "height" + }, + { + "type": "float", + "name": "density" + }, + { + "type": "Color", + "name": "inner" + }, + { + "type": "Color", + "name": "outer" + } + ] + }, + { + "name": "GenImageGradientSquare", + "description": "Generate image: square gradient", + "returnType": "Image", + "params": [ + { + "type": "int", + "name": "width" + }, + { + "type": "int", + "name": "height" + }, + { + "type": "float", + "name": "density" + }, + { + "type": "Color", + "name": "inner" + }, + { + "type": "Color", + "name": "outer" + } + ] + }, + { + "name": "GenImageChecked", + "description": "Generate image: checked", + "returnType": "Image", + "params": [ + { + "type": "int", + "name": "width" + }, + { + "type": "int", + "name": "height" + }, + { + "type": "int", + "name": "checksX" + }, + { + "type": "int", + "name": "checksY" + }, + { + "type": "Color", + "name": "col1" + }, + { + "type": "Color", + "name": "col2" + } + ] + }, + { + "name": "GenImageWhiteNoise", + "description": "Generate image: white noise", + "returnType": "Image", + "params": [ + { + "type": "int", + "name": "width" + }, + { + "type": "int", + "name": "height" + }, + { + "type": "float", + "name": "factor" + } + ] + }, + { + "name": "GenImagePerlinNoise", + "description": "Generate image: perlin noise", + "returnType": "Image", + "params": [ + { + "type": "int", + "name": "width" + }, + { + "type": "int", + "name": "height" + }, + { + "type": "int", + "name": "offsetX" + }, + { + "type": "int", + "name": "offsetY" + }, + { + "type": "float", + "name": "scale" + } + ] + }, + { + "name": "GenImageCellular", + "description": "Generate image: cellular algorithm, bigger tileSize means bigger cells", + "returnType": "Image", + "params": [ + { + "type": "int", + "name": "width" + }, + { + "type": "int", + "name": "height" + }, + { + "type": "int", + "name": "tileSize" + } + ] + }, + { + "name": "GenImageText", + "description": "Generate image: grayscale image from text data", + "returnType": "Image", + "params": [ + { + "type": "int", + "name": "width" + }, + { + "type": "int", + "name": "height" + }, + { + "type": "const char *", + "name": "text" + } + ] + }, + { + "name": "ImageCopy", + "description": "Create an image duplicate (useful for transformations)", + "returnType": "Image", + "params": [ + { + "type": "Image", + "name": "image" + } + ] + }, + { + "name": "ImageFromImage", + "description": "Create an image from another image piece", + "returnType": "Image", + "params": [ + { + "type": "Image", + "name": "image" + }, + { + "type": "Rectangle", + "name": "rec" + } + ] + }, + { + "name": "ImageText", + "description": "Create an image from text (default font)", + "returnType": "Image", + "params": [ + { + "type": "const char *", + "name": "text" + }, + { + "type": "int", + "name": "fontSize" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "ImageTextEx", + "description": "Create an image from text (custom sprite font)", + "returnType": "Image", + "params": [ + { + "type": "Font", + "name": "font" + }, + { + "type": "const char *", + "name": "text" + }, + { + "type": "float", + "name": "fontSize" + }, + { + "type": "float", + "name": "spacing" + }, + { + "type": "Color", + "name": "tint" + } + ] + }, + { + "name": "ImageFormat", + "description": "Convert image data to desired format", + "returnType": "void", + "params": [ + { + "type": "Image *", + "name": "image" + }, + { + "type": "int", + "name": "newFormat" + } + ] + }, + { + "name": "ImageToPOT", + "description": "Convert image to POT (power-of-two)", + "returnType": "void", + "params": [ + { + "type": "Image *", + "name": "image" + }, + { + "type": "Color", + "name": "fill" + } + ] + }, + { + "name": "ImageCrop", + "description": "Crop an image to a defined rectangle", + "returnType": "void", + "params": [ + { + "type": "Image *", + "name": "image" + }, + { + "type": "Rectangle", + "name": "crop" + } + ] + }, + { + "name": "ImageAlphaCrop", + "description": "Crop image depending on alpha value", + "returnType": "void", + "params": [ + { + "type": "Image *", + "name": "image" + }, + { + "type": "float", + "name": "threshold" + } + ] + }, + { + "name": "ImageAlphaClear", + "description": "Clear alpha channel to desired color", + "returnType": "void", + "params": [ + { + "type": "Image *", + "name": "image" + }, + { + "type": "Color", + "name": "color" + }, + { + "type": "float", + "name": "threshold" + } + ] + }, + { + "name": "ImageAlphaMask", + "description": "Apply alpha mask to image", + "returnType": "void", + "params": [ + { + "type": "Image *", + "name": "image" + }, + { + "type": "Image", + "name": "alphaMask" + } + ] + }, + { + "name": "ImageAlphaPremultiply", + "description": "Premultiply alpha channel", + "returnType": "void", + "params": [ + { + "type": "Image *", + "name": "image" + } + ] + }, + { + "name": "ImageBlurGaussian", + "description": "Apply Gaussian blur using a box blur approximation", + "returnType": "void", + "params": [ + { + "type": "Image *", + "name": "image" + }, + { + "type": "int", + "name": "blurSize" + } + ] + }, + { + "name": "ImageKernelConvolution", + "description": "Apply Custom Square image convolution kernel", + "returnType": "void", + "params": [ + { + "type": "Image *", + "name": "image" + }, + { + "type": "float *", + "name": "kernel" + }, + { + "type": "int", + "name": "kernelSize" + } + ] + }, + { + "name": "ImageResize", + "description": "Resize image (Bicubic scaling algorithm)", + "returnType": "void", + "params": [ + { + "type": "Image *", + "name": "image" + }, + { + "type": "int", + "name": "newWidth" + }, + { + "type": "int", + "name": "newHeight" + } + ] + }, + { + "name": "ImageResizeNN", + "description": "Resize image (Nearest-Neighbor scaling algorithm)", + "returnType": "void", + "params": [ + { + "type": "Image *", + "name": "image" + }, + { + "type": "int", + "name": "newWidth" + }, + { + "type": "int", + "name": "newHeight" + } + ] + }, + { + "name": "ImageResizeCanvas", + "description": "Resize canvas and fill with color", + "returnType": "void", + "params": [ + { + "type": "Image *", + "name": "image" + }, + { + "type": "int", + "name": "newWidth" + }, + { + "type": "int", + "name": "newHeight" + }, + { + "type": "int", + "name": "offsetX" + }, + { + "type": "int", + "name": "offsetY" + }, + { + "type": "Color", + "name": "fill" + } + ] + }, + { + "name": "ImageMipmaps", + "description": "Compute all mipmap levels for a provided image", + "returnType": "void", + "params": [ + { + "type": "Image *", + "name": "image" + } + ] + }, + { + "name": "ImageDither", + "description": "Dither image data to 16bpp or lower (Floyd-Steinberg dithering)", + "returnType": "void", + "params": [ + { + "type": "Image *", + "name": "image" + }, + { + "type": "int", + "name": "rBpp" + }, + { + "type": "int", + "name": "gBpp" + }, + { + "type": "int", + "name": "bBpp" + }, + { + "type": "int", + "name": "aBpp" + } + ] + }, + { + "name": "ImageFlipVertical", + "description": "Flip image vertically", + "returnType": "void", + "params": [ + { + "type": "Image *", + "name": "image" + } + ] + }, + { + "name": "ImageFlipHorizontal", + "description": "Flip image horizontally", + "returnType": "void", + "params": [ + { + "type": "Image *", + "name": "image" + } + ] + }, + { + "name": "ImageRotate", + "description": "Rotate image by input angle in degrees (-359 to 359)", + "returnType": "void", + "params": [ + { + "type": "Image *", + "name": "image" + }, + { + "type": "int", + "name": "degrees" + } + ] + }, + { + "name": "ImageRotateCW", + "description": "Rotate image clockwise 90deg", + "returnType": "void", + "params": [ + { + "type": "Image *", + "name": "image" + } + ] + }, + { + "name": "ImageRotateCCW", + "description": "Rotate image counter-clockwise 90deg", + "returnType": "void", + "params": [ + { + "type": "Image *", + "name": "image" + } + ] + }, + { + "name": "ImageColorTint", + "description": "Modify image color: tint", + "returnType": "void", + "params": [ + { + "type": "Image *", + "name": "image" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "ImageColorInvert", + "description": "Modify image color: invert", + "returnType": "void", + "params": [ + { + "type": "Image *", + "name": "image" + } + ] + }, + { + "name": "ImageColorGrayscale", + "description": "Modify image color: grayscale", + "returnType": "void", + "params": [ + { + "type": "Image *", + "name": "image" + } + ] + }, + { + "name": "ImageColorContrast", + "description": "Modify image color: contrast (-100 to 100)", + "returnType": "void", + "params": [ + { + "type": "Image *", + "name": "image" + }, + { + "type": "float", + "name": "contrast" + } + ] + }, + { + "name": "ImageColorBrightness", + "description": "Modify image color: brightness (-255 to 255)", + "returnType": "void", + "params": [ + { + "type": "Image *", + "name": "image" + }, + { + "type": "int", + "name": "brightness" + } + ] + }, + { + "name": "ImageColorReplace", + "description": "Modify image color: replace color", + "returnType": "void", + "params": [ + { + "type": "Image *", + "name": "image" + }, + { + "type": "Color", + "name": "color" + }, + { + "type": "Color", + "name": "replace" + } + ] + }, + { + "name": "LoadImageColors", + "description": "Load color data from image as a Color array (RGBA - 32bit)", + "returnType": "Color *", + "params": [ + { + "type": "Image", + "name": "image" + } + ] + }, + { + "name": "LoadImagePalette", + "description": "Load colors palette from image as a Color array (RGBA - 32bit)", + "returnType": "Color *", + "params": [ + { + "type": "Image", + "name": "image" + }, + { + "type": "int", + "name": "maxPaletteSize" + }, + { + "type": "int *", + "name": "colorCount" + } + ] + }, + { + "name": "UnloadImageColors", + "description": "Unload color data loaded with LoadImageColors()", + "returnType": "void", + "params": [ + { + "type": "Color *", + "name": "colors" + } + ] + }, + { + "name": "UnloadImagePalette", + "description": "Unload colors palette loaded with LoadImagePalette()", + "returnType": "void", + "params": [ + { + "type": "Color *", + "name": "colors" + } + ] + }, + { + "name": "GetImageAlphaBorder", + "description": "Get image alpha border rectangle", + "returnType": "Rectangle", + "params": [ + { + "type": "Image", + "name": "image" + }, + { + "type": "float", + "name": "threshold" + } + ] + }, + { + "name": "GetImageColor", + "description": "Get image pixel color at (x, y) position", + "returnType": "Color", + "params": [ + { + "type": "Image", + "name": "image" + }, + { + "type": "int", + "name": "x" + }, + { + "type": "int", + "name": "y" + } + ] + }, + { + "name": "ImageClearBackground", + "description": "Clear image background with given color", + "returnType": "void", + "params": [ + { + "type": "Image *", + "name": "dst" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "ImageDrawPixel", + "description": "Draw pixel within an image", + "returnType": "void", + "params": [ + { + "type": "Image *", + "name": "dst" + }, + { + "type": "int", + "name": "posX" + }, + { + "type": "int", + "name": "posY" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "ImageDrawPixelV", + "description": "Draw pixel within an image (Vector version)", + "returnType": "void", + "params": [ + { + "type": "Image *", + "name": "dst" + }, + { + "type": "Vector2", + "name": "position" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "ImageDrawLine", + "description": "Draw line within an image", + "returnType": "void", + "params": [ + { + "type": "Image *", + "name": "dst" + }, + { + "type": "int", + "name": "startPosX" + }, + { + "type": "int", + "name": "startPosY" + }, + { + "type": "int", + "name": "endPosX" + }, + { + "type": "int", + "name": "endPosY" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "ImageDrawLineV", + "description": "Draw line within an image (Vector version)", + "returnType": "void", + "params": [ + { + "type": "Image *", + "name": "dst" + }, + { + "type": "Vector2", + "name": "start" + }, + { + "type": "Vector2", + "name": "end" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "ImageDrawCircle", + "description": "Draw a filled circle within an image", + "returnType": "void", + "params": [ + { + "type": "Image *", + "name": "dst" + }, + { + "type": "int", + "name": "centerX" + }, + { + "type": "int", + "name": "centerY" + }, + { + "type": "int", + "name": "radius" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "ImageDrawCircleV", + "description": "Draw a filled circle within an image (Vector version)", + "returnType": "void", + "params": [ + { + "type": "Image *", + "name": "dst" + }, + { + "type": "Vector2", + "name": "center" + }, + { + "type": "int", + "name": "radius" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "ImageDrawCircleLines", + "description": "Draw circle outline within an image", + "returnType": "void", + "params": [ + { + "type": "Image *", + "name": "dst" + }, + { + "type": "int", + "name": "centerX" + }, + { + "type": "int", + "name": "centerY" + }, + { + "type": "int", + "name": "radius" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "ImageDrawCircleLinesV", + "description": "Draw circle outline within an image (Vector version)", + "returnType": "void", + "params": [ + { + "type": "Image *", + "name": "dst" + }, + { + "type": "Vector2", + "name": "center" + }, + { + "type": "int", + "name": "radius" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "ImageDrawRectangle", + "description": "Draw rectangle within an image", + "returnType": "void", + "params": [ + { + "type": "Image *", + "name": "dst" + }, + { + "type": "int", + "name": "posX" + }, + { + "type": "int", + "name": "posY" + }, + { + "type": "int", + "name": "width" + }, + { + "type": "int", + "name": "height" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "ImageDrawRectangleV", + "description": "Draw rectangle within an image (Vector version)", + "returnType": "void", + "params": [ + { + "type": "Image *", + "name": "dst" + }, + { + "type": "Vector2", + "name": "position" + }, + { + "type": "Vector2", + "name": "size" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "ImageDrawRectangleRec", + "description": "Draw rectangle within an image", + "returnType": "void", + "params": [ + { + "type": "Image *", + "name": "dst" + }, + { + "type": "Rectangle", + "name": "rec" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "ImageDrawRectangleLines", + "description": "Draw rectangle lines within an image", + "returnType": "void", + "params": [ + { + "type": "Image *", + "name": "dst" + }, + { + "type": "Rectangle", + "name": "rec" + }, + { + "type": "int", + "name": "thick" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "ImageDraw", + "description": "Draw a source image within a destination image (tint applied to source)", + "returnType": "void", + "params": [ + { + "type": "Image *", + "name": "dst" + }, + { + "type": "Image", + "name": "src" + }, + { + "type": "Rectangle", + "name": "srcRec" + }, + { + "type": "Rectangle", + "name": "dstRec" + }, + { + "type": "Color", + "name": "tint" + } + ] + }, + { + "name": "ImageDrawText", + "description": "Draw text (using default font) within an image (destination)", + "returnType": "void", + "params": [ + { + "type": "Image *", + "name": "dst" + }, + { + "type": "const char *", + "name": "text" + }, + { + "type": "int", + "name": "posX" + }, + { + "type": "int", + "name": "posY" + }, + { + "type": "int", + "name": "fontSize" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "ImageDrawTextEx", + "description": "Draw text (custom sprite font) within an image (destination)", + "returnType": "void", + "params": [ + { + "type": "Image *", + "name": "dst" + }, + { + "type": "Font", + "name": "font" + }, + { + "type": "const char *", + "name": "text" + }, + { + "type": "Vector2", + "name": "position" + }, + { + "type": "float", + "name": "fontSize" + }, + { + "type": "float", + "name": "spacing" + }, + { + "type": "Color", + "name": "tint" + } + ] + }, + { + "name": "LoadTexture", + "description": "Load texture from file into GPU memory (VRAM)", + "returnType": "Texture2D", + "params": [ + { + "type": "const char *", + "name": "fileName" + } + ] + }, + { + "name": "LoadTextureFromImage", + "description": "Load texture from image data", + "returnType": "Texture2D", + "params": [ + { + "type": "Image", + "name": "image" + } + ] + }, + { + "name": "LoadTextureCubemap", + "description": "Load cubemap from image, multiple image cubemap layouts supported", + "returnType": "TextureCubemap", + "params": [ + { + "type": "Image", + "name": "image" + }, + { + "type": "int", + "name": "layout" + } + ] + }, + { + "name": "LoadRenderTexture", + "description": "Load texture for rendering (framebuffer)", + "returnType": "RenderTexture2D", + "params": [ + { + "type": "int", + "name": "width" + }, + { + "type": "int", + "name": "height" + } + ] + }, + { + "name": "IsTextureReady", + "description": "Check if a texture is ready", + "returnType": "bool", + "params": [ + { + "type": "Texture2D", + "name": "texture" + } + ] + }, + { + "name": "UnloadTexture", + "description": "Unload texture from GPU memory (VRAM)", + "returnType": "void", + "params": [ + { + "type": "Texture2D", + "name": "texture" + } + ] + }, + { + "name": "IsRenderTextureReady", + "description": "Check if a render texture is ready", + "returnType": "bool", + "params": [ + { + "type": "RenderTexture2D", + "name": "target" + } + ] + }, + { + "name": "UnloadRenderTexture", + "description": "Unload render texture from GPU memory (VRAM)", + "returnType": "void", + "params": [ + { + "type": "RenderTexture2D", + "name": "target" + } + ] + }, + { + "name": "UpdateTexture", + "description": "Update GPU texture with new data", + "returnType": "void", + "params": [ + { + "type": "Texture2D", + "name": "texture" + }, + { + "type": "const void *", + "name": "pixels" + } + ] + }, + { + "name": "UpdateTextureRec", + "description": "Update GPU texture rectangle with new data", + "returnType": "void", + "params": [ + { + "type": "Texture2D", + "name": "texture" + }, + { + "type": "Rectangle", + "name": "rec" + }, + { + "type": "const void *", + "name": "pixels" + } + ] + }, + { + "name": "GenTextureMipmaps", + "description": "Generate GPU mipmaps for a texture", + "returnType": "void", + "params": [ + { + "type": "Texture2D *", + "name": "texture" + } + ] + }, + { + "name": "SetTextureFilter", + "description": "Set texture scaling filter mode", + "returnType": "void", + "params": [ + { + "type": "Texture2D", + "name": "texture" + }, + { + "type": "int", + "name": "filter" + } + ] + }, + { + "name": "SetTextureWrap", + "description": "Set texture wrapping mode", + "returnType": "void", + "params": [ + { + "type": "Texture2D", + "name": "texture" + }, + { + "type": "int", + "name": "wrap" + } + ] + }, + { + "name": "DrawTexture", + "description": "Draw a Texture2D", + "returnType": "void", + "params": [ + { + "type": "Texture2D", + "name": "texture" + }, + { + "type": "int", + "name": "posX" + }, + { + "type": "int", + "name": "posY" + }, + { + "type": "Color", + "name": "tint" + } + ] + }, + { + "name": "DrawTextureV", + "description": "Draw a Texture2D with position defined as Vector2", + "returnType": "void", + "params": [ + { + "type": "Texture2D", + "name": "texture" + }, + { + "type": "Vector2", + "name": "position" + }, + { + "type": "Color", + "name": "tint" + } + ] + }, + { + "name": "DrawTextureEx", + "description": "Draw a Texture2D with extended parameters", + "returnType": "void", + "params": [ + { + "type": "Texture2D", + "name": "texture" + }, + { + "type": "Vector2", + "name": "position" + }, + { + "type": "float", + "name": "rotation" + }, + { + "type": "float", + "name": "scale" + }, + { + "type": "Color", + "name": "tint" + } + ] + }, + { + "name": "DrawTextureRec", + "description": "Draw a part of a texture defined by a rectangle", + "returnType": "void", + "params": [ + { + "type": "Texture2D", + "name": "texture" + }, + { + "type": "Rectangle", + "name": "source" + }, + { + "type": "Vector2", + "name": "position" + }, + { + "type": "Color", + "name": "tint" + } + ] + }, + { + "name": "DrawTexturePro", + "description": "Draw a part of a texture defined by a rectangle with 'pro' parameters", + "returnType": "void", + "params": [ + { + "type": "Texture2D", + "name": "texture" + }, + { + "type": "Rectangle", + "name": "source" + }, + { + "type": "Rectangle", + "name": "dest" + }, + { + "type": "Vector2", + "name": "origin" + }, + { + "type": "float", + "name": "rotation" + }, + { + "type": "Color", + "name": "tint" + } + ] + }, + { + "name": "DrawTextureNPatch", + "description": "Draws a texture (or part of it) that stretches or shrinks nicely", + "returnType": "void", + "params": [ + { + "type": "Texture2D", + "name": "texture" + }, + { + "type": "NPatchInfo", + "name": "nPatchInfo" + }, + { + "type": "Rectangle", + "name": "dest" + }, + { + "type": "Vector2", + "name": "origin" + }, + { + "type": "float", + "name": "rotation" + }, + { + "type": "Color", + "name": "tint" + } + ] + }, + { + "name": "Fade", + "description": "Get color with alpha applied, alpha goes from 0.0f to 1.0f", + "returnType": "Color", + "params": [ + { + "type": "Color", + "name": "color" + }, + { + "type": "float", + "name": "alpha" + } + ] + }, + { + "name": "ColorToInt", + "description": "Get hexadecimal value for a Color", + "returnType": "int", + "params": [ + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "ColorNormalize", + "description": "Get Color normalized as float [0..1]", + "returnType": "Vector4", + "params": [ + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "ColorFromNormalized", + "description": "Get Color from normalized values [0..1]", + "returnType": "Color", + "params": [ + { + "type": "Vector4", + "name": "normalized" + } + ] + }, + { + "name": "ColorToHSV", + "description": "Get HSV values for a Color, hue [0..360], saturation/value [0..1]", + "returnType": "Vector3", + "params": [ + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "ColorFromHSV", + "description": "Get a Color from HSV values, hue [0..360], saturation/value [0..1]", + "returnType": "Color", + "params": [ + { + "type": "float", + "name": "hue" + }, + { + "type": "float", + "name": "saturation" + }, + { + "type": "float", + "name": "value" + } + ] + }, + { + "name": "ColorTint", + "description": "Get color multiplied with another color", + "returnType": "Color", + "params": [ + { + "type": "Color", + "name": "color" + }, + { + "type": "Color", + "name": "tint" + } + ] + }, + { + "name": "ColorBrightness", + "description": "Get color with brightness correction, brightness factor goes from -1.0f to 1.0f", + "returnType": "Color", + "params": [ + { + "type": "Color", + "name": "color" + }, + { + "type": "float", + "name": "factor" + } + ] + }, + { + "name": "ColorContrast", + "description": "Get color with contrast correction, contrast values between -1.0f and 1.0f", + "returnType": "Color", + "params": [ + { + "type": "Color", + "name": "color" + }, + { + "type": "float", + "name": "contrast" + } + ] + }, + { + "name": "ColorAlpha", + "description": "Get color with alpha applied, alpha goes from 0.0f to 1.0f", + "returnType": "Color", + "params": [ + { + "type": "Color", + "name": "color" + }, + { + "type": "float", + "name": "alpha" + } + ] + }, + { + "name": "ColorAlphaBlend", + "description": "Get src alpha-blended into dst color with tint", + "returnType": "Color", + "params": [ + { + "type": "Color", + "name": "dst" + }, + { + "type": "Color", + "name": "src" + }, + { + "type": "Color", + "name": "tint" + } + ] + }, + { + "name": "GetColor", + "description": "Get Color structure from hexadecimal value", + "returnType": "Color", + "params": [ + { + "type": "unsigned int", + "name": "hexValue" + } + ] + }, + { + "name": "GetPixelColor", + "description": "Get Color from a source pixel pointer of certain format", + "returnType": "Color", + "params": [ + { + "type": "void *", + "name": "srcPtr" + }, + { + "type": "int", + "name": "format" + } + ] + }, + { + "name": "SetPixelColor", + "description": "Set color formatted into destination pixel pointer", + "returnType": "void", + "params": [ + { + "type": "void *", + "name": "dstPtr" + }, + { + "type": "Color", + "name": "color" + }, + { + "type": "int", + "name": "format" + } + ] + }, + { + "name": "GetPixelDataSize", + "description": "Get pixel data size in bytes for certain format", + "returnType": "int", + "params": [ + { + "type": "int", + "name": "width" + }, + { + "type": "int", + "name": "height" + }, + { + "type": "int", + "name": "format" + } + ] + }, + { + "name": "GetFontDefault", + "description": "Get the default Font", + "returnType": "Font" + }, + { + "name": "LoadFont", + "description": "Load font from file into GPU memory (VRAM)", + "returnType": "Font", + "params": [ + { + "type": "const char *", + "name": "fileName" + } + ] + }, + { + "name": "LoadFontEx", + "description": "Load font from file with extended parameters, use NULL for codepoints and 0 for codepointCount to load the default character setFont", + "returnType": "Font", + "params": [ + { + "type": "const char *", + "name": "fileName" + }, + { + "type": "int", + "name": "fontSize" + }, + { + "type": "int *", + "name": "codepoints" + }, + { + "type": "int", + "name": "codepointCount" + } + ] + }, + { + "name": "LoadFontFromImage", + "description": "Load font from Image (XNA style)", + "returnType": "Font", + "params": [ + { + "type": "Image", + "name": "image" + }, + { + "type": "Color", + "name": "key" + }, + { + "type": "int", + "name": "firstChar" + } + ] + }, + { + "name": "LoadFontFromMemory", + "description": "Load font from memory buffer, fileType refers to extension: i.e. '.ttf'", + "returnType": "Font", + "params": [ + { + "type": "const char *", + "name": "fileType" + }, + { + "type": "const unsigned char *", + "name": "fileData" + }, + { + "type": "int", + "name": "dataSize" + }, + { + "type": "int", + "name": "fontSize" + }, + { + "type": "int *", + "name": "codepoints" + }, + { + "type": "int", + "name": "codepointCount" + } + ] + }, + { + "name": "IsFontReady", + "description": "Check if a font is ready", + "returnType": "bool", + "params": [ + { + "type": "Font", + "name": "font" + } + ] + }, + { + "name": "LoadFontData", + "description": "Load font data for further use", + "returnType": "GlyphInfo *", + "params": [ + { + "type": "const unsigned char *", + "name": "fileData" + }, + { + "type": "int", + "name": "dataSize" + }, + { + "type": "int", + "name": "fontSize" + }, + { + "type": "int *", + "name": "codepoints" + }, + { + "type": "int", + "name": "codepointCount" + }, + { + "type": "int", + "name": "type" + } + ] + }, + { + "name": "GenImageFontAtlas", + "description": "Generate image font atlas using chars info", + "returnType": "Image", + "params": [ + { + "type": "const GlyphInfo *", + "name": "glyphs" + }, + { + "type": "Rectangle **", + "name": "glyphRecs" + }, + { + "type": "int", + "name": "glyphCount" + }, + { + "type": "int", + "name": "fontSize" + }, + { + "type": "int", + "name": "padding" + }, + { + "type": "int", + "name": "packMethod" + } + ] + }, + { + "name": "UnloadFontData", + "description": "Unload font chars info data (RAM)", + "returnType": "void", + "params": [ + { + "type": "GlyphInfo *", + "name": "glyphs" + }, + { + "type": "int", + "name": "glyphCount" + } + ] + }, + { + "name": "UnloadFont", + "description": "Unload font from GPU memory (VRAM)", + "returnType": "void", + "params": [ + { + "type": "Font", + "name": "font" + } + ] + }, + { + "name": "ExportFontAsCode", + "description": "Export font as code file, returns true on success", + "returnType": "bool", + "params": [ + { + "type": "Font", + "name": "font" + }, + { + "type": "const char *", + "name": "fileName" + } + ] + }, + { + "name": "DrawFPS", + "description": "Draw current FPS", + "returnType": "void", + "params": [ + { + "type": "int", + "name": "posX" + }, + { + "type": "int", + "name": "posY" + } + ] + }, + { + "name": "DrawText", + "description": "Draw text (using default font)", + "returnType": "void", + "params": [ + { + "type": "const char *", + "name": "text" + }, + { + "type": "int", + "name": "posX" + }, + { + "type": "int", + "name": "posY" + }, + { + "type": "int", + "name": "fontSize" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawTextEx", + "description": "Draw text using font and additional parameters", + "returnType": "void", + "params": [ + { + "type": "Font", + "name": "font" + }, + { + "type": "const char *", + "name": "text" + }, + { + "type": "Vector2", + "name": "position" + }, + { + "type": "float", + "name": "fontSize" + }, + { + "type": "float", + "name": "spacing" + }, + { + "type": "Color", + "name": "tint" + } + ] + }, + { + "name": "DrawTextPro", + "description": "Draw text using Font and pro parameters (rotation)", + "returnType": "void", + "params": [ + { + "type": "Font", + "name": "font" + }, + { + "type": "const char *", + "name": "text" + }, + { + "type": "Vector2", + "name": "position" + }, + { + "type": "Vector2", + "name": "origin" + }, + { + "type": "float", + "name": "rotation" + }, + { + "type": "float", + "name": "fontSize" + }, + { + "type": "float", + "name": "spacing" + }, + { + "type": "Color", + "name": "tint" + } + ] + }, + { + "name": "DrawTextCodepoint", + "description": "Draw one character (codepoint)", + "returnType": "void", + "params": [ + { + "type": "Font", + "name": "font" + }, + { + "type": "int", + "name": "codepoint" + }, + { + "type": "Vector2", + "name": "position" + }, + { + "type": "float", + "name": "fontSize" + }, + { + "type": "Color", + "name": "tint" + } + ] + }, + { + "name": "DrawTextCodepoints", + "description": "Draw multiple character (codepoint)", + "returnType": "void", + "params": [ + { + "type": "Font", + "name": "font" + }, + { + "type": "const int *", + "name": "codepoints" + }, + { + "type": "int", + "name": "codepointCount" + }, + { + "type": "Vector2", + "name": "position" + }, + { + "type": "float", + "name": "fontSize" + }, + { + "type": "float", + "name": "spacing" + }, + { + "type": "Color", + "name": "tint" + } + ] + }, + { + "name": "SetTextLineSpacing", + "description": "Set vertical line spacing when drawing with line-breaks", + "returnType": "void", + "params": [ + { + "type": "int", + "name": "spacing" + } + ] + }, + { + "name": "MeasureText", + "description": "Measure string width for default font", + "returnType": "int", + "params": [ + { + "type": "const char *", + "name": "text" + }, + { + "type": "int", + "name": "fontSize" + } + ] + }, + { + "name": "MeasureTextEx", + "description": "Measure string size for Font", + "returnType": "Vector2", + "params": [ + { + "type": "Font", + "name": "font" + }, + { + "type": "const char *", + "name": "text" + }, + { + "type": "float", + "name": "fontSize" + }, + { + "type": "float", + "name": "spacing" + } + ] + }, + { + "name": "GetGlyphIndex", + "description": "Get glyph index position in font for a codepoint (unicode character), fallback to '?' if not found", + "returnType": "int", + "params": [ + { + "type": "Font", + "name": "font" + }, + { + "type": "int", + "name": "codepoint" + } + ] + }, + { + "name": "GetGlyphInfo", + "description": "Get glyph font info data for a codepoint (unicode character), fallback to '?' if not found", + "returnType": "GlyphInfo", + "params": [ + { + "type": "Font", + "name": "font" + }, + { + "type": "int", + "name": "codepoint" + } + ] + }, + { + "name": "GetGlyphAtlasRec", + "description": "Get glyph rectangle in font atlas for a codepoint (unicode character), fallback to '?' if not found", + "returnType": "Rectangle", + "params": [ + { + "type": "Font", + "name": "font" + }, + { + "type": "int", + "name": "codepoint" + } + ] + }, + { + "name": "LoadUTF8", + "description": "Load UTF-8 text encoded from codepoints array", + "returnType": "char *", + "params": [ + { + "type": "const int *", + "name": "codepoints" + }, + { + "type": "int", + "name": "length" + } + ] + }, + { + "name": "UnloadUTF8", + "description": "Unload UTF-8 text encoded from codepoints array", + "returnType": "void", + "params": [ + { + "type": "char *", + "name": "text" + } + ] + }, + { + "name": "LoadCodepoints", + "description": "Load all codepoints from a UTF-8 text string, codepoints count returned by parameter", + "returnType": "int *", + "params": [ + { + "type": "const char *", + "name": "text" + }, + { + "type": "int *", + "name": "count" + } + ] + }, + { + "name": "UnloadCodepoints", + "description": "Unload codepoints data from memory", + "returnType": "void", + "params": [ + { + "type": "int *", + "name": "codepoints" + } + ] + }, + { + "name": "GetCodepointCount", + "description": "Get total number of codepoints in a UTF-8 encoded string", + "returnType": "int", + "params": [ + { + "type": "const char *", + "name": "text" + } + ] + }, + { + "name": "GetCodepoint", + "description": "Get next codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure", + "returnType": "int", + "params": [ + { + "type": "const char *", + "name": "text" + }, + { + "type": "int *", + "name": "codepointSize" + } + ] + }, + { + "name": "GetCodepointNext", + "description": "Get next codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure", + "returnType": "int", + "params": [ + { + "type": "const char *", + "name": "text" + }, + { + "type": "int *", + "name": "codepointSize" + } + ] + }, + { + "name": "GetCodepointPrevious", + "description": "Get previous codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure", + "returnType": "int", + "params": [ + { + "type": "const char *", + "name": "text" + }, + { + "type": "int *", + "name": "codepointSize" + } + ] + }, + { + "name": "CodepointToUTF8", + "description": "Encode one codepoint into UTF-8 byte array (array length returned as parameter)", + "returnType": "const char *", + "params": [ + { + "type": "int", + "name": "codepoint" + }, + { + "type": "int *", + "name": "utf8Size" + } + ] + }, + { + "name": "TextCopy", + "description": "Copy one string to another, returns bytes copied", + "returnType": "int", + "params": [ + { + "type": "char *", + "name": "dst" + }, + { + "type": "const char *", + "name": "src" + } + ] + }, + { + "name": "TextIsEqual", + "description": "Check if two text string are equal", + "returnType": "bool", + "params": [ + { + "type": "const char *", + "name": "text1" + }, + { + "type": "const char *", + "name": "text2" + } + ] + }, + { + "name": "TextLength", + "description": "Get text length, checks for '\\0' ending", + "returnType": "unsigned int", + "params": [ + { + "type": "const char *", + "name": "text" + } + ] + }, + { + "name": "TextFormat", + "description": "Text formatting with variables (sprintf() style)", + "returnType": "const char *", + "params": [ + { + "type": "const char *", + "name": "text" + }, + { + "type": "...", + "name": "args" + } + ] + }, + { + "name": "TextSubtext", + "description": "Get a piece of a text string", + "returnType": "const char *", + "params": [ + { + "type": "const char *", + "name": "text" + }, + { + "type": "int", + "name": "position" + }, + { + "type": "int", + "name": "length" + } + ] + }, + { + "name": "TextReplace", + "description": "Replace text string (WARNING: memory must be freed!)", + "returnType": "char *", + "params": [ + { + "type": "char *", + "name": "text" + }, + { + "type": "const char *", + "name": "replace" + }, + { + "type": "const char *", + "name": "by" + } + ] + }, + { + "name": "TextInsert", + "description": "Insert text in a position (WARNING: memory must be freed!)", + "returnType": "char *", + "params": [ + { + "type": "const char *", + "name": "text" + }, + { + "type": "const char *", + "name": "insert" + }, + { + "type": "int", + "name": "position" + } + ] + }, + { + "name": "TextJoin", + "description": "Join text strings with delimiter", + "returnType": "const char *", + "params": [ + { + "type": "const char **", + "name": "textList" + }, + { + "type": "int", + "name": "count" + }, + { + "type": "const char *", + "name": "delimiter" + } + ] + }, + { + "name": "TextSplit", + "description": "Split text into multiple strings", + "returnType": "const char **", + "params": [ + { + "type": "const char *", + "name": "text" + }, + { + "type": "char", + "name": "delimiter" + }, + { + "type": "int *", + "name": "count" + } + ] + }, + { + "name": "TextAppend", + "description": "Append text at specific position and move cursor!", + "returnType": "void", + "params": [ + { + "type": "char *", + "name": "text" + }, + { + "type": "const char *", + "name": "append" + }, + { + "type": "int *", + "name": "position" + } + ] + }, + { + "name": "TextFindIndex", + "description": "Find first text occurrence within a string", + "returnType": "int", + "params": [ + { + "type": "const char *", + "name": "text" + }, + { + "type": "const char *", + "name": "find" + } + ] + }, + { + "name": "TextToUpper", + "description": "Get upper case version of provided string", + "returnType": "const char *", + "params": [ + { + "type": "const char *", + "name": "text" + } + ] + }, + { + "name": "TextToLower", + "description": "Get lower case version of provided string", + "returnType": "const char *", + "params": [ + { + "type": "const char *", + "name": "text" + } + ] + }, + { + "name": "TextToPascal", + "description": "Get Pascal case notation version of provided string", + "returnType": "const char *", + "params": [ + { + "type": "const char *", + "name": "text" + } + ] + }, + { + "name": "TextToInteger", + "description": "Get integer value from text (negative values not supported)", + "returnType": "int", + "params": [ + { + "type": "const char *", + "name": "text" + } + ] + }, + { + "name": "DrawLine3D", + "description": "Draw a line in 3D world space", + "returnType": "void", + "params": [ + { + "type": "Vector3", + "name": "startPos" + }, + { + "type": "Vector3", + "name": "endPos" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawPoint3D", + "description": "Draw a point in 3D space, actually a small line", + "returnType": "void", + "params": [ + { + "type": "Vector3", + "name": "position" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawCircle3D", + "description": "Draw a circle in 3D world space", + "returnType": "void", + "params": [ + { + "type": "Vector3", + "name": "center" + }, + { + "type": "float", + "name": "radius" + }, + { + "type": "Vector3", + "name": "rotationAxis" + }, + { + "type": "float", + "name": "rotationAngle" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawTriangle3D", + "description": "Draw a color-filled triangle (vertex in counter-clockwise order!)", + "returnType": "void", + "params": [ + { + "type": "Vector3", + "name": "v1" + }, + { + "type": "Vector3", + "name": "v2" + }, + { + "type": "Vector3", + "name": "v3" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawTriangleStrip3D", + "description": "Draw a triangle strip defined by points", + "returnType": "void", + "params": [ + { + "type": "Vector3[]", + "name": "points" + }, + { + "type": "int", + "name": "pointCount" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawCube", + "description": "Draw cube", + "returnType": "void", + "params": [ + { + "type": "Vector3", + "name": "position" + }, + { + "type": "float", + "name": "width" + }, + { + "type": "float", + "name": "height" + }, + { + "type": "float", + "name": "length" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawCubeV", + "description": "Draw cube (Vector version)", + "returnType": "void", + "params": [ + { + "type": "Vector3", + "name": "position" + }, + { + "type": "Vector3", + "name": "size" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawCubeWires", + "description": "Draw cube wires", + "returnType": "void", + "params": [ + { + "type": "Vector3", + "name": "position" + }, + { + "type": "float", + "name": "width" + }, + { + "type": "float", + "name": "height" + }, + { + "type": "float", + "name": "length" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawCubeWiresV", + "description": "Draw cube wires (Vector version)", + "returnType": "void", + "params": [ + { + "type": "Vector3", + "name": "position" + }, + { + "type": "Vector3", + "name": "size" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawSphere", + "description": "Draw sphere", + "returnType": "void", + "params": [ + { + "type": "Vector3", + "name": "centerPos" + }, + { + "type": "float", + "name": "radius" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawSphereEx", + "description": "Draw sphere with extended parameters", + "returnType": "void", + "params": [ + { + "type": "Vector3", + "name": "centerPos" + }, + { + "type": "float", + "name": "radius" + }, + { + "type": "int", + "name": "rings" + }, + { + "type": "int", + "name": "slices" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawSphereWires", + "description": "Draw sphere wires", + "returnType": "void", + "params": [ + { + "type": "Vector3", + "name": "centerPos" + }, + { + "type": "float", + "name": "radius" + }, + { + "type": "int", + "name": "rings" + }, + { + "type": "int", + "name": "slices" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawCylinder", + "description": "Draw a cylinder/cone", + "returnType": "void", + "params": [ + { + "type": "Vector3", + "name": "position" + }, + { + "type": "float", + "name": "radiusTop" + }, + { + "type": "float", + "name": "radiusBottom" + }, + { + "type": "float", + "name": "height" + }, + { + "type": "int", + "name": "slices" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawCylinderEx", + "description": "Draw a cylinder with base at startPos and top at endPos", + "returnType": "void", + "params": [ + { + "type": "Vector3", + "name": "startPos" + }, + { + "type": "Vector3", + "name": "endPos" + }, + { + "type": "float", + "name": "startRadius" + }, + { + "type": "float", + "name": "endRadius" + }, + { + "type": "int", + "name": "sides" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawCylinderWires", + "description": "Draw a cylinder/cone wires", + "returnType": "void", + "params": [ + { + "type": "Vector3", + "name": "position" + }, + { + "type": "float", + "name": "radiusTop" + }, + { + "type": "float", + "name": "radiusBottom" + }, + { + "type": "float", + "name": "height" + }, + { + "type": "int", + "name": "slices" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawCylinderWiresEx", + "description": "Draw a cylinder wires with base at startPos and top at endPos", + "returnType": "void", + "params": [ + { + "type": "Vector3", + "name": "startPos" + }, + { + "type": "Vector3", + "name": "endPos" + }, + { + "type": "float", + "name": "startRadius" + }, + { + "type": "float", + "name": "endRadius" + }, + { + "type": "int", + "name": "sides" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawCapsule", + "description": "Draw a capsule with the center of its sphere caps at startPos and endPos", + "returnType": "void", + "params": [ + { + "type": "Vector3", + "name": "startPos" + }, + { + "type": "Vector3", + "name": "endPos" + }, + { + "type": "float", + "name": "radius" + }, + { + "type": "int", + "name": "slices" + }, + { + "type": "int", + "name": "rings" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawCapsuleWires", + "description": "Draw capsule wireframe with the center of its sphere caps at startPos and endPos", + "returnType": "void", + "params": [ + { + "type": "Vector3", + "name": "startPos" + }, + { + "type": "Vector3", + "name": "endPos" + }, + { + "type": "float", + "name": "radius" + }, + { + "type": "int", + "name": "slices" + }, + { + "type": "int", + "name": "rings" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawPlane", + "description": "Draw a plane XZ", + "returnType": "void", + "params": [ + { + "type": "Vector3", + "name": "centerPos" + }, + { + "type": "Vector2", + "name": "size" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawRay", + "description": "Draw a ray line", + "returnType": "void", + "params": [ + { + "type": "Ray", + "name": "ray" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawGrid", + "description": "Draw a grid (centered at (0, 0, 0))", + "returnType": "void", + "params": [ + { + "type": "int", + "name": "slices" + }, + { + "type": "float", + "name": "spacing" + } + ] + }, + { + "name": "LoadModel", + "description": "Load model from files (meshes and materials)", + "returnType": "Model", + "params": [ + { + "type": "const char *", + "name": "fileName" + } + ] + }, + { + "name": "LoadModelFromMesh", + "description": "Load model from generated mesh (default material)", + "returnType": "Model", + "params": [ + { + "type": "Mesh", + "name": "mesh" + } + ] + }, + { + "name": "IsModelReady", + "description": "Check if a model is ready", + "returnType": "bool", + "params": [ + { + "type": "Model", + "name": "model" + } + ] + }, + { + "name": "UnloadModel", + "description": "Unload model (including meshes) from memory (RAM and/or VRAM)", + "returnType": "void", + "params": [ + { + "type": "Model", + "name": "model" + } + ] + }, + { + "name": "GetModelBoundingBox", + "description": "Compute model bounding box limits (considers all meshes)", + "returnType": "BoundingBox", + "params": [ + { + "type": "Model", + "name": "model" + } + ] + }, + { + "name": "DrawModel", + "description": "Draw a model (with texture if set)", + "returnType": "void", + "params": [ + { + "type": "Model", + "name": "model" + }, + { + "type": "Vector3", + "name": "position" + }, + { + "type": "float", + "name": "scale" + }, + { + "type": "Color", + "name": "tint" + } + ] + }, + { + "name": "DrawModelEx", + "description": "Draw a model with extended parameters", + "returnType": "void", + "params": [ + { + "type": "Model", + "name": "model" + }, + { + "type": "Vector3", + "name": "position" + }, + { + "type": "Vector3", + "name": "rotationAxis" + }, + { + "type": "float", + "name": "rotationAngle" + }, + { + "type": "Vector3", + "name": "scale" + }, + { + "type": "Color", + "name": "tint" + } + ] + }, + { + "name": "DrawModelWires", + "description": "Draw a model wires (with texture if set)", + "returnType": "void", + "params": [ + { + "type": "Model", + "name": "model" + }, + { + "type": "Vector3", + "name": "position" + }, + { + "type": "float", + "name": "scale" + }, + { + "type": "Color", + "name": "tint" + } + ] + }, + { + "name": "DrawModelWiresEx", + "description": "Draw a model wires (with texture if set) with extended parameters", + "returnType": "void", + "params": [ + { + "type": "Model", + "name": "model" + }, + { + "type": "Vector3", + "name": "position" + }, + { + "type": "Vector3", + "name": "rotationAxis" + }, + { + "type": "float", + "name": "rotationAngle" + }, + { + "type": "Vector3", + "name": "scale" + }, + { + "type": "Color", + "name": "tint" + } + ] + }, + { + "name": "DrawBoundingBox", + "description": "Draw bounding box (wires)", + "returnType": "void", + "params": [ + { + "type": "BoundingBox", + "name": "box" + }, + { + "type": "Color", + "name": "color" + } + ] + }, + { + "name": "DrawBillboard", + "description": "Draw a billboard texture", + "returnType": "void", + "params": [ + { + "type": "Camera", + "name": "camera" + }, + { + "type": "Texture2D", + "name": "texture" + }, + { + "type": "Vector3", + "name": "position" + }, + { + "type": "float", + "name": "size" + }, + { + "type": "Color", + "name": "tint" + } + ] + }, + { + "name": "DrawBillboardRec", + "description": "Draw a billboard texture defined by source", + "returnType": "void", + "params": [ + { + "type": "Camera", + "name": "camera" + }, + { + "type": "Texture2D", + "name": "texture" + }, + { + "type": "Rectangle", + "name": "source" + }, + { + "type": "Vector3", + "name": "position" + }, + { + "type": "Vector2", + "name": "size" + }, + { + "type": "Color", + "name": "tint" + } + ] + }, + { + "name": "DrawBillboardPro", + "description": "Draw a billboard texture defined by source and rotation", + "returnType": "void", + "params": [ + { + "type": "Camera", + "name": "camera" + }, + { + "type": "Texture2D", + "name": "texture" + }, + { + "type": "Rectangle", + "name": "source" + }, + { + "type": "Vector3", + "name": "position" + }, + { + "type": "Vector3", + "name": "up" + }, + { + "type": "Vector2", + "name": "size" + }, + { + "type": "Vector2", + "name": "origin" + }, + { + "type": "float", + "name": "rotation" + }, + { + "type": "Color", + "name": "tint" + } + ] + }, + { + "name": "UploadMesh", + "description": "Upload mesh vertex data in GPU and provide VAO/VBO ids", + "returnType": "void", + "params": [ + { + "type": "Mesh *", + "name": "mesh" + }, + { + "type": "bool", + "name": "dynamic" + } + ] + }, + { + "name": "UpdateMeshBuffer", + "description": "Update mesh vertex data in GPU for a specific buffer index", + "returnType": "void", + "params": [ + { + "type": "Mesh", + "name": "mesh" + }, + { + "type": "int", + "name": "index" + }, + { + "type": "const void *", + "name": "data" + }, + { + "type": "int", + "name": "dataSize" + }, + { + "type": "int", + "name": "offset" + } + ] + }, + { + "name": "UnloadMesh", + "description": "Unload mesh data from CPU and GPU", + "returnType": "void", + "params": [ + { + "type": "Mesh", + "name": "mesh" + } + ] + }, + { + "name": "DrawMesh", + "description": "Draw a 3d mesh with material and transform", + "returnType": "void", + "params": [ + { + "type": "Mesh", + "name": "mesh" + }, + { + "type": "Material", + "name": "material" + }, + { + "type": "Matrix", + "name": "transform" + } + ] + }, + { + "name": "DrawMeshInstanced", + "description": "Draw multiple mesh instances with material and different transforms", + "returnType": "void", + "params": [ + { + "type": "Mesh", + "name": "mesh" + }, + { + "type": "Material", + "name": "material" + }, + { + "type": "Matrix[]", + "name": "transforms" + }, + { + "type": "int", + "name": "instances" + } + ] + }, + { + "name": "ExportMesh", + "description": "Export mesh data to file, returns true on success", + "returnType": "bool", + "params": [ + { + "type": "Mesh", + "name": "mesh" + }, + { + "type": "const char *", + "name": "fileName" + } + ] + }, + { + "name": "GetMeshBoundingBox", + "description": "Compute mesh bounding box limits", + "returnType": "BoundingBox", + "params": [ + { + "type": "Mesh", + "name": "mesh" + } + ] + }, + { + "name": "GenMeshTangents", + "description": "Compute mesh tangents", + "returnType": "void", + "params": [ + { + "type": "Mesh *", + "name": "mesh" + } + ] + }, + { + "name": "GenMeshPoly", + "description": "Generate polygonal mesh", + "returnType": "Mesh", + "params": [ + { + "type": "int", + "name": "sides" + }, + { + "type": "float", + "name": "radius" + } + ] + }, + { + "name": "GenMeshPlane", + "description": "Generate plane mesh (with subdivisions)", + "returnType": "Mesh", + "params": [ + { + "type": "float", + "name": "width" + }, + { + "type": "float", + "name": "length" + }, + { + "type": "int", + "name": "resX" + }, + { + "type": "int", + "name": "resZ" + } + ] + }, + { + "name": "GenMeshCube", + "description": "Generate cuboid mesh", + "returnType": "Mesh", + "params": [ + { + "type": "float", + "name": "width" + }, + { + "type": "float", + "name": "height" + }, + { + "type": "float", + "name": "length" + } + ] + }, + { + "name": "GenMeshSphere", + "description": "Generate sphere mesh (standard sphere)", + "returnType": "Mesh", + "params": [ + { + "type": "float", + "name": "radius" + }, + { + "type": "int", + "name": "rings" + }, + { + "type": "int", + "name": "slices" + } + ] + }, + { + "name": "GenMeshHemiSphere", + "description": "Generate half-sphere mesh (no bottom cap)", + "returnType": "Mesh", + "params": [ + { + "type": "float", + "name": "radius" + }, + { + "type": "int", + "name": "rings" + }, + { + "type": "int", + "name": "slices" + } + ] + }, + { + "name": "GenMeshCylinder", + "description": "Generate cylinder mesh", + "returnType": "Mesh", + "params": [ + { + "type": "float", + "name": "radius" + }, + { + "type": "float", + "name": "height" + }, + { + "type": "int", + "name": "slices" + } + ] + }, + { + "name": "GenMeshCone", + "description": "Generate cone/pyramid mesh", + "returnType": "Mesh", + "params": [ + { + "type": "float", + "name": "radius" + }, + { + "type": "float", + "name": "height" + }, + { + "type": "int", + "name": "slices" + } + ] + }, + { + "name": "GenMeshTorus", + "description": "Generate torus mesh", + "returnType": "Mesh", + "params": [ + { + "type": "float", + "name": "radius" + }, + { + "type": "float", + "name": "size" + }, + { + "type": "int", + "name": "radSeg" + }, + { + "type": "int", + "name": "sides" + } + ] + }, + { + "name": "GenMeshKnot", + "description": "Generate trefoil knot mesh", + "returnType": "Mesh", + "params": [ + { + "type": "float", + "name": "radius" + }, + { + "type": "float", + "name": "size" + }, + { + "type": "int", + "name": "radSeg" + }, + { + "type": "int", + "name": "sides" + } + ] + }, + { + "name": "GenMeshHeightmap", + "description": "Generate heightmap mesh from image data", + "returnType": "Mesh", + "params": [ + { + "type": "Image", + "name": "heightmap" + }, + { + "type": "Vector3", + "name": "size" + } + ] + }, + { + "name": "GenMeshCubicmap", + "description": "Generate cubes-based map mesh from image data", + "returnType": "Mesh", + "params": [ + { + "type": "Image", + "name": "cubicmap" + }, + { + "type": "Vector3", + "name": "cubeSize" + } + ] + }, + { + "name": "LoadMaterials", + "description": "Load materials from model file", + "returnType": "Material *", + "params": [ + { + "type": "const char *", + "name": "fileName" + }, + { + "type": "int *", + "name": "materialCount" + } + ] + }, + { + "name": "LoadMaterialDefault", + "description": "Load default material (Supports: DIFFUSE, SPECULAR, NORMAL maps)", + "returnType": "Material" + }, + { + "name": "IsMaterialReady", + "description": "Check if a material is ready", + "returnType": "bool", + "params": [ + { + "type": "Material", + "name": "material" + } + ] + }, + { + "name": "UnloadMaterial", + "description": "Unload material from GPU memory (VRAM)", + "returnType": "void", + "params": [ + { + "type": "Material", + "name": "material" + } + ] + }, + { + "name": "SetMaterialTexture", + "description": "Set texture for a material map type (MATERIAL_MAP_DIFFUSE, MATERIAL_MAP_SPECULAR...)", + "returnType": "void", + "params": [ + { + "type": "Material *", + "name": "material" + }, + { + "type": "int", + "name": "mapType" + }, + { + "type": "Texture2D", + "name": "texture" + } + ] + }, + { + "name": "SetModelMeshMaterial", + "description": "Set material for a mesh", + "returnType": "void", + "params": [ + { + "type": "Model *", + "name": "model" + }, + { + "type": "int", + "name": "meshId" + }, + { + "type": "int", + "name": "materialId" + } + ] + }, + { + "name": "LoadModelAnimations", + "description": "Load model animations from file", + "returnType": "ModelAnimation *", + "params": [ + { + "type": "const char *", + "name": "fileName" + }, + { + "type": "int *", + "name": "animCount" + } + ] + }, + { + "name": "UpdateModelAnimation", + "description": "Update model animation pose", + "returnType": "void", + "params": [ + { + "type": "Model", + "name": "model" + }, + { + "type": "ModelAnimation", + "name": "anim" + }, + { + "type": "int", + "name": "frame" + } + ] + }, + { + "name": "UnloadModelAnimation", + "description": "Unload animation data", + "returnType": "void", + "params": [ + { + "type": "ModelAnimation", + "name": "anim" + } + ] + }, + { + "name": "UnloadModelAnimations", + "description": "Unload animation array data", + "returnType": "void", + "params": [ + { + "type": "ModelAnimation *", + "name": "animations" + }, + { + "type": "int", + "name": "animCount" + } + ] + }, + { + "name": "IsModelAnimationValid", + "description": "Check model animation skeleton match", + "returnType": "bool", + "params": [ + { + "type": "Model", + "name": "model" + }, + { + "type": "ModelAnimation", + "name": "anim" + } + ] + }, + { + "name": "CheckCollisionSpheres", + "description": "Check collision between two spheres", + "returnType": "bool", + "params": [ + { + "type": "Vector3", + "name": "center1" + }, + { + "type": "float", + "name": "radius1" + }, + { + "type": "Vector3", + "name": "center2" + }, + { + "type": "float", + "name": "radius2" + } + ] + }, + { + "name": "CheckCollisionBoxes", + "description": "Check collision between two bounding boxes", + "returnType": "bool", + "params": [ + { + "type": "BoundingBox", + "name": "box1" + }, + { + "type": "BoundingBox", + "name": "box2" + } + ] + }, + { + "name": "CheckCollisionBoxSphere", + "description": "Check collision between box and sphere", + "returnType": "bool", + "params": [ + { + "type": "BoundingBox", + "name": "box" + }, + { + "type": "Vector3", + "name": "center" + }, + { + "type": "float", + "name": "radius" + } + ] + }, + { + "name": "GetRayCollisionSphere", + "description": "Get collision info between ray and sphere", + "returnType": "RayCollision", + "params": [ + { + "type": "Ray", + "name": "ray" + }, + { + "type": "Vector3", + "name": "center" + }, + { + "type": "float", + "name": "radius" + } + ] + }, + { + "name": "GetRayCollisionBox", + "description": "Get collision info between ray and box", + "returnType": "RayCollision", + "params": [ + { + "type": "Ray", + "name": "ray" + }, + { + "type": "BoundingBox", + "name": "box" + } + ] + }, + { + "name": "GetRayCollisionMesh", + "description": "Get collision info between ray and mesh", + "returnType": "RayCollision", + "params": [ + { + "type": "Ray", + "name": "ray" + }, + { + "type": "Mesh", + "name": "mesh" + }, + { + "type": "Matrix", + "name": "transform" + } + ] + }, + { + "name": "GetRayCollisionTriangle", + "description": "Get collision info between ray and triangle", + "returnType": "RayCollision", + "params": [ + { + "type": "Ray", + "name": "ray" + }, + { + "type": "Vector3", + "name": "p1" + }, + { + "type": "Vector3", + "name": "p2" + }, + { + "type": "Vector3", + "name": "p3" + } + ] + }, + { + "name": "GetRayCollisionQuad", + "description": "Get collision info between ray and quad", + "returnType": "RayCollision", + "params": [ + { + "type": "Ray", + "name": "ray" + }, + { + "type": "Vector3", + "name": "p1" + }, + { + "type": "Vector3", + "name": "p2" + }, + { + "type": "Vector3", + "name": "p3" + }, + { + "type": "Vector3", + "name": "p4" + } + ] + }, + { + "name": "InitAudioDevice", + "description": "Initialize audio device and context", + "returnType": "void" + }, + { + "name": "CloseAudioDevice", + "description": "Close the audio device and context", + "returnType": "void" + }, + { + "name": "IsAudioDeviceReady", + "description": "Check if audio device has been initialized successfully", + "returnType": "bool" + }, + { + "name": "SetMasterVolume", + "description": "Set master volume (listener)", + "returnType": "void", + "params": [ + { + "type": "float", + "name": "volume" + } + ] + }, + { + "name": "GetMasterVolume", + "description": "Get master volume (listener)", + "returnType": "float" + }, + { + "name": "LoadWave", + "description": "Load wave data from file", + "returnType": "Wave", + "params": [ + { + "type": "const char *", + "name": "fileName" + } + ] + }, + { + "name": "LoadWaveFromMemory", + "description": "Load wave from memory buffer, fileType refers to extension: i.e. '.wav'", + "returnType": "Wave", + "params": [ + { + "type": "const char *", + "name": "fileType" + }, + { + "type": "const unsigned char *", + "name": "fileData" + }, + { + "type": "int", + "name": "dataSize" + } + ] + }, + { + "name": "IsWaveReady", + "description": "Checks if wave data is ready", + "returnType": "bool", + "params": [ + { + "type": "Wave", + "name": "wave" + } + ] + }, + { + "name": "LoadSound", + "description": "Load sound from file", + "returnType": "Sound", + "params": [ + { + "type": "const char *", + "name": "fileName" + } + ] + }, + { + "name": "LoadSoundFromWave", + "description": "Load sound from wave data", + "returnType": "Sound", + "params": [ + { + "type": "Wave", + "name": "wave" + } + ] + }, + { + "name": "LoadSoundAlias", + "description": "Create a new sound that shares the same sample data as the source sound, does not own the sound data", + "returnType": "Sound", + "params": [ + { + "type": "Sound", + "name": "source" + } + ] + }, + { + "name": "IsSoundReady", + "description": "Checks if a sound is ready", + "returnType": "bool", + "params": [ + { + "type": "Sound", + "name": "sound" + } + ] + }, + { + "name": "UpdateSound", + "description": "Update sound buffer with new data", + "returnType": "void", + "params": [ + { + "type": "Sound", + "name": "sound" + }, + { + "type": "const void *", + "name": "data" + }, + { + "type": "int", + "name": "sampleCount" + } + ] + }, + { + "name": "UnloadWave", + "description": "Unload wave data", + "returnType": "void", + "params": [ + { + "type": "Wave", + "name": "wave" + } + ] + }, + { + "name": "UnloadSound", + "description": "Unload sound", + "returnType": "void", + "params": [ + { + "type": "Sound", + "name": "sound" + } + ] + }, + { + "name": "UnloadSoundAlias", + "description": "Unload a sound alias (does not deallocate sample data)", + "returnType": "void", + "params": [ + { + "type": "Sound", + "name": "alias" + } + ] + }, + { + "name": "ExportWave", + "description": "Export wave data to file, returns true on success", + "returnType": "bool", + "params": [ + { + "type": "Wave", + "name": "wave" + }, + { + "type": "const char *", + "name": "fileName" + } + ] + }, + { + "name": "ExportWaveAsCode", + "description": "Export wave sample data to code (.h), returns true on success", + "returnType": "bool", + "params": [ + { + "type": "Wave", + "name": "wave" + }, + { + "type": "const char *", + "name": "fileName" + } + ] + }, + { + "name": "PlaySound", + "description": "Play a sound", + "returnType": "void", + "params": [ + { + "type": "Sound", + "name": "sound" + } + ] + }, + { + "name": "StopSound", + "description": "Stop playing a sound", + "returnType": "void", + "params": [ + { + "type": "Sound", + "name": "sound" + } + ] + }, + { + "name": "PauseSound", + "description": "Pause a sound", + "returnType": "void", + "params": [ + { + "type": "Sound", + "name": "sound" + } + ] + }, + { + "name": "ResumeSound", + "description": "Resume a paused sound", + "returnType": "void", + "params": [ + { + "type": "Sound", + "name": "sound" + } + ] + }, + { + "name": "IsSoundPlaying", + "description": "Check if a sound is currently playing", + "returnType": "bool", + "params": [ + { + "type": "Sound", + "name": "sound" + } + ] + }, + { + "name": "SetSoundVolume", + "description": "Set volume for a sound (1.0 is max level)", + "returnType": "void", + "params": [ + { + "type": "Sound", + "name": "sound" + }, + { + "type": "float", + "name": "volume" + } + ] + }, + { + "name": "SetSoundPitch", + "description": "Set pitch for a sound (1.0 is base level)", + "returnType": "void", + "params": [ + { + "type": "Sound", + "name": "sound" + }, + { + "type": "float", + "name": "pitch" + } + ] + }, + { + "name": "SetSoundPan", + "description": "Set pan for a sound (0.5 is center)", + "returnType": "void", + "params": [ + { + "type": "Sound", + "name": "sound" + }, + { + "type": "float", + "name": "pan" + } + ] + }, + { + "name": "WaveCopy", + "description": "Copy a wave to a new wave", + "returnType": "Wave", + "params": [ + { + "type": "Wave", + "name": "wave" + } + ] + }, + { + "name": "WaveCrop", + "description": "Crop a wave to defined samples range", + "returnType": "void", + "params": [ + { + "type": "Wave *", + "name": "wave" + }, + { + "type": "int", + "name": "initSample" + }, + { + "type": "int", + "name": "finalSample" + } + ] + }, + { + "name": "WaveFormat", + "description": "Convert wave data to desired format", + "returnType": "void", + "params": [ + { + "type": "Wave *", + "name": "wave" + }, + { + "type": "int", + "name": "sampleRate" + }, + { + "type": "int", + "name": "sampleSize" + }, + { + "type": "int", + "name": "channels" + } + ] + }, + { + "name": "LoadWaveSamples", + "description": "Load samples data from wave as a 32bit float data array", + "returnType": "float *", + "params": [ + { + "type": "Wave", + "name": "wave" + } + ] + }, + { + "name": "UnloadWaveSamples", + "description": "Unload samples data loaded with LoadWaveSamples()", + "returnType": "void", + "params": [ + { + "type": "float *", + "name": "samples" + } + ] + }, + { + "name": "LoadMusicStream", + "description": "Load music stream from file", + "returnType": "Music", + "params": [ + { + "type": "const char *", + "name": "fileName" + } + ] + }, + { + "name": "LoadMusicStreamFromMemory", + "description": "Load music stream from data", + "returnType": "Music", + "params": [ + { + "type": "const char *", + "name": "fileType" + }, + { + "type": "const unsigned char *", + "name": "data" + }, + { + "type": "int", + "name": "dataSize" + } + ] + }, + { + "name": "IsMusicReady", + "description": "Checks if a music stream is ready", + "returnType": "bool", + "params": [ + { + "type": "Music", + "name": "music" + } + ] + }, + { + "name": "UnloadMusicStream", + "description": "Unload music stream", + "returnType": "void", + "params": [ + { + "type": "Music", + "name": "music" + } + ] + }, + { + "name": "PlayMusicStream", + "description": "Start music playing", + "returnType": "void", + "params": [ + { + "type": "Music", + "name": "music" + } + ] + }, + { + "name": "IsMusicStreamPlaying", + "description": "Check if music is playing", + "returnType": "bool", + "params": [ + { + "type": "Music", + "name": "music" + } + ] + }, + { + "name": "UpdateMusicStream", + "description": "Updates buffers for music streaming", + "returnType": "void", + "params": [ + { + "type": "Music", + "name": "music" + } + ] + }, + { + "name": "StopMusicStream", + "description": "Stop music playing", + "returnType": "void", + "params": [ + { + "type": "Music", + "name": "music" + } + ] + }, + { + "name": "PauseMusicStream", + "description": "Pause music playing", + "returnType": "void", + "params": [ + { + "type": "Music", + "name": "music" + } + ] + }, + { + "name": "ResumeMusicStream", + "description": "Resume playing paused music", + "returnType": "void", + "params": [ + { + "type": "Music", + "name": "music" + } + ] + }, + { + "name": "SeekMusicStream", + "description": "Seek music to a position (in seconds)", + "returnType": "void", + "params": [ + { + "type": "Music", + "name": "music" + }, + { + "type": "float", + "name": "position" + } + ] + }, + { + "name": "SetMusicVolume", + "description": "Set volume for music (1.0 is max level)", + "returnType": "void", + "params": [ + { + "type": "Music", + "name": "music" + }, + { + "type": "float", + "name": "volume" + } + ] + }, + { + "name": "SetMusicPitch", + "description": "Set pitch for a music (1.0 is base level)", + "returnType": "void", + "params": [ + { + "type": "Music", + "name": "music" + }, + { + "type": "float", + "name": "pitch" + } + ] + }, + { + "name": "SetMusicPan", + "description": "Set pan for a music (0.5 is center)", + "returnType": "void", + "params": [ + { + "type": "Music", + "name": "music" + }, + { + "type": "float", + "name": "pan" + } + ] + }, + { + "name": "GetMusicTimeLength", + "description": "Get music time length (in seconds)", + "returnType": "float", + "params": [ + { + "type": "Music", + "name": "music" + } + ] + }, + { + "name": "GetMusicTimePlayed", + "description": "Get current music time played (in seconds)", + "returnType": "float", + "params": [ + { + "type": "Music", + "name": "music" + } + ] + }, + { + "name": "LoadAudioStream", + "description": "Load audio stream (to stream raw audio pcm data)", + "returnType": "AudioStream", + "params": [ + { + "type": "unsigned int", + "name": "sampleRate" + }, + { + "type": "unsigned int", + "name": "sampleSize" + }, + { + "type": "unsigned int", + "name": "channels" + } + ] + }, + { + "name": "IsAudioStreamReady", + "description": "Checks if an audio stream is ready", + "returnType": "bool", + "params": [ + { + "type": "AudioStream", + "name": "stream" + } + ] + }, + { + "name": "UnloadAudioStream", + "description": "Unload audio stream and free memory", + "returnType": "void", + "params": [ + { + "type": "AudioStream", + "name": "stream" + } + ] + }, + { + "name": "UpdateAudioStream", + "description": "Update audio stream buffers with data", + "returnType": "void", + "params": [ + { + "type": "AudioStream", + "name": "stream" + }, + { + "type": "const void *", + "name": "data" + }, + { + "type": "int", + "name": "frameCount" + } + ] + }, + { + "name": "IsAudioStreamProcessed", + "description": "Check if any audio stream buffers requires refill", + "returnType": "bool", + "params": [ + { + "type": "AudioStream", + "name": "stream" + } + ] + }, + { + "name": "PlayAudioStream", + "description": "Play audio stream", + "returnType": "void", + "params": [ + { + "type": "AudioStream", + "name": "stream" + } + ] + }, + { + "name": "PauseAudioStream", + "description": "Pause audio stream", + "returnType": "void", + "params": [ + { + "type": "AudioStream", + "name": "stream" + } + ] + }, + { + "name": "ResumeAudioStream", + "description": "Resume audio stream", + "returnType": "void", + "params": [ + { + "type": "AudioStream", + "name": "stream" + } + ] + }, + { + "name": "IsAudioStreamPlaying", + "description": "Check if audio stream is playing", + "returnType": "bool", + "params": [ + { + "type": "AudioStream", + "name": "stream" + } + ] + }, + { + "name": "StopAudioStream", + "description": "Stop audio stream", + "returnType": "void", + "params": [ + { + "type": "AudioStream", + "name": "stream" + } + ] + }, + { + "name": "SetAudioStreamVolume", + "description": "Set volume for audio stream (1.0 is max level)", + "returnType": "void", + "params": [ + { + "type": "AudioStream", + "name": "stream" + }, + { + "type": "float", + "name": "volume" + } + ] + }, + { + "name": "SetAudioStreamPitch", + "description": "Set pitch for audio stream (1.0 is base level)", + "returnType": "void", + "params": [ + { + "type": "AudioStream", + "name": "stream" + }, + { + "type": "float", + "name": "pitch" + } + ] + }, + { + "name": "SetAudioStreamPan", + "description": "Set pan for audio stream (0.5 is centered)", + "returnType": "void", + "params": [ + { + "type": "AudioStream", + "name": "stream" + }, + { + "type": "float", + "name": "pan" + } + ] + }, + { + "name": "SetAudioStreamBufferSizeDefault", + "description": "Default size for new audio streams", + "returnType": "void", + "params": [ + { + "type": "int", + "name": "size" + } + ] + }, + { + "name": "SetAudioStreamCallback", + "description": "Audio thread callback to request new data", + "returnType": "void", + "params": [ + { + "type": "AudioStream", + "name": "stream" + }, + { + "type": "AudioCallback", + "name": "callback" + } + ] + }, + { + "name": "AttachAudioStreamProcessor", + "description": "Attach audio stream processor to stream, receives the samples as s", + "returnType": "void", + "params": [ + { + "type": "AudioStream", + "name": "stream" + }, + { + "type": "AudioCallback", + "name": "processor" + } + ] + }, + { + "name": "DetachAudioStreamProcessor", + "description": "Detach audio stream processor from stream", + "returnType": "void", + "params": [ + { + "type": "AudioStream", + "name": "stream" + }, + { + "type": "AudioCallback", + "name": "processor" + } + ] + }, + { + "name": "AttachAudioMixedProcessor", + "description": "Attach audio stream processor to the entire audio pipeline, receives the samples as s", + "returnType": "void", + "params": [ + { + "type": "AudioCallback", + "name": "processor" + } + ] + }, + { + "name": "DetachAudioMixedProcessor", + "description": "Detach audio stream processor from the entire audio pipeline", + "returnType": "void", + "params": [ + { + "type": "AudioCallback", + "name": "processor" + } + ] + } + ] +} diff --git a/api/raymath_api.json b/api/raymath_api.json new file mode 100644 index 0000000..e731557 --- /dev/null +++ b/api/raymath_api.json @@ -0,0 +1,1954 @@ +{ + "defines": [ + { + "name": "RAYMATH_H", + "type": "GUARD", + "value": "", + "description": "" + }, + { + "name": "RMAPI", + "type": "UNKNOWN", + "value": "__declspec(dllexport) extern inline", + "description": "We are building raylib as a Win32 shared library (.dll)." + }, + { + "name": "PI", + "type": "FLOAT", + "value": 3.14159265358979323846, + "description": "" + }, + { + "name": "EPSILON", + "type": "FLOAT", + "value": 0.000001, + "description": "" + }, + { + "name": "DEG2RAD", + "type": "FLOAT_MATH", + "value": "(PI/180.0f)", + "description": "" + }, + { + "name": "RAD2DEG", + "type": "FLOAT_MATH", + "value": "(180.0f/PI)", + "description": "" + }, + { + "name": "MatrixToFloat(mat)", + "type": "MACRO", + "value": "(MatrixToFloatV(mat).v)", + "description": "" + }, + { + "name": "Vector3ToFloat(vec)", + "type": "MACRO", + "value": "(Vector3ToFloatV(vec).v)", + "description": "" + }, + { + "name": "RL_VECTOR2_TYPE", + "type": "GUARD", + "value": "", + "description": "" + }, + { + "name": "RL_VECTOR3_TYPE", + "type": "GUARD", + "value": "", + "description": "" + }, + { + "name": "RL_VECTOR4_TYPE", + "type": "GUARD", + "value": "", + "description": "" + }, + { + "name": "RL_QUATERNION_TYPE", + "type": "GUARD", + "value": "", + "description": "" + }, + { + "name": "RL_MATRIX_TYPE", + "type": "GUARD", + "value": "", + "description": "" + } + ], + "structs": [ + { + "name": "Vector2", + "description": "Vector2 type", + "fields": [ + { + "type": "float", + "name": "x", + "description": "" + }, + { + "type": "float", + "name": "y", + "description": "" + } + ] + }, + { + "name": "Vector3", + "description": "Vector3 type", + "fields": [ + { + "type": "float", + "name": "x", + "description": "" + }, + { + "type": "float", + "name": "y", + "description": "" + }, + { + "type": "float", + "name": "z", + "description": "" + } + ] + }, + { + "name": "Vector4", + "description": "Vector4 type", + "fields": [ + { + "type": "float", + "name": "x", + "description": "" + }, + { + "type": "float", + "name": "y", + "description": "" + }, + { + "type": "float", + "name": "z", + "description": "" + }, + { + "type": "float", + "name": "w", + "description": "" + } + ] + }, + { + "name": "Matrix", + "description": "Matrix type (OpenGL style 4x4 - right handed, column major)", + "fields": [ + { + "type": "float", + "name": "m0", + "description": "Matrix first row (4 components)" + }, + { + "type": "float", + "name": "m4", + "description": "Matrix first row (4 components)" + }, + { + "type": "float", + "name": "m8", + "description": "Matrix first row (4 components)" + }, + { + "type": "float", + "name": "m12", + "description": "Matrix first row (4 components)" + }, + { + "type": "float", + "name": "m1", + "description": "Matrix second row (4 components)" + }, + { + "type": "float", + "name": "m5", + "description": "Matrix second row (4 components)" + }, + { + "type": "float", + "name": "m9", + "description": "Matrix second row (4 components)" + }, + { + "type": "float", + "name": "m13", + "description": "Matrix second row (4 components)" + }, + { + "type": "float", + "name": "m2", + "description": "Matrix third row (4 components)" + }, + { + "type": "float", + "name": "m6", + "description": "Matrix third row (4 components)" + }, + { + "type": "float", + "name": "m10", + "description": "Matrix third row (4 components)" + }, + { + "type": "float", + "name": "m14", + "description": "Matrix third row (4 components)" + }, + { + "type": "float", + "name": "m3", + "description": "Matrix fourth row (4 components)" + }, + { + "type": "float", + "name": "m7", + "description": "Matrix fourth row (4 components)" + }, + { + "type": "float", + "name": "m11", + "description": "Matrix fourth row (4 components)" + }, + { + "type": "float", + "name": "m15", + "description": "Matrix fourth row (4 components)" + } + ] + }, + { + "name": "float3", + "description": "NOTE: Helper types to be used instead of array return types for *ToFloat functions", + "fields": [ + { + "type": "float[3]", + "name": "v", + "description": "" + } + ] + }, + { + "name": "float16", + "description": "", + "fields": [ + { + "type": "float[16]", + "name": "v", + "description": "" + } + ] + } + ], + "aliases": [ + { + "type": "Vector4", + "name": "Quaternion", + "description": "Quaternion type" + } + ], + "enums": [ + ], + "callbacks": [ + ], + "functions": [ + { + "name": "Clamp", + "description": "", + "returnType": "float", + "params": [ + { + "type": "float", + "name": "value" + }, + { + "type": "float", + "name": "min" + }, + { + "type": "float", + "name": "max" + } + ] + }, + { + "name": "Lerp", + "description": "", + "returnType": "float", + "params": [ + { + "type": "float", + "name": "start" + }, + { + "type": "float", + "name": "end" + }, + { + "type": "float", + "name": "amount" + } + ] + }, + { + "name": "Normalize", + "description": "", + "returnType": "float", + "params": [ + { + "type": "float", + "name": "value" + }, + { + "type": "float", + "name": "start" + }, + { + "type": "float", + "name": "end" + } + ] + }, + { + "name": "Remap", + "description": "", + "returnType": "float", + "params": [ + { + "type": "float", + "name": "value" + }, + { + "type": "float", + "name": "inputStart" + }, + { + "type": "float", + "name": "inputEnd" + }, + { + "type": "float", + "name": "outputStart" + }, + { + "type": "float", + "name": "outputEnd" + } + ] + }, + { + "name": "Wrap", + "description": "", + "returnType": "float", + "params": [ + { + "type": "float", + "name": "value" + }, + { + "type": "float", + "name": "min" + }, + { + "type": "float", + "name": "max" + } + ] + }, + { + "name": "FloatEquals", + "description": "", + "returnType": "int", + "params": [ + { + "type": "float", + "name": "x" + }, + { + "type": "float", + "name": "y" + } + ] + }, + { + "name": "Vector2Zero", + "description": "", + "returnType": "Vector2" + }, + { + "name": "Vector2One", + "description": "", + "returnType": "Vector2" + }, + { + "name": "Vector2Add", + "description": "", + "returnType": "Vector2", + "params": [ + { + "type": "Vector2", + "name": "v1" + }, + { + "type": "Vector2", + "name": "v2" + } + ] + }, + { + "name": "Vector2AddValue", + "description": "", + "returnType": "Vector2", + "params": [ + { + "type": "Vector2", + "name": "v" + }, + { + "type": "float", + "name": "add" + } + ] + }, + { + "name": "Vector2Subtract", + "description": "", + "returnType": "Vector2", + "params": [ + { + "type": "Vector2", + "name": "v1" + }, + { + "type": "Vector2", + "name": "v2" + } + ] + }, + { + "name": "Vector2SubtractValue", + "description": "", + "returnType": "Vector2", + "params": [ + { + "type": "Vector2", + "name": "v" + }, + { + "type": "float", + "name": "sub" + } + ] + }, + { + "name": "Vector2Length", + "description": "", + "returnType": "float", + "params": [ + { + "type": "Vector2", + "name": "v" + } + ] + }, + { + "name": "Vector2LengthSqr", + "description": "", + "returnType": "float", + "params": [ + { + "type": "Vector2", + "name": "v" + } + ] + }, + { + "name": "Vector2DotProduct", + "description": "", + "returnType": "float", + "params": [ + { + "type": "Vector2", + "name": "v1" + }, + { + "type": "Vector2", + "name": "v2" + } + ] + }, + { + "name": "Vector2Distance", + "description": "", + "returnType": "float", + "params": [ + { + "type": "Vector2", + "name": "v1" + }, + { + "type": "Vector2", + "name": "v2" + } + ] + }, + { + "name": "Vector2DistanceSqr", + "description": "", + "returnType": "float", + "params": [ + { + "type": "Vector2", + "name": "v1" + }, + { + "type": "Vector2", + "name": "v2" + } + ] + }, + { + "name": "Vector2Angle", + "description": "", + "returnType": "float", + "params": [ + { + "type": "Vector2", + "name": "v1" + }, + { + "type": "Vector2", + "name": "v2" + } + ] + }, + { + "name": "Vector2LineAngle", + "description": "", + "returnType": "float", + "params": [ + { + "type": "Vector2", + "name": "start" + }, + { + "type": "Vector2", + "name": "end" + } + ] + }, + { + "name": "Vector2Scale", + "description": "", + "returnType": "Vector2", + "params": [ + { + "type": "Vector2", + "name": "v" + }, + { + "type": "float", + "name": "scale" + } + ] + }, + { + "name": "Vector2Multiply", + "description": "", + "returnType": "Vector2", + "params": [ + { + "type": "Vector2", + "name": "v1" + }, + { + "type": "Vector2", + "name": "v2" + } + ] + }, + { + "name": "Vector2Negate", + "description": "", + "returnType": "Vector2", + "params": [ + { + "type": "Vector2", + "name": "v" + } + ] + }, + { + "name": "Vector2Divide", + "description": "", + "returnType": "Vector2", + "params": [ + { + "type": "Vector2", + "name": "v1" + }, + { + "type": "Vector2", + "name": "v2" + } + ] + }, + { + "name": "Vector2Normalize", + "description": "", + "returnType": "Vector2", + "params": [ + { + "type": "Vector2", + "name": "v" + } + ] + }, + { + "name": "Vector2Transform", + "description": "", + "returnType": "Vector2", + "params": [ + { + "type": "Vector2", + "name": "v" + }, + { + "type": "Matrix", + "name": "mat" + } + ] + }, + { + "name": "Vector2Lerp", + "description": "", + "returnType": "Vector2", + "params": [ + { + "type": "Vector2", + "name": "v1" + }, + { + "type": "Vector2", + "name": "v2" + }, + { + "type": "float", + "name": "amount" + } + ] + }, + { + "name": "Vector2Reflect", + "description": "", + "returnType": "Vector2", + "params": [ + { + "type": "Vector2", + "name": "v" + }, + { + "type": "Vector2", + "name": "normal" + } + ] + }, + { + "name": "Vector2Rotate", + "description": "", + "returnType": "Vector2", + "params": [ + { + "type": "Vector2", + "name": "v" + }, + { + "type": "float", + "name": "angle" + } + ] + }, + { + "name": "Vector2MoveTowards", + "description": "", + "returnType": "Vector2", + "params": [ + { + "type": "Vector2", + "name": "v" + }, + { + "type": "Vector2", + "name": "target" + }, + { + "type": "float", + "name": "maxDistance" + } + ] + }, + { + "name": "Vector2Invert", + "description": "", + "returnType": "Vector2", + "params": [ + { + "type": "Vector2", + "name": "v" + } + ] + }, + { + "name": "Vector2Clamp", + "description": "", + "returnType": "Vector2", + "params": [ + { + "type": "Vector2", + "name": "v" + }, + { + "type": "Vector2", + "name": "min" + }, + { + "type": "Vector2", + "name": "max" + } + ] + }, + { + "name": "Vector2ClampValue", + "description": "", + "returnType": "Vector2", + "params": [ + { + "type": "Vector2", + "name": "v" + }, + { + "type": "float", + "name": "min" + }, + { + "type": "float", + "name": "max" + } + ] + }, + { + "name": "Vector2Equals", + "description": "", + "returnType": "int", + "params": [ + { + "type": "Vector2", + "name": "p" + }, + { + "type": "Vector2", + "name": "q" + } + ] + }, + { + "name": "Vector3Zero", + "description": "", + "returnType": "Vector3" + }, + { + "name": "Vector3One", + "description": "", + "returnType": "Vector3" + }, + { + "name": "Vector3Add", + "description": "", + "returnType": "Vector3", + "params": [ + { + "type": "Vector3", + "name": "v1" + }, + { + "type": "Vector3", + "name": "v2" + } + ] + }, + { + "name": "Vector3AddValue", + "description": "", + "returnType": "Vector3", + "params": [ + { + "type": "Vector3", + "name": "v" + }, + { + "type": "float", + "name": "add" + } + ] + }, + { + "name": "Vector3Subtract", + "description": "", + "returnType": "Vector3", + "params": [ + { + "type": "Vector3", + "name": "v1" + }, + { + "type": "Vector3", + "name": "v2" + } + ] + }, + { + "name": "Vector3SubtractValue", + "description": "", + "returnType": "Vector3", + "params": [ + { + "type": "Vector3", + "name": "v" + }, + { + "type": "float", + "name": "sub" + } + ] + }, + { + "name": "Vector3Scale", + "description": "", + "returnType": "Vector3", + "params": [ + { + "type": "Vector3", + "name": "v" + }, + { + "type": "float", + "name": "scalar" + } + ] + }, + { + "name": "Vector3Multiply", + "description": "", + "returnType": "Vector3", + "params": [ + { + "type": "Vector3", + "name": "v1" + }, + { + "type": "Vector3", + "name": "v2" + } + ] + }, + { + "name": "Vector3CrossProduct", + "description": "", + "returnType": "Vector3", + "params": [ + { + "type": "Vector3", + "name": "v1" + }, + { + "type": "Vector3", + "name": "v2" + } + ] + }, + { + "name": "Vector3Perpendicular", + "description": "", + "returnType": "Vector3", + "params": [ + { + "type": "Vector3", + "name": "v" + } + ] + }, + { + "name": "Vector3Length", + "description": "", + "returnType": "float", + "params": [ + { + "type": "Vector3", + "name": "v" + } + ] + }, + { + "name": "Vector3LengthSqr", + "description": "", + "returnType": "float", + "params": [ + { + "type": "Vector3", + "name": "v" + } + ] + }, + { + "name": "Vector3DotProduct", + "description": "", + "returnType": "float", + "params": [ + { + "type": "Vector3", + "name": "v1" + }, + { + "type": "Vector3", + "name": "v2" + } + ] + }, + { + "name": "Vector3Distance", + "description": "", + "returnType": "float", + "params": [ + { + "type": "Vector3", + "name": "v1" + }, + { + "type": "Vector3", + "name": "v2" + } + ] + }, + { + "name": "Vector3DistanceSqr", + "description": "", + "returnType": "float", + "params": [ + { + "type": "Vector3", + "name": "v1" + }, + { + "type": "Vector3", + "name": "v2" + } + ] + }, + { + "name": "Vector3Angle", + "description": "", + "returnType": "float", + "params": [ + { + "type": "Vector3", + "name": "v1" + }, + { + "type": "Vector3", + "name": "v2" + } + ] + }, + { + "name": "Vector3Negate", + "description": "", + "returnType": "Vector3", + "params": [ + { + "type": "Vector3", + "name": "v" + } + ] + }, + { + "name": "Vector3Divide", + "description": "", + "returnType": "Vector3", + "params": [ + { + "type": "Vector3", + "name": "v1" + }, + { + "type": "Vector3", + "name": "v2" + } + ] + }, + { + "name": "Vector3Normalize", + "description": "", + "returnType": "Vector3", + "params": [ + { + "type": "Vector3", + "name": "v" + } + ] + }, + { + "name": "Vector3Project", + "description": "", + "returnType": "Vector3", + "params": [ + { + "type": "Vector3", + "name": "v1" + }, + { + "type": "Vector3", + "name": "v2" + } + ] + }, + { + "name": "Vector3Reject", + "description": "", + "returnType": "Vector3", + "params": [ + { + "type": "Vector3", + "name": "v1" + }, + { + "type": "Vector3", + "name": "v2" + } + ] + }, + { + "name": "Vector3OrthoNormalize", + "description": "", + "returnType": "void", + "params": [ + { + "type": "Vector3 *", + "name": "v1" + }, + { + "type": "Vector3 *", + "name": "v2" + } + ] + }, + { + "name": "Vector3Transform", + "description": "", + "returnType": "Vector3", + "params": [ + { + "type": "Vector3", + "name": "v" + }, + { + "type": "Matrix", + "name": "mat" + } + ] + }, + { + "name": "Vector3RotateByQuaternion", + "description": "", + "returnType": "Vector3", + "params": [ + { + "type": "Vector3", + "name": "v" + }, + { + "type": "Quaternion", + "name": "q" + } + ] + }, + { + "name": "Vector3RotateByAxisAngle", + "description": "", + "returnType": "Vector3", + "params": [ + { + "type": "Vector3", + "name": "v" + }, + { + "type": "Vector3", + "name": "axis" + }, + { + "type": "float", + "name": "angle" + } + ] + }, + { + "name": "Vector3Lerp", + "description": "", + "returnType": "Vector3", + "params": [ + { + "type": "Vector3", + "name": "v1" + }, + { + "type": "Vector3", + "name": "v2" + }, + { + "type": "float", + "name": "amount" + } + ] + }, + { + "name": "Vector3Reflect", + "description": "", + "returnType": "Vector3", + "params": [ + { + "type": "Vector3", + "name": "v" + }, + { + "type": "Vector3", + "name": "normal" + } + ] + }, + { + "name": "Vector3Min", + "description": "", + "returnType": "Vector3", + "params": [ + { + "type": "Vector3", + "name": "v1" + }, + { + "type": "Vector3", + "name": "v2" + } + ] + }, + { + "name": "Vector3Max", + "description": "", + "returnType": "Vector3", + "params": [ + { + "type": "Vector3", + "name": "v1" + }, + { + "type": "Vector3", + "name": "v2" + } + ] + }, + { + "name": "Vector3Barycenter", + "description": "", + "returnType": "Vector3", + "params": [ + { + "type": "Vector3", + "name": "p" + }, + { + "type": "Vector3", + "name": "a" + }, + { + "type": "Vector3", + "name": "b" + }, + { + "type": "Vector3", + "name": "c" + } + ] + }, + { + "name": "Vector3Unproject", + "description": "", + "returnType": "Vector3", + "params": [ + { + "type": "Vector3", + "name": "source" + }, + { + "type": "Matrix", + "name": "projection" + }, + { + "type": "Matrix", + "name": "view" + } + ] + }, + { + "name": "Vector3ToFloatV", + "description": "", + "returnType": "float3", + "params": [ + { + "type": "Vector3", + "name": "v" + } + ] + }, + { + "name": "Vector3Invert", + "description": "", + "returnType": "Vector3", + "params": [ + { + "type": "Vector3", + "name": "v" + } + ] + }, + { + "name": "Vector3Clamp", + "description": "", + "returnType": "Vector3", + "params": [ + { + "type": "Vector3", + "name": "v" + }, + { + "type": "Vector3", + "name": "min" + }, + { + "type": "Vector3", + "name": "max" + } + ] + }, + { + "name": "Vector3ClampValue", + "description": "", + "returnType": "Vector3", + "params": [ + { + "type": "Vector3", + "name": "v" + }, + { + "type": "float", + "name": "min" + }, + { + "type": "float", + "name": "max" + } + ] + }, + { + "name": "Vector3Equals", + "description": "", + "returnType": "int", + "params": [ + { + "type": "Vector3", + "name": "p" + }, + { + "type": "Vector3", + "name": "q" + } + ] + }, + { + "name": "Vector3Refract", + "description": "", + "returnType": "Vector3", + "params": [ + { + "type": "Vector3", + "name": "v" + }, + { + "type": "Vector3", + "name": "n" + }, + { + "type": "float", + "name": "r" + } + ] + }, + { + "name": "MatrixDeterminant", + "description": "", + "returnType": "float", + "params": [ + { + "type": "Matrix", + "name": "mat" + } + ] + }, + { + "name": "MatrixTrace", + "description": "", + "returnType": "float", + "params": [ + { + "type": "Matrix", + "name": "mat" + } + ] + }, + { + "name": "MatrixTranspose", + "description": "", + "returnType": "Matrix", + "params": [ + { + "type": "Matrix", + "name": "mat" + } + ] + }, + { + "name": "MatrixInvert", + "description": "", + "returnType": "Matrix", + "params": [ + { + "type": "Matrix", + "name": "mat" + } + ] + }, + { + "name": "MatrixIdentity", + "description": "", + "returnType": "Matrix" + }, + { + "name": "MatrixAdd", + "description": "", + "returnType": "Matrix", + "params": [ + { + "type": "Matrix", + "name": "left" + }, + { + "type": "Matrix", + "name": "right" + } + ] + }, + { + "name": "MatrixSubtract", + "description": "", + "returnType": "Matrix", + "params": [ + { + "type": "Matrix", + "name": "left" + }, + { + "type": "Matrix", + "name": "right" + } + ] + }, + { + "name": "MatrixMultiply", + "description": "", + "returnType": "Matrix", + "params": [ + { + "type": "Matrix", + "name": "left" + }, + { + "type": "Matrix", + "name": "right" + } + ] + }, + { + "name": "MatrixTranslate", + "description": "", + "returnType": "Matrix", + "params": [ + { + "type": "float", + "name": "x" + }, + { + "type": "float", + "name": "y" + }, + { + "type": "float", + "name": "z" + } + ] + }, + { + "name": "MatrixRotate", + "description": "", + "returnType": "Matrix", + "params": [ + { + "type": "Vector3", + "name": "axis" + }, + { + "type": "float", + "name": "angle" + } + ] + }, + { + "name": "MatrixRotateX", + "description": "", + "returnType": "Matrix", + "params": [ + { + "type": "float", + "name": "angle" + } + ] + }, + { + "name": "MatrixRotateY", + "description": "", + "returnType": "Matrix", + "params": [ + { + "type": "float", + "name": "angle" + } + ] + }, + { + "name": "MatrixRotateZ", + "description": "", + "returnType": "Matrix", + "params": [ + { + "type": "float", + "name": "angle" + } + ] + }, + { + "name": "MatrixRotateXYZ", + "description": "", + "returnType": "Matrix", + "params": [ + { + "type": "Vector3", + "name": "angle" + } + ] + }, + { + "name": "MatrixRotateZYX", + "description": "", + "returnType": "Matrix", + "params": [ + { + "type": "Vector3", + "name": "angle" + } + ] + }, + { + "name": "MatrixScale", + "description": "", + "returnType": "Matrix", + "params": [ + { + "type": "float", + "name": "x" + }, + { + "type": "float", + "name": "y" + }, + { + "type": "float", + "name": "z" + } + ] + }, + { + "name": "MatrixFrustum", + "description": "", + "returnType": "Matrix", + "params": [ + { + "type": "double", + "name": "left" + }, + { + "type": "double", + "name": "right" + }, + { + "type": "double", + "name": "bottom" + }, + { + "type": "double", + "name": "top" + }, + { + "type": "double", + "name": "near" + }, + { + "type": "double", + "name": "far" + } + ] + }, + { + "name": "MatrixPerspective", + "description": "", + "returnType": "Matrix", + "params": [ + { + "type": "double", + "name": "fovY" + }, + { + "type": "double", + "name": "aspect" + }, + { + "type": "double", + "name": "nearPlane" + }, + { + "type": "double", + "name": "farPlane" + } + ] + }, + { + "name": "MatrixOrtho", + "description": "", + "returnType": "Matrix", + "params": [ + { + "type": "double", + "name": "left" + }, + { + "type": "double", + "name": "right" + }, + { + "type": "double", + "name": "bottom" + }, + { + "type": "double", + "name": "top" + }, + { + "type": "double", + "name": "nearPlane" + }, + { + "type": "double", + "name": "farPlane" + } + ] + }, + { + "name": "MatrixLookAt", + "description": "", + "returnType": "Matrix", + "params": [ + { + "type": "Vector3", + "name": "eye" + }, + { + "type": "Vector3", + "name": "target" + }, + { + "type": "Vector3", + "name": "up" + } + ] + }, + { + "name": "MatrixToFloatV", + "description": "", + "returnType": "float16", + "params": [ + { + "type": "Matrix", + "name": "mat" + } + ] + }, + { + "name": "QuaternionAdd", + "description": "", + "returnType": "Quaternion", + "params": [ + { + "type": "Quaternion", + "name": "q1" + }, + { + "type": "Quaternion", + "name": "q2" + } + ] + }, + { + "name": "QuaternionAddValue", + "description": "", + "returnType": "Quaternion", + "params": [ + { + "type": "Quaternion", + "name": "q" + }, + { + "type": "float", + "name": "add" + } + ] + }, + { + "name": "QuaternionSubtract", + "description": "", + "returnType": "Quaternion", + "params": [ + { + "type": "Quaternion", + "name": "q1" + }, + { + "type": "Quaternion", + "name": "q2" + } + ] + }, + { + "name": "QuaternionSubtractValue", + "description": "", + "returnType": "Quaternion", + "params": [ + { + "type": "Quaternion", + "name": "q" + }, + { + "type": "float", + "name": "sub" + } + ] + }, + { + "name": "QuaternionIdentity", + "description": "", + "returnType": "Quaternion" + }, + { + "name": "QuaternionLength", + "description": "", + "returnType": "float", + "params": [ + { + "type": "Quaternion", + "name": "q" + } + ] + }, + { + "name": "QuaternionNormalize", + "description": "", + "returnType": "Quaternion", + "params": [ + { + "type": "Quaternion", + "name": "q" + } + ] + }, + { + "name": "QuaternionInvert", + "description": "", + "returnType": "Quaternion", + "params": [ + { + "type": "Quaternion", + "name": "q" + } + ] + }, + { + "name": "QuaternionMultiply", + "description": "", + "returnType": "Quaternion", + "params": [ + { + "type": "Quaternion", + "name": "q1" + }, + { + "type": "Quaternion", + "name": "q2" + } + ] + }, + { + "name": "QuaternionScale", + "description": "", + "returnType": "Quaternion", + "params": [ + { + "type": "Quaternion", + "name": "q" + }, + { + "type": "float", + "name": "mul" + } + ] + }, + { + "name": "QuaternionDivide", + "description": "", + "returnType": "Quaternion", + "params": [ + { + "type": "Quaternion", + "name": "q1" + }, + { + "type": "Quaternion", + "name": "q2" + } + ] + }, + { + "name": "QuaternionLerp", + "description": "", + "returnType": "Quaternion", + "params": [ + { + "type": "Quaternion", + "name": "q1" + }, + { + "type": "Quaternion", + "name": "q2" + }, + { + "type": "float", + "name": "amount" + } + ] + }, + { + "name": "QuaternionNlerp", + "description": "", + "returnType": "Quaternion", + "params": [ + { + "type": "Quaternion", + "name": "q1" + }, + { + "type": "Quaternion", + "name": "q2" + }, + { + "type": "float", + "name": "amount" + } + ] + }, + { + "name": "QuaternionSlerp", + "description": "", + "returnType": "Quaternion", + "params": [ + { + "type": "Quaternion", + "name": "q1" + }, + { + "type": "Quaternion", + "name": "q2" + }, + { + "type": "float", + "name": "amount" + } + ] + }, + { + "name": "QuaternionFromVector3ToVector3", + "description": "", + "returnType": "Quaternion", + "params": [ + { + "type": "Vector3", + "name": "from" + }, + { + "type": "Vector3", + "name": "to" + } + ] + }, + { + "name": "QuaternionFromMatrix", + "description": "", + "returnType": "Quaternion", + "params": [ + { + "type": "Matrix", + "name": "mat" + } + ] + }, + { + "name": "QuaternionToMatrix", + "description": "", + "returnType": "Matrix", + "params": [ + { + "type": "Quaternion", + "name": "q" + } + ] + }, + { + "name": "QuaternionFromAxisAngle", + "description": "", + "returnType": "Quaternion", + "params": [ + { + "type": "Vector3", + "name": "axis" + }, + { + "type": "float", + "name": "angle" + } + ] + }, + { + "name": "QuaternionToAxisAngle", + "description": "", + "returnType": "void", + "params": [ + { + "type": "Quaternion", + "name": "q" + }, + { + "type": "Vector3 *", + "name": "outAxis" + }, + { + "type": "float *", + "name": "outAngle" + } + ] + }, + { + "name": "QuaternionFromEuler", + "description": "", + "returnType": "Quaternion", + "params": [ + { + "type": "float", + "name": "pitch" + }, + { + "type": "float", + "name": "yaw" + }, + { + "type": "float", + "name": "roll" + } + ] + }, + { + "name": "QuaternionToEuler", + "description": "", + "returnType": "Vector3", + "params": [ + { + "type": "Quaternion", + "name": "q" + } + ] + }, + { + "name": "QuaternionTransform", + "description": "", + "returnType": "Quaternion", + "params": [ + { + "type": "Quaternion", + "name": "q" + }, + { + "type": "Matrix", + "name": "mat" + } + ] + }, + { + "name": "QuaternionEquals", + "description": "", + "returnType": "int", + "params": [ + { + "type": "Quaternion", + "name": "p" + }, + { + "type": "Quaternion", + "name": "q" + } + ] + } + ] +} diff --git a/api/rcamera_api.json b/api/rcamera_api.json new file mode 100755 index 0000000..eaf204a --- /dev/null +++ b/api/rcamera_api.json @@ -0,0 +1,498 @@ +{ + "defines": [ + { + "name": "RCAMERA_H", + "type": "GUARD", + "value": "", + "description": "" + }, + { + "name": "__declspec(x)", + "type": "MACRO", + "value": "__attribute__((x))", + "description": "" + }, + { + "name": "RLAPI", + "type": "UNKNOWN", + "value": "__declspec(dllexport)", + "description": "We are building the library as a Win32 shared library (.dll)" + }, + { + "name": "CAMERA_CULL_DISTANCE_NEAR", + "type": "DOUBLE", + "value": 0.01, + "description": "" + }, + { + "name": "CAMERA_CULL_DISTANCE_FAR", + "type": "DOUBLE", + "value": 1000.0, + "description": "" + }, + { + "name": "CAMERA_MOVE_SPEED", + "type": "FLOAT", + "value": 0.09, + "description": "" + }, + { + "name": "CAMERA_ROTATION_SPEED", + "type": "FLOAT", + "value": 0.03, + "description": "" + }, + { + "name": "CAMERA_PAN_SPEED", + "type": "FLOAT", + "value": 0.2, + "description": "" + }, + { + "name": "CAMERA_MOUSE_MOVE_SENSITIVITY", + "type": "FLOAT", + "value": 0.003, + "description": "TODO: it should be independant of framerate" + }, + { + "name": "CAMERA_MOUSE_SCROLL_SENSITIVITY", + "type": "FLOAT", + "value": 1.5, + "description": "" + }, + { + "name": "CAMERA_ORBITAL_SPEED", + "type": "FLOAT", + "value": 0.5, + "description": "Radians per second" + }, + { + "name": "CAMERA_FIRST_PERSON_STEP_TRIGONOMETRIC_DIVIDER", + "type": "FLOAT", + "value": 8.0, + "description": "" + }, + { + "name": "CAMERA_FIRST_PERSON_STEP_DIVIDER", + "type": "FLOAT", + "value": 30.0, + "description": "" + }, + { + "name": "CAMERA_FIRST_PERSON_WAVING_DIVIDER", + "type": "FLOAT", + "value": 200.0, + "description": "" + }, + { + "name": "PLAYER_MOVEMENT_SENSITIVITY", + "type": "FLOAT", + "value": 20.0, + "description": "" + } + ], + "structs": [ + { + "name": "Vector2", + "description": "Vector2, 2 components", + "fields": [ + { + "type": "float", + "name": "x", + "description": "Vector x component" + }, + { + "type": "float", + "name": "y", + "description": "Vector y component" + } + ] + }, + { + "name": "Vector3", + "description": "Vector3, 3 components", + "fields": [ + { + "type": "float", + "name": "x", + "description": "Vector x component" + }, + { + "type": "float", + "name": "y", + "description": "Vector y component" + }, + { + "type": "float", + "name": "z", + "description": "Vector z component" + } + ] + }, + { + "name": "Matrix", + "description": "Matrix, 4x4 components, column major, OpenGL style, right-handed", + "fields": [ + { + "type": "float", + "name": "m0", + "description": "Matrix first row (4 components)" + }, + { + "type": "float", + "name": "m4", + "description": "Matrix first row (4 components)" + }, + { + "type": "float", + "name": "m8", + "description": "Matrix first row (4 components)" + }, + { + "type": "float", + "name": "m12", + "description": "Matrix first row (4 components)" + }, + { + "type": "float", + "name": "m1", + "description": "Matrix second row (4 components)" + }, + { + "type": "float", + "name": "m5", + "description": "Matrix second row (4 components)" + }, + { + "type": "float", + "name": "m9", + "description": "Matrix second row (4 components)" + }, + { + "type": "float", + "name": "m13", + "description": "Matrix second row (4 components)" + }, + { + "type": "float", + "name": "m2", + "description": "Matrix third row (4 components)" + }, + { + "type": "float", + "name": "m6", + "description": "Matrix third row (4 components)" + }, + { + "type": "float", + "name": "m10", + "description": "Matrix third row (4 components)" + }, + { + "type": "float", + "name": "m14", + "description": "Matrix third row (4 components)" + }, + { + "type": "float", + "name": "m3", + "description": "Matrix fourth row (4 components)" + }, + { + "type": "float", + "name": "m7", + "description": "Matrix fourth row (4 components)" + }, + { + "type": "float", + "name": "m11", + "description": "Matrix fourth row (4 components)" + }, + { + "type": "float", + "name": "m15", + "description": "Matrix fourth row (4 components)" + } + ] + }, + { + "name": "Camera3D", + "description": "Camera type, defines a camera position/orientation in 3d space", + "fields": [ + { + "type": "Vector3", + "name": "position", + "description": "Camera position" + }, + { + "type": "Vector3", + "name": "target", + "description": "Camera target it looks-at" + }, + { + "type": "Vector3", + "name": "up", + "description": "Camera up vector (rotation over its axis)" + }, + { + "type": "float", + "name": "fovy", + "description": "Camera field-of-view apperture in Y (degrees) in perspective, used as near plane width in orthographic" + }, + { + "type": "int", + "name": "projection", + "description": "Camera projection type: CAMERA_PERSPECTIVE or CAMERA_ORTHOGRAPHIC" + } + ] + } + ], + "aliases": [ + { + "type": "Camera3D", + "name": "Camera", + "description": "Camera type fallback, defaults to Camera3D" + } + ], + "enums": [ + { + "name": "CameraProjection", + "description": "Camera projection", + "values": [ + { + "name": "CAMERA_PERSPECTIVE", + "value": 0, + "description": "Perspective projection" + }, + { + "name": "CAMERA_ORTHOGRAPHIC", + "value": 1, + "description": "Orthographic projection" + } + ] + }, + { + "name": "CameraMode", + "description": "Camera system modes", + "values": [ + { + "name": "CAMERA_CUSTOM", + "value": 0, + "description": "Camera custom, controlled by user (UpdateCamera() does nothing)" + }, + { + "name": "CAMERA_FREE", + "value": 1, + "description": "Camera free mode" + }, + { + "name": "CAMERA_ORBITAL", + "value": 2, + "description": "Camera orbital, around target, zoom supported" + }, + { + "name": "CAMERA_FIRST_PERSON", + "value": 3, + "description": "Camera first person" + }, + { + "name": "CAMERA_THIRD_PERSON", + "value": 4, + "description": "Camera third person" + } + ] + } + ], + "callbacks": [ + ], + "functions": [ + { + "name": "GetCameraForward", + "description": "", + "returnType": "Vector3", + "params": [ + { + "type": "Camera *", + "name": "camera" + } + ] + }, + { + "name": "GetCameraUp", + "description": "", + "returnType": "Vector3", + "params": [ + { + "type": "Camera *", + "name": "camera" + } + ] + }, + { + "name": "GetCameraRight", + "description": "", + "returnType": "Vector3", + "params": [ + { + "type": "Camera *", + "name": "camera" + } + ] + }, + { + "name": "CameraMoveForward", + "description": "", + "returnType": "void", + "params": [ + { + "type": "Camera *", + "name": "camera" + }, + { + "type": "float", + "name": "distance" + }, + { + "type": "bool", + "name": "moveInWorldPlane" + } + ] + }, + { + "name": "CameraMoveUp", + "description": "", + "returnType": "void", + "params": [ + { + "type": "Camera *", + "name": "camera" + }, + { + "type": "float", + "name": "distance" + } + ] + }, + { + "name": "CameraMoveRight", + "description": "", + "returnType": "void", + "params": [ + { + "type": "Camera *", + "name": "camera" + }, + { + "type": "float", + "name": "distance" + }, + { + "type": "bool", + "name": "moveInWorldPlane" + } + ] + }, + { + "name": "CameraMoveToTarget", + "description": "", + "returnType": "void", + "params": [ + { + "type": "Camera *", + "name": "camera" + }, + { + "type": "float", + "name": "delta" + } + ] + }, + { + "name": "CameraYaw", + "description": "", + "returnType": "void", + "params": [ + { + "type": "Camera *", + "name": "camera" + }, + { + "type": "float", + "name": "angle" + }, + { + "type": "bool", + "name": "rotateAroundTarget" + } + ] + }, + { + "name": "CameraPitch", + "description": "", + "returnType": "void", + "params": [ + { + "type": "Camera *", + "name": "camera" + }, + { + "type": "float", + "name": "angle" + }, + { + "type": "bool", + "name": "lockView" + }, + { + "type": "bool", + "name": "rotateAroundTarget" + }, + { + "type": "bool", + "name": "rotateUp" + } + ] + }, + { + "name": "CameraRoll", + "description": "", + "returnType": "void", + "params": [ + { + "type": "Camera *", + "name": "camera" + }, + { + "type": "float", + "name": "angle" + } + ] + }, + { + "name": "GetCameraViewMatrix", + "description": "", + "returnType": "Matrix", + "params": [ + { + "type": "Camera *", + "name": "camera" + } + ] + }, + { + "name": "GetCameraProjectionMatrix", + "description": "", + "returnType": "Matrix", + "params": [ + { + "type": "Camera*", + "name": "camera" + }, + { + "type": "float", + "name": "aspect" + } + ] + } + ] +} diff --git a/src/raylib_qjs.c b/src/raylib_qjs.c index fef3576..c0b0681 100644 --- a/src/raylib_qjs.c +++ b/src/raylib_qjs.c @@ -42,6 +42,8 @@ enum { JS_ATOM_END, }; +#include "raymath.h" + #include #define countof(x) (sizeof(x) / sizeof((x)[0])) @@ -7732,11 +7734,41 @@ static JSValue js_IsCursorOnScreen(JSContext *ctx, JSValueConst this_val, int ar static JSValue js_ClearBackground(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Color * argptr0 = (Color *)JS_GetOpaque2(ctx, argv[0], js_Color_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + Color arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[0], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg0.r = (unsigned char)r_int; - Color arg0 = *argptr0; + JSValue g = JS_GetPropertyUint32(ctx, argv[0], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg0.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[0], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg0.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[0], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg0.a = (unsigned char)a_int; + } + else { + Color * argptr0 = (Color *)JS_GetOpaque2(ctx, argv[0], js_Color_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + ClearBackground(arg0); @@ -8129,11 +8161,31 @@ static JSValue js_UnloadShader(JSContext *ctx, JSValueConst this_val, int argc, static JSValue js_GetMouseRay(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Vector2 arg0 = *argptr0; - Camera * argptr1 = (Camera *)JS_GetOpaque2(ctx, argv[1], js_Camera_class_id); + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + Camera * argptr1 = (Camera *)JS_GetOpaque2(ctx, argv[1], js_Camera_class_id); if (argptr1 == NULL) argptr1 = (Camera *)JS_GetOpaque2(ctx, argv[1], js_Camera3D_class_id); if (argptr1 == NULL) return JS_EXCEPTION; @@ -8194,11 +8246,36 @@ static JSValue js_GetCameraMatrix2D(JSContext *ctx, JSValueConst this_val, int a static JSValue js_GetWorldToScreen(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + Vector3 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Vector3 arg0 = *argptr0; - Camera * argptr1 = (Camera *)JS_GetOpaque2(ctx, argv[1], js_Camera_class_id); + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + Camera * argptr1 = (Camera *)JS_GetOpaque2(ctx, argv[1], js_Camera_class_id); if (argptr1 == NULL) argptr1 = (Camera *)JS_GetOpaque2(ctx, argv[1], js_Camera3D_class_id); if (argptr1 == NULL) return JS_EXCEPTION; @@ -8219,11 +8296,31 @@ static JSValue js_GetWorldToScreen(JSContext *ctx, JSValueConst this_val, int ar static JSValue js_GetScreenToWorld2D(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Vector2 arg0 = *argptr0; - Camera2D * argptr1 = (Camera2D *)JS_GetOpaque2(ctx, argv[1], js_Camera2D_class_id); + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + Camera2D * argptr1 = (Camera2D *)JS_GetOpaque2(ctx, argv[1], js_Camera2D_class_id); if (argptr1 == NULL) return JS_EXCEPTION; Camera2D arg1 = *argptr1; @@ -8242,11 +8339,36 @@ static JSValue js_GetScreenToWorld2D(JSContext *ctx, JSValueConst this_val, int static JSValue js_GetWorldToScreenEx(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + Vector3 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Vector3 arg0 = *argptr0; - Camera * argptr1 = (Camera *)JS_GetOpaque2(ctx, argv[1], js_Camera_class_id); + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + Camera * argptr1 = (Camera *)JS_GetOpaque2(ctx, argv[1], js_Camera_class_id); if (argptr1 == NULL) argptr1 = (Camera *)JS_GetOpaque2(ctx, argv[1], js_Camera3D_class_id); if (argptr1 == NULL) return JS_EXCEPTION; @@ -8271,11 +8393,31 @@ static JSValue js_GetWorldToScreenEx(JSContext *ctx, JSValueConst this_val, int static JSValue js_GetWorldToScreen2D(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Vector2 arg0 = *argptr0; - Camera2D * argptr1 = (Camera2D *)JS_GetOpaque2(ctx, argv[1], js_Camera2D_class_id); + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + Camera2D * argptr1 = (Camera2D *)JS_GetOpaque2(ctx, argv[1], js_Camera2D_class_id); if (argptr1 == NULL) return JS_EXCEPTION; Camera2D arg1 = *argptr1; @@ -8558,7 +8700,20 @@ const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); static JSValue js_UnloadFileText(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { -return JS_UNDEFINED; + JSValue arg0_js = JS_GetPropertyStr(ctx, argv[0], "text"); + size_t arg0_len; + const char * arg0_str = JS_ToCStringLen(ctx, &arg0_len, arg0_js); + char * arg0 = malloc(arg0_len+1); + memcpy((void *)arg0, arg0_str, arg0_len); + arg0[arg0_len] = 0; + + UnloadFileText(arg0); + + JS_FreeCString(ctx, arg0_str); + JS_SetPropertyStr(ctx, argv[0], "text", JS_NewString(ctx, arg0)); + free(arg0); + + return JS_UNDEFINED; } static JSValue js_SaveFileText(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) @@ -9527,15 +9682,65 @@ static JSValue js_UpdateCameraPro(JSContext *ctx, JSValueConst this_val, int arg Camera * arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera_class_id); if (arg0 == NULL) arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera3D_class_id); - Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; + + + Vector3 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; - Vector3 arg1 = *argptr1; - Vector3 * argptr2 = (Vector3 *)JS_GetOpaque2(ctx, argv[2], js_Vector3_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[1], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg1.z = (float)z_double; + } + else { + + Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } - Vector3 arg2 = *argptr2; - double arg3; + + Vector3 arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[2], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg2.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[2], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg2.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[2], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg2.z = (float)z_double; + } + else { + + Vector3 * argptr2 = (Vector3 *)JS_GetOpaque2(ctx, argv[2], js_Vector3_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + double arg3; JS_ToFloat64(ctx, &arg3, argv[3]); UpdateCameraPro(arg0, arg1, arg2, arg3); @@ -9552,11 +9757,41 @@ static JSValue js_SetShapesTexture(JSContext *ctx, JSValueConst this_val, int ar if (argptr0 == NULL) return JS_EXCEPTION; Texture2D arg0 = *argptr0; - Rectangle * argptr1 = (Rectangle *)JS_GetOpaque2(ctx, argv[1], js_Rectangle_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; + + + Rectangle arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; - Rectangle arg1 = *argptr1; + JSValue w = JS_GetPropertyUint32(ctx, argv[1], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg1.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[1], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg1.height = (float)h_double; + } + else { + + Rectangle * argptr1 = (Rectangle *)JS_GetOpaque2(ctx, argv[1], js_Rectangle_class_id); + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + SetShapesTexture(arg0, arg1); @@ -9569,11 +9804,41 @@ static JSValue js_DrawPixel(JSContext *ctx, JSValueConst this_val, int argc, JSV JS_ToInt32(ctx, &arg0, argv[0]); int arg1; JS_ToInt32(ctx, &arg1, argv[1]); - Color * argptr2 = (Color *)JS_GetOpaque2(ctx, argv[2], js_Color_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; + + + Color arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[2], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg2.r = (unsigned char)r_int; - Color arg2 = *argptr2; + JSValue g = JS_GetPropertyUint32(ctx, argv[2], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg2.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[2], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg2.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[2], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg2.a = (unsigned char)a_int; + } + else { + Color * argptr2 = (Color *)JS_GetOpaque2(ctx, argv[2], js_Color_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + DrawPixel(arg0, arg1, arg2); @@ -9582,15 +9847,65 @@ static JSValue js_DrawPixel(JSContext *ctx, JSValueConst this_val, int argc, JSV static JSValue js_DrawPixelV(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Vector2 arg0 = *argptr0; - Color * argptr1 = (Color *)JS_GetOpaque2(ctx, argv[1], js_Color_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } - Color arg1 = *argptr1; + Color arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[1], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg1.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[1], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg1.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[1], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg1.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[1], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg1.a = (unsigned char)a_int; + } + else { + + Color * argptr1 = (Color *)JS_GetOpaque2(ctx, argv[1], js_Color_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + DrawPixelV(arg0, arg1); @@ -9607,11 +9922,41 @@ static JSValue js_DrawLine(JSContext *ctx, JSValueConst this_val, int argc, JSVa JS_ToInt32(ctx, &arg2, argv[2]); int arg3; JS_ToInt32(ctx, &arg3, argv[3]); - Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); - if (argptr4 == NULL) return JS_EXCEPTION; + + + Color arg4; + + if (JS_IsArray(ctx, argv[4])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[4], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg4.r = (unsigned char)r_int; - Color arg4 = *argptr4; + JSValue g = JS_GetPropertyUint32(ctx, argv[4], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg4.g = (unsigned char)g_int; + JSValue b = JS_GetPropertyUint32(ctx, argv[4], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg4.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[4], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg4.a = (unsigned char)a_int; + } + else { + + Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); + + if (argptr4 == NULL) return JS_EXCEPTION; + + arg4 = *argptr4; + } + DrawLine(arg0, arg1, arg2, arg3, arg4); @@ -9620,19 +9965,89 @@ static JSValue js_DrawLine(JSContext *ctx, JSValueConst this_val, int argc, JSVa static JSValue js_DrawLineV(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Vector2 arg0 = *argptr0; - Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } - Vector2 arg1 = *argptr1; - Color * argptr2 = (Color *)JS_GetOpaque2(ctx, argv[2], js_Color_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; + + Vector2 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + } + else { + + Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + + Color arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[2], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg2.r = (unsigned char)r_int; - Color arg2 = *argptr2; + JSValue g = JS_GetPropertyUint32(ctx, argv[2], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg2.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[2], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg2.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[2], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg2.a = (unsigned char)a_int; + } + else { + + Color * argptr2 = (Color *)JS_GetOpaque2(ctx, argv[2], js_Color_class_id); + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + DrawLineV(arg0, arg1, arg2); @@ -9641,44 +10056,251 @@ static JSValue js_DrawLineV(JSContext *ctx, JSValueConst this_val, int argc, JSV static JSValue js_DrawLineEx(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Vector2 arg0 = *argptr0; - Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } - Vector2 arg1 = *argptr1; - double arg2; + + Vector2 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + } + else { + + Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + double arg2; JS_ToFloat64(ctx, &arg2, argv[2]); - Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); - if (argptr3 == NULL) return JS_EXCEPTION; + + + Color arg3; + + if (JS_IsArray(ctx, argv[3])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[3], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg3.r = (unsigned char)r_int; - Color arg3 = *argptr3; + JSValue g = JS_GetPropertyUint32(ctx, argv[3], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg3.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[3], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg3.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[3], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg3.a = (unsigned char)a_int; + } + else { + Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); + + if (argptr3 == NULL) return JS_EXCEPTION; + + arg3 = *argptr3; + } + DrawLineEx(arg0, arg1, arg2, arg3); return JS_UNDEFINED; } +static JSValue js_DrawLineStrip(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + JSValue arg0_length_js = JS_GetProperty(ctx, argv[0], JS_ATOM_length); + + int32_t arg0_length; + + JS_ToInt32(ctx, &arg0_length, arg0_length_js); + + Vector2 * arg0 = (Vector2 *)malloc(arg0_length*sizeof(Vector2)); + + for (int i=0; i < arg0_length; ++i) { + + JSValue val = JS_GetPropertyUint32(ctx, argv[0], i); + + Vector2 * obj = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + arg0[i] = *obj; + } + + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); + + + Color arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[2], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg2.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[2], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg2.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[2], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg2.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[2], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg2.a = (unsigned char)a_int; + } + else { + + Color * argptr2 = (Color *)JS_GetOpaque2(ctx, argv[2], js_Color_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + + DrawLineStrip(arg0, arg1, arg2); + + + if (arg0) + free(arg0); + + return JS_UNDEFINED; +} + static JSValue js_DrawLineBezier(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Vector2 arg0 = *argptr0; - Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } - Vector2 arg1 = *argptr1; - double arg2; + + Vector2 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + } + else { + + Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + double arg2; JS_ToFloat64(ctx, &arg2, argv[2]); - Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); - if (argptr3 == NULL) return JS_EXCEPTION; + + + Color arg3; + + if (JS_IsArray(ctx, argv[3])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[3], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg3.r = (unsigned char)r_int; - Color arg3 = *argptr3; + JSValue g = JS_GetPropertyUint32(ctx, argv[3], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg3.g = (unsigned char)g_int; + JSValue b = JS_GetPropertyUint32(ctx, argv[3], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg3.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[3], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg3.a = (unsigned char)a_int; + } + else { + + Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); + + if (argptr3 == NULL) return JS_EXCEPTION; + + arg3 = *argptr3; + } + DrawLineBezier(arg0, arg1, arg2, arg3); @@ -9693,11 +10315,41 @@ static JSValue js_DrawCircle(JSContext *ctx, JSValueConst this_val, int argc, JS JS_ToInt32(ctx, &arg1, argv[1]); double arg2; JS_ToFloat64(ctx, &arg2, argv[2]); - Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); - if (argptr3 == NULL) return JS_EXCEPTION; + + + Color arg3; + + if (JS_IsArray(ctx, argv[3])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[3], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg3.r = (unsigned char)r_int; - Color arg3 = *argptr3; + JSValue g = JS_GetPropertyUint32(ctx, argv[3], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg3.g = (unsigned char)g_int; + JSValue b = JS_GetPropertyUint32(ctx, argv[3], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg3.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[3], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg3.a = (unsigned char)a_int; + } + else { + + Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); + + if (argptr3 == NULL) return JS_EXCEPTION; + + arg3 = *argptr3; + } + DrawCircle(arg0, arg1, arg2, arg3); @@ -9706,11 +10358,31 @@ static JSValue js_DrawCircle(JSContext *ctx, JSValueConst this_val, int argc, JS static JSValue js_DrawCircleSector(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Vector2 arg0 = *argptr0; - double arg1; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + double arg1; JS_ToFloat64(ctx, &arg1, argv[1]); double arg2; JS_ToFloat64(ctx, &arg2, argv[2]); @@ -9718,24 +10390,74 @@ static JSValue js_DrawCircleSector(JSContext *ctx, JSValueConst this_val, int ar JS_ToFloat64(ctx, &arg3, argv[3]); int arg4; JS_ToInt32(ctx, &arg4, argv[4]); - Color * argptr5 = (Color *)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); - if (argptr5 == NULL) return JS_EXCEPTION; + + + Color arg5; + + if (JS_IsArray(ctx, argv[5])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[5], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg5.r = (unsigned char)r_int; - Color arg5 = *argptr5; + JSValue g = JS_GetPropertyUint32(ctx, argv[5], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg5.g = (unsigned char)g_int; - DrawCircleSector(arg0, arg1, arg2, arg3, arg4, arg5); + JSValue b = JS_GetPropertyUint32(ctx, argv[5], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg5.b = (unsigned char)b_int; + JSValue a = JS_GetPropertyUint32(ctx, argv[5], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg5.a = (unsigned char)a_int; + } + else { - return JS_UNDEFINED; -} + Color * argptr5 = (Color *)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); + + if (argptr5 == NULL) return JS_EXCEPTION; + + arg5 = *argptr5; + } + + DrawCircleSector(arg0, arg1, arg2, arg3, arg4, arg5); + + + return JS_UNDEFINED; +} static JSValue js_DrawCircleSectorLines(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Vector2 arg0 = *argptr0; - double arg1; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + double arg1; JS_ToFloat64(ctx, &arg1, argv[1]); double arg2; JS_ToFloat64(ctx, &arg2, argv[2]); @@ -9743,11 +10465,41 @@ static JSValue js_DrawCircleSectorLines(JSContext *ctx, JSValueConst this_val, i JS_ToFloat64(ctx, &arg3, argv[3]); int arg4; JS_ToInt32(ctx, &arg4, argv[4]); - Color * argptr5 = (Color *)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); - if (argptr5 == NULL) return JS_EXCEPTION; + + + Color arg5; + + if (JS_IsArray(ctx, argv[5])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[5], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg5.r = (unsigned char)r_int; - Color arg5 = *argptr5; + JSValue g = JS_GetPropertyUint32(ctx, argv[5], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg5.g = (unsigned char)g_int; + JSValue b = JS_GetPropertyUint32(ctx, argv[5], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg5.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[5], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg5.a = (unsigned char)a_int; + } + else { + + Color * argptr5 = (Color *)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); + + if (argptr5 == NULL) return JS_EXCEPTION; + + arg5 = *argptr5; + } + DrawCircleSectorLines(arg0, arg1, arg2, arg3, arg4, arg5); @@ -9762,15 +10514,75 @@ static JSValue js_DrawCircleGradient(JSContext *ctx, JSValueConst this_val, int JS_ToInt32(ctx, &arg1, argv[1]); double arg2; JS_ToFloat64(ctx, &arg2, argv[2]); - Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); - if (argptr3 == NULL) return JS_EXCEPTION; + + + Color arg3; + + if (JS_IsArray(ctx, argv[3])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[3], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg3.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[3], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg3.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[3], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg3.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[3], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg3.a = (unsigned char)a_int; + } + else { + + Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); + + if (argptr3 == NULL) return JS_EXCEPTION; + + arg3 = *argptr3; + } - Color arg3 = *argptr3; - Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); - if (argptr4 == NULL) return JS_EXCEPTION; + + Color arg4; + + if (JS_IsArray(ctx, argv[4])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[4], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg4.r = (unsigned char)r_int; - Color arg4 = *argptr4; + JSValue g = JS_GetPropertyUint32(ctx, argv[4], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg4.g = (unsigned char)g_int; + JSValue b = JS_GetPropertyUint32(ctx, argv[4], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg4.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[4], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg4.a = (unsigned char)a_int; + } + else { + + Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); + + if (argptr4 == NULL) return JS_EXCEPTION; + + arg4 = *argptr4; + } + DrawCircleGradient(arg0, arg1, arg2, arg3, arg4); @@ -9779,17 +10591,67 @@ static JSValue js_DrawCircleGradient(JSContext *ctx, JSValueConst this_val, int static JSValue js_DrawCircleV(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Vector2 arg0 = *argptr0; - double arg1; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + double arg1; JS_ToFloat64(ctx, &arg1, argv[1]); - Color * argptr2 = (Color *)JS_GetOpaque2(ctx, argv[2], js_Color_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; + + + Color arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[2], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg2.r = (unsigned char)r_int; - Color arg2 = *argptr2; + JSValue g = JS_GetPropertyUint32(ctx, argv[2], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg2.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[2], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg2.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[2], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg2.a = (unsigned char)a_int; + } + else { + Color * argptr2 = (Color *)JS_GetOpaque2(ctx, argv[2], js_Color_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + DrawCircleV(arg0, arg1, arg2); @@ -9804,11 +10666,41 @@ static JSValue js_DrawCircleLines(JSContext *ctx, JSValueConst this_val, int arg JS_ToInt32(ctx, &arg1, argv[1]); double arg2; JS_ToFloat64(ctx, &arg2, argv[2]); - Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); - if (argptr3 == NULL) return JS_EXCEPTION; + + + Color arg3; + + if (JS_IsArray(ctx, argv[3])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[3], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg3.r = (unsigned char)r_int; - Color arg3 = *argptr3; + JSValue g = JS_GetPropertyUint32(ctx, argv[3], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg3.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[3], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg3.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[3], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg3.a = (unsigned char)a_int; + } + else { + Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); + + if (argptr3 == NULL) return JS_EXCEPTION; + + arg3 = *argptr3; + } + DrawCircleLines(arg0, arg1, arg2, arg3); @@ -9817,17 +10709,67 @@ static JSValue js_DrawCircleLines(JSContext *ctx, JSValueConst this_val, int arg static JSValue js_DrawCircleLinesV(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Vector2 arg0 = *argptr0; - double arg1; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + double arg1; JS_ToFloat64(ctx, &arg1, argv[1]); - Color * argptr2 = (Color *)JS_GetOpaque2(ctx, argv[2], js_Color_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; + + + Color arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[2], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg2.r = (unsigned char)r_int; - Color arg2 = *argptr2; + JSValue g = JS_GetPropertyUint32(ctx, argv[2], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg2.g = (unsigned char)g_int; + JSValue b = JS_GetPropertyUint32(ctx, argv[2], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg2.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[2], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg2.a = (unsigned char)a_int; + } + else { + + Color * argptr2 = (Color *)JS_GetOpaque2(ctx, argv[2], js_Color_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + DrawCircleLinesV(arg0, arg1, arg2); @@ -9844,11 +10786,41 @@ static JSValue js_DrawEllipse(JSContext *ctx, JSValueConst this_val, int argc, J JS_ToFloat64(ctx, &arg2, argv[2]); double arg3; JS_ToFloat64(ctx, &arg3, argv[3]); - Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); - if (argptr4 == NULL) return JS_EXCEPTION; + + + Color arg4; + + if (JS_IsArray(ctx, argv[4])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[4], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg4.r = (unsigned char)r_int; - Color arg4 = *argptr4; + JSValue g = JS_GetPropertyUint32(ctx, argv[4], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg4.g = (unsigned char)g_int; + JSValue b = JS_GetPropertyUint32(ctx, argv[4], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg4.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[4], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg4.a = (unsigned char)a_int; + } + else { + + Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); + + if (argptr4 == NULL) return JS_EXCEPTION; + + arg4 = *argptr4; + } + DrawEllipse(arg0, arg1, arg2, arg3, arg4); @@ -9865,11 +10837,41 @@ static JSValue js_DrawEllipseLines(JSContext *ctx, JSValueConst this_val, int ar JS_ToFloat64(ctx, &arg2, argv[2]); double arg3; JS_ToFloat64(ctx, &arg3, argv[3]); - Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); - if (argptr4 == NULL) return JS_EXCEPTION; + + + Color arg4; + + if (JS_IsArray(ctx, argv[4])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[4], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg4.r = (unsigned char)r_int; - Color arg4 = *argptr4; + JSValue g = JS_GetPropertyUint32(ctx, argv[4], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg4.g = (unsigned char)g_int; + JSValue b = JS_GetPropertyUint32(ctx, argv[4], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg4.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[4], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg4.a = (unsigned char)a_int; + } + else { + + Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); + + if (argptr4 == NULL) return JS_EXCEPTION; + + arg4 = *argptr4; + } + DrawEllipseLines(arg0, arg1, arg2, arg3, arg4); @@ -9878,11 +10880,31 @@ static JSValue js_DrawEllipseLines(JSContext *ctx, JSValueConst this_val, int ar static JSValue js_DrawRing(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Vector2 arg0 = *argptr0; - double arg1; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + double arg1; JS_ToFloat64(ctx, &arg1, argv[1]); double arg2; JS_ToFloat64(ctx, &arg2, argv[2]); @@ -9892,11 +10914,41 @@ static JSValue js_DrawRing(JSContext *ctx, JSValueConst this_val, int argc, JSVa JS_ToFloat64(ctx, &arg4, argv[4]); int arg5; JS_ToInt32(ctx, &arg5, argv[5]); - Color * argptr6 = (Color *)JS_GetOpaque2(ctx, argv[6], js_Color_class_id); - if (argptr6 == NULL) return JS_EXCEPTION; + + + Color arg6; + + if (JS_IsArray(ctx, argv[6])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[6], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg6.r = (unsigned char)r_int; - Color arg6 = *argptr6; + JSValue g = JS_GetPropertyUint32(ctx, argv[6], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg6.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[6], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg6.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[6], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg6.a = (unsigned char)a_int; + } + else { + + Color * argptr6 = (Color *)JS_GetOpaque2(ctx, argv[6], js_Color_class_id); + if (argptr6 == NULL) return JS_EXCEPTION; + + arg6 = *argptr6; + } + DrawRing(arg0, arg1, arg2, arg3, arg4, arg5, arg6); @@ -9905,11 +10957,31 @@ static JSValue js_DrawRing(JSContext *ctx, JSValueConst this_val, int argc, JSVa static JSValue js_DrawRingLines(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Vector2 arg0 = *argptr0; - double arg1; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + double arg1; JS_ToFloat64(ctx, &arg1, argv[1]); double arg2; JS_ToFloat64(ctx, &arg2, argv[2]); @@ -9919,11 +10991,41 @@ static JSValue js_DrawRingLines(JSContext *ctx, JSValueConst this_val, int argc, JS_ToFloat64(ctx, &arg4, argv[4]); int arg5; JS_ToInt32(ctx, &arg5, argv[5]); - Color * argptr6 = (Color *)JS_GetOpaque2(ctx, argv[6], js_Color_class_id); - if (argptr6 == NULL) return JS_EXCEPTION; + + + Color arg6; + + if (JS_IsArray(ctx, argv[6])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[6], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg6.r = (unsigned char)r_int; - Color arg6 = *argptr6; + JSValue g = JS_GetPropertyUint32(ctx, argv[6], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg6.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[6], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg6.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[6], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg6.a = (unsigned char)a_int; + } + else { + Color * argptr6 = (Color *)JS_GetOpaque2(ctx, argv[6], js_Color_class_id); + + if (argptr6 == NULL) return JS_EXCEPTION; + + arg6 = *argptr6; + } + DrawRingLines(arg0, arg1, arg2, arg3, arg4, arg5, arg6); @@ -9940,11 +11042,41 @@ static JSValue js_DrawRectangle(JSContext *ctx, JSValueConst this_val, int argc, JS_ToInt32(ctx, &arg2, argv[2]); int arg3; JS_ToInt32(ctx, &arg3, argv[3]); - Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); - if (argptr4 == NULL) return JS_EXCEPTION; + + + Color arg4; + + if (JS_IsArray(ctx, argv[4])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[4], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg4.r = (unsigned char)r_int; - Color arg4 = *argptr4; + JSValue g = JS_GetPropertyUint32(ctx, argv[4], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg4.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[4], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg4.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[4], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg4.a = (unsigned char)a_int; + } + else { + Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); + + if (argptr4 == NULL) return JS_EXCEPTION; + + arg4 = *argptr4; + } + DrawRectangle(arg0, arg1, arg2, arg3, arg4); @@ -9953,19 +11085,89 @@ static JSValue js_DrawRectangle(JSContext *ctx, JSValueConst this_val, int argc, static JSValue js_DrawRectangleV(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Vector2 arg0 = *argptr0; - Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } - Vector2 arg1 = *argptr1; - Color * argptr2 = (Color *)JS_GetOpaque2(ctx, argv[2], js_Color_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; + + Vector2 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + } + else { + + Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + + Color arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[2], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg2.r = (unsigned char)r_int; - Color arg2 = *argptr2; + JSValue g = JS_GetPropertyUint32(ctx, argv[2], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg2.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[2], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg2.b = (unsigned char)b_int; + JSValue a = JS_GetPropertyUint32(ctx, argv[2], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg2.a = (unsigned char)a_int; + } + else { + + Color * argptr2 = (Color *)JS_GetOpaque2(ctx, argv[2], js_Color_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + DrawRectangleV(arg0, arg1, arg2); @@ -9974,15 +11176,75 @@ static JSValue js_DrawRectangleV(JSContext *ctx, JSValueConst this_val, int argc static JSValue js_DrawRectangleRec(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + Rectangle arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Rectangle arg0 = *argptr0; - Color * argptr1 = (Color *)JS_GetOpaque2(ctx, argv[1], js_Color_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; - Color arg1 = *argptr1; + JSValue w = JS_GetPropertyUint32(ctx, argv[0], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg0.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[0], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg0.height = (float)h_double; + } + else { + + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + + Color arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[1], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg1.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[1], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg1.g = (unsigned char)g_int; + JSValue b = JS_GetPropertyUint32(ctx, argv[1], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg1.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[1], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg1.a = (unsigned char)a_int; + } + else { + + Color * argptr1 = (Color *)JS_GetOpaque2(ctx, argv[1], js_Color_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + DrawRectangleRec(arg0, arg1); @@ -9991,21 +11253,101 @@ static JSValue js_DrawRectangleRec(JSContext *ctx, JSValueConst this_val, int ar static JSValue js_DrawRectanglePro(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + Rectangle arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Rectangle arg0 = *argptr0; - Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; - Vector2 arg1 = *argptr1; - double arg2; + JSValue w = JS_GetPropertyUint32(ctx, argv[0], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg0.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[0], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg0.height = (float)h_double; + } + else { + + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + + Vector2 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + } + else { + + Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + double arg2; JS_ToFloat64(ctx, &arg2, argv[2]); - Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); - if (argptr3 == NULL) return JS_EXCEPTION; + + + Color arg3; + + if (JS_IsArray(ctx, argv[3])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[3], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg3.r = (unsigned char)r_int; - Color arg3 = *argptr3; + JSValue g = JS_GetPropertyUint32(ctx, argv[3], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg3.g = (unsigned char)g_int; + JSValue b = JS_GetPropertyUint32(ctx, argv[3], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg3.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[3], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg3.a = (unsigned char)a_int; + } + else { + + Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); + + if (argptr3 == NULL) return JS_EXCEPTION; + + arg3 = *argptr3; + } + DrawRectanglePro(arg0, arg1, arg2, arg3); @@ -10022,15 +11364,75 @@ static JSValue js_DrawRectangleGradientV(JSContext *ctx, JSValueConst this_val, JS_ToInt32(ctx, &arg2, argv[2]); int arg3; JS_ToInt32(ctx, &arg3, argv[3]); - Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); - if (argptr4 == NULL) return JS_EXCEPTION; + + + Color arg4; + + if (JS_IsArray(ctx, argv[4])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[4], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg4.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[4], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg4.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[4], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg4.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[4], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg4.a = (unsigned char)a_int; + } + else { + + Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); + + if (argptr4 == NULL) return JS_EXCEPTION; + + arg4 = *argptr4; + } - Color arg4 = *argptr4; - Color * argptr5 = (Color *)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); - if (argptr5 == NULL) return JS_EXCEPTION; + + Color arg5; + + if (JS_IsArray(ctx, argv[5])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[5], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg5.r = (unsigned char)r_int; - Color arg5 = *argptr5; + JSValue g = JS_GetPropertyUint32(ctx, argv[5], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg5.g = (unsigned char)g_int; + JSValue b = JS_GetPropertyUint32(ctx, argv[5], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg5.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[5], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg5.a = (unsigned char)a_int; + } + else { + + Color * argptr5 = (Color *)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); + + if (argptr5 == NULL) return JS_EXCEPTION; + + arg5 = *argptr5; + } + DrawRectangleGradientV(arg0, arg1, arg2, arg3, arg4, arg5); @@ -10047,15 +11449,75 @@ static JSValue js_DrawRectangleGradientH(JSContext *ctx, JSValueConst this_val, JS_ToInt32(ctx, &arg2, argv[2]); int arg3; JS_ToInt32(ctx, &arg3, argv[3]); - Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); - if (argptr4 == NULL) return JS_EXCEPTION; + + + Color arg4; + + if (JS_IsArray(ctx, argv[4])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[4], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg4.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[4], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg4.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[4], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg4.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[4], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg4.a = (unsigned char)a_int; + } + else { + + Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); + + if (argptr4 == NULL) return JS_EXCEPTION; + + arg4 = *argptr4; + } - Color arg4 = *argptr4; - Color * argptr5 = (Color *)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); - if (argptr5 == NULL) return JS_EXCEPTION; + + Color arg5; + + if (JS_IsArray(ctx, argv[5])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[5], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg5.r = (unsigned char)r_int; - Color arg5 = *argptr5; + JSValue g = JS_GetPropertyUint32(ctx, argv[5], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg5.g = (unsigned char)g_int; + JSValue b = JS_GetPropertyUint32(ctx, argv[5], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg5.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[5], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg5.a = (unsigned char)a_int; + } + else { + + Color * argptr5 = (Color *)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); + + if (argptr5 == NULL) return JS_EXCEPTION; + + arg5 = *argptr5; + } + DrawRectangleGradientH(arg0, arg1, arg2, arg3, arg4, arg5); @@ -10064,27 +11526,177 @@ static JSValue js_DrawRectangleGradientH(JSContext *ctx, JSValueConst this_val, static JSValue js_DrawRectangleGradientEx(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + Rectangle arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Rectangle arg0 = *argptr0; - Color * argptr1 = (Color *)JS_GetOpaque2(ctx, argv[1], js_Color_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; - Color arg1 = *argptr1; - Color * argptr2 = (Color *)JS_GetOpaque2(ctx, argv[2], js_Color_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; + JSValue w = JS_GetPropertyUint32(ctx, argv[0], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg0.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[0], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg0.height = (float)h_double; + } + else { + + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + + Color arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[1], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg1.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[1], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg1.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[1], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg1.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[1], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg1.a = (unsigned char)a_int; + } + else { + + Color * argptr1 = (Color *)JS_GetOpaque2(ctx, argv[1], js_Color_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + + Color arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[2], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg2.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[2], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg2.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[2], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg2.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[2], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg2.a = (unsigned char)a_int; + } + else { + + Color * argptr2 = (Color *)JS_GetOpaque2(ctx, argv[2], js_Color_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + + + Color arg3; + + if (JS_IsArray(ctx, argv[3])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[3], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg3.r = (unsigned char)r_int; - Color arg2 = *argptr2; - Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); - if (argptr3 == NULL) return JS_EXCEPTION; + JSValue g = JS_GetPropertyUint32(ctx, argv[3], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg3.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[3], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg3.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[3], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg3.a = (unsigned char)a_int; + } + else { + + Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); + + if (argptr3 == NULL) return JS_EXCEPTION; + + arg3 = *argptr3; + } - Color arg3 = *argptr3; - Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); - if (argptr4 == NULL) return JS_EXCEPTION; + + Color arg4; + + if (JS_IsArray(ctx, argv[4])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[4], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg4.r = (unsigned char)r_int; - Color arg4 = *argptr4; + JSValue g = JS_GetPropertyUint32(ctx, argv[4], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg4.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[4], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg4.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[4], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg4.a = (unsigned char)a_int; + } + else { + Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); + + if (argptr4 == NULL) return JS_EXCEPTION; + + arg4 = *argptr4; + } + DrawRectangleGradientEx(arg0, arg1, arg2, arg3, arg4); @@ -10101,11 +11713,41 @@ static JSValue js_DrawRectangleLines(JSContext *ctx, JSValueConst this_val, int JS_ToInt32(ctx, &arg2, argv[2]); int arg3; JS_ToInt32(ctx, &arg3, argv[3]); - Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); - if (argptr4 == NULL) return JS_EXCEPTION; + + + Color arg4; + + if (JS_IsArray(ctx, argv[4])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[4], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg4.r = (unsigned char)r_int; - Color arg4 = *argptr4; + JSValue g = JS_GetPropertyUint32(ctx, argv[4], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg4.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[4], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg4.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[4], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg4.a = (unsigned char)a_int; + } + else { + Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); + + if (argptr4 == NULL) return JS_EXCEPTION; + + arg4 = *argptr4; + } + DrawRectangleLines(arg0, arg1, arg2, arg3, arg4); @@ -10114,17 +11756,77 @@ static JSValue js_DrawRectangleLines(JSContext *ctx, JSValueConst this_val, int static JSValue js_DrawRectangleLinesEx(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + Rectangle arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Rectangle arg0 = *argptr0; - double arg1; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue w = JS_GetPropertyUint32(ctx, argv[0], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg0.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[0], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg0.height = (float)h_double; + } + else { + + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + double arg1; JS_ToFloat64(ctx, &arg1, argv[1]); - Color * argptr2 = (Color *)JS_GetOpaque2(ctx, argv[2], js_Color_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; + + + Color arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[2], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg2.r = (unsigned char)r_int; - Color arg2 = *argptr2; + JSValue g = JS_GetPropertyUint32(ctx, argv[2], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg2.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[2], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg2.b = (unsigned char)b_int; + JSValue a = JS_GetPropertyUint32(ctx, argv[2], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg2.a = (unsigned char)a_int; + } + else { + + Color * argptr2 = (Color *)JS_GetOpaque2(ctx, argv[2], js_Color_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + DrawRectangleLinesEx(arg0, arg1, arg2); @@ -10133,19 +11835,79 @@ static JSValue js_DrawRectangleLinesEx(JSContext *ctx, JSValueConst this_val, in static JSValue js_DrawRectangleRounded(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + Rectangle arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Rectangle arg0 = *argptr0; - double arg1; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue w = JS_GetPropertyUint32(ctx, argv[0], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg0.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[0], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg0.height = (float)h_double; + } + else { + + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + double arg1; JS_ToFloat64(ctx, &arg1, argv[1]); int arg2; JS_ToInt32(ctx, &arg2, argv[2]); - Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); - if (argptr3 == NULL) return JS_EXCEPTION; + + + Color arg3; + + if (JS_IsArray(ctx, argv[3])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[3], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg3.r = (unsigned char)r_int; - Color arg3 = *argptr3; + JSValue g = JS_GetPropertyUint32(ctx, argv[3], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg3.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[3], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg3.b = (unsigned char)b_int; + JSValue a = JS_GetPropertyUint32(ctx, argv[3], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg3.a = (unsigned char)a_int; + } + else { + + Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); + + if (argptr3 == NULL) return JS_EXCEPTION; + + arg3 = *argptr3; + } + DrawRectangleRounded(arg0, arg1, arg2, arg3); @@ -10154,21 +11916,81 @@ static JSValue js_DrawRectangleRounded(JSContext *ctx, JSValueConst this_val, in static JSValue js_DrawRectangleRoundedLines(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + Rectangle arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Rectangle arg0 = *argptr0; - double arg1; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue w = JS_GetPropertyUint32(ctx, argv[0], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg0.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[0], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg0.height = (float)h_double; + } + else { + + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + double arg1; JS_ToFloat64(ctx, &arg1, argv[1]); int arg2; JS_ToInt32(ctx, &arg2, argv[2]); double arg3; JS_ToFloat64(ctx, &arg3, argv[3]); - Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); - if (argptr4 == NULL) return JS_EXCEPTION; + + + Color arg4; + + if (JS_IsArray(ctx, argv[4])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[4], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg4.r = (unsigned char)r_int; - Color arg4 = *argptr4; + JSValue g = JS_GetPropertyUint32(ctx, argv[4], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg4.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[4], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg4.b = (unsigned char)b_int; + JSValue a = JS_GetPropertyUint32(ctx, argv[4], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg4.a = (unsigned char)a_int; + } + else { + + Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); + + if (argptr4 == NULL) return JS_EXCEPTION; + + arg4 = *argptr4; + } + DrawRectangleRoundedLines(arg0, arg1, arg2, arg3, arg4); @@ -10177,23 +11999,113 @@ static JSValue js_DrawRectangleRoundedLines(JSContext *ctx, JSValueConst this_va static JSValue js_DrawTriangle(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Vector2 arg0 = *argptr0; - Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } - Vector2 arg1 = *argptr1; - Vector2 * argptr2 = (Vector2 *)JS_GetOpaque2(ctx, argv[2], js_Vector2_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; + + Vector2 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + } + else { + + Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + + Vector2 arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[2], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg2.x = (float)x_double; - Vector2 arg2 = *argptr2; - Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); - if (argptr3 == NULL) return JS_EXCEPTION; + JSValue y = JS_GetPropertyUint32(ctx, argv[2], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg2.y = (float)y_double; + } + else { + + Vector2 * argptr2 = (Vector2 *)JS_GetOpaque2(ctx, argv[2], js_Vector2_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + + + Color arg3; + + if (JS_IsArray(ctx, argv[3])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[3], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg3.r = (unsigned char)r_int; - Color arg3 = *argptr3; + JSValue g = JS_GetPropertyUint32(ctx, argv[3], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg3.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[3], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg3.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[3], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg3.a = (unsigned char)a_int; + } + else { + Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); + + if (argptr3 == NULL) return JS_EXCEPTION; + + arg3 = *argptr3; + } + DrawTriangle(arg0, arg1, arg2, arg3); @@ -10202,4679 +12114,16283 @@ static JSValue js_DrawTriangle(JSContext *ctx, JSValueConst this_val, int argc, static JSValue js_DrawTriangleLines(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Vector2 arg0 = *argptr0; - Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } - Vector2 arg1 = *argptr1; - Vector2 * argptr2 = (Vector2 *)JS_GetOpaque2(ctx, argv[2], js_Vector2_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; + + Vector2 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + } + else { + + Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + + Vector2 arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[2], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg2.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[2], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg2.y = (float)y_double; + } + else { + + Vector2 * argptr2 = (Vector2 *)JS_GetOpaque2(ctx, argv[2], js_Vector2_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } - Vector2 arg2 = *argptr2; - Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); - if (argptr3 == NULL) return JS_EXCEPTION; + + Color arg3; + + if (JS_IsArray(ctx, argv[3])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[3], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg3.r = (unsigned char)r_int; - Color arg3 = *argptr3; + JSValue g = JS_GetPropertyUint32(ctx, argv[3], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg3.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[3], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg3.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[3], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg3.a = (unsigned char)a_int; + } + else { + + Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); + if (argptr3 == NULL) return JS_EXCEPTION; + + arg3 = *argptr3; + } + DrawTriangleLines(arg0, arg1, arg2, arg3); return JS_UNDEFINED; } -static JSValue js_DrawPoly(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_DrawTriangleFan(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + JSValue arg0_length_js = JS_GetProperty(ctx, argv[0], JS_ATOM_length); + + int32_t arg0_length; + + JS_ToInt32(ctx, &arg0_length, arg0_length_js); + + Vector2 * arg0 = (Vector2 *)malloc(arg0_length*sizeof(Vector2)); + + for (int i=0; i < arg0_length; ++i) { + + JSValue val = JS_GetPropertyUint32(ctx, argv[0], i); + + Vector2 * obj = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + arg0[i] = *obj; + } - Vector2 arg0 = *argptr0; - int arg1; + int arg1; JS_ToInt32(ctx, &arg1, argv[1]); - double arg2; - JS_ToFloat64(ctx, &arg2, argv[2]); - double arg3; - JS_ToFloat64(ctx, &arg3, argv[3]); - Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); - if (argptr4 == NULL) return JS_EXCEPTION; + + + Color arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[2], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg2.r = (unsigned char)r_int; - Color arg4 = *argptr4; + JSValue g = JS_GetPropertyUint32(ctx, argv[2], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg2.g = (unsigned char)g_int; - DrawPoly(arg0, arg1, arg2, arg3, arg4); + JSValue b = JS_GetPropertyUint32(ctx, argv[2], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg2.b = (unsigned char)b_int; + JSValue a = JS_GetPropertyUint32(ctx, argv[2], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg2.a = (unsigned char)a_int; + } + else { + Color * argptr2 = (Color *)JS_GetOpaque2(ctx, argv[2], js_Color_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + + DrawTriangleFan(arg0, arg1, arg2); + + + if (arg0) + free(arg0); + return JS_UNDEFINED; } -static JSValue js_DrawPolyLines(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_DrawTriangleStrip(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + JSValue arg0_length_js = JS_GetProperty(ctx, argv[0], JS_ATOM_length); + + int32_t arg0_length; + + JS_ToInt32(ctx, &arg0_length, arg0_length_js); + + Vector2 * arg0 = (Vector2 *)malloc(arg0_length*sizeof(Vector2)); + + for (int i=0; i < arg0_length; ++i) { + + JSValue val = JS_GetPropertyUint32(ctx, argv[0], i); + + Vector2 * obj = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + arg0[i] = *obj; + } - Vector2 arg0 = *argptr0; - int arg1; + int arg1; JS_ToInt32(ctx, &arg1, argv[1]); - double arg2; - JS_ToFloat64(ctx, &arg2, argv[2]); - double arg3; - JS_ToFloat64(ctx, &arg3, argv[3]); - Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); - if (argptr4 == NULL) return JS_EXCEPTION; + + + Color arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[2], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg2.r = (unsigned char)r_int; - Color arg4 = *argptr4; + JSValue g = JS_GetPropertyUint32(ctx, argv[2], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg2.g = (unsigned char)g_int; - DrawPolyLines(arg0, arg1, arg2, arg3, arg4); + JSValue b = JS_GetPropertyUint32(ctx, argv[2], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg2.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[2], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg2.a = (unsigned char)a_int; + } + else { + + Color * argptr2 = (Color *)JS_GetOpaque2(ctx, argv[2], js_Color_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + + DrawTriangleStrip(arg0, arg1, arg2); + if (arg0) + free(arg0); + return JS_UNDEFINED; } -static JSValue js_DrawPolyLinesEx(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_DrawPoly(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Vector2 arg0 = *argptr0; - int arg1; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + int arg1; JS_ToInt32(ctx, &arg1, argv[1]); double arg2; JS_ToFloat64(ctx, &arg2, argv[2]); double arg3; JS_ToFloat64(ctx, &arg3, argv[3]); - double arg4; - JS_ToFloat64(ctx, &arg4, argv[4]); - Color * argptr5 = (Color *)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); - if (argptr5 == NULL) return JS_EXCEPTION; - - Color arg5 = *argptr5; - DrawPolyLinesEx(arg0, arg1, arg2, arg3, arg4, arg5); + Color arg4; - return JS_UNDEFINED; -} + if (JS_IsArray(ctx, argv[4])) { -static JSValue js_DrawSplineSegmentLinear(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Vector2 arg0 = *argptr0; - Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; - - Vector2 arg1 = *argptr1; - double arg2; - JS_ToFloat64(ctx, &arg2, argv[2]); - Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); - if (argptr3 == NULL) return JS_EXCEPTION; + JSValue r = JS_GetPropertyUint32(ctx, argv[4], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg4.r = (unsigned char)r_int; - Color arg3 = *argptr3; + JSValue g = JS_GetPropertyUint32(ctx, argv[4], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg4.g = (unsigned char)g_int; - DrawSplineSegmentLinear(arg0, arg1, arg2, arg3); + JSValue b = JS_GetPropertyUint32(ctx, argv[4], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg4.b = (unsigned char)b_int; + JSValue a = JS_GetPropertyUint32(ctx, argv[4], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg4.a = (unsigned char)a_int; + } + else { - return JS_UNDEFINED; -} + Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); -static JSValue js_DrawSplineSegmentBasis(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Vector2 arg0 = *argptr0; - Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; - - Vector2 arg1 = *argptr1; - Vector2 * argptr2 = (Vector2 *)JS_GetOpaque2(ctx, argv[2], js_Vector2_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; - - Vector2 arg2 = *argptr2; - Vector2 * argptr3 = (Vector2 *)JS_GetOpaque2(ctx, argv[3], js_Vector2_class_id); - if (argptr3 == NULL) return JS_EXCEPTION; - - Vector2 arg3 = *argptr3; - double arg4; - JS_ToFloat64(ctx, &arg4, argv[4]); - Color * argptr5 = (Color *)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); - if (argptr5 == NULL) return JS_EXCEPTION; + if (argptr4 == NULL) return JS_EXCEPTION; + + arg4 = *argptr4; + } - Color arg5 = *argptr5; - - DrawSplineSegmentBasis(arg0, arg1, arg2, arg3, arg4, arg5); + DrawPoly(arg0, arg1, arg2, arg3, arg4); return JS_UNDEFINED; } -static JSValue js_DrawSplineSegmentCatmullRom(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_DrawPolyLines(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Vector2 arg0 = *argptr0; - Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; - - Vector2 arg1 = *argptr1; - Vector2 * argptr2 = (Vector2 *)JS_GetOpaque2(ctx, argv[2], js_Vector2_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; - - Vector2 arg2 = *argptr2; - Vector2 * argptr3 = (Vector2 *)JS_GetOpaque2(ctx, argv[3], js_Vector2_class_id); - if (argptr3 == NULL) return JS_EXCEPTION; - - Vector2 arg3 = *argptr3; - double arg4; - JS_ToFloat64(ctx, &arg4, argv[4]); - Color * argptr5 = (Color *)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); - if (argptr5 == NULL) return JS_EXCEPTION; - - Color arg5 = *argptr5; - DrawSplineSegmentCatmullRom(arg0, arg1, arg2, arg3, arg4, arg5); + Vector2 arg0; - return JS_UNDEFINED; -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_DrawSplineSegmentBezierQuadratic(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Vector2 arg0 = *argptr0; - Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Vector2 arg1 = *argptr1; - Vector2 * argptr2 = (Vector2 *)JS_GetOpaque2(ctx, argv[2], js_Vector2_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; - - Vector2 arg2 = *argptr2; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); double arg3; JS_ToFloat64(ctx, &arg3, argv[3]); - Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); - if (argptr4 == NULL) return JS_EXCEPTION; - - Color arg4 = *argptr4; - DrawSplineSegmentBezierQuadratic(arg0, arg1, arg2, arg3, arg4); + Color arg4; - return JS_UNDEFINED; -} + if (JS_IsArray(ctx, argv[4])) { -static JSValue js_DrawSplineSegmentBezierCubic(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Vector2 arg0 = *argptr0; - Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; - - Vector2 arg1 = *argptr1; - Vector2 * argptr2 = (Vector2 *)JS_GetOpaque2(ctx, argv[2], js_Vector2_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; - - Vector2 arg2 = *argptr2; - Vector2 * argptr3 = (Vector2 *)JS_GetOpaque2(ctx, argv[3], js_Vector2_class_id); - if (argptr3 == NULL) return JS_EXCEPTION; - - Vector2 arg3 = *argptr3; - double arg4; - JS_ToFloat64(ctx, &arg4, argv[4]); - Color * argptr5 = (Color *)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); - if (argptr5 == NULL) return JS_EXCEPTION; + JSValue r = JS_GetPropertyUint32(ctx, argv[4], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg4.r = (unsigned char)r_int; - Color arg5 = *argptr5; + JSValue g = JS_GetPropertyUint32(ctx, argv[4], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg4.g = (unsigned char)g_int; - DrawSplineSegmentBezierCubic(arg0, arg1, arg2, arg3, arg4, arg5); + JSValue b = JS_GetPropertyUint32(ctx, argv[4], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg4.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[4], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg4.a = (unsigned char)a_int; + } + else { + + Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); + + if (argptr4 == NULL) return JS_EXCEPTION; + + arg4 = *argptr4; + } + + DrawPolyLines(arg0, arg1, arg2, arg3, arg4); return JS_UNDEFINED; } -static JSValue js_GetSplinePointLinear(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_DrawPolyLinesEx(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Vector2 arg0 = *argptr0; - Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; - - Vector2 arg1 = *argptr1; - double arg2; - JS_ToFloat64(ctx, &arg2, argv[2]); - Vector2 returnVal = GetSplinePointLinear(arg0, arg1, arg2); + Vector2 arg0; - - Vector2* ret_ptr = (Vector2 *)js_malloc(ctx, sizeof(Vector2)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Vector2_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_GetSplinePointBasis(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Vector2 arg0 = *argptr0; - Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; - - Vector2 arg1 = *argptr1; - Vector2 * argptr2 = (Vector2 *)JS_GetOpaque2(ctx, argv[2], js_Vector2_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; - - Vector2 arg2 = *argptr2; - Vector2 * argptr3 = (Vector2 *)JS_GetOpaque2(ctx, argv[3], js_Vector2_class_id); - if (argptr3 == NULL) return JS_EXCEPTION; + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Vector2 arg3 = *argptr3; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); + double arg3; + JS_ToFloat64(ctx, &arg3, argv[3]); double arg4; JS_ToFloat64(ctx, &arg4, argv[4]); - Vector2 returnVal = GetSplinePointBasis(arg0, arg1, arg2, arg3, arg4); + Color arg5; - - Vector2* ret_ptr = (Vector2 *)js_malloc(ctx, sizeof(Vector2)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Vector2_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - -} + if (JS_IsArray(ctx, argv[5])) { -static JSValue js_GetSplinePointCatmullRom(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Vector2 arg0 = *argptr0; - Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; + JSValue r = JS_GetPropertyUint32(ctx, argv[5], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg5.r = (unsigned char)r_int; - Vector2 arg1 = *argptr1; - Vector2 * argptr2 = (Vector2 *)JS_GetOpaque2(ctx, argv[2], js_Vector2_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; - - Vector2 arg2 = *argptr2; - Vector2 * argptr3 = (Vector2 *)JS_GetOpaque2(ctx, argv[3], js_Vector2_class_id); - if (argptr3 == NULL) return JS_EXCEPTION; - - Vector2 arg3 = *argptr3; - double arg4; - JS_ToFloat64(ctx, &arg4, argv[4]); + JSValue g = JS_GetPropertyUint32(ctx, argv[5], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg5.g = (unsigned char)g_int; - Vector2 returnVal = GetSplinePointCatmullRom(arg0, arg1, arg2, arg3, arg4); + JSValue b = JS_GetPropertyUint32(ctx, argv[5], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg5.b = (unsigned char)b_int; + JSValue a = JS_GetPropertyUint32(ctx, argv[5], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg5.a = (unsigned char)a_int; + } + else { - - Vector2* ret_ptr = (Vector2 *)js_malloc(ctx, sizeof(Vector2)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Vector2_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - -} + Color * argptr5 = (Color *)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); -static JSValue js_GetSplinePointBezierQuad(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Vector2 arg0 = *argptr0; - Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; - - Vector2 arg1 = *argptr1; - Vector2 * argptr2 = (Vector2 *)JS_GetOpaque2(ctx, argv[2], js_Vector2_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; + if (argptr5 == NULL) return JS_EXCEPTION; + + arg5 = *argptr5; + } - Vector2 arg2 = *argptr2; - double arg3; - JS_ToFloat64(ctx, &arg3, argv[3]); - - Vector2 returnVal = GetSplinePointBezierQuad(arg0, arg1, arg2, arg3); + DrawPolyLinesEx(arg0, arg1, arg2, arg3, arg4, arg5); - - Vector2* ret_ptr = (Vector2 *)js_malloc(ctx, sizeof(Vector2)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Vector2_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - + return JS_UNDEFINED; } -static JSValue js_GetSplinePointBezierCubic(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_DrawSplineLinear(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Vector2 arg0 = *argptr0; - Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; - - Vector2 arg1 = *argptr1; - Vector2 * argptr2 = (Vector2 *)JS_GetOpaque2(ctx, argv[2], js_Vector2_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; - - Vector2 arg2 = *argptr2; - Vector2 * argptr3 = (Vector2 *)JS_GetOpaque2(ctx, argv[3], js_Vector2_class_id); - if (argptr3 == NULL) return JS_EXCEPTION; - - Vector2 arg3 = *argptr3; - double arg4; - JS_ToFloat64(ctx, &arg4, argv[4]); - Vector2 returnVal = GetSplinePointBezierCubic(arg0, arg1, arg2, arg3, arg4); + JSValue arg0_length_js = JS_GetProperty(ctx, argv[0], JS_ATOM_length); + + int32_t arg0_length; + + JS_ToInt32(ctx, &arg0_length, arg0_length_js); - - Vector2* ret_ptr = (Vector2 *)js_malloc(ctx, sizeof(Vector2)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Vector2_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - -} + Vector2 * arg0 = (Vector2 *)malloc(arg0_length*sizeof(Vector2)); -static JSValue js_CheckCollisionRecs(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Rectangle arg0 = *argptr0; - Rectangle * argptr1 = (Rectangle *)JS_GetOpaque2(ctx, argv[1], js_Rectangle_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; + for (int i=0; i < arg0_length; ++i) { + + JSValue val = JS_GetPropertyUint32(ctx, argv[0], i); + + Vector2 * obj = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + arg0[i] = *obj; + } - Rectangle arg1 = *argptr1; + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); - bool ret = CheckCollisionRecs(arg0, arg1); + Color arg3; - return JS_NewBool(ctx, ret); -} + if (JS_IsArray(ctx, argv[3])) { -static JSValue js_CheckCollisionCircles(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Vector2 arg0 = *argptr0; - double arg1; - JS_ToFloat64(ctx, &arg1, argv[1]); - Vector2 * argptr2 = (Vector2 *)JS_GetOpaque2(ctx, argv[2], js_Vector2_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; + JSValue r = JS_GetPropertyUint32(ctx, argv[3], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg3.r = (unsigned char)r_int; - Vector2 arg2 = *argptr2; - double arg3; - JS_ToFloat64(ctx, &arg3, argv[3]); + JSValue g = JS_GetPropertyUint32(ctx, argv[3], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg3.g = (unsigned char)g_int; - bool ret = CheckCollisionCircles(arg0, arg1, arg2, arg3); + JSValue b = JS_GetPropertyUint32(ctx, argv[3], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg3.b = (unsigned char)b_int; + JSValue a = JS_GetPropertyUint32(ctx, argv[3], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg3.a = (unsigned char)a_int; + } + else { - return JS_NewBool(ctx, ret); -} + Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); -static JSValue js_CheckCollisionCircleRec(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Vector2 arg0 = *argptr0; - double arg1; - JS_ToFloat64(ctx, &arg1, argv[1]); - Rectangle * argptr2 = (Rectangle *)JS_GetOpaque2(ctx, argv[2], js_Rectangle_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; + if (argptr3 == NULL) return JS_EXCEPTION; + + arg3 = *argptr3; + } - Rectangle arg2 = *argptr2; - - bool ret = CheckCollisionCircleRec(arg0, arg1, arg2); + DrawSplineLinear(arg0, arg1, arg2, arg3); - return JS_NewBool(ctx, ret); + if (arg0) + free(arg0); + + return JS_UNDEFINED; } -static JSValue js_CheckCollisionPointRec(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_DrawSplineBasis(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Vector2 arg0 = *argptr0; - Rectangle * argptr1 = (Rectangle *)JS_GetOpaque2(ctx, argv[1], js_Rectangle_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; - - Rectangle arg1 = *argptr1; - bool ret = CheckCollisionPointRec(arg0, arg1); + JSValue arg0_length_js = JS_GetProperty(ctx, argv[0], JS_ATOM_length); + + int32_t arg0_length; + + JS_ToInt32(ctx, &arg0_length, arg0_length_js); - return JS_NewBool(ctx, ret); -} + Vector2 * arg0 = (Vector2 *)malloc(arg0_length*sizeof(Vector2)); -static JSValue js_CheckCollisionPointCircle(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Vector2 arg0 = *argptr0; - Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; + for (int i=0; i < arg0_length; ++i) { + + JSValue val = JS_GetPropertyUint32(ctx, argv[0], i); + + Vector2 * obj = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + arg0[i] = *obj; + } - Vector2 arg1 = *argptr1; + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); double arg2; JS_ToFloat64(ctx, &arg2, argv[2]); - bool ret = CheckCollisionPointCircle(arg0, arg1, arg2); + Color arg3; - return JS_NewBool(ctx, ret); -} + if (JS_IsArray(ctx, argv[3])) { -static JSValue js_CheckCollisionPointTriangle(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + JSValue r = JS_GetPropertyUint32(ctx, argv[3], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg3.r = (unsigned char)r_int; - Vector2 arg0 = *argptr0; - Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; - - Vector2 arg1 = *argptr1; - Vector2 * argptr2 = (Vector2 *)JS_GetOpaque2(ctx, argv[2], js_Vector2_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; - - Vector2 arg2 = *argptr2; - Vector2 * argptr3 = (Vector2 *)JS_GetOpaque2(ctx, argv[3], js_Vector2_class_id); - if (argptr3 == NULL) return JS_EXCEPTION; - - Vector2 arg3 = *argptr3; + JSValue g = JS_GetPropertyUint32(ctx, argv[3], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg3.g = (unsigned char)g_int; - bool ret = CheckCollisionPointTriangle(arg0, arg1, arg2, arg3); + JSValue b = JS_GetPropertyUint32(ctx, argv[3], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg3.b = (unsigned char)b_int; + JSValue a = JS_GetPropertyUint32(ctx, argv[3], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg3.a = (unsigned char)a_int; + } + else { - return JS_NewBool(ctx, ret); -} + Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); -static JSValue js_CheckCollisionPointLine(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Vector2 arg0 = *argptr0; - Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; + if (argptr3 == NULL) return JS_EXCEPTION; + + arg3 = *argptr3; + } - Vector2 arg1 = *argptr1; - Vector2 * argptr2 = (Vector2 *)JS_GetOpaque2(ctx, argv[2], js_Vector2_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; - - Vector2 arg2 = *argptr2; - int arg3; - JS_ToInt32(ctx, &arg3, argv[3]); - - bool ret = CheckCollisionPointLine(arg0, arg1, arg2, arg3); + DrawSplineBasis(arg0, arg1, arg2, arg3); - return JS_NewBool(ctx, ret); + if (arg0) + free(arg0); + + return JS_UNDEFINED; } -static JSValue js_GetCollisionRec(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_DrawSplineCatmullRom(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Rectangle arg0 = *argptr0; - Rectangle * argptr1 = (Rectangle *)JS_GetOpaque2(ctx, argv[1], js_Rectangle_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; + + + JSValue arg0_length_js = JS_GetProperty(ctx, argv[0], JS_ATOM_length); + + int32_t arg0_length; + + JS_ToInt32(ctx, &arg0_length, arg0_length_js); + + Vector2 * arg0 = (Vector2 *)malloc(arg0_length*sizeof(Vector2)); + + for (int i=0; i < arg0_length; ++i) { + + JSValue val = JS_GetPropertyUint32(ctx, argv[0], i); + + Vector2 * obj = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + arg0[i] = *obj; + } - Rectangle arg1 = *argptr1; + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); - Rectangle returnVal = GetCollisionRec(arg0, arg1); + Color arg3; - - Rectangle* ret_ptr = (Rectangle *)js_malloc(ctx, sizeof(Rectangle)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Rectangle_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - -} + if (JS_IsArray(ctx, argv[3])) { -static JSValue js_LoadImage(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); + JSValue r = JS_GetPropertyUint32(ctx, argv[3], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg3.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[3], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg3.g = (unsigned char)g_int; - Image returnVal = LoadImage(arg0); + JSValue b = JS_GetPropertyUint32(ctx, argv[3], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg3.b = (unsigned char)b_int; - JS_FreeCString(ctx, arg0); + JSValue a = JS_GetPropertyUint32(ctx, argv[3], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg3.a = (unsigned char)a_int; + } + else { - - Image* ret_ptr = (Image *)js_malloc(ctx, sizeof(Image)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Image_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - + Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); + + if (argptr3 == NULL) return JS_EXCEPTION; + + arg3 = *argptr3; + } + + DrawSplineCatmullRom(arg0, arg1, arg2, arg3); + + + if (arg0) + free(arg0); + + return JS_UNDEFINED; } -static JSValue js_LoadImageRaw(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_DrawSplineBezierQuadratic(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); - int arg1; - JS_ToInt32(ctx, &arg1, argv[1]); - int arg2; - JS_ToInt32(ctx, &arg2, argv[2]); - int arg3; - JS_ToInt32(ctx, &arg3, argv[3]); - int arg4; - JS_ToInt32(ctx, &arg4, argv[4]); - Image returnVal = LoadImageRaw(arg0, arg1, arg2, arg3, arg4); - JS_FreeCString(ctx, arg0); + JSValue arg0_length_js = JS_GetProperty(ctx, argv[0], JS_ATOM_length); + + int32_t arg0_length; + + JS_ToInt32(ctx, &arg0_length, arg0_length_js); - - Image* ret_ptr = (Image *)js_malloc(ctx, sizeof(Image)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Image_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - -} + Vector2 * arg0 = (Vector2 *)malloc(arg0_length*sizeof(Vector2)); -static JSValue js_LoadImageSvg(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); - int arg1; + for (int i=0; i < arg0_length; ++i) { + + JSValue val = JS_GetPropertyUint32(ctx, argv[0], i); + + Vector2 * obj = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + arg0[i] = *obj; + } + + int arg1; JS_ToInt32(ctx, &arg1, argv[1]); - int arg2; - JS_ToInt32(ctx, &arg2, argv[2]); + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); - Image returnVal = LoadImageSvg(arg0, arg1, arg2); - JS_FreeCString(ctx, arg0); + Color arg3; - - Image* ret_ptr = (Image *)js_malloc(ctx, sizeof(Image)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Image_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - -} + if (JS_IsArray(ctx, argv[3])) { -static JSValue js_LoadImageAnim(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); -JSValue arg1_js = JS_GetPropertyStr(ctx, argv[1], "frames"); - int arg1_int; - JS_ToInt32(ctx, &arg1_int, arg1_js); - int * arg1 = &arg1_int; + JSValue r = JS_GetPropertyUint32(ctx, argv[3], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg3.r = (unsigned char)r_int; - Image returnVal = LoadImageAnim(arg0, arg1); + JSValue g = JS_GetPropertyUint32(ctx, argv[3], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg3.g = (unsigned char)g_int; - JS_FreeCString(ctx, arg0); -JS_SetPropertyStr(ctx, argv[1], "frames", JS_NewInt32(ctx, arg1_int)); + JSValue b = JS_GetPropertyUint32(ctx, argv[3], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg3.b = (unsigned char)b_int; - - Image* ret_ptr = (Image *)js_malloc(ctx, sizeof(Image)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Image_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - -} + JSValue a = JS_GetPropertyUint32(ctx, argv[3], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg3.a = (unsigned char)a_int; + } + else { -static JSValue js_LoadImageFromMemory(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); -size_t data_size1; - const unsigned char * arg1 = (const unsigned char *)JS_GetArrayBuffer(ctx, &data_size1, argv[1]); - int arg2; - JS_ToInt32(ctx, &arg2, argv[2]); + Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); - Image returnVal = LoadImageFromMemory(arg0, arg1, arg2); + if (argptr3 == NULL) return JS_EXCEPTION; + + arg3 = *argptr3; + } + + DrawSplineBezierQuadratic(arg0, arg1, arg2, arg3); - JS_FreeCString(ctx, arg0); - - Image* ret_ptr = (Image *)js_malloc(ctx, sizeof(Image)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Image_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - + if (arg0) + free(arg0); + + return JS_UNDEFINED; } -static JSValue js_LoadImageFromTexture(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_DrawSplineBezierCubic(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Texture2D * argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture2D_class_id); - if (argptr0 == NULL) - argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Texture2D arg0 = *argptr0; - Image returnVal = LoadImageFromTexture(arg0); + JSValue arg0_length_js = JS_GetProperty(ctx, argv[0], JS_ATOM_length); + + int32_t arg0_length; + + JS_ToInt32(ctx, &arg0_length, arg0_length_js); - - Image* ret_ptr = (Image *)js_malloc(ctx, sizeof(Image)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Image_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - -} + Vector2 * arg0 = (Vector2 *)malloc(arg0_length*sizeof(Vector2)); -static JSValue js_LoadImageFromScreen(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ + for (int i=0; i < arg0_length; ++i) { - Image returnVal = LoadImageFromScreen(); + JSValue val = JS_GetPropertyUint32(ctx, argv[0], i); + Vector2 * obj = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + arg0[i] = *obj; + } + + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); - - Image* ret_ptr = (Image *)js_malloc(ctx, sizeof(Image)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Image_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - -} -static JSValue js_IsImageReady(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Image * argptr0 = (Image *)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + Color arg3; + + if (JS_IsArray(ctx, argv[3])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[3], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg3.r = (unsigned char)r_int; - Image arg0 = *argptr0; + JSValue g = JS_GetPropertyUint32(ctx, argv[3], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg3.g = (unsigned char)g_int; - bool ret = IsImageReady(arg0); + JSValue b = JS_GetPropertyUint32(ctx, argv[3], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg3.b = (unsigned char)b_int; + JSValue a = JS_GetPropertyUint32(ctx, argv[3], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg3.a = (unsigned char)a_int; + } + else { - return JS_NewBool(ctx, ret); -} + Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); -static JSValue js_UnloadImage(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Image * argptr0 = (Image *)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + if (argptr3 == NULL) return JS_EXCEPTION; + + arg3 = *argptr3; + } - Image arg0 = *argptr0; - - UnloadImage(arg0); + DrawSplineBezierCubic(arg0, arg1, arg2, arg3); + if (arg0) + free(arg0); + return JS_UNDEFINED; } -static JSValue js_ExportImage(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_DrawSplineSegmentLinear(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Image * argptr0 = (Image *)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Image arg0 = *argptr0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); - bool ret = ExportImage(arg0, arg1); - JS_FreeCString(ctx, arg1); + Vector2 arg0; - return JS_NewBool(ctx, ret); -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_ExportImageToMemory(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Image * argptr0 = (Image *)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Image arg0 = *argptr0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); -JSValue arg2_js = JS_GetPropertyStr(ctx, argv[2], "fileSize"); - int arg2_int; - JS_ToInt32(ctx, &arg2_int, arg2_js); - int * arg2 = &arg2_int; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } - unsigned char * retVal = ExportImageToMemory(arg0, arg1, arg2); - JS_FreeCString(ctx, arg1); -JS_SetPropertyStr(ctx, argv[2], "fileSize", JS_NewInt32(ctx, arg2_int)); + Vector2 arg1; - JSValue ret = JS_NewArrayBufferCopy(ctx, (const uint8_t*)retVal, 7777 /*<>*/); - return ret; -} + if (JS_IsArray(ctx, argv[1])) { -static JSValue js_ExportImageAsCode(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Image * argptr0 = (Image *)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; - Image arg0 = *argptr0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + } + else { - bool ret = ExportImageAsCode(arg0, arg1); + Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); - JS_FreeCString(ctx, arg1); + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); - return JS_NewBool(ctx, ret); -} -static JSValue js_GenImageColor(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - int arg0; - JS_ToInt32(ctx, &arg0, argv[0]); - int arg1; - JS_ToInt32(ctx, &arg1, argv[1]); - Color * argptr2 = (Color *)JS_GetOpaque2(ctx, argv[2], js_Color_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; - - Color arg2 = *argptr2; + Color arg3; - Image returnVal = GenImageColor(arg0, arg1, arg2); + if (JS_IsArray(ctx, argv[3])) { + JSValue r = JS_GetPropertyUint32(ctx, argv[3], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg3.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[3], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg3.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[3], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg3.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[3], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg3.a = (unsigned char)a_int; + } + else { + + Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); + + if (argptr3 == NULL) return JS_EXCEPTION; + + arg3 = *argptr3; + } + + DrawSplineSegmentLinear(arg0, arg1, arg2, arg3); + + + return JS_UNDEFINED; +} + +static JSValue js_DrawSplineSegmentBasis(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + + Vector2 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + } + else { + + Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + + Vector2 arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[2], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg2.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[2], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg2.y = (float)y_double; + } + else { + + Vector2 * argptr2 = (Vector2 *)JS_GetOpaque2(ctx, argv[2], js_Vector2_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + + + Vector2 arg3; + + if (JS_IsArray(ctx, argv[3])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[3], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg3.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[3], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg3.y = (float)y_double; + } + else { + + Vector2 * argptr3 = (Vector2 *)JS_GetOpaque2(ctx, argv[3], js_Vector2_class_id); + + if (argptr3 == NULL) return JS_EXCEPTION; + + arg3 = *argptr3; + } + double arg4; + JS_ToFloat64(ctx, &arg4, argv[4]); + + + Color arg5; + + if (JS_IsArray(ctx, argv[5])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[5], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg5.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[5], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg5.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[5], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg5.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[5], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg5.a = (unsigned char)a_int; + } + else { + + Color * argptr5 = (Color *)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); + + if (argptr5 == NULL) return JS_EXCEPTION; + + arg5 = *argptr5; + } + + DrawSplineSegmentBasis(arg0, arg1, arg2, arg3, arg4, arg5); + + + return JS_UNDEFINED; +} + +static JSValue js_DrawSplineSegmentCatmullRom(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + + Vector2 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + } + else { + + Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + + Vector2 arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[2], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg2.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[2], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg2.y = (float)y_double; + } + else { + + Vector2 * argptr2 = (Vector2 *)JS_GetOpaque2(ctx, argv[2], js_Vector2_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + + + Vector2 arg3; + + if (JS_IsArray(ctx, argv[3])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[3], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg3.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[3], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg3.y = (float)y_double; + } + else { + + Vector2 * argptr3 = (Vector2 *)JS_GetOpaque2(ctx, argv[3], js_Vector2_class_id); + + if (argptr3 == NULL) return JS_EXCEPTION; + + arg3 = *argptr3; + } + double arg4; + JS_ToFloat64(ctx, &arg4, argv[4]); + + + Color arg5; + + if (JS_IsArray(ctx, argv[5])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[5], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg5.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[5], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg5.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[5], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg5.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[5], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg5.a = (unsigned char)a_int; + } + else { + + Color * argptr5 = (Color *)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); + + if (argptr5 == NULL) return JS_EXCEPTION; + + arg5 = *argptr5; + } + + DrawSplineSegmentCatmullRom(arg0, arg1, arg2, arg3, arg4, arg5); + + + return JS_UNDEFINED; +} + +static JSValue js_DrawSplineSegmentBezierQuadratic(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + + Vector2 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + } + else { + + Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + + Vector2 arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[2], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg2.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[2], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg2.y = (float)y_double; + } + else { + + Vector2 * argptr2 = (Vector2 *)JS_GetOpaque2(ctx, argv[2], js_Vector2_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + double arg3; + JS_ToFloat64(ctx, &arg3, argv[3]); + + + Color arg4; + + if (JS_IsArray(ctx, argv[4])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[4], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg4.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[4], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg4.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[4], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg4.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[4], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg4.a = (unsigned char)a_int; + } + else { + + Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); + + if (argptr4 == NULL) return JS_EXCEPTION; + + arg4 = *argptr4; + } + + DrawSplineSegmentBezierQuadratic(arg0, arg1, arg2, arg3, arg4); + + + return JS_UNDEFINED; +} + +static JSValue js_DrawSplineSegmentBezierCubic(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + + Vector2 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + } + else { + + Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + + Vector2 arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[2], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg2.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[2], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg2.y = (float)y_double; + } + else { + + Vector2 * argptr2 = (Vector2 *)JS_GetOpaque2(ctx, argv[2], js_Vector2_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + + + Vector2 arg3; + + if (JS_IsArray(ctx, argv[3])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[3], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg3.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[3], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg3.y = (float)y_double; + } + else { + + Vector2 * argptr3 = (Vector2 *)JS_GetOpaque2(ctx, argv[3], js_Vector2_class_id); + + if (argptr3 == NULL) return JS_EXCEPTION; + + arg3 = *argptr3; + } + double arg4; + JS_ToFloat64(ctx, &arg4, argv[4]); + + + Color arg5; + + if (JS_IsArray(ctx, argv[5])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[5], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg5.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[5], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg5.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[5], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg5.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[5], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg5.a = (unsigned char)a_int; + } + else { + + Color * argptr5 = (Color *)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); + + if (argptr5 == NULL) return JS_EXCEPTION; + + arg5 = *argptr5; + } + + DrawSplineSegmentBezierCubic(arg0, arg1, arg2, arg3, arg4, arg5); + + + return JS_UNDEFINED; +} + +static JSValue js_GetSplinePointLinear(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + + Vector2 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + } + else { + + Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); + + Vector2 returnVal = GetSplinePointLinear(arg0, arg1, arg2); + + + + Vector2* ret_ptr = (Vector2 *)js_malloc(ctx, sizeof(Vector2)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector2_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_GetSplinePointBasis(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + + Vector2 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + } + else { + + Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + + Vector2 arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[2], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg2.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[2], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg2.y = (float)y_double; + } + else { + + Vector2 * argptr2 = (Vector2 *)JS_GetOpaque2(ctx, argv[2], js_Vector2_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + + + Vector2 arg3; + + if (JS_IsArray(ctx, argv[3])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[3], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg3.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[3], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg3.y = (float)y_double; + } + else { + + Vector2 * argptr3 = (Vector2 *)JS_GetOpaque2(ctx, argv[3], js_Vector2_class_id); + + if (argptr3 == NULL) return JS_EXCEPTION; + + arg3 = *argptr3; + } + double arg4; + JS_ToFloat64(ctx, &arg4, argv[4]); + + Vector2 returnVal = GetSplinePointBasis(arg0, arg1, arg2, arg3, arg4); + + + + Vector2* ret_ptr = (Vector2 *)js_malloc(ctx, sizeof(Vector2)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector2_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_GetSplinePointCatmullRom(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + + Vector2 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + } + else { + + Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + + Vector2 arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[2], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg2.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[2], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg2.y = (float)y_double; + } + else { + + Vector2 * argptr2 = (Vector2 *)JS_GetOpaque2(ctx, argv[2], js_Vector2_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + + + Vector2 arg3; + + if (JS_IsArray(ctx, argv[3])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[3], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg3.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[3], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg3.y = (float)y_double; + } + else { + + Vector2 * argptr3 = (Vector2 *)JS_GetOpaque2(ctx, argv[3], js_Vector2_class_id); + + if (argptr3 == NULL) return JS_EXCEPTION; + + arg3 = *argptr3; + } + double arg4; + JS_ToFloat64(ctx, &arg4, argv[4]); + + Vector2 returnVal = GetSplinePointCatmullRom(arg0, arg1, arg2, arg3, arg4); + + + + Vector2* ret_ptr = (Vector2 *)js_malloc(ctx, sizeof(Vector2)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector2_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_GetSplinePointBezierQuad(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + + Vector2 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + } + else { + + Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + + Vector2 arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[2], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg2.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[2], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg2.y = (float)y_double; + } + else { + + Vector2 * argptr2 = (Vector2 *)JS_GetOpaque2(ctx, argv[2], js_Vector2_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + double arg3; + JS_ToFloat64(ctx, &arg3, argv[3]); + + Vector2 returnVal = GetSplinePointBezierQuad(arg0, arg1, arg2, arg3); + + + + Vector2* ret_ptr = (Vector2 *)js_malloc(ctx, sizeof(Vector2)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector2_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_GetSplinePointBezierCubic(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + + Vector2 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + } + else { + + Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + + Vector2 arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[2], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg2.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[2], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg2.y = (float)y_double; + } + else { + + Vector2 * argptr2 = (Vector2 *)JS_GetOpaque2(ctx, argv[2], js_Vector2_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + + + Vector2 arg3; + + if (JS_IsArray(ctx, argv[3])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[3], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg3.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[3], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg3.y = (float)y_double; + } + else { + + Vector2 * argptr3 = (Vector2 *)JS_GetOpaque2(ctx, argv[3], js_Vector2_class_id); + + if (argptr3 == NULL) return JS_EXCEPTION; + + arg3 = *argptr3; + } + double arg4; + JS_ToFloat64(ctx, &arg4, argv[4]); + + Vector2 returnVal = GetSplinePointBezierCubic(arg0, arg1, arg2, arg3, arg4); + + + + Vector2* ret_ptr = (Vector2 *)js_malloc(ctx, sizeof(Vector2)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector2_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_CheckCollisionRecs(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Rectangle arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue w = JS_GetPropertyUint32(ctx, argv[0], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg0.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[0], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg0.height = (float)h_double; + } + else { + + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + + Rectangle arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + + JSValue w = JS_GetPropertyUint32(ctx, argv[1], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg1.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[1], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg1.height = (float)h_double; + } + else { + + Rectangle * argptr1 = (Rectangle *)JS_GetOpaque2(ctx, argv[1], js_Rectangle_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + bool ret = CheckCollisionRecs(arg0, arg1); + + + return JS_NewBool(ctx, ret); +} + +static JSValue js_CheckCollisionCircles(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + + + Vector2 arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[2], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg2.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[2], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg2.y = (float)y_double; + } + else { + + Vector2 * argptr2 = (Vector2 *)JS_GetOpaque2(ctx, argv[2], js_Vector2_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + double arg3; + JS_ToFloat64(ctx, &arg3, argv[3]); + + bool ret = CheckCollisionCircles(arg0, arg1, arg2, arg3); + + + return JS_NewBool(ctx, ret); +} + +static JSValue js_CheckCollisionCircleRec(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + + + Rectangle arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[2], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg2.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[2], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg2.y = (float)y_double; + + JSValue w = JS_GetPropertyUint32(ctx, argv[2], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg2.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[2], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg2.height = (float)h_double; + } + else { + + Rectangle * argptr2 = (Rectangle *)JS_GetOpaque2(ctx, argv[2], js_Rectangle_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + + bool ret = CheckCollisionCircleRec(arg0, arg1, arg2); + + + return JS_NewBool(ctx, ret); +} + +static JSValue js_CheckCollisionPointRec(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + + Rectangle arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + + JSValue w = JS_GetPropertyUint32(ctx, argv[1], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg1.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[1], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg1.height = (float)h_double; + } + else { + + Rectangle * argptr1 = (Rectangle *)JS_GetOpaque2(ctx, argv[1], js_Rectangle_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + bool ret = CheckCollisionPointRec(arg0, arg1); + + + return JS_NewBool(ctx, ret); +} + +static JSValue js_CheckCollisionPointCircle(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + + Vector2 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + } + else { + + Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); + + bool ret = CheckCollisionPointCircle(arg0, arg1, arg2); + + + return JS_NewBool(ctx, ret); +} + +static JSValue js_CheckCollisionPointTriangle(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + + Vector2 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + } + else { + + Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + + Vector2 arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[2], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg2.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[2], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg2.y = (float)y_double; + } + else { + + Vector2 * argptr2 = (Vector2 *)JS_GetOpaque2(ctx, argv[2], js_Vector2_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + + + Vector2 arg3; + + if (JS_IsArray(ctx, argv[3])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[3], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg3.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[3], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg3.y = (float)y_double; + } + else { + + Vector2 * argptr3 = (Vector2 *)JS_GetOpaque2(ctx, argv[3], js_Vector2_class_id); + + if (argptr3 == NULL) return JS_EXCEPTION; + + arg3 = *argptr3; + } + + bool ret = CheckCollisionPointTriangle(arg0, arg1, arg2, arg3); + + + return JS_NewBool(ctx, ret); +} + +static JSValue js_CheckCollisionPointPoly(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + + JSValue arg1_length_js = JS_GetProperty(ctx, argv[1], JS_ATOM_length); + + int32_t arg1_length; + + JS_ToInt32(ctx, &arg1_length, arg1_length_js); + + Vector2 * arg1 = (Vector2 *)malloc(arg1_length*sizeof(Vector2)); + + for (int i=0; i < arg1_length; ++i) { + + JSValue val = JS_GetPropertyUint32(ctx, argv[1], i); + + Vector2 * obj = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); + + arg1[i] = *obj; + } + + int arg2; + JS_ToInt32(ctx, &arg2, argv[2]); + + bool ret = CheckCollisionPointPoly(arg0, arg1, arg2); + + + if (arg1) + free(arg1); + + return JS_NewBool(ctx, ret); +} + +static JSValue js_CheckCollisionLines(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + + Vector2 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + } + else { + + Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + + Vector2 arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[2], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg2.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[2], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg2.y = (float)y_double; + } + else { + + Vector2 * argptr2 = (Vector2 *)JS_GetOpaque2(ctx, argv[2], js_Vector2_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + + + Vector2 arg3; + + if (JS_IsArray(ctx, argv[3])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[3], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg3.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[3], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg3.y = (float)y_double; + } + else { + + Vector2 * argptr3 = (Vector2 *)JS_GetOpaque2(ctx, argv[3], js_Vector2_class_id); + + if (argptr3 == NULL) return JS_EXCEPTION; + + arg3 = *argptr3; + } + Vector2 * arg4 = (Vector2 *)JS_GetOpaque2(ctx, argv[4], js_Vector2_class_id); + + bool ret = CheckCollisionLines(arg0, arg1, arg2, arg3, arg4); + + + return JS_NewBool(ctx, ret); +} + +static JSValue js_CheckCollisionPointLine(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + + Vector2 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + } + else { + + Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + + Vector2 arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[2], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg2.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[2], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg2.y = (float)y_double; + } + else { + + Vector2 * argptr2 = (Vector2 *)JS_GetOpaque2(ctx, argv[2], js_Vector2_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + int arg3; + JS_ToInt32(ctx, &arg3, argv[3]); + + bool ret = CheckCollisionPointLine(arg0, arg1, arg2, arg3); + + + return JS_NewBool(ctx, ret); +} + +static JSValue js_GetCollisionRec(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Rectangle arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue w = JS_GetPropertyUint32(ctx, argv[0], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg0.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[0], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg0.height = (float)h_double; + } + else { + + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + + Rectangle arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + + JSValue w = JS_GetPropertyUint32(ctx, argv[1], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg1.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[1], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg1.height = (float)h_double; + } + else { + + Rectangle * argptr1 = (Rectangle *)JS_GetOpaque2(ctx, argv[1], js_Rectangle_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + Rectangle returnVal = GetCollisionRec(arg0, arg1); + + + + Rectangle* ret_ptr = (Rectangle *)js_malloc(ctx, sizeof(Rectangle)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Rectangle_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_LoadImage(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); + + Image returnVal = LoadImage(arg0); + + JS_FreeCString(ctx, arg0); + + + Image* ret_ptr = (Image *)js_malloc(ctx, sizeof(Image)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Image_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_LoadImageRaw(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); + int arg2; + JS_ToInt32(ctx, &arg2, argv[2]); + int arg3; + JS_ToInt32(ctx, &arg3, argv[3]); + int arg4; + JS_ToInt32(ctx, &arg4, argv[4]); + + Image returnVal = LoadImageRaw(arg0, arg1, arg2, arg3, arg4); + + JS_FreeCString(ctx, arg0); + + + Image* ret_ptr = (Image *)js_malloc(ctx, sizeof(Image)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Image_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_LoadImageSvg(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); + int arg2; + JS_ToInt32(ctx, &arg2, argv[2]); + + Image returnVal = LoadImageSvg(arg0, arg1, arg2); + + JS_FreeCString(ctx, arg0); + + + Image* ret_ptr = (Image *)js_malloc(ctx, sizeof(Image)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Image_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_LoadImageAnim(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); +JSValue arg1_js = JS_GetPropertyStr(ctx, argv[1], "frames"); + int arg1_int; + JS_ToInt32(ctx, &arg1_int, arg1_js); + int * arg1 = &arg1_int; + + Image returnVal = LoadImageAnim(arg0, arg1); + + JS_FreeCString(ctx, arg0); +JS_SetPropertyStr(ctx, argv[1], "frames", JS_NewInt32(ctx, arg1_int)); + + + Image* ret_ptr = (Image *)js_malloc(ctx, sizeof(Image)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Image_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_LoadImageFromMemory(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); +size_t data_size1; + const unsigned char * arg1 = (const unsigned char *)JS_GetArrayBuffer(ctx, &data_size1, argv[1]); + int arg2; + JS_ToInt32(ctx, &arg2, argv[2]); + + Image returnVal = LoadImageFromMemory(arg0, arg1, arg2); + + JS_FreeCString(ctx, arg0); + + + Image* ret_ptr = (Image *)js_malloc(ctx, sizeof(Image)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Image_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_LoadImageFromTexture(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Texture2D * argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture2D_class_id); + if (argptr0 == NULL) + argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Texture2D arg0 = *argptr0; + + Image returnVal = LoadImageFromTexture(arg0); + + + + Image* ret_ptr = (Image *)js_malloc(ctx, sizeof(Image)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Image_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_LoadImageFromScreen(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + Image returnVal = LoadImageFromScreen(); + + + + Image* ret_ptr = (Image *)js_malloc(ctx, sizeof(Image)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Image_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_IsImageReady(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Image * argptr0 = (Image *)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Image arg0 = *argptr0; + + bool ret = IsImageReady(arg0); + + + return JS_NewBool(ctx, ret); +} + +static JSValue js_UnloadImage(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Image * argptr0 = (Image *)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Image arg0 = *argptr0; + + UnloadImage(arg0); + + + return JS_UNDEFINED; +} + +static JSValue js_ExportImage(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Image * argptr0 = (Image *)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Image arg0 = *argptr0; + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); + + bool ret = ExportImage(arg0, arg1); + + JS_FreeCString(ctx, arg1); + + return JS_NewBool(ctx, ret); +} + +static JSValue js_ExportImageToMemory(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Image * argptr0 = (Image *)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Image arg0 = *argptr0; + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); +JSValue arg2_js = JS_GetPropertyStr(ctx, argv[2], "fileSize"); + int arg2_int; + JS_ToInt32(ctx, &arg2_int, arg2_js); + int * arg2 = &arg2_int; + + unsigned char * retVal = ExportImageToMemory(arg0, arg1, arg2); + + JS_FreeCString(ctx, arg1); +JS_SetPropertyStr(ctx, argv[2], "fileSize", JS_NewInt32(ctx, arg2_int)); + + JSValue ret = JS_NewArrayBufferCopy(ctx, (const uint8_t*)retVal, 7777 /*<>*/); + return ret; +} + +static JSValue js_ExportImageAsCode(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Image * argptr0 = (Image *)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Image arg0 = *argptr0; + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); + + bool ret = ExportImageAsCode(arg0, arg1); + + JS_FreeCString(ctx, arg1); + + return JS_NewBool(ctx, ret); +} + +static JSValue js_GenImageColor(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + int arg0; + JS_ToInt32(ctx, &arg0, argv[0]); + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); + + + Color arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[2], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg2.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[2], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg2.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[2], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg2.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[2], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg2.a = (unsigned char)a_int; + } + else { + + Color * argptr2 = (Color *)JS_GetOpaque2(ctx, argv[2], js_Color_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + + Image returnVal = GenImageColor(arg0, arg1, arg2); + + + + Image* ret_ptr = (Image *)js_malloc(ctx, sizeof(Image)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Image_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_GenImageGradientLinear(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + int arg0; + JS_ToInt32(ctx, &arg0, argv[0]); + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); + int arg2; + JS_ToInt32(ctx, &arg2, argv[2]); + + + Color arg3; + + if (JS_IsArray(ctx, argv[3])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[3], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg3.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[3], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg3.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[3], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg3.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[3], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg3.a = (unsigned char)a_int; + } + else { + + Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); + + if (argptr3 == NULL) return JS_EXCEPTION; + + arg3 = *argptr3; + } + + + Color arg4; + + if (JS_IsArray(ctx, argv[4])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[4], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg4.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[4], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg4.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[4], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg4.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[4], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg4.a = (unsigned char)a_int; + } + else { + + Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); + + if (argptr4 == NULL) return JS_EXCEPTION; + + arg4 = *argptr4; + } + + Image returnVal = GenImageGradientLinear(arg0, arg1, arg2, arg3, arg4); + + + + Image* ret_ptr = (Image *)js_malloc(ctx, sizeof(Image)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Image_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_GenImageGradientRadial(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + int arg0; + JS_ToInt32(ctx, &arg0, argv[0]); + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); + + + Color arg3; + + if (JS_IsArray(ctx, argv[3])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[3], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg3.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[3], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg3.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[3], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg3.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[3], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg3.a = (unsigned char)a_int; + } + else { + + Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); + + if (argptr3 == NULL) return JS_EXCEPTION; + + arg3 = *argptr3; + } + + + Color arg4; + + if (JS_IsArray(ctx, argv[4])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[4], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg4.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[4], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg4.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[4], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg4.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[4], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg4.a = (unsigned char)a_int; + } + else { + + Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); + + if (argptr4 == NULL) return JS_EXCEPTION; + + arg4 = *argptr4; + } + + Image returnVal = GenImageGradientRadial(arg0, arg1, arg2, arg3, arg4); + + + + Image* ret_ptr = (Image *)js_malloc(ctx, sizeof(Image)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Image_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_GenImageGradientSquare(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + int arg0; + JS_ToInt32(ctx, &arg0, argv[0]); + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); + + + Color arg3; + + if (JS_IsArray(ctx, argv[3])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[3], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg3.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[3], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg3.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[3], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg3.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[3], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg3.a = (unsigned char)a_int; + } + else { + + Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); + + if (argptr3 == NULL) return JS_EXCEPTION; + + arg3 = *argptr3; + } + + + Color arg4; + + if (JS_IsArray(ctx, argv[4])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[4], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg4.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[4], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg4.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[4], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg4.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[4], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg4.a = (unsigned char)a_int; + } + else { + + Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); + + if (argptr4 == NULL) return JS_EXCEPTION; + + arg4 = *argptr4; + } + + Image returnVal = GenImageGradientSquare(arg0, arg1, arg2, arg3, arg4); + + + + Image* ret_ptr = (Image *)js_malloc(ctx, sizeof(Image)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Image_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_GenImageChecked(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + int arg0; + JS_ToInt32(ctx, &arg0, argv[0]); + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); + int arg2; + JS_ToInt32(ctx, &arg2, argv[2]); + int arg3; + JS_ToInt32(ctx, &arg3, argv[3]); + + + Color arg4; + + if (JS_IsArray(ctx, argv[4])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[4], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg4.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[4], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg4.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[4], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg4.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[4], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg4.a = (unsigned char)a_int; + } + else { + + Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); + + if (argptr4 == NULL) return JS_EXCEPTION; + + arg4 = *argptr4; + } + + + Color arg5; + + if (JS_IsArray(ctx, argv[5])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[5], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg5.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[5], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg5.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[5], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg5.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[5], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg5.a = (unsigned char)a_int; + } + else { + + Color * argptr5 = (Color *)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); + + if (argptr5 == NULL) return JS_EXCEPTION; + + arg5 = *argptr5; + } + + Image returnVal = GenImageChecked(arg0, arg1, arg2, arg3, arg4, arg5); + + + + Image* ret_ptr = (Image *)js_malloc(ctx, sizeof(Image)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Image_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_GenImageWhiteNoise(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + int arg0; + JS_ToInt32(ctx, &arg0, argv[0]); + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); + + Image returnVal = GenImageWhiteNoise(arg0, arg1, arg2); + + + + Image* ret_ptr = (Image *)js_malloc(ctx, sizeof(Image)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Image_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_GenImagePerlinNoise(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + int arg0; + JS_ToInt32(ctx, &arg0, argv[0]); + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); + int arg2; + JS_ToInt32(ctx, &arg2, argv[2]); + int arg3; + JS_ToInt32(ctx, &arg3, argv[3]); + double arg4; + JS_ToFloat64(ctx, &arg4, argv[4]); + + Image returnVal = GenImagePerlinNoise(arg0, arg1, arg2, arg3, arg4); + + + + Image* ret_ptr = (Image *)js_malloc(ctx, sizeof(Image)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Image_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_GenImageCellular(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + int arg0; + JS_ToInt32(ctx, &arg0, argv[0]); + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); + int arg2; + JS_ToInt32(ctx, &arg2, argv[2]); + + Image returnVal = GenImageCellular(arg0, arg1, arg2); + + + + Image* ret_ptr = (Image *)js_malloc(ctx, sizeof(Image)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Image_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_GenImageText(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + int arg0; + JS_ToInt32(ctx, &arg0, argv[0]); + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); + const char * arg2 = (const char *)JS_ToCString(ctx, argv[2]); + + Image returnVal = GenImageText(arg0, arg1, arg2); + + JS_FreeCString(ctx, arg2); + + + Image* ret_ptr = (Image *)js_malloc(ctx, sizeof(Image)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Image_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_GetImageAlphaBorder(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Image * argptr0 = (Image *)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Image arg0 = *argptr0; + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + + Rectangle returnVal = GetImageAlphaBorder(arg0, arg1); + + + + Rectangle* ret_ptr = (Rectangle *)js_malloc(ctx, sizeof(Rectangle)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Rectangle_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_GetImageColor(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Image * argptr0 = (Image *)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Image arg0 = *argptr0; + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); + int arg2; + JS_ToInt32(ctx, &arg2, argv[2]); + + Color returnVal = GetImageColor(arg0, arg1, arg2); + + + + Color* ret_ptr = (Color *)js_malloc(ctx, sizeof(Color)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Color_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_LoadTexture(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); + + Texture2D returnVal = LoadTexture(arg0); + + JS_FreeCString(ctx, arg0); + + + Texture2D* ret_ptr = (Texture2D *)js_malloc(ctx, sizeof(Texture2D)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Texture2D_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_LoadTextureFromImage(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Image * argptr0 = (Image *)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Image arg0 = *argptr0; + + Texture2D returnVal = LoadTextureFromImage(arg0); + + + + Texture2D* ret_ptr = (Texture2D *)js_malloc(ctx, sizeof(Texture2D)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Texture2D_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_LoadTextureCubemap(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Image * argptr0 = (Image *)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Image arg0 = *argptr0; + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); + + TextureCubemap returnVal = LoadTextureCubemap(arg0, arg1); + + + + TextureCubemap* ret_ptr = (TextureCubemap *)js_malloc(ctx, sizeof(TextureCubemap)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_TextureCubemap_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_LoadRenderTexture(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + int arg0; + JS_ToInt32(ctx, &arg0, argv[0]); + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); + + RenderTexture2D returnVal = LoadRenderTexture(arg0, arg1); + + + + RenderTexture2D* ret_ptr = (RenderTexture2D *)js_malloc(ctx, sizeof(RenderTexture2D)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_RenderTexture2D_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_IsTextureReady(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Texture2D * argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture2D_class_id); + if (argptr0 == NULL) + argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Texture2D arg0 = *argptr0; + + bool ret = IsTextureReady(arg0); + + + return JS_NewBool(ctx, ret); +} + +static JSValue js_UnloadTexture(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Texture2D * argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture2D_class_id); + if (argptr0 == NULL) + argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Texture2D arg0 = *argptr0; + + UnloadTexture(arg0); + + + return JS_UNDEFINED; +} + +static JSValue js_IsRenderTextureReady(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + RenderTexture2D * argptr0 = (RenderTexture2D *)JS_GetOpaque2(ctx, argv[0], js_RenderTexture2D_class_id); + if (argptr0 == NULL) + argptr0 = (RenderTexture2D *)JS_GetOpaque2(ctx, argv[0], js_RenderTexture_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + RenderTexture2D arg0 = *argptr0; + + bool ret = IsRenderTextureReady(arg0); + + + return JS_NewBool(ctx, ret); +} + +static JSValue js_UnloadRenderTexture(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + RenderTexture2D * argptr0 = (RenderTexture2D *)JS_GetOpaque2(ctx, argv[0], js_RenderTexture2D_class_id); + if (argptr0 == NULL) + argptr0 = (RenderTexture2D *)JS_GetOpaque2(ctx, argv[0], js_RenderTexture_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + RenderTexture2D arg0 = *argptr0; + + UnloadRenderTexture(arg0); + + + return JS_UNDEFINED; +} + +static JSValue js_UpdateTexture(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Texture2D * argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture2D_class_id); + if (argptr0 == NULL) + argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Texture2D arg0 = *argptr0; +size_t data_size1; + const void * arg1 = (const void *)JS_GetArrayBuffer(ctx, &data_size1, argv[1]); + + UpdateTexture(arg0, arg1); + + + return JS_UNDEFINED; +} + +static JSValue js_UpdateTextureRec(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Texture2D * argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture2D_class_id); + if (argptr0 == NULL) + argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Texture2D arg0 = *argptr0; + + + Rectangle arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + + JSValue w = JS_GetPropertyUint32(ctx, argv[1], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg1.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[1], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg1.height = (float)h_double; + } + else { + + Rectangle * argptr1 = (Rectangle *)JS_GetOpaque2(ctx, argv[1], js_Rectangle_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + size_t data_size2; + const void * arg2 = (const void *)JS_GetArrayBuffer(ctx, &data_size2, argv[2]); + + UpdateTextureRec(arg0, arg1, arg2); + + + return JS_UNDEFINED; +} + +static JSValue js_GenTextureMipmaps(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Texture2D * arg0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture2D_class_id); + if (arg0 == NULL) + arg0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture_class_id); + + GenTextureMipmaps(arg0); + + + return JS_UNDEFINED; +} + +static JSValue js_SetTextureFilter(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Texture2D * argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture2D_class_id); + if (argptr0 == NULL) + argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Texture2D arg0 = *argptr0; + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); + + SetTextureFilter(arg0, arg1); + + + return JS_UNDEFINED; +} + +static JSValue js_SetTextureWrap(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Texture2D * argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture2D_class_id); + if (argptr0 == NULL) + argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Texture2D arg0 = *argptr0; + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); + + SetTextureWrap(arg0, arg1); + + + return JS_UNDEFINED; +} + +static JSValue js_DrawTexture(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Texture2D * argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture2D_class_id); + if (argptr0 == NULL) + argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Texture2D arg0 = *argptr0; + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); + int arg2; + JS_ToInt32(ctx, &arg2, argv[2]); + + + Color arg3; + + if (JS_IsArray(ctx, argv[3])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[3], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg3.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[3], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg3.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[3], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg3.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[3], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg3.a = (unsigned char)a_int; + } + else { + + Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); + + if (argptr3 == NULL) return JS_EXCEPTION; + + arg3 = *argptr3; + } + + DrawTexture(arg0, arg1, arg2, arg3); + + + return JS_UNDEFINED; +} + +static JSValue js_DrawTextureV(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Texture2D * argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture2D_class_id); + if (argptr0 == NULL) + argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Texture2D arg0 = *argptr0; + + + Vector2 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + } + else { + + Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + + Color arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[2], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg2.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[2], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg2.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[2], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg2.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[2], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg2.a = (unsigned char)a_int; + } + else { + + Color * argptr2 = (Color *)JS_GetOpaque2(ctx, argv[2], js_Color_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + + DrawTextureV(arg0, arg1, arg2); + + + return JS_UNDEFINED; +} + +static JSValue js_DrawTextureEx(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Texture2D * argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture2D_class_id); + if (argptr0 == NULL) + argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Texture2D arg0 = *argptr0; + + + Vector2 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + } + else { + + Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); + double arg3; + JS_ToFloat64(ctx, &arg3, argv[3]); + + + Color arg4; + + if (JS_IsArray(ctx, argv[4])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[4], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg4.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[4], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg4.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[4], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg4.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[4], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg4.a = (unsigned char)a_int; + } + else { + + Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); + + if (argptr4 == NULL) return JS_EXCEPTION; + + arg4 = *argptr4; + } + + DrawTextureEx(arg0, arg1, arg2, arg3, arg4); + + + return JS_UNDEFINED; +} + +static JSValue js_DrawTextureRec(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Texture2D * argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture2D_class_id); + if (argptr0 == NULL) + argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Texture2D arg0 = *argptr0; + + + Rectangle arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + + JSValue w = JS_GetPropertyUint32(ctx, argv[1], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg1.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[1], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg1.height = (float)h_double; + } + else { + + Rectangle * argptr1 = (Rectangle *)JS_GetOpaque2(ctx, argv[1], js_Rectangle_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + + Vector2 arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[2], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg2.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[2], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg2.y = (float)y_double; + } + else { + + Vector2 * argptr2 = (Vector2 *)JS_GetOpaque2(ctx, argv[2], js_Vector2_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + + + Color arg3; + + if (JS_IsArray(ctx, argv[3])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[3], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg3.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[3], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg3.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[3], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg3.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[3], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg3.a = (unsigned char)a_int; + } + else { + + Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); + + if (argptr3 == NULL) return JS_EXCEPTION; + + arg3 = *argptr3; + } + + DrawTextureRec(arg0, arg1, arg2, arg3); + + + return JS_UNDEFINED; +} + +static JSValue js_DrawTexturePro(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Texture2D * argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture2D_class_id); + if (argptr0 == NULL) + argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Texture2D arg0 = *argptr0; + + + Rectangle arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + + JSValue w = JS_GetPropertyUint32(ctx, argv[1], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg1.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[1], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg1.height = (float)h_double; + } + else { + + Rectangle * argptr1 = (Rectangle *)JS_GetOpaque2(ctx, argv[1], js_Rectangle_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + + Rectangle arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[2], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg2.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[2], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg2.y = (float)y_double; + + JSValue w = JS_GetPropertyUint32(ctx, argv[2], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg2.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[2], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg2.height = (float)h_double; + } + else { + + Rectangle * argptr2 = (Rectangle *)JS_GetOpaque2(ctx, argv[2], js_Rectangle_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + + + Vector2 arg3; + + if (JS_IsArray(ctx, argv[3])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[3], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg3.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[3], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg3.y = (float)y_double; + } + else { + + Vector2 * argptr3 = (Vector2 *)JS_GetOpaque2(ctx, argv[3], js_Vector2_class_id); + + if (argptr3 == NULL) return JS_EXCEPTION; + + arg3 = *argptr3; + } + double arg4; + JS_ToFloat64(ctx, &arg4, argv[4]); + + + Color arg5; + + if (JS_IsArray(ctx, argv[5])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[5], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg5.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[5], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg5.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[5], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg5.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[5], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg5.a = (unsigned char)a_int; + } + else { + + Color * argptr5 = (Color *)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); + + if (argptr5 == NULL) return JS_EXCEPTION; + + arg5 = *argptr5; + } + + DrawTexturePro(arg0, arg1, arg2, arg3, arg4, arg5); + + + return JS_UNDEFINED; +} + +static JSValue js_DrawTextureNPatch(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Texture2D * argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture2D_class_id); + if (argptr0 == NULL) + argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Texture2D arg0 = *argptr0; + NPatchInfo * argptr1 = (NPatchInfo *)JS_GetOpaque2(ctx, argv[1], js_NPatchInfo_class_id); + if (argptr1 == NULL) return JS_EXCEPTION; + + NPatchInfo arg1 = *argptr1; + + + Rectangle arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[2], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg2.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[2], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg2.y = (float)y_double; + + JSValue w = JS_GetPropertyUint32(ctx, argv[2], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg2.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[2], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg2.height = (float)h_double; + } + else { + + Rectangle * argptr2 = (Rectangle *)JS_GetOpaque2(ctx, argv[2], js_Rectangle_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + + + Vector2 arg3; + + if (JS_IsArray(ctx, argv[3])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[3], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg3.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[3], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg3.y = (float)y_double; + } + else { + + Vector2 * argptr3 = (Vector2 *)JS_GetOpaque2(ctx, argv[3], js_Vector2_class_id); + + if (argptr3 == NULL) return JS_EXCEPTION; + + arg3 = *argptr3; + } + double arg4; + JS_ToFloat64(ctx, &arg4, argv[4]); + + + Color arg5; + + if (JS_IsArray(ctx, argv[5])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[5], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg5.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[5], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg5.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[5], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg5.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[5], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg5.a = (unsigned char)a_int; + } + else { + + Color * argptr5 = (Color *)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); + + if (argptr5 == NULL) return JS_EXCEPTION; + + arg5 = *argptr5; + } + + DrawTextureNPatch(arg0, arg1, arg2, arg3, arg4, arg5); + + + return JS_UNDEFINED; +} + +static JSValue js_Fade(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Color arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[0], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg0.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[0], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg0.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[0], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg0.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[0], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg0.a = (unsigned char)a_int; + } + else { + + Color * argptr0 = (Color *)JS_GetOpaque2(ctx, argv[0], js_Color_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + + Color returnVal = Fade(arg0, arg1); + + + + Color* ret_ptr = (Color *)js_malloc(ctx, sizeof(Color)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Color_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_ColorToInt(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Color arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[0], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg0.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[0], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg0.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[0], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg0.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[0], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg0.a = (unsigned char)a_int; + } + else { + + Color * argptr0 = (Color *)JS_GetOpaque2(ctx, argv[0], js_Color_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + int ret = ColorToInt(arg0); + + + return JS_NewInt32(ctx, ret); +} + +static JSValue js_ColorNormalize(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Color arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[0], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg0.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[0], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg0.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[0], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg0.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[0], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg0.a = (unsigned char)a_int; + } + else { + + Color * argptr0 = (Color *)JS_GetOpaque2(ctx, argv[0], js_Color_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + Vector4 returnVal = ColorNormalize(arg0); + + + + Vector4* ret_ptr = (Vector4 *)js_malloc(ctx, sizeof(Vector4)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector4_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_ColorFromNormalized(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Vector4 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + + JSValue w = JS_GetPropertyUint32(ctx, argv[0], 3); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg0.w = (float)w_double; + } + else { + + Vector4 * argptr0 = (Vector4 *)JS_GetOpaque2(ctx, argv[0], js_Vector4_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + Color returnVal = ColorFromNormalized(arg0); + + + + Color* ret_ptr = (Color *)js_malloc(ctx, sizeof(Color)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Color_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_ColorToHSV(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Color arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[0], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg0.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[0], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg0.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[0], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg0.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[0], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg0.a = (unsigned char)a_int; + } + else { + + Color * argptr0 = (Color *)JS_GetOpaque2(ctx, argv[0], js_Color_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + Vector3 returnVal = ColorToHSV(arg0); + + + + Vector3* ret_ptr = (Vector3 *)js_malloc(ctx, sizeof(Vector3)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_ColorFromHSV(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + double arg0; + JS_ToFloat64(ctx, &arg0, argv[0]); + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); + + Color returnVal = ColorFromHSV(arg0, arg1, arg2); + + + + Color* ret_ptr = (Color *)js_malloc(ctx, sizeof(Color)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Color_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_ColorTint(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Color arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[0], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg0.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[0], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg0.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[0], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg0.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[0], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg0.a = (unsigned char)a_int; + } + else { + + Color * argptr0 = (Color *)JS_GetOpaque2(ctx, argv[0], js_Color_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + + Color arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[1], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg1.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[1], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg1.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[1], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg1.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[1], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg1.a = (unsigned char)a_int; + } + else { + + Color * argptr1 = (Color *)JS_GetOpaque2(ctx, argv[1], js_Color_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + Color returnVal = ColorTint(arg0, arg1); + + + + Color* ret_ptr = (Color *)js_malloc(ctx, sizeof(Color)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Color_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_ColorBrightness(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Color arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[0], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg0.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[0], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg0.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[0], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg0.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[0], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg0.a = (unsigned char)a_int; + } + else { + + Color * argptr0 = (Color *)JS_GetOpaque2(ctx, argv[0], js_Color_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + + Color returnVal = ColorBrightness(arg0, arg1); + + + + Color* ret_ptr = (Color *)js_malloc(ctx, sizeof(Color)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Color_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_ColorContrast(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Color arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[0], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg0.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[0], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg0.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[0], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg0.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[0], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg0.a = (unsigned char)a_int; + } + else { + + Color * argptr0 = (Color *)JS_GetOpaque2(ctx, argv[0], js_Color_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + + Color returnVal = ColorContrast(arg0, arg1); + + + + Color* ret_ptr = (Color *)js_malloc(ctx, sizeof(Color)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Color_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_ColorAlpha(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Color arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[0], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg0.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[0], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg0.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[0], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg0.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[0], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg0.a = (unsigned char)a_int; + } + else { + + Color * argptr0 = (Color *)JS_GetOpaque2(ctx, argv[0], js_Color_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + + Color returnVal = ColorAlpha(arg0, arg1); + + + + Color* ret_ptr = (Color *)js_malloc(ctx, sizeof(Color)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Color_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_ColorAlphaBlend(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Color arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[0], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg0.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[0], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg0.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[0], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg0.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[0], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg0.a = (unsigned char)a_int; + } + else { + + Color * argptr0 = (Color *)JS_GetOpaque2(ctx, argv[0], js_Color_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + + Color arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[1], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg1.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[1], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg1.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[1], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg1.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[1], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg1.a = (unsigned char)a_int; + } + else { + + Color * argptr1 = (Color *)JS_GetOpaque2(ctx, argv[1], js_Color_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + + Color arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[2], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg2.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[2], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg2.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[2], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg2.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[2], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg2.a = (unsigned char)a_int; + } + else { + + Color * argptr2 = (Color *)JS_GetOpaque2(ctx, argv[2], js_Color_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + + Color returnVal = ColorAlphaBlend(arg0, arg1, arg2); + + + + Color* ret_ptr = (Color *)js_malloc(ctx, sizeof(Color)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Color_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_GetColor(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + unsigned int arg0; + JS_ToUint32(ctx, &arg0, argv[0]); + + Color returnVal = GetColor(arg0); + + + + Color* ret_ptr = (Color *)js_malloc(ctx, sizeof(Color)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Color_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_GetPixelColor(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ +size_t data_size0; + void * arg0 = (void *)JS_GetArrayBuffer(ctx, &data_size0, argv[0]); + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); + + Color returnVal = GetPixelColor(arg0, arg1); + + + + Color* ret_ptr = (Color *)js_malloc(ctx, sizeof(Color)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Color_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_SetPixelColor(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ +size_t data_size0; + void * arg0 = (void *)JS_GetArrayBuffer(ctx, &data_size0, argv[0]); + + + Color arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[1], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg1.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[1], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg1.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[1], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg1.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[1], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg1.a = (unsigned char)a_int; + } + else { + + Color * argptr1 = (Color *)JS_GetOpaque2(ctx, argv[1], js_Color_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + int arg2; + JS_ToInt32(ctx, &arg2, argv[2]); + + SetPixelColor(arg0, arg1, arg2); + + + return JS_UNDEFINED; +} + +static JSValue js_GetPixelDataSize(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + int arg0; + JS_ToInt32(ctx, &arg0, argv[0]); + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); + int arg2; + JS_ToInt32(ctx, &arg2, argv[2]); + + int ret = GetPixelDataSize(arg0, arg1, arg2); + + + return JS_NewInt32(ctx, ret); +} + +static JSValue js_GetFontDefault(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + Font returnVal = GetFontDefault(); + + + + Font* ret_ptr = (Font *)js_malloc(ctx, sizeof(Font)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Font_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_LoadFont(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); + + Font returnVal = LoadFont(arg0); + + JS_FreeCString(ctx, arg0); + + + Font* ret_ptr = (Font *)js_malloc(ctx, sizeof(Font)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Font_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_LoadFontEx(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); +JSValue arg2_js = JS_GetPropertyStr(ctx, argv[2], "codepoints"); + int arg2_int; + JS_ToInt32(ctx, &arg2_int, arg2_js); + int * arg2 = &arg2_int; + int arg3; + JS_ToInt32(ctx, &arg3, argv[3]); + + Font returnVal = LoadFontEx(arg0, arg1, arg2, arg3); + + JS_FreeCString(ctx, arg0); +JS_SetPropertyStr(ctx, argv[2], "codepoints", JS_NewInt32(ctx, arg2_int)); + + + Font* ret_ptr = (Font *)js_malloc(ctx, sizeof(Font)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Font_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_LoadFontFromImage(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Image * argptr0 = (Image *)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Image arg0 = *argptr0; + + + Color arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[1], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg1.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[1], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg1.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[1], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg1.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[1], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg1.a = (unsigned char)a_int; + } + else { + + Color * argptr1 = (Color *)JS_GetOpaque2(ctx, argv[1], js_Color_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + int arg2; + JS_ToInt32(ctx, &arg2, argv[2]); + + Font returnVal = LoadFontFromImage(arg0, arg1, arg2); + + + + Font* ret_ptr = (Font *)js_malloc(ctx, sizeof(Font)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Font_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_LoadFontFromMemory(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); +size_t data_size1; + const unsigned char * arg1 = (const unsigned char *)JS_GetArrayBuffer(ctx, &data_size1, argv[1]); + int arg2; + JS_ToInt32(ctx, &arg2, argv[2]); + int arg3; + JS_ToInt32(ctx, &arg3, argv[3]); +JSValue arg4_js = JS_GetPropertyStr(ctx, argv[4], "codepoints"); + int arg4_int; + JS_ToInt32(ctx, &arg4_int, arg4_js); + int * arg4 = &arg4_int; + int arg5; + JS_ToInt32(ctx, &arg5, argv[5]); + + Font returnVal = LoadFontFromMemory(arg0, arg1, arg2, arg3, arg4, arg5); + + JS_FreeCString(ctx, arg0); +JS_SetPropertyStr(ctx, argv[4], "codepoints", JS_NewInt32(ctx, arg4_int)); + + + Font* ret_ptr = (Font *)js_malloc(ctx, sizeof(Font)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Font_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_IsFontReady(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Font * argptr0 = (Font *)JS_GetOpaque2(ctx, argv[0], js_Font_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Font arg0 = *argptr0; + + bool ret = IsFontReady(arg0); + + + return JS_NewBool(ctx, ret); +} + +static JSValue js_UnloadFont(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Font * argptr0 = (Font *)JS_GetOpaque2(ctx, argv[0], js_Font_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Font arg0 = *argptr0; + + UnloadFont(arg0); + + + return JS_UNDEFINED; +} + +static JSValue js_ExportFontAsCode(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Font * argptr0 = (Font *)JS_GetOpaque2(ctx, argv[0], js_Font_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Font arg0 = *argptr0; + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); + + bool ret = ExportFontAsCode(arg0, arg1); + + JS_FreeCString(ctx, arg1); + + return JS_NewBool(ctx, ret); +} + +static JSValue js_DrawFPS(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + int arg0; + JS_ToInt32(ctx, &arg0, argv[0]); + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); + + DrawFPS(arg0, arg1); + + + return JS_UNDEFINED; +} + +static JSValue js_DrawText(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); + int arg2; + JS_ToInt32(ctx, &arg2, argv[2]); + int arg3; + JS_ToInt32(ctx, &arg3, argv[3]); + + + Color arg4; + + if (JS_IsArray(ctx, argv[4])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[4], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg4.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[4], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg4.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[4], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg4.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[4], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg4.a = (unsigned char)a_int; + } + else { + + Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); + + if (argptr4 == NULL) return JS_EXCEPTION; + + arg4 = *argptr4; + } + + DrawText(arg0, arg1, arg2, arg3, arg4); + + JS_FreeCString(ctx, arg0); + + return JS_UNDEFINED; +} + +static JSValue js_DrawTextEx(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Font * argptr0 = (Font *)JS_GetOpaque2(ctx, argv[0], js_Font_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Font arg0 = *argptr0; + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); + + + Vector2 arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[2], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg2.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[2], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg2.y = (float)y_double; + } + else { + + Vector2 * argptr2 = (Vector2 *)JS_GetOpaque2(ctx, argv[2], js_Vector2_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + double arg3; + JS_ToFloat64(ctx, &arg3, argv[3]); + double arg4; + JS_ToFloat64(ctx, &arg4, argv[4]); + + + Color arg5; + + if (JS_IsArray(ctx, argv[5])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[5], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg5.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[5], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg5.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[5], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg5.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[5], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg5.a = (unsigned char)a_int; + } + else { + + Color * argptr5 = (Color *)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); + + if (argptr5 == NULL) return JS_EXCEPTION; + + arg5 = *argptr5; + } + + DrawTextEx(arg0, arg1, arg2, arg3, arg4, arg5); + + JS_FreeCString(ctx, arg1); + + return JS_UNDEFINED; +} + +static JSValue js_DrawTextPro(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Font * argptr0 = (Font *)JS_GetOpaque2(ctx, argv[0], js_Font_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Font arg0 = *argptr0; + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); + + + Vector2 arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[2], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg2.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[2], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg2.y = (float)y_double; + } + else { + + Vector2 * argptr2 = (Vector2 *)JS_GetOpaque2(ctx, argv[2], js_Vector2_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + + + Vector2 arg3; + + if (JS_IsArray(ctx, argv[3])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[3], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg3.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[3], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg3.y = (float)y_double; + } + else { + + Vector2 * argptr3 = (Vector2 *)JS_GetOpaque2(ctx, argv[3], js_Vector2_class_id); + + if (argptr3 == NULL) return JS_EXCEPTION; + + arg3 = *argptr3; + } + double arg4; + JS_ToFloat64(ctx, &arg4, argv[4]); + double arg5; + JS_ToFloat64(ctx, &arg5, argv[5]); + double arg6; + JS_ToFloat64(ctx, &arg6, argv[6]); + + + Color arg7; + + if (JS_IsArray(ctx, argv[7])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[7], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg7.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[7], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg7.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[7], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg7.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[7], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg7.a = (unsigned char)a_int; + } + else { + + Color * argptr7 = (Color *)JS_GetOpaque2(ctx, argv[7], js_Color_class_id); + + if (argptr7 == NULL) return JS_EXCEPTION; + + arg7 = *argptr7; + } + + DrawTextPro(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); + + JS_FreeCString(ctx, arg1); + + return JS_UNDEFINED; +} + +static JSValue js_DrawTextCodepoint(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Font * argptr0 = (Font *)JS_GetOpaque2(ctx, argv[0], js_Font_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Font arg0 = *argptr0; + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); + + + Vector2 arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[2], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg2.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[2], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg2.y = (float)y_double; + } + else { + + Vector2 * argptr2 = (Vector2 *)JS_GetOpaque2(ctx, argv[2], js_Vector2_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + double arg3; + JS_ToFloat64(ctx, &arg3, argv[3]); + + + Color arg4; + + if (JS_IsArray(ctx, argv[4])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[4], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg4.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[4], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg4.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[4], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg4.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[4], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg4.a = (unsigned char)a_int; + } + else { + + Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); + + if (argptr4 == NULL) return JS_EXCEPTION; + + arg4 = *argptr4; + } + + DrawTextCodepoint(arg0, arg1, arg2, arg3, arg4); + + + return JS_UNDEFINED; +} + +static JSValue js_DrawTextCodepoints(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Font * argptr0 = (Font *)JS_GetOpaque2(ctx, argv[0], js_Font_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Font arg0 = *argptr0; +JSValue arg1_js = JS_GetPropertyStr(ctx, argv[1], "codepoints"); + int arg1_int; + JS_ToInt32(ctx, &arg1_int, arg1_js); + int * arg1 = &arg1_int; + int arg2; + JS_ToInt32(ctx, &arg2, argv[2]); + + + Vector2 arg3; + + if (JS_IsArray(ctx, argv[3])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[3], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg3.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[3], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg3.y = (float)y_double; + } + else { + + Vector2 * argptr3 = (Vector2 *)JS_GetOpaque2(ctx, argv[3], js_Vector2_class_id); + + if (argptr3 == NULL) return JS_EXCEPTION; + + arg3 = *argptr3; + } + double arg4; + JS_ToFloat64(ctx, &arg4, argv[4]); + double arg5; + JS_ToFloat64(ctx, &arg5, argv[5]); + + + Color arg6; + + if (JS_IsArray(ctx, argv[6])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[6], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg6.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[6], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg6.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[6], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg6.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[6], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg6.a = (unsigned char)a_int; + } + else { + + Color * argptr6 = (Color *)JS_GetOpaque2(ctx, argv[6], js_Color_class_id); + + if (argptr6 == NULL) return JS_EXCEPTION; + + arg6 = *argptr6; + } + + DrawTextCodepoints(arg0, arg1, arg2, arg3, arg4, arg5, arg6); + +JS_SetPropertyStr(ctx, argv[1], "codepoints", JS_NewInt32(ctx, arg1_int)); + + return JS_UNDEFINED; +} + +static JSValue js_SetTextLineSpacing(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + int arg0; + JS_ToInt32(ctx, &arg0, argv[0]); + + SetTextLineSpacing(arg0); + + + return JS_UNDEFINED; +} + +static JSValue js_MeasureText(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); + + int ret = MeasureText(arg0, arg1); + + JS_FreeCString(ctx, arg0); + + return JS_NewInt32(ctx, ret); +} + +static JSValue js_MeasureTextEx(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Font * argptr0 = (Font *)JS_GetOpaque2(ctx, argv[0], js_Font_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Font arg0 = *argptr0; + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); + double arg3; + JS_ToFloat64(ctx, &arg3, argv[3]); + + Vector2 returnVal = MeasureTextEx(arg0, arg1, arg2, arg3); + + JS_FreeCString(ctx, arg1); + + + Vector2* ret_ptr = (Vector2 *)js_malloc(ctx, sizeof(Vector2)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector2_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_GetGlyphIndex(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Font * argptr0 = (Font *)JS_GetOpaque2(ctx, argv[0], js_Font_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Font arg0 = *argptr0; + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); + + int ret = GetGlyphIndex(arg0, arg1); + + + return JS_NewInt32(ctx, ret); +} + +static JSValue js_GetGlyphInfo(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Font * argptr0 = (Font *)JS_GetOpaque2(ctx, argv[0], js_Font_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Font arg0 = *argptr0; + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); + + GlyphInfo returnVal = GetGlyphInfo(arg0, arg1); + + + + GlyphInfo* ret_ptr = (GlyphInfo *)js_malloc(ctx, sizeof(GlyphInfo)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_GlyphInfo_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_GetGlyphAtlasRec(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Font * argptr0 = (Font *)JS_GetOpaque2(ctx, argv[0], js_Font_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Font arg0 = *argptr0; + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); + + Rectangle returnVal = GetGlyphAtlasRec(arg0, arg1); + + + + Rectangle* ret_ptr = (Rectangle *)js_malloc(ctx, sizeof(Rectangle)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Rectangle_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_LoadUTF8(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ +JSValue arg0_js = JS_GetPropertyStr(ctx, argv[0], "codepoints"); + int arg0_int; + JS_ToInt32(ctx, &arg0_int, arg0_js); + int * arg0 = &arg0_int; + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); + + char * retVal = LoadUTF8(arg0, arg1); + +JS_SetPropertyStr(ctx, argv[0], "codepoints", JS_NewInt32(ctx, arg0_int)); + + JSValue ret = JS_NewArrayBufferCopy(ctx, (const uint8_t*)retVal, 7777 /*<>*/); + return ret; +} + +static JSValue js_UnloadUTF8(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + JSValue arg0_js = JS_GetPropertyStr(ctx, argv[0], "text"); + size_t arg0_len; + const char * arg0_str = JS_ToCStringLen(ctx, &arg0_len, arg0_js); + char * arg0 = malloc(arg0_len+1); + memcpy((void *)arg0, arg0_str, arg0_len); + arg0[arg0_len] = 0; + + UnloadUTF8(arg0); + + JS_FreeCString(ctx, arg0_str); + JS_SetPropertyStr(ctx, argv[0], "text", JS_NewString(ctx, arg0)); + free(arg0); + + return JS_UNDEFINED; +} + +static JSValue js_LoadCodepoints(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); +JSValue arg1_js = JS_GetPropertyStr(ctx, argv[1], "count"); + int arg1_int; + JS_ToInt32(ctx, &arg1_int, arg1_js); + int * arg1 = &arg1_int; + + int * retBuf = LoadCodepoints(arg0, arg1); + + JS_FreeCString(ctx, arg0); +JS_SetPropertyStr(ctx, argv[1], "count", JS_NewInt32(ctx, arg1_int)); + + JSValue ret = JS_NewArray(ctx); + for(int i; i < 7777 /*<>*/; i++){ + JS_SetPropertyUint32(ctx, ret, i, JS_NewInt32(ctx, retBuf[i])); + } + return ret; + +} + +static JSValue js_UnloadCodepoints(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ +JSValue arg0_js = JS_GetPropertyStr(ctx, argv[0], "codepoints"); + int arg0_int; + JS_ToInt32(ctx, &arg0_int, arg0_js); + int * arg0 = &arg0_int; + + UnloadCodepoints(arg0); + +JS_SetPropertyStr(ctx, argv[0], "codepoints", JS_NewInt32(ctx, arg0_int)); + + return JS_UNDEFINED; +} + +static JSValue js_GetCodepointCount(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); + + int ret = GetCodepointCount(arg0); + + JS_FreeCString(ctx, arg0); + + return JS_NewInt32(ctx, ret); +} + +static JSValue js_GetCodepoint(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); +JSValue arg1_js = JS_GetPropertyStr(ctx, argv[1], "codepointSize"); + int arg1_int; + JS_ToInt32(ctx, &arg1_int, arg1_js); + int * arg1 = &arg1_int; + + int ret = GetCodepoint(arg0, arg1); + + JS_FreeCString(ctx, arg0); +JS_SetPropertyStr(ctx, argv[1], "codepointSize", JS_NewInt32(ctx, arg1_int)); + + return JS_NewInt32(ctx, ret); +} + +static JSValue js_GetCodepointNext(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); +JSValue arg1_js = JS_GetPropertyStr(ctx, argv[1], "codepointSize"); + int arg1_int; + JS_ToInt32(ctx, &arg1_int, arg1_js); + int * arg1 = &arg1_int; + + int ret = GetCodepointNext(arg0, arg1); + + JS_FreeCString(ctx, arg0); +JS_SetPropertyStr(ctx, argv[1], "codepointSize", JS_NewInt32(ctx, arg1_int)); + + return JS_NewInt32(ctx, ret); +} + +static JSValue js_GetCodepointPrevious(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); +JSValue arg1_js = JS_GetPropertyStr(ctx, argv[1], "codepointSize"); + int arg1_int; + JS_ToInt32(ctx, &arg1_int, arg1_js); + int * arg1 = &arg1_int; + + int ret = GetCodepointPrevious(arg0, arg1); + + JS_FreeCString(ctx, arg0); +JS_SetPropertyStr(ctx, argv[1], "codepointSize", JS_NewInt32(ctx, arg1_int)); + + return JS_NewInt32(ctx, ret); +} + +static JSValue js_CodepointToUTF8(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + int arg0; + JS_ToInt32(ctx, &arg0, argv[0]); +JSValue arg1_js = JS_GetPropertyStr(ctx, argv[1], "utf8Size"); + int arg1_int; + JS_ToInt32(ctx, &arg1_int, arg1_js); + int * arg1 = &arg1_int; + + const char * returnVal = CodepointToUTF8(arg0, arg1); + +JS_SetPropertyStr(ctx, argv[1], "utf8Size", JS_NewInt32(ctx, arg1_int)); + + JSValue ret = JS_NewString(ctx, returnVal); + return ret; +} + +static JSValue js_TextCopy(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + JSValue arg0_js = JS_GetPropertyStr(ctx, argv[0], "dst"); + size_t arg0_len; + const char * arg0_str = JS_ToCStringLen(ctx, &arg0_len, arg0_js); + char * arg0 = malloc(arg0_len+1); + memcpy((void *)arg0, arg0_str, arg0_len); + arg0[arg0_len] = 0; + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); + + int ret = TextCopy(arg0, arg1); + + JS_FreeCString(ctx, arg0_str); + JS_SetPropertyStr(ctx, argv[0], "dst", JS_NewString(ctx, arg0)); + free(arg0); + JS_FreeCString(ctx, arg1); + + return JS_NewInt32(ctx, ret); +} + +static JSValue js_TextIsEqual(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); + + bool ret = TextIsEqual(arg0, arg1); + + JS_FreeCString(ctx, arg0); + JS_FreeCString(ctx, arg1); + + return JS_NewBool(ctx, ret); +} + +static JSValue js_TextLength(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); + + unsigned int ret = TextLength(arg0); + + JS_FreeCString(ctx, arg0); + + return JS_NewUint32(ctx, ret); +} + +static JSValue js_TextSubtext(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); + int arg2; + JS_ToInt32(ctx, &arg2, argv[2]); + + const char * returnVal = TextSubtext(arg0, arg1, arg2); + + JS_FreeCString(ctx, arg0); + + JSValue ret = JS_NewString(ctx, returnVal); + return ret; +} + +static JSValue js_TextReplace(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + JSValue arg0_js = JS_GetPropertyStr(ctx, argv[0], "text"); + size_t arg0_len; + const char * arg0_str = JS_ToCStringLen(ctx, &arg0_len, arg0_js); + char * arg0 = malloc(arg0_len+1); + memcpy((void *)arg0, arg0_str, arg0_len); + arg0[arg0_len] = 0; + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); + const char * arg2 = (const char *)JS_ToCString(ctx, argv[2]); + + char * retVal = TextReplace(arg0, arg1, arg2); + + JS_FreeCString(ctx, arg0_str); + JS_SetPropertyStr(ctx, argv[0], "text", JS_NewString(ctx, arg0)); + free(arg0); + JS_FreeCString(ctx, arg1); + JS_FreeCString(ctx, arg2); + + JSValue ret = JS_NewArrayBufferCopy(ctx, (const uint8_t*)retVal, 7777 /*<>*/); + return ret; +} + +static JSValue js_TextInsert(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); + int arg2; + JS_ToInt32(ctx, &arg2, argv[2]); + + char * retVal = TextInsert(arg0, arg1, arg2); + + JS_FreeCString(ctx, arg0); + JS_FreeCString(ctx, arg1); + + JSValue ret = JS_NewArrayBufferCopy(ctx, (const uint8_t*)retVal, 7777 /*<>*/); + return ret; +} + +static JSValue js_TextAppend(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + JSValue arg0_js = JS_GetPropertyStr(ctx, argv[0], "text"); + size_t arg0_len; + const char * arg0_str = JS_ToCStringLen(ctx, &arg0_len, arg0_js); + char * arg0 = malloc(arg0_len+1); + memcpy((void *)arg0, arg0_str, arg0_len); + arg0[arg0_len] = 0; + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); +JSValue arg2_js = JS_GetPropertyStr(ctx, argv[2], "position"); + int arg2_int; + JS_ToInt32(ctx, &arg2_int, arg2_js); + int * arg2 = &arg2_int; + + TextAppend(arg0, arg1, arg2); + + JS_FreeCString(ctx, arg0_str); + JS_SetPropertyStr(ctx, argv[0], "text", JS_NewString(ctx, arg0)); + free(arg0); + JS_FreeCString(ctx, arg1); +JS_SetPropertyStr(ctx, argv[2], "position", JS_NewInt32(ctx, arg2_int)); + + return JS_UNDEFINED; +} + +static JSValue js_TextFindIndex(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); + + int ret = TextFindIndex(arg0, arg1); + + JS_FreeCString(ctx, arg0); + JS_FreeCString(ctx, arg1); + + return JS_NewInt32(ctx, ret); +} + +static JSValue js_TextToUpper(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); + + const char * returnVal = TextToUpper(arg0); + + JS_FreeCString(ctx, arg0); + + JSValue ret = JS_NewString(ctx, returnVal); + return ret; +} + +static JSValue js_TextToLower(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); + + const char * returnVal = TextToLower(arg0); + + JS_FreeCString(ctx, arg0); + + JSValue ret = JS_NewString(ctx, returnVal); + return ret; +} + +static JSValue js_TextToPascal(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); + + const char * returnVal = TextToPascal(arg0); + + JS_FreeCString(ctx, arg0); + + JSValue ret = JS_NewString(ctx, returnVal); + return ret; +} + +static JSValue js_TextToInteger(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); + + int ret = TextToInteger(arg0); + + JS_FreeCString(ctx, arg0); + + return JS_NewInt32(ctx, ret); +} + +static JSValue js_DrawLine3D(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Vector3 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + + Vector3 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[1], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg1.z = (float)z_double; + } + else { + + Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + + Color arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[2], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg2.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[2], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg2.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[2], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg2.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[2], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg2.a = (unsigned char)a_int; + } + else { + + Color * argptr2 = (Color *)JS_GetOpaque2(ctx, argv[2], js_Color_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + + DrawLine3D(arg0, arg1, arg2); + + + return JS_UNDEFINED; +} + +static JSValue js_DrawPoint3D(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Vector3 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + + Color arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[1], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg1.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[1], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg1.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[1], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg1.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[1], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg1.a = (unsigned char)a_int; + } + else { + + Color * argptr1 = (Color *)JS_GetOpaque2(ctx, argv[1], js_Color_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + DrawPoint3D(arg0, arg1); + + + return JS_UNDEFINED; +} + +static JSValue js_DrawCircle3D(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Vector3 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + + + Vector3 arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[2], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg2.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[2], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg2.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[2], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg2.z = (float)z_double; + } + else { + + Vector3 * argptr2 = (Vector3 *)JS_GetOpaque2(ctx, argv[2], js_Vector3_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + double arg3; + JS_ToFloat64(ctx, &arg3, argv[3]); + + + Color arg4; + + if (JS_IsArray(ctx, argv[4])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[4], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg4.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[4], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg4.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[4], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg4.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[4], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg4.a = (unsigned char)a_int; + } + else { + + Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); + + if (argptr4 == NULL) return JS_EXCEPTION; + + arg4 = *argptr4; + } + + DrawCircle3D(arg0, arg1, arg2, arg3, arg4); + + + return JS_UNDEFINED; +} + +static JSValue js_DrawTriangle3D(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Vector3 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + + Vector3 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[1], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg1.z = (float)z_double; + } + else { + + Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + + Vector3 arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[2], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg2.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[2], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg2.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[2], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg2.z = (float)z_double; + } + else { + + Vector3 * argptr2 = (Vector3 *)JS_GetOpaque2(ctx, argv[2], js_Vector3_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + + + Color arg3; + + if (JS_IsArray(ctx, argv[3])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[3], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg3.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[3], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg3.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[3], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg3.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[3], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg3.a = (unsigned char)a_int; + } + else { + + Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); + + if (argptr3 == NULL) return JS_EXCEPTION; + + arg3 = *argptr3; + } + + DrawTriangle3D(arg0, arg1, arg2, arg3); + + + return JS_UNDEFINED; +} + +static JSValue js_DrawTriangleStrip3D(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + JSValue arg0_length_js = JS_GetProperty(ctx, argv[0], JS_ATOM_length); + + int32_t arg0_length; + + JS_ToInt32(ctx, &arg0_length, arg0_length_js); + + Vector3 * arg0 = (Vector3 *)malloc(arg0_length*sizeof(Vector3)); + + for (int i=0; i < arg0_length; ++i) { + + JSValue val = JS_GetPropertyUint32(ctx, argv[0], i); + + Vector3 * obj = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + + arg0[i] = *obj; + } + + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); + + + Color arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[2], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg2.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[2], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg2.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[2], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg2.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[2], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg2.a = (unsigned char)a_int; + } + else { + + Color * argptr2 = (Color *)JS_GetOpaque2(ctx, argv[2], js_Color_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + + DrawTriangleStrip3D(arg0, arg1, arg2); + + + if (arg0) + free(arg0); + + return JS_UNDEFINED; +} + +static JSValue js_DrawCube(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Vector3 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); + double arg3; + JS_ToFloat64(ctx, &arg3, argv[3]); + + + Color arg4; + + if (JS_IsArray(ctx, argv[4])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[4], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg4.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[4], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg4.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[4], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg4.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[4], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg4.a = (unsigned char)a_int; + } + else { + + Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); + + if (argptr4 == NULL) return JS_EXCEPTION; + + arg4 = *argptr4; + } + + DrawCube(arg0, arg1, arg2, arg3, arg4); + + + return JS_UNDEFINED; +} + +static JSValue js_DrawCubeV(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Vector3 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + + Vector3 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[1], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg1.z = (float)z_double; + } + else { + + Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + + Color arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[2], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg2.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[2], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg2.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[2], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg2.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[2], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg2.a = (unsigned char)a_int; + } + else { + + Color * argptr2 = (Color *)JS_GetOpaque2(ctx, argv[2], js_Color_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + + DrawCubeV(arg0, arg1, arg2); + + + return JS_UNDEFINED; +} + +static JSValue js_DrawCubeWires(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Vector3 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); + double arg3; + JS_ToFloat64(ctx, &arg3, argv[3]); + + + Color arg4; + + if (JS_IsArray(ctx, argv[4])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[4], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg4.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[4], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg4.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[4], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg4.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[4], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg4.a = (unsigned char)a_int; + } + else { + + Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); + + if (argptr4 == NULL) return JS_EXCEPTION; + + arg4 = *argptr4; + } + + DrawCubeWires(arg0, arg1, arg2, arg3, arg4); + + + return JS_UNDEFINED; +} + +static JSValue js_DrawCubeWiresV(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Vector3 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + + Vector3 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[1], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg1.z = (float)z_double; + } + else { + + Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + + Color arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[2], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg2.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[2], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg2.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[2], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg2.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[2], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg2.a = (unsigned char)a_int; + } + else { + + Color * argptr2 = (Color *)JS_GetOpaque2(ctx, argv[2], js_Color_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + + DrawCubeWiresV(arg0, arg1, arg2); + + + return JS_UNDEFINED; +} + +static JSValue js_DrawSphere(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Vector3 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + + + Color arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[2], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg2.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[2], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg2.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[2], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg2.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[2], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg2.a = (unsigned char)a_int; + } + else { + + Color * argptr2 = (Color *)JS_GetOpaque2(ctx, argv[2], js_Color_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + + DrawSphere(arg0, arg1, arg2); + + + return JS_UNDEFINED; +} + +static JSValue js_DrawSphereEx(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Vector3 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + int arg2; + JS_ToInt32(ctx, &arg2, argv[2]); + int arg3; + JS_ToInt32(ctx, &arg3, argv[3]); + + + Color arg4; + + if (JS_IsArray(ctx, argv[4])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[4], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg4.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[4], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg4.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[4], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg4.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[4], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg4.a = (unsigned char)a_int; + } + else { + + Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); + + if (argptr4 == NULL) return JS_EXCEPTION; + + arg4 = *argptr4; + } + + DrawSphereEx(arg0, arg1, arg2, arg3, arg4); + + + return JS_UNDEFINED; +} + +static JSValue js_DrawSphereWires(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Vector3 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + int arg2; + JS_ToInt32(ctx, &arg2, argv[2]); + int arg3; + JS_ToInt32(ctx, &arg3, argv[3]); + + + Color arg4; + + if (JS_IsArray(ctx, argv[4])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[4], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg4.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[4], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg4.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[4], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg4.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[4], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg4.a = (unsigned char)a_int; + } + else { + + Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); + + if (argptr4 == NULL) return JS_EXCEPTION; + + arg4 = *argptr4; + } + + DrawSphereWires(arg0, arg1, arg2, arg3, arg4); + + + return JS_UNDEFINED; +} + +static JSValue js_DrawCylinder(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Vector3 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); + double arg3; + JS_ToFloat64(ctx, &arg3, argv[3]); + int arg4; + JS_ToInt32(ctx, &arg4, argv[4]); + + + Color arg5; + + if (JS_IsArray(ctx, argv[5])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[5], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg5.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[5], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg5.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[5], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg5.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[5], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg5.a = (unsigned char)a_int; + } + else { + + Color * argptr5 = (Color *)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); + + if (argptr5 == NULL) return JS_EXCEPTION; + + arg5 = *argptr5; + } + + DrawCylinder(arg0, arg1, arg2, arg3, arg4, arg5); + + + return JS_UNDEFINED; +} + +static JSValue js_DrawCylinderEx(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Vector3 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + + Vector3 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[1], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg1.z = (float)z_double; + } + else { + + Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); + double arg3; + JS_ToFloat64(ctx, &arg3, argv[3]); + int arg4; + JS_ToInt32(ctx, &arg4, argv[4]); + + + Color arg5; + + if (JS_IsArray(ctx, argv[5])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[5], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg5.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[5], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg5.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[5], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg5.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[5], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg5.a = (unsigned char)a_int; + } + else { + + Color * argptr5 = (Color *)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); + + if (argptr5 == NULL) return JS_EXCEPTION; + + arg5 = *argptr5; + } + + DrawCylinderEx(arg0, arg1, arg2, arg3, arg4, arg5); + + + return JS_UNDEFINED; +} + +static JSValue js_DrawCylinderWires(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Vector3 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); + double arg3; + JS_ToFloat64(ctx, &arg3, argv[3]); + int arg4; + JS_ToInt32(ctx, &arg4, argv[4]); + + + Color arg5; + + if (JS_IsArray(ctx, argv[5])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[5], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg5.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[5], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg5.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[5], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg5.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[5], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg5.a = (unsigned char)a_int; + } + else { + + Color * argptr5 = (Color *)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); + + if (argptr5 == NULL) return JS_EXCEPTION; + + arg5 = *argptr5; + } + + DrawCylinderWires(arg0, arg1, arg2, arg3, arg4, arg5); + + + return JS_UNDEFINED; +} + +static JSValue js_DrawCylinderWiresEx(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Vector3 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + + Vector3 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[1], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg1.z = (float)z_double; + } + else { + + Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); + double arg3; + JS_ToFloat64(ctx, &arg3, argv[3]); + int arg4; + JS_ToInt32(ctx, &arg4, argv[4]); + + + Color arg5; + + if (JS_IsArray(ctx, argv[5])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[5], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg5.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[5], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg5.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[5], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg5.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[5], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg5.a = (unsigned char)a_int; + } + else { + + Color * argptr5 = (Color *)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); + + if (argptr5 == NULL) return JS_EXCEPTION; + + arg5 = *argptr5; + } + + DrawCylinderWiresEx(arg0, arg1, arg2, arg3, arg4, arg5); + + + return JS_UNDEFINED; +} + +static JSValue js_DrawCapsule(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Vector3 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + + Vector3 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[1], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg1.z = (float)z_double; + } + else { + + Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); + int arg3; + JS_ToInt32(ctx, &arg3, argv[3]); + int arg4; + JS_ToInt32(ctx, &arg4, argv[4]); + + + Color arg5; + + if (JS_IsArray(ctx, argv[5])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[5], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg5.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[5], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg5.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[5], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg5.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[5], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg5.a = (unsigned char)a_int; + } + else { + + Color * argptr5 = (Color *)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); + + if (argptr5 == NULL) return JS_EXCEPTION; + + arg5 = *argptr5; + } + + DrawCapsule(arg0, arg1, arg2, arg3, arg4, arg5); + + + return JS_UNDEFINED; +} + +static JSValue js_DrawCapsuleWires(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Vector3 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + + Vector3 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[1], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg1.z = (float)z_double; + } + else { + + Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); + int arg3; + JS_ToInt32(ctx, &arg3, argv[3]); + int arg4; + JS_ToInt32(ctx, &arg4, argv[4]); + + + Color arg5; + + if (JS_IsArray(ctx, argv[5])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[5], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg5.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[5], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg5.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[5], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg5.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[5], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg5.a = (unsigned char)a_int; + } + else { + + Color * argptr5 = (Color *)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); + + if (argptr5 == NULL) return JS_EXCEPTION; + + arg5 = *argptr5; + } + + DrawCapsuleWires(arg0, arg1, arg2, arg3, arg4, arg5); + + + return JS_UNDEFINED; +} + +static JSValue js_DrawPlane(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Vector3 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + + Vector2 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + } + else { + + Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + + Color arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[2], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg2.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[2], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg2.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[2], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg2.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[2], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg2.a = (unsigned char)a_int; + } + else { + + Color * argptr2 = (Color *)JS_GetOpaque2(ctx, argv[2], js_Color_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + + DrawPlane(arg0, arg1, arg2); + + + return JS_UNDEFINED; +} + +static JSValue js_DrawRay(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Ray * argptr0 = (Ray *)JS_GetOpaque2(ctx, argv[0], js_Ray_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Ray arg0 = *argptr0; + + + Color arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[1], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg1.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[1], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg1.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[1], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg1.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[1], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg1.a = (unsigned char)a_int; + } + else { + + Color * argptr1 = (Color *)JS_GetOpaque2(ctx, argv[1], js_Color_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + DrawRay(arg0, arg1); + + + return JS_UNDEFINED; +} + +static JSValue js_DrawGrid(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + int arg0; + JS_ToInt32(ctx, &arg0, argv[0]); + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + + DrawGrid(arg0, arg1); + + + return JS_UNDEFINED; +} + +static JSValue js_LoadModel(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); + + Model returnVal = LoadModel(arg0); + + JS_FreeCString(ctx, arg0); + + + Model* ret_ptr = (Model *)js_malloc(ctx, sizeof(Model)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Model_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_LoadModelFromMesh(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Mesh * argptr0 = (Mesh *)JS_GetOpaque2(ctx, argv[0], js_Mesh_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Mesh arg0 = *argptr0; + + Model returnVal = LoadModelFromMesh(arg0); + + + + Model* ret_ptr = (Model *)js_malloc(ctx, sizeof(Model)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Model_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_IsModelReady(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Model * argptr0 = (Model *)JS_GetOpaque2(ctx, argv[0], js_Model_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Model arg0 = *argptr0; + + bool ret = IsModelReady(arg0); + + + return JS_NewBool(ctx, ret); +} + +static JSValue js_UnloadModel(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Model * argptr0 = (Model *)JS_GetOpaque2(ctx, argv[0], js_Model_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Model arg0 = *argptr0; + + UnloadModel(arg0); + + + return JS_UNDEFINED; +} + +static JSValue js_GetModelBoundingBox(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Model * argptr0 = (Model *)JS_GetOpaque2(ctx, argv[0], js_Model_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Model arg0 = *argptr0; + + BoundingBox returnVal = GetModelBoundingBox(arg0); + + + + BoundingBox* ret_ptr = (BoundingBox *)js_malloc(ctx, sizeof(BoundingBox)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_BoundingBox_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_DrawModel(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Model * argptr0 = (Model *)JS_GetOpaque2(ctx, argv[0], js_Model_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Model arg0 = *argptr0; + + + Vector3 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[1], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg1.z = (float)z_double; + } + else { + + Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); + + + Color arg3; + + if (JS_IsArray(ctx, argv[3])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[3], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg3.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[3], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg3.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[3], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg3.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[3], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg3.a = (unsigned char)a_int; + } + else { + + Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); + + if (argptr3 == NULL) return JS_EXCEPTION; + + arg3 = *argptr3; + } + + DrawModel(arg0, arg1, arg2, arg3); + + + return JS_UNDEFINED; +} + +static JSValue js_DrawModelEx(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Model * argptr0 = (Model *)JS_GetOpaque2(ctx, argv[0], js_Model_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Model arg0 = *argptr0; + + + Vector3 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[1], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg1.z = (float)z_double; + } + else { + + Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + + Vector3 arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[2], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg2.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[2], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg2.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[2], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg2.z = (float)z_double; + } + else { + + Vector3 * argptr2 = (Vector3 *)JS_GetOpaque2(ctx, argv[2], js_Vector3_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + double arg3; + JS_ToFloat64(ctx, &arg3, argv[3]); + + + Vector3 arg4; + + if (JS_IsArray(ctx, argv[4])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[4], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg4.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[4], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg4.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[4], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg4.z = (float)z_double; + } + else { + + Vector3 * argptr4 = (Vector3 *)JS_GetOpaque2(ctx, argv[4], js_Vector3_class_id); + + if (argptr4 == NULL) return JS_EXCEPTION; + + arg4 = *argptr4; + } + + + Color arg5; + + if (JS_IsArray(ctx, argv[5])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[5], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg5.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[5], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg5.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[5], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg5.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[5], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg5.a = (unsigned char)a_int; + } + else { + + Color * argptr5 = (Color *)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); + + if (argptr5 == NULL) return JS_EXCEPTION; + + arg5 = *argptr5; + } + + DrawModelEx(arg0, arg1, arg2, arg3, arg4, arg5); + + + return JS_UNDEFINED; +} + +static JSValue js_DrawModelWires(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Model * argptr0 = (Model *)JS_GetOpaque2(ctx, argv[0], js_Model_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Model arg0 = *argptr0; + + + Vector3 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[1], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg1.z = (float)z_double; + } + else { + + Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); + + + Color arg3; + + if (JS_IsArray(ctx, argv[3])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[3], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg3.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[3], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg3.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[3], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg3.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[3], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg3.a = (unsigned char)a_int; + } + else { + + Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); + + if (argptr3 == NULL) return JS_EXCEPTION; + + arg3 = *argptr3; + } + + DrawModelWires(arg0, arg1, arg2, arg3); + + + return JS_UNDEFINED; +} + +static JSValue js_DrawModelWiresEx(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Model * argptr0 = (Model *)JS_GetOpaque2(ctx, argv[0], js_Model_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Model arg0 = *argptr0; + + + Vector3 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[1], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg1.z = (float)z_double; + } + else { + + Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + + Vector3 arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[2], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg2.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[2], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg2.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[2], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg2.z = (float)z_double; + } + else { + + Vector3 * argptr2 = (Vector3 *)JS_GetOpaque2(ctx, argv[2], js_Vector3_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + double arg3; + JS_ToFloat64(ctx, &arg3, argv[3]); + + + Vector3 arg4; + + if (JS_IsArray(ctx, argv[4])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[4], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg4.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[4], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg4.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[4], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg4.z = (float)z_double; + } + else { + + Vector3 * argptr4 = (Vector3 *)JS_GetOpaque2(ctx, argv[4], js_Vector3_class_id); + + if (argptr4 == NULL) return JS_EXCEPTION; + + arg4 = *argptr4; + } + + + Color arg5; + + if (JS_IsArray(ctx, argv[5])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[5], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg5.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[5], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg5.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[5], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg5.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[5], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg5.a = (unsigned char)a_int; + } + else { + + Color * argptr5 = (Color *)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); + + if (argptr5 == NULL) return JS_EXCEPTION; + + arg5 = *argptr5; + } + + DrawModelWiresEx(arg0, arg1, arg2, arg3, arg4, arg5); + + + return JS_UNDEFINED; +} + +static JSValue js_DrawBoundingBox(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + BoundingBox * argptr0 = (BoundingBox *)JS_GetOpaque2(ctx, argv[0], js_BoundingBox_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + BoundingBox arg0 = *argptr0; + + + Color arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[1], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg1.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[1], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg1.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[1], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg1.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[1], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg1.a = (unsigned char)a_int; + } + else { + + Color * argptr1 = (Color *)JS_GetOpaque2(ctx, argv[1], js_Color_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + DrawBoundingBox(arg0, arg1); + + + return JS_UNDEFINED; +} + +static JSValue js_DrawBillboard(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Camera * argptr0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera_class_id); + if (argptr0 == NULL) + argptr0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera3D_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Camera arg0 = *argptr0; + Texture2D * argptr1 = (Texture2D *)JS_GetOpaque2(ctx, argv[1], js_Texture2D_class_id); + if (argptr1 == NULL) + argptr1 = (Texture2D *)JS_GetOpaque2(ctx, argv[1], js_Texture_class_id); + if (argptr1 == NULL) return JS_EXCEPTION; + + Texture2D arg1 = *argptr1; + + + Vector3 arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[2], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg2.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[2], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg2.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[2], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg2.z = (float)z_double; + } + else { + + Vector3 * argptr2 = (Vector3 *)JS_GetOpaque2(ctx, argv[2], js_Vector3_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + double arg3; + JS_ToFloat64(ctx, &arg3, argv[3]); + + + Color arg4; + + if (JS_IsArray(ctx, argv[4])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[4], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg4.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[4], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg4.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[4], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg4.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[4], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg4.a = (unsigned char)a_int; + } + else { + + Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); + + if (argptr4 == NULL) return JS_EXCEPTION; + + arg4 = *argptr4; + } + + DrawBillboard(arg0, arg1, arg2, arg3, arg4); + + + return JS_UNDEFINED; +} + +static JSValue js_DrawBillboardRec(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Camera * argptr0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera_class_id); + if (argptr0 == NULL) + argptr0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera3D_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Camera arg0 = *argptr0; + Texture2D * argptr1 = (Texture2D *)JS_GetOpaque2(ctx, argv[1], js_Texture2D_class_id); + if (argptr1 == NULL) + argptr1 = (Texture2D *)JS_GetOpaque2(ctx, argv[1], js_Texture_class_id); + if (argptr1 == NULL) return JS_EXCEPTION; + + Texture2D arg1 = *argptr1; + + + Rectangle arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[2], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg2.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[2], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg2.y = (float)y_double; + + JSValue w = JS_GetPropertyUint32(ctx, argv[2], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg2.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[2], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg2.height = (float)h_double; + } + else { + + Rectangle * argptr2 = (Rectangle *)JS_GetOpaque2(ctx, argv[2], js_Rectangle_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + + + Vector3 arg3; + + if (JS_IsArray(ctx, argv[3])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[3], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg3.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[3], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg3.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[3], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg3.z = (float)z_double; + } + else { + + Vector3 * argptr3 = (Vector3 *)JS_GetOpaque2(ctx, argv[3], js_Vector3_class_id); + + if (argptr3 == NULL) return JS_EXCEPTION; + + arg3 = *argptr3; + } + + + Vector2 arg4; + + if (JS_IsArray(ctx, argv[4])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[4], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg4.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[4], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg4.y = (float)y_double; + } + else { + + Vector2 * argptr4 = (Vector2 *)JS_GetOpaque2(ctx, argv[4], js_Vector2_class_id); + + if (argptr4 == NULL) return JS_EXCEPTION; + + arg4 = *argptr4; + } + + + Color arg5; + + if (JS_IsArray(ctx, argv[5])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[5], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg5.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[5], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg5.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[5], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg5.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[5], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg5.a = (unsigned char)a_int; + } + else { + + Color * argptr5 = (Color *)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); + + if (argptr5 == NULL) return JS_EXCEPTION; + + arg5 = *argptr5; + } + + DrawBillboardRec(arg0, arg1, arg2, arg3, arg4, arg5); + + + return JS_UNDEFINED; +} + +static JSValue js_DrawBillboardPro(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Camera * argptr0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera_class_id); + if (argptr0 == NULL) + argptr0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera3D_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Camera arg0 = *argptr0; + Texture2D * argptr1 = (Texture2D *)JS_GetOpaque2(ctx, argv[1], js_Texture2D_class_id); + if (argptr1 == NULL) + argptr1 = (Texture2D *)JS_GetOpaque2(ctx, argv[1], js_Texture_class_id); + if (argptr1 == NULL) return JS_EXCEPTION; + + Texture2D arg1 = *argptr1; + + + Rectangle arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[2], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg2.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[2], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg2.y = (float)y_double; + + JSValue w = JS_GetPropertyUint32(ctx, argv[2], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg2.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[2], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg2.height = (float)h_double; + } + else { + + Rectangle * argptr2 = (Rectangle *)JS_GetOpaque2(ctx, argv[2], js_Rectangle_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + + + Vector3 arg3; + + if (JS_IsArray(ctx, argv[3])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[3], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg3.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[3], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg3.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[3], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg3.z = (float)z_double; + } + else { + + Vector3 * argptr3 = (Vector3 *)JS_GetOpaque2(ctx, argv[3], js_Vector3_class_id); + + if (argptr3 == NULL) return JS_EXCEPTION; + + arg3 = *argptr3; + } + + + Vector3 arg4; + + if (JS_IsArray(ctx, argv[4])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[4], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg4.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[4], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg4.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[4], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg4.z = (float)z_double; + } + else { + + Vector3 * argptr4 = (Vector3 *)JS_GetOpaque2(ctx, argv[4], js_Vector3_class_id); + + if (argptr4 == NULL) return JS_EXCEPTION; + + arg4 = *argptr4; + } + + + Vector2 arg5; + + if (JS_IsArray(ctx, argv[5])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[5], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg5.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[5], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg5.y = (float)y_double; + } + else { + + Vector2 * argptr5 = (Vector2 *)JS_GetOpaque2(ctx, argv[5], js_Vector2_class_id); + + if (argptr5 == NULL) return JS_EXCEPTION; + + arg5 = *argptr5; + } + + + Vector2 arg6; + + if (JS_IsArray(ctx, argv[6])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[6], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg6.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[6], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg6.y = (float)y_double; + } + else { + + Vector2 * argptr6 = (Vector2 *)JS_GetOpaque2(ctx, argv[6], js_Vector2_class_id); + + if (argptr6 == NULL) return JS_EXCEPTION; + + arg6 = *argptr6; + } + double arg7; + JS_ToFloat64(ctx, &arg7, argv[7]); + + + Color arg8; + + if (JS_IsArray(ctx, argv[8])) { + + JSValue r = JS_GetPropertyUint32(ctx, argv[8], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg8.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[8], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg8.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[8], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg8.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[8], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg8.a = (unsigned char)a_int; + } + else { + + Color * argptr8 = (Color *)JS_GetOpaque2(ctx, argv[8], js_Color_class_id); + + if (argptr8 == NULL) return JS_EXCEPTION; + + arg8 = *argptr8; + } + + DrawBillboardPro(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); + + + return JS_UNDEFINED; +} + +static JSValue js_UploadMesh(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Mesh * arg0 = (Mesh *)JS_GetOpaque2(ctx, argv[0], js_Mesh_class_id); + JS_BOOL argbool1 = JS_ToBool(ctx, argv[1]); + bool arg1 = (bool) argbool1; + + UploadMesh(arg0, arg1); + + + return JS_UNDEFINED; +} + +static JSValue js_UpdateMeshBuffer(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Mesh * argptr0 = (Mesh *)JS_GetOpaque2(ctx, argv[0], js_Mesh_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Mesh arg0 = *argptr0; + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); +size_t data_size2; + const void * arg2 = (const void *)JS_GetArrayBuffer(ctx, &data_size2, argv[2]); + int arg3; + JS_ToInt32(ctx, &arg3, argv[3]); + int arg4; + JS_ToInt32(ctx, &arg4, argv[4]); + + UpdateMeshBuffer(arg0, arg1, arg2, arg3, arg4); + + + return JS_UNDEFINED; +} + +static JSValue js_UnloadMesh(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Mesh * argptr0 = (Mesh *)JS_GetOpaque2(ctx, argv[0], js_Mesh_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Mesh arg0 = *argptr0; + + UnloadMesh(arg0); + + + return JS_UNDEFINED; +} + +static JSValue js_DrawMesh(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Mesh * argptr0 = (Mesh *)JS_GetOpaque2(ctx, argv[0], js_Mesh_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Mesh arg0 = *argptr0; + Material * argptr1 = (Material *)JS_GetOpaque2(ctx, argv[1], js_Material_class_id); + if (argptr1 == NULL) return JS_EXCEPTION; + + Material arg1 = *argptr1; + Matrix * argptr2 = (Matrix *)JS_GetOpaque2(ctx, argv[2], js_Matrix_class_id); + if (argptr2 == NULL) return JS_EXCEPTION; + + Matrix arg2 = *argptr2; + + DrawMesh(arg0, arg1, arg2); + + + return JS_UNDEFINED; +} + +static JSValue js_DrawMeshInstanced(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Mesh * argptr0 = (Mesh *)JS_GetOpaque2(ctx, argv[0], js_Mesh_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Mesh arg0 = *argptr0; + Material * argptr1 = (Material *)JS_GetOpaque2(ctx, argv[1], js_Material_class_id); + if (argptr1 == NULL) return JS_EXCEPTION; + + Material arg1 = *argptr1; + + + JSValue arg2_length_js = JS_GetProperty(ctx, argv[2], JS_ATOM_length); + + int32_t arg2_length; + + JS_ToInt32(ctx, &arg2_length, arg2_length_js); + + Matrix * arg2 = (Matrix *)malloc(arg2_length*sizeof(Matrix)); + + for (int i=0; i < arg2_length; ++i) { + + JSValue val = JS_GetPropertyUint32(ctx, argv[2], i); + + Matrix * obj = (Matrix *)JS_GetOpaque2(ctx, argv[2], js_Matrix_class_id); + + arg2[i] = *obj; + } + + int arg3; + JS_ToInt32(ctx, &arg3, argv[3]); + + DrawMeshInstanced(arg0, arg1, arg2, arg3); + + + if (arg2) + free(arg2); + + return JS_UNDEFINED; +} + +static JSValue js_ExportMesh(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Mesh * argptr0 = (Mesh *)JS_GetOpaque2(ctx, argv[0], js_Mesh_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Mesh arg0 = *argptr0; + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); + + bool ret = ExportMesh(arg0, arg1); + + JS_FreeCString(ctx, arg1); + + return JS_NewBool(ctx, ret); +} + +static JSValue js_GetMeshBoundingBox(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Mesh * argptr0 = (Mesh *)JS_GetOpaque2(ctx, argv[0], js_Mesh_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Mesh arg0 = *argptr0; + + BoundingBox returnVal = GetMeshBoundingBox(arg0); + + + + BoundingBox* ret_ptr = (BoundingBox *)js_malloc(ctx, sizeof(BoundingBox)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_BoundingBox_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_GenMeshTangents(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Mesh * arg0 = (Mesh *)JS_GetOpaque2(ctx, argv[0], js_Mesh_class_id); + + GenMeshTangents(arg0); + + + return JS_UNDEFINED; +} + +static JSValue js_GenMeshPoly(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + int arg0; + JS_ToInt32(ctx, &arg0, argv[0]); + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + + Mesh returnVal = GenMeshPoly(arg0, arg1); + + + + Mesh* ret_ptr = (Mesh *)js_malloc(ctx, sizeof(Mesh)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Mesh_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_GenMeshPlane(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + double arg0; + JS_ToFloat64(ctx, &arg0, argv[0]); + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + int arg2; + JS_ToInt32(ctx, &arg2, argv[2]); + int arg3; + JS_ToInt32(ctx, &arg3, argv[3]); + + Mesh returnVal = GenMeshPlane(arg0, arg1, arg2, arg3); + + + + Mesh* ret_ptr = (Mesh *)js_malloc(ctx, sizeof(Mesh)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Mesh_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_GenMeshCube(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + double arg0; + JS_ToFloat64(ctx, &arg0, argv[0]); + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); + + Mesh returnVal = GenMeshCube(arg0, arg1, arg2); + + + + Mesh* ret_ptr = (Mesh *)js_malloc(ctx, sizeof(Mesh)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Mesh_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_GenMeshSphere(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + double arg0; + JS_ToFloat64(ctx, &arg0, argv[0]); + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); + int arg2; + JS_ToInt32(ctx, &arg2, argv[2]); + + Mesh returnVal = GenMeshSphere(arg0, arg1, arg2); + + + + Mesh* ret_ptr = (Mesh *)js_malloc(ctx, sizeof(Mesh)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Mesh_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_GenMeshHemiSphere(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + double arg0; + JS_ToFloat64(ctx, &arg0, argv[0]); + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); + int arg2; + JS_ToInt32(ctx, &arg2, argv[2]); + + Mesh returnVal = GenMeshHemiSphere(arg0, arg1, arg2); + + + + Mesh* ret_ptr = (Mesh *)js_malloc(ctx, sizeof(Mesh)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Mesh_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_GenMeshCylinder(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + double arg0; + JS_ToFloat64(ctx, &arg0, argv[0]); + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + int arg2; + JS_ToInt32(ctx, &arg2, argv[2]); + + Mesh returnVal = GenMeshCylinder(arg0, arg1, arg2); + + + + Mesh* ret_ptr = (Mesh *)js_malloc(ctx, sizeof(Mesh)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Mesh_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_GenMeshCone(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + double arg0; + JS_ToFloat64(ctx, &arg0, argv[0]); + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + int arg2; + JS_ToInt32(ctx, &arg2, argv[2]); + + Mesh returnVal = GenMeshCone(arg0, arg1, arg2); + + + + Mesh* ret_ptr = (Mesh *)js_malloc(ctx, sizeof(Mesh)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Mesh_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_GenMeshTorus(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + double arg0; + JS_ToFloat64(ctx, &arg0, argv[0]); + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + int arg2; + JS_ToInt32(ctx, &arg2, argv[2]); + int arg3; + JS_ToInt32(ctx, &arg3, argv[3]); + + Mesh returnVal = GenMeshTorus(arg0, arg1, arg2, arg3); + + + + Mesh* ret_ptr = (Mesh *)js_malloc(ctx, sizeof(Mesh)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Mesh_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_GenMeshKnot(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + double arg0; + JS_ToFloat64(ctx, &arg0, argv[0]); + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + int arg2; + JS_ToInt32(ctx, &arg2, argv[2]); + int arg3; + JS_ToInt32(ctx, &arg3, argv[3]); + + Mesh returnVal = GenMeshKnot(arg0, arg1, arg2, arg3); + + + + Mesh* ret_ptr = (Mesh *)js_malloc(ctx, sizeof(Mesh)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Mesh_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_GenMeshHeightmap(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Image * argptr0 = (Image *)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Image arg0 = *argptr0; + + + Vector3 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[1], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg1.z = (float)z_double; + } + else { + + Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + Mesh returnVal = GenMeshHeightmap(arg0, arg1); + + + + Mesh* ret_ptr = (Mesh *)js_malloc(ctx, sizeof(Mesh)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Mesh_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_GenMeshCubicmap(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Image * argptr0 = (Image *)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Image arg0 = *argptr0; + + + Vector3 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[1], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg1.z = (float)z_double; + } + else { + + Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + Mesh returnVal = GenMeshCubicmap(arg0, arg1); + + + + Mesh* ret_ptr = (Mesh *)js_malloc(ctx, sizeof(Mesh)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Mesh_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_LoadMaterials(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); + + JSValue arg1_js = JS_GetPropertyStr(ctx, argv[1], "materialCount"); + int arg1; + JS_ToInt32(ctx, &arg1, arg1_js); + + Material * materials = LoadMaterials(arg0, &arg1); + + // TODO: how to do the unloading ? + + JS_FreeCString(ctx, arg0); + + JSValue ret = JS_NewArray(ctx); + + for(int i = 0; i < arg1; i++) { + + JSValue obj = JS_NewObjectClass(ctx, js_Material_class_id); + + JS_SetOpaque(obj, &materials[i]); + + JS_SetPropertyUint32(ctx, ret, i, obj); + } + + return ret; + + +} + +static JSValue js_LoadMaterialDefault(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + Material returnVal = LoadMaterialDefault(); + + + + Material* ret_ptr = (Material *)js_malloc(ctx, sizeof(Material)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Material_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_IsMaterialReady(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Material * argptr0 = (Material *)JS_GetOpaque2(ctx, argv[0], js_Material_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Material arg0 = *argptr0; + + bool ret = IsMaterialReady(arg0); + + + return JS_NewBool(ctx, ret); +} + +static JSValue js_UnloadMaterial(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Material * argptr0 = (Material *)JS_GetOpaque2(ctx, argv[0], js_Material_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Material arg0 = *argptr0; + + UnloadMaterial(arg0); + + + return JS_UNDEFINED; +} + +static JSValue js_SetMaterialTexture(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Material * arg0 = (Material *)JS_GetOpaque2(ctx, argv[0], js_Material_class_id); + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); + Texture2D * argptr2 = (Texture2D *)JS_GetOpaque2(ctx, argv[2], js_Texture2D_class_id); + if (argptr2 == NULL) + argptr2 = (Texture2D *)JS_GetOpaque2(ctx, argv[2], js_Texture_class_id); + if (argptr2 == NULL) return JS_EXCEPTION; + + Texture2D arg2 = *argptr2; + + SetMaterialTexture(arg0, arg1, arg2); + + + return JS_UNDEFINED; +} + +static JSValue js_SetModelMeshMaterial(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Model * arg0 = (Model *)JS_GetOpaque2(ctx, argv[0], js_Model_class_id); + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); + int arg2; + JS_ToInt32(ctx, &arg2, argv[2]); + + SetModelMeshMaterial(arg0, arg1, arg2); + + + return JS_UNDEFINED; +} + +static JSValue js_UpdateModelAnimation(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Model * argptr0 = (Model *)JS_GetOpaque2(ctx, argv[0], js_Model_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Model arg0 = *argptr0; + ModelAnimation * argptr1 = (ModelAnimation *)JS_GetOpaque2(ctx, argv[1], js_ModelAnimation_class_id); + if (argptr1 == NULL) return JS_EXCEPTION; + + ModelAnimation arg1 = *argptr1; + int arg2; + JS_ToInt32(ctx, &arg2, argv[2]); + + UpdateModelAnimation(arg0, arg1, arg2); + + + return JS_UNDEFINED; +} + +static JSValue js_UnloadModelAnimation(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + ModelAnimation * argptr0 = (ModelAnimation *)JS_GetOpaque2(ctx, argv[0], js_ModelAnimation_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + ModelAnimation arg0 = *argptr0; + + UnloadModelAnimation(arg0); + + + return JS_UNDEFINED; +} + +static JSValue js_IsModelAnimationValid(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Model * argptr0 = (Model *)JS_GetOpaque2(ctx, argv[0], js_Model_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Model arg0 = *argptr0; + ModelAnimation * argptr1 = (ModelAnimation *)JS_GetOpaque2(ctx, argv[1], js_ModelAnimation_class_id); + if (argptr1 == NULL) return JS_EXCEPTION; + + ModelAnimation arg1 = *argptr1; + + bool ret = IsModelAnimationValid(arg0, arg1); + + + return JS_NewBool(ctx, ret); +} + +static JSValue js_CheckCollisionSpheres(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + + Vector3 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + + + Vector3 arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[2], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg2.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[2], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg2.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[2], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg2.z = (float)z_double; + } + else { + + Vector3 * argptr2 = (Vector3 *)JS_GetOpaque2(ctx, argv[2], js_Vector3_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + double arg3; + JS_ToFloat64(ctx, &arg3, argv[3]); + + bool ret = CheckCollisionSpheres(arg0, arg1, arg2, arg3); + + + return JS_NewBool(ctx, ret); +} + +static JSValue js_CheckCollisionBoxes(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + BoundingBox * argptr0 = (BoundingBox *)JS_GetOpaque2(ctx, argv[0], js_BoundingBox_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + BoundingBox arg0 = *argptr0; + BoundingBox * argptr1 = (BoundingBox *)JS_GetOpaque2(ctx, argv[1], js_BoundingBox_class_id); + if (argptr1 == NULL) return JS_EXCEPTION; + + BoundingBox arg1 = *argptr1; + + bool ret = CheckCollisionBoxes(arg0, arg1); + + + return JS_NewBool(ctx, ret); +} + +static JSValue js_CheckCollisionBoxSphere(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + BoundingBox * argptr0 = (BoundingBox *)JS_GetOpaque2(ctx, argv[0], js_BoundingBox_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + BoundingBox arg0 = *argptr0; + + + Vector3 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[1], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg1.z = (float)z_double; + } + else { + + Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); + + bool ret = CheckCollisionBoxSphere(arg0, arg1, arg2); + + + return JS_NewBool(ctx, ret); +} + +static JSValue js_GetRayCollisionSphere(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Ray * argptr0 = (Ray *)JS_GetOpaque2(ctx, argv[0], js_Ray_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Ray arg0 = *argptr0; + + + Vector3 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[1], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg1.z = (float)z_double; + } + else { + + Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); + + RayCollision returnVal = GetRayCollisionSphere(arg0, arg1, arg2); + + + + RayCollision* ret_ptr = (RayCollision *)js_malloc(ctx, sizeof(RayCollision)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_RayCollision_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_GetRayCollisionBox(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Ray * argptr0 = (Ray *)JS_GetOpaque2(ctx, argv[0], js_Ray_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Ray arg0 = *argptr0; + BoundingBox * argptr1 = (BoundingBox *)JS_GetOpaque2(ctx, argv[1], js_BoundingBox_class_id); + if (argptr1 == NULL) return JS_EXCEPTION; + + BoundingBox arg1 = *argptr1; + + RayCollision returnVal = GetRayCollisionBox(arg0, arg1); + + + + RayCollision* ret_ptr = (RayCollision *)js_malloc(ctx, sizeof(RayCollision)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_RayCollision_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_GetRayCollisionMesh(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Ray * argptr0 = (Ray *)JS_GetOpaque2(ctx, argv[0], js_Ray_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Ray arg0 = *argptr0; + Mesh * argptr1 = (Mesh *)JS_GetOpaque2(ctx, argv[1], js_Mesh_class_id); + if (argptr1 == NULL) return JS_EXCEPTION; + + Mesh arg1 = *argptr1; + Matrix * argptr2 = (Matrix *)JS_GetOpaque2(ctx, argv[2], js_Matrix_class_id); + if (argptr2 == NULL) return JS_EXCEPTION; + + Matrix arg2 = *argptr2; + + RayCollision returnVal = GetRayCollisionMesh(arg0, arg1, arg2); + + + + RayCollision* ret_ptr = (RayCollision *)js_malloc(ctx, sizeof(RayCollision)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_RayCollision_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_GetRayCollisionTriangle(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Ray * argptr0 = (Ray *)JS_GetOpaque2(ctx, argv[0], js_Ray_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Ray arg0 = *argptr0; + + + Vector3 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[1], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg1.z = (float)z_double; + } + else { + + Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + + Vector3 arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[2], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg2.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[2], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg2.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[2], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg2.z = (float)z_double; + } + else { + + Vector3 * argptr2 = (Vector3 *)JS_GetOpaque2(ctx, argv[2], js_Vector3_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + + + Vector3 arg3; + + if (JS_IsArray(ctx, argv[3])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[3], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg3.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[3], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg3.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[3], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg3.z = (float)z_double; + } + else { + + Vector3 * argptr3 = (Vector3 *)JS_GetOpaque2(ctx, argv[3], js_Vector3_class_id); + + if (argptr3 == NULL) return JS_EXCEPTION; + + arg3 = *argptr3; + } + + RayCollision returnVal = GetRayCollisionTriangle(arg0, arg1, arg2, arg3); + + + + RayCollision* ret_ptr = (RayCollision *)js_malloc(ctx, sizeof(RayCollision)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_RayCollision_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_GetRayCollisionQuad(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Ray * argptr0 = (Ray *)JS_GetOpaque2(ctx, argv[0], js_Ray_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Ray arg0 = *argptr0; + + + Vector3 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[1], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg1.z = (float)z_double; + } + else { + + Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + + Vector3 arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[2], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg2.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[2], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg2.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[2], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg2.z = (float)z_double; + } + else { + + Vector3 * argptr2 = (Vector3 *)JS_GetOpaque2(ctx, argv[2], js_Vector3_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + + + Vector3 arg3; + + if (JS_IsArray(ctx, argv[3])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[3], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg3.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[3], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg3.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[3], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg3.z = (float)z_double; + } + else { + + Vector3 * argptr3 = (Vector3 *)JS_GetOpaque2(ctx, argv[3], js_Vector3_class_id); + + if (argptr3 == NULL) return JS_EXCEPTION; + + arg3 = *argptr3; + } + + + Vector3 arg4; + + if (JS_IsArray(ctx, argv[4])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[4], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg4.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[4], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg4.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[4], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg4.z = (float)z_double; + } + else { + + Vector3 * argptr4 = (Vector3 *)JS_GetOpaque2(ctx, argv[4], js_Vector3_class_id); + + if (argptr4 == NULL) return JS_EXCEPTION; + + arg4 = *argptr4; + } + + RayCollision returnVal = GetRayCollisionQuad(arg0, arg1, arg2, arg3, arg4); + + + + RayCollision* ret_ptr = (RayCollision *)js_malloc(ctx, sizeof(RayCollision)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_RayCollision_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_InitAudioDevice(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + InitAudioDevice(); + + + return JS_UNDEFINED; +} + +static JSValue js_CloseAudioDevice(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + CloseAudioDevice(); + + + return JS_UNDEFINED; +} + +static JSValue js_IsAudioDeviceReady(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + bool ret = IsAudioDeviceReady(); + + + return JS_NewBool(ctx, ret); +} + +static JSValue js_SetMasterVolume(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + double arg0; + JS_ToFloat64(ctx, &arg0, argv[0]); + + SetMasterVolume(arg0); + + + return JS_UNDEFINED; +} + +static JSValue js_GetMasterVolume(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + float ret = GetMasterVolume(); + + + return JS_NewFloat64(ctx, ret); +} + +static JSValue js_LoadWave(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); + + Wave returnVal = LoadWave(arg0); + + JS_FreeCString(ctx, arg0); + + + Wave* ret_ptr = (Wave *)js_malloc(ctx, sizeof(Wave)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Wave_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_LoadWaveFromMemory(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); +size_t data_size1; + const unsigned char * arg1 = (const unsigned char *)JS_GetArrayBuffer(ctx, &data_size1, argv[1]); + int arg2; + JS_ToInt32(ctx, &arg2, argv[2]); + + Wave returnVal = LoadWaveFromMemory(arg0, arg1, arg2); + + JS_FreeCString(ctx, arg0); + + + Wave* ret_ptr = (Wave *)js_malloc(ctx, sizeof(Wave)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Wave_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_IsWaveReady(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Wave * argptr0 = (Wave *)JS_GetOpaque2(ctx, argv[0], js_Wave_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Wave arg0 = *argptr0; + + bool ret = IsWaveReady(arg0); + + + return JS_NewBool(ctx, ret); +} + +static JSValue js_LoadSound(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); + + Sound returnVal = LoadSound(arg0); + + JS_FreeCString(ctx, arg0); + + + Sound* ret_ptr = (Sound *)js_malloc(ctx, sizeof(Sound)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Sound_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_LoadSoundFromWave(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Wave * argptr0 = (Wave *)JS_GetOpaque2(ctx, argv[0], js_Wave_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Wave arg0 = *argptr0; + + Sound returnVal = LoadSoundFromWave(arg0); + + + + Sound* ret_ptr = (Sound *)js_malloc(ctx, sizeof(Sound)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Sound_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_LoadSoundAlias(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Sound * argptr0 = (Sound *)JS_GetOpaque2(ctx, argv[0], js_Sound_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Sound arg0 = *argptr0; + + Sound returnVal = LoadSoundAlias(arg0); + + + + Sound* ret_ptr = (Sound *)js_malloc(ctx, sizeof(Sound)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Sound_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_IsSoundReady(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Sound * argptr0 = (Sound *)JS_GetOpaque2(ctx, argv[0], js_Sound_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Sound arg0 = *argptr0; + + bool ret = IsSoundReady(arg0); + + + return JS_NewBool(ctx, ret); +} + +static JSValue js_UpdateSound(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Sound * argptr0 = (Sound *)JS_GetOpaque2(ctx, argv[0], js_Sound_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Sound arg0 = *argptr0; +size_t data_size1; + const void * arg1 = (const void *)JS_GetArrayBuffer(ctx, &data_size1, argv[1]); + int arg2; + JS_ToInt32(ctx, &arg2, argv[2]); + + UpdateSound(arg0, arg1, arg2); + + + return JS_UNDEFINED; +} + +static JSValue js_UnloadWave(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Wave * argptr0 = (Wave *)JS_GetOpaque2(ctx, argv[0], js_Wave_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Wave arg0 = *argptr0; + + UnloadWave(arg0); + + + return JS_UNDEFINED; +} + +static JSValue js_UnloadSound(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Sound * argptr0 = (Sound *)JS_GetOpaque2(ctx, argv[0], js_Sound_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Sound arg0 = *argptr0; + + UnloadSound(arg0); + + + return JS_UNDEFINED; +} + +static JSValue js_UnloadSoundAlias(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Sound * argptr0 = (Sound *)JS_GetOpaque2(ctx, argv[0], js_Sound_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Sound arg0 = *argptr0; + + UnloadSoundAlias(arg0); + + + return JS_UNDEFINED; +} + +static JSValue js_ExportWave(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Wave * argptr0 = (Wave *)JS_GetOpaque2(ctx, argv[0], js_Wave_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Wave arg0 = *argptr0; + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); + + bool ret = ExportWave(arg0, arg1); + + JS_FreeCString(ctx, arg1); + + return JS_NewBool(ctx, ret); +} + +static JSValue js_ExportWaveAsCode(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Wave * argptr0 = (Wave *)JS_GetOpaque2(ctx, argv[0], js_Wave_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Wave arg0 = *argptr0; + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); + + bool ret = ExportWaveAsCode(arg0, arg1); + + JS_FreeCString(ctx, arg1); + + return JS_NewBool(ctx, ret); +} + +static JSValue js_PlaySound(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Sound * argptr0 = (Sound *)JS_GetOpaque2(ctx, argv[0], js_Sound_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Sound arg0 = *argptr0; + + PlaySound(arg0); + + + return JS_UNDEFINED; +} + +static JSValue js_StopSound(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Sound * argptr0 = (Sound *)JS_GetOpaque2(ctx, argv[0], js_Sound_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Sound arg0 = *argptr0; + + StopSound(arg0); + + + return JS_UNDEFINED; +} + +static JSValue js_PauseSound(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Sound * argptr0 = (Sound *)JS_GetOpaque2(ctx, argv[0], js_Sound_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Sound arg0 = *argptr0; + + PauseSound(arg0); + + + return JS_UNDEFINED; +} + +static JSValue js_ResumeSound(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Sound * argptr0 = (Sound *)JS_GetOpaque2(ctx, argv[0], js_Sound_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Sound arg0 = *argptr0; + + ResumeSound(arg0); + + + return JS_UNDEFINED; +} + +static JSValue js_IsSoundPlaying(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Sound * argptr0 = (Sound *)JS_GetOpaque2(ctx, argv[0], js_Sound_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Sound arg0 = *argptr0; + + bool ret = IsSoundPlaying(arg0); + + + return JS_NewBool(ctx, ret); +} + +static JSValue js_SetSoundVolume(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Sound * argptr0 = (Sound *)JS_GetOpaque2(ctx, argv[0], js_Sound_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Sound arg0 = *argptr0; + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + + SetSoundVolume(arg0, arg1); + + + return JS_UNDEFINED; +} + +static JSValue js_SetSoundPitch(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Sound * argptr0 = (Sound *)JS_GetOpaque2(ctx, argv[0], js_Sound_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Sound arg0 = *argptr0; + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + + SetSoundPitch(arg0, arg1); + + + return JS_UNDEFINED; +} + +static JSValue js_SetSoundPan(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Sound * argptr0 = (Sound *)JS_GetOpaque2(ctx, argv[0], js_Sound_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Sound arg0 = *argptr0; + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + + SetSoundPan(arg0, arg1); + + + return JS_UNDEFINED; +} + +static JSValue js_WaveCopy(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Wave * argptr0 = (Wave *)JS_GetOpaque2(ctx, argv[0], js_Wave_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Wave arg0 = *argptr0; + + Wave returnVal = WaveCopy(arg0); + + + + Wave* ret_ptr = (Wave *)js_malloc(ctx, sizeof(Wave)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Wave_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_WaveCrop(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Wave * arg0 = (Wave *)JS_GetOpaque2(ctx, argv[0], js_Wave_class_id); + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); + int arg2; + JS_ToInt32(ctx, &arg2, argv[2]); + + WaveCrop(arg0, arg1, arg2); + + + return JS_UNDEFINED; +} + +static JSValue js_WaveFormat(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Wave * arg0 = (Wave *)JS_GetOpaque2(ctx, argv[0], js_Wave_class_id); + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); + int arg2; + JS_ToInt32(ctx, &arg2, argv[2]); + int arg3; + JS_ToInt32(ctx, &arg3, argv[3]); + + WaveFormat(arg0, arg1, arg2, arg3); + + + return JS_UNDEFINED; +} + +static JSValue js_LoadWaveSamples(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Wave * argptr0 = (Wave *)JS_GetOpaque2(ctx, argv[0], js_Wave_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Wave arg0 = *argptr0; + + float * retBuf = LoadWaveSamples(arg0); + + + JSValue ret = JS_NewArray(ctx); + //TODO + return ret; + +} + +static JSValue js_LoadMusicStream(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); + + Music returnVal = LoadMusicStream(arg0); + + JS_FreeCString(ctx, arg0); + + + Music* ret_ptr = (Music *)js_malloc(ctx, sizeof(Music)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Music_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_LoadMusicStreamFromMemory(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); +size_t data_size1; + const unsigned char * arg1 = (const unsigned char *)JS_GetArrayBuffer(ctx, &data_size1, argv[1]); + int arg2; + JS_ToInt32(ctx, &arg2, argv[2]); + + Music returnVal = LoadMusicStreamFromMemory(arg0, arg1, arg2); + + JS_FreeCString(ctx, arg0); + + + Music* ret_ptr = (Music *)js_malloc(ctx, sizeof(Music)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Music_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_IsMusicReady(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Music * argptr0 = (Music *)JS_GetOpaque2(ctx, argv[0], js_Music_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Music arg0 = *argptr0; + + bool ret = IsMusicReady(arg0); + + + return JS_NewBool(ctx, ret); +} + +static JSValue js_UnloadMusicStream(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Music * argptr0 = (Music *)JS_GetOpaque2(ctx, argv[0], js_Music_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Music arg0 = *argptr0; + + UnloadMusicStream(arg0); + + + return JS_UNDEFINED; +} + +static JSValue js_PlayMusicStream(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Music * argptr0 = (Music *)JS_GetOpaque2(ctx, argv[0], js_Music_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Music arg0 = *argptr0; + + PlayMusicStream(arg0); + + + return JS_UNDEFINED; +} + +static JSValue js_IsMusicStreamPlaying(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Music * argptr0 = (Music *)JS_GetOpaque2(ctx, argv[0], js_Music_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Music arg0 = *argptr0; + + bool ret = IsMusicStreamPlaying(arg0); + + + return JS_NewBool(ctx, ret); +} + +static JSValue js_UpdateMusicStream(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Music * argptr0 = (Music *)JS_GetOpaque2(ctx, argv[0], js_Music_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Music arg0 = *argptr0; + + UpdateMusicStream(arg0); + + + return JS_UNDEFINED; +} + +static JSValue js_StopMusicStream(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Music * argptr0 = (Music *)JS_GetOpaque2(ctx, argv[0], js_Music_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Music arg0 = *argptr0; + + StopMusicStream(arg0); + + + return JS_UNDEFINED; +} + +static JSValue js_PauseMusicStream(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Music * argptr0 = (Music *)JS_GetOpaque2(ctx, argv[0], js_Music_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Music arg0 = *argptr0; + + PauseMusicStream(arg0); + + + return JS_UNDEFINED; +} + +static JSValue js_ResumeMusicStream(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Music * argptr0 = (Music *)JS_GetOpaque2(ctx, argv[0], js_Music_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Music arg0 = *argptr0; + + ResumeMusicStream(arg0); + + + return JS_UNDEFINED; +} + +static JSValue js_SeekMusicStream(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Music * argptr0 = (Music *)JS_GetOpaque2(ctx, argv[0], js_Music_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Music arg0 = *argptr0; + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + + SeekMusicStream(arg0, arg1); + + + return JS_UNDEFINED; +} + +static JSValue js_SetMusicVolume(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Music * argptr0 = (Music *)JS_GetOpaque2(ctx, argv[0], js_Music_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Music arg0 = *argptr0; + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + + SetMusicVolume(arg0, arg1); + + + return JS_UNDEFINED; +} + +static JSValue js_SetMusicPitch(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Music * argptr0 = (Music *)JS_GetOpaque2(ctx, argv[0], js_Music_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Music arg0 = *argptr0; + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + + SetMusicPitch(arg0, arg1); + + + return JS_UNDEFINED; +} + +static JSValue js_SetMusicPan(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Music * argptr0 = (Music *)JS_GetOpaque2(ctx, argv[0], js_Music_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Music arg0 = *argptr0; + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + + SetMusicPan(arg0, arg1); + + + return JS_UNDEFINED; +} + +static JSValue js_GetMusicTimeLength(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Music * argptr0 = (Music *)JS_GetOpaque2(ctx, argv[0], js_Music_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Music arg0 = *argptr0; + + float ret = GetMusicTimeLength(arg0); + + + return JS_NewFloat64(ctx, ret); +} + +static JSValue js_GetMusicTimePlayed(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Music * argptr0 = (Music *)JS_GetOpaque2(ctx, argv[0], js_Music_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Music arg0 = *argptr0; + + float ret = GetMusicTimePlayed(arg0); + + + return JS_NewFloat64(ctx, ret); +} + +static JSValue js_LoadAudioStream(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + unsigned int arg0; + JS_ToUint32(ctx, &arg0, argv[0]); + unsigned int arg1; + JS_ToUint32(ctx, &arg1, argv[1]); + unsigned int arg2; + JS_ToUint32(ctx, &arg2, argv[2]); + + AudioStream returnVal = LoadAudioStream(arg0, arg1, arg2); + + + + AudioStream* ret_ptr = (AudioStream *)js_malloc(ctx, sizeof(AudioStream)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_AudioStream_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_IsAudioStreamReady(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + AudioStream * argptr0 = (AudioStream *)JS_GetOpaque2(ctx, argv[0], js_AudioStream_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + AudioStream arg0 = *argptr0; + + bool ret = IsAudioStreamReady(arg0); + + + return JS_NewBool(ctx, ret); +} + +static JSValue js_UnloadAudioStream(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + AudioStream * argptr0 = (AudioStream *)JS_GetOpaque2(ctx, argv[0], js_AudioStream_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + AudioStream arg0 = *argptr0; + + UnloadAudioStream(arg0); + + + return JS_UNDEFINED; +} + +static JSValue js_UpdateAudioStream(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + AudioStream * argptr0 = (AudioStream *)JS_GetOpaque2(ctx, argv[0], js_AudioStream_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + AudioStream arg0 = *argptr0; +size_t data_size1; + const void * arg1 = (const void *)JS_GetArrayBuffer(ctx, &data_size1, argv[1]); + int arg2; + JS_ToInt32(ctx, &arg2, argv[2]); + + UpdateAudioStream(arg0, arg1, arg2); + + + return JS_UNDEFINED; +} + +static JSValue js_IsAudioStreamProcessed(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + AudioStream * argptr0 = (AudioStream *)JS_GetOpaque2(ctx, argv[0], js_AudioStream_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + AudioStream arg0 = *argptr0; + + bool ret = IsAudioStreamProcessed(arg0); + + + return JS_NewBool(ctx, ret); +} + +static JSValue js_PlayAudioStream(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + AudioStream * argptr0 = (AudioStream *)JS_GetOpaque2(ctx, argv[0], js_AudioStream_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + AudioStream arg0 = *argptr0; + + PlayAudioStream(arg0); + + + return JS_UNDEFINED; +} + +static JSValue js_PauseAudioStream(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + AudioStream * argptr0 = (AudioStream *)JS_GetOpaque2(ctx, argv[0], js_AudioStream_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + AudioStream arg0 = *argptr0; + + PauseAudioStream(arg0); + + + return JS_UNDEFINED; +} + +static JSValue js_ResumeAudioStream(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + AudioStream * argptr0 = (AudioStream *)JS_GetOpaque2(ctx, argv[0], js_AudioStream_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + AudioStream arg0 = *argptr0; + + ResumeAudioStream(arg0); + + + return JS_UNDEFINED; +} + +static JSValue js_IsAudioStreamPlaying(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + AudioStream * argptr0 = (AudioStream *)JS_GetOpaque2(ctx, argv[0], js_AudioStream_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + AudioStream arg0 = *argptr0; + + bool ret = IsAudioStreamPlaying(arg0); + + + return JS_NewBool(ctx, ret); +} + +static JSValue js_StopAudioStream(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + AudioStream * argptr0 = (AudioStream *)JS_GetOpaque2(ctx, argv[0], js_AudioStream_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + AudioStream arg0 = *argptr0; + + StopAudioStream(arg0); + + + return JS_UNDEFINED; +} + +static JSValue js_SetAudioStreamVolume(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + AudioStream * argptr0 = (AudioStream *)JS_GetOpaque2(ctx, argv[0], js_AudioStream_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + AudioStream arg0 = *argptr0; + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + + SetAudioStreamVolume(arg0, arg1); + + + return JS_UNDEFINED; +} + +static JSValue js_SetAudioStreamPitch(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + AudioStream * argptr0 = (AudioStream *)JS_GetOpaque2(ctx, argv[0], js_AudioStream_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + AudioStream arg0 = *argptr0; + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + + SetAudioStreamPitch(arg0, arg1); + + + return JS_UNDEFINED; +} + +static JSValue js_SetAudioStreamPan(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + AudioStream * argptr0 = (AudioStream *)JS_GetOpaque2(ctx, argv[0], js_AudioStream_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + AudioStream arg0 = *argptr0; + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + + SetAudioStreamPan(arg0, arg1); + + + return JS_UNDEFINED; +} + +static JSValue js_SetAudioStreamBufferSizeDefault(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + int arg0; + JS_ToInt32(ctx, &arg0, argv[0]); + + SetAudioStreamBufferSizeDefault(arg0); + + + return JS_UNDEFINED; +} + +static JSValue js_GetCameraForward(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Camera * arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera_class_id); + if (arg0 == NULL) + arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera3D_class_id); + + Vector3 returnVal = GetCameraForward(arg0); + + + + Vector3* ret_ptr = (Vector3 *)js_malloc(ctx, sizeof(Vector3)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_GetCameraUp(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Camera * arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera_class_id); + if (arg0 == NULL) + arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera3D_class_id); + + Vector3 returnVal = GetCameraUp(arg0); + + + + Vector3* ret_ptr = (Vector3 *)js_malloc(ctx, sizeof(Vector3)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_GetCameraRight(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Camera * arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera_class_id); + if (arg0 == NULL) + arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera3D_class_id); + + Vector3 returnVal = GetCameraRight(arg0); + + + + Vector3* ret_ptr = (Vector3 *)js_malloc(ctx, sizeof(Vector3)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_CameraMoveForward(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Camera * arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera_class_id); + if (arg0 == NULL) + arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera3D_class_id); + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + JS_BOOL argbool2 = JS_ToBool(ctx, argv[2]); + bool arg2 = (bool) argbool2; + + CameraMoveForward(arg0, arg1, arg2); + + + return JS_UNDEFINED; +} + +static JSValue js_CameraMoveUp(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Camera * arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera_class_id); + if (arg0 == NULL) + arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera3D_class_id); + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + + CameraMoveUp(arg0, arg1); + + + return JS_UNDEFINED; +} + +static JSValue js_CameraMoveRight(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Camera * arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera_class_id); + if (arg0 == NULL) + arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera3D_class_id); + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + JS_BOOL argbool2 = JS_ToBool(ctx, argv[2]); + bool arg2 = (bool) argbool2; + + CameraMoveRight(arg0, arg1, arg2); + + + return JS_UNDEFINED; +} + +static JSValue js_CameraMoveToTarget(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Camera * arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera_class_id); + if (arg0 == NULL) + arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera3D_class_id); + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + + CameraMoveToTarget(arg0, arg1); + + + return JS_UNDEFINED; +} + +static JSValue js_CameraYaw(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Camera * arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera_class_id); + if (arg0 == NULL) + arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera3D_class_id); + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + JS_BOOL argbool2 = JS_ToBool(ctx, argv[2]); + bool arg2 = (bool) argbool2; + + CameraYaw(arg0, arg1, arg2); + + + return JS_UNDEFINED; +} + +static JSValue js_CameraPitch(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Camera * arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera_class_id); + if (arg0 == NULL) + arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera3D_class_id); + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + JS_BOOL argbool2 = JS_ToBool(ctx, argv[2]); + bool arg2 = (bool) argbool2; + JS_BOOL argbool3 = JS_ToBool(ctx, argv[3]); + bool arg3 = (bool) argbool3; + JS_BOOL argbool4 = JS_ToBool(ctx, argv[4]); + bool arg4 = (bool) argbool4; + + CameraPitch(arg0, arg1, arg2, arg3, arg4); + + + return JS_UNDEFINED; +} + +static JSValue js_CameraRoll(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Camera * arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera_class_id); + if (arg0 == NULL) + arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera3D_class_id); + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); - - Image* ret_ptr = (Image *)js_malloc(ctx, sizeof(Image)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Image_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - + CameraRoll(arg0, arg1); + + + return JS_UNDEFINED; } -static JSValue js_GenImageGradientLinear(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GetCameraViewMatrix(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - int arg0; - JS_ToInt32(ctx, &arg0, argv[0]); - int arg1; - JS_ToInt32(ctx, &arg1, argv[1]); - int arg2; - JS_ToInt32(ctx, &arg2, argv[2]); - Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); - if (argptr3 == NULL) return JS_EXCEPTION; - - Color arg3 = *argptr3; - Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); - if (argptr4 == NULL) return JS_EXCEPTION; - - Color arg4 = *argptr4; + Camera * arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera_class_id); + if (arg0 == NULL) + arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera3D_class_id); - Image returnVal = GenImageGradientLinear(arg0, arg1, arg2, arg3, arg4); + Matrix returnVal = GetCameraViewMatrix(arg0); - Image* ret_ptr = (Image *)js_malloc(ctx, sizeof(Image)); + Matrix* ret_ptr = (Matrix *)js_malloc(ctx, sizeof(Matrix)); *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Image_class_id); + JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); JS_SetOpaque(ret, ret_ptr); return ret; } -static JSValue js_GenImageGradientRadial(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GetCameraProjectionMatrix(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - int arg0; - JS_ToInt32(ctx, &arg0, argv[0]); - int arg1; - JS_ToInt32(ctx, &arg1, argv[1]); - double arg2; - JS_ToFloat64(ctx, &arg2, argv[2]); - Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); - if (argptr3 == NULL) return JS_EXCEPTION; - - Color arg3 = *argptr3; - Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); - if (argptr4 == NULL) return JS_EXCEPTION; - - Color arg4 = *argptr4; + Camera * arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera_class_id); + if (arg0 == NULL) + arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera3D_class_id); + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); - Image returnVal = GenImageGradientRadial(arg0, arg1, arg2, arg3, arg4); + Matrix returnVal = GetCameraProjectionMatrix(arg0, arg1); - Image* ret_ptr = (Image *)js_malloc(ctx, sizeof(Image)); + Matrix* ret_ptr = (Matrix *)js_malloc(ctx, sizeof(Matrix)); *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Image_class_id); + JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); JS_SetOpaque(ret, ret_ptr); return ret; } -static JSValue js_GenImageGradientSquare(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) + + +static JSClassID js_GuiStyleProp_class_id; + +static JSValue js_GuiStyleProp_get(JSContext *ctx, JSValueConst this_val, int magic) { - int arg0; - JS_ToInt32(ctx, &arg0, argv[0]); - int arg1; - JS_ToInt32(ctx, &arg1, argv[1]); - double arg2; - JS_ToFloat64(ctx, &arg2, argv[2]); - Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); - if (argptr3 == NULL) return JS_EXCEPTION; - - Color arg3 = *argptr3; - Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); - if (argptr4 == NULL) return JS_EXCEPTION; - - Color arg4 = *argptr4; + GuiStyleProp *s = JS_GetOpaque2(ctx, this_val, js_GuiStyleProp_class_id); + if (!s) + return JS_EXCEPTION; - Image returnVal = GenImageGradientSquare(arg0, arg1, arg2, arg3, arg4); + +if (magic == 0) { + return JS_NewUint32(ctx, (unsigned short) s->controlId); +} + +if (magic == 1) { + return JS_NewUint32(ctx, (unsigned short) s->propertyId); +} + +if (magic == 2) { + return JS_NewInt32(ctx, (int) s->propertyValue); +} + + + return JS_UNDEFINED; +} +static JSValue js_GuiStyleProp_set(JSContext *ctx, JSValueConst this_val, JSValue val, int magic) +{ + GuiStyleProp *s = JS_GetOpaque2(ctx, this_val, js_GuiStyleProp_class_id); + if (!s) + return JS_EXCEPTION; - Image* ret_ptr = (Image *)js_malloc(ctx, sizeof(Image)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Image_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; +if (magic == 0) { + unsigned short v0; + if (JS_ToUint32(ctx, &v0, val)) + return JS_EXCEPTION; + s->controlId = (unsigned short) v0; +} + +if (magic == 1) { + unsigned short v1; + if (JS_ToUint32(ctx, &v1, val)) + return JS_EXCEPTION; + s->propertyId = (unsigned short) v1; +} + +if (magic == 2) { + int v2; + if (JS_ToInt32(ctx, &v2, val)) + return JS_EXCEPTION; + s->propertyValue = (int) v2; +} + + return JS_UNDEFINED; } -static JSValue js_GenImageChecked(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static void js_GuiStyleProp_finalizer(JSRuntime *rt, JSValue val) { - int arg0; - JS_ToInt32(ctx, &arg0, argv[0]); - int arg1; - JS_ToInt32(ctx, &arg1, argv[1]); - int arg2; - JS_ToInt32(ctx, &arg2, argv[2]); - int arg3; - JS_ToInt32(ctx, &arg3, argv[3]); - Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); - if (argptr4 == NULL) return JS_EXCEPTION; - - Color arg4 = *argptr4; - Color * argptr5 = (Color *)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); - if (argptr5 == NULL) return JS_EXCEPTION; - - Color arg5 = *argptr5; + GuiStyleProp *s = JS_GetOpaque(val, js_GuiStyleProp_class_id); + /* Note: 's' can be NULL in case JS_SetOpaque() was not called */ + js_free_rt(rt, s); +} - Image returnVal = GenImageChecked(arg0, arg1, arg2, arg3, arg4, arg5); +static JSValue js_GuiStyleProp_ctor(JSContext *ctx, + JSValueConst new_target, + int argc, JSValueConst *argv) +{ + + /*emscripten_log(EM_LOG_CONSOLE, "--> js_GuiStyleProp_ctor: argc=%d", argc); + + for (int i=0; i < argc; ++i) { + emscripten_log(EM_LOG_CONSOLE, "%d: %d", i, JS_VALUE_GET_TAG(argv[i])); + }*/ + + GuiStyleProp *s; + JSValue obj = JS_UNDEFINED; + JSValue proto; + s = js_mallocz(ctx, sizeof(*s)); + if (!s) + return JS_EXCEPTION; - Image* ret_ptr = (Image *)js_malloc(ctx, sizeof(Image)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Image_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; + /* using new_target to get the prototype is necessary when the + class is extended. */ + +unsigned short v0; +if (JS_ToUint32(ctx, &v0, argv[0])) + goto fail; +s->controlId = (unsigned short) v0; + +/*emscripten_log(EM_LOG_CONSOLE, "Set prop: 0 = %lf", s->0);*/ + + +unsigned short v1; +if (JS_ToUint32(ctx, &v1, argv[1])) + goto fail; +s->propertyId = (unsigned short) v1; + +/*emscripten_log(EM_LOG_CONSOLE, "Set prop: 1 = %lf", s->1);*/ + + +int v2; +if (JS_ToInt32(ctx, &v2, argv[2])) + goto fail; +s->propertyValue = (int) v2; + +/*emscripten_log(EM_LOG_CONSOLE, "Set prop: 2 = %lf", s->2);*/ + + + proto = JS_GetPropertyStr(ctx, new_target, "prototype"); + if (JS_IsException(proto)) + goto fail; + obj = JS_NewObjectProtoClass(ctx, proto, js_GuiStyleProp_class_id); + JS_FreeValue(ctx, proto); + if (JS_IsException(obj)) + goto fail; + JS_SetOpaque(obj, s); + return obj; + fail: + js_free(ctx, s); + JS_FreeValue(ctx, obj); + return JS_EXCEPTION; +} + +static JSClassDef js_GuiStyleProp_class = { + "GuiStyleProp", + .finalizer = js_GuiStyleProp_finalizer, +}; + +static const JSCFunctionListEntry js_GuiStyleProp_proto_funcs[] = { + JS_CGETSET_MAGIC_DEF("controlId", js_GuiStyleProp_get, js_GuiStyleProp_set, 0), + JS_CGETSET_MAGIC_DEF("propertyId", js_GuiStyleProp_get, js_GuiStyleProp_set, 1), + JS_CGETSET_MAGIC_DEF("propertyValue", js_GuiStyleProp_get, js_GuiStyleProp_set, 2), + + /*JS_PROP_STRING_DEF("[Symbol.toStringTag]", "GuiStyleProp", JS_PROP_CONFIGURABLE ),*/ +}; +static int js_declare_GuiStyleProp(JSContext *ctx, JSModuleDef *m) +{ + JSValue proto, class; + + /* create the class */ + JS_NewClassID(&js_GuiStyleProp_class_id); + JS_NewClass(JS_GetRuntime(ctx), js_GuiStyleProp_class_id, &js_GuiStyleProp_class); + + proto = JS_NewObject(ctx); + JS_SetPropertyFunctionList(ctx, proto, js_GuiStyleProp_proto_funcs, countof(js_GuiStyleProp_proto_funcs)); + + class = JS_NewCFunction2(ctx, js_GuiStyleProp_ctor, "GuiStyleProp", 3, JS_CFUNC_constructor, 0); + /* set proto.constructor and ctor.prototype */ + JS_SetConstructor(ctx, class, proto); + JS_SetClassProto(ctx, js_GuiStyleProp_class_id, proto); + + JS_SetModuleExport(ctx, m, "GuiStyleProp", class); + return 0; } -static JSValue js_GenImageWhiteNoise(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiEnable(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - int arg0; - JS_ToInt32(ctx, &arg0, argv[0]); - int arg1; - JS_ToInt32(ctx, &arg1, argv[1]); - double arg2; - JS_ToFloat64(ctx, &arg2, argv[2]); - Image returnVal = GenImageWhiteNoise(arg0, arg1, arg2); + GuiEnable(); - - Image* ret_ptr = (Image *)js_malloc(ctx, sizeof(Image)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Image_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - + return JS_UNDEFINED; +} + +static JSValue js_GuiDisable(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + + GuiDisable(); + + + return JS_UNDEFINED; } -static JSValue js_GenImagePerlinNoise(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiLock(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - int arg0; - JS_ToInt32(ctx, &arg0, argv[0]); - int arg1; - JS_ToInt32(ctx, &arg1, argv[1]); - int arg2; - JS_ToInt32(ctx, &arg2, argv[2]); - int arg3; - JS_ToInt32(ctx, &arg3, argv[3]); - double arg4; - JS_ToFloat64(ctx, &arg4, argv[4]); - Image returnVal = GenImagePerlinNoise(arg0, arg1, arg2, arg3, arg4); + GuiLock(); - - Image* ret_ptr = (Image *)js_malloc(ctx, sizeof(Image)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Image_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - + return JS_UNDEFINED; } -static JSValue js_GenImageCellular(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiUnlock(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - int arg0; - JS_ToInt32(ctx, &arg0, argv[0]); - int arg1; - JS_ToInt32(ctx, &arg1, argv[1]); - int arg2; - JS_ToInt32(ctx, &arg2, argv[2]); - Image returnVal = GenImageCellular(arg0, arg1, arg2); + GuiUnlock(); - - Image* ret_ptr = (Image *)js_malloc(ctx, sizeof(Image)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Image_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - + return JS_UNDEFINED; } -static JSValue js_GenImageText(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiIsLocked(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - int arg0; - JS_ToInt32(ctx, &arg0, argv[0]); - int arg1; - JS_ToInt32(ctx, &arg1, argv[1]); - const char * arg2 = (const char *)JS_ToCString(ctx, argv[2]); - Image returnVal = GenImageText(arg0, arg1, arg2); + bool ret = GuiIsLocked(); - JS_FreeCString(ctx, arg2); - - Image* ret_ptr = (Image *)js_malloc(ctx, sizeof(Image)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Image_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - + return JS_NewBool(ctx, ret); } -static JSValue js_GetImageAlphaBorder(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiSetAlpha(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Image * argptr0 = (Image *)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Image arg0 = *argptr0; - double arg1; - JS_ToFloat64(ctx, &arg1, argv[1]); + double arg0; + JS_ToFloat64(ctx, &arg0, argv[0]); - Rectangle returnVal = GetImageAlphaBorder(arg0, arg1); + GuiSetAlpha(arg0); - - Rectangle* ret_ptr = (Rectangle *)js_malloc(ctx, sizeof(Rectangle)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Rectangle_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - + return JS_UNDEFINED; } -static JSValue js_GetImageColor(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiSetState(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Image * argptr0 = (Image *)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Image arg0 = *argptr0; - int arg1; - JS_ToInt32(ctx, &arg1, argv[1]); - int arg2; - JS_ToInt32(ctx, &arg2, argv[2]); + int arg0; + JS_ToInt32(ctx, &arg0, argv[0]); - Color returnVal = GetImageColor(arg0, arg1, arg2); + GuiSetState(arg0); - - Color* ret_ptr = (Color *)js_malloc(ctx, sizeof(Color)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Color_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - + return JS_UNDEFINED; } -static JSValue js_LoadTexture(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiGetState(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); - Texture2D returnVal = LoadTexture(arg0); + int ret = GuiGetState(); - JS_FreeCString(ctx, arg0); - - Texture2D* ret_ptr = (Texture2D *)js_malloc(ctx, sizeof(Texture2D)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Texture2D_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - + return JS_NewInt32(ctx, ret); } -static JSValue js_LoadTextureFromImage(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiSetFont(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Image * argptr0 = (Image *)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); + Font * argptr0 = (Font *)JS_GetOpaque2(ctx, argv[0], js_Font_class_id); if (argptr0 == NULL) return JS_EXCEPTION; - Image arg0 = *argptr0; + Font arg0 = *argptr0; - Texture2D returnVal = LoadTextureFromImage(arg0); + GuiSetFont(arg0); - - Texture2D* ret_ptr = (Texture2D *)js_malloc(ctx, sizeof(Texture2D)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Texture2D_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - + return JS_UNDEFINED; } -static JSValue js_LoadTextureCubemap(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiGetFont(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Image * argptr0 = (Image *)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Image arg0 = *argptr0; - int arg1; - JS_ToInt32(ctx, &arg1, argv[1]); - TextureCubemap returnVal = LoadTextureCubemap(arg0, arg1); + Font returnVal = GuiGetFont(); - TextureCubemap* ret_ptr = (TextureCubemap *)js_malloc(ctx, sizeof(TextureCubemap)); + Font* ret_ptr = (Font *)js_malloc(ctx, sizeof(Font)); *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_TextureCubemap_class_id); + JSValue ret = JS_NewObjectClass(ctx, js_Font_class_id); JS_SetOpaque(ret, ret_ptr); return ret; } -static JSValue js_LoadRenderTexture(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiSetStyle(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { int arg0; JS_ToInt32(ctx, &arg0, argv[0]); int arg1; JS_ToInt32(ctx, &arg1, argv[1]); + int arg2; + JS_ToInt32(ctx, &arg2, argv[2]); - RenderTexture2D returnVal = LoadRenderTexture(arg0, arg1); + GuiSetStyle(arg0, arg1, arg2); - - RenderTexture2D* ret_ptr = (RenderTexture2D *)js_malloc(ctx, sizeof(RenderTexture2D)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_RenderTexture2D_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - + return JS_UNDEFINED; } -static JSValue js_IsTextureReady(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiGetStyle(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Texture2D * argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture2D_class_id); - if (argptr0 == NULL) - argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Texture2D arg0 = *argptr0; + int arg0; + JS_ToInt32(ctx, &arg0, argv[0]); + int arg1; + JS_ToInt32(ctx, &arg1, argv[1]); - bool ret = IsTextureReady(arg0); + int ret = GuiGetStyle(arg0, arg1); - return JS_NewBool(ctx, ret); + return JS_NewInt32(ctx, ret); } -static JSValue js_UnloadTexture(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiLoadStyle(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Texture2D * argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture2D_class_id); - if (argptr0 == NULL) - argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Texture2D arg0 = *argptr0; + const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); - UnloadTexture(arg0); + GuiLoadStyle(arg0); + JS_FreeCString(ctx, arg0); return JS_UNDEFINED; } -static JSValue js_IsRenderTextureReady(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiLoadStyleDefault(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - RenderTexture2D * argptr0 = (RenderTexture2D *)JS_GetOpaque2(ctx, argv[0], js_RenderTexture2D_class_id); - if (argptr0 == NULL) - argptr0 = (RenderTexture2D *)JS_GetOpaque2(ctx, argv[0], js_RenderTexture_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - RenderTexture2D arg0 = *argptr0; - bool ret = IsRenderTextureReady(arg0); + GuiLoadStyleDefault(); - return JS_NewBool(ctx, ret); + return JS_UNDEFINED; } -static JSValue js_UnloadRenderTexture(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiEnableTooltip(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - RenderTexture2D * argptr0 = (RenderTexture2D *)JS_GetOpaque2(ctx, argv[0], js_RenderTexture2D_class_id); - if (argptr0 == NULL) - argptr0 = (RenderTexture2D *)JS_GetOpaque2(ctx, argv[0], js_RenderTexture_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - RenderTexture2D arg0 = *argptr0; - UnloadRenderTexture(arg0); + GuiEnableTooltip(); return JS_UNDEFINED; } -static JSValue js_UpdateTexture(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiDisableTooltip(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Texture2D * argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture2D_class_id); - if (argptr0 == NULL) - argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Texture2D arg0 = *argptr0; -size_t data_size1; - const void * arg1 = (const void *)JS_GetArrayBuffer(ctx, &data_size1, argv[1]); - UpdateTexture(arg0, arg1); + GuiDisableTooltip(); return JS_UNDEFINED; } -static JSValue js_UpdateTextureRec(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiSetTooltip(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Texture2D * argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture2D_class_id); - if (argptr0 == NULL) - argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Texture2D arg0 = *argptr0; - Rectangle * argptr1 = (Rectangle *)JS_GetOpaque2(ctx, argv[1], js_Rectangle_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; - - Rectangle arg1 = *argptr1; -size_t data_size2; - const void * arg2 = (const void *)JS_GetArrayBuffer(ctx, &data_size2, argv[2]); + const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); - UpdateTextureRec(arg0, arg1, arg2); + GuiSetTooltip(arg0); + JS_FreeCString(ctx, arg0); return JS_UNDEFINED; } -static JSValue js_SetTextureFilter(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiIconText(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Texture2D * argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture2D_class_id); - if (argptr0 == NULL) - argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Texture2D arg0 = *argptr0; - int arg1; - JS_ToInt32(ctx, &arg1, argv[1]); + int arg0; + JS_ToInt32(ctx, &arg0, argv[0]); + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); + + const char * returnVal = GuiIconText(arg0, arg1); + + JS_FreeCString(ctx, arg1); + + JSValue ret = JS_NewString(ctx, returnVal); + return ret; +} - SetTextureFilter(arg0, arg1); +static JSValue js_GuiSetIconScale(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + int arg0; + JS_ToInt32(ctx, &arg0, argv[0]); + + GuiSetIconScale(arg0); return JS_UNDEFINED; } -static JSValue js_SetTextureWrap(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiLoadIcons(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Texture2D * argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture2D_class_id); - if (argptr0 == NULL) - argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Texture2D arg0 = *argptr0; - int arg1; - JS_ToInt32(ctx, &arg1, argv[1]); + const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); + JS_BOOL argbool1 = JS_ToBool(ctx, argv[1]); + bool arg1 = (bool) argbool1; - SetTextureWrap(arg0, arg1); + GuiLoadIcons(arg0, arg1); + JS_FreeCString(ctx, arg0); return JS_UNDEFINED; } -static JSValue js_DrawTexture(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiDrawIcon(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Texture2D * argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture2D_class_id); - if (argptr0 == NULL) - argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Texture2D arg0 = *argptr0; + int arg0; + JS_ToInt32(ctx, &arg0, argv[0]); int arg1; JS_ToInt32(ctx, &arg1, argv[1]); int arg2; JS_ToInt32(ctx, &arg2, argv[2]); - Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); - if (argptr3 == NULL) return JS_EXCEPTION; - - Color arg3 = *argptr3; + int arg3; + JS_ToInt32(ctx, &arg3, argv[3]); - DrawTexture(arg0, arg1, arg2, arg3); + Color arg4; - return JS_UNDEFINED; -} + if (JS_IsArray(ctx, argv[4])) { -static JSValue js_DrawTextureV(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Texture2D * argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture2D_class_id); - if (argptr0 == NULL) - argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Texture2D arg0 = *argptr0; - Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; - - Vector2 arg1 = *argptr1; - Color * argptr2 = (Color *)JS_GetOpaque2(ctx, argv[2], js_Color_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; + JSValue r = JS_GetPropertyUint32(ctx, argv[4], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg4.r = (unsigned char)r_int; - Color arg2 = *argptr2; + JSValue g = JS_GetPropertyUint32(ctx, argv[4], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg4.g = (unsigned char)g_int; - DrawTextureV(arg0, arg1, arg2); + JSValue b = JS_GetPropertyUint32(ctx, argv[4], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg4.b = (unsigned char)b_int; + JSValue a = JS_GetPropertyUint32(ctx, argv[4], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg4.a = (unsigned char)a_int; + } + else { - return JS_UNDEFINED; -} + Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); -static JSValue js_DrawTextureEx(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Texture2D * argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture2D_class_id); - if (argptr0 == NULL) - argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Texture2D arg0 = *argptr0; - Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; - - Vector2 arg1 = *argptr1; - double arg2; - JS_ToFloat64(ctx, &arg2, argv[2]); - double arg3; - JS_ToFloat64(ctx, &arg3, argv[3]); - Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); - if (argptr4 == NULL) return JS_EXCEPTION; + if (argptr4 == NULL) return JS_EXCEPTION; + + arg4 = *argptr4; + } - Color arg4 = *argptr4; - - DrawTextureEx(arg0, arg1, arg2, arg3, arg4); + GuiDrawIcon(arg0, arg1, arg2, arg3, arg4); return JS_UNDEFINED; } -static JSValue js_DrawTextureRec(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiWindowBox(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Texture2D * argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture2D_class_id); - if (argptr0 == NULL) - argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Texture2D arg0 = *argptr0; - Rectangle * argptr1 = (Rectangle *)JS_GetOpaque2(ctx, argv[1], js_Rectangle_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; - - Rectangle arg1 = *argptr1; - Vector2 * argptr2 = (Vector2 *)JS_GetOpaque2(ctx, argv[2], js_Vector2_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; - - Vector2 arg2 = *argptr2; - Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); - if (argptr3 == NULL) return JS_EXCEPTION; - - Color arg3 = *argptr3; - DrawTextureRec(arg0, arg1, arg2, arg3); + Rectangle arg0; - return JS_UNDEFINED; -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_DrawTexturePro(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Texture2D * argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture2D_class_id); - if (argptr0 == NULL) - argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Texture2D arg0 = *argptr0; - Rectangle * argptr1 = (Rectangle *)JS_GetOpaque2(ctx, argv[1], js_Rectangle_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; - - Rectangle arg1 = *argptr1; - Rectangle * argptr2 = (Rectangle *)JS_GetOpaque2(ctx, argv[2], js_Rectangle_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Rectangle arg2 = *argptr2; - Vector2 * argptr3 = (Vector2 *)JS_GetOpaque2(ctx, argv[3], js_Vector2_class_id); - if (argptr3 == NULL) return JS_EXCEPTION; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; - Vector2 arg3 = *argptr3; - double arg4; - JS_ToFloat64(ctx, &arg4, argv[4]); - Color * argptr5 = (Color *)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); - if (argptr5 == NULL) return JS_EXCEPTION; + JSValue w = JS_GetPropertyUint32(ctx, argv[0], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg0.width = (float)w_double; - Color arg5 = *argptr5; + JSValue h = JS_GetPropertyUint32(ctx, argv[0], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg0.height = (float)h_double; + } + else { - DrawTexturePro(arg0, arg1, arg2, arg3, arg4, arg5); + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); - return JS_UNDEFINED; + int ret = GuiWindowBox(arg0, arg1); + + JS_FreeCString(ctx, arg1); + + return JS_NewInt32(ctx, ret); } -static JSValue js_DrawTextureNPatch(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiGroupBox(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Texture2D * argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture2D_class_id); - if (argptr0 == NULL) - argptr0 = (Texture2D *)JS_GetOpaque2(ctx, argv[0], js_Texture_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Texture2D arg0 = *argptr0; - NPatchInfo * argptr1 = (NPatchInfo *)JS_GetOpaque2(ctx, argv[1], js_NPatchInfo_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; - - NPatchInfo arg1 = *argptr1; - Rectangle * argptr2 = (Rectangle *)JS_GetOpaque2(ctx, argv[2], js_Rectangle_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; + + + Rectangle arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Rectangle arg2 = *argptr2; - Vector2 * argptr3 = (Vector2 *)JS_GetOpaque2(ctx, argv[3], js_Vector2_class_id); - if (argptr3 == NULL) return JS_EXCEPTION; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; - Vector2 arg3 = *argptr3; - double arg4; - JS_ToFloat64(ctx, &arg4, argv[4]); - Color * argptr5 = (Color *)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); - if (argptr5 == NULL) return JS_EXCEPTION; + JSValue w = JS_GetPropertyUint32(ctx, argv[0], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg0.width = (float)w_double; - Color arg5 = *argptr5; + JSValue h = JS_GetPropertyUint32(ctx, argv[0], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg0.height = (float)h_double; + } + else { - DrawTextureNPatch(arg0, arg1, arg2, arg3, arg4, arg5); + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); - return JS_UNDEFINED; + int ret = GuiGroupBox(arg0, arg1); + + JS_FreeCString(ctx, arg1); + + return JS_NewInt32(ctx, ret); } -static JSValue js_Fade(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiLine(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Color * argptr0 = (Color *)JS_GetOpaque2(ctx, argv[0], js_Color_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Color arg0 = *argptr0; - double arg1; - JS_ToFloat64(ctx, &arg1, argv[1]); - Color returnVal = Fade(arg0, arg1); + Rectangle arg0; - - Color* ret_ptr = (Color *)js_malloc(ctx, sizeof(Color)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Color_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_ColorToInt(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Color * argptr0 = (Color *)JS_GetOpaque2(ctx, argv[0], js_Color_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; - Color arg0 = *argptr0; + JSValue w = JS_GetPropertyUint32(ctx, argv[0], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg0.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[0], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg0.height = (float)h_double; + } + else { - int ret = ColorToInt(arg0); + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); + + int ret = GuiLine(arg0, arg1); + + JS_FreeCString(ctx, arg1); return JS_NewInt32(ctx, ret); } -static JSValue js_ColorNormalize(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiPanel(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Color * argptr0 = (Color *)JS_GetOpaque2(ctx, argv[0], js_Color_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Color arg0 = *argptr0; - Vector4 returnVal = ColorNormalize(arg0); + Rectangle arg0; - - Vector4* ret_ptr = (Vector4 *)js_malloc(ctx, sizeof(Vector4)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Vector4_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_ColorFromNormalized(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Vector4 * argptr0 = (Vector4 *)JS_GetOpaque2(ctx, argv[0], js_Vector4_class_id); - if (argptr0 == NULL) - argptr0 = (Vector4 *)JS_GetOpaque2(ctx, argv[0], js_Quaternion_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; - Vector4 arg0 = *argptr0; + JSValue w = JS_GetPropertyUint32(ctx, argv[0], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg0.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[0], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg0.height = (float)h_double; + } + else { - Color returnVal = ColorFromNormalized(arg0); + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); - - Color* ret_ptr = (Color *)js_malloc(ctx, sizeof(Color)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Color_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - + int ret = GuiPanel(arg0, arg1); + + JS_FreeCString(ctx, arg1); + + return JS_NewInt32(ctx, ret); } -static JSValue js_ColorToHSV(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiTabBar(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Color * argptr0 = (Color *)JS_GetOpaque2(ctx, argv[0], js_Color_class_id); + + + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); if (argptr0 == NULL) return JS_EXCEPTION; - Color arg0 = *argptr0; + Rectangle arg0 = *argptr0; - Vector3 returnVal = ColorToHSV(arg0); + JSValue length_js = JS_GetProperty(ctx, argv[1], JS_ATOM_length); + + int32_t length; + + JS_ToInt32(ctx, &length, length_js); + char ** tabs = (char **)malloc((length+1)*sizeof(char *)); - - Vector3* ret_ptr = (Vector3 *)js_malloc(ctx, sizeof(Vector3)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - -} + tabs[length] = 0; -static JSValue js_ColorFromHSV(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - double arg0; - JS_ToFloat64(ctx, &arg0, argv[0]); - double arg1; - JS_ToFloat64(ctx, &arg1, argv[1]); - double arg2; - JS_ToFloat64(ctx, &arg2, argv[2]); + for (int i=0; i < length; ++i) {{ - Color returnVal = ColorFromHSV(arg0, arg1, arg2); + JSValue val = JS_GetPropertyUint32(ctx, argv[1], i); + const char * str = JS_ToCString(ctx, val); + + tabs[i] = str; + }} + + int arg2; + JS_ToInt32(ctx, &arg2, argv[2]); - - Color* ret_ptr = (Color *)js_malloc(ctx, sizeof(Color)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Color_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - + JSValue arg3_js = JS_GetPropertyStr(ctx, argv[3], "active"); + int arg3; + JS_ToInt32(ctx, &arg3, arg3_js); + + int ret = GuiTabBar(arg0, tabs, arg2, &arg3); + + JS_SetPropertyStr(ctx, argv[3], "active", JS_NewInt32(ctx, arg3)); + + for (int i=0; i < length; ++i) {{ + + JS_FreeCString(ctx, tabs[i]); + }} + + if (tabs) + free(tabs); + + return JS_NewInt32(ctx, ret); } -static JSValue js_ColorTint(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiScrollPanel(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Color * argptr0 = (Color *)JS_GetOpaque2(ctx, argv[0], js_Color_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + Rectangle arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Color arg0 = *argptr0; - Color * argptr1 = (Color *)JS_GetOpaque2(ctx, argv[1], js_Color_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue w = JS_GetPropertyUint32(ctx, argv[0], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg0.width = (float)w_double; - Color arg1 = *argptr1; + JSValue h = JS_GetPropertyUint32(ctx, argv[0], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg0.height = (float)h_double; + } + else { - Color returnVal = ColorTint(arg0, arg1); + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); - - Color* ret_ptr = (Color *)js_malloc(ctx, sizeof(Color)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Color_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - -} -static JSValue js_ColorBrightness(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Color * argptr0 = (Color *)JS_GetOpaque2(ctx, argv[0], js_Color_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + Rectangle arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[2], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg2.x = (float)x_double; - Color arg0 = *argptr0; - double arg1; - JS_ToFloat64(ctx, &arg1, argv[1]); + JSValue y = JS_GetPropertyUint32(ctx, argv[2], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg2.y = (float)y_double; + + JSValue w = JS_GetPropertyUint32(ctx, argv[2], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg2.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[2], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg2.height = (float)h_double; + } + else { - Color returnVal = ColorBrightness(arg0, arg1); + Rectangle * argptr2 = (Rectangle *)JS_GetOpaque2(ctx, argv[2], js_Rectangle_class_id); + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + Vector2 * arg3 = (Vector2 *)JS_GetOpaque2(ctx, argv[3], js_Vector2_class_id); + Rectangle * arg4 = (Rectangle *)JS_GetOpaque2(ctx, argv[4], js_Rectangle_class_id); - - Color* ret_ptr = (Color *)js_malloc(ctx, sizeof(Color)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Color_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - + int ret = GuiScrollPanel(arg0, arg1, arg2, arg3, arg4); + + JS_FreeCString(ctx, arg1); + + return JS_NewInt32(ctx, ret); } -static JSValue js_ColorContrast(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiLabel(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Color * argptr0 = (Color *)JS_GetOpaque2(ctx, argv[0], js_Color_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Color arg0 = *argptr0; - double arg1; - JS_ToFloat64(ctx, &arg1, argv[1]); - Color returnVal = ColorContrast(arg0, arg1); + Rectangle arg0; - - Color* ret_ptr = (Color *)js_malloc(ctx, sizeof(Color)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Color_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_ColorAlpha(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Color * argptr0 = (Color *)JS_GetOpaque2(ctx, argv[0], js_Color_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Color arg0 = *argptr0; - double arg1; - JS_ToFloat64(ctx, &arg1, argv[1]); + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue w = JS_GetPropertyUint32(ctx, argv[0], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg0.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[0], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg0.height = (float)h_double; + } + else { - Color returnVal = ColorAlpha(arg0, arg1); + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); - - Color* ret_ptr = (Color *)js_malloc(ctx, sizeof(Color)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Color_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - + int ret = GuiLabel(arg0, arg1); + + JS_FreeCString(ctx, arg1); + + return JS_NewInt32(ctx, ret); } -static JSValue js_ColorAlphaBlend(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiButton(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Color * argptr0 = (Color *)JS_GetOpaque2(ctx, argv[0], js_Color_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + Rectangle arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Color arg0 = *argptr0; - Color * argptr1 = (Color *)JS_GetOpaque2(ctx, argv[1], js_Color_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; - Color arg1 = *argptr1; - Color * argptr2 = (Color *)JS_GetOpaque2(ctx, argv[2], js_Color_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; + JSValue w = JS_GetPropertyUint32(ctx, argv[0], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg0.width = (float)w_double; - Color arg2 = *argptr2; + JSValue h = JS_GetPropertyUint32(ctx, argv[0], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg0.height = (float)h_double; + } + else { - Color returnVal = ColorAlphaBlend(arg0, arg1, arg2); + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); - - Color* ret_ptr = (Color *)js_malloc(ctx, sizeof(Color)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Color_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - + int ret = GuiButton(arg0, arg1); + + JS_FreeCString(ctx, arg1); + + return JS_NewInt32(ctx, ret); } -static JSValue js_GetColor(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiLabelButton(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - unsigned int arg0; - JS_ToUint32(ctx, &arg0, argv[0]); - Color returnVal = GetColor(arg0); + Rectangle arg0; - - Color* ret_ptr = (Color *)js_malloc(ctx, sizeof(Color)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Color_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_GetPixelColor(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ -size_t data_size0; - void * arg0 = (void *)JS_GetArrayBuffer(ctx, &data_size0, argv[0]); - int arg1; - JS_ToInt32(ctx, &arg1, argv[1]); + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue w = JS_GetPropertyUint32(ctx, argv[0], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg0.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[0], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg0.height = (float)h_double; + } + else { - Color returnVal = GetPixelColor(arg0, arg1); + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); - - Color* ret_ptr = (Color *)js_malloc(ctx, sizeof(Color)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Color_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - + int ret = GuiLabelButton(arg0, arg1); + + JS_FreeCString(ctx, arg1); + + return JS_NewInt32(ctx, ret); } -static JSValue js_SetPixelColor(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiToggle(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { -size_t data_size0; - void * arg0 = (void *)JS_GetArrayBuffer(ctx, &data_size0, argv[0]); - Color * argptr1 = (Color *)JS_GetOpaque2(ctx, argv[1], js_Color_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; - - Color arg1 = *argptr1; - int arg2; - JS_ToInt32(ctx, &arg2, argv[2]); - SetPixelColor(arg0, arg1, arg2); + Rectangle arg0; - return JS_UNDEFINED; -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_GetPixelDataSize(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - int arg0; - JS_ToInt32(ctx, &arg0, argv[0]); - int arg1; - JS_ToInt32(ctx, &arg1, argv[1]); - int arg2; - JS_ToInt32(ctx, &arg2, argv[2]); + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue w = JS_GetPropertyUint32(ctx, argv[0], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg0.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[0], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg0.height = (float)h_double; + } + else { - int ret = GetPixelDataSize(arg0, arg1, arg2); + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); +JSValue arg2_js = JS_GetPropertyStr(ctx, argv[2], "active"); + int arg2_int; + JS_ToInt32(ctx, &arg2_int, arg2_js); + int * arg2 = &arg2_int; + + int ret = GuiToggle(arg0, arg1, arg2); + JS_FreeCString(ctx, arg1); +JS_SetPropertyStr(ctx, argv[2], "active", JS_NewInt32(ctx, arg2_int)); return JS_NewInt32(ctx, ret); } -static JSValue js_GetFontDefault(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiToggleGroup(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Font returnVal = GetFontDefault(); + Rectangle arg0; - - Font* ret_ptr = (Font *)js_malloc(ctx, sizeof(Font)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Font_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_LoadFont(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue w = JS_GetPropertyUint32(ctx, argv[0], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg0.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[0], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg0.height = (float)h_double; + } + else { - Font returnVal = LoadFont(arg0); + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); - JS_FreeCString(ctx, arg0); + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); +JSValue arg2_js = JS_GetPropertyStr(ctx, argv[2], "active"); + int arg2_int; + JS_ToInt32(ctx, &arg2_int, arg2_js); + int * arg2 = &arg2_int; + + int ret = GuiToggleGroup(arg0, arg1, arg2); - - Font* ret_ptr = (Font *)js_malloc(ctx, sizeof(Font)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Font_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - + JS_FreeCString(ctx, arg1); +JS_SetPropertyStr(ctx, argv[2], "active", JS_NewInt32(ctx, arg2_int)); + + return JS_NewInt32(ctx, ret); } -static JSValue js_LoadFontEx(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiToggleSlider(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); - int arg1; - JS_ToInt32(ctx, &arg1, argv[1]); -JSValue arg2_js = JS_GetPropertyStr(ctx, argv[2], "codepoints"); + + + Rectangle arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue w = JS_GetPropertyUint32(ctx, argv[0], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg0.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[0], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg0.height = (float)h_double; + } + else { + + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); +JSValue arg2_js = JS_GetPropertyStr(ctx, argv[2], "active"); int arg2_int; JS_ToInt32(ctx, &arg2_int, arg2_js); int * arg2 = &arg2_int; - int arg3; - JS_ToInt32(ctx, &arg3, argv[3]); - - Font returnVal = LoadFontEx(arg0, arg1, arg2, arg3); + + int ret = GuiToggleSlider(arg0, arg1, arg2); - JS_FreeCString(ctx, arg0); -JS_SetPropertyStr(ctx, argv[2], "codepoints", JS_NewInt32(ctx, arg2_int)); + JS_FreeCString(ctx, arg1); +JS_SetPropertyStr(ctx, argv[2], "active", JS_NewInt32(ctx, arg2_int)); - - Font* ret_ptr = (Font *)js_malloc(ctx, sizeof(Font)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Font_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - + return JS_NewInt32(ctx, ret); } -static JSValue js_LoadFontFromImage(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiCheckBox(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Image * argptr0 = (Image *)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + Rectangle arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Image arg0 = *argptr0; - Color * argptr1 = (Color *)JS_GetOpaque2(ctx, argv[1], js_Color_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; - Color arg1 = *argptr1; - int arg2; - JS_ToInt32(ctx, &arg2, argv[2]); + JSValue w = JS_GetPropertyUint32(ctx, argv[0], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg0.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[0], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg0.height = (float)h_double; + } + else { - Font returnVal = LoadFontFromImage(arg0, arg1, arg2); + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); +JSValue arg2_js = JS_GetPropertyStr(ctx, argv[2], "checked"); + int arg2_int; + JS_ToInt32(ctx, &arg2_int, arg2_js); + int * arg2 = &arg2_int; + + int ret = GuiCheckBox(arg0, arg1, arg2); + JS_FreeCString(ctx, arg1); +JS_SetPropertyStr(ctx, argv[2], "checked", JS_NewInt32(ctx, arg2_int)); - - Font* ret_ptr = (Font *)js_malloc(ctx, sizeof(Font)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Font_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - + return JS_NewInt32(ctx, ret); } -static JSValue js_LoadFontFromMemory(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiComboBox(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); -size_t data_size1; - const unsigned char * arg1 = (const unsigned char *)JS_GetArrayBuffer(ctx, &data_size1, argv[1]); - int arg2; - JS_ToInt32(ctx, &arg2, argv[2]); - int arg3; - JS_ToInt32(ctx, &arg3, argv[3]); -JSValue arg4_js = JS_GetPropertyStr(ctx, argv[4], "codepoints"); - int arg4_int; - JS_ToInt32(ctx, &arg4_int, arg4_js); - int * arg4 = &arg4_int; - int arg5; - JS_ToInt32(ctx, &arg5, argv[5]); - Font returnVal = LoadFontFromMemory(arg0, arg1, arg2, arg3, arg4, arg5); - JS_FreeCString(ctx, arg0); -JS_SetPropertyStr(ctx, argv[4], "codepoints", JS_NewInt32(ctx, arg4_int)); + Rectangle arg0; - - Font* ret_ptr = (Font *)js_malloc(ctx, sizeof(Font)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Font_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_IsFontReady(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Font * argptr0 = (Font *)JS_GetOpaque2(ctx, argv[0], js_Font_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Font arg0 = *argptr0; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue w = JS_GetPropertyUint32(ctx, argv[0], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg0.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[0], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg0.height = (float)h_double; + } + else { - bool ret = IsFontReady(arg0); + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); +JSValue arg2_js = JS_GetPropertyStr(ctx, argv[2], "active"); + int arg2_int; + JS_ToInt32(ctx, &arg2_int, arg2_js); + int * arg2 = &arg2_int; + + int ret = GuiComboBox(arg0, arg1, arg2); - return JS_NewBool(ctx, ret); + JS_FreeCString(ctx, arg1); +JS_SetPropertyStr(ctx, argv[2], "active", JS_NewInt32(ctx, arg2_int)); + + return JS_NewInt32(ctx, ret); } -static JSValue js_UnloadFont(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiDropdownBox(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Font * argptr0 = (Font *)JS_GetOpaque2(ctx, argv[0], js_Font_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Font arg0 = *argptr0; - UnloadFont(arg0); + Rectangle arg0; - return JS_UNDEFINED; -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_ExportFontAsCode(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Font * argptr0 = (Font *)JS_GetOpaque2(ctx, argv[0], js_Font_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Font arg0 = *argptr0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue w = JS_GetPropertyUint32(ctx, argv[0], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg0.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[0], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg0.height = (float)h_double; + } + else { - bool ret = ExportFontAsCode(arg0, arg1); + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); +JSValue arg2_js = JS_GetPropertyStr(ctx, argv[2], "active"); + int arg2_int; + JS_ToInt32(ctx, &arg2_int, arg2_js); + int * arg2 = &arg2_int; + JS_BOOL argbool3 = JS_ToBool(ctx, argv[3]); + bool arg3 = (bool) argbool3; + + int ret = GuiDropdownBox(arg0, arg1, arg2, arg3); JS_FreeCString(ctx, arg1); +JS_SetPropertyStr(ctx, argv[2], "active", JS_NewInt32(ctx, arg2_int)); - return JS_NewBool(ctx, ret); + return JS_NewInt32(ctx, ret); } -static JSValue js_DrawFPS(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiSpinner(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - int arg0; - JS_ToInt32(ctx, &arg0, argv[0]); - int arg1; - JS_ToInt32(ctx, &arg1, argv[1]); - DrawFPS(arg0, arg1); + Rectangle arg0; - return JS_UNDEFINED; -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_DrawText(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); - int arg1; - JS_ToInt32(ctx, &arg1, argv[1]); - int arg2; - JS_ToInt32(ctx, &arg2, argv[2]); - int arg3; - JS_ToInt32(ctx, &arg3, argv[3]); - Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); - if (argptr4 == NULL) return JS_EXCEPTION; + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; - Color arg4 = *argptr4; + JSValue w = JS_GetPropertyUint32(ctx, argv[0], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg0.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[0], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg0.height = (float)h_double; + } + else { - DrawText(arg0, arg1, arg2, arg3, arg4); + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); - JS_FreeCString(ctx, arg0); + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); +JSValue arg2_js = JS_GetPropertyStr(ctx, argv[2], "value"); + int arg2_int; + JS_ToInt32(ctx, &arg2_int, arg2_js); + int * arg2 = &arg2_int; + int arg3; + JS_ToInt32(ctx, &arg3, argv[3]); + int arg4; + JS_ToInt32(ctx, &arg4, argv[4]); + JS_BOOL argbool5 = JS_ToBool(ctx, argv[5]); + bool arg5 = (bool) argbool5; - return JS_UNDEFINED; + int ret = GuiSpinner(arg0, arg1, arg2, arg3, arg4, arg5); + + JS_FreeCString(ctx, arg1); +JS_SetPropertyStr(ctx, argv[2], "value", JS_NewInt32(ctx, arg2_int)); + + return JS_NewInt32(ctx, ret); } -static JSValue js_DrawTextEx(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiValueBox(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Font * argptr0 = (Font *)JS_GetOpaque2(ctx, argv[0], js_Font_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + Rectangle arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Font arg0 = *argptr0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); - Vector2 * argptr2 = (Vector2 *)JS_GetOpaque2(ctx, argv[2], js_Vector2_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; - Vector2 arg2 = *argptr2; - double arg3; - JS_ToFloat64(ctx, &arg3, argv[3]); - double arg4; - JS_ToFloat64(ctx, &arg4, argv[4]); - Color * argptr5 = (Color *)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); - if (argptr5 == NULL) return JS_EXCEPTION; + JSValue w = JS_GetPropertyUint32(ctx, argv[0], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg0.width = (float)w_double; - Color arg5 = *argptr5; + JSValue h = JS_GetPropertyUint32(ctx, argv[0], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg0.height = (float)h_double; + } + else { - DrawTextEx(arg0, arg1, arg2, arg3, arg4, arg5); + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); +JSValue arg2_js = JS_GetPropertyStr(ctx, argv[2], "value"); + int arg2_int; + JS_ToInt32(ctx, &arg2_int, arg2_js); + int * arg2 = &arg2_int; + int arg3; + JS_ToInt32(ctx, &arg3, argv[3]); + int arg4; + JS_ToInt32(ctx, &arg4, argv[4]); + JS_BOOL argbool5 = JS_ToBool(ctx, argv[5]); + bool arg5 = (bool) argbool5; + + int ret = GuiValueBox(arg0, arg1, arg2, arg3, arg4, arg5); JS_FreeCString(ctx, arg1); +JS_SetPropertyStr(ctx, argv[2], "value", JS_NewInt32(ctx, arg2_int)); - return JS_UNDEFINED; + return JS_NewInt32(ctx, ret); } -static JSValue js_DrawTextPro(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiValueBoxFloat(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Font * argptr0 = (Font *)JS_GetOpaque2(ctx, argv[0], js_Font_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Font arg0 = *argptr0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); - Vector2 * argptr2 = (Vector2 *)JS_GetOpaque2(ctx, argv[2], js_Vector2_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; + + + Rectangle arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Vector2 arg2 = *argptr2; - Vector2 * argptr3 = (Vector2 *)JS_GetOpaque2(ctx, argv[3], js_Vector2_class_id); - if (argptr3 == NULL) return JS_EXCEPTION; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; - Vector2 arg3 = *argptr3; - double arg4; - JS_ToFloat64(ctx, &arg4, argv[4]); - double arg5; - JS_ToFloat64(ctx, &arg5, argv[5]); - double arg6; - JS_ToFloat64(ctx, &arg6, argv[6]); - Color * argptr7 = (Color *)JS_GetOpaque2(ctx, argv[7], js_Color_class_id); - if (argptr7 == NULL) return JS_EXCEPTION; + JSValue w = JS_GetPropertyUint32(ctx, argv[0], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg0.width = (float)w_double; - Color arg7 = *argptr7; + JSValue h = JS_GetPropertyUint32(ctx, argv[0], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg0.height = (float)h_double; + } + else { - DrawTextPro(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); + JSValue arg2_js = JS_GetPropertyStr(ctx, argv[2], "textValue"); + size_t arg2_len; + const char * arg2_str = JS_ToCStringLen(ctx, &arg2_len, arg2_js); + char * arg2 = malloc(arg2_len+1); + memcpy((void *)arg2, arg2_str, arg2_len); + arg2[arg2_len] = 0; + JSValue arg3_js = JS_GetPropertyStr(ctx, argv[3], "value"); + double arg3_double; + JS_ToFloat64(ctx, &arg3_double, arg3_js); + float arg3_float = (float)arg3_double; + float * arg3 = &arg3_float; + JS_BOOL argbool4 = JS_ToBool(ctx, argv[4]); + bool arg4 = (bool) argbool4; + + int ret = GuiValueBoxFloat(arg0, arg1, arg2, arg3, arg4); JS_FreeCString(ctx, arg1); + JS_FreeCString(ctx, arg2_str); + JS_SetPropertyStr(ctx, argv[2], "textValue", JS_NewString(ctx, arg2)); + free(arg2); +JS_SetPropertyStr(ctx, argv[3], "value", JS_NewFloat64(ctx, arg3_float)); - return JS_UNDEFINED; + return JS_NewInt32(ctx, ret); } -static JSValue js_DrawTextCodepoint(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiTextBox(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Font * argptr0 = (Font *)JS_GetOpaque2(ctx, argv[0], js_Font_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + Rectangle arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Font arg0 = *argptr0; - int arg1; - JS_ToInt32(ctx, &arg1, argv[1]); - Vector2 * argptr2 = (Vector2 *)JS_GetOpaque2(ctx, argv[2], js_Vector2_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; - Vector2 arg2 = *argptr2; - double arg3; - JS_ToFloat64(ctx, &arg3, argv[3]); - Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); - if (argptr4 == NULL) return JS_EXCEPTION; + JSValue w = JS_GetPropertyUint32(ctx, argv[0], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg0.width = (float)w_double; - Color arg4 = *argptr4; + JSValue h = JS_GetPropertyUint32(ctx, argv[0], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg0.height = (float)h_double; + } + else { - DrawTextCodepoint(arg0, arg1, arg2, arg3, arg4); + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + JSValue arg1_js = JS_GetPropertyStr(ctx, argv[1], "text"); + size_t arg1_len; + const char * arg1_str = JS_ToCStringLen(ctx, &arg1_len, arg1_js); + char * arg1 = malloc(arg1_len+1); + memcpy((void *)arg1, arg1_str, arg1_len); + arg1[arg1_len] = 0; + int arg2; + JS_ToInt32(ctx, &arg2, argv[2]); + JS_BOOL argbool3 = JS_ToBool(ctx, argv[3]); + bool arg3 = (bool) argbool3; + int ret = GuiTextBox(arg0, arg1, arg2, arg3); - return JS_UNDEFINED; + JS_FreeCString(ctx, arg1_str); + JS_SetPropertyStr(ctx, argv[1], "text", JS_NewString(ctx, arg1)); + free(arg1); + + return JS_NewInt32(ctx, ret); } -static JSValue js_DrawTextCodepoints(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiSlider(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Font * argptr0 = (Font *)JS_GetOpaque2(ctx, argv[0], js_Font_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + Rectangle arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Font arg0 = *argptr0; -JSValue arg1_js = JS_GetPropertyStr(ctx, argv[1], "codepoints"); - int arg1_int; - JS_ToInt32(ctx, &arg1_int, arg1_js); - int * arg1 = &arg1_int; - int arg2; - JS_ToInt32(ctx, &arg2, argv[2]); - Vector2 * argptr3 = (Vector2 *)JS_GetOpaque2(ctx, argv[3], js_Vector2_class_id); - if (argptr3 == NULL) return JS_EXCEPTION; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; - Vector2 arg3 = *argptr3; - double arg4; + JSValue w = JS_GetPropertyUint32(ctx, argv[0], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg0.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[0], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg0.height = (float)h_double; + } + else { + + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); + const char * arg2 = (const char *)JS_ToCString(ctx, argv[2]); +JSValue arg3_js = JS_GetPropertyStr(ctx, argv[3], "value"); + double arg3_double; + JS_ToFloat64(ctx, &arg3_double, arg3_js); + float arg3_float = (float)arg3_double; + float * arg3 = &arg3_float; + double arg4; JS_ToFloat64(ctx, &arg4, argv[4]); double arg5; JS_ToFloat64(ctx, &arg5, argv[5]); - Color * argptr6 = (Color *)JS_GetOpaque2(ctx, argv[6], js_Color_class_id); - if (argptr6 == NULL) return JS_EXCEPTION; - - Color arg6 = *argptr6; - DrawTextCodepoints(arg0, arg1, arg2, arg3, arg4, arg5, arg6); + int ret = GuiSlider(arg0, arg1, arg2, arg3, arg4, arg5); -JS_SetPropertyStr(ctx, argv[1], "codepoints", JS_NewInt32(ctx, arg1_int)); + JS_FreeCString(ctx, arg1); + JS_FreeCString(ctx, arg2); +JS_SetPropertyStr(ctx, argv[3], "value", JS_NewFloat64(ctx, arg3_float)); - return JS_UNDEFINED; + return JS_NewInt32(ctx, ret); } -static JSValue js_SetTextLineSpacing(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiSliderBar(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - int arg0; - JS_ToInt32(ctx, &arg0, argv[0]); - SetTextLineSpacing(arg0); + Rectangle arg0; - return JS_UNDEFINED; -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_MeasureText(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); - int arg1; - JS_ToInt32(ctx, &arg1, argv[1]); + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue w = JS_GetPropertyUint32(ctx, argv[0], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg0.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[0], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg0.height = (float)h_double; + } + else { - int ret = MeasureText(arg0, arg1); + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); - JS_FreeCString(ctx, arg0); + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); + const char * arg2 = (const char *)JS_ToCString(ctx, argv[2]); +JSValue arg3_js = JS_GetPropertyStr(ctx, argv[3], "value"); + double arg3_double; + JS_ToFloat64(ctx, &arg3_double, arg3_js); + float arg3_float = (float)arg3_double; + float * arg3 = &arg3_float; + double arg4; + JS_ToFloat64(ctx, &arg4, argv[4]); + double arg5; + JS_ToFloat64(ctx, &arg5, argv[5]); + + int ret = GuiSliderBar(arg0, arg1, arg2, arg3, arg4, arg5); + + JS_FreeCString(ctx, arg1); + JS_FreeCString(ctx, arg2); +JS_SetPropertyStr(ctx, argv[3], "value", JS_NewFloat64(ctx, arg3_float)); return JS_NewInt32(ctx, ret); } -static JSValue js_MeasureTextEx(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiProgressBar(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Font * argptr0 = (Font *)JS_GetOpaque2(ctx, argv[0], js_Font_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Font arg0 = *argptr0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); - double arg2; - JS_ToFloat64(ctx, &arg2, argv[2]); - double arg3; - JS_ToFloat64(ctx, &arg3, argv[3]); - Vector2 returnVal = MeasureTextEx(arg0, arg1, arg2, arg3); - JS_FreeCString(ctx, arg1); + Rectangle arg0; - - Vector2* ret_ptr = (Vector2 *)js_malloc(ctx, sizeof(Vector2)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Vector2_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_GetGlyphIndex(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Font * argptr0 = (Font *)JS_GetOpaque2(ctx, argv[0], js_Font_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Font arg0 = *argptr0; - int arg1; - JS_ToInt32(ctx, &arg1, argv[1]); + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue w = JS_GetPropertyUint32(ctx, argv[0], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg0.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[0], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg0.height = (float)h_double; + } + else { - int ret = GetGlyphIndex(arg0, arg1); + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); + const char * arg2 = (const char *)JS_ToCString(ctx, argv[2]); +JSValue arg3_js = JS_GetPropertyStr(ctx, argv[3], "value"); + double arg3_double; + JS_ToFloat64(ctx, &arg3_double, arg3_js); + float arg3_float = (float)arg3_double; + float * arg3 = &arg3_float; + double arg4; + JS_ToFloat64(ctx, &arg4, argv[4]); + double arg5; + JS_ToFloat64(ctx, &arg5, argv[5]); + + int ret = GuiProgressBar(arg0, arg1, arg2, arg3, arg4, arg5); + JS_FreeCString(ctx, arg1); + JS_FreeCString(ctx, arg2); +JS_SetPropertyStr(ctx, argv[3], "value", JS_NewFloat64(ctx, arg3_float)); return JS_NewInt32(ctx, ret); } -static JSValue js_GetGlyphInfo(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiStatusBar(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Font * argptr0 = (Font *)JS_GetOpaque2(ctx, argv[0], js_Font_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Font arg0 = *argptr0; - int arg1; - JS_ToInt32(ctx, &arg1, argv[1]); - GlyphInfo returnVal = GetGlyphInfo(arg0, arg1); + Rectangle arg0; - - GlyphInfo* ret_ptr = (GlyphInfo *)js_malloc(ctx, sizeof(GlyphInfo)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_GlyphInfo_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_GetGlyphAtlasRec(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Font * argptr0 = (Font *)JS_GetOpaque2(ctx, argv[0], js_Font_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Font arg0 = *argptr0; - int arg1; - JS_ToInt32(ctx, &arg1, argv[1]); - - Rectangle returnVal = GetGlyphAtlasRec(arg0, arg1); - + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue w = JS_GetPropertyUint32(ctx, argv[0], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg0.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[0], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg0.height = (float)h_double; + } + else { - - Rectangle* ret_ptr = (Rectangle *)js_malloc(ctx, sizeof(Rectangle)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Rectangle_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - -} + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); -static JSValue js_LoadUTF8(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ -JSValue arg0_js = JS_GetPropertyStr(ctx, argv[0], "codepoints"); - int arg0_int; - JS_ToInt32(ctx, &arg0_int, arg0_js); - int * arg0 = &arg0_int; - int arg1; - JS_ToInt32(ctx, &arg1, argv[1]); + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); - char * retVal = LoadUTF8(arg0, arg1); + int ret = GuiStatusBar(arg0, arg1); -JS_SetPropertyStr(ctx, argv[0], "codepoints", JS_NewInt32(ctx, arg0_int)); + JS_FreeCString(ctx, arg1); - JSValue ret = JS_NewArrayBufferCopy(ctx, (const uint8_t*)retVal, 7777 /*<>*/); - return ret; + return JS_NewInt32(ctx, ret); } -static JSValue js_UnloadUTF8(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiDummyRec(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - JSValue arg0_js = JS_GetPropertyStr(ctx, argv[0], "text"); - size_t arg0_len; - const char * arg0_str = JS_ToCStringLen(ctx, &arg0_len, arg0_js); - char * arg0 = malloc(arg0_len+1); - memcpy((void *)arg0, arg0_str, arg0_len); - arg0[arg0_len] = 0; - - UnloadUTF8(arg0); - JS_FreeCString(ctx, arg0_str); - JS_SetPropertyStr(ctx, argv[0], "text", JS_NewString(ctx, arg0)); - free(arg0); - return JS_UNDEFINED; -} + Rectangle arg0; -static JSValue js_LoadCodepoints(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); -JSValue arg1_js = JS_GetPropertyStr(ctx, argv[1], "count"); - int arg1_int; - JS_ToInt32(ctx, &arg1_int, arg1_js); - int * arg1 = &arg1_int; + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - int * retBuf = LoadCodepoints(arg0, arg1); + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue w = JS_GetPropertyUint32(ctx, argv[0], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg0.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[0], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg0.height = (float)h_double; + } + else { - JS_FreeCString(ctx, arg0); -JS_SetPropertyStr(ctx, argv[1], "count", JS_NewInt32(ctx, arg1_int)); + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); - JSValue ret = JS_NewArray(ctx); - for(int i; i < 7777 /*<>*/; i++){ - JS_SetPropertyUint32(ctx, ret, i, JS_NewInt32(ctx, retBuf[i])); - } - return ret; - -} + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); -static JSValue js_UnloadCodepoints(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ -JSValue arg0_js = JS_GetPropertyStr(ctx, argv[0], "codepoints"); - int arg0_int; - JS_ToInt32(ctx, &arg0_int, arg0_js); - int * arg0 = &arg0_int; - - UnloadCodepoints(arg0); + int ret = GuiDummyRec(arg0, arg1); -JS_SetPropertyStr(ctx, argv[0], "codepoints", JS_NewInt32(ctx, arg0_int)); + JS_FreeCString(ctx, arg1); - return JS_UNDEFINED; + return JS_NewInt32(ctx, ret); } -static JSValue js_GetCodepointCount(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiGrid(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); - int ret = GetCodepointCount(arg0); - JS_FreeCString(ctx, arg0); + Rectangle arg0; - return JS_NewInt32(ctx, ret); -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_GetCodepoint(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); -JSValue arg1_js = JS_GetPropertyStr(ctx, argv[1], "codepointSize"); - int arg1_int; - JS_ToInt32(ctx, &arg1_int, arg1_js); - int * arg1 = &arg1_int; + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - int ret = GetCodepoint(arg0, arg1); + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue w = JS_GetPropertyUint32(ctx, argv[0], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg0.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[0], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg0.height = (float)h_double; + } + else { - JS_FreeCString(ctx, arg0); -JS_SetPropertyStr(ctx, argv[1], "codepointSize", JS_NewInt32(ctx, arg1_int)); + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); - return JS_NewInt32(ctx, ret); -} + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); + int arg3; + JS_ToInt32(ctx, &arg3, argv[3]); + Vector2 * arg4 = (Vector2 *)JS_GetOpaque2(ctx, argv[4], js_Vector2_class_id); -static JSValue js_GetCodepointNext(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); -JSValue arg1_js = JS_GetPropertyStr(ctx, argv[1], "codepointSize"); - int arg1_int; - JS_ToInt32(ctx, &arg1_int, arg1_js); - int * arg1 = &arg1_int; - - int ret = GetCodepointNext(arg0, arg1); + int ret = GuiGrid(arg0, arg1, arg2, arg3, arg4); - JS_FreeCString(ctx, arg0); -JS_SetPropertyStr(ctx, argv[1], "codepointSize", JS_NewInt32(ctx, arg1_int)); + JS_FreeCString(ctx, arg1); return JS_NewInt32(ctx, ret); } -static JSValue js_GetCodepointPrevious(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiListView(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); -JSValue arg1_js = JS_GetPropertyStr(ctx, argv[1], "codepointSize"); - int arg1_int; - JS_ToInt32(ctx, &arg1_int, arg1_js); - int * arg1 = &arg1_int; + + + Rectangle arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - int ret = GetCodepointPrevious(arg0, arg1); + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue w = JS_GetPropertyUint32(ctx, argv[0], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg0.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[0], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg0.height = (float)h_double; + } + else { + + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); +JSValue arg2_js = JS_GetPropertyStr(ctx, argv[2], "scrollIndex"); + int arg2_int; + JS_ToInt32(ctx, &arg2_int, arg2_js); + int * arg2 = &arg2_int; + JSValue arg3_js = JS_GetPropertyStr(ctx, argv[3], "active"); + int arg3_int; + JS_ToInt32(ctx, &arg3_int, arg3_js); + int * arg3 = &arg3_int; + + int ret = GuiListView(arg0, arg1, arg2, arg3); - JS_FreeCString(ctx, arg0); -JS_SetPropertyStr(ctx, argv[1], "codepointSize", JS_NewInt32(ctx, arg1_int)); + JS_FreeCString(ctx, arg1); +JS_SetPropertyStr(ctx, argv[2], "scrollIndex", JS_NewInt32(ctx, arg2_int)); +JS_SetPropertyStr(ctx, argv[3], "active", JS_NewInt32(ctx, arg3_int)); return JS_NewInt32(ctx, ret); } -static JSValue js_CodepointToUTF8(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiListViewEx(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - int arg0; - JS_ToInt32(ctx, &arg0, argv[0]); -JSValue arg1_js = JS_GetPropertyStr(ctx, argv[1], "utf8Size"); - int arg1_int; - JS_ToInt32(ctx, &arg1_int, arg1_js); - int * arg1 = &arg1_int; + + + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; - const char * returnVal = CodepointToUTF8(arg0, arg1); + Rectangle arg0 = *argptr0; -JS_SetPropertyStr(ctx, argv[1], "utf8Size", JS_NewInt32(ctx, arg1_int)); + JSValue length_js = JS_GetProperty(ctx, argv[1], JS_ATOM_length); + + int32_t length; + + JS_ToInt32(ctx, &length, length_js); - JSValue ret = JS_NewString(ctx, returnVal); - return ret; -} + char ** text = (char **)malloc((length+1)*sizeof(char *)); -static JSValue js_TextCopy(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - JSValue arg0_js = JS_GetPropertyStr(ctx, argv[0], "dst"); - size_t arg0_len; - const char * arg0_str = JS_ToCStringLen(ctx, &arg0_len, arg0_js); - char * arg0 = malloc(arg0_len+1); - memcpy((void *)arg0, arg0_str, arg0_len); - arg0[arg0_len] = 0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); + text[length] = 0; - int ret = TextCopy(arg0, arg1); + for (int i=0; i < length; ++i) {{ - JS_FreeCString(ctx, arg0_str); - JS_SetPropertyStr(ctx, argv[0], "dst", JS_NewString(ctx, arg0)); - free(arg0); - JS_FreeCString(ctx, arg1); + JSValue val = JS_GetPropertyUint32(ctx, argv[1], i); - return JS_NewInt32(ctx, ret); -} + text[i] = JS_ToCString(ctx, val); + }} + + int arg2; + JS_ToInt32(ctx, &arg2, argv[2]); -static JSValue js_TextIsEqual(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); + JSValue arg3_js = JS_GetPropertyStr(ctx, argv[3], "scrollIndex"); + int arg3; + JS_ToInt32(ctx, &arg3, arg3_js); - bool ret = TextIsEqual(arg0, arg1); + JSValue arg4_js = JS_GetPropertyStr(ctx, argv[4], "active"); + int arg4; + JS_ToInt32(ctx, &arg4, arg4_js); - JS_FreeCString(ctx, arg0); - JS_FreeCString(ctx, arg1); + JSValue arg5_js = JS_GetPropertyStr(ctx, argv[5], "focus"); + int arg5; + JS_ToInt32(ctx, &arg5, arg5_js); - return JS_NewBool(ctx, ret); -} + int ret = GuiListViewEx(arg0, text, arg2, &arg3, &arg4, &arg5); -static JSValue js_TextLength(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); + JS_SetPropertyStr(ctx, argv[3], "scrollIndex", JS_NewInt32(ctx, arg3)); + JS_SetPropertyStr(ctx, argv[4], "active", JS_NewInt32(ctx, arg4)); + JS_SetPropertyStr(ctx, argv[5], "focus", JS_NewInt32(ctx, arg5)); - unsigned int ret = TextLength(arg0); + for (int i=0; i < length; ++i) {{ - JS_FreeCString(ctx, arg0); + JS_FreeCString(ctx, text[i]); + }} + + if (text) + free(text); - return JS_NewUint32(ctx, ret); + return JS_NewInt32(ctx, ret); } -static JSValue js_TextSubtext(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiMessageBox(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); - int arg1; - JS_ToInt32(ctx, &arg1, argv[1]); - int arg2; - JS_ToInt32(ctx, &arg2, argv[2]); - const char * returnVal = TextSubtext(arg0, arg1, arg2); - JS_FreeCString(ctx, arg0); + Rectangle arg0; - JSValue ret = JS_NewString(ctx, returnVal); - return ret; -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_TextReplace(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - JSValue arg0_js = JS_GetPropertyStr(ctx, argv[0], "text"); - size_t arg0_len; - const char * arg0_str = JS_ToCStringLen(ctx, &arg0_len, arg0_js); - char * arg0 = malloc(arg0_len+1); - memcpy((void *)arg0, arg0_str, arg0_len); - arg0[arg0_len] = 0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue w = JS_GetPropertyUint32(ctx, argv[0], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg0.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[0], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg0.height = (float)h_double; + } + else { + + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); const char * arg2 = (const char *)JS_ToCString(ctx, argv[2]); + const char * arg3 = (const char *)JS_ToCString(ctx, argv[3]); - char * retVal = TextReplace(arg0, arg1, arg2); + int ret = GuiMessageBox(arg0, arg1, arg2, arg3); - JS_FreeCString(ctx, arg0_str); - JS_SetPropertyStr(ctx, argv[0], "text", JS_NewString(ctx, arg0)); - free(arg0); JS_FreeCString(ctx, arg1); JS_FreeCString(ctx, arg2); + JS_FreeCString(ctx, arg3); - JSValue ret = JS_NewArrayBufferCopy(ctx, (const uint8_t*)retVal, 7777 /*<>*/); - return ret; + return JS_NewInt32(ctx, ret); } -static JSValue js_TextInsert(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiTextInputBox(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); - int arg2; - JS_ToInt32(ctx, &arg2, argv[2]); - char * retVal = TextInsert(arg0, arg1, arg2); - JS_FreeCString(ctx, arg0); - JS_FreeCString(ctx, arg1); + Rectangle arg0; - JSValue ret = JS_NewArrayBufferCopy(ctx, (const uint8_t*)retVal, 7777 /*<>*/); - return ret; -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_TextAppend(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - JSValue arg0_js = JS_GetPropertyStr(ctx, argv[0], "text"); - size_t arg0_len; - const char * arg0_str = JS_ToCStringLen(ctx, &arg0_len, arg0_js); - char * arg0 = malloc(arg0_len+1); - memcpy((void *)arg0, arg0_str, arg0_len); - arg0[arg0_len] = 0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); -JSValue arg2_js = JS_GetPropertyStr(ctx, argv[2], "position"); - int arg2_int; - JS_ToInt32(ctx, &arg2_int, arg2_js); - int * arg2 = &arg2_int; + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - TextAppend(arg0, arg1, arg2); + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue w = JS_GetPropertyUint32(ctx, argv[0], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg0.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[0], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg0.height = (float)h_double; + } + else { + + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); + const char * arg2 = (const char *)JS_ToCString(ctx, argv[2]); + const char * arg3 = (const char *)JS_ToCString(ctx, argv[3]); + JSValue arg4_js = JS_GetPropertyStr(ctx, argv[4], "text"); + size_t arg4_len; + const char * arg4_str = JS_ToCStringLen(ctx, &arg4_len, arg4_js); + char * arg4 = malloc(arg4_len+1); + memcpy((void *)arg4, arg4_str, arg4_len); + arg4[arg4_len] = 0; + int arg5; + JS_ToInt32(ctx, &arg5, argv[5]); +JSValue arg6_js = JS_GetPropertyStr(ctx, argv[6], "secretViewActive"); + int arg6_int; + JS_ToInt32(ctx, &arg6_int, arg6_js); + int * arg6 = &arg6_int; + + int ret = GuiTextInputBox(arg0, arg1, arg2, arg3, arg4, arg5, arg6); - JS_FreeCString(ctx, arg0_str); - JS_SetPropertyStr(ctx, argv[0], "text", JS_NewString(ctx, arg0)); - free(arg0); JS_FreeCString(ctx, arg1); -JS_SetPropertyStr(ctx, argv[2], "position", JS_NewInt32(ctx, arg2_int)); + JS_FreeCString(ctx, arg2); + JS_FreeCString(ctx, arg3); + JS_FreeCString(ctx, arg4_str); + JS_SetPropertyStr(ctx, argv[4], "text", JS_NewString(ctx, arg4)); + free(arg4); +JS_SetPropertyStr(ctx, argv[6], "secretViewActive", JS_NewInt32(ctx, arg6_int)); - return JS_UNDEFINED; + return JS_NewInt32(ctx, ret); } -static JSValue js_TextFindIndex(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiColorPicker(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); - int ret = TextFindIndex(arg0, arg1); - JS_FreeCString(ctx, arg0); + Rectangle arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue w = JS_GetPropertyUint32(ctx, argv[0], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg0.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[0], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg0.height = (float)h_double; + } + else { + + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); + Color * arg2 = (Color *)JS_GetOpaque2(ctx, argv[2], js_Color_class_id); + + int ret = GuiColorPicker(arg0, arg1, arg2); + JS_FreeCString(ctx, arg1); return JS_NewInt32(ctx, ret); } -static JSValue js_TextToUpper(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiColorPanel(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); - const char * returnVal = TextToUpper(arg0); - JS_FreeCString(ctx, arg0); + Rectangle arg0; - JSValue ret = JS_NewString(ctx, returnVal); - return ret; -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_TextToLower(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue w = JS_GetPropertyUint32(ctx, argv[0], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg0.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[0], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg0.height = (float)h_double; + } + else { - const char * returnVal = TextToLower(arg0); + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); - JS_FreeCString(ctx, arg0); + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); + Color * arg2 = (Color *)JS_GetOpaque2(ctx, argv[2], js_Color_class_id); - JSValue ret = JS_NewString(ctx, returnVal); - return ret; + int ret = GuiColorPanel(arg0, arg1, arg2); + + JS_FreeCString(ctx, arg1); + + return JS_NewInt32(ctx, ret); } -static JSValue js_TextToPascal(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiColorBarAlpha(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); - const char * returnVal = TextToPascal(arg0); - JS_FreeCString(ctx, arg0); + Rectangle arg0; - JSValue ret = JS_NewString(ctx, returnVal); - return ret; -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_TextToInteger(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue w = JS_GetPropertyUint32(ctx, argv[0], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg0.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[0], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg0.height = (float)h_double; + } + else { - int ret = TextToInteger(arg0); + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); - JS_FreeCString(ctx, arg0); + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); +JSValue arg2_js = JS_GetPropertyStr(ctx, argv[2], "alpha"); + double arg2_double; + JS_ToFloat64(ctx, &arg2_double, arg2_js); + float arg2_float = (float)arg2_double; + float * arg2 = &arg2_float; + + int ret = GuiColorBarAlpha(arg0, arg1, arg2); + + JS_FreeCString(ctx, arg1); +JS_SetPropertyStr(ctx, argv[2], "alpha", JS_NewFloat64(ctx, arg2_float)); return JS_NewInt32(ctx, ret); } -static JSValue js_DrawLine3D(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiColorBarHue(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + Rectangle arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Vector3 arg0 = *argptr0; - Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; - Vector3 arg1 = *argptr1; - Color * argptr2 = (Color *)JS_GetOpaque2(ctx, argv[2], js_Color_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; + JSValue w = JS_GetPropertyUint32(ctx, argv[0], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg0.width = (float)w_double; - Color arg2 = *argptr2; + JSValue h = JS_GetPropertyUint32(ctx, argv[0], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg0.height = (float)h_double; + } + else { - DrawLine3D(arg0, arg1, arg2); + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); +JSValue arg2_js = JS_GetPropertyStr(ctx, argv[2], "value"); + double arg2_double; + JS_ToFloat64(ctx, &arg2_double, arg2_js); + float arg2_float = (float)arg2_double; + float * arg2 = &arg2_float; + + int ret = GuiColorBarHue(arg0, arg1, arg2); + JS_FreeCString(ctx, arg1); +JS_SetPropertyStr(ctx, argv[2], "value", JS_NewFloat64(ctx, arg2_float)); - return JS_UNDEFINED; + return JS_NewInt32(ctx, ret); } -static JSValue js_DrawPoint3D(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiColorPickerHSV(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Vector3 arg0 = *argptr0; - Color * argptr1 = (Color *)JS_GetOpaque2(ctx, argv[1], js_Color_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; - - Color arg1 = *argptr1; - DrawPoint3D(arg0, arg1); + Rectangle arg0; - return JS_UNDEFINED; -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_DrawCircle3D(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Vector3 arg0 = *argptr0; - double arg1; - JS_ToFloat64(ctx, &arg1, argv[1]); - Vector3 * argptr2 = (Vector3 *)JS_GetOpaque2(ctx, argv[2], js_Vector3_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; - Vector3 arg2 = *argptr2; - double arg3; - JS_ToFloat64(ctx, &arg3, argv[3]); - Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); - if (argptr4 == NULL) return JS_EXCEPTION; + JSValue w = JS_GetPropertyUint32(ctx, argv[0], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg0.width = (float)w_double; - Color arg4 = *argptr4; + JSValue h = JS_GetPropertyUint32(ctx, argv[0], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg0.height = (float)h_double; + } + else { - DrawCircle3D(arg0, arg1, arg2, arg3, arg4); + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); + Vector3 * arg2 = (Vector3 *)JS_GetOpaque2(ctx, argv[2], js_Vector3_class_id); - return JS_UNDEFINED; + int ret = GuiColorPickerHSV(arg0, arg1, arg2); + + JS_FreeCString(ctx, arg1); + + return JS_NewInt32(ctx, ret); } -static JSValue js_DrawTriangle3D(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_GuiColorPanelHSV(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Vector3 arg0 = *argptr0; - Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; + + + Rectangle arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Vector3 arg1 = *argptr1; - Vector3 * argptr2 = (Vector3 *)JS_GetOpaque2(ctx, argv[2], js_Vector3_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; - Vector3 arg2 = *argptr2; - Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); - if (argptr3 == NULL) return JS_EXCEPTION; + JSValue w = JS_GetPropertyUint32(ctx, argv[0], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg0.width = (float)w_double; - Color arg3 = *argptr3; + JSValue h = JS_GetPropertyUint32(ctx, argv[0], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg0.height = (float)h_double; + } + else { - DrawTriangle3D(arg0, arg1, arg2, arg3); + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); + Vector3 * arg2 = (Vector3 *)JS_GetOpaque2(ctx, argv[2], js_Vector3_class_id); - return JS_UNDEFINED; + int ret = GuiColorPanelHSV(arg0, arg1, arg2); + + JS_FreeCString(ctx, arg1); + + return JS_NewInt32(ctx, ret); } -static JSValue js_DrawCube(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Vector3 arg0 = *argptr0; - double arg1; - JS_ToFloat64(ctx, &arg1, argv[1]); - double arg2; - JS_ToFloat64(ctx, &arg2, argv[2]); - double arg3; - JS_ToFloat64(ctx, &arg3, argv[3]); - Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); - if (argptr4 == NULL) return JS_EXCEPTION; - - Color arg4 = *argptr4; - DrawCube(arg0, arg1, arg2, arg3, arg4); +static JSClassID js_float3_class_id; + +static JSValue js_float3_get(JSContext *ctx, JSValueConst this_val, int magic) +{ + float3 *s = JS_GetOpaque2(ctx, this_val, js_float3_class_id); + if (!s) + return JS_EXCEPTION; + + + return JS_UNDEFINED; } -static JSValue js_DrawCubeV(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_float3_set(JSContext *ctx, JSValueConst this_val, JSValue val, int magic) { - Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Vector3 arg0 = *argptr0; - Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; - - Vector3 arg1 = *argptr1; - Color * argptr2 = (Color *)JS_GetOpaque2(ctx, argv[2], js_Color_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; - - Color arg2 = *argptr2; - - DrawCubeV(arg0, arg1, arg2); - + float3 *s = JS_GetOpaque2(ctx, this_val, js_float3_class_id); + if (!s) + return JS_EXCEPTION; + + + return JS_UNDEFINED; } -static JSValue js_DrawCubeWires(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static void js_float3_finalizer(JSRuntime *rt, JSValue val) { - Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Vector3 arg0 = *argptr0; - double arg1; - JS_ToFloat64(ctx, &arg1, argv[1]); - double arg2; - JS_ToFloat64(ctx, &arg2, argv[2]); - double arg3; - JS_ToFloat64(ctx, &arg3, argv[3]); - Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); - if (argptr4 == NULL) return JS_EXCEPTION; - - Color arg4 = *argptr4; + float3 *s = JS_GetOpaque(val, js_float3_class_id); + /* Note: 's' can be NULL in case JS_SetOpaque() was not called */ + js_free_rt(rt, s); +} - DrawCubeWires(arg0, arg1, arg2, arg3, arg4); +static JSValue js_float3_ctor(JSContext *ctx, + JSValueConst new_target, + int argc, JSValueConst *argv) +{ + /*emscripten_log(EM_LOG_CONSOLE, "--> js_float3_ctor: argc=%d", argc); - return JS_UNDEFINED; + for (int i=0; i < argc; ++i) { + + emscripten_log(EM_LOG_CONSOLE, "%d: %d", i, JS_VALUE_GET_TAG(argv[i])); + }*/ + + float3 *s; + JSValue obj = JS_UNDEFINED; + JSValue proto; + + s = js_mallocz(ctx, sizeof(*s)); + if (!s) + return JS_EXCEPTION; + + /* using new_target to get the prototype is necessary when the + class is extended. */ + + + proto = JS_GetPropertyStr(ctx, new_target, "prototype"); + if (JS_IsException(proto)) + goto fail; + obj = JS_NewObjectProtoClass(ctx, proto, js_float3_class_id); + JS_FreeValue(ctx, proto); + if (JS_IsException(obj)) + goto fail; + JS_SetOpaque(obj, s); + return obj; + fail: + js_free(ctx, s); + JS_FreeValue(ctx, obj); + return JS_EXCEPTION; } -static JSValue js_DrawCubeWiresV(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSClassDef js_float3_class = { + "float3", + .finalizer = js_float3_finalizer, +}; + +static const JSCFunctionListEntry js_float3_proto_funcs[] = { + JS_CGETSET_MAGIC_DEF("v", js_float3_get, js_float3_set, 0), + + /*JS_PROP_STRING_DEF("[Symbol.toStringTag]", "float3", JS_PROP_CONFIGURABLE ),*/ +}; + +static int js_declare_float3(JSContext *ctx, JSModuleDef *m) { - Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Vector3 arg0 = *argptr0; - Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; - - Vector3 arg1 = *argptr1; - Color * argptr2 = (Color *)JS_GetOpaque2(ctx, argv[2], js_Color_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; - - Color arg2 = *argptr2; + JSValue proto, class; - DrawCubeWiresV(arg0, arg1, arg2); + /* create the class */ + JS_NewClassID(&js_float3_class_id); + JS_NewClass(JS_GetRuntime(ctx), js_float3_class_id, &js_float3_class); + proto = JS_NewObject(ctx); + JS_SetPropertyFunctionList(ctx, proto, js_float3_proto_funcs, countof(js_float3_proto_funcs)); - return JS_UNDEFINED; + class = JS_NewCFunction2(ctx, js_float3_ctor, "float3", 1, JS_CFUNC_constructor, 0); + /* set proto.constructor and ctor.prototype */ + JS_SetConstructor(ctx, class, proto); + JS_SetClassProto(ctx, js_float3_class_id, proto); + + JS_SetModuleExport(ctx, m, "float3", class); + return 0; } -static JSValue js_DrawSphere(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) + + +static JSClassID js_float16_class_id; + +static JSValue js_float16_get(JSContext *ctx, JSValueConst this_val, int magic) { - Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Vector3 arg0 = *argptr0; - double arg1; - JS_ToFloat64(ctx, &arg1, argv[1]); - Color * argptr2 = (Color *)JS_GetOpaque2(ctx, argv[2], js_Color_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; - - Color arg2 = *argptr2; + float16 *s = JS_GetOpaque2(ctx, this_val, js_float16_class_id); + if (!s) + return JS_EXCEPTION; - DrawSphere(arg0, arg1, arg2); + + + + return JS_UNDEFINED; +} +static JSValue js_float16_set(JSContext *ctx, JSValueConst this_val, JSValue val, int magic) +{ + float16 *s = JS_GetOpaque2(ctx, this_val, js_float16_class_id); + if (!s) + return JS_EXCEPTION; + + + return JS_UNDEFINED; } -static JSValue js_DrawSphereEx(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static void js_float16_finalizer(JSRuntime *rt, JSValue val) { - Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Vector3 arg0 = *argptr0; - double arg1; - JS_ToFloat64(ctx, &arg1, argv[1]); - int arg2; - JS_ToInt32(ctx, &arg2, argv[2]); - int arg3; - JS_ToInt32(ctx, &arg3, argv[3]); - Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); - if (argptr4 == NULL) return JS_EXCEPTION; - - Color arg4 = *argptr4; + float16 *s = JS_GetOpaque(val, js_float16_class_id); + /* Note: 's' can be NULL in case JS_SetOpaque() was not called */ + js_free_rt(rt, s); +} - DrawSphereEx(arg0, arg1, arg2, arg3, arg4); +static JSValue js_float16_ctor(JSContext *ctx, + JSValueConst new_target, + int argc, JSValueConst *argv) +{ + /*emscripten_log(EM_LOG_CONSOLE, "--> js_float16_ctor: argc=%d", argc); - return JS_UNDEFINED; + for (int i=0; i < argc; ++i) { + + emscripten_log(EM_LOG_CONSOLE, "%d: %d", i, JS_VALUE_GET_TAG(argv[i])); + }*/ + + float16 *s; + JSValue obj = JS_UNDEFINED; + JSValue proto; + + s = js_mallocz(ctx, sizeof(*s)); + if (!s) + return JS_EXCEPTION; + + /* using new_target to get the prototype is necessary when the + class is extended. */ + + + proto = JS_GetPropertyStr(ctx, new_target, "prototype"); + if (JS_IsException(proto)) + goto fail; + obj = JS_NewObjectProtoClass(ctx, proto, js_float16_class_id); + JS_FreeValue(ctx, proto); + if (JS_IsException(obj)) + goto fail; + JS_SetOpaque(obj, s); + return obj; + fail: + js_free(ctx, s); + JS_FreeValue(ctx, obj); + return JS_EXCEPTION; } -static JSValue js_DrawSphereWires(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSClassDef js_float16_class = { + "float16", + .finalizer = js_float16_finalizer, +}; + +static const JSCFunctionListEntry js_float16_proto_funcs[] = { + JS_CGETSET_MAGIC_DEF("v", js_float16_get, js_float16_set, 0), + + /*JS_PROP_STRING_DEF("[Symbol.toStringTag]", "float16", JS_PROP_CONFIGURABLE ),*/ +}; + +static int js_declare_float16(JSContext *ctx, JSModuleDef *m) { - Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Vector3 arg0 = *argptr0; - double arg1; - JS_ToFloat64(ctx, &arg1, argv[1]); - int arg2; - JS_ToInt32(ctx, &arg2, argv[2]); - int arg3; - JS_ToInt32(ctx, &arg3, argv[3]); - Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); - if (argptr4 == NULL) return JS_EXCEPTION; - - Color arg4 = *argptr4; + JSValue proto, class; - DrawSphereWires(arg0, arg1, arg2, arg3, arg4); + /* create the class */ + JS_NewClassID(&js_float16_class_id); + JS_NewClass(JS_GetRuntime(ctx), js_float16_class_id, &js_float16_class); + proto = JS_NewObject(ctx); + JS_SetPropertyFunctionList(ctx, proto, js_float16_proto_funcs, countof(js_float16_proto_funcs)); - return JS_UNDEFINED; + class = JS_NewCFunction2(ctx, js_float16_ctor, "float16", 1, JS_CFUNC_constructor, 0); + /* set proto.constructor and ctor.prototype */ + JS_SetConstructor(ctx, class, proto); + JS_SetClassProto(ctx, js_float16_class_id, proto); + + JS_SetModuleExport(ctx, m, "float16", class); + return 0; } -static JSValue js_DrawCylinder(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Clamp(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Vector3 arg0 = *argptr0; + double arg0; + JS_ToFloat64(ctx, &arg0, argv[0]); double arg1; JS_ToFloat64(ctx, &arg1, argv[1]); double arg2; JS_ToFloat64(ctx, &arg2, argv[2]); - double arg3; - JS_ToFloat64(ctx, &arg3, argv[3]); - int arg4; - JS_ToInt32(ctx, &arg4, argv[4]); - Color * argptr5 = (Color *)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); - if (argptr5 == NULL) return JS_EXCEPTION; - - Color arg5 = *argptr5; - DrawCylinder(arg0, arg1, arg2, arg3, arg4, arg5); + float ret = Clamp(arg0, arg1, arg2); - return JS_UNDEFINED; + return JS_NewFloat64(ctx, ret); } -static JSValue js_DrawCylinderEx(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Lerp(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Vector3 arg0 = *argptr0; - Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; - - Vector3 arg1 = *argptr1; + double arg0; + JS_ToFloat64(ctx, &arg0, argv[0]); + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); double arg2; JS_ToFloat64(ctx, &arg2, argv[2]); - double arg3; - JS_ToFloat64(ctx, &arg3, argv[3]); - int arg4; - JS_ToInt32(ctx, &arg4, argv[4]); - Color * argptr5 = (Color *)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); - if (argptr5 == NULL) return JS_EXCEPTION; - - Color arg5 = *argptr5; - DrawCylinderEx(arg0, arg1, arg2, arg3, arg4, arg5); + float ret = Lerp(arg0, arg1, arg2); - return JS_UNDEFINED; + return JS_NewFloat64(ctx, ret); } -static JSValue js_DrawCylinderWires(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Normalize(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Vector3 arg0 = *argptr0; + double arg0; + JS_ToFloat64(ctx, &arg0, argv[0]); double arg1; JS_ToFloat64(ctx, &arg1, argv[1]); double arg2; JS_ToFloat64(ctx, &arg2, argv[2]); - double arg3; - JS_ToFloat64(ctx, &arg3, argv[3]); - int arg4; - JS_ToInt32(ctx, &arg4, argv[4]); - Color * argptr5 = (Color *)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); - if (argptr5 == NULL) return JS_EXCEPTION; - - Color arg5 = *argptr5; - DrawCylinderWires(arg0, arg1, arg2, arg3, arg4, arg5); + float ret = Normalize(arg0, arg1, arg2); - return JS_UNDEFINED; + return JS_NewFloat64(ctx, ret); } -static JSValue js_DrawCylinderWiresEx(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Remap(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Vector3 arg0 = *argptr0; - Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; - - Vector3 arg1 = *argptr1; + double arg0; + JS_ToFloat64(ctx, &arg0, argv[0]); + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); double arg2; JS_ToFloat64(ctx, &arg2, argv[2]); double arg3; JS_ToFloat64(ctx, &arg3, argv[3]); - int arg4; - JS_ToInt32(ctx, &arg4, argv[4]); - Color * argptr5 = (Color *)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); - if (argptr5 == NULL) return JS_EXCEPTION; - - Color arg5 = *argptr5; + double arg4; + JS_ToFloat64(ctx, &arg4, argv[4]); - DrawCylinderWiresEx(arg0, arg1, arg2, arg3, arg4, arg5); + float ret = Remap(arg0, arg1, arg2, arg3, arg4); - return JS_UNDEFINED; + return JS_NewFloat64(ctx, ret); } -static JSValue js_DrawCapsule(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Wrap(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Vector3 arg0 = *argptr0; - Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; - - Vector3 arg1 = *argptr1; + double arg0; + JS_ToFloat64(ctx, &arg0, argv[0]); + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); double arg2; JS_ToFloat64(ctx, &arg2, argv[2]); - int arg3; - JS_ToInt32(ctx, &arg3, argv[3]); - int arg4; - JS_ToInt32(ctx, &arg4, argv[4]); - Color * argptr5 = (Color *)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); - if (argptr5 == NULL) return JS_EXCEPTION; - - Color arg5 = *argptr5; - DrawCapsule(arg0, arg1, arg2, arg3, arg4, arg5); + float ret = Wrap(arg0, arg1, arg2); - return JS_UNDEFINED; + return JS_NewFloat64(ctx, ret); } -static JSValue js_DrawCapsuleWires(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_FloatEquals(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Vector3 arg0 = *argptr0; - Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; - - Vector3 arg1 = *argptr1; - double arg2; - JS_ToFloat64(ctx, &arg2, argv[2]); - int arg3; - JS_ToInt32(ctx, &arg3, argv[3]); - int arg4; - JS_ToInt32(ctx, &arg4, argv[4]); - Color * argptr5 = (Color *)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); - if (argptr5 == NULL) return JS_EXCEPTION; - - Color arg5 = *argptr5; + double arg0; + JS_ToFloat64(ctx, &arg0, argv[0]); + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); - DrawCapsuleWires(arg0, arg1, arg2, arg3, arg4, arg5); + int ret = FloatEquals(arg0, arg1); - return JS_UNDEFINED; + return JS_NewInt32(ctx, ret); } -static JSValue js_DrawPlane(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector2Zero(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Vector3 arg0 = *argptr0; - Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; - - Vector2 arg1 = *argptr1; - Color * argptr2 = (Color *)JS_GetOpaque2(ctx, argv[2], js_Color_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; - - Color arg2 = *argptr2; - DrawPlane(arg0, arg1, arg2); + Vector2 returnVal = Vector2Zero(); - return JS_UNDEFINED; + + Vector2* ret_ptr = (Vector2 *)js_malloc(ctx, sizeof(Vector2)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector2_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_DrawRay(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector2One(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Ray * argptr0 = (Ray *)JS_GetOpaque2(ctx, argv[0], js_Ray_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Ray arg0 = *argptr0; - Color * argptr1 = (Color *)JS_GetOpaque2(ctx, argv[1], js_Color_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; - - Color arg1 = *argptr1; - DrawRay(arg0, arg1); + Vector2 returnVal = Vector2One(); - return JS_UNDEFINED; + + Vector2* ret_ptr = (Vector2 *)js_malloc(ctx, sizeof(Vector2)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector2_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_DrawGrid(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector2Add(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - int arg0; - JS_ToInt32(ctx, &arg0, argv[0]); - double arg1; - JS_ToFloat64(ctx, &arg1, argv[1]); - DrawGrid(arg0, arg1); + Vector2 arg0; - return JS_UNDEFINED; -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_LoadModel(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { - Model returnVal = LoadModel(arg0); + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + + Vector2 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + } + else { + + Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + Vector2 returnVal = Vector2Add(arg0, arg1); - JS_FreeCString(ctx, arg0); - Model* ret_ptr = (Model *)js_malloc(ctx, sizeof(Model)); + Vector2* ret_ptr = (Vector2 *)js_malloc(ctx, sizeof(Vector2)); *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Model_class_id); + JSValue ret = JS_NewObjectClass(ctx, js_Vector2_class_id); JS_SetOpaque(ret, ret_ptr); return ret; } -static JSValue js_LoadModelFromMesh(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector2AddValue(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Mesh * argptr0 = (Mesh *)JS_GetOpaque2(ctx, argv[0], js_Mesh_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Mesh arg0 = *argptr0; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { - Model returnVal = LoadModelFromMesh(arg0); + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + + Vector2 returnVal = Vector2AddValue(arg0, arg1); - Model* ret_ptr = (Model *)js_malloc(ctx, sizeof(Model)); + Vector2* ret_ptr = (Vector2 *)js_malloc(ctx, sizeof(Vector2)); *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Model_class_id); + JSValue ret = JS_NewObjectClass(ctx, js_Vector2_class_id); JS_SetOpaque(ret, ret_ptr); return ret; } -static JSValue js_IsModelReady(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector2Subtract(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Model * argptr0 = (Model *)JS_GetOpaque2(ctx, argv[0], js_Model_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Model arg0 = *argptr0; - bool ret = IsModelReady(arg0); + Vector2 arg0; - return JS_NewBool(ctx, ret); -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_UnloadModel(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Model * argptr0 = (Model *)JS_GetOpaque2(ctx, argv[0], js_Model_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Model arg0 = *argptr0; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { - UnloadModel(arg0); + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + - return JS_UNDEFINED; -} + Vector2 arg1; -static JSValue js_GetModelBoundingBox(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Model * argptr0 = (Model *)JS_GetOpaque2(ctx, argv[0], js_Model_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; - Model arg0 = *argptr0; + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + } + else { - BoundingBox returnVal = GetModelBoundingBox(arg0); + Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + Vector2 returnVal = Vector2Subtract(arg0, arg1); - BoundingBox* ret_ptr = (BoundingBox *)js_malloc(ctx, sizeof(BoundingBox)); + Vector2* ret_ptr = (Vector2 *)js_malloc(ctx, sizeof(Vector2)); *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_BoundingBox_class_id); + JSValue ret = JS_NewObjectClass(ctx, js_Vector2_class_id); JS_SetOpaque(ret, ret_ptr); return ret; } -static JSValue js_DrawModel(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector2SubtractValue(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Model * argptr0 = (Model *)JS_GetOpaque2(ctx, argv[0], js_Model_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Model arg0 = *argptr0; - Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; - - Vector3 arg1 = *argptr1; - double arg2; - JS_ToFloat64(ctx, &arg2, argv[2]); - Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); - if (argptr3 == NULL) return JS_EXCEPTION; - - Color arg3 = *argptr3; - DrawModel(arg0, arg1, arg2, arg3); + Vector2 arg0; - return JS_UNDEFINED; -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_DrawModelEx(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Model * argptr0 = (Model *)JS_GetOpaque2(ctx, argv[0], js_Model_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Model arg0 = *argptr0; - Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; - - Vector3 arg1 = *argptr1; - Vector3 * argptr2 = (Vector3 *)JS_GetOpaque2(ctx, argv[2], js_Vector3_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; - - Vector3 arg2 = *argptr2; - double arg3; - JS_ToFloat64(ctx, &arg3, argv[3]); - Vector3 * argptr4 = (Vector3 *)JS_GetOpaque2(ctx, argv[4], js_Vector3_class_id); - if (argptr4 == NULL) return JS_EXCEPTION; + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Vector3 arg4 = *argptr4; - Color * argptr5 = (Color *)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); - if (argptr5 == NULL) return JS_EXCEPTION; - - Color arg5 = *argptr5; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + + Vector2 returnVal = Vector2SubtractValue(arg0, arg1); + + + + Vector2* ret_ptr = (Vector2 *)js_malloc(ctx, sizeof(Vector2)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector2_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} - DrawModelEx(arg0, arg1, arg2, arg3, arg4, arg5); +static JSValue js_Vector2Length(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ - return JS_UNDEFINED; -} + Vector2 arg0; -static JSValue js_DrawModelWires(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Model * argptr0 = (Model *)JS_GetOpaque2(ctx, argv[0], js_Model_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Model arg0 = *argptr0; - Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; - - Vector3 arg1 = *argptr1; - double arg2; - JS_ToFloat64(ctx, &arg2, argv[2]); - Color * argptr3 = (Color *)JS_GetOpaque2(ctx, argv[3], js_Color_class_id); - if (argptr3 == NULL) return JS_EXCEPTION; + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Color arg3 = *argptr3; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { - DrawModelWires(arg0, arg1, arg2, arg3); + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + float ret = Vector2Length(arg0); - return JS_UNDEFINED; + + return JS_NewFloat64(ctx, ret); } -static JSValue js_DrawModelWiresEx(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector2LengthSqr(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Model * argptr0 = (Model *)JS_GetOpaque2(ctx, argv[0], js_Model_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Model arg0 = *argptr0; - Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; - - Vector3 arg1 = *argptr1; - Vector3 * argptr2 = (Vector3 *)JS_GetOpaque2(ctx, argv[2], js_Vector3_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; - - Vector3 arg2 = *argptr2; - double arg3; - JS_ToFloat64(ctx, &arg3, argv[3]); - Vector3 * argptr4 = (Vector3 *)JS_GetOpaque2(ctx, argv[4], js_Vector3_class_id); - if (argptr4 == NULL) return JS_EXCEPTION; - - Vector3 arg4 = *argptr4; - Color * argptr5 = (Color *)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); - if (argptr5 == NULL) return JS_EXCEPTION; - - Color arg5 = *argptr5; - DrawModelWiresEx(arg0, arg1, arg2, arg3, arg4, arg5); + Vector2 arg0; - return JS_UNDEFINED; -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_DrawBoundingBox(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - BoundingBox * argptr0 = (BoundingBox *)JS_GetOpaque2(ctx, argv[0], js_BoundingBox_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - BoundingBox arg0 = *argptr0; - Color * argptr1 = (Color *)JS_GetOpaque2(ctx, argv[1], js_Color_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Color arg1 = *argptr1; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { - DrawBoundingBox(arg0, arg1); + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + float ret = Vector2LengthSqr(arg0); - return JS_UNDEFINED; + return JS_NewFloat64(ctx, ret); } -static JSValue js_DrawBillboard(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector2DotProduct(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Camera * argptr0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera_class_id); - if (argptr0 == NULL) - argptr0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera3D_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Camera arg0 = *argptr0; - Texture2D * argptr1 = (Texture2D *)JS_GetOpaque2(ctx, argv[1], js_Texture2D_class_id); - if (argptr1 == NULL) - argptr1 = (Texture2D *)JS_GetOpaque2(ctx, argv[1], js_Texture_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; + + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Texture2D arg1 = *argptr1; - Vector3 * argptr2 = (Vector3 *)JS_GetOpaque2(ctx, argv[2], js_Vector3_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } - Vector3 arg2 = *argptr2; - double arg3; - JS_ToFloat64(ctx, &arg3, argv[3]); - Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); - if (argptr4 == NULL) return JS_EXCEPTION; + + Vector2 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; - Color arg4 = *argptr4; + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + } + else { - DrawBillboard(arg0, arg1, arg2, arg3, arg4); + Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + float ret = Vector2DotProduct(arg0, arg1); - return JS_UNDEFINED; + return JS_NewFloat64(ctx, ret); } -static JSValue js_DrawBillboardRec(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector2Distance(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Camera * argptr0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera_class_id); - if (argptr0 == NULL) - argptr0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera3D_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Camera arg0 = *argptr0; - Texture2D * argptr1 = (Texture2D *)JS_GetOpaque2(ctx, argv[1], js_Texture2D_class_id); - if (argptr1 == NULL) - argptr1 = (Texture2D *)JS_GetOpaque2(ctx, argv[1], js_Texture_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; - - Texture2D arg1 = *argptr1; - Rectangle * argptr2 = (Rectangle *)JS_GetOpaque2(ctx, argv[2], js_Rectangle_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; - - Rectangle arg2 = *argptr2; - Vector3 * argptr3 = (Vector3 *)JS_GetOpaque2(ctx, argv[3], js_Vector3_class_id); - if (argptr3 == NULL) return JS_EXCEPTION; + + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Vector3 arg3 = *argptr3; - Vector2 * argptr4 = (Vector2 *)JS_GetOpaque2(ctx, argv[4], js_Vector2_class_id); - if (argptr4 == NULL) return JS_EXCEPTION; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } - Vector2 arg4 = *argptr4; - Color * argptr5 = (Color *)JS_GetOpaque2(ctx, argv[5], js_Color_class_id); - if (argptr5 == NULL) return JS_EXCEPTION; + + Vector2 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; - Color arg5 = *argptr5; + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + } + else { - DrawBillboardRec(arg0, arg1, arg2, arg3, arg4, arg5); + Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + float ret = Vector2Distance(arg0, arg1); - return JS_UNDEFINED; + return JS_NewFloat64(ctx, ret); } -static JSValue js_DrawBillboardPro(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector2DistanceSqr(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Camera * argptr0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera_class_id); - if (argptr0 == NULL) - argptr0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera3D_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Camera arg0 = *argptr0; - Texture2D * argptr1 = (Texture2D *)JS_GetOpaque2(ctx, argv[1], js_Texture2D_class_id); - if (argptr1 == NULL) - argptr1 = (Texture2D *)JS_GetOpaque2(ctx, argv[1], js_Texture_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; - - Texture2D arg1 = *argptr1; - Rectangle * argptr2 = (Rectangle *)JS_GetOpaque2(ctx, argv[2], js_Rectangle_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; - - Rectangle arg2 = *argptr2; - Vector3 * argptr3 = (Vector3 *)JS_GetOpaque2(ctx, argv[3], js_Vector3_class_id); - if (argptr3 == NULL) return JS_EXCEPTION; - - Vector3 arg3 = *argptr3; - Vector3 * argptr4 = (Vector3 *)JS_GetOpaque2(ctx, argv[4], js_Vector3_class_id); - if (argptr4 == NULL) return JS_EXCEPTION; - - Vector3 arg4 = *argptr4; - Vector2 * argptr5 = (Vector2 *)JS_GetOpaque2(ctx, argv[5], js_Vector2_class_id); - if (argptr5 == NULL) return JS_EXCEPTION; + + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Vector2 arg5 = *argptr5; - Vector2 * argptr6 = (Vector2 *)JS_GetOpaque2(ctx, argv[6], js_Vector2_class_id); - if (argptr6 == NULL) return JS_EXCEPTION; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } - Vector2 arg6 = *argptr6; - double arg7; - JS_ToFloat64(ctx, &arg7, argv[7]); - Color * argptr8 = (Color *)JS_GetOpaque2(ctx, argv[8], js_Color_class_id); - if (argptr8 == NULL) return JS_EXCEPTION; + + Vector2 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; - Color arg8 = *argptr8; + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + } + else { - DrawBillboardPro(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); + Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + float ret = Vector2DistanceSqr(arg0, arg1); - return JS_UNDEFINED; + + return JS_NewFloat64(ctx, ret); } -static JSValue js_UpdateMeshBuffer(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector2Angle(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Mesh * argptr0 = (Mesh *)JS_GetOpaque2(ctx, argv[0], js_Mesh_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Mesh arg0 = *argptr0; - int arg1; - JS_ToInt32(ctx, &arg1, argv[1]); -size_t data_size2; - const void * arg2 = (const void *)JS_GetArrayBuffer(ctx, &data_size2, argv[2]); - int arg3; - JS_ToInt32(ctx, &arg3, argv[3]); - int arg4; - JS_ToInt32(ctx, &arg4, argv[4]); + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { - UpdateMeshBuffer(arg0, arg1, arg2, arg3, arg4); + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + - return JS_UNDEFINED; -} + Vector2 arg1; -static JSValue js_UnloadMesh(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Mesh * argptr0 = (Mesh *)JS_GetOpaque2(ctx, argv[0], js_Mesh_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; - Mesh arg0 = *argptr0; + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + } + else { - UnloadMesh(arg0); + Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + float ret = Vector2Angle(arg0, arg1); - return JS_UNDEFINED; + return JS_NewFloat64(ctx, ret); } -static JSValue js_DrawMesh(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector2LineAngle(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Mesh * argptr0 = (Mesh *)JS_GetOpaque2(ctx, argv[0], js_Mesh_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Mesh arg0 = *argptr0; - Material * argptr1 = (Material *)JS_GetOpaque2(ctx, argv[1], js_Material_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } - Material arg1 = *argptr1; - Matrix * argptr2 = (Matrix *)JS_GetOpaque2(ctx, argv[2], js_Matrix_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; + + Vector2 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; - Matrix arg2 = *argptr2; + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + } + else { - DrawMesh(arg0, arg1, arg2); + Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + float ret = Vector2LineAngle(arg0, arg1); - return JS_UNDEFINED; + return JS_NewFloat64(ctx, ret); } -static JSValue js_ExportMesh(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector2Scale(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Mesh * argptr0 = (Mesh *)JS_GetOpaque2(ctx, argv[0], js_Mesh_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Mesh arg0 = *argptr0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); - bool ret = ExportMesh(arg0, arg1); - JS_FreeCString(ctx, arg1); + Vector2 arg0; - return JS_NewBool(ctx, ret); -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_GetMeshBoundingBox(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Mesh * argptr0 = (Mesh *)JS_GetOpaque2(ctx, argv[0], js_Mesh_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Mesh arg0 = *argptr0; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { - BoundingBox returnVal = GetMeshBoundingBox(arg0); + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + + Vector2 returnVal = Vector2Scale(arg0, arg1); - BoundingBox* ret_ptr = (BoundingBox *)js_malloc(ctx, sizeof(BoundingBox)); + Vector2* ret_ptr = (Vector2 *)js_malloc(ctx, sizeof(Vector2)); *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_BoundingBox_class_id); + JSValue ret = JS_NewObjectClass(ctx, js_Vector2_class_id); JS_SetOpaque(ret, ret_ptr); return ret; } -static JSValue js_GenMeshPoly(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector2Multiply(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - int arg0; - JS_ToInt32(ctx, &arg0, argv[0]); - double arg1; - JS_ToFloat64(ctx, &arg1, argv[1]); - Mesh returnVal = GenMeshPoly(arg0, arg1); + Vector2 arg0; - - Mesh* ret_ptr = (Mesh *)js_malloc(ctx, sizeof(Mesh)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Mesh_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_GenMeshPlane(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - double arg0; - JS_ToFloat64(ctx, &arg0, argv[0]); - double arg1; - JS_ToFloat64(ctx, &arg1, argv[1]); - int arg2; - JS_ToInt32(ctx, &arg2, argv[2]); - int arg3; - JS_ToInt32(ctx, &arg3, argv[3]); + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + + Vector2 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + } + else { - Mesh returnVal = GenMeshPlane(arg0, arg1, arg2, arg3); + Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + Vector2 returnVal = Vector2Multiply(arg0, arg1); - Mesh* ret_ptr = (Mesh *)js_malloc(ctx, sizeof(Mesh)); + Vector2* ret_ptr = (Vector2 *)js_malloc(ctx, sizeof(Vector2)); *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Mesh_class_id); + JSValue ret = JS_NewObjectClass(ctx, js_Vector2_class_id); JS_SetOpaque(ret, ret_ptr); return ret; } -static JSValue js_GenMeshCube(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector2Negate(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - double arg0; - JS_ToFloat64(ctx, &arg0, argv[0]); - double arg1; - JS_ToFloat64(ctx, &arg1, argv[1]); - double arg2; - JS_ToFloat64(ctx, &arg2, argv[2]); - Mesh returnVal = GenMeshCube(arg0, arg1, arg2); + Vector2 arg0; - - Mesh* ret_ptr = (Mesh *)js_malloc(ctx, sizeof(Mesh)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Mesh_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_GenMeshSphere(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - double arg0; - JS_ToFloat64(ctx, &arg0, argv[0]); - int arg1; - JS_ToInt32(ctx, &arg1, argv[1]); - int arg2; - JS_ToInt32(ctx, &arg2, argv[2]); + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { - Mesh returnVal = GenMeshSphere(arg0, arg1, arg2); + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + Vector2 returnVal = Vector2Negate(arg0); - Mesh* ret_ptr = (Mesh *)js_malloc(ctx, sizeof(Mesh)); + Vector2* ret_ptr = (Vector2 *)js_malloc(ctx, sizeof(Vector2)); *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Mesh_class_id); + JSValue ret = JS_NewObjectClass(ctx, js_Vector2_class_id); JS_SetOpaque(ret, ret_ptr); return ret; } -static JSValue js_GenMeshHemiSphere(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector2Divide(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - double arg0; - JS_ToFloat64(ctx, &arg0, argv[0]); - int arg1; - JS_ToInt32(ctx, &arg1, argv[1]); - int arg2; - JS_ToInt32(ctx, &arg2, argv[2]); - Mesh returnVal = GenMeshHemiSphere(arg0, arg1, arg2); + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + + Vector2 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + } + else { + + Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + Vector2 returnVal = Vector2Divide(arg0, arg1); - Mesh* ret_ptr = (Mesh *)js_malloc(ctx, sizeof(Mesh)); + Vector2* ret_ptr = (Vector2 *)js_malloc(ctx, sizeof(Vector2)); *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Mesh_class_id); + JSValue ret = JS_NewObjectClass(ctx, js_Vector2_class_id); JS_SetOpaque(ret, ret_ptr); return ret; } -static JSValue js_GenMeshCylinder(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector2Normalize(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - double arg0; - JS_ToFloat64(ctx, &arg0, argv[0]); - double arg1; - JS_ToFloat64(ctx, &arg1, argv[1]); - int arg2; - JS_ToInt32(ctx, &arg2, argv[2]); - Mesh returnVal = GenMeshCylinder(arg0, arg1, arg2); + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + Vector2 returnVal = Vector2Normalize(arg0); - Mesh* ret_ptr = (Mesh *)js_malloc(ctx, sizeof(Mesh)); + Vector2* ret_ptr = (Vector2 *)js_malloc(ctx, sizeof(Vector2)); *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Mesh_class_id); + JSValue ret = JS_NewObjectClass(ctx, js_Vector2_class_id); JS_SetOpaque(ret, ret_ptr); return ret; } -static JSValue js_GenMeshCone(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector2Transform(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - double arg0; - JS_ToFloat64(ctx, &arg0, argv[0]); - double arg1; - JS_ToFloat64(ctx, &arg1, argv[1]); - int arg2; - JS_ToInt32(ctx, &arg2, argv[2]); - Mesh returnVal = GenMeshCone(arg0, arg1, arg2); + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + Matrix * argptr1 = (Matrix *)JS_GetOpaque2(ctx, argv[1], js_Matrix_class_id); + if (argptr1 == NULL) return JS_EXCEPTION; + + Matrix arg1 = *argptr1; + + Vector2 returnVal = Vector2Transform(arg0, arg1); - Mesh* ret_ptr = (Mesh *)js_malloc(ctx, sizeof(Mesh)); + Vector2* ret_ptr = (Vector2 *)js_malloc(ctx, sizeof(Vector2)); *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Mesh_class_id); + JSValue ret = JS_NewObjectClass(ctx, js_Vector2_class_id); JS_SetOpaque(ret, ret_ptr); return ret; } -static JSValue js_GenMeshTorus(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector2Lerp(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - double arg0; - JS_ToFloat64(ctx, &arg0, argv[0]); - double arg1; - JS_ToFloat64(ctx, &arg1, argv[1]); - int arg2; - JS_ToInt32(ctx, &arg2, argv[2]); - int arg3; - JS_ToInt32(ctx, &arg3, argv[3]); - Mesh returnVal = GenMeshTorus(arg0, arg1, arg2, arg3); + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + + Vector2 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + } + else { + + Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); + + Vector2 returnVal = Vector2Lerp(arg0, arg1, arg2); - Mesh* ret_ptr = (Mesh *)js_malloc(ctx, sizeof(Mesh)); + Vector2* ret_ptr = (Vector2 *)js_malloc(ctx, sizeof(Vector2)); *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Mesh_class_id); + JSValue ret = JS_NewObjectClass(ctx, js_Vector2_class_id); JS_SetOpaque(ret, ret_ptr); return ret; } -static JSValue js_GenMeshKnot(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector2Reflect(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - double arg0; - JS_ToFloat64(ctx, &arg0, argv[0]); - double arg1; - JS_ToFloat64(ctx, &arg1, argv[1]); - int arg2; - JS_ToInt32(ctx, &arg2, argv[2]); - int arg3; - JS_ToInt32(ctx, &arg3, argv[3]); - Mesh returnVal = GenMeshKnot(arg0, arg1, arg2, arg3); + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + + Vector2 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + } + else { + + Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + Vector2 returnVal = Vector2Reflect(arg0, arg1); - Mesh* ret_ptr = (Mesh *)js_malloc(ctx, sizeof(Mesh)); + Vector2* ret_ptr = (Vector2 *)js_malloc(ctx, sizeof(Vector2)); *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Mesh_class_id); + JSValue ret = JS_NewObjectClass(ctx, js_Vector2_class_id); JS_SetOpaque(ret, ret_ptr); return ret; } -static JSValue js_GenMeshHeightmap(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector2Rotate(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Image * argptr0 = (Image *)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Image arg0 = *argptr0; - Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; + + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Vector3 arg1 = *argptr1; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { - Mesh returnVal = GenMeshHeightmap(arg0, arg1); + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + + Vector2 returnVal = Vector2Rotate(arg0, arg1); - Mesh* ret_ptr = (Mesh *)js_malloc(ctx, sizeof(Mesh)); + Vector2* ret_ptr = (Vector2 *)js_malloc(ctx, sizeof(Vector2)); *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Mesh_class_id); + JSValue ret = JS_NewObjectClass(ctx, js_Vector2_class_id); JS_SetOpaque(ret, ret_ptr); return ret; } -static JSValue js_GenMeshCubicmap(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector2MoveTowards(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Image * argptr0 = (Image *)JS_GetOpaque2(ctx, argv[0], js_Image_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Image arg0 = *argptr0; - Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } - Vector3 arg1 = *argptr1; - Mesh returnVal = GenMeshCubicmap(arg0, arg1); + Vector2 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + } + else { + + Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); + + Vector2 returnVal = Vector2MoveTowards(arg0, arg1, arg2); - Mesh* ret_ptr = (Mesh *)js_malloc(ctx, sizeof(Mesh)); + Vector2* ret_ptr = (Vector2 *)js_malloc(ctx, sizeof(Vector2)); *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Mesh_class_id); + JSValue ret = JS_NewObjectClass(ctx, js_Vector2_class_id); JS_SetOpaque(ret, ret_ptr); return ret; } -static JSValue js_LoadMaterialDefault(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector2Invert(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Material returnVal = LoadMaterialDefault(); + + Vector2 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + Vector2 returnVal = Vector2Invert(arg0); - Material* ret_ptr = (Material *)js_malloc(ctx, sizeof(Material)); + Vector2* ret_ptr = (Vector2 *)js_malloc(ctx, sizeof(Vector2)); *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Material_class_id); + JSValue ret = JS_NewObjectClass(ctx, js_Vector2_class_id); JS_SetOpaque(ret, ret_ptr); return ret; } -static JSValue js_IsMaterialReady(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector2Clamp(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Material * argptr0 = (Material *)JS_GetOpaque2(ctx, argv[0], js_Material_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Material arg0 = *argptr0; - bool ret = IsMaterialReady(arg0); + Vector2 arg0; - return JS_NewBool(ctx, ret); -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_UnloadMaterial(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Material * argptr0 = (Material *)JS_GetOpaque2(ctx, argv[0], js_Material_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Material arg0 = *argptr0; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { - UnloadMaterial(arg0); + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + - return JS_UNDEFINED; -} + Vector2 arg1; -static JSValue js_UpdateModelAnimation(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Model * argptr0 = (Model *)JS_GetOpaque2(ctx, argv[0], js_Model_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Model arg0 = *argptr0; - ModelAnimation * argptr1 = (ModelAnimation *)JS_GetOpaque2(ctx, argv[1], js_ModelAnimation_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; - - ModelAnimation arg1 = *argptr1; - int arg2; - JS_ToInt32(ctx, &arg2, argv[2]); + if (JS_IsArray(ctx, argv[1])) { - UpdateModelAnimation(arg0, arg1, arg2); + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + } + else { + Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); - return JS_UNDEFINED; -} + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + -static JSValue js_UnloadModelAnimation(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - ModelAnimation * argptr0 = (ModelAnimation *)JS_GetOpaque2(ctx, argv[0], js_ModelAnimation_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + Vector2 arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[2], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg2.x = (float)x_double; - ModelAnimation arg0 = *argptr0; + JSValue y = JS_GetPropertyUint32(ctx, argv[2], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg2.y = (float)y_double; + } + else { - UnloadModelAnimation(arg0); + Vector2 * argptr2 = (Vector2 *)JS_GetOpaque2(ctx, argv[2], js_Vector2_class_id); + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + + Vector2 returnVal = Vector2Clamp(arg0, arg1, arg2); - return JS_UNDEFINED; + + + Vector2* ret_ptr = (Vector2 *)js_malloc(ctx, sizeof(Vector2)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector2_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_IsModelAnimationValid(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector2ClampValue(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Model * argptr0 = (Model *)JS_GetOpaque2(ctx, argv[0], js_Model_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Model arg0 = *argptr0; - ModelAnimation * argptr1 = (ModelAnimation *)JS_GetOpaque2(ctx, argv[1], js_ModelAnimation_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; - - ModelAnimation arg1 = *argptr1; - bool ret = IsModelAnimationValid(arg0, arg1); + Vector2 arg0; - return JS_NewBool(ctx, ret); -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_CheckCollisionSpheres(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Vector3 arg0 = *argptr0; - double arg1; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + double arg1; JS_ToFloat64(ctx, &arg1, argv[1]); - Vector3 * argptr2 = (Vector3 *)JS_GetOpaque2(ctx, argv[2], js_Vector3_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; - - Vector3 arg2 = *argptr2; - double arg3; - JS_ToFloat64(ctx, &arg3, argv[3]); + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); - bool ret = CheckCollisionSpheres(arg0, arg1, arg2, arg3); + Vector2 returnVal = Vector2ClampValue(arg0, arg1, arg2); - return JS_NewBool(ctx, ret); + + Vector2* ret_ptr = (Vector2 *)js_malloc(ctx, sizeof(Vector2)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector2_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_CheckCollisionBoxes(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector2Equals(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - BoundingBox * argptr0 = (BoundingBox *)JS_GetOpaque2(ctx, argv[0], js_BoundingBox_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - BoundingBox arg0 = *argptr0; - BoundingBox * argptr1 = (BoundingBox *)JS_GetOpaque2(ctx, argv[1], js_BoundingBox_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; - - BoundingBox arg1 = *argptr1; - bool ret = CheckCollisionBoxes(arg0, arg1); + Vector2 arg0; - return JS_NewBool(ctx, ret); -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_CheckCollisionBoxSphere(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - BoundingBox * argptr0 = (BoundingBox *)JS_GetOpaque2(ctx, argv[0], js_BoundingBox_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - BoundingBox arg0 = *argptr0; - Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + } + else { + + Vector2 * argptr0 = (Vector2 *)JS_GetOpaque2(ctx, argv[0], js_Vector2_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } - Vector3 arg1 = *argptr1; - double arg2; - JS_ToFloat64(ctx, &arg2, argv[2]); - bool ret = CheckCollisionBoxSphere(arg0, arg1, arg2); + Vector2 arg1; + if (JS_IsArray(ctx, argv[1])) { - return JS_NewBool(ctx, ret); + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + } + else { + + Vector2 * argptr1 = (Vector2 *)JS_GetOpaque2(ctx, argv[1], js_Vector2_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + int ret = Vector2Equals(arg0, arg1); + + + return JS_NewInt32(ctx, ret); } -static JSValue js_GetRayCollisionSphere(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector3Zero(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Ray * argptr0 = (Ray *)JS_GetOpaque2(ctx, argv[0], js_Ray_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Ray arg0 = *argptr0; - Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; - - Vector3 arg1 = *argptr1; - double arg2; - JS_ToFloat64(ctx, &arg2, argv[2]); - RayCollision returnVal = GetRayCollisionSphere(arg0, arg1, arg2); + Vector3 returnVal = Vector3Zero(); - RayCollision* ret_ptr = (RayCollision *)js_malloc(ctx, sizeof(RayCollision)); + Vector3* ret_ptr = (Vector3 *)js_malloc(ctx, sizeof(Vector3)); *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_RayCollision_class_id); + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); JS_SetOpaque(ret, ret_ptr); return ret; } -static JSValue js_GetRayCollisionBox(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector3One(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Ray * argptr0 = (Ray *)JS_GetOpaque2(ctx, argv[0], js_Ray_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Ray arg0 = *argptr0; - BoundingBox * argptr1 = (BoundingBox *)JS_GetOpaque2(ctx, argv[1], js_BoundingBox_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; - - BoundingBox arg1 = *argptr1; - RayCollision returnVal = GetRayCollisionBox(arg0, arg1); + Vector3 returnVal = Vector3One(); - RayCollision* ret_ptr = (RayCollision *)js_malloc(ctx, sizeof(RayCollision)); + Vector3* ret_ptr = (Vector3 *)js_malloc(ctx, sizeof(Vector3)); *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_RayCollision_class_id); + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); JS_SetOpaque(ret, ret_ptr); return ret; } -static JSValue js_GetRayCollisionMesh(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector3Add(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Ray * argptr0 = (Ray *)JS_GetOpaque2(ctx, argv[0], js_Ray_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + Vector3 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Ray arg0 = *argptr0; - Mesh * argptr1 = (Mesh *)JS_GetOpaque2(ctx, argv[1], js_Mesh_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } - Mesh arg1 = *argptr1; - Matrix * argptr2 = (Matrix *)JS_GetOpaque2(ctx, argv[2], js_Matrix_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; + + Vector3 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; - Matrix arg2 = *argptr2; + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; - RayCollision returnVal = GetRayCollisionMesh(arg0, arg1, arg2); + JSValue z = JS_GetPropertyUint32(ctx, argv[1], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg1.z = (float)z_double; + } + else { + + Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + Vector3 returnVal = Vector3Add(arg0, arg1); - RayCollision* ret_ptr = (RayCollision *)js_malloc(ctx, sizeof(RayCollision)); + Vector3* ret_ptr = (Vector3 *)js_malloc(ctx, sizeof(Vector3)); *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_RayCollision_class_id); + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); JS_SetOpaque(ret, ret_ptr); return ret; } -static JSValue js_GetRayCollisionTriangle(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector3AddValue(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Ray * argptr0 = (Ray *)JS_GetOpaque2(ctx, argv[0], js_Ray_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Ray arg0 = *argptr0; - Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; - - Vector3 arg1 = *argptr1; - Vector3 * argptr2 = (Vector3 *)JS_GetOpaque2(ctx, argv[2], js_Vector3_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; - - Vector3 arg2 = *argptr2; - Vector3 * argptr3 = (Vector3 *)JS_GetOpaque2(ctx, argv[3], js_Vector3_class_id); - if (argptr3 == NULL) return JS_EXCEPTION; + + + Vector3 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Vector3 arg3 = *argptr3; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; - RayCollision returnVal = GetRayCollisionTriangle(arg0, arg1, arg2, arg3); + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + + Vector3 returnVal = Vector3AddValue(arg0, arg1); - RayCollision* ret_ptr = (RayCollision *)js_malloc(ctx, sizeof(RayCollision)); + Vector3* ret_ptr = (Vector3 *)js_malloc(ctx, sizeof(Vector3)); *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_RayCollision_class_id); + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); JS_SetOpaque(ret, ret_ptr); return ret; } -static JSValue js_GetRayCollisionQuad(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector3Subtract(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Ray * argptr0 = (Ray *)JS_GetOpaque2(ctx, argv[0], js_Ray_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Ray arg0 = *argptr0; - Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); - if (argptr1 == NULL) return JS_EXCEPTION; - - Vector3 arg1 = *argptr1; - Vector3 * argptr2 = (Vector3 *)JS_GetOpaque2(ctx, argv[2], js_Vector3_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; + + + Vector3 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Vector3 arg2 = *argptr2; - Vector3 * argptr3 = (Vector3 *)JS_GetOpaque2(ctx, argv[3], js_Vector3_class_id); - if (argptr3 == NULL) return JS_EXCEPTION; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } - Vector3 arg3 = *argptr3; - Vector3 * argptr4 = (Vector3 *)JS_GetOpaque2(ctx, argv[4], js_Vector3_class_id); - if (argptr4 == NULL) return JS_EXCEPTION; + + Vector3 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; - Vector3 arg4 = *argptr4; + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; - RayCollision returnVal = GetRayCollisionQuad(arg0, arg1, arg2, arg3, arg4); + JSValue z = JS_GetPropertyUint32(ctx, argv[1], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg1.z = (float)z_double; + } + else { + + Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + Vector3 returnVal = Vector3Subtract(arg0, arg1); - RayCollision* ret_ptr = (RayCollision *)js_malloc(ctx, sizeof(RayCollision)); + Vector3* ret_ptr = (Vector3 *)js_malloc(ctx, sizeof(Vector3)); *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_RayCollision_class_id); + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); JS_SetOpaque(ret, ret_ptr); return ret; } -static JSValue js_InitAudioDevice(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector3SubtractValue(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - InitAudioDevice(); - - return JS_UNDEFINED; -} + Vector3 arg0; -static JSValue js_CloseAudioDevice(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ + if (JS_IsArray(ctx, argv[0])) { - CloseAudioDevice(); + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { - return JS_UNDEFINED; -} + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); -static JSValue js_IsAudioDeviceReady(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); - bool ret = IsAudioDeviceReady(); + Vector3 returnVal = Vector3SubtractValue(arg0, arg1); - return JS_NewBool(ctx, ret); + + Vector3* ret_ptr = (Vector3 *)js_malloc(ctx, sizeof(Vector3)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_SetMasterVolume(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector3Scale(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - double arg0; - JS_ToFloat64(ctx, &arg0, argv[0]); - - SetMasterVolume(arg0); - return JS_UNDEFINED; -} + Vector3 arg0; -static JSValue js_GetMasterVolume(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ + if (JS_IsArray(ctx, argv[0])) { - float ret = GetMasterVolume(); + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { - return JS_NewFloat64(ctx, ret); -} + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); -static JSValue js_LoadWave(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); - Wave returnVal = LoadWave(arg0); + Vector3 returnVal = Vector3Scale(arg0, arg1); - JS_FreeCString(ctx, arg0); - Wave* ret_ptr = (Wave *)js_malloc(ctx, sizeof(Wave)); + Vector3* ret_ptr = (Vector3 *)js_malloc(ctx, sizeof(Vector3)); *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Wave_class_id); + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); JS_SetOpaque(ret, ret_ptr); return ret; } -static JSValue js_LoadWaveFromMemory(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector3Multiply(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); -size_t data_size1; - const unsigned char * arg1 = (const unsigned char *)JS_GetArrayBuffer(ctx, &data_size1, argv[1]); - int arg2; - JS_ToInt32(ctx, &arg2, argv[2]); - Wave returnVal = LoadWaveFromMemory(arg0, arg1, arg2); - JS_FreeCString(ctx, arg0); + Vector3 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + + Vector3 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[1], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg1.z = (float)z_double; + } + else { + + Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + Vector3 returnVal = Vector3Multiply(arg0, arg1); + - Wave* ret_ptr = (Wave *)js_malloc(ctx, sizeof(Wave)); + Vector3* ret_ptr = (Vector3 *)js_malloc(ctx, sizeof(Vector3)); *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Wave_class_id); + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); JS_SetOpaque(ret, ret_ptr); return ret; } -static JSValue js_IsWaveReady(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector3CrossProduct(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Wave * argptr0 = (Wave *)JS_GetOpaque2(ctx, argv[0], js_Wave_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Wave arg0 = *argptr0; - bool ret = IsWaveReady(arg0); + Vector3 arg0; - return JS_NewBool(ctx, ret); -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_LoadSound(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; - Sound returnVal = LoadSound(arg0); + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { - JS_FreeCString(ctx, arg0); + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); - - Sound* ret_ptr = (Sound *)js_malloc(ctx, sizeof(Sound)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Sound_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - -} + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + -static JSValue js_LoadSoundFromWave(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Wave * argptr0 = (Wave *)JS_GetOpaque2(ctx, argv[0], js_Wave_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + Vector3 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; - Wave arg0 = *argptr0; + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; - Sound returnVal = LoadSoundFromWave(arg0); + JSValue z = JS_GetPropertyUint32(ctx, argv[1], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg1.z = (float)z_double; + } + else { + + Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + Vector3 returnVal = Vector3CrossProduct(arg0, arg1); - Sound* ret_ptr = (Sound *)js_malloc(ctx, sizeof(Sound)); + Vector3* ret_ptr = (Vector3 *)js_malloc(ctx, sizeof(Vector3)); *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Sound_class_id); + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); JS_SetOpaque(ret, ret_ptr); return ret; } -static JSValue js_LoadSoundAlias(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector3Perpendicular(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Sound * argptr0 = (Sound *)JS_GetOpaque2(ctx, argv[0], js_Sound_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + Vector3 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Sound arg0 = *argptr0; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; - Sound returnVal = LoadSoundAlias(arg0); + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + Vector3 returnVal = Vector3Perpendicular(arg0); - Sound* ret_ptr = (Sound *)js_malloc(ctx, sizeof(Sound)); + Vector3* ret_ptr = (Vector3 *)js_malloc(ctx, sizeof(Vector3)); *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Sound_class_id); + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); JS_SetOpaque(ret, ret_ptr); return ret; } -static JSValue js_IsSoundReady(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector3Length(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Sound * argptr0 = (Sound *)JS_GetOpaque2(ctx, argv[0], js_Sound_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Sound arg0 = *argptr0; - bool ret = IsSoundReady(arg0); + Vector3 arg0; - return JS_NewBool(ctx, ret); -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_UpdateSound(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Sound * argptr0 = (Sound *)JS_GetOpaque2(ctx, argv[0], js_Sound_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Sound arg0 = *argptr0; -size_t data_size1; - const void * arg1 = (const void *)JS_GetArrayBuffer(ctx, &data_size1, argv[1]); - int arg2; - JS_ToInt32(ctx, &arg2, argv[2]); + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; - UpdateSound(arg0, arg1, arg2); + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); - return JS_UNDEFINED; + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + float ret = Vector3Length(arg0); + + + return JS_NewFloat64(ctx, ret); } -static JSValue js_UnloadWave(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector3LengthSqr(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Wave * argptr0 = (Wave *)JS_GetOpaque2(ctx, argv[0], js_Wave_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Wave arg0 = *argptr0; - UnloadWave(arg0); + Vector3 arg0; - return JS_UNDEFINED; -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_UnloadSound(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Sound * argptr0 = (Sound *)JS_GetOpaque2(ctx, argv[0], js_Sound_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Sound arg0 = *argptr0; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; - UnloadSound(arg0); + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); - return JS_UNDEFINED; + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + float ret = Vector3LengthSqr(arg0); + + + return JS_NewFloat64(ctx, ret); } -static JSValue js_UnloadSoundAlias(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector3DotProduct(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Sound * argptr0 = (Sound *)JS_GetOpaque2(ctx, argv[0], js_Sound_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Sound arg0 = *argptr0; - UnloadSoundAlias(arg0); + Vector3 arg0; - return JS_UNDEFINED; -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_ExportWave(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Wave * argptr0 = (Wave *)JS_GetOpaque2(ctx, argv[0], js_Wave_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Wave arg0 = *argptr0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; - bool ret = ExportWave(arg0, arg1); + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { - JS_FreeCString(ctx, arg1); + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); - return JS_NewBool(ctx, ret); -} + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + -static JSValue js_ExportWaveAsCode(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Wave * argptr0 = (Wave *)JS_GetOpaque2(ctx, argv[0], js_Wave_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + Vector3 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; - Wave arg0 = *argptr0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; - bool ret = ExportWaveAsCode(arg0, arg1); + JSValue z = JS_GetPropertyUint32(ctx, argv[1], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg1.z = (float)z_double; + } + else { - JS_FreeCString(ctx, arg1); + Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); - return JS_NewBool(ctx, ret); + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + float ret = Vector3DotProduct(arg0, arg1); + + + return JS_NewFloat64(ctx, ret); } -static JSValue js_PlaySound(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector3Distance(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Sound * argptr0 = (Sound *)JS_GetOpaque2(ctx, argv[0], js_Sound_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Sound arg0 = *argptr0; - PlaySound(arg0); + Vector3 arg0; - return JS_UNDEFINED; -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_StopSound(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Sound * argptr0 = (Sound *)JS_GetOpaque2(ctx, argv[0], js_Sound_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Sound arg0 = *argptr0; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; - StopSound(arg0); + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); - return JS_UNDEFINED; -} + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + -static JSValue js_PauseSound(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Sound * argptr0 = (Sound *)JS_GetOpaque2(ctx, argv[0], js_Sound_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + Vector3 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; - Sound arg0 = *argptr0; + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; - PauseSound(arg0); + JSValue z = JS_GetPropertyUint32(ctx, argv[1], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg1.z = (float)z_double; + } + else { + Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); - return JS_UNDEFINED; + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + float ret = Vector3Distance(arg0, arg1); + + + return JS_NewFloat64(ctx, ret); } -static JSValue js_ResumeSound(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector3DistanceSqr(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Sound * argptr0 = (Sound *)JS_GetOpaque2(ctx, argv[0], js_Sound_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Sound arg0 = *argptr0; - ResumeSound(arg0); + Vector3 arg0; - return JS_UNDEFINED; -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_IsSoundPlaying(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Sound * argptr0 = (Sound *)JS_GetOpaque2(ctx, argv[0], js_Sound_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Sound arg0 = *argptr0; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; - bool ret = IsSoundPlaying(arg0); + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); - return JS_NewBool(ctx, ret); -} + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + -static JSValue js_SetSoundVolume(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Sound * argptr0 = (Sound *)JS_GetOpaque2(ctx, argv[0], js_Sound_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + Vector3 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; - Sound arg0 = *argptr0; - double arg1; - JS_ToFloat64(ctx, &arg1, argv[1]); + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; - SetSoundVolume(arg0, arg1); + JSValue z = JS_GetPropertyUint32(ctx, argv[1], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg1.z = (float)z_double; + } + else { + Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); - return JS_UNDEFINED; + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + float ret = Vector3DistanceSqr(arg0, arg1); + + + return JS_NewFloat64(ctx, ret); } -static JSValue js_SetSoundPitch(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector3Angle(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Sound * argptr0 = (Sound *)JS_GetOpaque2(ctx, argv[0], js_Sound_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Sound arg0 = *argptr0; - double arg1; - JS_ToFloat64(ctx, &arg1, argv[1]); - SetSoundPitch(arg0, arg1); + Vector3 arg0; - return JS_UNDEFINED; -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_SetSoundPan(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Sound * argptr0 = (Sound *)JS_GetOpaque2(ctx, argv[0], js_Sound_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Sound arg0 = *argptr0; - double arg1; - JS_ToFloat64(ctx, &arg1, argv[1]); + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; - SetSoundPan(arg0, arg1); + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); - return JS_UNDEFINED; -} + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + -static JSValue js_WaveCopy(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Wave * argptr0 = (Wave *)JS_GetOpaque2(ctx, argv[0], js_Wave_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + Vector3 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; - Wave arg0 = *argptr0; + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; - Wave returnVal = WaveCopy(arg0); + JSValue z = JS_GetPropertyUint32(ctx, argv[1], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg1.z = (float)z_double; + } + else { + Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); - - Wave* ret_ptr = (Wave *)js_malloc(ctx, sizeof(Wave)); - *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Wave_class_id); - JS_SetOpaque(ret, ret_ptr); - return ret; - + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + float ret = Vector3Angle(arg0, arg1); + + + return JS_NewFloat64(ctx, ret); } -static JSValue js_LoadWaveSamples(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector3Negate(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Wave * argptr0 = (Wave *)JS_GetOpaque2(ctx, argv[0], js_Wave_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Wave arg0 = *argptr0; - float * retBuf = LoadWaveSamples(arg0); + Vector3 arg0; - JSValue ret = JS_NewArray(ctx); - //TODO - return ret; - -} + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { -static JSValue js_LoadMusicStream(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); - Music returnVal = LoadMusicStream(arg0); + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + Vector3 returnVal = Vector3Negate(arg0); - JS_FreeCString(ctx, arg0); - Music* ret_ptr = (Music *)js_malloc(ctx, sizeof(Music)); + Vector3* ret_ptr = (Vector3 *)js_malloc(ctx, sizeof(Vector3)); *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Music_class_id); + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); JS_SetOpaque(ret, ret_ptr); return ret; } -static JSValue js_LoadMusicStreamFromMemory(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector3Divide(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); -size_t data_size1; - const unsigned char * arg1 = (const unsigned char *)JS_GetArrayBuffer(ctx, &data_size1, argv[1]); - int arg2; - JS_ToInt32(ctx, &arg2, argv[2]); - Music returnVal = LoadMusicStreamFromMemory(arg0, arg1, arg2); - JS_FreeCString(ctx, arg0); + Vector3 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + + Vector3 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[1], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg1.z = (float)z_double; + } + else { + + Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + Vector3 returnVal = Vector3Divide(arg0, arg1); + - Music* ret_ptr = (Music *)js_malloc(ctx, sizeof(Music)); + Vector3* ret_ptr = (Vector3 *)js_malloc(ctx, sizeof(Vector3)); *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Music_class_id); + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); JS_SetOpaque(ret, ret_ptr); return ret; } -static JSValue js_IsMusicReady(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector3Normalize(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Music * argptr0 = (Music *)JS_GetOpaque2(ctx, argv[0], js_Music_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Music arg0 = *argptr0; - bool ret = IsMusicReady(arg0); + Vector3 arg0; - return JS_NewBool(ctx, ret); -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_UnloadMusicStream(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Music * argptr0 = (Music *)JS_GetOpaque2(ctx, argv[0], js_Music_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Music arg0 = *argptr0; - - UnloadMusicStream(arg0); + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { - return JS_UNDEFINED; -} + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); -static JSValue js_PlayMusicStream(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Music * argptr0 = (Music *)JS_GetOpaque2(ctx, argv[0], js_Music_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } - Music arg0 = *argptr0; - - PlayMusicStream(arg0); + Vector3 returnVal = Vector3Normalize(arg0); - return JS_UNDEFINED; + + Vector3* ret_ptr = (Vector3 *)js_malloc(ctx, sizeof(Vector3)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_IsMusicStreamPlaying(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector3Project(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Music * argptr0 = (Music *)JS_GetOpaque2(ctx, argv[0], js_Music_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Music arg0 = *argptr0; - bool ret = IsMusicStreamPlaying(arg0); + Vector3 arg0; - return JS_NewBool(ctx, ret); -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_UpdateMusicStream(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Music * argptr0 = (Music *)JS_GetOpaque2(ctx, argv[0], js_Music_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Music arg0 = *argptr0; - - UpdateMusicStream(arg0); + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { - return JS_UNDEFINED; -} + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); -static JSValue js_StopMusicStream(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Music * argptr0 = (Music *)JS_GetOpaque2(ctx, argv[0], js_Music_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } - Music arg0 = *argptr0; - - StopMusicStream(arg0); + Vector3 arg1; - return JS_UNDEFINED; -} + if (JS_IsArray(ctx, argv[1])) { -static JSValue js_PauseMusicStream(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Music * argptr0 = (Music *)JS_GetOpaque2(ctx, argv[0], js_Music_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; - Music arg0 = *argptr0; - - PauseMusicStream(arg0); + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + JSValue z = JS_GetPropertyUint32(ctx, argv[1], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg1.z = (float)z_double; + } + else { - return JS_UNDEFINED; -} + Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); -static JSValue js_ResumeMusicStream(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Music * argptr0 = (Music *)JS_GetOpaque2(ctx, argv[0], js_Music_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } - Music arg0 = *argptr0; - - ResumeMusicStream(arg0); + Vector3 returnVal = Vector3Project(arg0, arg1); - return JS_UNDEFINED; + + Vector3* ret_ptr = (Vector3 *)js_malloc(ctx, sizeof(Vector3)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_SeekMusicStream(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector3Reject(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Music * argptr0 = (Music *)JS_GetOpaque2(ctx, argv[0], js_Music_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Music arg0 = *argptr0; - double arg1; - JS_ToFloat64(ctx, &arg1, argv[1]); - SeekMusicStream(arg0, arg1); + Vector3 arg0; - return JS_UNDEFINED; -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_SetMusicVolume(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Music * argptr0 = (Music *)JS_GetOpaque2(ctx, argv[0], js_Music_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Music arg0 = *argptr0; - double arg1; - JS_ToFloat64(ctx, &arg1, argv[1]); + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; - SetMusicVolume(arg0, arg1); + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); - return JS_UNDEFINED; -} + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + -static JSValue js_SetMusicPitch(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Music * argptr0 = (Music *)JS_GetOpaque2(ctx, argv[0], js_Music_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + Vector3 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; - Music arg0 = *argptr0; - double arg1; - JS_ToFloat64(ctx, &arg1, argv[1]); + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; - SetMusicPitch(arg0, arg1); + JSValue z = JS_GetPropertyUint32(ctx, argv[1], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg1.z = (float)z_double; + } + else { + Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); - return JS_UNDEFINED; + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + Vector3 returnVal = Vector3Reject(arg0, arg1); + + + + Vector3* ret_ptr = (Vector3 *)js_malloc(ctx, sizeof(Vector3)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_SetMusicPan(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector3OrthoNormalize(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Music * argptr0 = (Music *)JS_GetOpaque2(ctx, argv[0], js_Music_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Music arg0 = *argptr0; - double arg1; - JS_ToFloat64(ctx, &arg1, argv[1]); + Vector3 * arg0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + Vector3 * arg1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); - SetMusicPan(arg0, arg1); + Vector3OrthoNormalize(arg0, arg1); return JS_UNDEFINED; } -static JSValue js_GetMusicTimeLength(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector3Transform(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Music * argptr0 = (Music *)JS_GetOpaque2(ctx, argv[0], js_Music_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Music arg0 = *argptr0; - float ret = GetMusicTimeLength(arg0); + Vector3 arg0; - return JS_NewFloat64(ctx, ret); -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_GetMusicTimePlayed(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Music * argptr0 = (Music *)JS_GetOpaque2(ctx, argv[0], js_Music_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Music arg0 = *argptr0; - - float ret = GetMusicTimePlayed(arg0); + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { - return JS_NewFloat64(ctx, ret); -} + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); -static JSValue js_LoadAudioStream(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - unsigned int arg0; - JS_ToUint32(ctx, &arg0, argv[0]); - unsigned int arg1; - JS_ToUint32(ctx, &arg1, argv[1]); - unsigned int arg2; - JS_ToUint32(ctx, &arg2, argv[2]); + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + Matrix * argptr1 = (Matrix *)JS_GetOpaque2(ctx, argv[1], js_Matrix_class_id); + if (argptr1 == NULL) return JS_EXCEPTION; + + Matrix arg1 = *argptr1; - AudioStream returnVal = LoadAudioStream(arg0, arg1, arg2); + Vector3 returnVal = Vector3Transform(arg0, arg1); - AudioStream* ret_ptr = (AudioStream *)js_malloc(ctx, sizeof(AudioStream)); + Vector3* ret_ptr = (Vector3 *)js_malloc(ctx, sizeof(Vector3)); *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_AudioStream_class_id); + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); JS_SetOpaque(ret, ret_ptr); return ret; } -static JSValue js_IsAudioStreamReady(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector3RotateByQuaternion(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - AudioStream * argptr0 = (AudioStream *)JS_GetOpaque2(ctx, argv[0], js_AudioStream_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - AudioStream arg0 = *argptr0; - bool ret = IsAudioStreamReady(arg0); + Vector3 arg0; - return JS_NewBool(ctx, ret); -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_UnloadAudioStream(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - AudioStream * argptr0 = (AudioStream *)JS_GetOpaque2(ctx, argv[0], js_AudioStream_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - AudioStream arg0 = *argptr0; - - UnloadAudioStream(arg0); + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { - return JS_UNDEFINED; -} + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); -static JSValue js_UpdateAudioStream(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - AudioStream * argptr0 = (AudioStream *)JS_GetOpaque2(ctx, argv[0], js_AudioStream_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + Quaternion * argptr1 = (Quaternion *)JS_GetOpaque2(ctx, argv[1], js_Quaternion_class_id); + if (argptr1 == NULL) + argptr1 = (Quaternion *)JS_GetOpaque2(ctx, argv[1], js_Vector4_class_id); + if (argptr1 == NULL) return JS_EXCEPTION; - AudioStream arg0 = *argptr0; -size_t data_size1; - const void * arg1 = (const void *)JS_GetArrayBuffer(ctx, &data_size1, argv[1]); - int arg2; - JS_ToInt32(ctx, &arg2, argv[2]); + Quaternion arg1 = *argptr1; - UpdateAudioStream(arg0, arg1, arg2); + Vector3 returnVal = Vector3RotateByQuaternion(arg0, arg1); - return JS_UNDEFINED; + + Vector3* ret_ptr = (Vector3 *)js_malloc(ctx, sizeof(Vector3)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_IsAudioStreamProcessed(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector3RotateByAxisAngle(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - AudioStream * argptr0 = (AudioStream *)JS_GetOpaque2(ctx, argv[0], js_AudioStream_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - AudioStream arg0 = *argptr0; - bool ret = IsAudioStreamProcessed(arg0); + Vector3 arg0; - return JS_NewBool(ctx, ret); -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_PlayAudioStream(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - AudioStream * argptr0 = (AudioStream *)JS_GetOpaque2(ctx, argv[0], js_AudioStream_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - AudioStream arg0 = *argptr0; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; - PlayAudioStream(arg0); + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + Vector3 arg1; - return JS_UNDEFINED; -} + if (JS_IsArray(ctx, argv[1])) { -static JSValue js_PauseAudioStream(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - AudioStream * argptr0 = (AudioStream *)JS_GetOpaque2(ctx, argv[0], js_AudioStream_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; - AudioStream arg0 = *argptr0; - - PauseAudioStream(arg0); + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + JSValue z = JS_GetPropertyUint32(ctx, argv[1], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg1.z = (float)z_double; + } + else { - return JS_UNDEFINED; -} + Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); -static JSValue js_ResumeAudioStream(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - AudioStream * argptr0 = (AudioStream *)JS_GetOpaque2(ctx, argv[0], js_AudioStream_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - AudioStream arg0 = *argptr0; + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); - ResumeAudioStream(arg0); + Vector3 returnVal = Vector3RotateByAxisAngle(arg0, arg1, arg2); - return JS_UNDEFINED; + + Vector3* ret_ptr = (Vector3 *)js_malloc(ctx, sizeof(Vector3)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_IsAudioStreamPlaying(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector3Lerp(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - AudioStream * argptr0 = (AudioStream *)JS_GetOpaque2(ctx, argv[0], js_AudioStream_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - AudioStream arg0 = *argptr0; - bool ret = IsAudioStreamPlaying(arg0); + Vector3 arg0; - return JS_NewBool(ctx, ret); -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_StopAudioStream(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - AudioStream * argptr0 = (AudioStream *)JS_GetOpaque2(ctx, argv[0], js_AudioStream_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - AudioStream arg0 = *argptr0; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; - StopAudioStream(arg0); + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); - return JS_UNDEFINED; -} + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + -static JSValue js_SetAudioStreamVolume(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - AudioStream * argptr0 = (AudioStream *)JS_GetOpaque2(ctx, argv[0], js_AudioStream_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + Vector3 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; - AudioStream arg0 = *argptr0; - double arg1; - JS_ToFloat64(ctx, &arg1, argv[1]); + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; - SetAudioStreamVolume(arg0, arg1); + JSValue z = JS_GetPropertyUint32(ctx, argv[1], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg1.z = (float)z_double; + } + else { + Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); - return JS_UNDEFINED; + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); + + Vector3 returnVal = Vector3Lerp(arg0, arg1, arg2); + + + + Vector3* ret_ptr = (Vector3 *)js_malloc(ctx, sizeof(Vector3)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_SetAudioStreamPitch(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector3Reflect(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - AudioStream * argptr0 = (AudioStream *)JS_GetOpaque2(ctx, argv[0], js_AudioStream_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - AudioStream arg0 = *argptr0; - double arg1; - JS_ToFloat64(ctx, &arg1, argv[1]); - SetAudioStreamPitch(arg0, arg1); + Vector3 arg0; - return JS_UNDEFINED; -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_SetAudioStreamPan(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - AudioStream * argptr0 = (AudioStream *)JS_GetOpaque2(ctx, argv[0], js_AudioStream_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - AudioStream arg0 = *argptr0; - double arg1; - JS_ToFloat64(ctx, &arg1, argv[1]); + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; - SetAudioStreamPan(arg0, arg1); + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); - return JS_UNDEFINED; -} + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + -static JSValue js_SetAudioStreamBufferSizeDefault(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - int arg0; - JS_ToInt32(ctx, &arg0, argv[0]); + Vector3 arg1; - SetAudioStreamBufferSizeDefault(arg0); + if (JS_IsArray(ctx, argv[1])) { + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; - return JS_UNDEFINED; -} + JSValue z = JS_GetPropertyUint32(ctx, argv[1], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg1.z = (float)z_double; + } + else { -static JSValue js_GetCameraForward(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Camera * arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera_class_id); - if (arg0 == NULL) - arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera3D_class_id); + Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); - Vector3 returnVal = GetCameraForward(arg0); + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + Vector3 returnVal = Vector3Reflect(arg0, arg1); @@ -14886,13 +28402,68 @@ static JSValue js_GetCameraForward(JSContext *ctx, JSValueConst this_val, int ar } -static JSValue js_GetCameraUp(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector3Min(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Camera * arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera_class_id); - if (arg0 == NULL) - arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera3D_class_id); - Vector3 returnVal = GetCameraUp(arg0); + + Vector3 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + + Vector3 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[1], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg1.z = (float)z_double; + } + else { + + Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + Vector3 returnVal = Vector3Min(arg0, arg1); @@ -14904,13 +28475,68 @@ static JSValue js_GetCameraUp(JSContext *ctx, JSValueConst this_val, int argc, J } -static JSValue js_GetCameraRight(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector3Max(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Camera * arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera_class_id); - if (arg0 == NULL) - arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera3D_class_id); - Vector3 returnVal = GetCameraRight(arg0); + + Vector3 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + + Vector3 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[1], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg1.z = (float)z_double; + } + else { + + Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + Vector3 returnVal = Vector3Max(arg0, arg1); @@ -14922,1275 +28548,1743 @@ static JSValue js_GetCameraRight(JSContext *ctx, JSValueConst this_val, int argc } -static JSValue js_CameraMoveForward(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector3Barycenter(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Camera * arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera_class_id); - if (arg0 == NULL) - arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera3D_class_id); - double arg1; - JS_ToFloat64(ctx, &arg1, argv[1]); - JS_BOOL argbool2 = JS_ToBool(ctx, argv[2]); - bool arg2 = (bool) argbool2; - CameraMoveForward(arg0, arg1, arg2); + Vector3 arg0; - return JS_UNDEFINED; -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_CameraMoveUp(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Camera * arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera_class_id); - if (arg0 == NULL) - arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera3D_class_id); - double arg1; - JS_ToFloat64(ctx, &arg1, argv[1]); + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; - CameraMoveUp(arg0, arg1); + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); - return JS_UNDEFINED; -} + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + -static JSValue js_CameraMoveRight(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Camera * arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera_class_id); - if (arg0 == NULL) - arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera3D_class_id); - double arg1; - JS_ToFloat64(ctx, &arg1, argv[1]); - JS_BOOL argbool2 = JS_ToBool(ctx, argv[2]); - bool arg2 = (bool) argbool2; + Vector3 arg1; - CameraMoveRight(arg0, arg1, arg2); + if (JS_IsArray(ctx, argv[1])) { + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; - return JS_UNDEFINED; -} + JSValue z = JS_GetPropertyUint32(ctx, argv[1], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg1.z = (float)z_double; + } + else { -static JSValue js_CameraMoveToTarget(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Camera * arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera_class_id); - if (arg0 == NULL) - arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera3D_class_id); - double arg1; - JS_ToFloat64(ctx, &arg1, argv[1]); + Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); - CameraMoveToTarget(arg0, arg1); + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + Vector3 arg2; - return JS_UNDEFINED; -} + if (JS_IsArray(ctx, argv[2])) { -static JSValue js_CameraYaw(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Camera * arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera_class_id); - if (arg0 == NULL) - arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera3D_class_id); - double arg1; - JS_ToFloat64(ctx, &arg1, argv[1]); - JS_BOOL argbool2 = JS_ToBool(ctx, argv[2]); - bool arg2 = (bool) argbool2; + JSValue x = JS_GetPropertyUint32(ctx, argv[2], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg2.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[2], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg2.y = (float)y_double; - CameraYaw(arg0, arg1, arg2); + JSValue z = JS_GetPropertyUint32(ctx, argv[2], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg2.z = (float)z_double; + } + else { + Vector3 * argptr2 = (Vector3 *)JS_GetOpaque2(ctx, argv[2], js_Vector3_class_id); - return JS_UNDEFINED; + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + + + Vector3 arg3; + + if (JS_IsArray(ctx, argv[3])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[3], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg3.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[3], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg3.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[3], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg3.z = (float)z_double; + } + else { + + Vector3 * argptr3 = (Vector3 *)JS_GetOpaque2(ctx, argv[3], js_Vector3_class_id); + + if (argptr3 == NULL) return JS_EXCEPTION; + + arg3 = *argptr3; + } + + Vector3 returnVal = Vector3Barycenter(arg0, arg1, arg2, arg3); + + + + Vector3* ret_ptr = (Vector3 *)js_malloc(ctx, sizeof(Vector3)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_CameraPitch(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector3Unproject(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Camera * arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera_class_id); - if (arg0 == NULL) - arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera3D_class_id); - double arg1; - JS_ToFloat64(ctx, &arg1, argv[1]); - JS_BOOL argbool2 = JS_ToBool(ctx, argv[2]); - bool arg2 = (bool) argbool2; - JS_BOOL argbool3 = JS_ToBool(ctx, argv[3]); - bool arg3 = (bool) argbool3; - JS_BOOL argbool4 = JS_ToBool(ctx, argv[4]); - bool arg4 = (bool) argbool4; - CameraPitch(arg0, arg1, arg2, arg3, arg4); + Vector3 arg0; - return JS_UNDEFINED; + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + Matrix * argptr1 = (Matrix *)JS_GetOpaque2(ctx, argv[1], js_Matrix_class_id); + if (argptr1 == NULL) return JS_EXCEPTION; + + Matrix arg1 = *argptr1; + Matrix * argptr2 = (Matrix *)JS_GetOpaque2(ctx, argv[2], js_Matrix_class_id); + if (argptr2 == NULL) return JS_EXCEPTION; + + Matrix arg2 = *argptr2; + + Vector3 returnVal = Vector3Unproject(arg0, arg1, arg2); + + + + Vector3* ret_ptr = (Vector3 *)js_malloc(ctx, sizeof(Vector3)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_CameraRoll(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector3ToFloatV(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Camera * arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera_class_id); - if (arg0 == NULL) - arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera3D_class_id); - double arg1; - JS_ToFloat64(ctx, &arg1, argv[1]); - CameraRoll(arg0, arg1); + Vector3 arg0; - return JS_UNDEFINED; -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_GetCameraViewMatrix(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Camera * arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera_class_id); - if (arg0 == NULL) - arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera3D_class_id); + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; - Matrix returnVal = GetCameraViewMatrix(arg0); + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + float3 returnVal = Vector3ToFloatV(arg0); - Matrix* ret_ptr = (Matrix *)js_malloc(ctx, sizeof(Matrix)); + float3* ret_ptr = (float3 *)js_malloc(ctx, sizeof(float3)); *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); + JSValue ret = JS_NewObjectClass(ctx, js_float3_class_id); JS_SetOpaque(ret, ret_ptr); return ret; } -static JSValue js_GetCameraProjectionMatrix(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector3Invert(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Camera * arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera_class_id); - if (arg0 == NULL) - arg0 = (Camera *)JS_GetOpaque2(ctx, argv[0], js_Camera3D_class_id); - double arg1; - JS_ToFloat64(ctx, &arg1, argv[1]); - Matrix returnVal = GetCameraProjectionMatrix(arg0, arg1); + + Vector3 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + Vector3 returnVal = Vector3Invert(arg0); - Matrix* ret_ptr = (Matrix *)js_malloc(ctx, sizeof(Matrix)); + Vector3* ret_ptr = (Vector3 *)js_malloc(ctx, sizeof(Vector3)); *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); JS_SetOpaque(ret, ret_ptr); return ret; } +static JSValue js_Vector3Clamp(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ -static JSClassID js_GuiStyleProp_class_id; + Vector3 arg0; -static JSValue js_GuiStyleProp_get(JSContext *ctx, JSValueConst this_val, int magic) -{ - GuiStyleProp *s = JS_GetOpaque2(ctx, this_val, js_GuiStyleProp_class_id); - if (!s) - return JS_EXCEPTION; + if (JS_IsArray(ctx, argv[0])) { - -if (magic == 0) { - return JS_NewUint32(ctx, (unsigned short) s->controlId); -} + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; -if (magic == 1) { - return JS_NewUint32(ctx, (unsigned short) s->propertyId); -} + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { -if (magic == 2) { - return JS_NewInt32(ctx, (int) s->propertyValue); -} + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + - return JS_UNDEFINED; -} + Vector3 arg1; -static JSValue js_GuiStyleProp_set(JSContext *ctx, JSValueConst this_val, JSValue val, int magic) -{ - GuiStyleProp *s = JS_GetOpaque2(ctx, this_val, js_GuiStyleProp_class_id); - if (!s) - return JS_EXCEPTION; + if (JS_IsArray(ctx, argv[1])) { - -if (magic == 0) { - unsigned short v0; - if (JS_ToUint32(ctx, &v0, val)) - return JS_EXCEPTION; - s->controlId = (unsigned short) v0; -} + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; -if (magic == 1) { - unsigned short v1; - if (JS_ToUint32(ctx, &v1, val)) - return JS_EXCEPTION; - s->propertyId = (unsigned short) v1; -} + JSValue z = JS_GetPropertyUint32(ctx, argv[1], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg1.z = (float)z_double; + } + else { + + Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + + Vector3 arg2; + + if (JS_IsArray(ctx, argv[2])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[2], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg2.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[2], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg2.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[2], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg2.z = (float)z_double; + } + else { + + Vector3 * argptr2 = (Vector3 *)JS_GetOpaque2(ctx, argv[2], js_Vector3_class_id); + + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } + + Vector3 returnVal = Vector3Clamp(arg0, arg1, arg2); -if (magic == 2) { - int v2; - if (JS_ToInt32(ctx, &v2, val)) - return JS_EXCEPTION; - s->propertyValue = (int) v2; -} - return JS_UNDEFINED; + Vector3* ret_ptr = (Vector3 *)js_malloc(ctx, sizeof(Vector3)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static void js_GuiStyleProp_finalizer(JSRuntime *rt, JSValue val) +static JSValue js_Vector3ClampValue(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - GuiStyleProp *s = JS_GetOpaque(val, js_GuiStyleProp_class_id); - /* Note: 's' can be NULL in case JS_SetOpaque() was not called */ - js_free_rt(rt, s); -} -static JSValue js_GuiStyleProp_ctor(JSContext *ctx, - JSValueConst new_target, - int argc, JSValueConst *argv) -{ - /*emscripten_log(EM_LOG_CONSOLE, "--> js_GuiStyleProp_ctor: argc=%d", argc); + Vector3 arg0; - for (int i=0; i < argc; ++i) { + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); + + Vector3 returnVal = Vector3ClampValue(arg0, arg1, arg2); - emscripten_log(EM_LOG_CONSOLE, "%d: %d", i, JS_VALUE_GET_TAG(argv[i])); - }*/ - - GuiStyleProp *s; - JSValue obj = JS_UNDEFINED; - JSValue proto; - s = js_mallocz(ctx, sizeof(*s)); - if (!s) - return JS_EXCEPTION; - /* using new_target to get the prototype is necessary when the - class is extended. */ + Vector3* ret_ptr = (Vector3 *)js_malloc(ctx, sizeof(Vector3)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; -unsigned short v0; -if (JS_ToUint32(ctx, &v0, argv[0])) - goto fail; -s->controlId = (unsigned short) v0; +} -/*emscripten_log(EM_LOG_CONSOLE, "Set prop: 0 = %lf", s->0);*/ - +static JSValue js_Vector3Equals(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ -unsigned short v1; -if (JS_ToUint32(ctx, &v1, argv[1])) - goto fail; -s->propertyId = (unsigned short) v1; -/*emscripten_log(EM_LOG_CONSOLE, "Set prop: 1 = %lf", s->1);*/ - + Vector3 arg0; -int v2; -if (JS_ToInt32(ctx, &v2, argv[2])) - goto fail; -s->propertyValue = (int) v2; + if (JS_IsArray(ctx, argv[0])) { -/*emscripten_log(EM_LOG_CONSOLE, "Set prop: 2 = %lf", s->2);*/ - + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; - proto = JS_GetPropertyStr(ctx, new_target, "prototype"); - if (JS_IsException(proto)) - goto fail; - obj = JS_NewObjectProtoClass(ctx, proto, js_GuiStyleProp_class_id); - JS_FreeValue(ctx, proto); - if (JS_IsException(obj)) - goto fail; - JS_SetOpaque(obj, s); - return obj; - fail: - js_free(ctx, s); - JS_FreeValue(ctx, obj); - return JS_EXCEPTION; -} + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { -static JSClassDef js_GuiStyleProp_class = { - "GuiStyleProp", - .finalizer = js_GuiStyleProp_finalizer, -}; + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); -static const JSCFunctionListEntry js_GuiStyleProp_proto_funcs[] = { - JS_CGETSET_MAGIC_DEF("controlId", js_GuiStyleProp_get, js_GuiStyleProp_set, 0), - JS_CGETSET_MAGIC_DEF("propertyId", js_GuiStyleProp_get, js_GuiStyleProp_set, 1), - JS_CGETSET_MAGIC_DEF("propertyValue", js_GuiStyleProp_get, js_GuiStyleProp_set, 2), + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + - /*JS_PROP_STRING_DEF("[Symbol.toStringTag]", "GuiStyleProp", JS_PROP_CONFIGURABLE ),*/ -}; - -static int js_declare_GuiStyleProp(JSContext *ctx, JSModuleDef *m) -{ - JSValue proto, class; + Vector3 arg1; - /* create the class */ - JS_NewClassID(&js_GuiStyleProp_class_id); - JS_NewClass(JS_GetRuntime(ctx), js_GuiStyleProp_class_id, &js_GuiStyleProp_class); + if (JS_IsArray(ctx, argv[1])) { - proto = JS_NewObject(ctx); - JS_SetPropertyFunctionList(ctx, proto, js_GuiStyleProp_proto_funcs, countof(js_GuiStyleProp_proto_funcs)); + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; - class = JS_NewCFunction2(ctx, js_GuiStyleProp_ctor, "GuiStyleProp", 3, JS_CFUNC_constructor, 0); - /* set proto.constructor and ctor.prototype */ - JS_SetConstructor(ctx, class, proto); - JS_SetClassProto(ctx, js_GuiStyleProp_class_id, proto); + JSValue z = JS_GetPropertyUint32(ctx, argv[1], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg1.z = (float)z_double; + } + else { - JS_SetModuleExport(ctx, m, "GuiStyleProp", class); - return 0; + Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + int ret = Vector3Equals(arg0, arg1); + + + return JS_NewInt32(ctx, ret); } -static JSValue js_GuiEnable(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_Vector3Refract(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - GuiEnable(); + Vector3 arg0; - return JS_UNDEFINED; + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + + Vector3 arg1; + + if (JS_IsArray(ctx, argv[1])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[1], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg1.z = (float)z_double; + } + else { + + Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); + + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); + + Vector3 returnVal = Vector3Refract(arg0, arg1, arg2); + + + + Vector3* ret_ptr = (Vector3 *)js_malloc(ctx, sizeof(Vector3)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_GuiDisable(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_MatrixDeterminant(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { + Matrix * argptr0 = (Matrix *)JS_GetOpaque2(ctx, argv[0], js_Matrix_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Matrix arg0 = *argptr0; - GuiDisable(); + float ret = MatrixDeterminant(arg0); - return JS_UNDEFINED; + return JS_NewFloat64(ctx, ret); } -static JSValue js_GuiLock(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_MatrixTrace(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { + Matrix * argptr0 = (Matrix *)JS_GetOpaque2(ctx, argv[0], js_Matrix_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Matrix arg0 = *argptr0; - GuiLock(); + float ret = MatrixTrace(arg0); - return JS_UNDEFINED; + return JS_NewFloat64(ctx, ret); } -static JSValue js_GuiUnlock(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_MatrixTranspose(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { + Matrix * argptr0 = (Matrix *)JS_GetOpaque2(ctx, argv[0], js_Matrix_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Matrix arg0 = *argptr0; - GuiUnlock(); + Matrix returnVal = MatrixTranspose(arg0); - return JS_UNDEFINED; + + Matrix* ret_ptr = (Matrix *)js_malloc(ctx, sizeof(Matrix)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_GuiIsLocked(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_MatrixInvert(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { + Matrix * argptr0 = (Matrix *)JS_GetOpaque2(ctx, argv[0], js_Matrix_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Matrix arg0 = *argptr0; - bool ret = GuiIsLocked(); + Matrix returnVal = MatrixInvert(arg0); - return JS_NewBool(ctx, ret); + + Matrix* ret_ptr = (Matrix *)js_malloc(ctx, sizeof(Matrix)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_GuiSetAlpha(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_MatrixIdentity(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - double arg0; - JS_ToFloat64(ctx, &arg0, argv[0]); - GuiSetAlpha(arg0); + Matrix returnVal = MatrixIdentity(); - return JS_UNDEFINED; + + Matrix* ret_ptr = (Matrix *)js_malloc(ctx, sizeof(Matrix)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_GuiSetState(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_MatrixAdd(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - int arg0; - JS_ToInt32(ctx, &arg0, argv[0]); + Matrix * argptr0 = (Matrix *)JS_GetOpaque2(ctx, argv[0], js_Matrix_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Matrix arg0 = *argptr0; + Matrix * argptr1 = (Matrix *)JS_GetOpaque2(ctx, argv[1], js_Matrix_class_id); + if (argptr1 == NULL) return JS_EXCEPTION; + + Matrix arg1 = *argptr1; - GuiSetState(arg0); + Matrix returnVal = MatrixAdd(arg0, arg1); - return JS_UNDEFINED; + + Matrix* ret_ptr = (Matrix *)js_malloc(ctx, sizeof(Matrix)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_GuiGetState(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_MatrixSubtract(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { + Matrix * argptr0 = (Matrix *)JS_GetOpaque2(ctx, argv[0], js_Matrix_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Matrix arg0 = *argptr0; + Matrix * argptr1 = (Matrix *)JS_GetOpaque2(ctx, argv[1], js_Matrix_class_id); + if (argptr1 == NULL) return JS_EXCEPTION; + + Matrix arg1 = *argptr1; - int ret = GuiGetState(); + Matrix returnVal = MatrixSubtract(arg0, arg1); - return JS_NewInt32(ctx, ret); + + Matrix* ret_ptr = (Matrix *)js_malloc(ctx, sizeof(Matrix)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_GuiSetFont(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_MatrixMultiply(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Font * argptr0 = (Font *)JS_GetOpaque2(ctx, argv[0], js_Font_class_id); + Matrix * argptr0 = (Matrix *)JS_GetOpaque2(ctx, argv[0], js_Matrix_class_id); if (argptr0 == NULL) return JS_EXCEPTION; - Font arg0 = *argptr0; + Matrix arg0 = *argptr0; + Matrix * argptr1 = (Matrix *)JS_GetOpaque2(ctx, argv[1], js_Matrix_class_id); + if (argptr1 == NULL) return JS_EXCEPTION; + + Matrix arg1 = *argptr1; - GuiSetFont(arg0); + Matrix returnVal = MatrixMultiply(arg0, arg1); - return JS_UNDEFINED; + + Matrix* ret_ptr = (Matrix *)js_malloc(ctx, sizeof(Matrix)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_GuiGetFont(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_MatrixTranslate(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { + double arg0; + JS_ToFloat64(ctx, &arg0, argv[0]); + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); - Font returnVal = GuiGetFont(); + Matrix returnVal = MatrixTranslate(arg0, arg1, arg2); - Font* ret_ptr = (Font *)js_malloc(ctx, sizeof(Font)); + Matrix* ret_ptr = (Matrix *)js_malloc(ctx, sizeof(Matrix)); *ret_ptr = returnVal; - JSValue ret = JS_NewObjectClass(ctx, js_Font_class_id); + JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); JS_SetOpaque(ret, ret_ptr); return ret; } -static JSValue js_GuiSetStyle(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_MatrixRotate(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - int arg0; - JS_ToInt32(ctx, &arg0, argv[0]); - int arg1; - JS_ToInt32(ctx, &arg1, argv[1]); - int arg2; - JS_ToInt32(ctx, &arg2, argv[2]); - - GuiSetStyle(arg0, arg1, arg2); - return JS_UNDEFINED; -} + Vector3 arg0; -static JSValue js_GuiGetStyle(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - int arg0; - JS_ToInt32(ctx, &arg0, argv[0]); - int arg1; - JS_ToInt32(ctx, &arg1, argv[1]); + if (JS_IsArray(ctx, argv[0])) { - int ret = GuiGetStyle(arg0, arg1); + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { - return JS_NewInt32(ctx, ret); -} + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); -static JSValue js_GuiLoadStyle(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); - GuiLoadStyle(arg0); + Matrix returnVal = MatrixRotate(arg0, arg1); - JS_FreeCString(ctx, arg0); - return JS_UNDEFINED; + + Matrix* ret_ptr = (Matrix *)js_malloc(ctx, sizeof(Matrix)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_GuiLoadStyleDefault(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_MatrixRotateX(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { + double arg0; + JS_ToFloat64(ctx, &arg0, argv[0]); - GuiLoadStyleDefault(); + Matrix returnVal = MatrixRotateX(arg0); - return JS_UNDEFINED; + + Matrix* ret_ptr = (Matrix *)js_malloc(ctx, sizeof(Matrix)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_GuiEnableTooltip(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_MatrixRotateY(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { + double arg0; + JS_ToFloat64(ctx, &arg0, argv[0]); - GuiEnableTooltip(); + Matrix returnVal = MatrixRotateY(arg0); - return JS_UNDEFINED; + + Matrix* ret_ptr = (Matrix *)js_malloc(ctx, sizeof(Matrix)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_GuiDisableTooltip(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_MatrixRotateZ(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { + double arg0; + JS_ToFloat64(ctx, &arg0, argv[0]); - GuiDisableTooltip(); + Matrix returnVal = MatrixRotateZ(arg0); - return JS_UNDEFINED; + + Matrix* ret_ptr = (Matrix *)js_malloc(ctx, sizeof(Matrix)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_GuiSetTooltip(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_MatrixRotateXYZ(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); - GuiSetTooltip(arg0); - JS_FreeCString(ctx, arg0); + Vector3 arg0; - return JS_UNDEFINED; -} + if (JS_IsArray(ctx, argv[0])) { -static JSValue js_GuiIconText(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - int arg0; - JS_ToInt32(ctx, &arg0, argv[0]); - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; - const char * returnVal = GuiIconText(arg0, arg1); + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { - JS_FreeCString(ctx, arg1); + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); - JSValue ret = JS_NewString(ctx, returnVal); + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + + Matrix returnVal = MatrixRotateXYZ(arg0); + + + + Matrix* ret_ptr = (Matrix *)js_malloc(ctx, sizeof(Matrix)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); + JS_SetOpaque(ret, ret_ptr); return ret; + } -static JSValue js_GuiSetIconScale(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_MatrixRotateZYX(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - int arg0; - JS_ToInt32(ctx, &arg0, argv[0]); - - GuiSetIconScale(arg0); - return JS_UNDEFINED; -} + Vector3 arg0; -static JSValue js_GuiLoadIcons(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); - JS_BOOL argbool1 = JS_ToBool(ctx, argv[1]); - bool arg1 = (bool) argbool1; + if (JS_IsArray(ctx, argv[0])) { - GuiLoadIcons(arg0, arg1); + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; - JS_FreeCString(ctx, arg0); + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { - return JS_UNDEFINED; -} + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); -static JSValue js_GuiDrawIcon(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - int arg0; - JS_ToInt32(ctx, &arg0, argv[0]); - int arg1; - JS_ToInt32(ctx, &arg1, argv[1]); - int arg2; - JS_ToInt32(ctx, &arg2, argv[2]); - int arg3; - JS_ToInt32(ctx, &arg3, argv[3]); - Color * argptr4 = (Color *)JS_GetOpaque2(ctx, argv[4], js_Color_class_id); - if (argptr4 == NULL) return JS_EXCEPTION; + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } - Color arg4 = *argptr4; - - GuiDrawIcon(arg0, arg1, arg2, arg3, arg4); + Matrix returnVal = MatrixRotateZYX(arg0); - return JS_UNDEFINED; + + Matrix* ret_ptr = (Matrix *)js_malloc(ctx, sizeof(Matrix)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_GuiWindowBox(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_MatrixScale(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Rectangle arg0 = *argptr0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); + double arg0; + JS_ToFloat64(ctx, &arg0, argv[0]); + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); - int ret = GuiWindowBox(arg0, arg1); + Matrix returnVal = MatrixScale(arg0, arg1, arg2); - JS_FreeCString(ctx, arg1); - return JS_NewInt32(ctx, ret); + + Matrix* ret_ptr = (Matrix *)js_malloc(ctx, sizeof(Matrix)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_GuiGroupBox(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_MatrixFrustum(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Rectangle arg0 = *argptr0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); + double arg0; + JS_ToFloat64(ctx, &arg0, argv[0]); + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); + double arg3; + JS_ToFloat64(ctx, &arg3, argv[3]); + double arg4; + JS_ToFloat64(ctx, &arg4, argv[4]); + double arg5; + JS_ToFloat64(ctx, &arg5, argv[5]); - int ret = GuiGroupBox(arg0, arg1); + Matrix returnVal = MatrixFrustum(arg0, arg1, arg2, arg3, arg4, arg5); - JS_FreeCString(ctx, arg1); - return JS_NewInt32(ctx, ret); + + Matrix* ret_ptr = (Matrix *)js_malloc(ctx, sizeof(Matrix)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_GuiLine(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_MatrixPerspective(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Rectangle arg0 = *argptr0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); + double arg0; + JS_ToFloat64(ctx, &arg0, argv[0]); + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); + double arg3; + JS_ToFloat64(ctx, &arg3, argv[3]); - int ret = GuiLine(arg0, arg1); + Matrix returnVal = MatrixPerspective(arg0, arg1, arg2, arg3); - JS_FreeCString(ctx, arg1); - return JS_NewInt32(ctx, ret); + + Matrix* ret_ptr = (Matrix *)js_malloc(ctx, sizeof(Matrix)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_GuiPanel(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_MatrixOrtho(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Rectangle arg0 = *argptr0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); + double arg0; + JS_ToFloat64(ctx, &arg0, argv[0]); + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); + double arg3; + JS_ToFloat64(ctx, &arg3, argv[3]); + double arg4; + JS_ToFloat64(ctx, &arg4, argv[4]); + double arg5; + JS_ToFloat64(ctx, &arg5, argv[5]); - int ret = GuiPanel(arg0, arg1); + Matrix returnVal = MatrixOrtho(arg0, arg1, arg2, arg3, arg4, arg5); - JS_FreeCString(ctx, arg1); - return JS_NewInt32(ctx, ret); + + Matrix* ret_ptr = (Matrix *)js_malloc(ctx, sizeof(Matrix)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_GuiTabBar(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_MatrixLookAt(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Rectangle arg0 = *argptr0; - - JSValue length_js = JS_GetProperty(ctx, argv[1], JS_ATOM_length); - - int32_t length; - - JS_ToInt32(ctx, &length, length_js); - - char ** tabs = (char **)malloc((length+1)*sizeof(char *)); + Vector3 arg0; - tabs[length] = 0; + if (JS_IsArray(ctx, argv[0])) { - for (int i=0; i < length; ++i) {{ + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; - JSValue val = JS_GetPropertyUint32(ctx, argv[1], i); + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { - const char * str = JS_ToCString(ctx, val); - - tabs[i] = str; - }} - - int arg2; - JS_ToInt32(ctx, &arg2, argv[2]); + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); - JSValue arg3_js = JS_GetPropertyStr(ctx, argv[3], "active"); - int arg3; - JS_ToInt32(ctx, &arg3, arg3_js); + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + - int ret = GuiTabBar(arg0, tabs, arg2, &arg3); + Vector3 arg1; - JS_SetPropertyStr(ctx, argv[3], "active", JS_NewInt32(ctx, arg3)); + if (JS_IsArray(ctx, argv[1])) { - for (int i=0; i < length; ++i) {{ + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; - JS_FreeCString(ctx, tabs[i]); - }} - - if (tabs) - free(tabs); + JSValue z = JS_GetPropertyUint32(ctx, argv[1], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg1.z = (float)z_double; + } + else { - return JS_NewInt32(ctx, ret); -} + Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); -static JSValue js_GuiScrollPanel(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Rectangle arg0 = *argptr0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); - Rectangle * argptr2 = (Rectangle *)JS_GetOpaque2(ctx, argv[2], js_Rectangle_class_id); - if (argptr2 == NULL) return JS_EXCEPTION; + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } - Rectangle arg2 = *argptr2; - Vector2 * arg3 = (Vector2 *)JS_GetOpaque2(ctx, argv[3], js_Vector2_class_id); - Rectangle * arg4 = (Rectangle *)JS_GetOpaque2(ctx, argv[4], js_Rectangle_class_id); - - int ret = GuiScrollPanel(arg0, arg1, arg2, arg3, arg4); - JS_FreeCString(ctx, arg1); + Vector3 arg2; - return JS_NewInt32(ctx, ret); -} + if (JS_IsArray(ctx, argv[2])) { -static JSValue js_GuiLabel(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + JSValue x = JS_GetPropertyUint32(ctx, argv[2], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg2.x = (float)x_double; - Rectangle arg0 = *argptr0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); - - int ret = GuiLabel(arg0, arg1); + JSValue y = JS_GetPropertyUint32(ctx, argv[2], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg2.y = (float)y_double; - JS_FreeCString(ctx, arg1); + JSValue z = JS_GetPropertyUint32(ctx, argv[2], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg2.z = (float)z_double; + } + else { - return JS_NewInt32(ctx, ret); -} + Vector3 * argptr2 = (Vector3 *)JS_GetOpaque2(ctx, argv[2], js_Vector3_class_id); -static JSValue js_GuiButton(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + if (argptr2 == NULL) return JS_EXCEPTION; + + arg2 = *argptr2; + } - Rectangle arg0 = *argptr0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); - - int ret = GuiButton(arg0, arg1); + Matrix returnVal = MatrixLookAt(arg0, arg1, arg2); - JS_FreeCString(ctx, arg1); - return JS_NewInt32(ctx, ret); + + Matrix* ret_ptr = (Matrix *)js_malloc(ctx, sizeof(Matrix)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_GuiLabelButton(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_MatrixToFloatV(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + Matrix * argptr0 = (Matrix *)JS_GetOpaque2(ctx, argv[0], js_Matrix_class_id); if (argptr0 == NULL) return JS_EXCEPTION; - Rectangle arg0 = *argptr0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); + Matrix arg0 = *argptr0; - int ret = GuiLabelButton(arg0, arg1); + float16 returnVal = MatrixToFloatV(arg0); - JS_FreeCString(ctx, arg1); - return JS_NewInt32(ctx, ret); + + float16* ret_ptr = (float16 *)js_malloc(ctx, sizeof(float16)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_float16_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_GuiToggle(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_QuaternionAdd(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + Quaternion * argptr0 = (Quaternion *)JS_GetOpaque2(ctx, argv[0], js_Quaternion_class_id); + if (argptr0 == NULL) + argptr0 = (Quaternion *)JS_GetOpaque2(ctx, argv[0], js_Vector4_class_id); if (argptr0 == NULL) return JS_EXCEPTION; - Rectangle arg0 = *argptr0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); -JSValue arg2_js = JS_GetPropertyStr(ctx, argv[2], "active"); - int arg2_int; - JS_ToInt32(ctx, &arg2_int, arg2_js); - int * arg2 = &arg2_int; + Quaternion arg0 = *argptr0; + Quaternion * argptr1 = (Quaternion *)JS_GetOpaque2(ctx, argv[1], js_Quaternion_class_id); + if (argptr1 == NULL) + argptr1 = (Quaternion *)JS_GetOpaque2(ctx, argv[1], js_Vector4_class_id); + if (argptr1 == NULL) return JS_EXCEPTION; - int ret = GuiToggle(arg0, arg1, arg2); - - JS_FreeCString(ctx, arg1); -JS_SetPropertyStr(ctx, argv[2], "active", JS_NewInt32(ctx, arg2_int)); - - return JS_NewInt32(ctx, ret); -} + Quaternion arg1 = *argptr1; -static JSValue js_GuiToggleGroup(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Rectangle arg0 = *argptr0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); -JSValue arg2_js = JS_GetPropertyStr(ctx, argv[2], "active"); - int arg2_int; - JS_ToInt32(ctx, &arg2_int, arg2_js); - int * arg2 = &arg2_int; - - int ret = GuiToggleGroup(arg0, arg1, arg2); + Quaternion returnVal = QuaternionAdd(arg0, arg1); - JS_FreeCString(ctx, arg1); -JS_SetPropertyStr(ctx, argv[2], "active", JS_NewInt32(ctx, arg2_int)); - return JS_NewInt32(ctx, ret); + + Quaternion* ret_ptr = (Quaternion *)js_malloc(ctx, sizeof(Quaternion)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Quaternion_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_GuiToggleSlider(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_QuaternionAddValue(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + Quaternion * argptr0 = (Quaternion *)JS_GetOpaque2(ctx, argv[0], js_Quaternion_class_id); + if (argptr0 == NULL) + argptr0 = (Quaternion *)JS_GetOpaque2(ctx, argv[0], js_Vector4_class_id); if (argptr0 == NULL) return JS_EXCEPTION; - Rectangle arg0 = *argptr0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); -JSValue arg2_js = JS_GetPropertyStr(ctx, argv[2], "active"); - int arg2_int; - JS_ToInt32(ctx, &arg2_int, arg2_js); - int * arg2 = &arg2_int; - - int ret = GuiToggleSlider(arg0, arg1, arg2); - - JS_FreeCString(ctx, arg1); -JS_SetPropertyStr(ctx, argv[2], "active", JS_NewInt32(ctx, arg2_int)); - - return JS_NewInt32(ctx, ret); -} + Quaternion arg0 = *argptr0; + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); -static JSValue js_GuiCheckBox(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Rectangle arg0 = *argptr0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); -JSValue arg2_js = JS_GetPropertyStr(ctx, argv[2], "checked"); - int arg2_int; - JS_ToInt32(ctx, &arg2_int, arg2_js); - int * arg2 = &arg2_int; - - int ret = GuiCheckBox(arg0, arg1, arg2); + Quaternion returnVal = QuaternionAddValue(arg0, arg1); - JS_FreeCString(ctx, arg1); -JS_SetPropertyStr(ctx, argv[2], "checked", JS_NewInt32(ctx, arg2_int)); - return JS_NewInt32(ctx, ret); + + Quaternion* ret_ptr = (Quaternion *)js_malloc(ctx, sizeof(Quaternion)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Quaternion_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_GuiComboBox(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Rectangle arg0 = *argptr0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); -JSValue arg2_js = JS_GetPropertyStr(ctx, argv[2], "active"); - int arg2_int; - JS_ToInt32(ctx, &arg2_int, arg2_js); - int * arg2 = &arg2_int; +static JSValue js_QuaternionSubtract(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Quaternion * argptr0 = (Quaternion *)JS_GetOpaque2(ctx, argv[0], js_Quaternion_class_id); + if (argptr0 == NULL) + argptr0 = (Quaternion *)JS_GetOpaque2(ctx, argv[0], js_Vector4_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; - int ret = GuiComboBox(arg0, arg1, arg2); + Quaternion arg0 = *argptr0; + Quaternion * argptr1 = (Quaternion *)JS_GetOpaque2(ctx, argv[1], js_Quaternion_class_id); + if (argptr1 == NULL) + argptr1 = (Quaternion *)JS_GetOpaque2(ctx, argv[1], js_Vector4_class_id); + if (argptr1 == NULL) return JS_EXCEPTION; + + Quaternion arg1 = *argptr1; - JS_FreeCString(ctx, arg1); -JS_SetPropertyStr(ctx, argv[2], "active", JS_NewInt32(ctx, arg2_int)); + Quaternion returnVal = QuaternionSubtract(arg0, arg1); - return JS_NewInt32(ctx, ret); + + + Quaternion* ret_ptr = (Quaternion *)js_malloc(ctx, sizeof(Quaternion)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Quaternion_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_GuiDropdownBox(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_QuaternionSubtractValue(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + Quaternion * argptr0 = (Quaternion *)JS_GetOpaque2(ctx, argv[0], js_Quaternion_class_id); + if (argptr0 == NULL) + argptr0 = (Quaternion *)JS_GetOpaque2(ctx, argv[0], js_Vector4_class_id); if (argptr0 == NULL) return JS_EXCEPTION; - Rectangle arg0 = *argptr0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); -JSValue arg2_js = JS_GetPropertyStr(ctx, argv[2], "active"); - int arg2_int; - JS_ToInt32(ctx, &arg2_int, arg2_js); - int * arg2 = &arg2_int; - JS_BOOL argbool3 = JS_ToBool(ctx, argv[3]); - bool arg3 = (bool) argbool3; + Quaternion arg0 = *argptr0; + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); - int ret = GuiDropdownBox(arg0, arg1, arg2, arg3); + Quaternion returnVal = QuaternionSubtractValue(arg0, arg1); - JS_FreeCString(ctx, arg1); -JS_SetPropertyStr(ctx, argv[2], "active", JS_NewInt32(ctx, arg2_int)); - return JS_NewInt32(ctx, ret); + + Quaternion* ret_ptr = (Quaternion *)js_malloc(ctx, sizeof(Quaternion)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Quaternion_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_GuiSpinner(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_QuaternionIdentity(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; - - Rectangle arg0 = *argptr0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); -JSValue arg2_js = JS_GetPropertyStr(ctx, argv[2], "value"); - int arg2_int; - JS_ToInt32(ctx, &arg2_int, arg2_js); - int * arg2 = &arg2_int; - int arg3; - JS_ToInt32(ctx, &arg3, argv[3]); - int arg4; - JS_ToInt32(ctx, &arg4, argv[4]); - JS_BOOL argbool5 = JS_ToBool(ctx, argv[5]); - bool arg5 = (bool) argbool5; - int ret = GuiSpinner(arg0, arg1, arg2, arg3, arg4, arg5); + Quaternion returnVal = QuaternionIdentity(); - JS_FreeCString(ctx, arg1); -JS_SetPropertyStr(ctx, argv[2], "value", JS_NewInt32(ctx, arg2_int)); - return JS_NewInt32(ctx, ret); + + Quaternion* ret_ptr = (Quaternion *)js_malloc(ctx, sizeof(Quaternion)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Quaternion_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_GuiValueBox(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_QuaternionLength(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + Quaternion * argptr0 = (Quaternion *)JS_GetOpaque2(ctx, argv[0], js_Quaternion_class_id); + if (argptr0 == NULL) + argptr0 = (Quaternion *)JS_GetOpaque2(ctx, argv[0], js_Vector4_class_id); if (argptr0 == NULL) return JS_EXCEPTION; - Rectangle arg0 = *argptr0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); -JSValue arg2_js = JS_GetPropertyStr(ctx, argv[2], "value"); - int arg2_int; - JS_ToInt32(ctx, &arg2_int, arg2_js); - int * arg2 = &arg2_int; - int arg3; - JS_ToInt32(ctx, &arg3, argv[3]); - int arg4; - JS_ToInt32(ctx, &arg4, argv[4]); - JS_BOOL argbool5 = JS_ToBool(ctx, argv[5]); - bool arg5 = (bool) argbool5; + Quaternion arg0 = *argptr0; - int ret = GuiValueBox(arg0, arg1, arg2, arg3, arg4, arg5); + float ret = QuaternionLength(arg0); - JS_FreeCString(ctx, arg1); -JS_SetPropertyStr(ctx, argv[2], "value", JS_NewInt32(ctx, arg2_int)); - return JS_NewInt32(ctx, ret); + return JS_NewFloat64(ctx, ret); } -static JSValue js_GuiValueBoxFloat(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_QuaternionNormalize(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + Quaternion * argptr0 = (Quaternion *)JS_GetOpaque2(ctx, argv[0], js_Quaternion_class_id); + if (argptr0 == NULL) + argptr0 = (Quaternion *)JS_GetOpaque2(ctx, argv[0], js_Vector4_class_id); if (argptr0 == NULL) return JS_EXCEPTION; - Rectangle arg0 = *argptr0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); - JSValue arg2_js = JS_GetPropertyStr(ctx, argv[2], "textValue"); - size_t arg2_len; - const char * arg2_str = JS_ToCStringLen(ctx, &arg2_len, arg2_js); - char * arg2 = malloc(arg2_len+1); - memcpy((void *)arg2, arg2_str, arg2_len); - arg2[arg2_len] = 0; - JSValue arg3_js = JS_GetPropertyStr(ctx, argv[3], "value"); - double arg3_double; - JS_ToFloat64(ctx, &arg3_double, arg3_js); - float arg3_float = (float)arg3_double; - float * arg3 = &arg3_float; - JS_BOOL argbool4 = JS_ToBool(ctx, argv[4]); - bool arg4 = (bool) argbool4; + Quaternion arg0 = *argptr0; - int ret = GuiValueBoxFloat(arg0, arg1, arg2, arg3, arg4); + Quaternion returnVal = QuaternionNormalize(arg0); - JS_FreeCString(ctx, arg1); - JS_FreeCString(ctx, arg2_str); - JS_SetPropertyStr(ctx, argv[2], "textValue", JS_NewString(ctx, arg2)); - free(arg2); -JS_SetPropertyStr(ctx, argv[3], "value", JS_NewFloat64(ctx, arg3_float)); - return JS_NewInt32(ctx, ret); + + Quaternion* ret_ptr = (Quaternion *)js_malloc(ctx, sizeof(Quaternion)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Quaternion_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_GuiTextBox(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_QuaternionInvert(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + Quaternion * argptr0 = (Quaternion *)JS_GetOpaque2(ctx, argv[0], js_Quaternion_class_id); + if (argptr0 == NULL) + argptr0 = (Quaternion *)JS_GetOpaque2(ctx, argv[0], js_Vector4_class_id); if (argptr0 == NULL) return JS_EXCEPTION; - Rectangle arg0 = *argptr0; - JSValue arg1_js = JS_GetPropertyStr(ctx, argv[1], "text"); - size_t arg1_len; - const char * arg1_str = JS_ToCStringLen(ctx, &arg1_len, arg1_js); - char * arg1 = malloc(arg1_len+1); - memcpy((void *)arg1, arg1_str, arg1_len); - arg1[arg1_len] = 0; - int arg2; - JS_ToInt32(ctx, &arg2, argv[2]); - JS_BOOL argbool3 = JS_ToBool(ctx, argv[3]); - bool arg3 = (bool) argbool3; + Quaternion arg0 = *argptr0; - int ret = GuiTextBox(arg0, arg1, arg2, arg3); + Quaternion returnVal = QuaternionInvert(arg0); - JS_FreeCString(ctx, arg1_str); - JS_SetPropertyStr(ctx, argv[1], "text", JS_NewString(ctx, arg1)); - free(arg1); - return JS_NewInt32(ctx, ret); + + Quaternion* ret_ptr = (Quaternion *)js_malloc(ctx, sizeof(Quaternion)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Quaternion_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_GuiSlider(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_QuaternionMultiply(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + Quaternion * argptr0 = (Quaternion *)JS_GetOpaque2(ctx, argv[0], js_Quaternion_class_id); + if (argptr0 == NULL) + argptr0 = (Quaternion *)JS_GetOpaque2(ctx, argv[0], js_Vector4_class_id); if (argptr0 == NULL) return JS_EXCEPTION; - Rectangle arg0 = *argptr0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); - const char * arg2 = (const char *)JS_ToCString(ctx, argv[2]); -JSValue arg3_js = JS_GetPropertyStr(ctx, argv[3], "value"); - double arg3_double; - JS_ToFloat64(ctx, &arg3_double, arg3_js); - float arg3_float = (float)arg3_double; - float * arg3 = &arg3_float; - double arg4; - JS_ToFloat64(ctx, &arg4, argv[4]); - double arg5; - JS_ToFloat64(ctx, &arg5, argv[5]); + Quaternion arg0 = *argptr0; + Quaternion * argptr1 = (Quaternion *)JS_GetOpaque2(ctx, argv[1], js_Quaternion_class_id); + if (argptr1 == NULL) + argptr1 = (Quaternion *)JS_GetOpaque2(ctx, argv[1], js_Vector4_class_id); + if (argptr1 == NULL) return JS_EXCEPTION; + + Quaternion arg1 = *argptr1; - int ret = GuiSlider(arg0, arg1, arg2, arg3, arg4, arg5); + Quaternion returnVal = QuaternionMultiply(arg0, arg1); - JS_FreeCString(ctx, arg1); - JS_FreeCString(ctx, arg2); -JS_SetPropertyStr(ctx, argv[3], "value", JS_NewFloat64(ctx, arg3_float)); - return JS_NewInt32(ctx, ret); + + Quaternion* ret_ptr = (Quaternion *)js_malloc(ctx, sizeof(Quaternion)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Quaternion_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_GuiSliderBar(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_QuaternionScale(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + Quaternion * argptr0 = (Quaternion *)JS_GetOpaque2(ctx, argv[0], js_Quaternion_class_id); + if (argptr0 == NULL) + argptr0 = (Quaternion *)JS_GetOpaque2(ctx, argv[0], js_Vector4_class_id); if (argptr0 == NULL) return JS_EXCEPTION; - Rectangle arg0 = *argptr0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); - const char * arg2 = (const char *)JS_ToCString(ctx, argv[2]); -JSValue arg3_js = JS_GetPropertyStr(ctx, argv[3], "value"); - double arg3_double; - JS_ToFloat64(ctx, &arg3_double, arg3_js); - float arg3_float = (float)arg3_double; - float * arg3 = &arg3_float; - double arg4; - JS_ToFloat64(ctx, &arg4, argv[4]); - double arg5; - JS_ToFloat64(ctx, &arg5, argv[5]); + Quaternion arg0 = *argptr0; + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); - int ret = GuiSliderBar(arg0, arg1, arg2, arg3, arg4, arg5); + Quaternion returnVal = QuaternionScale(arg0, arg1); - JS_FreeCString(ctx, arg1); - JS_FreeCString(ctx, arg2); -JS_SetPropertyStr(ctx, argv[3], "value", JS_NewFloat64(ctx, arg3_float)); - return JS_NewInt32(ctx, ret); + + Quaternion* ret_ptr = (Quaternion *)js_malloc(ctx, sizeof(Quaternion)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Quaternion_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_GuiProgressBar(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_QuaternionDivide(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + Quaternion * argptr0 = (Quaternion *)JS_GetOpaque2(ctx, argv[0], js_Quaternion_class_id); + if (argptr0 == NULL) + argptr0 = (Quaternion *)JS_GetOpaque2(ctx, argv[0], js_Vector4_class_id); if (argptr0 == NULL) return JS_EXCEPTION; - Rectangle arg0 = *argptr0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); - const char * arg2 = (const char *)JS_ToCString(ctx, argv[2]); -JSValue arg3_js = JS_GetPropertyStr(ctx, argv[3], "value"); - double arg3_double; - JS_ToFloat64(ctx, &arg3_double, arg3_js); - float arg3_float = (float)arg3_double; - float * arg3 = &arg3_float; - double arg4; - JS_ToFloat64(ctx, &arg4, argv[4]); - double arg5; - JS_ToFloat64(ctx, &arg5, argv[5]); + Quaternion arg0 = *argptr0; + Quaternion * argptr1 = (Quaternion *)JS_GetOpaque2(ctx, argv[1], js_Quaternion_class_id); + if (argptr1 == NULL) + argptr1 = (Quaternion *)JS_GetOpaque2(ctx, argv[1], js_Vector4_class_id); + if (argptr1 == NULL) return JS_EXCEPTION; + + Quaternion arg1 = *argptr1; - int ret = GuiProgressBar(arg0, arg1, arg2, arg3, arg4, arg5); + Quaternion returnVal = QuaternionDivide(arg0, arg1); - JS_FreeCString(ctx, arg1); - JS_FreeCString(ctx, arg2); -JS_SetPropertyStr(ctx, argv[3], "value", JS_NewFloat64(ctx, arg3_float)); - return JS_NewInt32(ctx, ret); + + Quaternion* ret_ptr = (Quaternion *)js_malloc(ctx, sizeof(Quaternion)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Quaternion_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_GuiStatusBar(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_QuaternionLerp(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + Quaternion * argptr0 = (Quaternion *)JS_GetOpaque2(ctx, argv[0], js_Quaternion_class_id); + if (argptr0 == NULL) + argptr0 = (Quaternion *)JS_GetOpaque2(ctx, argv[0], js_Vector4_class_id); if (argptr0 == NULL) return JS_EXCEPTION; - Rectangle arg0 = *argptr0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); + Quaternion arg0 = *argptr0; + Quaternion * argptr1 = (Quaternion *)JS_GetOpaque2(ctx, argv[1], js_Quaternion_class_id); + if (argptr1 == NULL) + argptr1 = (Quaternion *)JS_GetOpaque2(ctx, argv[1], js_Vector4_class_id); + if (argptr1 == NULL) return JS_EXCEPTION; + + Quaternion arg1 = *argptr1; + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); - int ret = GuiStatusBar(arg0, arg1); + Quaternion returnVal = QuaternionLerp(arg0, arg1, arg2); - JS_FreeCString(ctx, arg1); - return JS_NewInt32(ctx, ret); + + Quaternion* ret_ptr = (Quaternion *)js_malloc(ctx, sizeof(Quaternion)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Quaternion_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_GuiDummyRec(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_QuaternionNlerp(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + Quaternion * argptr0 = (Quaternion *)JS_GetOpaque2(ctx, argv[0], js_Quaternion_class_id); + if (argptr0 == NULL) + argptr0 = (Quaternion *)JS_GetOpaque2(ctx, argv[0], js_Vector4_class_id); if (argptr0 == NULL) return JS_EXCEPTION; - Rectangle arg0 = *argptr0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); + Quaternion arg0 = *argptr0; + Quaternion * argptr1 = (Quaternion *)JS_GetOpaque2(ctx, argv[1], js_Quaternion_class_id); + if (argptr1 == NULL) + argptr1 = (Quaternion *)JS_GetOpaque2(ctx, argv[1], js_Vector4_class_id); + if (argptr1 == NULL) return JS_EXCEPTION; + + Quaternion arg1 = *argptr1; + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); - int ret = GuiDummyRec(arg0, arg1); + Quaternion returnVal = QuaternionNlerp(arg0, arg1, arg2); - JS_FreeCString(ctx, arg1); - return JS_NewInt32(ctx, ret); + + Quaternion* ret_ptr = (Quaternion *)js_malloc(ctx, sizeof(Quaternion)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Quaternion_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_GuiGrid(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_QuaternionSlerp(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + Quaternion * argptr0 = (Quaternion *)JS_GetOpaque2(ctx, argv[0], js_Quaternion_class_id); + if (argptr0 == NULL) + argptr0 = (Quaternion *)JS_GetOpaque2(ctx, argv[0], js_Vector4_class_id); if (argptr0 == NULL) return JS_EXCEPTION; - Rectangle arg0 = *argptr0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); + Quaternion arg0 = *argptr0; + Quaternion * argptr1 = (Quaternion *)JS_GetOpaque2(ctx, argv[1], js_Quaternion_class_id); + if (argptr1 == NULL) + argptr1 = (Quaternion *)JS_GetOpaque2(ctx, argv[1], js_Vector4_class_id); + if (argptr1 == NULL) return JS_EXCEPTION; + + Quaternion arg1 = *argptr1; double arg2; JS_ToFloat64(ctx, &arg2, argv[2]); - int arg3; - JS_ToInt32(ctx, &arg3, argv[3]); - Vector2 * arg4 = (Vector2 *)JS_GetOpaque2(ctx, argv[4], js_Vector2_class_id); - int ret = GuiGrid(arg0, arg1, arg2, arg3, arg4); + Quaternion returnVal = QuaternionSlerp(arg0, arg1, arg2); - JS_FreeCString(ctx, arg1); - return JS_NewInt32(ctx, ret); + + Quaternion* ret_ptr = (Quaternion *)js_malloc(ctx, sizeof(Quaternion)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Quaternion_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_GuiListView(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_QuaternionFromVector3ToVector3(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + Vector3 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Rectangle arg0 = *argptr0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); -JSValue arg2_js = JS_GetPropertyStr(ctx, argv[2], "scrollIndex"); - int arg2_int; - JS_ToInt32(ctx, &arg2_int, arg2_js); - int * arg2 = &arg2_int; - JSValue arg3_js = JS_GetPropertyStr(ctx, argv[3], "active"); - int arg3_int; - JS_ToInt32(ctx, &arg3_int, arg3_js); - int * arg3 = &arg3_int; + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { + + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); + + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } - int ret = GuiListView(arg0, arg1, arg2, arg3); - JS_FreeCString(ctx, arg1); -JS_SetPropertyStr(ctx, argv[2], "scrollIndex", JS_NewInt32(ctx, arg2_int)); -JS_SetPropertyStr(ctx, argv[3], "active", JS_NewInt32(ctx, arg3_int)); + Vector3 arg1; - return JS_NewInt32(ctx, ret); -} + if (JS_IsArray(ctx, argv[1])) { -static JSValue js_GuiMessageBox(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -{ - Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + JSValue x = JS_GetPropertyUint32(ctx, argv[1], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg1.x = (float)x_double; - Rectangle arg0 = *argptr0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); - const char * arg2 = (const char *)JS_ToCString(ctx, argv[2]); - const char * arg3 = (const char *)JS_ToCString(ctx, argv[3]); + JSValue y = JS_GetPropertyUint32(ctx, argv[1], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg1.y = (float)y_double; - int ret = GuiMessageBox(arg0, arg1, arg2, arg3); + JSValue z = JS_GetPropertyUint32(ctx, argv[1], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg1.z = (float)z_double; + } + else { - JS_FreeCString(ctx, arg1); - JS_FreeCString(ctx, arg2); - JS_FreeCString(ctx, arg3); + Vector3 * argptr1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); - return JS_NewInt32(ctx, ret); + if (argptr1 == NULL) return JS_EXCEPTION; + + arg1 = *argptr1; + } + + Quaternion returnVal = QuaternionFromVector3ToVector3(arg0, arg1); + + + + Quaternion* ret_ptr = (Quaternion *)js_malloc(ctx, sizeof(Quaternion)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Quaternion_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_GuiTextInputBox(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_QuaternionFromMatrix(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + Matrix * argptr0 = (Matrix *)JS_GetOpaque2(ctx, argv[0], js_Matrix_class_id); if (argptr0 == NULL) return JS_EXCEPTION; - Rectangle arg0 = *argptr0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); - const char * arg2 = (const char *)JS_ToCString(ctx, argv[2]); - const char * arg3 = (const char *)JS_ToCString(ctx, argv[3]); - JSValue arg4_js = JS_GetPropertyStr(ctx, argv[4], "text"); - size_t arg4_len; - const char * arg4_str = JS_ToCStringLen(ctx, &arg4_len, arg4_js); - char * arg4 = malloc(arg4_len+1); - memcpy((void *)arg4, arg4_str, arg4_len); - arg4[arg4_len] = 0; - int arg5; - JS_ToInt32(ctx, &arg5, argv[5]); -JSValue arg6_js = JS_GetPropertyStr(ctx, argv[6], "secretViewActive"); - int arg6_int; - JS_ToInt32(ctx, &arg6_int, arg6_js); - int * arg6 = &arg6_int; - - int ret = GuiTextInputBox(arg0, arg1, arg2, arg3, arg4, arg5, arg6); + Matrix arg0 = *argptr0; - JS_FreeCString(ctx, arg1); - JS_FreeCString(ctx, arg2); - JS_FreeCString(ctx, arg3); - JS_FreeCString(ctx, arg4_str); - JS_SetPropertyStr(ctx, argv[4], "text", JS_NewString(ctx, arg4)); - free(arg4); -JS_SetPropertyStr(ctx, argv[6], "secretViewActive", JS_NewInt32(ctx, arg6_int)); + Quaternion returnVal = QuaternionFromMatrix(arg0); - return JS_NewInt32(ctx, ret); + + + Quaternion* ret_ptr = (Quaternion *)js_malloc(ctx, sizeof(Quaternion)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Quaternion_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_GuiColorPicker(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_QuaternionToMatrix(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + Quaternion * argptr0 = (Quaternion *)JS_GetOpaque2(ctx, argv[0], js_Quaternion_class_id); + if (argptr0 == NULL) + argptr0 = (Quaternion *)JS_GetOpaque2(ctx, argv[0], js_Vector4_class_id); if (argptr0 == NULL) return JS_EXCEPTION; - Rectangle arg0 = *argptr0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); - Color * arg2 = (Color *)JS_GetOpaque2(ctx, argv[2], js_Color_class_id); + Quaternion arg0 = *argptr0; - int ret = GuiColorPicker(arg0, arg1, arg2); + Matrix returnVal = QuaternionToMatrix(arg0); - JS_FreeCString(ctx, arg1); - return JS_NewInt32(ctx, ret); + + Matrix* ret_ptr = (Matrix *)js_malloc(ctx, sizeof(Matrix)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Matrix_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_GuiColorPanel(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_QuaternionFromAxisAngle(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); - if (argptr0 == NULL) return JS_EXCEPTION; + + + Vector3 arg0; + + if (JS_IsArray(ctx, argv[0])) { + + JSValue x = JS_GetPropertyUint32(ctx, argv[0], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg0.x = (float)x_double; - Rectangle arg0 = *argptr0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); - Color * arg2 = (Color *)JS_GetOpaque2(ctx, argv[2], js_Color_class_id); + JSValue y = JS_GetPropertyUint32(ctx, argv[0], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg0.y = (float)y_double; - int ret = GuiColorPanel(arg0, arg1, arg2); + JSValue z = JS_GetPropertyUint32(ctx, argv[0], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg0.z = (float)z_double; + } + else { - JS_FreeCString(ctx, arg1); + Vector3 * argptr0 = (Vector3 *)JS_GetOpaque2(ctx, argv[0], js_Vector3_class_id); - return JS_NewInt32(ctx, ret); + if (argptr0 == NULL) return JS_EXCEPTION; + + arg0 = *argptr0; + } + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + + Quaternion returnVal = QuaternionFromAxisAngle(arg0, arg1); + + + + Quaternion* ret_ptr = (Quaternion *)js_malloc(ctx, sizeof(Quaternion)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Quaternion_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_GuiColorBarAlpha(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_QuaternionToAxisAngle(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + Quaternion * argptr0 = (Quaternion *)JS_GetOpaque2(ctx, argv[0], js_Quaternion_class_id); + if (argptr0 == NULL) + argptr0 = (Quaternion *)JS_GetOpaque2(ctx, argv[0], js_Vector4_class_id); if (argptr0 == NULL) return JS_EXCEPTION; - Rectangle arg0 = *argptr0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); -JSValue arg2_js = JS_GetPropertyStr(ctx, argv[2], "alpha"); + Quaternion arg0 = *argptr0; + Vector3 * arg1 = (Vector3 *)JS_GetOpaque2(ctx, argv[1], js_Vector3_class_id); +JSValue arg2_js = JS_GetPropertyStr(ctx, argv[2], "outAngle"); double arg2_double; JS_ToFloat64(ctx, &arg2_double, arg2_js); float arg2_float = (float)arg2_double; float * arg2 = &arg2_float; - int ret = GuiColorBarAlpha(arg0, arg1, arg2); + QuaternionToAxisAngle(arg0, arg1, arg2); - JS_FreeCString(ctx, arg1); -JS_SetPropertyStr(ctx, argv[2], "alpha", JS_NewFloat64(ctx, arg2_float)); +JS_SetPropertyStr(ctx, argv[2], "outAngle", JS_NewFloat64(ctx, arg2_float)); - return JS_NewInt32(ctx, ret); + return JS_UNDEFINED; } -static JSValue js_GuiColorBarHue(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_QuaternionFromEuler(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + double arg0; + JS_ToFloat64(ctx, &arg0, argv[0]); + double arg1; + JS_ToFloat64(ctx, &arg1, argv[1]); + double arg2; + JS_ToFloat64(ctx, &arg2, argv[2]); + + Quaternion returnVal = QuaternionFromEuler(arg0, arg1, arg2); + + + + Quaternion* ret_ptr = (Quaternion *)js_malloc(ctx, sizeof(Quaternion)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Quaternion_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + +} + +static JSValue js_QuaternionToEuler(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +{ + Quaternion * argptr0 = (Quaternion *)JS_GetOpaque2(ctx, argv[0], js_Quaternion_class_id); + if (argptr0 == NULL) + argptr0 = (Quaternion *)JS_GetOpaque2(ctx, argv[0], js_Vector4_class_id); if (argptr0 == NULL) return JS_EXCEPTION; - Rectangle arg0 = *argptr0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); -JSValue arg2_js = JS_GetPropertyStr(ctx, argv[2], "value"); - double arg2_double; - JS_ToFloat64(ctx, &arg2_double, arg2_js); - float arg2_float = (float)arg2_double; - float * arg2 = &arg2_float; - - int ret = GuiColorBarHue(arg0, arg1, arg2); + Quaternion arg0 = *argptr0; - JS_FreeCString(ctx, arg1); -JS_SetPropertyStr(ctx, argv[2], "value", JS_NewFloat64(ctx, arg2_float)); + Vector3 returnVal = QuaternionToEuler(arg0); - return JS_NewInt32(ctx, ret); + + + Vector3* ret_ptr = (Vector3 *)js_malloc(ctx, sizeof(Vector3)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Vector3_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_GuiColorPickerHSV(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_QuaternionTransform(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + Quaternion * argptr0 = (Quaternion *)JS_GetOpaque2(ctx, argv[0], js_Quaternion_class_id); + if (argptr0 == NULL) + argptr0 = (Quaternion *)JS_GetOpaque2(ctx, argv[0], js_Vector4_class_id); if (argptr0 == NULL) return JS_EXCEPTION; - Rectangle arg0 = *argptr0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); - Vector3 * arg2 = (Vector3 *)JS_GetOpaque2(ctx, argv[2], js_Vector3_class_id); + Quaternion arg0 = *argptr0; + Matrix * argptr1 = (Matrix *)JS_GetOpaque2(ctx, argv[1], js_Matrix_class_id); + if (argptr1 == NULL) return JS_EXCEPTION; + + Matrix arg1 = *argptr1; - int ret = GuiColorPickerHSV(arg0, arg1, arg2); + Quaternion returnVal = QuaternionTransform(arg0, arg1); - JS_FreeCString(ctx, arg1); - return JS_NewInt32(ctx, ret); + + Quaternion* ret_ptr = (Quaternion *)js_malloc(ctx, sizeof(Quaternion)); + *ret_ptr = returnVal; + JSValue ret = JS_NewObjectClass(ctx, js_Quaternion_class_id); + JS_SetOpaque(ret, ret_ptr); + return ret; + } -static JSValue js_GuiColorPanelHSV(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) +static JSValue js_QuaternionEquals(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { - Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + Quaternion * argptr0 = (Quaternion *)JS_GetOpaque2(ctx, argv[0], js_Quaternion_class_id); + if (argptr0 == NULL) + argptr0 = (Quaternion *)JS_GetOpaque2(ctx, argv[0], js_Vector4_class_id); if (argptr0 == NULL) return JS_EXCEPTION; - Rectangle arg0 = *argptr0; - const char * arg1 = (const char *)JS_ToCString(ctx, argv[1]); - Vector3 * arg2 = (Vector3 *)JS_GetOpaque2(ctx, argv[2], js_Vector3_class_id); + Quaternion arg0 = *argptr0; + Quaternion * argptr1 = (Quaternion *)JS_GetOpaque2(ctx, argv[1], js_Quaternion_class_id); + if (argptr1 == NULL) + argptr1 = (Quaternion *)JS_GetOpaque2(ctx, argv[1], js_Vector4_class_id); + if (argptr1 == NULL) return JS_EXCEPTION; + + Quaternion arg1 = *argptr1; - int ret = GuiColorPanelHSV(arg0, arg1, arg2); + int ret = QuaternionEquals(arg0, arg1); - JS_FreeCString(ctx, arg1); return JS_NewInt32(ctx, ret); } @@ -16307,7 +30401,7 @@ static const JSCFunctionListEntry js_raylib_funcs[] = { JS_CFUNC_DEF("SaveFileData", 3, js_SaveFileData ), JS_CFUNC_DEF("ExportDataAsCode", 3, js_ExportDataAsCode ), JS_CFUNC_DEF("LoadFileText", 1, js_LoadFileText ), - JS_CFUNC_DEF("UnloadFileText", 0, js_UnloadFileText ), + JS_CFUNC_DEF("UnloadFileText", 1, js_UnloadFileText ), JS_CFUNC_DEF("SaveFileText", 2, js_SaveFileText ), JS_CFUNC_DEF("FileExists", 1, js_FileExists ), JS_CFUNC_DEF("DirectoryExists", 1, js_DirectoryExists ), @@ -16394,6 +30488,7 @@ static const JSCFunctionListEntry js_raylib_funcs[] = { JS_CFUNC_DEF("DrawLine", 5, js_DrawLine ), JS_CFUNC_DEF("DrawLineV", 3, js_DrawLineV ), JS_CFUNC_DEF("DrawLineEx", 4, js_DrawLineEx ), + JS_CFUNC_DEF("DrawLineStrip", 3, js_DrawLineStrip ), JS_CFUNC_DEF("DrawLineBezier", 4, js_DrawLineBezier ), JS_CFUNC_DEF("DrawCircle", 4, js_DrawCircle ), JS_CFUNC_DEF("DrawCircleSector", 6, js_DrawCircleSector ), @@ -16419,9 +30514,16 @@ static const JSCFunctionListEntry js_raylib_funcs[] = { JS_CFUNC_DEF("DrawRectangleRoundedLines", 5, js_DrawRectangleRoundedLines ), JS_CFUNC_DEF("DrawTriangle", 4, js_DrawTriangle ), JS_CFUNC_DEF("DrawTriangleLines", 4, js_DrawTriangleLines ), + JS_CFUNC_DEF("DrawTriangleFan", 3, js_DrawTriangleFan ), + JS_CFUNC_DEF("DrawTriangleStrip", 3, js_DrawTriangleStrip ), JS_CFUNC_DEF("DrawPoly", 5, js_DrawPoly ), JS_CFUNC_DEF("DrawPolyLines", 5, js_DrawPolyLines ), JS_CFUNC_DEF("DrawPolyLinesEx", 6, js_DrawPolyLinesEx ), + JS_CFUNC_DEF("DrawSplineLinear", 4, js_DrawSplineLinear ), + JS_CFUNC_DEF("DrawSplineBasis", 4, js_DrawSplineBasis ), + JS_CFUNC_DEF("DrawSplineCatmullRom", 4, js_DrawSplineCatmullRom ), + JS_CFUNC_DEF("DrawSplineBezierQuadratic", 4, js_DrawSplineBezierQuadratic ), + JS_CFUNC_DEF("DrawSplineBezierCubic", 4, js_DrawSplineBezierCubic ), JS_CFUNC_DEF("DrawSplineSegmentLinear", 4, js_DrawSplineSegmentLinear ), JS_CFUNC_DEF("DrawSplineSegmentBasis", 6, js_DrawSplineSegmentBasis ), JS_CFUNC_DEF("DrawSplineSegmentCatmullRom", 6, js_DrawSplineSegmentCatmullRom ), @@ -16438,6 +30540,8 @@ static const JSCFunctionListEntry js_raylib_funcs[] = { JS_CFUNC_DEF("CheckCollisionPointRec", 2, js_CheckCollisionPointRec ), JS_CFUNC_DEF("CheckCollisionPointCircle", 3, js_CheckCollisionPointCircle ), JS_CFUNC_DEF("CheckCollisionPointTriangle", 4, js_CheckCollisionPointTriangle ), + JS_CFUNC_DEF("CheckCollisionPointPoly", 3, js_CheckCollisionPointPoly ), + JS_CFUNC_DEF("CheckCollisionLines", 5, js_CheckCollisionLines ), JS_CFUNC_DEF("CheckCollisionPointLine", 4, js_CheckCollisionPointLine ), JS_CFUNC_DEF("GetCollisionRec", 2, js_GetCollisionRec ), JS_CFUNC_DEF("LoadImage", 1, js_LoadImage ), @@ -16473,6 +30577,7 @@ static const JSCFunctionListEntry js_raylib_funcs[] = { JS_CFUNC_DEF("UnloadRenderTexture", 1, js_UnloadRenderTexture ), JS_CFUNC_DEF("UpdateTexture", 2, js_UpdateTexture ), JS_CFUNC_DEF("UpdateTextureRec", 3, js_UpdateTextureRec ), + JS_CFUNC_DEF("GenTextureMipmaps", 1, js_GenTextureMipmaps ), JS_CFUNC_DEF("SetTextureFilter", 2, js_SetTextureFilter ), JS_CFUNC_DEF("SetTextureWrap", 2, js_SetTextureWrap ), JS_CFUNC_DEF("DrawTexture", 4, js_DrawTexture ), @@ -16541,6 +30646,7 @@ static const JSCFunctionListEntry js_raylib_funcs[] = { JS_CFUNC_DEF("DrawPoint3D", 2, js_DrawPoint3D ), JS_CFUNC_DEF("DrawCircle3D", 5, js_DrawCircle3D ), JS_CFUNC_DEF("DrawTriangle3D", 4, js_DrawTriangle3D ), + JS_CFUNC_DEF("DrawTriangleStrip3D", 3, js_DrawTriangleStrip3D ), JS_CFUNC_DEF("DrawCube", 5, js_DrawCube ), JS_CFUNC_DEF("DrawCubeV", 3, js_DrawCubeV ), JS_CFUNC_DEF("DrawCubeWires", 5, js_DrawCubeWires ), @@ -16570,11 +30676,14 @@ static const JSCFunctionListEntry js_raylib_funcs[] = { JS_CFUNC_DEF("DrawBillboard", 5, js_DrawBillboard ), JS_CFUNC_DEF("DrawBillboardRec", 6, js_DrawBillboardRec ), JS_CFUNC_DEF("DrawBillboardPro", 9, js_DrawBillboardPro ), + JS_CFUNC_DEF("UploadMesh", 2, js_UploadMesh ), JS_CFUNC_DEF("UpdateMeshBuffer", 5, js_UpdateMeshBuffer ), JS_CFUNC_DEF("UnloadMesh", 1, js_UnloadMesh ), JS_CFUNC_DEF("DrawMesh", 3, js_DrawMesh ), + JS_CFUNC_DEF("DrawMeshInstanced", 4, js_DrawMeshInstanced ), JS_CFUNC_DEF("ExportMesh", 2, js_ExportMesh ), JS_CFUNC_DEF("GetMeshBoundingBox", 1, js_GetMeshBoundingBox ), + JS_CFUNC_DEF("GenMeshTangents", 1, js_GenMeshTangents ), JS_CFUNC_DEF("GenMeshPoly", 2, js_GenMeshPoly ), JS_CFUNC_DEF("GenMeshPlane", 4, js_GenMeshPlane ), JS_CFUNC_DEF("GenMeshCube", 3, js_GenMeshCube ), @@ -16586,9 +30695,12 @@ static const JSCFunctionListEntry js_raylib_funcs[] = { JS_CFUNC_DEF("GenMeshKnot", 4, js_GenMeshKnot ), JS_CFUNC_DEF("GenMeshHeightmap", 2, js_GenMeshHeightmap ), JS_CFUNC_DEF("GenMeshCubicmap", 2, js_GenMeshCubicmap ), + JS_CFUNC_DEF("LoadMaterials", 2, js_LoadMaterials ), JS_CFUNC_DEF("LoadMaterialDefault", 0, js_LoadMaterialDefault ), JS_CFUNC_DEF("IsMaterialReady", 1, js_IsMaterialReady ), JS_CFUNC_DEF("UnloadMaterial", 1, js_UnloadMaterial ), + JS_CFUNC_DEF("SetMaterialTexture", 3, js_SetMaterialTexture ), + JS_CFUNC_DEF("SetModelMeshMaterial", 3, js_SetModelMeshMaterial ), JS_CFUNC_DEF("UpdateModelAnimation", 3, js_UpdateModelAnimation ), JS_CFUNC_DEF("UnloadModelAnimation", 1, js_UnloadModelAnimation ), JS_CFUNC_DEF("IsModelAnimationValid", 2, js_IsModelAnimationValid ), @@ -16627,6 +30739,8 @@ static const JSCFunctionListEntry js_raylib_funcs[] = { JS_CFUNC_DEF("SetSoundPitch", 2, js_SetSoundPitch ), JS_CFUNC_DEF("SetSoundPan", 2, js_SetSoundPan ), JS_CFUNC_DEF("WaveCopy", 1, js_WaveCopy ), + JS_CFUNC_DEF("WaveCrop", 3, js_WaveCrop ), + JS_CFUNC_DEF("WaveFormat", 4, js_WaveFormat ), JS_CFUNC_DEF("LoadWaveSamples", 1, js_LoadWaveSamples ), JS_CFUNC_DEF("LoadMusicStream", 1, js_LoadMusicStream ), JS_CFUNC_DEF("LoadMusicStreamFromMemory", 3, js_LoadMusicStreamFromMemory ), @@ -16717,6 +30831,7 @@ static const JSCFunctionListEntry js_raylib_funcs[] = { JS_CFUNC_DEF("GuiDummyRec", 2, js_GuiDummyRec ), JS_CFUNC_DEF("GuiGrid", 5, js_GuiGrid ), JS_CFUNC_DEF("GuiListView", 4, js_GuiListView ), + JS_CFUNC_DEF("GuiListViewEx", 6, js_GuiListViewEx ), JS_CFUNC_DEF("GuiMessageBox", 4, js_GuiMessageBox ), JS_CFUNC_DEF("GuiTextInputBox", 7, js_GuiTextInputBox ), JS_CFUNC_DEF("GuiColorPicker", 3, js_GuiColorPicker ), @@ -16725,6 +30840,120 @@ static const JSCFunctionListEntry js_raylib_funcs[] = { JS_CFUNC_DEF("GuiColorBarHue", 3, js_GuiColorBarHue ), JS_CFUNC_DEF("GuiColorPickerHSV", 3, js_GuiColorPickerHSV ), JS_CFUNC_DEF("GuiColorPanelHSV", 3, js_GuiColorPanelHSV ), + JS_CFUNC_DEF("Clamp", 3, js_Clamp ), + JS_CFUNC_DEF("Lerp", 3, js_Lerp ), + JS_CFUNC_DEF("Normalize", 3, js_Normalize ), + JS_CFUNC_DEF("Remap", 5, js_Remap ), + JS_CFUNC_DEF("Wrap", 3, js_Wrap ), + JS_CFUNC_DEF("FloatEquals", 2, js_FloatEquals ), + JS_CFUNC_DEF("Vector2Zero", 0, js_Vector2Zero ), + JS_CFUNC_DEF("Vector2One", 0, js_Vector2One ), + JS_CFUNC_DEF("Vector2Add", 2, js_Vector2Add ), + JS_CFUNC_DEF("Vector2AddValue", 2, js_Vector2AddValue ), + JS_CFUNC_DEF("Vector2Subtract", 2, js_Vector2Subtract ), + JS_CFUNC_DEF("Vector2SubtractValue", 2, js_Vector2SubtractValue ), + JS_CFUNC_DEF("Vector2Length", 1, js_Vector2Length ), + JS_CFUNC_DEF("Vector2LengthSqr", 1, js_Vector2LengthSqr ), + JS_CFUNC_DEF("Vector2DotProduct", 2, js_Vector2DotProduct ), + JS_CFUNC_DEF("Vector2Distance", 2, js_Vector2Distance ), + JS_CFUNC_DEF("Vector2DistanceSqr", 2, js_Vector2DistanceSqr ), + JS_CFUNC_DEF("Vector2Angle", 2, js_Vector2Angle ), + JS_CFUNC_DEF("Vector2LineAngle", 2, js_Vector2LineAngle ), + JS_CFUNC_DEF("Vector2Scale", 2, js_Vector2Scale ), + JS_CFUNC_DEF("Vector2Multiply", 2, js_Vector2Multiply ), + JS_CFUNC_DEF("Vector2Negate", 1, js_Vector2Negate ), + JS_CFUNC_DEF("Vector2Divide", 2, js_Vector2Divide ), + JS_CFUNC_DEF("Vector2Normalize", 1, js_Vector2Normalize ), + JS_CFUNC_DEF("Vector2Transform", 2, js_Vector2Transform ), + JS_CFUNC_DEF("Vector2Lerp", 3, js_Vector2Lerp ), + JS_CFUNC_DEF("Vector2Reflect", 2, js_Vector2Reflect ), + JS_CFUNC_DEF("Vector2Rotate", 2, js_Vector2Rotate ), + JS_CFUNC_DEF("Vector2MoveTowards", 3, js_Vector2MoveTowards ), + JS_CFUNC_DEF("Vector2Invert", 1, js_Vector2Invert ), + JS_CFUNC_DEF("Vector2Clamp", 3, js_Vector2Clamp ), + JS_CFUNC_DEF("Vector2ClampValue", 3, js_Vector2ClampValue ), + JS_CFUNC_DEF("Vector2Equals", 2, js_Vector2Equals ), + JS_CFUNC_DEF("Vector3Zero", 0, js_Vector3Zero ), + JS_CFUNC_DEF("Vector3One", 0, js_Vector3One ), + JS_CFUNC_DEF("Vector3Add", 2, js_Vector3Add ), + JS_CFUNC_DEF("Vector3AddValue", 2, js_Vector3AddValue ), + JS_CFUNC_DEF("Vector3Subtract", 2, js_Vector3Subtract ), + JS_CFUNC_DEF("Vector3SubtractValue", 2, js_Vector3SubtractValue ), + JS_CFUNC_DEF("Vector3Scale", 2, js_Vector3Scale ), + JS_CFUNC_DEF("Vector3Multiply", 2, js_Vector3Multiply ), + JS_CFUNC_DEF("Vector3CrossProduct", 2, js_Vector3CrossProduct ), + JS_CFUNC_DEF("Vector3Perpendicular", 1, js_Vector3Perpendicular ), + JS_CFUNC_DEF("Vector3Length", 1, js_Vector3Length ), + JS_CFUNC_DEF("Vector3LengthSqr", 1, js_Vector3LengthSqr ), + JS_CFUNC_DEF("Vector3DotProduct", 2, js_Vector3DotProduct ), + JS_CFUNC_DEF("Vector3Distance", 2, js_Vector3Distance ), + JS_CFUNC_DEF("Vector3DistanceSqr", 2, js_Vector3DistanceSqr ), + JS_CFUNC_DEF("Vector3Angle", 2, js_Vector3Angle ), + JS_CFUNC_DEF("Vector3Negate", 1, js_Vector3Negate ), + JS_CFUNC_DEF("Vector3Divide", 2, js_Vector3Divide ), + JS_CFUNC_DEF("Vector3Normalize", 1, js_Vector3Normalize ), + JS_CFUNC_DEF("Vector3Project", 2, js_Vector3Project ), + JS_CFUNC_DEF("Vector3Reject", 2, js_Vector3Reject ), + JS_CFUNC_DEF("Vector3OrthoNormalize", 2, js_Vector3OrthoNormalize ), + JS_CFUNC_DEF("Vector3Transform", 2, js_Vector3Transform ), + JS_CFUNC_DEF("Vector3RotateByQuaternion", 2, js_Vector3RotateByQuaternion ), + JS_CFUNC_DEF("Vector3RotateByAxisAngle", 3, js_Vector3RotateByAxisAngle ), + JS_CFUNC_DEF("Vector3Lerp", 3, js_Vector3Lerp ), + JS_CFUNC_DEF("Vector3Reflect", 2, js_Vector3Reflect ), + JS_CFUNC_DEF("Vector3Min", 2, js_Vector3Min ), + JS_CFUNC_DEF("Vector3Max", 2, js_Vector3Max ), + JS_CFUNC_DEF("Vector3Barycenter", 4, js_Vector3Barycenter ), + JS_CFUNC_DEF("Vector3Unproject", 3, js_Vector3Unproject ), + JS_CFUNC_DEF("Vector3ToFloatV", 1, js_Vector3ToFloatV ), + JS_CFUNC_DEF("Vector3Invert", 1, js_Vector3Invert ), + JS_CFUNC_DEF("Vector3Clamp", 3, js_Vector3Clamp ), + JS_CFUNC_DEF("Vector3ClampValue", 3, js_Vector3ClampValue ), + JS_CFUNC_DEF("Vector3Equals", 2, js_Vector3Equals ), + JS_CFUNC_DEF("Vector3Refract", 3, js_Vector3Refract ), + JS_CFUNC_DEF("MatrixDeterminant", 1, js_MatrixDeterminant ), + JS_CFUNC_DEF("MatrixTrace", 1, js_MatrixTrace ), + JS_CFUNC_DEF("MatrixTranspose", 1, js_MatrixTranspose ), + JS_CFUNC_DEF("MatrixInvert", 1, js_MatrixInvert ), + JS_CFUNC_DEF("MatrixIdentity", 0, js_MatrixIdentity ), + JS_CFUNC_DEF("MatrixAdd", 2, js_MatrixAdd ), + JS_CFUNC_DEF("MatrixSubtract", 2, js_MatrixSubtract ), + JS_CFUNC_DEF("MatrixMultiply", 2, js_MatrixMultiply ), + JS_CFUNC_DEF("MatrixTranslate", 3, js_MatrixTranslate ), + JS_CFUNC_DEF("MatrixRotate", 2, js_MatrixRotate ), + JS_CFUNC_DEF("MatrixRotateX", 1, js_MatrixRotateX ), + JS_CFUNC_DEF("MatrixRotateY", 1, js_MatrixRotateY ), + JS_CFUNC_DEF("MatrixRotateZ", 1, js_MatrixRotateZ ), + JS_CFUNC_DEF("MatrixRotateXYZ", 1, js_MatrixRotateXYZ ), + JS_CFUNC_DEF("MatrixRotateZYX", 1, js_MatrixRotateZYX ), + JS_CFUNC_DEF("MatrixScale", 3, js_MatrixScale ), + JS_CFUNC_DEF("MatrixFrustum", 6, js_MatrixFrustum ), + JS_CFUNC_DEF("MatrixPerspective", 4, js_MatrixPerspective ), + JS_CFUNC_DEF("MatrixOrtho", 6, js_MatrixOrtho ), + JS_CFUNC_DEF("MatrixLookAt", 3, js_MatrixLookAt ), + JS_CFUNC_DEF("MatrixToFloatV", 1, js_MatrixToFloatV ), + JS_CFUNC_DEF("QuaternionAdd", 2, js_QuaternionAdd ), + JS_CFUNC_DEF("QuaternionAddValue", 2, js_QuaternionAddValue ), + JS_CFUNC_DEF("QuaternionSubtract", 2, js_QuaternionSubtract ), + JS_CFUNC_DEF("QuaternionSubtractValue", 2, js_QuaternionSubtractValue ), + JS_CFUNC_DEF("QuaternionIdentity", 0, js_QuaternionIdentity ), + JS_CFUNC_DEF("QuaternionLength", 1, js_QuaternionLength ), + JS_CFUNC_DEF("QuaternionNormalize", 1, js_QuaternionNormalize ), + JS_CFUNC_DEF("QuaternionInvert", 1, js_QuaternionInvert ), + JS_CFUNC_DEF("QuaternionMultiply", 2, js_QuaternionMultiply ), + JS_CFUNC_DEF("QuaternionScale", 2, js_QuaternionScale ), + JS_CFUNC_DEF("QuaternionDivide", 2, js_QuaternionDivide ), + JS_CFUNC_DEF("QuaternionLerp", 3, js_QuaternionLerp ), + JS_CFUNC_DEF("QuaternionNlerp", 3, js_QuaternionNlerp ), + JS_CFUNC_DEF("QuaternionSlerp", 3, js_QuaternionSlerp ), + JS_CFUNC_DEF("QuaternionFromVector3ToVector3", 2, js_QuaternionFromVector3ToVector3 ), + JS_CFUNC_DEF("QuaternionFromMatrix", 1, js_QuaternionFromMatrix ), + JS_CFUNC_DEF("QuaternionToMatrix", 1, js_QuaternionToMatrix ), + JS_CFUNC_DEF("QuaternionFromAxisAngle", 2, js_QuaternionFromAxisAngle ), + JS_CFUNC_DEF("QuaternionToAxisAngle", 3, js_QuaternionToAxisAngle ), + JS_CFUNC_DEF("QuaternionFromEuler", 3, js_QuaternionFromEuler ), + JS_CFUNC_DEF("QuaternionToEuler", 1, js_QuaternionToEuler ), + JS_CFUNC_DEF("QuaternionTransform", 2, js_QuaternionTransform ), + JS_CFUNC_DEF("QuaternionEquals", 2, js_QuaternionEquals ), }; static int js_raylib_init(JSContext *ctx, JSModuleDef *m) { @@ -16770,6 +30999,8 @@ static int js_raylib_init(JSContext *ctx, JSModuleDef *m) js_declare_AutomationEvent(ctx, m); js_declare_AutomationEventList(ctx, m); js_declare_GuiStyleProp(ctx, m); + js_declare_float3(ctx, m); + js_declare_float16(ctx, m); JS_SetModuleExport(ctx, m, "FLAG_VSYNC_HINT", JS_NewInt32(ctx, FLAG_VSYNC_HINT)); JS_SetModuleExport(ctx, m, "FLAG_FULLSCREEN_MODE", JS_NewInt32(ctx, FLAG_FULLSCREEN_MODE)); @@ -17777,6 +32008,8 @@ JSModuleDef *js_init_module(JSContext *ctx, const char *module_name) JS_AddModuleExport(ctx, m, "HUEBAR_PADDING"); JS_AddModuleExport(ctx, m, "HUEBAR_SELECTOR_HEIGHT"); JS_AddModuleExport(ctx, m, "HUEBAR_SELECTOR_OVERFLOW"); + JS_AddModuleExport(ctx, m, "float3"); + JS_AddModuleExport(ctx, m, "float16"); return m; diff --git a/src/raylib_qjs.py b/src/raylib_qjs.py index c92d118..3ff3b41 100644 --- a/src/raylib_qjs.py +++ b/src/raylib_qjs.py @@ -2,10 +2,7 @@ import sys import re -#funcAuthorized = ['InitWindow', 'CloseWindow', 'WindowShouldClose', 'SetTargetFPS', 'BeginDrawing', 'EndDrawing', 'IsWindowReady', 'IsWindowFullscreen', 'IsWindowHidden', 'IsWindowMinimized', 'IsWindowMaximized', 'IsWindowFocused', 'IsWindowResized', 'IsWindowState', 'SetWindowState', 'ClearWindowState', 'ToggleFullscreen', 'ToggleBorderlessWindowed', 'MaximizeWindow', 'MinimizeWindow', 'RestoreWindow', 'LoadImage', 'SetWindowIcon', 'SetWindowTitle', 'SetWindowPosition', 'SetWindowMonitor', 'SetWindowMinSize', 'SetWindowMaxSize', 'SetWindowSize', 'SetWindowOpacity', 'SetWindowOpacity', 'SetWindowFocused', 'GetWindowHandle', 'GetScreenWidth', 'GetScreenHeight', 'GetRenderWidth', 'GetRenderHeight', 'GetMonitorCount', 'GetCurrentMonitor', 'GetMonitorPosition', 'GetMonitorWidth', 'GetMonitorHeight', 'GetMonitorPhysicalWidth', 'GetMonitorPhysicalHeight', 'GetMonitorRefreshRate', 'GetWindowPosition', 'GetWindowScaleDPI', 'GetMonitorName' ] -#structAuthorized = ['Vector2', 'Image'] - -funcNotExported = ['UnloadFileData', 'UnloadFileData', 'SetWindowIcons', 'TraceLog', 'SetTraceLogCallback', 'SetLoadFileDataCallback', 'SetSaveFileDataCallback', 'SetLoadFileTextCallback', 'SetSaveFileTextCallback', 'DrawLineStrip', 'DrawTriangleFan', 'DrawTriangleStrip', 'DrawSplineLinear', 'DrawSplineBasis', 'DrawSplineCatmullRom', 'DrawSplineBezierQuadratic', 'DrawSplineBezierCubic', 'LoadImageColors', 'LoadImagePalette', 'UnloadImageColors', 'UnloadImagePalette', 'LoadFontData', 'GenImageFontAtlas', 'UnloadFontData', 'TextFormat', 'GenTextureMipmaps', 'TextJoin', 'TextSplit', 'DrawTriangleStrip3D', 'UploadMesh', 'GenMeshTangents', 'LoadMaterials', 'SetMaterialTexture', 'DrawMeshInstanced', 'CheckCollisionPointPoly', 'CheckCollisionLines', 'SetModelMeshMaterial', 'LoadModelAnimations', 'UnloadModelAnimations', 'WaveCrop', 'WaveFormat', 'SetAudioStreamCallback', 'AttachAudioStreamProcessor', 'DetachAudioStreamProcessor', 'AttachAudioMixedProcessor', 'DetachAudioMixedProcessor', 'UnloadWaveSamples' ] +funcNotExported = ['UnloadFileData', 'UnloadFileData', 'UnloadImageColors', 'UnloadImagePalette', 'SetWindowIcons', 'TraceLog', 'SetTraceLogCallback', 'SetLoadFileDataCallback', 'SetSaveFileDataCallback', 'SetLoadFileTextCallback', 'SetSaveFileTextCallback', 'LoadImageColors', 'LoadImagePalette', 'LoadFontData', 'GenImageFontAtlas', 'UnloadFontData', 'TextFormat', 'TextJoin', 'TextSplit', 'LoadModelAnimations', 'UnloadModelAnimations', 'SetAudioStreamCallback', 'AttachAudioStreamProcessor', 'DetachAudioStreamProcessor', 'AttachAudioMixedProcessor', 'DetachAudioMixedProcessor', 'UnloadWaveSamples' ] RayType = { 'double': { 'q': 'Float64', 'r': 'double'}, @@ -101,16 +98,96 @@ return JS_NewInt32(ctx, ret);''', 'nb_args': 4 }, - 'UnloadFileData': { + 'GuiListViewEx': { - 'call': '''return JS_UNDEFINED;''', - 'nb_args': 0 - }, - 'UnloadFileText': { + 'call': ''' + + Rectangle * argptr0 = (Rectangle *)JS_GetOpaque2(ctx, argv[0], js_Rectangle_class_id); + if (argptr0 == NULL) return JS_EXCEPTION; + + Rectangle arg0 = *argptr0; + + JSValue length_js = JS_GetProperty(ctx, argv[1], JS_ATOM_length); + + int32_t length; + + JS_ToInt32(ctx, &length, length_js); + + char ** text = (char **)malloc((length+1)*sizeof(char *)); + + text[length] = 0; + + for (int i=0; i < length; ++i) {{ + + JSValue val = JS_GetPropertyUint32(ctx, argv[1], i); + + text[i] = JS_ToCString(ctx, val); + }} + + int arg2; + JS_ToInt32(ctx, &arg2, argv[2]); - 'call': '''return JS_UNDEFINED;''', - 'nb_args': 0 + JSValue arg3_js = JS_GetPropertyStr(ctx, argv[3], "scrollIndex"); + int arg3; + JS_ToInt32(ctx, &arg3, arg3_js); + + JSValue arg4_js = JS_GetPropertyStr(ctx, argv[4], "active"); + int arg4; + JS_ToInt32(ctx, &arg4, arg4_js); + + JSValue arg5_js = JS_GetPropertyStr(ctx, argv[5], "focus"); + int arg5; + JS_ToInt32(ctx, &arg5, arg5_js); + + int ret = GuiListViewEx(arg0, text, arg2, &arg3, &arg4, &arg5); + + JS_SetPropertyStr(ctx, argv[3], "scrollIndex", JS_NewInt32(ctx, arg3)); + JS_SetPropertyStr(ctx, argv[4], "active", JS_NewInt32(ctx, arg4)); + JS_SetPropertyStr(ctx, argv[5], "focus", JS_NewInt32(ctx, arg5)); + + for (int i=0; i < length; ++i) {{ + + JS_FreeCString(ctx, text[i]); + }} + + if (text) + free(text); + + return JS_NewInt32(ctx, ret);''', + 'nb_args': 6 }, + 'LoadMaterials': { + + 'call': ''' + + const char * arg0 = (const char *)JS_ToCString(ctx, argv[0]); + + JSValue arg1_js = JS_GetPropertyStr(ctx, argv[1], "materialCount"); + int arg1; + JS_ToInt32(ctx, &arg1, arg1_js); + + Material * materials = LoadMaterials(arg0, &arg1); + + // TODO: how to do the unloading ? + + JS_FreeCString(ctx, arg0); + + JSValue ret = JS_NewArray(ctx); + + for(int i = 0; i < arg1; i++) { + + JSValue obj = JS_NewObjectClass(ctx, js_Material_class_id); + + JS_SetOpaque(obj, &materials[i]); + + JS_SetPropertyUint32(ctx, ret, i, obj); + } + + return ret; + + ''', + 'nb_args': 2 + } } funcList = '' @@ -121,6 +198,7 @@ customTypes = [] customTypesPtr = {} +customTypesArr = {} callbacks = {} aliases = {} @@ -340,6 +418,7 @@ class = JS_NewCFunction2(ctx, js_{0}_ctor, "{0}", {5}, JS_CFUNC_constructor, 0); customTypes.append(struct['name']) customTypesPtr[struct['name'] + " *"] = struct['name'] customTypesPtr[struct['name'] + "*"] = struct['name'] + customTypesArr[struct['name'] + "[]"] = struct['name'] #customTypes.append(struct['name']+' *') #customTypes.append(struct['name']+' **') #customTypes.append('const '+struct['name']+' *') @@ -447,6 +526,186 @@ def parseFunc(func): freeCalls += 'JS_SetPropertyStr(ctx, argv[{0}], "{1}", JS_NewInt32(ctx, arg{0}_int));\n'.format(i, p['name']) elif p['type'] == '...': pass + + elif p['type'] == 'Rectangle': + + # Rectangle can also be an array + arguments += ''' + + {0} arg{1}; + + if (JS_IsArray(ctx, argv[{1}])) {{ + + JSValue x = JS_GetPropertyUint32(ctx, argv[{1}], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg{1}.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[{1}], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg{1}.y = (float)y_double; + + JSValue w = JS_GetPropertyUint32(ctx, argv[{1}], 2); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg{1}.width = (float)w_double; + + JSValue h = JS_GetPropertyUint32(ctx, argv[{1}], 3); + double h_double; + JS_ToFloat64(ctx, &h_double, h); + arg{1}.height = (float)h_double; + }} + else {{ + + {0} * argptr{1} = ({0} *)JS_GetOpaque2(ctx, argv[{1}], js_{0}_class_id); + + if (argptr{1} == NULL) return JS_EXCEPTION; + + arg{1} = *argptr{1}; + }} + '''.format(p['type'], i) + + elif p['type'] == 'Vector2': + + # Vector2 can also be an array + arguments += ''' + + {0} arg{1}; + + if (JS_IsArray(ctx, argv[{1}])) {{ + + JSValue x = JS_GetPropertyUint32(ctx, argv[{1}], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg{1}.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[{1}], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg{1}.y = (float)y_double; + }} + else {{ + + {0} * argptr{1} = ({0} *)JS_GetOpaque2(ctx, argv[{1}], js_{0}_class_id); + + if (argptr{1} == NULL) return JS_EXCEPTION; + + arg{1} = *argptr{1}; + }} + '''.format(p['type'], i) + + elif p['type'] == 'Vector3': + + # Vector3 can also be an array + arguments += ''' + + {0} arg{1}; + + if (JS_IsArray(ctx, argv[{1}])) {{ + + JSValue x = JS_GetPropertyUint32(ctx, argv[{1}], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg{1}.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[{1}], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg{1}.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[{1}], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg{1}.z = (float)z_double; + }} + else {{ + + {0} * argptr{1} = ({0} *)JS_GetOpaque2(ctx, argv[{1}], js_{0}_class_id); + + if (argptr{1} == NULL) return JS_EXCEPTION; + + arg{1} = *argptr{1}; + }} + '''.format(p['type'], i) + + elif p['type'] == 'Vector4': + + # Vector4 can also be an array + arguments += ''' + + {0} arg{1}; + + if (JS_IsArray(ctx, argv[{1}])) {{ + + JSValue x = JS_GetPropertyUint32(ctx, argv[{1}], 0); + double x_double; + JS_ToFloat64(ctx, &x_double, x); + arg{1}.x = (float)x_double; + + JSValue y = JS_GetPropertyUint32(ctx, argv[{1}], 1); + double y_double; + JS_ToFloat64(ctx, &y_double, y); + arg{1}.y = (float)y_double; + + JSValue z = JS_GetPropertyUint32(ctx, argv[{1}], 2); + double z_double; + JS_ToFloat64(ctx, &z_double, z); + arg{1}.z = (float)z_double; + + JSValue w = JS_GetPropertyUint32(ctx, argv[{1}], 3); + double w_double; + JS_ToFloat64(ctx, &w_double, w); + arg{1}.w = (float)w_double; + }} + else {{ + + {0} * argptr{1} = ({0} *)JS_GetOpaque2(ctx, argv[{1}], js_{0}_class_id); + + if (argptr{1} == NULL) return JS_EXCEPTION; + + arg{1} = *argptr{1}; + }} + '''.format(p['type'], i) + + elif p['type'] == 'Color': + + # Color can also be an array + arguments += ''' + + {0} arg{1}; + + if (JS_IsArray(ctx, argv[{1}])) {{ + + JSValue r = JS_GetPropertyUint32(ctx, argv[{1}], 0); + uint32_t r_int; + JS_ToUint32(ctx, &r_int, r); + arg{1}.r = (unsigned char)r_int; + + JSValue g = JS_GetPropertyUint32(ctx, argv[{1}], 1); + uint32_t g_int; + JS_ToUint32(ctx, &g_int, g); + arg{1}.g = (unsigned char)g_int; + + JSValue b = JS_GetPropertyUint32(ctx, argv[{1}], 2); + uint32_t b_int; + JS_ToUint32(ctx, &b_int, b); + arg{1}.b = (unsigned char)b_int; + + JSValue a = JS_GetPropertyUint32(ctx, argv[{1}], 3); + uint32_t a_int; + JS_ToUint32(ctx, &a_int, a); + arg{1}.a = (unsigned char)a_int; + }} + else {{ + + {0} * argptr{1} = ({0} *)JS_GetOpaque2(ctx, argv[{1}], js_{0}_class_id); + + if (argptr{1} == NULL) return JS_EXCEPTION; + + arg{1} = *argptr{1}; + }} + '''.format(p['type'], i) elif p['type'] in customTypes: arguments += ''' {0} * argptr{1} = ({0} *)JS_GetOpaque2(ctx, argv[{1}], js_{0}_class_id); '''.format(p['type'], i) @@ -469,6 +728,33 @@ def parseFunc(func): arg{1} = ({0} *)JS_GetOpaque2(ctx, argv[{1}], js_{2}_class_id); '''.format(customTypesPtr[p['type']], i, aliases[customTypesPtr[p['type']]]) + elif p['type'] in customTypesArr: + arguments += ''' + + JSValue arg{1}_length_js = JS_GetProperty(ctx, argv[{1}], JS_ATOM_length); + + int32_t arg{1}_length; + + JS_ToInt32(ctx, &arg{1}_length, arg{1}_length_js); + + {0} * arg{1} = ({0} *)malloc(arg{1}_length*sizeof({0})); + + for (int i=0; i < arg{1}_length; ++i) {{ + + JSValue val = JS_GetPropertyUint32(ctx, argv[{1}], i); + + {0} * obj = ({0} *)JS_GetOpaque2(ctx, argv[{1}], js_{0}_class_id); + + arg{1}[i] = *obj; + }} + + '''.format(customTypesArr[p['type']], i) + + freeCalls += ''' + if (arg{0}) + free(arg{0}); + '''.format(i) + elif p['type'] in callbacks: pass else: @@ -691,6 +977,8 @@ def parseFile(file_name): JS_ATOM_END, }; +#include "raymath.h" + #include #define countof(x) (sizeof(x) / sizeof((x)[0]))