Added task 3

Author: Ilya Makarov

src/CMakeLists.txt

@@ -18,3 +18,4 @@ add_subdirectory(sayfudinova)
 add_subdirectory(Antonova)
 add_subdirectory(Biryuchkov)
 add_subdirectory(Bondarchuk)
+add_subdirectory(kolodkin)

src/kolodkin/CMakeLists.txt

@@ -0,0 +1 @@
+add_subdirectory(task3)

src/kolodkin/task3/CMakeLists.txt

@@ -0,0 +1,47 @@
+set(SRC_LIST
+        cameraview.cpp
+        cameraview.hpp
+        dialog.cpp
+        dialog.hpp
+        dialog.ui
+        direcltylight.cpp
+        direcltylight.hpp
+        GuroSceneObject.frag
+        GuroSceneObject.vert
+        keyboard.cpp
+        keyboard.hpp
+        lightsource.hpp
+        LightSource.vert
+        main.cpp
+        mainwindow.cpp
+        mainwindow.hpp
+        mainwindow.ui
+        material.hpp
+        materialfactory.hpp
+        mesh.hpp
+        meshfactory.cpp
+        meshfactory.hpp
+        meshobject.cpp
+        meshobject.hpp
+        object.hpp
+        objectsgrid.cpp
+        objectsgrid.hpp
+        pointlightsource.cpp
+        pointlightsource.hpp
+        renderobject.hpp
+        scene.cpp
+        scene.hpp
+        sceneobject.cpp
+        sceneobject.hpp
+        scenewidget.cpp
+        scenewidget.hpp
+        shaders.qrc
+        spotlightsource.cpp
+        spotlightsource.hpp
+        vertex.hpp)
+
+add_executable(kolodkin-task3 ${SRC_LIST})
+
+find_package(Qt5 COMPONENTS Widgets REQUIRED)
+
+target_link_libraries(kolodkin-task3 PRIVATE Qt5::Widgets)

src/kolodkin/task3/GuroSceneObject.frag

@@ -0,0 +1,9 @@
+#version 400
+in lowp vec4 vertexColor;
+
+out vec4 outColor;
+
+void main()
+{
+    outColor = vertexColor;
+}

src/kolodkin/task3/GuroSceneObject.vert

@@ -0,0 +1,143 @@
+#version 400
+uniform highp mat4 model;
+uniform highp mat4 normModel;
+uniform highp mat4 projView;
+uniform highp vec3 cameraPos;
+
+struct Material
+{
+    vec3 ambient;
+    vec3 diffuse;
+    vec3 specular;
+    float shininess;
+};
+
+struct DirLightSource
+{
+    lowp vec3 color;
+    float intensity;
+    highp vec3 direction;
+};
+
+struct PointLightSource
+{
+    lowp vec3 color;
+    highp vec3 position;
+
+    float intensity;
+    float constFactor;
+    float linFactor;
+    float quadFactor;
+};
+
+struct SpotLightSource
+{
+    lowp vec3 color;
+    highp vec3 position;
+    highp vec3 direction;
+
+    float cutOff;
+    float outerCutOff;
+
+    float intensity;
+    float constFactor;
+    float linFactor;
+    float quadFactor;
+};
+
+uniform DirLightSource dirLights[10];
+uniform int dirLightsCount;
+
+uniform PointLightSource pointLights[10];
+uniform int pointLightsCount;
+
+uniform SpotLightSource spotLights[10];
+uniform int spotLightsCount;
+
+uniform Material material;
+
+vec3 CalcDirLight(DirLightSource light, vec3 normal, vec3 toEye)
+{
+    vec3 lightDir = normalize(-light.direction);
+    // diffuse shading
+    float diff = max(dot(normal, lightDir), 0.0);
+    // specular shading
+    vec3 reflectDir = reflect(-lightDir, normal);
+    float spec = pow(max(dot(toEye, reflectDir), 0.0), material.shininess) * sign(diff);
+    // combine results
+    vec3 ambient  = material.ambient;
+    vec3 diffuse  = diff * material.diffuse;
+    vec3 specular = spec * material.specular;
+    return light.intensity * light.color * (ambient + diffuse + specular);
+}
+
+vec3 CalcPointLight(PointLightSource light, vec3 normal, vec3 vertexPos, vec3 toEye)
+{
+    vec3 lightDir = normalize(light.position - vertexPos);
+    // diffuse shading
+    float diff = max(dot(normal, lightDir), 0.0);
+    // specular shading
+    vec3 reflectDir = reflect(-lightDir, normal);
+    float spec = pow(max(dot(toEye, reflectDir), 0.0), 256) * sign(diff);
+    // attenuation
+    float distance = length(light.position - vertexPos);
+    float attenuation = 1.0 / (light.constFactor + light.linFactor * distance +
+    light.quadFactor * distance * distance);
+    // combine results
+    vec3 diffuse  = diff * material.diffuse;
+    vec3 specular = spec * material.specular;
+
+    return light.intensity * attenuation * (diffuse + specular) * light.color;
+}
+
+vec3 CalcSpotLight(SpotLightSource light, vec3 normal, vec3 vertexPos, vec3 toEye)
+{
+    vec3 lightDir = normalize(light.position - vertexPos);
+    // diffuse shading
+    float diff = max(dot(normal, lightDir), 0.0);
+    // specular shading
+    vec3 reflectDir = reflect(-lightDir, normal);
+    float spec = pow(max(dot(toEye, reflectDir), 0.0), material.shininess) * sign(diff);
+    // attenuation
+    float distance = length(light.position - vertexPos);
+    float attenuation = 1.0 / (light.constFactor + light.linFactor * distance +
+    light.quadFactor * distance * distance);
+    // spotlight intensity
+    float theta = acos(dot(lightDir, normalize(-light.direction)));
+    float epsilon = light.cutOff - light.outerCutOff;
+    float intensity = light.intensity * clamp((theta - light.outerCutOff) / epsilon, 0.0, 1.0);
+    // combine results
+    vec3 diffuse  = diff * material.diffuse;
+    vec3 specular = spec * material.specular;
+
+    return attenuation * intensity * (diffuse + specular) * light.color;
+}
+
+layout (location = 0) in highp vec3 position;
+layout (location = 1) in highp vec3 normal;
+
+out lowp vec4 vertexColor;
+
+void main()
+{
+    vec3 norm = normalize(mat3(normModel) * normal);
+    vec4 worldVertexPos = model * vec4(position, 1.f);
+    vec3 toEye = normalize(cameraPos - worldVertexPos.xyz);
+    vec3 resultCol = vec3(0.0);
+
+    for (int i = 0; i < min(dirLightsCount, 10); ++i)
+    {
+        resultCol += CalcDirLight(dirLights[i], norm, toEye);
+    }
+    for (int i = 0; i < min(pointLightsCount, 10); ++i)
+    {
+        resultCol += CalcPointLight(pointLights[i], norm, worldVertexPos.xyz, toEye);
+    }
+    for (int i = 0; i < min(spotLightsCount, 10); ++i)
+    {
+        resultCol += CalcSpotLight(spotLights[i], norm, worldVertexPos.xyz, toEye);
+    }
+
+    vertexColor = vec4(resultCol, 1.0);
+    gl_Position = projView * worldVertexPos;
+}

src/kolodkin/task3/LightSource.vert

@@ -0,0 +1,17 @@
+#version 400
+uniform highp mat4 model;
+uniform highp mat4 normModel;
+uniform highp mat4 projView;
+
+uniform lowp vec3 lightColor;
+
+in highp vec3 position;
+in highp vec3 normal;
+
+out lowp vec4 vertexColor;
+
+void main()
+{
+    vertexColor = vec4(lightColor, 1.0);
+    gl_Position = projView * model * vec4(position, 1.f);
+}

src/kolodkin/task3/cameraview.cpp

@@ -0,0 +1,80 @@
+#include "cameraview.hpp"
+#include <algorithm>
+#include <cmath>
+
+void CameraView::updateVectors() {
+  front_.setX(std::cos(yaw_) * std::cos(pitch_));
+  front_.setY(-std::sin(pitch_));
+  front_.setZ(std::sin(yaw_) * std::cos(pitch_));
+  front_.normalize();
+  right_ = QVector3D::crossProduct(front_, worldUp_).normalized();
+  up_ = QVector3D::crossProduct(right_, front_).normalized();
+}
+
+CameraView::CameraView(const QVector3D &eye_pos, const QVector3D &front,
+                       const QVector3D &up)
+    : eyePos_(eye_pos), front_(front), worldUp_(up) {
+  yaw_ = std::atan2(front_.z(), front_.x());
+  pitch_ = -std::asin(front_.y());
+  updateVectors();
+}
+
+QMatrix4x4 const &CameraView::getViewMatrix() {
+  view_.setToIdentity();
+  view_.lookAt(eyePos_, eyePos_ + front_, up_);
+  return view_;
+}
+
+const QMatrix4x4 &CameraView::getProjectionMatrix() {
+  projection_.setToIdentity();
+  projection_.perspective(fov_, aspectRatio_, zNear_, zFar_);
+  return projection_;
+}
+
+const QMatrix4x4 &CameraView::getProjViewMatrix() {
+  projView_ = getProjectionMatrix() * getViewMatrix();
+  return projView_;
+}
+
+const QVector3D &CameraView::cameraPosition() const { return eyePos_; }
+
+const QVector3D &CameraView::front() const { return front_; }
+
+const QVector3D &CameraView::up() const { return up_; }
+
+const QVector3D &CameraView::right() const { return right_; }
+
+void CameraView::setProjection(float fov, float aspectRatio, float zNear,
+                               float zFar) {
+  setFOV(fov);
+  setAspectRatio(aspectRatio);
+  setZNear(zNear);
+  setZFar(zFar);
+}
+
+void CameraView::setFOV(float fov) { fov_ = fov; }
+
+void CameraView::setAspectRatio(float ratio) { aspectRatio_ = ratio; }
+
+void CameraView::setZNear(float zNear) { zNear_ = zNear; }
+
+void CameraView::setZFar(float zFar) { zFar_ = zFar; }
+
+void CameraView::offsetMove(const QVector3D &offset) {
+  eyePos_ += front_ * offset.z();
+  eyePos_ += up_ * offset.y();
+  eyePos_ += right_ * offset.x();
+}
+
+void CameraView::moveTo(const QVector3D &position) { eyePos_ = position; }
+
+void CameraView::rotate(float yaw, float pitch) {
+  yaw_ += yaw;
+  pitch_ += pitch;
+
+  if constexpr (constrainPitch) {
+    pitch_ = std::clamp(pitch_, -static_cast<float>(M_PI) / 2.2f,
+                        static_cast<float>(M_PI) / 2.2f);
+  }
+  updateVectors();
+}

src/kolodkin/task3/cameraview.hpp

@@ -0,0 +1,54 @@
+#pragma once
+
+#include "object.hpp"
+
+#include <QMatrix4x4>
+#include <QVector3D>
+#include <cmath>
+
+class CameraView final : public Object {
+  QMatrix4x4 view_{};
+  QMatrix4x4 projection_{};
+  QMatrix4x4 projView_{};
+
+  QVector3D eyePos_;
+  QVector3D up_;
+  QVector3D front_;
+  QVector3D right_;
+  QVector3D worldUp_;
+
+  float aspectRatio_;
+  float zNear_;
+  float zFar_;
+  float fov_;
+
+  float yaw_ = -M_PI / 2;
+  float pitch_ = 0.f;
+
+  void updateVectors();
+
+public:
+  inline static constexpr bool constrainPitch = true;
+
+  CameraView(QVector3D const &eye_pos = {},
+             QVector3D const &front = {0.f, 0.f, -1.f},
+             QVector3D const &up = {0.f, 1.f, 0.f});
+  QMatrix4x4 const &getViewMatrix();
+  QMatrix4x4 const &getProjectionMatrix();
+  QMatrix4x4 const &getProjViewMatrix();
+  const QVector3D &cameraPosition() const;
+  const QVector3D &front() const;
+  const QVector3D &up() const;
+  const QVector3D &right() const;
+
+  void setProjection(float fov, float aspectRatio, float zNear, float zFar);
+  void setFOV(float fov);
+  void setAspectRatio(float ratio);
+  void setZNear(float zNear);
+  void setZFar(float zFar);
+
+  void offsetMove(QVector3D const &offset) override;
+  void moveTo(QVector3D const &position) override;
+
+  void rotate(float yaw, float pitch);
+};