/**
* Initialize an EGL context for the current display.
*/
int Engine::InitDisplay()
{
if( !initialized_resources_ )
{
gl_context_->Init( app_->window );
LoadResources();
initialized_resources_ = true;
}
else
{
// initialize OpenGL ES and EGL
if( EGL_SUCCESS != gl_context_->Resume( app_->window ) )
{
UnloadResources();
LoadResources();
}
}
ShowUI();
// Initialize GL state.
glEnable( GL_CULL_FACE );
glEnable( GL_DEPTH_TEST );
glDepthFunc( GL_LEQUAL );
//Note that screen size might have been changed
glViewport( 0, 0, gl_context_->GetScreenWidth(), gl_context_->GetScreenHeight() );
renderer_.UpdateViewport();
tap_camera_.SetFlip( 1.f, -1.f, -1.f );
tap_camera_.SetPinchTransformFactor( 10.f, 10.f, 8.f );
return 0;
}
//-----------------------------------------------------------------------------
// Main
int Main(void)
{
// Start things up & load resources ---------------------------------------------------
loadResources();
ResetNewGame();
// Set up rendering ---------------------------------------------------------------------
glViewport(0, 0, SYS_WIDTH, SYS_HEIGHT);
glClearColor(0.0f, 0.1f, 0.3f, 0.0f);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0.0, G_WIDTH, 0.0, G_HEIGHT, 0.0, 1.0);
glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
//glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// Main game loop! ======================================================================
while (!SYS_GottaQuit())
{
Render();
SYS_Show();
ProcessInput();
RunGame();
SYS_Pump();
SYS_Sleep(16); // Cant be static if game should run equally on different hardware!
g_time += FRAMETIME;
}
UnloadResources();
return 0;
}
/**
* Initialize an EGL context for the current display.
*/
int Engine::InitDisplay(const int32_t cmd) {
if (!initialized_resources_) {
startup_mutex_.lock();
gl_context_->Init(app_->window);
InitUI();
LoadResources();
initialized_resources_ = true;
startup_mutex_.unlock();
} else {
// initialize OpenGL ES and EGL
if (EGL_SUCCESS != gl_context_->Resume(app_->window)) {
UnloadResources();
LoadResources();
}
jui_helper::JUIWindow::GetInstance()->Resume(app_->activity, cmd);
}
// Enable culling OpenGL state
glEnable(GL_CULL_FACE);
// Enabled depth test OpenGL state
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
// Note that screen size might have been changed
glViewport(0, 0, gl_context_->GetScreenWidth(),
gl_context_->GetScreenHeight());
renderer_.UpdateViewport();
tap_camera_.SetFlip(1.f, -1.f, -1.f);
tap_camera_.SetPinchTransformFactor(2.f, 2.f, 8.f);
return 0;
}
/**
* Initialize an EGL context for the current display.
*/
int Engine::InitDisplay(android_app* app) {
if (!initialized_resources_) {
gl_context_->Init(app_->window);
LoadResources();
initialized_resources_ = true;
} else if(app->window != gl_context_->GetANativeWindow()) {
// Re-initialize ANativeWindow.
// On some devices, ANativeWindow is re-created when the app is resumed
assert(gl_context_->GetANativeWindow());
UnloadResources();
gl_context_->Invalidate();
app_ = app;
gl_context_->Init(app->window);
LoadResources();
initialized_resources_ = true;
} else {
// initialize OpenGL ES and EGL
if (EGL_SUCCESS == gl_context_->Resume(app_->window)) {
UnloadResources();
LoadResources();
} else {
assert(0);
}
}
ShowUI();
// Initialize GL state.
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
// Note that screen size might have been changed
glViewport(0, 0, gl_context_->GetScreenWidth(),
gl_context_->GetScreenHeight());
renderer_.UpdateViewport();
tap_camera_.SetFlip(1.f, -1.f, -1.f);
tap_camera_.SetPinchTransformFactor(2.f, 2.f, 8.f);
return 0;
}
void GraphicsService::Stop()
{
LOGI("GraphicsService::Stop");
PostEffect::Shutdown();
UnloadResources();
Render::DisableAlphaBlend();
Render::DisableOrthoMode();
Render::Uninit();
}
/**
* Just the current frame in the display.
*/
void Engine::DrawFrame() {
float fps;
if (monitor_.Update(fps)) {
UpdateFPS(fps);
}
renderer_.Update(monitor_.GetCurrentTime());
// Just fill the screen with a color.
glClearColor(0.5f, 0.5f, 0.5f, 1.f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
renderer_.Render();
// Swap
if (EGL_SUCCESS != gl_context_->Swap()) {
UnloadResources();
LoadResources();
}
}
void Effkseer_DeviceLost(void* data)
{
if(GetUseDirect3DDevice9() == NULL) return;
// デバイスロストが発生した時に呼ぶ。
g_renderer2d->OnLostDevice();
g_renderer3d->OnLostDevice();
// 読み込んだエフェクトのリソースは全て破棄する。
for (auto e : effectHandleToEffect)
{
auto effect = e.second;
effect->UnloadResources();
}
// DXライブラリは内部でデバイス自体を消去しているのでNULLを設定する。
auto renderer2d = (EffekseerRendererDX9::Renderer*)g_renderer2d;
auto renderer3d = (EffekseerRendererDX9::Renderer*)g_renderer3d;
renderer2d->ChangeDevice(NULL);
renderer3d->ChangeDevice(NULL);
}
void UIScreen::UnloadGroup()
{
if (groupId < 0)
{
if (!isLoaded)return;
UnloadResources();
isLoaded = false;
}else
{
for (List<UIScreen*>::iterator t = appScreens.begin(); t != appScreens.end(); ++t)
{
UIScreen * screen = *t;
if ((screen->groupId == groupId) && (screen->isLoaded))
{
screen->UnloadResources();
screen->isLoaded = false;
}
}
}
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
void EffectImplemented::ReloadResources( const EFK_CHAR* materialPath )
{
UnloadResources();
const EFK_CHAR* matPath = materialPath != NULL ? materialPath : m_materialPath.c_str();
Setting* loader = GetSetting();
{
TextureLoader* textureLoader = loader->GetTextureLoader();
if( textureLoader != NULL )
{
for( int32_t ind = 0; ind < m_ImageCount; ind++ )
{
EFK_CHAR fullPath[512];
PathCombine( fullPath, matPath, m_ImagePaths[ ind ] );
m_pImages[ind] = textureLoader->Load( fullPath, TextureType::Color );
}
}
}
{
TextureLoader* textureLoader = loader->GetTextureLoader();
if (textureLoader != NULL)
{
for (int32_t ind = 0; ind < m_normalImageCount; ind++)
{
EFK_CHAR fullPath[512];
PathCombine(fullPath, matPath, m_normalImagePaths[ind]);
m_normalImages[ind] = textureLoader->Load(fullPath, TextureType::Normal);
}
}
}
{
TextureLoader* textureLoader = loader->GetTextureLoader();
if (textureLoader != NULL)
{
for (int32_t ind = 0; ind < m_distortionImageCount; ind++)
{
EFK_CHAR fullPath[512];
PathCombine(fullPath, matPath, m_distortionImagePaths[ind]);
m_distortionImages[ind] = textureLoader->Load(fullPath, TextureType::Distortion);
}
}
}
{
SoundLoader* soundLoader = loader->GetSoundLoader();
if( soundLoader != NULL )
{
for( int32_t ind = 0; ind < m_WaveCount; ind++ )
{
EFK_CHAR fullPath[512];
PathCombine( fullPath, matPath, m_WavePaths[ ind ] );
m_pWaves[ind] = soundLoader->Load( fullPath );
}
}
}
{
ModelLoader* modelLoader = loader->GetModelLoader();
if( modelLoader != NULL )
{
for( int32_t ind = 0; ind < m_modelCount; ind++ )
{
EFK_CHAR fullPath[512];
PathCombine( fullPath, matPath, m_modelPaths[ ind ] );
m_pModels[ind] = modelLoader->Load( fullPath );
}
}
}
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
void EffectImplemented::Reset()
{
UnloadResources();
Setting* loader = GetSetting();
TextureLoader* textureLoader = loader->GetTextureLoader();
for( int i = 0; i < m_ImageCount; i++ )
{
if( m_ImagePaths[i] != NULL ) delete [] m_ImagePaths[i];
}
m_ImageCount = 0;
ES_SAFE_DELETE_ARRAY( m_ImagePaths );
ES_SAFE_DELETE_ARRAY(m_pImages);
{
for (int i = 0; i < m_normalImageCount; i++)
{
if (m_normalImagePaths[i] != NULL) delete [] m_normalImagePaths[i];
}
m_normalImageCount = 0;
ES_SAFE_DELETE_ARRAY(m_normalImagePaths);
ES_SAFE_DELETE_ARRAY(m_normalImages);
}
{
for (int i = 0; i < m_distortionImageCount; i++)
{
if (m_distortionImagePaths[i] != NULL) delete [] m_distortionImagePaths[i];
}
m_distortionImageCount = 0;
ES_SAFE_DELETE_ARRAY(m_distortionImagePaths);
ES_SAFE_DELETE_ARRAY(m_distortionImages);
}
for( int i = 0; i < m_WaveCount; i++ )
{
if( m_WavePaths[i] != NULL ) delete [] m_WavePaths[i];
}
m_WaveCount = 0;
ES_SAFE_DELETE_ARRAY( m_WavePaths );
ES_SAFE_DELETE_ARRAY( m_pWaves );
for( int i = 0; i < m_modelCount; i++ )
{
if( m_modelPaths[i] != NULL ) delete [] m_modelPaths[i];
}
m_modelCount = 0;
ES_SAFE_DELETE_ARRAY( m_modelPaths );
ES_SAFE_DELETE_ARRAY( m_pModels );
ES_SAFE_DELETE( m_pRoot );
}
CGameView::~CGameView()
{
UnloadResources();
delete m;
}
void RManager::ReloadResources()
{
UnloadResources();
LoadResources();
}
