BGE

Static Methods

getNewMemoryScratchRegion( width: float, height: float, ): ScratchRegion

Parameters

• width (float)
• height (float)

Returns

• ScratchRegion

isBackFaceDrawMode(drawMode: SceneObjectDrawMode): boolean

Parameters

• drawMode (SceneObjectDrawMode)

Returns

• boolean

isDirectDrawMode(drawMode: SceneObjectDrawMode): boolean

Parameters

• drawMode (SceneObjectDrawMode)

Returns

• boolean

isOrientedDrawMode(drawMode: SceneObjectDrawMode): boolean

Parameters

• drawMode (SceneObjectDrawMode)

Returns

• boolean

isScreenAlignedDrawMode(drawMode: SceneObjectDrawMode): boolean

The draw modes that keep an object square to the screen rather than turning it in 3D - the billboard modes. directScaled belongs here even though isOrientedDrawMode groups it with the oriented modes: it faces the camera like directToCamera and only differs in taking its size from how far away it is (a Doom-style sprite).

Parameters

• drawMode (SceneObjectDrawMode)

Returns

• boolean

isWireFrameDrawMode(drawMode: SceneObjectDrawMode): boolean

Parameters

• drawMode (SceneObjectDrawMode)

Returns

• boolean

isSolidDrawMode(drawMode: SceneObjectDrawMode): boolean

Parameters

• drawMode (SceneObjectDrawMode)

Returns

• boolean

isFullDrawMode(drawMode: SceneObjectDrawMode): boolean

Parameters

• drawMode (SceneObjectDrawMode)

Returns

• boolean

getDrawModeName(drawMode: SceneObjectDrawMode): string

The name of a draw mode, as written in the SceneObjectDrawMode enum - handy for debug overlays and for examples that let you cycle through the draw modes.

Parameters

• drawMode (SceneObjectDrawMode)

Returns

• string — the mode's name, or "unknown" for a value outside the enum

getDrawModeBooleanLookupArray(defaultValue?: boolean): dynamic

Parameters

• defaultValue (boolean, optional, default: false)

Returns

• dynamic

getDotProductFromSurfaceToCamera( rendererObj: BGE.Renderer, facePoint: BGE.Math.Vector, faceNormal: BGE.Math.Vector, ): float

Parameters

• rendererObj (BGE.Renderer)
• facePoint (BGE.Math.Vector)
• faceNormal (BGE.Math.Vector)

Returns

• float

isNormalFacingCamera( rendererObj: BGE.Renderer, facePoint: BGE.Math.Vector, faceNormal: BGE.Math.Vector, ): boolean

Parameters

• rendererObj (BGE.Renderer)
• facePoint (BGE.Math.Vector)
• faceNormal (BGE.Math.Vector)

Returns

• boolean

HSVtoRGBA( hPercent: float, sPercent: float, vPercent: float, a?: integer, ): integer

Parameters

• hPercent (float)
• sPercent (float)
• vPercent (float)
• a (integer, optional, default: -1)

Returns

• integer

RGBAtoRGBA( red: integer, green: integer, blue: integer, alpha?: float, ): integer

Parameters

• red (integer)
• green (integer)
• blue (integer)
• alpha (float, optional, default: 1)

Returns

• integer

unpackRGB(rgb: integer): roAssociativeArray

Unpacks a packed RGB color (0xRRGGBB) into its R/G/B channels.

Parameters

• rgb (integer)

Returns

• roAssociativeArray — {r, g, b}, each 0-255

unpackRGBA(rgba: integer): roAssociativeArray

Unpacks a packed RGBA color (0xRRGGBBAA) into its R/G/B/A channels.

Parameters

• rgba (integer)

Returns

• roAssociativeArray — {r, g, b, a}, each 0-255

GetColor(name: string): integer

Looks up a BGE.Colors value by name (case-insensitive). Falls back to White for a name that isn't a known color.

Parameters

• name (string)

Returns

• integer

GetColorRGB(name: string): integer

Looks up a BGE.ColorsRGB value by name (case-insensitive). Falls back to White for a name that isn't a known color.

Parameters

• name (string)

Returns

• integer

getRandomColorRGB( r?: integer, g?: integer, b?: integer, ): integer

A random color as a packed RGB integer (0xRRGGBB, no alpha byte) - the format Drawable.color/Drawable.outlineRGBA expect. Use getRandomColorRGBA for the packed-RGBA format the Renderer.draw* calls take.

Parameters

• r (integer, optional, default: 255) — exclusive upper bound for the red channel
• g (integer, optional, default: 255) — exclusive upper bound for the green channel
• b (integer, optional, default: 255) — exclusive upper bound for the blue channel

Returns

• integer — packed RGB color

getRandomColorRGBA( r?: integer, g?: integer, b?: integer, a?: integer, ): integer

Parameters

• r (integer, optional, default: 255)
• g (integer, optional, default: 255)
• b (integer, optional, default: 255)
• a (integer, optional, default: 255)

Returns

• integer

colorBrightness(rgba: integer, brightness: float): integer

Parameters

• rgba (integer)
• brightness (float)

Returns

• integer

colorOpacity(rgba: integer, opacity: float): integer

Parameters

• rgba (integer)
• opacity (float)

Returns

• integer

lerpColorRGB( colorA: integer, colorB: integer, t: float, ): integer

Linearly interpolates between two packed RGB colors (0xRRGGBB), channel-wise.

Parameters

• colorA (integer) — start color, packed RGB (returned at t=0)
• colorB (integer) — end color, packed RGB (returned at t=1)
• t (float) — interpolation factor, clamped to 0-1

Returns

• integer — the interpolated packed RGB color

registryWrite( registry_section: string, key: string, value: dynamic, ): void

Parameters

• registry_section (string)
• key (string)
• value (dynamic)

Returns

• void

registryRead( registry_section: string, key: string, default_value?: dynamic, ): dynamic

Parameters

• registry_section (string)
• key (string)
• default_value (dynamic, optional, default: "invalid")

Returns

• dynamic

getNumberOfLinesInAString(text: string): integer

Gets the number of lines in a string by counting the newlines

Parameters

• text (string)

Returns

• integer

lastInStr(text: string, substring: string): integer

Finds the index of the last time a substring appears in a string

Parameters

• text (string)
• substring (string)

Returns

• integer

numberToFixed(num: float, precision: integer): string

Given a float number, returns the number with a fixed numbers of decimals as a string

Parameters

• num (float)
• precision (integer)

Returns

• string

arrayToStr(things: dynamic): string

Parameters

• things (dynamic)

Returns

• string

stringToFloat(input: string): float

Parameters

• input (string)

Returns

• float

TexturePacker_GetRegions( atlas: dynamic, bitmap: ifDraw2d, ): roAssociativeArray

TODO: figure this out... is useful for sprites with different size frames

Parameters

• atlas (dynamic)
• bitmap (ifDraw2d)

Returns

• roAssociativeArray

sliceGridRegions( bitmap: ifDraw2d, cellWidth: integer, cellHeight: integer, ): dynamic

Slices a bitmap into a row-major grid of cellWidth x cellHeight roRegions.

Parameters

• bitmap (ifDraw2d)
• cellWidth (integer)
• cellHeight (integer)

Returns

• dynamic

ArrayInsert( array: dynamic, index: integer, value: dynamic, ): dynamic

Parameters

• array (dynamic)
• index (integer)
• value (dynamic)

Returns

• dynamic

DrawCircleOutline( draw2d: ifDraw2d, line_count: integer, x: float, y: float, radius: float, rgba: integer, ): void

Parameters

• draw2d (ifDraw2d)
• line_count (integer)
• x (float)
• y (float)
• radius (float)
• rgba (integer)

Returns

• void

DrawRectangleOutline( draw2d: ifDraw2d, x: float, y: float, width: float, height: float, rgba: integer, ): void

Parameters

• draw2d (ifDraw2d)
• x (float)
• y (float)
• width (float)
• height (float)
• rgba (integer)

Returns

• void

isValidEntity(entity: EntityWithId): boolean

Parameters

• entity (EntityWithId)

Returns

• boolean

buttonNameFromCode(buttonCode: integer): string

Parameters

• buttonCode (integer)

Returns

• string

buttonAliasToName(buttonName: string): string

Resolves a button name or common alias to the (lowercased) BGE canonical button name, e.g. for use with GameInput.isButton(). Unrecognized names are returned lowercased, unchanged, so a caller checking a name BGE doesn't know about still gets consistent case-insensitive behavior.

Parameters

• buttonName (string) — a button name or alias (case insensitive)

Returns

• string

cloneArray(original?: Array.<dynamic>): dynamic

Clone an array (shallow)

Parameters

• original (Array.<dynamic>, optional, default: "[]") — the original array to be clones

Returns

• dynamic — A shallow copy of the original array

pointArraysEqual(a?: dynamic, b?: dynamic): boolean

Check if two arrays of points are teh same - that is, if each point, in order has same x and y values

Parameters

• a (dynamic, optional, default: "[]") — the first array
• b (dynamic, optional, default: "[]") — the second array

Returns

• boolean — true if both arrays have same number of points and x and y values are the same for each point

isTrue(value: dynamic): boolean

Parameters

• value (dynamic)

Returns

• boolean

bytesToInteger( bytes: dynamic, offset?: integer, isLittleEndian?: boolean, ): integer

Parameters

• bytes (dynamic)
• offset (integer, optional, default: 0)
• isLittleEndian (boolean, optional, default: true)

Returns

• integer

bytesToFloat( bytes: dynamic, offset?: integer, isLittleEndian?: boolean, ): float

Parameters

• bytes (dynamic)
• offset (integer, optional, default: 0)
• isLittleEndian (boolean, optional, default: true)

Returns

• float

subArray( array: ifArray, startIndex: integer, length: integer, ): roArray

Parameters

• array (ifArray)
• startIndex (integer)
• length (integer)

Returns

• roArray

decToHex(dec: integer): string

Parameters

• dec (integer)

Returns

• string

Enums

.TweenApplyMode

How a managed tween writes its interpolated value onto its target - internal, not part of the public API. "fields" is what to()/addManagedTween() uses for plain named-field targets; the color variants repack channels back into a single packed int instead.

Properties

• fields (default: "fields")
• colorRGB (default: "colorRGB")
• colorRGBA (default: "colorRGBA")

.ParticleShape

The shape drawn for every particle spawned by a DrawableParticles emitter.

Properties

• Line (default: "line")
• Rectangle (default: "rectangle")
• Image (default: "image")

.SpritePlayMode

Properties

• Loop (default: "loop")
• Forward (default: "forward")
• Reverse (default: "reverse")
• PingPong (default: "pingpong")

.CameraFrustumSide

Properties

• top (default: "top")
• bottom (default: "bottom")
• left (default: "left")
• right (default: "right")
• near (default: "near")

.SceneObjectType

Properties

• Line (default: "Line")
• Rectangle (default: "Rectangle")
• Text (default: "Text")
• Bitmap (default: "Bitmap")
• Polygon (default: "Polygon")
• Billboard (default: "Billboard")
• Model (default: "Model")
• Plane (default: "Plane")
• ParallaxLayer (default: "ParallaxLayer")
• Circle (default: "Circle")
• Particle (default: "Particle")

.SceneObjectDrawMode

Properties

• matchCamera (default: 0) — Rotations are ignored
• directToCamera (default: 1) — Do not orient in 3d space
• directScaled (default: 2) — Do not orient in 3d space, but scale in relation to distance from camera
• oriented (default: 3) — Orient in 3d space
• orientedDrawBackFace (default: 4) — Orient the object, and draw any back faces
• wireFrame (default: 5) — Just draw a wire frame
• wireFrameDrawBackFace (default: 6) — Just draw a wire frame, including back faces
• solid (default: 7) — Draw a solid polygon
• solidDrawBackFace (default: 8) — Draw a solid polygon, including back faces

.Colors

Named colors as packed RGBA integers (0xRRGGBBAA), fully opaque. Values match RGBAtoRGBA(r, g, b) for the same named color.

Properties

• Black (default: 255)
• White (default: 4294967295)
• Red (default: 4278190335)
• Lime (default: 16711935)
• Blue (default: 65535)
• Yellow (default: 4294902015)
• Cyan (default: 16777215)
• Aqua (default: 16777215)
• Magenta (default: 4278255615)
• Pink (default: 4278255615)
• Fuchsia (default: 4278255615)
• Silver (default: 3233857791)
• Gray (default: 2155905279)
• Grey (default: 2155905279)
• Maroon (default: 2147483903)
• Olive (default: 2155872511)
• Green (default: 8388863)
• Purple (default: 2147516671)
• Teal (default: 8421631)
• Navy (default: 33023)

.ColorsRGB

Named colors as packed RGB integers (0xRRGGBB, no alpha byte) - the same values as BGE.Colors, right-shifted by 8.

Properties

• Black (default: 0)
• White (default: 16777215)
• Red (default: 16711680)
• Lime (default: 65280)
• Blue (default: 255)
• Yellow (default: 16776960)
• Cyan (default: 65535)
• Aqua (default: 65535)
• Magenta (default: 16711935)
• Pink (default: 16711935)
• Fuchsia (default: 16711935)
• Silver (default: 12632256)
• Gray (default: 8421504)
• Grey (default: 8421504)
• Maroon (default: 8388608)
• Olive (default: 8421376)
• Green (default: 32768)
• Purple (default: 8388736)
• Teal (default: 32896)
• Navy (default: 128)

Other

Canvas

Contains a roku roBitmap which all game objects get drawn to.

Parameters

• gameEngine (Game)
• canvasWidth (integer) — width of canvas
• canvasHeight (integer) — height of canvas
• options (RendererOptions, optional, default: "{useBitmapPooling: true}")

Properties

• bitmap (ifDraw2D) — bitmap GameEntity images get drawn to
• offset (BGE.Math.Vector) — Position offset from screen coordinates (z value ignored)
• scale (BGE.Math.Vector) — Scale (z value ignored)
• renderer (Renderer) — Renderer for this canvas
• rendererOptions (RendererOptions)

Returns

• BGE.Canvas

Game

Main Game Engine class which runs everything The main game loop is as follows:

1. Update - For each GameEntity:

• Process Input from roku remote
• Process Audio Events (https://developer.roku.com/en-ca/docs/references/brightscript/events/roaudioplayerevent.md)
• Process ECP input (https://developer.roku.com/en-ca/docs/developer-program/debugging/external-control-api.md)
• Process URL events (https://developer.roku.com/en-ca/docs/references/brightscript/events/rourlevent.md)
• Runs the Entity's onUpdate() function
• Moves Entity based on velocity

2. Collisions - For each GameEntity:

• Run Entity's onPreCollision() function
• For any collisions, runs Entity's onCollision() function
• Runs entity's onPostCollision() function (At any time, the Entity in question may Delete() itself. Before every entity interaction, the entity is checked to make sure it is still valid in case it was deleted in the last interaction)

3. Draw - For each GameEntity, sorted by zIndex

• Runs the Entity onDrawBegin() function
• For each drawable in the Entity, run the draw() function
• Run the Entity onDrawEnd() function

4. Draw all debug items in game space (e.g. colliders, screen safe zones, etc).

5. UI - For the tree of widgets in the UI Container

• Run onUpdate()
• Run draw()

6. Debug UI - Draw all debug windows in the tree of the Debug UI

Parameters

• canvasWidth (integer) — Width of the canvas the game is drawn to
• canvasHeight (integer) — Height of the canvas the game is drawn to
• uiWidth (integer, optional, default: 0) — Width of the UI canvas - if 0, will be same as screen
• uiHeight (integer, optional, default: 0) — Height of the UI canvas - if 0, will be same as screen

Properties

• sortedEntities (dynamic)
• compositor (roCompositor)
• screen (roScreen)
• canvas (BGE.Canvas)
• uiCanvas (BGE.Canvas)
• dummyScreen (roScreen)
• currentRoom (Room) — Reference to the current room in play
• currentRoomArgs (dynamic) — Any special arguments for the current room
• Entities (dynamic) — All of the GameEntities by room => => GameEntity
• Statics (dynamic) — All static variables for a given object type
• Rooms (dynamic) — The room definitions by name (the room creation functions)
• Interfaces (dynamic) — The interface definitions by name
• Bitmaps (dynamic) — The loaded bitmaps by name
• Sounds (dynamic) — The loaded sounds by name
• Fonts (dynamic) — The loaded fonts by name
• Models (dynamic) — The loaded Models by name
• tweenManager (BGE.TweenManager) — Ticks every live tween once per frame and writes interpolated values onto arbitrary ' target fields - see BGE.TweenManager.to().
• gameUi (BGE.UI.UiContainer) — Container for all UI
• debugUi (BGE.UI.UiContainer) — Container for Debug UI

Returns

• BGE.Game

GameEntity

Every thing (character, player, object, etc) in the game should extend this class. This class has a number of empty methods that are designed to be overridden in subclasses. For example, override onInput() to handle input event, and onUpdate() to handle updating each frame

Parameters

• game (Game) — The game engine that this entity is going to be assigned to
• gameEngine (Game)
• args (roAssociativeArray, optional, default: "{}") — Any extra properties to be added to this entity

Properties

• name (string) — Constant - name of this Entity
• id (dynamic) — Constant - Unique Id
• game (Game)
• enabled (boolean) — Is this GameEntity enabled
• persistent (boolean) — Does this entity persist across room changes?
• pauseable (boolean) — When the game is paused, does this entity pause too?
• position (dynamic) — position of where this entity is in game world
• velocity (dynamic) — Speed of this entity, in units/second (not units/frame) - added to position each frame scaled by elapsed time
• rotation (dynamic) — Rotation of entity - applies to all images
• scale (dynamic) — Scale of entity - applies to all images
• colliders (roAssociativeArray) — The colliders for this entity by name
• drawables (dynamic) — The array of drawables to draw for this entity
• drawablesByName (roAssociativeArray) — Associative array of drawables by name
• tagsList (dynamic) — Game Entities can be tagged with any number of tags so they can be easily identified (e.g. "enemy", "wall", etc.)
• transformationMatrix (dynamic) — The Current Transformation Matrix
• motionChecker (MotionChecker)

Returns

• BGE.GameEntity

GameInput

Class that contains all information about the current input during a given frame from the remote

Parameters

• buttonCode (integer) — button to use for the data
• heldTimeMs (integer) — how long was this button held for

Properties

• button (string) — The name of the button associated with the current input
• buttonCode (integer) — The code for the input
• press (boolean) — Was the button pressed since the last frame
• held (boolean) — Was the button held down since last frame
• release (boolean) — Was the button released this frame
• heldTimeMs (integer) — How many milliseconds was the current input held for
• x (float) — Current horizontal directional input: left -> -1, right -> 1
• y (float) — Current vertical directional input, in world space (+y is up, matching ' the engine's world coordinate convention - the renderer flips this when ' projecting to raster/canvas space): up -> 1, down -> -1

Returns

• BGE.GameInput

Example

' -------Button Code Reference--------
' Button  Pressed Released  Held
' ------------------------------
' Back         0      100   1000
' Up           2      102   1002
' Down         3      103   1003
' Left         4      104   1004
' Right        5      105   1005
' OK           6      106   1006
' Replay       7      107   1007
' Rewind       8      108   1008
' FastForward  9      109   1009
' Options     10      110   1010
' Play        13      113   1013

GameTimer

Wrapper for Roku's roTimeSpan that allows time adjustment

Returns

• BGE.GameTimer

Room

Extends: GameEntity

Parameters

• gameEngine (Game)
• args (roAssociativeArray, optional, default: "{}")

Returns

• BGE.Room

ManagedTween

One tween TweenManager is tracking - internal bookkeeping, not part of the public API a consumer touches directly (that's to()/toColorRGB()/toColorRGBA()/cancel()).

Properties

• tweenObj (BGE.Tweens.TweenObject)
• target (object) — The object setAnchor()-style consumers pass to to()/toColorRGB()/toColorRGBA() - ' genuinely arbitrary (a Vector, a Drawable, a plain associative array), so there's no ' narrower type to give it.
• applyMode (TweenApplyMode)
• fieldName (string) — Only set (to the field on target holding the packed color) when applyMode is ' colorRGB/colorRGBA - invalid for applyMode = fields.
• owner (BGE.GameEntity) — The GameEntity to validate every tick via isValidEntity(), or invalid for a tween ' with no automatic cleanup - see TweenManager's class doc.
• onComplete (function) — Called once, with this tween's own target, when it retires - see to()'s doc for why ' it takes targetObj as a parameter instead of relying on m/closure state. invalid if no ' onComplete was given.
• loopMode (BGE.Tweens.TweenLoopMode)
• delayMs (integer)
• delayTimer (BGE.GameTimer) — Only non-invalid while a nonzero delay hasn't elapsed yet.
• originalStart (roAssociativeArray) — The tween's original start/dest fields, before any pingPong ChangeTweenDest() calls ' have swapped tweenObj's own start/dest - pingPong alternates between these two fixed ' endpoints forever, rather than drifting based on whatever the current leg left behind.
• originalDest (roAssociativeArray)
• pingPongForwardNext (boolean)

TweenManager

Ticks every live tween once per frame (see Game.tweenManager) and writes interpolated values straight onto arbitrary target object fields - no manual per-frame HandleTween() bookkeeping required. Wraps BGE.Tweens.CreateTweenObject()/HandleTween() per managed tween rather than reimplementing interpolation.

CircleCollider

Extends: Collider

Collider with the shape of a circle centered at (offset.x, offset.y), with given radius

Parameters

• colliderName (string) — name of this collider
• args (roAssociativeArray, optional, default: "{}") — additional properties (e.g {radius: 10})

Properties

• radius (integer) — Radius of the collider

Returns

• BGE.CircleCollider

Collider

Colliders are attached to GameEntities and when two colliders intersect, it triggers the onCollision() method in the GameEntity

Parameters

• colliderName (string) — the name this collider will be identified by
• args (roAssociativeArray, optional, default: "{}") — additional properties to be added to this collider

Properties

• colliderType (string) — The type of this collider - should be defined in sub classes (eg. "circle", "rectangle")
• name (string) — Name this collider will be identified by
• enabled (boolean) — Does this collider trigger onCollision() ?
• offset (BGE.Math.Vector) — Offset from the GameEntity it is attached to
• memberFlags (integer) — Bitflag for collision detection: this collider is in this group - https://developer.roku.com/en-ca/docs/references/brightscript/interfaces/ifsprite.md#setmemberflagsflags-as-integer-as-void
• collidableFlags (integer) — Bitflag for collision detection: this collider will only collider with colliders in this group - https://developer.roku.com/en-ca/docs/references/brightscript/interfaces/ifsprite.md#setcollidableflagsflags-as-integer-as-void
• compositorObject (roSprite) — Used internal to Game - should not be modified manually
• tagsList (dynamic) — Colliders can be tagged with any number of tags so they can be easily identified (e.g. "enemy", "wall", etc.)

Returns

• BGE.Collider

RectangleCollider

Extends: Collider

Collider with the shape of a rectangle with bottom left at (offset.x, offset.y) - i.e. top left is at (offset.x, offset.y - height) - with given width and height

Parameters

• colliderName (string) — name of this collider
• args (roAssociativeArray, optional, default: "{}") — additional properties (e.g {width: 10, height: 20})

Properties

• width (float)
• height (float)

Returns

• BGE.RectangleCollider

AnimatedImage

Extends: Image

Parameters

• owner (GameEntity)
• regions (dynamic)
• args (roAssociativeArray, optional, default: "{}")

Properties

• index (integer) — The current index of image - this would not normally be changed manually, but if you wanted to stop on a specific image in the spritesheet this could be set.
• animationDurationMs (float) — The time in milliseconds for a single cycle through the animation to play.
• animationTween (string) — The name of the tween to use for choosing the next image
• regions (dynamic) — ------------Never To Be Manually Changed----------------- ' These values should never need to be manually changed.
• animationTimer (dynamic)
• tweensReference (dynamic)

Returns

• BGE.AnimatedImage

Drawable

Abstract drawable class - all drawables extend from this

Parameters

• owner (GameEntity)
• args (roAssociativeArray, optional, default: "{}")

Properties

• name (string) — -------------Values That Can Be Changed------------
• offset (dynamic) — The offset of the image from the owner's position
• scale (dynamic) — The image scale
• rotation (dynamic) — Rotation of the image
• color (integer) — This can be used to tint the image with the provided color if desired. White makes no change to the original image.
• outlineRGBA (integer) — RGB color for the outline stroke. Leave invalid for no outline at all.
• outlineWidth (integer) — Thickness of the outline stroke, in pixels. Only used when outlineRGBA is set.
• alpha (float) — Change the image alpha (transparency).
• enabled (boolean) — Whether or not the image will be drawn.
• transformationMatrix (dynamic)
• motionChecker (MotionChecker)
• shouldRedraw (boolean)
• geometryVersion (integer) — Bumped every time this drawable's geometry changes in a way the ' position/rotation/scale dirty-checking can't see - a rectangle being resized, for ' instance. SceneObject compares against it to know it has to recompute projected ' geometry even though nothing moved. Bump it via invalidateGeometry().
• anchor (dynamic) — Normalized anchor point (0-1 on each axis) this drawable pivots around, where (0,0) is ' the top left corner (today's default behavior for every existing drawable) and (1,1) is ' the bottom right. Change it via setAnchor(), not by assigning directly - the renderer ' needs to know the geometry changed.
• anchorIsSet (boolean) — Whether setAnchor() has ever been called. Image consults this to decide whether to keep ' honoring whatever pretranslation is already on its region (e.g. from a sprite atlas ' pivot) or to override it - see Image.applyAnchorToRegion().
• owner (GameEntity) — owner GameEntity
• width (float)
• height (float)
• sceneObjects (dynamic)
• drawMode (SceneObjectDrawMode)
• isShaded (boolean)

Returns

• BGE.Drawable

DrawableCircle

Extends: Drawable

Draws a filled circle via the renderer's shared circle texture (see Renderer.getCircleResource()), with an optional outline stroked as a regular polygon inscribed in the circle's own quad - see SceneObjectCircle.

Like DrawableRectangle, the circle's top left (of its bounding square) sits at the drawable's own world position, extending radius * 2 right and down - so it anchors and composes with the rest of the engine the same way every other drawable does. In the oriented/solid/wireFrame 3D draw modes it foreshortens into an ellipse when viewed at an angle, the same as any other billboard (see DrawableSphere for a circle that never does this).

Parameters

• owner (GameEntity)
• radius (float)
• args (roAssociativeArray, optional, default: "{}")

Properties

• radius (float)
• outlineSegments (integer) — Regular-polygon segment count used only for the outline - the fill is a texture ' blit, not a polygon, so this has no effect on fill smoothness.

Returns

• BGE.DrawableCircle

DrawableLine

Extends: Drawable

Parameters

• owner (GameEntity)
• startPos (BGE.Math.Vector)
• endPos (BGE.Math.Vector)
• args (roAssociativeArray, optional, default: "{}")

Properties

• startPosition (BGE.Math.Vector)
• endPosition (BGE.Math.Vector)

Returns

• BGE.DrawableLine

DrawableParallaxLayer

Extends: Drawable

Scrolls a tiled/non-tiled bitmap layer at a configurable per-axis fraction of the camera's movement (parallax). {1,1} is the default and behaves exactly like an ordinary drawable; {0,0} pins the layer to the camera; 0 < factor < 1 is a background layer that drifts slower than the world; factor > 1 is a foreground layer that scrolls faster. See SceneObjectParallaxLayer for the actual per-frame math.

Combines with the owning entity's position/offset exactly like every other Drawable - there is no special "independent of owner" positioning mode. Attach this to a dedicated static entity if you want a fixed background anchor.

Parameters

• owner (BGE.GameEntity)
• region (roRegion)
• args (roAssociativeArray, optional, default: "{}")

Properties

• region (roRegion) — The bitmap tile to scroll/repeat.
• parallaxFactor (BGE.Math.Vector) — Per-axis fraction of camera movement this layer scrolls at. See the class doc for ' what different values mean.
• repeatX (boolean) — Whether this layer tiles to cover the canvas along each axis. repeatX defaults true ' (the common side-scroller case); repeatY defaults false.
• repeatY (boolean)

Returns

• BGE.DrawableParallaxLayer

ParticleRecord

One live particle spawned by a DrawableParticles emitter.

Properties

• position (BGE.Math.Vector)
• velocity (BGE.Math.Vector)
• age (float)
• lifetime (float)
• startColor (integer)
• endColor (integer)
• startAlpha (float)
• endAlpha (float)
• startSize (float)
• endSize (float)
• rotation (float)

DrawableParticles

Extends: Drawable

Emits and simulates lightweight particles (lines, rectangles, or images) with randomized velocity, constant acceleration, and lifetime-driven fade/color/size interpolation. Draws through a single SceneObjectParticle per emitter rather than one SceneObject per particle, so spawning/expiring particles never touches Renderer.addSceneObject/removeSceneObject - see specs/2026-08-18-particle-system-design.md for why that matters for depth-sort performance.

Parameters

• owner (GameEntity)
• shape (ParticleShape)
• args (roAssociativeArray, optional, default: "{}")

Properties

• shape (ParticleShape) — Shape drawn for every particle. See BGE.ParticleShape.
• image (dynamic) — Bitmap or region drawn for each particle when shape = BGE.ParticleShape.Image. ' Ignored for other shapes.
• cellWidth (integer) — Width/height (pixels) of one animation cell if image is a sprite sheet, the ' BGE.ParticleShape.Image shape only. When both are >0, image is sliced into a ' row-major grid of frames and ' each particle's current frame is driven by its own age/lifetime - a fade-style sheet ' (bright to transparent) reproduces its own fade this way, with no extra frame-rate ' config needed. 0 (the default) means image is drawn as a single static bitmap, ' unchanged from previous behavior.
• cellHeight (integer)
• regions (dynamic)
• spawnRate (float) — Particles spawned per second while emitting (see start()/stop()).
• lifetime (float) — Base lifetime in seconds each particle survives, randomized by +/- lifetimeSpread.
• lifetimeSpread (float)
• velocity (BGE.Math.Vector) — Base emission velocity (world units/second) shared by every particle before ' randomization is applied.
• velocitySpreadAngleDegrees (float) — Randomizes each particle's velocity direction by +/- this many degrees around ' velocity.
• velocitySpreadMagnitude (float) — Randomizes each particle's velocity magnitude by +/- this amount. If velocity ' is zero, particles instead radiate outward in a uniformly random direction at this ' magnitude - this is what makes a stationary emitter usable for an explosion/burst ' effect.
• acceleration (BGE.Math.Vector) — Constant acceleration (world units/second^2) applied to every particle every ' frame, e.g. gravity.
• startColor (integer) — Packed RGB (0xRRGGBB) color interpolated over each particle's lifetime.
• endColor (integer)
• startAlpha (float) — Alpha (0-255) interpolated over each particle's lifetime.
• endAlpha (float)
• startSize (float) — Size interpolated over each particle's lifetime - a line's length, a rectangle's ' side length, or an image's scale multiplier (1.0 = the image's native size), ' depending on shape.
• endSize (float)
• rotationSpeed (float) — Degrees/second of rotation applied to each particle. Only used when ' shape = BGE.ParticleShape.Image - see the design spec for why line/rectangle ' particles never rotate.
• maxParticles (integer) — Hard cap on live particles. Once reached, further spawns (continuous emission or ' burst()) are silently dropped until a slot frees up via natural expiry.
• particles (dynamic) — Live particle records. See BGE.ParticleRecord.
• emitting (boolean)
• spawnAccumulator (float)
• timer (dynamic)

Returns

• BGE.DrawableParticles

DrawablePlane

Extends: BGE.Image

Used to draw a "infinite" plane in 3d space Ideally used for a ground or floor

Parameters

• owner (BGE.GameEntity)
• region (roRegion)
• plane (BGE.Math.Plane)
• args (object, optional, default: "{}")

Properties

• plane (BGE.Math.Plane)

Returns

• BGE.DrawablePlane

DrawablePolygon

Extends: Drawable

Parameters

• owner (GameEntity)
• points (dynamic, optional, default: "[]")
• args (roAssociativeArray, optional, default: "{}")

Properties

• points (dynamic) — the set of points defining a convex polygon

Returns

• BGE.DrawablePolygon

DrawableRectangle

Extends: Drawable

Draws a rectangle, filled and/or outlined.

The rectangle's top left corner sits at the drawable's own world position (its offset transformed by the owning entity), extending width to the right and height downwards on screen - the same anchoring an Image uses, so the two are interchangeable.

In the direct (billboard) draw modes - which is what a 2D game gets, since a Camera2d resolves matchCamera to directToCamera - this is a plain axis-aligned rectangle. In the oriented/solid/wireFrame draw modes it becomes a quad that rotates and foreshortens in 3D like any other billboard (see examples/3d's RectanglesRoom).

Set color for the fill and outlineRGBA for the outline (both packed RGB, no alpha byte - alpha is separate). Leaving outlineRGBA unset means no outline at all; set filled = false for an outline-only rectangle.

Parameters

• owner (GameEntity)
• width (float)
• height (float)
• args (roAssociativeArray, optional, default: "{}")

Properties

• filled (boolean) — Whether the rectangle's interior is filled with color. Set false for an outline-only ' rectangle, which needs outlineRGBA set too or nothing is drawn at all.

Returns

• BGE.DrawableRectangle

DrawableSphere

Extends: DrawableCircle

A circle that always looks the same from any camera angle, because a sphere looks the same from every direction. Everything about the fill/outline is identical to DrawableCircle (which this extends unchanged, including addToScene) - the only difference is forcing drawMode to directScaled in the constructor, which billboards (never rotates/foreshortens) while still scaling with camera distance in 3D. See SceneObject.getActualDrawMode(): it only resolves the matchCamera default through the camera, so any other explicit drawMode - this one included - is used as-is.

Deliberately does NOT re-append args after forcing drawMode (DrawableCircle's own constructor already applied them once) - a caller passing {drawMode: ...} here should not be able to silently defeat a DrawableSphere's entire reason for existing. A caller who genuinely wants a different draw mode can still assign sphere.drawMode = ... directly after construction.

Parameters

• owner (GameEntity)
• radius (float)
• args (roAssociativeArray, optional, default: "{}")

Returns

• BGE.DrawableSphere

MIN_TEXT_REGION_SIZE

Default: 256

DrawableText

Extends: Drawable

Class to draw text

Parameters

• owner (GameEntity)
• text (string, optional, default: "\"\"")
• font (roFont, optional, default: "invalid")
• args (roAssociativeArray, optional, default: "{}")

Properties

• text (string) — The text to write on the screen
• font (roFont) — The Font object to use ( get this from the font registry)
• alignment (BGE.UI.HorizAlignment) — The Horizontal alignment for the text
• textColor (integer) — The color the text is drawn in
• lastTextValue (string)
• lastTextColor (integer)
• tempCanvas (roBitmap)
• tempRegion (roRegion)
• lastAlignment (BGE.UI.HorizAlignment)

Returns

• BGE.DrawableText

Image

Extends: BGE.Drawable

Used to draw a bitmap image to the screen

Parameters

• owner (BGE.GameEntity)
• region (roRegion)
• args (roAssociativeArray, optional, default: "{}")

Properties

• regionId (string) — An optional unique name for the region, used for caching image data. If not provided, the name of the drawable will be used as the region name.
• region (roRegion) — ------------Never To Be Manually Changed----------------- ' These values should never need to be manually changed.

Returns

• BGE.Image

Model3dTexture

Parameters

• srcRegionWithId (BGE.RendererHelpers.RegionWithId)
• points (dynamic)

Properties

• srcRegionWithId (BGE.RendererHelpers.RegionWithId)
• points (dynamic)

Returns

• BGE.Model3dTexture

Model3dLoadOptions

The options accepted by Game.load3dModel() for an .obj model's texture.

Properties

• texturePath (string)

Model3dFace

Properties

• vertices (dynamic)
• normal (BGE.Math.Vector)
• Texture (Model3dTexture)
• brightness (float)
• priority (float)
• color (integer)

Model3d

Parameters

• faces (dynamic)

Properties

• faces (dynamic)
• name (string)
• texturePath (string)

Returns

• BGE.Model3d

DrawableModel

Extends: Drawable

Parameters

• owner (BGE.GameEntity)
• model (Model3d)
• args (roAssociativeArray, optional, default: "{}")

Properties

• model (Model3d)

Returns

• BGE.DrawableModel

AnimationFrameDescription

Properties

• startFrame (integer)
• frameCount (integer)

SpriteAnimation

CReate a new SpriteAnimation

Parameters

• name (string) — Name of the animation
• frameList (dynamic) — Wither an array of cell indexes, or an object {startFrame, frameCount}
• frameRate (integer) — Frames per second the animation should play at
• playMode (SpritePlayMode, optional, default: "SpritePlayMode.Loop") — Play mode for the sprite: loop, forward, reverse, pingpong

Properties

• name (string) — Name of the animation
• frameRate (integer) — Frames per second the animation should play at
• frameList (dynamic) — Array of the regions of the each cell of this animation
• playMode (SpritePlayMode) — Play mode for the sprite: loop, forward, reverse, pingpong

Returns

• BGE.SpriteAnimation

Sprite

Extends: AnimatedImage

Parameters

• owner (GameEntity)
• spriteSheet (ifDraw2d)
• cellWidth (integer)
• cellHeight (integer)
• args (roAssociativeArray, optional, default: "{}")

Properties

• spriteSheet (ifDraw2d) — roBitmap to pick cells from
• cellWidth (integer) — Width of each animation cell in the sprite image in pixels
• cellHeight (integer) — Height of each animation cell in the sprite image in pixels
• animations (roAssociativeArray) — Lookup map of animation name -> SpriteAnimation object
• activeAnimation (SpriteAnimation) — The current animation being played

Returns

• BGE.Sprite

RoomChangeInfo

Properties

• room (Room)
• args (roAssociativeArray)

GarbageCollectionInfo

Properties

• count (integer)
• orphaned (integer)
• root (integer)

DebugColors

Properties

• colliders (integer)
• safe_action_zone (integer)
• safe_title_zone (integer)

EntityWithId

Properties

• id (dynamic)

PositionXY

Properties

• x (float)
• y (float)

SizeWH

Properties

• width (float)
• height (float)

RendererResourceSize

Default: 400

TriangleDrawThreshold

Default: 4

TriangleQuickDrawThreshold

Default: 64

TriangleQuickDrawThresholdForSimulator

Default: 32

DEPTH_TIE_EPSILON

Default: 0.5

LevelOfDetailOptions

Properties

• levelOffset (integer)
• levelOfDetail (integer)

RendererOptions

Properties

• useBitmapPooling (boolean)

Renderer

Wrapper for Draw2D calls, so that we can keep track of how much is being drawn per frame

Parameters

• draw2d (ifDraw2d)
• mainGame (BGE.Game, optional, default: "invalid")
• cam (BGE.Camera, optional, default: "invalid")
• options (RendererOptions, optional, default: "{useBitmapPooling: true}")

Properties

• nextSceneObjectId (integer)
• minimumFrameRateTarget (integer) — Frame rate target - the game will reduce quality if this target is not met
• onlyDrawWhenInFrame (boolean)
• drawDebugCells (boolean)
• drawDebugTrianglePoints (boolean)
• computeOverlapClusters (boolean) — Whether drawScene() computes overlap clusters (BGE.DepthSort.groupIntoClusters) ' this frame. Off by default: nothing in the engine's actual draw path consumes ' getOverlapClusters() yet (that's a future follow-up - see #59's Plan 2), the cost ' of the O(n^2)-ish broad phase across every scene object hasn't been measured ' on-device, and the design's own requirement is that a solo (non-overlapping) ' scene sees zero regression from today's cost. Set this true to opt in (see ' examples/depthsort's ClusterVisualizerRoom, which visualizes the result) - ' TieBreakRoom deliberately does NOT opt in, since it only demonstrates the ' tie-break fix, not clustering. ' ' Known limitation: see drawPendingClusterPrimitives()'s doc comment for a ' disclosed draw-order gap affecting objects excluded from cluster candidacy ' entirely (lines, planes, or anything else with a degenerate bounding-point set).
• camera (Camera)
• triangleCache (dynamic)
• frameCount (integer)
• bmpPool (BGE.ScratchBitmapPool)
• game (BGE.Game)
• name (string)
• statsString (string)
• resources (dynamic)
• dummyScreen (roScreen)

Returns

• BGE.Renderer

DrawPinnedCornersOptions

Properties

• splitIntoFour (boolean)
• alwaysUseTLtoBR (boolean)

ScratchBitmap

Parameters

• id (string)
• w (integer)
• h (integer)

Properties

• bitmap (roBitmap)
• id (string)

Returns

• BGE.ScratchBitmap

ScratchRegion

Parameters

• region (roRegion)
• scratchBmp (ScratchBitmap)

Properties

• region (roRegion)
• scratchBmp (ScratchBitmap)
• scale (dynamic)

Returns

• BGE.ScratchRegion

ScratchBitmapPool

Parameters

• doPooling (boolean, optional, default: true)
• initialCount (integer, optional, default: 10)

Returns

• BGE.ScratchBitmapPool

TriangleCacheEntry

Parameters

• triangle (BGE.RendererHelpers.TriangleBitmap)

Properties

• triangle (BGE.RendererHelpers.TriangleBitmap)
• timeLastUsed (integer)

Returns

• BGE.TriangleCacheEntry

TriangleCache

Parameters

• cacheKeepSeconds (integer, optional, default: 60)

Returns

• BGE.TriangleCache

Camera

Properties

• orientation (dynamic) — A vector pointed in the direction of the camera
• position (BGE.Math.Vector)
• motionChecker (MotionChecker)
• frameSize (BGE.Math.Vector)
• projectionVersion (integer) — Bumped whenever something about the camera's projection - as opposed to its ' position or orientation - changes. MotionChecker watches only position and ' orientation, so without this a frame-size or field-of-view change is invisible to ' every dirty check in the renderer, and a stationary culled object stays culled ' through a projection change that should have brought it back into view.
• zoom (float) — TODO: do something with zoom!
• worldToCamera (dynamic)
• name (string)

Returns

• BGE.Camera

Camera2d

Extends: Camera

Properties

• top (float)
• bottom (float)
• right (float)
• left (float)
• near (float)
• far (float)
• name (string)

CameraFrustumNormals

Properties

• top (BGE.Math.Vector)
• bottom (BGE.Math.Vector)
• left (BGE.Math.Vector)
• right (BGE.Math.Vector)
• near (BGE.Math.Vector)

CameraFrustumRays

Properties

• topLeft (BGE.Math.Ray)
• topRight (BGE.Math.Ray)
• bottomLeft (BGE.Math.Ray)
• bottomRight (BGE.Math.Ray)

Camera3d

Extends: Camera

Properties

• fieldOfViewDegrees (float)
• rollDegrees (float) — Rotation about the camera's own forward/view axis, in degrees. Positive = right ' side down (aviation convention). getUpVector()/getRightVector() apply this on ' top of the "level" vectors - see getLevelUpVector()/getLevelRightVector().
• frustumNormals (CameraFrustumNormals)
• frustrumConvergence (BGE.Math.Vector)
• frustumRays (CameraFrustumRays)
• name (string)

MAX_DRAW_MODE

Default: 8

SceneObject

Parameters

• name (string)
• drawableObj (Drawable)
• objType (SceneObjectType)

Properties

• name (string)
• id (string) — Unique Id
• clusterMemberCount (integer) — How many members are in this object's overlap cluster this frame (see ' Renderer.getOverlapClusters()) - 1 means solo (the common case, and the only ' value possible when Renderer.computeOverlapClusters is false). Set once per frame ' by Renderer, right after it computes clusters - not meant to be set directly by ' game code.
• drawable (Drawable)
• type (SceneObjectType)
• negDistanceFromCamera (float) — The negative distance from the camera, used for depth sorting
• worldPosition (dynamic)
• transformationMatrix (dynamic) — The Current Transformation Matrix
• lastFrameWasCulled (boolean) — Whether the last frame's draw was skipped because the frustum rejected this object, ' or because a subsequent draw attempt failed deterministically (see ' isDeterministicDrawFailure()). Both latch: nothing moved, so re-running the check ' would give the same answer, and skipping it is what makes a static off-screen object ' free. A draw that was attempted and failed for a reason that could change without ' anything moving (e.g. a transient scratch-bitmap-pool exhaustion) must not latch - ' findCanvasPosition() and performDraw() both already retry on the following frame, ' and treating that kind of failure as a cull is what made one bad frame permanent. ' See issue #48 (the original cull-latch fix) and issue #73 (extending it to ' deterministic draw failures, like a backface or an off-canvas rejection, which used ' to re-run the full frustum check every single frame with no latch at all).
• lastFrameDidDraw (boolean) — Whether the last frame's draw actually happened. Distinct from lastFrameWasCulled ' because a frame has four possible outcomes, not two: drew, was culled by the ' frustum, entered the draw path and failed deterministically, or entered the draw ' path and failed transiently. Only the first kind of failure may latch (folded into ' lastFrameWasCulled); a transient failure must retry; and reaching a failure at all is ' what makes the frustum check reachable, which is what puts an object into the culled ' state in the first place.
• hasValidWorldPosition (boolean)
• hasValidCanvasPosition (boolean)
• wasEnabledLastFrame (boolean)
• isFirstFrameSinceEnabled (boolean)
• isLowEndDevice (boolean)
• lastGeometryVersion (integer) — The drawable's geometryVersion as of the last completed draw - see geometryChanged()
• lastDrawMode (integer) — The draw mode this object last drew in - see drawModeChanged()
• lastProjectionVersion (integer) — The camera's projectionVersion as of the last draw - see projectionChanged()
• depthChangedThisFrame (boolean) — True for exactly the frame this object's negDistanceFromCamera was recomputed - ' Renderer.updateSceneObjects() ORs these together to decide whether the whole ' scene needs a re-sort this frame, instead of always resorting even when nothing ' that could change draw order actually happened.
• stableSortKey (float) — What Renderer actually sorts by - negDistanceFromCamera quantized into ' DEPTH_TIE_EPSILON-wide buckets, combined with this object's sort position from ' the previous frame, so two objects whose depths quantize into the same bucket ' keep their previous relative order instead of swapping from floating-point jitter ' alone. This is bucket quantization, not a true epsilon-tolerance comparison - ' two depths closer together than the epsilon can still straddle a bucket boundary ' and swap order. A genuine depth crossover still swaps order correctly, since the ' quantized depth term dominates the combined key.

Returns

• BGE.SceneObject

TransformTempBitmapDetails

Properties

• origin (BGE.Math.Vector)
• rotation (float)
• scaleX (float)
• scaleY (float)

TempBitmapDrawResult

Properties

• worked (boolean)
• didFastDraw (boolean)

SceneObjectBillboard

Extends: SceneObject

Parameters

• name (string)
• drawableObj (Drawable)
• objType (SceneObjectType)

Properties

• worldPoints (BGE.Math.CornerPoints)
• canvasPoints (BGE.Math.CornerPoints)
• canvasPosition (BGE.Math.Vector)
• useTempBitmapMap (dynamic)

Returns

• BGE.SceneObjectBillboard

SceneObjectCircle

Extends: SceneObjectBillboard

Draws a DrawableCircle. The fill is inherited, unmodified SceneObjectBillboard machinery (pinned-corners texture warp, tinting, temp-bitmap caching) blitting the renderer's shared circle resource (Renderer.getCircleResource(), built lazily on first use) - exactly like SceneObjectImage, just with a fixed texture instead of one supplied by the drawable. Only the outline differs from a plain Image: it's stroked as an N-gon inscribed in this object's own already-transformed canvasPoints quad (via the generic getOutlineCanvasPoints() hook), which is far cheaper than rasterizing the fill itself as a many-sided polygon and needs no new Renderer draw method.

Parameters

• name (string)
• drawableObj (DrawableCircle)

Properties

• drawable (DrawableCircle)

Returns

• BGE.SceneObjectCircle

SceneObjectImage

Extends: SceneObjectBillboard

Parameters

• name (string)
• drawableObj (Image)

Properties

• drawable (Image)
• frameNumber (integer)

Returns

• BGE.SceneObjectImage

SceneObjectLine

Extends: SceneObject

Parameters

• name (string)
• drawableObj (DrawableLine)

Properties

• drawable (DrawableLine)

Returns

• BGE.SceneObjectLine

SceneObjectModel

Extends: SceneObjectBillboard

Parameters

• name (string)
• drawableObj (DrawableModel)

Properties

• drawable (DrawableModel)

Returns

• BGE.SceneObjectModel

SceneObjectParallaxLayer

Extends: SceneObject

Parameters

• name (string)
• drawableObj (DrawableParallaxLayer)

Properties

• drawable (DrawableParallaxLayer)

Returns

• BGE.SceneObjectParallaxLayer

SceneObjectParticle

Extends: SceneObject

Draws an entire DrawableParticles emitter's live particles with a single SceneObject

• not one SceneObject per particle. See specs/2026-08-18-particle-system-design.md ("Why one SceneObjectParticle per emitter, not per particle") for why: per-particle SceneObjects would call Renderer.addSceneObject/removeSceneObject every frame during continuous emission, permanently defeating the depth-sort skip-optimization for the whole renderer.

Parameters

• name (string)
• drawableObj (DrawableParticles)

Properties

• drawable (DrawableParticles)

Returns

• BGE.SceneObjectParticle

PerspectiveCalculationResult

Properties

• actual (BGE.Math.CornerPoints)
• mapped (BGE.Math.CornerPoints)

PerspectiveSlice

Properties

• srcWidth (float)
• srcHeight (float)
• srcTopLeft (BGE.PositionXY)
• scaleX (float)

SCENE_OBJECT_PLANE_NEAR_DISTANCE

Default: 0

SCENE_OBJECT_PLANE_FAR_DISTANCE

Default: 512

SCENE_OBJECT_PLANE_SLICE_COUNT

Default: 50

SceneObjectPlane

Extends: SceneObject

Parameters

• name (string)
• drawableObj (DrawablePlane)

Properties

• drawable (DrawablePlane)

Returns

• BGE.SceneObjectPlane

SceneObjectPolygon

Extends: SceneObjectBillboard

Parameters

• name (string)
• drawableObj (DrawablePolygon)

Properties

• drawable (DrawablePolygon)

Returns

• BGE.SceneObjectPolygon

SceneObjectRectangle

Extends: SceneObjectBillboard

Draws a DrawableRectangle. Extends SceneObjectBillboard, so a rectangle orients and foreshortens in 3D in the oriented draw modes and stays screen-aligned in the direct ones, exactly like an image does.

Unlike an image, though, a rectangle has no texture to sample: it's a single flat color. So it never needs the inherited pinned-corners path - filling the projected quad produces identical pixels for far less work, and DrawableRectangle never has to hold a bitmap of its own. This is how SceneObjectPolygon draws, for the same reason.

It does still cache that fill into a temp bitmap in the oriented draw modes, exactly like a polygon: filling a rotated quad means rasterizing two triangles through scratch bitmaps, which is far too expensive to repeat every frame for an object that hasn't moved. In the direct (billboard) draw modes there's nothing worth caching - the draw is already a single DrawRect - so those skip the temp bitmap entirely.

Parameters

• name (string)
• drawableObj (DrawableRectangle)

Properties

• drawable (DrawableRectangle)

Returns

• BGE.SceneObjectRectangle

SceneObjectText

Extends: SceneObjectBillboard

Parameters

• name (string)
• drawableObj (DrawableText)

Properties

• drawable (DrawableText)

Returns

• BGE.SceneObjectText

MotionChecker

Properties

• previousTransform (dynamic)
• movedLastFrame (boolean)

SomeConst

Default: 23

TagList

Returns

• BGE.TagList