bool GuiDemo::setup(void)
{
gkBlendFile* blend = gkBlendLoader::getSingleton().loadFile(gkUtils::getFile(m_blend), "", GUIDEMO_GROUP_NAME);
if (!blend)
{
gkPrintf("File loading failed.\n");
return false;
}
m_scene = blend->getMainScene();
if (!m_scene)
{
gkPrintf("No usable scenes found in blend.\n");
return false;
}
m_scene->createInstance();
// add input hooks
gkWindowSystem::getSingleton().addListener(this);
gkBlendLoader::getSingleton().loadFile(gkUtils::getFile(ASSETS_BLEND_FILE), "", GUIDEMO_GROUP_NAME);
//--
initRocket();
return true;
}
bool gkWaveform::load(const char* buf, int len)
{
m_reader = new utMemoryStream();
static_cast<utMemoryStream*>(m_reader)->open(buf, len, utStream::SM_READ);
if (!m_reader->isOpen())
{
gkPrintf("Waveform: Buffer loading failed.\n");
return false;
}
if (!loadStreamImpl())
{
gkPrintf("Waveform: Buffer loading failed.\n");
return false;
}
// make sure a valid format & block size is present
if (getFormat() <= 0)
{
gkPrintf("Waveform: Buffer loading failed. (invalid format read)\n");
return false;
}
if (getBitsPerSecond() <= 0)
{
gkPrintf("Waveform: Buffer loading failed. (invalid block size (%i))\n", getBitsPerSecond());
return false;
}
m_data = new char[getBitsPerSecond() + 1];
return true;
}
bool OgreKit::setup(void)
{
gkBlendFile* blend = gkBlendLoader::getSingleton().loadFile(gkUtils::getFile(m_blend), gkBlendLoader::LO_ALL_SCENES);
if (!blend)
{
gkPrintf("File loading failed.\n");
return false;
}
m_scene = blend->getSceneByName("StartScene");
if (!m_scene)
m_scene = blend->getMainScene();
if (!m_scene)
{
gkPrintf("No usable scenes found in blend.\n");
return false;
}
m_scene->createInstance();
// add input hooks
gkWindowSystem::getSingleton().addListener(this);
#ifdef OGREKIT_USE_COMPOSITOR
//gkCompositorManager::getSingleton().setCompositorChain(GK_COMPOSITOR_OP_ADD, GK_COMPOSITOR_BLOOM);
#endif
return true;
}
bool gkAndroidApp::setup(void) {
AAssetManager* assetMgr = m_state->activity->assetManager;
if (assetMgr) {
Ogre::ArchiveManager::getSingleton().addArchiveFactory(new Ogre::APKFileSystemArchiveFactory(assetMgr));
Ogre::ArchiveManager::getSingleton().addArchiveFactory(new Ogre::APKZipArchiveFactory(assetMgr));
Ogre::ResourceGroupManager::getSingleton().addResourceLocation("/", "APKFileSystem",
Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
}
Ogre::DataStreamPtr stream = Ogre::ResourceGroupManager::getSingleton().
openResource(m_blend, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
if (stream.isNull()) {
gkPrintf("Error: Can't open file %s.\n", m_blend.c_str());
return false;
}
size_t size = stream->size();
char* buf = new char[size];
stream->read(buf, size);
gkBlendFile* blend = gkBlendLoader::getSingleton().loadFromMemory(buf,size,gkBlendLoader::LO_ALL_SCENES);
gkScene* scene = blend->getMainScene();
if (!scene) {
gkPrintf("No usable scenes found in blend.\n");
return false;
}
scene->createInstance();
scene->getMainCamera()->getCamera()->setAutoAspectRatio(true);
return true;
}
gkScene* okApp::mergeScene(gkScene* dstScene, const gkString& blend, const gkString& sceneName, bool ignoreCache)
{
if (!m_inited) return NULL;
GK_ASSERT(dstScene);
int options = gkBlendLoader::LO_ONLY_ACTIVE_SCENE | gkBlendLoader::LO_CREATE_UNIQUE_GROUP;
if (ignoreCache) options |= gkBlendLoader::LO_IGNORE_CACHE_FILE;
gkBlendFile* file = gkBlendLoader::getSingleton().loadFile(blend, options, sceneName);
if (!file)
{
gkPrintf("Can't open the blend file: %s", blend.c_str());
return false;
}
gkScene* scene = NULL;
if (!sceneName.empty())
scene = file->getSceneByName(sceneName);
if (!scene)
scene = file->getMainScene();
if (!scene)
{
gkPrintf("Can't create the scene.");
return false;
}
gkSceneManager::getSingleton().copyObjects(scene, dstScene);
//m_scenes.push_back(scene);
return scene;
}
void dumpGkInfo()
{
gkPrintf("scene: %d object: %d objinst: %d group: %d sound: %d lua: %d skel: %d mesh: %d anim: %d text: %d blend: %d font: %d window: %d resgroup: %d",
gkSceneManager::getSingleton().getResourceCount(),
gkGameObjectManager::getSingleton().getResourceCount(),
gkGameObjectManager::getSingleton().getInstances().size(),
gkGroupManager::getSingleton().getResourceCount(),
gkSoundManager::getSingleton().getResourceCount(),
gkLuaManager::getSingleton().getResourceCount(),
gkSkeletonManager::getSingleton().getResourceCount(),
gkMeshManager::getSingleton().getResourceCount(),
gkAnimationManager::getSingleton().getResourceCount(),
gkTextManager::getSingleton().getResourceCount(),
gkBlendLoader::getSingleton().getFiles().size(),
gkFontManager::getSingleton().getResourceCount(),
gkWindowSystem::getSingleton().getWindowCount(),
gkResourceGroupManager::getSingleton().getResourceGroupList().size()
);
gkResourceManager::ResourceIterator it = gkSceneManager::getSingleton().getResourceIterator();
while (it.hasMoreElements())
{
gkScene* scene = static_cast<gkScene*>(it.getNext().second);
gkPrintf("scene name: %s group: %s objects: %d instances: %d light: %d camera: %d",
scene->getName().c_str(),
scene->getResourceName().getFullName().c_str(),
scene->getObjects().size(),
scene->getInstancedObjects().size(),
scene->getLights().size(),
scene->getCameras().size()
);
}
}
bool okApp::setup(void)
{
if (!createEmptyScene())
{
gkPrintf("Can't create empty scene.");
return false;
}
gkWindowSystem::getSingleton().addListener(this);
gkPrintf("done\n");
return true;
}
bool gkWindowAndroid::setupInput(const gkUserDefs& prefs)
{
// OIS
try
{
#if 0
size_t handle = getWindowHandle();
if (handle == 0)
{
gkPrintf("Window handle is null.");
return false;
}
#else
size_t handle = 0;
#endif
OIS::ParamList params;
params.insert(std::make_pair("WINDOW", Ogre::StringConverter::toString(handle)));
m_input = OIS::InputManager::createInputSystem(params);
m_input->enableAddOnFactory(OIS::InputManager::AddOn_All);
m_ikeyboard = (OIS::Keyboard*)m_input->createInputObject(OIS::OISKeyboard, true); GK_ASSERT(m_ikeyboard);
m_ikeyboard->setEventCallback(this);
// TODO: Option for disabling accelration! Performance...
try{
m_iacc = (OIS::JoyStick*)m_input->createInputObject(OIS::OISJoyStick, true);
m_iacc->setEventCallback(this);
m_ijoysticks.push_back(m_iacc);
gkJoystick* gkjs = new gkJoystick(0,0);
m_joysticks.push_back(gkjs);
} catch (OIS::Exception&){
m_iacc=0;
}
m_itouch = (OIS::MultiTouch*)m_input->createInputObject(OIS::OISMultiTouch, true); GK_ASSERT(m_itouch);
m_itouch->setEventCallback(this);
}
catch (OIS::Exception& e)
{
gkPrintf("%s", e.what());
return false;
}
return true;
}
void lua_dumpstack(lua_State* L)
{
int top = lua_gettop(L), i = 0;
while (top > 0)
{
char extra[256];
extra[0] = 0;
switch (lua_type(L, top))
{
case LUA_TNONE: sprintf(extra, "LUA_TNONE : NONE"); break;
case LUA_TNIL: sprintf(extra, "LUA_TNIL : NULL"); break;
case LUA_TBOOLEAN: sprintf(extra, "LUA_TBOOLEAN : %s", lua_toboolean(L, top) ? "true" : "false"); break;
case LUA_TLIGHTUSERDATA: sprintf(extra, "LUA_TLIGHTUSERDATA : %p", lua_touserdata(L, top)); break;
case LUA_TUSERDATA: sprintf(extra, "LUA_TUSERDATA : %p", lua_touserdata(L, top)); break;
case LUA_TNUMBER: sprintf(extra, "LUA_TNUMBER : %f", lua_tonumber(L, top)); break;
case LUA_TSTRING: sprintf(extra, "LUA_TSTRING : %s", lua_tostring(L, top)); break;
case LUA_TTABLE: sprintf(extra, "LUA_TTABLE : %p", lua_topointer(L, top)); break;
case LUA_TFUNCTION: sprintf(extra, "LUA_TFUNCTION : %p", lua_topointer(L, top)); break;
case LUA_TTHREAD: sprintf(extra, "LUA_TTHREAD : %p", lua_topointer(L, top)); break;
}
gkPrintf("%i: %s\n", i, extra);
i++;
top--;
}
}
bool OgreKit::init(const gkString& blend)
{
gkPrintf("----------- OgreKit Android Demo init -----------------");
LOG_FOOT;
gkString cfgfname;
// Parse command line
m_blend = gkDefaultBlend;
if (!blend.empty()) m_blend = blend;
getPrefs().debugFps = true;
getPrefs().wintitle = gkString("OgreKit Demo (Press Escape to exit)[") + m_blend + gkString("]");
getPrefs().blendermat=true;
//getPrefs().shaderCachePath="/sdcard/gamekit";
getPrefs().enableshadows=false;
getPrefs().viewportOrientation="portrait";
// m_prefs.disableSound=false;
gkPath path = cfgfname;
LOG_FOOT;
// overide settings if found
if (path.isFileInBundle())
getPrefs().load(path.getPath());
LOG_FOOT;
m_inited = initialize();
LOG_FOOT;
//gkMessageManager::getSingleton().addListener(this);
return m_inited;
}
wxTreeItemId luProjTree::findItemByData(const wxTreeItemId& parent, const wxString& data)
{
if (!parent.IsOk()) return parent;
ItemData* item = dynamic_cast<ItemData*>(GetItemData(parent));
if (item && item->GetName() == data)
return parent;
if (item) gkPrintf("%s", (const char*)item->GetName());
if (HasChildren(parent))
{
wxTreeItemIdValue cookie;
wxTreeItemId item = GetFirstChild(parent, cookie);
while (item.IsOk())
{
wxTreeItemId find = findItemByData(item, data); //find is item self or children.
if (find.IsOk()) return find;
item = GetNextChild(item, cookie);
}
}
return wxTreeItemId(); //not found
}
void gkTextureLoader::loadResource(Ogre::Resource* resource)
{
Ogre::Texture* texture = static_cast<Ogre::Texture*>(resource);
if (!m_stream)
{
gkPrintf("Warning: Skipping image %s no packed file information is present!", texture->getName().c_str());
return;
}
Ogre::DataStreamPtr stream(OGRE_NEW Ogre::MemoryDataStream(m_stream->ptr(), m_stream->size()));
Ogre::Image ima;
ima.load(stream);
texture->setUsage(Ogre::TU_DEFAULT);
texture->setTextureType(Ogre::TEX_TYPE_2D);
texture->setNumMipmaps(gkEngine::getSingleton().getUserDefs().defaultMipMap);
texture->setWidth(ima.getWidth());
texture->setHeight(ima.getHeight());
texture->setDepth(ima.getDepth());
texture->setFormat(ima.getFormat());
Ogre::ConstImagePtrList ptrs;
ptrs.push_back(&ima);
texture->_loadImages(ptrs);
}
void gkHUDElement::setMaterialAlpha(float factor)
{
if (!m_element) return;
try
{
Ogre::MaterialPtr material = m_element->getMaterial();
Ogre::Pass* pass = material->getTechnique(0)->getPass(0);
if (m_alphaBlend > 1.f)
{
pass->setSceneBlending(Ogre::SBT_TRANSPARENT_ALPHA);
m_alphaBlend = 1.f;
}
Ogre::TextureUnitState* tu = pass->getTextureUnitState(0);
if (tu)
{
factor = gkClamp(factor, 0.f, 1.f);
tu->setAlphaOperation(Ogre::LBX_SOURCE1, Ogre::LBS_MANUAL, Ogre::LBS_CURRENT, factor);
m_alphaBlend = factor;
}
}
catch (Ogre::Exception& e)
{
gkPrintf("HUD Error: %s", e.what());
}
}
void gkScene::addObject(gkGameObject* gobj)
{
GK_ASSERT(gobj);
const gkHashedString name = gobj->getName();
if (m_objects.find(name) != GK_NPOS)
{
gkPrintf("Scene: Duplicate object '%s' found in this scene\n", name.str().c_str());
return;
}
if (gobj->getType() == GK_LIGHT)
m_hasLights = true;
if (gobj->getOwner() != this)
{
if (gobj->getOwner() != 0)
{
if (!_replaceObjectInScene(gobj, gobj->getOwner(), this))
return;
}
else
{
gobj->setOwner(this);
m_objects.insert(name, gobj);
}
}
}
bool gkLuaScript::execute(void)
{
if (!m_compiled)
compile();
if (m_isInvalid)
return false;
m_lastRetBoolValue = false;
m_lastRetStrValue = "";
lua_State* L = gkLuaManager::getSingleton().getLua();;
//lua_dumpstack(L);
lua_pushtraceback(L);
int trace = lua_gettop(L);
lua_rawgeti(L, LUA_REGISTRYINDEX, m_script);
if (lua_pcall(L, 0, LUA_MULTRET, trace) != 0)
{
gkPrintf("%s\n", lua_tostring(L, -1));
dsPrintf("%s\n", lua_tostring(L, -1));
lua_pop(L, 1);
m_isInvalid = true;
return false;
}
m_lastRetBoolValue = lua_toboolean(L, -1) != 0;
char* str = (char*)lua_tostring(L, -1);
if (str) m_lastRetStrValue = str;
lua_gc(L, LUA_GCSTEP, 1);
lua_popall(L);
return true;
}
void gkLuaScript::compile(void)
{
if (m_isInvalid)
return;
lua_State* L = gkLuaManager::getSingleton().getLua();
//lua_dumpstack(L);
{
lua_pushvalue(L, LUA_GLOBALSINDEX);
if (luaL_loadbuffer(L, m_text.c_str(), m_text.size() - 1, getName().c_str()) != 0)
{
gkPrintf("%s\n", lua_tostring(L, -1));
dsPrintf("%s\n", lua_tostring(L, -1));
lua_pop(L, 1);
m_isInvalid = true;
return;
}
// script function is now on the stack
int fnc = lua_gettop(L);
if (!lua_isfunction(L, fnc))
{
lua_pop(L, 1);
m_isInvalid = true;
return;
}
lua_pushvalue(L, fnc);
m_script = luaL_ref(L, LUA_REGISTRYINDEX);
lua_popall(L);
}
m_compiled = true;
}
void luAnimDlg::playAnim(const wxString& name)
{
if (!m_obj) return;
if (!(m_scene->getUpdateFlags() & gkScene::UF_ANIMATIONS))
m_scene->setUpdateFlags(gkScene::UF_ANIMATIONS);
gkString animName(WX2GK(name));
gkAnimationPlayer* player = m_obj->getAnimationPlayer(animName);
if (!player)
player = m_obj->addAnimation(animName);
GK_ASSERT(player);
m_curAnimPlayer = player;
m_curAnimName = animName;
m_curAnimLength = player->getLength();
m_length = GK2STR(m_curAnimLength);
m_curPos = "0";
m_curPosEdit->GetValidator()->TransferToWindow();
m_lengthEdit->GetValidator()->TransferToWindow();
m_timeSlider->SetRange(0, 100);
m_timeSlider->SetValue(0);
m_obj->playAnimation(animName, 1); //gkAppData::gkGlobalActionBlend);
m_playBtn->SetLabelText(wxT("Stop"));
gkPrintf("play anim: %s", (const char*)name);
}
void gkDebugPropertyPage::initialize(void)
{
if (m_isInit)
return;
try
{
// always initialize after gkDebugScreen!
Ogre::OverlayManager& mgr = Ogre::OverlayManager::getSingleton();
m_over = mgr.create("<gkBuiltin/gkDebugPropertyPage>");
m_key = mgr.createOverlayElement("TextArea", "<gkBuiltin/gkDebugPropertyPage/Keys>");
m_val = mgr.createOverlayElement("TextArea", "<gkBuiltin/gkDebugPropertyPage/Vals>");
m_cont = (Ogre::OverlayContainer*)mgr.createOverlayElement("Panel", "<gkBuiltin/gkDebugPropertyPage/Containter1>");
m_cont->setMetricsMode(Ogre::GMM_PIXELS);
m_cont->setVerticalAlignment(Ogre::GVA_TOP);
m_cont->setHorizontalAlignment(Ogre::GHA_LEFT);
m_key->setMetricsMode(Ogre::GMM_PIXELS);
m_key->setVerticalAlignment(Ogre::GVA_TOP);
m_key->setHorizontalAlignment(Ogre::GHA_LEFT);
m_val->setMetricsMode(Ogre::GMM_PIXELS);
m_val->setVerticalAlignment(Ogre::GVA_TOP);
m_val->setHorizontalAlignment(Ogre::GHA_LEFT);
Ogre::TextAreaOverlayElement* textArea;
textArea = static_cast<Ogre::TextAreaOverlayElement*>(m_key);
textArea->setFontName("<gkBuiltin/Font>");
textArea->setCharHeight(PROP_SIZE);
textArea->setColour(Ogre::ColourValue::White);
textArea = static_cast<Ogre::TextAreaOverlayElement*>(m_val);
textArea->setFontName("<gkBuiltin/Font>");
textArea->setCharHeight(PROP_SIZE);
textArea->setColour(Ogre::ColourValue::White);
m_over->setZOrder(500);
m_cont->addChild(m_key);
m_cont->addChild(m_val);
m_over->add2D(m_cont);
}
catch (Ogre::Exception& e)
{
gkPrintf("%s", e.getDescription().c_str());
return;
}
m_isInit = true;
}
bool openXMLDocumentOnFile(const gkString& fileName, TiXmlDocument &XMLDoc)
{
if (!XMLDoc.LoadFile(fileName))
{
gkPrintf("[XML] Error - The TiXmlDocument reported an error: %s",XMLDoc.ErrorDesc());
return false;
}
return true;
}
void gkGamePlayer::handleMessage(gkMessageManager::Message* message)
{
/// subjects : CHAT,UPDATE_POSROTVEL
if(message->m_subject.compare("Position")==0)
{ gkPrintf("Message received from :%s with subject %s and data = %s",message->m_from.c_str(),message->m_subject.c_str(),message->m_body.c_str());
const Ogre::Vector3 v;
Ogre::StringConverter::parseVector3(message->m_body,v);
m_physics->setPosition(v);
}
}
void luProjTree::OnKeyChar(wxKeyEvent& event)
{
int key = event.GetKeyCode();
if (key == WXK_DELETE)
{
wxCommandEvent evt(wxEVT_NULL, ID_PROJ_REMOVE_FILE);
wxTheApp->GetTopWindow()->GetEventHandler()->ProcessEvent(evt);
gkPrintf("delete");
}
//gkPrintf("key: %d", key);
}
void gkScene::removeObject(gkGameObject* gobj)
{
const gkHashedString name = gobj->getName();
if (m_objects.find(name) != GK_NPOS)
{
gkPrintf("Scene: object '%s' not found in this scene\n", name.str().c_str());
return;
}
gobj->destroyInstance();
}
bool xmlConfig::load(const gkString &fileName)
{
if (!openSections(fileName, mSections, "config")) {
gkPrintf("[XML] Can't open file: '%s'", fileName.c_str());
return false;
}
mLoaded = true;
mFileName = fileName;
return mLoaded;
}
gkParticleObject* gkScene::createParticleObject(const gkHashedString& name)
{
if (m_objects.find(name) != GK_NPOS)
{
gkPrintf("Scene: Duplicate object '%s' found\n", name.str().c_str());
return 0;
}
gkParticleObject* gobj = gkGameObjectManager::getSingleton().createParticleObject(gkResourceName(name, getGroupName()));
addObject(gobj);
return gobj;
}
gkScene* okApp::loadScene(gkWindow* window, const gkString& blend, const gkString& sceneName, bool ignoreCache)
{
if (!m_inited) return NULL;
GK_ASSERT(window);
int options = gkBlendLoader::LO_ONLY_ACTIVE_SCENE | gkBlendLoader::LO_CREATE_UNIQUE_GROUP;
if (ignoreCache) options |= gkBlendLoader::LO_IGNORE_CACHE_FILE;
gkBlendFile* file = gkBlendLoader::getSingleton().loadFile(blend, options, sceneName);
if (!file)
{
gkPrintf("Can't open the blend file: %s", blend.c_str());
return false;
}
gkScene* scene = NULL;
if (!sceneName.empty())
scene = file->getSceneByName(sceneName);
if (!scene)
scene = file->getMainScene();
if (!scene)
{
gkPrintf("Can't create the scene.");
return false;
}
scene->setDisplayWindow(window);
if (m_showPhysicsDebug)
scene->getDynamicsWorld()->enableDebugPhysics(true, true);
scene->createInstance();
m_scenes.push_back(scene);
return scene;
}
bool openXMLDocument(const gkString& fileName, TiXmlDocument &XMLDoc, const gkString& resGroupName)
{
try
{
//open from file
if (!Ogre::ResourceGroupManager::getSingletonPtr())
return openXMLDocumentOnFile(fileName, XMLDoc);
//open from resource
// Strip the path
gkString basename, path;
Ogre::StringUtil::splitFilename(fileName, basename, path);
Ogre::DataStreamPtr pStream = Ogre::ResourceGroupManager::getSingleton().
openResource( basename, resGroupName );
gkString data = pStream->getAsString();
// Open the .scene File
XMLDoc.Parse( data.c_str() );
pStream->close();
pStream.setNull();
if (XMLDoc.Error())
{
gkPrintf("[XML] Error - The TiXmlDocument reported an error: %s", XMLDoc.ErrorDesc());
return false;
}
}
catch(Ogre::Exception &e)
{
gkPrintf("[XML] Error - creating TiXmlDocument %s %s", fileName.c_str(), e.getDescription().c_str());
return false;
}
return true;
}
void gkSkeleton::createInstanceImpl(void)
{
if (!m_resource)
{
gkPrintf("Skeleton: '%s' Has no internal data.\n", m_name.getName().c_str());
m_instanceState = ST_ERROR;
return;
}
gkGameObject::createInstanceImpl();
if (m_baseProps.isInvisible())
m_node->setVisible(false);
}
gkThread::~gkThread()
{
#ifdef WIN32
CloseHandle(m_hChilThread);
#elif __ANDROID__
int status = 0;
if ((status = pthread_kill(m_threadId, SIGUSR1)) != 0)
{
gkPrintf("Error cancelling thread id:%d error:%d", m_threadId, status);
}
#else
pthread_cancel(m_threadId);
#endif
}
TiXmlElement* openXMLDocumentRootOnFile(const gkString& fileName, TiXmlDocument &XMLDoc, const gkString& rootElementName)
{
if (!openXMLDocumentOnFile(fileName, XMLDoc))
return NULL;
TiXmlElement* XMLRoot = XMLDoc.RootElement();
if (!rootElementName.empty() && rootElementName != XMLRoot->Value())
{
gkPrintf( "[XML] Error - Invalid .xml File. Missing %s", rootElementName.c_str());
return NULL;
}
return XMLRoot;
}
void gkHUDElement::setMaterialName(const gkString& material)
{
try
{
if (m_element)
{
m_alphaBlend = 2.f;
return m_element->setMaterialName(material);
}
}
catch (Ogre::Exception& e)
{
gkPrintf("HUD Error: %s", e.what());
}
}
