int WINAPI WinMain(HINSTANCE hInstance, //Main windows function
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nShowCmd)
{
if(!InitializeWindow(hInstance, nShowCmd, Width, Height, true))
{
MessageBox(0, L"Window Initialization - Failed",
L"Error", MB_OK);
return 0;
}
if(!InitializeDirect3d11App(hInstance)) //Initialize Direct3D
{
MessageBox(0, L"Direct3D Initialization - Failed",
L"Error", MB_OK);
return 0;
}
if(!InitScene()) //Initialize our scene
{
MessageBox(0, L"Scene Initialization - Failed",
L"Error", MB_OK);
return 0;
}
messageloop();
CleanUp();
return 0;
}
STDMETHODIMP
CVWRender2D::Init(HWND hWnd, LPDIRECT2DRM pd2drm)
{
// if (!(pddsBackBuffer && pd2drm && hWnd))
// return E_INVALIDOBJECT;
if (!(pd2drm && hWnd))
return E_INVALIDOBJECT;
if (m_pfEmptyScene)
return E_ALREADYINITIALIZED;
HRESULT hr;
pd2drm->AddRef();
m_pd2drm = pd2drm;
m_hWnd = hWnd;
if (FAILED(hr = InitScene())) {
return hr;
}
// N.B.: wait for first OnSize message to initialize the size-based objects
return S_OK;
}
void Test3()
{
LoadBCP("data.bcp");
ReadLanguageFile();
InitWindow();
//InitRectDrawing();
//IDirect3DTexture9 *mytex = GetTexture("Interface\\LOADING SCREEN 1.tga");
//IDirect3DPixelShader9 *psh = LoadPixelShader("test.psh");
InitScene(); LoadMap("testmap.bcm");
while(!appexit)
{
BeginDrawing();
//ddev->SetRenderState(D3DRS_ZENABLE, FALSE);
//ddev->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
//ddev->SetPixelShader(psh);
//ddev->SetTexture(0, mytex);
//DrawRect(0, 0, 640, 480, -1);
DrawScene();
EndDrawing();
HandleWindow();
if(keyheld[VK_UP]) camerapos += Vector3(0.0f, 0.0f, walkstep);
if(keyheld[VK_DOWN]) camerapos -= Vector3(0.0f, 0.0f, walkstep);
if(keyheld[VK_LEFT]) camerapos -= Vector3(walkstep, 0.0f, 0.0f);
if(keyheld[VK_RIGHT]) camerapos += Vector3(walkstep, 0.0f, 0.0f);
if(keyheld['E']) camerapos += Vector3(0.0f, walkstep, 0.0f);
if(keyheld['D']) camerapos -= Vector3(0.0f, walkstep, 0.0f);
}
}
void MainForm::Init()
{
wxPanel * wxDrawPanelHolder = (wxPanel*)wxForm->FindWindowByName(wxString("pnlDraw"));
//wxSizer * pnlSizer = wxDrawPanelHolder->GetSizer();
drawPanel = new DrawPanel(wxDrawPanelHolder,wxDefaultPosition,wxDrawPanelHolder->GetSize(),wxDEFAULT_FRAME_STYLE,wxT("drawPnl111"));
drawPanel->OnMouseEvent(std::bind(&MainForm::DrawPanel_MouseEvent, this, std::placeholders::_1));
drawPanel->OnKeyboardEvent(std::bind(&MainForm::DrawPanel_KeyboardEvent, this, std::placeholders::_1));
//pnlSizer->Add(drawPanel->GetWxControl());
wxPanel * propPanel = (wxPanel*)wxForm->FindWindowByName(wxString("pnlPropBar"));
wxSizer * propSizer = propPanel->GetSizer();
PropertiesPanel::SetPanel(propPanel);
PropertySectionsManager::SetParent(propPanel);
InitScene();
wxButton * btnAddStaticEntity = (wxButton*)wxForm->FindWindowByName(wxString("btnCreateStaticEntity"));
btnAddStaticEntity->Bind(wxEVT_LEFT_DOWN,&MainForm::OnAddStaticEntity_Click,this);
wxButton * btnAddLight = (wxButton*)wxForm->FindWindowByName(wxString("btnCreatePointLight"));
btnAddLight->Bind(wxEVT_LEFT_DOWN, &MainForm::OnAddPointLight_Click, this);
wxButton * btnAddDirLight = (wxButton*)wxForm->FindWindowByName(wxString("btnCreateDirLight"));
btnAddDirLight->Bind(wxEVT_LEFT_DOWN, &MainForm::OnAddDirLight_Click, this);
}
int main(int argc, char **argv)
{
/* Initialize KOS */
pvr_init(¶ms);
printf("bullet test beginning\n");
/* Get basic stuff initialized */
glKosInit();
glShadeModel(GL_SMOOTH);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClearDepth(1.0f);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
Logger::log("init..\n");
InitScene();
myTimer.start();
Logger::log("go\n");
mGamepad = new Gamepad();
while(1)
{
mGamepad->Update();
if(mGamepad->Button(GAMEPAD_BTN_START)) break;
/* Begin frame */
glKosBeginFrame();
UpdatePhysics();
if (myTimer.getNumUpdates()%120==0)
{
printf("fps: %.4f\n",myTimer.getNumUpdates()/myTimer.totalSeconds());
printf("fps (immediate): %.4f\n",1.0/myTimer.lastUpdateSeconds());
}
// printf("cam: %f,%f,%f\n",myCamera.position.x,myCamera.position.y,myCamera.position.z);
// printf("target: %f,%f,%f\n",targetObj.controller().position.x,targetObj.controller().position.y,targetObj.controller().position.z);
//printf("obj: %f,%f,%f\n",myRigidSceneObj.controller().position.x,myRigidSceneObj.controller().position.y,myRigidSceneObj.controller().position.z);
/* Draw the "scene" */
draw_gl();
/* Finish the frame */
glKosFinishFrame();
}
return 0;
}
bool InitEverything(SDL_GLContext& g_Context, SDL_Window*& g_Window, std::unique_ptr<Scene>& pScene) {
if (InitSDL())
if (InitGL(g_Context, g_Window))
if (InitSound())
if (InitPython())
if (InitScene(pScene))
return true;
return false;
}
BOOL C3dMazeEffect::Initialize(HDC hDC, BOOL)
{
if(! m_pMaze->InitRandomMaze())
return FALSE;
if(! m_pAI->InitAI(m_pMaze))
return FALSE;
if(!InitScene(hDC))
return FALSE;
return TRUE;
}
int main(int argc, char** argv)
{
glutInit(&argc,argv);
glutInitDisplayMode (GLUT_DOUBLE | GLUT_DEPTH | GLUT_RGB);
glutInitWindowSize(windowSize, windowSize);
glutInitWindowPosition(0,0);
glutCreateWindow("Multisample Corruption (v2)");
glutReshapeFunc(Resize);
glutDisplayFunc(Render);
InitScene();
glutMainLoop();
}
//********************************************************************
//
// Newton Tutorial 2 Using Callbacks
//
//********************************************************************
int main(int argc, char **argv)
{
// initilize opengl
InitOpenGl (argc, argv, "Newton Tutotial 2: Using Callbacks", DrawScene);
// create the physics scene
InitScene();
// Execute opengl main loop for ever
glutMainLoop();
return 0;
}
bool GameScene_17::init()
{
if (!CCLayer::init())
{
return false;
}
visibleSize = CCDirector::sharedDirector()->getVisibleSize();
visibleOrigin = CCDirector::sharedDirector()->getVisibleOrigin();
InitScene();
return true;
}
void __cdecl main()
{
// Initialize Direct3D
if( FAILED( InitD3D() ) )
return;
// Initialize the vertex buffer
if( FAILED( InitScene() ) )
return;
InitTime();
GameService::Initialize(
FALSE, // require online
2, // achievement count
0, // version id
0, // trial version
TRUE // dump log
#if defined(_PS3)
, 5000 // free space available in KB for PS3
#endif
);
for(;;) // loop forever
{
// What time is it?
UpdateTime();
// Update the world
Update();
GameService::Update();
#if defined(TRACKING_TEST)
static int s_send = 0;
static int s_level_id = 0;
if (!s_send) // only send GAME_START tag once
{
s_send = 1;
char tracking_attr[128];
//char ls_reason[10];
sprintf_s(tracking_attr, 128, "VERSION=%d&LICENSETYPE=%d&LANGUAGE=li", 13, 0);
GameService::TrackingSendTag("GAME_START", tracking_attr);
}
#endif
// Render the scene
Render();
}
GameService::Destroy();
}
void CTestScene::runThisScene( )
{
//show some effect
InitScene();
if (!Director::getInstance()->getRunningScene())
{
Director::getInstance()->runWithScene(this);
}
else
{
Director::getInstance()->replaceScene(this);
}
}
void TEngine::LaunchRendering(const TGraphicsSettings& parContext)
{
ASSERT_MSG_NO_RELEASE(!FRenderingRunning, "Rendering already launched, it is just paused.");
TPipeline* pipeline = GenerateGraphicPipeline(m_scene, parContext.width, parContext.lenght, TPipelineConfig::MINIMAL );
FRenderer->CreateRenderWindow(parContext);
FRenderer->SetPipeline(pipeline);
InitScene();
#if __posix__
FThreadData = CREATE_THREAD(FTRenderingThread,CreateRenderingThread,FRenderer);
#elif WIN32
CREATE_THREAD(FTRenderingThread,CreateRenderingThread,FRenderer);
#endif
ENGINE_INFO("Redering thread created");
FRenderingRunning = true;
}
void SceneManager::CreateDevice(HWND hwnd,RECT rect)
{
srand((unsigned)time(NULL));//初始化随机数生成器
// Window initialization
hdc = GetDC(hwnd);
SetBestPixelFormat(hdc);
hglrc = wglCreateContext(hdc);
wglMakeCurrent(hdc, hglrc);
InitScene(hwnd);//初始化场景
soundengine = new SoundEngine(float(150) * 0.01f);
}
void InitFramework (int *argc, char *argv[])
{
glutInit (argc, argv);
glutInitWindowPosition (0, 0);
glutInitWindowSize (200, 200);
glutInitDisplayMode (GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
glutCreateWindow (argv[0]);
glewInit();
printf ("VENDOR: %s\n", glGetString (GL_VENDOR));
printf ("RENDERER: %s\n", glGetString (GL_RENDERER));
InitScene ();
glutDisplayFunc (Display);
glutIdleFunc (Idle);
glutMainLoop ();
}
int UpdateScreen(Screen *screen){
SceneControl(screen);//デバッグ用
if(screen->update_screen == NO_UPDATE_SCENE){
return NOT_UPDATED;
}
if(IsChange(screen) == CHANGE_SCENE){//画面切り替えトリガ
//画面遷移行う場合
//>> screen->next_state = NEXT_SCENE_CODE
if(ChangeState(screen) == INVALID_SCENE_STATUS){
return SWITCH_FALED;
}
InitScene(screen);
TransitionStart(screen);//遷移間フレーム未実装
return SWITCH_SUCCESS;
}
Draw(screen);//描画
return UPDATE_SUCCESS;
}
int CArMaXCtrl::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
if (COleControl::OnCreate(lpCreateStruct) == -1)
return -1;
// Set pixel format
m_hDC = ::GetDC(m_hWnd);
if(SetWindowPixelFormat(m_hDC))
{
m_hRC = wglCreateContext(m_hDC);
if(m_hRC)
wglMakeCurrent (m_hDC, m_hRC);
else
return 0;
}
InitScene();
return 0;
}
//---------------------------------------
bool Mesh::Load( const char* filename )
{
mName = filename;
mScene = mImporter.ReadFile( filename,
aiProcess_Triangulate | aiProcess_GenSmoothNormals | aiProcess_FlipUVs );
if ( mScene )
{
if ( mScene->HasAnimations() )
{
mScene->mRootNode->mTransformation;
}
return InitScene( mScene, filename );
}
DebugPrintf( "Error loading Mesh: '%s': '%s'\n", filename, mImporter.GetErrorString() );
return false;
}
bool EngineSystem::Init()
{
do
{
// 是否显示帧率
bool bShowFPS = false;
VARIABLESYSTEM->GetVariable(VariableSystem::_TYPED_CONFIG_SYSTEM_, "SYS", "ShowFPS", bShowFPS);
bool bResourceEncryptioned = true;
VARIABLESYSTEM->GetVariable(VariableSystem::_TYPED_CONFIG_SYSTEM_, "SYS", "ResourceEncryptioned", bResourceEncryptioned);
// 创建游戏导演类，并进行参数设计
// 初始化全局的字体，字体大小等信息
cocos2d::CCDirector* pDirector = cocos2d::CCDirector::sharedDirector();
pDirector->setResEncryptioned(bResourceEncryptioned);
pDirector->setResEncryptionedKey("com.cyou.mrd.yaojiimage87564");
pDirector->setDefaultFontName("Heiti SC");
pDirector->setDefaultMenuItemFontName("Heiti SC");
pDirector->setDisplayStats(bShowFPS);
pDirector->setAnimationInterval(1.0f/NinjiaTribeApp::get_instance2()->GetFPS());
pDirector->setDefaultFontSize(20);
pDirector->setDefaultMenuItemFontSize(22);
pDirector->setProjection(cocos2d::kCCDirectorProjection2D);
pDirector->registerMenuItemEventCallback(OnEngineMenuItemCallbackEventHandler);
// 初始化场景对象
InitScene();
LoadSysResource();
// 设置所有动画Sprite播放间隔
float interval = 0.3f;
VARIABLESYSTEM->GetVariable(VariableSystem::_TYPED_CONFIG_SYSTEM_, "SYS", "AnimationSpritePlayInterval", interval);
pDirector->setAnimationSpritePlayInterval(interval);
LOGGERSYSTEM->LogInfo("Init EngineSystem Success\n");
return true;
}
while (false);
LOGGERSYSTEM->LogFatal("Init EngineSystem Failed!!!\n");
return false;
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
glutInitWindowSize(800, 600);
glutCreateWindow("LAB 7");
InitScene();
glutDisplayFunc(Display);
glutIdleFunc(Idle);
glutReshapeFunc(Resize);
glutMotionFunc(MouseMotion);
glutMouseFunc(MouseButton);
glutKeyboardFunc(Keyboard);
glutMainLoop();
return 0;
}
int WINAPI WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nShowCmd)
{
// Initialisiere und Registriere das Fenster.
if (!InitializeWindow(hInstance, nShowCmd, Width, Height, true))
{
MessageBox(0, L"Window Initialization - Failed",
L"Error", MB_OK);
return 0;
}
//Initialisiere Direct3D
if (!InitializeDirect3d11App(hInstance))
{
MessageBox(0, L"Direct3D Initialization - Failed",
L"Error", MB_OK);
return 0;
}
//Initialisiere die Szene
if (!InitScene())
{
MessageBox(0, L"Scene Initialization - Failed",
L"Error", MB_OK);
return 0;
}
// im der messageloop() Schleife läuft das eigentliche Programm ab.
messageloop();
//Räume auf
ReleaseObjects();
return 0;
}
bool wd::Application::Initialize(
const HINSTANCE& hInstance,
const int& nCmdShow)
{
// Init config file - get global settings.
InitConfig();
// Create OS window.
if (!InitWindow(hInstance, nCmdShow))
return false;
// Create video device and context.
if (!InitVideoDevice())
return false;
InitInput();
// Show window. By now we should be able to show some sort of loading screen.
m_pWindow->Show();
// Create scene.
InitScene();
return true;
}
int main(int argc, char **argv)
{
if (argc != 2) {
cout << "How to use: HTRViewer htrfile.htr\n";
return 0;
}
string htrfile = argv[1];
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
glutInitWindowPosition(100,100);
glutInitWindowSize(500,500);
string windowName = "HTR Viewer " + htrfile;
glutCreateWindow(windowName.c_str());
// register all callbacks
InitWindow();
InitScene(htrfile.c_str());
glutMainLoop();
return(0);
}
void CALLBACK OnD3D11FrameRender(ID3D11Device* d3dDevice, ID3D11DeviceContext* d3dDeviceContext, double time,
float elapsedTime, void* userContext)
{
D3DXVECTOR3 cubePos;
if (gZeroNextFrameTime) {
elapsedTime = 0.0f;
}
gZeroNextFrameTime = false;
if (gD3DSettingsDlg.IsActive()) {
gD3DSettingsDlg.OnRender(elapsedTime);
return;
}
// Lazily create the application if need be
if (!gApp) {
InitApp(d3dDevice);
}
// Lazily load scene
/*!gMeshOpaque.IsLoaded() && !gMeshAlpha.IsLoaded() &&!gMeshOpaque2.IsLoaded()*/
if (!sceneGraph.IsLoaded()) {
InitScene(d3dDevice);
}
if(PXEngine)
{
for(int i = 0; i < cubeList->size(); i++)
PXEngine->StepPhysX();
if(cubeList)
{
for(int i = 0; i < cubeList->size(); i++)
{
if((*cubeList)[i]->id<0)
{
sceneGraph.SetInstancePosition(1,(*cubeList)[i]->id, (*cubeList)[i]->x, (*cubeList)[i]->y, (*cubeList)[i]->z);
}
else
{
sceneGraph.SetMeshPosition(0,(*cubeList)[i]->id, (*cubeList)[i]->x, (*cubeList)[i]->y, (*cubeList)[i]->z);
}
}
}
}
//crosshair
D3DRECT rec2 = {screenCenterX-20, screenCenterY, screenCenterX + 20, screenCenterY + 2};
D3DRECT rec3 = {screenCenterX, screenCenterY - 20, screenCenterX + 2, screenCenterY + 20};
ID3D11RenderTargetView* pRTV = DXUTGetD3D11RenderTargetView();
D3D11_VIEWPORT viewport;
viewport.Width = static_cast<float>(DXUTGetDXGIBackBufferSurfaceDesc()->Width);
viewport.Height = static_cast<float>(DXUTGetDXGIBackBufferSurfaceDesc()->Height);
viewport.MinDepth = 0.0f;
viewport.MaxDepth = 1.0f;
viewport.TopLeftX = 0.0f;
viewport.TopLeftY = 0.0f;
screenCenterX = viewport.Width / 2;
screenCenterY = viewport.Height / 2;
gViewPort.Width = viewport.Width;
gViewPort.Height = viewport.Height;
gViewPort.MaxZ = viewport.MaxDepth;
gViewPort.MinZ = viewport.MinDepth;
gViewPort.X = viewport.TopLeftX;
gViewPort.Y = viewport.TopLeftY;
gApp->Render(d3dDeviceContext, pRTV, sceneGraph, gSkyboxSRV,
gWorldMatrix, &gViewerCamera, &viewport, &gUIConstants);
sceneGraph.SetMeshPosition(0,1, 100000, 100000, 100000);
if (gDisplayUI) {
d3dDeviceContext->RSSetViewports(1, &viewport);
// Render HUDs in reverse order
d3dDeviceContext->OMSetRenderTargets(1, &pRTV, 0);
for (int i = HUD_NUM - 1; i >= 0; --i) {
gHUD[i].OnRender(elapsedTime);
}
// Render text
gTextHelper->Begin();
gTextHelper->SetInsertionPos(2, 0);
gTextHelper->SetForegroundColor(D3DXCOLOR(1.0f, 1.0f, 0.0f, 1.0f));
gTextHelper->DrawTextLine(DXUTGetFrameStats(DXUTIsVsyncEnabled()));
//gTextHelper->DrawTextLine(DXUTGetDeviceStats());
// Output frame time
{
std::wostringstream oss;
oss << 1000.0f / DXUTGetFPS() << " ms / frame";
gTextHelper->DrawTextLine(oss.str().c_str());
}
// Output light info
{
std::wostringstream oss;
oss << "Lights: " << gApp->GetActiveLights();
gTextHelper->DrawTextLine(oss.str().c_str());
}
gTextHelper->End();
}
}
int App::Run()
{
int r(0);
// somebody must attach a worker
BOOST_ASSERT( m_Worker);
int width(640);
int height(480);
SDL_Surface *screen;
screen = SDL_SetVideoMode(width, height, 32, SDL_OPENGL|SDL_RESIZABLE);
if (screen == NULL)
{
THROW("Unable to set %dx%d video! SDL Error: %s\n", width, height, SDL_GetError());
}
Renderer* renderer = dynamic_cast<Renderer*>(m_Worker.get());
BOOST_ASSERT(renderer);
renderer->Init();
InitScene( renderer, width, height );
// Run our worker thread
boost::thread worker(boost::bind(&Worker::Run, m_Worker));
bool running(true);
SDL_Event event;
do
{
int eventsPending(0);
SDL_WaitEvent(&event);
do
{
bool processed( renderer->HandleEvent( event ) );
for ( auto entity = m_EventHandlerList.begin();
entity != m_EventHandlerList.end() && !processed; )
{
processed |= (*entity)->HandleEvent(event);
if (processed)
{
break;
}
// Remove from event handler as well if marked for deletion
if ( (*entity)->AreFlagsSet( Entity::F_DELETE ) ) {
entity = m_EventHandlerList.erase( entity );
continue;
}
++entity;
}
if (!processed)
{
switch (event.type)
{
case SDL_KEYDOWN:
switch (event.key.keysym.sym)
{
case SDLK_ESCAPE:
running = false;
break;
default:
break;
}
printf("The %s key was pressed!\n",
SDL_GetKeyName(event.key.keysym.sym));
break;
case SDL_QUIT:
running = false;
break;
}
}
if (running)
{
eventsPending = SDL_PollEvent(&event);
}
} while (eventsPending > 0 && running);
} while (running);
// Remove all instances to Entities in the event handler list
m_EventHandlerList.clear();
// terminate worker
m_Worker->Terminate();
worker.join();
return r;
}
LRESULT CGameApp::InitGame()
{
if(S_OK!=InitDInput()) return E_FAIL;
if(S_OK!=InitD3D()) return E_FAIL;
HFONT hOldFont, hNewFont;
// 创建逻辑字体hLeftFont,用于显示加载界面
hNewFont = CreateFont(32, 0, 0, 0, FW_BOLD, 0, 0, 0, ANSI_CHARSET, 0, 0, 0, 0, "Comic Sans MS");;
HDC hwndDC=GetDC(m_hwnd);
hOldFont=(HFONT)SelectObject(hwndDC,hNewFont);
SetTextColor(hwndDC, RGB(255, 255, 0));
RECT rectRange;
GetClientRect(m_hwnd,&rectRange);
HDC dcMem=CreateCompatibleDC(hwndDC);
HBITMAP bmpMem=(HBITMAP)LoadImage(NULL,"logo.bmp",IMAGE_BITMAP,
rectRange.right-rectRange.left ,
rectRange.bottom-rectRange.top,
LR_LOADFROMFILE);
SelectObject(dcMem,bmpMem);
BitBlt(hwndDC,rectRange.left,rectRange.top,rectRange.right,rectRange.bottom,dcMem,0,0,SRCCOPY);
SetBkMode(hwndDC,TRANSPARENT);
int x = (rectRange.left + rectRange.right)/2 - 150;
int y = 5;
TextOut(hwndDC,x,y,"正在加载文件，请稍候...\n",23);
TCHAR szDriver[5];
TCHAR szDir[_MAX_PATH];
::GetModuleFileName(NULL, m_szWorkDir, sizeof(m_szWorkDir)/sizeof(TCHAR));
_tsplitpath(m_szWorkDir, szDriver, szDir, NULL, NULL);
_tcscpy(m_szWorkDir, szDriver);
_tcscat(m_szWorkDir, szDir);
m_Reader.SetWorkDir(m_szWorkDir);
m_Reader.SetMapFile("config\\map.cfg");
m_Reader.SetPosFile("config\\position.cfg");
m_Reader.SetTourFile("config\\tour.cfg");
m_Reader.SetRoadFile("config\\road.cfg");
m_Reader.LoadAll();
if(S_OK!=InitScene()) return E_FAIL;
//释放临时的GDI对象
SelectObject(hwndDC,hOldFont);
DeleteObject(hNewFont);
DeleteObject(bmpMem);
DeleteObject(dcMem);
DeleteObject(hwndDC);
RECT rt;
::GetClientRect(m_hwnd, &rt);
rt.left += 40;
rt.right = rt.left + 140;
rt.top += 10;
rt.bottom = rt.top + 40;
m_pStopWatch = new CStopWatch(m_pD3DDevice, FALSE);
m_pStopWatch->SetPosition(rt);
_tcscpy(szDir, m_szWorkDir);
_tcscat(szDir, m_Reader.m_szStopWatch);
m_pStopWatch->SetTexture(szDir);
m_pStopWatch->Start(game_time);
::SendMessage(m_hwnd, MSG_GAME_NEW, 0, 0);
return D3D_OK;
}
NAMESPACE_BEGIN
Renderer::Renderer(const String& basePath, const String& prefPath,
Input* inputMgr, const String& windowTitle)
: mInputMgr(inputMgr),
mWindow(nullptr),
mLogManager(nullptr),
mLog(nullptr),
mRoot(nullptr),
mSceneManager(nullptr),
mRootNode(nullptr),
mRenderWindow(nullptr),
mViewport(nullptr),
mDefaultCamera(nullptr),
mRaySceneQuery(nullptr),
mRenderSystemPlugin(nullptr),
mParticleUniversePlugin(nullptr),
mRTRoot(nullptr),
mRTRootPosition(Position::origin)
{
// Read config file
Vec2i displayMode = Config::Get<Vec2i>("displaymode", Vec2i(1280, 800));
bool fullscreen = Config::Get<bool>("fullscreen", false);
bool vsync = Config::Get<bool>("vsync", true);
// Set up Ogre's log manager
mLogManager = new Ogre::LogManager();
mLog = mLogManager->createLog(prefPath + "ogre.log", true, false, false);
// Create the Ogre root
mRoot = new Ogre::Root("", "");
LOG << "Created Ogre Root";
LOG << "\tVersion: " << OGRE_VERSION_MAJOR << "." << OGRE_VERSION_MINOR << "."
<< OGRE_VERSION_PATCH << " " << OGRE_VERSION_NAME;
// PLUGIN STAGE
LoadPlugins();
// Set the render system to the first available renderer
if (mRoot->getAvailableRenderers().empty())
{
// TODO: THIS SHOULD NEVER HAPPEN
assert(0);
}
mRoot->setRenderSystem(mRoot->getAvailableRenderers().front());
// WINDOW CREATION STAGE
// Window options
Ogre::NameValuePairList options;
options["vsync"] = vsync ? "true" : "false";
options["gamma"] = "true";
options["title"] = windowTitle;
CreateSDLWindow(windowTitle, displayMode, fullscreen, options);
// Initialise Ogre and use the SDL window
mRoot->initialise(false, "", "");
mRenderWindow = mRoot->createRenderWindow(windowTitle, displayMode.x, displayMode.y, fullscreen, &options);
mRenderWindow->setVisible(true);
// OGRE IS NOW READY, SET UP THE SCENE
InitResources(basePath);
InitScene();
// Set up the raycast query object
mRaySceneQuery = mSceneManager->createRayQuery(Ogre::Ray(), Ogre::SceneManager::WORLD_GEOMETRY_TYPE_MASK);
mRaySceneQuery->setSortByDistance(true);
mRaySceneQuery->setQueryMask(UNIVERSE_OBJECT);
// Set up the deferred shading system
mDeferredShadingMgr = new DeferredShadingManager(mViewport, mSceneManager);
// Set up post processing
mHDRComp = Ogre::CompositorManager::getSingleton().addCompositor(mViewport, "HDR");
mBlurComp = Ogre::CompositorManager::getSingleton().addCompositor(mViewport, "GaussianBlur");
mHDRComp->setEnabled(true);
//mBlurComp->setEnabled(true);
// Set up the sprite manager
mSpriteManager = new SpriteManager(mViewport, mSceneManager);
// Set up the root scene nodes
mRootNode = mSceneManager->getRootSceneNode();
mRTRoot = mRootNode->createChildSceneNode();
// Add event delegates
ADD_LISTENER(Renderer, EvtData_KeyDown);
}
//*************************************************************************************************************
int main(int argc, char* argv[])
{
LARGE_INTEGER qwTicksPerSec = { 0, 0 };
LARGE_INTEGER qwTime;
LONGLONG tickspersec;
double last, current;
double delta, accum = 0;
WNDCLASSEX wc =
{
sizeof(WNDCLASSEX),
CS_CLASSDC,
(WNDPROC)WndProc,
0L,
0L,
GetModuleHandle(NULL),
NULL,
LoadCursor(0, IDC_ARROW),
NULL, NULL, "TestClass", NULL
};
RegisterClassEx(&wc);
SystemParametersInfo(SPI_GETWORKAREA, 0, &workarea, 0);
RECT rect = { 0, 0, screenwidth, screenheight };
DWORD style = WS_CLIPCHILDREN|WS_CLIPSIBLINGS;
memset(&devmode, 0, sizeof(DEVMODE));
devmode.dmSize = sizeof(DEVMODE);
devmode.dmBitsPerPel = 32;
devmode.dmPelsWidth = screenwidth;
devmode.dmPelsHeight = screenheight;
devmode.dmFields = DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;
style |= WS_SYSMENU|WS_BORDER|WS_CAPTION|WS_MINIMIZEBOX;
Adjust(rect, screenwidth, screenheight, style, true);
hwnd = CreateWindowA("TestClass", TITLE, style,
rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top,
NULL, NULL, wc.hInstance, NULL);
if( !hwnd )
{
MYERROR("Could not create window");
goto _end;
}
if( !InitGL(hwnd) )
{
MYERROR("Failed to initialize OpenGL");
goto _end;
}
if( !InitScene() )
{
MYERROR("Failed to initialize scene");
goto _end;
}
ShowWindow(hwnd, SW_SHOWDEFAULT);
UpdateWindow(hwnd);
MSG msg;
ZeroMemory(&msg, sizeof(msg));
POINT p;
GetCursorPos(&p);
ScreenToClient(hwnd, &p);
QueryPerformanceFrequency(&qwTicksPerSec);
tickspersec = qwTicksPerSec.QuadPart;
QueryPerformanceCounter(&qwTime);
last = (double)qwTime.QuadPart / (double)tickspersec;
while( msg.message != WM_QUIT )
{
QueryPerformanceCounter(&qwTime);
current = (double)qwTime.QuadPart / (double)tickspersec;
delta = (current - last);
last = current;
accum += delta;
mousedx = mousedy = 0;
while( accum > 0.1f )
{
accum -= 0.1f;
while( PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE) )
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
Update(0.1f);
}
if( msg.message != WM_QUIT )
Render((float)accum / 0.1f, (float)delta);
}
_end:
UninitGL();
std::cout << "Exiting...\n";
UnregisterClass("TestClass", wc.hInstance);
_CrtDumpMemoryLeaks();
#ifdef _DEBUG
//system("pause");
#endif
return 0;
}
// Initializes OpenGL rendering context. If succeeds, returns true.
// hInstance - application instance
// a_hWnd - window to init OpenGL into
// a_initScene - pointer to init function
// a_renderScene - pointer to render function
// a_releaseScene - optional parameter of release function
bool COpenGLControl::InitOpenGL(HINSTANCE hInstance, HWND* a_hWnd, void (*a_InitScene)(LPVOID), void (*a_RenderScene)(LPVOID), void(*a_ReleaseScene)(LPVOID), LPVOID lpParam)
{
if(!InitGLEW(hInstance))return false;
hWnd = a_hWnd;
hDC = GetDC(*hWnd);
bool bError = false;
PIXELFORMATDESCRIPTOR pfd;
// if we have access to these functions
if(WGLEW_ARB_create_context && WGLEW_ARB_pixel_format)
{
const int iPixelFormatAttribList[] =
{
WGL_DRAW_TO_WINDOW_ARB, GL_TRUE,
WGL_SUPPORT_OPENGL_ARB, GL_TRUE, // Enable OpenGL support
WGL_DOUBLE_BUFFER_ARB, GL_TRUE, // and double buffer
WGL_PIXEL_TYPE_ARB, WGL_TYPE_RGBA_ARB,
WGL_COLOR_BITS_ARB, 32,
WGL_DEPTH_BITS_ARB, 24, // Depth buffer size
WGL_STENCIL_BITS_ARB, 8,
0 // End of attributes list
};
int iContextAttribs[] =
{
WGL_CONTEXT_MAJOR_VERSION_ARB, 3, // OpenGL
WGL_CONTEXT_MINOR_VERSION_ARB, 3, // version 3.3
WGL_CONTEXT_FLAGS_ARB, WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB,
0 // End of attributes list
};
int iPixelFormat, iNumFormats;
wglChoosePixelFormatARB(hDC, iPixelFormatAttribList, NULL, 1, &iPixelFormat, (UINT*)&iNumFormats);
// PFD seems to be only redundant parameter now
if(!SetPixelFormat(hDC, iPixelFormat, &pfd))return false;
hRC = wglCreateContextAttribsARB(hDC, 0, iContextAttribs);
// If everything went OK
if(hRC) wglMakeCurrent(hDC, hRC);
else bError = true;
}
else bError = true;
if(bError)
{
// Generate error messages
char sErrorMessage[255], sErrorTitle[255];
sprintf(sErrorMessage, "OpenGL 3.3 is not supported! Please download latest GPU drivers!");
sprintf(sErrorTitle, "OpenGL 3.3 Not Supported");
MessageBox(*hWnd, sErrorMessage, sErrorTitle, MB_ICONINFORMATION);
return false;
}
RenderScene = a_RenderScene;
InitScene = a_InitScene;
ReleaseScene = a_ReleaseScene;
if(InitScene != NULL)InitScene(lpParam);
return true;
}
int main(int argc, char *argv[])
{
string inputSkeleton;
string inputMotion;
SMRMotion motion;
ParamHandler argh;
argh.AddLong("motion", 'm').SetString().SetDesc("input motion file" , "<file>");
argh.AddLong("skeleton", 's').SetString().SetDesc("input skeleton file" , "<file>");
argh.AddLong("help", 'h').SetBool().SetDesc("Displays quick manual.");
argh.StartParse(argc, argv);
for(;;)
{
int c = argh.GetParam();
if(c == -1)break;
switch(c)
{
case 's': inputSkeleton = argh.GetString(); break;//worst = argh.GetBool(); break;
case 'm': inputMotion = argh.GetString(); break;
default :
printf(
"*** SMR simple viewer demo ***\n"
"\n Usage: motionPlayer [<option> [<...>]] \n"
"\n This demo lets you play bvh or asf/amc animations\n");
argh.ListOptions();
printf("\nNo warranty whatsoever.\n");
return 0;
}
}
if (inputMotion.find(".amc",0) != string::npos )
{
if (inputSkeleton.find(".asf") == string::npos )
{
cout << "You shall specify an asf skeleton file with an amc file" << endl;
return 0;
}else
{
motion = loadMotionFromAcclaim( getFileName(inputSkeleton), getFileName(inputMotion) );
myMotionPlayer = new SMRMotionPlayer( &motion );
}
}else if (inputMotion.find(".bvh",0) != string::npos )
{
motion = loadMotionFromBVH( getFileName(inputMotion) );
myMotionPlayer = new SMRMotionPlayer( &motion );
}else if (inputSkeleton.find(".vsk",0) != string::npos )
{
motion = loadMotionFromVSK( inputSkeleton, inputMotion);
myMotionPlayer = new SMRMotionPlayer( &motion );
//SMRSkeleton mySkeleton = loadSkeletonFromVSK(inputSkeleton);
//SMRQuaternion identity;
//identity.identity();
//for(int i = 0; i< mySkeleton.getNumJoints(); i++)
//{
// mySkeleton.getJoint(i)->setOrientation(identity);
//}
//save the file as bvh
//exportMotionToBVH("shrug.bvh",motion, mySkeleton);
//
//exportPoseToBVH("blah.bvh", mySkeleton);
//mySkeleton.setMode(RELATIVEMODE);
}
else
{
cout << "unknown file format" << endl;
return 0;
}
// get GLUT to work
InitializeGlut(&argc, argv);
// Init the Smr Library
Smr::initSmr();
// Init the shaders capability
InitShaders();
// Get my scene prepared
InitScene();
// Enter the endless loop
glutMainLoop();
// Exit properly
ShutDown();
//delete(motion);
return 0;
}
