void Application::Update()
{
SDL_Event event;
while (SDL_PollEvent(&event))
{
if (event.type == SDL_EventType::SDL_QUIT)
{
_running = false;
}
}
_input.Update();
if (_input.KeyPressed(SDL_SCANCODE_SPACE)) { _updateScene = !_updateScene; }
if (_input.KeyPressed(SDL_SCANCODE_G)) { _useDeferredShading = !_useDeferredShading; }
if (_input.KeyPressed(SDL_SCANCODE_T)) { _showTangents = !_showTangents; }
if (_input.KeyPressed(SDL_SCANCODE_R)) { _renderer.sortEnabled = !_renderer.sortEnabled; }
if (_input.KeyPressed(SDL_SCANCODE_F))
{
//Toggle shadow maps
for (size_t i = 0; i < _lights.size(); i++)
{
if (_lights[i].shadowMap == nullptr) { _lights[i].shadowMap = &_shadowMaps[i]; }
else { _lights[i].shadowMap = nullptr; }
}
}
if (_input.KeyPressed(SDL_SCANCODE_MINUS)) { _renderer.ignoreCount++; }
if (_input.KeyPressed(SDL_SCANCODE_EQUALS)) { _renderer.ignoreCount = Math::Max(_renderer.ignoreCount - 1, 0); }
//std::cout << "Ignoring: " << _renderer.ignoreCount << std::endl;
Simulate();
RenderShadowMaps();
if (_useDeferredShading)
{
RenderDeferred();
}
else
{
RenderForward();
}
SDL_GL_SwapWindow(_window);
}
bool SuzanneGL::InitScene()
{
std::string s = (const char *)glGetString(GL_EXTENSIONS);
OutputDebugString(s.c_str());
OutputDebugString("\n");
up = glm::vec3(0.0f, 1.0f, 0.0f);
eye = glm::vec3(3.0f, 3.0f, 5.0f);
right = glm::vec3(1.0f, 0.0f, 0.0f);
center = glm::vec3(0.0f, 0.0f, 0.0f);
// COMPILE SHADERS
std::vector<GLuint> shadowShaders;
shadowShaders.push_back(GLUtil::CreateShader(GL_VERTEX_SHADER, shaderPath + "ShadowMappingVert.glsl"));
shadowShaders.push_back(GLUtil::CreateShader(GL_FRAGMENT_SHADER, shaderPath + "ShadowMappingFrag.glsl"));
shadowShaderProgram = GLUtil::CreateProgram(shadowShaders);
for_each(shadowShaders.begin(), shadowShaders.end(), glDeleteShader);
shadowShaders.clear();
std::vector<GLuint> shaders;
shaders.push_back(GLUtil::CreateShader(GL_VERTEX_SHADER, shaderPath + "TestSceneVert.glsl"));
shaders.push_back(GLUtil::CreateShader(GL_FRAGMENT_SHADER, shaderPath + "TestSceneFrag.glsl"));
shaderProgram = GLUtil::CreateProgram(shaders);
for_each(shaders.begin(), shaders.end(), glDeleteShader);
shaders.clear();
// PREPARE MODELS
glm::mat4 matrix;
matrix = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 1.0f, 0.0f));
models.push_back(ModelGL(modelPath + "monkey.bin", modelPath + "monkey2.mtl", matrix, true));
matrix = glm::mat4(1.0f);
matrix = glm::scale(matrix, glm::vec3(5.0f, 5.0f, 5.0f));
matrix = glm::translate(matrix, glm::vec3(0.0f, 0.0f, 0.0f));
models.push_back(ModelGL(modelPath + "plane.bin", modelPath + "plane.mtl", matrix, true));
// PREPARE LIGHTING
lighting.ambient = Vector4(0.1f, 0.1f, 0.1f, 1.0f);
Light light1;
light1.position = Vector4(-5.0f, 5.0f, 5.0f, 0.0f);
light1.diffuse = Vector4(0.5f, 0.5f, 0.5f, 1.0f);
light1.specular = Vector4(0.5f, 0.5f, 0.5f, 1.0f);
Light light2;
light2.position = Vector4(5.0f, 5.0f, 5.0f, 0.0f);
light2.diffuse = Vector4(0.5f, 0.5f, 0.5f, 1.0f);
light2.specular = Vector4(0.5f, 0.5f, 0.5f, 1.0f);
lighting.lights[0] = light1;
lighting.lights[1] = light2;
GLuint lightBuffer;
glCreateBuffers(1, &lightBuffer);
glNamedBufferData(lightBuffer, sizeof(Lighting), &lighting, GL_STATIC_DRAW);
glBindBufferBase(GL_UNIFORM_BUFFER, lightBindingPoint, lightBuffer);
GLuint lightBlockIndex = glGetUniformBlockIndex(shaderProgram, "Lighting");
glUniformBlockBinding(shaderProgram, lightBlockIndex, lightBindingPoint);
RenderShadowMaps();
// SETUP FRAMEBUFFER
glClearColor(bgColor.r, bgColor.g, bgColor.b, bgColor.a);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
glEnable(GL_CULL_FACE);
glFrontFace(GL_CCW);
glCullFace(GL_BACK);
glViewport(0, 0, mWidth, mHeight);
// PREPARE MATERIAL BUFFER
glCreateBuffers(1, &materialBuffer);
glNamedBufferData(materialBuffer, sizeof(Material), NULL, GL_STATIC_DRAW);
glBindBufferBase(GL_UNIFORM_BUFFER, materialBindingPoint, materialBuffer);
GLuint materialBlockIndex = glGetUniformBlockIndex(shaderProgram, "Material");
glUniformBlockBinding(shaderProgram, materialBlockIndex, materialBindingPoint);
// UPLOAD MVP MATRICES
modelMatrixIndex = glGetUniformLocation(shaderProgram, "modelMatrix");
viewMatrixIndex = glGetUniformLocation(shaderProgram, "viewMatrix");
projectionMatrixIndex = glGetUniformLocation(shaderProgram, "projectionMatrix");
glm::mat4 viewMatrix = glm::lookAt(eye, center, up);
glProgramUniformMatrix4fv(shaderProgram, viewMatrixIndex, 1, GL_FALSE, glm::value_ptr(viewMatrix));
glm::mat4 projectionMatrix = glm::perspective(glm::radians(60.0f), 800.0f / 800.0f, 1.0f, 500.0f);
glProgramUniformMatrix4fv(shaderProgram, projectionMatrixIndex, 1, GL_FALSE, glm::value_ptr(projectionMatrix));
for (int i = 0; i < NUMBER_OF_LIGHTS; ++i)
{
glActiveTexture(GL_TEXTURE0 + i);
glBindTexture(GL_TEXTURE_2D, shadowMaps[i]);
}
return true;
}
bool SuzanneDX::InitScene()
{
XMStoreFloat4(&up, XMVectorSet(0.0f, 1.0f, 0.0f, 1.0f));
XMStoreFloat4(&eye, XMVectorSet(3.0f, 3.0f, 5.0f, 1.0f));
XMStoreFloat4(&right, XMVectorSet(1.0f, 0.0f, 0.0f, 1.0f));
XMStoreFloat4(¢er, XMVectorSet(0.0f, 0.0f, 0.0f, 1.0f));
ID3D11RasterizerState1 *rasterizerState;
D3D11_RASTERIZER_DESC1 rasterizerDesc;
ZeroMemory(&rasterizerDesc, sizeof(rasterizerDesc));
rasterizerDesc.CullMode = D3D11_CULL_BACK;
rasterizerDesc.FillMode = D3D11_FILL_SOLID;
rasterizerDesc.FrontCounterClockwise = true;
mDevice->CreateRasterizerState1(&rasterizerDesc, &rasterizerState);
mDeviceContext->RSSetState(rasterizerState);
rasterizerState->Release();
// COMPILE SHADERS
D3DCompileFromFile(Util::s2ws(shaderPath + "TestSceneVert.hlsl").c_str(), NULL, NULL, "vertexShader", "vs_5_0", NULL, NULL, &vertexShaderBuffer, NULL);
D3DCompileFromFile(Util::s2ws(shaderPath + "TestSceneFrag.hlsl").c_str(), NULL, NULL, "pixelShader", "ps_5_0", NULL, NULL, &pixelShaderBuffer, NULL);
mDevice->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &vertexShader);
mDevice->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &pixelShader);
D3DCompileFromFile(Util::s2ws(shaderPath + "ShadowMappingVert.hlsl").c_str(), NULL, NULL, "vertexShader", "vs_5_0", NULL, NULL, &shadowVertexShaderBuffer, NULL);
D3DCompileFromFile(Util::s2ws(shaderPath + "ShadowMappingFrag.hlsl").c_str(), NULL, NULL, "pixelShader", "ps_5_0", NULL, NULL, &shadowPixelShaderBuffer, NULL);
mDevice->CreateVertexShader(shadowVertexShaderBuffer->GetBufferPointer(), shadowVertexShaderBuffer->GetBufferSize(), NULL, &shadowVertexShader);
mDevice->CreatePixelShader(shadowPixelShaderBuffer->GetBufferPointer(), shadowPixelShaderBuffer->GetBufferSize(), NULL, &shadowPixelShader);
// PREPARE MODELS
std::vector<D3D11_INPUT_ELEMENT_DESC> vertexLayout;
vertexLayout.push_back({ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 });
vertexLayout.push_back({ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, sizeof(Vertex().position), D3D11_INPUT_PER_VERTEX_DATA, 0 });
XMMATRIX modelMatrix;
modelMatrix = XMMatrixTranslation(0.0f, 1.0f, 0.0f);
models.push_back(ModelDX(modelPath + "monkey.bin", modelPath + "monkey2.mtl", mDevice, vertexShaderBuffer, vertexLayout, modelMatrix, true));
modelMatrix = XMMatrixScaling(5.0f, 5.0f, 5.0f);
models.push_back(ModelDX(modelPath + "plane.bin", modelPath + "plane.mtl", mDevice, vertexShaderBuffer, vertexLayout, modelMatrix, true));
// PREPARE LIGHTING
lighting.ambient = Vector4(0.1f, 0.1f, 0.1f, 1.0f);
Light light1;
light1.position = Vector4(-5.0f, 5.0f, 5.0f, 0.0f);
light1.diffuse = Vector4(0.5f, 0.5f, 0.5f, 1.0f);
light1.specular = Vector4(0.5f, 0.5f, 0.5f, 1.0f);
Light light2;
light2.position = Vector4(5.0f, 5.0f, 5.0f, 0.0f);
light2.diffuse = Vector4(0.5f, 0.5f, 0.5f, 1.0f);
light2.specular = Vector4(0.5f, 0.5f, 0.5f, 1.0f);
lighting.lights[0] = light1;
lighting.lights[1] = light2;
D3D11_BUFFER_DESC lightDesc;
ZeroMemory(&lightDesc, sizeof(lightDesc));
lightDesc.ByteWidth = sizeof(Lighting);
lightDesc.Usage = D3D11_USAGE_DEFAULT;
lightDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
lightDesc.CPUAccessFlags = 0;
D3D11_SUBRESOURCE_DATA lightData;
ZeroMemory(&lightData, sizeof(lightData));
lightData.pSysMem = &lighting;
ID3D11Buffer* lightBuffer;
mDevice->CreateBuffer(&lightDesc, &lightData, &lightBuffer);
mDeviceContext->VSSetConstantBuffers(lightBufferSlot, 1, &lightBuffer);
mDeviceContext->PSSetConstantBuffers(lightBufferSlot, 1, &lightBuffer);
lightBuffer->Release();
RenderShadowMaps();
D3D11_SAMPLER_DESC samplerDesc;
ZeroMemory(&samplerDesc, sizeof(samplerDesc));
samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_BORDER;
samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_BORDER;
samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_BORDER;
samplerDesc.BorderColor[0] = 1.0f;
samplerDesc.BorderColor[1] = 1.0f;
samplerDesc.BorderColor[2] = 1.0f;
samplerDesc.BorderColor[3] = 1.0f;
samplerDesc.MinLOD = 0.f;
samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
samplerDesc.MipLODBias = 0.f;
samplerDesc.MaxAnisotropy = 0;
samplerDesc.ComparisonFunc = D3D11_COMPARISON_LESS_EQUAL;
samplerDesc.Filter = D3D11_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR;
mDevice->CreateSamplerState(&samplerDesc, &shadowMapSamplerState);
// PREPARE MATERIAL BUFFER
D3D11_BUFFER_DESC materialDesc;
ZeroMemory(&materialDesc, sizeof(materialDesc));
materialDesc.ByteWidth = sizeof(Material);
materialDesc.Usage = D3D11_USAGE_DEFAULT;
materialDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
materialDesc.CPUAccessFlags = 0;
mDevice->CreateBuffer(&materialDesc, NULL, &materialBuffer);
mDeviceContext->PSSetConstantBuffers(materialBufferSlot, 1, &materialBuffer);
// PREPARE VIEW AND PROJECTION
XMMATRIX viewMatrix = XMMatrixLookAtRH(XMLoadFloat4(&eye), XMLoadFloat4(¢er), XMLoadFloat4(&up));
viewMatrixBuffer = DXUtil::CreateMatrixBuffer(mDevice, viewMatrix);
mDeviceContext->VSSetConstantBuffers(viewMatrixBufferSlot, 1, &viewMatrixBuffer);
XMMATRIX projectionMatrix = XMMatrixPerspectiveFovRH(XMConvertToRadians(60.0f), 800 / 800, 1.0f, 500.0f);
ID3D11Buffer* projectionMatrixBuffer = DXUtil::CreateMatrixBuffer(mDevice, projectionMatrix);
mDeviceContext->VSSetConstantBuffers(projectionMatrixBufferSlot, 1, &projectionMatrixBuffer);
projectionMatrixBuffer->Release();
mDeviceContext->PSSetShaderResources(0, 2, &shadowMapResources[0]);
mDeviceContext->PSSetSamplers(0, 1, &shadowMapSamplerState);
return true;
}
