gitweb.ps.run Git - subsurface_scattering/blob - src/main.cpp

   1 #include <stdio.h>\r
   2 \r
   3 #include <GL/glew.h>\r
   4 \r
   5 #include <glm/glm.hpp>\r
   6 #include <glm/gtc/matrix_transform.hpp>\r
   7 #include <glm/gtc/type_ptr.hpp>\r
   8 \r
   9 #include <SFML/OpenGL.hpp>\r
  10 #include <SFML/Window.hpp>\r
  11 \r
  12 #include <assimp/Importer.hpp>\r
  13 #include <assimp/postprocess.h>\r
  14 #include <assimp/scene.h>\r
  15 \r
  16 const char *vertexShaderSource = R"(\r
  17 #version 330 core\r
  18 \r
  19 layout (location = 0) in vec3 pos;\r
  20 layout (location = 0) in vec3 normal;\r
  21 \r
  22 out vec3 FragPos;\r
  23 out vec3 Normal;\r
  24 \r
  25 uniform mat4 model;\r
  26 uniform mat4 view;\r
  27 uniform mat4 projection;\r
  28 \r
  29 void main()\r
  30 {\r
  31   gl_Position = projection * view * model * vec4(pos, 1.0);\r
  32   FragPos = vec3(model * vec4(pos, 1));\r
  33   Normal = normal;\r
  34 }\r
  35 )";\r
  36 \r
  37 const char *fragmentShaderSource = R"(\r
  38 #version 330 core\r
  39 \r
  40 in vec3 FragPos;\r
  41 in vec3 Normal;\r
  42 \r
  43 out vec4 FragColor;\r
  44 \r
  45 uniform vec3 objectColor;\r
  46 uniform vec3 lightColor;\r
  47 uniform vec3 lightPos;\r
  48 \r
  49 void main()\r
  50 {\r
  51   vec3 norm = normalize(Normal);\r
  52   vec3 lightDir = normalize(lightPos - FragPos);\r
  53 \r
  54   float diff = max(dot(norm, lightDir), 0.0);\r
  55   vec3 diffuse = diff * lightColor;\r
  56 \r
  57   float ambientStrength = 0.1;\r
  58   vec3 ambient = ambientStrength * lightColor;\r
  59 \r
  60   vec3 result = (ambient + diffuse) * objectColor;\r
  61   FragColor = vec4(result, 1.0f);\r
  62 }\r
  63 )";\r
  64 \r
  65 std::vector<float> vertices;\r
  66 std::vector<GLuint> indices;\r
  67 \r
  68 glm::vec3 lightPos(1.2f, 0.5f, 2.0f);\r
  69 \r
  70 void load(const std::string &filename, std::vector<float> &vertices,\r
  71           std::vector<GLuint> &indices) {\r
  72   Assimp::Importer importer;\r
  73 \r
  74   const aiScene *scene = importer.ReadFile(\r
  75       filename, aiProcess_CalcTangentSpace | aiProcess_Triangulate |\r
  76                     aiProcess_SortByPType | aiProcess_GenNormals);\r
  77 \r
  78   for (int i = 0; i < scene->mMeshes[0]->mNumVertices; i++) {\r
  79     aiVector3D v = scene->mMeshes[0]->mVertices[i];\r
  80     aiVector3D n = scene->mMeshes[0]->mNormals[i];\r
  81     vertices.push_back(v.x);\r
  82     vertices.push_back(v.y);\r
  83     vertices.push_back(v.z);\r
  84     vertices.push_back(n.x);\r
  85     vertices.push_back(n.y);\r
  86     vertices.push_back(n.z);\r
  87   }\r
  88 \r
  89   for (int i = 0; i < scene->mMeshes[0]->mNumFaces; i++) {\r
  90     aiFace f = scene->mMeshes[0]->mFaces[i];\r
  91     for (int j = 0; j < f.mNumIndices; j++) {\r
  92       indices.push_back(f.mIndices[j]);\r
  93     }\r
  94   }\r
  95 }\r
  96 \r
  97 int main() {\r
  98   // Window Setup\r
  99 \r
 100   sf::ContextSettings settings;\r
 101   settings.depthBits = 24;\r
 102   settings.antialiasingLevel = 0;\r
 103   settings.majorVersion = 4;\r
 104   settings.minorVersion = 6;\r
 105 \r
 106   sf::Window window(sf::VideoMode(800, 600), "Subsurface Scattering",\r
 107                     sf::Style::Default, settings);\r
 108   window.setVerticalSyncEnabled(true);\r
 109 \r
 110   window.setActive(true);\r
 111 \r
 112   // Initialize GLEW\r
 113 \r
 114   if (glewInit() != GLEW_OK) {\r
 115   }\r
 116 \r
 117   load("models/Isotrop-upperjaw.ply", vertices, indices);\r
 118 \r
 119   // Compile Shaders\r
 120 \r
 121   GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);\r
 122   glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);\r
 123   glCompileShader(vertexShader);\r
 124 \r
 125   int success;\r
 126   char infoLog[512];\r
 127   glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);\r
 128   if (!success) {\r
 129     glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);\r
 130     printf("Error compiling vertex shader: %s\n", infoLog);\r
 131   }\r
 132 \r
 133   GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);\r
 134   glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);\r
 135   glCompileShader(fragmentShader);\r
 136 \r
 137   glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);\r
 138   if (!success) {\r
 139     glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);\r
 140     printf("Error compiling fragment shader: %s\n", infoLog);\r
 141   }\r
 142 \r
 143   // Link Shader Program\r
 144 \r
 145   GLuint shaderProgram = glCreateProgram();\r
 146   glAttachShader(shaderProgram, vertexShader);\r
 147   glAttachShader(shaderProgram, fragmentShader);\r
 148   glLinkProgram(shaderProgram);\r
 149 \r
 150   glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);\r
 151   if (!success) {\r
 152     glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog);\r
 153     printf("Error linking shader program: %s\n", infoLog);\r
 154   }\r
 155 \r
 156   glDeleteShader(vertexShader);\r
 157   glDeleteShader(fragmentShader);\r
 158 \r
 159   // Create VBO\r
 160 \r
 161   GLuint VBO;\r
 162   glGenBuffers(1, &VBO);\r
 163 \r
 164   // Create EBO\r
 165 \r
 166   GLuint EBO;\r
 167   glGenBuffers(1, &EBO);\r
 168 \r
 169   // Create VAO\r
 170 \r
 171   GLuint VAO;\r
 172   glGenVertexArrays(1, &VAO);\r
 173 \r
 174   glBindVertexArray(VAO);\r
 175 \r
 176   glBindBuffer(GL_ARRAY_BUFFER, VBO);\r
 177   glBufferData(GL_ARRAY_BUFFER, sizeof(float) * vertices.size(),\r
 178                vertices.data(), GL_STATIC_DRAW);\r
 179 \r
 180   glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);\r
 181   glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint) * indices.size(),\r
 182                indices.data(), GL_STATIC_DRAW);\r
 183 \r
 184   glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 6, (void*)0);\r
 185   glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 6, (void*)3);\r
 186   glEnableVertexAttribArray(0);\r
 187 \r
 188   glBindVertexArray(0);\r
 189 \r
 190   // Perspective\r
 191 \r
 192   glm::mat4 model = glm::scale(glm::mat4(1.0f), glm::vec3(0.01f, 0.01f, 0.01f));\r
 193 \r
 194   glm::mat4 view =\r
 195       glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -3.0f));\r
 196 \r
 197   glm::mat4 proj =\r
 198       glm::perspective(glm::radians(45.0f), 800.0f / 600.0f, 0.1f, 1000.0f);\r
 199 \r
 200   bool wireframe = false;\r
 201 \r
 202   bool running = true;\r
 203   while (running) {\r
 204     sf::Event event;\r
 205     while (window.pollEvent(event)) {\r
 206       if (event.type == sf::Event::Closed) {\r
 207         running = false;\r
 208       } else if (event.type == sf::Event::Resized) {\r
 209         glViewport(0, 0, event.size.width, event.size.height);\r
 210       } else if (event.type == sf::Event::KeyReleased) {\r
 211         using keys = sf::Keyboard;\r
 212         switch (event.key.code) {\r
 213         case keys::W:\r
 214           wireframe = !wireframe;\r
 215           break;\r
 216         case keys::Escape:\r
 217           running = false;\r
 218           break;\r
 219         }\r
 220       }\r
 221     }\r
 222 \r
 223     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);\r
 224 \r
 225     glEnable(GL_DEPTH_TEST);\r
 226 \r
 227     if (wireframe)\r
 228       glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);\r
 229     else\r
 230       glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);\r
 231 \r
 232     glUseProgram(shaderProgram);\r
 233 \r
 234     model = glm::rotate(model, glm::radians(0.2f), glm::vec3(0.0f, 1.0f, 0.0f));\r
 235 \r
 236     glUniformMatrix4fv(glGetUniformLocation(shaderProgram, "model"), 1,\r
 237                        GL_FALSE, glm::value_ptr(model));\r
 238     glUniformMatrix4fv(glGetUniformLocation(shaderProgram, "view"), 1, GL_FALSE,\r
 239                        glm::value_ptr(view));\r
 240     glUniformMatrix4fv(glGetUniformLocation(shaderProgram, "projection"), 1,\r
 241                        GL_FALSE, glm::value_ptr(proj));\r
 242 \r
 243     glUniform3f(glGetUniformLocation(shaderProgram, "objectColor"), 1.0f, 0.5f,\r
 244                 0.31f);\r
 245     glUniform3f(glGetUniformLocation(shaderProgram, "lightColor"), 1.0f, 1.0f,\r
 246                 1.0f);\r
 247     glUniform3fv(glGetUniformLocation(shaderProgram, "lightPos"), 1, glm::value_ptr(lightPos));\r
 248 \r
 249     glBindVertexArray(VAO);\r
 250     glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_INT, 0);\r
 251     glBindVertexArray(0);\r
 252 \r
 253     window.display();\r
 254   }\r
 255 \r
 256   return 0;\r
 257 }