Creates and returns a new empty cursor.

Destroys a previously created cursor.

Creates a cursor from a buffer containing RGBA pixel data.

Adds a frame to a cursor from a buffer containing RGBA pixel data.

Creates a cursor from a surface.

Adds a frame to a cursor from a surface.

Loads a cursor from a file.

Note: This takes a CUR/ANI file, not an image.

Note: An ANI cursor doesn't currently get split into frames on load, so trying to append frames to it will not work like you expect.

Appends a frame to a cursor from a file.

Note: This takes a CUR/ANI file, not an image.

Note: An ANI cursor doesn't currently get split into frames on load, so trying to append frames to it will not work like you expect.

Creates a cursor from a sprite.

If frame is not specified or is undefined, all frames will be added.
Otherwise a single frame is used.

If fps is not specified, game's framerate is used.

Like above, but with scale/color/alpha.

You can use gpu_set_texfilter (GMS2) or texture_set_interpolation (GMS1) to control how the images will be scaled.

Adds a sprite frame to a cursor.

You should call this once per frame or your cursors won't animate when the mouse isn't moving.

Switches the cursor to a specified one.

Reverts to default GameMaker cursor behavior.

Returns the current frame of a cursor.

Note that this is calculated in real-time.

Changes the current frame for a cursor.

Returns current animation speed for a cursor.

Changes animation speed for a cursor.

Changes the function/script that fires on mouse movement.

Resets the callback if function argument is omitted or is undefined.

The function receives x, y arguments (window mouse coordinates) that come from WM_SETCURSOR and can take an opportunity to change the cursor.

Windows may serve mouse events an arbitrary number of times per second - for example, if the player uses a gaming mouse with a 8000 Hz polling rate, your function might be called up to 133 times per frame (at 60fps).

For this reason it's best to keep your callback logic minimal or even allow the user to opt out by switching to a lower-frequency callback mode.

For example, the following creates a handful of "directional crosshair" cursors from a spr_cursor_dir sprite and then selects the appropriate one based on direction between window center and mouse position:

dir_count = 360;
dir_cursors = [];
var _surf = surface_create(64, 64);
var _texf = gpu_get_texfilter();
gpu_set_tex_filter(true);
for (var i = 0; i < dir_count; i++) {
    surface_set_target(_surf);
    draw_clear_alpha(c_white, 0);
    draw_sprite_ext(spr_cursor_dir, 0, 32, 32, 1, 1, i * 360 / dir_count, c_white, 1);
    surface_reset_target();
    dir_cursors[i] = native_cursor_create_from_surface(_surf, 32, 32);
}
surface_free(_surf);
gpu_set_tex_filter(_texf);
native_cursor_set_callback(function(_x, _y) {
    var dir = point_direction(
        window_get_width() div 2,
        window_get_height() div 2,
        _x, _y
    );
    var ind = round(dir / 360 * dir_count) % dir_count;
    if (ind < 0) ind += dir_count;
    native_cursor_set(dir_cursors[ind]);
});

Returns the current callback.

Changes the callback handling mode.

The supported values are:

• native_cursor_set_callback_mode_highp:
  The callback is executed once per WM_MOUSEMOVE event.
• native_cursor_set_callback_mode_lowp:
  The callback is executed once per frame when you run native_cursor_update (provided that the mouse )

Returns the current callback handling mode.