lesson2.1

Author: levshx

lesson1.2/.gitignore

@@ -0,0 +1,4 @@
+cache/
+nimblecache/
+htmldocs/
+*.exe

lesson1.2/README.md

@@ -0,0 +1 @@
+# Lesson 1.1

lesson1.2/core/camera.nim

@@ -0,0 +1,68 @@
+import os, strutils
+import nimgl/opengl
+import glm
+
+
+type
+    Camera* = object
+        position*: Vec3[GLfloat]
+        front*: Vec3[GLfloat]
+        up*: Vec3[GLfloat]
+        right*: Vec3[GLfloat]
+        worldUp*: Vec3[GLfloat]
+        # Eular Angles
+        yaw*: GLfloat
+        pitch*: GLfloat
+        # roll*: GLfloat # чекать
+        # Camera options
+        # movementSpeed*: GLfloat
+        # mouseSensitivity*: GLfloat
+        zoom*: GLfloat
+proc updateCameraVectors(self: var Camera): void; 
+   
+
+
+proc newCamera*(
+    position: Vec3[GLfloat] = vec3(0.0f, 0.0f, 0.0f),
+    up: Vec3[GLfloat] = vec3(0.0f, 1.0f, 0.0f), 
+    yaw: GLfloat = -90.0f,
+    pitch: GLfloat = 0.0f,
+    zoom: GLfloat = radians(45.0f)
+    ): Camera = 
+    ## Constructor with vectors
+    result.position = position
+    result.position = position
+    result.worldUp = up
+    result.yaw = yaw
+    result.pitch = pitch
+    result.zoom = zoom
+    result.updateCameraVectors()
+
+proc newCamera*(
+    posX, posY, posZ, upX, upY, upZ, yaw, pitch: GLfloat, zoom: GLfloat = radians(45.0f)
+    ): Camera = 
+    ## Constructor with scalars
+    result.position = vec3(posX, posY, posZ)
+    result.worldUp = vec3(upX, upY, upZ)
+    result.yaw = yaw
+    result.pitch = pitch
+    result.zoom = zoom
+    result.updateCameraVectors()
+
+#proc setDirection(self: var Camera): void = 
+
+
+proc getViewMatrix*(self: var Camera): Mat4[GLfloat] =
+    self.updateCameraVectors()
+    return lookAt(self.position, self.position + self.front, self.up)
+
+proc updateCameraVectors(self: var Camera): void =
+    var front: Vec3[GLfloat]
+    front.x = cos(radians(self.yaw)) * cos(radians(self.pitch))
+    front.y = sin(radians(self.pitch))
+    front.z = sin(radians(self.yaw)) * cos(radians(self.pitch))
+    self.front = normalize(front);
+    #Also re-calculate the Right and Up vector
+    self.right = normalize(cross(self.front, self.worldUp)) # Normalize the vectors, because their length gets closer to 0 the more you look up or down which results in slower movement.
+    self.up = normalize(cross(self.right, self.front))
+

lesson1.2/core/mesh.nim

@@ -0,0 +1,75 @@
+import nimgl/opengl
+import glm
+import ../core/shader
+
+type 
+    TextureType* = enum
+        texture_diffuse,
+        texture_specular,
+        texture_normal,
+        texture_height
+    Texture*  = object
+        id*: GLuint 
+        texType*: TextureType
+    Vertex* = object 
+        position*: Vec3[GLfloat]
+        normal*: Vec3[GLfloat]
+        texCoords*: Vec2[GLfloat]
+    Mesh* = object
+        vertices*: seq[Vertex]       
+        indices*: seq[GLuint]
+        textures*: seq[Texture] 
+        VAO, VBO, EBO: GLuint  
+    
+proc setupMesh*(mesh: var Mesh): void =
+    glGenVertexArrays(1, addr mesh.VAO)
+    glGenBuffers(1, addr mesh.VBO)
+    glGenBuffers(1, addr mesh.EBO)
+
+    glBindVertexArray(mesh.VAO)
+    glBindBuffer(GL_ARRAY_BUFFER, mesh.VBO)
+
+    glBufferData(GL_ARRAY_BUFFER, mesh.vertices.sizeof(), addr mesh.vertices[0], GL_STATIC_DRAW) 
+
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mesh.EBO);
+    glBufferData(GL_ELEMENT_ARRAY_BUFFER, mesh.indices.sizeof(), addr mesh.indices[0], GL_STATIC_DRAW)
+    # vertex positions
+    glEnableVertexAttribArray(0.GLuint)
+    glVertexAttribPointer(0.GLuint, 3.GLint, EGL_FLOAT, false, sizeof(Vertex).GLsizei, cast[pointer](0))
+    # vertex normals
+    glEnableVertexAttribArray(1.GLuint)
+    glVertexAttribPointer(1.GLuint, 3.GLint, EGL_FLOAT, false, sizeof(Vertex).GLsizei, cast[pointer](offsetof(Vertex, normal)))
+    # vertex texture coords
+    glEnableVertexAttribArray(2.GLuint)
+    glVertexAttribPointer(2.GLuint, 2.GLint, EGL_FLOAT, false, sizeof(Vertex).GLsizei,  cast[pointer](offsetof(Vertex, texCoords)))
+    glBindVertexArray(0)
+
+# , shader: var Shader
+proc draw*(mesh: var Mesh): void =
+
+    if mesh.textures.len > 0:
+        for textureN in 0..mesh.textures.len-1:    
+            glActiveTexture((GL_TEXTURE0.GLuint + textureN.GLuint).GLEnum) #activate proper texture unit before binding
+            case (mesh.textures[textureN].texType):
+                of texture_diffuse:                     
+                    break
+                of texture_specular:                    
+                    break
+                of texture_normal:
+                    break
+                of texture_height:
+                    break
+                else:
+                    errorMessageWriter("Unknown TextureType." & $mesh.textures[textureN].texType)
+
+            # now set the sampler to the correct texture unit
+            #glUniform1i(glGetUniformLocation(shader.ID, (name + number).c_str()), i)                
+            glBindTexture(GL_TEXTURE_2D, mesh.textures[textureN].id)
+
+        glActiveTexture(GL_TEXTURE0);
+    
+    # draw mesh
+    glBindVertexArray(mesh.VAO);
+    glDrawElements(GL_TRIANGLES, mesh.indices.len.GLsizei, GL_UNSIGNED_INT, cast[pointer](0));
+    glBindVertexArray(0);
+

lesson1.2/core/shader.nim

@@ -0,0 +1,93 @@
+import os, strutils
+import nimgl/opengl
+import glm
+
+    
+type
+    Shader* = object
+        id*: GLuint
+
+
+proc readShader*(filepath: string): cstring  =
+    ## Read shader from file with dependencies
+    try:        
+        var source = splitLines(readFile(filepath))
+        let path = splitFile(filepath)
+
+        for line in 0..source.len-1:
+            if source[line].find("#include ") != -1:
+                let file = source[line].splitWhitespace()
+                source[line] = $readShader(path.dir & "/" & file[1])
+        return join(source, "\n\r").cstring
+    except IOError:
+        echo("ERROR LOAD SHADER " & filepath)
+    
+proc statusShader(shader: GLuint) =
+    ## (ECHO ERROR) 
+    var status: int32
+    glGetShaderiv(shader, GL_COMPILE_STATUS, status.addr);
+    if status != GL_TRUE.ord:
+        var
+            log_length: int32
+            message = newSeq[char](1024)
+            res: string
+        glGetShaderInfoLog(shader, 1024, log_length.addr, message[0].addr);
+        for i in message:
+            res &= i
+        echo res
+
+proc statusProgram(program: GLuint) =
+    ## (ECHO ERROR)
+    var
+        log_length: int32
+        message = newSeq[char](1024)
+        pLinked: int32
+        res: string
+    glGetProgramiv(program, GL_LINK_STATUS, pLinked.addr);
+    if pLinked != GL_TRUE.ord:
+        glGetProgramInfoLog(program, 1024, log_length.addr, message[0].addr);
+        for i in message:
+            res &= i
+        echo res
+
+
+proc newShader*(vertexPath, fragmentPath: string): Shader =
+    try:      
+        var     
+            vertexCode = readShader(vertexPath)
+            fragmentCode = readShader(fragmentPath)
+
+        let vertex = glCreateShader(GL_VERTEX_SHADER)
+        glShaderSource(vertex, 1'i32, vertexCode.addr, nil)
+        glCompileShader(vertex)
+        statusShader(vertex)
+
+        let fragment = glCreateShader(GL_FRAGMENT_SHADER)
+        glShaderSource(fragment, 1, fragmentCode.addr, nil)
+        glCompileShader(fragment)
+        statusShader(fragment)
+
+        let program = glCreateProgram()
+        glAttachShader(program, vertex)
+        glAttachShader(program, fragment)
+        glLinkProgram(program)
+        statusProgram(program)
+
+        result.id = program
+
+        glDeleteShader(vertex)
+        glDeleteShader(fragment)
+    except:
+        echo("Shader was not loaded!!!")
+
+proc use*(shader: Shader): void =
+    glUseProgram(shader.id)
+
+proc setBool*(shader: Shader, name: string, value: GLboolean): void = 
+    glUniform1i(glGetUniformLocation(shader.id, name), value.GLint)
+
+proc setInt*(shader: Shader, name: string, value: GLint): void = 
+    glUniform1i(glGetUniformLocation(shader.id, name), value)
+
+proc setFloat*(shader: Shader, name: string, value: GLfloat): void = 
+    glUniform1f(glGetUniformLocation(shader.id, name), value)

lesson1.2/core/texture.nim

@@ -0,0 +1,46 @@
+import nimgl/opengl
+import ../vendor/stb_image/read as stbi
+import os
+
+type
+  Texture* = ref object
+    rendererId*: uint32
+    filepath*: string
+    localBuffer*: seq[byte]
+    width*: int
+    height*: int
+    bpp*: int
+
+
+proc newTexture*(filepath: string): Texture =
+  result = Texture(filepath: filepath)
+  stbi.setFlipVerticallyOnLoad(false)
+  result.localBuffer = stbi.load(filepath, result.width, result.height, result.bpp, 4)
+  glGenTextures(1, result.rendererId.addr)
+  glBindTexture(GL_TEXTURE_2D, result.rendererId)
+
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR.int32)
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR.int32)
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE.int32)
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE.int32)
+
+  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8.int32, result.width.int32, result.height.int32, 0,
+               GL_RGBA, GL_UNSIGNED_BYTE, result.localBuffer[0].addr)
+  glGenerateMipmap(GL_TEXTURE_2D)
+
+  result.localBuffer = @[]
+
+# разобраться в номерах текстур
+
+proc `bind`*(texture: Texture, offset: uint32 = 0) =
+  if texture.rendererId + offset < 16:
+    glActiveTexture(GLenum(GL_TEXTURE0.ord + texture.rendererId))
+  glBindTexture(GL_TEXTURE_2D, texture.rendererId)
+
+# proc `bind`*(texture: Texture, offset: uint32 = 0) =
+#   if texture.rendererId + offset < 16:
+#     glActiveTexture(GLenum(GL_TEXTURE0.ord + offset + texture.rendererId))
+#   glBindTexture(GL_TEXTURE_2D, texture.rendererId)
+
+proc unbind*(texture: Texture) =
+  glBindTexture(GL_TEXTURE_2D, 0)