@defold-typescript/types 0.26.0 → 0.28.0

package/generated/versions/defold-1.12.4/gui.d.ts

@@ -1726,49 +1726,49 @@ declare global {
      * - `index` number index into array property (1 based)
      * - `key` hash name of internal property
      * @example
-     * ```lua
-     * Updates the position property on an existing node:
-     * local node = gui.get_node("my_box_node")
-     * local node_position = gui.get(node, "position")
-     * gui.set(node, "position.x", node_position.x + 128)
-     *
-     * Updates the rotation property on an existing node:
-     * local node = gui.get_node("my_box_node")
-     * gui.set(node, "rotation", vmath.quat_rotation_z(math.rad(45)))
-     * -- this is equivalent to:
-     * gui.set(node, "euler.z", 45)
-     * -- or using the entire vector:
-     * gui.set(node, "euler", vmath.vector3(0,0,45))
-     * -- or using the set_rotation
-     * gui.set_rotation(node, vmath.vector3(0,0,45))
-     *
-     * Sets various material constants for a node:
-     * local node = gui.get_node("my_box_node")
-     * gui.set(node, "tint", vmath.vector4(1,0,0,1))
-     * -- matrix4 is also supported
-     * gui.set(node, "light_matrix", vmath.matrix4())
-     * -- update a constant in an array at position 4. the array is specified in the shader as:
-     * -- uniform vec4 tint_array[4]; // lua is 1 based, shader is 0 based
-     * gui.set(node, "tint_array", vmath.vector4(1,0,0,1), { index = 4 })
-     * -- update a matrix constant in an array at position 4. the array is specified in the shader as:
-     * -- uniform mat4 light_matrix_array[4];
-     * gui.set(node, "light_matrix_array", vmath.matrix4(), { index = 4 })
-     * -- update a sub-element in a constant
-     * gui.set(node, "tint.x", 1)
-     * -- update a sub-element in an array constant at position 4
-     * gui.set(node, "tint_array.x", 1, {index = 4})
-     *
-     * Set a named property
-     * function on_message(self, message_id, message, sender)
-     *    if message_id == hash("set_font") then
-     *        gui.set(msg.url(), "fonts", message.font, {key = "my_font_name"})
-     *        gui.set_font(gui.get_node("text"), "my_font_name")
-     *    elseif message_id == hash("set_texture") then
-     *        gui.set(msg.url(), "textures", message.texture, {key = "my_texture"})
-     *        gui.set_texture(gui.get_node("box"), "my_texture")
-     *        gui.play_flipbook(gui.get_node("box"), "logo_256")
-     *    end
-     * end
+     * ```ts
+     * // Updates the position property on an existing node:
+     * const node = gui.get_node("my_box_node");
+     * const node_position = gui.get(node, "position");
+     * gui.set(node, "position.x", node_position.x + 128);
+     *
+     * // Updates the rotation property on an existing node:
+     * gui.set(node, "rotation", vmath.quat_rotation_z(math.rad(45)));
+     * // this is equivalent to:
+     * gui.set(node, "euler.z", 45);
+     * // or using the entire vector:
+     * gui.set(node, "euler", vmath.vector3(0, 0, 45));
+     * // or using the set_rotation
+     * gui.set_rotation(node, vmath.vector3(0, 0, 45));
+     *
+     * // Sets various material constants for a node:
+     * gui.set(node, "tint", vmath.vector4(1, 0, 0, 1));
+     * // matrix4 is also supported
+     * gui.set(node, "light_matrix", vmath.matrix4());
+     * // update a constant in an array at position 4. the array is specified in the shader as:
+     * // uniform vec4 tint_array[4]; // lua is 1 based, shader is 0 based
+     * gui.set(node, "tint_array", vmath.vector4(1, 0, 0, 1), { index: 4 });
+     * // update a matrix constant in an array at position 4. the array is specified in the shader as:
+     * // uniform mat4 light_matrix_array[4];
+     * gui.set(node, "light_matrix_array", vmath.matrix4(), { index: 4 });
+     * // update a sub-element in a constant
+     * gui.set(node, "tint.x", 1);
+     * // update a sub-element in an array constant at position 4
+     * gui.set(node, "tint_array.x", 1, { index: 4 });
+     *
+     * // Set a named property
+     * export default defineScript({
+     *   on_message(self, message_id, message) {
+     *     if (message_id === hash("set_font")) {
+     *       gui.set(msg.url(), "fonts", message.font, { key: "my_font_name" });
+     *       gui.set_font(gui.get_node("text"), "my_font_name");
+     *     } else if (message_id === hash("set_texture")) {
+     *       gui.set(msg.url(), "textures", message.texture, { key: "my_texture" });
+     *       gui.set_texture(gui.get_node("box"), "my_texture");
+     *       gui.play_flipbook(gui.get_node("box"), "logo_256");
+     *     }
+     *   },
+     * });
      * ```
      */
     function set(node: Opaque<"node"> | Url, property: string | Hash | Opaque<"constant">, value: number | Vector4 | Vector3 | Quaternion, options?: { index?: number; key?: Hash }): void;

package/generated/versions/defold-1.12.4/liveupdate.d.ts

@@ -67,11 +67,11 @@ declare global {
      * @param callback - Callback after the asynchronous request completed
      * @returns The result of the request
      * @example
-     * ```lua
-     * Add multiple mounts. Higher priority takes precedence.
-     * liveupdate.add_mount("common", "zip:/path/to/common_stuff.zip", 10, function (result) end) -- base pack
-     * liveupdate.add_mount("levelpack_1", "zip:/path/to/levels_1_to_20.zip", 20, function (result) end) -- level pack
-     * liveupdate.add_mount("season_pack_1", "zip:/path/to/easter_pack_1.zip", 30, function (result) end) -- season pack, overriding content in the other packs
+     * ```ts
+     * // Add multiple mounts. Higher priority takes precedence.
+     * liveupdate.add_mount("common", "zip:/path/to/common_stuff.zip", 10, (result) => {}); // base pack
+     * liveupdate.add_mount("levelpack_1", "zip:/path/to/levels_1_to_20.zip", 20, (result) => {}); // level pack
+     * liveupdate.add_mount("season_pack_1", "zip:/path/to/easter_pack_1.zip", 30, (result) => {}); // season pack, overriding content in the other packs
      * ```
      */
     function add_mount(name: string, uri: string, priority: number, callback: (...args: unknown[]) => unknown): number;
@@ -81,24 +81,24 @@ declare global {
      *
      * @returns Array of mounts
      * @example
-     * ```lua
-     * Output the current resource mounts
-     * pprint("MOUNTS", liveupdate.get_mounts())
+     * ```ts
+     * // Output the current resource mounts
+     * pprint("MOUNTS", liveupdate.get_mounts());
      *
-     * Give an output like:
-     * DEBUG:SCRIPT: MOUNTS,
-     * { --[[0x119667bf0]]
-     *   1 = { --[[0x119667c50]]
-     *     name = "liveupdate",
-     *     uri = "zip:/device/path/to/acchives/liveupdate.zip",
-     *     priority = 5
-     *   },
-     *   2 = { --[[0x119667d50]]
-     *     name = "_base",
-     *     uri = "archive:build/default/game.dmanifest",
-     *     priority = -10
-     *   }
-     * }
+     * // Give an output like:
+     * // DEBUG:SCRIPT: MOUNTS,
+     * // {
+     * //   1 = {
+     * //     name = "liveupdate",
+     * //     uri = "zip:/device/path/to/acchives/liveupdate.zip",
+     * //     priority = 5
+     * //   },
+     * //   2 = {
+     * //     name = "_base",
+     * //     uri = "archive:build/default/game.dmanifest",
+     * //     priority = -10
+     * //   }
+     * // }
      * ```
      */
     function get_mounts(): { name: string; uri: string; priority: number }[];

package/generated/versions/defold-1.12.4/physics.d.ts

@@ -288,82 +288,85 @@ declare global {
      * `data`
      * table The callback value data is a table that contains event-related data. See the documentation for details on the messages.
      * @example
-     * ```lua
-     * local function physics_world_listener(self, events)
-     *   for _,event in ipairs(events):
-     *       local event_type = event['type']
-     *       if event_type == hash("contact_point_event") then
-     *           pprint(event)
-     *           -- {
-     *           --  distance = 2.1490633487701,
-     *           --  applied_impulse = 0
-     *           --  a = { --[[0x113f7c6c0]]
-     *           --    group = hash: [box],
-     *           --    id = hash: [/box]
-     *           --    mass = 0,
-     *           --    normal = vmath.vector3(0.379, 0.925, -0),
-     *           --    position = vmath.vector3(517.337, 235.068, 0),
-     *           --    instance_position = vmath.vector3(480, 144, 0),
-     *           --    relative_velocity = vmath.vector3(-0, -0, -0),
-     *           --  },
-     *           --  b = { --[[0x113f7c840]]
-     *           --    group = hash: [circle],
-     *           --    id = hash: [/circle]
-     *           --    mass = 0,
-     *           --    normal = vmath.vector3(-0.379, -0.925, 0),
-     *           --    position = vmath.vector3(517.337, 235.068, 0),
-     *           --    instance_position = vmath.vector3(-0.0021, 0, -0.0022),
-     *           --    relative_velocity = vmath.vector3(0, 0, 0),
-     *           --  },
-     *           -- }
-     *       elseif event == hash("collision_event") then
-     *           pprint(event)
-     *           -- {
-     *           --  a = {
-     *           --          group = hash: [default],
-     *           --          position = vmath.vector3(183, 666, 0),
-     *           --          id = hash: [/go1]
-     *           --      },
-     *           --  b = {
-     *           --          group = hash: [default],
-     *           --          position = vmath.vector3(185, 704.05865478516, 0),
-     *           --          id = hash: [/go2]
-     *           --      }
-     *           -- }
-     *       elseif event ==  hash("trigger_event") then
-     *           pprint(event)
-     *           -- {
-     *           --  enter = true,
-     *           --  b = {
-     *           --      group = hash: [default],
-     *           --      id = hash: [/go2]
-     *           --  },
-     *           --  a = {
-     *           --      group = hash: [default],
-     *           --      id = hash: [/go1]
-     *           --  }
-     *           -- },
-     *       elseif event ==  hash("ray_cast_response") then
-     *           pprint(event)
-     *           --{
-     *           --  group = hash: [default],
-     *           --  request_id = 0,
-     *           --  position = vmath.vector3(249.92222595215, 249.92222595215, 0),
-     *           --  fraction = 0.68759721517563,
-     *           --  normal = vmath.vector3(0, 1, 0),
-     *           --  id = hash: [/go]
-     *           -- }
-     *       elseif event ==  hash("ray_cast_missed") then
-     *           pprint(event)
-     *           -- {
-     *           --  request_id = 0
-     *           --},
-     *       end
-     * end
+     * ```ts
+     * function physics_world_listener(self, events) {
+     *   for (const event of events) {
+     *     const event_type = event["type"];
+     *     if (event_type === hash("contact_point_event")) {
+     *       pprint(event);
+     *       // {
+     *       //  distance = 2.1490633487701,
+     *       //  applied_impulse = 0
+     *       //  a = { --[[0x113f7c6c0]]
+     *       //    group = hash: [box],
+     *       //    id = hash: [/box]
+     *       //    mass = 0,
+     *       //    normal = vmath.vector3(0.379, 0.925, -0),
+     *       //    position = vmath.vector3(517.337, 235.068, 0),
+     *       //    instance_position = vmath.vector3(480, 144, 0),
+     *       //    relative_velocity = vmath.vector3(-0, -0, -0),
+     *       //  },
+     *       //  b = { --[[0x113f7c840]]
+     *       //    group = hash: [circle],
+     *       //    id = hash: [/circle]
+     *       //    mass = 0,
+     *       //    normal = vmath.vector3(-0.379, -0.925, 0),
+     *       //    position = vmath.vector3(517.337, 235.068, 0),
+     *       //    instance_position = vmath.vector3(-0.0021, 0, -0.0022),
+     *       //    relative_velocity = vmath.vector3(0, 0, 0),
+     *       //  },
+     *       // }
+     *     } else if (event === hash("collision_event")) {
+     *       pprint(event);
+     *       // {
+     *       //  a = {
+     *       //          group = hash: [default],
+     *       //          position = vmath.vector3(183, 666, 0),
+     *       //          id = hash: [/go1]
+     *       //      },
+     *       //  b = {
+     *       //          group = hash: [default],
+     *       //          position = vmath.vector3(185, 704.05865478516, 0),
+     *       //          id = hash: [/go2]
+     *       //      }
+     *       // }
+     *     } else if (event === hash("trigger_event")) {
+     *       pprint(event);
+     *       // {
+     *       //  enter = true,
+     *       //  b = {
+     *       //      group = hash: [default],
+     *       //      id = hash: [/go2]
+     *       //  },
+     *       //  a = {
+     *       //      group = hash: [default],
+     *       //      id = hash: [/go1]
+     *       //  }
+     *       // },
+     *     } else if (event === hash("ray_cast_response")) {
+     *       pprint(event);
+     *       // {
+     *       //  group = hash: [default],
+     *       //  request_id = 0,
+     *       //  position = vmath.vector3(249.92222595215, 249.92222595215, 0),
+     *       //  fraction = 0.68759721517563,
+     *       //  normal = vmath.vector3(0, 1, 0),
+     *       //  id = hash: [/go]
+     *       // }
+     *     } else if (event === hash("ray_cast_missed")) {
+     *       pprint(event);
+     *       // {
+     *       //  request_id = 0
+     *       // },
+     *     }
+     *   }
+     * }
      *
-     * function init(self)
-     *     physics.set_event_listener(physics_world_listener)
-     * end
+     * export default defineScript({
+     *   init(self) {
+     *     physics.set_event_listener(physics_world_listener);
+     *   },
+     * });
      * ```
      */
     function set_event_listener(callback?: (self: unknown, events: unknown) => void): void;

package/generated/versions/defold-1.12.4/render.d.ts

@@ -575,66 +575,86 @@ declare global {
      * @param parameters - table of buffer parameters, see the description for available keys and values
      * @returns new render target
      * @example
-     * ```lua
-     * How to create a new render target and draw to it:
-     * function init(self)
-     *     -- render target buffer parameters
-     *     local color_params = { format = graphics.TEXTURE_FORMAT_RGBA,
-     *                            width = render.get_window_width(),
-     *                            height = render.get_window_height(),
-     *                            min_filter = graphics.TEXTURE_FILTER_LINEAR,
-     *                            mag_filter = graphics.TEXTURE_FILTER_LINEAR,
-     *                            u_wrap = graphics.TEXTURE_WRAP_CLAMP_TO_EDGE,
-     *                            v_wrap = graphics.TEXTURE_WRAP_CLAMP_TO_EDGE }
-     *     local depth_params = { format = graphics.TEXTURE_FORMAT_DEPTH,
-     *                            width = render.get_window_width(),
-     *                            height = render.get_window_height(),
-     *                            u_wrap = graphics.TEXTURE_WRAP_CLAMP_TO_EDGE,
-     *                            v_wrap = graphics.TEXTURE_WRAP_CLAMP_TO_EDGE }
-     *     self.my_render_target = render.render_target({[graphics.BUFFER_TYPE_COLOR0_BIT] = color_params, [graphics.BUFFER_TYPE_DEPTH_BIT] = depth_params })
-     * end
+     * ```ts
+     * // How to create a new render target and draw to it:
+     * export default defineScript({
+     *   init() {
+     *     // render target buffer parameters
+     *     const color_params = {
+     *       format: graphics.TEXTURE_FORMAT_RGBA,
+     *       width: render.get_window_width(),
+     *       height: render.get_window_height(),
+     *       min_filter: graphics.TEXTURE_FILTER_LINEAR,
+     *       mag_filter: graphics.TEXTURE_FILTER_LINEAR,
+     *       u_wrap: graphics.TEXTURE_WRAP_CLAMP_TO_EDGE,
+     *       v_wrap: graphics.TEXTURE_WRAP_CLAMP_TO_EDGE,
+     *     };
+     *     const depth_params = {
+     *       format: graphics.TEXTURE_FORMAT_DEPTH,
+     *       width: render.get_window_width(),
+     *       height: render.get_window_height(),
+     *       u_wrap: graphics.TEXTURE_WRAP_CLAMP_TO_EDGE,
+     *       v_wrap: graphics.TEXTURE_WRAP_CLAMP_TO_EDGE,
+     *     };
+     *     return {
+     *       my_render_target: render.render_target({
+     *         [graphics.BUFFER_TYPE_COLOR0_BIT]: color_params,
+     *         [graphics.BUFFER_TYPE_DEPTH_BIT]: depth_params,
+     *       }),
+     *     };
+     *   },
      *
-     * function update(self, dt)
-     *     -- enable target so all drawing is done to it
-     *     render.set_render_target(self.my_render_target)
+     *   update(self, dt) {
+     *     // enable target so all drawing is done to it
+     *     render.set_render_target(self.my_render_target);
      *
-     *     -- draw a predicate to the render target
-     *     render.draw(self.my_pred)
-     * end
+     *     // draw a predicate to the render target
+     *     render.draw(self.my_pred);
+     *   },
+     * });
      *
-     * How to create a render target with multiple outputs:
-     * function init(self)
-     *     -- render target buffer parameters
-     *     local color_params_rgba = { format = graphics.TEXTURE_FORMAT_RGBA,
-     *                                 width = render.get_window_width(),
-     *                                 height = render.get_window_height(),
-     *                                 min_filter = graphics.TEXTURE_FILTER_LINEAR,
-     *                                 mag_filter = graphics.TEXTURE_FILTER_LINEAR,
-     *                                 u_wrap = graphics.TEXTURE_WRAP_CLAMP_TO_EDGE,
-     *                                 v_wrap = graphics.TEXTURE_WRAP_CLAMP_TO_EDGE }
-     *     local color_params_float = { format = graphics.TEXTURE_FORMAT_RG32F,
-     *                            width = render.get_window_width(),
-     *                            height = render.get_window_height(),
-     *                            min_filter = graphics.TEXTURE_FILTER_LINEAR,
-     *                            mag_filter = graphics.TEXTURE_FILTER_LINEAR,
-     *                            u_wrap = graphics.TEXTURE_WRAP_CLAMP_TO_EDGE,
-     *                            v_wrap = graphics.TEXTURE_WRAP_CLAMP_TO_EDGE }
-     *
-     *     -- Create a render target with three color attachments
-     *     -- Note: No depth buffer is attached here
-     *     self.my_render_target = render.render_target({
-     *            [graphics.BUFFER_TYPE_COLOR0_BIT] = color_params_rgba,
-     *            [graphics.BUFFER_TYPE_COLOR1_BIT] = color_params_rgba,
-     *            [graphics.BUFFER_TYPE_COLOR2_BIT] = color_params_float, })
-     * end
+     * // How to create a render target with multiple outputs:
+     * export default defineScript({
+     *   init() {
+     *     // render target buffer parameters
+     *     const color_params_rgba = {
+     *       format: graphics.TEXTURE_FORMAT_RGBA,
+     *       width: render.get_window_width(),
+     *       height: render.get_window_height(),
+     *       min_filter: graphics.TEXTURE_FILTER_LINEAR,
+     *       mag_filter: graphics.TEXTURE_FILTER_LINEAR,
+     *       u_wrap: graphics.TEXTURE_WRAP_CLAMP_TO_EDGE,
+     *       v_wrap: graphics.TEXTURE_WRAP_CLAMP_TO_EDGE,
+     *     };
+     *     const color_params_float = {
+     *       format: graphics.TEXTURE_FORMAT_RG32F,
+     *       width: render.get_window_width(),
+     *       height: render.get_window_height(),
+     *       min_filter: graphics.TEXTURE_FILTER_LINEAR,
+     *       mag_filter: graphics.TEXTURE_FILTER_LINEAR,
+     *       u_wrap: graphics.TEXTURE_WRAP_CLAMP_TO_EDGE,
+     *       v_wrap: graphics.TEXTURE_WRAP_CLAMP_TO_EDGE,
+     *     };
      *
-     * function update(self, dt)
-     *     -- enable target so all drawing is done to it
-     *     render.enable_render_target(self.my_render_target)
+     *     // Create a render target with three color attachments
+     *     // Note: No depth buffer is attached here
+     *     return {
+     *       my_render_target: render.render_target({
+     *         [graphics.BUFFER_TYPE_COLOR0_BIT]: color_params_rgba,
+     *         [graphics.BUFFER_TYPE_COLOR1_BIT]: color_params_rgba,
+     *         [graphics.BUFFER_TYPE_COLOR2_BIT]: color_params_float,
+     *       }),
+     *     };
+     *   },
      *
-     *     -- draw a predicate to the render target
-     *     render.draw(self.my_pred)
-     * end
+     *   update(self, dt) {
+     *     // enable target so all drawing is done to it
+     *     render.enable_render_target(self.my_render_target);
+     *
+     *     // draw a predicate to the render target
+     *     render.draw(self.my_pred);
+     *   },
+     * });
      * ```
      */
     function render_target(name: string, parameters: Record<string | number, unknown>): Opaque<"render_target">;