Class Index | File Index

Classes


Class Index

_global_


R

The Render Engine namespace

R.collision.broadphase.AbstractCollisionModel

An abstract class to represent broad-phase collision models.

R.collision.broadphase.AbstractCollisionNode

A node within a broad-phase collision model which contains a list of game objects within it.

R.collision.broadphase.SpatialGrid

A structure which divides a finite space up into a coarse grid to perform "broad phase" collision determinations within the space.

R.collision.broadphase.SpatialGridNode

A single node within a R.collision.broadphase.SpatialGrid.

R.collision.CircleHull

A circular convex hull.

R.collision.ConvexHull

A convex hull with which to perform collision testing.

R.collision.OBBHull

A rectangular convex hull.

R.components.Base

All components extend from this object class.

R.components.Collider

Creates a collider component which tests the collision model for potential collisions.

R.components.collision.Box

An extension of the R.components.Collider which will check the object's axis-aligned bounding boxes for collision.

R.components.collision.Circle

An extension of the ColliderComponent which will check if the object's are colliding based on their world bounding circles.

R.components.collision.Convex

An extension of the ColliderComponent which will check the object's convex collision hulls using the Separating Axis Theorm (SAT).

R.components.Debug

A debugging component to render helpful debug widgets alongside an object.

R.components.Input

A component which can read an input device and make those inputs available to a R.engine.GameObject.

R.components.input.Keyboard

A component which responds to keyboard events and notifies its R.engine.GameObject when one of the events occurs.

R.components.input.Mouse

A component which responds to mouse events and notifies the host object when one of the events occurs.

R.components.input.Touch

A component which responds to touch events and notifies its R.engine.GameObject by triggering one of three events.

R.components.input.Wiimote

A component which responds to the Wiimote (in the Opera browser) is notifies its host object by calling a number of methods.

R.components.Logic

Logic components are sort of a catch-all of components.

R.components.logic.behaviors.Arrival

The arrival behavior component.

R.components.logic.behaviors.BaseBehavior

The base behavior component.

R.components.logic.behaviors.Flee

The flee behavior component.

R.components.logic.behaviors.ObstacleAvoidance

The obstacle avoidance behavior component.

R.components.logic.behaviors.Seek

The seek behavior component.

R.components.logic.behaviors.UnalignedCollisionAvoidance

The unaligned collision avoidance behavior component.

R.components.logic.behaviors.Wander

The wander behavior for the vehicle.

R.components.logic.Bounds

.

R.components.logic.Host

A component that can execute game objects.

R.components.logic.NetworkClientPosition

A very simple example component which sends the game object's client position in the world using a web socket.

R.components.logic.Notifier

A component which notifies objects when an action occurs.

R.components.logic.StateMachine

A component that uses a behavior tree to process state changes.

R.components.physics.BaseBody

The base component which initializes rigid bodies for use in a R.physics.Simulation.

R.components.physics.BaseJoint

The base component which initializes physical joints for use in a R.physics.Simulation.

R.components.physics.BaseMotorJoint

The base motor joint for all joints which can be driven by a motor.

R.components.physics.BoxBody

An extension of the R.components.BaseBody which creates a rectangular rigid body.

R.components.physics.CircleBody

An extension of the R.components.physics.BaseBody which creates a circular rigid body.

R.components.physics.DistanceJoint

A distance joint which maintains constant distance between two bodies in a R.physics.Simulation.

R.components.physics.MouseJoint

A mouse joint which allows the mouse to be used to interact within a R.physics.Simulation.

R.components.physics.PolyBody

An extension of R.components.BaseBody which creates a polygonal rigid body.

R.components.physics.PrismaticJoint

A prismatic joint which allows movement in one degree of freedom: translation along an axis anchored in the first body.

R.components.physics.PulleyJoint

A pulley joint which links two bodies together via a pulley in a R.physics.Simulation.

R.components.physics.RevoluteJoint

A revolute joint which allows two bodies to revolve around a common anchor point in a R.physics.Simulation.

R.components.physics.WeldJoint

A weld joint effectively welds two bodies together at a given point in a R.physics.Simulation.

R.components.Render

The base component class for components which render to an {@link R.rendercontexts.AbstractRenderContext render context}.

R.components.render.Billboard2D

The billboard component renders the contents of an image which was generated by a linked render component.

R.components.render.DOM

Render component for DOM elements.

R.components.render.Image

A {@link R.components.Render render component} that draws an image to the render context.

R.components.render.ParticleEmitter

A {@link R.components.Render render component} that allows the developer to link a particle emitter to a game object.

R.components.render.Sprite

A render component that renders its contents from a R.resources.types.Sprite.

R.components.render.Vector2D

A render component that renders its contents from an Array of points.

R.components.transform.BehaviorMover2D

A 2d transform component driven by different behaviors.

R.components.transform.Mover2D

A mover component that adds simplified physical transformations to an object.

R.components.transform.PlatformMover2D

A transform component to move around a tile map like the old "platformer" games

R.components.Transform2D

A simple component that maintains position, rotation, and scale.

R.debug.Console

A class for logging messages to a console reference object.

R.debug.ConsoleRef

The base class for all console objects.

R.debug.Metrics

A static class to be used to measure metrics of engine and game performance.

R.debug.Profiler

A static JavaScript implementation of a simple profiler.

R.Engine

The main engine class which is responsible for keeping the world up to date.

R.engine.BaseObject

The base object class which represents an object within the engine.

R.engine.Events

A static object for uniformly handling events within all browser platforms.

R.engine.Game

The game object represents an instance of a game.

R.engine.GameObject

A game object is a container for components.

R.engine.PooledObject

Pooled objects are created as needed, and reused from a static pool of all objects, organized by classname.

R.engine.Script

A static class which is used to load new JavaScript into the browser.

R.engine.Support

A static class with support methods the engine or games can use.

R.lang.AbstractTimer

The base abstract class for all timer objects.

R.lang.IntervalTimer

An extension of R.lang.AbstractTimer that wraps the window.setInterval method.

R.lang.Iterator

Create an iterator over a R.struct.Container or Array instance.

R.lang.Math2

A static class which provides methods for generating random integers and floats between 0 and 1.

R.lang.MultiTimeout

An extension of R.lang.Timeout that will repeat the specified number of times before destroying itself.

R.lang.OneShotTimeout

An extension of R.lang.Timeout which is a one-shot timer that cannot be restarted and will self-destroy after it completes its interval.

R.lang.OneShotTrigger

An extension of R.lang.OneShotTimeout which is a one-shot timer that triggers a callback, at regular intervals, until the timer has expired.

R.lang.Timeout

An extension of R.lang.AbstractTimer that wraps the window.setTimeout method.

R.math.Circle2D

A 2D circle class with helpful manipulation methods.

R.math.Math2D

A static class with methods and fields that are helpful when dealing with two dimensional mathematics.

R.math.Math3D

A static class with methods and fields that are helpful when dealing with two dimensional mathematics.

R.math.Point2D

A 2D point class with helpful methods for manipulation

R.math.Point3D

A 3D point class with helpful methods for manipulation

R.math.PooledMathObject

The base object class which represents a math object within the engine.

R.math.Rectangle2D

A 2D rectangle class with helpful manipulation methods.

R.math.Vector2D

A 2D vector class with helpful manipulation methods.

R.math.Vector3D

A 3D vector class with helpful manipulation methods.

R.objects.Fixture

A fixture is a simple rectangular area used to define either a solid area, or a trigger for a callback.

R.objects.Object2D

An object for use in a 2d game environment.

R.objects.PhysicsActor

A R.objects.PhysicsActor is an actor object within a game represented by a collection of components which can include rigid bodies and joints.

R.objects.SpriteActor

A SpriteActor is an actor object within a game, whose renderer is a 2D sprite.

R.particles.AbstractParticle

Base particle class.

R.particles.AccumulatorParticleEngine

An updated particle engine with an accumulator buffer so that effects such as bloom, glow, and tail can be achieved.

R.particles.effects.ExplosionParticle

An explosion particle

R.particles.effects.SprayParticle

A spray particle

R.particles.Emitter

Particle emitter class.

R.particles.ParticleEngine

The particle engine is a system for updating and expiring particles within a game environment.

R.physics.Simulation

A representation of a physical world.

R.rendercontexts.AbstractRenderContext

A base rendering context.

R.rendercontexts.CanvasContext

A canvas element represented within the engine.

R.rendercontexts.DocumentContext

A reference to the document.body element as a rendering context.

R.rendercontexts.HTMLDivContext

A simple extension of the R.rendercontexts.HTMLElementContext which uses a DIV element to represent the context.

R.rendercontexts.HTMLElementContext

A wrapper for any HTML element to convert it into a targetable render context.

R.rendercontexts.RenderContext2D

All 2D contexts should extend from this to inherit the methods which abstract the drawing methods.

R.rendercontexts.VirtualCanvasContext

A canvas render context whose world boundary is larger than the actual viewport.

R.rendercontexts.VirtualHTMLDivContext

A HTML element render context whose world boundary is larger than the actual viewport.

R.resources.loaders.AbstractResourceLoader

A resource loader is a generalized interface used by all resource loaders.

R.resources.loaders.BitmapFontLoader

Loads bitmap fonts and makes them available to the system.

R.resources.loaders.ImageLoader

Loads images and stores the reference to those images.

R.resources.loaders.LevelLoader

Loads 2D tilemapped levels for use in games.

R.resources.loaders.MultiResourceLoader

A resource loader which can load files of varying types from the server.

R.resources.loaders.ObjectLoader

Loads JSON objects from a specified URL.

R.resources.loaders.RemoteLoader

A base loader which implements the #exists method to synchronously check for the existence of a file.

R.resources.loaders.SoundLoader

Loads sounds and stores the reference to them using the provided sound system.

R.resources.loaders.SpriteLoader

Loads sprite resources and makes them available to the system.

R.resources.loaders.TileLoader

Loads tile resources and makes them available to the system.

R.resources.loaders.XMLLoader

Loads XML files from a specified URL.

R.resources.types.Image

A wrapper class for images.

R.resources.types.Level

Creates an instance of a Level object.

R.resources.types.Sound

Represents a sound object that is abstracted from the sound system.

R.resources.types.Sprite

A 2D sprite object.

R.resources.types.Tile

Represents a 2d tile.

R.resources.types.TileMap

A 2d tile map, comprised of many tiles.

R.Socket

A web socket for two-way network communication.

R.sound.AbstractSoundSystem

Sound system abstraction class for pluggable sound architecture.

R.sound.HTML5

Initializes the HTML5 sound system.

R.sound.SM2

Initializes the SoundManager2 sound system.

R.storage.AbstractDBStorage

R.storage.AbstractStorage is the base class of all storage objects.

R.storage.AbstractStorage

R.storage.AbstractStorage is the base class of all storage objects.

R.storage.BrowserStorage

R.storage.BrowserStorage is a generalized class for browser-based storage mechanisms.

R.storage.CookieStorage

R.storage.CookieStorage is used to maintain data in a cookie using a JSON object.

R.storage.PersistentStorage

R.storage.PersistentStorage is used to maintain data between browser sessions.

R.storage.TransientStorage

R.storage.TransientStorage is used to hold data that is used only while the game is active.

R.storage.WindowStorage

R.storage.WindowStorage is used to maintain data in "window.name" using a JSON object.

R.struct.CollisionData

An object which contains information about a collision.

R.struct.Container

A container is a logical collection of objects.

R.struct.HashContainer

A hash container is a logical collection of objects.

R.struct.LinkedList

A linked list is a logical collection of objects.

R.struct.MouseInfo

An object which contains information about the mouse in relation to a rendering context.

R.struct.RayInfo

An object which contains information about a ray.

R.struct.RedBlackTree

An implementation of a RedBlackTree data structure.

R.struct.Touch

A data object which represents a touch event generated by R.components.TouchInput.

R.struct.TouchInfo

An object which contains information about touch gestures in relation to a rendering context.

R.text.AbstractTextRenderer

Abstract class that provides the basic interface for all text render objects used by the R.text.TextRenderer.

R.text.BitmapText

A text renderer which draws text from a bitmap font file.

R.text.ContextText

A text renderer which draws text using the context's native text rendering mechansim.

R.text.TextRenderer

A 2d text rendering object.

R.text.VectorText

A text renderer which draws text with simple vectors.

R.ui.AbstractUIControl

Abstract class that provides the foundation for all UI controls which are rendered to a graphical context.

R.ui.ButtonControl

UI button control.

R.ui.CheckboxControl

UI checkbox control.

R.ui.FieldGroup

A physical grouping of UI controls.

R.ui.LabelControl

UI label control.

R.ui.RadioControl

UI checkbox control.

R.ui.TextInputControl

UI input control for the input of a single line of text.

R.util.console.Firebug

A console reference to the Firebug console.

R.util.console.HTML

A debug console that will use a pre-defined element to display its output.

R.util.console.MSIE

A console reference to the MSIE console.

R.util.console.Opera

A debug console for Opera browsers.

R.util.console.Webkit

A debug console abstraction for Webkit browsers.

R.util.FNV132

Implementation of FNV1 - a fast hash function.

R.util.FNV1a32

Implementation of FNV1a - a fast hash function.

R.util.FNV1Hash

A class for creating a hash value from a string.

R.util.RenderUtil

A static class of rendering utilities.

R.util.SocketUtil

A static class to create sockets for two-way network communication.

Documentation generated by JsDoc Toolkit 2.4.0 on Mon Mar 18 2013 16:09:21 GMT-0400 (EDT)