Jason McKesson avatar Jason McKesson committed 748373c

Normalized mesh names across tutorials.
Checked glossterms.
Checked programlistings for languages.

Comments (0)

Files changed (27)

Documents/Basics/Tutorial 01.xml

                 the list of vertices represents.</para>
             <para>OpenGL can interpret a list of vertices in a variety of different ways. The way
                 OpenGL interprets vertex lists is given by the draw command:</para>
-            <programlisting>glDrawArrays(GL_TRIANGLES, 0, 3);</programlisting>
+            <programlisting language="cpp">glDrawArrays(GL_TRIANGLES, 0, 3);</programlisting>
             <para>The enum <literal>GL_TRIANGLES</literal> tells OpenGL that every 3 vertices of the
                 list should be used to build a triangle. Since we passed only 3 vertices, we get 1
                 triangle.</para>

Documents/Illumination/Tutorial 09.xml

     glm::mat3 normMatrix(modelMatrix.Top());
     glUniformMatrix3fv(g_VertexDiffuseColor.normalModelToCameraMatrixUnif, 1, GL_FALSE, glm::value_ptr(normMatrix));
     glUniform4f(g_VertexDiffuseColor.lightIntensityUnif, 1.0f, 1.0f, 1.0f, 1.0f);
-    g_pCylinderMesh->Render("tint");
+    g_pCylinderMesh->Render("lit-color");
 }
 else
 {
     glm::mat3 normMatrix(modelMatrix.Top());
     glUniformMatrix3fv(g_WhiteDiffuseColor.normalModelToCameraMatrixUnif, 1, GL_FALSE, glm::value_ptr(normMatrix));
     glUniform4f(g_WhiteDiffuseColor.lightIntensityUnif, 1.0f, 1.0f, 1.0f, 1.0f);
-    g_pCylinderMesh->Render("flat");
+    g_pCylinderMesh->Render("lit");
 }
 glUseProgram(0);</programlisting>
             </example>
                     <filename>DirVertexLighting_PCN</filename>:</para>
             <example>
                 <title>Lighting Vertex Shader</title>
-                <programlisting>#version 330
+                <programlisting language="glsl">#version 330
 
 layout(location = 0) in vec3 position;
 layout(location = 1) in vec4 diffuseColor;
 }
 glUniformMatrix3fv(g_VertexDiffuseColor.normalModelToCameraMatrixUnif, 1, GL_FALSE, glm::value_ptr(normMatrix));
 glUniform4f(g_VertexDiffuseColor.lightIntensityUnif, 1.0f, 1.0f, 1.0f, 1.0f);
-g_pCylinderMesh->Render("tint");
+g_pCylinderMesh->Render("lit-color");
 glUseProgram(0);</programlisting>
         </example>
         <para>It's pretty self-explanatory.</para>

Documents/Illumination/Tutorial 10.xml

     <title>Plane Lights</title>
     <para>Directional lights are useful for representing light sources like the sun and so forth.
         But most light sources are more likely to be represented as point lights.</para>
-    <para>A <glossterm>point light</glossterm> is a light source that has a position in the world
-        and shines with equal intensity in all directions. Our simple diffuse lighting equation is a
-        function of these properties:</para>
+    <para>A <glossterm>point light source</glossterm> is a light source that has a position in the
+        world and shines with equal intensity in all directions. Our simple diffuse lighting
+        equation is a function of these properties:</para>
     <itemizedlist>
         <listitem>
             <para>The surface normal at that point.</para>
             changes:</para>
         <example>
             <title>Per-Vertex Point Light Vertex Shader</title>
-            <programlisting>#version 330
+            <programlisting language="glsl">#version 330
 
 layout(location = 0) in vec3 position;
 layout(location = 1) in vec4 diffuseColor;

Documents/Illumination/Tutorial 11.xml

             Instead it is determined by... making things up.</para>
         <sidebar>
             <title>On Phong and Nomenclature</title>
-            <para>The term <glossterm>Phong shading</glossterm> was once commonly used to refer to
-                what we now know as per-fragment (or per-pixel) lighting. That is, evaluating the
-                lighting equation at every fragment over a surface. This term should not be confused
-                with the Phong specular lighting model. Because of this, the term <quote>Phong
+            <para>The term <quote>Phong shading</quote> was once commonly used to refer to what we
+                now know as per-fragment (or per-pixel) lighting. That is, evaluating the lighting
+                equation at every fragment over a surface. This term should not be confused with the
+                Phong specular lighting model. Because of this, the term <quote>Phong
                     shading</quote> has fallen out of common usage.</para>
         </sidebar>
         <para>The Phong model is not really based on anything real. It doesn't deal in microfacet
                 <glossterm>inverse cosine, arc cosine</glossterm>
                 <glossdef>
                     <para>Performs the opposite of the cosine function. The cosine function takes
-                        angles and returns a value on the range (-1, 1). The inverse cosine takes
-                        values on the range (-1, 1) and returns an angle in radians.</para>
+                        angles and returns a value on the range [-1, 1]. The inverse cosine takes
+                        values on the range [-1, 1] and returns an angle in radians.</para>
                 </glossdef>
             </glossentry>
         </glosslist>

Documents/Illumination/Tutorial 12.xml

             <para>The code that builds the material uniform buffer is as follows:</para>
             <example>
                 <title>Material UBO Construction</title>
-                <programlisting>int uniformBufferAlignSize = 0;
+                <programlisting language="cpp">int uniformBufferAlignSize = 0;
 glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &amp;uniformBufferAlignSize);
 
 m_sizeMaterialBlock = sizeof(MaterialBlock);
             <para>The only difference between directional and point lights in the lighting function
                 are attenuation (directional lights don't use attenuation) and how the light
                 direction is computed. So we simply compute these based on the W component:</para>
-            <programlisting>vec3 lightDir;
+            <programlisting language="glsl">vec3 lightDir;
 vec4 lightIntensity;
 if(lightData.cameraSpaceLightPos.w == 0.0)
 {
             monitor's gamma-correction circuitry has been mangling.</para>
         <section>
             <title>Gamma Functions</title>
-            <para>A <glossterm>gamma function</glossterm> is the function that maps linear RGB space
-                to non-linear RGB space. The gamma function for CRT displays was fairly standard,
-                and all non-CRT displays mimic this standard. It is ultimately based on a math
-                function of CRT displays. The strength of the electron beam is controlled by the
-                voltage passed through it. This correlates with the light intensity as
-                follows:</para>
+            <para>A gamma function is the function that maps linear RGB space to non-linear RGB
+                space. The gamma function for CRT displays was fairly standard, and all non-CRT
+                displays mimic this standard. It is ultimately based on a math function of CRT
+                displays. The strength of the electron beam is controlled by the voltage passed
+                through it. This correlates with the light intensity as follows:</para>
             <equation>
                 <title>Display Gamma Function</title>
                 <mediaobject>

Documents/Illumination/Tutorial 13.xml

             fragment shader:</para>
         <example>
             <title>Depth Correct Fragment Shader</title>
-            <programlisting>Impostor(cameraPos, cameraNormal);
+            <programlisting language="glsl">Impostor(cameraPos, cameraNormal);
 	
 //Set the depth based on the new cameraPos.
 vec4 clipPos = cameraToClipMatrix * vec4(cameraPos, 1.0);
                     <glossterm>interleaving</glossterm>. It is a very useful technique; indeed, for
                 performance reasons, data should generally be interleaved where possible. One thing
                 that it allows us to do is build our vertex data based on a struct:</para>
-            <programlisting>struct VertexData
+            <programlisting language="cpp">struct VertexData
 {
     glm::vec3 cameraPosition;
     float sphereRadius;
                 </glossdef>
             </glossentry>
             <glossentry>
+                <glossterm>early depth test, early-z</glossterm>
+                <glossdef>
+                    <para>An optimization in the depth test, where the incoming fragment's depth
+                        value is tested <emphasis>before</emphasis> the fragment shader executes. If
+                        the fragment shader is long, this can save a great deal of time. If the
+                        fragment shader exercises the option to modify or replace the fragment's
+                        depth, then the early depth test optimization will not be active.</para>
+                </glossdef>
+            </glossentry>
+            <glossentry>
                 <glossterm>interleaving</glossterm>
                 <glossdef>
-                    <para>The process of entwining vertex data, so that all of one vertex is
-                        spatially adjacent in the buffer object. This is as opposed to giving each
-                        vertex attribute its own array. Interleaving can lead to higher rendering
-                        performance in vertex transfer limited cases.</para>
+                    <para>A way of storing vertex attributes in a buffer object. This involves
+                        entwining the attribute data, so that most or all of a vertex's attributes
+                        are spatially adjacent in the buffer object. This is as opposed to giving
+                        each vertex attribute its own array. Interleaving can lead to higher
+                        rendering performance in vertex transfer limited cases.</para>
                 </glossdef>
             </glossentry>
             <glossentry>

Documents/Positioning/Tutorial 04.xml

                         <quote>y,</quote>
                         <quote>z,</quote> and <quote>w</quote> to pick components out of the input
                         vector. Swizzle operations look like this:</para>
-                    <programlisting>vec2 firstVec;
+                    <programlisting language="glsl">vec2 firstVec;
 vec4 secondVec = firstVec.xyxx;
 vec3 thirdVec = secondVec.wzy;</programlisting>
                     <para>Swizzle selection is, in graphics hardware, considered an operation so

Documents/Positioning/Tutorial 05.xml

                         less than the range zFar.</para>
                 </glossdef>
             </glossentry>
-            <glossentry>
-                <glossterm>early depth test, early-z</glossterm>
-                <glossdef>
-                    <para>An optimization in the depth test, where the incoming fragment's depth
-                        value is tested <emphasis>before</emphasis> the fragment shader executes. If
-                        the fragment shader is long, this can save a great deal of time. If the
-                        fragment shader exercises the option to modify or replace the fragment's
-                        depth, then the early depth test optimization will not be active.</para>
-                </glossdef>
-            </glossentry>
 			<!--TODO: Reinstate this.-->
 			<!--
             <glossentry>

Documents/Positioning/Tutorial 07.xml

                 by updating the world-to-camera matrix.</para>
             <example>
                 <title>Upload World to Camera Matrix</title>
-                <programlisting>const glm::vec3 &amp;camPos = ResolveCamPosition();
+                <programlisting language="cpp">const glm::vec3 &amp;camPos = ResolveCamPosition();
 
 Framework::MatrixStack camMatrix;
 camMatrix.SetMatrix(CalcLookAtMatrix(camPos, g_camTarget,
                 all, they don't have storage within a program object; their data comes from a buffer
                 object.</para>
             <para>So instead of calling glGetUniformLocation, we have a new function.</para>
-            <programlisting>data.globalUniformBlockIndex =
+            <programlisting language="cpp">data.globalUniformBlockIndex =
     glGetUniformBlockIndex(data.theProgram, "GlobalMatrices");</programlisting>
             <para>The function <function>glGetUniformBlockIndex</function> takes a program object
                 and the name of a uniform block. It returns a <glossterm>uniform block
             <para>Therefore, to use a uniform buffer, one first must tell the program which binding
                 point in the context to find the buffer. This association is made with the
                     <function>glUniformBlockBinding</function> function.</para>
-            <programlisting>glUniformBlockBinding(data.theProgram, data.globalUniformBlockIndex,
+            <programlisting language="cpp">glUniformBlockBinding(data.theProgram, data.globalUniformBlockIndex,
     g_iGlobalMatricesBindingIndex);</programlisting>
             <para>The first parameter is the program, the second is the uniform block index queried
                 before. The third is the uniform buffer binding point that this block should
             <para>After doing this for each program, the uniform buffer must be bound to that
                 binding point. This is done with a new function,
                     <function>glBindBufferRange</function>.</para>
-            <programlisting>glBindBufferRange(GL_UNIFORM_BUFFER, g_iGlobalMatricesBindingIndex,
+            <programlisting language="cpp">glBindBufferRange(GL_UNIFORM_BUFFER, g_iGlobalMatricesBindingIndex,
     g_GlobalMatricesUBO, 0, sizeof(glm::mat4) * 2);</programlisting>
             <para>This functions similarly to glBindBuffer; in addition to binding the buffer to the
                     <literal>GL_UNIFORM_BUFFER</literal> target, it also binds the buffer to the
                 matrix that always positions the object at the target point.</para>
             <example>
                 <title>Viewing Point with UBO</title>
-                <programlisting>glDisable(GL_DEPTH_TEST);
+                <programlisting language="cpp">glDisable(GL_DEPTH_TEST);
 
 Framework::MatrixStackPusher push(modelMatrix);
 

Documents/Positioning/Tutorial 08.xml

             <para>The code for slerp is rather complex:</para>
             <example>
                 <title>Spherical Linear Interpolation</title>
-                <programlisting>glm::fquat Slerp(const glm::fquat &amp;v0, const glm::fquat &amp;v1, float alpha)
+                <programlisting language="cpp">glm::fquat Slerp(const glm::fquat &amp;v0, const glm::fquat &amp;v1, float alpha)
 {
     float dot = glm::dot(v0, v1);
     

Tut 09 Lights on/Ambient Lighting.cpp

 					glUniformMatrix4fv(vertexDiffuse.modelToCameraMatrixUnif, 1, GL_FALSE, glm::value_ptr(modelMatrix.Top()));
 					glm::mat3 normMatrix(modelMatrix.Top());
 					glUniformMatrix3fv(vertexDiffuse.normalModelToCameraMatrixUnif, 1, GL_FALSE, glm::value_ptr(normMatrix));
-					g_pCylinderMesh->Render("tint");
+					g_pCylinderMesh->Render("lit-color");
 				}
 				else
 				{
 					glUniformMatrix4fv(whiteDiffuse.modelToCameraMatrixUnif, 1, GL_FALSE, glm::value_ptr(modelMatrix.Top()));
 					glm::mat3 normMatrix(modelMatrix.Top());
 					glUniformMatrix3fv(whiteDiffuse.normalModelToCameraMatrixUnif, 1, GL_FALSE, glm::value_ptr(normMatrix));
-					g_pCylinderMesh->Render("flat");
+					g_pCylinderMesh->Render("lit");
 				}
 				glUseProgram(0);
 			}

Tut 09 Lights on/Basic Lighting.cpp

 					glm::mat3 normMatrix(modelMatrix.Top());
 					glUniformMatrix3fv(g_VertexDiffuseColor.normalModelToCameraMatrixUnif, 1, GL_FALSE, glm::value_ptr(normMatrix));
 					glUniform4f(g_VertexDiffuseColor.lightIntensityUnif, 1.0f, 1.0f, 1.0f, 1.0f);
-					g_pCylinderMesh->Render("tint");
+					g_pCylinderMesh->Render("lit-color");
 				}
 				else
 				{
 					glm::mat3 normMatrix(modelMatrix.Top());
 					glUniformMatrix3fv(g_WhiteDiffuseColor.normalModelToCameraMatrixUnif, 1, GL_FALSE, glm::value_ptr(normMatrix));
 					glUniform4f(g_WhiteDiffuseColor.lightIntensityUnif, 1.0f, 1.0f, 1.0f, 1.0f);
-					g_pCylinderMesh->Render("flat");
+					g_pCylinderMesh->Render("lit");
 				}
 				glUseProgram(0);
 			}

Tut 09 Lights on/Scale and Lighting.cpp

 				}
 				glUniformMatrix3fv(g_VertexDiffuseColor.normalModelToCameraMatrixUnif, 1, GL_FALSE, glm::value_ptr(normMatrix));
 				glUniform4f(g_VertexDiffuseColor.lightIntensityUnif, 1.0f, 1.0f, 1.0f, 1.0f);
-				g_pCylinderMesh->Render("tint");
+				g_pCylinderMesh->Render("lit-color");
 				glUseProgram(0);
 			}
 		}

Tut 09 Lights on/data/GenCylinder.lua

 			writer:AddText(GenStringFromArray(normals));
 		writer:PopElement();
 		writer:PushElement("vao");
-			writer:AddAttribute("name", "tint");
+			writer:AddAttribute("name", "lit-color");
 			writer:PushElement("source"); writer:AddAttribute("attrib", "0"); writer:PopElement();
 			writer:PushElement("source"); writer:AddAttribute("attrib", "1"); writer:PopElement();
 			writer:PushElement("source"); writer:AddAttribute("attrib", "2"); writer:PopElement();
 		writer:PopElement();
 		writer:PushElement("vao");
-			writer:AddAttribute("name", "flat");
+			writer:AddAttribute("name", "lit");
 			writer:PushElement("source"); writer:AddAttribute("attrib", "0"); writer:PopElement();
 			writer:PushElement("source"); writer:AddAttribute("attrib", "2"); writer:PopElement();
 		writer:PopElement();
 		writer:PushElement("vao");
-			writer:AddAttribute("name", "tint-unlit");
+			writer:AddAttribute("name", "color");
 			writer:PushElement("source"); writer:AddAttribute("attrib", "0"); writer:PopElement();
 			writer:PushElement("source"); writer:AddAttribute("attrib", "1"); writer:PopElement();
 		writer:PopElement();

Tut 09 Lights on/data/UnitCylinder.xml

         0.91354344291528 0 -0.40674116819729
         0.97814653407707 0 -0.20791670897984
         0.97814653407707 0 -0.20791670897984</attribute>
-	<vao name="tint" >
+	<vao name="lit-color" >
 		<source attrib="0" />
 		<source attrib="1" />
 		<source attrib="2" />
 	</vao>
-	<vao name="flat" >
+	<vao name="lit" >
 		<source attrib="0" />
 		<source attrib="2" />
 	</vao>
-	<vao name="tint-unlit" >
+	<vao name="color" >
 		<source attrib="0" />
 		<source attrib="1" />
 	</vao>

Tut 10 Plane Lights/Fragment Attenuation.cpp

 
 					glUniformMatrix3fv(g_FragVertexDiffuseColor.normalModelToCameraMatrixUnif, 1, GL_FALSE,
 						glm::value_ptr(normMatrix));
-					g_pCylinderMesh->Render("tint");
+					g_pCylinderMesh->Render("lit-color");
 				}
 				else
 				{
 
 					glUniformMatrix3fv(g_FragWhiteDiffuseColor.normalModelToCameraMatrixUnif, 1, GL_FALSE,
 						glm::value_ptr(normMatrix));
-					g_pCylinderMesh->Render("flat");
+					g_pCylinderMesh->Render("lit");
 				}
 				glUseProgram(0);
 			}

Tut 10 Plane Lights/Fragment Point Lighting.cpp

 
 					glUniform3fv(pVertColorProgram->modelSpaceLightPosUnif, 1, glm::value_ptr(lightPosModelSpace));
 
-					g_pCylinderMesh->Render("tint");
+					g_pCylinderMesh->Render("lit-color");
 				}
 				else
 				{
 
 					glUniform3fv(pWhiteProgram->modelSpaceLightPosUnif, 1, glm::value_ptr(lightPosModelSpace));
 
-					g_pCylinderMesh->Render("flat");
+					g_pCylinderMesh->Render("lit");
 				}
 				glUseProgram(0);
 			}

Tut 10 Plane Lights/Vertex Point Lighting.cpp

 					glm::mat3 normMatrix(modelMatrix.Top());
 					glUniformMatrix3fv(g_VertexDiffuseColor.normalModelToCameraMatrixUnif, 1, GL_FALSE,
 						glm::value_ptr(normMatrix));
-					g_pCylinderMesh->Render("tint");
+					g_pCylinderMesh->Render("lit-color");
 				}
 				else
 				{
 					glm::mat3 normMatrix(modelMatrix.Top());
 					glUniformMatrix3fv(g_WhiteDiffuseColor.normalModelToCameraMatrixUnif, 1, GL_FALSE,
 						glm::value_ptr(normMatrix));
-					g_pCylinderMesh->Render("flat");
+					g_pCylinderMesh->Render("lit");
 				}
 				glUseProgram(0);
 			}

Tut 10 Plane Lights/data/GenCylinder.lua

 			writer:AddText(GenStringFromArray(normals));
 		writer:PopElement();
 		writer:PushElement("vao");
-			writer:AddAttribute("name", "tint");
+			writer:AddAttribute("name", "lit-color");
 			writer:PushElement("source"); writer:AddAttribute("attrib", "0"); writer:PopElement();
 			writer:PushElement("source"); writer:AddAttribute("attrib", "1"); writer:PopElement();
 			writer:PushElement("source"); writer:AddAttribute("attrib", "2"); writer:PopElement();
 		writer:PopElement();
 		writer:PushElement("vao");
-			writer:AddAttribute("name", "flat");
+			writer:AddAttribute("name", "lit");
 			writer:PushElement("source"); writer:AddAttribute("attrib", "0"); writer:PopElement();
 			writer:PushElement("source"); writer:AddAttribute("attrib", "2"); writer:PopElement();
 		writer:PopElement();
 		writer:PushElement("vao");
-			writer:AddAttribute("name", "tint-unlit");
+			writer:AddAttribute("name", "color");
 			writer:PushElement("source"); writer:AddAttribute("attrib", "0"); writer:PopElement();
 			writer:PushElement("source"); writer:AddAttribute("attrib", "1"); writer:PopElement();
 		writer:PopElement();

Tut 10 Plane Lights/data/ModelPosVertexLighting_PCN.vert

 layout(location = 1) in vec4 inDiffuseColor;
 layout(location = 2) in vec3 normal;
 
-out vec4 interpColor;
+smooth out vec4 interpColor;
 
 uniform vec3 modelSpaceLightPos;
 uniform vec4 lightIntensity;

Tut 10 Plane Lights/data/ModelPosVertexLighting_PN.vert

 layout(location = 0) in vec3 position;
 layout(location = 2) in vec3 normal;
 
-out vec4 interpColor;
+smooth out vec4 interpColor;
 
 uniform vec3 modelSpaceLightPos;
 uniform vec4 lightIntensity;

Tut 10 Plane Lights/data/UnitCylinder.xml

         0.91354344291528 0 -0.40674116819729
         0.97814653407707 0 -0.20791670897984
         0.97814653407707 0 -0.20791670897984</attribute>
-	<vao name="tint" >
+	<vao name="lit-color" >
 		<source attrib="0" />
 		<source attrib="1" />
 		<source attrib="2" />
 	</vao>
-	<vao name="flat" >
+	<vao name="lit" >
 		<source attrib="0" />
 		<source attrib="2" />
 	</vao>
-	<vao name="tint-unlit" >
+	<vao name="color" >
 		<source attrib="0" />
 		<source attrib="1" />
 	</vao>

Tut 11 Shinies/Blinn vs Phong Lighting.cpp

 					glm::value_ptr(normMatrix));
 
 				if(g_bDrawColoredCyl)
-					g_pCylinderMesh->Render("tint");
+					g_pCylinderMesh->Render("lit-color");
 				else
-					g_pCylinderMesh->Render("flat");
+					g_pCylinderMesh->Render("lit");
 
 				glUseProgram(0);
 			}

Tut 11 Shinies/Gaussian Specular Lighting.cpp

 					glm::value_ptr(normMatrix));
 
 				if(g_bDrawColoredCyl)
-					g_pCylinderMesh->Render("tint");
+					g_pCylinderMesh->Render("lit-color");
 				else
-					g_pCylinderMesh->Render("flat");
+					g_pCylinderMesh->Render("lit");
 
 				glUseProgram(0);
 			}

Tut 11 Shinies/Phong Lighting.cpp

 					glm::value_ptr(normMatrix));
 
 				if(g_bDrawColoredCyl)
-					g_pCylinderMesh->Render("tint");
+					g_pCylinderMesh->Render("lit-color");
 				else
-					g_pCylinderMesh->Render("flat");
+					g_pCylinderMesh->Render("lit");
 
 				glUseProgram(0);
 			}

Tut 11 Shinies/data/GenCylinder.lua

 			writer:AddText(GenStringFromArray(normals));
 		writer:PopElement();
 		writer:PushElement("vao");
-			writer:AddAttribute("name", "tint");
+			writer:AddAttribute("name", "lit-color");
 			writer:PushElement("source"); writer:AddAttribute("attrib", "0"); writer:PopElement();
 			writer:PushElement("source"); writer:AddAttribute("attrib", "1"); writer:PopElement();
 			writer:PushElement("source"); writer:AddAttribute("attrib", "2"); writer:PopElement();
 		writer:PopElement();
 		writer:PushElement("vao");
-			writer:AddAttribute("name", "flat");
+			writer:AddAttribute("name", "lit");
 			writer:PushElement("source"); writer:AddAttribute("attrib", "0"); writer:PopElement();
 			writer:PushElement("source"); writer:AddAttribute("attrib", "2"); writer:PopElement();
 		writer:PopElement();
 		writer:PushElement("vao");
-			writer:AddAttribute("name", "tint-unlit");
+			writer:AddAttribute("name", "color");
 			writer:PushElement("source"); writer:AddAttribute("attrib", "0"); writer:PopElement();
 			writer:PushElement("source"); writer:AddAttribute("attrib", "1"); writer:PopElement();
 		writer:PopElement();

Tut 11 Shinies/data/UnitCylinder.xml

         0.91354344291528 0 -0.40674116819729
         0.97814653407707 0 -0.20791670897984
         0.97814653407707 0 -0.20791670897984</attribute>
-	<vao name="tint" >
+	<vao name="lit-color" >
 		<source attrib="0" />
 		<source attrib="1" />
 		<source attrib="2" />
 	</vao>
-	<vao name="flat" >
+	<vao name="lit" >
 		<source attrib="0" />
 		<source attrib="2" />
 	</vao>
-	<vao name="tint-unlit" >
+	<vao name="color" >
 		<source attrib="0" />
 		<source attrib="1" />
 	</vao>
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.