//----------------------------------------------------------------//
MOAITileDeck2D::MOAITileDeck2D () {
RTTI_SINGLE ( MOAIDeck2D )
this->SetContentMask ( MOAIProp::CAN_DRAW );
this->mRect.Init ( -0.5f, -0.5f, 0.5f, 0.5f );
}
//----------------------------------------------------------------//
MOAISim::MOAISim () :
mTimerState ( RESUMING ),
mDeviceTime ( 0.0f ),
mStep ( 0.01f ),
mTime ( 0.0f ),
mFrameTime ( 0.0 ),
mFrameRate ( 0.0f ),
mFrameRateIdx ( 0 ),
mClearFlags ( GL_COLOR_BUFFER_BIT ),
mClearColor ( 0xff000000 ) {
RTTI_SINGLE ( USLuaObject )
this->mDeviceTime = USDeviceTime::GetTimeInSeconds ();
// Start Lua
USLuaRuntime& luaRuntime = USLuaRuntime::Get ();
luaRuntime.Open ();
luaRuntime.LoadLibs ( "moai" );
for ( u32 i = 0; i < FPS_BUFFER_SIZE; ++i ) {
this->mFrameRateBuffer [ i ] = 0.0f;
}
}
//----------------------------------------------------------------//
MOAIScriptDeck::MOAIScriptDeck () {
RTTI_SINGLE ( MOAIDeck )
this->mRect.Init ( 0.0f, 0.0f, 0.0f, 0.0f );
this->mDefaultShaderID = MOAIShaderMgr::LINE_SHADER;
}
//----------------------------------------------------------------//
MOAIGfxDevice::MOAIGfxDevice () :
mCullFunc ( 0 ),
mDepthFunc ( 0 ),
mDepthMask ( true ),
mBlendEnabled ( 0 ),
mBuffer ( 0 ),
mClearFlags ( GL_COLOR_BUFFER_BIT ),
mClearColor ( 0xff000000 ),
mClearColorNode ( 0 ),
mCpuVertexTransform ( false ),
mCpuUVTransform ( false ),
mDefaultFrameBuffer ( 0 ),
mDeviceScale ( 1.0f ),
mHasContext ( false ),
mHeight ( 0 ),
mIsFramebufferSupported ( 0 ),
mIsOpenGLES ( false ),
mIsProgrammable ( false ),
mMajorVersion ( 0 ),
mMaxPrims ( 0 ),
mMinorVersion ( 0 ),
mFinalColor32 ( 0xffffffff ),
mPenWidth ( 1.0f ),
mPointSize ( 1.0f ),
mPrimCount ( 0 ),
mPrimSize ( 0 ),
mPrimTop ( 0 ),
mPrimType ( GL_POINTS ),
mShader ( 0 ),
mSize ( 0 ),
mActiveTextures ( 0 ),
mTextureMemoryUsage ( 0 ),
mMaxTextureSize ( 0 ),
mTop ( 0 ),
mUVMtxInput ( UV_STAGE_MODEL ),
mUVMtxOutput ( UV_STAGE_MODEL ),
mVertexFormat ( 0 ),
mVertexMtxInput ( VTX_STAGE_MODEL ),
mVertexMtxOutput ( VTX_STAGE_MODEL ),
mWidth ( 0 ) {
RTTI_SINGLE ( MOAIGlobalEventSource )
this->Reserve ( DEFAULT_BUFFER_SIZE );
for ( u32 i = 0; i < TOTAL_VTX_TRANSFORMS; ++i ) {
this->mVertexTransforms [ i ].Ident ();
}
this->mUVTransform.Ident ();
this->mCpuVertexTransformMtx.Ident ();
this->mAmbientColor.Set ( 1.0f, 1.0f, 1.0f, 1.0f );
this->mFinalColor.Set ( 1.0f, 1.0f, 1.0f, 1.0f );
this->mPenColor.Set ( 1.0f, 1.0f, 1.0f, 1.0f );
this->mViewRect.Init ( 0.0f, 0.0f, 0.0f, 0.0f );
this->mScissorRect.Init ( 0.0f, 0.0f, 0.0f, 0.0f );
}
//----------------------------------------------------------------//
MOAIGfxQuad2D::MOAIGfxQuad2D () {
RTTI_SINGLE ( MOAIDeck2D )
this->SetContentMask ( MOAIProp::CAN_DRAW );
// set up rects to draw a unit tile centered at the origin
this->mRect.Init ( -0.5f, -0.5f, 0.5f, 0.5f );
this->mUVRect.Init ( 0.0f, 1.0f, 1.0f, 0.0f );
}
//----------------------------------------------------------------//
MOAIHttpTaskCurl::MOAIHttpTaskCurl () :
mDefaultTimeout ( 10 ),
mEasyHandle ( 0 ),
mHeaderList ( 0 ),
mStream ( 0 ) {
RTTI_SINGLE ( MOAIHttpTaskBase )
this->Reset ();
}
//----------------------------------------------------------------//
MOAIVertexFormat::MOAIVertexFormat () :
mTotalAttributes ( 0 ),
mVertexSize ( 0 ) {
RTTI_SINGLE ( USLuaObject )
this->mAttributes.Init ( TOTAL_ARRAY_TYPES );
for ( u32 i = 0; i < TOTAL_ARRAY_TYPES; ++i ) {
this->mAttributeUseTable [ i ].mUse = MOAIVertexFormat::GetUseForIndex ( i );
this->mAttributeUseTable [ i ].mAttrID = NULL_INDEX;
}
}
//----------------------------------------------------------------//
MOAIGetTouchesAndroid::MOAIGetTouchesAndroid () {
RTTI_SINGLE ( MOAILuaObject );
}
MOAITaskThread* taskThread = ( MOAITaskThread* )param;
while ( threadState.IsRunning ()) {
taskThread->Process ();
MOAIThread::Sleep ();
}
}
//================================================================//
// MOAITaskThread
//================================================================//
//----------------------------------------------------------------//
MOAITaskThread::MOAITaskThread () {
RTTI_SINGLE ( MOAITaskQueue )
}
//----------------------------------------------------------------//
MOAITaskThread::~MOAITaskThread () {
this->Stop ();
}
//----------------------------------------------------------------//
void MOAITaskThread::PushTask ( MOAITask& task ) {
MOAITaskQueue::PushTask ( task );
this->mThread.Start ( _main, this, 0 );
}
self->SetDependentMember ( self->mSourceTransform, sourceTransform );
self->SetDependentMember ( self->mSourceLayer, sourceLayer );
self->SetDependentMember ( self->mDestLayer, destLayer );
return 0;
}
//================================================================//
// MOAILayerBridge
//================================================================//
//----------------------------------------------------------------//
MOAILayerBridge::MOAILayerBridge () {
RTTI_SINGLE ( MOAITransform )
}
//----------------------------------------------------------------//
MOAILayerBridge::~MOAILayerBridge () {
}
//----------------------------------------------------------------//
void MOAILayerBridge::OnDepNodeUpdate () {
if ( !( this->mSourceTransform && this->mSourceLayer && this->mDestLayer )) return;
//this->mLocalToWorldMtx = this->mSourceTransform->GetLocalToWorldMtx ();
//
//USAffine3D mtx;
//
//----------------------------------------------------------------//
MOAIMesh::MOAIMesh () {
RTTI_SINGLE ( MOAIDeck )
this->SetContentMask ( MOAIProp::CAN_DRAW );
}
//----------------------------------------------------------------//
MOAIGfxQuadDeck2D::MOAIGfxQuadDeck2D () {
RTTI_SINGLE ( MOAIDeck2D )
this->SetContentMask ( MOAIProp::CAN_DRAW );
}
gfxDevice.BeginPrim ();
for ( u32 i = 0; i < count; ++i ) {
u32 v = i << 1;
gfxDevice.WriteVtx ( verts [ v ], verts [ v + 1 ]);
gfxDevice.WritePenColor4b ();
}
gfxDevice.EndPrim ();
}
//----------------------------------------------------------------//
MOAIDraw::MOAIDraw () {
RTTI_SINGLE ( MOAIDraw )
}
//----------------------------------------------------------------//
MOAIDraw::~MOAIDraw () {
}
//----------------------------------------------------------------//
void MOAIDraw::RegisterLuaClass ( USLuaState& state ) {
UNUSED ( state );
luaL_Reg regTable [] = {
//{ "drawAxisGrid", _drawAxisGrid }, // TODO
{ "drawCircle", _drawCircle },
{ "drawEllipse", _drawEllipse },
//{ "drawGrid", _drawGrid }, // TODO
//----------------------------------------------------------------//
MOAISurfaceDeck2D::MOAISurfaceDeck2D () {
RTTI_SINGLE ( MOAIDeck )
this->SetContentMask ( MOAIProp::CAN_DRAW_DEBUG | MOAIProp::CAN_GATHER_SURFACES );
}
gfxDevice.BeginPrim ();
for ( u32 i = 0; i < count; ++i ) {
u32 v = i << 1;
gfxDevice.WriteVtx ( verts [ v ], verts [ v + 1 ], 0.0f );
gfxDevice.WriteFinalColor4b ();
}
gfxDevice.EndPrim ();
}
//----------------------------------------------------------------//
MOAIDraw::MOAIDraw () {
RTTI_SINGLE ( MOAILuaObject )
}
//----------------------------------------------------------------//
MOAIDraw::~MOAIDraw () {
}
//----------------------------------------------------------------//
void MOAIDraw::RegisterLuaClass ( MOAILuaState& state ) {
UNUSED ( state );
luaL_Reg regTable [] = {
{ "drawAnimCurve", _drawAnimCurve },
//{ "drawAxisGrid", _drawAxisGrid }, // TODO
{ "drawBoxOutline", _drawBoxOutline },
{ "drawCircle", _drawCircle },
//----------------------------------------------------------------//
USFont* MOAIFont::Bind () {
USDrawBuffer& drawbuffer = USDrawBuffer::Get ();
if ( drawbuffer.SetTexture ( &this->mTexture )) {
return this;
}
return 0;
}
//----------------------------------------------------------------//
MOAIFont::MOAIFont () {
RTTI_SINGLE ( USLuaObject )
}
//----------------------------------------------------------------//
MOAIFont::~MOAIFont () {
}
//----------------------------------------------------------------//
void MOAIFont::LoadFont ( MOAIDataBuffer& fontImageData, cc8* charCodes ) {
USImage image;
USFontRipper ripper;
ripper.RipAndReturn ( fontImageData, *this, image, charCodes );
this->mTexture.Init ( image );
this->mTexture.SetFilter ( GL_LINEAR, GL_LINEAR );
}
//----------------------------------------------------------------//
MOAIDebugLines::MOAIDebugLines () {
RTTI_SINGLE ( MOAILuaObject )
this->Reset ();
}
//----------------------------------------------------------------//
MOAIAnimCurveQuat::MOAIAnimCurveQuat () {
RTTI_SINGLE ( MOAIAnimCurveBase )
this->mValue.Identity ();
}
//----------------------------------------------------------------//
MOAIChartBoostAndroid::MOAIChartBoostAndroid () {
RTTI_SINGLE ( MOAIGlobalEventSource )
this->SetClass ( "com/moaisdk/chartboost/MoaiChartBoost" );
}
if ( state.IsType ( 1, LUA_TSTRING )) {
MOAIEnvironment& environment = MOAIEnvironment::Get ();
environment.SetValue ( state );
}
return 0;
}
//================================================================//
// MOAIEnvironment
//================================================================//
//----------------------------------------------------------------//
MOAIEnvironment::MOAIEnvironment () {
RTTI_SINGLE ( MOAIGlobalEventSource )
}
//----------------------------------------------------------------//
MOAIEnvironment::~MOAIEnvironment () {
}
//----------------------------------------------------------------//
void MOAIEnvironment::RegisterLuaClass ( MOAILuaState& state ) {
MOAIGlobalEventSource::RegisterLuaClass ( state );
state.SetField ( -1, "EVENT_VALUE_CHANGED", ( u32 )EVENT_VALUE_CHANGED );
state.SetField ( -1, "CONNECTION_TYPE_NONE", ( u32 )CONNECTION_TYPE_NONE );
state.SetField ( -1, "CONNECTION_TYPE_WIFI", ( u32 )CONNECTION_TYPE_WIFI );
state.SetField ( -1, "CONNECTION_TYPE_WWAN", ( u32 )CONNECTION_TYPE_WWAN );
//----------------------------------------------------------------//
MOAITapjoyAndroid::MOAITapjoyAndroid () {
RTTI_SINGLE ( MOAIGlobalEventSource )
this->SetClass ( "com/ziplinegames/moai/MoaiTapjoy" );
}
//----------------------------------------------------------------//
MOAITapjoyAndroid::MOAITapjoyAndroid () {
RTTI_SINGLE ( MOAIGlobalEventSource )
this->SetClass ( "com/moaisdk/tapjoy/MoaiTapjoy" );
}
MOAIHusky::MOAIHusky() {
RTTI_SINGLE ( MOAILuaObject );
_map = new LoaderHandleMap();
_currentHuskyHandle = NULL;
_instance = NULL;
_fHuskyName = NULL;
_fHuskyShutdown = NULL;
_huskyCapabilities = 0;
#ifdef __APPLE__
const char* extension = ".dylib";
/** Grab the directory the exectuable is in, by default we want to load Huskies from where the moai exe is **/
NSString *executablePath = [[[[NSProcessInfo processInfo] arguments] objectAtIndex:0] stringByDeletingLastPathComponent];
const char *dirname = [executablePath fileSystemRepresentation];
unsigned long dirlength = strlen(dirname);
DIR *dir = opendir(dirname);
struct dirent *ent;
/** Cycle through the entries in the directory **/
while((ent = readdir(dir)) != NULL) {
/** Is this entry a regular file? **/
if (ent->d_type == DT_REG) {
if (endsWith(ent->d_name, extension)) {
/** We need a full path to load the dll **/
unsigned long filenamelength = strlen(ent->d_name);
char* fullpath = (char*)malloc(sizeof(char) * (filenamelength + dirlength + 2));
strcpy(fullpath, dirname);
strcat(fullpath, "/");
strcat(fullpath, ent->d_name);
void* dll_handle = dlopen(fullpath, RTLD_LOCAL|RTLD_LAZY);
free(fullpath);
/** Got a handle? try to get the husky entry points **/
if (dll_handle) {
HuskyGetStaticInstance* fHuskyInstance = (HuskyGetStaticInstance*)dlsym(dll_handle, "getHuskyInstance");
HuskyGetName* fHuskyName = (HuskyGetName*)dlsym(dll_handle, "getHuskyName");
HuskyShutdownStaticInstance* fHuskyShutdown;
fHuskyShutdown = (HuskyShutdownStaticInstance*)dlsym(dll_handle, "shutdownHuskyInstance");
if (fHuskyName && fHuskyInstance && fHuskyShutdown) {
/** Got Husky Entry points? great, now record this handle so we can use it later **/
HuskyLoaderHandle *handleObj = new HuskyLoaderHandle(dll_handle);
std::string *name = new std::string(fHuskyName());
if (_currentHuskyHandle == NULL) {
_currentHuskyHandle = handleObj->dllhandle;
_instance = fHuskyInstance();
_fHuskyName = fHuskyName;
_fHuskyShutdown = fHuskyShutdown;
_instance->setObserver(this);
_huskyCapabilities = _instance->getCapabilities();
}
_map->insert(LoaderHandleMap::value_type(*name, *handleObj));
}
}
}
}
}
#elif WIN32
LPTSTR extension = "\*.dll";
LPTSTR search;
DWORD length = 255;
search = (LPTSTR)malloc(sizeof(char) * length);
DWORD result = GetModuleFileName(NULL, search, length - 1);
if (result == 0) {
strcpy(search, ".");
}
PathRemoveFileSpec(search);
PathAppend(search, extension);
WIN32_FIND_DATA findfiledata;
HANDLE hFind = FindFirstFile(search, &findfiledata);
if (hFind != INVALID_HANDLE_VALUE ) {
do {
HMODULE dll_handle = LoadLibrary(findfiledata.cFileName);
if (dll_handle) {
HuskyGetStaticInstance* fHuskyInstance = (HuskyGetStaticInstance*)GetProcAddress(dll_handle, "getHuskyInstance");
HuskyGetName* fHuskyName = (HuskyGetName*)GetProcAddress(dll_handle, "getHuskyName");
HuskyShutdownStaticInstance* fHuskyShutdown;
fHuskyShutdown = (HuskyShutdownStaticInstance*)GetProcAddress(dll_handle, "shutdownHuskyInstance");
if (fHuskyName && fHuskyInstance && fHuskyShutdown) {
HuskyLoaderHandle *handleObj = new HuskyLoaderHandle(dll_handle);
std::string *name = new std::string(fHuskyName());
if (_currentHuskyHandle == NULL) {
_currentHuskyHandle = handleObj->dllhandle;
_instance = fHuskyInstance();
_fHuskyName = fHuskyName;
_fHuskyShutdown = fHuskyShutdown;
_instance->setObserver(this);
_huskyCapabilities = _instance->getCapabilities();
}
_map->insert(LoaderHandleMap::value_type(*name, *handleObj));
}
}
} while(FindNextFile(hFind, &findfiledata) != 0);
FindClose(hFind);
}
free(search);
#endif
}
//----------------------------------------------------------------//
void MOAIEnvironment::DetectEnvironment () {
RTTI_SINGLE ( MOAIGlobalEventSource )
#if defined( MOAI_OS_WINDOWS )
//printf ( "Env Windows\n" );
this->SetValue ( MOAI_ENV_osBrand, "Windows" );
UUID uuid;
UuidCreateSequential ( &uuid );
// For now, we'll just use the MAC address which is the last 6 bytes of the uuid.
char buf[13];
sprintf ( buf, "%02X%02X%02X%02X%02X%02X", uuid.Data4[2], uuid.Data4[3], uuid.Data4[4], uuid.Data4[5], uuid.Data4[6], uuid.Data4[7]);
this->SetValue ( MOAI_ENV_udid, buf );
char path[MAX_PATH];
//HRESULT hr = SHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, SHGFP_TYPE_CURRENT, path);
SHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, SHGFP_TYPE_CURRENT, path);
this->SetValue ( MOAI_ENV_documentDirectory, path );
const int BUFSIZE = 256;
TCHAR pszOS[BUFSIZE];
OSVERSIONINFOEX osvi;
SYSTEM_INFO si;
PGNSI pGNSI;
ZeroMemory(&si, sizeof(SYSTEM_INFO));
ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));
osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
GetVersionEx((OSVERSIONINFO*) &osvi);
pGNSI = (PGNSI) GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")), "GetNativeSystemInfo");
if(NULL != pGNSI) {
pGNSI(&si);
}
else {
GetSystemInfo(&si);
}
if ( VER_PLATFORM_WIN32_NT==osvi.dwPlatformId && osvi.dwMajorVersion > 4 ) {
strcpy ( pszOS, TEXT ( "Win" ));
if ( osvi.dwMajorVersion == 6 ) {
if ( osvi.dwMinorVersion == 1 ) {
if( osvi.wProductType == VER_NT_WORKSTATION )
strcat(pszOS, TEXT("7"));
else strcat(pszOS, TEXT("2008R2" ));
}
else if( osvi.dwMinorVersion == 0 ) {
if( osvi.wProductType == VER_NT_WORKSTATION )
strcat(pszOS, TEXT("Vista"));
else strcat(pszOS, TEXT("Server2008" ));
}
}
else if ( osvi.dwMajorVersion == 5 ) {
if (osvi.dwMinorVersion == 2) {
if( osvi.wProductType == VER_NT_WORKSTATION && si.wProcessorArchitecture==PROCESSOR_ARCHITECTURE_AMD64) {
strcat(pszOS, TEXT( "XPx64"));
}
else {
strcat(pszOS, TEXT("Server2003"));
}
}
else if ( osvi.dwMinorVersion == 1 ) {
strcat(pszOS, TEXT("XP"));
}
else if ( osvi.dwMinorVersion == 0 ) {
strcat(pszOS, TEXT("2000"));
}
}
this->SetValue ( MOAI_ENV_osVersion, pszOS );
}
else {
this->SetValue ( MOAI_ENV_osVersion, "WinUnknown" );
}
#elif defined( MOAI_OS_LINUX )
//printf ( "Env Linux\n" );
this->SetValue ( MOAI_ENV_osBrand, "Linux" );
#elif defined ( MOAI_OS_OSX )
//printf ( "Env OSX\n" );
this->SetValue ( MOAI_ENV_osBrand, "OSX" );
#if 0 /* doesn't compile yet */
// OS Version
SInt32 majorVersion,minorVersion,bugFixVersion;
Gestalt(gestaltSystemVersionMajor, &majorVersion);
Gestalt(gestaltSystemVersionMinor, &minorVersion);
Gestalt(gestaltSystemVersionBugFix, &bugFixVersion);
char buffer[256];
sprintf(buffer, "%d.%d.%d",majorVersion,minorVersion,bugFixVersion);
this->SetValue ( MOAI_ENV_osVersion, buffer );
#endif
#else
//printf ( "No environment detected\n" );
#endif
}
//----------------------------------------------------------------//
MOAIInputMgr::MOAIInputMgr () {
RTTI_SINGLE ( MOAILuaObject )
this->mInput.SetChunkSize ( 1024 );
}
this->mX = eventStream.Read < float >();
this->mY = eventStream.Read < float >();
if ( this->mOnStick ) {
USLuaStateHandle state = this->mOnStick.GetSelf ();
lua_pushnumber ( state, this->mX );
lua_pushnumber ( state, this->mY );
state.DebugCall ( 2, 0 );
}
}
//----------------------------------------------------------------//
MOAIJoystickSensor::MOAIJoystickSensor () {
RTTI_SINGLE ( MOAISensor )
}
//----------------------------------------------------------------//
MOAIJoystickSensor::~MOAIJoystickSensor () {
}
//----------------------------------------------------------------//
void MOAIJoystickSensor::RegisterLuaClass ( USLuaState& state ) {
MOAISensor::RegisterLuaClass ( state );
}
//----------------------------------------------------------------//
void MOAIJoystickSensor::RegisterLuaFuncs ( USLuaState& state ) {
//================================================================//
//----------------------------------------------------------------//
bool MOAIScriptNode::ApplyAttrOp ( u32 attrID, MOAIAttrOp& attrOp, u32 op ) {
if ( attrID < this->mAttributes.Size ()) {
this->mAttributes [ attrID ] = attrOp.Apply ( this->mAttributes [ attrID ], op, MOAINode::ATTR_READ_WRITE );
return true;
}
return false;
}
//----------------------------------------------------------------//
MOAIScriptNode::MOAIScriptNode () {
RTTI_SINGLE ( MOAINode )
}
//----------------------------------------------------------------//
MOAIScriptNode::~MOAIScriptNode () {
}
//----------------------------------------------------------------//
void MOAIScriptNode::OnDepNodeUpdate () {
if ( this->mOnUpdate ) {
MOAILuaStateHandle state = MOAILuaRuntime::Get ().State ();
this->PushLocal ( state, this->mOnUpdate );
this->PushLuaUserdata ( state );
#include <moaicore/MOAIPathGraph.h>
//================================================================//
// local
//================================================================//
//----------------------------------------------------------------//
//================================================================//
// MOAIPathFinder
//================================================================//
//----------------------------------------------------------------//
MOAIPathGraph::MOAIPathGraph () {
RTTI_SINGLE ( MOAIPathGraph )
}
//----------------------------------------------------------------//
MOAIPathGraph::~MOAIPathGraph () {
}
//----------------------------------------------------------------//
void MOAIPathGraph::RegisterLuaClass ( MOAILuaState& state ) {
UNUSED ( state );
}
//----------------------------------------------------------------//
void MOAIPathGraph::RegisterLuaFuncs ( MOAILuaState& state ) {
UNUSED ( state );
}
