//----------------------------------------------------------------------------//
OpenGLRenderer& OpenGLRenderer::create(const TextureTargetType tt_type,
const int abi)
{
System::performVersionTest(CEGUI_VERSION_ABI, abi, CEGUI_FUNCTION_NAME);
return *CEGUI_NEW_AO OpenGLRenderer(tt_type);
}
bool EngineApp::InitInstance( SDL_Window* window, int screenWidth, int screenHeight )
{
/*auto test = std::vector< Vec2 >( { Vec2( 1.0f, 1.0f ), Vec2( 5.0f, 5.0f ), Vec2( 4.0f, 4.0f ), Vec2( 1.0f, -3.0f ) } );*/
//auto test = std::vector< Vec2 >( { Vec2( 0.0f, 2.0f ), Vec2( 1.0f, 4.0f ), Vec2( 2.0f, 0.0f ), Vec2( 3.0f, 1.0f ), Vec2( 4.0f, 3.0f ) } );
//Triangulation( test );
// Check for existing instance of the same window
// Not sure if this feature is working normally....
#ifndef _DEBUG
// Note - it can be really useful to debug network code to have
// more than one instance of the game up at one time - so
// feel free to comment these lines in or out as you wish!
if (!IsOnlyInstance( VGetGameTitle() ) )
{
return false;
}
#endif
//---------------------------------
// Check system requirements
//---------------------------------
bool resourceCheck = false;
while (!resourceCheck)
{
const DWORDLONG physicalRAM = 512 * MEGABYTE;
const DWORDLONG virtualRAM = 1024 * MEGABYTE;
const DWORDLONG diskSpace = 10 * MEGABYTE;
if ( !CheckStorage(diskSpace) )
{
return false;
}
const DWORD minCpuSpeed = 1300; // 1.3Ghz
DWORD thisCPU = ReadCPUSpeed();
if ( thisCPU < minCpuSpeed )
{
ENG_ERROR("GetCPUSpeed reports CPU is too slow for this game.");
return false;
}
resourceCheck = true;
}
//---------------------------------
// Check system requirements
//---------------------------------
//---------------------------------
// Initialize ResCache, all assets are within a zip file
//---------------------------------
IResourceFile *pFile = NULL;
if( m_EngineOptions.GetIsUsingDevDirectory() )
{
pFile = ENG_NEW DevResourceFile( DevResourceFile::Editor );
}
else
{
pFile = ENG_NEW ResourceZipFile( L"Assets.zip" );
}
m_pResCache = ENG_NEW ResourceCache( 50, pFile );
if ( !m_pResCache->Init() )
{
ENG_ERROR("Failed to initialize resource cache! Are your paths set up correctly?");
return false;
}
// extern shared_ptr<IResourceLoader> CreateWAVResourceLoader();
m_pResCache->RegisterLoader< XmlResourceLoader >();
m_pResCache->RegisterLoader< MeshResourceLoader >();
m_pResCache->RegisterLoader< TextureResourceLoader >();
m_pResCache->RegisterLoader< ScriptResourceLoader >();
if( !LoadStrings("English") )
{
ENG_ERROR("Failed to load strings");
return false;
}
//---------------------------------
// Initialize ResCache
//---------------------------------
//---------------------------------
// Initialize Lua scripting
//---------------------------------
// Rez up the Lua State manager now, and run the initial script - discussed in Chapter 5, page 144.
if( !LuaStateManager::GetSingleton().VInit() )
{
ENG_ERROR( "Failed to initialize Lua" );
return false;
}
ScriptExports::Register();
Resource resource( m_EngineOptions.GetPreInitScriptFile() );
shared_ptr<ResHandle> pResourceHandle = m_pResCache->GetHandle( resource );
ENG_ASSERT( pResourceHandle );
RegisterScriptClass< AnimationClipNode, IAnimationNode >();
RegisterScriptClass< AnimationLerpNode, IAnimationNode >();
RegisterScriptClass< AnimationState >();
//---------------------------------
// Initialize Lua scripting
//---------------------------------
//---------------------------------
// Initialize EventManager
//---------------------------------
// Set as global EventManager
m_pEventManager = ENG_NEW EventManager( "Engine Event Manager", true );
if ( !m_pEventManager )
{
ENG_ERROR( "Failed to create EventManager." );
return false;
}
//---------------------------------
// Initialize EventManager
//---------------------------------
//---------------------------------
// Initiate window & SDL, glew
//---------------------------------
if ( SDL_Init(SDL_INIT_EVERYTHING) != 0 )
{
ENG_ERROR( SDL_GetError() );
return false;
}
CHAR charTitle[100];
if( GenericToAnsiCch( charTitle, VGetGameTitle(), strlen( charTitle ) ) != S_OK )
{
ENG_ERROR( "Game title translation failed" );
}
if( !window )
{
m_pWindow = SDL_CreateWindow( charTitle, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, screenWidth,screenHeight, SDL_WINDOW_OPENGL );
if ( !m_pWindow )
{
ENG_ERROR( SDL_GetError() );
return false;
}
}
else
{
m_pWindow = window;
}
// Only if execute under editor can engine allow file drop
if( m_EngineOptions.GetEngineEnvironment() == Environment_Editor )
{
SDL_EventState( SDL_DROPFILE, SDL_ENABLE );
}
if( m_EngineOptions.GetShowMouseCursor() )
{
SDL_ShowCursor( SDL_ENABLE );
}
else
{
SDL_ShowCursor( SDL_DISABLE );
}
SDL_WarpMouseInWindow( g_pApp->GetWindow(), g_pApp->GetScreenSize().GetX() / 2, g_pApp->GetScreenSize().GetY() / 2 );
// setup opengl rendering context
SDL_GLContext glContext = SDL_GL_CreateContext( m_pWindow );
if( !glContext )
{
ENG_ERROR( SDL_GetError() );
}
// Needed for core profile
glewExperimental = true;
GLenum error = glewInit();
if( error != GLEW_OK )
{
ENG_ERROR( reinterpret_cast<const char *>( gluErrorString( error ) ) );
}
// set two buffer for rendering
SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
m_ShutDownEventType = RegisterEvent( 1 );
//---------------------------------
// Initiate window & SDL, glew
//---------------------------------
//---------------------------------
// SDL_Image
//---------------------------------
int initFlags= IMG_INIT_JPG | IMG_INIT_PNG | IMG_INIT_TIF;
int initted = IMG_Init( initFlags );
if( ( initted & initFlags ) != initFlags )
{
ENG_ERROR( IMG_GetError() );
}
//---------------------------------
// SDL_Image
//---------------------------------
//---------------------------------
// Set Renderer
//---------------------------------
if( GetRendererImpl() == Renderer_OpenGL )
{
m_pRenderer = shared_ptr<IRenderer>( ENG_NEW OpenGLRenderer() );
}
else
{
ENG_ERROR( "Not supported renderer type" );
}
m_pRenderer->VSetBackgroundColor( g_Black );
// Enable depth test
glEnable( GL_DEPTH_TEST );
// Accept fragment if it closer to the camera than the former one
glDepthFunc( GL_LESS );
// Cull triangles which normal is not towards the camera
glEnable( GL_CULL_FACE );
m_pRenderer->VOnRestore();
//---------------------------------
// Set Renderer
//---------------------------------
// Start global timer
GetGlobalTimer()->Reset();
// initialize the directory location you can store save game files
_tcscpy_s( m_saveGameDirectory, GetSaveGameDirectory( GetHwnd(), VGetGameAppDirectory() ) );
//---------------------------------
// Create game & view
//---------------------------------
m_pEngineLogic = VCreateLogic();
if (!m_pEngineLogic)
{
return false;
}
//---------------------------------
// Create game & view
//---------------------------------
m_bIsRunning = true;
return true;
}
bool Application::VInitializeInstance()
{
/*m_pGame = VCreateGameAndView();
if (!m_pGame)
return false;*/
//
// Initialize the ResCache - Chapter 5, page 141
//
// Note - this is a little different from the book. Here we have a speccial resource ZIP file class, DevelopmentResourceZipFile,
// that actually reads directly from the source asset files, rather than the ZIP file. This is MUCH better during development, since
// you don't want to have to rebuild the ZIP file every time you make a minor change to an asset.
//
//IResourceFile *zipFile = (m_bIsEditorRunning || m_Options.m_useDevelopmentDirectories) ?
//WE_NEW DevelopmentResourceZipFile(L"Assets.zip", DevelopmentResourceZipFile::Editor) :
IResourceFile *ZipFile = WE_NEW ResourceZipFile(L"Assets.zip");
m_ResCache = WE_NEW ResCache(50, ZipFile);
if (!m_ResCache->Init())
{
printf("Failed to initialize resource cache! Are your paths set up correctly?");
return false;
}
//extern shared_ptr<IResourceLoader> CreateWAVResourceLoader();
//extern shared_ptr<IResourceLoader> CreateOGGResourceLoader();
//extern shared_ptr<IResourceLoader> CreateDDSResourceLoader();
//extern shared_ptr<IResourceLoader> CreateJPGResourceLoader();
extern shared_ptr<IResourceLoader> CreateXMLResourceLoader();
//extern shared_ptr<IResourceLoader> CreateSdkMeshResourceLoader();
//extern shared_ptr<IResourceLoader> CreateScriptResourceLoader();
// Note - register these in order from least specific to most specific! They get pushed onto a list.
// RegisterLoader is discussed in Chapter 5, page 142
//m_ResCache->RegisterLoader(CreateWAVResourceLoader());
//m_ResCache->RegisterLoader(CreateOGGResourceLoader());
//m_ResCache->RegisterLoader(CreateDDSResourceLoader());
//m_ResCache->RegisterLoader(CreateJPGResourceLoader());
m_ResCache->RegisterLoader(CreateXMLResourceLoader());
//m_ResCache->RegisterLoader(CreateSdkMeshResourceLoader());
//m_ResCache->RegisterLoader(CreateScriptResourceLoader());
m_ProcessManager = new ProcessManager;
m_pEventManager = WE_NEW EventManager("Warp Engine Generic Event Manager", true);
EventListenerDelegate DelegateFunction = fastdelegate::MakeDelegate(this, &Application::EngineLoadedDelegate);
IEventManager::Get()->VAddListener(DelegateFunction, EventData_Engine_Loaded::sk_EventType);
TS = WE_NEW TestSystem();
TS->Initialize();
// Create a window
//IWindow* Wind = new GLFWWindow();
//Wind->VInitializeInstance(640, 400, "Main Window");
// Splash Screen Creation
m_pSplash = new GLFWSplashScreen();
m_pSplash->VInitializeInstance(1024, 512, "Splash");
// Renderer setup
m_Renderer = shared_ptr<IRenderer>(WE_NEW OpenGLRenderer());
//m_Renderer->SetBackgroundColor()
// Temporary!
m_pGame = WE_NEW BaseGameLogic;
if (!m_pGame)
return false;
Human = WE_NEW HumanView(m_Renderer);
m_pGame->VAddView(shared_ptr<IGameView>(Human));
Human->SetWindow(m_pSplash);
m_pSplash->VOnUpdate(1.0f);
m_pSplash->VOnRender();
//Human->SetWindow(Wind);
StrongProcessPtr EngineLoad(new ProcessEngineLoad(3));
m_ProcessManager->AttachProcess(EngineLoad);
//m_Renderer->VAddRenderTarget(Wind);
/*
Mat4x4 Mat = Mat4x4();
Mat.BuildRotationX(0.5f);
Mat.BuildTranslation(2.0f, 3.0f, 10.0f);
Mat.BuildTranslation(1.0f, 0.0f, 0.0f);
Mat.BuildTranslation(1.0f, 0.0f, 0.0f);
Mat.BuildTranslation(1.0f, 0.0f, 0.0f);
Mat.BuildTranslation(1.0f, 0.0f, 0.0f);
Mat.BuildTranslation(2.0f, 0.0f, 0.0f);
StrongProcessPtr Render(new ProcessRender());
StrongProcessPtr Delay(new ProcessDelay(10));
StrongProcessPtr Delay2(new ProcessDelay(2));
m_ProcessManager->AttachProcess(Delay);
Delay->AttachChild(Delay2);
Delay->AttachChild(Render);
*/
return true;
}
