//----------------------------------------------------------------//
uintptr USLuaSerializer::Affirm ( USLuaState& state, int idx ) {
// if we're an object, affirm as such...
if ( state.IsType ( idx, LUA_TUSERDATA )) {
return this->Affirm ( state.GetLuaObject < USLuaObject >( -1 ));
}
// bail if we're not a table
if ( !state.IsType ( idx, LUA_TTABLE )) return 0;
// get the table's address
uintptr tableID = ( uintptr )lua_topointer ( state, idx );
// bail if the table's already been added
if ( this->mTableMap.contains ( tableID )) return tableID;
// add the ref now to avoid cycles
this->mTableMap [ tableID ].SetStrongRef ( state, idx );
// follow the table's refs to make sure everything gets added
u32 itr = state.PushTableItr ( idx );
while ( state.TableItrNext ( itr )) {
this->Affirm ( state, -1 );
}
return tableID;
}
//----------------------------------------------------------------//
u32 USLuaSerializer::WriteTableInitializer ( USStream& stream, USLuaState& state, int idx, cc8* prefix ) {
u32 count = 0;
u32 itr = state.PushTableItr ( idx );
while ( state.TableItrNext ( itr )) {
switch ( lua_type ( state, -2 )) {
case LUA_TSTRING: {
stream.Print ( "\t%s [ \"%s\" ] = ", prefix, lua_tostring ( state, -2 ));
break;
}
case LUA_TNUMBER: {
stream.Print ( "\t%s [ %s ]\t= ", prefix, lua_tostring ( state, -2 ));
break;
}
};
switch ( lua_type ( state, -1 )) {
case LUA_TBOOLEAN: {
int value = lua_toboolean ( state, -1 );
cc8* str = ( value ) ? "true": "false";
stream.Print ( "%s\n", str );
break;
}
case LUA_TTABLE: {
uintptr tableID = ( uintptr )lua_topointer ( state, -1 );
if ( this->mTableMap.contains ( tableID )) {
stream.Print ( "objects [ 0x%08X ]\n", tableID );
}
break;
}
case LUA_TSTRING: {
STLString str = _escapeString ( lua_tostring ( state, -1 ));
stream.Print ( "\"%s\"\n", str.c_str ());
break;
}
case LUA_TNUMBER: {
stream.Print ( "%s\n", lua_tostring ( state, -1 ));
break;
}
case LUA_TUSERDATA: {
USLuaObject* object = state.GetLuaObject < USLuaObject >( -1 );
u32 instanceID = this->GetID ( object );
stream.Print ( "objects [ 0x%08X ]\n", instanceID );
break;
}
case LUA_TLIGHTUSERDATA: {
stream.Print ( "%p,\n", lua_touserdata ( state, -1 ));
break;
}
};
++count;
}
return count;
}
//----------------------------------------------------------------//
void MOAIVertexFormat::RegisterLuaClass ( USLuaState& state ) {
state.SetField ( -1, "GL_BYTE", ( u32 )GL_BYTE );
//state.SetField ( -1, "GL_FIXED", ( u32 )GL_FIXED );
state.SetField ( -1, "GL_FLOAT", ( u32 )GL_FLOAT );
state.SetField ( -1, "GL_SHORT", ( u32 )GL_SHORT );
state.SetField ( -1, "GL_UNSIGNED_BYTE", ( u32 )GL_UNSIGNED_BYTE );
state.SetField ( -1, "GL_UNSIGNED_SHORT", ( u32 )GL_UNSIGNED_SHORT );
}
/** @name areaForRect
@text Returns the area for the specified rectangle.
@in number x1
@in number y1
@in number x2
@in number y2
@out number area The calculated area.
*/
int MOAICpShape::_areaForRect ( lua_State* L ) {
USLuaState state ( L );
if ( !state.CheckParams ( 1, "NNNN" )) return 0;
USMetaRect < cpFloat > rect = state.GetRect < cpFloat >( 1 );
rect.Bless ();
lua_pushnumber ( L, rect.Area ());
return 1;
}
/** @name setFrameSize
@text Sets the amount of time it takes for one frame to pass. This in effect can be used to set the FPS limit of the application by passing (1 / FPS).
@in number size The frame size (how long in seconds it takes for one frame to be rendered).
@out nil
*/
int MOAISim::_setFrameSize ( lua_State* L ) {
USLuaState state ( L );
if ( !state.CheckParams ( 1, "N" )) return 0;
MOAISim& device = MOAISim::Get ();
device.mStep = state.GetValue < double >( 1, device.mStep );
return 0;
}
/** @name getScale
@text Returns the default size of this font for use with the MOAITextbox:setTextSize function.
@in MOAIFont self
@out number size The default point size of the font.
*/
int MOAIFont::_getScale ( lua_State* L ) {
USLuaState state ( L );
if ( !state.CheckParams ( 1, "U" )) return 0;
MOAIFont* self = state.GetLuaObject < MOAIFont >( 1 );
if ( !self ) return 0;
lua_pushnumber ( state, self->GetScale ());
return 1;
}
//----------------------------------------------------------------//
void MOAITraits::RegisterLuaClass ( USLuaState& state ) {
MOAINode::RegisterLuaClass ( state );
state.SetField ( -1, "INHERIT_LOC", ( u32 )INHERIT_LOC );
state.SetField ( -1, "INHERIT_TRANSFORM", ( u32 )INHERIT_TRANSFORM );
state.SetField ( -1, "INHERIT_COLOR", ( u32 )INHERIT_COLOR );
state.SetField ( -1, "INHERIT_FRAME", ( u32 )INHERIT_FRAME );
state.SetField ( -1, "INHERIT_PARTITION", ( u32 )INHERIT_PARTITION );
state.SetField ( -1, "INHERIT_SHADER", ( u32 )INHERIT_SHADER );
}
/** @name timeToFrames
@text Converts the number of time passed in seconds to frames.
@in number time The number of seconds.
@out number frames The equivilant number of frames for the specified number of seconds.
*/
int MOAISim::_timeToFrames ( lua_State* L ) {
USLuaState state ( L );
if ( !state.CheckParams ( 1, "N" )) return 0;
float time = state.GetValue < float >( 1, 0.0f );
MOAISim& device = MOAISim::Get ();
lua_pushnumber ( state, time / device.mStep );
return 0;
}
/** @name framesToTime
@text Converts the number of frames to time passed in seconds.
@in number frames The number of frames.
@out number time The equivilant number of seconds for the specified number of frames.
*/
int MOAISim::_framesToTime ( lua_State* L ) {
USLuaState state ( L );
if ( !state.CheckParams ( 1, "N" )) return 0;
float frames = state.GetValue < float >( 1, 0.0f );
MOAISim& device = MOAISim::Get ();
lua_pushnumber ( state, frames * device.mStep );
return 1;
}
/** @name showStyle
@text Enables of disables drawing of a given debug line style.
@in number styleID See MOAIDebugLines class documentation for a list of styles.
@opt boolean show Default value is 'true'
@out nil
*/
int MOAIDebugLines::_showStyle ( lua_State* L ) {
USLuaState state ( L );
if ( !state.CheckParams ( 1, "N" )) return 0;
u32 styleID = state.GetValue < u32 >( 1, 0 );
bool show = state.GetValue < bool >( 2, true );
MOAIDebugLines::Get ().ShowStyle ( styleID, show );
return 0;
}
/** @name pushRenderPass
@text Pushes the specified prim onto the render stack.
@in MOAIProp2D prop The viewport of the render prim.
@out nil
*/
int MOAISim::_pushRenderPass ( lua_State* L ) {
USLuaState state ( L );
if ( !state.CheckParams ( 1, "U" )) return 0;
MOAIProp2D* prop = state.GetLuaObject < MOAIProp2D >( 1 );
if ( !prop ) return 0;
MOAISim& device = MOAISim::Get ();
device.PushRenderPass ( prop );
return 0;
}
/** @name areaForCircle
@text Returns the area for a polygon.
@in table vertices Array containg vertex coordinate components ( t[1] = x0, t[2] = y0, t[3] = x1, t[4] = y1... )
@out number area
*/
int MOAICpShape::_areaForPolygon ( lua_State* L ) {
USLuaState state ( L );
if ( !state.CheckParams ( 1, "T" )) return 0;
cpVect verts [ MAX_POLY_VERTS ];
int numVerts = MOAICpShape::LoadVerts ( state, 1, verts, MAX_POLY_VERTS );
if ( numVerts && cpPolyValidate ( verts, numVerts )) {
cpFloat area = cpAreaForPoly ( numVerts, verts );
area = area < 0 ? -area : area;
lua_pushnumber ( L, area );
return 1;
}
return 0;
}
/** @name serializeToString
@text Serializes the specified table or userdata to a string. Useful for sending data to a remote server.
@in MOAISerializer self
@opt table data The table data to serialize.
@opt userdata data The userdata (object) to serialize. You must provide either a table or userdata, but not both.
@out string serialized The serialized string.
*/
int MOAISerializer::_serializeToString ( lua_State* L ) {
USLuaState state ( L );
if ( !state.CheckParams ( 1, "U" )) return 0;
if ( !( state.IsType ( 1, LUA_TTABLE ) || state.IsType ( 1, LUA_TUSERDATA ))) return 0;
USLuaSerializer serializer;
serializer.Affirm ( state, 1 );
serializer.AddLuaReturn ( state, 1 );
STLString result = serializer.SerializeToString ();
lua_pushstring ( state, result );
return 1;
}
//----------------------------------------------------------------//
bool MOAIEventSource::PushListenerAndSelf ( u32 eventID, USLuaState& state ) {
if ( this->mListenerTable ) {
this->mListenerTable.PushRef ( state );
if ( state.GetFieldWithType ( -1, eventID, LUA_TFUNCTION )) {
lua_replace ( state, -2 );
this->PushLuaUserdata ( state );
return true;
}
state.Pop ( 1 );
}
return false;
}
//----------------------------------------------------------------//
void MOAIDebugLines::RegisterLuaClass ( USLuaState& state ) {
luaL_Reg regTable[] = {
{ "setStyle", _setStyle },
{ "showStyle", _showStyle },
{ NULL, NULL }
};
luaL_register( state, 0, regTable );
state.SetField ( -1, "PARTITION_CELLS", ( u32 )PARTITION_CELLS );
state.SetField ( -1, "PARTITION_PADDED_CELLS", ( u32 )PARTITION_PADDED_CELLS );
state.SetField ( -1, "PROP_MODEL_BOUNDS", ( u32 )PROP_MODEL_BOUNDS );
state.SetField ( -1, "PROP_WORLD_BOUNDS", ( u32 )PROP_WORLD_BOUNDS );
state.SetField ( -1, "TEXT_BOX", ( u32 )TEXT_BOX );
}
//----------------------------------------------------------------//
void MOAIGfxQuad2D::RegisterLuaClass ( USLuaState& state ) {
this->MOAIDeck2D::RegisterLuaClass ( state );
state.SetField ( -1, "FILTER_POINT", ( u32 )GL_NEAREST );
state.SetField ( -1, "FILTER_BILERP", ( u32 )GL_LINEAR );
}
/** @name areaForSegment
@text Returns the area for the specified segment.
@in number x1
@in number y1
@in number x2
@in number y2
@in number r
@out number area The calculated area.
*/
int MOAICpShape::_areaForSegment ( lua_State* L ) {
USLuaState state ( L );
if ( !state.CheckParams ( 1, "UUNNNN" )) return 0;
cpVect a;
a.x = state.GetValue < cpFloat >( 1, 0 );
a.y = state.GetValue < cpFloat >( 2, 0 );
cpVect b;
b.x = state.GetValue < cpFloat >( 3, 0 );
b.y = state.GetValue < cpFloat >( 4, 0 );
cpFloat r = state.GetValue < cpFloat >( 5, 0 );
lua_pushnumber ( L, cpAreaForSegment ( a, b, r ));
return 1;
}
//----------------------------------------------------------------//
void USLuaSerializer::SetRefField ( USLuaState& state, int idx, cc8* name, USLuaObject* object ) {
if ( state.IsType ( idx, LUA_TTABLE )) {
this->PushRef ( state, object );
lua_setfield ( state, -2, name );
}
}
/** @name setStyle
@text Sets the particulars of a given debug line style.
@in number styleID See MOAIDebugLines class documentation for a list of styles.
@opt number size Pen size (in pixels) for the style. Default value is 1.
@opt number r Red component of line color. Default value is 1.
@opt number g Green component of line color. Default value is 1.
@opt number b Blue component of line color. Default value is 1.
@opt number a Alpha component of line color. Default value is 1.
@out nil
*/
int MOAIDebugLines::_setStyle ( lua_State* L ) {
USLuaState state ( L );
if ( !state.CheckParams ( 1, "N" )) return 0;
u32 styleID = state.GetValue < u32 >( 1, 0 );
u32 size = state.GetValue < u32 >( 2, 1 );
float r = state.GetValue < float >( 3, 1.0f );
float g = state.GetValue < float >( 4, 1.0f );
float b = state.GetValue < float >( 5, 1.0f );
float a = state.GetValue < float >( 6, 1.0f );
u32 color = USColor::PackRGBA ( r, g, b, a );
MOAIDebugLines::Get ().SetStyle ( styleID, size, color );
return 0;
}
//----------------------------------------------------------------//
void MOAIEventSource::AffirmListenerTable ( USLuaState& state ) {
if ( !mListenerTable ) {
lua_newtable ( state );
this->mListenerTable.SetRef ( state, -1, false );
state.Pop ( 1 );
}
}
/** @name openWindow
@text Opens a new window for the application to render on. This must be called before any rendering can be done, and it must only be called once.
@in string title The title of the window.
@in number width The width of the window in pixels.
@in number height The height of the window in pixels.
@out nil
*/
int MOAISim::_openWindow ( lua_State* L ) {
USLuaState state ( L );
if ( !state.CheckParams ( 1, "SNN" )) return 0;
cc8* title = lua_tostring ( state, 1 );
u32 width = state.GetValue < u32 >( 2, 320 );
u32 height = state.GetValue < u32 >( 3, 480 );
USGfxDevice::Get ().SetSize ( width, height );
AKUOpenWindowFunc openWindow = AKUGetFunc_OpenWindow ();
if ( openWindow ) {
openWindow ( title, width, height );
}
return 0;
}
/** @name setClearColor
@text At the start of each frame the device will by default automatically render a background color. Using this function you can set the background color that is drawn each frame. If you specify no arguments to this function, then automatic redraw of the background color will be turned off (i.e. the previous render will be used as the background).
@opt number red The red value of the color.
@opt number green The green value of the color.
@opt number blue The blue value of the color.
@opt number alpha The alpha value of the color.
@out nil
*/
int MOAISim::_setClearColor ( lua_State* L ) {
USLuaState state ( L );
MOAISim& sim = MOAISim::Get ();
if ( state.GetTop () == 0 ) {
sim.mClearFlags &= ~GL_COLOR_BUFFER_BIT;
}
else {
float r = state.GetValue < float >( 1, 0.0f );
float g = state.GetValue < float >( 2, 0.0f );
float b = state.GetValue < float >( 3, 0.0f );
float a = state.GetValue < float >( 4, 1.0f );
sim.mClearColor = USColor::PackRGBA ( r, g, b, a );
sim.mClearFlags |= GL_COLOR_BUFFER_BIT;
}
return 0;
}
SUPPRESS_EMPTY_FILE_WARNING
#if USE_CHIPMUNK
//================================================================//
// local
//================================================================//
//----------------------------------------------------------------//
/** @name areaForCircle
@text Returns the area for a ring or circle.
@overload
@in number radius
@out number area
@overload
@in number innerRadius
@in number outerRadius
@out number area
*/
int MOAICpShape::_areaForCircle ( lua_State* L ) {
USLuaState state ( L );
if ( !state.CheckParams ( 1, "N" )) return 0;
cpFloat r1;
cpFloat r2;
if ( state.GetTop () >= 2 ) {
r1 = state.GetValue < cpFloat >( 1, 0 );
r2 = state.GetValue < cpFloat >( 2, 0 );
}
else {
r1 = 0;
r2 = state.GetValue < cpFloat >( 1, 0 );
}
lua_pushnumber ( L, cpAreaForCircle ( r1, r2 ));
return 1;
}
//----------------------------------------------------------------//
void MOAIDraw::DrawLuaParams ( lua_State* L, u32 primType ) {
MOAIGfxDevice& gfxDevice = MOAIGfxDevice::Get ();
USLuaState state ( L );
u32 total = state.GetTop () >> 1;
gfxDevice.BeginPrim ( primType );
for ( u32 i = 0; i < total; ++i ) {
u32 idx = ( i << 1 ) + 1;
float x = state.GetValue < float >( idx, 0.0f );
float y = state.GetValue < float >( idx + 1, 0.0f );
gfxDevice.WriteVtx ( x, y );
gfxDevice.WritePenColor4b ();
}
gfxDevice.EndPrim ();
}
/** @name load
@text Attempts to load glyphs from the specified image file or MOAIDataBuffer containing image data.
@in MOAIFont self
@opt string filename A string indicating the path to an image file.
@opt MOAIDataBuffer data A MOAIDataBuffer containing image data. You must provide either a string or a MOAIDataBuffer, but not both.
@in string charCodes A string which defines the characters found in the font. For example if A and B are the first letters in the image, the first characters in the string would be "AB" and so forth.
@out nil
*/
int MOAIFont::_load ( lua_State* L ) {
USLuaState state ( L );
if ( !state.CheckParams ( 1, "U" )) return 0;
MOAIFont* self = state.GetLuaObject < MOAIFont >( 1 );
if ( !self ) return 0;
STLString charCodes = state.GetValue ( 3, "0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz.,?!" );
MOAIDataBuffer *data = state.GetLuaObject < MOAIDataBuffer >( 2 );
if ( data ) {
self->LoadFont ( *data, charCodes );
}
else {
STLString imageFile = state.GetValue ( 2, "" );
self->LoadFont ( imageFile, charCodes );
}
return 0;
}
//----------------------------------------------------------------//
void USLuaRef::SetRef ( USLuaState& state, int idx, bool weak ) {
this->Clear ();
this->mWeak = weak;
int top = state.GetTop ();
if ( lua_isnil ( state, idx ) == false ) {
USLuaRuntime& luaRuntime = USLuaRuntime::Get ();
if ( weak ) {
this->mRef = luaRuntime.mWeakRefTable.Ref ( state, idx );
}
else {
this->mRef = luaRuntime.mStrongRefTable.Ref ( state, idx );
}
this->mOwnsRef = true;
}
assert ( top == state.GetTop ());
}
//----------------------------------------------------------------//
void MOAIGfxDevice::RegisterLuaClass ( USLuaState& state ) {
state.SetField ( -1, "EVENT_RESIZE", ( u32 )EVENT_RESIZE );
luaL_Reg regTable [] = {
{ "isProgrammable", _isProgrammable },
{ "setListener", &MOAIGlobalEventSource::_setListener < MOAIGfxDevice > },
{ "setPenColor", _setPenColor },
{ "setPenWidth", _setPenWidth },
{ "setPointSize", _setPointSize },
{ NULL, NULL }
};
luaL_register( state, 0, regTable );
}
//----------------------------------------------------------------//
int USLuaRefTable::Ref ( USLuaState& state, int idx ) {
assert ( this->mTableID != LUA_NOREF );
idx = state.AbsIndex ( idx );
int refID = this->ReserveRefID ();
lua_rawgeti ( state, LUA_REGISTRYINDEX, this->mTableID );
lua_pushnumber ( state, refID );
lua_pushvalue ( state, idx );
lua_settable ( state, -3 );
lua_pop ( state, 1 );
return refID;
}
//----------------------------------------------------------------//
void MOAILayoutFrame::RegisterLuaClass ( USLuaState& state ) {
MOAITransform::RegisterLuaClass ( state );
state.SetField ( -1, "LAYOUT_ALIGN_MIN", ( u32 )LAYOUT_ALIGN_MIN );
state.SetField ( -1, "LAYOUT_ALIGN_MAX", ( u32 )LAYOUT_ALIGN_MAX );
state.SetField ( -1, "LAYOUT_ALIGN_CENTER", ( u32 )LAYOUT_ALIGN_CENTER );
state.SetField ( -1, "LAYOUT_JUSTIFY_MIN", ( u32 )LAYOUT_JUSTIFY_MIN );
state.SetField ( -1, "LAYOUT_JUSTIFY_MAX", ( u32 )LAYOUT_JUSTIFY_MAX );
state.SetField ( -1, "LAYOUT_JUSTIFY_CENTER", ( u32 )LAYOUT_JUSTIFY_CENTER );
state.SetField ( -1, "FIT_EXPAND", ( u32 )FIT_EXPAND );
state.SetField ( -1, "FIT_ABSOLUTE", ( u32 )FIT_ABSOLUTE );
state.SetField ( -1, "FIT_CONTENT", ( u32 )FIT_CONTENT );
}
//----------------------------------------------------------------//
u32 USLuaSerializer::WriteTable ( USStream& stream, USLuaState& state, int idx, u32 tab ) {
STLString indent;
for ( u32 i = 0; i < tab; ++i ) {
indent.append ( "\t" );
}
u32 count = 0;
u32 itr = state.PushTableItr ( idx );
while ( state.TableItrNext ( itr )) {
if ( count == 0 ) {
stream.Print ( "\n" );
}
switch ( lua_type ( state, -2 )) {
case LUA_TSTRING: {
stream.Print ( "%s[ \"%s\" ] = ", indent.c_str (), lua_tostring ( state, -2 ));
break;
}
case LUA_TNUMBER: {
stream.Print ( "%s[ %s ]\t= ", indent.c_str (), lua_tostring ( state, -2 ));
break;
}
};
switch ( lua_type ( state, -1 )) {
case LUA_TBOOLEAN: {
int value = lua_toboolean ( state, -1 );
cc8* str = ( value ) ? "true": "false";
stream.Print ( "%s,\n", str );
break;
}
case LUA_TTABLE: {
uintptr tableID = ( uintptr )lua_topointer ( state, -1 );
if ( this->mTableMap.contains ( tableID )) {
stream.Print ( "objects [ 0x%08X ],\n", tableID );
}
else {
stream.Print ( "{" );
if ( this->WriteTable ( stream, state, -1, tab + 1 )) {
stream.Print ( "%s},\n", indent.c_str ());
}
else {
stream.Print ( "},\n" );
}
}
break;
}
case LUA_TSTRING: {
STLString str = _escapeString ( lua_tostring ( state, -1 ));
stream.Print ( "\"%s\",\n", str.c_str ());
break;
}
case LUA_TNUMBER: {
stream.Print ( "%s,\n", lua_tostring ( state, -1 ));
break;
}
case LUA_TLIGHTUSERDATA: {
stream.Print ( "%p,\n", lua_touserdata ( state, -1 ));
break;
}
};
++count;
}
return count;
}
