OpenGL 法线贴图 基础

最新推荐文章于 2024-08-19 15:26:16 发布
最新推荐文章于 2024-08-19 15:26:16 发布
阅读量1.7k 收藏 2
点赞数
分类专栏： OpenGL 文章标签： opengl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yulinxx/article/details/54607594
版权

法线贴图

http://learnopengl-cn.readthedocs.io/zh/latest/05%20Advanced%20Lighting/04%20Normal%20Mapping/

main.cpp

#include <string>

#define GLEW_STATIC
#include <GL/glew.h>

#include <GLFW/glfw3.h>

#include "shader.h"
#include "camera.h"

#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <SOIL/SOIL.h>

#pragma comment(lib, "./SOIL.lib")

#pragma comment (lib, "opengl32.lib")
#pragma comment (lib, "glew32s.lib")
#pragma comment (lib, "glfw3.lib") 
#pragma comment (lib, "glfw3dll.lib") 
#pragma comment (lib, "glew32mxs.lib")
#pragma comment (lib, "assimp.lib")


const GLuint SCR_WIDTH = 800, SCR_HEIGHT = 600;

void key_callback(GLFWwindow* pWnd, int key, int scancode, int action, int mode);
void scroll_callback(GLFWwindow* pWnd, double xoffset, double yoffset);
void mouse_callback(GLFWwindow* pWnd, double xpos, double ypos);
void Do_Movement();
GLuint loadTexture(GLchar* path);
void RenderQuad();

Camera camera(glm::vec3(0.0f, 0.0f, 3.0f));

GLfloat deltaTime = 0.0f;
GLfloat lastFrame = 0.0f;

//////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
int main()
{
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);

    GLFWwindow* pWnd = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "OGL Mapping", nullptr, nullptr);
    glfwMakeContextCurrent(pWnd);

    //glfwSetKeyCallback(pWnd, key_callback);
    //glfwSetCursorPosCallback(pWnd, mouse_callback);
    //glfwSetScrollCallback(pWnd, scroll_callback);

    //glfwSetInputMode(pWnd, GLFW_CURSOR, GLFW_CURSOR_DISABLED);

    glewExperimental = GL_TRUE;
    glewInit();

    glViewport(0, 0, SCR_WIDTH, SCR_HEIGHT);

    glEnable(GL_DEPTH_TEST);

    Shader shader("./Shader/normal_mapping.vs", "./Shader/normal_mapping.frag");

    GLuint diffuseMap = loadTexture("./resource/brickwall.jpg");    // 漫反射贴图
    GLuint normalMap = loadTexture("./resource/brickwall_normal.jpg");  // 法线贴图

    shader.useShaderPrograme();
    glUniform1i(glGetUniformLocation(shader.getPrograme(), "diffuseMap"), 0);
    glUniform1i(glGetUniformLocation(shader.getPrograme(), "normalMap"), 1);

    glm::vec3 lightPos(0.5f, 1.0f, 0.3f);


    while (!glfwWindowShouldClose(pWnd))
    {
        GLfloat currentFrame = glfwGetTime();
        deltaTime = currentFrame - lastFrame;
        lastFrame = currentFrame;

        glfwPollEvents();
        Do_Movement();

        glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        shader.useShaderPrograme();
        glm::mat4 view = camera.GetViewMatrix();
        glm::mat4 projection = glm::perspective(camera.Zoom, (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);

        glUniformMatrix4fv(glGetUniformLocation(shader.getPrograme(), "view"), 1, GL_FALSE, glm::value_ptr(view));
        glUniformMatrix4fv(glGetUniformLocation(shader.getPrograme(), "projection"), 1, GL_FALSE, glm::value_ptr(projection));

        glm::mat4 model;
        model = glm::rotate(model, (GLfloat)glfwGetTime() * 1, glm::normalize(glm::vec3(1.0, 0.0, 1.0)));   // 旋转动画
        glUniformMatrix4fv(glGetUniformLocation(shader.getPrograme(), "model"), 1, GL_FALSE, glm::value_ptr(model));
        glUniform3fv(glGetUniformLocation(shader.getPrograme(), "lightPos"), 1, &lightPos[0]);
        glUniform3fv(glGetUniformLocation(shader.getPrograme(), "viewPos"), 1, &camera.Position[0]);

        // 砖墙纹理
        glActiveTexture(GL_TEXTURE0);
        glBindTexture(GL_TEXTURE_2D, diffuseMap);

        // 法线贴图反射光
        glActiveTexture(GL_TEXTURE1);
        glBindTexture(GL_TEXTURE_2D, normalMap);

        RenderQuad();   // 绘制砖墙

        model = glm::mat4();
        model = glm::translate(model, lightPos);
        model = glm::scale(model, glm::vec3(0.1f));
        glUniformMatrix4fv(glGetUniformLocation(shader.getPrograme(), "model"), 1, GL_FALSE, glm::value_ptr(model));

        //RenderQuad(); // 立方体 当作灯泡

        glfwSwapBuffers(pWnd);
    }

    glfwTerminate();
    return 0;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////


GLuint quadVAO = 0;
GLuint quadVBO;

void RenderQuad()
{
    if (quadVAO == 0)
    {
        // 位置
        glm::vec3 pos1(-1.0, 1.0, 0.0);     glm::vec3 pos2(-1.0, -1.0, 0.0);
        glm::vec3 pos3(1.0, -1.0, 0.0);     glm::vec3 pos4(1.0, 1.0, 0.0);
        // 纹理坐标
        glm::vec2 uv1(0.0, 1.0);        glm::vec2 uv2(0.0, 0.0);
        glm::vec2 uv3(1.0, 0.0);        glm::vec2 uv4(1.0, 1.0);
        // 向量 normal vector
        glm::vec3 nm(0.0, 0.0, 1.0);

        // calculate tangent/bitangent vectors of both triangles
        // 切线
        glm::vec3 tangent1, bitangent1;
        glm::vec3 tangent2, bitangent2;

        // 先计算第一个三角形的边和deltaUV坐标   - triangle 1 
        glm::vec3 edge1 = pos2 - pos1;
        glm::vec3 edge2 = pos3 - pos1;
        glm::vec2 deltaUV1 = uv2 - uv1;
        glm::vec2 deltaUV2 = uv3 - uv1;

        // 根据公式进行计算
        GLfloat f = 1.0f / (deltaUV1.x * deltaUV2.y - deltaUV2.x * deltaUV1.y);

        tangent1.x = f * (deltaUV2.y * edge1.x - deltaUV1.y * edge2.x);
        tangent1.y = f * (deltaUV2.y * edge1.y - deltaUV1.y * edge2.y);
        tangent1.z = f * (deltaUV2.y * edge1.z - deltaUV1.y * edge2.z);
        tangent1 = glm::normalize(tangent1);    // 进行标准化

        bitangent1.x = f * (-deltaUV2.x * edge1.x + deltaUV1.x * edge2.x);
        bitangent1.y = f * (-deltaUV2.x * edge1.y + deltaUV1.x * edge2.y);
        bitangent1.z = f * (-deltaUV2.x * edge1.z + deltaUV1.x * edge2.z);
        bitangent1 = glm::normalize(bitangent1);

        // - triangle 2
        edge1 = pos3 - pos1;
        edge2 = pos4 - pos1;
        deltaUV1 = uv3 - uv1;
        deltaUV2 = uv4 - uv1;

        f = 1.0f / (deltaUV1.x * deltaUV2.y - deltaUV2.x * deltaUV1.y);

        tangent2.x = f * (deltaUV2.y * edge1.x - deltaUV1.y * edge2.x);
        tangent2.y = f * (deltaUV2.y * edge1.y - deltaUV1.y * edge2.y);
        tangent2.z = f * (deltaUV2.y * edge1.z - deltaUV1.y * edge2.z);
        tangent2 = glm::normalize(tangent2);

        bitangent2.x = f * (-deltaUV2.x * edge1.x + deltaUV1.x * edge2.x);
        bitangent2.y = f * (-deltaUV2.x * edge1.y + deltaUV1.x * edge2.y);
        bitangent2.z = f * (-deltaUV2.x * edge1.z + deltaUV1.x * edge2.z);
        bitangent2 = glm::normalize(bitangent2);


        GLfloat quadVertices[] = {
            // Positions            // normal         // TexCoords  // Tangent                          // Bitangent
            pos1.x, pos1.y, pos1.z, nm.x, nm.y, nm.z, uv1.x, uv1.y, tangent1.x, tangent1.y, tangent1.z, bitangent1.x, bitangent1.y, bitangent1.z,
            pos2.x, pos2.y, pos2.z, nm.x, nm.y, nm.z, uv2.x, uv2.y, tangent1.x, tangent1.y, tangent1.z, bitangent1.x, bitangent1.y, bitangent1.z,
            pos3.x, pos3.y, pos3.z, nm.x, nm.y, nm.z, uv3.x, uv3.y, tangent1.x, tangent1.y, tangent1.z, bitangent1.x, bitangent1.y, bitangent1.z,

            pos1.x, pos1.y, pos1.z, nm.x, nm.y, nm.z, uv1.x, uv1.y, tangent2.x, tangent2.y, tangent2.z, bitangent2.x, bitangent2.y, bitangent2.z,
            pos3.x, pos3.y, pos3.z, nm.x, nm.y, nm.z, uv3.x, uv3.y, tangent2.x, tangent2.y, tangent2.z, bitangent2.x, bitangent2.y, bitangent2.z,
            pos4.x, pos4.y, pos4.z, nm.x, nm.y, nm.z, uv4.x, uv4.y, tangent2.x, tangent2.y, tangent2.z, bitangent2.x, bitangent2.y, bitangent2.z
        };

        // 平面
        glGenVertexArrays(1, &quadVAO);
        glBindVertexArray(quadVAO);
        {
            glGenBuffers(1, &quadVBO);
            glBindBuffer(GL_ARRAY_BUFFER, quadVBO);
            {
                glBufferData(GL_ARRAY_BUFFER, sizeof(quadVertices), &quadVertices, GL_STATIC_DRAW);

                glEnableVertexAttribArray(0);       // 对应vs的 position
                glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 14 * sizeof(GLfloat), (GLvoid*)0);

                glEnableVertexAttribArray(1);       // 对应vs的 normal
                glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 14 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat)));

                glEnableVertexAttribArray(2);       // 对应vs的 texCoords
                glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 14 * sizeof(GLfloat), (GLvoid*)(6 * sizeof(GLfloat)));

                glEnableVertexAttribArray(3);       // 对应vs的 tangent
                glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, 14 * sizeof(GLfloat), (GLvoid*)(8 * sizeof(GLfloat)));

                glEnableVertexAttribArray(4);       // 对应vs的 bitangent
                glVertexAttribPointer(4, 3, GL_FLOAT, GL_FALSE, 14 * sizeof(GLfloat), (GLvoid*)(11 * sizeof(GLfloat)));
            }
            glBindBuffer(GL_ARRAY_BUFFER, 0);
        }
        glBindVertexArray(0);
    }

    glBindVertexArray(quadVAO);
    glDrawArrays(GL_TRIANGLES, 0, 6);
    glBindVertexArray(0);
}


GLuint loadTexture(GLchar* path)
{
    GLuint textureID;
    glGenTextures(1, &textureID);
    int width, height;
    unsigned char* image = SOIL_load_image(path, &width, &height, 0, SOIL_LOAD_RGB);

    glBindTexture(GL_TEXTURE_2D, textureID);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image);
    glGenerateMipmap(GL_TEXTURE_2D);

    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);
    glBindTexture(GL_TEXTURE_2D, 0);
    SOIL_free_image_data(image);
    return textureID;
}


bool keys[1024];
bool keysPressed[1024];
void Do_Movement()
{
    // Camera controls
    if (keys[GLFW_KEY_W])
        camera.ProcessKeyboard(FORWARD, deltaTime);
    if (keys[GLFW_KEY_S])
        camera.ProcessKeyboard(BACKWARD, deltaTime);
    if (keys[GLFW_KEY_A])
        camera.ProcessKeyboard(LEFT, deltaTime);
    if (keys[GLFW_KEY_D])
        camera.ProcessKeyboard(RIGHT, deltaTime);
}


void key_callback(GLFWwindow* pWnd, int key, int scancode, int action, int mode)
{
    if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)
        glfwSetWindowShouldClose(pWnd, GL_TRUE);

    if (key >= 0 && key <= 1024)
    {
        if (action == GLFW_PRESS)
            keys[key] = true;
        else if (action == GLFW_RELEASE)
        {
            keys[key] = false;
            keysPressed[key] = false;
        }
    }
}

GLfloat lastX = 400, lastY = 300;
bool firstMouse = true;
void mouse_callback(GLFWwindow* pWnd, double xpos, double ypos)
{
    if (firstMouse)
    {
        lastX = xpos;
        lastY = ypos;
        firstMouse = false;
    }

    GLfloat xoffset = xpos - lastX;
    GLfloat yoffset = lastY - ypos;

    lastX = xpos;
    lastY = ypos;

    camera.ProcessMouseMovement(xoffset, yoffset);
}

void scroll_callback(GLFWwindow* pWnd, double xoffset, double yoffset)
{
    camera.ProcessMouseScroll(yoffset);
}

Camera.h

//Camera.h 

#pragma once

// Std. Includes
#include <vector>

// GL Includes
#include <GL/glew.h>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>


// 摄像机移动方向  程序中用WSAD控制
enum Camera_Movement {
    FORWARD,
    BACKWARD,
    LEFT,
    RIGHT
};

// Default camera values
const GLfloat YAW = -90.0f;
const GLfloat PITCH = 0.0f;
const GLfloat SPEED = 3.0f;
const GLfloat SENSITIVTY = 0.25f;
const GLfloat ZOOM = 45.0f;


class Camera
{
public:
    // Camera Attributes
    glm::vec3 Position;
    glm::vec3 Front;
    glm::vec3 Up;
    glm::vec3 Right;
    glm::vec3 WorldUp;
    // Eular Angles
    GLfloat Yaw;
    GLfloat Pitch;
    // Camera options
    GLfloat MovementSpeed;
    GLfloat MouseSensitivity;
    GLfloat Zoom;

    // Constructor with vectors
    Camera(glm::vec3 position = glm::vec3(0.0f, 0.0f, 0.0f), 
        glm::vec3 up = glm::vec3(0.0f, 1.0f, 0.0f), GLfloat yaw = YAW, 
        GLfloat pitch = PITCH) : Front(glm::vec3(0.0f, 0.0f, -1.0f)), 
        MovementSpeed(SPEED), MouseSensitivity(SENSITIVTY), Zoom(ZOOM)
    {
        this->Position = position;
        this->WorldUp = up;
        this->Yaw = yaw;
        this->Pitch = pitch;
        this->updateCameraVectors();
    }
    // Constructor with scalar values
    Camera(GLfloat posX, GLfloat posY, GLfloat posZ, GLfloat upX, GLfloat upY, 
        GLfloat upZ, GLfloat yaw, GLfloat pitch) : Front(glm::vec3(0.0f, 0.0f, -1.0f)), 
        MovementSpeed(SPEED), MouseSensitivity(SENSITIVTY), Zoom(ZOOM)
    {
        this->Position = glm::vec3(posX, posY, posZ);
        this->WorldUp = glm::vec3(upX, upY, upZ);
        this->Yaw = yaw;
        this->Pitch = pitch;
        this->updateCameraVectors();
    }

    // Returns the view matrix calculated using Eular Angles and the LookAt Matrix
    glm::mat4 GetViewMatrix()
    {
        return glm::lookAt(this->Position, this->Position + this->Front, this->Up);
    }

    // 按键处理
    void ProcessKeyboard(Camera_Movement direction, GLfloat deltaTime)
    {
        GLfloat velocity = this->MovementSpeed * deltaTime;
        if (direction == FORWARD)
            this->Position += this->Front * velocity;
        if (direction == BACKWARD)
            this->Position -= this->Front * velocity;
        if (direction == LEFT)
            this->Position -= this->Right * velocity;
        if (direction == RIGHT)
            this->Position += this->Right * velocity;
    }

    // 鼠标移动处理
    void ProcessMouseMovement(GLfloat xoffset, GLfloat yoffset, 
        GLboolean constrainPitch = true)
    {
        xoffset *= this->MouseSensitivity;
        yoffset *= this->MouseSensitivity;

        this->Yaw += xoffset;
        this->Pitch += yoffset;

        // Make sure that when pitch is out of bounds, screen doesn't get flipped
        if (constrainPitch)
        {
            if (this->Pitch > 89.0f)
                this->Pitch = 89.0f;
            if (this->Pitch < -89.0f)
                this->Pitch = -89.0f;
        }

        // Update Front, Right and Up Vectors using the updated Eular angles
        this->updateCameraVectors();
    }

    // Processes input received from a mouse scroll-wheel event. 
    //      Only requires input on the vertical wheel-axis
    void ProcessMouseScroll(GLfloat yoffset)
    {
        if (this->Zoom >= 1.0f && this->Zoom <= 45.0f)
            this->Zoom -= yoffset;
        if (this->Zoom <= 1.0f)
            this->Zoom = 1.0f;
        if (this->Zoom >= 45.0f)
            this->Zoom = 45.0f;
    }

private:
    // Calculates the front vector from the Camera's (updated) Eular Angles
    void updateCameraVectors()
    {
        // Calculate the new Front vector
        glm::vec3 front;
        front.x = cos(glm::radians(this->Yaw)) * cos(glm::radians(this->Pitch));
        front.y = sin(glm::radians(this->Pitch));
        front.z = sin(glm::radians(this->Yaw)) * cos(glm::radians(this->Pitch));
        this->Front = glm::normalize(front);
        // Also re-calculate the Right and Up vector
        // Normalize the vectors, because their length gets closer to 0 the more 
        //      you look up or down which results in slower movement.
        this->Right = glm::normalize(glm::cross(this->Front, this->WorldUp));  
        this->Up = glm::normalize(glm::cross(this->Right, this->Front));
    }
};

Shader.h

//Shader.h 
#pragma once

#ifndef TEXTURE_SHADER_H_
#define TEXTURE_SHADER_H_

#include <string>
#include <fstream>
#include <sstream>
#include <iostream>

#include <gl/glew.h>

#include <string>
#include <fstream>
#include <sstream>
#include <iostream>

#include <GL/glew.h>

class Shader
{
public:
    Shader(const GLchar* vertexPath, const GLchar* fragmentPath);
    ~Shader();

public:
    void useShaderPrograme();

    GLuint getPrograme() {
        return this->m_nProgram;
    }

private:
    GLuint  m_nProgram;
};

Shader::Shader(const GLchar* vertexPath, const GLchar* fragmentPath)
{
    std::string vertexCode;
    std::string fragmentCode;
    std::ifstream vertexShaderF;
    std::ifstream fragementShaderF;

    vertexShaderF.exceptions(std::ifstream::badbit);
    fragementShaderF.exceptions(std::ifstream::badbit);

    try
    {
        vertexShaderF.open(vertexPath);     // 打开文件
        fragementShaderF.open(fragmentPath);

        std::stringstream vertexShaderStream, fragementShaderStream;
        vertexShaderStream << vertexShaderF.rdbuf();    // 读取文件至stringstream中
        fragementShaderStream << fragementShaderF.rdbuf();

        vertexShaderF.close();
        fragementShaderF.close();

        vertexCode = vertexShaderStream.str();      // 转换成string类型
        fragmentCode = fragementShaderStream.str();
    }
    catch (std::ifstream::failure e)
    {
        std::cout << "ERROR::SHADER::FILE_NOT_SUCCESSFULLY_READ:" << std::endl;
    }

    const GLchar* pVertexCode = vertexCode.c_str(); // string 转 char*
    const GLchar* pFragementCode = fragmentCode.c_str();

    GLuint nVertexShader, nFragementShader;
    GLint nRes = 0;
    GLchar chLogInfo[512] = { '\0' };

    // 创建顶点着色器
    nVertexShader = glCreateShader(GL_VERTEX_SHADER);
    // 将顶点着色程序的源代码字符数组绑定到顶点着色器对象
    glShaderSource(nVertexShader, 1, &pVertexCode, nullptr);
    glCompileShader(nVertexShader); // compile shader 编译着色器

    // 获取编译结果
    glGetShaderiv(nVertexShader, GL_COMPILE_STATUS, &nRes);
    if (!nRes)
    {
        glGetShaderInfoLog(nVertexShader, 512, nullptr, chLogInfo);
        std::cout << "ERROR::SHADEF::VERTEX::COMPILATION_FAILED:" << chLogInfo << std::endl;
    }

    // 创建片断着色器
    nFragementShader = glCreateShader(GL_FRAGMENT_SHADER);
    // 将片段着色程序的源代码字符数组绑定到片段着色器对象
    glShaderSource(nFragementShader, 1, &pFragementCode, nullptr);
    glCompileShader(nFragementShader);
    glGetShaderiv(nFragementShader, GL_COMPILE_STATUS, &nRes);
    if (!nRes)
    {
        glGetShaderInfoLog(nFragementShader, 512, nullptr, chLogInfo);
        std::cout << "ERROR::SHADEF::FRAGEMENT::COMPILATION_FAILED:" << chLogInfo << std::endl;
    }

    this->m_nProgram = glCreateProgram();   // 创建GLSL程序
    glAttachShader(this->m_nProgram, nVertexShader);    // 绑定shader到program
    glAttachShader(this->m_nProgram, nFragementShader);

    // glLinkProgram操作产生最后的可执行程序，它包含最后可以在硬件上执行的硬件指令
    glLinkProgram(this->m_nProgram);        // 链接
    glGetProgramiv(this->m_nProgram, GL_LINK_STATUS, &nRes);
    if (!nRes)
    {
        glGetProgramInfoLog(this->m_nProgram, 512, nullptr, chLogInfo);
        std::cout << "ERROR::SHADEF::FRAGEMENT::LINK_FAILED:" << chLogInfo << std::endl;
    }

    glDeleteShader(nVertexShader);
    glDeleteShader(nFragementShader);
}

Shader::~Shader()
{
}

#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>

void Shader::useShaderPrograme()
{
    glUseProgram(this->m_nProgram); // 使用porgram
}

#endif

GLSL Shader 部分

normal_mapping.vs


#version 330 core

// 先将前面计算出来的切线和副切线向量传给顶点着色器
layout (location = 0) in vec3 position;
layout (location = 1) in vec3 normal;
layout (location = 2) in vec2 texCoords;
layout (location = 3) in vec3 tangent;
layout (location = 4) in vec3 bitangent;

out VS_OUT {
    vec3 FragPos;
    vec2 TexCoords;
    vec3 TangentLightPos;
    vec3 TangentViewPos;
    vec3 TangentFragPos;
} vs_out;

uniform mat4 projection;
uniform mat4 view;
uniform mat4 model;

uniform vec3 lightPos;
uniform vec3 viewPos;


void main()
{
    gl_Position = projection * view * model * vec4(position, 1.0f);
    vs_out.FragPos = vec3(model * vec4(position, 1.0));   
    vs_out.TexCoords = texCoords;

    // 创建TBN矩阵
    mat3 normalMatrix = transpose(inverse(mat3(model)));
    vec3 T = normalize(normalMatrix * tangent);
    vec3 B = normalize(normalMatrix * bitangent);
    vec3 N = normalize(normalMatrix * normal);    

    mat3 TBN = transpose(mat3(T, B, N));  
    vs_out.TangentLightPos = TBN * lightPos;
    vs_out.TangentViewPos  = TBN * viewPos;
    vs_out.TangentFragPos  = TBN * vs_out.FragPos;
}

normal_mapping.frag

#version 330 core
out vec4 FragColor;

in VS_OUT {
    vec3 FragPos;
    vec2 TexCoords;
    vec3 TangentLightPos;
    vec3 TangentViewPos;
    vec3 TangentFragPos;
} fs_in;

uniform sampler2D diffuseMap;
uniform sampler2D normalMap;

uniform bool normalMapping;

void main()
{           
    // Obtain normal from normal map in range [0,1]
    vec3 normal = texture(normalMap, fs_in.TexCoords).rgb;
    // Transform normal vector to range [-1,1]
    normal = normalize(normal * 2.0 - 1.0);  // this normal is in tangent space

    // Get diffuse color
    vec3 color = texture(diffuseMap, fs_in.TexCoords).rgb;
    // Ambient
    vec3 ambient = 0.1 * color;
    // Diffuse
    vec3 lightDir = normalize(fs_in.TangentLightPos - fs_in.TangentFragPos);
    float diff = max(dot(lightDir, normal), 0.0);
    vec3 diffuse = diff * color;
    // Specular
    vec3 viewDir = normalize(fs_in.TangentViewPos - fs_in.TangentFragPos);
    vec3 reflectDir = reflect(-lightDir, normal);
    vec3 halfwayDir = normalize(lightDir + viewDir);  
    float spec = pow(max(dot(normal, halfwayDir), 0.0), 32.0);
    vec3 specular = vec3(0.2) * spec;

    FragColor = vec4(ambient + diffuse + specular, 1.0f);
}

这里写图片描述

这里写图片描述

这里写图片描述

源码下载:VS2015
http://download.csdn.net/detail/yulinxx/9741014

cmake.EXE
关注
专栏目录
OpenGL法线贴图
qq_44800780的博客
10-09 971
参考： https://learnopenglcn.github.io/05%20Advanced%20Lighting/04%20Normal%20Mapping/ 现实中的物体表面并非是平坦的，而是表现出无数（凹凸不平的）细节. 例如，砖块的表面。砖块的表面非常粗糙，显然不是完全平坦的：它包含着接缝处水泥凹痕，以及非常多的细小的空洞。如果我们在一个有光的场景中看这样一个砖块的表面，问题就出来了...
opengles法线贴图
hb707934728的博客
06-06 880
效果图： shader实现： const char* vs = { "attribute vec3 inVertex;"//顶点坐标 "attribute vec3 inNormal;"//法向量 "attribute vec2 inTexCoord;"//纹理坐标 "attribute vec3 inTangent;"// 切线坐标
法线贴图的实现【OpenGL】
cycler_725的博客
05-07 1006
复杂物体法线贴图实现【OpenGL】
LearnOpenGL——法线贴图、视差贴图学习笔记
最新发布
weixin_70073176的博客
08-19 1073
我们将观察方向变化到切线空间中，所以P向量的x和y分量会与表面切线和副切线对齐，由于切线和副切线向量与表面纹理坐标的方向相同，我们可以用P的x和y元素作为纹理坐标的偏移量。目前，如果我们让平面竖直面对我们，此时效果正常，因为法线贴图中的法线方向指向z正方向并且平面的法线也指向z轴正方向。将法线向量的x、y、z元素储存到纹理中，代替颜色的r、g、b元素，因为法线向量的范围在[-1,1]，所以我们要先将其映射到[0,1]，变换为RGB颜色元素。法线向量从z轴方向也有向其他方向的偏差，颜色也就发生了轻微的变化。
openGL CG 系列教程06 – Normal Mapping (法线贴图)
GAIA LABORATORY FOR GRAPHICS
05-13 1万+
*原创文章，转载请注明出处* openGL CG 系列教程06 – Normal Mapping (法线贴图) Normal Mapping(法线贴图)，不论是在游戏开发还是其他计算机图形开发中都是使用很广泛的技术。如果一个物体的表面粗糙不平，物体顶点的法线也就朝向各个不同的方向，所以物体看起凹凸不平。要表现这样的物体，当然可以使用相当多的包含不同法线的顶点数据，这样做
Android opengles 法线贴图(Normal Mapping)
红色与青色
05-19 572
在褶皱的画面上做画面替换，比如一件衣服替换衣服的花纹，再比如旗子上替换图案，由于不知道用的是什么计算就搜索相关的东西，原来这种技术叫凹凸映射，有两种实现方法高度纹理(height map)和法线纹理(normal map)，原理方面我也不太懂，所以就不说了，有兴趣可以自己搜索相关内容，我在网上找到了法线纹理的实现方法normalMapping，高度纹理以后找找看 法线纹理是将原图 通过法线贴图 计算出法线向量，最后渲染出来凹凸感 生成法线贴图的工具网上有很多，可以自己搜索 代码和素材都
Normal_mapping.rar_normal_normal mapping_opengl 法线_法线贴图
09-14
在"Normal_mapping.rar_normal_normal mapping_opengl 法线_法线贴图"这个压缩包中，包含了实现OpenGL 4环境下法线贴图所需的各种资源和代码。 首先，我们来看法线贴图的概念。法线贴图是一个二维纹理，其中存储了...
OpenGL ES中的法线贴图（Normal Mapping）应用与优化
# 理解法线贴图（Normal Mapping） ## 1.1 什么是法线贴图？ 法线贴图是一种在表面上模拟光照效果的技术。它通过调整顶点的法线向量来伪造表面的凹凸感，从而增强模型的细节。与传统的纹理贴图不同，法线贴图并不...
OpenGLES—法线贴图
GameCocos2dx的专栏
06-24 1161
{ 1:法线介绍 2:实例 3:推荐博客 } {1:法线介绍 光的强度=光照+法线+法线贴图 模型凹凸纹理效果=基础贴图 X 光的强度 模型有两种贴图 基础贴图 例如一个盒子，盒子是木头纹理，或铁皮纹理 法线贴图 把基础贴图中凹凸的地方生成一个张原纹理大小的贴图 法线 幅法线 切线 } {2:实例 { 1:Shader 2:调用
UE5 Shader基础学习笔记——01-12 图形管线/创建shader/数学节点/贴图压缩/LerpDotUV/常用向量/坐标空间/MinMaxClampSaturate/法线贴图混合
清清！的博客
10-19 4817
本系列学习资料来源，Ben Cloward的油管空间，本笔记主要对其中UE的部分进行记录。
UnityShader 浮雕凹凸贴图BumpMap与法线贴图NormalMap的原理及其区别
起个名字好难啊
05-20 5356
效果图： 浮雕凹凸贴图效果 ====》 高度图 法线贴图凹凸效果 ====> 法线贴图 简介 法线贴图是目前游戏开发中最常见的贴图之一。我们知道，一般情况下，模型面数越高，可以表现的细节越多，效果也越好。但是，由于面数多了，顶点数多了，计算量也就上去了，效果永远...
法线贴图normal mapping
04-03
一个简单的法线贴图实现，使用opengl，在codeblocks+gcc环境下编译
OpenGL核心技术之法线贴图
热门推荐
海洋个人博客
02-28 1万+
笔者介绍：姜雪伟，IT公司技术合伙人，IT高级讲师，CSDN社区专家，特邀编辑，畅销书作者;已出版书籍：《手把手教你架构3D游戏引擎》电子工业出版社和《Unity3D实战核心技术详解》电子工业出版社等。 CSDN视频网址：http://edu.csdn.net/lecturer/144 游戏画面中的美术品质对产品来说非常重要，这决定了产品是否能吸引玩家。美术品质的好坏主要体现在材质的渲染上，材...
学习OpenGL ES之法线贴图
weixin_33895475的博客
01-25 305
获取示例代码 本文将给大家介绍法线贴图的相关知识，在游戏中由于GPU资源有限，尤其是在移动设备中，所以无法使用大量的三角形来表示3D模型的细节。这时候法线贴图就成为了折中的渲染方案，既能够带来不错的细节表现效果，还可以减少资源的消耗。 未使用法线贴图的Cube 使用了法线贴图的Cube 通过上面的图可以看出，法线贴图给Cube表面增加了很多光照上的细节。 什么是法线贴图 到目前为止我们接触到...
openGL增强表面细节----法线贴图
aoxuestudy的专栏
03-06 1743
法线贴图 凹凸贴图的一种替代方法是使用查找表来替换法向量。这样我们就可以在不依赖数学函数的情况下，对凸起进行构造，例如月球上的陨石坑所对应的凸起。一种使用查找表的常见方法叫作法线贴图。
OpenGL基础47：法线贴图
加载中...
08-19 1907
前置：OpenGL基础46：切线空间 这章在《OpenGL基础46：切线空间》之后，如果不了解切线空间的话，是没法很好理解法线贴图的 五、逐像素光照 前文提到过：为了得到正确的光照，需要知道物体每个顶点的法向量，但为了保证效率，一般物体的顶点不会太多，就像一面很长很宽的墙壁，它的表面往往凹凸不平，但事实上它可能单纯的只是一个立方体，每一面给上了一个贴图。这样如果还想要体现出物体“凹凸不平”的效果，就需要用到法线贴图或者高度贴图 之前所有的光照都是逐顶点光照：也就是说对于当前片段，它的法向量取决...
OpenGL3.3法线贴图
qq_43535469的博客
05-25 251
法线贴图 法线贴图：简单来说就是每一个片段都有他自己相应的法线的一个贴图 而不是一个平面统一使用同一个法线（这个贴图目前我知道的只能使用过ps制作出来 不会通过代码实现（很奇怪）） 法线贴图的使用方法： 把纹理贴图使用ps得到法线贴图，将法线贴图存储在项目的纹理中， 通过采样器获取纹理相应的rgb值，这些rgb值就是贴图片段的法线xyz值 把每个片段法线应用在片段上就行 计算出一种矩阵（这种矩阵叫做TBN矩阵（切线矩阵）这三个字母分别代表tangent、bitangent和normal向量），把法线从切线空
openGL之API学习（五十八）烘焙法线贴图
hankern的专栏
05-03 655
假如下面是我们的低面数模型，上面是我们的高面数模型，上面的模型在计算光照时，由于面数多，每个面的法线方向不同，所以各个面的光照计算结果都不同，就有凹凸的感觉了，而下面的低模，只有一个面，整个面的光照条件都是一致的，就没有凹凸的感觉了。我们如果把上面的高模的法线信息保存下来，类似纹理贴图那样，存在一张图里，再给低模使用，低模就可以有跟高模一样的法线，进而在计算光照时达到和高模类似的效果，这也就是...
openGL中关于顶点的法线、切线、副切线
aoxuestudy的专栏
01-14 4248
openGL系列文章目录 前言 我们在openGL中绘制球体，或者圆环体的时候，经常可以到法线、切线、副切线这几个词，一脸疑惑，特别是副切线，这时什么鬼？ 一、法线（normal） 物体模型由成百上千个平坦的三角形围成.三角形上附加纹理的方式来增加额外细节. 提升真实感. 但是近看时,就有问题了.变成平面.缺乏细节.原因: 物体表面并非平坦的. 而是表示出无数(凹凸不平的)细节.如果以光的视角来看这个问题：是什么使表面被视为完全平坦的表面来照亮？ 这时就需要法线 法线定义 三维平面的法线是垂直于该平面的三维
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值