Physics

Functions

Bitmap Circle Collision

Tests if a bitmap drawn at pt would intersect with a circle.

Parameters:

Name	Type	Description
bmp	`Bitmap`	The bitmap to test
pt	`Point 2d`	The location where the bitmap is drawn
circ	`Circle`	The circle to test

Return Type: Boolean

Signatures:

bool bitmap_circle_collision(bitmap bmp, const point_2d &pt, const circle &circ)

public bool Bitmap.CircleCollision(Point2D pt, Circle circ);
public static bool SplashKit.BitmapCircleCollision(Bitmap bmp, Point2D pt, Circle circ);

def bitmap_circle_collision_at_point(bmp, pt, circ):

function BitmapCircleCollision(bmp: Bitmap; const pt: Point2D; const circ: Circle): Boolean

Bitmap Circle Collision

Tests if a bitmap drawn at x, y would intersect with a circle.

Parameters:

Name	Type	Description
bmp	`Bitmap`	The bitmap to test
x	`Double`	The x location where the bitmap is drawn
y	`Double`	The y location where the bitmap is drawn
circ	`Circle`	The circle to test

Return Type: Boolean

Signatures:

bool bitmap_circle_collision(bitmap bmp, double x, double y, const circle &circ)

public bool Bitmap.CircleCollision(double x, double y, Circle circ);
public static bool SplashKit.BitmapCircleCollision(Bitmap bmp, double x, double y, Circle circ);

def bitmap_circle_collision(bmp, x, y, circ):

function BitmapCircleCollision(bmp: Bitmap; x: Double; y: Double; const circ: Circle): Boolean

Bitmap Circle Collision

Tests if a bitmap cell drawn using a passed in translation, will intersect with a circle. You can use this to detect collisions between bitmaps and circles.

Parameters:

Name	Type	Description
bmp	`Bitmap`	The bitmap to test
cell	`Integer`	The cell of the bitmap to check
translation	`Matrix 2d`	The matrix used to transfrom the bitmap when drawing
circ	`Circle`	The circle to test

Return Type: Boolean

Signatures:

bool bitmap_circle_collision(bitmap bmp, int cell, const matrix_2d &translation, const circle &circ)

public bool Bitmap.CircleCollision(int cell, Matrix2D translation, Circle circ);
public static bool SplashKit.BitmapCircleCollision(Bitmap bmp, int cell, Matrix2D translation, Circle circ);

def bitmap_circle_collision_for_cell_with_translation(bmp, cell, translation, circ):

function BitmapCircleCollision(bmp: Bitmap; cell: Integer; const translation: Matrix2D; const circ: Circle): Boolean

Bitmap Circle Collision

Tests if a bitmap cell drawn at pt would intersect with a circle.

Parameters:

Name	Type	Description
bmp	`Bitmap`	The bitmap to test
cell	`Integer`	The cell of the bitmap to check
pt	`Point 2d`	The location where the bitmap is drawn
circ	`Circle`	The circle to test

Return Type: Boolean

Signatures:

bool bitmap_circle_collision(bitmap bmp, int cell, const point_2d &pt, const circle &circ)

public bool Bitmap.CircleCollision(int cell, Point2D pt, Circle circ);
public static bool SplashKit.BitmapCircleCollision(Bitmap bmp, int cell, Point2D pt, Circle circ);

def bitmap_circle_collision_for_cell_at_point(bmp, cell, pt, circ):

function BitmapCircleCollision(bmp: Bitmap; cell: Integer; const pt: Point2D; const circ: Circle): Boolean

Bitmap Circle Collision

Tests if a bitmap cell drawn at x, y would intersect with a circle.

Parameters:

Name	Type	Description
bmp	`Bitmap`	The bitmap to test
cell	`Integer`	The cell of the bitmap to check
x	`Double`	The x location where the bitmap is drawn
y	`Double`	The y location where the bitmap is drawn
circ	`Circle`	The circle to test

Return Type: Boolean

Signatures:

bool bitmap_circle_collision(bitmap bmp, int cell, double x, double y, const circle &circ)

public bool Bitmap.CircleCollision(int cell, double x, double y, Circle circ);
public static bool SplashKit.BitmapCircleCollision(Bitmap bmp, int cell, double x, double y, Circle circ);

def bitmap_circle_collision_for_cell(bmp, cell, x, y, circ):

function BitmapCircleCollision(bmp: Bitmap; cell: Integer; x: Double; y: Double; const circ: Circle): Boolean

Bitmap Collision

Check if two bitmaps collide.

Parameters:

Name	Type	Description
bmp1	`Bitmap`	The first bitmap
x1	`Double`	The x location where the first bitmap is drawn
y1	`Double`	The y location where the first bitmap is drawn
bmp2	`Bitmap`	The second bitmap
x2	`Double`	The x location where the second bitmap is drawn
y2	`Double`	The y location where the second bitmap is drawn

Return Type: Boolean

Signatures:

bool bitmap_collision(bitmap bmp1, double x1, double y1, bitmap bmp2, double x2, double y2)

public bool Bitmap.BitmapCollision(double x1, double y1, Bitmap bmp2, double x2, double y2);
public static bool SplashKit.BitmapCollision(Bitmap bmp1, double x1, double y1, Bitmap bmp2, double x2, double y2);

def bitmap_collision(bmp1, x1, y1, bmp2, x2, y2):

function BitmapCollision(bmp1: Bitmap; x1: Double; y1: Double; bmp2: Bitmap; x2: Double; y2: Double): Boolean

Bitmap Collision

Check if two bitmaps collide.

Parameters:

Name	Type	Description
bmp1	`Bitmap`	The first bitmap
pt1	`Point 2d`	The point where bitmap 1 is drawn
bmp2	`Bitmap`	The second bitmap
pt2	`Point 2d`	The point where bitmap 2 is drawn

Return Type: Boolean

Signatures:

bool bitmap_collision(bitmap bmp1, const point_2d &pt1, bitmap bmp2, const point_2d &pt2)

public bool Bitmap.BitmapCollision(Point2D pt1, Bitmap bmp2, Point2D pt2);
public static bool SplashKit.BitmapCollision(Bitmap bmp1, Point2D pt1, Bitmap bmp2, Point2D pt2);

def bitmap_collision_at_points(bmp1, pt1, bmp2, pt2):

function BitmapCollision(bmp1: Bitmap; const pt1: Point2D; bmp2: Bitmap; const pt2: Point2D): Boolean

Bitmap Collision

Check if two bitmaps collide, based on their cell and transform matricies.

Parameters:

Name	Type	Description
bmp1	`Bitmap`	The first bitmap
cell1	`Integer`	The cell of the first bitmap.
matrix1	`Matrix 2d`	The transformation for the first matrix
bmp2	`Bitmap`	The second bitmap
cell2	`Integer`	The cell of the second bitmap.
matrix2	`Matrix 2d`	The transformation for the second matrix

Return Type: Boolean

Signatures:

bool bitmap_collision(bitmap bmp1, int cell1, const matrix_2d &matrix1, bitmap bmp2, int cell2, const matrix_2d &matrix2)

public bool Bitmap.BitmapCollision(int cell1, Matrix2D matrix1, Bitmap bmp2, int cell2, Matrix2D matrix2);
public static bool SplashKit.BitmapCollision(Bitmap bmp1, int cell1, Matrix2D matrix1, Bitmap bmp2, int cell2, Matrix2D matrix2);

def bitmap_collision_for_cells_with_translations(bmp1, cell1, matrix1, bmp2, cell2, matrix2):

function BitmapCollision(bmp1: Bitmap; cell1: Integer; const matrix1: Matrix2D; bmp2: Bitmap; cell2: Integer; const matrix2: Matrix2D): Boolean

Bitmap Collision

Check if two bitmaps collide.

Parameters:

Name	Type	Description
bmp1	`Bitmap`	The first bitmap
cell1	`Integer`	The cell of the first bitmap.
pt1	`Point 2d`	The point where bitmap 1 is drawn
bmp2	`Bitmap`	The second bitmap
cell2	`Integer`	The cell of the second bitmap.
pt2	`Point 2d`	The point where bitmap 2 is drawn

Return Type: Boolean

Signatures:

bool bitmap_collision(bitmap bmp1, int cell1, const point_2d &pt1, bitmap bmp2, int cell2, const point_2d &pt2)

public bool Bitmap.BitmapCollision(int cell1, Point2D pt1, Bitmap bmp2, int cell2, Point2D pt2);
public static bool SplashKit.BitmapCollision(Bitmap bmp1, int cell1, Point2D pt1, Bitmap bmp2, int cell2, Point2D pt2);

def bitmap_collision_for_cells_at_points(bmp1, cell1, pt1, bmp2, cell2, pt2):

function BitmapCollision(bmp1: Bitmap; cell1: Integer; const pt1: Point2D; bmp2: Bitmap; cell2: Integer; const pt2: Point2D): Boolean

Bitmap Collision

Check if two bitmaps collide.

Parameters:

Name	Type	Description
bmp1	`Bitmap`	The first bitmap
cell1	`Integer`	The cell of the first bitmap.
x1	`Double`	The x location where the first bitmap is drawn
y1	`Double`	The y location where the first bitmap is drawn
bmp2	`Bitmap`	The second bitmap
cell2	`Integer`	The cell of the second bitmap.
x2	`Double`	The x location where the second bitmap is drawn
y2	`Double`	The y location where the second bitmap is drawn

Return Type: Boolean

Signatures:

bool bitmap_collision(bitmap bmp1, int cell1, double x1, double y1, bitmap bmp2, int cell2, double x2, double y2)

public bool Bitmap.BitmapCollision(int cell1, double x1, double y1, Bitmap bmp2, int cell2, double x2, double y2);
public static bool SplashKit.BitmapCollision(Bitmap bmp1, int cell1, double x1, double y1, Bitmap bmp2, int cell2, double x2, double y2);

def bitmap_collision_for_cells(bmp1, cell1, x1, y1, bmp2, cell2, x2, y2):

function BitmapCollision(bmp1: Bitmap; cell1: Integer; x1: Double; y1: Double; bmp2: Bitmap; cell2: Integer; x2: Double; y2: Double): Boolean

Bitmap Point Collision

Tests if a bitmap drawn using the passed in translation matrix would draw a pixel at the passed in point. Use to check collisions between a point and a bitmap.

Parameters:

Name	Type	Description
bmp	`Bitmap`	The bitmap to test.
translation	`Matrix 2d`	The translation matrix that represents the position, scale, and rotation of the bitmap when it is drawn.
pt	`Point 2d`	The point in the resulting drawing that is being tested.

Return Type: Boolean

Signatures:

bool bitmap_point_collision(bitmap bmp, const matrix_2d &translation, const point_2d &pt)

public bool Bitmap.PointCollision(Matrix2D translation, Point2D pt);
public static bool SplashKit.BitmapPointCollision(Bitmap bmp, Matrix2D translation, Point2D pt);

def bitmap_point_collision_with_translation(bmp, translation, pt):

function BitmapPointCollision(bmp: Bitmap; const translation: Matrix2D; const pt: Point2D): Boolean

Bitmap Point Collision

Tests if a bitmap drawn at the bmp_pt point would draw a pixel at point pt. Use to check collisions between a point and a bitmap.

Parameters:

Name	Type	Description
bmp	`Bitmap`	The bitmap to test.
bmp_pt	`Point 2d`	The point where the bitmap is drawn.
pt	`Point 2d`	The point in the resulting drawing that is being tested.

Return Type: Boolean

Signatures:

bool bitmap_point_collision(bitmap bmp, const point_2d &bmp_pt, const point_2d &pt)

public bool Bitmap.PointCollision(Point2D bmpPt, Point2D pt);
public static bool SplashKit.BitmapPointCollision(Bitmap bmp, Point2D bmpPt, Point2D pt);

def bitmap_point_collision_at_point(bmp, bmp_pt, pt):

function BitmapPointCollision(bmp: Bitmap; const bmpPt: Point2D; const pt: Point2D): Boolean

Bitmap Point Collision

Tests if a bitmap drawn at x,y would draw a pixel at the passed in point. Use to check collisions between a point and a bitmap.

Parameters:

Name	Type	Description
bmp	`Bitmap`	The bitmap to test.
bmp_x	`Double`	The x location where the bitmap is drawn
bmp_y	`Double`	The y location where the bitmap is drawn
x	`Double`	The x location of the point to test
y	`Double`	The y location of the point to test

Return Type: Boolean

Signatures:

bool bitmap_point_collision(bitmap bmp, double bmp_x, double bmp_y, double x, double y)

public bool Bitmap.PointCollision(double bmpX, double bmpY, double x, double y);
public static bool SplashKit.BitmapPointCollision(Bitmap bmp, double bmpX, double bmpY, double x, double y);

def bitmap_point_collision(bmp, bmp_x, bmp_y, x, y):

function BitmapPointCollision(bmp: Bitmap; bmpX: Double; bmpY: Double; x: Double; y: Double): Boolean

Bitmap Point Collision

Tests if a bitmap cell drawn using the passed in translation matrix would draw a pixel at the passed in point.

Parameters:

Name	Type	Description
bmp	`Bitmap`	The bitmap to test.
cell	`Integer`	The cell of the bitmap to check.
translation	`Matrix 2d`	The translation matrix that represents the position, scale, and rotation of the bitmap when it is drawn.
pt	`Point 2d`	The point in the resulting drawing that is being tested.

Return Type: Boolean

Signatures:

bool bitmap_point_collision(bitmap bmp, int cell, const matrix_2d &translation, const point_2d &pt)

public bool Bitmap.PointCollision(int cell, Matrix2D translation, Point2D pt);
public static bool SplashKit.BitmapPointCollision(Bitmap bmp, int cell, Matrix2D translation, Point2D pt);

def bitmap_point_collision_for_cell_with_translation(bmp, cell, translation, pt):

function BitmapPointCollision(bmp: Bitmap; cell: Integer; const translation: Matrix2D; const pt: Point2D): Boolean

Bitmap Point Collision

Tests if a cell of a bitmap drawn at x,y would draw a pixel at the passed in point. Use to check collisions between a point and a bitmap.

Parameters:

Name	Type	Description
bmp	`Bitmap`	The bitmap to test
cell	`Integer`	The cell of the bitmap to test
bmp_pt	`Point 2d`	The point where the bitmap is drawn.
pt	`Point 2d`	The point in the resulting drawing that is being tested.

Return Type: Boolean

Signatures:

bool bitmap_point_collision(bitmap bmp, int cell, const point_2d &bmp_pt, const point_2d &pt)

public bool Bitmap.PointCollision(int cell, Point2D bmpPt, Point2D pt);
public static bool SplashKit.BitmapPointCollision(Bitmap bmp, int cell, Point2D bmpPt, Point2D pt);

def bitmap_point_collision_for_cell_at_point(bmp, cell, bmp_pt, pt):

function BitmapPointCollision(bmp: Bitmap; cell: Integer; const bmpPt: Point2D; const pt: Point2D): Boolean

Bitmap Point Collision

Tests if a cell of a bitmap drawn at x,y would draw a pixel at the passed in point. Use to check collisions between a point and a bitmap.

Parameters:

Name	Type	Description
bmp	`Bitmap`	The bitmap to test
cell	`Integer`	The cell of the bitmap to test
bmp_x	`Double`	The x location where the bitmap is drawn
bmp_y	`Double`	The y location where the bitmap is drawn
x	`Double`	The x location of the point to test
y	`Double`	The y location of the point to test

Return Type: Boolean

Signatures:

bool bitmap_point_collision(bitmap bmp, int cell, double bmp_x, double bmp_y, double x, double y)

public bool Bitmap.PointCollision(int cell, double bmpX, double bmpY, double x, double y);
public static bool SplashKit.BitmapPointCollision(Bitmap bmp, int cell, double bmpX, double bmpY, double x, double y);

def bitmap_point_collision_for_cell(bmp, cell, bmp_x, bmp_y, x, y):

function BitmapPointCollision(bmp: Bitmap; cell: Integer; bmpX: Double; bmpY: Double; x: Double; y: Double): Boolean

Bitmap Quad Collision

Tests if a bitmap drawn at pt would intersect with a quad.

Parameters:

Name	Type	Description
bmp	`Bitmap`	The bitmap to test
pt	`Point 2d`	The location where the bitmap is drawn
q	`Quad`	The quad to test

Return Type: Boolean

Signatures:

bool bitmap_quad_collision(bitmap bmp, const point_2d &pt, const quad &q)

public bool Bitmap.QuadCollision(Point2D pt, Quad q);
public static bool SplashKit.BitmapQuadCollision(Bitmap bmp, Point2D pt, Quad q);

def bitmap_quad_collision_at_point(bmp, pt, q):

function BitmapQuadCollision(bmp: Bitmap; const pt: Point2D; const q: Quad): Boolean

Bitmap Quad Collision

Tests if a bitmap drawn at x, y would intersect with a quad.

Parameters:

Name	Type	Description
bmp	`Bitmap`	The bitmap to test
x	`Double`	The x location where the bitmap is drawn
y	`Double`	The y location where the bitmap is drawn
q	`Quad`	The quad to test

Return Type: Boolean

Signatures:

bool bitmap_quad_collision(bitmap bmp, double x, double y, const quad &q)

public bool Bitmap.QuadCollision(double x, double y, Quad q);
public static bool SplashKit.BitmapQuadCollision(Bitmap bmp, double x, double y, Quad q);

def bitmap_quad_collision(bmp, x, y, q):

function BitmapQuadCollision(bmp: Bitmap; x: Double; y: Double; const q: Quad): Boolean

Bitmap Quad Collision

Tests if a bitmap cell drawn using a passed in translation, will intersect with a quad. You can use this to detect collisions between bitmaps and quads.

Parameters:

Name	Type	Description
bmp	`Bitmap`	The bitmap to test
cell	`Integer`	The cell of the bitmap to check
translation	`Matrix 2d`	The matrix used to transfrom the bitmap when drawing
q	`Quad`	The quad to test

Return Type: Boolean

Signatures:

bool bitmap_quad_collision(bitmap bmp, int cell, const matrix_2d &translation, const quad &q)

public bool Bitmap.QuadCollision(int cell, Matrix2D translation, Quad q);
public static bool SplashKit.BitmapQuadCollision(Bitmap bmp, int cell, Matrix2D translation, Quad q);

def bitmap_quad_collision_for_cell_with_translation(bmp, cell, translation, q):

function BitmapQuadCollision(bmp: Bitmap; cell: Integer; const translation: Matrix2D; const q: Quad): Boolean

Bitmap Quad Collision

Tests if a bitmap cell drawn at pt would intersect with a quad.

Parameters:

Name	Type	Description
bmp	`Bitmap`	The bitmap to test
cell	`Integer`	The cell of the bitmap to check
pt	`Point 2d`	The location where the bitmap is drawn
q	`Quad`	The quad to test

Return Type: Boolean

Signatures:

bool bitmap_quad_collision(bitmap bmp, int cell, const point_2d &pt, const quad &q)

public bool Bitmap.QuadCollision(int cell, Point2D pt, Quad q);
public static bool SplashKit.BitmapQuadCollision(Bitmap bmp, int cell, Point2D pt, Quad q);

def bitmap_quad_collision_for_cell_at_point(bmp, cell, pt, q):

function BitmapQuadCollision(bmp: Bitmap; cell: Integer; const pt: Point2D; const q: Quad): Boolean

Bitmap Quad Collision

Tests if a bitmap cell drawn at x, y would intersect with a quad.

Parameters:

Name	Type	Description
bmp	`Bitmap`	The bitmap to test
cell	`Integer`	The cell of the bitmap to check
x	`Double`	The x location where the bitmap is drawn
y	`Double`	The y location where the bitmap is drawn
q	`Quad`	The quad to test

Return Type: Boolean

Signatures:

bool bitmap_quad_collision(bitmap bmp, int cell, double x, double y, const quad &q)

public bool Bitmap.QuadCollision(int cell, double x, double y, Quad q);
public static bool SplashKit.BitmapQuadCollision(Bitmap bmp, int cell, double x, double y, Quad q);

def bitmap_quad_collision_for_cell(bmp, cell, x, y, q):

function BitmapQuadCollision(bmp: Bitmap; cell: Integer; x: Double; y: Double; const q: Quad): Boolean

Bitmap Ray Collision

Tests if a bitmap drawn at pt would intersect with a ray.

Parameters:

Name	Type	Description
bmp	`Bitmap`	The bitmap to test
pt	`Point 2d`	The location where the bitmap is drawn
origin	`Point 2d`	The origin of the ray
heading	`Vector 2d`	The heading of the ray

Return Type: Boolean

Signatures:

bool bitmap_ray_collision(bitmap bmp, const point_2d &pt, const point_2d &origin, const vector_2d &heading)

public bool Bitmap.RayCollision(Point2D pt, Point2D origin, Vector2D heading);
public static bool SplashKit.BitmapRayCollision(Bitmap bmp, Point2D pt, Point2D origin, Vector2D heading);

def bitmap_ray_collision_at_point(bmp, pt, origin, heading):

function BitmapRayCollision(bmp: Bitmap; const pt: Point2D; const origin: Point2D; const heading: Vector2D): Boolean

Bitmap Ray Collision

Tests if a bitmap drawn at x, y would intersect with a ray.

Parameters:

Name	Type	Description
bmp	`Bitmap`	The bitmap to test
x	`Double`	The x location where the bitmap is drawn
y	`Double`	The y location where the bitmap is drawn
origin	`Point 2d`	The origin of the ray
heading	`Vector 2d`	The heading of the ray

Return Type: Boolean

Signatures:

bool bitmap_ray_collision(bitmap bmp, double x, double y, const point_2d &origin, const vector_2d &heading)

public bool Bitmap.RayCollision(double x, double y, Point2D origin, Vector2D heading);
public static bool SplashKit.BitmapRayCollision(Bitmap bmp, double x, double y, Point2D origin, Vector2D heading);

def bitmap_ray_collision(bmp, x, y, origin, heading):

function BitmapRayCollision(bmp: Bitmap; x: Double; y: Double; const origin: Point2D; const heading: Vector2D): Boolean

Bitmap Ray Collision

Tests if a bitmap cell drawn using a passed in translation, will intersect with a ray. You can use this to detect collisions between bitmaps and rays.

Parameters:

Name	Type	Description
bmp	`Bitmap`	The bitmap to test
cell	`Integer`	The cell of the bitmap to check
translation	`Matrix 2d`	The matrix used to transfrom the bitmap when drawing
origin	`Point 2d`	The origin of the ray
heading	`Vector 2d`	The heading of the ray

Return Type: Boolean

Signatures:

bool bitmap_ray_collision(bitmap bmp, int cell, const matrix_2d &translation, const point_2d &origin, const vector_2d &heading)

public bool Bitmap.RayCollision(int cell, Matrix2D translation, Point2D origin, Vector2D heading);
public static bool SplashKit.BitmapRayCollision(Bitmap bmp, int cell, Matrix2D translation, Point2D origin, Vector2D heading);

def bitmap_ray_collision_for_cell_with_translation(bmp, cell, translation, origin, heading):

function BitmapRayCollision(bmp: Bitmap; cell: Integer; const translation: Matrix2D; const origin: Point2D; const heading: Vector2D): Boolean

Bitmap Ray Collision

Tests if a bitmap cell drawn at pt would intersect with a ray.

Parameters:

Name	Type	Description
bmp	`Bitmap`	The bitmap to test
cell	`Integer`	The cell of the bitmap to check
pt	`Point 2d`	The location where the bitmap is drawn
origin	`Point 2d`	The origin of the ray
heading	`Vector 2d`	The heading of the ray

Return Type: Boolean

Signatures:

bool bitmap_ray_collision(bitmap bmp, int cell, const point_2d &pt, const point_2d &origin, const vector_2d &heading)

public bool Bitmap.RayCollision(int cell, Point2D pt, Point2D origin, Vector2D heading);
public static bool SplashKit.BitmapRayCollision(Bitmap bmp, int cell, Point2D pt, Point2D origin, Vector2D heading);

def bitmap_ray_collision_for_cell_at_point(bmp, cell, pt, origin, heading):

function BitmapRayCollision(bmp: Bitmap; cell: Integer; const pt: Point2D; const origin: Point2D; const heading: Vector2D): Boolean

Bitmap Ray Collision

Tests if a bitmap cell drawn at x, y would intersect with a ray.

Parameters:

Name	Type	Description
bmp	`Bitmap`	The bitmap to test
cell	`Integer`	The cell of the bitmap to check
x	`Double`	The x location where the bitmap is drawn
y	`Double`	The y location where the bitmap is drawn
origin	`Point 2d`	The origin of the ray
heading	`Vector 2d`	The heading of the ray

Return Type: Boolean

Signatures:

bool bitmap_ray_collision(bitmap bmp, int cell, double x, double y, const point_2d &origin, const vector_2d &heading)

public bool Bitmap.RayCollision(int cell, double x, double y, Point2D origin, Vector2D heading);
public static bool SplashKit.BitmapRayCollision(Bitmap bmp, int cell, double x, double y, Point2D origin, Vector2D heading);

def bitmap_ray_collision_for_cell(bmp, cell, x, y, origin, heading):

function BitmapRayCollision(bmp: Bitmap; cell: Integer; x: Double; y: Double; const origin: Point2D; const heading: Vector2D): Boolean

Bitmap Rectangle Collision

Tests if a bitmap drawn at pt would intersect with a rectangle.

Parameters:

Name	Type	Description
bmp	`Bitmap`	The bitmap to test
pt	`Point 2d`	The location where the bitmap is drawn
rect	`Rectangle`	The rectangle to test

Return Type: Boolean

Signatures:

bool bitmap_rectangle_collision(bitmap bmp, const point_2d &pt, const rectangle &rect)

public bool Bitmap.RectangleCollision(Point2D pt, Rectangle rect);
public static bool SplashKit.BitmapRectangleCollision(Bitmap bmp, Point2D pt, Rectangle rect);

def bitmap_rectangle_collision_at_point(bmp, pt, rect):

function BitmapRectangleCollision(bmp: Bitmap; const pt: Point2D; const rect: Rectangle): Boolean

Bitmap Rectangle Collision

Tests if a bitmap drawn at x, y would intersect with a rectangle.

Parameters:

Name	Type	Description
bmp	`Bitmap`	The bitmap to test
x	`Double`	The x location where the bitmap is drawn
y	`Double`	The y location where the bitmap is drawn
rect	`Rectangle`	The rectangle to test

Return Type: Boolean

Signatures:

bool bitmap_rectangle_collision(bitmap bmp, double x, double y, const rectangle &rect)

public bool Bitmap.RectangleCollision(double x, double y, Rectangle rect);
public static bool SplashKit.BitmapRectangleCollision(Bitmap bmp, double x, double y, Rectangle rect);

def bitmap_rectangle_collision(bmp, x, y, rect):

function BitmapRectangleCollision(bmp: Bitmap; x: Double; y: Double; const rect: Rectangle): Boolean

Bitmap Rectangle Collision

Tests if a bitmap cell drawn using a passed in translation, will intersect with a rectangle. You can use this to detect collisions between bitmaps and rectangles.

Parameters:

Name	Type	Description
bmp	`Bitmap`	The bitmap to test
cell	`Integer`	The cell of the bitmap to check
translation	`Matrix 2d`	The matrix used to transfrom the bitmap when drawing
rect	`Rectangle`	The rectangle to test

Return Type: Boolean

Signatures:

bool bitmap_rectangle_collision(bitmap bmp, int cell, const matrix_2d &translation, const rectangle &rect)

public bool Bitmap.RectangleCollision(int cell, Matrix2D translation, Rectangle rect);
public static bool SplashKit.BitmapRectangleCollision(Bitmap bmp, int cell, Matrix2D translation, Rectangle rect);

def bitmap_rectangle_collision_for_cell_with_translation(bmp, cell, translation, rect):

function BitmapRectangleCollision(bmp: Bitmap; cell: Integer; const translation: Matrix2D; const rect: Rectangle): Boolean

Bitmap Rectangle Collision

Tests if a bitmap cell drawn at pt would intersect with a rectangle.

Parameters:

Name	Type	Description
bmp	`Bitmap`	The bitmap to test
cell	`Integer`	The cell of the bitmap to check
pt	`Point 2d`	The location where the bitmap is drawn
rect	`Rectangle`	The rectangle to test

Return Type: Boolean

Signatures:

bool bitmap_rectangle_collision(bitmap bmp, int cell, const point_2d &pt, const rectangle &rect)

public bool Bitmap.RectangleCollision(int cell, Point2D pt, Rectangle rect);
public static bool SplashKit.BitmapRectangleCollision(Bitmap bmp, int cell, Point2D pt, Rectangle rect);

def bitmap_rectangle_collision_for_cell_at_point(bmp, cell, pt, rect):

function BitmapRectangleCollision(bmp: Bitmap; cell: Integer; const pt: Point2D; const rect: Rectangle): Boolean

Bitmap Rectangle Collision

Tests if a cell of the bitmap drawn at x, y would intersect with a rectangle.

Parameters:

Name	Type	Description
bmp	`Bitmap`	The bitmap to test
cell	`Integer`	The cell of the bitmap to check
x	`Double`	The x location where the bitmap is drawn
y	`Double`	The y location where the bitmap is drawn
rect	`Rectangle`	The rectangle to test

Return Type: Boolean

Signatures:

bool bitmap_rectangle_collision(bitmap bmp, int cell, double x, double y, const rectangle &rect)

public bool Bitmap.RectangleCollision(int cell, double x, double y, Rectangle rect);
public static bool SplashKit.BitmapRectangleCollision(Bitmap bmp, int cell, double x, double y, Rectangle rect);

def bitmap_rectangle_collision_for_cell(bmp, cell, x, y, rect):

function BitmapRectangleCollision(bmp: Bitmap; cell: Integer; x: Double; y: Double; const rect: Rectangle): Boolean

Bitmap Triangle Collision

Tests if a bitmap drawn at pt would intersect with a triangle.

Parameters:

Name	Type	Description
bmp	`Bitmap`	The bitmap to test
pt	`Point 2d`	The location where the bitmap is drawn
tri	`Triangle`	The triangle to test

Return Type: Boolean

Signatures:

bool bitmap_triangle_collision(bitmap bmp, const point_2d &pt, const triangle &tri)

public bool Bitmap.TriangleCollision(Point2D pt, Triangle tri);
public static bool SplashKit.BitmapTriangleCollision(Bitmap bmp, Point2D pt, Triangle tri);

def bitmap_triangle_collision_at_point(bmp, pt, tri):

function BitmapTriangleCollision(bmp: Bitmap; const pt: Point2D; const tri: Triangle): Boolean

Bitmap Triangle Collision

Tests if a bitmap drawn at x, y would intersect with a triangle.

Parameters:

Name	Type	Description
bmp	`Bitmap`	The bitmap to test
x	`Double`	The x location where the bitmap is drawn
y	`Double`	The y location where the bitmap is drawn
tri	`Triangle`	The triangle to test

Return Type: Boolean

Signatures:

bool bitmap_triangle_collision(bitmap bmp, double x, double y, const triangle &tri)

public bool Bitmap.TriangleCollision(double x, double y, Triangle tri);
public static bool SplashKit.BitmapTriangleCollision(Bitmap bmp, double x, double y, Triangle tri);

def bitmap_triangle_collision(bmp, x, y, tri):

function BitmapTriangleCollision(bmp: Bitmap; x: Double; y: Double; const tri: Triangle): Boolean

Bitmap Triangle Collision

Tests if a bitmap cell drawn using a passed in translation, will intersect with a triangle. You can use this to detect collisions between bitmaps and triangles.

Parameters:

Name	Type	Description
bmp	`Bitmap`	The bitmap to test
cell	`Integer`	The cell of the bitmap to check
translation	`Matrix 2d`	The matrix used to transfrom the bitmap when drawing
tri	`Triangle`	The triangle to test

Return Type: Boolean

Signatures:

bool bitmap_triangle_collision(bitmap bmp, int cell, const matrix_2d &translation, const triangle &tri)

public bool Bitmap.TriangleCollision(int cell, Matrix2D translation, Triangle tri);
public static bool SplashKit.BitmapTriangleCollision(Bitmap bmp, int cell, Matrix2D translation, Triangle tri);

def bitmap_triangle_collision_for_cell_with_translation(bmp, cell, translation, tri):

function BitmapTriangleCollision(bmp: Bitmap; cell: Integer; const translation: Matrix2D; const tri: Triangle): Boolean

Bitmap Triangle Collision

Tests if a bitmap cell drawn at pt would intersect with a triangle.

Parameters:

Name	Type	Description
bmp	`Bitmap`	The bitmap to test
cell	`Integer`	The cell of the bitmap to check
pt	`Point 2d`	The location where the bitmap is drawn
tri	`Triangle`	The triangle to test

Return Type: Boolean

Signatures:

bool bitmap_triangle_collision(bitmap bmp, int cell, const point_2d &pt, const triangle &tri)

public bool Bitmap.TriangleCollision(int cell, Point2D pt, Triangle tri);
public static bool SplashKit.BitmapTriangleCollision(Bitmap bmp, int cell, Point2D pt, Triangle tri);

def bitmap_triangle_collision_for_cell_at_point(bmp, cell, pt, tri):

function BitmapTriangleCollision(bmp: Bitmap; cell: Integer; const pt: Point2D; const tri: Triangle): Boolean

Bitmap Triangle Collision

Tests if a bitmap cell drawn at x, y would intersect with a triangle.

Parameters:

Name	Type	Description
bmp	`Bitmap`	The bitmap to test
cell	`Integer`	The cell of the bitmap to check
x	`Double`	The x location where the bitmap is drawn
y	`Double`	The y location where the bitmap is drawn
tri	`Triangle`	The triangle to test

Return Type: Boolean

Signatures:

bool bitmap_triangle_collision(bitmap bmp, int cell, double x, double y, const triangle &tri)

public bool Bitmap.TriangleCollision(int cell, double x, double y, Triangle tri);
public static bool SplashKit.BitmapTriangleCollision(Bitmap bmp, int cell, double x, double y, Triangle tri);

def bitmap_triangle_collision_for_cell(bmp, cell, x, y, tri):

function BitmapTriangleCollision(bmp: Bitmap; cell: Integer; x: Double; y: Double; const tri: Triangle): Boolean

Calculate Collision Direction

Returns the direction of the collision between a collider quad and a collidee quad relative to the collider quad. If the quads are not colliding, this function will return a zero vector.

Parameters:

Name	Type	Description
collider	`Quad`	The quad that is colliding
collidee	`Quad`	The quad that is being collided with

Return Type: Vector 2d

Signatures:

vector_2d calculate_collision_direction(const quad &collider, const quad &collidee)

public static Vector2D SplashKit.CalculateCollisionDirection(Quad collider, Quad collidee);

def calculate_collision_direction_between_quads(collider, collidee):

function CalculateCollisionDirection(const collider: Quad; const collidee: Quad): Vector2D

Calculate Collision Direction

Returns the direction of the collision between a collider circle and a collidee circle relative to the collider circle. If the circles are not colliding, this function will return a zero vector.

Parameters:

Name	Type	Description
collider	`Circle`	The circle that is colliding
collidee	`Circle`	The circle that is being collided with

Return Type: Vector 2d

Signatures:

vector_2d calculate_collision_direction(const circle &collider, const circle &collidee)

public static Vector2D SplashKit.CalculateCollisionDirection(Circle collider, Circle collidee);

def calculate_collision_direction_between_circles(collider, collidee):

function CalculateCollisionDirection(const collider: Circle; const collidee: Circle): Vector2D

Calculate Collision Direction

Returns the direction of the collision between a circle and a quad relative to the circle. If the circle and quad are not colliding, this function will return a zero vector.

Parameters:

Name	Type	Description
collider	`Circle`	The circle that is colliding
collidee	`Quad`	The quad that is being collided with

Return Type: Vector 2d

Signatures:

vector_2d calculate_collision_direction(const circle &collider, const quad &collidee)

public static Vector2D SplashKit.CalculateCollisionDirection(Circle collider, Quad collidee);

def calculate_collision_direction_between_circle_and_quad(collider, collidee):

function CalculateCollisionDirection(const collider: Circle; const collidee: Quad): Vector2D

Calculate Collision Direction

Returns the direction of the collision between a circle and a rectangle relative to the circle. If the circle and rectangle are not colliding, this function will return a zero vector.

Parameters:

Name	Type	Description
collider	`Circle`	The circle that is colliding
collidee	`Rectangle`	The rectangle that is being collided with

Return Type: Vector 2d

Signatures:

vector_2d calculate_collision_direction(const circle &collider, const rectangle &collidee)

public static Vector2D SplashKit.CalculateCollisionDirection(Circle collider, Rectangle collidee);

def calculate_collision_direction_between_circle_and_rectangle(collider, collidee):

function CalculateCollisionDirection(const collider: Circle; const collidee: Rectangle): Vector2D

Calculate Collision Direction

Returns the direction of the collision between a circle and a sprite relative to the circle. If the circle and sprite are not colliding, this function will return a zero vector.

Parameters:

Name	Type	Description
collider	`Circle`	The circle that is colliding
collidee	`Sprite`	The sprite that is being collided with

Return Type: Vector 2d

Signatures:

vector_2d calculate_collision_direction(const circle &collider, const sprite collidee)

public static Vector2D SplashKit.CalculateCollisionDirection(Circle collider, Sprite collidee);

def calculate_collision_direction_between_circle_and_sprite(collider, collidee):

function CalculateCollisionDirection(const collider: Circle; collidee: Sprite): Vector2D

Calculate Collision Direction

Returns the direction of the collision between a circle and a triangle relative to the circle. If the circle and triangle are not colliding, this function will return a zero vector.

Parameters:

Name	Type	Description
collider	`Circle`	The circle that is colliding
collidee	`Triangle`	The triangle that is being collided with

Return Type: Vector 2d

Signatures:

vector_2d calculate_collision_direction(const circle &collider, const triangle &collidee)

public static Vector2D SplashKit.CalculateCollisionDirection(Circle collider, Triangle collidee);

def calculate_collision_direction_between_circle_and_triangle(collider, collidee):

function CalculateCollisionDirection(const collider: Circle; const collidee: Triangle): Vector2D

Calculate Collision Direction

Returns the direction of the collision between a quad and a circle relative to the quad. If the quad and circle are not colliding, this function will return a zero vector.

Parameters:

Name	Type	Description
collider	`Quad`	The quad that is colliding
collidee	`Circle`	The circle that is being collided with

Return Type: Vector 2d

Signatures:

vector_2d calculate_collision_direction(const quad &collider, const circle &collidee)

public static Vector2D SplashKit.CalculateCollisionDirection(Quad collider, Circle collidee);

def calculate_collision_direction_between_quad_and_circle(collider, collidee):

function CalculateCollisionDirection(const collider: Quad; const collidee: Circle): Vector2D

Calculate Collision Direction

Returns the direction of the collision between a quad and a rectangle relative to the quad. If the quad and rectangle are not colliding, this function will return a zero vector.

Parameters:

Name	Type	Description
collider	`Quad`	The quad that is colliding
collidee	`Rectangle`	The rectangle that is being collided with

Return Type: Vector 2d

Signatures:

vector_2d calculate_collision_direction(const quad &collider, const rectangle &collidee)

public static Vector2D SplashKit.CalculateCollisionDirection(Quad collider, Rectangle collidee);

def calculate_collision_direction_between_quad_and_rectangle(collider, collidee):

function CalculateCollisionDirection(const collider: Quad; const collidee: Rectangle): Vector2D

Calculate Collision Direction

Returns the direction of the collision between a quad and a sprite relative to the quad. If the quad and sprite are not colliding, this function will return a zero vector.

Parameters:

Name	Type	Description
collider	`Quad`	The quad that is colliding
collidee	`Sprite`	The sprite that is being collided with

Return Type: Vector 2d

Signatures:

vector_2d calculate_collision_direction(const quad &collider, const sprite collidee)

public static Vector2D SplashKit.CalculateCollisionDirection(Quad collider, Sprite collidee);

def calculate_collision_direction_between_quad_and_sprite(collider, collidee):

function CalculateCollisionDirection(const collider: Quad; collidee: Sprite): Vector2D

Calculate Collision Direction

Returns the direction of the collision between a quad and a triangle relative to the quad. If the quad and triangle are not colliding, this function will return a zero vector.

Parameters:

Name	Type	Description
collider	`Quad`	The quad that is colliding
collidee	`Triangle`	The triangle that is being collided with

Return Type: Vector 2d

Signatures:

vector_2d calculate_collision_direction(const quad &collider, const triangle &collidee)

public static Vector2D SplashKit.CalculateCollisionDirection(Quad collider, Triangle collidee);

def calculate_collision_direction_between_quad_and_triangle(collider, collidee):

function CalculateCollisionDirection(const collider: Quad; const collidee: Triangle): Vector2D

Calculate Collision Direction

Returns the direction of the collision between a rectangle and a circle relative to the rectangle. If the rectangle and sprite are not colliding, this function will return a zero vector.

Parameters:

Name	Type	Description
collider	`Rectangle`	The rectangle that is colliding
collidee	`Circle`	The circle that is being collided with

Return Type: Vector 2d

Signatures:

vector_2d calculate_collision_direction(const rectangle &collider, const circle &collidee)

public static Vector2D SplashKit.CalculateCollisionDirection(Rectangle collider, Circle collidee);

def calculate_collision_direction_between_rectangle_and_circle(collider, collidee):

function CalculateCollisionDirection(const collider: Rectangle; const collidee: Circle): Vector2D

Calculate Collision Direction

Returns the direction of the collision between a rectangle and a quad relative to the rectangle. If the rectangle and sprite are not colliding, this function will return a zero vector.

Parameters:

Name	Type	Description
collider	`Rectangle`	The rectangle that is colliding
collidee	`Quad`	The quad that is being collided with

Return Type: Vector 2d

Signatures:

vector_2d calculate_collision_direction(const rectangle &collider, const quad &collidee)

public static Vector2D SplashKit.CalculateCollisionDirection(Rectangle collider, Quad collidee);

def calculate_collision_direction_between_rectangle_and_quad(collider, collidee):

function CalculateCollisionDirection(const collider: Rectangle; const collidee: Quad): Vector2D

Returns the direction of the collision between a collider rectangle and a collidee rectangle relative to the collider rectangle. If the rectangles are not colliding, this function will return a zero vector.

Parameters:

Name	Type	Description
collider	`Rectangle`	The rectangle that is colliding
collidee	`Rectangle`	The rectangle that is being collided with

Return Type: Vector 2d

Signatures:

vector_2d calculate_collision_direction(const rectangle &collider, const rectangle &collidee)

public static Vector2D SplashKit.CalculateCollisionDirection(Rectangle collider, Rectangle collidee);

def calculate_collision_direction_between_rectangles(collider, collidee):

function CalculateCollisionDirection(const collider: Rectangle; const collidee: Rectangle): Vector2D

Calculate Collision Direction

Returns the direction of the collision between a rectangle and a sprite relative to the rectangle. If the rectangle and sprite are not colliding, this function will return a zero vector.

Parameters:

Name	Type	Description
collider	`Rectangle`	The rectangle that is colliding
collidee	`Sprite`	The sprite that is being collided with

Return Type: Vector 2d

Signatures:

vector_2d calculate_collision_direction(const rectangle &collider, const sprite collidee)

public static Vector2D SplashKit.CalculateCollisionDirection(Rectangle collider, Sprite collidee);

def calculate_collision_direction_between_rectangle_and_sprite(collider, collidee):

function CalculateCollisionDirection(const collider: Rectangle; collidee: Sprite): Vector2D

Calculate Collision Direction

Returns the direction of the collision between a rectangle and a triangle relative to the rectangle. If the rectangle and sprite are not colliding, this function will return a zero vector.

Parameters:

Name	Type	Description
collider	`Rectangle`	The rectangle that is colliding
collidee	`Triangle`	The triangle that is being collided with

Return Type: Vector 2d

Signatures:

vector_2d calculate_collision_direction(const rectangle &collider, const triangle &collidee)

public static Vector2D SplashKit.CalculateCollisionDirection(Rectangle collider, Triangle collidee);

def calculate_collision_direction_between_rectangle_and_triangle(collider, collidee):

function CalculateCollisionDirection(const collider: Rectangle; const collidee: Triangle): Vector2D

Calculate Collision Direction

Returns the direction of the collision between a sprite and a circle relative to the sprite. If the sprite and circle are not colliding, this function will return a zero vector.

Parameters:

Name	Type	Description
collider	`Sprite`	The sprite that is colliding
collidee	`Circle`	The circle that is being collided with

Return Type: Vector 2d

Signatures:

vector_2d calculate_collision_direction(const sprite collider, const circle &collidee)

public static Vector2D SplashKit.CalculateCollisionDirection(Sprite collider, Circle collidee);

def calculate_collision_direction_between_sprite_and_circle(collider, collidee):

function CalculateCollisionDirection(collider: Sprite; const collidee: Circle): Vector2D

Calculate Collision Direction

Returns the direction of the collision between a sprite and a quad relative to the sprite. If the sprite and quad are not colliding, this function will return a zero vector.

Parameters:

Name	Type	Description
collider	`Sprite`	The sprite that is colliding
collidee	`Quad`	The quad that is being collided with

Return Type: Vector 2d

Signatures:

vector_2d calculate_collision_direction(const sprite collider, const quad &collidee)

public static Vector2D SplashKit.CalculateCollisionDirection(Sprite collider, Quad collidee);

def calculate_collision_direction_between_sprite_and_quad(collider, collidee):

function CalculateCollisionDirection(collider: Sprite; const collidee: Quad): Vector2D

Calculate Collision Direction

Returns the direction of the collision between a sprite and a rectangle relative to the sprite. If the sprite and rectangle are not colliding, this function will return a zero vector.

Parameters:

Name	Type	Description
collider	`Sprite`	The sprite that is colliding
collidee	`Rectangle`	The rectangle that is being collided with

Return Type: Vector 2d

Signatures:

vector_2d calculate_collision_direction(const sprite collider, const rectangle &collidee)

public static Vector2D SplashKit.CalculateCollisionDirection(Sprite collider, Rectangle collidee);

def calculate_collision_direction_between_sprite_and_rectangle(collider, collidee):

function CalculateCollisionDirection(collider: Sprite; const collidee: Rectangle): Vector2D

Calculate Collision Direction

Returns the direction of the collision between two sprites relative to the collider sprite. If the sprites are not colliding, this function will return a zero vector.

Parameters:

Name	Type	Description
collider	`Sprite`	The sprite that is colliding
collidee	`Sprite`	The sprite that is being collided with

Return Type: Vector 2d

Signatures:

vector_2d calculate_collision_direction(const sprite collider, const sprite collidee)

public static Vector2D SplashKit.CalculateCollisionDirection(Sprite collider, Sprite collidee);

def calculate_collision_direction_between_sprites(collider, collidee):

function CalculateCollisionDirection(collider: Sprite; collidee: Sprite): Vector2D

Calculate Collision Direction

Returns the direction of the collision between a sprite and a triangle relative to the sprite. If the sprite and triangle are not colliding, this function will return a zero vector.

Parameters:

Name	Type	Description
collider	`Sprite`	The sprite that is colliding
collidee	`Triangle`	The triangle that is being collided with

Return Type: Vector 2d

Signatures:

vector_2d calculate_collision_direction(const sprite collider, const triangle &collidee)

public static Vector2D SplashKit.CalculateCollisionDirection(Sprite collider, Triangle collidee);

def calculate_collision_direction_between_sprite_and_triangle(collider, collidee):

function CalculateCollisionDirection(collider: Sprite; const collidee: Triangle): Vector2D

Calculate Collision Direction

Returns the direction of the collision between a triangle and a circle relative to the triangle. If the triangle and circle are not colliding, this function will return a zero vector.

Parameters:

Name	Type	Description
collider	`Triangle`	The triangle that is colliding
collidee	`Circle`	The circle that is being collided with

Return Type: Vector 2d

Signatures:

vector_2d calculate_collision_direction(const triangle &collider, const circle &collidee)

public static Vector2D SplashKit.CalculateCollisionDirection(Triangle collider, Circle collidee);

def calculate_collision_direction_between_triangle_and_circle(collider, collidee):

function CalculateCollisionDirection(const collider: Triangle; const collidee: Circle): Vector2D

Calculate Collision Direction

Returns the direction of the collision between a triangle and a quad relative to the triangle. If the triangle and quad are not colliding, this function will return a zero vector.

Parameters:

Name	Type	Description
collider	`Triangle`	The triangle that is colliding
collidee	`Quad`	The quad that is being collided with

Return Type: Vector 2d

Signatures:

vector_2d calculate_collision_direction(const triangle &collider, const quad &collidee)

public static Vector2D SplashKit.CalculateCollisionDirection(Triangle collider, Quad collidee);

def calculate_collision_direction_between_triangle_and_quad(collider, collidee):

function CalculateCollisionDirection(const collider: Triangle; const collidee: Quad): Vector2D

Calculate Collision Direction

Returns the direction of the collision between a triangle and a rectangle relative to the triangle. If the triangle and rectangle are not colliding, this function will return a zero vector.

Parameters:

Name	Type	Description
collider	`Triangle`	The triangle that is colliding
collidee	`Rectangle`	The rectangle that is being collided with

Return Type: Vector 2d

Signatures:

vector_2d calculate_collision_direction(const triangle &collider, const rectangle &collidee)

public static Vector2D SplashKit.CalculateCollisionDirection(Triangle collider, Rectangle collidee);

def calculate_collision_direction_between_triangle_and_rectangle(collider, collidee):

function CalculateCollisionDirection(const collider: Triangle; const collidee: Rectangle): Vector2D

Calculate Collision Direction

Returns the direction of the collision between a triangle and a sprite relative to the triangle. If the triangle and sprite are not colliding, this function will return a zero vector.

Parameters:

Name	Type	Description
collider	`Triangle`	The triangle that is colliding
collidee	`Sprite`	The sprite that is being collided with

Return Type: Vector 2d

Signatures:

vector_2d calculate_collision_direction(const triangle &collider, const sprite collidee)

public static Vector2D SplashKit.CalculateCollisionDirection(Triangle collider, Sprite collidee);

def calculate_collision_direction_between_triangle_and_sprite(collider, collidee):

function CalculateCollisionDirection(const collider: Triangle; collidee: Sprite): Vector2D

Calculate Collision Direction

Returns the direction of the collision between a collider triangle and a collidee triangle relative to the collider triangle. If the triangles are not colliding, this function will return a zero vector.

Parameters:

Name	Type	Description
collider	`Triangle`	The triangle that is colliding
collidee	`Triangle`	The triangle that is being collided with

Return Type: Vector 2d

Signatures:

vector_2d calculate_collision_direction(const triangle &collider, const triangle &collidee)

public static Vector2D SplashKit.CalculateCollisionDirection(Triangle collider, Triangle collidee);

def calculate_collision_direction_between_triangles(collider, collidee):

function CalculateCollisionDirection(const collider: Triangle; const collidee: Triangle): Vector2D

Resolve Collision

Resolves the collision between a collider quad and a collidee quad by moving the collider quad to the edge of the collidee quad. The direction of the resolution is determined by the direction parameter. If the quads are not colliding, this function will return false.

Parameters:

Name	Type	Description
collider	`Quad`	The quad which will be altered if there is a collision
collidee	`Quad`	The quad which will not be altered
direction	`Vector 2d`	The direction of the collision relative to the collider quad, expressed as a vector. If a zero vector is passed, the function will not resolve the collision.

Return Type: Boolean

Signatures:

bool resolve_collision(quad &collider, const quad &collidee, const vector_2d &direction)

public static bool SplashKit.ResolveCollision(ref Quad collider, Quad collidee, Vector2D direction);

def resolve_collision_between_quads(collider, collidee, direction):

function ResolveCollision(var collider: Quad; const collidee: Quad; const direction: Vector2D): Boolean

Resolve Collision

Resolves the collision between a collider circle and a collidee circle by moving the collider circle to the edge of the collidee circle. The direction of the resolution is determined by the direction parameter. If the circles are not colliding, this function will return false.

Parameters:

Name	Type	Description
collider	`Circle`	The circle which will be altered if there is a collision
collidee	`Circle`	The circle which will not be altered
direction	`Vector 2d`	The direction of the collision relative to the collider circle, expressed as a vector. If a zero vector is passed, the function will not resolve the collision.

Return Type: Boolean

Signatures:

bool resolve_collision(circle &collider, const circle &collidee, const vector_2d &direction)

public static bool SplashKit.ResolveCollision(ref Circle collider, Circle collidee, Vector2D direction);

def resolve_collision_between_circles(collider, collidee, direction):

function ResolveCollision(var collider: Circle; const collidee: Circle; const direction: Vector2D): Boolean

Resolve Collision

Resolves the collision between a circle and a quad by moving the circle to the edge of the quad. The direction of the resolution is determined by the direction parameter. If the circle and quad are not colliding, this function will return false.

Parameters:

Name	Type	Description
collider	`Circle`	The circle which will be altered if there is a collision
collidee	`Quad`	The quad which will not be altered
direction	`Vector 2d`	The direction of the collision relative to the circle, expressed as a vector. If a zero vector is passed, the function will not resolve the collision.

Return Type: Boolean

Signatures:

bool resolve_collision(circle &collider, const quad &collidee, const vector_2d &direction)

public static bool SplashKit.ResolveCollision(ref Circle collider, Quad collidee, Vector2D direction);

def resolve_collision_between_circle_and_quad(collider, collidee, direction):

function ResolveCollision(var collider: Circle; const collidee: Quad; const direction: Vector2D): Boolean

Resolve Collision

Resolves the collision between a circle and a rectangle by moving the circle to the edge of the rectangle. The direction of the resolution is determined by the direction parameter. If the circle and rectangle are not colliding, this function will return false.

Parameters:

Name	Type	Description
collider	`Circle`	The circle which will be altered if there is a collision
collidee	`Rectangle`	The rectangle which will not be altered
direction	`Vector 2d`	The direction of the collision relative to the circle, expressed as a vector. If a zero vector is passed, the function will not resolve the collision.

Return Type: Boolean

Signatures:

bool resolve_collision(circle &collider, const rectangle &collidee, const vector_2d &direction)

public static bool SplashKit.ResolveCollision(ref Circle collider, Rectangle collidee, Vector2D direction);

def resolve_collision_between_circle_and_rectangle(collider, collidee, direction):

function ResolveCollision(var collider: Circle; const collidee: Rectangle; const direction: Vector2D): Boolean

Resolve Collision

Resolves the collision between a circle and a sprite by moving the circle to the edge of the sprite. The direction of the resolution is determined by the direction parameter. If the circle and sprite are not colliding, this function will return false.

Parameters:

Name	Type	Description
collider	`Circle`	The circle which will be altered if there is a collision
collidee	`Sprite`	The sprite which will not be altered
direction	`Vector 2d`	The direction of the collision relative to the circle, expressed as a vector. If a zero vector is passed, the function will not resolve the collision.

Return Type: Boolean

Signatures:

bool resolve_collision(circle &collider, const sprite collidee, const vector_2d &direction)

public static bool SplashKit.ResolveCollision(ref Circle collider, Sprite collidee, Vector2D direction);

def resolve_collision_between_circle_and_sprite(collider, collidee, direction):

function ResolveCollision(var collider: Circle; collidee: Sprite; const direction: Vector2D): Boolean

Resolve Collision

Resolves the collision between a circle and a triangle by moving the circle to the edge of the triangle. The direction of the resolution is determined by the direction parameter. If the circle and triangle are not colliding, this function will return false.

Parameters:

Name	Type	Description
collider	`Circle`	The circle which will be altered if there is a collision
collidee	`Triangle`	The triangle which will not be altered
direction	`Vector 2d`	The direction of the collision relative to the circle, expressed as a vector. If a zero vector is passed, the function will not resolve the collision.

Return Type: Boolean

Signatures:

bool resolve_collision(circle &collider, const triangle &collidee, const vector_2d &direction)

public static bool SplashKit.ResolveCollision(ref Circle collider, Triangle collidee, Vector2D direction);

def resolve_collision_between_circle_and_triangle(collider, collidee, direction):

function ResolveCollision(var collider: Circle; const collidee: Triangle; const direction: Vector2D): Boolean

Resolve Collision

Resolves the collision between a quad and a circle by moving the quad to the edge of the circle. The direction of the resolution is determined by the direction parameter. If the quad and circle are not colliding, this function will return false.

Parameters:

Name	Type	Description
collider	`Quad`	The quad which will be altered if there is a collision
collidee	`Circle`	The circle which will not be altered
direction	`Vector 2d`	The direction of the collision relative to the quad, expressed as a vector. If a zero vector is passed, the function will not resolve the collision.

Return Type: Boolean

Signatures:

bool resolve_collision(quad &collider, const circle &collidee, const vector_2d &direction)

public static bool SplashKit.ResolveCollision(ref Quad collider, Circle collidee, Vector2D direction);

def resolve_collision_between_quad_and_circle(collider, collidee, direction):

function ResolveCollision(var collider: Quad; const collidee: Circle; const direction: Vector2D): Boolean

Resolve Collision

Resolves the collision between a quad and a rectangle by moving the quad to the edge of the rectangle. The direction of the resolution is determined by the direction parameter. If the quad and rectangle are not colliding, this function will return false.

Parameters:

Name	Type	Description
collider	`Quad`	The quad which will be altered if there is a collision
collidee	`Rectangle`	The rectangle which will not be altered
direction	`Vector 2d`	The direction of the collision relative to the quad, expressed as a vector. If a zero vector is passed, the function will not resolve the collision.

Return Type: Boolean

Signatures:

bool resolve_collision(quad &collider, const rectangle &collidee, const vector_2d &direction)

public static bool SplashKit.ResolveCollision(ref Quad collider, Rectangle collidee, Vector2D direction);

def resolve_collision_between_quad_and_rectangle(collider, collidee, direction):

function ResolveCollision(var collider: Quad; const collidee: Rectangle; const direction: Vector2D): Boolean

Resolve Collision

Resolves the collision between a quad and a sprite by moving the quad to the edge of the sprite. The direction of the resolution is determined by the direction parameter. If the quad and sprite are not colliding, this function will return false.

Parameters:

Name	Type	Description
collider	`Quad`	The quad which will be altered if there is a collision
collidee	`Sprite`	The sprite which will not be altered
direction	`Vector 2d`	The direction of the collision relative to the quad, expressed as a vector. If a zero vector is passed, the function will not resolve the collision.

Return Type: Boolean

Signatures:

bool resolve_collision(quad &collider, const sprite collidee, const vector_2d &direction)

public static bool SplashKit.ResolveCollision(ref Quad collider, Sprite collidee, Vector2D direction);

def resolve_collision_between_quad_and_sprite(collider, collidee, direction):

function ResolveCollision(var collider: Quad; collidee: Sprite; const direction: Vector2D): Boolean

Resolve Collision

Resolves the collision between a quad and a triangle by moving the quad to the edge of the triangle. The direction of the resolution is determined by the direction parameter. If the quad and triangle are not colliding, this function will return false.

Parameters:

Name	Type	Description
collider	`Quad`	The quad which will be altered if there is a collision
collidee	`Triangle`	The triangle which will not be altered
direction	`Vector 2d`	The direction of the collision relative to the quad, expressed as a vector. If a zero vector is passed, the function will not resolve the collision.

Return Type: Boolean

Signatures:

bool resolve_collision(quad &collider, const triangle &collidee, const vector_2d &direction)

public static bool SplashKit.ResolveCollision(ref Quad collider, Triangle collidee, Vector2D direction);

def resolve_collision_between_quad_and_triangle(collider, collidee, direction):

function ResolveCollision(var collider: Quad; const collidee: Triangle; const direction: Vector2D): Boolean

Resolve Collision

Resolves the collision between a rectangle and a circle by moving the rectangle to the edge of the circle. The direction of the resolution is determined by the direction parameter. If the rectangle and circle are not colliding, this function will return false.

Parameters:

Name	Type	Description
collider	`Rectangle`	The rectangle which will be altered if there is a collision
collidee	`Circle`	The circle which will not be altered
direction	`Vector 2d`	The direction of the collision relative to the rectangle, expressed as a vector. If a zero vector is passed, the function will not resolve the collision.

Return Type: Boolean

Signatures:

bool resolve_collision(rectangle &collider, const circle &collidee, const vector_2d &direction)

public static bool SplashKit.ResolveCollision(ref Rectangle collider, Circle collidee, Vector2D direction);

def resolve_collision_between_rectangle_and_circle(collider, collidee, direction):

function ResolveCollision(var collider: Rectangle; const collidee: Circle; const direction: Vector2D): Boolean

Resolve Collision

Resolves the collision between a rectangle and a quad by moving the rectangle to the edge of the quad. The direction of the resolution is determined by the direction parameter. If the rectangle and quad are not colliding, this function will return false.

Parameters:

Name	Type	Description
collider	`Rectangle`	The rectangle which will be altered if there is a collision
collidee	`Quad`	The quad which will not be altered
direction	`Vector 2d`	The direction of the collision relative to the rectangle, expressed as a vector. If a zero vector is passed, the function will not resolve the collision.

Return Type: Boolean

Signatures:

bool resolve_collision(rectangle &collider, const quad &collidee, const vector_2d &direction)

public static bool SplashKit.ResolveCollision(ref Rectangle collider, Quad collidee, Vector2D direction);

def resolve_collision_between_rectangle_and_quad(collider, collidee, direction):

function ResolveCollision(var collider: Rectangle; const collidee: Quad; const direction: Vector2D): Boolean

Resolve Collision

Resolves the collision between two rectangles by moving the collider rectangle to the edge of the collidee rectangle. The direction of the resolution is determined by the direction parameter. If the rectangles are not colliding, this function will return false.

Parameters:

Name	Type	Description
collider	`Rectangle`	The rectangle which will be altered if there is a collision
collidee	`Rectangle`	The rectangle which will not be altered
direction	`Vector 2d`	The direction of the collision relative to the collider rectangle, expressed as a vector. If a zero vector is passed, the function will not resolve the collision.

Return Type: Boolean

Signatures:

bool resolve_collision(rectangle &collider, const rectangle &collidee, const vector_2d &direction)

public static bool SplashKit.ResolveCollision(ref Rectangle collider, Rectangle collidee, Vector2D direction);

def resolve_collision_between_rectangles(collider, collidee, direction):

function ResolveCollision(var collider: Rectangle; const collidee: Rectangle; const direction: Vector2D): Boolean

Resolve Collision

Resolves the collision between a rectangle and a sprite by moving the rectangle to the edge of the sprite. The direction of the resolution is determined by the direction parameter. If the rectangle and sprite are not colliding, this function will return false.

Parameters:

Name	Type	Description
collider	`Rectangle`	The rectangle which will be altered if there is a collision
collidee	`Sprite`	The sprite which will not be altered
direction	`Vector 2d`	The direction of the collision relative to the rectangle, expressed as a vector. If a zero vector is passed, the function will not resolve the collision.

Return Type: Boolean

Signatures:

bool resolve_collision(rectangle &collider, const sprite collidee, const vector_2d &direction)

public static bool SplashKit.ResolveCollision(ref Rectangle collider, Sprite collidee, Vector2D direction);

def resolve_collision_between_rectangle_and_sprite(collider, collidee, direction):

function ResolveCollision(var collider: Rectangle; collidee: Sprite; const direction: Vector2D): Boolean

Resolve Collision

Resolves the collision between a rectangle and a triangle by moving the rectangle to the edge of the triangle. The direction of the resolution is determined by the direction parameter. If the rectangle and triangle are not colliding, this function will return false.

Parameters:

Name	Type	Description
collider	`Rectangle`	The rectangle which will be altered if there is a collision
collidee	`Triangle`	The triangle which will not be altered
direction	`Vector 2d`	The direction of the collision relative to the rectangle, expressed as a vector. If a zero vector is passed, the function will not resolve the collision.

Return Type: Boolean

Signatures:

bool resolve_collision(rectangle &collider, const triangle &collidee, const vector_2d &direction)

public static bool SplashKit.ResolveCollision(ref Rectangle collider, Triangle collidee, Vector2D direction);

def resolve_collision_between_rectangle_and_triangle(collider, collidee, direction):

function ResolveCollision(var collider: Rectangle; const collidee: Triangle; const direction: Vector2D): Boolean

Resolve Collision

Resolves the collision between a sprite and a circle by moving the sprite to the edge of the circle. The direction of the resolution is determined by the direction parameter. If the sprite and circle are not colliding, this function will return false.

Parameters:

Name	Type	Description
collider	`Sprite`	The sprite which will be altered if there is a collision
collidee	`Circle`	The circle which will not be altered
direction	`Vector 2d`	The direction of the collision relative to the sprite, expressed as a vector. If a zero vector is passed, the function will not resolve the collision.

Return Type: Boolean

Signatures:

bool resolve_collision(sprite collider, const circle &collidee, const vector_2d &direction)

public static bool SplashKit.ResolveCollision(Sprite collider, Circle collidee, Vector2D direction);

def resolve_collision_between_sprite_and_circle(collider, collidee, direction):

function ResolveCollision(collider: Sprite; const collidee: Circle; const direction: Vector2D): Boolean

Resolve Collision

Resolves the collision between a sprite and a quad by moving the sprite to the edge of the quad. The direction of the resolution is determined by the direction parameter. If the sprite and quad are not colliding, this function will return false.

Parameters:

Name	Type	Description
collider	`Sprite`	The sprite which will be altered if there is a collision
collidee	`Quad`	The quad which will not be altered
direction	`Vector 2d`	The direction of the collision relative to the sprite, expressed as a vector. If a zero vector is passed, the function will not resolve the collision.

Return Type: Boolean

Signatures:

bool resolve_collision(sprite collider, const quad &collidee, const vector_2d &direction)

public static bool SplashKit.ResolveCollision(Sprite collider, Quad collidee, Vector2D direction);

def resolve_collision_between_sprite_and_quad(collider, collidee, direction):

function ResolveCollision(collider: Sprite; const collidee: Quad; const direction: Vector2D): Boolean

Resolve Collision

Resolves the collision between a sprite and a rectangle by moving the sprite to the edge of the rectangle. The direction of the resolution is determined by the direction parameter. If the sprite and rectangle are not colliding, this function will return false.

Parameters:

Name	Type	Description
collider	`Sprite`	The sprite which will be altered if there is a collision
collidee	`Rectangle`	The rectangle which will not be altered
direction	`Vector 2d`	The direction of the collision relative to the sprite, expressed as a vector. If a zero vector is passed, the function will not resolve the collision.

Return Type: Boolean

Signatures:

bool resolve_collision(sprite collider, const rectangle &collidee, const vector_2d &direction)

public static bool SplashKit.ResolveCollision(Sprite collider, Rectangle collidee, Vector2D direction);

def resolve_collision_between_sprite_and_rectangle(collider, collidee, direction):

function ResolveCollision(collider: Sprite; const collidee: Rectangle; const direction: Vector2D): Boolean

Resolve Collision

Resolves the collision between two sprites by moving the collider sprite to the edge of the collidee sprite. The direction of the resolution is determined by the direction parameter. If the sprites are not colliding, this function will return false.

Parameters:

Name	Type	Description
collider	`Sprite`	The sprite which will be altered if there is a collision
collidee	`Sprite`	The sprite which will not be altered
direction	`Vector 2d`	The direction of the collision relative to the collider sprite, expressed as a vector. If a zero vector is passed, the function will not resolve the collision.

Return Type: Boolean

Signatures:

bool resolve_collision(sprite collider, const sprite collidee, const vector_2d &direction)

public static bool SplashKit.ResolveCollision(Sprite collider, Sprite collidee, Vector2D direction);

def resolve_collision_between_sprites(collider, collidee, direction):

function ResolveCollision(collider: Sprite; collidee: Sprite; const direction: Vector2D): Boolean

Resolve Collision

Resolves the collision between a sprite and a triangle by moving the sprite to the edge of the triangle. The direction of the resolution is determined by the direction parameter. If the sprite and triangle are not colliding, this function will return false.

Parameters:

Name	Type	Description
collider	`Sprite`	The sprite which will be altered if there is a collision
collidee	`Triangle`	The triangle which will not be altered
direction	`Vector 2d`	The direction of the collision relative to the sprite, expressed as a vector. If a zero vector is passed, the function will not resolve the collision.

Return Type: Boolean

Signatures:

bool resolve_collision(sprite collider, const triangle &collidee, const vector_2d &direction)

public static bool SplashKit.ResolveCollision(Sprite collider, Triangle collidee, Vector2D direction);

def resolve_collision_between_sprite_and_triangle(collider, collidee, direction):

function ResolveCollision(collider: Sprite; const collidee: Triangle; const direction: Vector2D): Boolean

Resolve Collision

Resolves the collision between a triangle and a circle by moving the triangle to the edge of the circle. The direction of the resolution is determined by the direction parameter. If the triangle and circle are not colliding, this function will return false.

Parameters:

Name	Type	Description
collider	`Triangle`	The triangle which will be altered if there is a collision
collidee	`Circle`	The circle which will not be altered
direction	`Vector 2d`	The direction of the collision relative to the triangle, expressed as a vector. If a zero vector is passed, the function will not resolve the collision.

Return Type: Boolean

Signatures:

bool resolve_collision(triangle &collider, const circle &collidee, const vector_2d &direction)

public static bool SplashKit.ResolveCollision(ref Triangle collider, Circle collidee, Vector2D direction);

def resolve_collision_between_triangle_and_circle(collider, collidee, direction):

function ResolveCollision(var collider: Triangle; const collidee: Circle; const direction: Vector2D): Boolean

Resolve Collision

Resolves the collision between a triangle and a quad by moving the triangle to the edge of the quad. The direction of the resolution is determined by the direction parameter. If the triangle and quad are not colliding, this function will return false.

Parameters:

Name	Type	Description
collider	`Triangle`	The triangle which will be altered if there is a collision
collidee	`Quad`	The quad which will not be altered
direction	`Vector 2d`	The direction of the collision relative to the triangle, expressed as a vector. If a zero vector is passed, the function will not resolve the collision.

Return Type: Boolean

Signatures:

bool resolve_collision(triangle &collider, const quad &collidee, const vector_2d &direction)

public static bool SplashKit.ResolveCollision(ref Triangle collider, Quad collidee, Vector2D direction);

def resolve_collision_between_triangle_and_quad(collider, collidee, direction):

function ResolveCollision(var collider: Triangle; const collidee: Quad; const direction: Vector2D): Boolean

Resolve Collision

Resolves the collision between a triangle and a rectangle by moving the triangle to the edge of the rectangle. The direction of the resolution is determined by the direction parameter. If the triangle and rectangle are not colliding, this function will return false.

Parameters:

Name	Type	Description
collider	`Triangle`	The triangle which will be altered if there is a collision
collidee	`Rectangle`	The rectangle which will not be altered
direction	`Vector 2d`	The direction of the collision relative to the triangle, expressed as a vector. If a zero vector is passed, the function will not resolve the collision.

Return Type: Boolean

Signatures:

bool resolve_collision(triangle &collider, const rectangle &collidee, const vector_2d &direction)

public static bool SplashKit.ResolveCollision(ref Triangle collider, Rectangle collidee, Vector2D direction);

def resolve_collision_between_triangle_and_rectangle(collider, collidee, direction):

function ResolveCollision(var collider: Triangle; const collidee: Rectangle; const direction: Vector2D): Boolean

Resolve Collision

Resolves the collision between a triangle and a sprite by moving the triangle to the edge of the sprite. The direction of the resolution is determined by the direction parameter. If the triangle and sprite are not colliding, this function will return false.

Parameters:

Name	Type	Description
collider	`Triangle`	The triangle which will be altered if there is a collision
collidee	`Sprite`	The sprite which will not be altered
direction	`Vector 2d`	The direction of the collision relative to the triangle, expressed as a vector. If a zero vector is passed, the function will not resolve the collision.

Return Type: Boolean

Signatures:

bool resolve_collision(triangle &collider, const sprite collidee, const vector_2d &direction)

public static bool SplashKit.ResolveCollision(ref Triangle collider, Sprite collidee, Vector2D direction);

def resolve_collision_between_triangle_and_sprite(collider, collidee, direction):

function ResolveCollision(var collider: Triangle; collidee: Sprite; const direction: Vector2D): Boolean

Resolve Collision

Resolves the collision between a collider triangle and a collidee triangle by moving the collider triangle to the edge of the collidee triangle. The direction of the resolution is determined by the direction parameter. If the triangles are not colliding, this function will return false.

Parameters:

Name	Type	Description
collider	`Triangle`	The triangle which will be altered if there is a collision
collidee	`Triangle`	The triangle which will not be altered
direction	`Vector 2d`	The direction of the collision relative to the collider triangle, expressed as a vector. If a zero vector is passed, the function will not resolve the collision.

Return Type: Boolean

Signatures:

bool resolve_collision(triangle &collider, const triangle &collidee, const vector_2d &direction)

public static bool SplashKit.ResolveCollision(ref Triangle collider, Triangle collidee, Vector2D direction);

def resolve_collision_between_triangles(collider, collidee, direction):

function ResolveCollision(var collider: Triangle; const collidee: Triangle; const direction: Vector2D): Boolean

Sprite Bitmap Collision

Tests if a sprite will collide with a bitmap drawn at the indicated location.

Parameters:

Name	Type	Description
s	`Sprite`	The sprite to test
bmp	`Bitmap`	The bitmap to test
x	`Double`	The x location where the bitmap is drawn
y	`Double`	The y location where the bitmap is drawn

Return Type: Boolean

Signatures:

bool sprite_bitmap_collision(sprite s, bitmap bmp, double x, double y)

public bool Sprite.BitmapCollision(Bitmap bmp, double x, double y);
public static bool SplashKit.SpriteBitmapCollision(Sprite s, Bitmap bmp, double x, double y);

def sprite_bitmap_collision(s, bmp, x, y):

function SpriteBitmapCollision(s: Sprite; bmp: Bitmap; x: Double; y: Double): Boolean

Usage:

Example 1: Does SplashKit have bugs?

#include "splashkit.h"

int main()
{
    // Open a new window
    open_window("Bitmap Collisions", 315, 330);

    // Load the bitmaps
    bitmap sk_bmp = load_bitmap("skbox", "skbox.png");
    bitmap file_bmp = load_bitmap("file", "file_image.png");
    bitmap bug_bmp = load_bitmap("bug", "bug_image.png");

    // Create a sprite using the bitmap
    sprite sk_sprite = create_sprite(sk_bmp);

    // Define positions
    point_2d sk_sprite_loc = point_at(50, 50);
    point_2d file_bmp_loc = point_at(20, 20);
    point_2d bug_bmp_loc = point_at(200, 150);

    // Set sprite position
    sprite_set_position(sk_sprite, sk_sprite_loc);

    // Clear the screen and draw all elements
    clear_screen(COLOR_WHITE);
    draw_sprite(sk_sprite);
    draw_bitmap(file_bmp, file_bmp_loc.x, file_bmp_loc.y);
    draw_bitmap(bug_bmp, bug_bmp_loc.x, bug_bmp_loc.y);

    // Check for collisions
    if (sprite_bitmap_collision(sk_sprite, file_bmp, file_bmp_loc.x, file_bmp_loc.y))
        write_line("SplashKit got a new file!");

    if (sprite_bitmap_collision(sk_sprite, file_bmp, bug_bmp_loc.x, bug_bmp_loc.y))
        write_line("SplashKit has bugs!");

    // Refresh the screen and delay before closing
    refresh_screen();
    delay(4000);

    close_all_windows();

    return 0;
}

Top-level Statements
Object-Oriented

using static SplashKitSDK.SplashKit;
using SplashKitSDK;

// Open a new window
OpenWindow("Bitmap Collisions", 315, 330);

// Load the bitmaps
Bitmap skBmp = LoadBitmap("skbox", "skbox.png");
Bitmap fileBmp = LoadBitmap("file", "file_image.png");
Bitmap bugBmp = LoadBitmap("bug", "bug_image.png");

// Create a sprite using the bitmap
Sprite skSprite = CreateSprite(skBmp);

// Define positions
Point2D skSpriteLoc = PointAt(50, 50);
Point2D fileBmpLoc = PointAt(20, 20);
Point2D bugBmpLoc = PointAt(200, 150);

// Set sprite position
SpriteSetPosition(skSprite, skSpriteLoc);

// Clear the screen and draw all elements
ClearScreen(ColorWhite());
DrawSprite(skSprite);
DrawBitmap(fileBmp, fileBmpLoc.X, fileBmpLoc.Y);
DrawBitmap(bugBmp, bugBmpLoc.X, bugBmpLoc.Y);

// Check for collisions
if (SpriteBitmapCollision(skSprite, fileBmp, fileBmpLoc.X, fileBmpLoc.Y))
    WriteLine("SplashKit got a new file!");

if (SpriteBitmapCollision(skSprite, bugBmp, bugBmpLoc.X, bugBmpLoc.Y))
    WriteLine("SplashKit has bugs!");

// Refresh the screen and delay before closing
RefreshScreen();
Delay(4000);

CloseAllWindows();

using SplashKitSDK;

namespace SpriteBitmapCollisionExample
{
    public class Program
    {
        public static void Main()
        {
            // Open a new window
            SplashKit.OpenWindow("Bitmap Collisions", 315, 330);

            // Load the bitmaps
            Bitmap skBmp = SplashKit.LoadBitmap("skbox", "skbox.png");
            Bitmap fileBmp = SplashKit.LoadBitmap("file", "file_image.png");
            Bitmap bugBmp = SplashKit.LoadBitmap("bug", "bug_image.png");

            // Create a sprite using the bitmap
            Sprite skSprite = SplashKit.CreateSprite(skBmp);

            // Define positions
            Point2D skSpriteLoc = new Point2D() { X = 50, Y = 50 };
            Point2D fileBmpLoc = new Point2D() { X = 20, Y = 20 };
            Point2D bugBmpLoc = new Point2D() { X = 200, Y = 150 };

            // Set sprite position
            SplashKit.SpriteSetPosition(skSprite, skSpriteLoc);

            // Clear the screen and draw all elements
            SplashKit.ClearScreen(Color.White);
            SplashKit.DrawSprite(skSprite);
            SplashKit.DrawBitmap(fileBmp, fileBmpLoc.X, fileBmpLoc.Y);
            SplashKit.DrawBitmap(bugBmp, bugBmpLoc.X, bugBmpLoc.Y);

            // Check for collisions
            if (SplashKit.SpriteBitmapCollision(skSprite, fileBmp, fileBmpLoc.X, fileBmpLoc.Y))
                SplashKit.WriteLine("SplashKit got a new file!");

            if (SplashKit.SpriteBitmapCollision(skSprite, bugBmp, bugBmpLoc.X, bugBmpLoc.Y))
                SplashKit.WriteLine("SplashKit has bugs!");

            // Refresh the screen and delay before closing
            SplashKit.RefreshScreen();
            SplashKit.Delay(4000);

            SplashKit.CloseAllWindows();
        }
    }
}

from splashkit import *

# Open a new window
open_window("Bitmap Collisions", 315, 330)

# Load the bitmaps
sk_bmp = load_bitmap("skbox", "skbox.png")
file_bmp = load_bitmap("file", "file_image.png")
bug_bmp = load_bitmap("bug", "bug_image.png")

# Create a sprite using the bitmap
sk_sprite = create_sprite(sk_bmp)

# Define positions
sk_sprite_loc = point_at(50, 50)
file_bmp_loc = point_at(20, 20)
bug_bmp_loc = point_at(200, 150)

# Set sprite position
sprite_set_position(sk_sprite, sk_sprite_loc)

# Clear the screen and draw all elements
clear_screen(color_white())
draw_sprite(sk_sprite)
draw_bitmap(file_bmp, file_bmp_loc.x, file_bmp_loc.y)
draw_bitmap(bug_bmp, bug_bmp_loc.x, bug_bmp_loc.y)

# Check for collisions
if sprite_bitmap_collision(sk_sprite, file_bmp, file_bmp_loc.x, file_bmp_loc.y):
    write_line("SplashKit got a new file!")

if sprite_bitmap_collision(sk_sprite, bug_bmp, bug_bmp_loc.x, bug_bmp_loc.y):
    write_line("SplashKit has bugs!")

# Refresh the screen and delay before closing
refresh_screen()
delay(4000)

close_all_windows()

Output:

sprite_bitmap_collision-1-example example

Sprite Bitmap Collision

Tests if a sprite will collide with a bitmap drawn at the indicated location.

Parameters:

Name	Type	Description
s	`Sprite`	The sprite to test
bmp	`Bitmap`	The bitmap to test
cell	`Integer`	The cell of the bitmap to check
pt	`Point 2d`	The point where the bitmap is drawn

Return Type: Boolean

Signatures:

bool sprite_bitmap_collision(sprite s, bitmap bmp, int cell, const point_2d &pt)

public bool Sprite.BitmapCollision(Bitmap bmp, int cell, Point2D pt);
public static bool SplashKit.SpriteBitmapCollision(Sprite s, Bitmap bmp, int cell, Point2D pt);

def sprite_bitmap_collision_with_cell_at_point(s, bmp, cell, pt):

function SpriteBitmapCollision(s: Sprite; bmp: Bitmap; cell: Integer; const pt: Point2D): Boolean

Sprite Bitmap Collision

Tests if a sprite will collide with a bitmap drawn at the indicated location.

Parameters:

Name	Type	Description
s	`Sprite`	The sprite to test
bmp	`Bitmap`	The bitmap to test
cell	`Integer`	The cell of the bitmap to check
x	`Double`	The x location where the bitmap is drawn
y	`Double`	The y location where the bitmap is drawn

Return Type: Boolean

Signatures:

bool sprite_bitmap_collision(sprite s, bitmap bmp, int cell, double x, double y)

public bool Sprite.BitmapCollision(Bitmap bmp, int cell, double x, double y);
public static bool SplashKit.SpriteBitmapCollision(Sprite s, Bitmap bmp, int cell, double x, double y);

def sprite_bitmap_collision_with_cell(s, bmp, cell, x, y):

function SpriteBitmapCollision(s: Sprite; bmp: Bitmap; cell: Integer; x: Double; y: Double): Boolean

Sprite Circle Collision

Tests if a sprite is drawn within an given area (circle).

Parameters:

Name	Type	Description
s	`Sprite`	The sprite to test
c	`Circle`	The circle to check

Return Type: Boolean

Signatures:

bool sprite_circle_collision(sprite s, const circle &c)

public bool Sprite.CircleCollision(Circle c);
public static bool SplashKit.SpriteCircleCollision(Sprite s, Circle c);

def sprite_circle_collision(s, c):

function SpriteCircleCollision(s: Sprite; const c: Circle): Boolean

Sprite Collision

Tests if two given sprites s1 and s2 are collided

Parameters:

Name	Type	Description
s1	`Sprite`	the first `Sprite` to test
s2	`Sprite`	the second `Sprite` to test

Return Type: Boolean

Signatures:

bool sprite_collision(sprite s1, sprite s2)

public bool Sprite.SpriteCollision(Sprite s2);
public static bool SplashKit.SpriteCollision(Sprite s1, Sprite s2);

def sprite_collision(s1, s2):

function SpriteCollision(s1: Sprite; s2: Sprite): Boolean

Usage:

Example 1: Colliding Sprites

#include "splashkit.h"

int main()
{
    // Open a new window
    open_window("Bitmap Collisions", 315, 330);

    // Load the bitmaps
    bitmap sk_bmp = load_bitmap("skbox", "skbox.png");
    bitmap file_bmp = load_bitmap("file", "file_image.png");
    bitmap bug_bmp = load_bitmap("bug", "bug_image.png");

    // Create sprites from the bitmaps
    sprite sk_sprite = create_sprite(sk_bmp);
    sprite file_sprite = create_sprite(file_bmp);
    sprite bug_sprite = create_sprite(bug_bmp);

    // Define sprite positions
    point_2d sk_sprite_loc = point_at(50, 50);
    point_2d file_sprite_loc = point_at(20, 20);
    point_2d bug_sprite_loc = point_at(200, 150);

    // Set sprite positions
    sprite_set_position(sk_sprite, sk_sprite_loc);
    sprite_set_position(file_sprite, file_sprite_loc);
    sprite_set_position(bug_sprite, bug_sprite_loc);

    // Clear the screen and draw sprites
    clear_screen(COLOR_WHITE);
    draw_sprite(sk_sprite);
    draw_sprite(file_sprite);
    draw_sprite(bug_sprite);

    // Check for collisions
    if (sprite_collision(sk_sprite, file_sprite))
        write_line("SplashKit got a new file!");

    if (sprite_collision(sk_sprite, bug_sprite))
        write_line("SplashKit has bugs!");

    // Refresh the screen and delay before closing
    refresh_screen();
    delay(4000);

    close_all_windows();

    return 0;
}

Top-level Statements
Object-Oriented

using static SplashKitSDK.SplashKit;
using SplashKitSDK;

// Open a new window
OpenWindow("Bitmap Collisions", 315, 330);

// Load the bitmaps
Bitmap skBmp = LoadBitmap("skbox", "skbox.png");
Bitmap fileBmp = LoadBitmap("file", "file_image.png");
Bitmap bugBmp = LoadBitmap("bug", "bug_image.png");

// Create sprites from the bitmaps
Sprite skSprite = CreateSprite(skBmp);
Sprite fileSprite = CreateSprite(fileBmp);
Sprite bugSprite = CreateSprite(bugBmp);

// Define sprite positions
Point2D skSpriteLoc = PointAt(50, 50);
Point2D fileSpriteLoc = PointAt(20, 20);
Point2D bugSpriteLoc = PointAt(200, 150);

// Set sprite positions
SpriteSetPosition(skSprite, skSpriteLoc);
SpriteSetPosition(fileSprite, fileSpriteLoc);
SpriteSetPosition(bugSprite, bugSpriteLoc);

// Clear the screen and draw sprites
ClearScreen(ColorWhite());
DrawSprite(skSprite);
DrawSprite(fileSprite);
DrawSprite(bugSprite);

// Check for collisions
if (SpriteCollision(skSprite, fileSprite))
    WriteLine("SplashKit got a new file!");

if (SpriteCollision(skSprite, bugSprite))
    WriteLine("SplashKit has bugs!");

// Refresh the screen and delay before closing
RefreshScreen();
Delay(4000);

CloseAllWindows();

using SplashKitSDK;

namespace SpriteCollisionExample
{
    public class Program
    {
        public static void Main()
        {
            // Open a new window
            SplashKit.OpenWindow("Bitmap Collisions", 315, 330);

            // Load the bitmaps
            Bitmap skBmp = SplashKit.LoadBitmap("skbox", "skbox.png");
            Bitmap fileBmp = SplashKit.LoadBitmap("file", "file_image.png");
            Bitmap bugBmp = SplashKit.LoadBitmap("bug", "bug_image.png");

            // Create sprites from the bitmaps
            Sprite skSprite = SplashKit.CreateSprite(skBmp);
            Sprite fileSprite = SplashKit.CreateSprite(fileBmp);
            Sprite bugSprite = SplashKit.CreateSprite(bugBmp);

            // Define sprite positions
            Point2D skSpriteLoc = new Point2D() { X = 50, Y = 50 };
            Point2D fileSpriteLoc = new Point2D() { X = 20, Y = 20 };
            Point2D bugSpriteLoc = new Point2D() { X = 200, Y = 150 };

            // Set sprite positions
            SplashKit.SpriteSetPosition(skSprite, skSpriteLoc);
            SplashKit.SpriteSetPosition(fileSprite, fileSpriteLoc);
            SplashKit.SpriteSetPosition(bugSprite, bugSpriteLoc);

            // Clear the screen and draw sprites
            SplashKit.ClearScreen(Color.White);
            SplashKit.DrawSprite(skSprite);
            SplashKit.DrawSprite(fileSprite);
            SplashKit.DrawSprite(bugSprite);

            // Check for collisions
            if (SplashKit.SpriteCollision(skSprite, fileSprite))
                SplashKit.WriteLine("SplashKit got a new file!");

            if (SplashKit.SpriteCollision(skSprite, bugSprite))
                SplashKit.WriteLine("SplashKit has bugs!");

            // Refresh the screen and delay before closing
            SplashKit.RefreshScreen();
            SplashKit.Delay(4000);

            SplashKit.CloseAllWindows();
        }
    }
}

from splashkit import *

# Open a new window
open_window("Bitmap Collisions", 315, 330)

# Load the bitmaps
sk_bmp = load_bitmap("skbox", "skbox.png")
file_bmp = load_bitmap("file", "file_image.png")
bug_bmp = load_bitmap("bug", "bug_image.png")

# Create sprites from the bitmaps
sk_sprite = create_sprite(sk_bmp)
file_sprite = create_sprite(file_bmp)
bug_sprite = create_sprite(bug_bmp)

# Define sprite positions
sk_sprite_loc = point_at(50, 50)
file_sprite_loc = point_at(20, 20)
bug_sprite_loc = point_at(200, 150)

# Set sprite positions
sprite_set_position(sk_sprite, sk_sprite_loc)
sprite_set_position(file_sprite, file_sprite_loc)
sprite_set_position(bug_sprite, bug_sprite_loc)

# Clear the screen and draw sprites
clear_screen(color_white())
draw_sprite(sk_sprite)
draw_sprite(file_sprite)
draw_sprite(bug_sprite)

# Check for collisions
if sprite_collision(sk_sprite, file_sprite):
    write_line("SplashKit got a new file!")

if sprite_collision(sk_sprite, bug_sprite):
    write_line("SplashKit has bugs!")

# Refresh the screen and delay before closing
refresh_screen()
delay(4000)

close_all_windows()

Output:

sprite_collision-1-example example

Sprite Point Collision

Tests if a sprite is drawn at a given point.

Parameters:

Name	Type	Description
s	`Sprite`	The sprite to test
pt	`Point 2d`	The point to check

Return Type: Boolean

Signatures:

bool sprite_point_collision(sprite s, const point_2d &pt)

public bool Sprite.PointCollision(Point2D pt);
public static bool SplashKit.SpritePointCollision(Sprite s, Point2D pt);

def sprite_point_collision(s, pt):

function SpritePointCollision(s: Sprite; const pt: Point2D): Boolean

Usage:

Example 1: Determine Sprite Collisions with Points

#include "splashkit.h"

int main()
{
    // Open a new window
    open_window("Bitmap Collisions", 315, 330);

    // Load the bitmap
    bitmap sk_bmp = load_bitmap("skbox", "skbox.png");

    // Create a sprite using the bitmap
    sprite sk_sprite = create_sprite(sk_bmp);

    // Define sprite and collision point positions
    point_2d sk_sprite_loc = {50, 50};
    point_2d collision_loc_1 = {20, 20};
    point_2d collision_loc_2 = {200, 150};

    // Set sprite position
    sprite_set_position(sk_sprite, sk_sprite_loc);

    // Clear the screen and draw elements
    clear_screen(COLOR_WHITE);
    draw_sprite(sk_sprite);
    fill_circle(COLOR_BLACK, circle_at(collision_loc_1, 2));
    fill_circle(COLOR_RED, circle_at(collision_loc_2, 2));

    // Check for collisions
    if (sprite_point_collision(sk_sprite, collision_loc_1))
        write_line("Black Dot Collision");
    if (sprite_point_collision(sk_sprite, collision_loc_2))
        write_line("Red Dot Collision");

    // Refresh the screen and delay before closing
    refresh_screen();
    delay(4000);

    close_all_windows();

    return 0;
}

Top-level Statements
Object-Oriented

using static SplashKitSDK.SplashKit;
using SplashKitSDK;

// Open a new window
OpenWindow("Bitmap Collisions", 315, 330);

// Load the bitmap
Bitmap skBmp = LoadBitmap("skbox", "skbox.png");

// Create a sprite using the bitmap
Sprite skSprite = CreateSprite(skBmp);

// Define sprite and collision point positions
Point2D skSpriteLoc = PointAt(50, 50);
Point2D collisionLoc1 = PointAt(20, 20);
Point2D collisionLoc2 = PointAt(200, 150);

// Set sprite position
SpriteSetPosition(skSprite, skSpriteLoc);

// Clear the screen and draw elements
ClearScreen(ColorWhite());
DrawSprite(skSprite);
FillCircle(ColorBlack(), CircleAt(collisionLoc1, 2));
FillCircle(ColorRed(), CircleAt(collisionLoc2, 2));

// Check for collisions
if (SpritePointCollision(skSprite, collisionLoc1))
    WriteLine("Black Dot Collision");
if (SpritePointCollision(skSprite, collisionLoc2))
    WriteLine("Red Dot Collision");

// Refresh the screen and delay before closing
RefreshScreen();
Delay(4000);

CloseAllWindows();

using SplashKitSDK;

namespace SpritePointCollisionExample
{
    public class Program
    {
        public static void Main()
        {
            // Open a new window
            SplashKit.OpenWindow("Bitmap Collisions", 315, 330);

            // Load the bitmap
            Bitmap skBmp = SplashKit.LoadBitmap("skbox", "skbox.png");

            // Create a sprite using the bitmap
            Sprite skSprite = SplashKit.CreateSprite(skBmp);

            // Define sprite and collision point positions
            Point2D skSpriteLoc = new Point2D() { X = 50, Y = 50 };
            Point2D collisionLoc1 = new Point2D() { X = 20, Y = 20 };
            Point2D collisionLoc2 = new Point2D() { X = 200, Y = 150 };

            // Set sprite position
            SplashKit.SpriteSetPosition(skSprite, skSpriteLoc);

            // Clear the screen and draw elements
            SplashKit.ClearScreen(Color.White);
            skSprite.Draw();
            SplashKit.FillCircle(Color.Black, SplashKit.CircleAt(collisionLoc1, 2));
            SplashKit.FillCircle(Color.Red, SplashKit.CircleAt(collisionLoc2, 2));

            // Check for collisions
            if (SplashKit.SpritePointCollision(skSprite, collisionLoc1))
                SplashKit.WriteLine("Black Dot Collision");
            if (SplashKit.SpritePointCollision(skSprite, collisionLoc2))
                SplashKit.WriteLine("Red Dot Collision");

            // Refresh the screen and delay before closing
            SplashKit.RefreshScreen();
            SplashKit.Delay(4000);

            SplashKit.CloseAllWindows();
        }
    }
}

from splashkit import *

# Open a new window
open_window("Bitmap Collisions", 315, 330)

# Load the bitmap
sk_bmp = load_bitmap("skbox", "skbox.png")

# Create a sprite using the bitmap
sk_sprite = create_sprite(sk_bmp)

# Define sprite and collision point positions
sk_sprite_loc = point_at(50, 50)
file_sprite_loc = point_at(20, 20)
bug_sprite_loc = point_at(200, 150)

# Set sprite position
sprite_set_position(sk_sprite, sk_sprite_loc)

# Clear the screen and draw elements
clear_screen(color_white())
draw_sprite(sk_sprite)
fill_circle_record(color_black(), circle_at(collision_loc_1, 2))
fill_circle_record(color_red(), circle_at(collision_loc_2, 2))

# Check for collisions
if sprite_point_collision(sk_sprite, collision_loc_1):
    write_line("Black Dot Collision")
if sprite_point_collision(sk_sprite, collision_loc_2):
    write_line("Red Dot Collision")

# Refresh the screen and delay before closing
refresh_screen()
delay(4000)

close_all_windows()

Output:

sprite_point_collision-1-example example

Sprite Quad Collision

Tests if a sprite is drawn within an given area (quad).

Parameters:

Name	Type	Description
s	`Sprite`	The sprite to test
q	`Quad`	The quad to check

Return Type: Boolean

Signatures:

bool sprite_quad_collision(sprite s, const quad &q)

public bool Sprite.QuadCollision(Quad q);
public static bool SplashKit.SpriteQuadCollision(Sprite s, Quad q);

def sprite_quad_collision(s, q):

function SpriteQuadCollision(s: Sprite; const q: Quad): Boolean

Sprite Ray Collision

Tests if a sprite is drawn along a given ray.

Parameters:

Name	Type	Description
s	`Sprite`	The sprite to test
origin	`Point 2d`	The origin of the ray
heading	`Vector 2d`	The heading of the ray

Return Type: Boolean

Signatures:

bool sprite_ray_collision(sprite s, const point_2d &origin, const vector_2d &heading)

public bool Sprite.RayCollision(Point2D origin, Vector2D heading);
public static bool SplashKit.SpriteRayCollision(Sprite s, Point2D origin, Vector2D heading);

def sprite_ray_collision(s, origin, heading):

function SpriteRayCollision(s: Sprite; const origin: Point2D; const heading: Vector2D): Boolean

Sprite Rectangle Collision

Tests if a sprite is drawn within an given area (rectangle).

Parameters:

Name	Type	Description
s	`Sprite`	The sprite to test
rect	`Rectangle`	The rectangle to check

Return Type: Boolean

Signatures:

bool sprite_rectangle_collision(sprite s, const rectangle &rect)

public bool Sprite.RectangleCollision(Rectangle rect);
public static bool SplashKit.SpriteRectangleCollision(Sprite s, Rectangle rect);

def sprite_rectangle_collision(s, rect):

function SpriteRectangleCollision(s: Sprite; const rect: Rectangle): Boolean

Usage:

Example 1: Detect Sprite Collisions with Rectangles

#include "splashkit.h"

int main()
{
    // Open a new window
    open_window("Bitmap Collisions", 315, 330);

    // Load the bitmap
    bitmap sk_bmp = load_bitmap("skbox", "skbox.png");

    // Create a sprite using the bitmap
    sprite sk_sprite = create_sprite(sk_bmp);

    // Define sprite and rectangle positions
    point_2d sk_sprite_loc = {50, 50};
    sprite_set_position(sk_sprite, sk_sprite_loc);

    // Define the first rectangle
    rectangle test_rectangle_1;
    test_rectangle_1.x = 20;
    test_rectangle_1.y = 20;
    test_rectangle_1.width = 20;
    test_rectangle_1.height = 20;

    // Define the second rectangle
    rectangle test_rectangle_2;
    test_rectangle_2.x = 150;
    test_rectangle_2.y = 200;
    test_rectangle_2.width = 20;
    test_rectangle_2.height = 20;

    // Clear the screen and draw elements
    clear_screen(COLOR_WHITE);
    draw_sprite(sk_sprite);
    fill_rectangle(COLOR_BLACK, test_rectangle_1);
    fill_rectangle(COLOR_RED, test_rectangle_2);

    // Check for collisions
    if (sprite_rectangle_collision(sk_sprite, test_rectangle_1))
        write_line("Black Rectangle Collision");
    if (sprite_rectangle_collision(sk_sprite, test_rectangle_2))
        write_line("Red Rectangle Collision");

    // Refresh the screen and delay before closing
    refresh_screen();
    delay(4000);

    close_all_windows();

    return 0;
}

Top-level Statements
Object-Oriented

using static SplashKitSDK.SplashKit;
using SplashKitSDK;

// Open a new window
OpenWindow("Bitmap Collisions", 315, 330);

// Load the bitmap
Bitmap skBmp = LoadBitmap("skbox", "skbox.png");

// Create a sprite using the bitmap
Sprite skSprite = CreateSprite(skBmp);

// Define sprite and rectangle positions
Point2D skSpriteLoc = PointAt(50, 50);
SpriteSetPosition(skSprite, skSpriteLoc);

// Define the rectangles
Rectangle testRectangle1 = RectangleFrom(20, 20, 20, 20);
Rectangle testRectangle2 = RectangleFrom(150, 200, 20, 20);

// Clear the screen and draw elements
ClearScreen(ColorWhite());
DrawSprite(skSprite);
FillRectangle(ColorBlack(), testRectangle1);
FillRectangle(ColorRed(), testRectangle2);

// Check for collisions
if (SpriteRectangleCollision(skSprite, testRectangle1))
    WriteLine("Black Rectangle Collision");
if (SpriteRectangleCollision(skSprite, testRectangle2))
    WriteLine("Red Rectangle Collision");

// Refresh the screen and delay before closing
RefreshScreen();
Delay(4000);

CloseAllWindows();

using SplashKitSDK;

namespace SpriteRectangleCollisionExample
{
    public class Program
    {
        public static void Main()
        {
            // Open a new window
            SplashKit.OpenWindow("Bitmap Collisions", 315, 330);

            // Load the bitmap
            Bitmap skBmp = SplashKit.LoadBitmap("skbox", "skbox.png");

            // Create a sprite using the bitmap
            Sprite skSprite = SplashKit.CreateSprite(skBmp);

            // Define sprite and rectangle positions
            Point2D skSpriteLoc = new Point2D() { X = 50, Y = 50 };
            SplashKit.SpriteSetPosition(skSprite, skSpriteLoc);

            // Define the rectangles
            Rectangle testRectangle1 = new Rectangle() { X = 20, Y = 20, Width = 20, Height = 20 };
            Rectangle testRectangle2 = new Rectangle() { X = 150, Y = 200, Width = 20, Height = 20 };

            // Clear the screen and draw elements
            SplashKit.ClearScreen(SplashKit.ColorWhite());
            SplashKit.DrawSprite(skSprite);
            SplashKit.FillRectangle(SplashKit.ColorBlack(), testRectangle1);
            SplashKit.FillRectangle(SplashKit.ColorRed(), testRectangle2);

            // Check for collisions
            if (SplashKit.SpriteRectangleCollision(skSprite, testRectangle1))
                SplashKit.WriteLine("Black Rectangle Collision");
            if (SplashKit.SpriteRectangleCollision(skSprite, testRectangle2))
                SplashKit.WriteLine("Red Rectangle Collision");

            // Refresh the screen and delay before closing
            SplashKit.RefreshScreen();
            SplashKit.Delay(4000);

            SplashKit.CloseAllWindows();
        }
    }
}

from splashkit import *

# Open a new window
open_window("Bitmap Collisions", 315, 330)

# Load the bitmap
sk_bmp = load_bitmap("skbox", "skbox.png")

# Create a sprite using the bitmap
sk_sprite = create_sprite(sk_bmp)

# Define sprite and rectangle positions
sk_sprite_loc = point_at(50, 50)
sprite_set_position(sk_sprite, sk_sprite_loc)

# Define the first rectangle
test_rectangle_1 = rectangle_from(20, 20, 20, 20)

# Define the second rectangle
test_rectangle_2 = rectangle_from(150, 200, 20, 20)

# Clear the screen and draw elements
clear_screen(color_white())
draw_sprite(sk_sprite)
fill_rectangle_record(color_black(), test_rectangle_1)
fill_rectangle_record(color_red(), test_rectangle_2)

# Check for collisions
if sprite_rectangle_collision(sk_sprite, test_rectangle_1):
    write_line("Black Rectangle Collision")
if sprite_rectangle_collision(sk_sprite, test_rectangle_2):
    write_line("Red Rectangle Collision")

# Refresh the screen and delay before closing
refresh_screen()
delay(4000)

close_all_windows()

Output:

sprite_rectangle_collision-1-example example

Sprite Triangle Collision

Tests if a sprite is drawn within an given area (triangle).

Parameters:

Name	Type	Description
s	`Sprite`	The sprite to test
t	`Triangle`	The triangle to check

Return Type: Boolean

Signatures:

bool sprite_triangle_collision(sprite s, const triangle &t)

public bool Sprite.TriangleCollision(Triangle t);
public static bool SplashKit.SpriteTriangleCollision(Sprite s, Triangle t);

def sprite_triangle_collision(s, t):

function SpriteTriangleCollision(s: Sprite; const t: Triangle): Boolean

Apply Matrix

Use a matrix to transform all of the points in a quad.

Parameters:

Name	Type	Description
matrix	`Matrix 2d`	The matrix with the transformations needed.
q	`Quad`	The quad to transform.

Signatures:

void apply_matrix(const matrix_2d &matrix, quad &q)

public static void SplashKit.ApplyMatrix(Matrix2D matrix, ref Quad q);

def apply_matrix_to_quad(matrix, q):

procedure ApplyMatrix(const matrix: Matrix2D; var q: Quad)

Apply Matrix

Use a matrix to transform all of the points in a triangle.

Parameters:

Name	Type	Description
m	`Matrix 2d`	The matrix to be applied to the triangle.
tri	`Triangle`	The triangle to tranform.

Signatures:

void apply_matrix(const matrix_2d &m, triangle &tri)

public static void SplashKit.ApplyMatrix(Matrix2D m, ref Triangle tri);

def apply_matrix_to_triangle(m, tri):

procedure ApplyMatrix(const m: Matrix2D; var tri: Triangle)

Identity Matrix

Returns the identity matrix. When a matrix_2d or Vector is multiplied by the identity matrix the result is the original matrix or vector.

Return Type: Matrix 2d

Signatures:

matrix_2d identity_matrix()

public static Matrix2D SplashKit.IdentityMatrix();

def identity_matrix():

function IdentityMatrix(): Matrix2D

Matrix Inverse

Calculate the inverse of a matrix.

Parameters:

Name	Type	Description
m	`Matrix 2d`	The matrix to invert.

Return Type: Matrix 2d

Signatures:

matrix_2d matrix_inverse(const matrix_2d &m)

public static Matrix2D SplashKit.MatrixInverse(Matrix2D m);

def matrix_inverse(m):

function MatrixInverse(const m: Matrix2D): Matrix2D

Matrix Multiply

Multiplies the Point 2d parameter v with the [Matrix 2d](/api/physics/#matrix-2d) m and returns the result as a Point 2d. Use this to transform the vector with the matrix (to apply scaling, rotation or translation effects).

Parameters:

Name	Type	Description
m	`Matrix 2d`	The matrix with the transformation to apply.
pt	`Point 2d`	The point to be transformed.

Return Type: Point 2d

Signatures:

point_2d matrix_multiply(const matrix_2d &m, const point_2d &pt)

public static Point2D SplashKit.MatrixMultiply(Matrix2D m, Point2D pt);

def matrix_multiply_point(m, pt):

function MatrixMultiply(const m: Matrix2D; const pt: Point2D): Point2D

Matrix Multiply

Multiplies the two Matrix 2d parameters, m1 by m2, and returns the result as a new Matrix 2d. Use this to combine the effects to two matrix transformations.

Parameters:

Name	Type	Description
m1	`Matrix 2d`	The first matrix
m2	`Matrix 2d`	The second matrix

Return Type: Matrix 2d

Signatures:

matrix_2d matrix_multiply(const matrix_2d &m1, const matrix_2d &m2)

public static Matrix2D SplashKit.MatrixMultiply(Matrix2D m1, Matrix2D m2);

def matrix_multiply_matrix(m1, m2):

function MatrixMultiply(const m1: Matrix2D; const m2: Matrix2D): Matrix2D

Matrix Multiply

Multiplies the Vector parameter v with the Matrix 2d m and returns the result as a Vector. Use this to transform the vector with the matrix (to apply scaling, rotation or translation effects).

Parameters:

Name	Type	Description
m	`Matrix 2d`	The matrix with the transformation to apply.
v	`Vector 2d`	The vector to be transformed.

Return Type: Vector 2d

Signatures:

vector_2d matrix_multiply(const matrix_2d &m, const vector_2d &v)

public static Vector2D SplashKit.MatrixMultiply(Matrix2D m, Vector2D v);

def matrix_multiply_vector(m, v):

function MatrixMultiply(const m: Matrix2D; const v: Vector2D): Vector2D

Matrix To String

This function returns a string representation of a Matrix.

Parameters:

Name	Type	Description
matrix	`Matrix 2d`	The matrix to convert to a string.

Return Type: String

Signatures:

string matrix_to_string(const matrix_2d &matrix)

public static string SplashKit.MatrixToString(Matrix2D matrix);

def matrix_to_string(matrix):

function MatrixToString(const matrix: Matrix2D): String

Rotation Matrix

Returns a rotation matrix that rotates 2d points by the angle.

Parameters:

Name	Type	Description
deg	`Double`	The amount to rotate points

Return Type: Matrix 2d

Signatures:

matrix_2d rotation_matrix(double deg)

public static Matrix2D SplashKit.RotationMatrix(double deg);

def rotation_matrix(deg):

function RotationMatrix(deg: Double): Matrix2D

Scale Matrix

Create a scale matrix that scales x and y to different degrees.

Parameters:

Name	Type	Description
scale	`Point 2d`	The amount to scale, with separate x and y components.

Return Type: Matrix 2d

Signatures:

matrix_2d scale_matrix(const point_2d &scale)

public static Matrix2D SplashKit.ScaleMatrix(Point2D scale);

def scale_matrix_from_point(scale):

function ScaleMatrix(const scale: Point2D): Matrix2D

Scale Matrix

Create a scale matrix that scales x and y to different degrees.

Parameters:

Name	Type	Description
scale	`Vector 2d`	The amount to scale, with separate x and y components.

Return Type: Matrix 2d

Signatures:

matrix_2d scale_matrix(const vector_2d &scale)

public static Matrix2D SplashKit.ScaleMatrix(Vector2D scale);

def scale_matrix_from_vector(scale):

function ScaleMatrix(const scale: Vector2D): Matrix2D

Scale Matrix

Returns a matrix that can be used to scale 2d points (both x and y).

Parameters:

Name	Type	Description
scale	`Double`	The amount to scale points by.

Return Type: Matrix 2d

Signatures:

matrix_2d scale_matrix(double scale)

public static Matrix2D SplashKit.ScaleMatrix(double scale);

def scale_matrix(scale):

function ScaleMatrix(scale: Double): Matrix2D

Scale Rotate Translate Matrix

Create a matrix that can scale, rotate then translate geometry points.

Parameters:

Name	Type	Description
scale	`Point 2d`	The amount to scale
deg	`Double`	The amount to rotate
translate	`Point 2d`	The amount to move

Return Type: Matrix 2d

Signatures:

matrix_2d scale_rotate_translate_matrix(const point_2d &scale, double deg, const point_2d &translate)

public static Matrix2D SplashKit.ScaleRotateTranslateMatrix(Point2D scale, double deg, Point2D translate);

def scale_rotate_translate_matrix(scale, deg, translate):

function ScaleRotateTranslateMatrix(const scale: Point2D; deg: Double; const translate: Point2D): Matrix2D

Translation Matrix

Returns a translation matric used to translate 2d points by the distance in the point_2d.

Parameters:

Name	Type	Description
pt	`Point 2d`	The point to translate to.

Return Type: Matrix 2d

Signatures:

matrix_2d translation_matrix(const point_2d &pt)

public static Matrix2D SplashKit.TranslationMatrix(Point2D pt);

def translation_matrix_to_point(pt):

function TranslationMatrix(const pt: Point2D): Matrix2D

Translation Matrix

Returns a translation matric used to translate 2d points by the distance in the vector_2d.

Parameters:

Name	Type	Description
pt	`Vector 2d`	The point to translate to.

Return Type: Matrix 2d

Signatures:

matrix_2d translation_matrix(const vector_2d &pt)

public static Matrix2D SplashKit.TranslationMatrix(Vector2D pt);

def translation_matrix_from_vector(pt):

function TranslationMatrix(const pt: Vector2D): Matrix2D

Translation Matrix

Returns a matrix that can be used to translate 2d points. Moving them by dx and dy.

Parameters:

Name	Type	Description
dx	`Double`	The amount to move points along the x axis.
dy	`Double`	The amount to move points along the y axis.

Return Type: Matrix 2d

Signatures:

matrix_2d translation_matrix(double dx, double dy)

public static Matrix2D SplashKit.TranslationMatrix(double dx, double dy);

def translation_matrix(dx, dy):

function TranslationMatrix(dx: Double; dy: Double): Matrix2D

Angle Between

Calculates the angle from one vector to another.

Parameters:

Name	Type	Description
v1	`Vector 2d`	The first vector
v2	`Vector 2d`	The second vector

Return Type: Double

Signatures:

double angle_between(const vector_2d &v1, const vector_2d &v2)

public static double SplashKit.AngleBetween(Vector2D v1, Vector2D v2);

def angle_between(v1, v2):

function AngleBetween(const v1: Vector2D; const v2: Vector2D): Double

Usage:

Dot Product

Calculates the dot product (scalar product) between the two vector parameters provided (v1 and v2). It returns the result as a scalar value. If the result is 0.0 it means that the vectors are orthogonal (at right angles to each other). If v1 and v2 are unit vectors (length of 1.0) and the dot product is 1.0, it means that v1 and v2 vectors are parallel.

Parameters:

Name	Type	Description
v1	`Vector 2d`	The first vector
v2	`Vector 2d`	The other vector

Return Type: Double

Signatures:

double dot_product(const vector_2d &v1, const vector_2d &v2)

public static double SplashKit.DotProduct(Vector2D v1, Vector2D v2);

def dot_product(v1, v2):

function DotProduct(const v1: Vector2D; const v2: Vector2D): Double

Usage:

Is Zero Vector

Returns if the vector is a null/zero vector — having no size or direction.

Parameters:

Name	Type	Description
v	`Vector 2d`	The vector

Return Type: Boolean

Signatures:

bool is_zero_vector(const vector_2d &v)

public static bool SplashKit.IsZeroVector(Vector2D v);

def is_zero_vector(v):

function IsZeroVector(const v: Vector2D): Boolean

Ray Intersection Point

Casts a ray in a heading and returns true is it intersects with a line

Parameters:

Name	Type	Description
from_pt	`Point 2d`	The origin of the ray
heading	`Vector 2d`	The direction the ray is heading (as a `Vector 2d`)
l	`Line`	The line to be checked
pt	`Point 2d`	Outputs the point where the line and ray intersect

Return Type: Boolean

Signatures:

bool ray_intersection_point(const point_2d &from_pt, const vector_2d &heading, const line &l, point_2d &pt)

public static bool SplashKit.RayIntersectionPoint(Point2D fromPt, Vector2D heading, Line l, ref Point2D pt);

def ray_intersection_point(from_pt, heading, l, pt):

function RayIntersectionPoint(const fromPt: Point2D; const heading: Vector2D; const l: Line; var pt: Point2D): Boolean

Unit Vector

Returns the unit vector of the parameter vector (v). The unit vector has a magnitude of 1, resulting in a vector that indicates the direction of the original vector.

Parameters:

Name	Type	Description
v	`Vector 2d`	The vector

Return Type: Vector 2d

Signatures:

vector_2d unit_vector(const vector_2d &v)

public static Vector2D SplashKit.UnitVector(Vector2D v);

def unit_vector(v):

function UnitVector(const v: Vector2D): Vector2D

Usage:

Vector Add

Adds the two passed in vectors returns the result as new Vector 2d.

Parameters:

Name	Type	Description
v1	`Vector 2d`	The first vector.
v2	`Vector 2d`	The other vector.

Return Type: Vector 2d

Signatures:

vector_2d vector_add(const vector_2d &v1, const vector_2d &v2)

public static Vector2D SplashKit.VectorAdd(Vector2D v1, Vector2D v2);

def vector_add(v1, v2):

function VectorAdd(const v1: Vector2D; const v2: Vector2D): Vector2D

Usage:

Vector Angle

Calculates the angle of a vector

Parameters:

Name	Type	Description
v	`Vector 2d`	The vector

Return Type: Double

Signatures:

double vector_angle(const vector_2d v)

public static double SplashKit.VectorAngle(Vector2D v);

def vector_angle(v):

function VectorAngle(v: Vector2D): Double

Usage:

Vector From Angle

Returns a Vector 2d from the supplied angle and distance.

Parameters:

Name	Type	Description
angle	`Double`	The angle in degrees
magnitude	`Double`	The length of the vector

Return Type: Vector 2d

Signatures:

vector_2d vector_from_angle(double angle, double magnitude)

public static Vector2D SplashKit.VectorFromAngle(double angle, double magnitude);

def vector_from_angle(angle, magnitude):

function VectorFromAngle(angle: Double; magnitude: Double): Vector2D

Usage:

Vector From Line

Returns a vector that points from the start to the end of a line.

Parameters:

Name	Type	Description
l	`Line`	The line

Return Type: Vector 2d

Signatures:

vector_2d vector_from_line(const line &l)

public static Vector2D SplashKit.VectorFromLine(Line l);

def vector_from_line(l):

function VectorFromLine(const l: Line): Vector2D

Vector From Point To Rect

Returns a vector from a point to a rectangle.

Parameters:

Name	Type	Description
pt	`Point 2d`	The point
rect	`Rectangle`	The rectangle

Return Type: Vector 2d

Signatures:

vector_2d vector_from_point_to_rect(const point_2d &pt, const rectangle &rect)

public static Vector2D SplashKit.VectorFromPointToRect(Point2D pt, Rectangle rect);

def vector_from_point_to_rect(pt, rect):

function VectorFromPointToRect(const pt: Point2D; const rect: Rectangle): Vector2D

Vector In Rect

Returns true if the resulting vector would end in the rectangle if placed at the origin.

Parameters:

Name	Type	Description
v	`Vector 2d`	The vector
rect	`Rectangle`	The rectangle

Return Type: Boolean

Signatures:

bool vector_in_rect(const vector_2d &v, const rectangle &rect)

public static bool SplashKit.VectorInRect(Vector2D v, Rectangle rect);

def vector_in_rect(v, rect):

function VectorInRect(const v: Vector2D; const rect: Rectangle): Boolean

Vector Invert

Returns a new Vector that is an inverted version of the parameter vector (v). In other words, the -/+ sign of the x and y values are changed.

Parameters:

Name	Type	Description
v	`Vector 2d`	The vector

Return Type: Vector 2d

Signatures:

vector_2d vector_invert(const vector_2d &v)

public static Vector2D SplashKit.VectorInvert(Vector2D v);

def vector_invert(v):

function VectorInvert(const v: Vector2D): Vector2D

Usage:

Vector Limit

Returns a scaled vector that ensures the new vector points in the same direction as v, but has a magnitude that is limited to the length specified in the limit prameter.

Parameters:

Name	Type	Description
v	`Vector 2d`	The vector
limit	`Double`	Its maximum magnitude

Return Type: Vector 2d

Signatures:

vector_2d vector_limit(const vector_2d &v, double limit)

public static Vector2D SplashKit.VectorLimit(Vector2D v, double limit);

def vector_limit(v, limit):

function VectorLimit(const v: Vector2D; limit: Double): Vector2D

Vector Magnitude

Returns the magnitude (or “length”) of the vector.

Parameters:

Name	Type	Description
v	`Vector 2d`	The vector

Return Type: Double

Signatures:

double vector_magnitude(const vector_2d &v)

public static double SplashKit.VectorMagnitude(Vector2D v);

def vector_magnitude(v):

function VectorMagnitude(const v: Vector2D): Double

Usage:

Vector Magnitude Squared

Returns the squared magnitude (or “length”) of the vector.

Parameters:

Name	Type	Description
v	`Vector 2d`	The vector

Return Type: Double

Signatures:

double vector_magnitude_squared(const vector_2d &v)

public static double SplashKit.VectorMagnitudeSquared(Vector2D v);

def vector_magnitude_squared(v):

function VectorMagnitudeSquared(const v: Vector2D): Double

Usage:

Vector Multiply

Multiplies the vector by the passed in value.

Parameters:

Name	Type	Description
v1	`Vector 2d`	The original vector
s	`Double`	The amount to multiply by

Return Type: Vector 2d

Signatures:

vector_2d vector_multiply(const vector_2d &v1, double s)

public static Vector2D SplashKit.VectorMultiply(Vector2D v1, double s);

def vector_multiply(v1, s):

function VectorMultiply(const v1: Vector2D; s: Double): Vector2D

Usage:

Vector Normal

Returns a new Vector 2d that is perpendicular (“normal”) to the parameter vector v provided. The concept of a “normal” vector is usually extracted from (or associated with) a line. Note: when passed a zero or null vector (a vector with no magnitude or direction) then this function returns a zero/null vector.

Parameters:

Name	Type	Description
v	`Vector 2d`	The vector

Return Type: Vector 2d

Signatures:

vector_2d vector_normal(const vector_2d &v)

public static Vector2D SplashKit.VectorNormal(Vector2D v);

def vector_normal(v):

function VectorNormal(const v: Vector2D): Vector2D

Usage:

Vector Out Of Circle From Circle

Returns a vector to back one circle out of another, assuming the first circle was moving at a specified velocity.

Parameters:

Name	Type	Description
src	`Circle`	The circle that is moving
bounds	`Circle`	The area you want to move the circle out of
velocity	`Vector 2d`	The circle’s velocity

Return Type: Vector 2d

Signatures:

vector_2d vector_out_of_circle_from_circle(const circle &src, const circle &bounds, const vector_2d &velocity)

public static Vector2D SplashKit.VectorOutOfCircleFromCircle(Circle src, Circle bounds, Vector2D velocity);

def vector_out_of_circle_from_circle(src, bounds, velocity):

function VectorOutOfCircleFromCircle(const src: Circle; const bounds: Circle; const velocity: Vector2D): Vector2D

Vector Out Of Circle From Point

Returns the vector out to move a point back out of a circle, given the point was moving at the specified velocity.

Parameters:

Name	Type	Description
pt	`Point 2d`	The point that is moving
c	`Circle`	The circle you want to move the point out of
velocity	`Vector 2d`	The point’s velocity

Return Type: Vector 2d

Signatures:

vector_2d vector_out_of_circle_from_point(const point_2d &pt, const circle &c, const vector_2d &velocity)

public static Vector2D SplashKit.VectorOutOfCircleFromPoint(Point2D pt, Circle c, Vector2D velocity);

def vector_out_of_circle_from_point(pt, c, velocity):

function VectorOutOfCircleFromPoint(const pt: Point2D; const c: Circle; const velocity: Vector2D): Vector2D

Vector Out Of Rect From Circle

Returns a vector that can be used to move a circle back out of a rectangle, given that the circle is moving at the specified velocity.

Parameters:

Name	Type	Description
c	`Circle`	The circle that is moving
rect	`Rectangle`	The area you wan to move the circle out of
velocity	`Vector 2d`	The circle’s velocity

Return Type: Vector 2d

Signatures:

vector_2d vector_out_of_rect_from_circle(const circle &c, const rectangle &rect, const vector_2d &velocity)

public static Vector2D SplashKit.VectorOutOfRectFromCircle(Circle c, Rectangle rect, Vector2D velocity);

def vector_out_of_rect_from_circle(c, rect, velocity):

function VectorOutOfRectFromCircle(const c: Circle; const rect: Rectangle; const velocity: Vector2D): Vector2D

Vector Out Of Rect From Point

Determines the vector needed to move back from point pt out of rectangle rect given the point was moving at the velocity specified.

Parameters:

Name	Type	Description
pt	`Point 2d`	The point you want to move out of a rectangle
rect	`Rectangle`	The rectangle to move out of
velocity	`Vector 2d`	The velocity of the point. This is used to determine where the point should return to.

Return Type: Vector 2d

Signatures:

vector_2d vector_out_of_rect_from_point(const point_2d &pt, const rectangle &rect, const vector_2d &velocity)

public static Vector2D SplashKit.VectorOutOfRectFromPoint(Point2D pt, Rectangle rect, Vector2D velocity);

def vector_out_of_rect_from_point(pt, rect, velocity):

function VectorOutOfRectFromPoint(const pt: Point2D; const rect: Rectangle; const velocity: Vector2D): Vector2D

Vector Out Of Rect From Rect

Returns the vector needed to move rectangle src back out of rectangle bounds assuming the rectangle was moving at the velocity specified.

Parameters:

Name	Type	Description
src	`Rectangle`	The rectangle you want to move.
bounds	`Rectangle`	The area you want to move the rectangle out of
velocity	`Vector 2d`	The velocity of the `src` rectangle

Return Type: Vector 2d

Signatures:

vector_2d vector_out_of_rect_from_rect(const rectangle &src, const rectangle &bounds, const vector_2d &velocity)

public static Vector2D SplashKit.VectorOutOfRectFromRect(Rectangle src, Rectangle bounds, Vector2D velocity);

def vector_out_of_rect_from_rect(src, bounds, velocity):

function VectorOutOfRectFromRect(const src: Rectangle; const bounds: Rectangle; const velocity: Vector2D): Vector2D

Vector Point To Point

Returns a Vector 2d created from the difference from the p1 to the second p2 points (Point2D).

Parameters:

Name	Type	Description
start	`Point 2d`	The starting point
end_pt	`Point 2d`	The ending point

Return Type: Vector 2d

Signatures:

vector_2d vector_point_to_point(const point_2d &start, const point_2d &end_pt)

public static Vector2D SplashKit.VectorPointToPoint(Point2D start, Point2D endPt);

def vector_point_to_point(start, end_pt):

function VectorPointToPoint(const start: Point2D; const endPt: Point2D): Vector2D

Usage:

Vector Subtract

Subtracts the second vector parameter (v2) from the first vector (v1) and returns the result as new Vector 2d.

Parameters:

Name	Type	Description
v1	`Vector 2d`	The first vector.
v2	`Vector 2d`	The other vector.

Return Type: Vector 2d

Signatures:

vector_2d vector_subtract(const vector_2d &v1, const vector_2d &v2)

public static Vector2D SplashKit.VectorSubtract(Vector2D v1, Vector2D v2);

def vector_subtract(v1, v2):

function VectorSubtract(const v1: Vector2D; const v2: Vector2D): Vector2D

Usage:

Vector To

Returns a new Vector 2d using the x and y value of a Point 2d parameter. This is a vector from the origin to that point.

Parameters:

Name	Type	Description
p1	`Point 2d`	The point

Return Type: Vector 2d

Signatures:

vector_2d vector_to(const point_2d &p1)

public static Vector2D SplashKit.VectorTo(Point2D p1);

def vector_to_point(p1):

function VectorTo(const p1: Point2D): Vector2D

Vector To

Returns a vector to the indicated point.

Parameters:

Name	Type	Description
x	`Double`	The amount to move horizontally
y	`Double`	The amount to move vertically

Return Type: Vector 2d

Signatures:

vector_2d vector_to(double x, double y)

public static Vector2D SplashKit.VectorTo(double x, double y);

def vector_to(x, y):

function VectorTo(x: Double; y: Double): Vector2D

Usage:

Vector To String

Get a text description of the Vector 2d.

Parameters:

Name	Type	Description
v	`Vector 2d`	The vector

Return Type: String

Signatures:

string vector_to_string(const vector_2d &v)

public static string SplashKit.VectorToString(Vector2D v);

def vector_to_string(v):

function VectorToString(const v: Vector2D): String

Usage:

Vectors Equal

Determines if two vectors are the same.

Parameters:

Name	Type	Description
v1	`Vector 2d`	The first vector
v2	`Vector 2d`	The other vector

Return Type: Boolean

Signatures:

bool vectors_equal(const vector_2d &v1, const vector_2d v2)

public static bool SplashKit.VectorsEqual(Vector2D v1, Vector2D v2);

def vectors_equal(v1, v2):

function VectorsEqual(const v1: Vector2D; v2: Vector2D): Boolean

Vectors Not Equal

Determines if two vectors are not the same.

Parameters:

Name	Type	Description
v1	`Vector 2d`	The first vector
v2	`Vector 2d`	The other vector

Return Type: Boolean

Signatures:

bool vectors_not_equal(const vector_2d &v1, const vector_2d v2)

public static bool SplashKit.VectorsNotEqual(Vector2D v1, Vector2D v2);

def vectors_not_equal(v1, v2):

function VectorsNotEqual(const v1: Vector2D; v2: Vector2D): Boolean

Types

Matrix 2d

Field	Type	Description
elements	`Double`	The elements of the matrix

In SplashKit, matrices can be used to combine together a number of operations that need to be performed on Vector 2d values. You can translate, rotate and scale, and combine these together into a single matrix that can then be applied to vectors and points.