1048 lines
41 KiB
C++
1048 lines
41 KiB
C++
// main.cpp
|
|
//
|
|
// A physically based renderer that demonstrates height mapping via parallax,
|
|
// improved lighting (point & directional lights), and renders a skybox for background.
|
|
// It uses procedural spheres and a plane. Materials (including height maps) can be loaded
|
|
// and saved via YAML (using yaml-cpp) and are editable via ImGui.
|
|
//
|
|
// Compile (on Linux):
|
|
// g++ main.cpp -lglfw -lGLEW -lGL -ldl -limgui -lyaml-cpp -o pbr_renderer
|
|
//
|
|
// Adjust library paths and names as needed.
|
|
|
|
#include <GL/glew.h>
|
|
#include <GLFW/glfw3.h>
|
|
|
|
#include <glm/glm.hpp>
|
|
#include <glm/gtc/matrix_transform.hpp>
|
|
#include <glm/gtc/type_ptr.hpp>
|
|
|
|
#include <fstream>
|
|
#include <iostream>
|
|
#include <vector>
|
|
#include <cmath>
|
|
#include <cstring>
|
|
#include <string>
|
|
#include <sstream>
|
|
|
|
// ImGui includes.
|
|
#include "imgui.h"
|
|
#include "imgui_internal.h" // For IM_PI
|
|
#include "imgui_impl_glfw.h"
|
|
#include "imgui_impl_opengl3.h"
|
|
|
|
// stb_image for texture loading.
|
|
#define STB_IMAGE_IMPLEMENTATION
|
|
#include "stb_image.h"
|
|
|
|
// yaml-cpp for YAML material loading/saving.
|
|
#include <yaml-cpp/yaml.h>
|
|
|
|
// ------------------------------------------
|
|
// Shader sources
|
|
// ------------------------------------------
|
|
|
|
// Vertex Shader (common to objects)
|
|
const char* vertexShaderSource = R"(
|
|
#version 330 core
|
|
layout (location = 0) in vec3 aPos; // position
|
|
layout (location = 1) in vec3 aNormal; // normal
|
|
layout (location = 2) in vec2 aTexCoords; // texture coordinates
|
|
layout (location = 3) in vec3 aTangent; // tangent
|
|
|
|
out vec3 WorldPos;
|
|
out vec3 Normal;
|
|
out vec2 TexCoords;
|
|
out vec3 Tangent;
|
|
|
|
uniform mat4 model;
|
|
uniform mat4 view;
|
|
uniform mat4 projection;
|
|
|
|
void main(){
|
|
WorldPos = vec3(model * vec4(aPos, 1.0));
|
|
Normal = mat3(transpose(inverse(model))) * aNormal;
|
|
Tangent = mat3(model) * aTangent; // simple transform (ignore scale issues)
|
|
TexCoords = aTexCoords;
|
|
gl_Position = projection * view * vec4(WorldPos, 1.0);
|
|
}
|
|
)";
|
|
|
|
// Fragment Shader with parallax (height) mapping and two light types.
|
|
const char* fragmentShaderSource = R"(#version 330 core
|
|
out vec4 FragColor;
|
|
|
|
in vec3 WorldPos;
|
|
in vec3 Normal;
|
|
in vec2 TexCoords;
|
|
in vec3 Tangent;
|
|
|
|
uniform vec3 camPos;
|
|
|
|
// Base material uniforms.
|
|
uniform vec3 albedo;
|
|
uniform float metallic;
|
|
uniform float roughness;
|
|
uniform float ao;
|
|
|
|
// Texture samplers & usage flags.
|
|
uniform bool useAlbedoMap;
|
|
uniform bool useMetallicMap;
|
|
uniform bool useRoughnessMap;
|
|
uniform bool useAOMap;
|
|
uniform bool useNormalMap;
|
|
uniform bool useHeightMap; // Height map flag
|
|
|
|
uniform sampler2D albedoMap;
|
|
uniform sampler2D metallicMap;
|
|
uniform sampler2D roughnessMap;
|
|
uniform sampler2D aoMap;
|
|
uniform sampler2D normalMap;
|
|
uniform sampler2D heightMap; // Height map sampler
|
|
|
|
// Parallax mapping scale factor.
|
|
uniform float parallaxScale;
|
|
|
|
// Use ImGui's internal PI constant.
|
|
uniform float PI;
|
|
|
|
// Point light uniforms.
|
|
uniform vec3 pointLightPos;
|
|
uniform vec3 pointLightColor;
|
|
|
|
// Directional light uniforms.
|
|
uniform bool useDirLight;
|
|
uniform vec3 dirLightDir;
|
|
uniform vec3 dirLightColor;
|
|
|
|
// NEW: Environment reflection uniforms.
|
|
uniform samplerCube envMap;
|
|
uniform float envReflectionIntensity;
|
|
|
|
//
|
|
// Helper functions for PBR
|
|
//
|
|
vec3 fresnelSchlick(float cosTheta, vec3 F0) {
|
|
return F0 + (1.0 - F0) * pow(1.0 - cosTheta, 5.0);
|
|
}
|
|
|
|
float DistributionGGX(vec3 N, vec3 H, float roughness) {
|
|
float a = roughness * roughness;
|
|
float a2 = a * a;
|
|
float NdotH = max(dot(N, H), 0.0);
|
|
float NdotH2 = NdotH * NdotH;
|
|
float denom = (NdotH2 * (a2 - 1.0) + 1.0);
|
|
denom = PI * denom * denom;
|
|
return a2 / max(denom, 0.001);
|
|
}
|
|
|
|
float GeometrySchlickGGX(float NdotV, float roughness) {
|
|
float r = roughness + 1.0;
|
|
float k = (r * r) / 8.0;
|
|
return NdotV / (NdotV * (1.0 - k) + k);
|
|
}
|
|
|
|
float GeometrySmith(vec3 N, vec3 V, vec3 L, float roughness) {
|
|
float NdotV = max(dot(N, V), 0.0);
|
|
float NdotL = max(dot(N, L), 0.0);
|
|
float ggx1 = GeometrySchlickGGX(NdotV, roughness);
|
|
float ggx2 = GeometrySchlickGGX(NdotL, roughness);
|
|
return ggx1 * ggx2;
|
|
}
|
|
|
|
void main(){
|
|
// Start with the input geometry normal.
|
|
vec3 Nn = normalize(Normal);
|
|
|
|
// Compute the TBN matrix if using normal or height maps.
|
|
mat3 TBN = mat3(1.0);
|
|
if (useNormalMap || useHeightMap) {
|
|
vec3 T = normalize(Tangent);
|
|
vec3 B = normalize(cross(Normal, T));
|
|
TBN = mat3(T, B, Normal);
|
|
}
|
|
|
|
// Compute modified texture coordinates (parallax mapping) if height mapping is enabled.
|
|
vec2 texCoordsModified = TexCoords;
|
|
if (useHeightMap) {
|
|
// Transform view direction into tangent space.
|
|
vec3 viewDirT = normalize(TBN * (camPos - WorldPos));
|
|
// Sample the height value.
|
|
float heightValue = texture(heightMap, TexCoords).r;
|
|
// Offset the texture coordinates.
|
|
texCoordsModified = TexCoords - viewDirT.xy * (heightValue * parallaxScale);
|
|
}
|
|
|
|
// Apply normal mapping if enabled.
|
|
if (useNormalMap) {
|
|
vec3 tangentNormal = texture(normalMap, texCoordsModified).rgb;
|
|
tangentNormal = tangentNormal * 2.0 - 1.0;
|
|
Nn = normalize(TBN * tangentNormal);
|
|
}
|
|
|
|
vec3 V = normalize(camPos - WorldPos);
|
|
|
|
// Sample material textures using modified texture coordinates.
|
|
vec3 albedoValue = albedo;
|
|
if (useAlbedoMap)
|
|
albedoValue = texture(albedoMap, texCoordsModified).rgb;
|
|
|
|
float metallicValue = metallic;
|
|
if (useMetallicMap)
|
|
metallicValue = texture(metallicMap, texCoordsModified).r;
|
|
|
|
float roughnessValue = roughness;
|
|
if (useRoughnessMap)
|
|
roughnessValue = texture(roughnessMap, texCoordsModified).r;
|
|
|
|
float aoValue = ao;
|
|
if (useAOMap)
|
|
aoValue = texture(aoMap, texCoordsModified).r;
|
|
|
|
// Calculate reflectance at normal incidence.
|
|
vec3 F0 = vec3(0.04);
|
|
F0 = mix(F0, albedoValue, metallicValue);
|
|
|
|
// --- Compute point light contribution ---
|
|
vec3 Lp = normalize(pointLightPos - WorldPos);
|
|
vec3 Hp = normalize(V + Lp);
|
|
float NDFp = DistributionGGX(Nn, Hp, roughnessValue);
|
|
float Gp = GeometrySmith(Nn, V, Lp, roughnessValue);
|
|
vec3 Fp = fresnelSchlick(max(dot(Hp, V), 0.0), F0);
|
|
vec3 numeratorP = NDFp * Gp * Fp;
|
|
float denominatorP = 4.0 * max(dot(Nn, V), 0.0) * max(dot(Nn, Lp), 0.0) + 0.001;
|
|
vec3 specularP = numeratorP / denominatorP;
|
|
|
|
vec3 kS = Fp;
|
|
vec3 kD = vec3(1.0) - kS;
|
|
kD *= 1.0 - metallicValue;
|
|
float NdotLp = max(dot(Nn, Lp), 0.0);
|
|
vec3 irradianceP = pointLightColor * NdotLp;
|
|
vec3 diffuseP = (albedoValue / PI);
|
|
vec3 lightingPoint = (kD * diffuseP + specularP) * irradianceP;
|
|
|
|
// --- Compute directional light contribution ---
|
|
vec3 lightingDir = vec3(0.0);
|
|
if (useDirLight) {
|
|
vec3 Ld = normalize(-dirLightDir);
|
|
vec3 Hd = normalize(V + Ld);
|
|
float NDFd = DistributionGGX(Nn, Hd, roughnessValue);
|
|
float Gd = GeometrySmith(Nn, V, Ld, roughnessValue);
|
|
vec3 Fd = fresnelSchlick(max(dot(Hd, V), 0.0), F0);
|
|
vec3 numeratorD = NDFd * Gd * Fd;
|
|
float denominatorD = 4.0 * max(dot(Nn, V), 0.0) * max(dot(Nn, Ld), 0.0) + 0.001;
|
|
vec3 specularD = numeratorD / denominatorD;
|
|
vec3 kS_d = Fd;
|
|
vec3 kD_d = vec3(1.0) - kS_d;
|
|
kD_d *= 1.0 - metallicValue;
|
|
float NdotLd = max(dot(Nn, Ld), 0.0);
|
|
vec3 irradianceD = dirLightColor * NdotLd;
|
|
vec3 diffuseD = (albedoValue / PI);
|
|
lightingDir = (kD_d * diffuseD + specularD) * irradianceD;
|
|
}
|
|
|
|
// Sum direct lighting contributions.
|
|
vec3 lighting = lightingPoint + lightingDir;
|
|
|
|
// --- Compute environment reflection contribution ---
|
|
// Calculate reflection vector and sample cubemap.
|
|
vec3 R = reflect(-V, Nn);
|
|
vec3 envSpec = texture(envMap, R).rgb;
|
|
lighting += envSpec * envReflectionIntensity;
|
|
|
|
// Add a simple ambient term.
|
|
vec3 ambient = vec3(0.03) * albedoValue * aoValue;
|
|
lighting += ambient;
|
|
|
|
// Tone mapping and gamma correction.
|
|
lighting = lighting / (lighting + vec3(1.0));
|
|
lighting = pow(lighting, vec3(1.0/2.2));
|
|
|
|
FragColor = vec4(lighting, 1.0);
|
|
}
|
|
|
|
)";
|
|
|
|
// Skybox shaders
|
|
const char* skyboxVertexShaderSource = R"(
|
|
#version 330 core
|
|
layout (location = 0) in vec3 aPos;
|
|
out vec3 TexCoords;
|
|
|
|
uniform mat4 view;
|
|
uniform mat4 projection;
|
|
void main(){
|
|
TexCoords = aPos;
|
|
vec4 pos = projection * view * vec4(aPos, 1.0);
|
|
gl_Position = pos.xyww; // set w component to 1.0 to always pass depth test
|
|
}
|
|
)";
|
|
|
|
const char* skyboxFragmentShaderSource = R"(
|
|
#version 330 core
|
|
out vec4 FragColor;
|
|
in vec3 TexCoords;
|
|
uniform samplerCube skybox;
|
|
void main(){
|
|
FragColor = texture(skybox, TexCoords);
|
|
}
|
|
)";
|
|
|
|
// ------------------------------------------
|
|
// Helper functions
|
|
// ------------------------------------------
|
|
GLuint compileShader(GLenum type, const char* source) {
|
|
GLuint shader = glCreateShader(type);
|
|
glShaderSource(shader, 1, &source, nullptr);
|
|
glCompileShader(shader);
|
|
GLint success;
|
|
glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
|
|
if(!success) {
|
|
char infoLog[512];
|
|
glGetShaderInfoLog(shader,512,nullptr,infoLog);
|
|
std::cerr << "Shader compile error:\n" << infoLog << std::endl;
|
|
}
|
|
return shader;
|
|
}
|
|
|
|
GLuint createProgram(GLuint vs, GLuint fs) {
|
|
GLuint program = glCreateProgram();
|
|
glAttachShader(program, vs);
|
|
glAttachShader(program, fs);
|
|
glLinkProgram(program);
|
|
GLint success;
|
|
glGetProgramiv(program, GL_LINK_STATUS, &success);
|
|
if(!success) {
|
|
char infoLog[512];
|
|
glGetProgramInfoLog(program,512,nullptr,infoLog);
|
|
std::cerr << "Program link error:\n" << infoLog << std::endl;
|
|
}
|
|
return program;
|
|
}
|
|
|
|
GLuint LoadTexture(const char* path) {
|
|
int width, height, nrChannels;
|
|
stbi_set_flip_vertically_on_load(true);
|
|
unsigned char* data = stbi_load(path, &width, &height, &nrChannels, 0);
|
|
if(!data) {
|
|
std::cerr << "Failed to load texture: " << path << std::endl;
|
|
return 0;
|
|
}
|
|
GLenum format;
|
|
if(nrChannels == 1)
|
|
format = GL_RED;
|
|
else if(nrChannels == 3)
|
|
format = GL_RGB;
|
|
else if(nrChannels == 4)
|
|
format = GL_RGBA;
|
|
GLuint texID;
|
|
glGenTextures(1, &texID);
|
|
glBindTexture(GL_TEXTURE_2D, texID);
|
|
glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data);
|
|
glGenerateMipmap(GL_TEXTURE_2D);
|
|
// Set texture parameters.
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
stbi_image_free(data);
|
|
return texID;
|
|
}
|
|
|
|
// Load a cubemap (skybox) from 6 images. Expect faces in order: right, left, top, bottom, front, back.
|
|
GLuint loadCubemap(std::vector<std::string> faces) {
|
|
GLuint textureID;
|
|
glGenTextures(1, &textureID);
|
|
glBindTexture(GL_TEXTURE_CUBE_MAP, textureID);
|
|
int width, height, nrChannels;
|
|
for(unsigned int i=0; i<faces.size(); i++){
|
|
unsigned char* data = stbi_load(faces[i].c_str(), &width, &height, &nrChannels, 0);
|
|
if(data){
|
|
GLenum format;
|
|
if(nrChannels == 1)
|
|
format = GL_RED;
|
|
else if(nrChannels == 3)
|
|
format = GL_RGB;
|
|
else if(nrChannels == 4)
|
|
format = GL_RGBA;
|
|
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i,
|
|
0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data);
|
|
stbi_image_free(data);
|
|
} else {
|
|
std::cerr << "Cubemap texture failed to load at path: " << faces[i] << std::endl;
|
|
stbi_image_free(data);
|
|
}
|
|
}
|
|
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
|
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
|
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
|
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
|
|
return textureID;
|
|
}
|
|
|
|
// Generate a sphere mesh with per-vertex: position (3), normal (3), texcoords (2), tangent (3)
|
|
// (Total 11 floats per vertex)
|
|
void generateSphereMesh(std::vector<float>& vertices, std::vector<unsigned int>& indices, unsigned int X_SEGMENTS = 64, unsigned int Y_SEGMENTS = 64) {
|
|
vertices.clear();
|
|
indices.clear();
|
|
for (unsigned int y = 0; y <= Y_SEGMENTS; ++y) {
|
|
for (unsigned int x = 0; x <= X_SEGMENTS; ++x) {
|
|
float xSegment = (float)x / (float)X_SEGMENTS;
|
|
float ySegment = (float)y / (float)Y_SEGMENTS;
|
|
float xPos = std::cos(xSegment * 2.0f * IM_PI) * std::sin(ySegment * IM_PI);
|
|
float yPos = std::cos(ySegment * IM_PI);
|
|
float zPos = std::sin(xSegment * 2.0f * IM_PI) * std::sin(ySegment * IM_PI);
|
|
// Position.
|
|
vertices.push_back(xPos);
|
|
vertices.push_back(yPos);
|
|
vertices.push_back(zPos);
|
|
// Normal (for a unit sphere, same as position).
|
|
vertices.push_back(xPos);
|
|
vertices.push_back(yPos);
|
|
vertices.push_back(zPos);
|
|
// Texcoords.
|
|
vertices.push_back(xSegment);
|
|
vertices.push_back(ySegment);
|
|
// Tangent: approximate (derivative with respect to u).
|
|
float tangentX = -std::sin(xSegment * 2.0f * IM_PI);
|
|
float tangentY = 0.0f;
|
|
float tangentZ = std::cos(xSegment * 2.0f * IM_PI);
|
|
vertices.push_back(tangentX);
|
|
vertices.push_back(tangentY);
|
|
vertices.push_back(tangentZ);
|
|
}
|
|
}
|
|
for (unsigned int y = 0; y < Y_SEGMENTS; ++y) {
|
|
for (unsigned int x = 0; x < X_SEGMENTS; ++x) {
|
|
unsigned int i0 = y * (X_SEGMENTS + 1) + x;
|
|
unsigned int i1 = i0 + 1;
|
|
unsigned int i2 = i0 + (X_SEGMENTS + 1);
|
|
unsigned int i3 = i2 + 1;
|
|
indices.push_back(i0);
|
|
indices.push_back(i2);
|
|
indices.push_back(i1);
|
|
indices.push_back(i1);
|
|
indices.push_back(i2);
|
|
indices.push_back(i3);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Generate a plane mesh (quad) in the XZ plane centered at origin.
|
|
// The plane spans [-1,1] in X and Z, y=0.
|
|
void generatePlaneMesh(std::vector<float>& vertices, std::vector<unsigned int>& indices) {
|
|
// 4 vertices: position (3), normal (3), texcoords (2), tangent (3) = 11 floats.
|
|
float planeVerts[] = {
|
|
// positions // normals // texcoords // tangent
|
|
-1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f,
|
|
1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f,
|
|
1.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f,
|
|
-1.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f,
|
|
};
|
|
unsigned int planeIndices[] = {
|
|
0, 1, 2,
|
|
0, 2, 3
|
|
};
|
|
vertices.assign(planeVerts, planeVerts + sizeof(planeVerts) / sizeof(float));
|
|
indices.assign(planeIndices, planeIndices + sizeof(planeIndices)/sizeof(unsigned int));
|
|
}
|
|
|
|
// ------------------------------------------
|
|
// Material and Object Structures
|
|
// ------------------------------------------
|
|
// Extend Material to include height map.
|
|
struct Material {
|
|
glm::vec3 albedo;
|
|
float metallic;
|
|
float roughness;
|
|
float ao;
|
|
|
|
// Texture IDs.
|
|
GLuint albedoTex;
|
|
GLuint metallicTex;
|
|
GLuint roughnessTex;
|
|
GLuint aoTex;
|
|
GLuint normalTex;
|
|
GLuint heightTex; // new height map texture.
|
|
|
|
// Flags indicating texture usage.
|
|
bool useAlbedoMap;
|
|
bool useMetallicMap;
|
|
bool useRoughnessMap;
|
|
bool useAOMap;
|
|
bool useNormalMap;
|
|
bool useHeightMap; // flag for height map
|
|
|
|
// File path buffers.
|
|
char albedoPath[256];
|
|
char metallicPath[256];
|
|
char roughnessPath[256];
|
|
char aoPath[256];
|
|
char normalPath[256];
|
|
char heightPath[256]; // file path for height map.
|
|
|
|
Material() : albedo(0.5f, 0.0f, 0.0f), metallic(0.0f), roughness(0.5f), ao(1.0f),
|
|
albedoTex(0), metallicTex(0), roughnessTex(0), aoTex(0), normalTex(0), heightTex(0),
|
|
useAlbedoMap(false), useMetallicMap(false), useRoughnessMap(false),
|
|
useAOMap(false), useNormalMap(false), useHeightMap(false)
|
|
{
|
|
strcpy(albedoPath, "");
|
|
strcpy(metallicPath, "");
|
|
strcpy(roughnessPath, "");
|
|
strcpy(aoPath, "");
|
|
strcpy(normalPath, "");
|
|
strcpy(heightPath, "");
|
|
}
|
|
};
|
|
|
|
struct SphereInstance {
|
|
glm::vec3 position;
|
|
float rotation; // in radians.
|
|
Material material;
|
|
};
|
|
|
|
struct PlaneInstance {
|
|
glm::vec3 position;
|
|
float rotation; // around Y axis.
|
|
Material material;
|
|
};
|
|
|
|
// ------------------------------------------
|
|
// YAML Material Loading and Saving
|
|
// ------------------------------------------
|
|
Material loadMaterialFromYAML(const std::string& filename) {
|
|
Material mat;
|
|
try {
|
|
YAML::Node config = YAML::LoadFile(filename);
|
|
if (config["albedo"]) {
|
|
mat.albedo = glm::vec3(config["albedo"][0].as<float>(),
|
|
config["albedo"][1].as<float>(),
|
|
config["albedo"][2].as<float>());
|
|
}
|
|
if (config["metallic"])
|
|
mat.metallic = config["metallic"].as<float>();
|
|
if (config["roughness"])
|
|
mat.roughness = config["roughness"].as<float>();
|
|
if (config["ao"])
|
|
mat.ao = config["ao"].as<float>();
|
|
|
|
if (config["albedo_texture"]) {
|
|
std::string path = config["albedo_texture"].as<std::string>();
|
|
strncpy(mat.albedoPath, path.c_str(), sizeof(mat.albedoPath));
|
|
GLuint tex = LoadTexture(mat.albedoPath);
|
|
if (tex != 0) { mat.albedoTex = tex; mat.useAlbedoMap = true; }
|
|
}
|
|
if (config["metallic_texture"]) {
|
|
std::string path = config["metallic_texture"].as<std::string>();
|
|
strncpy(mat.metallicPath, path.c_str(), sizeof(mat.metallicPath));
|
|
GLuint tex = LoadTexture(mat.metallicPath);
|
|
if (tex != 0) { mat.metallicTex = tex; mat.useMetallicMap = true; }
|
|
}
|
|
if (config["roughness_texture"]) {
|
|
std::string path = config["roughness_texture"].as<std::string>();
|
|
strncpy(mat.roughnessPath, path.c_str(), sizeof(mat.roughnessPath));
|
|
GLuint tex = LoadTexture(mat.roughnessPath);
|
|
if (tex != 0) { mat.roughnessTex = tex; mat.useRoughnessMap = true; }
|
|
}
|
|
if (config["ao_texture"]) {
|
|
std::string path = config["ao_texture"].as<std::string>();
|
|
strncpy(mat.aoPath, path.c_str(), sizeof(mat.aoPath));
|
|
GLuint tex = LoadTexture(mat.aoPath);
|
|
if (tex != 0) { mat.aoTex = tex; mat.useAOMap = true; }
|
|
}
|
|
if (config["normal_texture"]) {
|
|
std::string path = config["normal_texture"].as<std::string>();
|
|
strncpy(mat.normalPath, path.c_str(), sizeof(mat.normalPath));
|
|
GLuint tex = LoadTexture(mat.normalPath);
|
|
if (tex != 0) { mat.normalTex = tex; mat.useNormalMap = true; }
|
|
}
|
|
if (config["height_texture"]) {
|
|
std::string path = config["height_texture"].as<std::string>();
|
|
strncpy(mat.heightPath, path.c_str(), sizeof(mat.heightPath));
|
|
GLuint tex = LoadTexture(mat.heightPath);
|
|
if (tex != 0) { mat.heightTex = tex; mat.useHeightMap = true; }
|
|
}
|
|
} catch(const std::exception& e) {
|
|
std::cerr << "Error loading YAML material from " << filename << ": " << e.what() << std::endl;
|
|
}
|
|
return mat;
|
|
}
|
|
|
|
bool saveMaterialToYAML(const std::string& filename, const Material& mat) {
|
|
YAML::Emitter out;
|
|
out << YAML::BeginMap;
|
|
out << YAML::Key << "albedo" << YAML::Value << YAML::Flow << std::vector<float>{mat.albedo.r, mat.albedo.g, mat.albedo.b};
|
|
out << YAML::Key << "metallic" << YAML::Value << mat.metallic;
|
|
out << YAML::Key << "roughness" << YAML::Value << mat.roughness;
|
|
out << YAML::Key << "ao" << YAML::Value << mat.ao;
|
|
if (mat.useAlbedoMap)
|
|
out << YAML::Key << "albedo_texture" << YAML::Value << std::string(mat.albedoPath);
|
|
if (mat.useMetallicMap)
|
|
out << YAML::Key << "metallic_texture" << YAML::Value << std::string(mat.metallicPath);
|
|
if (mat.useRoughnessMap)
|
|
out << YAML::Key << "roughness_texture" << YAML::Value << std::string(mat.roughnessPath);
|
|
if (mat.useAOMap)
|
|
out << YAML::Key << "ao_texture" << YAML::Value << std::string(mat.aoPath);
|
|
if (mat.useNormalMap)
|
|
out << YAML::Key << "normal_texture" << YAML::Value << std::string(mat.normalPath);
|
|
if (mat.useHeightMap)
|
|
out << YAML::Key << "height_texture" << YAML::Value << std::string(mat.heightPath);
|
|
out << YAML::EndMap;
|
|
|
|
std::ofstream fout(filename);
|
|
if(!fout.is_open()){
|
|
std::cerr << "Failed to open " << filename << " for saving material." << std::endl;
|
|
return false;
|
|
}
|
|
fout << out.c_str();
|
|
fout.close();
|
|
return true;
|
|
}
|
|
|
|
// ------------------------------------------
|
|
// Skybox geometry
|
|
// ------------------------------------------
|
|
// Cube vertices for the skybox.
|
|
float skyboxVertices[] = {
|
|
// positions
|
|
-1.0f, 1.0f, -1.0f,
|
|
-1.0f, -1.0f, -1.0f,
|
|
1.0f, -1.0f, -1.0f,
|
|
1.0f, -1.0f, -1.0f,
|
|
1.0f, 1.0f, -1.0f,
|
|
-1.0f, 1.0f, -1.0f,
|
|
|
|
-1.0f, -1.0f, 1.0f,
|
|
-1.0f, -1.0f, -1.0f,
|
|
-1.0f, 1.0f, -1.0f,
|
|
-1.0f, 1.0f, -1.0f,
|
|
-1.0f, 1.0f, 1.0f,
|
|
-1.0f, -1.0f, 1.0f,
|
|
|
|
1.0f, -1.0f, -1.0f,
|
|
1.0f, -1.0f, 1.0f,
|
|
1.0f, 1.0f, 1.0f,
|
|
1.0f, 1.0f, 1.0f,
|
|
1.0f, 1.0f, -1.0f,
|
|
1.0f, -1.0f, -1.0f,
|
|
|
|
-1.0f, -1.0f, 1.0f,
|
|
-1.0f, 1.0f, 1.0f,
|
|
1.0f, 1.0f, 1.0f,
|
|
1.0f, 1.0f, 1.0f,
|
|
1.0f, -1.0f, 1.0f,
|
|
-1.0f, -1.0f, 1.0f,
|
|
|
|
-1.0f, 1.0f, -1.0f,
|
|
1.0f, 1.0f, -1.0f,
|
|
1.0f, 1.0f, 1.0f,
|
|
1.0f, 1.0f, 1.0f,
|
|
-1.0f, 1.0f, 1.0f,
|
|
-1.0f, 1.0f, -1.0f,
|
|
|
|
-1.0f, -1.0f, -1.0f,
|
|
-1.0f, -1.0f, 1.0f,
|
|
1.0f, -1.0f, -1.0f,
|
|
1.0f, -1.0f, -1.0f,
|
|
-1.0f, -1.0f, 1.0f,
|
|
1.0f, -1.0f, 1.0f
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int main(){
|
|
if(!glfwInit()){
|
|
std::cerr << "Failed to initialize GLFW!" << std::endl;
|
|
return -1;
|
|
}
|
|
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
|
|
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
|
|
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
|
|
|
|
GLFWwindow* window = glfwCreateWindow(800, 600, "PBR Renderer with Height Maps, Improved Lighting & Skybox", nullptr, nullptr);
|
|
if(!window){
|
|
std::cerr << "Failed to create GLFW window!" << std::endl;
|
|
glfwTerminate();
|
|
return -1;
|
|
}
|
|
glfwMakeContextCurrent(window);
|
|
|
|
glewExperimental = GL_TRUE;
|
|
if(glewInit() != GLEW_OK){
|
|
std::cerr << "Failed to initialize GLEW!" << std::endl;
|
|
return -1;
|
|
}
|
|
glEnable(GL_DEPTH_TEST);
|
|
|
|
// Setup ImGui.
|
|
IMGUI_CHECKVERSION();
|
|
ImGui::CreateContext();
|
|
ImGuiIO& io = ImGui::GetIO(); (void)io;
|
|
ImGui::StyleColorsDark();
|
|
ImGui_ImplGlfw_InitForOpenGL(window, true);
|
|
ImGui_ImplOpenGL3_Init("#version 330");
|
|
|
|
// Compile main shaders.
|
|
GLuint vs = compileShader(GL_VERTEX_SHADER, vertexShaderSource);
|
|
GLuint fs = compileShader(GL_FRAGMENT_SHADER, fragmentShaderSource);
|
|
GLuint shaderProgram = createProgram(vs, fs);
|
|
glDeleteShader(vs);
|
|
glDeleteShader(fs);
|
|
|
|
// Compile skybox shaders.
|
|
GLuint skybox_vs = compileShader(GL_VERTEX_SHADER, skyboxVertexShaderSource);
|
|
GLuint skybox_fs = compileShader(GL_FRAGMENT_SHADER, skyboxFragmentShaderSource);
|
|
GLuint skyboxShader = createProgram(skybox_vs, skybox_fs);
|
|
glDeleteShader(skybox_vs);
|
|
glDeleteShader(skybox_fs);
|
|
|
|
// Generate sphere mesh.
|
|
std::vector<float> sphereVertices;
|
|
std::vector<unsigned int> sphereIndices;
|
|
generateSphereMesh(sphereVertices, sphereIndices);
|
|
GLuint sphereVAO, sphereVBO, sphereEBO;
|
|
glGenVertexArrays(1, &sphereVAO);
|
|
glGenBuffers(1, &sphereVBO);
|
|
glGenBuffers(1, &sphereEBO);
|
|
glBindVertexArray(sphereVAO);
|
|
glBindBuffer(GL_ARRAY_BUFFER, sphereVBO);
|
|
glBufferData(GL_ARRAY_BUFFER, sphereVertices.size() * sizeof(float), sphereVertices.data(), GL_STATIC_DRAW);
|
|
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, sphereEBO);
|
|
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sphereIndices.size() * sizeof(unsigned int), sphereIndices.data(), GL_STATIC_DRAW);
|
|
// Attributes: pos (3), normal (3), texcoords (2), tangent (3)
|
|
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 11 * sizeof(float), (void*)0);
|
|
glEnableVertexAttribArray(0);
|
|
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 11 * sizeof(float), (void*)(3 * sizeof(float)));
|
|
glEnableVertexAttribArray(1);
|
|
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 11 * sizeof(float), (void*)(6 * sizeof(float)));
|
|
glEnableVertexAttribArray(2);
|
|
glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, 11 * sizeof(float), (void*)(8 * sizeof(float)));
|
|
glEnableVertexAttribArray(3);
|
|
glBindVertexArray(0);
|
|
|
|
// Generate plane mesh.
|
|
std::vector<float> planeVertices;
|
|
std::vector<unsigned int> planeIndices;
|
|
generatePlaneMesh(planeVertices, planeIndices);
|
|
GLuint planeVAO, planeVBO, planeEBO;
|
|
glGenVertexArrays(1, &planeVAO);
|
|
glGenBuffers(1, &planeVBO);
|
|
glGenBuffers(1, &planeEBO);
|
|
glBindVertexArray(planeVAO);
|
|
glBindBuffer(GL_ARRAY_BUFFER, planeVBO);
|
|
glBufferData(GL_ARRAY_BUFFER, planeVertices.size() * sizeof(float), planeVertices.data(), GL_STATIC_DRAW);
|
|
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, planeEBO);
|
|
glBufferData(GL_ELEMENT_ARRAY_BUFFER, planeIndices.size() * sizeof(unsigned int), planeIndices.data(), GL_STATIC_DRAW);
|
|
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 11 * sizeof(float), (void*)0);
|
|
glEnableVertexAttribArray(0);
|
|
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 11 * sizeof(float), (void*)(3 * sizeof(float)));
|
|
glEnableVertexAttribArray(1);
|
|
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 11 * sizeof(float), (void*)(6 * sizeof(float)));
|
|
glEnableVertexAttribArray(2);
|
|
glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, 11 * sizeof(float), (void*)(8 * sizeof(float)));
|
|
glEnableVertexAttribArray(3);
|
|
glBindVertexArray(0);
|
|
|
|
// Set up skybox VAO & VBO.
|
|
GLuint skyboxVAO, skyboxVBO;
|
|
glGenVertexArrays(1, &skyboxVAO);
|
|
glGenBuffers(1, &skyboxVBO);
|
|
glBindVertexArray(skyboxVAO);
|
|
glBindBuffer(GL_ARRAY_BUFFER, skyboxVBO);
|
|
glBufferData(GL_ARRAY_BUFFER, sizeof(skyboxVertices), &skyboxVertices, GL_STATIC_DRAW);
|
|
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
|
|
glEnableVertexAttribArray(0);
|
|
glBindVertexArray(0);
|
|
|
|
// Load a default cubemap for the skybox.
|
|
std::vector<std::string> faces{
|
|
"skybox/right.jpg",
|
|
"skybox/left.jpg",
|
|
"skybox/top.jpg",
|
|
"skybox/bottom.jpg",
|
|
"skybox/front.jpg",
|
|
"skybox/back.jpg"
|
|
};
|
|
GLuint cubemapTexture = loadCubemap(faces);
|
|
|
|
// ------------------------------------------
|
|
// Scene Data
|
|
// ------------------------------------------
|
|
std::vector<SphereInstance> spheres;
|
|
spheres.push_back({ glm::vec3(0.0f, 0.0f, 0.0f), 0.0f, Material() });
|
|
std::vector<PlaneInstance> planes;
|
|
planes.push_back({ glm::vec3(0.0f, -1.0f, 0.0f), 0.0f, Material() });
|
|
|
|
// Global lighting parameters.
|
|
glm::vec3 camPosVec(0.0f, 1.0f, 5.0f);
|
|
glm::vec3 pointLightPos(0.0f, 3.0f, 3.0f);
|
|
glm::vec3 pointLightColor(300.0f, 300.0f, 300.0f);
|
|
// Directional light.
|
|
bool useDirLight = true;
|
|
glm::vec3 dirLightDir(-0.2f, -1.0f, -0.3f);
|
|
glm::vec3 dirLightColor(0.8f, 0.8f, 0.8f);
|
|
|
|
// Toggle for which object to render: 0 = sphere, 1 = plane.
|
|
int activeObject = 0;
|
|
|
|
// For material YAML loading/saving.
|
|
static char yamlPathBuffer[256] = "";
|
|
|
|
// Declare a global parallax scale variable so it is available later.
|
|
static float globalParallaxScale = 0.05f;
|
|
|
|
// Main Loop.
|
|
while(!glfwWindowShouldClose(window)){
|
|
glfwPollEvents();
|
|
ImGui_ImplOpenGL3_NewFrame();
|
|
ImGui_ImplGlfw_NewFrame();
|
|
ImGui::NewFrame();
|
|
|
|
// ---------------------- ImGui UI -----------------------
|
|
{
|
|
ImGui::Begin("Scene Controls");
|
|
ImGui::Text("Global Lighting");
|
|
ImGui::DragFloat3("Camera Pos", glm::value_ptr(camPosVec), 0.1f);
|
|
ImGui::DragFloat3("Point Light Pos", glm::value_ptr(pointLightPos), 0.1f);
|
|
ImGui::ColorEdit3("Point Light Color", glm::value_ptr(pointLightColor));
|
|
ImGui::Checkbox("Use Directional Light", &useDirLight);
|
|
ImGui::DragFloat3("Dir Light Dir", glm::value_ptr(dirLightDir), 0.1f);
|
|
ImGui::ColorEdit3("Dir Light Color", glm::value_ptr(dirLightColor));
|
|
ImGui::Separator();
|
|
ImGui::RadioButton("Render Sphere", &activeObject, 0);
|
|
ImGui::RadioButton("Render Plane", &activeObject, 1);
|
|
ImGui::Separator();
|
|
// Material controls for the active object.
|
|
Material* mat = nullptr;
|
|
if(activeObject == 0 && !spheres.empty())
|
|
mat = &spheres[0].material;
|
|
else if(activeObject == 1 && !planes.empty())
|
|
mat = &planes[0].material;
|
|
if(mat){
|
|
ImGui::Text("Material Properties:");
|
|
ImGui::ColorEdit3("Albedo", glm::value_ptr(mat->albedo));
|
|
ImGui::SliderFloat("Metallic", &mat->metallic, 0.0f, 1.0f);
|
|
ImGui::SliderFloat("Roughness", &mat->roughness, 0.05f, 1.0f);
|
|
ImGui::SliderFloat("AO", &mat->ao, 0.0f, 1.0f);
|
|
ImGui::SliderFloat("Parallax Scale", &globalParallaxScale, 0.0f, 0.2f);
|
|
ImGui::InputText("Albedo Texture Path", mat->albedoPath, sizeof(mat->albedoPath));
|
|
if(ImGui::Button("Load Albedo Texture")){
|
|
GLuint tex = LoadTexture(mat->albedoPath);
|
|
if(tex != 0){ mat->albedoTex = tex; mat->useAlbedoMap = true; }
|
|
}
|
|
ImGui::InputText("Metallic Texture Path", mat->metallicPath, sizeof(mat->metallicPath));
|
|
if(ImGui::Button("Load Metallic Texture")){
|
|
GLuint tex = LoadTexture(mat->metallicPath);
|
|
if(tex != 0){ mat->metallicTex = tex; mat->useMetallicMap = true; }
|
|
}
|
|
ImGui::InputText("Roughness Texture Path", mat->roughnessPath, sizeof(mat->roughnessPath));
|
|
if(ImGui::Button("Load Roughness Texture")){
|
|
GLuint tex = LoadTexture(mat->roughnessPath);
|
|
if(tex != 0){ mat->roughnessTex = tex; mat->useRoughnessMap = true; }
|
|
}
|
|
ImGui::InputText("AO Texture Path", mat->aoPath, sizeof(mat->aoPath));
|
|
if(ImGui::Button("Load AO Texture")){
|
|
GLuint tex = LoadTexture(mat->aoPath);
|
|
if(tex != 0){ mat->aoTex = tex; mat->useAOMap = true; }
|
|
}
|
|
ImGui::InputText("Normal Texture Path", mat->normalPath, sizeof(mat->normalPath));
|
|
if(ImGui::Button("Load Normal Texture")){
|
|
GLuint tex = LoadTexture(mat->normalPath);
|
|
if(tex != 0){ mat->normalTex = tex; mat->useNormalMap = true; }
|
|
}
|
|
ImGui::InputText("Height Texture Path", mat->heightPath, sizeof(mat->heightPath));
|
|
if(ImGui::Button("Load Height Texture")){
|
|
GLuint tex = LoadTexture(mat->heightPath);
|
|
if(tex != 0){ mat->heightTex = tex; mat->useHeightMap = true; }
|
|
}
|
|
ImGui::InputText("YAML Material Path", yamlPathBuffer, sizeof(yamlPathBuffer));
|
|
if(ImGui::Button("Load Material from YAML")){
|
|
Material m = loadMaterialFromYAML(yamlPathBuffer);
|
|
*mat = m;
|
|
}
|
|
if(ImGui::Button("Save Material to YAML")){
|
|
if(saveMaterialToYAML(std::string(yamlPathBuffer), *mat))
|
|
std::cout << "Material saved to " << yamlPathBuffer << std::endl;
|
|
}
|
|
}
|
|
ImGui::Separator();
|
|
ImGui::Text("Skybox: Using default paths in code.");
|
|
ImGui::End();
|
|
}
|
|
|
|
// ---------------------- Rendering ----------------------
|
|
int scrWidth, scrHeight;
|
|
glfwGetFramebufferSize(window, &scrWidth, &scrHeight);
|
|
float aspect = scrWidth / static_cast<float>(scrHeight);
|
|
glViewport(0, 0, scrWidth, scrHeight);
|
|
glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
|
|
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
|
|
glm::mat4 projection = glm::perspective(glm::radians(45.0f), aspect, 0.1f, 100.0f);
|
|
glm::mat4 view = glm::lookAt(camPosVec, glm::vec3(0.0f,0.0f,0.0f), glm::vec3(0,1,0));
|
|
|
|
// Render scene objects using the main shader.
|
|
glUseProgram(shaderProgram);
|
|
glUniformMatrix4fv(glGetUniformLocation(shaderProgram, "projection"), 1, GL_FALSE, glm::value_ptr(projection));
|
|
glUniformMatrix4fv(glGetUniformLocation(shaderProgram, "view"), 1, GL_FALSE, glm::value_ptr(view));
|
|
glUniform3fv(glGetUniformLocation(shaderProgram, "camPos"), 1, glm::value_ptr(camPosVec));
|
|
glUniform3fv(glGetUniformLocation(shaderProgram, "pointLightPos"), 1, glm::value_ptr(pointLightPos));
|
|
glUniform3fv(glGetUniformLocation(shaderProgram, "pointLightColor"), 1, glm::value_ptr(pointLightColor));
|
|
glUniform1i(glGetUniformLocation(shaderProgram, "useDirLight"), useDirLight);
|
|
glUniform3fv(glGetUniformLocation(shaderProgram, "dirLightDir"), 1, glm::value_ptr(dirLightDir));
|
|
glUniform3fv(glGetUniformLocation(shaderProgram, "dirLightColor"), 1, glm::value_ptr(dirLightColor));
|
|
glUniform1f(glGetUniformLocation(shaderProgram, "parallaxScale"), globalParallaxScale);
|
|
glUniform1f(glGetUniformLocation(shaderProgram, "PI"), IM_PI);
|
|
// Set environment reflection uniforms.
|
|
glActiveTexture(GL_TEXTURE6);
|
|
glBindTexture(GL_TEXTURE_CUBE_MAP, cubemapTexture);
|
|
glUniform1i(glGetUniformLocation(shaderProgram, "envMap"), 6);
|
|
glUniform1f(glGetUniformLocation(shaderProgram, "envReflectionIntensity"), 0.3f); // adjust intensity as needed
|
|
|
|
if(activeObject == 0 && !spheres.empty()){
|
|
// Render sphere.
|
|
glm::mat4 model = glm::translate(glm::mat4(1.0f), spheres[0].position);
|
|
model = glm::rotate(model, spheres[0].rotation, glm::vec3(0,1,0));
|
|
glUniformMatrix4fv(glGetUniformLocation(shaderProgram, "model"), 1, GL_FALSE, glm::value_ptr(model));
|
|
Material& m = spheres[0].material;
|
|
glUniform3fv(glGetUniformLocation(shaderProgram, "albedo"), 1, glm::value_ptr(m.albedo));
|
|
glUniform1f(glGetUniformLocation(shaderProgram, "metallic"), m.metallic);
|
|
glUniform1f(glGetUniformLocation(shaderProgram, "roughness"), m.roughness);
|
|
glUniform1f(glGetUniformLocation(shaderProgram, "ao"), m.ao);
|
|
glUniform1i(glGetUniformLocation(shaderProgram, "useAlbedoMap"), m.useAlbedoMap ? 1 : 0);
|
|
glUniform1i(glGetUniformLocation(shaderProgram, "useMetallicMap"), m.useMetallicMap ? 1 : 0);
|
|
glUniform1i(glGetUniformLocation(shaderProgram, "useRoughnessMap"), m.useRoughnessMap ? 1 : 0);
|
|
glUniform1i(glGetUniformLocation(shaderProgram, "useAOMap"), m.useAOMap ? 1 : 0);
|
|
glUniform1i(glGetUniformLocation(shaderProgram, "useNormalMap"), m.useNormalMap ? 1 : 0);
|
|
glUniform1i(glGetUniformLocation(shaderProgram, "useHeightMap"), m.useHeightMap ? 1 : 0);
|
|
if(m.useAlbedoMap){
|
|
glActiveTexture(GL_TEXTURE0);
|
|
glBindTexture(GL_TEXTURE_2D, m.albedoTex);
|
|
glUniform1i(glGetUniformLocation(shaderProgram, "albedoMap"), 0);
|
|
}
|
|
if(m.useMetallicMap){
|
|
glActiveTexture(GL_TEXTURE1);
|
|
glBindTexture(GL_TEXTURE_2D, m.metallicTex);
|
|
glUniform1i(glGetUniformLocation(shaderProgram, "metallicMap"), 1);
|
|
}
|
|
if(m.useRoughnessMap){
|
|
glActiveTexture(GL_TEXTURE2);
|
|
glBindTexture(GL_TEXTURE_2D, m.roughnessTex);
|
|
glUniform1i(glGetUniformLocation(shaderProgram, "roughnessMap"), 2);
|
|
}
|
|
if(m.useAOMap){
|
|
glActiveTexture(GL_TEXTURE3);
|
|
glBindTexture(GL_TEXTURE_2D, m.aoTex);
|
|
glUniform1i(glGetUniformLocation(shaderProgram, "aoMap"), 3);
|
|
}
|
|
if(m.useNormalMap){
|
|
glActiveTexture(GL_TEXTURE4);
|
|
glBindTexture(GL_TEXTURE_2D, m.normalTex);
|
|
glUniform1i(glGetUniformLocation(shaderProgram, "normalMap"), 4);
|
|
}
|
|
if(m.useHeightMap){
|
|
glActiveTexture(GL_TEXTURE5);
|
|
glBindTexture(GL_TEXTURE_2D, m.heightTex);
|
|
glUniform1i(glGetUniformLocation(shaderProgram, "heightMap"), 5);
|
|
}
|
|
glBindVertexArray(sphereVAO);
|
|
glDrawElements(GL_TRIANGLES, sphereIndices.size(), GL_UNSIGNED_INT, 0);
|
|
glBindVertexArray(0);
|
|
}
|
|
else if(activeObject == 1 && !planes.empty()){
|
|
// Render plane.
|
|
glm::mat4 model = glm::translate(glm::mat4(1.0f), planes[0].position);
|
|
model = glm::rotate(model, planes[0].rotation, glm::vec3(0,1,0));
|
|
glUniformMatrix4fv(glGetUniformLocation(shaderProgram, "model"), 1, GL_FALSE, glm::value_ptr(model));
|
|
Material& m = planes[0].material;
|
|
glUniform3fv(glGetUniformLocation(shaderProgram, "albedo"), 1, glm::value_ptr(m.albedo));
|
|
glUniform1f(glGetUniformLocation(shaderProgram, "metallic"), m.metallic);
|
|
glUniform1f(glGetUniformLocation(shaderProgram, "roughness"), m.roughness);
|
|
glUniform1f(glGetUniformLocation(shaderProgram, "ao"), m.ao);
|
|
glUniform1i(glGetUniformLocation(shaderProgram, "useAlbedoMap"), m.useAlbedoMap ? 1 : 0);
|
|
glUniform1i(glGetUniformLocation(shaderProgram, "useMetallicMap"), m.useMetallicMap ? 1 : 0);
|
|
glUniform1i(glGetUniformLocation(shaderProgram, "useRoughnessMap"), m.useRoughnessMap ? 1 : 0);
|
|
glUniform1i(glGetUniformLocation(shaderProgram, "useAOMap"), m.useAOMap ? 1 : 0);
|
|
glUniform1i(glGetUniformLocation(shaderProgram, "useNormalMap"), m.useNormalMap ? 1 : 0);
|
|
glUniform1i(glGetUniformLocation(shaderProgram, "useHeightMap"), m.useHeightMap ? 1 : 0);
|
|
if(m.useAlbedoMap){
|
|
glActiveTexture(GL_TEXTURE0);
|
|
glBindTexture(GL_TEXTURE_2D, m.albedoTex);
|
|
glUniform1i(glGetUniformLocation(shaderProgram, "albedoMap"), 0);
|
|
}
|
|
if(m.useMetallicMap){
|
|
glActiveTexture(GL_TEXTURE1);
|
|
glBindTexture(GL_TEXTURE_2D, m.metallicTex);
|
|
glUniform1i(glGetUniformLocation(shaderProgram, "metallicMap"), 1);
|
|
}
|
|
if(m.useRoughnessMap){
|
|
glActiveTexture(GL_TEXTURE_2D);
|
|
glBindTexture(GL_TEXTURE_2D, m.roughnessTex);
|
|
glUniform1i(glGetUniformLocation(shaderProgram, "roughnessMap"), 2);
|
|
}
|
|
if(m.useAOMap){
|
|
glActiveTexture(GL_TEXTURE_2D);
|
|
glBindTexture(GL_TEXTURE_2D, m.aoTex);
|
|
glUniform1i(glGetUniformLocation(shaderProgram, "aoMap"), 3);
|
|
}
|
|
if(m.useNormalMap){
|
|
glActiveTexture(GL_TEXTURE_2D);
|
|
glBindTexture(GL_TEXTURE_2D, m.normalTex);
|
|
glUniform1i(glGetUniformLocation(shaderProgram, "normalMap"), 4);
|
|
}
|
|
if(m.useHeightMap){
|
|
glActiveTexture(GL_TEXTURE_2D);
|
|
glBindTexture(GL_TEXTURE_2D, m.heightTex);
|
|
glUniform1i(glGetUniformLocation(shaderProgram, "heightMap"), 5);
|
|
}
|
|
glBindVertexArray(planeVAO);
|
|
glDrawElements(GL_TRIANGLES, planeIndices.size(), GL_UNSIGNED_INT, 0);
|
|
glBindVertexArray(0);
|
|
}
|
|
|
|
// ---------------------- Render Skybox ----------------------
|
|
glDepthFunc(GL_LEQUAL);
|
|
glUseProgram(skyboxShader);
|
|
// Remove translation from the view matrix.
|
|
glm::mat4 viewSky = glm::mat4(glm::mat3(view));
|
|
glUniformMatrix4fv(glGetUniformLocation(skyboxShader, "view"), 1, GL_FALSE, glm::value_ptr(viewSky));
|
|
glUniformMatrix4fv(glGetUniformLocation(skyboxShader, "projection"), 1, GL_FALSE, glm::value_ptr(projection));
|
|
glBindVertexArray(skyboxVAO);
|
|
glActiveTexture(GL_TEXTURE0);
|
|
glBindTexture(GL_TEXTURE_CUBE_MAP, cubemapTexture);
|
|
glUniform1i(glGetUniformLocation(skyboxShader, "skybox"), 0);
|
|
glDrawArrays(GL_TRIANGLES, 0, 36);
|
|
glBindVertexArray(0);
|
|
glDepthFunc(GL_LESS);
|
|
|
|
ImGui::Render();
|
|
ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
|
|
glfwSwapBuffers(window);
|
|
}
|
|
|
|
// Cleanup
|
|
glDeleteVertexArrays(1, &sphereVAO);
|
|
glDeleteBuffers(1, &sphereVBO);
|
|
glDeleteBuffers(1, &sphereEBO);
|
|
glDeleteVertexArrays(1, &planeVAO);
|
|
glDeleteBuffers(1, &planeVBO);
|
|
glDeleteBuffers(1, &planeEBO);
|
|
glDeleteVertexArrays(1, &skyboxVAO);
|
|
glDeleteBuffers(1, &skyboxVBO);
|
|
glDeleteProgram(shaderProgram);
|
|
glDeleteProgram(skyboxShader);
|
|
|
|
ImGui_ImplOpenGL3_Shutdown();
|
|
ImGui_ImplGlfw_Shutdown();
|
|
ImGui::DestroyContext();
|
|
glfwTerminate();
|
|
return 0;
|
|
}
|