cugl Namespace Reference

Namespaces
namespace	audio
namespace	filetool
namespace	graphics
namespace	hashtool
namespace	netcode
namespace	physics2
namespace	poly2
namespace	scene2
namespace	scene3
namespace	strtool

Classes
class	AccelerationEvent
class	Accelerometer
class	Action
class	ActionTimeline
class	Affine2
class	AnimateSprite
class	Application
class	Asset
class	AssetManager
class	BaseLoader
class	BinaryReader
class	BinaryWriter
class	ButtonState
class	Camera
class	Color4
class	Color4f
class	ComplexExtruder
class	CoreGesture
class	CoreGestureEvent
class	DelaunayTriangulator
class	Display
class	EarclipTriangulator
class	EasingBezier
class	EasingFactory
class	FreeList
class	Frustum
class	GameController
class	GameControllerAxisEvent
class	GameControllerButtonEvent
class	GameControllerDPadEvent
class	GameControllerInput
class	GameControllerInputEvent
class	GenericLoader
class	GestureRecognizer
class	GreedyFreeList
class	Input
class	InputDevice
class	JsonLoader
class	JsonReader
class	JsonValue
class	JsonWriter
class	Keyboard
struct	KeyCodeHasher
class	KeyEvent
class	Loader
class	Logger
class	Mat4
class	Mouse
class	MouseEvent
class	MouseWheelEvent
class	OrthographicCamera
class	PanEvent
class	PanGesture
class	Path2
class	PathFactory
class	PathSmoother
class	PerspectiveCamera
class	PinchEvent
class	PinchGesture
class	Plane
class	Poly2
class	PolyFactory
class	Polynomial
class	Quaternion
class	Random
class	Ray
class	Rect
class	Scene
struct	scheduable
class	SimpleExtruder
class	Size
class	SpinEvent
class	SpinGesture
class	Spline2
class	SplinePather
class	TextEditEvent
class	TextInput
class	TextInputEvent
class	TextReader
class	TextWriter
class	ThreadPool
class	Timestamp
class	TouchEvent
class	Touchscreen
class	UnistrokeGesture
class	Vec2
class	Vec3
class	Vec4
class	WidgetLoader
class	WidgetValue

Typedefs
typedef std::function< void(float t, ActionState state)>	ActionFunction
typedef std::function< void(const std::string key, float time, float actual)>	ActionListener
typedef std::function< float(float)>	EasingFunction
typedef std::function< void(const std::string key, bool success)>	LoaderCallback
typedef Sint64	TouchID
typedef Vec2	Point2
typedef Vec3	Point3

Enumerations
enum class	ActionState : int { BEGIN , UPDATE , FINISH }
enum class	KeyCode : int {   NUM_0 = SDLK_0 , NUM_1 = SDLK_1 , NUM_2 = SDLK_2 , NUM_3 = SDLK_3 ,   NUM_4 = SDLK_4 , NUM_5 = SDLK_5 , NUM_6 = SDLK_6 , NUM_7 = SDLK_7 ,   NUM_8 = SDLK_8 , NUM_9 = SDLK_9 , A = SDLK_a , B = SDLK_b ,   C = SDLK_c , D = SDLK_d , E = SDLK_e , F = SDLK_f ,   G = SDLK_g , H = SDLK_h , I = SDLK_i , J = SDLK_j ,   K = SDLK_k , L = SDLK_l , M = SDLK_m , N = SDLK_n ,   O = SDLK_o , P = SDLK_p , Q = SDLK_q , R = SDLK_r ,   S = SDLK_s , T = SDLK_t , U = SDLK_u , V = SDLK_v ,   W = SDLK_w , X = SDLK_x , Y = SDLK_y , Z = SDLK_z ,   ARROW_DOWN = SDLK_DOWN , ARROW_LEFT = SDLK_LEFT , ARROW_RIGHT = SDLK_RIGHT , ARROW_UP = SDLK_UP ,   QUOTE = SDLK_QUOTE , BACKSLASH = SDLK_BACKSLASH , COMMA = SDLK_COMMA , EQUALS = SDLK_EQUALS ,   BACKQUOTE = SDLK_BACKQUOTE , LEFT_BRACKET = SDLK_LEFTBRACKET , MINUS = SDLK_MINUS , PERIOD = SDLK_PERIOD ,   RIGHT_BRACKET = SDLK_RIGHTBRACKET , SEMICOLON = SDLK_SEMICOLON , SLASH = SDLK_SLASH , BACKSPACE = SDLK_BACKSPACE ,   SPACE = SDLK_SPACE , TAB = SDLK_TAB , DEL = SDLK_DELETE , END = SDLK_END ,   ESCAPE = SDLK_ESCAPE , HOME = SDLK_HOME , HELP = SDLK_HELP , PAGE_DOWN = SDLK_PAGEDOWN ,   PAGE_UP = SDLK_PAGEUP , PAUSE = SDLK_PAUSE , RETURN = SDLK_RETURN , ENTER = SDLK_RETURN2 ,   CAPS_LOCK = SDLK_CAPSLOCK , LEFT_ALT = SDLK_LALT , LEFT_CTRL = SDLK_LCTRL , LEFT_SHIFT = SDLK_LSHIFT ,   LEFT_META = SDLK_LGUI , RIGHT_ALT = SDLK_RALT , RIGHT_CTRL = SDLK_RCTRL , RIGHT_SHIFT = SDLK_RSHIFT ,   RIGHT_META = SDLK_RGUI , NUMLOCK = SDLK_NUMLOCKCLEAR , KEYPAD_0 = SDLK_KP_0 , KEYPAD_1 = SDLK_KP_1 ,   KEYPAD_2 = SDLK_KP_2 , KEYPAD_3 = SDLK_KP_3 , KEYPAD_4 = SDLK_KP_4 , KEYPAD_5 = SDLK_KP_5 ,   KEYPAD_6 = SDLK_KP_6 , KEYPAD_7 = SDLK_KP_7 , KEYPAD_8 = SDLK_KP_8 , KEYPAD_9 = SDLK_KP_9 ,   KEYPAD_CLEAR = SDLK_KP_CLEAR , KEYPAD_EQUALS = SDLK_KP_EQUALS , KEYPAD_DIVIDE = SDLK_KP_DIVIDE , KEYPAD_MULTIPLY = SDLK_KP_MULTIPLY ,   KEYPAD_MINUS = SDLK_KP_MINUS , KEYPAD_PLUS = SDLK_KP_PLUS , KEYPAD_ENTER = SDLK_KP_ENTER , UNKNOWN = SDLK_POWER }
enum class	KeyCategory {   NUMBER , LETTER , ARROW , PUNCTUATION ,   SPECIAL , MODIFIER , KEYPAD , UNKNOWN }
enum class	CoreGestureType : int { NONE = 0 , PAN = 1 , PINCH = 2 , SPIN = 3 }

Functions
Vec2 &	operator*= (Vec2 &v, const Affine2 &m)
const Vec2	operator* (const Vec2 v, const Affine2 &m)
const Affine2	operator* (float scalar, const Affine2 &m)
const Color4f	operator* (float s, const Color4f c)
const Color4	operator* (float s, Color4 c)
Vec2 &	operator*= (Vec2 &v, const Mat4 &m)
const Vec2	operator* (const Vec2 v, const Mat4 &m)
Vec3 &	operator*= (Vec3 &v, const Mat4 &m)
const Vec3	operator* (const Vec3 v, const Mat4 &m)
Vec4 &	operator*= (Vec4 &v, const Mat4 &m)
const Vec4	operator* (const Vec4 v, const Mat4 &m)
const Mat4	operator* (float scalar, const Mat4 &m)
Vec3 &	operator*= (Vec3 &v, const Quaternion &quat)
const Vec3	operator* (const Vec3 v, const Quaternion &quat)
const Quaternion	operator* (float s, const Quaternion &quat)
const Vec2	operator* (float x, const Vec2 v)
const Vec2	operator/ (float x, const Vec2 v)
const Vec3	operator* (float x, const Vec3 v)
const Vec3	operator/ (float x, const Vec3 v)
const Vec4	operator* (float x, const Vec4 v)
const Vec4	operator/ (float x, const Vec4 v)
SDL_FORCE_INLINE Uint16	marshall (Sint16 value)
SDL_FORCE_INLINE Uint16	marshall (Uint16 value)
SDL_FORCE_INLINE Uint32	marshall (Sint32 value)
SDL_FORCE_INLINE Uint32	marshall (Uint32 value)
SDL_FORCE_INLINE Uint64	marshall (Sint64 value)
SDL_FORCE_INLINE Uint64	marshall (Uint64 value)
SDL_FORCE_INLINE float	marshall (float value)
SDL_FORCE_INLINE double	marshall (double value)

Detailed Description

The primary CUGL namespace

This namespace is for all classes and functions internal to the CUGL game engine. It does not include external tools like Box 2d or poly2tri.

Typedef Documentation

ActionFunction

cugl::ActionFunction

This type represents an action to interpolate.

Actions can be represented as any function on the range [0,1], where 0 is the beginning of the action and 1 is the end of the action (e.g. time is normalized). The effect of this function on game state is user-defined.

For easing purposes, the interpolation function should support inputs outside the range [0,1], even if that just means clamping the input. In addition, the function should make no assumptions about monotonicity of the function calls; the value t can jump about unexpectedly.

Because of this, it can be hard to tell when the animation has just started and when it has ended. That is the purpose of the state attribute.

The function type is equivalent to

 std::function<void(float t, ActionState state)>

Parameters

t	The interpolation value [0,1]
state	The action state

ActionListener

cugl::ActionListener

This type represents a listener for monitoring an ActionTimeline

In CUGL, listeners are implemented as a set of callback functions, not as objects. This allows each listener to implement as much or as little functionality as it wants. A listener is identified by a key which should be a globally unique unsigned int.

Typically ActionTimeline listeners are used for notifying when an action has completed. But like Unity, we allow for a callback function at any point of the timeline. With that said, frame rate imprecision means that the time at which the callback is executed is not exactly the same a time as when the listener is invoked.

Listener times are relative to the duration of the event, and are not normalized in the range [0,1].

The function type is equivalent to

 std::function<void(const std::string key, float time, float actual)>

Parameters

key	The key identifying the action
time	The requested time of this callback
actual	The actual time of this callback

EasingFunction

cugl::EasingFunction

An easing function is an interpolation function that (usually) maps [0,1] to [0,1] with f(0) = 0 and f(1) = 1. It is used to control the speed of an action. If f(t) = t, the result is standard linear interpolation, providing a smooth animation. Nonlinear curves allow the animation to adjust its speed over time. An easing function can map outside of the range so long as the end points are still fixed. This allows for overshoot and correction in the animation. See

http://easings.net

For examples of easing functions.

LoaderCallback

cugl::LoaderCallback

This type represents a callback for asynchronous asset loading

This callback is associated with an asset at the time of the asychronous load request. When the asset either loads, or fails to load, this callback is called with the asset status.

In the case of JSON asset directories, a single callback may be associated with several assets. In that case, the callback funtion is called each time that an asset loads or fails to load. If an entire node in the asset directory fails to load, the callback function will be notified using the key for that JSON node.

The function type is equivalent to

 std::function<void(const std::string key, bool success)>

Parameters

key	The key to associate with the asset (or asset category)
success	Whether the asset was successfully loaded

Point2

typedef Vec2 cugl::Point2

Provide an alternative name for Vec2

Point3

typedef Vec3 cugl::Point3

Provide an alternative name for Vec3

TouchID

typedef Sint64 cugl::TouchID

This is the type representing a finger or touch

Enumeration Type Documentation

ActionState

enum class cugl::ActionState : int

strong

This class represents the state of an action.

Actions have a beginning, a middle, and end. Because of easing functions, it is never possible to tell which part we are in from the time alone. Therefore we use this enum to track this state.

Enumerator
BEGIN	The start of this action (before the first update)
UPDATE	The middle of this action (currently updating)
FINISH	The end of this action (after the last update)

CoreGestureType

enum class cugl::CoreGestureType : int

strong

This enum represents a core gesture type.

Core gestures are the primary two-finger gestures: pan, spin, and spread. This simple enumeration indicates which gestures have been recognized.

These types are currently exclusive (e.g. you cannot have a pan at the same time as a pinch). This is because the purpose of the core gesture device is to intelligently choose between gestures.

KeyCategory

enum class cugl::KeyCategory

strong

! This enum represents the category of the key

Categories are used to group key codes in rough groups

Enumerator
NUMBER	This key code is a number 0 to 9
LETTER	This key code is letter in the roman alphabet
ARROW	This key code is an arrow key
PUNCTUATION	This key code is a punctuation (or space) marker
SPECIAL	This key code is a special character, including return or enter
MODIFIER	This key code is a modier like shift or control
KEYPAD	This key code is a character from the keypad
UNKNOWN	This key code is not supported by CUGL

KeyCode

enum class cugl::KeyCode : int

strong

This is enum represents a key on a keyboard.

The keys available are subset of the full range of available keys. Because of our goal of cross-platform support, we only support keys that are found on most common keyboards.

The Input dispatcher will convert from an SDL keycode this enum. That means it is possible to receive a KeyCode that is not present in the enum. Any switch statement for this enum should have a default value.

Enumerator
NUM_0	The 0 key
NUM_1	The 1 key
NUM_2	The 2 key
NUM_3	The 3 key
NUM_4	The 4 key
NUM_5	The 5 key
NUM_6	The 6 key
NUM_7	The 7 key
NUM_8	The 8 key
NUM_9	The 9 key
A	The A key
B	The B key
C	The C key
D	The D key
E	The E key
F	The F key
G	The G key
H	The H key
I	The I key
J	The J key
K	The K key
L	The L key
M	The M key
N	The N key
O	The O key
P	The P key
Q	The Q key
R	The R key
S	The S key
T	The T key
U	The U key
V	The V key
W	The W key
X	The X key
Y	The Y key
Z	The Z key
ARROW_DOWN	The down arrow key
ARROW_LEFT	The Left arrow key
ARROW_RIGHT	The right arrow key
ARROW_UP	The up arrow key
QUOTE	The ' (apostrophe) key
BACKSLASH	The \ (backslash) key
COMMA	The , (comma) key
EQUALS	The = (equals) key
BACKQUOTE	The ` (grave accent) key
LEFT_BRACKET	The [ (left bracket) ley
MINUS	The - (minus) key
PERIOD	The . (period) key
RIGHT_BRACKET	The ] (right bracket) key
SEMICOLON	The ; (semicolon) key
SLASH	The / (slash) key
BACKSPACE	The backspace key
SPACE	The spacebar
TAB	The tab key
DEL	The Delete key
END	The End key
ESCAPE	The Esc key
HOME	The Home key
HELP	The Help key
PAGE_DOWN	The PageDown key
PAGE_UP	The PageUp key
PAUSE	The Pause/Break key
RETURN	The Return key
ENTER	The Enter key
CAPS_LOCK	The Caps Lock key
LEFT_ALT	The left Alt/Option key
LEFT_CTRL	The left Ctrl key
LEFT_SHIFT	The left Shift key
LEFT_META	The left Windows/Apple/Meta key
RIGHT_ALT	The right Alt/Option key
RIGHT_CTRL	The right Ctrl key
RIGHT_SHIFT	The right Shift key
RIGHT_META	The right Windows/Apple/Meta key
NUMLOCK	The Numlock/Clear key
KEYPAD_0	Tthe 0 key (numeric keypad)
KEYPAD_1	The 1 key (numeric keypad)
KEYPAD_2	The 2 key (numeric keypad)
KEYPAD_3	The 3 key (numeric keypad)
KEYPAD_4	The 4 key (numeric keypad)
KEYPAD_5	The 5 key (numeric keypad)
KEYPAD_6	The 6 key (numeric keypad)
KEYPAD_7	The 7 key (numeric keypad)
KEYPAD_8	The 8 key (numeric keypad)
KEYPAD_9	The 9 key (numeric keypad)
KEYPAD_CLEAR	The Clear key (numeric keypad)
KEYPAD_EQUALS	The = [equals] key (numeric keypad)
KEYPAD_DIVIDE	The / [divide] key (numeric keypad)
KEYPAD_MULTIPLY	The * [multiply] key (numeric keypad)
KEYPAD_MINUS	The - [minus] key (numeric keypad)
KEYPAD_PLUS	The + [plus] key (numeric keypad)
KEYPAD_ENTER	The Enter key (numeric keypad)
UNKNOWN	We have no idea what this key is

Function Documentation

marshall() [1/8]

SDL_FORCE_INLINE double cugl::marshall

(

double

value

)

Returns the given value encoded in network order

On a big-endian system, this function has no effect. On a little-endian system, it swaps the bytes to put them in big-endian order.

This function is idempotent. To decode an encoded value, call this function on the value again.

Parameters

value

The value to encode

Returns

the given value encoded in network order

marshall() [2/8]

SDL_FORCE_INLINE float cugl::marshall

(

float

value

)

Returns the given value encoded in network order

On a big-endian system, this function has no effect. On a little-endian system, it swaps the bytes to put them in big-endian order.

This function is idempotent. To decode an encoded value, call this function on the value again.

Parameters

value

The value to encode

Returns

the given value encoded in network order

marshall() [3/8]

SDL_FORCE_INLINE Uint16 cugl::marshall

(

Sint16

value

)

Returns the given value encoded in network order

On a big-endian system, this function has no effect. On a little-endian system, it swaps the bytes to put them in big-endian order.

This function is idempotent. To decode an encoded value, call this function on the value again.

Parameters

value

The value to encode

Returns

the given value encoded in network order

marshall() [4/8]

SDL_FORCE_INLINE Uint32 cugl::marshall

(

Sint32

value

)

Returns the given value encoded in network order

On a big-endian system, this function has no effect. On a little-endian system, it swaps the bytes to put them in big-endian order.

This function is idempotent. To decode an encoded value, call this function on the value again.

Parameters

value

The value to encode

Returns

the given value encoded in network order

marshall() [5/8]

SDL_FORCE_INLINE Uint64 cugl::marshall

(

Sint64

value

)

Returns the given value encoded in network order

On a big-endian system, this function has no effect. On a little-endian system, it swaps the bytes to put them in big-endian order.

This function is idempotent. To decode an encoded value, call this function on the value again.

Parameters

value

The value to encode

Returns

the given value encoded in network order

marshall() [6/8]

SDL_FORCE_INLINE Uint16 cugl::marshall

(

Uint16

value

)

Returns the given value encoded in network order

On a big-endian system, this function has no effect. On a little-endian system, it swaps the bytes to put them in big-endian order.

This function is idempotent. To decode an encoded value, call this function on the value again.

Parameters

value

The value to encode

Returns

the given value encoded in network order

marshall() [7/8]

SDL_FORCE_INLINE Uint32 cugl::marshall

(

Uint32

value

)

Returns the given value encoded in network order

On a big-endian system, this function has no effect. On a little-endian system, it swaps the bytes to put them in big-endian order.

This function is idempotent. To decode an encoded value, call this function on the value again.

Parameters

value

The value to encode

Returns

the given value encoded in network order

marshall() [8/8]

SDL_FORCE_INLINE Uint64 cugl::marshall

(

Uint64

value

)

Returns the given value encoded in network order

On a big-endian system, this function has no effect. On a little-endian system, it swaps the bytes to put them in big-endian order.

This function is idempotent. To decode an encoded value, call this function on the value again.

Parameters

value

The value to encode

Returns

the given value encoded in network order

operator*() [1/13]

const Vec2 cugl::operator* ( const Vec2  v, const Affine2 &  m  )

inline

Returns a copy of the vector after it is transformed.

Parameters

v	The point to transform.
m	The transform to apply.

Returns

a copy of the vector after it is transformed.

operator*() [2/13]

const Vec2 cugl::operator* ( const Vec2  v, const Mat4 &  m  )

inline

Returns a copy of the vector transformed by the given matrix.

The vector is treated as a point, which means that translation is applied to the result.

Parameters

v	The point to transform.
m	The matrix to transform by.

Returns

a copy of the vector transformed by the given matrix.

operator*() [3/13]

const Vec3 cugl::operator* ( const Vec3  v, const Mat4 &  m  )

inline

Returns a copy of the vector transformed by the given matrix.

The vector is treated as a point, which means that translation is applied to the result.

Parameters

v	The point to transform.
m	The matrix to transform by.

Returns

a copy of the vector transformed by the given matrix.

operator*() [4/13]

const Vec3 cugl::operator* ( const Vec3  v, const Quaternion &  quat  )

inline

Returns a copy of the vector rotated by the quaternion.

The rotation is defined by the matrix associated with the vector. As per the convention for Mat4, we only allow vectors to be multiplied on the right by quaternions.

Parameters

v	The vector to rotate.
quat	The rotation quaternion.

Returns

a copy of the vector rotated by the quaternion.

operator*() [5/13]

const Vec4 cugl::operator* ( const Vec4  v, const Mat4 &  m  )

inline

Returns a copy of the vector transformed by the given matrix.

The vector is treated as is. Hence whether or not translation is applied depends on the value of w.

Parameters

v	The point to transform.
m	The matrix to transform by.

Returns

a copy of the vector transformed by the given matrix.

operator*() [6/13]

const Color4 cugl::operator* ( float  s, Color4  c  )

inline

Returns the scalar product of the given color with the given value.

The scaling is clamped so that this remains a valid color.

This version of scaling always multiplies the alpha values.

Parameters

s	The value to scale by.
c	The color to scale.

Returns

The scaled color.

operator*() [7/13]

const Color4f cugl::operator* ( float  s, const Color4f  c  )

inline

Returns the scalar product of the given color with the given value.

The scaling is clamped so that this remains a valid color.

This version of scaling always multiplies the alpha values.

Parameters

s	The value to scale by.
c	The color to scale.

Returns

The scaled color.

operator*() [8/13]

const Quaternion cugl::operator* ( float  s, const Quaternion &  quat  )

inline

Returns the scalar product of the quaternion with the given value.

Parameters

s	The value to scale by.
quat	The quaternion to scale.

Returns

The scalar product of this quaternion with the given value.

operator*() [9/13]

const Affine2 cugl::operator* ( float  scalar, const Affine2 &  m  )

inline

Multiplies the components of the given matrix by the specified scalar.

The scalar is applied to BOTH the core matrix and the offset.

Parameters

scalar	The scalar value.
m	The transform to scale.

Returns

a copy of the scaled transform

operator*() [10/13]

const Mat4 cugl::operator* ( float  scalar, const Mat4 &  m  )

inline

Multiplies the components of the given matrix by the specified scalar.

Parameters

scalar	The scalar value.
m	The matrix to transform by.

Returns

a copy of the scaled matrix

operator*() [11/13]

const Vec2 cugl::operator* ( float  x, const Vec2  v  )

inline

Returns the scalar product of the given vector with the given value.

Parameters

x	The value to scale by.
v	The vector to scale.

Returns

The scaled vector.

operator*() [12/13]

const Vec3 cugl::operator* ( float  x, const Vec3  v  )

inline

Returns the scalar product of the given vector with the given value.

Parameters

x	The value to scale by.
v	The vector to scale.

Returns

The scaled vector.

operator*() [13/13]

const Vec4 cugl::operator* ( float  x, const Vec4  v  )

inline

Returns the scalar product of the given vector with the given value.

Parameters

x	The value to scale by.
v	The vector to scale.

Returns

The scaled vector.

operator*=() [1/5]

Vec2 & cugl::operator*= ( Vec2 &  v, const Affine2 &  m  )

inline

Transforms the given point in place.

Parameters

v	The point to transform.
m	The transform to apply.

Returns

this point, after the transformation occurs.

operator*=() [2/5]

Vec2 & cugl::operator*= ( Vec2 &  v, const Mat4 &  m  )

inline

Transforms the given point by the given matrix.

The vector is treated as a point, which means that translation is applied to the result.

Parameters

v	The point to transform.
m	The matrix to transform by.

Returns

this point, after the transformation occurs.

operator*=() [3/5]

Vec3 & cugl::operator*= ( Vec3 &  v, const Mat4 &  m  )

inline

Transforms the given point by the given matrix.

The vector is treated as a point, which means that translation is applied to the result.

Parameters

v	The point to transform.
m	The matrix to transform by.

Returns

this point, after the transformation occurs.

operator*=() [4/5]

Vec3 & cugl::operator*= ( Vec3 &  v, const Quaternion &  quat  )

inline

Rotates the vector in place by the quaternion.

The rotation is defined by the matrix associated with the vector. As per the convention for Mat4, we only allow vectors to be multiplied on the right by quaternions.

Parameters

v	The vector to rotate.
quat	The rotation quaternion.

Returns

a reference to the vector, after rotation.

operator*=() [5/5]

Vec4 & cugl::operator*= ( Vec4 &  v, const Mat4 &  m  )

inline

Transforms the given point by the given matrix.

The vector is treated as is. Hence whether or not translation is applied depends on the value of w.

Parameters

v	The point to transform.
m	The matrix to transform by.

Returns

this point, after the transformation occurs.

operator/() [1/3]

const Vec2 cugl::operator/ ( float  x, const Vec2  v  )

inline

Returns the division of the given value by the vector.

Parameters

x	The value to divide
v	The vector to divide by.

Returns

the division of the given value by the vector.

operator/() [2/3]

const Vec3 cugl::operator/ ( float  x, const Vec3  v  )

inline

Returns the division of the given value by the vector.

Parameters

x	The value to divide
v	The vector to divide by.

Returns

the division of the given value by the vector.

operator/() [3/3]

const Vec4 cugl::operator/ ( float  x, const Vec4  v  )

inline

Returns the division of the given value by the vector.

Parameters

x	The value to divide
v	The vector to divide by.

Returns

the division of the given value by the vector.