BasicModel::BasicModel(ID3D11Device* device, TextureMgr& texMgr, const std::string& modelFilename, const std::wstring& texturePath, MeshGeometry::Type type) : ModelMesh(type) { std::vector<M3dMaterial> mats; //M3DLoader m3dLoader; //m3dLoader.LoadM3d(modelFilename, Vertices, Indices, Subsets, mats); //test code OBJLoader objLoader; objLoader.LoadOBJ(device, modelFilename, BasicVertices, Indices, Subsets, mats, true, true); ModelMesh.SetVertices(device, &BasicVertices[0], BasicVertices.size()); ModelMesh.SetIndices(device, &Indices[0], Indices.size()); ModelMesh.SetSubsetTable(Subsets); SubsetCount = mats.size(); for (UINT i = 0; i < SubsetCount; ++i) { Material newMat; Mat.push_back(mats[i].Mat); ID3D11ShaderResourceView* diffuseMapSRV = texMgr.CreateTexture(texturePath + mats[i].DiffuseMapName); DiffuseMapSRV.push_back(diffuseMapSRV); //ID3D11ShaderResourceView* normalMapSRV = texMgr.CreateTexture(texturePath + mats[i].NormalMapName); //NormalMapSRV.push_back(normalMapSRV); } }
bool Object::loadOBJ(const string& geometryFile, const string& materialFile) { OBJLoader objLoader; bool loadMaterial = materialFile.compare("") != 0; cout << "Load object geometry." << endl; if (objLoader.loadGeometry(geometryFile, mesh)) { cout << "Object mesh successfully loaded." << endl; withNormals = mesh.normalsNumber() > 0; withUVs = mesh.uvsNumber() > 0; if (!withNormals) cout << "Loaded object does not have any normals."; if (!withUVs) cout << "Loaded object does not have any texture coordinates."; if (loadMaterial) { cout << "Load object material." << endl; objLoader.loadMaterial(materialFile); } } }
void Vao::initialize_vao (OBJLoader object_) { vaoID=vaoglobal; const float *vertices = object_.getVerticesArray(); const float *textureCoords = object_.getTextureCoordinatesArray(); const float *normals = object_.getNormalsArray(); glGenVertexArrays(1, &vao); //1. glBindVertexArray(vao); //2. glEnableVertexAttribArray(0); //3. glGenBuffers(1, &geomId); //4. glBindBuffer(GL_ARRAY_BUFFER, geomId); //5. glBufferData(GL_ARRAY_BUFFER, object_.getNVertices() * 3 * sizeof(float), vertices, GL_STATIC_DRAW); //6. GL_ARRAY_BUFFER: the type of buffer; sizeof(vertices): the memory size; vertices: the pointer to data; GL_STATIC_DRAW: data will remain on the graphics card's memory and will not be changed glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0); //7. 0: the *ATTRIBUTE* number; 3: the number of coordinates; GL_FLOAT: the type of data; GL_FALSE: is the data normalized? (usually it isn't), 0: stride (forget for now); 0: data position (forget for now) glEnableVertexAttribArray(1); glGenBuffers(1, &texUVId); glBindBuffer(GL_ARRAY_BUFFER, texUVId); glBufferData(GL_ARRAY_BUFFER, object_.getNVertices() * 2 * sizeof(float), textureCoords, GL_STATIC_DRAW); glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, 0); glEnableVertexAttribArray(2); glGenBuffers(1, &normalsId); glBindBuffer(GL_ARRAY_BUFFER, normalsId); glBufferData(GL_ARRAY_BUFFER, object_.getNVertices() * 3 * sizeof(float), normals, GL_STATIC_DRAW); glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, 0, 0); checkError("initBuffer"); glBindBuffer(GL_ARRAY_BUFFER, 0); //9. glBindVertexArray(0); //9. vaoglobal++; }
// Load a scene from a .dae or a .obj file: void SceneLoader::load(Scene* scene, const char* filename, ElementContainer::Type container_type) { // Determine the file type: string str_filename = string(filename); string extension = str_filename.substr(str_filename.find_last_of('.')); uint len = extension.length(); for(uint i=0 ; i < len ; i++) extension[i] = tolower(extension[i]); if(extension == ".dae") { DAELoader loader; loader.load(scene, filename, container_type); } else if(extension == ".obj") { OBJLoader loader; loader.load(scene, filename, container_type); } else logError("cannot load scene \"", filename, "\": unknown file type"); }
const bool Terrain::Initialize() { vector<string> configLines; if(!Utility::Instance()->LoadConfigFile("Resources/Config/Config.txt", configLines)) return false; map<string, string> config; if(!Utility::Instance()->ReturnConfigField(config, "Terrain", configLines)) return false; OBJLoader obj; vector<Utility::Vertex> faces; if(!obj.LoadFaces(config["OBJFile"].c_str(), faces)) return false; // Find out where the particles will land and place these in colour // section of the vertex ParticleManager::Instance()->GetSnowDrifts(faces); // Grass needs to know the position of the lake _grass.LakeFaces(faces); _grass.Initialize(); _vbo.CreateVBO(faces); Vector3f pos, scale, rotation; Utility::Instance()->StringToVector(config["Position"], pos); Utility::Instance()->StringToVector(config["Scale"], scale); Utility::Instance()->StringToVector(config["Rotation"], rotation); Pos(pos); Size(scale); Rotation(rotation); Vector4f amb, dif, spec; float shine; Utility::Instance()->StringToVector(config["Ambience"], amb); Utility::Instance()->StringToVector(config["Diffuse"], dif); Utility::Instance()->StringToVector(config["Specular"], spec); shine = (float)atof(config["Shine"].c_str()); InitializeTexture(config["TextureFile"].c_str()); ShaderManager::Instance()->AddNewShader("Terrain", "Resources/Shaders/Terrain.vert", "Resources/Shaders/Terrain.frag"); ShaderManager::Instance()->UseProgram("Terrain"); ShaderManager::Instance()->AddAttribTo("Terrain", "aTexCoord", 2, 12); ShaderManager::Instance()->AddAttribTo("Terrain", "aVertex", 3, 0); ShaderManager::Instance()->AddAttribTo("Terrain", "aNormal", 3, 20); ShaderManager::Instance()->AddAttribTo("Terrain", "aDisScale", 1, 32); ShaderManager::Instance()->AddUniformTo("Terrain", "texSampler"); ShaderManager::Instance()->AddUniformTo("Terrain", "uShine"); ShaderManager::Instance()->AddUniformTo("Terrain", "uDif"); ShaderManager::Instance()->AddUniformTo("Terrain", "uSpec"); ShaderManager::Instance()->AddUniformTo("Terrain", "uAmb"); ShaderManager::Instance()->AddUniformTo("Terrain", "uLightDir"); ShaderManager::Instance()->AddUniformTo("Terrain", "uPercThroughSeason"); ShaderManager::Instance()->UseUniform1f("Terrain", "uPercThroughSeason", 0.0f); ShaderManager::Instance()->UseUniform1i("Terrain", "texSampler", 0); ShaderManager::Instance()->UseUniform4fv("Terrain", "uAmb", amb); ShaderManager::Instance()->UseUniform4fv("Terrain", "uDif", dif); ShaderManager::Instance()->UseUniform4fv("Terrain", "uSpec", spec); ShaderManager::Instance()->UseUniform1f("Terrain", "uShine", shine); ShaderManager::Instance()->UnuseProgram("Terrain"); return true; }
bool MeshManager::loadOBJFile(const string& filename) { #if USE_REEB_GRAPH try { cout << "[VTK] Reading mesh file ..." << endl; vtkSmartPointer<vtkOBJReader> vtkReader = vtkSmartPointer<vtkOBJReader>::New(); vtkReader->SetFileName(filename.c_str()); vtkReader->Update(); vtkMesh = vtkReader->GetOutput(); cout << "[VTK] Creating reeb graph ..." << endl; updateReebGraph(); } catch (exception e) { cerr << e.what() << endl; } #endif OBJLoader loader; if( loader.load(filename) ) { cout << "file " << filename << " loaded." << endl; /// build a half edge mesh here //hds_mesh->printMesh("original"); hds_mesh.reset(buildHalfEdgeMesh(loader.getFaces(), loader.getVerts())); cutted_mesh.reset(); unfolded_mesh.reset(); smoothed_mesh.reset(); /// save the half edge mesh out to a temporary file hds_mesh->save("temp.obj"); /// preprocess the mesh with smoothing const int nsmooth = 10; QScopedPointer<HDS_Mesh> tmp_mesh; vector<string> smoothed_mesh_filenames; tmp_mesh.reset(new HDS_Mesh(*hds_mesh)); hds_mesh_smoothed.push_back(QSharedPointer<HDS_Mesh>(new HDS_Mesh(*tmp_mesh))); for (int i = 0; i < nsmooth; ++i) { const int stepsize = 10; string smesh_filename = filename.substr(0, filename.length() - 4) + "_smoothed_" + std::to_string((i + 1)*stepsize) + ".obj"; smoothed_mesh_filenames.push_back(smesh_filename); if (Utils::exists(smesh_filename)) { // load the mesh directly OBJLoader tmploader; tmploader.load(smesh_filename); tmp_mesh.reset(buildHalfEdgeMesh(tmploader.getFaces(), tmploader.getVerts())); } else { for (int j = 0; j < stepsize; ++j) { MeshSmoother::smoothMesh_Laplacian(tmp_mesh.data()); } tmp_mesh->save(smesh_filename); } hds_mesh_smoothed.push_back(QSharedPointer<HDS_Mesh>(new HDS_Mesh(*tmp_mesh))); } cout << "smoothed meshes computed finished." << endl; /// initialize the sparse graph gcomp.reset(new GeodesicComputer(filename)); gcomp_smoothed.push_back(QSharedPointer<GeodesicComputer>(gcomp.data())); for (int i = 0; i < smoothed_mesh_filenames.size(); ++i) { // compute or load SVG for smoothed meshes gcomp_smoothed.push_back(QSharedPointer<GeodesicComputer>(new GeodesicComputer(smoothed_mesh_filenames[i]))); } cout << "SVGs computed." << endl; return true; } else return false; }
int main(int argc, char* argv[]) { std::cout << "VoxelAO by Kevin Ortegren, 2015" << std::endl; bool running = true; //Setup SDL window SDL_SysWMinfo info; HWND handle; if (SDL_Init(SDL_INIT_TIMER) != 0) { std::cerr << "SDL_Init failed: " << SDL_GetError() << std::endl; } window = SDL_CreateWindow("VoxelAO", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, WINDOW_WIDTH, WINDOW_HEIGHT, SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE ); //Must init info struct with SDL version info, see documentation for explanation SDL_VERSION(&info.version); //If succeeded, init d3d11 and other things if (SDL_GetWindowWMInfo(window, &info)) { handle = info.info.win.window; } else { std::cerr << "Failed to get WMInfo: " << SDL_GetError() << std::endl; running = false; } InitD3D(handle); SetupAntTweakBar(); timer = new D3D11Timer(device, context); { ID3DBlob* vsblob,* psblob, *gsblob; ID3DBlob* errblob = nullptr; UINT flags = 0; #ifndef _DEBUG // IF NOT DEBUG flags |= D3DCOMPILE_OPTIMIZATION_LEVEL3; #endif //Create shaders CHECKDX(D3DCompileFromFile(L"../../Assets/Shaders/simple.vertex", nullptr, nullptr, "main", "vs_5_0", flags, 0, &vsblob, nullptr)); CHECKDX(D3DCompileFromFile(L"../../Assets/Shaders/simple.pixel", nullptr, nullptr, "main", "ps_5_0", flags, 0, &psblob, nullptr)); CHECKDX(device->CreateVertexShader(vsblob->GetBufferPointer(), vsblob->GetBufferSize(), nullptr, &VS)); CHECKDX(device->CreatePixelShader(psblob->GetBufferPointer(), psblob->GetBufferSize(), nullptr, &PS)); D3D11_INPUT_ELEMENT_DESC ied[] = { { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 }, { "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 }, { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 } }; CHECKDX(device->CreateInputLayout(ied, 3, vsblob->GetBufferPointer(), vsblob->GetBufferSize(), &layout)); //Full screen quad shader CHECKDX(D3DCompileFromFile(L"../../Assets/Shaders/fsq.vertex", nullptr, nullptr, "main", "vs_5_0", flags, 0, &vsblob, nullptr)); CHECKDX(D3DCompileFromFile(L"../../Assets/Shaders/fsq.pixel", nullptr, nullptr, "main", "ps_5_0", flags, 0, &psblob, &errblob)); CHECKDX(device->CreateVertexShader(vsblob->GetBufferPointer(), vsblob->GetBufferSize(), nullptr, &fsqVS)); CHECKDX(device->CreatePixelShader(psblob->GetBufferPointer(), psblob->GetBufferSize(), nullptr, &fsqPS)); CHECKDX(D3DCompileFromFile(L"../../Assets/Shaders/fsq_only_AO.pixel", nullptr, nullptr, "main", "ps_5_0", flags, 0, &psblob, &errblob)); CHECKDX(device->CreatePixelShader(psblob->GetBufferPointer(), psblob->GetBufferSize(), nullptr, &fsqOcclusionPS)); CHECKDX(D3DCompileFromFile(L"../../Assets/Shaders/fsq_no_AO.pixel", nullptr, nullptr, "main", "ps_5_0", flags, 0, &psblob, &errblob)); CHECKDX(device->CreatePixelShader(psblob->GetBufferPointer(), psblob->GetBufferSize(), nullptr, &fsqNOOcclusionPS)); D3D11_INPUT_ELEMENT_DESC iedfsq[] = { { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 } }; CHECKDX(device->CreateInputLayout(iedfsq, 1, vsblob->GetBufferPointer(), vsblob->GetBufferSize(), &fsqlayout)); //Create voxelizer shaders CHECKDX(D3DCompileFromFile(L"../../Assets/Shaders/voxelizing.vertex", nullptr, nullptr, "main", "vs_5_0", flags, 0, &vsblob, &errblob)); CHECKDX(D3DCompileFromFile(L"../../Assets/Shaders/voxelizing.geometry", nullptr, nullptr, "main", "gs_5_0", flags, 0, &gsblob, &errblob)); CHECKDX(D3DCompileFromFile(L"../../Assets/Shaders/voxelizing.pixel", nullptr, nullptr, "main", "ps_5_0", flags, 0, &psblob, &errblob)); CHECKDX(device->CreateVertexShader(vsblob->GetBufferPointer(), vsblob->GetBufferSize(), nullptr, &voxelVS)); CHECKDX(device->CreateGeometryShader(gsblob->GetBufferPointer(), gsblob->GetBufferSize(), nullptr, &voxelGS)); CHECKDX(device->CreatePixelShader(psblob->GetBufferPointer(), psblob->GetBufferSize(), nullptr, &voxelPS)); D3D11_INPUT_ELEMENT_DESC iedvox[] = { { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 }, { "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 }, { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 } }; CHECKDX(device->CreateInputLayout(ied, 3, vsblob->GetBufferPointer(), vsblob->GetBufferSize(), &voxelLayout)); vsblob->Release(); gsblob->Release(); psblob->Release(); } { OBJLoader objLoader; mesh = objLoader.LoadBIN("../../Assets/Models/sponza.bin"); } //Camera camera.SetLens((float)M_PI_4, NEARZ, FARZ, WINDOW_WIDTH, WINDOW_HEIGHT); { //Init primitive spritebatch from DirectXTK primitiveBatch = new DirectX::PrimitiveBatch<DirectX::VertexPositionColor>(context, 65536, (size_t)(65536/3)); basicEffect = new DirectX::BasicEffect(device); basicEffect->SetProjection(XMLoadFloat4x4(&camera.GetCamData().projMat)); basicEffect->SetVertexColorEnabled(true); void const* shaderByteCode; size_t byteCodeLength; basicEffect->GetVertexShaderBytecode(&shaderByteCode, &byteCodeLength); CHECKDX(device->CreateInputLayout(DirectX::VertexPositionColor::InputElements, DirectX::VertexPositionColor::InputElementCount, shaderByteCode, byteCodeLength, &basicInputLayout)); D3D11_BUFFER_DESC cbDesc; cbDesc.ByteWidth = sizeof(CameraData); cbDesc.Usage = D3D11_USAGE_DYNAMIC; cbDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; cbDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; cbDesc.MiscFlags = 0; cbDesc.StructureByteStride = 0; CHECKDX(device->CreateBuffer(&cbDesc, nullptr, &camConstBuffer)); D3D11_BUFFER_DESC cbkernelDesc; cbkernelDesc.ByteWidth = sizeof(SampleKernelOptions); cbkernelDesc.Usage = D3D11_USAGE_DYNAMIC; cbkernelDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; cbkernelDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; cbkernelDesc.MiscFlags = 0; cbkernelDesc.StructureByteStride = 0; CHECKDX(device->CreateBuffer(&cbkernelDesc, nullptr, &sampleConstBuffer)); D3D11_BUFFER_DESC cbvoxelDesc; cbvoxelDesc.ByteWidth = sizeof(VoxelOptions); cbvoxelDesc.Usage = D3D11_USAGE_DYNAMIC; cbvoxelDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; cbvoxelDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; cbvoxelDesc.MiscFlags = 0; cbvoxelDesc.StructureByteStride = 0; CHECKDX(device->CreateBuffer(&cbvoxelDesc, nullptr, &voxelOptionConstBuffer)); //Set up sampler state D3D11_SAMPLER_DESC samplerDesc; ZeroMemory(&samplerDesc, sizeof(samplerDesc)); samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR; samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP; samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP; samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP; samplerDesc.ComparisonFunc = D3D11_COMPARISON_NEVER; samplerDesc.MinLOD = 0; samplerDesc.MaxLOD = D3D11_FLOAT32_MAX; CHECKDX(device->CreateSamplerState(&samplerDesc, &linearSamplerState)); //Rasterizer state D3D11_RASTERIZER_DESC RSdesc; ZeroMemory(&RSdesc, sizeof(RSdesc)); RSdesc.FillMode = D3D11_FILL_SOLID; RSdesc.CullMode = D3D11_CULL_NONE; RSdesc.DepthClipEnable = TRUE; CHECKDX(device->CreateRasterizerState(&RSdesc, &RSStateSolid)); RSdesc.FillMode = D3D11_FILL_WIREFRAME; CHECKDX(device->CreateRasterizerState(&RSdesc, &RSStateWireframe)); } //Init voxel structure and GPU resources { voxelMatrix = Matrix::CreateOrthographic(VOXEL_STRUCTURE_WIDTH, VOXEL_STRUCTURE_WIDTH, 0.0f, VOXEL_STRUCTURE_WIDTH); voxelViewProjMatrix[0] = Matrix::CreateLookAt(Vector3(-VOXEL_STRUCTURE_WIDTH/2, 0, 0), Vector3(0, 0, 0), Vector3(0, 1, 0)) * voxelMatrix; voxelViewProjMatrix[1] = Matrix::CreateLookAt(Vector3(0, -VOXEL_STRUCTURE_WIDTH / 2, 0), Vector3(0, 0, 0), Vector3(1, 0, 0)) * voxelMatrix; voxelViewProjMatrix[2] = Matrix::CreateLookAt(Vector3(0, 0, -VOXEL_STRUCTURE_WIDTH / 2), Vector3(0, 0, 0), Vector3(0, 1, 0)) * voxelMatrix; D3D11_BUFFER_DESC voxmatbuffdesc; voxmatbuffdesc.ByteWidth = 3 * sizeof(Matrix); voxmatbuffdesc.Usage = D3D11_USAGE_IMMUTABLE; voxmatbuffdesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; voxmatbuffdesc.CPUAccessFlags = 0; voxmatbuffdesc.MiscFlags = 0; voxmatbuffdesc.StructureByteStride = 0; D3D11_SUBRESOURCE_DATA voxmatdata; voxmatdata.pSysMem = &voxelViewProjMatrix[0]; voxmatdata.SysMemPitch = 3 * sizeof(Matrix); voxmatdata.SysMemSlicePitch = 0; CHECKDX(device->CreateBuffer(&voxmatbuffdesc, &voxmatdata, &voxelMatBuffer)); // CreateVoxelBuffers(); D3D11_BLEND_DESC blendDesc = { 0 }; CHECKDX(device->CreateBlendState(&blendDesc, &voxelBlendState)); } RebuildKernel(); //RenderTarget clear color float clearColor[] = { 1.0f, 1.0f, 0.0f, 1.0f }; //Timer uint32 oldTime, currentTime; float dt; uint32 frames = 0; float collectedTime = 0.0f; float collectedAOTime = 0.0f; float collectedVoxelTime = 0.0f; currentTime = SDL_GetTicks(); while (running) { oldTime = currentTime; currentTime = SDL_GetTicks(); dt = (currentTime - oldTime) / 1000.0f; collectedTime += dt; ++frames; if (collectedTime >= 1.0f) { collectedTime -= 1.0f; FPS = frames; AOTime = collectedAOTime / (float)frames; voxelTime = collectedVoxelTime / (float)frames; collectedAOTime = 0.0f; collectedVoxelTime = 0.0f; frames = 0; } running = HandleEvents(); const Uint8* keystate = SDL_GetKeyboardState(NULL); //Check keys and move camera if (keystate[SDL_SCANCODE_A]) camera.StrafeLeft(dt); if (keystate[SDL_SCANCODE_D]) camera.StrafeRight(dt); if (keystate[SDL_SCANCODE_W]) camera.MoveForward(dt); if (keystate[SDL_SCANCODE_S]) camera.MoveBackward(dt); if (keystate[SDL_SCANCODE_LSHIFT]) camera.MoveDown(dt); if (keystate[SDL_SCANCODE_SPACE]) camera.MoveUp(dt); camera.Update(); D3D11_MAPPED_SUBRESOURCE camResource; CHECKDX(context->Map(camConstBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &camResource)); memcpy(camResource.pData, &camera.GetCamData(), sizeof(CameraData)); context->Unmap(camConstBuffer, 0); if (sampleOptions.sizeX != prevSampleOptions.sizeX || sampleOptions.sizeY != prevSampleOptions.sizeY) { prevSampleOptions.sizeX = sampleOptions.sizeX; prevSampleOptions.sizeY = sampleOptions.sizeY; RebuildKernel(); } D3D11_MAPPED_SUBRESOURCE kernelResource; CHECKDX(context->Map(sampleConstBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &kernelResource)); memcpy(kernelResource.pData, &sampleOptions, sizeof(SampleKernelOptions)); context->Unmap(sampleConstBuffer, 0); if (voxelRes != prevVoxelRes) { prevVoxelRes = voxelRes; switch (voxelRes) { case _64: numVoxels = 64; break; case _128: numVoxels = 128; break; case _256: numVoxels = 256; break; case _512: numVoxels = 512; break; case _1024: numVoxels = 1024; break; default: break; } voxelOptions.count = numVoxels; voxelOptions.width = VOXEL_STRUCTURE_WIDTH / (float)numVoxels; voxelElementCount = numVoxels * numVoxels * (numVoxels / 32); #ifdef ENABLE_VOXELDRAW delete[] voxelCPUstructure; voxelCPUstructure = new uint32[voxelElementCount]; #endif CreateVoxelBuffers(); D3D11_MAPPED_SUBRESOURCE voxelResource; CHECKDX(context->Map(voxelOptionConstBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &voxelResource)); memcpy(voxelResource.pData, &voxelOptions, sizeof(VoxelOptions)); context->Unmap(voxelOptionConstBuffer, 0); } /////////////////////// //Voxelize step /////////////////////// ID3D11RenderTargetView* RT = voxelVoidRT.GetRenderTargetView(); context->OMSetRenderTargetsAndUnorderedAccessViews(1, &RT, 0, 1, 1, &voxelUAV, nullptr); context->OMSetBlendState(voxelBlendState, nullptr, 0xffffffff); context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST); //Copy a null buffer to clear voxel structure. Needs to be done if having dynamic geometry //context->CopyResource(voxelStructure, voxelClearBuffer); D3D11_VIEWPORT voxviewPort; ZeroMemory(&voxviewPort, sizeof(D3D11_VIEWPORT)); voxviewPort.TopLeftX = 0; voxviewPort.TopLeftY = 0; voxviewPort.MinDepth = 0.0f; voxviewPort.MaxDepth = 1.0f; voxviewPort.Width = (float)numVoxels; voxviewPort.Height = (float)numVoxels; context->RSSetViewports(1, &voxviewPort); context->VSSetShader(voxelVS, 0, 0); context->GSSetShader(voxelGS, 0, 0); context->PSSetShader(voxelPS, 0, 0); context->PSSetConstantBuffers(1, 1, &voxelOptionConstBuffer); context->IASetInputLayout(voxelLayout); context->GSSetConstantBuffers(0, 1, &voxelMatBuffer); context->GSSetConstantBuffers(1, 1, &voxelOptionConstBuffer); context->RSSetState(RSStateSolid); timer->Start(); mesh->Apply(); mesh->Draw(); timer->Stop(); collectedVoxelTime += (float)timer->GetTime(); #ifdef ENABLE_VOXELDRAW if (enableDebugDraw) { context->CopyResource(voxelStagingStructure, voxelStructure); D3D11_MAPPED_SUBRESOURCE mapData; if (context->Map(voxelStagingStructure, 0, D3D11_MAP_READ, 0, &mapData) == S_OK) { memcpy(voxelCPUstructure, mapData.pData, voxelElementCount * sizeof(uint32)); context->Unmap(voxelStagingStructure, 0); } } #endif ///////////////////////////// //G-buffer pass ///////////////////////////// //Clear RTs before drawing colorRT.Clear(); normalRT.Clear(); positionRT.Clear(); context->ClearRenderTargetView(backBuffer, clearColor); context->ClearDepthStencilView(depthStencilView, D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 1.0f, 0); //Set Gbuffer RTs ID3D11RenderTargetView* RTs[] = { colorRT.GetRenderTargetView(), normalRT.GetRenderTargetView(), positionRT.GetRenderTargetView() }; ID3D11RenderTargetView* RTzero[] = { 0, 0, 0 }; context->OMSetRenderTargets(3, RTs, depthStencilView); context->OMSetBlendState(nullptr, nullptr, 0xffffffff); //Set shaders D3D11_VIEWPORT viewPort; ZeroMemory(&viewPort, sizeof(D3D11_VIEWPORT)); viewPort.TopLeftX = 0; viewPort.TopLeftY = 0; viewPort.MinDepth = 0.0f; viewPort.MaxDepth = 1.0f; viewPort.Width = WINDOW_WIDTH; viewPort.Height = WINDOW_HEIGHT; context->RSSetViewports(1, &viewPort); context->VSSetShader(VS, 0, 0); context->GSSetShader(nullptr, 0, 0); context->PSSetShader(PS, 0, 0); context->IASetInputLayout(layout); context->PSSetSamplers(0, 1, &linearSamplerState); context->VSSetConstantBuffers(0, 1, &camConstBuffer); context->RSSetState(RSStateSolid); //Draw geometry mesh->Apply(); mesh->DrawIndexed(); context->OMSetRenderTargets(3, RTzero, 0); ///////////////////////////// //Draw to backbuffer, AO pass ///////////////////////////// context->OMSetRenderTargets(1, &backBuffer, 0); context->VSSetShader(fsqVS, 0, 0); switch (drawMode) { case DRAW_NORMAL: context->PSSetShader(fsqPS, 0, 0); break; case DRAW_NO_AO: context->PSSetShader(fsqNOOcclusionPS, 0, 0); break; case DRAW_AO_ONLY: context->PSSetShader(fsqOcclusionPS, 0, 0); break; default: break; } context->IASetInputLayout(fsqlayout); colorRT.PSSetSRV(0); normalRT.PSSetSRV(1); positionRT.PSSetSRV(2); context->PSSetShaderResources(3, 1, &depthBufferView); context->PSSetShaderResources(4, 1, &voxelSRV); context->PSSetConstantBuffers(0, 1, &voxelSampleKernel); context->PSSetConstantBuffers(1, 1, &sampleConstBuffer); context->PSSetConstantBuffers(2, 1, &voxelOptionConstBuffer); context->RSSetState(RSStateSolid); timer->Start(); context->DrawInstanced(3, 1, 0, 0); timer->Stop(); collectedAOTime += (float)timer->GetTime(); //Unbind depth from input ID3D11ShaderResourceView* SRVzero[] = { 0 }; context->PSSetShaderResources(3, 1, SRVzero); //Set up some things for DXTK, to draw some lines or other primitives context->OMSetRenderTargets(1, &backBuffer, depthStencilView); basicEffect->SetView(XMLoadFloat4x4(&camera.GetCamData().viewMat)); basicEffect->Apply(context); context->IASetInputLayout(basicInputLayout); voxelCounter = 0; if(enableDebugDraw) DrawVoxels(primitiveBatch); if(enableDrawKernel) DrawKernel(primitiveBatch); TwRefreshBar(antbar); TwDraw(); swapChain->Present(0, 0); //Unbind all resources context->PSSetShaderResources(0, 1, SRVzero); context->PSSetShaderResources(1, 1, SRVzero); context->PSSetShaderResources(2, 1, SRVzero); context->PSSetShaderResources(3, 1, SRVzero); context->PSSetShaderResources(4, 1, SRVzero); } std::cout << "Exiting program!" << std::endl; //Cleanup delete primitiveBatch; delete basicEffect; delete timer; #ifdef ENABLE_VOXELDRAW delete[] voxelCPUstructure; #endif depthStencilView->Release(); RSStateSolid->Release(); RSStateWireframe->Release(); voxelBlendState->Release(); voxelStagingStructure->Release(); voxelSampleKernel->Release(); voxelClearBuffer->Release(); voxelSRV->Release(); fsqVS->Release(); fsqPS->Release(); fsqOcclusionPS->Release(); fsqNOOcclusionPS->Release(); camConstBuffer->Release(); sampleConstBuffer->Release(); voxelOptionConstBuffer->Release(); depthBufferView->Release(); layout->Release(); fsqlayout->Release(); voxelLayout->Release(); linearSamplerState->Release(); VS->Release(); PS->Release(); voxelVS->Release(); voxelGS->Release(); voxelPS->Release(); voxelStructure->Release(); voxelUAV->Release(); voxelMatBuffer->Release(); swapChain->Release(); backBuffer->Release(); device->Release(); context->Release(); basicInputLayout->Release(); SDL_DestroyWindow(window); return 0; }
void Initialize(void){ // Create the program for rendering the model OBJLoader loader; bool loadfile = loader.load("bunny.obj"); if(!loadfile) { exit(EXIT_FAILURE); } vertices = loader.getVertices(); normals = loader.getNormals(); indices = loader.getVertexIndices(); // Create and compile our GLSL program from the shaders program = LoadShaders("shader.vs", "shader.fs"); // Use our shader glUseProgram(program); view = lookAt(vec3(0.0f, 0.0f, 2.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 1.0f, 0.0f)); projection = mat4(1.0f); // Initialize shader lighting parameters glGenVertexArrays(1, &vao); glBindVertexArray(vao); glGenBuffers(2, vbo); glBindBuffer(GL_ARRAY_BUFFER, vbo[0]); glBufferData(GL_ARRAY_BUFFER, vertices.size()*sizeof(vec3), &vertices[0], GL_DYNAMIC_DRAW); glVertexAttribPointer(static_cast<GLuint>(0), 3, GL_FLOAT, GL_FALSE, 0, nullptr); glEnableVertexAttribArray(0); // Vertex position glBindBuffer(GL_ARRAY_BUFFER, vbo[1]); glBufferData(GL_ARRAY_BUFFER, normals.size() * sizeof(vec3), &normals[0], GL_STATIC_DRAW); glVertexAttribPointer(static_cast<GLuint>(1), 3, GL_FLOAT, GL_FALSE, 0, nullptr); glEnableVertexAttribArray(1); // Vertex normal glGenBuffers(1, &ebo); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo); glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size()*sizeof(int), &indices[0], GL_STATIC_DRAW); glBindVertexArray(0); vec3 light_intensity(1.0f, 1.0f, 1.0f); vec4 light_position(10.0f, 10.0f, 10.0f, 1.0f); vec3 material_ambient(0.9, 0.5, 0.3); vec3 material_diffuse(0.9, 0.5, 0.3); vec3 material_specular(0.8, 0.8, 0.8); GLfloat shininess = 100.0f; glUniform3fv(glGetUniformLocation(program, "Light.Intensity"), 1, reinterpret_cast<GLfloat*>(&light_intensity)); glUniform4fv(glGetUniformLocation(program, "Light.Position"), 1, reinterpret_cast<GLfloat*>(&light_position)); glUniform3fv(glGetUniformLocation(program, "Material.Ka"), 1, reinterpret_cast<GLfloat*>(&material_ambient)); glUniform3fv(glGetUniformLocation(program, "Material.Kd"), 1, static_cast<GLfloat*>(&material_diffuse[0])); glUniform3fv(glGetUniformLocation(program, "Material.Ks"), 1, static_cast<GLfloat*>(&material_specular[0])); glUniform1f(glGetUniformLocation(program, "Material.Shininess"), shininess); glClearColor(1.0, 1.0, 1.0, 1.0); }