[{"data":1,"prerenderedAt":2184},["ShallowReactive",2],{"page-\u002Fgraphy\u002Fopengel\u002F着色器":3},{"id":4,"title":5,"body":6,"description":2177,"extension":2178,"meta":2179,"navigation":72,"path":2180,"seo":2181,"stem":2182,"__hash__":2183},"content\u002Fgraphy\u002Fopengel\u002F着色器.md","着色器",{"type":7,"value":8,"toc":2163},"minimark",[9,20,23,28,31,34,37,153,165,221,227,231,255,259,270,352,358,390,397,443,461,532,535,538,560,587,601,612,626,631,747,752,812,822,828,831,835,849,855,913,923,936,946,1061,1075,1086,1163,1166,1441,1451,1470,1474,1483,1646,1663,1767,1774,1832,1839,1958,1968,1971,1974,1980,1984,1992,1998,2059,2062,2066,2072,2077,2132,2137,2152,2159],[10,11,12,13,19],"p",{},"​\t在[Hello Triangle](",[14,15,16],"a",{"href":16,"rel":17},"https:\u002F\u002Flearnopengl-cn.github.io\u002F01",[18],"nofollow"," Getting started\u002F04 Hello Triangle\u002F)教程中提到，着色器(Shader)是运行在GPU上的小程序。这些小程序为图形渲染管线的某个特定部分而运行。从基本意义上来说，着色器只是一种把输入转化为输出的程序。着色器也是一种非常独立的程序，因为它们之间不能相互通信；它们之间唯一的沟通只有通过输入和输出。",[10,21,22],{},"​\t前面的教程里我们简要地触及了一点着色器的皮毛，并了解了如何恰当地使用它们。现在我们会用一种更加广泛的形式详细解释着色器，特别是OpenGL着色器语言(GLSL)。",[24,25,27],"h1",{"id":26},"glsl","GLSL",[10,29,30],{},"​\t着色器是使用一种叫GLSL的类C语言写成的。GLSL是为图形计算量身定制的，它包含一些针对向量和矩阵操作的有用特性。",[10,32,33],{},"​\t着色器的开头总是要声明版本，接着是输入和输出变量、uniform和main函数。每个着色器的入口点都是main函数，在这个函数中我们处理所有的输入变量，并将结果输出到输出变量中。如果你不知道什么是uniform也不用担心，我们后面会进行讲解。",[10,35,36],{},"一个典型的着色器有下面的结构：",[38,39,44],"pre",{"className":40,"code":41,"language":42,"meta":43,"style":43},"language-c++ shiki shiki-themes github-light github-dark","#version version_number\nin type in_variable_name;\nin type in_variable_name;\n\nout type out_variable_name;\n\nuniform type uniform_name;\n\nvoid main()\n{\n  \u002F\u002F 处理输入并进行一些图形操作\n  ...\n  \u002F\u002F 输出处理过的结果到输出变量\n  out_variable_name = weird_stuff_we_processed;\n}\n","c++","",[45,46,47,56,62,67,74,80,85,91,96,110,116,123,129,135,147],"code",{"__ignoreMap":43},[48,49,52],"span",{"class":50,"line":51},"line",1,[48,53,55],{"class":54},"sVt8B","#version version_number\n",[48,57,59],{"class":50,"line":58},2,[48,60,61],{"class":54},"in type in_variable_name;\n",[48,63,65],{"class":50,"line":64},3,[48,66,61],{"class":54},[48,68,70],{"class":50,"line":69},4,[48,71,73],{"emptyLinePlaceholder":72},true,"\n",[48,75,77],{"class":50,"line":76},5,[48,78,79],{"class":54},"out type out_variable_name;\n",[48,81,83],{"class":50,"line":82},6,[48,84,73],{"emptyLinePlaceholder":72},[48,86,88],{"class":50,"line":87},7,[48,89,90],{"class":54},"uniform type uniform_name;\n",[48,92,94],{"class":50,"line":93},8,[48,95,73],{"emptyLinePlaceholder":72},[48,97,99,103,107],{"class":50,"line":98},9,[48,100,102],{"class":101},"szBVR","void",[48,104,106],{"class":105},"sScJk"," main",[48,108,109],{"class":54},"()\n",[48,111,113],{"class":50,"line":112},10,[48,114,115],{"class":54},"{\n",[48,117,119],{"class":50,"line":118},11,[48,120,122],{"class":121},"sJ8bj","  \u002F\u002F 处理输入并进行一些图形操作\n",[48,124,126],{"class":50,"line":125},12,[48,127,128],{"class":54},"  ...\n",[48,130,132],{"class":50,"line":131},13,[48,133,134],{"class":121},"  \u002F\u002F 输出处理过的结果到输出变量\n",[48,136,138,141,144],{"class":50,"line":137},14,[48,139,140],{"class":54},"  out_variable_name ",[48,142,143],{"class":101},"=",[48,145,146],{"class":54}," weird_stuff_we_processed;\n",[48,148,150],{"class":50,"line":149},15,[48,151,152],{"class":54},"}\n",[10,154,155,156,160,161,164],{},"​\t当我们特别谈论到",[157,158,159],"strong",{},"顶点着色器的时候","，每个",[157,162,163],{},"输入变量也叫顶点属性(Vertex Attribute)","。我们能声明的顶点属性是有上限的，它一般由硬件来决定。OpenGL确保至少有16个包含4分量的顶点属性可用，但是有些硬件或许允许更多的顶点属性，你可以查询GL_MAX_VERTEX_ATTRIBS来获取具体的上限：",[38,166,168],{"className":40,"code":167,"language":42,"meta":43,"style":43},"int nrAttributes;\nglGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &nrAttributes);\nstd::cout \u003C\u003C \"Maximum nr of vertex attributes supported: \" \u003C\u003C nrAttributes \u003C\u003C std::endl;\n",[45,169,170,178,192],{"__ignoreMap":43},[48,171,172,175],{"class":50,"line":51},[48,173,174],{"class":101},"int",[48,176,177],{"class":54}," nrAttributes;\n",[48,179,180,183,186,189],{"class":50,"line":58},[48,181,182],{"class":105},"glGetIntegerv",[48,184,185],{"class":54},"(GL_MAX_VERTEX_ATTRIBS, ",[48,187,188],{"class":101},"&",[48,190,191],{"class":54},"nrAttributes);\n",[48,193,194,197,200,203,207,210,213,215,218],{"class":50,"line":64},[48,195,196],{"class":105},"std",[48,198,199],{"class":54},"::cout ",[48,201,202],{"class":101},"\u003C\u003C",[48,204,206],{"class":205},"sZZnC"," \"Maximum nr of vertex attributes supported: \"",[48,208,209],{"class":101}," \u003C\u003C",[48,211,212],{"class":54}," nrAttributes ",[48,214,202],{"class":101},[48,216,217],{"class":105}," std",[48,219,220],{"class":54},"::endl;\n",[10,222,223,224],{},"​\t通常情况下它",[157,225,226],{},"至少会返回16个，大部分情况下是够用了。",[228,229,230],"h2",{"id":230},"数据类型",[10,232,233,234,237,238,240,241,240,244,240,247,250,251,254],{},"​\t和其他编程语言一样，",[157,235,236],{},"GLSL有数据类型可以来指定变量的种类","。GLSL中包含C等其它语言大部分的默认基础数据类型：",[45,239,174],{},"、",[45,242,243],{},"float",[45,245,246],{},"double",[45,248,249],{},"uint","和",[45,252,253],{},"bool","。GLSL也有两种容器类型，它们会在这个教程中使用很多，分别是向量(Vector)和矩阵(Matrix)，其中矩阵我们会在之后的教程里再讨论。",[256,257,258],"h3",{"id":258},"向量",[10,260,261,262,265,266,269],{},"​\tGLSL中的向量是一个",[157,263,264],{},"可以包含有2、3或者4个分量的容器","，分量的类型可以是前面默认基础类型的任意一个。它们可以是下面的形式（",[45,267,268],{},"n","代表分量的数量）：",[271,272,273,287],"table",{},[274,275,276],"thead",{},[277,278,279,284],"tr",{},[280,281,283],"th",{"align":282},"left","类型",[280,285,286],{"align":282},"含义",[288,289,290,304,316,328,340],"tbody",{},[277,291,292,298],{},[293,294,295],"td",{"align":282},[45,296,297],{},"vecn",[293,299,300,301,303],{"align":282},"包含",[45,302,268],{},"个float分量的默认向量",[277,305,306,311],{},[293,307,308],{"align":282},[45,309,310],{},"bvecn",[293,312,300,313,315],{"align":282},[45,314,268],{},"个bool分量的向量",[277,317,318,323],{},[293,319,320],{"align":282},[45,321,322],{},"ivecn",[293,324,300,325,327],{"align":282},[45,326,268],{},"个int分量的向量",[277,329,330,335],{},[293,331,332],{"align":282},[45,333,334],{},"uvecn",[293,336,300,337,339],{"align":282},[45,338,268],{},"个unsigned int分量的向量",[277,341,342,347],{},[293,343,344],{"align":282},[45,345,346],{},"dvecn",[293,348,300,349,351],{"align":282},[45,350,268],{},"个double分量的向量",[10,353,354,355,357],{},"​\t大多数时候我们使用",[45,356,297],{},"，因为float足够满足大多数要求了。",[10,359,360,361,364,365,368,369,240,372,240,375,250,378,381,382,385,386,389],{},"​\t一个向量的分量可以通过",[45,362,363],{},"vec.x","这种方式获取，这里",[45,366,367],{},"x","是指这个向量的第一个分量。你可以分别使用",[45,370,371],{},".x",[45,373,374],{},".y",[45,376,377],{},".z",[45,379,380],{},".w","来获取它们的第1、2、3、4个分量。GLSL也允许你对颜色使用",[45,383,384],{},"rgba","，或是对纹理坐标使用",[45,387,388],{},"stpq","访问相同的分量。",[10,391,392,393,396],{},"​\t向量这一数据类型也",[157,394,395],{},"允许一些有趣而灵活的分量选择方式","，叫做重组(Swizzling)。重组允许这样的语法：",[38,398,400],{"className":40,"code":399,"language":42,"meta":43,"style":43},"vec2 someVec;\nvec4 differentVec = someVec.xyxx;\nvec3 anotherVec = differentVec.zyw;\nvec4 otherVec = someVec.xxxx + anotherVec.yxzy;\n",[45,401,402,407,417,427],{"__ignoreMap":43},[48,403,404],{"class":50,"line":51},[48,405,406],{"class":54},"vec2 someVec;\n",[48,408,409,412,414],{"class":50,"line":58},[48,410,411],{"class":54},"vec4 differentVec ",[48,413,143],{"class":101},[48,415,416],{"class":54}," someVec.xyxx;\n",[48,418,419,422,424],{"class":50,"line":64},[48,420,421],{"class":54},"vec3 anotherVec ",[48,423,143],{"class":101},[48,425,426],{"class":54}," differentVec.zyw;\n",[48,428,429,432,434,437,440],{"class":50,"line":69},[48,430,431],{"class":54},"vec4 otherVec ",[48,433,143],{"class":101},[48,435,436],{"class":54}," someVec.xxxx ",[48,438,439],{"class":101},"+",[48,441,442],{"class":54}," anotherVec.yxzy;\n",[10,444,445,446,449,450,453,454,456,457,460],{},"​\t你可以",[157,447,448],{},"使用上面4个字母任意组合来创建一个和原来向量一样长的（同类型）新向量","，只要原来向量有那些分量即可；然而，你不允许在一个",[45,451,452],{},"vec2","向量中去获取",[45,455,377],{},"元素。我们也可以",[157,458,459],{},"把一个向量作为一个参数传给不同的向量构造函数，以减少需求参数的数量","：",[38,462,464],{"className":40,"code":463,"language":42,"meta":43,"style":43},"vec2 vect = vec2(0.5, 0.7); \nvec4 result = vec4(vect, 0.0, 0.0);\nvec4 otherResult = vec4(result.xyz, 1.0);\n",[45,465,466,492,515],{"__ignoreMap":43},[48,467,468,471,473,476,479,483,486,489],{"class":50,"line":51},[48,469,470],{"class":54},"vec2 vect ",[48,472,143],{"class":101},[48,474,475],{"class":105}," vec2",[48,477,478],{"class":54},"(",[48,480,482],{"class":481},"sj4cs","0.5",[48,484,485],{"class":54},", ",[48,487,488],{"class":481},"0.7",[48,490,491],{"class":54},"); \n",[48,493,494,497,499,502,505,508,510,512],{"class":50,"line":58},[48,495,496],{"class":54},"vec4 result ",[48,498,143],{"class":101},[48,500,501],{"class":105}," vec4",[48,503,504],{"class":54},"(vect, ",[48,506,507],{"class":481},"0.0",[48,509,485],{"class":54},[48,511,507],{"class":481},[48,513,514],{"class":54},");\n",[48,516,517,520,522,524,527,530],{"class":50,"line":64},[48,518,519],{"class":54},"vec4 otherResult ",[48,521,143],{"class":101},[48,523,501],{"class":105},[48,525,526],{"class":54},"(result.xyz, ",[48,528,529],{"class":481},"1.0",[48,531,514],{"class":54},[10,533,534],{},"​\t向量是一种灵活的数据类型，我们可以把它用在各种输入和输出上。学完教程你会看到很多新颖的管理向量的例子。",[228,536,537],{"id":537},"输入与输出",[10,539,540,541,544,545,548,549,250,552,555,556,559],{},"​\t虽然着色器",[157,542,543],{},"是各自独立的小程序","，但是它们都是一个整体的一部分，出于这样的原因，我们希望",[157,546,547],{},"每个着色器都有输入和输出","，这样才能进行数据交流和传递。GLSL定义了",[45,550,551],{},"in",[45,553,554],{},"out","关键字专门来实现这个目的。每个着色器使用这两个关键字设定输入和输出，只要一个输出变量与下一个着色器阶段的输入匹配，它就会传递下去。",[157,557,558],{},"但在顶点和片段着色器中会有点不同","。",[10,561,562,563,566,567,570,571,574,575,578,579,582,583,586],{},"​\t",[157,564,565],{},"顶点着色器应该接收的是一种特殊形式的输入，否则就会效率低下","。顶点着色器的输入特殊在，",[157,568,569],{},"它从顶点数据中直接接收输入","。为了定义顶点数据该如何管理，我们使用",[45,572,573],{},"location","这一元数据指定输入变量，",[157,576,577],{},"这样我们才可以在CPU上配置顶点属性","。我们已经在前面的教程看过这个了，",[45,580,581],{},"layout (location = 0)","。顶点着色器需要为它的输入提供一个额外的",[45,584,585],{},"layout","标识，这样我们才能把它链接到顶点数据。",[588,589,590,595],"blockquote",{},[10,591,592],{},[48,593,594],{},"!NOTE",[10,596,597,598,600],{},"你也可以忽略",[45,599,581],{},"标识符，通过在OpenGL代码中使用glGetAttribLocation查询属性位置值(Location)，但是我更喜欢在着色器中设置它们，这样会更容易理解而且节省你（和OpenGL）的工作量。",[10,602,603,604,607,608,611],{},"​\t另一个例外是片段着色器，它需要一个",[45,605,606],{},"vec4","颜色输出变量，因为",[157,609,610],{},"片段着色器需要生成一个最终输出的颜色","。如果你在片段着色器没有定义输出颜色，OpenGL会把你的物体渲染为黑色（或白色）。",[10,613,614,615,618,619,622,623,559],{},"​\t所以，如果",[157,616,617],{},"我们打算从一个着色器向另一个着色器发送数据，我们必须在发送方着色器中声明一个输出","，在接收方着色器中声明一个类似的输入。当类型和名字都一样的时候，",[157,620,621],{},"OpenGL就会把两个变量链接到一起","，它们之间就能发送数据了（这是在链接程序对象时完成的）。为了展示这是如何工作的，我们会稍微改动一下之前教程里的那个着色器，让顶点着色器",[157,624,625],{},"为片段着色器决定颜色",[10,627,628],{},[157,629,630],{},"顶点着色器",[38,632,634],{"className":40,"code":633,"language":42,"meta":43,"style":43},"#version 330 core\nlayout (location = 0) in vec3 aPos; \u002F\u002F 位置变量的属性位置值为0\n\nout vec4 vertexColor; \u002F\u002F 为片段着色器指定一个颜色输出\n\nvoid main()\n{\n    gl_Position = vec4(aPos, 1.0); \u002F\u002F 注意我们如何把一个vec3作为vec4的构造器的参数\n    vertexColor = vec4(0.5, 0.0, 0.0, 1.0); \u002F\u002F 把输出变量设置为暗红色\n}\n",[45,635,636,647,665,669,677,681,689,693,713,743],{"__ignoreMap":43},[48,637,638,641,644],{"class":50,"line":51},[48,639,640],{"class":54},"#version ",[48,642,643],{"class":481},"330",[48,645,646],{"class":54}," core\n",[48,648,649,651,654,656,659,662],{"class":50,"line":58},[48,650,585],{"class":105},[48,652,653],{"class":54}," (location ",[48,655,143],{"class":101},[48,657,658],{"class":481}," 0",[48,660,661],{"class":54},") in vec3 aPos;",[48,663,664],{"class":121}," \u002F\u002F 位置变量的属性位置值为0\n",[48,666,667],{"class":50,"line":64},[48,668,73],{"emptyLinePlaceholder":72},[48,670,671,674],{"class":50,"line":69},[48,672,673],{"class":54},"out vec4 vertexColor;",[48,675,676],{"class":121}," \u002F\u002F 为片段着色器指定一个颜色输出\n",[48,678,679],{"class":50,"line":76},[48,680,73],{"emptyLinePlaceholder":72},[48,682,683,685,687],{"class":50,"line":82},[48,684,102],{"class":101},[48,686,106],{"class":105},[48,688,109],{"class":54},[48,690,691],{"class":50,"line":87},[48,692,115],{"class":54},[48,694,695,698,700,702,705,707,710],{"class":50,"line":93},[48,696,697],{"class":54},"    gl_Position ",[48,699,143],{"class":101},[48,701,501],{"class":105},[48,703,704],{"class":54},"(aPos, ",[48,706,529],{"class":481},[48,708,709],{"class":54},");",[48,711,712],{"class":121}," \u002F\u002F 注意我们如何把一个vec3作为vec4的构造器的参数\n",[48,714,715,718,720,722,724,726,728,730,732,734,736,738,740],{"class":50,"line":98},[48,716,717],{"class":54},"    vertexColor ",[48,719,143],{"class":101},[48,721,501],{"class":105},[48,723,478],{"class":54},[48,725,482],{"class":481},[48,727,485],{"class":54},[48,729,507],{"class":481},[48,731,485],{"class":54},[48,733,507],{"class":481},[48,735,485],{"class":54},[48,737,529],{"class":481},[48,739,709],{"class":54},[48,741,742],{"class":121}," \u002F\u002F 把输出变量设置为暗红色\n",[48,744,745],{"class":50,"line":112},[48,746,152],{"class":54},[10,748,749],{},[157,750,751],{},"片段着色器",[38,753,755],{"className":40,"code":754,"language":42,"meta":43,"style":43},"#version 330 core\nout vec4 FragColor;\n\nin vec4 vertexColor; \u002F\u002F 从顶点着色器传来的输入变量（名称相同、类型相同）\n\nvoid main()\n{\n    FragColor = vertexColor;\n}\n",[45,756,757,765,770,774,782,786,794,798,808],{"__ignoreMap":43},[48,758,759,761,763],{"class":50,"line":51},[48,760,640],{"class":54},[48,762,643],{"class":481},[48,764,646],{"class":54},[48,766,767],{"class":50,"line":58},[48,768,769],{"class":54},"out vec4 FragColor;\n",[48,771,772],{"class":50,"line":64},[48,773,73],{"emptyLinePlaceholder":72},[48,775,776,779],{"class":50,"line":69},[48,777,778],{"class":54},"in vec4 vertexColor;",[48,780,781],{"class":121}," \u002F\u002F 从顶点着色器传来的输入变量（名称相同、类型相同）\n",[48,783,784],{"class":50,"line":76},[48,785,73],{"emptyLinePlaceholder":72},[48,787,788,790,792],{"class":50,"line":82},[48,789,102],{"class":101},[48,791,106],{"class":105},[48,793,109],{"class":54},[48,795,796],{"class":50,"line":87},[48,797,115],{"class":54},[48,799,800,803,805],{"class":50,"line":93},[48,801,802],{"class":54},"    FragColor ",[48,804,143],{"class":101},[48,806,807],{"class":54}," vertexColor;\n",[48,809,810],{"class":50,"line":98},[48,811,152],{"class":54},[10,813,814,815,817,818,821],{},"​\t你可以看到我们在顶点着色器中声明了一个vertexColor变量作为",[45,816,606],{},"输出，并在片段着色器中声明了一个类似的vertexColor。由于它们名字相同且类型相同，",[157,819,820],{},"片段着色器中的vertexColor就和顶点着色器中的vertexColor链接了","。由于我们在顶点着色器中将颜色设置为深红色，最终的片段也是深红色的。下面的图片展示了输出结果：",[10,823,824],{},[825,826],"img",{"alt":825,"src":827},".\u002Fassets\u002Fshaders.png",[10,829,830],{},"​\t完成了！我们成功地从顶点着色器向片段着色器发送数据。让我们更上一层楼，看看能否从应用程序中直接给片段着色器发送一个颜色！",[228,832,834],{"id":833},"uniform","Uniform",[10,836,837,838,841,842,845,846,559],{},"​\tUniform",[157,839,840],{},"是另一种从我们的应用程序在 CPU 上传递数据到 GPU 上的着色器的方式","，但uniform和顶点属性有些不同。首先，uniform是全局的(Global)。",[157,843,844],{},"全局意味着uniform变量必须在每个着色器程序对象中都是独一无二的","，而且",[157,847,848],{},"它可以被着色器程序的任意着色器在任意阶段访问。第二，无论你把uniform值设置成什么，uniform会一直保存它们的数据，直到它们被重置或更新",[10,850,851,852,854],{},"​\t要在 GLSL 中声明 uniform，我们只需在着色器中使用 ",[45,853,833],{}," 关键字，并带上类型和名称。从那时起，我们就可以在着色器中使用新声明的 uniform。我们来看看这次是否能通过uniform设置三角形的颜色：",[38,856,858],{"className":40,"code":857,"language":42,"meta":43,"style":43},"#version 330 core\nout vec4 FragColor;\n\nuniform vec4 ourColor; \u002F\u002F 在OpenGL程序代码中设定这个变量\n\nvoid main()\n{\n    FragColor = ourColor;\n}\n",[45,859,860,868,872,876,884,888,896,900,909],{"__ignoreMap":43},[48,861,862,864,866],{"class":50,"line":51},[48,863,640],{"class":54},[48,865,643],{"class":481},[48,867,646],{"class":54},[48,869,870],{"class":50,"line":58},[48,871,769],{"class":54},[48,873,874],{"class":50,"line":64},[48,875,73],{"emptyLinePlaceholder":72},[48,877,878,881],{"class":50,"line":69},[48,879,880],{"class":54},"uniform vec4 ourColor;",[48,882,883],{"class":121}," \u002F\u002F 在OpenGL程序代码中设定这个变量\n",[48,885,886],{"class":50,"line":76},[48,887,73],{"emptyLinePlaceholder":72},[48,889,890,892,894],{"class":50,"line":82},[48,891,102],{"class":101},[48,893,106],{"class":105},[48,895,109],{"class":54},[48,897,898],{"class":50,"line":87},[48,899,115],{"class":54},[48,901,902,904,906],{"class":50,"line":93},[48,903,802],{"class":54},[48,905,143],{"class":101},[48,907,908],{"class":54}," ourColor;\n",[48,910,911],{"class":50,"line":98},[48,912,152],{"class":54},[10,914,915,916,918,919,922],{},"​\t我们在片段着色器中声明了一个uniform ",[45,917,606],{},"的ourColor，并把",[157,920,921],{},"片段着色器的输出颜色设置为uniform值的内容","。因为uniform是全局变量，我们可以在任何着色器中定义它们，而无需通过顶点着色器作为中介。顶点着色器中不需要这个uniform，所以我们不用在那里定义它。",[588,924,925,929],{},[10,926,927],{},[48,928,594],{},[10,930,931,932,935],{},"如果你声明了一个uniform却在GLSL代码中没用过，",[157,933,934],{},"编译器会静默移除这个变量","，导致最后编译出的版本中并不会包含它，这可能导致几个非常麻烦的错误，记住这点！",[10,937,938,939,942,943,460],{},"​\t这个uniform现在还是空的；我们还没有给它添加任何数据，所以下面我们就做这件事。",[157,940,941],{},"我们首先需要找到着色器中uniform属性的索引\u002F位置值","。当我们得到uniform的索引\u002F位置值后，我们就可以更新它的值了。这次我们不去给像素传递单独一个颜色，而是",[157,944,945],{},"让它随着时间改变颜色",[38,947,949],{"className":40,"code":948,"language":42,"meta":43,"style":43},"float timeValue = glfwGetTime();\nfloat greenValue = (sin(timeValue) \u002F 2.0f) + 0.5f;\nint vertexColorLocation = glGetUniformLocation(shaderProgram, \"ourColor\");\nglUseProgram(shaderProgram);\nglUniform4f(vertexColorLocation, 0.0f, greenValue, 0.0f, 1.0f);\n",[45,950,951,966,1006,1026,1034],{"__ignoreMap":43},[48,952,953,955,958,960,963],{"class":50,"line":51},[48,954,243],{"class":101},[48,956,957],{"class":54}," timeValue ",[48,959,143],{"class":101},[48,961,962],{"class":105}," glfwGetTime",[48,964,965],{"class":54},"();\n",[48,967,968,970,973,975,978,981,984,987,990,993,996,998,1001,1003],{"class":50,"line":58},[48,969,243],{"class":101},[48,971,972],{"class":54}," greenValue ",[48,974,143],{"class":101},[48,976,977],{"class":54}," (",[48,979,980],{"class":105},"sin",[48,982,983],{"class":54},"(timeValue) ",[48,985,986],{"class":101},"\u002F",[48,988,989],{"class":481}," 2.0",[48,991,992],{"class":101},"f",[48,994,995],{"class":54},") ",[48,997,439],{"class":101},[48,999,1000],{"class":481}," 0.5",[48,1002,992],{"class":101},[48,1004,1005],{"class":54},";\n",[48,1007,1008,1010,1013,1015,1018,1021,1024],{"class":50,"line":64},[48,1009,174],{"class":101},[48,1011,1012],{"class":54}," vertexColorLocation ",[48,1014,143],{"class":101},[48,1016,1017],{"class":105}," glGetUniformLocation",[48,1019,1020],{"class":54},"(shaderProgram, ",[48,1022,1023],{"class":205},"\"ourColor\"",[48,1025,514],{"class":54},[48,1027,1028,1031],{"class":50,"line":69},[48,1029,1030],{"class":105},"glUseProgram",[48,1032,1033],{"class":54},"(shaderProgram);\n",[48,1035,1036,1039,1042,1044,1046,1049,1051,1053,1055,1057,1059],{"class":50,"line":76},[48,1037,1038],{"class":105},"glUniform4f",[48,1040,1041],{"class":54},"(vertexColorLocation, ",[48,1043,507],{"class":481},[48,1045,992],{"class":101},[48,1047,1048],{"class":54},", greenValue, ",[48,1050,507],{"class":481},[48,1052,992],{"class":101},[48,1054,485],{"class":54},[48,1056,529],{"class":481},[48,1058,992],{"class":101},[48,1060,514],{"class":54},[10,1062,1063,1064,1067,1068,1071,1072,559],{},"​\t首先我们",[157,1065,1066],{},"通过glfwGetTime()获取运行的秒数","。然后我们",[157,1069,1070],{},"使用sin函数让颜色在0.0到1.0之间改变","，最后",[157,1073,1074],{},"将结果储存到greenValue里",[10,1076,1077,1078,1081,1082,1085],{},"​\t接着，我们用glGetUniformLocation查询uniform ourColor的位置值。我们为查询函数提供着色器程序和uniform的名字（这是我们希望获得的位置值的来源）。如果glGetUniformLocation返回",[45,1079,1080],{},"-1","就代表没有找到这个位置值。最后，我们可以通过glUniform4f函数设置uniform值。注意，查询uniform地址不要求你之前使用过着色器程序，但是更新一个uniform之前你",[157,1083,1084],{},"必须","先使用程序（调用glUseProgram)，因为它是在当前激活的着色器程序中设置uniform的。",[588,1087,1088,1092,1095,1157],{},[10,1089,1090],{},[48,1091,594],{},[10,1093,1094],{},"因为OpenGL在其核心是一个C库，所以它不支持类型重载，在函数参数不同的时候就要为其定义新的函数；glUniform是一个典型例子。这个函数有一个特定的后缀，标识设定的uniform的类型。可能的后缀有：",[271,1096,1097,1106],{},[274,1098,1099],{},[277,1100,1101,1104],{},[280,1102,1103],{"align":282},"后缀",[280,1105,286],{"align":282},[288,1107,1108,1117,1127,1137,1147],{},[277,1109,1110,1114],{},[293,1111,1112],{"align":282},[45,1113,992],{},[293,1115,1116],{"align":282},"函数需要一个float作为它的值",[277,1118,1119,1124],{},[293,1120,1121],{"align":282},[45,1122,1123],{},"i",[293,1125,1126],{"align":282},"函数需要一个int作为它的值",[277,1128,1129,1134],{},[293,1130,1131],{"align":282},[45,1132,1133],{},"ui",[293,1135,1136],{"align":282},"函数需要一个unsigned int作为它的值",[277,1138,1139,1144],{},[293,1140,1141],{"align":282},[45,1142,1143],{},"3f",[293,1145,1146],{"align":282},"函数需要3个float作为它的值",[277,1148,1149,1154],{},[293,1150,1151],{"align":282},[45,1152,1153],{},"fv",[293,1155,1156],{"align":282},"函数需要一个float向量\u002F数组作为它的值",[10,1158,1159,1160,1162],{},"每当你打算配置一个OpenGL的选项时就可以简单地根据这些规则选择适合你的数据类型的重载函数。在我们的例子里，我们希望分别设定uniform的4个float值，所以我们通过glUniform4f传递我们的数据(注意，我们也可以使用",[45,1161,1153],{},"版本)。",[10,1164,1165],{},"​\t现在你知道如何设置uniform变量的值了，我们可以使用它们来渲染了。如果我们打算让颜色慢慢变化，我们就要在游戏循环的每一次迭代中（所以他会逐帧改变）更新这个uniform，否则三角形就不会改变颜色。下面我们就计算greenValue然后每个渲染迭代都更新这个uniform：",[38,1167,1169],{"className":40,"code":1168,"language":42,"meta":43,"style":43},"while(!glfwWindowShouldClose(window))\n{\n    \u002F\u002F 输入\n    processInput(window);\n\n    \u002F\u002F 渲染\n    \u002F\u002F 清除颜色缓冲\n    glClearColor(0.2f, 0.3f, 0.3f, 1.0f);\n    glClear(GL_COLOR_BUFFER_BIT);\n\n    \u002F\u002F 记得激活着色器\n    glUseProgram(shaderProgram);\n\n    \u002F\u002F 更新uniform颜色\n    float timeValue = glfwGetTime();\n    float greenValue = sin(timeValue) \u002F 2.0f + 0.5f;\n    int vertexColorLocation = glGetUniformLocation(shaderProgram, \"ourColor\");\n    glUniform4f(vertexColorLocation, 0.0f, greenValue, 0.0f, 1.0f);\n\n    \u002F\u002F 绘制三角形\n    glBindVertexArray(VAO);\n    glDrawArrays(GL_TRIANGLES, 0, 3);\n\n    \u002F\u002F 交换缓冲并查询IO事件\n    glfwSwapBuffers(window);\n    glfwPollEvents();\n}\n",[45,1170,1171,1187,1191,1196,1204,1208,1213,1218,1251,1259,1263,1268,1275,1279,1284,1297,1326,1344,1370,1375,1381,1390,1409,1414,1420,1428,1436],{"__ignoreMap":43},[48,1172,1173,1176,1178,1181,1184],{"class":50,"line":51},[48,1174,1175],{"class":101},"while",[48,1177,478],{"class":54},[48,1179,1180],{"class":101},"!",[48,1182,1183],{"class":105},"glfwWindowShouldClose",[48,1185,1186],{"class":54},"(window))\n",[48,1188,1189],{"class":50,"line":58},[48,1190,115],{"class":54},[48,1192,1193],{"class":50,"line":64},[48,1194,1195],{"class":121},"    \u002F\u002F 输入\n",[48,1197,1198,1201],{"class":50,"line":69},[48,1199,1200],{"class":105},"    processInput",[48,1202,1203],{"class":54},"(window);\n",[48,1205,1206],{"class":50,"line":76},[48,1207,73],{"emptyLinePlaceholder":72},[48,1209,1210],{"class":50,"line":82},[48,1211,1212],{"class":121},"    \u002F\u002F 渲染\n",[48,1214,1215],{"class":50,"line":87},[48,1216,1217],{"class":121},"    \u002F\u002F 清除颜色缓冲\n",[48,1219,1220,1223,1225,1228,1230,1232,1235,1237,1239,1241,1243,1245,1247,1249],{"class":50,"line":93},[48,1221,1222],{"class":105},"    glClearColor",[48,1224,478],{"class":54},[48,1226,1227],{"class":481},"0.2",[48,1229,992],{"class":101},[48,1231,485],{"class":54},[48,1233,1234],{"class":481},"0.3",[48,1236,992],{"class":101},[48,1238,485],{"class":54},[48,1240,1234],{"class":481},[48,1242,992],{"class":101},[48,1244,485],{"class":54},[48,1246,529],{"class":481},[48,1248,992],{"class":101},[48,1250,514],{"class":54},[48,1252,1253,1256],{"class":50,"line":98},[48,1254,1255],{"class":105},"    glClear",[48,1257,1258],{"class":54},"(GL_COLOR_BUFFER_BIT);\n",[48,1260,1261],{"class":50,"line":112},[48,1262,73],{"emptyLinePlaceholder":72},[48,1264,1265],{"class":50,"line":118},[48,1266,1267],{"class":121},"    \u002F\u002F 记得激活着色器\n",[48,1269,1270,1273],{"class":50,"line":125},[48,1271,1272],{"class":105},"    glUseProgram",[48,1274,1033],{"class":54},[48,1276,1277],{"class":50,"line":131},[48,1278,73],{"emptyLinePlaceholder":72},[48,1280,1281],{"class":50,"line":137},[48,1282,1283],{"class":121},"    \u002F\u002F 更新uniform颜色\n",[48,1285,1286,1289,1291,1293,1295],{"class":50,"line":149},[48,1287,1288],{"class":101},"    float",[48,1290,957],{"class":54},[48,1292,143],{"class":101},[48,1294,962],{"class":105},[48,1296,965],{"class":54},[48,1298,1300,1302,1304,1306,1309,1311,1313,1315,1317,1320,1322,1324],{"class":50,"line":1299},16,[48,1301,1288],{"class":101},[48,1303,972],{"class":54},[48,1305,143],{"class":101},[48,1307,1308],{"class":105}," sin",[48,1310,983],{"class":54},[48,1312,986],{"class":101},[48,1314,989],{"class":481},[48,1316,992],{"class":101},[48,1318,1319],{"class":101}," +",[48,1321,1000],{"class":481},[48,1323,992],{"class":101},[48,1325,1005],{"class":54},[48,1327,1329,1332,1334,1336,1338,1340,1342],{"class":50,"line":1328},17,[48,1330,1331],{"class":101},"    int",[48,1333,1012],{"class":54},[48,1335,143],{"class":101},[48,1337,1017],{"class":105},[48,1339,1020],{"class":54},[48,1341,1023],{"class":205},[48,1343,514],{"class":54},[48,1345,1347,1350,1352,1354,1356,1358,1360,1362,1364,1366,1368],{"class":50,"line":1346},18,[48,1348,1349],{"class":105},"    glUniform4f",[48,1351,1041],{"class":54},[48,1353,507],{"class":481},[48,1355,992],{"class":101},[48,1357,1048],{"class":54},[48,1359,507],{"class":481},[48,1361,992],{"class":101},[48,1363,485],{"class":54},[48,1365,529],{"class":481},[48,1367,992],{"class":101},[48,1369,514],{"class":54},[48,1371,1373],{"class":50,"line":1372},19,[48,1374,73],{"emptyLinePlaceholder":72},[48,1376,1378],{"class":50,"line":1377},20,[48,1379,1380],{"class":121},"    \u002F\u002F 绘制三角形\n",[48,1382,1384,1387],{"class":50,"line":1383},21,[48,1385,1386],{"class":105},"    glBindVertexArray",[48,1388,1389],{"class":54},"(VAO);\n",[48,1391,1393,1396,1399,1402,1404,1407],{"class":50,"line":1392},22,[48,1394,1395],{"class":105},"    glDrawArrays",[48,1397,1398],{"class":54},"(GL_TRIANGLES, ",[48,1400,1401],{"class":481},"0",[48,1403,485],{"class":54},[48,1405,1406],{"class":481},"3",[48,1408,514],{"class":54},[48,1410,1412],{"class":50,"line":1411},23,[48,1413,73],{"emptyLinePlaceholder":72},[48,1415,1417],{"class":50,"line":1416},24,[48,1418,1419],{"class":121},"    \u002F\u002F 交换缓冲并查询IO事件\n",[48,1421,1423,1426],{"class":50,"line":1422},25,[48,1424,1425],{"class":105},"    glfwSwapBuffers",[48,1427,1203],{"class":54},[48,1429,1431,1434],{"class":50,"line":1430},26,[48,1432,1433],{"class":105},"    glfwPollEvents",[48,1435,965],{"class":54},[48,1437,1439],{"class":50,"line":1438},27,[48,1440,152],{"class":54},[10,1442,1443,1444,1447,1448,559],{},"​\t这里的代码对之前代码是一次非常直接的修改。这次，我们在",[157,1445,1446],{},"每次迭代绘制三角形前先更新uniform值","。如果你正确更新了uniform，你会看到你的三角形",[157,1449,1450],{},"逐渐由绿变黑再变回绿色",[10,1452,1453,1454,1457,1458,1461,1462,1465,1466,1469],{},"​\t可以看到，",[157,1455,1456],{},"uniform对于设置一个在渲染迭代中会改变的属性是一个非常有用的工具","，它",[157,1459,1460],{},"也是一个在程序和着色器间数据交互的很好工具","，但假如我们",[157,1463,1464],{},"打算为每个顶点设置一个颜色的时候该怎么办","？这种情况下，我们",[157,1467,1468],{},"就不得不声明和顶点数目一样多的uniform了","。在这一问题上更好的解决方案是在顶点属性中包含更多的数据，这是我们接下来要做的事情。",[228,1471,1473],{"id":1472},"更多属性","更多属性！",[10,1475,562,1476,1479,1480,460],{},[157,1477,1478],{},"在前面的教程中，我们了解了如何填充VBO","、配置顶点属性指针以及如何把它们都储存到一个VAO里。这次，我们同样打算把颜色数据加进顶点数据中。",[157,1481,1482],{},"我们将把颜色数据添加为3个float值至vertices数组。我们将把三角形的三个角分别指定为红色、绿色和蓝色",[38,1484,1486],{"className":40,"code":1485,"language":42,"meta":43,"style":43},"float vertices[] = {\n    \u002F\u002F 位置              \u002F\u002F 颜色\n     0.5f, -0.5f, 0.0f,  1.0f, 0.0f, 0.0f,   \u002F\u002F 右下\n    -0.5f, -0.5f, 0.0f,  0.0f, 1.0f, 0.0f,   \u002F\u002F 左下\n     0.0f,  0.5f, 0.0f,  0.0f, 0.0f, 1.0f    \u002F\u002F 顶部\n};\n",[45,1487,1488,1500,1508,1555,1601,1641],{"__ignoreMap":43},[48,1489,1490,1492,1495,1497],{"class":50,"line":51},[48,1491,243],{"class":101},[48,1493,1494],{"class":54}," vertices[] ",[48,1496,143],{"class":101},[48,1498,1499],{"class":54}," {\n",[48,1501,1502,1505],{"class":50,"line":58},[48,1503,1504],{"class":121},"    \u002F\u002F 位置",[48,1506,1507],{"class":121},"              \u002F\u002F 颜色\n",[48,1509,1510,1513,1515,1517,1520,1522,1524,1526,1528,1530,1533,1535,1537,1539,1541,1543,1545,1547,1549,1552],{"class":50,"line":64},[48,1511,1512],{"class":481},"     0.5",[48,1514,992],{"class":101},[48,1516,485],{"class":54},[48,1518,1519],{"class":101},"-",[48,1521,482],{"class":481},[48,1523,992],{"class":101},[48,1525,485],{"class":54},[48,1527,507],{"class":481},[48,1529,992],{"class":101},[48,1531,1532],{"class":54},",  ",[48,1534,529],{"class":481},[48,1536,992],{"class":101},[48,1538,485],{"class":54},[48,1540,507],{"class":481},[48,1542,992],{"class":101},[48,1544,485],{"class":54},[48,1546,507],{"class":481},[48,1548,992],{"class":101},[48,1550,1551],{"class":54},",",[48,1553,1554],{"class":121},"   \u002F\u002F 右下\n",[48,1556,1557,1560,1562,1564,1566,1568,1570,1572,1574,1576,1578,1580,1582,1584,1586,1588,1590,1592,1594,1596,1598],{"class":50,"line":69},[48,1558,1559],{"class":101},"    -",[48,1561,482],{"class":481},[48,1563,992],{"class":101},[48,1565,485],{"class":54},[48,1567,1519],{"class":101},[48,1569,482],{"class":481},[48,1571,992],{"class":101},[48,1573,485],{"class":54},[48,1575,507],{"class":481},[48,1577,992],{"class":101},[48,1579,1532],{"class":54},[48,1581,507],{"class":481},[48,1583,992],{"class":101},[48,1585,485],{"class":54},[48,1587,529],{"class":481},[48,1589,992],{"class":101},[48,1591,485],{"class":54},[48,1593,507],{"class":481},[48,1595,992],{"class":101},[48,1597,1551],{"class":54},[48,1599,1600],{"class":121},"   \u002F\u002F 左下\n",[48,1602,1603,1606,1608,1610,1612,1614,1616,1618,1620,1622,1624,1626,1628,1630,1632,1634,1636,1638],{"class":50,"line":76},[48,1604,1605],{"class":481},"     0.0",[48,1607,992],{"class":101},[48,1609,1532],{"class":54},[48,1611,482],{"class":481},[48,1613,992],{"class":101},[48,1615,485],{"class":54},[48,1617,507],{"class":481},[48,1619,992],{"class":101},[48,1621,1532],{"class":54},[48,1623,507],{"class":481},[48,1625,992],{"class":101},[48,1627,485],{"class":54},[48,1629,507],{"class":481},[48,1631,992],{"class":101},[48,1633,485],{"class":54},[48,1635,529],{"class":481},[48,1637,992],{"class":101},[48,1639,1640],{"class":121},"    \u002F\u002F 顶部\n",[48,1642,1643],{"class":50,"line":82},[48,1644,1645],{"class":54},"};\n",[10,1647,1648,1649,1651,1652,1655,1656,1659,1660,1662],{},"​\t由于现在有更多的数据要发送到",[157,1650,630],{},"，我们有必要去",[157,1653,1654],{},"调整一下顶点着色器","，使它能够",[157,1657,1658],{},"接收颜色值作为一个顶点属性输入","。需要注意的是我们用",[45,1661,585],{},"标识符来把aColor属性的位置值设置为1：",[38,1664,1666],{"className":40,"code":1665,"language":42,"meta":43,"style":43},"#version 330 core\nlayout (location = 0) in vec3 aPos;   \u002F\u002F 位置变量的属性位置值为 0 \nlayout (location = 1) in vec3 aColor; \u002F\u002F 颜色变量的属性位置值为 1\n\nout vec3 ourColor; \u002F\u002F 向片段着色器输出一个颜色\n\nvoid main()\n{\n    gl_Position = vec4(aPos, 1.0);\n    ourColor = aColor; \u002F\u002F 将ourColor设置为我们从顶点数据那里得到的输入颜色\n}\n",[45,1667,1668,1676,1691,1708,1712,1720,1724,1732,1736,1750,1763],{"__ignoreMap":43},[48,1669,1670,1672,1674],{"class":50,"line":51},[48,1671,640],{"class":54},[48,1673,643],{"class":481},[48,1675,646],{"class":54},[48,1677,1678,1680,1682,1684,1686,1688],{"class":50,"line":58},[48,1679,585],{"class":105},[48,1681,653],{"class":54},[48,1683,143],{"class":101},[48,1685,658],{"class":481},[48,1687,661],{"class":54},[48,1689,1690],{"class":121},"   \u002F\u002F 位置变量的属性位置值为 0 \n",[48,1692,1693,1695,1697,1699,1702,1705],{"class":50,"line":64},[48,1694,585],{"class":105},[48,1696,653],{"class":54},[48,1698,143],{"class":101},[48,1700,1701],{"class":481}," 1",[48,1703,1704],{"class":54},") in vec3 aColor;",[48,1706,1707],{"class":121}," \u002F\u002F 颜色变量的属性位置值为 1\n",[48,1709,1710],{"class":50,"line":69},[48,1711,73],{"emptyLinePlaceholder":72},[48,1713,1714,1717],{"class":50,"line":76},[48,1715,1716],{"class":54},"out vec3 ourColor;",[48,1718,1719],{"class":121}," \u002F\u002F 向片段着色器输出一个颜色\n",[48,1721,1722],{"class":50,"line":82},[48,1723,73],{"emptyLinePlaceholder":72},[48,1725,1726,1728,1730],{"class":50,"line":87},[48,1727,102],{"class":101},[48,1729,106],{"class":105},[48,1731,109],{"class":54},[48,1733,1734],{"class":50,"line":93},[48,1735,115],{"class":54},[48,1737,1738,1740,1742,1744,1746,1748],{"class":50,"line":98},[48,1739,697],{"class":54},[48,1741,143],{"class":101},[48,1743,501],{"class":105},[48,1745,704],{"class":54},[48,1747,529],{"class":481},[48,1749,514],{"class":54},[48,1751,1752,1755,1757,1760],{"class":50,"line":112},[48,1753,1754],{"class":54},"    ourColor ",[48,1756,143],{"class":101},[48,1758,1759],{"class":54}," aColor;",[48,1761,1762],{"class":121}," \u002F\u002F 将ourColor设置为我们从顶点数据那里得到的输入颜色\n",[48,1764,1765],{"class":50,"line":118},[48,1766,152],{"class":54},[10,1768,1769,1770,1773],{},"​\t由于我们不再使用uniform来传递片段的颜色了，现在使用",[45,1771,1772],{},"ourColor","输出变量，我们必须再修改一下片段着色器：",[38,1775,1777],{"className":40,"code":1776,"language":42,"meta":43,"style":43},"#version 330 core\nout vec4 FragColor;  \nin vec3 ourColor;\n\nvoid main()\n{\n    FragColor = vec4(ourColor, 1.0);\n}\n",[45,1778,1779,1787,1792,1797,1801,1809,1813,1828],{"__ignoreMap":43},[48,1780,1781,1783,1785],{"class":50,"line":51},[48,1782,640],{"class":54},[48,1784,643],{"class":481},[48,1786,646],{"class":54},[48,1788,1789],{"class":50,"line":58},[48,1790,1791],{"class":54},"out vec4 FragColor;  \n",[48,1793,1794],{"class":50,"line":64},[48,1795,1796],{"class":54},"in vec3 ourColor;\n",[48,1798,1799],{"class":50,"line":69},[48,1800,73],{"emptyLinePlaceholder":72},[48,1802,1803,1805,1807],{"class":50,"line":76},[48,1804,102],{"class":101},[48,1806,106],{"class":105},[48,1808,109],{"class":54},[48,1810,1811],{"class":50,"line":82},[48,1812,115],{"class":54},[48,1814,1815,1817,1819,1821,1824,1826],{"class":50,"line":87},[48,1816,802],{"class":54},[48,1818,143],{"class":101},[48,1820,501],{"class":105},[48,1822,1823],{"class":54},"(ourColor, ",[48,1825,529],{"class":481},[48,1827,514],{"class":54},[48,1829,1830],{"class":50,"line":93},[48,1831,152],{"class":54},[228,1833,1835,1838],{"id":1834},"复合顶点数据-的标准方法",[157,1836,1837],{},"复合顶点数据"," 的标准方法",[38,1840,1842],{"className":40,"code":1841,"language":42,"meta":43,"style":43},"        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)0);\u002F\u002F 位置属性\n        glEnableVertexAttribArray(0);\n        glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)(3 * sizeof(float))); \u002F\u002F 颜色属性\n        glEnableVertexAttribArray(1);\n",[45,1843,1844,1889,1900,1948],{"__ignoreMap":43},[48,1845,1846,1849,1851,1853,1855,1857,1860,1863,1866,1869,1871,1873,1876,1879,1882,1884,1886],{"class":50,"line":51},[48,1847,1848],{"class":105},"        glVertexAttribPointer",[48,1850,478],{"class":54},[48,1852,1401],{"class":481},[48,1854,485],{"class":54},[48,1856,1406],{"class":481},[48,1858,1859],{"class":54},", GL_FLOAT, GL_FALSE, ",[48,1861,1862],{"class":481},"6",[48,1864,1865],{"class":101}," *",[48,1867,1868],{"class":101}," sizeof",[48,1870,478],{"class":54},[48,1872,243],{"class":101},[48,1874,1875],{"class":54},"), (",[48,1877,1878],{"class":101},"void*",[48,1880,1881],{"class":54},")",[48,1883,1401],{"class":481},[48,1885,709],{"class":54},[48,1887,1888],{"class":121},"\u002F\u002F 位置属性\n",[48,1890,1891,1894,1896,1898],{"class":50,"line":58},[48,1892,1893],{"class":105},"        glEnableVertexAttribArray",[48,1895,478],{"class":54},[48,1897,1401],{"class":481},[48,1899,514],{"class":54},[48,1901,1902,1904,1906,1909,1911,1913,1915,1917,1919,1921,1923,1925,1927,1929,1932,1934,1936,1938,1940,1942,1945],{"class":50,"line":64},[48,1903,1848],{"class":105},[48,1905,478],{"class":54},[48,1907,1908],{"class":481},"1",[48,1910,485],{"class":54},[48,1912,1406],{"class":481},[48,1914,1859],{"class":54},[48,1916,1862],{"class":481},[48,1918,1865],{"class":101},[48,1920,1868],{"class":101},[48,1922,478],{"class":54},[48,1924,243],{"class":101},[48,1926,1875],{"class":54},[48,1928,1878],{"class":101},[48,1930,1931],{"class":54},")(",[48,1933,1406],{"class":481},[48,1935,1865],{"class":101},[48,1937,1868],{"class":101},[48,1939,478],{"class":54},[48,1941,243],{"class":101},[48,1943,1944],{"class":54},")));",[48,1946,1947],{"class":121}," \u002F\u002F 颜色属性\n",[48,1949,1950,1952,1954,1956],{"class":50,"line":69},[48,1951,1893],{"class":105},[48,1953,478],{"class":54},[48,1955,1908],{"class":481},[48,1957,514],{"class":54},[10,1959,1960,1961,1964,1965,559],{},"​\t这段代码的核心在于设置了两个独立的顶点属性，它们从同一个 VBO 中读取数据，但具有不同的",[157,1962,1963],{},"步长（Stride）"," 和",[157,1966,1967],{},"偏移量（Offset）",[256,1969,1970],{"id":1970},"假设的顶点数据结构",[10,1972,1973],{},"​\t为了理解这些参数，我们首先假定你的 VBO 数据是按以下格式组织的（每个顶点有 6 个浮点数）：",[10,1975,1976],{},[825,1977],{"alt":1978,"src":1979},"image-20251006173313335",".\u002Fassets\u002Fimage-20251006173313335.png",[256,1981,1983],{"id":1982},"属性-1顶点位置-location-0","属性 1：顶点位置 (Location 0)",[38,1985,1990],{"className":1986,"code":1988,"language":1989},[1987],"language-text","glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)0); \u002F\u002F 位置属性\nglEnableVertexAttribArray(0);\n","text",[45,1991,1988],{"__ignoreMap":43},[10,1993,1994,1997],{},[45,1995,1996],{},"glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)0)"," 解释：",[1999,2000,2001,2020,2028,2037,2050],"ul",{},[2002,2003,2004,2009,2010,2012,2013,2015,2016,2019],"li",{},[157,2005,2006,2008],{},[45,2007,1401],{}," (Index):"," 对应于",[157,2011,630],{},"中的 ",[45,2014,581],{}," 输入变量（如 ",[45,2017,2018],{},"vec3 aPos","）。",[2002,2021,2022,2027],{},[157,2023,2024,2026],{},[45,2025,1406],{}," (Size):"," 位置由 3 个分量（x,y,z）组成。",[2002,2029,2030,2036],{},[157,2031,2032,2035],{},[45,2033,2034],{},"GL_FLOAT"," (Type):"," 每个分量是浮点数。",[2002,2038,2039,2045,2046,2049],{},[157,2040,2041,2044],{},[45,2042,2043],{},"6 \\* sizeof(float)"," (Stride):"," 这是最关键的。它指定了 ",[157,2047,2048],{},"从一个顶点的 x 坐标开始，到下一个顶点的 x 坐标开始，需要跳过的字节数","。因为每个顶点包含 6 个浮点数（3个位置 + 3个颜色），所以步长是 6×4=24 字节。",[2002,2051,2052,2058],{},[157,2053,2054,2057],{},[45,2055,2056],{},"(void\\*)0"," (Offset):"," 位置数据从 VBO 的**起始位置（0 字节）**开始。",[2060,2061],"hr",{},[256,2063,2065],{"id":2064},"属性-2顶点颜色-location-1","属性 2：顶点颜色 (Location 1)",[38,2067,2070],{"className":2068,"code":2069,"language":1989},[1987],"glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)(3 * sizeof(float))); \u002F\u002F 颜色属性\nglEnableVertexAttribArray(1);\n",[45,2071,2069],{"__ignoreMap":43},[10,2073,2074,1997],{},[45,2075,2076],{},"glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)(3 * sizeof(float)))",[1999,2078,2079,2092,2099,2105,2116],{},[2002,2080,2081,2085,2086,2015,2089,2019],{},[157,2082,2083,2008],{},[45,2084,1908],{}," 对应于顶点着色器中的 ",[45,2087,2088],{},"layout (location = 1)",[45,2090,2091],{},"vec3 aColor",[2002,2093,2094,2098],{},[157,2095,2096,2026],{},[45,2097,1406],{}," 颜色由 3 个分量（r,g,b）组成。",[2002,2100,2101,2036],{},[157,2102,2103,2035],{},[45,2104,2034],{},[2002,2106,2107,2111,2112,2115],{},[157,2108,2109,2044],{},[45,2110,2043],{}," 步长",[157,2113,2114],{},"与位置属性相同","（24 字节），因为从一个顶点的颜色 r 开始，到下一个顶点的颜色 r 开始，仍然需要跳过整个 6 个浮点数的数据块。",[2002,2117,2118,2123,2124,2127,2128,2131],{},[157,2119,2120,2057],{},[45,2121,2122],{},"(void\\*)(3 \\* sizeof(float))"," 这是另一个关键点。它指定了",[157,2125,2126],{},"颜色数据在每个顶点数据块中开始的位置","。由于前 3 个浮点数是位置数据，所以颜色数据从 ",[157,2129,2130],{},"3×4=12 字节"," 处开始。",[10,2133,2134],{},[825,2135],{"alt":825,"src":2136},".\u002Fassets\u002Fshaders3.png",[10,2138,2139,2140,2143,2144,2147,2148,2151],{},"​\t这个图片可能不是你所期望的那种，因为我们只提供了3个颜色，而不是我们现在看到的大调色板。",[157,2141,2142],{},"这是在片段着色器中进行的所谓片段插值(Fragment Interpolation)的结果","。当渲染一个三角形时，",[157,2145,2146],{},"光栅化(Rasterization)阶段通常会造成比原指定顶点更多的片段。光栅会根据每个片段在三角形形状上所处相对位置决定这些片段的位置","。\n基于这些位置，它会插值(Interpolate)所有片段着色器的输入变量。比如说，我们有一个线段，上面的端点是绿色的，下面的端点是蓝色的。如果一个片段着色器在线段的70%的位置运行，",[157,2149,2150],{},"它的颜色输入属性就会是一个绿色和蓝色的线性结合","；更精确地说就是30%蓝 + 70%绿。",[10,2153,2154,2155,2158],{},"​\t这正是在这个三角形中发生了什么。我们有3个顶点，和相应的3个颜色，",[157,2156,2157],{},"从这个三角形的像素来看它可能包含50000左右的片段，片段着色器为这些像素进行插值颜色","。如果你仔细看这些颜色就应该能明白了：红首先变成到紫再变为蓝色。片段插值会被应用到片段着色器的所有输入属性上。",[2160,2161,2162],"style",{},"html pre.shiki code .sVt8B, html code.shiki .sVt8B{--shiki-default:#24292E;--shiki-dark:#E1E4E8}html pre.shiki code .szBVR, html code.shiki .szBVR{--shiki-default:#D73A49;--shiki-dark:#F97583}html pre.shiki code .sScJk, html code.shiki .sScJk{--shiki-default:#6F42C1;--shiki-dark:#B392F0}html pre.shiki code .sJ8bj, html code.shiki .sJ8bj{--shiki-default:#6A737D;--shiki-dark:#6A737D}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html pre.shiki code .sZZnC, html code.shiki .sZZnC{--shiki-default:#032F62;--shiki-dark:#9ECBFF}html pre.shiki code .sj4cs, html code.shiki .sj4cs{--shiki-default:#005CC5;--shiki-dark:#79B8FF}",{"title":43,"searchDepth":58,"depth":58,"links":2164},[2165,2168,2169,2170,2171],{"id":230,"depth":58,"text":230,"children":2166},[2167],{"id":258,"depth":64,"text":258},{"id":537,"depth":58,"text":537},{"id":833,"depth":58,"text":834},{"id":1472,"depth":58,"text":1473},{"id":1834,"depth":58,"text":2172,"children":2173},"复合顶点数据 的标准方法",[2174,2175,2176],{"id":1970,"depth":64,"text":1970},{"id":1982,"depth":64,"text":1983},{"id":2064,"depth":64,"text":2065},"​\t在[Hello Triangle](https:\u002F\u002Flearnopengl-cn.github.io\u002F01 Getting started\u002F04 Hello Triangle\u002F)教程中提到，着色器(Shader)是运行在GPU上的小程序。这些小程序为图形渲染管线的某个特定部分而运行。从基本意义上来说，着色器只是一种把输入转化为输出的程序。着色器也是一种非常独立的程序，因为它们之间不能相互通信；它们之间唯一的沟通只有通过输入和输出。","md",{},"\u002Fgraphy\u002Fopengel\u002F着色器",{"description":2177},"graphy\u002Fopengel\u002F着色器","CjUjdspiTVLIhKnOBNsL-E0PpDfxlY8StmJYN07I9cw",1792338204665]