GLSL 创建自己的着色器

最新推荐文章于 2023-12-23 16:49:51 发布
最新推荐文章于 2023-12-23 16:49:51 发布
阅读量753 收藏 1
点赞数
分类专栏： opengl 文章标签： shader glsl 着色器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fztfztfzt/article/details/44653439
版权

这里讨论如何将类似于上一节的流经着色器编译和链接到OpenGL的程序中去
为了方便编译和修改，着色器程序都写在单独的文本文件中。
1.首先建立一个着色器对象，使用函数glCreateShader():

GLuint glCreateShader(GLenum type)
/*type指代着色器类型，GL_VERTEX_SHADER顶点着色器，GL_FRAGMENT_SHADER片段着色器*/
//返回一个唯一的对象标识符

下面代码分别建立了2个着色器对象：

GLuint v,f;
v=glCreateShader(GL_VERTEX_SHADER);
f=glCreateShader(GL_FRAGMENT_SHADER);

这是2个空白着色器，接下来要将它们关联到着色器上，假设2个着色器已经保存在文本文件中，流经顶点着色器保存在passthrough.vert,流经片段着色器保存在passthrough.frag。
首先要将着色器读取到内存中，可以使用CReader或自己写函数。
例：

char *vs=NULL,*fs=NULL;
CReader reader;
vs = reader.textFileRead("passthrough.vert");
fs = reader.textFileRead("passthrough.frag");

2.接着，将读取到内存中的着色器加载到着色器对象中，通过函数glShaderSource():

glShaderSource(GLuint unShaderObj,GLsizeit nNoStrings,const GLchar **ppchSource,const GLint nLength);
//该函数将ppchSource中保存的着色器程序放入着色器对象标识符unShaderObj指代的对象中。
//一种常用的参数组合是：将nLength设为NULL，字符串数量nNoStrings设为1，则ppchSources是一个以NULL结尾的字符串

例：

const char *vv=vs;
onst char *ff=fs;
glShaderSource(v,1,&vv,NULL);
glShaderSource(f,1,&ff,NULL);

3.然后对已经加载的着色器进行编译，使用函数glCompileShader():

void glCompileShader(GLuint nShaderObj)

例：

glCompileShader(v);
glCompileShader(f);

不在使用着色器时，可以使用glDeleteShader()删除void glDeleteShader(GLuint nShaderObj)
4.编译结束，该到链接了。在链接着色器对象之前，先要建立程序对象，使用函数：

GLuint glCreateProgram()

5.接下来使用glAttachShader(GLuint nProgramObj,GLuint nShaderObj)将着色器程序添加到程序对象中去。不在使用某着色器对象时，使用函数void glAttachShader(GLuint nProgramObj,GLuint nShaderObj)将着色器抽离程序对象。
6.然后使用void glLinkProgram(GLuint nProgramObj)进行链接。
7.当有多个程序对象时，可以使用void gluseProgram（GLuint nProgramObj)选择想要使用的程序对象。
例：

GLuint p;
p = glCreateProgram();
glAttachShader(p,v);
glAttachShader(p,f);
glLinkProgram(p);
gluseProgram(p);

8.在程序末尾不在使用某程序时，使用函数void glDeleteProgram(GLuint nProgramObj)来删除。
注意：编写着色器时:
1.main的返回值必须是void，不能是int；
2.需要下载glew库，并在加入前shader使用glewInit()初始化。
3.严格注意拼写问题！！！
例：
顶点流经着色器vertex.v：

void main()
{
    vec4 a;
    a = gl_ProjectionMatrix * gl_ModelViewMatrix * gl_Vertex;
    gl_Position.x = a.x*0.4;
    gl_Position.y = a.y*0.1;
}

片段流经着色器fragment.f：

void main()
{
    gl_FragColor = vec4(0.4,0.4,0.8,1.0);
}

cpp：

#include <Windows.h>
#include <iostream>
#include<stdlib.h>
#include<gl\glew.h>
//#include <gl\GL.h>
//#include <gl\GLU.h>
#pragma comment(lib,"opengl32.lib")//opengl相关库
#pragma comment(lib,"glu32.lib")
#pragma comment(lib,"glew32.lib")
#pragma comment(lib,"glew32s.lib")
/全局句柄
HGLRC hRC;
HDC hDC;
HWND hWnd;
/全局句柄

//全局变量
bool flag_depth = true;//是否深度测试
float rx = 0,ry=0;
char *vdata = NULL;
char *fdata = NULL;
GLfloat vec[][3] = {
    { -1, 1, -1 }, { 1, 1, -1 }, { 1, 1, 1 }, { -1, 1, -1 }, { 1, 1, 1 }, { -1, 1, 1 },//前
    { -1, -1, -1 }, { 1, -1, -1 }, { 1, -1, 1 }, { -1, -1, -1 }, { 1, -1, 1 }, { -1, -1, 1 },//后
    { -1, 1, 1 }, { -1, 1, -1 }, { -1, -1, -1 }, { -1, 1, 1 }, { -1, -1, -1 }, { -1, -1, 1 },//左
    { 1, 1, 1 }, { 1, 1, -1 }, { 1, -1, -1 }, { 1, 1, 1 }, { 1, -1, -1 }, { 1, -1, 1 },//右
    { -1, -1, 1 }, { -1, 1, 1 }, { 1, 1, 1 }, { -1, -1, 1 }, { 1, 1, 1 }, { 1, -1, 1 },//上
    { -1, -1, -1 }, { -1, 1, -1 }, { 1, 1, -1 }, { -1, -1, -1 }, { 1, 1, -1 }, { 1, -1, -1 },//下
};
GLfloat col[][3] = {
    { 1, 1, 1 }, { 1, 1, 1 }, { 1, 1, 1 }, { 0.1, 0.2, 0.3 }, { 0.1, 0.2, 0.3 }, { 0.1, 0.2, 0.3 },//前
    { 0.4, 0.4, 0.0 }, { 0.4, 0.4, 0.0 }, { 0.4, 0.4, 0.0 }, { 0.8, 0.4, 0.0 }, { 0.8, 0.4, 0.0 }, { 0.8, 0.4, 0.0 },//后
    { 0.8, 0.4, 0.8 }, { 0.8, 0.4, 0.8 }, { 0.8, 0.4, 0.8 }, { 0.0, 0.4, 0.8 }, { 0.0, 0.4, 0.8 }, { 0.0, 0.4, 0.8 },//左
    { 0.3, 0.3, 0.3 }, { 0.3, 0.3, 0.3 }, { 0.3, 0.3, 0.3 }, { 0.4, 0.4, 0.4 }, { 0.4, 0.4, 0.4 }, { 0.4, 0.4, 0.4 },//右
    { 0.4, 0.0, 0.4 }, { 0.4, 0.0, 0.4 }, { 0.4, 0.0, 0.4 }, { 0.4, 0.0, 0.0 }, { 0.4, 0.0, 0.0 }, { 0.4, 0.0, 0.0 },//上
    { 0.0, 0.4, 0.0 }, { 0.0, 0.4, 0.0 }, { 0.0, 0.4, 0.0 }, { 0.0, 0.0, 0.4 }, { 0.0, 0.0, 0.4 }, { 0.0, 0.0, 0.4 },//下
};
void InitGL()//初始化opengl参数
{
    glClearColor(0.5, 0.5, 0.5, 1);//设置颜色缓存颜色
    glEnableClientState(GL_VERTEX_ARRAY);
//  glEnableClientState(GL_COLOR_ARRAY);
    glTranslated(0, 0, -1);
    glVertexPointer(3, GL_FLOAT, 0, vec);
//  glColorPointer(3, GL_FLOAT, 0, col);
    glMatrixMode(GL_PROJECTION);                        // 选择投影矩阵
    glLoadIdentity();                           // 重置投影矩阵
    glMatrixMode(GL_MODELVIEW);                     // 选择模型观察矩阵
    glLoadIdentity();                           // 重置模型观察矩阵
    glScalef(0.5,0.5,0.5); //缩放0.5倍

}
char* ReadFile(char *filename)
{
    FILE *file = NULL;
    fopen_s(&file, filename, "rt");
    if (file == NULL)
    {
        return NULL;
    }
    fseek(file, 0, SEEK_END);
    long count = ftell(file);
    rewind(file);
    char *fileData = NULL;
    if (count > 0)
    {
        fileData = new char[count+1];
        fread(fileData, sizeof(char), count, file);
        fileData[count] = '\0';
    }
    return fileData;
}
void setShader()
{
    glewInit();//添加此句
    GLuint v, f;
    v = glCreateShader(GL_VERTEX_SHADER);
    f = glCreateShader(GL_FRAGMENT_SHADER);
    vdata = ReadFile("vertex.v");
    fdata = ReadFile("fragment.f");
    char *vv = vdata;
    char *ff = fdata;
    glShaderSource(v, 1, &vv, NULL);
    glShaderSource(f, 1, &ff, NULL);
    glCompileShader(v);
    glCompileShader(f);

    GLuint p = glCreateProgram();
    glAttachShader(p, v);
    glAttachShader(p, f);
    glLinkProgram(p);
    glUseProgram(p);

}
void DrawGLScene()
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // 每次刷新屏幕颜色缓存
    if (flag_depth) glEnable(GL_DEPTH_TEST);
    else glDisable(GL_DEPTH_TEST);
    glRotated(rx, 1, 0, 0);
    glRotated(ry, 0, 1, 0);
    glDrawArrays(GL_TRIANGLES, 0, 36);

}
LRESULT CALLBACK WndProc(HWND hwnd,UINT uMsg,WPARAM wParam,LPARAM lParam)// 消息处理回调函数
{
    switch (uMsg)                                   // Check For Windows Messages
    {
        case WM_ACTIVATE:                           // Watch For Window Activate Message
        {
            return 0;                               // Return To The Message Loop
        }
        case WM_SYSCOMMAND:                         // Intercept System Commands
        {
            switch (wParam)                         // Check System Calls
            {
            case SC_SCREENSAVE:                 // Screensaver Trying To Start?
            case SC_MONITORPOWER:               // Monitor Trying To Enter Powersave?
                return 0;                           // Prevent From Happening
            }
            break;                                  // Exit
        }
        case WM_CLOSE:                              // Did We Receive A Close Message?
        {
            PostQuitMessage(0);                     // Send A Quit Message
            return 0;                               // Jump Back
        }
        case WM_KEYDOWN:                            // 按键按下 由wParam决定
        {
            switch (wParam)
            {
            case 'D':
                flag_depth = !flag_depth;
                break;
            case VK_UP:
                rx += 0.001;
                break;
            case VK_DOWN:
                rx -= 0.001;
                break;
            case VK_LEFT:
                ry += 0.001;
                break;
            case VK_RIGHT:
                ry -= 0.001;
                break;
            }
            return 0;                               // Jump Back
        }
        case WM_KEYUP:                              // 按键松开
        {
            return 0;                               // Jump Back
        }
        case WM_SIZE:                               // Resize The OpenGL Window
        {
            glViewport(0, 0, LOWORD(lParam), HIWORD(lParam));//改变GL窗口大小
            return 0;                               // Jump Back
        }
        case WM_PAINT:
        {
            DrawGLScene();                  // Draw The Scene
            SwapBuffers(hDC);               // Swap Buffers (Double Buffering)
            return 0;                               // Jump Back
        }
    }
    // Pass All Unhandled Messages To DefWindowProc
    return DefWindowProc(hwnd, uMsg, wParam, lParam);//默认消息回调处理函数
}
void KillGLWindow()
{
    if (hRC)                                            // 删除着色描述表
    {
        if (!wglMakeCurrent(NULL, NULL))                    // Are We Able To Release The DC And RC Contexts?
        {
            MessageBox(NULL, "Release Of DC And RC Failed.", "SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION);
        }

        if (!wglDeleteContext(hRC))                     // Are We Able To Delete The RC?
        {
            MessageBox(NULL, "Release Rendering Context Failed.", "SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION);
        }
        hRC = NULL;                                     // Set RC To NULL
    }

    if (hDC && !ReleaseDC(hWnd, hDC))                   // 释放DC
    {
        MessageBox(NULL, "Release Device Context Failed.", "SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION);
        hDC = NULL;                                     // Set DC To NULL
    }

    if (hWnd && !DestroyWindow(hWnd))                   // Are We Able To Destroy The Window?
    {
        MessageBox(NULL, "Could Not Release hWnd.", "SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION);
        hWnd = NULL;                                        // Set hWnd To NULL
    }

}
int WINAPI WinMain(HINSTANCE h,HINSTANCE,LPSTR lpCmdLine,int nCmdShow)
{
    WNDCLASS wc;
    wc.hInstance = h;
    wc.hbrBackground = NULL;
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    wc.hIcon = LoadIcon(NULL, IDI_WINLOGO);
    wc.lpszMenuName = NULL;
    wc.lpszClassName = "OpenGL";
    wc.cbClsExtra = 0;                                  // No Extra Window Data
    wc.cbWndExtra = 0;
    wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;  // Redraw On Size, And Own DC For Window.
    wc.lpfnWndProc = (WNDPROC)WndProc;
    RegisterClass(&wc);
    hWnd = CreateWindow("OpenGL", "test", WS_OVERLAPPEDWINDOW | WS_SYSMENU | WS_BORDER | WS_MAXIMIZEBOX, 0, 0, 300, 300, NULL, NULL, h, NULL);
    //opengl设定
    hDC = GetDC(hWnd);
    static  PIXELFORMATDESCRIPTOR pfd =             // pfd Tells Windows How We Want Things To Be
    {
        sizeof(PIXELFORMATDESCRIPTOR),              // Size Of This Pixel Format Descriptor
        1,                                          // Version Number
        PFD_DRAW_TO_WINDOW |                        // Format Must Support Window
        PFD_SUPPORT_OPENGL |                        // Format Must Support OpenGL
        PFD_DOUBLEBUFFER,                           // Must Support Double Buffering
        PFD_TYPE_RGBA,                              // Request An RGBA Format
        24,                                     // Select Our Color Depth
        0, 0, 0, 0, 0, 0,                           // Color Bits Ignored
        0,                                          // No Alpha Buffer
        0,                                          // Shift Bit Ignored
        0,                                          // No Accumulation Buffer
        0, 0, 0, 0,                                 // Accumulation Bits Ignored
        16,                                         // 16Bit Z-Buffer (Depth Buffer)  
        0,                                          // No Stencil Buffer
        0,                                          // No Auxiliary Buffer
        PFD_MAIN_PLANE,                             // Main Drawing Layer
        0,                                          // Reserved
        0, 0, 0                                     // Layer Masks Ignored
    };
    int PixelFormat;
    if (!(PixelFormat = ChoosePixelFormat(hDC, &pfd)))              // 按照给定像素格式规范匹配与设备上下文合适的像素格式
    {
        KillGLWindow();                         // 重置显示区
        MessageBox(NULL, "不能设置像素格式", "错误", MB_OK | MB_ICONEXCLAMATION);
        return FALSE;                           // 返回 FALSE
    }
    if (!SetPixelFormat(hDC, PixelFormat, &pfd))                // 设置像素格式
    {
        KillGLWindow();                         // 重置显示区
        MessageBox(NULL, "不能设置像素格式", "错误", MB_OK | MB_ICONEXCLAMATION);
        return FALSE;                           // 返回 FALSE
    }

    if (!(hRC = wglCreateContext(hDC)))                 // 设置合适设备的OpenGL渲染上下文
    {
        KillGLWindow();                         // 重置显示区
        MessageBox(NULL, "不能创建OpenGL渲染描述表", "错误", MB_OK | MB_ICONEXCLAMATION);
        return FALSE;                           // 返回 FALSE
    }
    if (!wglMakeCurrent(hDC, hRC))                      // 尝试激活着色描述表
    {
        KillGLWindow();                         // 重置显示区
        MessageBox(NULL, "不能激活当前的OpenGL渲然描述表", "错误", MB_OK | MB_ICONEXCLAMATION);
        return FALSE;                           // 返回 FALSE
    }
    //opengl着色表设定结束

    ShowWindow(hWnd, SW_SHOW);

    InitGL();//opengl相关初始化
    setShader();
    //消息处理
    bool done = false;
    MSG msg;
    while (!done)                                   // Loop That Runs While done=FALSE
    {
        if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))   // 如果有消息就处理消息
        {
            if (msg.message == WM_QUIT)             // Have We Received A Quit Message?
            {
                done = TRUE;                            // If So done=TRUE
            }
            else                                    // If Not, Deal With Window Messages
            {
                TranslateMessage(&msg);             // Translate The Message
                DispatchMessage(&msg);              // Dispatch The Message
            }
        }
        else                                        // 没消息就处理界面
        {
            // Draw The Scene.  Watch For ESC Key And Quit Messages From DrawGLScene()              

        }
    }
    return TRUE;
}
fztfztfzt
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[OpenGL]OpenGL顶点着色器、编译着色器、片段着色器
用01改变世界
06-14 5178
1.顶点着色器（Vertex Shader） 顶点着色器：几个可编程着色器中的一个。 OpenGL用GLSL编写着色器，GLSL看起来很像C语言。 #version 330 core layout (location = 0) int vec3 aPos; void main() { gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0) } ...
【OpenGL学习笔记七】着色器语言(GLSL)
briant_ccj的专栏
01-16 3538
GLSL是类C语言 典型着色器结构 开头总是版本声明 使用in关键字定义输入变量 定义out关键字定义输出变量 定义uniform main函数 #version version_number in type in_variable_name; in type in_variable_name; out type out_variable_name; uniform type uniform_name; int main() { // 处理输入并进行一些图形操作 ... //
Three.js-着色器学习资源推荐（glsl）
damadashen的博客
07-16 723
glsl着色器语言的学习资源推荐。
【LearnOpenGL基础入门——5】着色器
最新发布
尘海折柳的博客
12-23 378
OpenGL着色器
着色器语言 GLSL (opengl-shader-language)入门大全
lzfshub
04-23 3048
GLSL 中文手册 基本类型: 类型 说明 void 空类型,即不返回任何值 bool 布尔类型 true,false int 带符号的整数 signed integer float 带符号的浮点数 floating scalar vec2, vec3, vec4 n维浮点数向量 n-component floating point vector bvec2, bvec3, bvec4 n维布尔向量 Boolean vector ivec2, ivec3, ivec4
简单GLSL纹理着色器
01-24
在C++或其它支持OpenGL的编程语言中，你需要加载纹理，创建GLSL程序对象，将着色器源码编译链接，设置纹理和着色器的 uniforms，最后在渲染循环中调用`glDrawArrays()`或`glDrawElements()`。 8. **shader ...
GLSLShaderLib:GLSL着色器库
05-10
GLSLShaderLib GLSL着色器库现代OpenGL严重依赖GLSL着色器。 您绘制的几乎所有内容都需要它们。 由于存在某些“默认”着色器效果，因此我决定创建此着色器集合，并希望它不会第n次（重新）编写着色器。着色器组织...
vscode-glsl-canvas:GLSL着色器的实时WebGL预览
05-01
:gem_stone: vscode-glsl-canvas 通过提供Show glslCanvas命令，该扩展程序可在VSCode中打开GLSL着色器的实时WebGL预览。 它使用的改进和改进版本，版本来自 javascript库和由制造的 。 现在支持WebGL2。 只需在文件...
GLSL:GLSL着色语言问题跟踪器
05-14
GLSL和ESSL是Khronos高级着色语言。 Khronos注册中心可用于 该项目包含 该GLSL着色语言项目包含GLSL和ESSL Khronos着色语言的以下内容： 跟踪核心规格 跟踪着色语言扩展的问题（但是，应与供应商讨论特定于供应商...
FollowersOfLight:SFML GLSL着色器实验
06-13
通过"FollowersOfLight"项目，开发者不仅可以提升C++和图形库的实战能力，还能深入了解GLSL着色器的潜力，以及如何利用它来创建引人入胜的视觉效果。无论是对于初学者还是有经验的开发者，这都是一个极好的学习和...
glsl 着色器整体概念介绍
leafinsnowfield的专栏
08-11 1060
https://blog.csdn.net/huodianyan/article/details/44341521  
GLSL教程 OpenGL Setup for GLSL 创建着色器程序
Bloodwolf的专栏
12-22 2501
下图展示了创建着色器程序并使之运行的必要步骤： 第一步：创建程序容器对象。用于此目的的函数返回一个指向程序容器对象的句柄。 在OpenGL 2.0中，该函数是： GLuint glCreateProgram(void); 如果使用ARB扩展，该函数是： GLhandleARB glCreateProgramObjectARB(void); 你可以根据自己的需要，创建足够多的着色器程序。一旦开始渲染，你可以在渲染单个帧的过程中，从一个着色器程序切换到另一个另一个着色器程序，你甚至
【GLSL教程】（二）在OpenGL中使用GLSL
热门推荐
racehorse的专栏
07-19 4万+
（二）在OpenGL中使用GLSL设置GLSL这一节讲述在OpenGL中配置GLSL，假设你已经写好了顶点shader和像素shader。如果你还没有准备好，可以从如下网址获得相关内容：http://www.3dshaders.com/home/http://www.opengl
初识OpenGL (3)片段着色器(Fragment Shader)
thefist的专栏
07-21 950
计算像素最后的颜色输出。片段着色器只需要一个输出变量，这个变量是一个4分量向量，它表示的是最终的输出颜色，我们应该自己将其计算出来。声明输出变量可以使用out关键字，这里我们命名为FragColor。step2.编译片段着色器。step1.片段着色器。...
简介LLVM
一个iOS开发者的小窝
11-19 3246
  LLVM到底是什么? 维基百科解释 LLVM是一个自由软件项目，它是一种编译器基础设施，以C++写成。它是为了任意一种编程语言而写成的程序，利用虚拟技术创造出编译时期、链接时期、运行时期以及“闲置时期”的最优化。它最早以C/C++为实现对象，而目前它已支持包括ActionScript、Ada、D语言、Fortran、GLSL、Haskell、Java字节码、Objective-C、Swi...
基于Three.js的glsl编写环境搭建
eevee_1的博客
03-01 1063
目前无论是Three.js官方库还是一些其他的做法，基于网页端glsl的编写都是以字符串的形式来编写的，代码整洁尚且不谈，代码提示和格式校验都十分困难。本文介绍一种glsl与js分离的编写环境搭建方法。 一.安装Parcel Parcel是一款Web 应用打包工具使用简单快捷。 打开终端 npm install -g parcel-bundler 等待自动处理即可安装完成。 安装好以后，先进入项目...
Unity Shader 顶点和片段着色器(Vertex and Fragment Shader)
jk823394954的专栏
10-19 7116
顶点着色器主要是处理顶点的平移，缩放等位置或者大小相关的函数。 片段着色器主要处理的是像素的颜色。 我们先来看一个简单的例子。 首先我们通过"Create->3D Object->Plane"来创建一个面板。 案例一 我们来通过一个Shader来把这个面板变成红色 我们创建一个材质并修改名字为RedMaterial。在创建一个Shader并修改名字为RedSha
编译器 LLVM Clang原理与实战 制作自己的编译器 source-to-source 源代码转换 编译遍 compile pass 代码插桩
万有文的博客
03-15 8867
编译器 LLVM Clang原理与实战 参考1 clang 简介 LLVM的命名最早来源于底层语言虚拟机（Low Level Virtual Machine）的缩写。它是一个用于建立编译器的基础框架，以C++编写。创建此工程的目的是对于任意的编程语言，利用该基础框架，构建一个包括编译时、链接时、执行时等的语言执行器。目前官方的LLVM只支持处理C/C++，Objective-C三种语言，当然也有一...
OpenGl中使用着色器的基本步骤及GLSL渲染简单示例
牧野的博客
12-14 2万+
OpenGL着色语言（OpenGL Shading Language，GLSL）是用来在OpenGL中着色编程的语言，是一种具有C/C++风格的高级过程语言，同样也以main函数开始，只不过执行是在GPU上。GLSL中着色器主要分为顶点着色器（Vertex Shader）和片段着色器（Fragment Shader）两部分，代替了固定渲染管线的一部分，使渲染管线中不同层次具有可编程性，程序控制更加
glsl 片源着色器教程
06-22
GLSL片源着色器教程的目的是为了帮助开发者了解如何创建自己的着色器程序。在GLSL中，着色器程序由一系列指令组成，这些指令被称为着色器代码。 首先，我们需要创建一个基本的片源着色器程序。在GLSL中，片源着色器...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值