More terrain work

Author: htmlboss

MP-APS/.vs/MP-APS/v15/.suo

@@ -30,6 +30,8 @@ void RenderSystem::Init(const pugi::xml_node& rendererNode) {
 std::cout << "OpenGL Renderer: " << glGetString(GL_RENDERER) << '\n';
 #endif
 
+getHardwareFeatures();
+
 const auto width = rendererNode.attribute("width").as_uint();
 const auto height = rendererNode.attribute("height").as_uint();
 
@@ -38,7 +40,7 @@ void RenderSystem::Init(const pugi::xml_node& rendererNode) {
 m_shadowMapResolution = rendererNode.attribute("shadowResolution").as_uint();
 
 m_hdrFBO.Init("HDR FBO", width, height);
-m_skybox.Init("Data/hdri/barcelona.hdr", 2048);
+m_skybox.Init("Data/hdri/hdriHaven4k.hdr", 3072);
 
 // Compile all shader programs in config.xml
 for (auto program = rendererNode.child("Program"); program; program = program.next_sibling("Program")) {
@@ -49,15 +51,18 @@ void RenderSystem::Init(const pugi::xml_node& rendererNode) {
 shaders.emplace_back(shader.attribute("path").as_string(), shader.attribute("type").as_string());
 }
 
+//GLShaderProgram prgrm;
+//prgrm.Init(program.attribute("name").as_string(), shaders);
+
 // Compile and cache shader program
+//m_shaderCache.try_emplace(program.attribute("name").as_string(), prgrm);
 m_shaderCache.try_emplace(program.attribute("name").as_string(), program.attribute("name").as_string(), shaders);
 }
 
 setupScreenquad();
 setupTextureSamplers();
 setupShadowMap();
 setupPostProcessing();
-
 
 #ifdef _DEBUG
 glEnable(GL_DEBUG_OUTPUT);
@@ -169,32 +174,42 @@ void RenderSystem::Render(const SceneBase& scene, const bool wireframe) {
 }
 
 /***********************************************************************************/
-// TODO: This needs to be gutted and put elsewhere
-void RenderSystem::InitView(const Camera& camera) {
-m_projMatrix = camera.GetProjMatrix(m_width, m_height);
-glBindBuffer(GL_UNIFORM_BUFFER, m_uboMatrices);
-glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(glm::mat4), value_ptr(m_projMatrix));
+void RenderSystem::InitScene(const SceneBase& scene) {
+//m_skybox.Init(scene.m_skyboxPath, scene.m_skyboxResolution);
+
+setProjectionMatrix(scene.m_camera);
 }
 
 /***********************************************************************************/
-void RenderSystem::Update(const Camera& camera, const double delta) {
+void RenderSystem::Update(const SceneBase& scene, const double delta) {
 
 // Window size changed.
 if (Input::GetInstance().ShouldResize()) {
 m_width = Input::GetInstance().GetWidth();
 m_height = Input::GetInstance().GetHeight();
 
-InitView(camera);
+setProjectionMatrix(scene.m_camera);
+
 glViewport(0, 0, m_width, m_height);
 m_shadowDepthFBO.Resize(m_width, m_height);
 }
 
 // Update view matrix inside UBO
-const auto view = camera.GetViewMatrix();
+const auto view = scene.m_camera.GetViewMatrix();
 glBindBuffer(GL_UNIFORM_BUFFER, m_uboMatrices);
 glBufferSubData(GL_UNIFORM_BUFFER, sizeof(glm::mat4), sizeof(glm::mat4), glm::value_ptr(view));
 }
 
+/***********************************************************************************/
+void RenderSystem::getHardwareFeatures() {
+glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &m_features.MaxAnisotropy);
+glGetIntegerv(GL_MAX_ARRAY_TEXTURE_LAYERS, &m_features.MaxArrayTextureLayers);
+glGetIntegerv(GL_MAX_COLOR_TEXTURE_SAMPLES, &m_features.MaxTextureSamples);
+glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &m_features.MaxTextureSamplers);
+glGetIntegerv(GL_MAX_VERTEX_UNIFORM_BLOCKS, &m_features.MaxVertexUniformBlocks);
+// finish getting hardware features
+}
+
 /***********************************************************************************/
 void RenderSystem::setDefaultState() {
 glFrontFace(GL_CCW);
@@ -264,6 +279,10 @@ void RenderSystem::renderQuad() const {
 
 /***********************************************************************************/
 void RenderSystem::renderShadowMap(const SceneBase& scene) {
+setDefaultState();
+glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+glBindBuffer(GL_UNIFORM_BUFFER, m_uboMatrices);
+
 static auto& shadowDepthShader = m_shaderCache.at("ShadowDepthShader");
 shadowDepthShader.Bind();
 static constexpr float near_plane = 0.0f, far_plane = 100.0f;
@@ -289,7 +308,6 @@ void RenderSystem::renderShadowMap(const SceneBase& scene) {
 glCullFace(GL_BACK);
 }
 
-
 /***********************************************************************************/
 void RenderSystem::setupScreenquad() {
 const std::array<Vertex, 4> screenQuadVertices {
@@ -312,17 +330,13 @@ void RenderSystem::setupScreenquad() {
 
 /***********************************************************************************/
 void RenderSystem::setupTextureSamplers() {
-// Find max supported hardware anisotropy
-float aniso = 0.0f;
-glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &aniso);
-
 // Sampler for PBR textures used on meshes
 glGenSamplers(1, &m_samplerPBRTextures);
 glSamplerParameteri(m_samplerPBRTextures, GL_TEXTURE_WRAP_S, GL_REPEAT);
 glSamplerParameteri(m_samplerPBRTextures, GL_TEXTURE_WRAP_T, GL_REPEAT);
 glSamplerParameteri(m_samplerPBRTextures, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
 glSamplerParameteri(m_samplerPBRTextures, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-glSamplerParameterf(m_samplerPBRTextures, GL_TEXTURE_MAX_ANISOTROPY_EXT, aniso);
+glSamplerParameterf(m_samplerPBRTextures, GL_TEXTURE_MAX_ANISOTROPY_EXT, m_features.MaxAnisotropy);
 
 }
 
@@ -419,3 +433,10 @@ void RenderSystem::setupPostProcessing() {
 bloomBlendShader.SetUniform("vibranceCoefficient", m_coefficient);
 
 }
+
+/***********************************************************************************/
+void RenderSystem::setProjectionMatrix(const Camera& camera) {
+m_projMatrix = camera.GetProjMatrix(m_width, m_height);
+glBindBuffer(GL_UNIFORM_BUFFER, m_uboMatrices);
+glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(glm::mat4), value_ptr(m_projMatrix));
+}

MP-APS/.vs/MP-APS/v15/Browse.VC.db

@@ -8,6 +8,9 @@
 
 #include <unordered_map>
 
+//https://github.com/tapio/weep/blob/master/engine/glrenderer/renderdevice.cpp
+// https://github.com/pboechat/PCSS
+
 /***********************************************************************************/
 // Forward Declarations
 class Camera;
@@ -31,18 +34,31 @@ class RenderSystem {
 ~RenderSystem() = default;
 
 void Init(const pugi::xml_node& rendererNode);
-void Update(const Camera& camera, const double delta);
+void Update(const SceneBase& scene, const double delta);
 // Release OpenGL resources
 void Shutdown() const;
 
-void InitView(const Camera& camera);
+void InitScene(const SceneBase& scene);
 
 // Where the magic happens
 void Render(const SceneBase& scene, const bool wireframe = false);
 
 private:
-// Helper functions
+struct Features {
+float MaxAnisotropy;
+int MaxArrayTextureLayers;
+int MaxTextureSamples;
+int MaxTextureSamplers;
+int MaxVertexUniformBlocks;
+int MaxGeometryUniformBlocks;
+int MaxFragmentUniformBlocks;
+int MaxComputeWorkGroupSize;
+int MaxComputeWorkGroupCount;
+} m_features;
 
+// Helper functions
+
+void getHardwareFeatures();
 // Sets the default state required for rendering
 void setDefaultState();
 // Render models contained in the renderlist
@@ -61,6 +77,8 @@ class RenderSystem {
 void setupShadowMap();
 // Configure post-processing effects
 void setupPostProcessing();
+// Sets projection matrix variable and updates UBO
+void setProjectionMatrix(const Camera& camera);
 
 // Screen dimensions
 std::size_t m_width, m_height;

MP-APS/AI/AISystem.cpp

@@ -46,9 +46,19 @@ float ComputeShadow(const vec4 fragPosLightSpace, const vec3 N, const vec3 L) {
 
  const float closestDepth = texture(shadowMap, projCoords.xy).r; 
  const float currentDepth = projCoords.z;
-
  const float bias = max(0.05 * (1.0 - dot(N, L)), 0.005); // Bias to solve shadow acne
- const float shadow = currentDepth - bias > closestDepth ? 1.0 : 0.0; 
+ 
+ // PCF
+ float shadow = 0.0;
+ const vec2 texelSize = 1.0 / textureSize(shadowMap, 0);
+ for(int x = -2; x <= 2; ++x) {
+ for(int y = -2; y <= 2; ++y) {
+ const float pcfDepth = texture(shadowMap, projCoords.xy + vec2(x, y) * texelSize).r; 
+ shadow += currentDepth - bias > pcfDepth ? 1.0 : 0.0; 
+ } 
+ }
+ 
+ shadow /= 25.0;
 
  return shadow;
 }