openglShder常用函数

最新推荐文章于 2024-05-20 15:29:54 发布
最新推荐文章于 2024-05-20 15:29:54 发布
阅读量214 收藏
点赞数
分类专栏： 计算机图形学 文章标签： c++ visual studio cocos2d
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzh123353/article/details/121875148
版权

Shader类

#pragma once
#ifndef SHADER_H
#define SHADER_H
#include <glad/glad.h>
#include "glm/glm.hpp"
#include <string>
#include <fstream>
#include <sstream>
#include <iostream>
class Shader {
public:
	//程序ID
	unsigned int ID;
	//构造器读取并构建着色器
    Shader(const GLchar* vertexPath, const GLchar* fragmentPath, const char* geometryPath = nullptr) {
        // 1. 从文件路径中获取顶点/片段着色器
        std::string vertexCode;
        std::string fragmentCode;
        std::string geometryCode;
        std::ifstream vShaderFile;
        std::ifstream fShaderFile;
        std::ifstream gShaderFile;
        // 保证ifstream对象可以抛出异常：

        // ensure ifstream objects can throw exceptions:
        vShaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
        fShaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
        gShaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
        try
        {
            // 打开文件
            vShaderFile.open(vertexPath);
            fShaderFile.open(fragmentPath);
            std::stringstream vShaderStream, fShaderStream;
            // 读取文件的缓冲内容到数据流中
            vShaderStream << vShaderFile.rdbuf();
            fShaderStream << fShaderFile.rdbuf();
            // 关闭文件处理器
            vShaderFile.close();
            fShaderFile.close();
            // 转换数据流到string
            vertexCode = vShaderStream.str();
            fragmentCode = fShaderStream.str();
            // if geometry shader path is present, also load a geometry shader
            if (geometryPath != nullptr)
            {
                gShaderFile.open(geometryPath);
                std::stringstream gShaderStream;
                gShaderStream << gShaderFile.rdbuf();
                gShaderFile.close();
                geometryCode = gShaderStream.str();
            }
        }
        catch (std::ifstream::failure e)
        {
            std::cout << "ERROR::SHADER::FILE_NOT_SUCCESFULLY_READ" << std::endl;
        }
        const char* vShaderCode = vertexCode.c_str();
        const char* fShaderCode = fragmentCode.c_str();

        //2.编译着色器
        unsigned int vertex, fragment;
        int success;
        char infoLog[512];

        //顶点着色器
        vertex = glCreateShader(GL_VERTEX_SHADER);
        glShaderSource(vertex, 1, &vShaderCode, NULL);
        glCompileShader(vertex);
        //检查编译
        glGetShaderiv(vertex, GL_COMPILE_STATUS, &success);
        if (!success) {
            glGetShaderInfoLog(vertex, 512, NULL, infoLog);
            std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" << infoLog << std::endl;
        }

        //片段着色器
        fragment = glCreateShader(GL_FRAGMENT_SHADER);
        glShaderSource(fragment, 1, &fShaderCode, NULL);
        glCompileShader(fragment);
        //检查编译
        glGetShaderiv(fragment, GL_COMPILE_STATUS, &success);
        if (!success) {
            glGetShaderInfoLog(fragment, 512, NULL, infoLog);
            std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" << infoLog << std::endl;
        }

        ID = glCreateProgram();
        glAttachShader(ID, vertex);
        glAttachShader(ID, fragment);
        glLinkProgram(ID);

        //打印连接错误
        glGetProgramiv(ID, GL_LINK_STATUS, &success);
        if (!success) {
            glGetProgramInfoLog(ID, 512, NULL, infoLog);
            std::cout << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << std::endl;
        }

        //删除着色器
        glDeleteShader(vertex);
        glDeleteShader(fragment);
    }
        //使用/激活程序
    void use() {
        glUseProgram(ID);
    }
    //uniform工具函数
    void setBool(const std::string& name, bool value) const
    {
        glUniform1i(glGetUniformLocation(ID, name.c_str()), (int)value);
    }

    void setInt(const std::string& name, int value) const
    {
        glUniform1i(glGetUniformLocation(ID, name.c_str()), value);
    }

    void setFloat(const std::string& name, float value) const
    {
        glUniform1f(glGetUniformLocation(ID, name.c_str()), value);
    }

    void setVec2(const std::string& name, const glm::vec2& value) const
    {
        glUniform2fv(glGetUniformLocation(ID, name.c_str()), 1, &value[0]);
    }
    void setVec2(const std::string& name, float x, float y) const
    {
        glUniform2f(glGetUniformLocation(ID, name.c_str()), x, y);
    }
    // ------------------------------------------------------------------------
    void setVec3(const std::string& name, const glm::vec3& value) const
    {
        glUniform3fv(glGetUniformLocation(ID, name.c_str()), 1, &value[0]);
    }
    void setVec3(const std::string& name, float x, float y, float z) const
    {
        glUniform3f(glGetUniformLocation(ID, name.c_str()), x, y, z);
    }
    // ------------------------------------------------------------------------
    void setVec4(const std::string& name, const glm::vec4& value) const
    {
        glUniform4fv(glGetUniformLocation(ID, name.c_str()), 1, &value[0]);
    }
    void setVec4(const std::string& name, float x, float y, float z, float w)
    {
        glUniform4f(glGetUniformLocation(ID, name.c_str()), x, y, z, w);
    }
    // ------------------------------------------------------------------------
    void setMat2(const std::string& name, const glm::mat2& mat) const
    {
        glUniformMatrix2fv(glGetUniformLocation(ID, name.c_str()), 1, GL_FALSE, &mat[0][0]);
    }
    // ------------------------------------------------------------------------
    void setMat3(const std::string& name, const glm::mat3& mat) const
    {
        glUniformMatrix3fv(glGetUniformLocation(ID, name.c_str()), 1, GL_FALSE, &mat[0][0]);
    }
    // ------------------------------------------------------------------------
    void setMat4(const std::string& name, const glm::mat4& mat) const
    {
        glUniformMatrix4fv(glGetUniformLocation(ID, name.c_str()), 1, GL_FALSE, &mat[0][0]);
    }

private:
    // utility function for checking shader compilation/linking errors.
    // ------------------------------------------------------------------------
    void checkCompileErrors(GLuint shader, std::string type)
    {
        GLint success;
        GLchar infoLog[1024];
        if (type != "PROGRAM")
        {
            glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
            if (!success)
            {
                glGetShaderInfoLog(shader, 1024, NULL, infoLog);
                std::cout << "ERROR::SHADER_COMPILATION_ERROR of type: " << type << "\n" << infoLog << "\n -- --------------------------------------------------- -- " << std::endl;
            }
        }
        else
        {
            glGetProgramiv(shader, GL_LINK_STATUS, &success);
            if (!success)
            {
                glGetProgramInfoLog(shader, 1024, NULL, infoLog);
                std::cout << "ERROR::PROGRAM_LINKING_ERROR of type: " << type << "\n" << infoLog << "\n -- --------------------------------------------------- -- " << std::endl;
            }
        }
    }
#endif // !SHADER_H

Camera

#ifndef CAMERA_H
#define CAMERA_H
#include <glad/glad.h>
#include "glm/glm.hpp"
#include "glm/gtc/matrix_transform.hpp"

#include <vector>

// Defines several possible options for camera movement. Used as abstraction to stay away from window-system specific input methods
enum Camera_Movement {
    FORWARD,
    BACKWARD,
    LEFT,
    RIGHT
};

//默认相机参数
const float YAW = -90.0f;
const float PITCH = 0.0f;
const float SPEED = 2.5f;
const float SENSITIVITY = 0.1f;
const float ZOOM = 45.0f;

class Camera
{
public:
    // 相机属性
    glm::vec3 Position;
    glm::vec3 Front;
    glm::vec3 Up;
    glm::vec3 Right;
    glm::vec3 WorldUp;
    // 欧拉角
    float Yaw;
    float Pitch;
    // 选项
    float MovementSpeed;
    float MouseSensitivity;
    float Zoom;

    //向量构造
    Camera(glm::vec3 position = glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3 up = glm::vec3(0.0f, 1.0f, 0.0f), float yaw = YAW, float pitch = PITCH) : Front(glm::vec3(0.0f, 0.0f, -1.0f)), MovementSpeed(SPEED), MouseSensitivity(SENSITIVITY), Zoom(ZOOM)
    {
        Position = position;
        WorldUp = up;
        Yaw = yaw;
        Pitch = pitch;
        updateCameraVectors();
    }
    // 标量值构造
    Camera(float posX, float posY, float posZ, float upX, float upY, float upZ, float yaw, float pitch) : Front(glm::vec3(0.0f, 0.0f, -1.0f)), MovementSpeed(SPEED), MouseSensitivity(SENSITIVITY), Zoom(ZOOM)
    {
        Position = glm::vec3(posX, posY, posZ);
        WorldUp = glm::vec3(upX, upY, upZ);
        Yaw = yaw;
        Pitch = pitch;
        updateCameraVectors();
    }

    // returns the view matrix calculated using Euler Angles and the LookAt Matrix
    glm::mat4 GetViewMatrix()
    {
        return glm::lookAt(Position, Position + Front, Up);
    }

    // processes input received from any keyboard-like input system. Accepts input parameter in the form of camera defined ENUM (to abstract it from windowing systems)
    void ProcessKeyboard(Camera_Movement direction, float deltaTime)
    {
        float velocity = MovementSpeed * deltaTime;
        if (direction == FORWARD)
            Position += Front * velocity;
        if (direction == BACKWARD)
            Position -= Front * velocity;
        if (direction == LEFT)
            Position -= Right * velocity;
        if (direction == RIGHT)
            Position += Right * velocity;
    }

    // processes input received from a mouse input system. Expects the offset value in both the x and y direction.
    void ProcessMouseMovement(float xoffset, float yoffset, GLboolean constrainPitch = true)
    {
        xoffset *= MouseSensitivity;
        yoffset *= MouseSensitivity;

        Yaw += xoffset;
        Pitch += yoffset;

        // make sure that when pitch is out of bounds, screen doesn't get flipped
        //保证如果超出范围 屏幕不会翻转
        if (constrainPitch)
        {
            if (Pitch > 89.0f)
                Pitch = 89.0f;
            if (Pitch < -89.0f)
                Pitch = -89.0f;
        }

        //更新向量
        updateCameraVectors();
    }

    // processes input received from a mouse scroll-wheel event. Only requires input on the vertical wheel-axis
       //处理滚轮
    void ProcessMouseScroll(float yoffset)
    {
        Zoom -= (float)yoffset;
        if (Zoom < 1.0f)
            Zoom = 1.0f;
        if (Zoom > 45.0f)
            Zoom = 45.0f;
    }

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


#endif // !CAMERA_H
zzh123353
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
EXCEL常用函数.xlsx
10-23
主要适用于EXCEL入门者，快速了解EXCEL常用的函数
MATLAB常用函数大全
03-18
MatLab常用函数大全 - 本文档集合了MATLAB中常用的函数,包括常用的基本数学函数，常用的三角函数以及适用于向量的常用函数
OpenGL学习笔记 四：着色器(Shader)
twicetwice的博客
07-19 2586
什么是着色器： 着色器(Shader)是运行在GPU上的小程序。这些小程序为图形渲染管线的某个特定部分而运行。是把输入转化为输出的程序。着色器之间的联系，把一个着色器的输出作为另一个着色器的输出。 GLSL： GLSL的类C语言，为图形计算量身定制的，它包含一些针对向量和矩阵操作的有用特性。 语法： 着色器的开头总是要声明版本，接着是输入和输出变量、uniform和main函数。每个着色器的入口点都是main函数，在这个函数中我们处理所有的输入变量，并将结果输出到输出变量中。 结构如下： #
【OpenGL】GLSL中的函数和子程序（subroutines）
weixin_33670713的博客
05-25 243
这篇文章里讲一下在GLSL如何使用函数和子程序（subroutines）。 在GLSL中使用函数 GLSL支持函数，它们的语法结构和C很相似。但是调用约定会有所不同。下面，我们以一个普通的ADS（ambient，diffuse，specular）shader为例，熟悉一下GLSL中函数的用法。 Vertex Shader： #version 400 layout (lo...
opengl多光源shader函数封装
wqdqwass的博客
08-16 203
着色器函数封装：1.注意手电筒光源也有自己的光属性性质2.FragColor着色不能少 #version 400 core out vec4 FragColor; in vec3 Normal; in vec3 FragPos; in vec2 TexCoords; uniform vec3 lightColor; uniform vec3 objectColor; uniform vec4 lightPos; uniform vec3 viewPos; uniform vec3 front; unif.
OpenGL学习笔记5：着色器
热门推荐
键盘春秋的博客
07-09 1万+
初识着色器语言变量和数据类型可用的数据类型只有4种：有符号整数，无符号整数，浮点数，布尔值。 OpenGL着色语言中没有指针和字符串或字符。返回值可以为void。向量类型所有4种基本数据类型都可以存储在二维、三维或者四维向量中： OpenGL着色语言向量数据类型 类型 描述 vec2,vec3,vec4 2分量、3分量和4分量浮点向量 ivec2,ivec3,ivec4 2
一文掌握OpenGL的shader内置函数
徐福记456
10-24 3604
OpenGL ES有大量的GLSL内置函数，包括：三角函数、指数函数、通用函数、浮点函数、几何函数、矩阵函数、矢量关系函数、纹理函数、原子函数、图像函数、插值函数、着色器函数等。
GLSL中的各种接口变量总结
GQB的专栏
08-23 5300
1、uint CreateShader(enum type) : 创建空的shader object;    type: VERTEX_SHADER, 2、void ShaderSource(uint shader, sizeicount, const **string, const int *length)：加载shader源码进shader object；可能多个字符串 3、
Shader 用到的数学函数总结及用法
lck8989的博客
08-22 729
在写shader相关的程序的时候往往需要用到 OpenGL内置的数学库，下面列举几个常用的函数用法和效果，下面的所有代码都是运行在shadertoy在线工具上的，推荐一个好用的数学工具desmos。
maxwell常用函数.txt
12-09
函数名称 功能描述 表达式用法 abs 绝对值函数 abs(x) 6 sin 正弦函数 sin(x) cos 余弦函数 cos(x) tan 正切函数 tan(x) asin 反正弦函数 asin(x) acos 反余弦函数 acos(x) atan 反正切函数 atan(x) atan2 ...
linux常用函数
10-17
linux系统常用函数，个人整理，可能不全，仅供参考和学习
VBScript 常用函数总结
09-05
在编写 QTP脚本的过程中，有一些经常使用的函数。如果我们能熟悉这些常用的函数及其用法，并合理地使用它们，那么一些问题就很容易得到解决。
OpenGL学习-高级OpenGL-ComputeShader
m0_56399931的博客
03-12 3324
-----------------------博主：mx 基本概念： OpenGL的Compute shader几乎可以被认为是独立于其他面向图形的阶段运行的独立管道。Compute shader是一种获得系统中图形处理器所拥有的计算能力的方法，不像Vertex 、Tessellation、Geometry、Fragment Shader，Compute shader可以被认为是一种特殊的、每个Compute shader都运行在单个工作单元上，称为工作项。而这些工作项被收集到一起，形成一个称为工.
【OpenGL】opengl shader内置变量和函数
Taily老段的专栏
06-19 2985
1、uint CreateShader(enum type) : 创建空的shader object;   type: VERTEX_SHADER,2、void ShaderSource(uint shader, sizeicount, const **string, const int *length)：加载shader源码进shader object；可能多个字符串3、void Compile...
OpenGL-07-01摄像机
韩天衣的博客
03-24 350
OpenGL-07-01摄像机 当我们讨论摄像机/观察空间(Camera/View Space)的时候，是在讨论以摄像机的视角作为场景原点时场景中所有的顶点坐标：观察矩阵把所有的世界坐标变换为相对于摄像机位置与方向的观察坐标。要定义一个摄像机，我们需要它在世界空间中的位置、观察的方向、一个指向它右侧的向量以及一个指向它上方的向量 创建一个摄像机 我们想要创建一个摄像机，并通过WASD来进行水平移动，步骤如下 很简单，创建一个摄像机位置，方向向量，摄像机上轴，注意，这三个是全局变量 glm::vec3 cam
OpenGL shader 内置函数 和 unity3d shaderlib 内置函数对照表
aerror的专栏
06-16 2432
-----opengl    ---shaderlab fract        frac mix                 lerp texture2D     tex2D inversesqrt   rsqrt mod food
C语言之函数指针（持续更新）
最新发布
qq_47607743的博客
05-20 275
C语言指针
kivy常用函数说明
05-04
以下是一些常用的Kivy函数说明： 1. App类的常用函数： - build(): 用于构建应用程序的根窗口。 - run(): 启动应用程序的事件循环。 - stop(): 停止应用程序的事件循环。 2. Widget类的常用函数： - add_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值