// 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); }
// Load the set file definition of this object // 1. Parse the block of name/parent/transform info for model block // 2. Load the model's binary payload (i.e., the meshes) // 3. Assert the # of meshes matches # of materials // 4. Load each mesh's material //----------------------------------------------------------------------------- CPUTResult CPUTModelOGL::LoadModel(CPUTConfigBlock *pBlock, int *pParentID, CPUTModel *pMasterModel, int numSystemMaterials, cString *pSystemMaterialNames) { CPUTResult result = CPUT_SUCCESS; CPUTAssetLibraryOGL *pAssetLibrary = (CPUTAssetLibraryOGL*)CPUTAssetLibrary::GetAssetLibrary(); cString modelSuffix = ptoc(this); // set the model's name mName = pBlock->GetValueByName(_L("name"))->ValueAsString(); mName = mName + _L(".mdl"); // resolve the full path name cString modelLocation; cString resolvedPathAndFile; modelLocation = ((CPUTAssetLibraryOGL*)CPUTAssetLibrary::GetAssetLibrary())->GetModelDirectoryName(); modelLocation = modelLocation+mName; CPUTFileSystem::ResolveAbsolutePathAndFilename(modelLocation, &resolvedPathAndFile); // Get the parent ID. Note: the caller will use this to set the parent. *pParentID = pBlock->GetValueByName(_L("parent"))->ValueAsInt(); LoadParentMatrixFromParameterBlock( pBlock ); // Get the bounding box information float3 center(0.0f), half(0.0f); pBlock->GetValueByName(_L("BoundingBoxCenter"))->ValueAsFloatArray(center.f, 3); pBlock->GetValueByName(_L("BoundingBoxHalf"))->ValueAsFloatArray(half.f, 3); mBoundingBoxCenterObjectSpace = center; mBoundingBoxHalfObjectSpace = half; mMeshCount = pBlock->GetValueByName(_L("meshcount"))->ValueAsInt(); mpMesh = new CPUTMesh*[mMeshCount]; mpLayoutCount = new UINT[mMeshCount]; mpRootMaterial = new CPUTMaterial*[mMeshCount]; memset( mpRootMaterial, 0, mMeshCount * sizeof(CPUTMaterial*) ); mpMaterialEffect = new CPUTMaterialEffect**[mMeshCount]; memset( mpMaterialEffect, 0, mMeshCount * sizeof(CPUTMaterialEffect*) ); // get the material names, load them, and match them up with each mesh cString materialName,shadowMaterialName; char pNumber[4]; cString materialValueName; CPUTModelOGL *pMasterModelDX = (CPUTModelOGL*)pMasterModel; for(UINT ii=0; ii<mMeshCount; ii++) { if(pMasterModelDX) { // Reference the master model's mesh. Don't create a new one. mpMesh[ii] = pMasterModelDX->mpMesh[ii]; mpMesh[ii]->AddRef(); } else { mpMesh[ii] = new CPUTMeshOGL(); } } if( !pMasterModelDX ) { // Not a clone/instance. So, load the model's binary payload (i.e., vertex and index buffers) // TODO: Change to use GetModel() result = LoadModelPayload(resolvedPathAndFile); ASSERT( CPUTSUCCESS(result), _L("Failed loading model") ); } for(UINT ii=0; ii<mMeshCount; ii++) { // get the right material number ('material0', 'material1', 'material2', etc) materialValueName = _L("material"); snprintf(pNumber, 4, "%d", ii); // _itoa(ii, pNumber, 4, 10); materialValueName.append(s2ws(pNumber)); materialName = pBlock->GetValueByName(materialValueName)->ValueAsString(); shadowMaterialName = pBlock->GetValueByName(_L("shadowCast") + materialValueName)->ValueAsString(); bool isSkinned = pBlock->GetValueByName(_L("skeleton")) != &CPUTConfigEntry::sNullConfigValue; if( shadowMaterialName.length() == 0 ) { if(!isSkinned) { shadowMaterialName = _L("%shadowCast"); } else { shadowMaterialName = _L("%shadowCastSkinned"); } } // Get/load material for this mesh UINT totalNameCount = numSystemMaterials + NUM_GLOBAL_SYSTEM_MATERIALS; cString *pFinalSystemNames = new cString[totalNameCount]; // Copy "global" system materials to caller-supplied list for( int jj=0; jj<numSystemMaterials; jj++ ) { pFinalSystemNames[jj] = pSystemMaterialNames[jj]; } pFinalSystemNames[totalNameCount + CPUT_MATERIAL_INDEX_SHADOW_CAST] = shadowMaterialName; // pFinalSystemNames[totalNameCount + CPUT_MATERIAL_INDEX_BOUNDING_BOX] = _L("%BoundingBox"); int finalNumSystemMaterials = numSystemMaterials + NUM_GLOBAL_SYSTEM_MATERIALS; CPUTMaterial *pMaterial = pAssetLibrary->GetMaterial(materialName, false, this, ii, NULL, finalNumSystemMaterials, pFinalSystemNames); ASSERT( pMaterial, _L("Couldn't find material.") ); delete []pFinalSystemNames; mpLayoutCount[ii] = pMaterial->GetMaterialEffectCount(); SetMaterial(ii, pMaterial); // Release the extra refcount we're holding from the GetMaterial operation earlier // now the asset library, and this model have the only refcounts on that material pMaterial->Release(); // Create two ID3D11InputLayout objects, one for each material. // mpMesh[ii]->BindVertexShaderLayout( mpMaterial[ii], mpShadowCastMaterial); // mpShadowCastMaterial->Release() } return result; }
fixed GlidePolar::GetVTakeoff() const { return half(GetVMin()); }
void Cowichan::main (int argc, char* argv[], bool use_randmat, bool use_thresh) { if ((argc == 1) || (strcmp (argv[1], CHAIN) == 0)) { chain (use_randmat, use_thresh); } else { INT64 start, end; if (strcmp (argv[1], MANDEL) == 0) { // set up nr = MANDEL_NR; nc = MANDEL_NC; mandelX0 = MANDEL_X0; mandelY0 = MANDEL_Y0; mandelDx = MANDEL_DX; mandelDy = MANDEL_DY; // initialize IntMatrix matrix = NULL; try { matrix = NEW_MATRIX_RECT(INT_TYPE); } catch (...) {out_of_memory();} // execute end = get_ticks (); mandel (matrix); timeInfo(&start, &end, MANDEL); print_rect_matrix<INT_TYPE> (matrix); // clean up delete [] matrix; } else if (strcmp (argv[1], RANDMAT) == 0) { // set up nr = RANDMAT_NR; nc = RANDMAT_NC; seed = RAND_SEED; // initialize IntMatrix matrix = NULL; try { matrix = NEW_MATRIX_RECT(INT_TYPE); } catch (...) {out_of_memory();} // execute end = get_ticks (); randmat (matrix); timeInfo(&start, &end, RANDMAT); print_rect_matrix<INT_TYPE> (matrix); // clean up delete [] matrix; } else if (strcmp (argv[1], HALF) == 0) { // set up nr = HALF_NR; nc = HALF_NC; srand(RAND_SEED); // initialize IntMatrix matrixIn = NULL; IntMatrix matrixOut = NULL; try { matrixIn = NEW_MATRIX_RECT(INT_TYPE); matrixOut = NEW_MATRIX_RECT(INT_TYPE); } catch (...) {out_of_memory();} index_t r, c; for (r = 0; r < nr; r++) { for (c = 0; c < nc; c++) { MATRIX_RECT(matrixIn, r, c) = rand () % RAND_M; } } // execute end = get_ticks (); half (matrixIn, matrixOut); timeInfo(&start, &end, HALF); print_rect_matrix<INT_TYPE> (matrixOut); // clean up delete [] matrixIn; delete [] matrixOut; } else if (strcmp (argv[1], INVPERC) == 0) { // set up nr = INVPERC_NR; nc = INVPERC_NC; invpercNFill = INVPERC_NFILL; srand(RAND_SEED); // initialize IntMatrix matrix = NULL; BoolMatrix mask = NULL; try { matrix = NEW_MATRIX_RECT(INT_TYPE); mask = NEW_MATRIX_RECT(bool); } catch (...) {out_of_memory();} index_t r, c; for (r = 0; r < nr; r++) { for (c = 0; c < nc; c++) { MATRIX_RECT(matrix, r, c) = rand () % RAND_M; MATRIX_RECT(mask, r, c) = false; } } // execute end = get_ticks (); invperc (matrix, mask); timeInfo(&start, &end, INVPERC); print_bool_rect_matrix (mask); // clean up delete [] matrix; delete [] mask; } else if (strcmp (argv[1], THRESH) == 0) {
int main( int argc, /* arg count */ char * argv[] /* arg vector */ ){ static char * context = "main(chain)"; char * stem = NULL; /* dump filename stem */ char * suffix = NULL; /* dump filename suffix */ char * suff2 = NULL; /* last half of suffix */ int nr, nc; /* integer matrix sizes */ int n; /* square matrix/vector size */ real base_x, base_y; /* base of Mandelbrot */ real ext_x, ext_y; /* extent of Mandelbrot */ int limit, seed; /* randmat controls */ real fraction; /* invperc/thresh filling */ int itersLife; /* life iterations */ int itersElastic, relax; /* elastic controls */ int2D i2D; /* integer matrix */ bool2D b2D; /* boolean matrix */ pt1D cities; /* cities point vector */ int n_cities; /* number of cities */ pt1D net; /* net point vector */ int n_net; /* number of net points */ real2D r2D_gauss; /* real matrix for Gaussian */ real2D r2D_sor; /* real matrix for SOR */ real1D r1D_gauss_v; /* real vector input for Gaussian */ real1D r1D_sor_v; /* real vector input for SOR */ real1D r1D_gauss_a; /* real vector answer for Gaussian */ real1D r1D_sor_a; /* real vector answer for SOR */ real1D r1D_gauss_c; /* real vector check for Gaussian */ real1D r1D_sor_c; /* real vector check for SOR */ real tol; /* SOR tolerance */ real realDiff; /* vector difference */ bool choicesSet = FALSE; /* path choices set? */ bool doMandel = TRUE; /* mandel vs. randmat */ bool doInvperc = TRUE; /* invperc vs. thresholding */ bool doDump = FALSE; /* dump intermediate results? */ int argd = 1; /* argument index */ /* arguments */ #if NUMA MAIN_INITENV(,32000000) #endif while (argd < argc){ CHECK(argv[argd][0] == '-', fail(context, "bad argument", "index", "%d", argd, NULL)); switch(argv[argd][1]){ case 'E' : /* elastic */ itersElastic = arg_int(context, argc, argv, argd+1, argv[argd]); relax = arg_int(context, argc, argv, argd+2, argv[argd]); argd += 3; break; case 'F' : /* fraction (invperc/thresh) */ fraction = arg_real(context, argc, argv, argd+1, argv[argd]); argd += 2; break; case 'L' : /* life */ itersLife = arg_int(context, argc, argv, argd+1, argv[argd]); argd += 2; break; case 'M' : /* mandel */ base_x = arg_real(context, argc, argv, argd+1, argv[argd]); base_y = arg_real(context, argc, argv, argd+2, argv[argd]); ext_x = arg_real(context, argc, argv, argd+3, argv[argd]); ext_y = arg_real(context, argc, argv, argd+4, argv[argd]); argd += 5; break; case 'N' : /* winnow */ n_cities = arg_int(context, argc, argv, argd+1, argv[argd]); argd += 2; break; case 'R' : /* randmat */ limit = arg_int(context, argc, argv, argd+1, argv[argd]); seed = arg_int(context, argc, argv, argd+2, argv[argd]); argd += 3; break; case 'S' : /* matrix size */ nr = arg_int(context, argc, argv, argd+1, argv[argd]); nc = arg_int(context, argc, argv, argd+2, argv[argd]); argd += 3; break; case 'T' : /* SOR tolerance */ tol = arg_real(context, argc, argv, argd+1, argv[argd]); argd += 2; break; case 'c' : /* choice */ CHECK(!choicesSet, fail(context, "choices already set", NULL)); suffix = arg_str(context, argc, argv, argd+1, argv[argd]); argd += 2; switch(suffix[0]){ case 'i' : doInvperc = TRUE; break; case 't' : doInvperc = FALSE; break; default : fail(context, "unknown choice(s)", "choice", "%s", suffix, NULL); } switch(suffix[1]){ case 'm' : doMandel = TRUE; break; case 'r' : doMandel = FALSE; break; default : fail(context, "unknown choice(s)", "choice", "%s", suffix, NULL); } suff2 = suffix+1; choicesSet = TRUE; break; case 'd' : /* dump */ doDump = TRUE; argd += 1; if ((argd < argc) && (argv[argd][0] != '-')){ stem = arg_str(context, argc, argv, argd, argv[argd-1]); argd += 1; } break; #if GRAPHICS case 'g' : gfx_open(app_chain, arg_gfxCtrl(context, argc, argv, argd+1, argv[argd])); argd += 2; break; #endif #if MIMD case 'p' : DataDist = arg_dataDist(context, argc, argv, argd+1, argv[argd]); ParWidth = arg_int(context, argc, argv, argd+2, argv[argd]); argd += 3; break; #endif case 'u' : io_init(FALSE); argd += 1; break; default : fail(context, "unknown flag", "flag", "%s", argv[argd], NULL); break; } } CHECK(choicesSet, fail("context", "choices not set using -c flag", NULL)); /* initialize */ #if MIMD sch_init(DataDist); #endif /* mandel vs. randmat */ if (doMandel){ mandel(i2D, nr, nc, base_x, base_y, ext_x, ext_y); if (doDump) io_wrInt2D(context, mkfname(stem, NULL, suff2, "i2"), i2D, nr, nc); } else { randmat(i2D, nr, nc, limit, seed); if (doDump) io_wrInt2D(context, mkfname(stem, NULL, suff2, "i2"), i2D, nr, nc); } /* half */ half(i2D, nr, nc); if (doDump) io_wrInt2D(context, mkfname(stem, "h", suff2, "i2"), i2D, nr, nc); /* invperc vs. thresh */ if (doInvperc){ invperc(i2D, b2D, nr, nc, fraction); if (doDump) io_wrBool2D(context, mkfname(stem, NULL, suffix, "b2"), b2D, nr, nc); } else { thresh(i2D, b2D, nr, nc, fraction); if (doDump) io_wrBool2D(context, mkfname(stem, NULL, suffix, "b2"), b2D, nr, nc); } /* life */ life(b2D, nr, nc, itersLife); if (doDump) io_wrBool2D(context, mkfname(stem, "l", suffix, "b2"), b2D, nr, nc); /* winnow */ winnow(i2D, b2D, nr, nc, cities, n_cities); if (doDump) io_wrPt1D(context, mkfname(stem, "w", suffix, "p1"), cities, n_cities); /* norm */ norm(cities, n_cities); if (doDump) io_wrPt1D(context, mkfname(stem, "n", suffix, "p1"), cities, n_cities); /* elastic */ n_net = (int)(ELASTIC_RATIO * n_cities); CHECK(n_net <= MAXEXT, fail(context, "too many net points required", "number of net points", "%d", n_net, NULL)); elastic(cities, n_cities, net, n_net, itersElastic, relax); if (doDump) io_wrPt1D(context, mkfname(stem, "e", suffix, "p1"), net, n_net); /* outer */ n = n_net; outer(net, r2D_gauss, r1D_gauss_v, n); if (doDump){ io_wrReal2D(context, mkfname(stem, "o", suffix, "r2"), r2D_gauss, n, n); io_wrReal1D(context, mkfname(stem, "o", suffix, "r1"), r1D_gauss_v, n); } cpReal2D(r2D_gauss, r2D_sor, n, n); cpReal1D(r1D_gauss_v, r1D_sor_v, n); /* gauss */ gauss(r2D_gauss, r1D_gauss_v, r1D_gauss_a, n); if (doDump) io_wrReal1D(context, mkfname(stem, "g", suffix, "r1"), r1D_gauss_a, n); /* product (gauss) */ product(r2D_gauss, r1D_gauss_a, r1D_gauss_c, n, n); if (doDump) io_wrReal1D(context, mkfname(stem, "pg", suffix, "r1"), r1D_gauss_c, n); /* sor */ sor(r2D_sor, r1D_sor_v, r1D_sor_a, n, tol); if (doDump) io_wrReal1D(context, mkfname(stem, "s", suffix, "r1"), r1D_gauss_a, n); /* product (sor) */ product(r2D_sor, r1D_sor_a, r1D_sor_c, n, n); if (doDump) io_wrReal1D(context, mkfname(stem, "ps", suffix, "r1"), r1D_gauss_c, n); /* difference */ vecdiff(r1D_gauss_a, r1D_sor_a, n, &realDiff); if (doDump) io_wrReal0D(context, mkfname(stem, "v", suffix, "r0"), realDiff); #if IEEE ieee_retrospective(stderr); #endif #if NUMA MAIN_END; #endif return 0; }