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; }