HWindow::HWindow(BRect rect, const char* name)
:
BWindow(rect, name, B_TITLED_WINDOW, B_AUTO_UPDATE_SIZE_LIMITS),
fFilePanel(NULL),
fPlayer(NULL)
{
InitGUI();
fFilePanel = new BFilePanel();
fFilePanel->SetTarget(this);
BPath path;
BMessage msg;
if (find_directory(B_USER_SETTINGS_DIRECTORY, &path) == B_OK) {
path.Append(kSettingsFile);
BFile file(path.Path(), B_READ_ONLY);
if (file.InitCheck() == B_OK && msg.Unflatten(&file) == B_OK
&& msg.FindRect("frame", &fFrame) == B_OK) {
MoveTo(fFrame.LeftTop());
ResizeTo(fFrame.Width(), fFrame.Height());
}
}
}
/***********************************************************
* Constructor.
***********************************************************/
HAddTrackerWindow::HAddTrackerWindow(BRect rect,const char* name)
:BWindow(rect,name,B_TITLED_WINDOW_LOOK,B_MODAL_APP_WINDOW_FEEL,B_NOT_RESIZABLE|B_NOT_ZOOMABLE|B_ASYNCHRONOUS_CONTROLS)
{
InitGUI();
BTextControl *control = cast_as(FindView("name"),BTextControl);
control->MakeFocus(true);
}
bool
dlgFontEditShowModal(const TCHAR * FontDescription,
LOGFONT &log_font,
LOGFONT autoLogFont)
{
bool bRetVal = false;
wf = LoadDialog(CallBackTable,
XCSoarInterface::main_window, _T("IDR_XML_FONTEDIT"));
if (wf == NULL)
return false;
NewLogFont = log_font;
resetLogFont = autoLogFont;
InitGUI(FontDescription);
LoadGUI();
if (wf->ShowModal() == mrOK) {
log_font = NewLogFont;
bRetVal = true;
}
delete wf;
return bRetVal;
}
/***********************************************************
* Constructor
***********************************************************/
HAddUrlDlg::HAddUrlDlg(BRect rect, const char* url)
: BWindow(rect, _("Add URLs"), B_DOCUMENT_WINDOW_LOOK, B_MODAL_APP_WINDOW_FEEL, B_NOT_ZOOMABLE) {
InitGUI();
AddShortcut(B_RETURN, 0, new BMessage(M_OK_MESSAGE));
AddShortcut('W', 0, new BMessage(B_QUIT_REQUESTED));
if (url)
fURLView->Insert(url);
fURLView->MakeFocus(true);
}
int main(int argc, const char **argv)
{
VariantMap settings;
settings["appName"] = "Puzzle Moppet";
settings["windowTitle"] = "Puzzle Moppet Configuration";
settings["screenWidth"] = 250;
settings["screenHeight"] = 330;
#ifndef __APPLE__
// Software renderer doesn't seem to work on Mac...
settings["softwareMode"] = true;
#endif
IEngine *engine = CreateEngine(argc, argv, &settings);
IrrlichtDevice *device = engine->GetIrrlichtDevice();
// Filesystem...
// Irrlicht needs this so it can load textures from same dir as font xml.
engine->GetIrrlichtDevice()->getFileSystem()->addFileArchive("../projects/ConfigApp/");
// Show the cursor
device->getCursorControl()->setVisible(true);
// Pause World, not needed for GUI app.
// (pausing World also disables mouse centring)
engine->GetWorld()->Pause();
// Load GUI
gui::IGUIEnvironment *guienv = device->getGUIEnvironment();
ASSERT( guienv->loadGUI("gui.xml") );
// Get pointers to important elements within the loaded GUI.
// Ideally in the future we'll have a layout manager and won't need the GUI
// defined in xml.
FindGUIElementPointers();
// Default font
guienv->getSkin()->setFont( guienv->getFont("lucida.xml") );
// Change background colour...
engine->GetRenderSystem()->SetBackgroundCol(video::SColor(0, 200,200,200));
// Receive GUI events.
// This prevents Litha Engine from receiving GUI events, but that doesn't matter.
IEventReceiver *eventReceiver = new EventReceiver(engine);
guienv->setUserEventReceiver(eventReceiver);
// Init
InitSettings();
InitGUI();
engine->Run();
engine->drop();
delete eventReceiver;
return 0;
}
Core::Core()
{
std::cout<<"Core: begin initialising\n";
_core = this;
InitHardware();
InitGUI();
std::cout<<"Core: core initialized\n";
}
int main()
{
InitGUI();
InitLOGO();
while(1)
{
system("CLS");
DispatchMessage();
}
return 0;
}
BOOL CNewFilterGroupDlg::OnInitDialog()
{
CDialog::OnInitDialog();
SetWindowText(m_szTitle);
InitGUI();
m_pLangRuleDlg->AddMsgReceiver(m_hWnd);
InitComboBox();
InitData();
return TRUE;
}
void main(void)
{
InitHeapPool(INIT_HEAP_DEFAULT);
InitGUI();
AppCalcDlg();
//Test2();
//Test3();
//Test4();
//Test5();
//Test7();
TestBtn();
//TestString();
}
//--------------------------------------------------------------------------------------
// Initialize everything and go into a render loop
//--------------------------------------------------------------------------------------
int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int nCmdShow)
{
HRESULT hr;
V_RETURN(DXUTSetMediaSearchPath(MEDIA_PATH));
// Enable run-time memory check for debug builds.
#if defined(DEBUG)
_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
#endif
// Set general DXUT callbacks
DXUTSetCallbackFrameMove(OnFrameMove);
DXUTSetCallbackKeyboard(OnKeyboard);
DXUTSetCallbackMouse(OnMouse);
DXUTSetCallbackMsgProc(MsgProc);
DXUTSetCallbackDeviceChanging(ModifyDeviceSettings);
DXUTSetCallbackDeviceRemoved(OnDeviceRemoved);
// Set the D3D11 DXUT callbacks
DXUTSetCallbackD3D11DeviceAcceptable (IsD3D11DeviceAcceptable);
DXUTSetCallbackD3D11DeviceCreated (OnD3D11CreateDevice);
DXUTSetCallbackD3D11SwapChainResized (OnD3D11ResizedSwapChain);
DXUTSetCallbackD3D11FrameRender (OnD3D11FrameRender);
DXUTSetCallbackD3D11SwapChainReleasing(OnD3D11ReleasingSwapChain);
DXUTSetCallbackD3D11DeviceDestroyed (OnD3D11DestroyDevice);
// Perform any application-level initialization here
InitAOParams(g_AOParams);
InitGUI();
UINT Width = 1920;
UINT Height = 1200;
DXUTInit(true, true, NULL); // Parse the command line, show msgboxes on error, no extra command line params
DXUTSetCursorSettings(true, true); // Show the cursor and clip it when in full screen
DXUTSetIsInGammaCorrectMode(false); // Do not use a SRGB back buffer for this sample
DXUTCreateWindow(L"Deinterleaved Texturing");
DXUTCreateDevice(D3D_FEATURE_LEVEL_11_0, true, Width, Height);
//DXUTToggleFullScreen();
DXUTMainLoop(); // Enter into the DXUT render loop
// Perform any application-level cleanup here
return DXUTGetExitCode();
}
bool dlgFontEditShowModal(const TCHAR * FontDescription,
const TCHAR * FontRegKey,
LOGFONT autoLogFont){
bool bRetVal=false;
char filename[MAX_PATH];
IsInitialized=false;
LocalPathS(filename, TEXT("dlgFontEdit.xml"));
wf = dlgLoadFromXML(CallBackTable,
filename,
hWndMainWindow,
TEXT("IDR_XML_FONTEDIT"));
int UseCustomFontsold = UseCustomFonts;
UseCustomFonts=1;// global var
InitializeOneFont (&NewFont,
FontRegKey,
autoLogFont,
&OriginalLogFont);
UseCustomFonts=UseCustomFontsold;
OriginalFontRegKey=FontRegKey;
NewLogFont=OriginalLogFont;
resetLogFont = autoLogFont;
if (wf) {
InitGUI(FontDescription);
LoadGUI();
if (wf->ShowModal()==mrOK) {
SaveValues(FontRegKey);
bRetVal=true;
}
delete wf;
}
wf = NULL;
return bRetVal;
}
// Initialisierung des Rendering Kontextes
void SetupRC() {
// Schwarzer Hintergrund
glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
// In Uhrzeigerrichtung zeigende Polygone sind die Vorderseiten.
// Dies ist umgekehrt als bei der Default-Einstellung weil wir Triangle_Fans benützen
glFrontFace(GL_CW);
//initialisiert die standard shader
shaderManager.InitializeStockShaders();
transformPipeline.SetMatrixStacks(modelViewMatrix, projectionMatrix);
//erzeuge die geometrie
CreateCone(0, 0, 0);
CreateCube(0, 0, 0);
CreateCylinder(0, 0, 0);
CreateSphere(0, 0, 0);
InitGUI();
}
C_Game::C_Game(sf::RenderWindow* sc)
: C_Mod(sc)
{
sf::Clock loadTimer;
glewInit();
InitFog();
InitTexture();
_cam->setPosition(Vector3D(CHUNK_SIZE/2, CHUNK_SIZE/2, CHUNK_ZVALUE/2 +1.6f));
_cam->setSpeed(0.0006);
_screen->ShowMouseCursor(false);
glEnable(GL_TEXTURE_2D);
InitCubes();
_boolJumping = false;
_frameJumping = 0;
InitGUI();
SetItemInHotkeys(CUBE_DIRT, 0);
SetItemInHotkeys(CUBE_SAND, 1);
SetItemInHotkeys(CUBE_SAND+1, 2);
SetItemInHotkeys(CUBE_SAND+2, 3);
SetItemInHotkeys(CUBE_SAND+3, 4);
SetItemInHotkeys(CUBE_SAND+4, 5);
SetItemInHotkeys(CUBE_SAND+5, 6);
SetItemInHotkeys(CUBE_SAND+6, 7);
SetItemInHotkeys(CUBE_SAND+7, 8);
_actuelCubeInHand = _itemInHotkeys[0];
C_Log::GetSingleton()->AddMessage( std::string("Scene loaded in " + FloatToString(loadTimer.GetElapsedTime()) + "sec.") );
/*C_LineEdit *widg = new C_LineEdit();
widg->move(10, sc->GetHeight()-40);
widg->resize(350, 30);
AddWidget(widg);*/
Launch();
}
INT WINAPI WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, INT nCmdShow )
{
FILE *f=fopen("bass.dll","rb");
if (f)
{
fclose(f);
DebugStart=false;
int MemUsage=0;
if ((GetSystemMetrics(SM_CXSCREEN)>=1024 && GetSystemMetrics(SM_CYSCREEN)>=768) || strstr(GetCommandLine(),"-fullscreen") && !strstr(GetCommandLine(),"-windowed"))
{
#ifndef Public_Release
LastClickedToolTip="ADVANCED DIGITAL DYNAMITE INTRO CREATION TOOL V1.97";
#else
LastClickedToolTip="ADVANCED DIGITAL DYNAMITE INTRO CREATION TOOL V1.97 PUBLIC RELEASE";
#endif
SetupEnvironment();
if (strstr(GetCommandLine(),"-fullscreen") || (GetSystemMetrics(SM_CXSCREEN)==1024 && GetSystemMetrics(SM_CYSCREEN==768)) && !strstr(GetCommandLine(),"-windowed")) fullscreen=true;
#ifndef Public_Release
Intro_CreateWindow("a.D.D.i.c.t. V1.97 (Build Date: " __DATE__ " " __TIME__ ")\0", 1024, 768, 32, fullscreen, LoadIcon(hInstance, MAKEINTRESOURCE(101)));
#else
Intro_CreateWindow("a.D.D.i.c.t. V1.97 Public Release (Build Date: " __DATE__ " " __TIME__ ")\0", 1024, 768, 32, fullscreen, LoadIcon(hInstance, MAKEINTRESOURCE(101)));
#endif
InitRadiosityStuff();
WGLSWAPINTERVALEXT wglSwapIntervalEXT = (WGLSWAPINTERVALEXT) wglGetProcAddress("wglSwapIntervalEXT");
if (wglSwapIntervalEXT && fullscreen) wglSwapIntervalEXT(1); // enable vertical synchronisation
//InitDemoSave();
InitGUI();
initVertexBlend();
MainLoop();
//DeinitDemoSave();
ReleaseDC(hWnd,hDC);
if (fullscreen) ChangeDisplaySettings(NULL,0);
return 0;
}
else
MessageBox( 0, "Sorry a.D.D.i.c.t. 2 requires at least a screen resolution of 1024x768 pixels.", "Error!", MB_OK );
}
else MessageBox( 0, "bass.dll not found", "Error!", MB_OK );
return 0;
}
int main (int args, const char* agr[])
#endif
{
int iRet = 0;
if (!InitGUI ()) {
#ifdef _INCORE_RES
fprintf (stderr, "InitGUI failure when using incore resource.\n");
#else
fprintf (stderr, "InitGUI failure when using %s as cfg file.\n",
ETCFILEPATH);
#endif /* _INCORE_RES */
return 1;
}
iRet = MiniGUIMain (args, agr);
TerminateGUI (iRet);
return iRet;
}
bool OGLIndexedDraw::Init(int windowWidth, int windowHeight)
{
bool res = gs::Stage::Init(windowWidth, windowHeight);
if (res) {
res &= InitGUI();
/******************************* Shaders ********************************/
auto vertexShader = std::make_unique<gs::Shader>(GL_VERTEX_SHADER);
auto fragmentShader = std::make_unique<gs::Shader>(GL_FRAGMENT_SHADER);
auto program = std::make_shared<gs::Program>();
vertexShader->SetSource("heightmap.vert");
res &= vertexShader->Compile();
fragmentShader->SetSource("heightmap.frag");
res &= fragmentShader->Compile();
program->Attach(vertexShader->get());
program->Attach(fragmentShader->get());
res &= program->Link();
program->Use();
programs.push_back(program);
glm::mat4 MVP = projection * glm::lookAt(glm::vec3(0, 40, -30), glm::vec3(0), glm::vec3(0, 1, 0));
GLint mvpLocation = glGetUniformLocation(program->get(), "MVP");
glUniformMatrix4fv(mvpLocation, 1, GL_FALSE, glm::value_ptr(MVP));
hDivLocation = glGetUniformLocation(program->get(), "heightDivider");
/******************************* Geometry ********************************/
auto vao = std::make_unique<gs::VertexArray>();
vao->BindVAO();
vaos.push_back(std::move(vao));
auto vbo = std::make_unique<gs::VertexBuffer>(GL_ARRAY_BUFFER);
vbo->BindVBO();
vbos.push_back(std::move(vbo));
heights = { 4.0f, 2.0f, 3.0f, 1.0f,
3.0f, 5.0f, 8.0f, 2.0f,
7.0f, 10.0f, 12.0f, 6.0f,
4.0f, 6.0f, 8.0f, 3.0f };
const float halfX = WORLD_SIZE_X * 0.5f;
const float halfZ = WORLD_SIZE_Z * 0.5f;
for (size_t i = 0; i < HM_SIZE_Z; i++) {
for (size_t j = 0; j < HM_SIZE_X; j++)
{
short currentLineOffset = (short)j * HM_SIZE_Z;
float xPos = j / (float)(HM_SIZE_X - 1) * WORLD_SIZE_X - halfX;
float yPos = heights[i + currentLineOffset];
float zPos = i / (float)(HM_SIZE_Z - 1) * WORLD_SIZE_Z - halfZ;
vertices[i + currentLineOffset] = glm::vec3(xPos, yPos, zPos);
}
}
glBufferData(GL_ARRAY_BUFFER, sizeof(glm::vec3) * vertices.size(), vertices.data(), GL_STATIC_DRAW);
/******************************* Indices ********************************/
auto ibo = std::make_unique<gs::VertexBuffer>(GL_ELEMENT_ARRAY_BUFFER);
ibo->BindVBO();
vbos.push_back(std::move(ibo));
const GLushort restartIndex = HM_SIZE_X * HM_SIZE_Z;
indices = { 0, 4, 1, 5, 2, 6, 3, 7, restartIndex,
4, 8, 5, 9, 6, 10, 7, 11, restartIndex,
8, 12, 9, 13, 10, 14, 11, 15};
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLushort) * indices.size(), indices.data(), GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
glEnable(GL_PRIMITIVE_RESTART);
glEnable(GL_DEPTH_TEST);
glPrimitiveRestartIndex(restartIndex);
}
return res;
}
void EditorFrameHandler::Init()
{
Ogre::SceneManager *scene_manager = CommonDeclarations::GetSceneManager();
EditorCamera = scene_manager->createCamera("EditorCamera");
EditorCamera->setNearClipDistance(5);
EditorCamera->setFarClipDistance(0);
EditorCamera->setPosition(CommonDeclarations::GetCamera()->GetOgreCamera()->getWorldPosition());
CommonDeclarations::GetApplication()->SetCurrentCamera(EditorCamera);
/*CommonDeclarations::ObjectsPool *objects = CommonDeclarations::GetEditableObjects();
for (CommonDeclarations::ObjectsPool::ListNode *pos = objects->GetBegin();pos!=NULL;pos=pos->Next)
{
SEditableObject obj;
obj.Object = pos->Value;
IScenable *scen = pos->Value->GetScenable();
if (scen)
{
obj.EditNode = NULL;
obj.EditEntity = NULL;
ICollidable *collid = pos->Value->GetCollidable();
if (collid)
{
obj.CollisionModel = collid->GetCollisionModel();
} else
{
const char *modelname = scen->GetModelName();
if (NULL == modelname)
modelname = AAUtilities::StringCopy("cube.mesh");
obj.CollisionModel = GetCollisionModel(modelname);
}
} else
{
obj.EditNode = scene_manager->getRootSceneNode()->createChildSceneNode();
char *buffer = CommonDeclarations::GenGUID();
obj.EditEntity = scene_manager->createEntity(buffer, "cube.mesh");
delete [] buffer;
obj.EditNode->attachObject(obj.EditEntity);
obj.CollisionModel = GetCollisionModel("cube.mesh");
}
EditableObjects.PushBack(obj);
}
delete objects;*/
//
CommonDeclarations::ObjectsPool *objects = CommonDeclarations::GetEditableObjects();
const char *str;
TiXmlElement *node = 0, *nodes, *env;
env = SceneRootElement->FirstChildElement("environment");
if (env)
{
node = env->FirstChildElement("skyBox");
if (node)
{
SEditableDescription descr;
descr.EditNode = NULL;
descr.EditElement = node;
EditorNodes.insert(std::make_pair("SkyBox", descr));
}
}
nodes = SceneRootElement->FirstChildElement("nodes");
if (nodes)
{
node = nodes->FirstChildElement("node");
Ogre::Node::ChildNodeIterator iFirst = scene_manager->getRootSceneNode()->getChildIterator(), iPos = iFirst;
while (node)
{
str = node->Attribute("name");
SEditableDescription descr;
Ogre::Node *t = NULL;
iPos = iFirst;
while (iPos.hasMoreElements())
{
t = iPos.getNext();
if (t->getName()==str)
{
descr.EditNode = t;
break;
}
}
descr.EditElement = node;
EditorNodes.insert(std::make_pair(str, descr));
node = node->NextSiblingElement("node");
}
}
delete objects;
//
MyGUI::Gui *gui = GUISystem::GetInstance()->GetGui();
OIS::Mouse *mouse = EditorFrameListener::GetInstance()->GetMouse();
InitGUI();
const OIS::MouseState &ms = mouse->getMouseState();
int x=ms.width/2,
y=ms.height/2;
mouse->setMousePosition(x,y);
gui->setPointerPosition(x, y);
gui->showPointer();
}
/***********************************************************
* Constructor
***********************************************************/
HCriteriaView::HCriteriaView(BRect rect,const char* name)
:BView(rect,name,B_FOLLOW_ALL,B_WILL_DRAW)
{
SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
InitGUI();
}
bool OGLFrustumCulling::Init(int windowWidth, int windowHeight)
{
bool res = gs::Stage::Init(windowWidth, windowHeight);
if (res) {
res &= InitGUI();
auto program = std::make_shared<gs::Program>();
program->CreateShader(GL_VERTEX_SHADER, "sinDisplacement.vert");
program->CreateShader(GL_GEOMETRY_SHADER, "frustumCulling.geom");
program->CreateShader(GL_FRAGMENT_SHADER, "roundedPoints.frag");
res &= program->Link();
program->Use();
programs.push_back(program);
program->AddUniform("MVP");
program->AddUniform("time");
program->AddUniform("frustumPlanes");
program->AddUniform("amplitude");
auto programFrustum = std::make_shared<gs::Program>();
programFrustum->CreateShader(GL_VERTEX_SHADER, "oglLight.vert");
programFrustum->CreateShader(GL_FRAGMENT_SHADER, "firstPoint.frag");
res &= programFrustum->Link();
programFrustum->Use();
programs.push_back(programFrustum);
programFrustum->AddUniform("MVP");
auto vao = std::make_unique<gs::VertexArray>();
vao->BindVAO();
auto vbo = std::make_unique<gs::VertexBuffer>(GL_ARRAY_BUFFER);
std::vector<glm::vec3> positions;
for (size_t z = 0; z <= NUM_VERTICESZ; z++) {
for (size_t x = 0; x <= NUM_VERTICESX; x++) {
auto xCoord = ((((float)x / ((NUM_VERTICESX - 1)) * 2) - 1)) * HALF_SIZEX;
auto zCoord = ((((float)z / ((NUM_VERTICESZ - 1)) * 2) - 1)) * HALF_SIZEZ;
positions.push_back(glm::vec3(xCoord, 0.0f, zCoord));
}
}
vbo->BindVBO();
glBufferData(vbo->GetTarget(), sizeof(glm::vec3) * positions.size(), positions.data(), GL_STATIC_DRAW);
vbos.push_back(std::move(vbo));
vao->AddAttribute(0, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
vaos.push_back(std::move(vao));
totalVertices = (int)positions.size();
ground.SetSize(1000);
ground.SetProgram(programs[1]);
ground.Load("");
camera.SetSpeed(10);
camera.SetPosition(glm::vec3(0,0,20));
camera.SetupProjection(45.0f, windowWidth/(float)windowHeight, 0.01f);
cameraExternal.SetSpeed(0);
cameraExternal.SetPosition(glm::vec3(0,20,30));
cameraExternal.SetTarget(camera.GetPosition());
cameraExternal.SetupProjection(45.0f, windowWidth/(float)windowHeight);
cameraExternal.Update();
glPointSize(30.0f);
//glCullFace(GL_FRONT_FACE);
}
return res;
}
bool OGLSimpleLighting::Init(int windowWidth, int windowHeight)
{
bool res = gs::Stage::Init(windowWidth, windowHeight);
if (res) {
res &= InitGUI();
// Program textured objects setup
auto vertexShader = std::make_unique<gs::Shader>(GL_VERTEX_SHADER);
auto programTex = std::make_shared<gs::Program>();
vertexShader->SetSource("simpleLighting.vert");
res &= vertexShader->Compile();
programTex->Attach(vertexShader->get());
auto fragmentShader = std::make_unique<gs::Shader>(GL_FRAGMENT_SHADER);
fragmentShader->SetSource("simpleLighting.frag");
res &= fragmentShader->Compile();
programTex->Attach(fragmentShader->get());
res &= programTex->Link();
programTex->Use();
programs.push_back(programTex);
mvpLocation = glGetUniformLocation(programTex->get(), "MVP");
normalMatrixLocation = glGetUniformLocation(programTex->get(), "NormalMatrix");
light.direction = glm::vec3(-1.0f, 0.0f, 0.0f);
light.ambientColor = glm::vec3(0.2f);
light.diffuseColor = glm::vec3(1.0f);
light.specularColor = light.diffuseColor;
lightDirLoc = glGetUniformLocation(programTex->get(), "light.direction");
diffuseLoc = glGetUniformLocation(programTex->get(), "light.diffuseColor");
ambientLoc = glGetUniformLocation(programTex->get(), "light.ambientColor");
//Texture setup
auto textureFloor = std::make_unique<gs::Texture>(IMAGE_TYPE::GLI);
res &= textureFloor->LoadTexture("Floor.dds");
textureFloor->ChangeParameter(GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR);
textureFloor->ChangeParameter(GL_TEXTURE_MAG_FILTER, GL_LINEAR);
textures.push_back(std::move(textureFloor));
auto textureCamouflage = std::make_unique<gs::Texture>(IMAGE_TYPE::GLI);
res &= textureCamouflage->LoadTexture("Hieroglyphes.dds");
textures.push_back(std::move(textureCamouflage));
// Geometry setup
auto vao = std::make_unique<gs::VertexArray>();
vao->BindVAO();
vaos.push_back(std::move(vao));
auto vbo = std::make_unique<gs::VertexBuffer>(GL_ARRAY_BUFFER);
vbo->BindVBO();
std::vector<gs::Vertex> vertices;
OGLCube cube;
cube.InitVertices(glm::vec3(0));
vertices.insert(vertices.end(), cube.GetVertices().begin(), cube.GetVertices().end());
OGLQuad quad;
quad.SetSize(1000);
quad.InitVertices(glm::vec3(0));
vertices.insert(vertices.end(), quad.GetVertices().begin(), quad.GetVertices().end());
glBufferData(GL_ARRAY_BUFFER, sizeof(gs::Vertex) * vertices.size(), vertices.data(), GL_STATIC_DRAW);
vbos.push_back(std::move(vbo));
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(gs::Vertex), (void*)offsetof(gs::Vertex, position));
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(gs::Vertex), (void*)offsetof(gs::Vertex, texCoords));
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, sizeof(gs::Vertex), (void*)offsetof(gs::Vertex, normal));
// Camera setup
camera.SetPosition(glm::vec3(0.0f, 0.0f, 3.0f));
camera.SetSpeed(8.0f);
camera.SetupProjection(45.0f, windowWidth/(float)windowHeight);
lightObj.Load("");
// OpenGL setup
glEnable(GL_DEPTH_TEST);
}
return res;
}
void TestBtn(void)
{
PWindow pWinSon0 = NULL;
PButton pBtnSon0 = NULL;
PEditView pEditSon0 = NULL;
PCheckBox pBkBoxSon0 = NULL;
PWindow pWinParent = NULL;
int iRnd;
int i;
int iParent;
CRect rect;
CFont font;
CBrush brush;
INT iID;
iID = 1;
InitHeapPool(INIT_HEAP_DEFAULT);
InitGUI();
Log("start...\n");
pWinParent = CreateWindowE(0, pWinRoot, iID++);
rect.m_iLeft = 10;
rect.m_iTop = 10;
rect.m_iHeigh = 200;
rect.m_iWidth = 300;
pWinParent->m_pfSelWinRect(P2H(pWinParent), &rect, NULL);
SetWinBKColor(pWinParent, 0xFF000000);
pBtnSon0 = CreateButton(pWinParent, iID++, "btn1", 0, WIN_MSG_BUTTON, WinOnUsrProc);
rect.m_iLeft = 80;
rect.m_iTop = 10;
rect.m_iHeigh = 50;
rect.m_iWidth = 50;
pBtnSon0->m_pfSelWinRect(P2H(pBtnSon0), &rect, NULL);
SetWinBKColor(&pBtnSon0->m_baseWin, 0xFF00FF00);
font.m_color = 0xFF000000;
pBtnSon0->m_pfSelWinFont(P2H(pBtnSon0), &font, NULL);
pWinSon0 = CreateWindowE(0, pWinParent, iID++);
rect.m_iLeft = 50;
rect.m_iTop = 10;
rect.m_iHeigh = 50;
rect.m_iWidth = 50;
pWinSon0->m_pfSelWinRect(P2H(pWinSon0), &rect, NULL);
SetWinBKColor(pWinSon0, 0xFFFF0000);
pEditSon0 = CreateEditView(pWinParent, iID++, "you are pig stupid, fool is your nick name kill youyou are pig stupid, fool is your nick name kill you", 0/*EDIT_VIEW_MULTI_LINE*/);
rect.m_iLeft = 30;
rect.m_iTop = 90;
rect.m_iHeigh = 50;
rect.m_iWidth = 100;
pEditSon0->m_pfSelWinRect(P2H(pEditSon0), &rect, NULL);
pEditSon0->m_pfSelWinFont(P2H(pEditSon0), &font, NULL);
brush.m_color = 0xFFFFFFFF;
pEditSon0->m_pfSelWinBrush(P2H(pEditSon0), &brush, NULL);
pEditSon0->m_iCurEdit = 10;
pBkBoxSon0 = CreateCheckBox(pWinParent, iID++, "CheckMe", TRUE, 0);
rect.m_iLeft = 146;
rect.m_iTop = 80;
rect.m_iHeigh = 24;
rect.m_iWidth = 100;
pBkBoxSon0->m_pfSelWinRect(P2H(pBkBoxSon0), &rect, NULL);
pBkBoxSon0->m_pfSelWinFont(P2H(pBkBoxSon0), &font, NULL);
brush.m_color = 0xFFFF00FF;
pBkBoxSon0->m_pfSelWinBrush(P2H(pBkBoxSon0), &brush, NULL);
Log("window flow...\n");
FlowWindow0(pWinRoot, WindowFlow);
//pWinTmp = FindWindowByID(25);
//Log("find...");
//WindowFlow(pWinTmp);
PrintScreen();
#if 0
pWinTmp = FindWindowByID(2);
if(pWinTmp == NULL)
{
Log("NULL pointer\r\n");
}
Log("OK\r\n");
ReorderWindow(pWinTmp);
FlowWindow0(pWinRoot, WindowFlow);
#endif
while(TRUE)
{
int x;
int y;
int iRet;
PPoint pPoint;
scanf("%d %d", &x, &y);
pPoint = (PPoint)Malloc(sizeof(CPoint));
pPoint->m_iX = x;
pPoint->m_iY = y;
iRet = pWinRoot->m_pfPostMessage(P2H(pWinRoot), WIN_MSG_ID_CLICK_SCREEN_DOWN, 0, pPoint);
Log("iRet[%d]\r\n", iRet);
WinFlowMain();
FlowWindow0(pWinRoot, WindowFlow);
PrintScreen();
}
DeleteEditView(pEditSon0);
DeleteButton(pBtnSon0);
}
void BaseApp::Init()
{
m_wireframe = false;
lockMouse = true;
m_freezeFrustum = false;
blurOffset = 0.01;
LoadOpenGLExt();
//importer3DS.Import3DS(&model, "data\\models\\3ds__tree2.3ds");
m_pFont = new Font("data\\textures\\fonts\\tahoma_10.tga");
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
m_pFont->Enable(m_width, m_height);
m_pFont->SetAlignment(FONT_HORIZ_ALIGN_LEFT, FONT_VERT_ALIGN_TOP);
m_pFont->Print(10, 10, "Loading...");
m_pFont->Disable();
SwapBuffers(m_hDC);
ShowCursor(false);
InitGUI();
InitSkyDome();
Vec2 *lixo, *lixo3;
Vec3 *lixo2;
g_heightMap = new HeightMap();
g_heightMap->SetWidthRatio(15.0f);
g_heightMap->SetHeightRatio(5.0f);
g_heightMap->SetYOffset(-150.0f);
g_heightMap->LoadFromFile("data\\heightmap.png");
int numVerts = 0;
numVerts = g_heightMap->BuildArray(&lixo2, &lixo, &lixo3);
g_quadtree = new Quadtree();
g_quadtree->Build(g_heightMap, g_heightMap->vertices, lixo, numVerts);
m_shdWater = new Shader("data\\shaders\\water");
m_shdWaterSpecular = new Shader("data\\shaders\\water_specular");
m_shdBlur = new Shader("data\\shaders\\blur");
m_shdHDR = new Shader("data\\shaders\\hdr");
m_shdSky = new Shader("data\\shaders\\sky");
m_shdUnderwater = new Shader("data\\shaders\\underwater");
m_shdSimpleColor = new Shader("data\\shaders\\simple_color");
m_sunPos.Set(0.0f, 1.0f, 0.0f);
m_sunPos.x = cosf(0.35f);
m_sunPos.y = 1.0 - sinf(0.35f);
m_camera.PositionCamera( -527.03f, 13.39f, -606.4f,
-526.3f, 13.4f, -605.75f,
0.0f, 1.0f, 0.0f );
glViewport(0, 0, m_width, m_height);
glClearColor(0.5f, 0.8f, 1.0f, 1.0f);
glEnable(GL_CULL_FACE);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
glMatrixMode(GL_PROJECTION);
projMat.BuildProjection(50.0f, (float)m_width / (float)m_height, 0.1f, 50000.0f);
glLoadMatrixf(projMat);
glMatrixMode(GL_MODELVIEW);
glGenRenderbuffersEXT(1, &g_renderBuffer[0]);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, g_renderBuffer[0]);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, m_width, m_height);
glGenRenderbuffersEXT(1, &g_renderBuffer[1]);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, g_renderBuffer[1]);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, m_width, m_height);
glGenFramebuffersEXT(1, &g_frameBuffer);
glGenRenderbuffersEXT(1, &g_depthRenderBuffer);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, g_depthRenderBuffer);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, m_width, m_height);
//glGenFramebuffersEXT(1, &g_frameBuffer2);//
glGenRenderbuffersEXT(1, &g_depthRenderBuffer2);//
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, g_depthRenderBuffer2);//
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, 512, 512);//
//glGenFramebuffersEXT(1, &g_frameBufferHDR);//
glGenRenderbuffersEXT(1, &g_depthRenderBufferHDR);//
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, g_depthRenderBufferHDR);//
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, m_width / 1, m_height / 1);//
glGenRenderbuffersEXT(1, &g_renderBufferBlurdHDR);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, g_renderBufferBlurdHDR);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, m_width / 4, m_height / 4);
GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
switch(status)
{
case GL_FRAMEBUFFER_COMPLETE_EXT:
//MessageBox(NULL,"GL_FRAMEBUFFER_COMPLETE_EXT!","SUCCESS",MB_OK|MB_ICONEXCLAMATION);
break;
case GL_FRAMEBUFFER_UNSUPPORTED_EXT:
MessageBox(NULL,"GL_FRAMEBUFFER_UNSUPPORTED_EXT!","ERROR",MB_OK|MB_ICONEXCLAMATION);
exit(0);
break;
default:
exit(0);
}
g_texFP16.CreateRenderTarget(m_width, m_height, 3, GL_RGB16F_ARB, true);
g_texFP162.CreateRenderTarget(m_width, m_height, 3, GL_RGB16F_ARB, true);
g_texHDR.CreateRenderTarget(m_width / 1, m_height / 1, 3, GL_RGB16F_ARB, true);
g_texHBluredHDR.CreateRenderTarget(m_width / 4, m_height / 4, 3, GL_RGB16F_ARB, true);
g_texVBluredHDR.CreateRenderTarget(m_width / 4, m_height / 4, 3, GL_RGB16F_ARB, true);
g_texWaterReflect.CreateRenderTarget(512, 512, 3, GL_RGB16F_ARB, true);
Image image;
image.Load("data\\textures\\water_nmap.png");
image.ToNormalMap(2);
water.Load2D(image, GL_REPEAT, GL_REPEAT, GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
image.Load("data\\textures\\teste.bmp");
m_skyGradient.Load1D(image, GL_CLAMP, GL_LINEAR, GL_LINEAR);
image.Load("data\\textures\\sun.png");
m_texSun.Load2D(image, GL_REPEAT, GL_REPEAT, GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
CubeMapFilePath cubeMapFilePath;
strcpy(cubeMapFilePath.posX, "data\\textures\\underwater_nmap.png");
strcpy(cubeMapFilePath.negX, "data\\textures\\underwater_nmap.png");
strcpy(cubeMapFilePath.posY, "data\\textures\\underwater_nmap.png");
strcpy(cubeMapFilePath.negY, "data\\textures\\underwater_nmap.png");
strcpy(cubeMapFilePath.posZ, "data\\textures\\underwater_nmap.png");
strcpy(cubeMapFilePath.negZ, "data\\textures\\underwater_nmap.png");
m_texCubeUnderwaterNormMap.LoadCubeMap(cubeMapFilePath, GL_REPEAT, GL_REPEAT, GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR_MIPMAP_LINEAR, 0);
m_texViewPort.CreateRenderTarget(m_width, m_height, 3, GL_RGB, true);
m_mouseLockedX = m_width * 0.5;
m_mouseLockedY = m_height * 0.5;
CenterMouse();
}
bool OGLSpotLight::Init(int windowWidth, int windowHeight)
{
bool res = gs::Stage::Init(windowWidth, windowHeight);
if (!res) {
return false;
}
cubePositions.resize(10);
res &= InitGUI();
// Init Camera
camera.SetPosition(glm::vec3(0, 0, 50));
camera.SetSpeed(15.0f);
camera.SetupProjection(45.0f, windowWidth / (float)windowHeight);
// Init light
InitLight();
// Init materials
InitCubePosition();
// Init program
res &= AddProgram("mesh.vert", "spotLight.frag");
auto program = programs[0];
// Get uniform locations
res &= AddLightUniform(program.get());
res &= AddMatricesUniform(program.get());
res &= program->AddUniform("material.shininess");
res &= program->AddUniform("samplerDiffuse1");
program->AddUniform("samplerDiffuse2");
program->AddUniform("samplerDiffuse3");
program->AddUniform("samplerSpecular1");
program->AddUniform("samplerSpecular2");
glUniform1i(program->GetUniform("samplerDiffuse1"), 0);
glUniform1i(program->GetUniform("samplerDiffuse2"), 1);
glUniform1i(program->GetUniform("samplerDiffuse3"), 2);
glUniform1i(program->GetUniform("samplerSpecular1"), 3);
glUniform1i(program->GetUniform("samplerSpecular2"), 4);
// Init geometry
auto vao = std::make_unique<gs::VertexArray>();
vao->BindVAO();
auto vbo = std::make_unique<gs::VertexBuffer>(GL_ARRAY_BUFFER);
vbo->BindVBO();
OGLCube cube;
auto& vertices = cube.GetVertices();
cube.InitVertices(glm::vec3(0));
glBufferData(vbo->GetTarget(), sizeof(gs::Vertex) * vertices.size(), vertices.data(), GL_STATIC_DRAW);
vbos.push_back(std::move(vbo));
vao->AddAttribute(0, 3, GL_FLOAT, GL_FALSE, sizeof(gs::Vertex), 0);
vao->AddAttribute(1, 2, GL_FLOAT, GL_FALSE, sizeof(gs::Vertex), (void*)offsetof(gs::Vertex, texCoords));
vao->AddAttribute(2, 3, GL_FLOAT, GL_FALSE, sizeof(gs::Vertex), (void*)offsetof(gs::Vertex, normal));
vaos.push_back(std::move(vao));
auto diffuse = std::make_unique<gs::Texture>(IMAGE_TYPE::GLI);
diffuse->SetContribution(LIGHT_CONTRIBUTION::DIFFUSE);
res &= diffuse->LoadTexture("containerDiffuse.dds");
diffuse->BindTexture(GL_TEXTURE0);
textures.push_back(std::move(diffuse));
auto specular = std::make_unique<gs::Texture>(IMAGE_TYPE::GLI);
specular->SetContribution(LIGHT_CONTRIBUTION::DIFFUSE);
res &= specular->LoadTexture("containerSpecular.dds");
specular->BindTexture(GL_TEXTURE3);
textures.push_back(std::move(specular));
glEnable(GL_DEPTH_TEST);
res = true;
return res;
}
/*notice the default arguments for main. SDL expects main to look like that, so don't change it*/
int main(int argc, char *argv[])
{
// SDL_Surface *temp = NULL;
int done;// the player
const Uint8 *keys;// the player
/* This section starts by loading the BG as a surface and converting it to a texture This will have to change
if I can manage to scroll the trexture arond the player*/
SDL_CreateWindowAndRenderer(800, 600, SDL_WINDOW_RESIZABLE, &mainWindow, &renderer);
SDL_SetWindowTitle(mainWindow, "Nitro Hotness");
if( TTF_Init() == -1 )
{
return false;
}
if( Mix_OpenAudio( 22050, MIX_DEFAULT_FORMAT, 2, 4096 ) == -1 )
{
return false;
}
InitSpriteSystem();
InitEntitySystem(entityMax);
map mymap = setWorld();
ObstacleList ol = newObstacleList();
mew = newPlayer();
Obstacle Doh = newObstacle(0);
Road_M Path = initRoad();
AI rival = new_AI();
GUI HUD = InitGUI();
mew.position=0;
done = 0;
//The music that will be played
Mix_Music *music = NULL;
Mix_Chunk *buzz = NULL;
buzz = Mix_LoadWAV( "sfx/buzz.wav" );
readSave(&mew);
showTitle();
showMain();
oldTime = 0;
currentTime = 0;
mytime = 0;
do
{
oldTime = 0;
currentTime = 0;
mytime = 0;
if( Mix_PlayingMusic() == 0 )
{
//Play the music
if( Mix_PlayMusic( level_music, -1 ) == -1 )
{
return 1;
}
}
SDL_Event e;
SDL_PollEvent( &e );
if(&e)
{
//User requests quit
if( e.type == SDL_QUIT )
{
done = 1;
}
//user presses enter to go to next menu
//User presses a key
else if( e.type == SDL_KEYDOWN )
{
//Select surfaces based on key press
switch( e.key.keysym.sym )
{
case SDLK_LEFT:
// slog("left is down");
mew.playerX += 3;
mew.accel = (mew.accel - .000001);
break;
case SDLK_RIGHT:
// slog("right is down");
mew.playerX -= 3;
mew.accel = (mew.accel - .000001);
break;
case SDLK_UP:
// slog("up is down");
mew.accel = (mew.accel + .00007);
Mix_PlayChannel( 1, buzz, 0 );
break;
case SDLK_DOWN:
// slog("down is down");
mew.accel = (mew.accel - .00008);
break;
}
}
else if( e.type == SDL_KEYUP )
{
//Select surfaces based on key press
switch( e.key.keysym.sym )
{
case SDLK_RETURN :
if(mew.done ==1)
{
Mix_HaltMusic();
if(GP == 1)
{
mew.done=0;
lvl++;
//slog("new level is %i",lvl);
mew.position = 0;
rival.position =0;
setWorld();
Results(mew.rank,lvl);
}
else if (GP == 0)
{
mew.done=0;
mew.position = 0;
rival.position =0;
levelSelect();
}
}
else
{
slog("too soon");
}
case SDLK_LEFT:
// slog("left is up");
e.type = SDLK_CLEAR;
break;
case SDLK_RIGHT:
// slog("right is up");
e.type = SDLK_CLEAR;
break;
case SDLK_UP:
// slog("up is up");
mew.accel = (mew.accel - .001);
Mix_HaltChannel(1);
e.type = SDLK_CLEAR;
break;
case SDLK_DOWN:
// slog("down is up");
mew.accel = 0;
e.type = SDLK_CLEAR;
break;
default:
//slog("simple decel");
mew.accel = (mew.accel-0.00001);
break;
}
}
if(mew.position > rival.position)
{
mew.rank = 1 ;
}
else if( rival.position > mew.position )
{
mew.rank = 2 ;
}
SDL_RenderClear(renderer);
DrawBG(BG1,BG2);
roadUpdate(Path,mymap,mew);
roadDraw(Path,mymap,&mew);
roadFetch(Path,mymap,&mew);
checkForObstacles(ol , &mew, Doh);
update_AI(&rival, &mew);
UpdatePlayer(&mew);
DrawGui(HUD,mew);
NextFrame();
keys = SDL_GetKeyboardState(NULL);
if(keys[SDL_SCANCODE_ESCAPE])
{
done = 1;
}
}
}while(!done);
//Free the sound effects
//Free the music
Mix_FreeMusic( music );
CloseEntitySystem();
CloseSpriteSystem();
exit(0); /*technically this will end the program, but the compiler likes all functions that can return a value TO return a value*/
return 0;
}
void Application::Initialize()
{
m_ElapsedTime = m_LastElapsedTime = 0.0f;
g_Application = this;
m_Log = new LogManager(this);
m_Log->AddLogType("Info" );
m_Log->AddLogType("Warning");
m_Log->AddLogType("Error" );
m_Log->SetTypeConsoleOutput(HW_INFORMATION,true);
m_Log->SetTypeConsoleOutput(HW_WARNING ,true);
m_Log->SetTypeConsoleOutput(HW_ERROR ,true);
m_Log->SetOutputsTime (true );
m_Log->SetOutputsType (true );
m_Log->SetOutputsFile (false);
m_Log->SetOutputsLine (false);
m_Log->SetOutputsFunction(false);
HW_INFO("Initializing...\n");
m_Window = new Window();
if(m_Window->Create(Vec2(800,600),"HelloWorld",true))
{
FreeImage_Initialise();
m_Rasterizer = m_Window->GetRasterizer();
((OpenGLRasterizer*)m_Rasterizer)->SetClearBuffers(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
m_Window->PollEvents();
m_TaskManager = new TaskManager();
m_Renderer = new DeferredRenderer(m_Rasterizer,m_TaskManager);
m_Rasterizer->SetRenderer(m_Renderer);
m_Renderer->Init();
m_AssetAllocator = new HWAssetAllocator(m_Renderer);
m_AssetManager = new AssetManager(m_AssetAllocator);
m_AssetAllocator->SetAssetManager(m_AssetManager);
HWInitializeAssetManager(m_AssetManager);
InitRenderer();
m_InputManager = new InputManager(m_Renderer);
m_InputManager->Initialize(BTN_COUNT);
m_InputManager->SetMouseButtonIDs(BTN_LEFT_MOUSE,BTN_RIGHT_MOUSE);
m_ShaderGenerator = m_Renderer->GetShaderGenerator();
Scalar Aspect = m_Rasterizer->GetContext()->GetResolution().y / m_Rasterizer->GetContext()->GetResolution().x;
m_Camera = new Camera(Vec2(60.0f,60.0f * Aspect),0.001f,2000.0f);
m_Renderer->GetScene()->SetActiveCamera(m_Camera);
m_Renderer->GetScene()->SetCullingAlgorithm(new BruteForceCullingAlgorithm(m_Renderer->GetScene(),m_TaskManager));
m_ElapsedTime = m_LastElapsedTime = m_Window->GetElapsedTime();
m_DeltaTime = 1.0f / 60.0f;
m_Rasterizer->SetClearColor(Vec4(0.1f,0.1f,0.1f,1.0f));
m_Window->PollEvents();
m_Rasterizer->ClearActiveFramebuffer();
m_DoShutdown = false;
m_UIManager = 0;
m_Cursor = 0;
InitGUI();
m_SSAO = 0;
//InitSSAO();
m_DebugDraw = 0;
InitDebugDisplay();
m_Game = new GameManager(this);
m_Game->Initialize();
}
else
{
m_DoShutdown = true;
m_Rasterizer = 0;
m_Renderer = 0;
m_ShaderGenerator = 0;
delete m_Window;
delete m_TaskManager;
m_Window = 0;
}
}
int WINAPI WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow)
{
startup_time = GetTickCount();
previous_time = 0;
frames = 0;
fps = 1;
#ifdef _DEBUG_TIMINGS
drawtime = 0;
drawtime_prv = 0;
drawtime_med = 1;
cleartime = 0;
cleartime_prv = 0;
cleartime_med = 1;
mainlooptime = 0;
mainlooptime_prv = 0;
mainlooptime_med = 1;
fliptime = 0;
fliptime_prv = 0;
fliptime_med = 1;
#endif
current_state = GAME_MAINMENU;
difficulty_pick = 0;
size_pick = 0;
race_pick = 0;
opponents_pick = 0;
mouseX = 0;
mouseY = 0;
mouse[0] = false;
mouse[1] = false;
mouse[2] = false;
tex_count = 0;
font_count = 0;
srand((unsigned)time(NULL));
LogToFile("Log started");
InitWindow(hInstance);
InitPaths();
InitTextures();
InitFonts();
InitStorages();
InitDefinitions();
InitGUI();
InitOGLSettings();
ResizeScene(cfg.scr_width, cfg.scr_height);
LogPaths();
//Load_v_03("test.txt");
Load_v_04("test.txt");
while(current_state != GAME_EXITING)
{
MainLoop();
ClearScene();
DrawScene();
Flip(&hDC);
}
// Now terminating all
KillWindow(hInstance);
LogToFile("Finished logging");
}
int WINAPI WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow)
{
LogToFile(DEFAULT_LOG_NAME, "Log started");
InitWindow(hInstance);
startup_time = GetTickCount();
previous_time = 0;
frames = 0;
fps = 1;
#ifdef _DEBUG_TIMINGS
drawtime = 0;
drawtime_prv = 0;
drawtime_med = 1;
cleartime = 0;
cleartime_prv = 0;
cleartime_med = 1;
mainlooptime = 0;
mainlooptime_prv = 0;
mainlooptime_med = 1;
fliptime = 0;
fliptime_prv = 0;
fliptime_med = 1;
#endif
current_state = GAME_MAINMENU;
mouseX = 0;
mouseY = 0;
mouse[0] = false;
mouse[1] = false;
mouse[2] = false;
tex_count = 0;
font_count = 0;
InitPaths();
LogPaths();
LoadTexturesFromFolder(path_textures, textures);
InitFonts();
InitGUI();
InitOGLSettings();
ResizeScene(cfg.scr_width, cfg.scr_height);
while(current_state != GAME_EXITING)
{
MainLoop();
ClearScene();
DrawScene();
Flip(hDC);
}
// Now terminating all
KillWindow(hInstance);
LogToFile(DEFAULT_LOG_NAME, "Finished logging");
}
