void initialize(void)
{
try
{
const gkString imgName = HALO_IMAGE_NAME;
Ogre::DataStreamPtr stream(OGRE_NEW Ogre::MemoryDataStream((void*)(FLARE_ALPHA_64), FLARE_ALPHA_64_SIZE));
Ogre::Image img;
img.load(stream);
Ogre::TextureManager::getSingleton().loadImage(imgName, GK_BUILTIN_GROUP, img);
Ogre::MaterialPtr mat = Ogre::MaterialManager::getSingleton().create(DEFAULT_HALO_MAT, GK_BUILTIN_GROUP);
Ogre::Pass *pass = mat->getTechnique(0)->getPass(0);
pass->setSceneBlending(Ogre::SBT_TRANSPARENT_ALPHA);
pass->setAlphaRejectSettings(Ogre::CMPF_GREATER_EQUAL, 150);
pass->setDepthWriteEnabled(false);
Ogre::TextureUnitState* tu = pass->createTextureUnitState(imgName);
}
catch(Ogre::Exception& e)
{
gkLogMessage("gkParticleManager: " << e.getDescription());
}
}
gkGameObjectInstance* gkGameObjectGroup::createGroupInstance(gkScene* scene, const gkResourceName& name, gkGameObject* root, UTuint32 layer )
{
GK_ASSERT(m_instanceManager);
if (m_instanceManager->exists(name))
{
gkLogMessage("GameObjectGroup: Duplicate instance '" << name.getName() << "(" << name.getGroup() << ")'");
return 0;
}
gkGameObjectInstance* newInst = m_instanceManager->create<gkGameObjectInstance>(name);
if (!root)
newInst->_updateFromGroup(this);
else
newInst->_setExternalRoot(this,root);
scene->addObject(newInst->getRoot());
newInst->setLayer(layer);
gkGameObject* obj = newInst->getRoot();
GK_ASSERT(obj);
if (obj)
obj->setOwner(scene);
Objects::Iterator iter = m_objects.iterator();
while (iter.hasMoreElements())
newInst->addObject(iter.getNext().second);
GroupInstances::Iterator grpInstIter = m_groupInstances.iterator();
while (grpInstIter.hasMoreElements())
newInst->addGroupInstance(grpInstIter.getNext());
return newInst;
}
void gkHUD::newImpl(void)
{
try
{
m_overlay = Ogre::OverlayManager::getSingleton().getByName(m_name.getName());
// Auto create if it's here
if (m_overlay)
{
Ogre::Overlay::Overlay2DElementsIterator elements = m_overlay->get2DElementsIterator();
while (elements.hasMoreElements())
{
Ogre::OverlayContainer* cont = elements.getNext();
addChild(new gkHUDElement(cont->getName()));
Ogre::OverlayContainer::ChildIterator childs = cont->getChildIterator();
while (childs.hasMoreElements())
{
Ogre::OverlayElement* elm = childs.getNext();
gkHUDElement* hele = new gkHUDElement(elm->getName());
addChild(hele);
}
}
}
}
catch (Ogre::Exception& e)
{
gkLogMessage("HUD: " << e.getDescription());
m_overlay = 0;
}
}
IGameObject* gkGameObjectSystem::CreateAnimGameObject( const gkStdString& name, const gkStdString& chrfile, Vec3& pos, Quat& rot )
{
gkGameObject* pGameObject = NULL;
pGameObject = _createGameObjectInternal(name);
// he will create the RenderLayer internal
if (gEnv->pAnimation)
{
IGameObjectAnimLayer* pAnimLayer = gEnv->pAnimation->CreateAnimLayer(name);
pGameObject->setGameObjectLayer(pAnimLayer);
pAnimLayer->loadChrFile(chrfile.c_str());
}
pGameObject->setGameObjectSuperClass(eGOClass_SKINNEDMESH);
pGameObject->setGameObjectClass(_T("AnimObject"));
gkLogMessage(_T("gkGOSys::%s [ %s ] Created."), pGameObject->getGameObjectClassName().c_str(), pGameObject->getName().c_str());
return pGameObject;
}
bool gkPak::openPakFile( const TCHAR* pszRelFilename, char** pData, size_t &size )
{
// NORMALIZE THE FILENAME
gkStdString finalpath(pszRelFilename);
gkNormalizePath( finalpath );
// UNICODE SHOULD TRANSLATE
#ifdef UNICODE
char buffer[MAX_PATH];
WideCharToMultiByte(CP_ACP, 0, finalpath.c_str(), -1, buffer, MAX_PATH, NULL, NULL);
uint32 crc32 = gkPak::s_crcGenerator.GetCRC32Lowercase( buffer );
#else
uint32 crc32 = gkPak::s_crcGenerator.GetCRC32Lowercase( finalpath.c_str() );
#endif
gkPakRecordMap::iterator it = m_pakMap.find( crc32 );
if ( it != m_pakMap.end() )
{
// 如果size不为0, 这里就是读文件头 [3/24/2013 Kaiming]
bool readHeader = true;
if (size == 0)
{
readHeader = false;
}
if ( size == 0 || size > it->second.size)
{
size = it->second.size;
}
// read the data
char* pTmp = new char[size];
//////////////////////////////////////////////////////////////////////////
// 文件操作，加锁
{
gkAutoLock<gkCritcalSectionLock> lock(eLGID_global, eLID_file_seek );
// find it
fseek(m_handle, m_pakHeader.m_data_offset + it->second.start, SEEK_SET);
}
size_t BytesRead = fread(pTmp, 1, size, m_handle);
//fseek(m_handle, 0, SEEK_SET);
//////////////////////////////////////////////////////////////////////////
if (BytesRead != size)
{
delete [] pTmp;
size = 0;
}
else if (readHeader)
{
// 读文件头，直接返回了
*pData = pTmp;
return true;
}
else
{ // 读取到了一个文件的数据，判断是否经过压缩 [3/7/2013 Kaiming]
if (it->second.compressHeaderSize != 0)
{
float decompress_start = gEnv->pTimer->GetAsyncCurTime();
char* pTmpUnCompressed = new char[it->second.compressHeaderSize];
size_t unCompressedSize = it->second.compressHeaderSize - GKPAK_UNCOMPRESS_HEADER_SIZE;
size_t realSize = size - LZMA_PROPS_SIZE - GKPAK_UNCOMPRESS_HEADER_SIZE;
// 前1KB是不压缩的
// | UNCOMPRESS 1024 | HEADER | COMPRESSED
memcpy( pTmpUnCompressed, pTmp, GKPAK_UNCOMPRESS_HEADER_SIZE);
//ELzmaStatus status;
//SRes res = LzmaDecode((unsigned char*)pTmpUnCompressed, &unCompressedSize, (unsigned char*)(pTmp + LZMA_PROPS_SIZE), &realSize, (unsigned char*)pTmp, LZMA_PROPS_SIZE, LZMA_FINISH_END, &status, &g_Alloc);
SRes res = LzmaUncompress( (unsigned char*)pTmpUnCompressed + GKPAK_UNCOMPRESS_HEADER_SIZE, &unCompressedSize, (unsigned char*)(pTmp + LZMA_PROPS_SIZE + GKPAK_UNCOMPRESS_HEADER_SIZE), &realSize, (unsigned char*)pTmp + GKPAK_UNCOMPRESS_HEADER_SIZE, LZMA_PROPS_SIZE );
if (res == SZ_OK && (unCompressedSize + GKPAK_UNCOMPRESS_HEADER_SIZE) == it->second.compressHeaderSize)
{
*pData = pTmpUnCompressed;
size = unCompressedSize + GKPAK_UNCOMPRESS_HEADER_SIZE;
delete[] pTmp;
}
else
{
*pData = pTmp;
delete[] pTmpUnCompressed;
}
decompress_start = gEnv->pTimer->GetAsyncCurTime() - decompress_start;
#ifdef OS_WIN32
uint32 threadid = ::GetCurrentThreadId();
if ( threadid == gEnv->pSystemInfo->mainThreadId)
{
gkLogMessage( _T("thread[main] lzma-dec [%s] using %.2fms"), finalpath.c_str(), decompress_start * 1000);
}
else
{
gkLogMessage( _T("thread[%d] lzma-dec [%s] using %.2fms"), threadid, finalpath.c_str(), decompress_start * 1000);
}
#endif
}
else
{
*pData = pTmp;
}
return true;
}
}
else
{
return false;
}
return false;
}
//-----------------------------------------------------------------------
void gkSceneBuilder::buildSceneFromFile( gkStdString filename,bool syncMode, bool bPak , Vec3 position, uint8 uRenderLayer, bool builtIn)
{
HRESULT hr = S_OK;
m_bBuiltInPak = builtIn;
m_uRenderLayer = uRenderLayer;
if (!builtIn)
{
// gkStdString relScenePath = gkGetGameRelativePath(wszPath);
//
TCHAR todfilename[MAX_PATH];
_tcscpy_s(todfilename, filename.c_str());
todfilename[_tcslen(todfilename) - 4] = 0;
_tcscat_s(todfilename, _T(".tod"));
IRapidXmlParser todParser;
todParser.initializeReading(todfilename);
if (!todParser.getRootXmlNode())
{
return;
}
gEnv->p3DEngine->getTimeOfDay()->loadTODSequence(todParser.getRootXmlNode(), true);
todParser.finishReading();
//
// gkLogMessage( _T("gkSceneBuilder::TodFile Loaded. [%s]"), filename.c_str() );
}
ms_nAllNodeCount = 0;
ms_nLoadedNodeCount = 0;
// if not syncMode, we should clear the cache
if (!syncMode)
{
m_currEntityList.clear();
m_lastEntityList.clear();
}
// first drim to a pure filename [8/20/2011 Kaiming-Desktop]
// uint8 index = filename.find_last_of('\\') + 1;
// uint8 count = filename.length() - index;
// filename = filename.substr(index, count);
//
// // 先在目录内查找名字 [9/18/2010 Kaiming-Desktop]
// TCHAR wszPath[MAX_PATH] = _T("");
// hr = gkFindFileRelativeGame(wszPath, MAX_PATH, filename.c_str());
// assert( hr == S_OK );
// if not builtIn, load tod file [1/8/2012 Kaiming]
gkLogMessage( _T("gkSceneBuilder::Creating: [%s] ..."), filename.c_str() );
float nStartTime = gEnv->pTimer->GetAsyncCurTime();
IRapidXmlParser sceneParser;
sceneParser.initializeReading(filename.c_str());
// 建立地形 [4/4/2013 Kaiming]
CRapidXmlParseNode* terrianNode = sceneParser.getRootXmlNode(_T("Terrian"));
if (terrianNode)
{
ITerrianSystem* terrian = gEnv->p3DEngine->createTerrian();
terrian->Create( terrianNode );
}
CRapidXmlParseNode* rootNode = sceneParser.getRootXmlNode(_T("SceneObjects"));
rootNode->GetAttribute(_T("AllCount"), ms_nAllNodeCount);
CRapidXmlParseNode* firstObject = rootNode->getChildNode(_T("gkObject"));
if (firstObject)
{
// parsing one by one
parseSceneObject(firstObject);
}
sceneParser.finishReading();
gEnv->pSystem->updateProgress( 100 );
removeEntitiesDeleted();
float nTimeLoadFile = gEnv->pTimer->GetAsyncCurTime() - nStartTime;
gkLogWarning( _T("gkSceneBuilder::Loaded: [%s], use %0.2f seconds. \n"), filename.c_str() , nTimeLoadFile );
}
void gkGLExtension::Init()
{
EXTENSIONS = glGetString(GL_EXTENSIONS);
TCHAR* str = (TCHAR*)EXTENSIONS;
#ifdef UNICODE
const char* org = (const char*)EXTENSIONS;
str = new TCHAR[ strlen(org) + 1 ];
MultiByteToWideChar( CP_ACP, NULL, org, -1, str, strlen(org) + 1);
#endif
gkLogMessage( _T("GLEXT: \n --------------------------- \n %s"), str );
gkLogMessage( _T("--------------------------- \n") );
// VAO EXT
glBindVertexArrayOES = (PFNGLBINDVERTEXARRAYOESPROC) GLEXTGetProcAddress(glBindVertexArrayOES);
glDeleteVertexArraysOES = (PFNGLDELETEVERTEXARRAYSOESPROC) GLEXTGetProcAddress(glDeleteVertexArraysOES);
glGenVertexArraysOES = (PFNGLGENVERTEXARRAYSOESPROC) GLEXTGetProcAddress(glGenVertexArraysOES);
glIsVertexArrayOES = (PFNGLISVERTEXARRAYOESPROC) GLEXTGetProcAddress(glIsVertexArrayOES);
if (glBindVertexArrayOES || glDeleteVertexArraysOES || glGenVertexArraysOES || glIsVertexArrayOES )
{
gkLogMessage( _T("RendererGLES2: Device support ext [VAO].") );
//EXT_VAO = true;
#ifdef OS_IOS
EXT_VAO = true;
#endif
}
glMapBufferOES = (PFNGLMAPBUFFEROESPROC) GLEXTGetProcAddress(glMapBufferOES);
glUnmapBufferOES = (PFNGLUNMAPBUFFEROESPROC) GLEXTGetProcAddress(glUnmapBufferOES);
glGetBufferPointervOES = (PFNGLGETBUFFERPOINTERVOESPROC) GLEXTGetProcAddress(glGetBufferPointervOES);
if (glMapBufferOES || glUnmapBufferOES || glGetBufferPointervOES )
{
gkLogMessage( _T("RendererGLES2: Device support ext [map_buffer_oes].") );
MAP_BUFFER = true;
#ifdef OS_IOS
MAP_BUFFER = true;
#endif
}
else
{
MAP_BUFFER = false;
}
int max_vs_uniforms = 0;
glGetIntegerv(GL_MAX_VERTEX_UNIFORM_VECTORS , &max_vs_uniforms);
int max_ps_uniforms = 0;
glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_VECTORS , &max_ps_uniforms);
gkLogMessage( _T("RendererGLES2: max uniforms [vs:%d] [ps:%d]."), max_vs_uniforms, max_ps_uniforms );
#if defined( GL_OES_vertex_half_float ) && defined( GL_OES_vertex_type_10_10_10_2 )
COMPRESS_VERTEX = true;
#endif
if ( IsGLExtensionSupported("GL_OES_element_index_uint") )
{
INDEX_32BIT = true;
}
#ifdef OS_ANDROID
//COMPRESS_VERTEX = false;
EXT_VAO = false;
#endif
#ifdef OS_WIN32
COMPRESS_VERTEX = false;
#endif
//////////////////////////////////////////////////////////////////////////
// check ext support
bool bIsPVRTCSupported = gkGLExtension::IsGLExtensionSupported("GL_IMG_texture_compression_pvrtc");
#ifndef OS_IOS
bool bIsBGRA8888Supported = gkGLExtension::IsGLExtensionSupported("GL_IMG_texture_format_BGRA8888");
#else
bool bIsBGRA8888Supported = gkGLExtension::IsGLExtensionSupported("GL_APPLE_texture_format_BGRA8888");
#endif
bool bIsFloat16Supported = gkGLExtension::IsGLExtensionSupported("GL_OES_texture_half_float");
bool bIsFloat32Supported = gkGLExtension::IsGLExtensionSupported("GL_OES_texture_float");
#ifndef OS_IOS
bool bIsETCSupported = gkGLExtension::IsGLExtensionSupported("GL_OES_compressed_ETC1_RGB8_texture");
#endif
}
HWND gkDeviceRenderContext::initDevice(ISystemInitInfo& sii)
{
//////////////////////////////////////////////////////////////////////////
// native create ogles2 device
int bDone;
m_NDT = 0;//(EGLNativeDisplayType)OsGetNativeDisplayType();
m_NPT = 0;//(EGLNativePixmapType) OsGetNativePixmapType();
m_NWT = (EGLNativeWindowType)(sii.nativeWindowPTR);//(EGLNativeWindowType) OsGetNativeWindowType();
m_EGLContext = 0;
do
{
bDone = true;
m_EGLDisplay = eglGetDisplay(m_NDT);
if(m_EGLDisplay == EGL_NO_DISPLAY)
{
#if defined(BUILD_OGLES2) || defined(BUILD_OVG) || defined(BUILD_OGLES3)
m_EGLDisplay = eglGetDisplay((EGLNativeDisplayType)EGL_DEFAULT_DISPLAY);
#else
m_EGLDisplay = eglGetDisplay((NativeDisplayType)EGL_DEFAULT_DISPLAY);
#endif
}
if(!eglInitialize(m_EGLDisplay, &m_MajorVersion, &m_MinorVersion))
{
gkLogError(_T("RendererGLES2::eglInitialize failed."));
return 0;
}
gkLogMessage(_T("RendererGLES2::eglInitialize success."));
// Check Extension avaliablility after EGL initialization
if (m_MajorVersion > 1 || (m_MajorVersion == 1 && m_MinorVersion >= 1))
{
m_bPowerManagementSupported = true;
}
else
{
m_bPowerManagementSupported = false;
}
do
{
{
//#if defined EGL_VERSION_1_3 && defined GL_ES_VERSION_2_0
if(!eglBindAPI(EGL_OPENGL_ES_API))
{
gkLogError(_T("RendererGLES2::Failed to bind OpenGL ES API\n"));
return 0;
}
//#endif
}
gkLogMessage(_T("RendererGLES2::eglBindAPI success."));
// Find an EGL config
m_EGLConfig = SelectEGLConfiguration();
eglGetConfigAttrib(m_EGLDisplay, m_EGLConfig, EGL_CONFIG_ID, &m_iConfig);
// Destroy the context if we already created one
if (m_EGLContext)
{
eglDestroyContext(m_EGLDisplay, m_EGLContext);
}
// Attempt to create a context
EGLint ai32ContextAttribs[32];
int i = 0;
//#if defined(EGL_VERSION_1_3) && defined(GL_ES_VERSION_2_0)
ai32ContextAttribs[i++] = EGL_CONTEXT_CLIENT_VERSION;
ai32ContextAttribs[i++] = 2;
//#endif
// #if defined(BUILD_OGLES2) || defined(BUILD_OGLES) || defined(BUILD_OGLES3)
// if(PVRShellIsExtensionSupported(m_EGLDisplay,"EGL_IMG_context_priority"))
// {
// ai32ContextAttribs[i++] = EGL_CONTEXT_PRIORITY_LEVEL_IMG;
// switch(m_pShell->PVRShellGet(prefPriority))
// {
// case 0: ai32ContextAttribs[i++] = EGL_CONTEXT_PRIORITY_LOW_IMG; break;
// case 1: ai32ContextAttribs[i++] = EGL_CONTEXT_PRIORITY_MEDIUM_IMG; break;
// default:ai32ContextAttribs[i++] = EGL_CONTEXT_PRIORITY_HIGH_IMG;
// }
// }
// #endif
ai32ContextAttribs[i] = EGL_NONE;
m_EGLContext = eglCreateContext(m_EGLDisplay, m_EGLConfig, NULL, ai32ContextAttribs);
if(m_EGLContext == EGL_NO_CONTEXT)
{
if(m_iRequestedConfig > 0)
{
// We failed to create a context
gkLogError(_T("RendererGLES2::eglCreateContext failed."));
return 0;
}
}
gkLogMessage(_T("RendererGLES2::eglCreateContext retry."));
} while(m_EGLContext == EGL_NO_CONTEXT);
EGLint attrib_list[16];
int i = 0;
// #if defined(EGL_VERSION_1_2)
// if(m_pShell->m_pShellData->bNeedAlphaFormatPre) // The default is EGL_ALPHA_FORMAT_NONPRE
// {
// attrib_list[i++] = EGL_ALPHA_FORMAT;
// attrib_list[i++] = EGL_ALPHA_FORMAT_PRE;
// }
// #endif
// Terminate the attribute list with EGL_NONE
attrib_list[i] = EGL_NONE;
// if(m_pShell->m_pShellData->bNeedPixmap)
// {
// m_pShell->PVRShellOutputDebug("InitAPI() Using pixmaps, about to create egl surface\n");
// m_EGLWindow = eglCreatePixmapSurface(m_EGLDisplay, m_EGLConfig, m_NPT, attrib_list);
// }
// else
{
//#if defined(ANDROID)
EGLint visualID;
eglGetConfigAttrib(m_EGLDisplay, m_EGLConfig, EGL_NATIVE_VISUAL_ID, &visualID);
gkLogMessage(_T("RendererGLES2::eglGetConfigAttrib success."));
// Change the format of our window to match our config
ANativeWindow_setBuffersGeometry(m_NWT, 0, 0, visualID);
gkLogMessage(_T("RendererGLES2::ANativeWindow_setBuffersGeometry success."));
//#endif
m_EGLWindow = eglCreateWindowSurface(m_EGLDisplay, m_EGLConfig, m_NWT, attrib_list);
// If we have failed to create a surface then try using Null
if(m_EGLWindow == EGL_NO_SURFACE)
{
m_EGLWindow = eglCreateWindowSurface(m_EGLDisplay, m_EGLConfig, NULL, attrib_list);
}
}
if (m_EGLWindow == EGL_NO_SURFACE)
{
gkLogError(_T("RendererGLES2::eglCreateWindowSurface failed."));
return false;
}
if (!eglMakeCurrent(m_EGLDisplay, m_EGLWindow, m_EGLWindow, m_EGLContext))
{
#ifdef EGL_VERSION_1_3
if((eglGetError() == EGL_CONTEXT_LOST))
#else
if((eglGetError() == EGL_CONTEXT_LOST_IMG) && m_bPowerManagementSupported)
#endif
{
bDone = false;
}
else
{
gkLogError(_T("RendererGLES2::eglMakeCurrent failed."));
return false;
}
}
} while(!bDone);
/*
Get correct screen width and height and
save them into
m_pShell->m_pShellData->nShellDimX and
m_pShell->m_pShellData->nShellDimY
*/
EGLint screenWidth;
EGLint screenHeight;
eglQuerySurface(m_EGLDisplay, m_EGLWindow, EGL_WIDTH, &screenWidth);
eglQuerySurface(m_EGLDisplay, m_EGLWindow, EGL_HEIGHT, &screenHeight);
getRenderer()->SetCurrContent(0,0,0,screenWidth, screenHeight);
glViewport(0,0,screenWidth, screenHeight);
gkLogMessage(_T("RendererGLES2::CreateDevice Success! %d x %d"), screenWidth, screenHeight);
eglSwapInterval(m_EGLDisplay, 0);
sii.fWidth = screenWidth;
sii.fHeight = screenHeight;
/*
Done - activate requested features
*/
//ApiActivatePreferences();
//glViewport(0,0,sii.fWidth, sii.fHeight);
return (HWND)1;
}
void gkTextManager::parseScripts(const gkString& group)
{
gkResourceManager::ResourceIterator iter = getResourceIterator();
while (iter.hasMoreElements())
{
gkTextFile* tf = static_cast<gkTextFile*>(iter.getNext().second);
if (!group.empty() && tf->getGroupName() != group) continue;
const gkString& buf = tf->getText();
const int type = tf->getType();
#ifdef OGREKIT_COMPILE_OGRE_SCRIPTS
try
{
if (type == TT_MATERIAL)
{
Ogre::DataStreamPtr memStream(
OGRE_NEW Ogre::MemoryDataStream((void*)buf.c_str(), buf.size()));
Ogre::MaterialManager::getSingleton().parseScript(memStream, group);
}
else if (type == TT_PARTICLE)
{
Ogre::DataStreamPtr memStream(
OGRE_NEW Ogre::MemoryDataStream((void*)buf.c_str(), buf.size()));
Ogre::ParticleSystemManager::getSingleton().parseScript(memStream, group);
}
else if (type == TT_FONT)
{
// Note: font must be an external file (.ttf anyway (texture fonts are not tested) )
Ogre::DataStreamPtr memStream(
OGRE_NEW Ogre::MemoryDataStream((void*)buf.c_str(), buf.size()));
Ogre::FontManager::getSingleton().parseScript(memStream, group);
}
else if (type == TT_COMPOSIT)
{
Ogre::DataStreamPtr memStream(
OGRE_NEW Ogre::MemoryDataStream((void*)buf.c_str(), buf.size()));
Ogre::CompositorManager::getSingleton().parseScript(memStream, group);
}
}
catch (Ogre::Exception& e)
{
gkLogMessage("TextManager: " << e.getDescription());
continue;
}
if (type == TT_BFONT)
{
utMemoryStream stream;
stream.open(buf.c_str(), buf.size(), utStream::SM_READ);
gkFontManager::getSingleton().parseScript(&stream);
}
#endif
#ifdef OGREKIT_USE_LUA
if (type == TT_LUA)
gkLuaManager::getSingleton().createFromText(gkResourceName(tf->getResourceName().getName(), group), buf);
#endif
}
#ifdef OGREKIT_COMPILE_OGRE_SCRIPTS
// Overlays are a dependant script. (.material .font)
try
{
TextArray overlays;
getTextFiles(overlays, TT_OVERLAY);
TextArray::Iterator it = overlays.iterator();
while (it.hasMoreElements())
{
gkTextFile* tf = (gkTextFile*)it.getNext();
const gkString& buf = tf->getText();
const int type = tf->getType();
Ogre::DataStreamPtr memStream(
OGRE_NEW Ogre::MemoryDataStream((void*)buf.c_str(), buf.size()));
Ogre::OverlayManager::getSingleton().parseScript(memStream, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
}
}
catch (Ogre::Exception& e)
{
gkLogMessage("TextManager: " << e.getDescription());
}
#endif
}
bool gkMaterial::loadImpl( void )
{
//////////////////////////////////////////////////////////////////////////
// 手动加载
gkNameValuePairList::iterator it = loadingParams.find(_T("file"));
if (it != loadingParams.end())
{
m_wstrIndividualFileName = it->second;
m_yLoadType = GKMATERIAL_LOADTYPE_INDIVIDUALFILE;
}
switch(m_yLoadType)
{
case GKMATERIAL_LOADTYPE_FILE:
m_wstrIndividualFileName = m_wstrFileName;
{
const TCHAR* path = m_wstrFileName.c_str();
// if not has the mat file, go with it [12/4/2011 Kaiming]
if (_tcscmp( &(path[_tcslen(path) - 4]), _T(".mtl") ))
{
m_wstrIndividualFileName += _T(".mtl");
}
}
case GKMATERIAL_LOADTYPE_INDIVIDUALFILE:
{
bool succesed = false;
if (m_bLoadFromFile)
{
// if loaded, just get params from params block
m_bLoadFromFile = false;
gkLogMessage(_T("load material %s"), m_wstrIndividualFileName.c_str());
IRapidXmlParser parser;
parser.initializeReading(m_wstrIndividualFileName.c_str());
CRapidXmlParseNode* rootXmlNode = parser.getRootXmlNode();
if (!rootXmlNode)
{
return false;
}
gkLogMessage(_T("parsing material %s"), m_wstrIndividualFileName.c_str());
// check
if (_tcsicmp(rootXmlNode->GetName(), _T("Material")))
{
GK_ASSERT(0);
return false;
}
// if main
if (rootXmlNode->getChildNode(_T("Effect")))
{
gkLogMessage(_T("parsing main material %s"), m_wstrIndividualFileName.c_str());
succesed = loadMaterialFormRapidXmlNode(rootXmlNode);
}
// submaterial loading
CRapidXmlParseNode* subMaterial = rootXmlNode->getChildNode(_T("SubMaterial"));
if (subMaterial)
{
for (; subMaterial; subMaterial = subMaterial->getNextSiblingNode(_T("SubMaterial")))
{
m_uSubMtlCount++;
gkStdString submtlname = m_wstrFileName;
submtlname.append( _T("|") );
submtlname.append( subMaterial->GetAttribute(_T("Name")) );
gkMaterial* pSub = new gkMaterial(NULL, submtlname.c_str(), 0 );
succesed = pSub->loadMaterialFormRapidXmlNode( subMaterial );
m_vecSubMtlList.push_back(gkMaterialPtr(pSub));
}
}
gkLogMessage(_T("parsing material %s"), m_wstrIndividualFileName.c_str());
parser.finishReading();
gkLogMessage(_T("parsed material %s"), m_wstrIndividualFileName.c_str());
}
else
{
//succesed = loadFromParamBlock();
// if sub
SubMaterialList::iterator it = m_vecSubMtlList.begin();
for (; it != m_vecSubMtlList.end(); ++it)
{
//succesed = ((gkMaterial*)((*it).getPointer()))->loadFromParamBlock();
}
}
return succesed;
}
break;
case GKMATERIAL_LOADTYPE_SCENE:
{
//return loadFromParamBlock();
}
break;
}
return true;
}
gkBlendListIterator::gkBlendListIterator(List* list)
: m_list(list),
#if OGREKIT_USE_BPARSE
m_index(0)
#else
m_index(list ? list->first : 0)
#endif
{
}
bool gkBlendListIterator::hasMoreElements() const
{
if (m_list == 0) return false;
#if OGREKIT_USE_BPARSE
return m_index < m_list->size();
#else
return m_index != 0;
#endif
}
gkBlendListIterator::ListItem* gkBlendListIterator::getNext(void)
{
#if OGREKIT_USE_BPARSE
return m_list->at(m_index++);
#else
ListItem* item = m_index;
m_index = m_index->next;
return item;
#endif
}
//--
gkBlendInternalFile::gkBlendInternalFile()
: m_file(0)
{
}
gkBlendInternalFile::~gkBlendInternalFile()
{
delete m_file;
m_file = 0;
}
bool gkBlendInternalFile::parse(const gkString& fname)
{
if (fname.empty())
{
gkLogMessage("BlendFile: File " << fname << " loading failed. File name is empty.");
return false;
}
#if OGREKIT_USE_BPARSE
utMemoryStream fs;
fs.open(fname.c_str(), utStream::SM_READ);
if (!fs.isOpen())
{
gkLogMessage("BlendFile: File " << fname << " loading failed. No such file.");
return false;
}
// Write contents and inflate.
utMemoryStream buffer(utStream::SM_WRITE);
fs.inflate(buffer);
m_file = new bParse::bBlenderFile((char*)buffer.ptr(), buffer.size());
m_file->parse(false);
if (!m_file->ok())
{
gkLogMessage("BlendFile: File " << fname << " loading failed. Data error.");
return false;
}
#else
m_file = new fbtBlend();
int status = m_file->parse(fname.c_str(), fbtFile::PM_COMPRESSED);
if (status != fbtFile::FS_OK)
{
delete m_file;
m_file = 0;
gkLogMessage("BlendFile: File " << fname << " loading failed. code: " << status);
//return false;
}
else
{
gkLogMessage("BlendFile: File " << fname << " loading end1" );
return true;
}
//gkLogMessage("BlendFile: File " << fname << " loading end" );
m_file = new fbtBlend();
Ogre::DataStreamPtr stream;
Ogre::ArchiveManager::ArchiveMapIterator beginItera = Ogre::ArchiveManager::getSingleton().getArchiveIterator();
while(beginItera.hasMoreElements())
{
typedef std::map<Ogre::String, Ogre::Archive*>::iterator ArchiveIterator;
ArchiveIterator arch = beginItera.current();
if (arch->second)
{
Ogre::FileInfoListPtr fileInfo = arch->second->findFileInfo(fname);
if (fileInfo->size() > 0)
{
stream = arch->second->open(fname);
gkLogMessage("BlendFile: File found create stream");
break;
}
}
beginItera.moveNext();
}
//gkLogMessage("malloc buffer");
unsigned char * buffer = new unsigned char[stream->size()];
//gkLogMessage(" stream->read ");
long sizeCount = stream->read(buffer,stream->size());
//gkLogMessage(" m_file->parse");
if(m_file) m_file->parse(buffer,sizeCount);
delete buffer;
//gkLogMessage(" m_file->parse end");
#endif
return true;
}
Blender::FileGlobal* gkBlendInternalFile::getFileGlobal()
{
GK_ASSERT(m_file);
#if OGREKIT_USE_BPARSE
return (Blender::FileGlobal*)m_file->getFileGlobal();
#else
return m_file->m_fg;
#endif
}
int gkBlendInternalFile::getVersion()
{
GK_ASSERT(m_file);
#if OGREKIT_USE_BPARSE
return m_file->getMain()->getVersion();
#else
return m_file->getVersion();
#endif
}
bool gkMaterial::loadMaterialFormRapidXmlNode( CRapidXmlParseNode* rootXmlNode )
{
CRapidXmlParseNode* fxXmlNode = rootXmlNode->getChildNode();
if (_tcsicmp(fxXmlNode->GetName(), _T("Effect")))
{
GK_ASSERT(0);
return false;
}
CRapidXmlParseNode* staticXmlNode = rootXmlNode->getChildNode(_T("Static"));
if (staticXmlNode)
{
CRapidXmlParseNode* uvXmlNode = staticXmlNode->getChildNode();
if (uvXmlNode->GetAttribute(_T("value")) == 0)
{
return false;
}
gkStdStringstream stream(uvXmlNode->GetAttribute(_T("value")));
stream>> m_vUVTill.x >> m_vUVTill.y >> m_vUVOffset.x >> m_vUVOffset.y;
}
// 构建一个临时的ParamBlock
// FIXME [11/2/2011 Kaiming]
gkMaterialParams* psParamBlock = new gkMaterialParams;
gkMaterialParams& sParamBlock = *psParamBlock;
// 赋值
sParamBlock.m_wstrMatName = rootXmlNode->GetAttribute(_T("Name"));
// 赋值
m_shaderFilename = fxXmlNode->GetAttribute(_T("FileName"));
fxXmlNode->GetAttribute(_T("CastShadow"), m_castShadow);
// macro
// 合并mask
if (m_marcoMask == -1)
{
int mask = 0;
fxXmlNode->GetAttribute(_T("Mask"), mask);
m_marcoMask = mask;
}
// remove extension
m_shaderFilename = gkGetPureFilename(m_shaderFilename.c_str());
gkStdStringstream ss;
ss << m_shaderFilename << _T("@") << m_marcoMask;
// 在这里建立MARCOS，加载shader
m_pShader = gEnv->pSystem->getShaderMngPtr()->load(ss.str(), _T(""));
gkLogMessage(_T("Parsing MaterialParams..."));
// parameter accessing
CRapidXmlParseNode *pParamChild = fxXmlNode->getChildNode();
// 遍历params
for ( ; pParamChild != 0; pParamChild = pParamChild->getNextSiblingNode())
{
//GKSHADERPARAM sParam;
gkStdString typeName;
GKSHADERPARAM* param = NULL;
// 先找属性
// 赋值
//sParam.pParamName = new char[MAX_PATH];
//ZeroMemory(sParam.pParamName, sizeof(char) * MAX_PATH);
char paramName[MAX_PATH];
#ifdef UNICODE
WideCharToMultiByte(CP_ACP, 0, pParamChild->GetAttribute(_T("name")), -1, paramName, MAX_PATH, NULL, NULL);
#else
_tcscpy_s(paramName, MAX_PATH, pParamChild->GetAttribute(_T("name")) );
#endif
typeName = pParamChild->GetAttribute(_T("type"));
gkStdStringstream stream(pParamChild->GetAttribute(_T("value")));
// 根据属性提供的类型，写入
if(typeName == _T("float"))
{
float tmpValue;
stream>>tmpValue;
param = new GKSHADERPARAM( paramName, tmpValue );
}
else if(typeName == _T("float2"))
bool gkSystem::Init( ISystemInitInfo& sii )
{
gkLogMessage(_T("Initializing gkSystem..."));
std::vector<gkStdString> result;
gkStdString path;
#ifdef OS_IOS
path = gkGetExecRootDir();
#else
path = gkGetExecRootDir() + _T("paks/");
#endif
enum_all_files_in_folder(path.c_str(), result, false);
for (int i=0; i < result.size(); ++i) {
gkStdString file = result[i];
const TCHAR* strLastSlash = _tcsrchr( file.c_str(), _T( '.' ) );
if( strLastSlash )
{
if ( !_tcsicmp( strLastSlash, _T(".gpk") ) )
{
gkNormalizePath(file);
gkStdString filename = gkGetFilename( file.c_str() );
#ifdef OS_IOS
#else
file = _T("/paks") + file;
#endif
gkLogMessage( _T("pak file [%s] loaded."), filename.c_str() );
m_ResFileManager.openPak( file.c_str() );
}
}
}
#ifdef OS_WIN32
m_fileMonitor = new FileChangeMonitor();
m_fileMonitor->StartMonitor();
gEnv->pFileChangeMonitor = m_fileMonitor;
#endif
m_bEditor = (sii.hInstance != 0);
//CrashRptHead();
m_bIsSceneEmpty = true;
/************************************************************************/
/* Module Loading
/************************************************************************/
#ifdef WIN32
TCHAR wszRenderDll[MAX_PATH] = _T("gkRendererD3D9");
if (!IsEditor())
{
gkStdString cfgfile = gkGetExecRootDir() + _T("media/config/startup.cfg");
GetPrivateProfileString( _T("launcher"), _T("renderer"), _T("gkRendererD3D9"), wszRenderDll, MAX_PATH, cfgfile.c_str() );
}
#else
TCHAR wszRenderDll[MAX_PATH] = _T("gkRendererGLES2");
#endif
#ifndef _STATIC_LIB
if ( !_tcsicmp( wszRenderDll, _T("gkRendererD3D9") ))
{
LOAD_MODULE_GLOBAL( m_moduleHandles.hRenderer, gkRendererD3D9 );
}
else if ( !_tcsicmp( wszRenderDll, _T("gkRendererGLES2") ) )
{
LOAD_MODULE_GLOBAL( m_moduleHandles.hRenderer, gkRendererGLES2 );
}
else if ( !_tcsicmp( wszRenderDll, _T("gkRendererGL330") ) )
{
LOAD_MODULE_GLOBAL( m_moduleHandles.hRenderer, gkRendererGL330 );
}
#else
//LOAD_MODULE_GLOBAL( m_moduleHandles.hRenderer, gkRendererGLES2 );
#ifdef OS_APPLE
LOAD_MODULE_GLOBAL( m_moduleHandles.hRenderer, gkRendererGL330 );
#elif defined( OS_IOS )
LOAD_MODULE_GLOBAL( m_moduleHandles.hRenderer, gkRendererGLES2 );
#else
LOAD_MODULE_GLOBAL( m_moduleHandles.hRenderer, gkRendererD3D9 );
#endif
#endif
LOAD_MODULE_GLOBAL(m_moduleHandles.h3DEngine, gkCore);
gEnv->p3DEngine->Init();
LOAD_MODULE_GLOBAL(m_moduleHandles.hInputLayer, gkInput);
//LoadLib(m_moduleHandles.hNetworkLayer, _T("gkNetwork"));
//////////////////////////////////////////////////////////////////////////
// load physics module
#ifndef MUTE_PHYSICS
# ifdef WIN32
TCHAR wszPhysicDll[MAX_PATH] = _T("");
gkStdString cfgfile = gkGetExecRootDir() + _T("media/config/startup.cfg");
GetPrivateProfileString( _T("launcher"), _T("physicsengine"), _T(""), wszPhysicDll, MAX_PATH, cfgfile.c_str() );
# else
TCHAR wszPhysicDll[MAX_PATH] = _T("gkHavok");
# endif // WIN32
# ifndef _STATIC_LIB
gkLoadModule( m_moduleHandles.hPhysics, wszPhysicDll );
# else
//LOAD_MODULE_GLOBAL( m_moduleHandles.hPhysics, gkHavok );
# endif // _STATIC_LIB
#endif // MUTE_PHYSICS
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
// load animation module
{
# ifdef WIN32
TCHAR wszAnimationDll[MAX_PATH] = _T("gkAnimationHavok");
gkStdString cfgfile = gkGetExecRootDir() + _T("media/config/startup.cfg");
GetPrivateProfileString( _T("launcher"), _T("animationengine"), _T("gkAnimationHavok"), wszAnimationDll, MAX_PATH, cfgfile.c_str() );
# else
TCHAR wszAnimationDll[MAX_PATH] = _T("gkAnimationHavok");
# endif // WIN32
#ifdef OS_APPLE
#else
# ifndef _STATIC_LIB
gkLoadModule( m_moduleHandles.hAnimation, wszAnimationDll );
# else
#if TARGET_OS_IPHONE
LOAD_MODULE_GLOBAL( m_moduleHandles.hAnimation, gkAnimation );
#endif
# endif // _STATIC_LIB
#endif
}
//////////////////////////////////////////////////////////////////////////
LOAD_MODULE_GLOBAL(m_moduleHandles.hGameObjectSystem, gkGameObjectSystem);
LOAD_MODULE_GLOBAL(m_moduleHandles.hFont, gkFont);
#ifdef OS_WIN32
LOAD_MODULE_GLOBAL(m_moduleHandles.hTrackBus, gkTrackBus);
LOAD_MODULE_GLOBAL(m_moduleHandles.hSound, gkSound);
//LOAD_MODULE_GLOBAL(m_moduleHandles.hVideo, gkVideo);
//LOAD_MODULE_GLOBAL(m_moduleHandles.hStereoDevice, gkStereoDevice);
{
TCHAR wszStereoDevDll[MAX_PATH] = _T("null");
gkStdString cfgfile = gkGetExecRootDir() + _T("media/config/startup.cfg");
GetPrivateProfileString( _T("launcher"), _T("stereodevice"), _T("null"), wszStereoDevDll, MAX_PATH, cfgfile.c_str() );
gkLoadModule( m_moduleHandles.hStereoDevice, wszStereoDevDll );
}
#endif
m_CVManager.initInput();
gkLogMessage(_T("CVar Manager Initialized."));
m_pSystemCVars = new gkSystemCVars;
g_pSystemCVars = m_pSystemCVars;
gkLogMessage(_T("System CVar Initialized."));
m_CVManager.reloadAllParameters();
// init Timer
if (!m_Timer.Init(this))
return (false);
m_Timer.ResetTimer();
gkLogMessage(_T("Timer Initialized."));
gkIniParser startupFile( _T("config/startup.cfg") );
startupFile.Parse();
gkStdString ret = startupFile.FetchValue( _T("launcher"), _T("width") );
if( !ret.empty() )
{
gkStdStringstream ss(ret);
ss >> sii.fWidth;
}
void gkFontManager::parseScript(utMemoryStream* buffer)
{
utScript script;
script.parseBuffer("FontManager:parseScript", gkString((const char*)buffer->ptr()));
utScriptTree* treePtr = script.getTreePtr();
if (treePtr->getNodes().empty())
return;
utScriptTree::Nodes::Iterator niter = treePtr->getNodes().iterator();
while (niter.hasMoreElements())
{
utScriptNode* tree = niter.getNext();
if (!tree->hasAttribute("source"))
{
gkLogMessage("FontManager: Missing font script attribute 'source'");
continue;
}
const gkString src = tree->getAttribute("source")->getValue();
if (!exists(src))
{
gkLogMessage("FontManager: Missing internal font " << src);
continue;
}
const gkString name = tree->getType();
Ogre::FontPtr fp = Ogre::FontManager::getSingleton().getByName(name);
if (!fp.isNull())
{
// use it
return;
}
gkFont* gkf = (gkFont*)getByName(src);
int size = 0, res = UT_NPOS;
if (tree->hasAttribute("size"))
gkFromString(tree->getAttribute("size")->getValue(), size);
if (tree->hasAttribute("resolution"))
gkFromString(tree->getAttribute("resolution")->getValue(), res);
try
{
gkFont::Loader* fl = gkf->addLoader(size > 0 && size != UT_NPOS ? size : 12, res != UT_NPOS ? res : 55);
fp = Ogre::FontManager::getSingleton().create(name, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, true, fl);
fl->setFont(fp.getPointer());
}
catch (Ogre::Exception& e)
{
gkLogMessage("FontManager::parseScript: " << e.getDescription());
}
}
}
void gkGameLevel::notifyResourceCreated(gkResource* res)
{
gkLogMessage(res->getManagerType() << ", " << res->getResourceType() <<
":handle " << res->getResourceHandle() << ", created " << res->getResourceName().getName());
}
void gkGameLevel::notifyInstanceCreated(gkInstancedObject* inst)
{
gkLogMessage("GameLevel: Instanced -> " << inst->getResourceName().getName());
}
