LRESULT CALLBACK MyGuiWindowProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) {
LRESULT result = 0;
switch (message) {
case WM_SIZE: {
RECT clientRect;
GetClientRect(hwnd, &clientRect);
ResizeWindow(clientRect.right - clientRect.left, clientRect.bottom - clientRect.top);
}break;
case WM_DESTROY: {
result = DefWindowProc(hwnd, message, wParam, lParam);
}break;
case WM_CLOSE: {
result = DefWindowProc(hwnd, message, wParam, lParam);
}break;
case WM_MOUSEMOVE:
{
int mouseX = GET_X_LPARAM(lParam);
int mouseY = GET_Y_LPARAM(lParam);
currMouseX = mouseX;
currMouseY = mouseY;
if (wParam & MK_LBUTTON) {
mouseState = HOLD;
}
}break;
case WM_LBUTTONDOWN:
{
int mouseX = GET_X_LPARAM(lParam);
int mouseY = GET_Y_LPARAM(lParam);
if(mouseState != HOLD){
mouseState = PRESS;
}
}break;
case WM_LBUTTONUP:
{
//int mouseX = GET_X_LPARAM(lParam);
//int mouseY = GET_Y_LPARAM(lParam);
mouseState = RELEASE;
//MouseDown(mouseX, mouseY);
}break;
case WM_SYSKEYDOWN:
case WM_SYSKEYUP:
case WM_KEYDOWN:
case WM_KEYUP: {
int code = wParam;
bool wasDown = (lParam & (1 << 30)) != 0;
bool isDown = (lParam & (1 << 31)) == 0;
keyStates[code] = StateFromBools(wasDown, isDown);
}break;
case WM_PAINT: {
WindowsPaintWindow(hwnd);
}break;
case WM_ACTIVATEAPP: {
}break;
case WM_MOUSEWHEEL: {
float zDelta = GET_WHEEL_DELTA_WPARAM(wParam);
printf("Whell delta: %f\n", zDelta);
}break;
case WM_GESTURE: {
printf("WM Gesture.\n");
}break;
case WM_TOUCH: {
printf("WM Touch.\n");
}break;
default: {
result = DefWindowProc(hwnd, message, wParam, lParam);
} break;
}
return result;
}
BOOL CALLBACK Machines_DlgProc (HWND hDlg, UINT msg, WPARAM wp, LPARAM lp)
{
if (Display_HandleColumnNotify (hDlg, msg, wp, lp, &gr.viewMch))
return FALSE;
switch (msg)
{
case WM_INITDIALOG:
{
RECT rTab;
GetClientRect (GetParent(hDlg), &rTab);
TabCtrl_AdjustRect (GetParent (hDlg), FALSE, &rTab);
ResizeWindow (hDlg, awdMachinesTab, rwaMoveToHere, &rTab);
HIMAGELIST hSmall = AfsAppLib_CreateImageList (FALSE);
HIMAGELIST hLarge = AfsAppLib_CreateImageList (TRUE);
FastList_SetImageLists (GetDlgItem (hDlg, IDC_MACHINES_LIST), hSmall, hLarge);
FastList_SetSortFunction (GetDlgItem (hDlg, IDC_MACHINES_LIST), General_ListSortFunction);
FL_RestoreView (GetDlgItem (hDlg, IDC_MACHINES_LIST), &gr.viewMch);
FastList_SetTextCallback (GetDlgItem (hDlg, IDC_MACHINES_LIST), Display_GetItemText, &gr.viewMch);
SetDlgItemText (hDlg, IDC_MACHINES_PATTERN, g.szPatternMachines);
Machines_EnableButtons(hDlg);
Display_PopulateMachineList();
l.dwTickLastType = 0;
}
break;
case WM_HELP:
WinHelp (hDlg, cszHELPFILENAME, HELP_FINDER, 0);
break;
case WM_DESTROY:
FL_StoreView (GetDlgItem (hDlg, IDC_MACHINES_LIST), &gr.viewMch);
break;
case WM_SIZE:
// if (lp==0), we're minimizing--don't call ResizeWindow().
//
if (lp != 0)
ResizeWindow (hDlg, awdMachinesTab, rwaFixupGuts);
break;
case WM_TIMER:
switch (wp)
{
case ID_SEARCH_TIMER:
if ( (l.dwTickLastType) && (GetTickCount() > l.dwTickLastType + msecSEARCH_TIMER) )
{
KillTimer (hDlg, ID_SEARCH_TIMER);
Display_PopulateMachineList();
}
break;
}
break;
case WM_CONTEXTMENU:
POINT ptScreen;
ptScreen.x = LOWORD(lp);
ptScreen.y = HIWORD(lp);
OnRightClick (pmMACHINE, GetDlgItem (hDlg, IDC_MACHINES_LIST), &ptScreen);
break;
case WM_COMMAND:
switch (LOWORD(wp))
{
case IDC_MACHINES_PATTERN:
if (HIWORD(wp) == EN_UPDATE)
{
l.dwTickLastType = GetTickCount();
KillTimer (hDlg, ID_SEARCH_TIMER);
SetTimer (hDlg, ID_SEARCH_TIMER, msecSEARCH_TIMER +15, NULL);
}
break;
default:
OnContextCommand (LOWORD(wp));
break;
}
break;
case WM_NOTIFY:
switch (((LPNMHDR)lp)->code)
{
case FLN_ITEMSELECT:
Main_SetMenus();
Machines_EnableButtons(hDlg);
break;
case FLN_LDBLCLICK:
PostMessage (hDlg, WM_COMMAND, MAKELONG(M_PROPERTIES,BN_CLICKED), (LPARAM)GetDlgItem (hDlg, M_PROPERTIES));
break;
}
break;
}
return FALSE;
}
void
TWindow::MessageReceived(BMessage* m)
{
bool active = fFatBits->Active();
switch (m->what) {
case msg_show_info:
if (active) {
fInfoBarState = !fInfoBarState;
ShowInfo(!fShowInfo);
}
break;
case msg_toggle_grid:
if (active)
SetGrid(!fShowGrid);
break;
case msg_grow:
if (active)
ResizeWindow(true);
break;
case msg_shrink:
if (active)
ResizeWindow(false);
break;
case msg_make_square:
if (active) {
if (fHPixelCount == fVPixelCount)
break;
int32 big = (fHPixelCount > fVPixelCount) ? fHPixelCount : fVPixelCount;
ResizeWindow(big, big);
}
break;
case msg_shrink_pixel:
if (active)
SetPixelSize(false);
break;
case msg_grow_pixel:
if (active)
SetPixelSize(true);
break;
case msg_add_cross_hair:
if (active && fShowInfo)
AddCrossHair();
break;
case msg_remove_cross_hair:
if (active && fShowInfo)
RemoveCrossHair();
break;
case msg_freeze:
if (active)
SetFlags(B_OUTLINE_RESIZE | B_NOT_ZOOMABLE | B_NOT_RESIZABLE);
else
SetFlags(B_OUTLINE_RESIZE | B_NOT_ZOOMABLE);
fFatBits->MakeActive(!fFatBits->Active());
break;
case msg_stick:
fFatBits->MakeSticked(!fFatBits->Sticked());
break;
case msg_save: {
// freeze the image here, unfreeze after dump or cancel
fFatBits->StartSave();
BMessenger messenger(this);
BMessage message(msg_dump);
fSavePanel = new BFilePanel(B_SAVE_PANEL, &messenger, 0, 0, false,
&message);
fSavePanel->SetSaveText("Bitmaps.h");
fSavePanel->Show();
} break;
case msg_dump:
{
delete fSavePanel;
entry_ref dirRef;
char* name;
m->FindRef("directory", &dirRef);
m->FindString((const char*)"name",(const char**) &name);
fFatBits->SaveImage(&dirRef, name);
}
break;
case B_CANCEL:
// image is frozen before the FilePanel is shown
fFatBits->EndSave();
break;
case msg_copy_image:
fFatBits->CopyImage();
break;
default:
BWindow::MessageReceived(m);
break;
}
}
EndGameHighScoreBaseWindow(WindowDesc *desc) : Window(desc)
{
this->InitNested();
CLRBITS(this->flags, WF_WHITE_BORDER);
ResizeWindow(this, _screen.width - this->width, _screen.height - this->height);
}
BootstrapBackground() : Window(&_background_desc)
{
this->InitNested(0);
CLRBITS(this->flags, WF_WHITE_BORDER);
ResizeWindow(this, _screen.width, _screen.height);
}
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR cmdLine, int cmdShow) {
#else
int main(int argc, char** argv) {
#endif
// Start by opening a debug log.
Debug::openLog(true);
Debug::logger->message("\n ----- Engine Loading -----");
if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) < 0) {
Debug::logger->message("Error: Could not load SDL");
Destroy();
return 1;
} else {
Debug::logger->message("SDL loaded..");
}
// Setup OpenGL.
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 5);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
flags = SDL_OPENGL | SDL_HWSURFACE | SDL_RESIZABLE;
screen = SDL_SetVideoMode(windowWidth, windowHeight, 32, flags);
Debug::logger->message("Video mode set..");
if(Mix_OpenAudio(44100, AUDIO_S16, 2, 4096)) {
Debug::logger->message("Audio opened..");
}
if(TTF_Init()) {
Debug::logger->message("SDL_ttf initialized.\n");
}
info = SDL_GetVideoInfo();
if(!info) {
// This should never accur.
Debug::logger->message("Video query failed!");
Destroy();
return 1;
}
SDL_WM_SetCaption("LibD", NULL);
srand((unsigned int)time(NULL));
Debug::logger->message("\n ----- Engine Initialization Complete -----");
Debug::logger->message("\n ----- Logic -----");
Game game;
game.Init();
CreateInput();
Uint32 timeStart = SDL_GetTicks();
float dt = 1.0f / 60.0f;
// We need to give OnResize()'s width and height params an initial value
// Otherwise it is just garbage, and the orthorgraphic view
// screws up for me. -- Allanis.
game.OnResize(windowWidth, windowHeight);
while(game.IsRunning()) {
while(SDL_PollEvent(&event)) {
if((event.type == SDL_QUIT) || KeyStillDown(SDLK_ESCAPE)) {
game.SetRunning(false);
break;
}
if(event.type == SDL_VIDEORESIZE) {
// Resize the window.
ResizeWindow(game, event.resize.w, event.resize.h);
break;
}
}
UpdateInput();
game.Prepare(dt);
game.ProcessEvents(dt);
game.Render();
SDL_GL_SwapBuffers();
Uint32 timeEnd = SDL_GetTicks();
dt = (float)(timeEnd - timeStart) / 1000.0f;
timeStart = timeEnd;
}
game.Shutdown();
Destroy();
Debug::closeLog();
return 0;
}
void ExternalRenderWindow::resizeEvent(QResizeEvent *e)
{
ResizeWindow(width(), height());
}
// --------------------------------------------------------------------------------------
static void handleEvents(EventRecord *event)
{
WindowRef window;
Boolean activate;
WindowPartCode partCode;
OSErr error;
Rect tempRect, newSize;
long menuChoice;
MenuCommand commandID;
RgnHandle grayRegion;
switch (event->what) // handle events according to the priority
{ // determined by the system
case activateEvt:
window = (WindowRef)event->message;
activate = (event->modifiers & activeFlag) != 0;
HandleActivate(window, activate);
break;
case mouseDown:
partCode = FindWindow(event->where, &window);
switch(partCode)
{
case inMenuBar:
menuChoice = MenuSelect(event->where);
error = GetMenuItemCommandID(GetMenuRef(HiWord(menuChoice)),
LoWord(menuChoice), &commandID);
if (error == noErr)
{
if (commandID == 0) // if the menu item clicked on does not have
commandID = (MenuCommand)menuChoice; // a command ID
HandleMenuChoice(commandID);
}
break;
case inSysWindow:
if (window != NULL)
SystemClick(event, window);
break;
case inContent: // the following window part codes will only be returned
if (window != FrontWindow()) // for the preferences window
SelectWindow(window);
else
HandleContentClick(window, event->where, event->modifiers);
break;
case inDrag:
grayRegion = GetGrayRgn();
DragWindow(window, event->where, &((*grayRegion)->rgnBBox));
break;
case inGrow:
SetRect(&tempRect, kPrefsWindowPlatinumWidth, kPrefsWindowPlatinumHeight,
SHRT_MAX, SHRT_MAX);
ResizeWindow(window, event->where, &tempRect, &newSize);
AdjustControls(window);
break;
case inGoAway:
ClosePrefsWindow(window);
break;
}
break;
case keyDown:
case autoKey: // a separate auto key handler would go after disk events
if ((event->modifiers & cmdKey) != 0)
{
UInt32 keyMenuChoice;
keyMenuChoice = MenuEvent(event);
error = GetMenuItemCommandID(GetMenuRef(HiWord(keyMenuChoice)),
LoWord(keyMenuChoice), &commandID);
if (error == noErr)
{
if (commandID == 0) // if the menu item chosen does not have a
commandID = (MenuCommand)keyMenuChoice; // command ID
HandleMenuChoice(commandID); // (but they all should)
}
}
else
{
window = FrontNonFloatingWindow();
if (window != NULL)
{
char keyCode = (event->message & keyCodeMask) >> 8;
HandleKeyDown(keyCode, window);
}
}
break;
case diskEvt:
if (HiWord(event->message) != noErr)
{
Point where;
SetPt(&where, 70, 50);
ShowCursor();
DIBadMount(where, event->message);
}
break;
case updateEvt:
window = (WindowRef)event->message;
SetPortWindowPort(window);
BeginUpdate(window);
HandleDrawContent(window);
EndUpdate(window);
break;
case kHighLevelEvent: // an OS Event handler would go before high level events
AEProcessAppleEvent(event);
break;
}
// Create a window context
//-----------------------------------------------------------------------------
CPUTResult CPUT_OGL::CPUTCreateWindowAndContext(const cString WindowTitle, CPUTWindowCreationParams windowParams)
{
CPUTResult result = CPUT_SUCCESS;
HEAPCHECK;
// We shouldn't destroy old window if it already exist,
// Framework user should do this by himself to be aware
// of what he is doing.
if( mpWindow )
{
return CPUT_ERROR_WINDOW_ALREADY_EXISTS;
}
result = MakeWindow(WindowTitle, windowParams);
if(CPUTFAILED(result))
{
return result;
}
HEAPCHECK;
// create the GL context
result = CreateOGLContext(windowParams.deviceParams);
if(CPUTFAILED(result))
{
return result;
}
HEAPCHECK;
result = CreateContext();
CPUTRenderStateBlock *pBlock = new CPUTRenderStateBlockOGL();
CPUTRenderStateBlock::SetDefaultRenderStateBlock( pBlock );
cString name = _L("$cbPerFrameValues");
mpPerFrameConstantBuffer = new CPUTBufferOGL(name);
GLuint id = mpPerFrameConstantBuffer->GetBufferID();
#ifndef CPUT_FOR_OGLES2
GL_CHECK(glBindBuffer(GL_UNIFORM_BUFFER, mpPerFrameConstantBuffer->GetBufferID()));
GL_CHECK(glBufferData(GL_UNIFORM_BUFFER, sizeof(CPUTFrameConstantBuffer), NULL, GL_DYNAMIC_DRAW)); // NULL to just init buffer size
DEBUG_PRINT(_L("bind per frame buffer buffer %d\n"), id);
//FIXME: constant buffer binding
GL_CHECK(ES3_COMPAT(glBindBufferBase(GL_UNIFORM_BUFFER, id, id)));
DEBUG_PRINT(_L("completed - bind buffer %d\n"), id);
GL_CHECK(glBindBuffer(GL_UNIFORM_BUFFER, 0));
#else
#warning "Need to do something with uniform buffers here"
#endif
CPUTAssetLibrary::GetAssetLibrary()->AddConstantBuffer(_L(""), name, _L(""), mpPerFrameConstantBuffer);
name = _L("$cbPerModelValues");
mpPerModelConstantBuffer = new CPUTBufferOGL(name, GL_UNIFORM_BUFFER, GL_DYNAMIC_DRAW, sizeof(CPUTModelConstantBuffer), NULL);
id = mpPerModelConstantBuffer->GetBufferID();
#ifndef CPUT_FOR_OGLES2
DEBUG_PRINT(_L("Bind per model values %d"), id);
GL_CHECK(ES3_COMPAT(glBindBufferBase(GL_UNIFORM_BUFFER, id, id)));
DEBUG_PRINT(_L("Completed bind per model values"));
GL_CHECK(glBindBuffer(GL_UNIFORM_BUFFER, 0));
#else
#warning "Need to do something with uniform buffers here"
#endif
CPUTAssetLibrary::GetAssetLibrary()->AddConstantBuffer(_L(""), name, _L(""), mpPerModelConstantBuffer);
name = _L("$cbGUIConstants");
CPUTBuffer* pBuffer = new CPUTBufferOGL(name, GL_UNIFORM_BUFFER, GL_DYNAMIC_DRAW, sizeof(GUIConstants), NULL);
CPUTAssetLibrary::GetAssetLibrary()->AddConstantBuffer(_L(""), name, _L(""), pBuffer);
SAFE_RELEASE(pBuffer);
// Add our programatic (and global) material parameters
CPUTMaterial::mGlobalProperties.AddValue( _L("cbPerFrameValues"), _L("$cbPerFrameValues") );
CPUTMaterial::mGlobalProperties.AddValue( _L("cbPerModelValues"), _L("$cbPerModelValues") );
CPUTMaterial::mGlobalProperties.AddValue( _L("cbGUIValues"), _L("$cbGUIValues") );
HEAPCHECK;
// Trigger a post-create user callback event
Create();
HEAPCHECK;
//
// Start the timer after everything is initialized and assets have been loaded
//
mpTimer->StartTimer();
int x,y,width,height;
mpWindow->GetClientDimensions(&x, &y, &width, &height);
ResizeWindow(width,height);
return result;
}
void update_Display(void){
if(update_have_gvec == 1){
update_have_gvec = 0;
update_gvec_down(1);
}
if(update_smokecolorbar == 1){
update_smokecolorbar = 0;
SmokeColorBarMenu(fire_colorbar_index);
}
if(update_colorbartype == 1){
colorbardata *cb;
cb = getcolorbar(colorbarname);
if(cb != NULL){
colorbartype = cb - colorbarinfo;
current_colorbar = cb;
if(colorbartype != colorbartype_default){
colorbartype_ini = colorbartype;
}
}
update_colorbartype = 0;
}
if(update_fire_line == 1){
WUI_CB(TERRAIN_FIRE_LINE_UPDATE);
update_fire_line = 0;
}
if(updatezoommenu == 1 || first_display > 0){
if(first_display > 0)first_display--;
updatezoommenu = 0;
ZoomMenu(zoomindex);
}
if(update_makeiblank_smoke3d == 1){
makeiblank_smoke3d();
}
#ifdef pp_CULL
if(update_initcull == 1)initcull(cullsmoke);
#endif
if(update_streaks == 1 && ReadPartFile == 1){
ParticleStreakShowMenu(streak_index);
update_streaks = 0;
}
if(update_screensize == 1){
update_screensize = 0;
update_windowsizelist();
ResizeWindow(screenWidthINI, screenHeightINI);
}
if(updatemenu == 1 && usemenu == 1 && menustatus == GLUT_MENU_NOT_IN_USE){
glutDetachMenu(GLUT_RIGHT_BUTTON);
InitMenus(LOAD);
glutAttachMenu(GLUT_RIGHT_BUTTON);
updatemenu = 0;
}
if(update_fire_colorbar_index == 1){
SmokeColorBarMenu(fire_colorbar_index_ini);
update_fire_colorbar_index = 0;
}
if(showtime == 0 && ntotal_smooth_blockages > 0){
update_smoothblockage_info();
}
if(update_colorbar_select_index == 1 && colorbar_select_index >= 0 && colorbar_select_index <= 255){
update_colorbar_select_index = 0;
UpdateRGBColors(colorbar_select_index);
}
}
void CFilterEdit::OnSize( UINT nType, int cx, int cy )
{
CEdit::OnSize( nType, cx, cy );
ResizeWindow();
}
// Handle OnCreation events
//-----------------------------------------------------------------------------
void MySample::Create()
{
CPUTAssetLibrary *pAssetLibrary = CPUTAssetLibrary::GetAssetLibrary();
gLightDir.normalize();
// TODO: read from cmd line, using these as defaults
//pAssetLibrary->SetMediaDirectoryName( _L("Media"));
CPUTGuiControllerDX11 *pGUI = CPUTGetGuiController();
// create some controls
CPUTButton *pButton = NULL;
pGUI->CreateButton(_L("Fullscreen"), ID_FULLSCREEN_BUTTON, ID_MAIN_PANEL, &pButton);
pGUI->CreateDropdown( L"Rasterizer Technique: SCALAR", ID_RASTERIZE_TYPE, ID_MAIN_PANEL, &mpTypeDropDown);
mpTypeDropDown->AddSelectionItem( L"Rasterizer Technique: SSE" );
mpTypeDropDown->SetSelectedItem(mSOCType + 1);
wchar_t string[CPUT_MAX_STRING_LENGTH];
pGUI->CreateText( _L("Occluders \t"), ID_OCCLUDERS, ID_MAIN_PANEL, &mpOccludersText);
swprintf_s(&string[0], CPUT_MAX_STRING_LENGTH, _L("\tNumber of Models: \t%d"), mNumOccluders);
pGUI->CreateText(string, ID_NUM_OCCLUDERS, ID_MAIN_PANEL, &mpNumOccludersText);
swprintf_s(&string[0], CPUT_MAX_STRING_LENGTH, _L("\tDepth rasterized models: %d"), mNumOccludersR2DB);
pGUI->CreateText(string, ID_NUM_OCCLUDERS_RASTERIZED_TO_DB, ID_MAIN_PANEL, &mpOccludersR2DBText);
swprintf_s(&string[0], CPUT_MAX_STRING_LENGTH, _L("\tNumber of tris: \t\t%f"), mNumOccluderTris);
pGUI->CreateText(string, ID_NUM_OCCLUDER_TRIS, ID_MAIN_PANEL, &mpOccluderTrisText);
swprintf_s(&string[0], CPUT_MAX_STRING_LENGTH, _L("\tDepth rasterized tris: \t%f"), mNumOccluderRasterizedTris);
pGUI->CreateText(string, ID_NUM_OCCLUDER_RASTERIZED_TRIS, ID_MAIN_PANEL, &mpOccluderRasterizedTrisText);
swprintf_s(&string[0], CPUT_MAX_STRING_LENGTH, _L("\tDepth raterizer time: \t%f"), mRasterizeTime);
pGUI->CreateText(string, ID_RASTERIZE_TIME, ID_MAIN_PANEL, &mpRasterizeTimeText);
swprintf_s(&string[0], CPUT_MAX_STRING_LENGTH, _L("Occluder Size Threshold: %0.4f"), mOccluderSizeThreshold);
pGUI->CreateSlider(string, ID_OCCLUDER_SIZE, ID_MAIN_PANEL, &mpOccluderSizeSlider);
mpOccluderSizeSlider->SetScale(0, 5.0, 51);
mpOccluderSizeSlider->SetValue(mOccluderSizeThreshold);
mpOccluderSizeSlider->SetTickDrawing(false);
pGUI->CreateText(_L("Occludees \t"), ID_OCCLUDEES, ID_MAIN_PANEL, &mpOccludeesText);
swprintf_s(&string[0], CPUT_MAX_STRING_LENGTH, _L("\tNumber of Models: \t%d"), mNumOccludees);
pGUI->CreateText(string, ID_NUM_OCCLUDEES, ID_MAIN_PANEL, &mpNumOccludeesText);
swprintf_s(&string[0], CPUT_MAX_STRING_LENGTH, _L("\tModels culled: \t%d"), mNumCulled);
pGUI->CreateText(string, ID_NUM_CULLED, ID_MAIN_PANEL, &mpCulledText);
swprintf_s(&string[0], CPUT_MAX_STRING_LENGTH, _L("\tModels visible: \t%d"), mNumVisible);
pGUI->CreateText(string, ID_NUM_VISIBLE, ID_MAIN_PANEL, &mpVisibleText);
swprintf_s(&string[0], CPUT_MAX_STRING_LENGTH, _L("\tNumber of tris: \t%d"), (int)mNumOccludeeTris);
pGUI->CreateText(string, ID_NUM_OCCLUDEE_TRIS, ID_MAIN_PANEL, &mpOccludeeTrisText);
swprintf_s(&string[0], CPUT_MAX_STRING_LENGTH, _L("\tCulled Triangles: \t%d"), (int)mNumOccludeeCulledTris);
pGUI->CreateText(string, ID_NUM_OCCLUDEE_CULLED_TRIS, ID_MAIN_PANEL, &mpCulledTrisText);
swprintf_s(&string[0], CPUT_MAX_STRING_LENGTH, _L("\tVisible Triangles: \t%d"), (int)mNumOccludeeVisibleTris);
pGUI->CreateText(string, ID_NUM_OCCLUDEE_VISIBLE_TRIS, ID_MAIN_PANEL, &mpVisibleTrisText);
swprintf_s(&string[0], CPUT_MAX_STRING_LENGTH, _L("\tVisible Triangles: \t%0.2f ms"), mDepthTestTime);
pGUI->CreateText(string, ID_DEPTHTEST_TIME, ID_MAIN_PANEL, &mpDepthTestTimeText);
swprintf_s(&string[0], CPUT_MAX_STRING_LENGTH, _L("Occludee Size Threshold: %0.4f"), mOccludeeSizeThreshold);
pGUI->CreateSlider(string, ID_OCCLUDEE_SIZE, ID_MAIN_PANEL, &mpOccludeeSizeSlider);
mpOccludeeSizeSlider->SetScale(0, 0.1f, 41);
mpOccludeeSizeSlider->SetValue(mOccludeeSizeThreshold);
mpOccludeeSizeSlider->SetTickDrawing(false);
swprintf_s(&string[0], CPUT_MAX_STRING_LENGTH, _L("Total Cull time: %0.2f"), mTotalCullTime);
pGUI->CreateText(string, ID_TOTAL_CULL_TIME, ID_MAIN_PANEL, &mpTotalCullTimeText);
pGUI->CreateCheckbox(_L("Depth Test Culling"), ID_ENABLE_CULLING, ID_MAIN_PANEL, &mpCullingCheckBox);
pGUI->CreateCheckbox(_L("Frustum Culling"), ID_ENABLE_FCULLING, ID_MAIN_PANEL, &mpFCullingCheckBox);
pGUI->CreateCheckbox(_L("View Depth Buffer"), ID_DEPTH_BUFFER_VISIBLE, ID_MAIN_PANEL, &mpDBCheckBox);
pGUI->CreateCheckbox(_L("View Bounding Box"), ID_BOUNDING_BOX_VISIBLE, ID_MAIN_PANEL, &mpBBCheckBox);
pGUI->CreateCheckbox(_L("Multi Tasking"), ID_ENABLE_TASKS, ID_MAIN_PANEL, &mpTasksCheckBox);
pGUI->CreateCheckbox(_L("Vsync"), ID_VSYNC_ON_OFF, ID_MAIN_PANEL, &mpVsyncCheckBox);
pGUI->CreateCheckbox(_L("Pipeline"), ID_PIPELINE, ID_MAIN_PANEL, &mpPipelineCheckBox);
swprintf_s(&string[0], CPUT_MAX_STRING_LENGTH, _L("Number of draw calls: \t%d"), mNumDrawCalls);
pGUI->CreateText(string, ID_NUM_DRAW_CALLS, ID_MAIN_PANEL, &mpDrawCallsText),
swprintf_s(&string[0], CPUT_MAX_STRING_LENGTH, _L("Depth Test Tasks: \t\t%d"), mNumDepthTestTasks);
pGUI->CreateSlider(string, ID_DEPTH_TEST_TASKS, ID_MAIN_PANEL, &mpDepthTestTaskSlider);
mpDepthTestTaskSlider->SetScale(1, (float)NUM_DT_TASKS, 11);
mpDepthTestTaskSlider->SetValue((float)mNumDepthTestTasks);
mpDepthTestTaskSlider->SetTickDrawing(false);
mpAABB->SetDepthTestTasks(mNumDepthTestTasks);
//
// Create Static text
//
pGUI->CreateText( _L("F1 for Help"), ID_IGNORE_CONTROL_ID, ID_SECONDARY_PANEL);
pGUI->CreateText( _L("[Escape] to quit application"), ID_IGNORE_CONTROL_ID, ID_SECONDARY_PANEL);
pGUI->CreateText( _L("A,S,D,F - move camera position"), ID_IGNORE_CONTROL_ID, ID_SECONDARY_PANEL);
pGUI->CreateText( _L("Q - camera position up"), ID_IGNORE_CONTROL_ID, ID_SECONDARY_PANEL);
pGUI->CreateText( _L("E - camera position down"), ID_IGNORE_CONTROL_ID, ID_SECONDARY_PANEL);
pGUI->CreateText( _L("mouse + right click - camera look location"), ID_IGNORE_CONTROL_ID, ID_SECONDARY_PANEL);
pGUI->CreateText( _L("size thresholds : computed using screen space metris"), ID_IGNORE_CONTROL_ID, ID_SECONDARY_PANEL);
pGUI->SetActivePanel(ID_MAIN_PANEL);
pGUI->DrawFPS(true);
// Add our programatic (and global) material parameters
CPUTMaterial::mGlobalProperties.AddValue( _L("cbPerFrameValues"), _L("$cbPerFrameValues") );
CPUTMaterial::mGlobalProperties.AddValue( _L("cbPerModelValues"), _L("$cbPerModelValues") );
CPUTMaterial::mGlobalProperties.AddValue( _L("_Shadow"), _L("$shadow_depth") );
// Creating a render target to view the CPU rasterized depth buffer
mpCPUDepthBuf[0] = new char[SCREENW*SCREENH*4];
mpCPUDepthBuf[1] = new char[SCREENW*SCREENH*4];
mpGPUDepthBuf = new char[SCREENW*SCREENH*4];
CD3D11_TEXTURE2D_DESC cpuRenderTargetDescSSE
(
DXGI_FORMAT_R8G8B8A8_UNORM,
SCREENW * 2, // TODO: round up to full tile sizes
SCREENH / 2,
1, // Array Size
1, // MIP Levels
D3D11_BIND_SHADER_RESOURCE,
D3D11_USAGE_DEFAULT,
0
);
HRESULT hr;
hr = mpD3dDevice->CreateTexture2D(&cpuRenderTargetDescSSE, NULL, &mpCPURenderTargetSSE[0]);
ASSERT(SUCCEEDED(hr), _L("Failed creating render target."));
hr = mpD3dDevice->CreateTexture2D(&cpuRenderTargetDescSSE, NULL, &mpCPURenderTargetSSE[1]);
ASSERT(SUCCEEDED(hr), _L("Failed creating render target."));
hr = mpD3dDevice->CreateShaderResourceView(mpCPURenderTargetSSE[0], NULL, &mpCPUSRVSSE[0]);
ASSERT(SUCCEEDED(hr), _L("Failed creating shader resource view."));
hr = mpD3dDevice->CreateShaderResourceView(mpCPURenderTargetSSE[1], NULL, &mpCPUSRVSSE[1]);
ASSERT(SUCCEEDED(hr), _L("Failed creating shader resource view."));
// Corresponding texture object
CPUTTextureDX11 *pDummyTex0 = new CPUTTextureDX11;
pDummyTex0->SetTextureAndShaderResourceView(mpCPURenderTargetSSE[0], mpCPUSRVSSE[0]);
pAssetLibrary->AddTexture( _L("$depthbuf_tex_SSE"), pDummyTex0 );
SAFE_RELEASE(pDummyTex0);
CPUTTextureDX11 *pDummyTex1 = new CPUTTextureDX11;
pDummyTex1->SetTextureAndShaderResourceView(mpCPURenderTargetSSE[1], mpCPUSRVSSE[1]);
pAssetLibrary->AddTexture( _L("$depthbuf_tex_SSE"), pDummyTex1 );
SAFE_RELEASE(pDummyTex1);
CD3D11_TEXTURE2D_DESC cpuRenderTargetDescScalar
(
DXGI_FORMAT_R8G8B8A8_UNORM,
SCREENW, // TODO: round up to full tile sizes
SCREENH,
1, // Array Size
1, // MIP Levels
D3D11_BIND_SHADER_RESOURCE,
D3D11_USAGE_DEFAULT,
0
);
hr = mpD3dDevice->CreateTexture2D(&cpuRenderTargetDescScalar, NULL, &mpCPURenderTargetScalar[0]);
ASSERT(SUCCEEDED(hr), _L("Failed creating render target."));
hr = mpD3dDevice->CreateTexture2D(&cpuRenderTargetDescScalar, NULL, &mpCPURenderTargetScalar[1]);
ASSERT(SUCCEEDED(hr), _L("Failed creating render target."));
hr = mpD3dDevice->CreateShaderResourceView(mpCPURenderTargetScalar[0], NULL, &mpCPUSRVScalar[0]);
ASSERT(SUCCEEDED(hr), _L("Failed creating shader resource view."));
hr = mpD3dDevice->CreateShaderResourceView(mpCPURenderTargetScalar[1], NULL, &mpCPUSRVScalar[1]);
ASSERT(SUCCEEDED(hr), _L("Failed creating shader resource view."));
// Corresponding texture object
CPUTTextureDX11 *pDummyTex2 = new CPUTTextureDX11;
pDummyTex2->SetTextureAndShaderResourceView(mpCPURenderTargetScalar[0], mpCPUSRVScalar[0]);
pAssetLibrary->AddTexture( _L("$depthbuf_tex_Scalar"), pDummyTex2 );
SAFE_RELEASE(pDummyTex2);
CPUTTextureDX11 *pDummyTex3 = new CPUTTextureDX11;
pDummyTex3->SetTextureAndShaderResourceView(mpCPURenderTargetScalar[1], mpCPUSRVScalar[1]);
pAssetLibrary->AddTexture( _L("$depthbuf_tex_Scalar"), pDummyTex3 );
SAFE_RELEASE(pDummyTex3);
// Create default shaders
CPUTPixelShaderDX11 *pPS = CPUTPixelShaderDX11::CreatePixelShaderFromMemory( _L("$DefaultShader"), CPUT_DX11::mpD3dDevice, _L("PSMain"), _L("ps_4_0"), gpDefaultShaderSource );
CPUTPixelShaderDX11 *pPSNoTex = CPUTPixelShaderDX11::CreatePixelShaderFromMemory( _L("$DefaultShaderNoTexture"), CPUT_DX11::mpD3dDevice, _L("PSMainNoTexture"), _L("ps_4_0"), gpDefaultShaderSource );
CPUTVertexShaderDX11 *pVS = CPUTVertexShaderDX11::CreateVertexShaderFromMemory( _L("$DefaultShader"), CPUT_DX11::mpD3dDevice, _L("VSMain"), _L("vs_4_0"), gpDefaultShaderSource );
CPUTVertexShaderDX11 *pVSNoTex = CPUTVertexShaderDX11::CreateVertexShaderFromMemory( _L("$DefaultShaderNoTexture"), CPUT_DX11::mpD3dDevice, _L("VSMainNoTexture"), _L("vs_4_0"), gpDefaultShaderSource );
// We just want to create them, which adds them to the library. We don't need them any more so release them, leaving refCount at 1 (only library owns a ref)
SAFE_RELEASE(pPS);
SAFE_RELEASE(pPSNoTex);
SAFE_RELEASE(pVS);
SAFE_RELEASE(pVSNoTex);
// load shadow casting material+sprite object
cString ExecutableDirectory;
CPUTOSServices::GetOSServices()->GetExecutableDirectory(&ExecutableDirectory);
pAssetLibrary->SetMediaDirectoryName( ExecutableDirectory+_L("..\\..\\Media\\"));
mpShadowRenderTarget = new CPUTRenderTargetDepth();
mpShadowRenderTarget->CreateRenderTarget( cString(_L("$shadow_depth")), SHADOW_WIDTH_HEIGHT, SHADOW_WIDTH_HEIGHT, DXGI_FORMAT_D32_FLOAT );
mpDebugSprite = new CPUTSprite();
mpDebugSprite->CreateSprite( -1.0f, -1.0f, 0.5f, 0.5f, _L("Sprite") );
int width, height;
CPUTOSServices::GetOSServices()->GetClientDimensions(&width, &height);
// Depth buffer visualization material
mpShowDepthBufMtrlScalar = (CPUTMaterialDX11*)CPUTAssetLibraryDX11::GetAssetLibrary()->GetMaterial( _L("showDepthBufScalar"));
mpShowDepthBufMtrlSSE = (CPUTMaterialDX11*)CPUTAssetLibraryDX11::GetAssetLibrary()->GetMaterial( _L("showDepthBufSSE"));
if(mSOCType == SCALAR_TYPE)
{
mpCPURenderTarget[0] = mpCPURenderTargetScalar[0];
mpCPURenderTarget[1] = mpCPURenderTargetScalar[1];
mpCPUSRV[0] = mpCPUSRVScalar[0];
mpCPUSRV[1] = mpCPUSRVScalar[1];
mpShowDepthBufMtrl = mpShowDepthBufMtrlScalar;
rowPitch = SCREENW * 4;
}
else
{
mpCPURenderTarget[0] = mpCPURenderTargetSSE[0];
mpCPURenderTarget[1] = mpCPURenderTargetSSE[1];
mpCPUSRV[0] = mpCPUSRVSSE[0];
mpCPUSRV[1] = mpCPUSRVSSE[1];
mpShowDepthBufMtrl = mpShowDepthBufMtrlSSE;
rowPitch = 2 * SCREENW * 4;
}
// Call ResizeWindow() because it creates some resources that our blur material needs (e.g., the back buffer)
ResizeWindow(width, height);
CPUTRenderStateBlockDX11 *pBlock = new CPUTRenderStateBlockDX11();
CPUTRenderStateDX11 *pStates = pBlock->GetState();
// Override default sampler desc for our default shadowing sampler
pStates->SamplerDesc[1].Filter = D3D11_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT;
pStates->SamplerDesc[1].AddressU = D3D11_TEXTURE_ADDRESS_BORDER;
pStates->SamplerDesc[1].AddressV = D3D11_TEXTURE_ADDRESS_BORDER;
pStates->SamplerDesc[1].ComparisonFunc = D3D11_COMPARISON_GREATER;
pBlock->CreateNativeResources();
CPUTAssetLibrary::GetAssetLibrary()->AddRenderStateBlock( _L("$DefaultRenderStates"), pBlock );
pBlock->Release(); // We're done with it. The library owns it now.
//
// Load .set files to load the castle scene
//
pAssetLibrary->SetMediaDirectoryName(_L("..\\..\\Media\\Castle\\"));
#ifdef DEBUG
mpAssetSetDBR[0] = pAssetLibrary->GetAssetSet(_L("castleLargeOccluders"));
ASSERT(mpAssetSetDBR[0], _L("Failed loading castle."));
mpAssetSetDBR[1] = pAssetLibrary->GetAssetSet(_L("groundDebug"));
ASSERT(mpAssetSetDBR[1], _L("Failed loading ground."));
mpAssetSetAABB[0] = pAssetLibrary->GetAssetSet(_L("marketStallsDebug"));
ASSERT(mpAssetSetAABB, _L("Failed loading marketStalls"));
mpAssetSetAABB[1] = pAssetLibrary->GetAssetSet(_L("castleSmallDecorationsDebug"));
ASSERT(mpAssetSetAABB, _L("Failed loading castleSmallDecorations"));
#else
mpAssetSetDBR[0] = pAssetLibrary->GetAssetSet(_L("castleLargeOccluders"));
ASSERT(mpAssetSetDBR[0], _L("Failed loading castle."));
mpAssetSetDBR[1] = pAssetLibrary->GetAssetSet(_L("ground"));
ASSERT(mpAssetSetDBR[1], _L("Failed loading ground."));
mpAssetSetAABB[0] = pAssetLibrary->GetAssetSet(_L("marketStalls"));
ASSERT(mpAssetSetAABB, _L("Failed loading marketStalls"));
mpAssetSetAABB[1] = pAssetLibrary->GetAssetSet(_L("castleSmallDecorations"));
ASSERT(mpAssetSetAABB, _L("Failed loading castleSmallDecorations"));
#endif
mpAssetSetSky = pAssetLibrary->GetAssetSet(_L("sky"));
ASSERT(mpAssetSetSky, _L("Failed loading sky"));
// For every occluder model in the sene create a place holder
// for the CPU transformed vertices of the model.
mpDBR->CreateTransformedModels(mpAssetSetDBR, OCCLUDER_SETS);
// Get number of occluders in the scene
mNumOccluders = mpDBR->GetNumOccluders();
// Get number of occluder triangles in the scene
mNumOccluderTris = mpDBR->GetNumTriangles();
// For every occludee model in the scene create a place holder
// for the triangles that make up the model axis aligned bounding box
mpAssetSetAABB[2] = mpAssetSetDBR[0];
mpAssetSetAABB[3] = mpAssetSetDBR[1];
mpAABB->CreateTransformedAABBoxes(mpAssetSetAABB, OCCLUDEE_SETS);
// Get number of occludees in the scene
mNumOccludees = mpAABB->GetNumOccludees();
// Get number of occluddee triangles in the scene
mNumOccludeeTris = mpAABB->GetNumTriangles();
swprintf_s(&string[0], CPUT_MAX_STRING_LENGTH, _L("\tNumber of Models: \t%d"), mNumOccluders);
mpNumOccludersText->SetText(string);
swprintf_s(&string[0], CPUT_MAX_STRING_LENGTH, _L("\tNumber of tris: \t\t%d"), mNumOccluderTris);
mpOccluderTrisText->SetText(string);
swprintf_s(&string[0], CPUT_MAX_STRING_LENGTH, _L("\tNumber of Model: \t%d"), mNumOccludees);
mpNumOccludeesText->SetText(string);
swprintf_s(&string[0], CPUT_MAX_STRING_LENGTH, _L("\tNumber of tris: \t\t%d"), mNumOccludeeTris);
mpOccludeeTrisText->SetText(string);
CPUTCheckboxState state;
if(mEnableCulling)
{
state = CPUT_CHECKBOX_CHECKED;
}
else
{
state = CPUT_CHECKBOX_UNCHECKED;
}
mpCullingCheckBox->SetCheckboxState(state);
if(mEnableFCulling)
{
state = CPUT_CHECKBOX_CHECKED;
}
else
{
state = CPUT_CHECKBOX_UNCHECKED;
}
mpFCullingCheckBox->SetCheckboxState(state);
mpDBR->SetEnableFCulling(mEnableFCulling);
mpAABB->SetEnableFCulling(mEnableFCulling);
if(mViewDepthBuffer)
{
state = CPUT_CHECKBOX_CHECKED;
}
else
{
state = CPUT_CHECKBOX_UNCHECKED;
}
mpDBCheckBox->SetCheckboxState(state);
if(mEnableTasks)
{
state = CPUT_CHECKBOX_CHECKED;
}
else
{
state = CPUT_CHECKBOX_UNCHECKED;
}
mpTasksCheckBox->SetCheckboxState(state);
if(mSyncInterval)
{
state = CPUT_CHECKBOX_CHECKED;
}
else
{
state = CPUT_CHECKBOX_UNCHECKED;
}
mpVsyncCheckBox->SetCheckboxState(state);
if(mPipeline)
{
state = CPUT_CHECKBOX_CHECKED;
}
else
{
state = CPUT_CHECKBOX_UNCHECKED;
}
mpPipelineCheckBox->SetCheckboxState(state);
// Setting occluder size threshold in DepthBufferRasterizer
mpDBR->SetOccluderSizeThreshold(mOccluderSizeThreshold);
// Setting occludee size threshold in AABBoxRasterizer
mpAABB->SetOccludeeSizeThreshold(mOccludeeSizeThreshold);
//
// If no cameras were created from the model sets then create a default simple camera
// and add it to the camera array.
//
if( mpAssetSetDBR[0] && mpAssetSetDBR[0]->GetCameraCount() )
{
mpCamera = mpAssetSetDBR[0]->GetFirstCamera();
mpCamera->AddRef();
} else
{
mpCamera = new CPUTCamera();
CPUTAssetLibraryDX11::GetAssetLibrary()->AddCamera( _L("SampleStart Camera"), mpCamera );
mpCamera->SetPosition( 0.0f, 0.0f, 5.0f );
// Set the projection matrix for all of the cameras to match our window.
// TODO: this should really be a viewport matrix. Otherwise, all cameras will have the same FOV and aspect ratio, etc instead of just viewport dimensions.
mpCamera->SetAspectRatio(((float)width)/((float)height));
}
mpCamera->SetFov(XMConvertToRadians(60.0f)); // TODO: Fix converter's FOV bug (Maya generates cameras for which fbx reports garbage for fov)
mpCamera->SetFarPlaneDistance(gFarClipDistance);
mpCamera->SetPosition(27.0f, 2.0f, 47.0f);
mpCamera->LookAt(41.0f, 8.0f, -50.0f);
mpCamera->Update();
// Set up the shadow camera (a camera that sees what the light sees)
float3 lookAtPoint(0.0f, 0.0f, 0.0f);
float3 half(1.0f, 1.0f, 1.0f);
if( mpAssetSetDBR[0] )
{
mpAssetSetDBR[0]->GetBoundingBox( &lookAtPoint, &half );
}
float length = half.length();
mpShadowCamera = new CPUTCamera();
mpShadowCamera->SetFov(XMConvertToRadians(45));
mpShadowCamera->SetAspectRatio(1.0f);
float fov = mpShadowCamera->GetFov();
float tanHalfFov = tanf(fov * 0.5f);
float cameraDistance = length/tanHalfFov;
float nearDistance = cameraDistance * 0.1f;
mpShadowCamera->SetNearPlaneDistance(nearDistance);
mpShadowCamera->SetFarPlaneDistance(2.0f * cameraDistance);
CPUTAssetLibraryDX11::GetAssetLibrary()->AddCamera( _L("ShadowCamera"), mpShadowCamera );
float3 shadowCameraPosition = lookAtPoint - gLightDir * cameraDistance;
mpShadowCamera->SetPosition( shadowCameraPosition );
mpShadowCamera->LookAt( lookAtPoint.x, lookAtPoint.y, lookAtPoint.z );
mpShadowCamera->Update();
mpCameraController = new CPUTCameraControllerFPS();
mpCameraController->SetCamera(mpCamera);
mpCameraController->SetLookSpeed(0.004f);
mpCameraController->SetMoveSpeed(2.5f);
gLightDir = float3(-40.48f, -142.493f, -3.348f);
gLightDir = gLightDir.normalize();
QueryPerformanceFrequency(&glFrequency);
}
bool Framework::Init( HINSTANCE hInstance, HWND hWindow, const LaunchInfo& launchInfo )
{
RECT rect;
if (GetClientRect(hWindow, &rect) == FALSE)
{
OutputDebugString(L"Failed to extract the initial window size");
return false;
}
unsigned int width = rect.right - rect.left;
unsigned int height = rect.bottom - rect.top;
PIXELFORMATDESCRIPTOR pfd =
{
sizeof(PIXELFORMATDESCRIPTOR),
1,
PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER, //Flags
PFD_TYPE_RGBA, //The kind of framebuffer. RGBA or palette.
32, //Colordepth of the framebuffer.
0, 0, 0, 0, 0, 0,
0,
0,
0,
0, 0, 0, 0,
24, //Number of bits for the depthbuffer
8, //Number of bits for the stencilbuffer
0, //Number of Aux buffers in the framebuffer.
PFD_MAIN_PLANE,
0,
0, 0, 0
};
m_WindowHandleToDeviceContext = GetDC(hWindow);
if (m_WindowHandleToDeviceContext == NULL)
{
return false;
}
int letWindowsChooseThisPixelFormat = ChoosePixelFormat(m_WindowHandleToDeviceContext, &pfd);
if (letWindowsChooseThisPixelFormat == 0)
{
return false;
}
if (SetPixelFormat(m_WindowHandleToDeviceContext, letWindowsChooseThisPixelFormat, &pfd) == FALSE)
{
return false;
}
HGLRC ourOpenGLRenderingContext = wglCreateContext(m_WindowHandleToDeviceContext);
if (ourOpenGLRenderingContext == NULL)
{
return false;
}
if (wglMakeCurrent(m_WindowHandleToDeviceContext, ourOpenGLRenderingContext) == FALSE)
{
return false;
}
// Initialize the OpenGL functions we will be using
// This must be called after we make our OpenGL rendering context above
OpenGLInterface::Initialize();
m_CameraManager = new CameraManager();
m_CameraPosition = m_PlayerPosition = glm::vec3();
m_PlayerRotationDegrees = 0.0f;
m_CameraOrientation = glm::vec3(0,0,1);
m_PlayerOrientation = glm::vec4( 0, 0, 1, 1 );
//m_CameraPosition = Vector3(0, 0, 100);
m_CameraPosition = glm::vec3( 0.0f, 30.f, 0.0f );
m_CameraTargetPitch = m_CameraCurrentPitch = 0.0f;
m_CameraTargetYaw = 0.0f;
m_CameraCurrentYaw = 0.0f;
m_FOVX = 45.0f;
assert(m_pInput == NULL);
m_pInput = new Input();
assert(m_pInput != NULL);
if (m_pInput->Init() == false)
{
return false;
}
// Initialize the stats related variables
m_OldFrameTime = timeGetTime();
m_OneSecondIntervalAccumulator = 0;
m_UpdateAccumulator = 0;
m_CurrentFPS = 0;
ResizeWindow(width, height);
m_Landscape.Initialize();
m_Loki.Load( "Media/Objects/capsule.sbm" );
//m_Loki.Load( "Media/Objects/dragon.sbm" );
// Initialize the 2D text system
m_Text2D.init( 128, 50 );
glm::vec3 cameraOffset( 35, 15, 0 );
CameraManager::CameraId followCamera = m_CameraManager->AddCamera( CameraManager::FOLLOW, "Follow" );
m_CameraManager->SetCameraTarget( followCamera, &m_Loki );
m_CameraManager->SetCameraPosition( followCamera, m_PlayerPosition + glm::vec3( cameraOffset.x, cameraOffset.y, 0 ) );
m_CameraManager->SetCameraOffset( followCamera, cameraOffset );
return true;
}
BOOL CALLBACK Main_DialogProc (HWND hDlg, UINT msg, WPARAM wp, LPARAM lp)
{
if (msg == WM_INITDIALOG)
{
g.hMain = hDlg;
AfsAppLib_SetMainWindow (g.hMain);
}
switch (msg)
{
case WM_INITDIALOG:
Main_OnInitDialog (hDlg);
break;
case WM_SHOW_YOURSELF:
if (lp || g.idCell)
{
ShowWindow (g.hMain, SW_SHOW);
SetForegroundWindow (g.hMain);
Actions_WindowToTop (TRUE);
}
break;
case WM_SHOW_ACTIONS:
if (gr.fShowActions)
Actions_OpenWindow();
break;
case WM_ACTIVATEAPP:
Actions_WindowToTop ((wp) ? TRUE : FALSE);
if (wp)
StartTask (taskEXPIRED_CREDS);
break;
case WM_EXPIRED_CREDENTIALS:
case WM_REFRESHED_CREDENTIALS:
g.hCreds = (UINT_PTR)lp;
StartTask (taskUPD_CREDS);
break;
case WM_SIZE:
// if (lp==0), we're minimizing--don't call ResizeWindow().
//
if (lp != 0)
ResizeWindow (hDlg, awdMain, rwaFixupGuts);
break;
case WM_ENDTASK:
LPTASKPACKET ptp;
if ((ptp = (LPTASKPACKET)lp) != NULL)
{
if (ptp->idTask == taskUPD_USERS)
Display_OnEndTask_UpdUsers (ptp);
else if (ptp->idTask == taskUPD_GROUPS)
Display_OnEndTask_UpdGroups (ptp);
else if (ptp->idTask == taskUPD_MACHINES)
Display_OnEndTask_UpdMachines (ptp);
FreeTaskPacket (ptp);
}
break;
case WM_ASC_NOTIFY_ACTION:
Actions_OnNotify (wp, lp);
break;
case WM_COMMAND:
switch (LOWORD(wp))
{
case IDCANCEL:
Quit (0);
break;
default:
OnContextCommand (LOWORD(wp));
break;
}
break;
case WM_NOTIFY:
switch (((LPNMHDR)lp)->code)
{
case TCN_SELCHANGE:
Main_PrepareTabChild();
break;
}
break;
case WM_HELP:
if ((lp == 0) || (IsAncestor (g.hMain, (HWND)(((LPHELPINFO)lp)->hItemHandle))))
{
WinHelp (hDlg, cszHELPFILENAME, HELP_FINDER, 0);
}
break;
}
return FALSE;
}
OBS::OBS()
{
App = this;
__cpuid(cpuInfo, 1);
bSSE2Available = (cpuInfo[3] & (1<<26)) != 0;
hSceneMutex = OSCreateMutex();
hAuxAudioMutex = OSCreateMutex();
monitors.Clear();
EnumDisplayMonitors(NULL, NULL, (MONITORENUMPROC)MonitorInfoEnumProc, (LPARAM)&monitors);
INITCOMMONCONTROLSEX ecce;
ecce.dwSize = sizeof(ecce);
ecce.dwICC = ICC_STANDARD_CLASSES;
if(!InitCommonControlsEx(&ecce))
CrashError(TEXT("Could not initalize common shell controls"));
InitHotkeyExControl(hinstMain);
InitColorControl(hinstMain);
InitVolumeControl();
InitVolumeMeter();
//-----------------------------------------------------
// load locale
if(!locale->LoadStringFile(TEXT("locale/en.txt")))
AppWarning(TEXT("Could not open locale string file '%s'"), TEXT("locale/en.txt"));
strLanguage = GlobalConfig->GetString(TEXT("General"), TEXT("Language"), TEXT("en"));
if(!strLanguage.CompareI(TEXT("en")))
{
String langFile;
langFile << TEXT("locale/") << strLanguage << TEXT(".txt");
if(!locale->LoadStringFile(langFile))
AppWarning(TEXT("Could not open locale string file '%s'"), langFile.Array());
}
//-----------------------------------------------------
// load classes
RegisterSceneClass(TEXT("Scene"), Str("Scene"), (OBSCREATEPROC)CreateNormalScene, NULL);
RegisterImageSourceClass(TEXT("DesktopImageSource"), Str("Sources.SoftwareCaptureSource"), (OBSCREATEPROC)CreateDesktopSource, (OBSCONFIGPROC)ConfigureDesktopSource);
RegisterImageSourceClass(TEXT("BitmapImageSource"), Str("Sources.BitmapSource"), (OBSCREATEPROC)CreateBitmapSource, (OBSCONFIGPROC)ConfigureBitmapSource);
RegisterImageSourceClass(TEXT("BitmapTransitionSource"), Str("Sources.TransitionSource"), (OBSCREATEPROC)CreateBitmapTransitionSource, (OBSCONFIGPROC)ConfigureBitmapTransitionSource);
RegisterImageSourceClass(TEXT("GlobalSource"), Str("Sources.GlobalSource"), (OBSCREATEPROC)CreateGlobalSource, (OBSCONFIGPROC)OBS::ConfigGlobalSource);
RegisterImageSourceClass(TEXT("TextSource"), Str("Sources.TextSource"), (OBSCREATEPROC)CreateTextSource, (OBSCONFIGPROC)ConfigureTextSource);
//-----------------------------------------------------
// render frame class
WNDCLASS wc;
zero(&wc, sizeof(wc));
wc.hInstance = hinstMain;
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.lpszClassName = OBS_RENDERFRAME_CLASS;
wc.lpfnWndProc = (WNDPROC)OBS::RenderFrameProc;
wc.hbrBackground = (HBRUSH)GetStockObject(GRAY_BRUSH);
if(!RegisterClass(&wc))
CrashError(TEXT("Could not register render frame class"));
//-----------------------------------------------------
// main window class
wc.lpszClassName = OBS_WINDOW_CLASS;
wc.lpfnWndProc = (WNDPROC)OBSProc;
wc.hIcon = LoadIcon(hinstMain, MAKEINTRESOURCE(IDI_ICON1));
wc.hbrBackground = (HBRUSH)COLOR_WINDOW;
wc.lpszMenuName = MAKEINTRESOURCE(IDR_MAINMENU);
if(!RegisterClass(&wc))
CrashError(TEXT("Could not register main window class"));
//-----------------------------------------------------
// create main window
int fullscreenX = GetSystemMetrics(SM_CXFULLSCREEN);
int fullscreenY = GetSystemMetrics(SM_CYFULLSCREEN);
borderXSize = borderYSize = 0;
borderXSize += GetSystemMetrics(SM_CXSIZEFRAME)*2;
borderYSize += GetSystemMetrics(SM_CYSIZEFRAME)*2;
borderYSize += GetSystemMetrics(SM_CYMENU);
borderYSize += GetSystemMetrics(SM_CYCAPTION);
clientWidth = GlobalConfig->GetInt(TEXT("General"), TEXT("Width"), 700);
clientHeight = GlobalConfig->GetInt(TEXT("General"), TEXT("Height"), 553);
if(clientWidth < minClientWidth)
clientWidth = minClientWidth;
if(clientHeight < minClientHeight)
clientHeight = minClientHeight;
int maxCX = fullscreenX-borderXSize;
int maxCY = fullscreenY-borderYSize;
if(clientWidth > maxCX)
clientWidth = maxCX;
if(clientHeight > maxCY)
clientHeight = maxCY;
int cx = clientWidth + borderXSize;
int cy = clientHeight + borderYSize;
int x = (fullscreenX/2)-(cx/2);
int y = (fullscreenY/2)-(cy/2);
int posX = GlobalConfig->GetInt(TEXT("General"), TEXT("PosX"));
int posY = GlobalConfig->GetInt(TEXT("General"), TEXT("PosY"));
bool bInsideMonitors = false;
if(posX || posY)
{
for(UINT i=0; i<monitors.Num(); i++)
{
if( posX >= monitors[i].rect.left && posX < monitors[i].rect.right &&
posY >= monitors[i].rect.top && posY < monitors[i].rect.bottom )
{
bInsideMonitors = true;
break;
}
}
}
if(bInsideMonitors)
{
x = posX;
y = posY;
}
hwndMain = CreateWindowEx(WS_EX_CONTROLPARENT|WS_EX_WINDOWEDGE, OBS_WINDOW_CLASS, OBS_VERSION_STRING,
WS_OVERLAPPED | WS_THICKFRAME | WS_MINIMIZEBOX | WS_CAPTION | WS_SYSMENU | WS_CLIPCHILDREN,
x, y, cx, cy, NULL, NULL, hinstMain, NULL);
if(!hwndMain)
CrashError(TEXT("Could not create main window"));
HMENU hMenu = GetMenu(hwndMain);
LocalizeMenu(hMenu);
//-----------------------------------------------------
// render frame
hwndRenderFrame = CreateWindow(OBS_RENDERFRAME_CLASS, NULL, WS_CHILDWINDOW|WS_VISIBLE,
0, 0, 0, 0,
hwndMain, NULL, hinstMain, NULL);
if(!hwndRenderFrame)
CrashError(TEXT("Could not create render frame"));
//-----------------------------------------------------
// scenes listbox
HWND hwndTemp;
hwndTemp = CreateWindowEx(WS_EX_CLIENTEDGE, TEXT("LISTBOX"), NULL,
WS_CHILDWINDOW|WS_VISIBLE|WS_TABSTOP|LBS_HASSTRINGS|WS_VSCROLL|LBS_NOTIFY|LBS_NOINTEGRALHEIGHT|WS_CLIPSIBLINGS,
0, 0, 0, 0, hwndMain, (HMENU)ID_SCENES, 0, 0);
SendMessage(hwndTemp, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), TRUE);
listboxProc = (WNDPROC)GetWindowLongPtr(hwndTemp, GWLP_WNDPROC);
SetWindowLongPtr(hwndTemp, GWLP_WNDPROC, (LONG_PTR)OBS::ListboxHook);
//-----------------------------------------------------
// elements listview
hwndTemp = CreateWindowEx(WS_EX_CLIENTEDGE, WC_LISTVIEW, NULL,
WS_CHILDWINDOW|WS_VISIBLE|WS_TABSTOP|WS_VSCROLL|WS_CLIPSIBLINGS|LVS_REPORT|LVS_NOCOLUMNHEADER|
LVS_SHOWSELALWAYS | LVS_ALIGNLEFT | LVS_NOLABELWRAP,
0, 0, 0, 0, hwndMain, (HMENU)ID_SOURCES, 0, 0);
SendMessage(hwndTemp, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), TRUE);
ListView_SetExtendedListViewStyle(hwndTemp, LVS_EX_CHECKBOXES | LVS_EX_FULLROWSELECT | LVS_EX_DOUBLEBUFFER);
//add single column needed for report style
LVCOLUMN column;
column.mask = LVCF_TEXT;
column.fmt = LVCFMT_FIXED_WIDTH;
column.cx = 0;
column.pszText = TEXT("");
ListView_InsertColumn(hwndTemp, 0, &column);
ListView_InsertColumn(hwndTemp, 1, &column);
listviewProc = (WNDPROC)GetWindowLongPtr(hwndTemp, GWLP_WNDPROC);
SetWindowLongPtr(hwndTemp, GWLP_WNDPROC, (LONG_PTR)OBS::ListboxHook);
HWND hwndSources = hwndTemp;
//-----------------------------------------------------
// status control
hwndTemp = CreateWindowEx(0, STATUSCLASSNAME, NULL,
WS_CHILD|WS_VISIBLE|SBARS_SIZEGRIP|WS_CLIPSIBLINGS,
0, 0, 0, 0, hwndMain, (HMENU)ID_STATUS, 0, 0);
SendMessage(hwndTemp, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), TRUE);
//-----------------------------------------------------
// mic volume control
hwndTemp = CreateWindow(VOLUME_CONTROL_CLASS, NULL,
WS_CHILDWINDOW|WS_VISIBLE|WS_CLIPSIBLINGS,
0, 0, 0, 0, hwndMain, (HMENU)ID_MICVOLUME, 0, 0);
SetVolumeControlIcons(hwndTemp, GetIcon(hinstMain, IDI_SOUND_MIC), GetIcon(hinstMain, IDI_SOUND_MIC_MUTED));
//-----------------------------------------------------
// mic volume meter
hwndTemp = CreateWindow(VOLUME_METER_CLASS, NULL,
WS_CHILDWINDOW|WS_VISIBLE|WS_CLIPSIBLINGS,
0, 0, 0, 0, hwndMain, (HMENU)ID_MICVOLUMEMETER, 0, 0);
//-----------------------------------------------------
// desktop volume meter
hwndTemp = CreateWindow(VOLUME_METER_CLASS, NULL,
WS_CHILDWINDOW|WS_VISIBLE|WS_CLIPSIBLINGS,
0, 0, 0, 0, hwndMain, (HMENU)ID_DESKTOPVOLUMEMETER, 0, 0);
//-----------------------------------------------------
// desktop volume control
hwndTemp = CreateWindow(VOLUME_CONTROL_CLASS, NULL,
WS_CHILDWINDOW|WS_VISIBLE|WS_CLIPSIBLINGS,
0, 0, 0, 0, hwndMain, (HMENU)ID_DESKTOPVOLUME, 0, 0);
SetVolumeControlIcons(hwndTemp, GetIcon(hinstMain, IDI_SOUND_DESKTOP), GetIcon(hinstMain, IDI_SOUND_DESKTOP_MUTED));
//-----------------------------------------------------
// settings button
hwndTemp = CreateWindow(TEXT("BUTTON"), Str("Settings"),
WS_CHILDWINDOW|WS_VISIBLE|WS_TABSTOP|BS_TEXT|BS_PUSHBUTTON|WS_CLIPSIBLINGS,
0, 0, 0, 0, hwndMain, (HMENU)ID_SETTINGS, 0, 0);
SendMessage(hwndTemp, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), TRUE);
//-----------------------------------------------------
// start/stop stream button
hwndTemp = CreateWindow(TEXT("BUTTON"), Str("MainWindow.StartStream"),
WS_CHILDWINDOW|WS_VISIBLE|WS_TABSTOP|BS_TEXT|BS_PUSHBUTTON|WS_CLIPSIBLINGS,
0, 0, 0, 0, hwndMain, (HMENU)ID_STARTSTOP, 0, 0);
SendMessage(hwndTemp, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), TRUE);
//-----------------------------------------------------
// edit scene button
hwndTemp = CreateWindow(TEXT("BUTTON"), Str("MainWindow.SceneEditor"),
WS_CHILDWINDOW|WS_VISIBLE|WS_TABSTOP|BS_TEXT|BS_AUTOCHECKBOX|BS_PUSHLIKE|WS_DISABLED|WS_CLIPSIBLINGS,
0, 0, 0, 0, hwndMain, (HMENU)ID_SCENEEDITOR, 0, 0);
SendMessage(hwndTemp, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), TRUE);
//-----------------------------------------------------
// global sources button
hwndTemp = CreateWindow(TEXT("BUTTON"), Str("GlobalSources"),
WS_CHILDWINDOW|WS_VISIBLE|WS_TABSTOP|BS_TEXT|BS_PUSHBUTTON|WS_CLIPSIBLINGS,
0, 0, 0, 0, hwndMain, (HMENU)ID_GLOBALSOURCES, 0, 0);
SendMessage(hwndTemp, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), TRUE);
//-----------------------------------------------------
// test stream button
hwndTemp = CreateWindow(TEXT("BUTTON"), Str("MainWindow.TestStream"),
WS_CHILDWINDOW|WS_VISIBLE|WS_TABSTOP|BS_TEXT|BS_PUSHBUTTON|WS_CLIPSIBLINGS,
0, 0, 0, 0, hwndMain, (HMENU)ID_TESTSTREAM, 0, 0);
SendMessage(hwndTemp, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), TRUE);
//-----------------------------------------------------
// plugins button
hwndTemp = CreateWindow(TEXT("BUTTON"), Str("MainWindow.Plugins"),
WS_CHILDWINDOW|WS_VISIBLE|WS_TABSTOP|BS_TEXT|BS_PUSHBUTTON|WS_CLIPSIBLINGS,
0, 0, 0, 0, hwndMain, (HMENU)ID_PLUGINS, 0, 0);
SendMessage(hwndTemp, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), TRUE);
//-----------------------------------------------------
// dashboard button
hwndTemp = CreateWindow(TEXT("BUTTON"), Str("MainWindow.Dashboard"),
WS_CHILDWINDOW|WS_VISIBLE|WS_TABSTOP|BS_TEXT|BS_PUSHBUTTON|WS_CLIPSIBLINGS,
0, 0, 0, 0, hwndMain, (HMENU)ID_DASHBOARD, 0, 0);
SendMessage(hwndTemp, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), TRUE);
//-----------------------------------------------------
// exit button
hwndTemp = CreateWindow(TEXT("BUTTON"), Str("MainWindow.Exit"),
WS_CHILDWINDOW|WS_VISIBLE|WS_TABSTOP|BS_TEXT|BS_PUSHBUTTON|WS_CLIPSIBLINGS,
0, 0, 0, 0, hwndMain, (HMENU)ID_EXIT, 0, 0);
SendMessage(hwndTemp, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), TRUE);
//-----------------------------------------------------
// scenes text
hwndTemp = CreateWindow(TEXT("STATIC"), Str("MainWindow.Scenes"),
WS_CHILDWINDOW|WS_VISIBLE|WS_CLIPSIBLINGS,
0, 0, 0, 0, hwndMain, (HMENU)ID_SCENES_TEXT, 0, 0);
SendMessage(hwndTemp, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), TRUE);
//-----------------------------------------------------
// scenes text
hwndTemp = CreateWindow(TEXT("STATIC"), Str("MainWindow.Sources"),
WS_CHILDWINDOW|WS_VISIBLE|WS_CLIPSIBLINGS,
0, 0, 0, 0, hwndMain, (HMENU)ID_SOURCES_TEXT, 0, 0);
SendMessage(hwndTemp, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), TRUE);
//-----------------------------------------------------
// populate scenes
hwndTemp = GetDlgItem(hwndMain, ID_SCENES);
String strScenesConfig;
strScenesConfig << lpAppDataPath << TEXT("\\scenes.xconfig");
if(!scenesConfig.Open(strScenesConfig))
CrashError(TEXT("Could not open '%s'"), strScenesConfig);
XElement *scenes = scenesConfig.GetElement(TEXT("scenes"));
if(!scenes)
scenes = scenesConfig.CreateElement(TEXT("scenes"));
UINT numScenes = scenes->NumElements();
if(!numScenes)
{
XElement *scene = scenes->CreateElement(Str("Scene"));
scene->SetString(TEXT("class"), TEXT("Scene"));
numScenes++;
}
for(UINT i=0; i<numScenes; i++)
{
XElement *scene = scenes->GetElementByID(i);
scene->SetString(TEXT("class"), TEXT("Scene"));
SendMessage(hwndTemp, LB_ADDSTRING, 0, (LPARAM)scene->GetName());
}
//-----------------------------------------------------
// populate sources
if(numScenes)
{
String strScene = AppConfig->GetString(TEXT("General"), TEXT("CurrentScene"));
int id = (int)SendMessage(hwndTemp, LB_FINDSTRINGEXACT, -1, 0);
if(id == LB_ERR)
id = 0;
SendMessage(hwndTemp, LB_SETCURSEL, (WPARAM)id, 0);
SendMessage(hwndMain, WM_COMMAND, MAKEWPARAM(ID_SCENES, LBN_SELCHANGE), (LPARAM)GetDlgItem(hwndMain, ID_SCENES));
}
//-----------------------------------------------------
hHotkeyMutex = OSCreateMutex();
hInfoMutex = OSCreateMutex();
hStartupShutdownMutex = OSCreateMutex();
//-----------------------------------------------------
API = CreateOBSApiInterface();
ResizeWindow(false);
ShowWindow(hwndMain, SW_SHOW);
// make sure sources listview column widths are as expected after obs window is shown
ListView_SetColumnWidth(hwndSources,0,LVSCW_AUTOSIZE_USEHEADER);
ListView_SetColumnWidth(hwndSources,1,LVSCW_AUTOSIZE_USEHEADER);
//-----------------------------------------------------
for(UINT i=0; i<numScenes; i++)
{
XElement *scene = scenes->GetElementByID(i);
DWORD hotkey = scene->GetInt(TEXT("hotkey"));
if(hotkey)
{
SceneHotkeyInfo hotkeyInfo;
hotkeyInfo.hotkey = hotkey;
hotkeyInfo.scene = scene;
hotkeyInfo.hotkeyID = API->CreateHotkey(hotkey, SceneHotkey, 0);
if(hotkeyInfo.hotkeyID)
sceneHotkeys << hotkeyInfo;
}
}
//-----------------------------------------------------
// load plugins
OSFindData ofd;
HANDLE hFind = OSFindFirstFile(TEXT("plugins/*.dll"), ofd);
if(hFind)
{
do
{
if(!ofd.bDirectory) //why would someone give a directory a .dll extension in the first place? pranksters.
{
String strLocation;
strLocation << TEXT("plugins/") << ofd.fileName;
HMODULE hPlugin = LoadLibrary(strLocation);
if(hPlugin)
{
LOADPLUGINPROC loadPlugin = (LOADPLUGINPROC)GetProcAddress(hPlugin, "LoadPlugin");
if(loadPlugin && loadPlugin())
{
PluginInfo *pluginInfo = plugins.CreateNew();
pluginInfo->hModule = hPlugin;
pluginInfo->strFile = ofd.fileName;
GETPLUGINNAMEPROC getName = (GETPLUGINNAMEPROC)GetProcAddress(hPlugin, "GetPluginName");
CTSTR lpName;
if(getName)
lpName = getName();
else
lpName = TEXT("<unknown>");
//FIXME: log this somewhere else, it comes before the OBS version info and looks weird.
//Log(TEXT("Loaded plugin '%s', %s"), lpName, strLocation);
}
else
{
Log(TEXT("Failed to initialize plugin %s"), strLocation);
FreeLibrary(hPlugin);
}
}
else
{
Log(TEXT("Failed to load plugin %s, %d"), strLocation, GetLastError());
}
}
} while (OSFindNextFile(hFind, ofd));
OSFindClose(hFind);
}
//-----------------------------------------------------
ReloadIniSettings();
ResetProfileMenu();
//-----------------------------------------------------
bAutoReconnect = AppConfig->GetInt(TEXT("Publish"), TEXT("AutoReconnect"), 1) != 0;
reconnectTimeout = AppConfig->GetInt(TEXT("Publish"), TEXT("AutoReconnectTimeout"), 10);
if(reconnectTimeout < 5)
reconnectTimeout = 5;
hHotkeyThread = OSCreateThread((XTHREAD)HotkeyThread, NULL);
#ifndef OBS_DISABLE_AUTOUPDATE
ULARGE_INTEGER lastUpdateTime;
ULARGE_INTEGER currentTime;
FILETIME systemTime;
lastUpdateTime.QuadPart = GlobalConfig->GetInt(TEXT("General"), TEXT("LastUpdateCheck"), 0);
GetSystemTimeAsFileTime(&systemTime);
currentTime.LowPart = systemTime.dwLowDateTime;
currentTime.HighPart = systemTime.dwHighDateTime;
//OBS doesn't support 64 bit ints in the config file, so we have to normalize it to a 32 bit int
currentTime.QuadPart /= 10000000;
currentTime.QuadPart -= 13000000000;
if (currentTime.QuadPart - lastUpdateTime.QuadPart >= 3600)
{
GlobalConfig->SetInt(TEXT("General"), TEXT("LastUpdateCheck"), (int)currentTime.QuadPart);
OSCloseThread(OSCreateThread((XTHREAD)CheckUpdateThread, NULL));
}
#endif
bRenderViewEnabled = true;
if(GlobalConfig->GetInt(TEXT("General"), TEXT("ShowWebrootWarning"), TRUE) && IsWebrootLoaded())
MessageBox(hwndMain, TEXT("Webroot Secureanywhere appears to be active. This product will cause problems with OBS as the security features block OBS from accessing Windows GDI functions. It is highly recommended that you disable Secureanywhere and restart OBS.\r\n\r\nOf course you can always just ignore this message if you want, but it may prevent you from being able to stream certain things. Please do not report any bugs you may encounter if you leave Secureanywhere enabled."), TEXT("Just a slight issue you might want to be aware of"), MB_OK);
}
BOOL CALLBACK Aggregates_DlgProc (HWND hDlg, UINT msg, WPARAM wp, LPARAM lp)
{
if (HandleColumnNotify (hDlg, msg, wp, lp, &gr.viewAgg))
return FALSE;
switch (msg)
{
case WM_INITDIALOG:
{
RECT rTab;
GetClientRect (GetParent(hDlg), &rTab);
TabCtrl_AdjustRect (GetParent (hDlg), FALSE, &rTab);
ResizeWindow (hDlg, awdAggregates, rwaMoveToHere, &rTab);
FL_RestoreView (GetDlgItem (hDlg, IDC_AGG_LIST), &gr.viewAgg);
FastList_SetTextCallback (GetDlgItem (hDlg, IDC_AGG_LIST), GetItemText, &gr.viewAgg);
Aggregates_SubclassList (hDlg);
}
break;
case WM_HELP:
WinHelp (hDlg, cszHELPFILENAME, HELP_FINDER, 0);
break;
case WM_DESTROY:
DontNotifyMeEver (hDlg);
FL_StoreView (GetDlgItem (hDlg, IDC_AGG_LIST), &gr.viewAgg);
break;
case WM_SIZE:
// if (lp==0), we're minimizing--don't call ResizeWindow().
//
if (lp != 0)
ResizeWindow (hDlg, awdAggregates, rwaFixupGuts);
break;
case WM_SERVER_CHANGED:
{
LPIDENT lpiServer = Server_GetServerForChild (hDlg);
DontNotifyMeEver (hDlg);
NotifyMe (WHEN_AGGS_CHANGE, lpiServer, hDlg, 0);
// Fix the text at the top of the Aggregates tab:
//
TCHAR szName[ cchRESOURCE ];
LPTSTR pszText;
if (lpiServer != NULL)
{
LPSERVER_PREF lpsp = (LPSERVER_PREF)lpiServer->GetUserParam();
lpiServer->GetServerName (szName);
if (lpsp && !lpsp->fIsMonitored)
pszText = FormatString (IDS_AGGREGATE_UNMON, TEXT("%s"), szName);
else
pszText = FormatString (IDS_AGGREGATES_IN_SERVER, TEXT("%s"), szName);
}
else if (g.lpiCell != NULL)
{
g.lpiCell->GetCellName (szName);
if (g.sub)
pszText = FormatString (IDS_AGGREGATE_SOME, TEXT("%s"), szName);
else
pszText = FormatString (IDS_AGGREGATES_IN_CELL, TEXT("%s"), szName);
}
else
{
pszText = FormatString (IDS_AGGREGATES_IN_NOTHING);
}
SetDlgItemText (hDlg, IDC_AGG_DESC, pszText);
FreeString (pszText);
UpdateDisplay_Aggregates (FALSE, GetDlgItem (hDlg, IDC_AGG_LIST), NULL, 0, NULL, NULL, NULL);
}
break;
case WM_NOTIFY_FROM_DISPATCH:
Aggregates_OnNotifyFromDispatch ((LPNOTIFYSTRUCT)lp);
Delete ((LPNOTIFYSTRUCT)lp);
break;
case WM_NOTIFY:
switch (((LPNMHDR)lp)->code)
{
case FLN_LDBLCLICK:
if (((LPNMHDR)lp)->hwndFrom == GetDlgItem (hDlg, IDC_AGG_LIST))
{
if (FL_GetSelectedData (GetDlgItem (hDlg, IDC_AGG_LIST)))
PostMessage (GetDlgItem (hDlg, IDC_AGG_LIST), WM_COMMAND, M_PROPERTIES, 0);
return TRUE;
}
break;
}
break;
case WM_CONTEXTMENU:
{
POINT ptScreen;
POINT ptClient;
ptScreen.x = LOWORD(lp);
ptScreen.y = HIWORD(lp);
ptClient = ptScreen;
ScreenToClient ((HWND)wp, &ptClient);
if ((HWND)wp == GetDlgItem (hDlg, IDC_AGG_LIST))
Aggregates_ShowPopupMenu ((HWND)wp, ptClient, ptScreen);
}
break;
case WM_COMMAND:
switch (LOWORD(wp))
{
case IDC_AGG_CREATESET:
SendMessage (GetDlgItem (hDlg, IDC_AGG_LIST), WM_COMMAND, M_SET_CREATE, 0);
break;
}
break;
}
return FALSE;
}
// Create a window context
//-----------------------------------------------------------------------------
CPUTResult CPUT_DX11::CPUTCreateWindowAndContext(const cString WindowTitle, CPUTWindowCreationParams windowParams)
{
CPUTResult result = CPUT_SUCCESS;
HEAPCHECK;
// create the window
result = MakeWindow(WindowTitle, windowParams.windowWidth, windowParams.windowHeight, windowParams.windowPositionX, windowParams.windowPositionY);
if(CPUTFAILED(result))
{
return result;
}
HEAPCHECK;
// create the DX context
result = CreateDXContext(windowParams);
if(CPUTFAILED(result))
{
return result;
}
HEAPCHECK;
#define ENABLE_GUI
#ifdef ENABLE_GUI
// initialize the gui controller
// Use the ResourceDirectory that was given during the Initialize() function
// to locate the GUI+font resources
CPUTGuiControllerDX11 *pGUIController = CPUTGuiControllerDX11::GetController();
cString ResourceDirectory = GetCPUTResourceDirectory();
result = pGUIController->Initialize(mpContext, ResourceDirectory);
if(CPUTFAILED(result))
{
return result;
}
// register the callback object for GUI events as our sample
CPUTGuiControllerDX11::GetController()->SetCallback(this);
#endif
HEAPCHECK;
DrawLoadingFrame();
HEAPCHECK;
// warn the user they are using the software rasterizer
if((D3D_DRIVER_TYPE_REFERENCE == mdriverType) || (D3D_DRIVER_TYPE_WARP == mdriverType))
{
CPUTOSServices::GetOSServices()->OpenMessageBox(_L("Performance warning"), _L("Your graphics hardware does not support the DirectX features required by this sample. The sample is now running using the DirectX software rasterizer."));
}
// trigger a post-create user callback event
HEAPCHECK;
Create();
HEAPCHECK;
//
// Start the timer after everything is initialized and assets have been loaded
//
mpTimer->StartTimer();
// if someone triggers the shutdown routine in on-create, exit
if(mbShutdown)
{
return result;
}
// fill first frame with clear values so render order later is ok
const float srgbClearColor[] = { 0.0993f, 0.0993f, 0.0993f, 1.0f };
mpContext->ClearRenderTargetView( mpBackBufferRTV, srgbClearColor );
mpContext->ClearDepthStencilView(mpDepthStencilView, D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 0.0f, 0);
// trigger a 'resize' event
int x,y,width,height;
CPUTOSServices::GetOSServices()->GetClientDimensions(&x, &y, &width, &height);
ResizeWindow(width,height);
return result;
}
void WINDOW_SDL::ChangeDisplay(
int width, int height,
int bpp, int dbpp,
bool fullscreen,
unsigned int antialiasing,
std::ostream & info_output,
std::ostream & error_output)
{
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, dbpp);
fsaa = 1;
if (antialiasing > 1)
{
fsaa = antialiasing;
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, fsaa);
info_output << "Enabling antialiasing: " << fsaa << "X" << std::endl;
}
else
{
info_output << "Disabling antialiasing" << std::endl;
}
#if SDL_VERSION_ATLEAST(2,0,0)
SDL_DisplayMode desktop_mode;
int display = GetVideoDisplay();
SDL_GetDesktopDisplayMode(display, &desktop_mode);
if (width == 0)
width = desktop_mode.w;
if (height == 0)
height = desktop_mode.h;
if (bpp == 0)
bpp = SDL_BITSPERPIXEL(desktop_mode.format);
// Try to resize the existing window and surface
if (!fullscreen && ResizeWindow(width, height))
return;
if (glcontext)
{
SDL_GL_DeleteContext(glcontext);
glcontext = NULL;
}
if (window)
{
SDL_DestroyWindow(window);
}
// Create a new window
Uint32 window_flags = SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL;
if (fullscreen)
window_flags |= SDL_WINDOW_FULLSCREEN;
window = SDL_CreateWindow(NULL,
SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
width, height, window_flags);
if (!window)
{
assert(0);
}
glcontext = SDL_GL_CreateContext(window);
if (!glcontext)
{
assert(0);
}
if (SDL_GL_MakeCurrent(window, glcontext) < 0)
{
assert(0);
}
#else
const SDL_VideoInfo *videoInfo = SDL_GetVideoInfo();
if (!videoInfo)
{
error_output << "SDL video query failed: " << SDL_GetError() << std::endl;
assert (0);
}
int videoFlags = SDL_OPENGL | SDL_GL_DOUBLEBUFFER | SDL_HWPALETTE;
if (fullscreen)
videoFlags |= (SDL_HWSURFACE | SDL_ANYFORMAT | SDL_FULLSCREEN);
else
videoFlags |= (SDL_SWSURFACE | SDL_ANYFORMAT);
if (surface != NULL)
{
SDL_FreeSurface(surface);
surface = NULL;
}
surface = SDL_SetVideoMode(width, height, bpp, videoFlags);
if (!surface)
{
error_output << "Display change failed: " << width << "x" << height << "x" << bpp << " " << dbpp << "z fullscreen=" << fullscreen << std::endl << "Error: " << SDL_GetError() << std::endl;
assert (0);
}
else
{
info_output << "Display change was successful: " << width << "x" << height << "x" << bpp << " " << dbpp << "z fullscreen=" << fullscreen << std::endl;
}
#endif
w = width;
h = height;
}
/*
==============
RenderBumpFlat_f
==============
*/
void RenderBumpFlat_f( const idCmdArgs &args ) {
int width, height;
idStr source;
int i;
idBounds bounds;
srfTriangles_t *mesh;
// update the screen as we print
common->SetRefreshOnPrint( true );
width = height = 256;
// check options
for ( i = 1 ; i < args.Argc() - 1; i++ ) {
const char *s;
s = args.Argv( i );
if ( s[0] == '-' ) {
i++;
s = args.Argv( i );
}
if ( !idStr::Icmp( s, "size" ) ) {
if ( i + 2 >= args.Argc() ) {
i = args.Argc();
break;
}
width = atoi( args.Argv( i + 1 ) );
height = atoi( args.Argv( i + 2 ) );
i += 2;
} else {
common->Printf( "WARNING: Unknown option \"%s\"\n", s );
break;
}
}
if ( i != ( args.Argc() - 1 ) ) {
common->Error( "usage: renderBumpFlat [-size width height] asefile" );
return;
}
common->Printf( "Final image size: %i, %i\n", width, height );
// load the source in "fastload" mode, because we don't
// need tangent and shadow information
source = args.Argv( i );
idRenderModel *highPolyModel = renderModelManager->AllocModel();
highPolyModel->PartialInitFromFile( source );
if ( highPolyModel->IsDefaultModel() ) {
common->Error( "failed to load %s", source.c_str() );
}
// combine the high poly model into a single polyset
if ( highPolyModel->NumSurfaces() != 1 ) {
highPolyModel = CombineModelSurfaces( highPolyModel );
}
// create normals if not present in file
const modelSurface_t *surf = highPolyModel->Surface( 0 );
mesh = surf->geometry;
// bound the entire file
R_BoundTriSurf( mesh );
bounds = mesh->bounds;
SaveWindow();
ResizeWindow( width, height );
// for small images, the viewport may be less than the minimum window
qglViewport( 0, 0, width, height );
qglEnable( GL_CULL_FACE );
qglCullFace( GL_FRONT );
qglDisable( GL_STENCIL_TEST );
qglDisable( GL_SCISSOR_TEST );
qglDisable( GL_ALPHA_TEST );
qglDisable( GL_BLEND );
qglEnable( GL_DEPTH_TEST );
qglDisable( GL_TEXTURE_2D );
qglDepthMask( GL_TRUE );
qglDepthFunc( GL_LEQUAL );
qglColor3f( 1, 1, 1 );
qglMatrixMode( GL_PROJECTION );
qglLoadIdentity();
qglOrtho( bounds[0][0], bounds[1][0], bounds[0][2],
bounds[1][2], -( bounds[0][1] - 1 ), -( bounds[1][1] + 1 ) );
qglMatrixMode( GL_MODELVIEW );
qglLoadIdentity();
// flat maps are automatically anti-aliased
idStr filename;
int j, k, c;
byte *buffer;
int *sumBuffer, *colorSumBuffer;
bool flat;
int sample;
sumBuffer = (int *)Mem_Alloc( width * height * 4 * 4 );
memset( sumBuffer, 0, width * height * 4 * 4 );
buffer = (byte *)Mem_Alloc( width * height * 4 );
colorSumBuffer = (int *)Mem_Alloc( width * height * 4 * 4 );
memset( sumBuffer, 0, width * height * 4 * 4 );
flat = false;
//flat = true;
for ( sample = 0 ; sample < 16 ; sample++ ) {
float xOff, yOff;
xOff = ( ( sample & 3 ) / 4.0 ) * ( bounds[1][0] - bounds[0][0] ) / width;
yOff = ( ( sample / 4 ) / 4.0 ) * ( bounds[1][2] - bounds[0][2] ) / height;
for ( int colorPass = 0 ; colorPass < 2 ; colorPass++ ) {
qglClearColor(0.5,0.5,0.5,0);
qglClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
qglBegin( GL_TRIANGLES );
for ( i = 0 ; i < highPolyModel->NumSurfaces() ; i++ ) {
const modelSurface_t *surf = highPolyModel->Surface( i );
mesh = surf->geometry;
if ( colorPass ) {
// just render the surface color for artist visualization
for ( j = 0 ; j < mesh->numIndexes ; j+=3 ) {
for ( k = 0 ; k < 3 ; k++ ) {
int v;
float *a;
v = mesh->indexes[j+k];
qglColor3ubv( mesh->verts[v].color );
a = mesh->verts[v].xyz.ToFloatPtr();
qglVertex3f( a[0] + xOff, a[2] + yOff, a[1] );
}
}
} else {
// render as normal map
// we can either flat shade from the plane,
// or smooth shade from the vertex normals
for ( j = 0 ; j < mesh->numIndexes ; j+=3 ) {
if ( flat ) {
idPlane plane;
idVec3 *a, *b, *c;
int v1, v2, v3;
v1 = mesh->indexes[j+0];
v2 = mesh->indexes[j+1];
v3 = mesh->indexes[j+2];
a = &mesh->verts[ v1 ].xyz;
b = &mesh->verts[ v2 ].xyz;
c = &mesh->verts[ v3 ].xyz;
plane.FromPoints( *a, *b, *c );
// NULLNORMAL is used by the artists to force an area to reflect no
// light at all
if ( surf->shader->GetSurfaceFlags() & SURF_NULLNORMAL ) {
qglColor3f( 0.5, 0.5, 0.5 );
} else {
qglColor3f( 0.5 + 0.5*plane[0], 0.5 - 0.5*plane[2], 0.5 - 0.5*plane[1] );
}
qglVertex3f( (*a)[0] + xOff, (*a)[2] + yOff, (*a)[1] );
qglVertex3f( (*b)[0] + xOff, (*b)[2] + yOff, (*b)[1] );
qglVertex3f( (*c)[0] + xOff, (*c)[2] + yOff, (*c)[1] );
} else {
for ( k = 0 ; k < 3 ; k++ ) {
int v;
float *n;
float *a;
v = mesh->indexes[j+k];
n = mesh->verts[v].normal.ToFloatPtr();
// NULLNORMAL is used by the artists to force an area to reflect no
// light at all
if ( surf->shader->GetSurfaceFlags() & SURF_NULLNORMAL ) {
qglColor3f( 0.5, 0.5, 0.5 );
} else {
// we are going to flip the normal Z direction
qglColor3f( 0.5 + 0.5*n[0], 0.5 - 0.5*n[2], 0.5 - 0.5*n[1] );
}
a = mesh->verts[v].xyz.ToFloatPtr();
qglVertex3f( a[0] + xOff, a[2] + yOff, a[1] );
}
}
}
}
}
qglEnd();
qglFlush();
GLimp_SwapBuffers();
qglReadPixels( 0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, buffer );
c = width * height;
if ( colorPass ) {
// add to the sum buffer
for ( i = 0 ; i < c ; i++ ) {
colorSumBuffer[i*4+0] += buffer[i*4+0];
colorSumBuffer[i*4+1] += buffer[i*4+1];
colorSumBuffer[i*4+2] += buffer[i*4+2];
colorSumBuffer[i*4+3] += buffer[i*4+3];
}
} else {
// normalize
for ( i = 0 ; i < c ; i++ ) {
idVec3 v;
v[0] = ( buffer[i*4+0] - 128 ) / 127.0;
v[1] = ( buffer[i*4+1] - 128 ) / 127.0;
v[2] = ( buffer[i*4+2] - 128 ) / 127.0;
v.Normalize();
buffer[i*4+0] = 128 + 127 * v[0];
buffer[i*4+1] = 128 + 127 * v[1];
buffer[i*4+2] = 128 + 127 * v[2];
}
// outline into non-drawn areas
for ( i = 0 ; i < 8 ; i++ ) {
OutlineNormalMap( buffer, width, height, 128, 128, 128 );
}
// add to the sum buffer
for ( i = 0 ; i < c ; i++ ) {
sumBuffer[i*4+0] += buffer[i*4+0];
sumBuffer[i*4+1] += buffer[i*4+1];
sumBuffer[i*4+2] += buffer[i*4+2];
sumBuffer[i*4+3] += buffer[i*4+3];
}
}
}
}
c = width * height;
// save out the color map
for ( i = 0 ; i < c ; i++ ) {
buffer[i*4+0] = colorSumBuffer[i*4+0] / 16;
buffer[i*4+1] = colorSumBuffer[i*4+1] / 16;
buffer[i*4+2] = colorSumBuffer[i*4+2] / 16;
buffer[i*4+3] = colorSumBuffer[i*4+3] / 16;
}
filename = source;
filename.StripFileExtension();
filename.Append( "_color.tga" );
R_VerticalFlip( buffer, width, height );
R_WriteTGA( filename, buffer, width, height );
// save out the local map
// scale the sum buffer back down to the sample buffer
// we allow this to denormalize
for ( i = 0 ; i < c ; i++ ) {
buffer[i*4+0] = sumBuffer[i*4+0] / 16;
buffer[i*4+1] = sumBuffer[i*4+1] / 16;
buffer[i*4+2] = sumBuffer[i*4+2] / 16;
buffer[i*4+3] = sumBuffer[i*4+3] / 16;
}
filename = source;
filename.StripFileExtension();
filename.Append( "_local.tga" );
common->Printf( "writing %s (%i,%i)\n", filename.c_str(), width, height );
R_VerticalFlip( buffer, width, height );
R_WriteTGA( filename, buffer, width, height );
// free the model
renderModelManager->FreeModel( highPolyModel );
// free our work buffer
Mem_Free( buffer );
Mem_Free( sumBuffer );
Mem_Free( colorSumBuffer );
RestoreWindow();
// stop updating the screen as we print
common->SetRefreshOnPrint( false );
common->Error( "Completed." );
}
BOOL CALLBACK Server_DlgProc (HWND hDlg, UINT msg, WPARAM wp, LPARAM lp)
{
LPIDENT lpiServer = Server_GetServer (hDlg);
if (Server_HandleDialogKeys (hDlg, msg, wp, lp))
return TRUE;
switch (msg)
{
case WM_INITDIALOG:
RECT rWindow;
Server_PrepareTabControl (GetDlgItem (hDlg, IDC_TABS));
GetWindowRect (hDlg, &rWindow);
ResizeWindow (hDlg, awdServer, rwaMoveToHere, &rWindow);
break;
case WM_HELP:
WinHelp (hDlg, cszHELPFILENAME, HELP_FINDER, 0);
break;
case WM_DESTROY:
GetWindowRect (hDlg, &gr.rServerLast);
if (lpiServer)
PropCache_Delete (pcSERVER, lpiServer);
break;
case WM_SIZE:
// if (lp==0), we're minimizing--don't call ResizeWindow().
//
if (lp != 0)
{
ResizeWindow (hDlg, awdServer, rwaFixupGuts);
Server_SaveRect (hDlg, TRUE);
}
break;
case WM_MOVE:
Server_SaveRect (hDlg, TRUE);
break;
case WM_SETFOCUS:
gr.tabLast = Server_GetDisplayedTab (hDlg);
break;
case WM_COMMAND:
switch (LOWORD(wp))
{
case IDCANCEL:
LPIDENT lpi;
if ((lpi = Server_GetServer (hDlg)) != NULL)
Server_Close (lpi);
else
DestroyWindow (hDlg);
break;
}
break;
case WM_NOTIFY:
switch (((LPNMHDR)lp)->code)
{
case TCN_SELCHANGE:
{
HWND hTab = GetDlgItem (hDlg, IDC_TABS);
int iPage = TabCtrl_GetCurSel (hTab);
Server_DisplayTab (hDlg, (CHILDTAB)iPage);
gr.tabLast = (CHILDTAB)iPage;
}
break;
}
break;
}
return FALSE;
}
