精华内容
下载资源
问答
  • Vertex1.2.10安装包

    2021-02-23 13:54:35
    Vertex1.2.10安装包
  • VERTEX MINI / MINI + VERTEX MINI MINI / MINI +是基于PRUSA RESEARCH的3D打印机项目,由VERTEX3D.ORG维护。起源于RepRap项目。 该存储库包含有关打印机的印刷和机械部件的资源和文档。 链接 VERTEX3D网站: ://...
  • Vertex Shader

    2019-04-19 12:45:46
    Vertex Shader

    首先给大家分享一个巨牛巨牛的人工智能教程,是我无意中发现的。教程不仅零基础,通俗易懂,而且非常风趣幽默,还时不时有内涵段子,像看小说一样,哈哈~我正在学习中,觉得太牛了,所以分享给大家!点这里可以跳转到教程

                   

    一、Vertex Shader简介

           前面一直有出现Vertex Shader,但Vertex Shader一直犹抱琵琶半遮面的感觉,本文将彻底揭开其面纱,看个清清楚楚、明明白折,以满足自己的好奇心。Vertex Shader在OpenGL ES 2.0的管道中的位置如下图所示:

           本节将描述以下内容:

           1)Vertex Shader的输入和输出

           2)Vertex Shader的可移植性问题

           3)Vertex Shader的例子

    二、Vertex Shader的输入/输出和操作对象

           Vertex Shader的操作对象是“顶点”。其输入/输出如下图所示:


         Vertex Shader输入:

         • Attributes:通过Vertex Arrays提供的每个顶点的数据
         • Uniforms:由Vertex Shader使用的常量数据

         Vertex Shader程序
         • Shader program:Vertex Shader的可执行程序,它描述将在顶点上执行的操作

         Vertex Shader输出:

         • varying变量:Vertex Shader的输出叫做varying变量,它有以下两个用处:

           1)用于计算产生fragment

           2)作为Fragment Shader的输入

    三、Vertex Shader的内嵌变量

           它包括以下几种内嵌变量:

            • 特别变量:被Vertex Shader作为输出

            • uniform状态:如深度范围

            • 指定最大值的常量:如attribute个数、varying个数、uniforms个数

    1. 特殊变量(Built-In Special Variables)

            它作为Vertex Shader的输出、且作为Fragment Shader的输入,可用特别变量如下:

            • gl_Position:它以裁剪坐标的方式输出“顶点位置”,且是一个highp变量。 

            • gl_PointSize:它以像素为单位输出“点的大小”,其值被限制在OpenGL ES 2.0可实现的范围内,且是一个mediump变量。

            • gl_FrontFacing:它不直接由Vertex Shader写,是一个boolean变量。

    2. Uniform状态变量(Built-In Uniform State)

           • gl_DepthRange:是Vertex Shader中唯一的一个Uniform状态变量,它以窗口坐标来表示深度范围。其数据类型如下:   

           struct gl_DepthRangeParameters {
                     highp float near; // near Z
                     highp float far; // far Z
                     highp float diff; // far - near
           } 

           uniform gl_DepthRangeParameters gl_DepthRange;

     3. 常量(Built-In Constants)

           Vertex Shader中指定最大值的常量如下:

           const mediump int gl_MaxVertexAttribs = 8;
           const mediump int gl_MaxVertexUniformVectors = 128;
           const mediump int gl_MaxVaryingVectors = 8;
           const mediump int gl_MaxVertexTextureImageUnits = 0;
           const mediump int gl_MaxCombinedTextureImageUnits = 8;

           1)gl_MaxVertexAttribs

                指示支持的Vertex Attribute的最大值,其值最小为8。

           2)gl_MaxVertexUniformVectors

                指示Vertex Shader最多支持多少个vec4 uniform,其值最小为128。

           3)gl_MaxVaryingVectors

                 Vertex Shader最多可以输出多少个vec4变量,其值最小为8。

           4)gl_MaxVertexTextureImageUnits

                Vertex Shader最多支持多少个纹理单元,其值最小为0,即不支持顶点纹理获取。

           5)gl_MaxCombinedTextureImageUnits

                Vertex Shader和Fragment Shader总共最多支持多少个纹理单元,其值最小为8。

           在具体的硬件平台上,可通过以下代码获取当前可支持的最大值:       

        GLint maxVertexAttribs, maxVertexUniforms, maxVaryings;    GLint maxVertexTextureUnits, maxCombinedTextureUnits;    glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &maxVertexAttribs);    glGetIntegerv(GL_MAX_VERTEX_UNIFORM_VECTORS, &maxVertexUniforms);    glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);    glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS,&maxVertexTextureUnits);    glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS,&maxCombinedTextureUnits);

            4. 精度限制 (Precision Qualifiers)

                在Vertex Shader中,如果没有指定默认的精度,则float和int的精度为highp。在Vertex Shader中,除color和lighting计算为mediump之外,其它的都为highp。

    四、OpenGL ES 2.0 Vertex Shader限制

           为了让Shader Source可以大部分平台上进行运行(即可移植性好),需要参加以下限制。

           1. Vertex Shader长度

               目前没有办法获得具体平台可支持的最大指令数,但如果Shader source超过其限制,则编译会失败。

           2. 临时变量(函数内局部变量)的个数

               也没有指定最大数,但如果Shader source超过其限制,则编译会失败。

           3. 流程控制

               • 对于for循环,有以下限制:

               1)只能有一个循环变量

               2)循环变量必须被常量表达式初始化

               3)条件判断必须为下面的一种:

            loop_indx < constant_expression        loop_indx <= constant_expression        loop_indx > constant_expression        loop_indx >= constant_expression        loop_indx != constant_expression        loop_indx == constant_expression

               4)循环变量必须通过以下方式来进行修改,且只能在循环表达式内部修改,不能在循环体内修改

            loop_index--        loop_index++        loop_index -= constant_expression        loop_index += constant_expression

               5)循环变量在循环体内部,只能做为函数的只读参数。
               注:while和do-while循环不支持。

               • 对于if-else判断语句,其条件判断bool_expression必须为scalar boolean value。

     

     

     

     

     

               

                      

               

    浏览人工智能教程

    展开全文
  • 欢迎使用Vertex Web SDK存储库。 这是包含用于Web平台的SDK的monorepo。 配套 包裹 版本 描述 2D / 3D几何实用程序。 用于流式传输3D图像的API客户端。 Vertex中使用的常规节点和Web实用程序。 Web SDK包含用于...
  • Vertex Blending

    2009-10-14 10:25:57
    精通DirectX 3D 程序与动画设计>>顶点混合例子源码,Vertex Blending
  • vertex-icons, 与Vertex主题匹配的Gnome icon 主题 顶点图标( 测试版)注意:这是一个未完成的测试版。 在某些情况下,它可能无法正常工作。顶点 icon 主题被设计成与顶点Gtk主题很好地结合在一起。 目前它主要包括...
  • Vertex Cover

    2017-08-19 17:08:42
    Vertex Cover Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 256000/256000 K (Java/Others) Total Submission(s): 0 Accepted Submission(s): 0 Special Judge Problem Description As we kn

    Vertex Cover

    Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 256000/256000 K (Java/Others)
    Total Submission(s): 0    Accepted Submission(s): 0
    Special Judge


    Problem Description
    As we know, minimumvertexcover is a classical NP-complete problem. There will not be polynomial time algorithm for it unless P=NP .

    You can see the definition of vertex cover in https://en.wikipedia.org/wiki/Vertex_cover.

    Today, little M designs an "approximate" algorithm for vertex cover. It is a greedy algorithm. The main idea of her algorithm is that always choosing the maximum degree vertex into the solution set. The pseudo code of her algorithm is as follows:

    We assume that the labels of the vertices are from 1 to n.
    for (int i = 1; i <= n; ++i) {
      use[i] = false;
        deg[i] = degree of the vertex i;
    }
    int ans = 0;
    while (true) {
      int mx = -1, u;
        for (int i = 1; i <= n; ++i) {
          if (use[i])
              continue;
            if (deg[i] >= mx) {
              mx = deg[i];
                u = i;
            }
        }
        if (mx <= 0)
          break;
        ++ans;
        use[u] = true;
        for (each vertex v adjacent to u)
          --deg[v];
    }
    return ans;
    


    As a theory computer scientist, you immediately find that it is a bad algorithm. To show her that this algorithm dose not have a constant approximate factor, you need to construct an instance of vertex cover such that the solution get by this algorithm is much worse than the optimal solution.

    Formally, your program need to output a simple undirected graph of at most 500 vertices. Moreover, you need to output a vertex cover solution of your graph. Your program will get Accept if and only if the solution size get by the above algorithm is at least three times as much as yours.
     

    Input
    There is no input.
     

    Output
    First, output two integer n and m in a line, separated by a space, means the number of the vertices and the number of the edges in your graph.
    In the next m lines, you should output two integers u and v for each line, separated by a space, which denotes an edge of your graph. It must be satisfied that 1u,vn and your graph is a simple undirected graph.
    In the next line, output an integer k(1kn) , means the size of your vertex cover solution.
    Then output k lines, each line contains an integer u(1un) which denotes the label of a vertex in your solution. It must be satisfied that your solution is a vertex cover of your graph.
     

    Sample Output
      
    4 4 1 2 2 3 3 4 4 1 2 1 3
    Hint
    The sample output is just to exemplify the output format.
    展开全文
  • VertexShader深入探讨

    2014-02-22 15:27:28
    DirectX 3D HLSL高级实例精讲_VertexShader深入探讨
  • Approximating the minimum weight weak vertex cover
  • Vertex-distinguishing total coloring of mC5
  • Vertex Atrributes

    2015-06-24 08:54:04
    一、Vertex Attributes简介  Vertex属性即顶点数据,它指定了每个顶点的各种属性数据。在OpenGL ES1.1中,顶点属性有四个预定义的名字:position(位置), normal(法线), color(颜色), 和 texture ...

    一、Vertex Attributes简介

           Vertex属性即顶点数据,它指定了每个顶点的各种属性数据。在OpenGL ES1.1中,顶点属性有四个预定义的名字:position(位置), normal(法线), color(颜色), 和 texture coordinates(纹理坐标)。在OpenGL ES2.0中,用户必须定义“顶点属性的名字”

    二、常量顶点属性(Constant Vertex Attribute)

         常量顶点属性对所有顶点都是一样的。因此只需要指定一个值就可以应用于所有顶点。一般很少使用。其设置函数有:

     

      

    [cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
    1. void glVertexAttrib1f(GLuint index, GLfloat x);  
    2. void glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y);  
    3. void glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z);  
    4. void glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z,GLfloat w);  
    5. void glVertexAttrib1fv(GLuint index, const GLfloat *values);  
    6. void glVertexAttrib2fv(GLuint index, const GLfloat *values);  
    7. void glVertexAttrib3fv(GLuint index, const GLfloat *values);  
    8. void glVertexAttrib4fv(GLuint index, const GLfloat *values);  

     

    三、 如何装载顶点数据?(Vertex Arrays)

           Vertex Array(顶点数组):是一个存储在应用程序空间(Client)中的内存buffer,它存储了每个顶点的属性数据。    

           如何把顶点数据组的数据传递给GPU呢?

            void glVertexAttribPointer(GLuint index,

                                                    GLint size,     //每个属性元素个数有效值1-4(x,y,z,w)
                                                    GLenum type,
                                                    GLboolean normalized,
                                                    GLsizei stride, //如果数据连续存放,则为0
                                                    const void *ptr)  //顶点数组指针

           举例如下:

     

    [cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
    1. GLfloat vVertices[] = {  0.0f,  0.5f, 0.0f,   
    2.                         -0.5f, -0.5f, 0.0f,  
    3.                          0.5f, -0.5f, 0.0f };  
    4.      
    5. // Set the viewport  
    6. glViewport ( 0, 0, esContext->width, esContext->height );  
    7.   
    8. // Clear the color buffer  
    9. glClear ( GL_COLOR_BUFFER_BIT );  
    10.   
    11. // Use the program object  
    12. glUseProgram (programObject );  
    13.   
    14. // Load the vertex data  
    15. glVertexAttribPointer ( 0, 3, GL_FLOAT, GL_FALSE, 0, vVertices );  

     

    四、顶点属性数据存储方式

    1.一个顶点的所有属性存储在一起(Array of Structures)

           如下图所示,顶点的位置(x,y,z)、法线(x,y,z)和两个纹理坐标(s,t)存储在一起,如下图所示:

    例子代码如下(当然,此代码在CPU上运动):

    [cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
    1. #define VERTEX_POS_SIZE         3 // x, y and z  
    2. #define VERTEX_NORMAL_SIZE      3 // x, y and z  
    3. #define VERTEX_TEXCOORD0_SIZE   2 // s and t  
    4. #define VERTEX_TEXCOORD1_SIZE   2 // s and t  
    5.   
    6. #define VERTEX_POS_INDX         0  
    7. #define VERTEX_NORMAL_INDX      1  
    8. #define VERTEX_TEXCOORD0_INDX   2  
    9. #define VERTEX_TEXCOORD1_INDX   3  
    10.   
    11. // the following 4 defines are used to determine location of various  
    12. // attributes if vertex data is are stored as an array of structures  
    13. #define VERTEX_POS_OFFSET       0  
    14. #define VERTEX_NORMAL_OFFSET    3  
    15. #define VERTEX_TEXCOORD0_OFFSET 6  
    16. #define VERTEX_TEXCOORD1_OFFSET 8  
    17.   
    18. #define VERTEX_ATTRIB_SIZE  VERTEX_POS_SIZE + \  
    19.                             VERTEX_NORMAL_SIZE + \  
    20.                             VERTEX_TEXCOORD0_SIZE + \  
    21.                             VERTEX_TEXCOORD1_SIZE  
    22.                               
    23. float *p = malloc(numVertices * VERTEX_ATTRIB_SIZE  
    24.                   * sizeof(float));  
    25.   
    26. // position is vertex attribute 0  
    27. glVertexAttribPointer(VERTEX_POS_INDX, VERTEX_POS_SIZE,  
    28.                       GL_FLOAT, GL_FALSE,  
    29.                       VERTEX_ATTRIB_SIZE * sizeof(float),  
    30.                       p+VERTEX_POS_OFFSET);  
    31.   
    32. // normal is vertex attribute 1  
    33. glVertexAttribPointer(VERTEX_NORMAL_INDX, VERTEX_NORMAL_SIZE,  
    34.                       GL_FLOAT, GL_FALSE,  
    35.                       VERTEX_ATTRIB_SIZE * sizeof(float),  
    36.                       (p + VERTEX_NORMAL_OFFSET));  
    37.   
    38. // texture coordinate 0 is vertex attribute 2  
    39. glVertexAttribPointer(VERTEX_TEXCOORD0_INDX, VERTEX_TEXCOORD0_SIZE,  
    40.                       GL_FLOAT, GL_FALSE,  
    41.                       VERTEX_ATTRIB_SIZE * sizeof(float),  
    42.                       (p + VERTEX_TEXCOORD0_OFFSET));  
    43.   
    44. // texture coordinate 1 is vertex attribute 3  
    45. glVertexAttribPointer(VERTEX_TEXCOORD1_INDX, VERTEX_TEXCOORD1_SIZE,  
    46.                       GL_FLOAT, GL_FALSE,  
    47.                       VERTEX_ATTRIB_SIZE * sizeof(float),  
    48.                       (p + VERTEX_TEXCOORD1_OFFSET));  


    2. 顶点的每个属性单独存储(Structure of Arrays)

    例子代码如下(当然,此代码在CPU上运动):

    [cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
    1. #define VERTEX_POS_SIZE         3 // x, y and z  
    2. #define VERTEX_NORMAL_SIZE      3 // x, y and z  
    3. #define VERTEX_TEXCOORD0_SIZE   2 // s and t  
    4. #define VERTEX_TEXCOORD1_SIZE   2 // s and t  
    5.   
    6. #define VERTEX_POS_INDX         0  
    7. #define VERTEX_NORMAL_INDX      1  
    8. #define VERTEX_TEXCOORD0_INDX   2  
    9. #define VERTEX_TEXCOORD1_INDX   3  
    10.   
    11.   
    12. #define VERTEX_ATTRIB_SIZE  VERTEX_POS_SIZE + \  
    13.                             VERTEX_NORMAL_SIZE + \  
    14.                             VERTEX_TEXCOORD0_SIZE + \  
    15.                             VERTEX_TEXCOORD1_SIZE  
    16.                               
    17. float *position  = malloc(numVertices * VERTEX_POS_SIZE *  
    18.                           sizeof(float));  
    19. float *normal    = malloc(numVertices * VERTEX_NORMAL_SIZE *  
    20.                           sizeof(float));  
    21. float *texcoord0 = malloc(numVertices * VERTEX_TEXCOORD0_SIZE *  
    22.                           sizeof(float));  
    23. float *texcoord1 = malloc(numVertices * VERTEX_TEXCOORD1_SIZE *  
    24.                           sizeof(float));  
    25.   
    26. // position is vertex attribute 0  
    27. glVertexAttribPointer(VERTEX_POS_INDX, VERTEX_POS_SIZE,  
    28.                       GL_FLOAT, GL_FALSE,  
    29.                       VERTEX_POS_SIZE * sizeof(float), position);  
    30.   
    31. // normal is vertex attribute 1  
    32. glVertexAttribPointer(VERTEX_NORMAL_INDX, VERTEX_NORMAL_SIZE,  
    33.                       GL_FLOAT, GL_FALSE,  
    34.                       VERTEX_NORMAL_SIZE * sizeof(float), normal);  
    35.   
    36. // texture coordinate 0 is vertex attribute 2  
    37. glVertexAttribPointer(VERTEX_TEXCOORD0_INDX, VERTEX_TEXCOORD0_SIZE,  
    38.                       GL_FLOAT, GL_FALSE, VERTEX_TEXCOORD0_SIZE *  
    39.                       sizeof(float), texcoord0);  
    40.   
    41. // texture coordinate 1 is vertex attribute 3  
    42. glVertexAttribPointer(VERTEX_TEXCOORD1_INDX, VERTEX_TEXCOORD1_SIZE,  
    43.                       GL_FLOAT, GL_FALSE,  
    44.                       VERTEX_TEXCOORD1_SIZE * sizeof(float),  //也可为0,因为数据是紧接着存放的  
    45.                       texcoord1);  


    3. 哪种顶点属性数据存储方式在GPU上性能更好?

           答案是:把一个顶点的所有属性放在一起(array of structures)。其原因是每个顶点的属性数据以连续的方式读取,使内存访问效率更高。其缺点是,如果要修改其中部分属性数据,将导致整个属性buffer全部重新装载,解决此问题的方法是把这些需要动态修改的属性数据放在单独的buffer中。

    五、 顶点属性数据类型优化

           顶点属性数据类型不会影响在GPU上每个顶点占用的内存,但在Render a Frame时,它影响CPU与GPU之间的内存带宽。推荐尽量使用GL_HALF_FLOAT_OES。

    六、glVertexAttribPointer中的归一化参数

           如果normalized为GL_FALSE:则直接把数据转换为GLfloat,因为Vertex Shader内部把顶点属性当作GLfloat(32位)来进行存储。

           GL_BYTE, GL_SHORT or GL_FIXED被归一化为[-1,1];GL_UNSIGNED_BYTE or GL_UNSIGNED_SHORT被归一化为[0.0,1.0]。具体转换公式为:

     

     

    七、选择常量或顶点数组Vertex Attribute

    可通过以下函数来Enable或Disable顶点数组(Vertex Array)。

    void glEnableVertexAttribArray(GLuint index);
    void glDisableVertexAttribArray(GLuint index);

    其关系如下图所示:

     八、申明attribute变量(在Vertex Shader中)

          Attribute变量的数据类型只能为:float, vec2,vec3, vec4, mat2, mat3, and mat4;Attribute变量不能为数组或结构。如下面的申明是错误的:        

    [cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
    1. attribute foo_t a_A; // foo_t is a structure  
    2. attribute vec4 a_B[10];  

         每个GPU支持GL_MAX_VERTEX_ATTRIBS vec4。float、vec2和vec3也被当作一个vec4来进行存储;mat2、mat3、mat4被分别当作2、3、和4个vec4来进行存储。

    九、把“顶点属性索引”绑定到“顶点属性名”

           把“顶点属性索引”绑定到“顶点属性名”有以下两个方法:

           1)OpenGL ES 2.0把“顶点属性索引”绑定到“顶点属性名”,当link program时,OpengGL ES 2.0执行此绑定。然后应用程序通过glGetAttribLocation(失败时返回-1)获取“顶点属性索引”。

    [html]  view plain copy 在CODE上查看代码片 派生到我的代码片
    1. GLint glGetAttribLocation(GLuint program, const GLchar *name)  

     

           2)应用程序通过glBindAttribLocation把“顶点属性索引”绑定到“顶点属性名”,glBindAttribLocation在program被link之前执行。

    [cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
    1. void glBindAttribLocation(GLuint program, GLuint index,const GLchar *name)  

           在link program时,OpenGL ES 2.0对每个顶点属性执行如下操作:

            (1)首先检查属性变量是否被通过glBindAttribLocation绑定了属性索引,如果是,则使用此绑定的属性索引;否则,为之分配一个属性索引

                 在应用程序中,一般使用函数glBindAttribLocation来绑定每个attribute变量的位置,然后用函数glVertexAttribPointer为每个attribute变量赋值。

    十、顶点buffer对象(Vertex Buffer Objects)

           顶点数组(Vertex Array)被保存在客户端内存,当执行glDrawArrays 或 glDrawElements时,才把它们从客户端内存copy到图形内存。这样占用了大量的内存带宽,Vertex Buffer Objects允许OpengGL ES2.0应用在高性能的图形内存中分配并cache顶点数据,然后从此图形内存中执行render,这样避免了每次画一个原语都要重发送数据。

           Vertex Buffer Objects有以下两种类型:

           (1)array buffer objects:通过GL_ARRAY_BUFFER标记创建,并存储vertex data。

           (2)element array buffer objects:通过GL_ELEMENT_ARRAY_BUFFER标记创建,并存储indices of a primitive。

           创建和绑定Vertex Buffer Objects例子代码如下:

    [html]  view plain copy 在CODE上查看代码片 派生到我的代码片
    1. void initVertexBufferObjects(vertex_t *vertexBuffer,  
    2.                              GLushort *indices,  
    3.                              GLuint numVertices, GLuint numIndices  
    4.                              GLuint *vboIds)  
    5. {  
    6.    glGenBuffers(2, vboIds);  
    7.    glBindBuffer(GL_ARRAY_BUFFER, vboIds[0]);  
    8.    glBufferData(GL_ARRAY_BUFFER, numVertices * sizeof(vertex_t),  
    9.                 vertexBuffer, GL_STATIC_DRAW); //save vertex attribute data  
    10.    // bind buffer object for element indices  
    11.    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vboIds[1]);  
    12.    glBufferData(GL_ELEMENT_ARRAY_BUFFER,  
    13.                 numIndices * sizeof(GLushort),indices,  
    14.                 GL_STATIC_DRAW); // save element indices that make up the primitive  
    15. }  

    有无Vertex Buffer Object画图例子: 

    [html]  view plain copy 在CODE上查看代码片 派生到我的代码片
    1. #define VERTEX_POS_SIZE 3 // x, y and z  
    2. #define VERTEX_NORMAL_SIZE 3 // x, y and z  
    3. #define VERTEX_TEXCOORD0_SIZE 2 // s and t  
    4. #define VERTEX_POS_INDX 0  
    5. #define VERTEX_NORMAL_INDX 1  
    6. #define VERTEX_TEXCOORD0_INDX 2  
    7. //  
    8. // vertices – pointer to a buffer that contains vertex attribute  
    9. data  
    10. // vtxStride – stride of attribute data / vertex in bytes  
    11. // numIndices – number of indices that make up primitive  
    12. // drawn as triangles  
    13. // indices - pointer to element index buffer.  
    14. //  
    15. void drawPrimitiveWithoutVBOs(GLfloat *vertices, GLint vtxStride,  
    16.                               GLint numIndices, GLushort *indices)  
    17. {  
    18.    GLfloat *vtxBuf = vertices;  
    19.    glBindBuffer(GL_ARRAY_BUFFER, 0);  
    20.    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);  
    21.    glEnableVertexAttribArray(VERTEX_POS_INDX);  
    22.    glEnableVertexAttribArray(VERTEX_NORMAL_INDX);  
    23.    glEnableVertexAttribArray{VERTEX_TEXCOORD0_INDX);  
    24.    glVertexAttribPointer(VERTEX_POS_INDX, VERTEX_POS_SIZE,  
    25.                          GL_FLOAT, GL_FALSE, vtxStride, vtxBuf);  
    26.    vtxBuf += VERTEX_POS_SIZE;  
    27.    glVertexAttribPointer(VERTEX_NORMAL_INDX, VERTEX_NORMAL_SIZE,  
    28.                          GL_FLOAT, GL_FALSE, vtxStride, vtxBuf);  
    29.    vtxBuf += VERTEX_NORMAL_SIZE;  
    30.    glVertexAttribPointer(VERTEX_TEXCOORD0_INDX,  
    31.                          VERTEX_TEXCOORD0_SIZE, GL_FLOAT,  
    32.                          GL_FALSE, vtxStride, vtxBuf);  
    33.    glBindAttribLocation(program, VERTEX_POS_INDX, "v_position");  
    34.    glBindAttribLocation(program, VERTEX_NORMAL_INDX, "v_normal");  
    35.    glBindAttribLocation(program, VERTEX_TEXCOORD0_INDX,"v_texcoord");  
    36.    glDrawElements(GL_TRIANGLES, numIndices, GL_UNSIGNED_SHORT,indices);  
    37. }  


     

    [html]  view plain copy 在CODE上查看代码片 派生到我的代码片
    1. void drawPrimitiveWithVBOs(GLint numVertices, GLfloat *vtxBuf,  
    2.                            GLint vtxStride, GLint numIndices,  
    3.                            GLushort *indices)  
    4. {  
    5.    GLuint offset = 0;  
    6.    GLuint vboIds[2];  
    7.    // vboIds[0] – used to store vertex attribute data  
    8.    // vboIds[1] – used to store element indices  
    9.    glGenBuffers(2, vboIds);  
    10.    glBindBuffer(GL_ARRAY_BUFFER, vboIds[0]);  
    11.    glBufferData(GL_ARRAY_BUFFER, vtxStride * numVertices,  
    12.                 vtxBuf, GL_STATIC_DRAW);  
    13.    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vboIds[1]);  
    14.    glBufferData(GL_ELEMENT_ARRAY_BUFFER,  
    15.                 sizeof(GLushort) * numIndices,  
    16.                 indices, GL_STATIC_DRAW);  
    17.    glEnableVertexAttribArray(VERTEX_POS_INDX);  
    18.    glEnableVertexAttribArray(VERTEX_NORMAL_INDX);  
    19.    glEnableVertexAttribArray{VERTEX_TEXCOORD0_INDX);  
    20.    glVertexAttribPointer(VERTEX_POS_INDX, VERTEX_POS_SIZE,  
    21.                          GL_FLOAT, GL_FALSE, vtxStride,  
    22.                          (const void*)offset);  
    23.    offset += VERTEX_POS_SIZE * sizeof(GLfloat);  
    24.    glVertexAttribPointer(VERTEX_NORMAL_INDX, VERTEX_NORMAL_SIZE,  
    25.                          GL_FLOAT, GL_FALSE, vtxStride,  
    26.                          (const void*)offset);  
    27.    offset += VERTEX_NORMAL_SIZE * sizeof(GLfloat);  
    28.    glVertexAttribPointer(VERTEX_TEXCOORD0_INDX,  
    29.                          VERTEX_TEXCOORD0_SIZE,  
    30.                          GL_FLOAT, GL_FALSE, vtxStride,  
    31.                          (const void*)offset);  
    32.    glBindAttribLocation(program, VERTEX_POS_INDX, "v_position");  
    33.    glBindAttribLocation(program, VERTEX_NORMAL_INDX, "v_normal");  
    34.    glBindAttribLocation(program, VERTEX_TEXCOORD0_INDX,"v_texcoord");  
    35.    glDrawElements(GL_TRIANGLES, numIndices, GL_UNSIGNED_SHORT, 0);  
    36.    glDeleteBuffers(2, vboIds);  
    37. }  
    展开全文
  • VertexShader入门

    千次阅读 2017-08-21 09:41:43
    VertexShader入门 Shader与固定管线 顶点着色(Vertex Shader)是一段执行在GPU上的程序(一般用HLSL来编写),用来取代fixed pipeline中的transformation和lighting,Vertex Shader主要操作顶点。 有图则...

    VertexShader入门

    Shader与固定管线

    顶点着色(Vertex Shader)是一段执行在GPU上的程序(一般用HLSL来编写),用来取代fixed pipeline中的transformation和lighting,Vertex Shader主要操作顶点。

    有图则一目了然。

    Vertex Shader做了什么工作

    由上图知,Vertex Shader对输入顶点完成了从local space到homogeneous clip space的变换过程,homogeneous clip space即projection space的下一个space。在这其间共有world transformation, view transformation和projection transformation及lighting几个过程。

    优点(与fixed pipeline比较)

    由于Vertex Shader是用户自定义程序,所以有很大的灵活性,不必再局限于D3D固定的算法,可以应用许多其他算法,比如可以操作顶点位置模拟衣服效果,操作顶点大小模拟例子系统及顶点混合,变形等,此外,顶点的数据结构也更加灵活。

    Shader代码文件

    Shader代码可以用纯文本文件来保存,比如记事本文件。我们来看一个最简单的Shader文件,该文件完成的功能是,将顶点由Local Space变换到Homogeneous Space,编辑Shader文件可以用DirectX的Effect Edit,不过新版SDK中没有这个工具了,另外显卡厂商也有自己的编辑器,NVIDIA 有FX Composer,ATI有Render Monkey。

    复制代码
         
    // World, View and Projection Matrix uniform extern float4x4 gWVP; // Output Vertex structure struct OutputVS { float4 posH : POSITION0; }; OutputVS Main(float3 posL : POSITION0) { // Zero out our output. OutputVS outVS = (OutputVS) 0 ; // Transform to homogeneous clip space. outVS.posH = mul(float4(posL, 1.0f ), gWVP); // Done--return the output. return outVS; }
    复制代码

    简单解释一下上述代码

    第一行定义了一个全局变量gWVP,这个变量的命名是有规则的,g表示global,即全局变量,W表示World,V表示View,P表示Projection,也就是说这是World,View和Projection矩阵的乘积。但是在程序中我们并没有用到World矩阵,所以实际上就是View矩阵和Projection矩阵的乘积。uniform表示这是个常量,也就是在Shader执行的过程中这个量是不能改变的,extern表示这是一个外部输入量,全局变量默认就是uniform extern的。

    接下来的Struct定义了顶点的输出格式,所谓输出就是有VertexShader操作完以后,顶点以何种方式呈现给下一级处理器(一般是Pixel Shader)。这里的输出格式很简单,只包含一个信息,就是顶点的位置。

    最后的Main函数就是主要的处理过程,需要注意的是这个函数的名字要和程序中指定的名字保持一致,否则编译会失败。首先定义一个输出结构并清零,然后就是顶点变换,使用mul函数将顶点从Local Space变换到 Homogeneous Space。注意输入顶点是三维的,而齐次坐标是四维的,所以需要转换一下。

    如何使用Shader

    有了上面的Shader文件,我们就可以在程序中使用它了,下面将以逐步添加代码的方式讲述如何使用Shader文件,为了简化程序,我们将着重讲述有关Shader的代码,其他代码简单带过。

    1.定义一个VertexShader指针,该指针可以用来用来保存编译后的Shader

        
    IDirect3DVertexShader9 * g_pVertexShader = NULL ; // vertex shader

    2. 定义一个常量表指针,常量表用来保存Shader文件中的变量,这些变量是Shader文件与C++ code通讯的媒介,比如我们要设置某些渲染状态,那么首先要通过程序修改这些变量,然后Shader文件读取这些变量就可以得到修改后的值。

        
    ID3DXConstantTable * g_pConstantTable = NULL ; // shader constant table

    3. 定义一个函数PrepareVertexShader,该函数用来编译Shader文件并做一些必要的设置,这个函数主要做两件事,一是从编译Shader文件,二是在编译完成后创建相应的Shader,每个步骤后面都有对应的错误处理,如果编译有错误,则输出错误信息,如果创建Shader失败也通知用户。当创建完Shader以后,就释放codeBuffer和errorBuffer。

    复制代码
         
    bool PrepareShader() { // Buffer to hold the compiled code ID3DXBuffer * codeBuffer = NULL; // Buffer to hold the error message if complile failed ID3DXBuffer * errorBuffer = NULL; // Compile shader from file HRESULT hr = D3DXCompileShaderFromFileA( " vertexshader.txt " , 0 , 0 , " Main " , " vs_1_1 " , D3DXSHADER_ENABLE_BACKWARDS_COMPATIBILITY, & codeBuffer, & errorBuffer, & g_pConstantTable) ; // output any error messages if ( errorBuffer ) { MessageBoxA( 0 , ( char * )errorBuffer -> GetBufferPointer(), 0 , 0 ); errorBuffer -> Release() ; return false ; } if (FAILED(hr)) { MessageBox( 0 , L " D3DXCompileShaderFromFile() - FAILED " , 0 , 0 ); return false ; } // Create vertex shader hr = g_pd3dDevice -> CreateVertexShader((DWORD * )codeBuffer -> GetBufferPointer(), & g_pVertexShader) ; // handling error if (FAILED(hr)) { MessageBox( 0 , L " CreateVertexShader - FAILED " , 0 , 0 ); return false ; } // Release code buffer if (codeBuffer != NULL) { codeBuffer -> Release() ; codeBuffer = NULL ; } // Release DX buffer if (errorBuffer != NULL) { errorBuffer -> Release() ; errorBuffer = NULL ; } // Set handle ViewProjMatrixHanle = g_pConstantTable -> GetConstantByName( 0 , " gWVP " ) ; return true ; }
    复制代码

    4. 设置View Matrix和Projection Matrix。

    单独定义一个函数用来设置矩阵,然后对View Matrix和Projection Matrix做乘积,最后通过常量表将乘积矩阵传递给Shader。Shader中通过这个矩阵来变换顶点,这就是本文的核心了。

    代码

    5 渲染,在Render函数中设置VertexShader,然后就可以渲染了。

    复制代码
         
    VOID Render() { // Clear the back-buffer to a red color g_pd3dDevice -> Clear( 0 , NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB( 0 , 0 , 0 ), 1.0f , 0 ); // Begin the scene if ( SUCCEEDED( g_pd3dDevice -> BeginScene() ) ) { // Set Vertex Shader g_pd3dDevice -> SetVertexShader(g_pVertexShader) ; // Render teapot g_pMesh -> DrawSubset( 0 ) ; // End the scene g_pd3dDevice -> EndScene(); } // Present the back-buffer contents to the display g_pd3dDevice -> Present( NULL, NULL, NULL, NULL ); }
    复制代码

    下面是完整的代码

    复制代码
         
    /* This is a simple vertex shader program which illustrate how to use vertex shader instead of fixed pipeline to perform world, view and projection transform */ #include < d3dx9.h > #include < MMSystem.h > LPDIRECT3D9 g_pD3D = NULL ; // Used to create the D3DDevice LPDIRECT3DDEVICE9 g_pd3dDevice = NULL ; // Our rendering device ID3DXMesh * g_pMesh = NULL ; // Hold the sphere IDirect3DVertexShader9 * g_pVertexShader = NULL ; // vertex shader ID3DXConstantTable * g_pConstantTable = NULL ; // shader constant table // Handle for world, view and projection matrix // We use this variable to communicate between the effect file Shader.txt and the C++ code D3DXHANDLE ViewProjMatrixHanle = 0 ; void SetupMatrix() ; bool PrepareShader() ; HRESULT InitD3D( HWND hWnd ) { // Create the D3D object, which is needed to create the D3DDevice. if ( NULL == ( g_pD3D = Direct3DCreate9( D3D_SDK_VERSION ) ) ) return E_FAIL; D3DPRESENT_PARAMETERS d3dpp; ZeroMemory( & d3dpp, sizeof (d3dpp) ); d3dpp.Windowed = TRUE; d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD; d3dpp.BackBufferFormat = D3DFMT_UNKNOWN; // Create device if ( FAILED( g_pD3D -> CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd, D3DCREATE_SOFTWARE_VERTEXPROCESSING, & d3dpp, & g_pd3dDevice ) ) ) { return E_FAIL; } // Turn off culling, so we see the front and back of the triangle g_pd3dDevice -> SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE ); // g_pd3dDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_WIREFRAME); g_pd3dDevice -> SetRenderState( D3DRS_LIGHTING , FALSE ); // Create a teapot D3DXCreateTeapot(g_pd3dDevice, & g_pMesh, NULL) ; // Prepare Shader PrepareShader() ; // Setup matrix SetupMatrix() ; return S_OK; } VOID Cleanup() { if ( g_pd3dDevice != NULL) g_pd3dDevice -> Release(); if ( g_pD3D != NULL) g_pD3D -> Release(); if (g_pMesh != NULL) g_pMesh -> Release() ; } bool PrepareShader() { // Buffer to hold the compiled code ID3DXBuffer * codeBuffer = NULL; // Buffer to hold the error message if complile failed ID3DXBuffer * errorBuffer = NULL; // Compile shader from file HRESULT hr = D3DXCompileShaderFromFileA( " vertexshader.txt " , 0 , 0 , " Main " , " vs_1_1 " , D3DXSHADER_ENABLE_BACKWARDS_COMPATIBILITY, & codeBuffer, & errorBuffer, & g_pConstantTable) ; // output any error messages if ( errorBuffer ) { MessageBoxA( 0 , ( char * )errorBuffer -> GetBufferPointer(), 0 , 0 ); errorBuffer -> Release() ; return false ; } if (FAILED(hr)) { MessageBox( 0 , L " D3DXCompileShaderFromFile() - FAILED " , 0 , 0 ); return false ; } // Create vertex shader hr = g_pd3dDevice -> CreateVertexShader((DWORD * )codeBuffer -> GetBufferPointer(), & g_pVertexShader) ; // handling error if (FAILED(hr)) { MessageBox( 0 , L " CreateVertexShader - FAILED " , 0 , 0 ); return false ; } // Release code buffer if (codeBuffer != NULL) { codeBuffer -> Release() ; codeBuffer = NULL ; } // Release DX buffer if (errorBuffer != NULL) { errorBuffer -> Release() ; errorBuffer = NULL ; } // Set handle ViewProjMatrixHanle = g_pConstantTable -> GetConstantByName( 0 , " gWVP " ) ; return true ; } void SetupMatrix() { D3DXVECTOR3 eyePt( 0.0f , 0.0f , - 10.0f ) ; D3DXVECTOR3 upVec( 0.0f , 1.0f , 0.0f ) ; D3DXVECTOR3 lookCenter( 0.0f , 0.0f , 0.0f ) ; // Set view matrix D3DXMATRIX view ; D3DXMatrixLookAtLH( & view, & eyePt, & lookCenter, & upVec) ; // Set projection matrix D3DXMATRIX proj ; D3DXMatrixPerspectiveFovLH( & proj, D3DX_PI / 4 , 1.0f , 1.0f , 1000.0f ) ; D3DXMATRIX viewproj = view * proj ; g_pConstantTable -> SetMatrix(g_pd3dDevice, ViewProjMatrixHanle, & viewproj) ; // this line is mandatory if you have used Constant table in your code g_pConstantTable -> SetDefaults(g_pd3dDevice); } VOID Render() { // Clear the back-buffer to a red color g_pd3dDevice -> Clear( 0 , NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB( 0 , 0 , 0 ), 1.0f , 0 ); // Begin the scene if ( SUCCEEDED( g_pd3dDevice -> BeginScene() ) ) { // Set Vertex Shader g_pd3dDevice -> SetVertexShader(g_pVertexShader) ; // Render teapot g_pMesh -> DrawSubset( 0 ) ; // End the scene g_pd3dDevice -> EndScene(); } // Present the back-buffer contents to the display g_pd3dDevice -> Present( NULL, NULL, NULL, NULL ); } LRESULT WINAPI MsgProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam ) { switch ( msg ) { case WM_KEYDOWN: { switch ( wParam ) { case VK_ESCAPE: SendMessage( hWnd, WM_CLOSE, 0 , 0 ); break ; default : break ; } } break ; case WM_DESTROY: Cleanup(); PostQuitMessage( 0 ); return 0 ; } return DefWindowProc( hWnd, msg, wParam, lParam ); } INT WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR szCmdLine, int iCmdShow) { WNDCLASSEX winClass ; winClass.lpszClassName = L " Teapot " ; winClass.cbSize = sizeof (WNDCLASSEX); winClass.style = CS_HREDRAW | CS_VREDRAW; winClass.lpfnWndProc = MsgProc; winClass.hInstance = hInstance; winClass.hIcon = NULL ; winClass.hIconSm = NULL ; winClass.hCursor = NULL ; winClass.hbrBackground = NULL ; winClass.lpszMenuName = NULL ; winClass.cbClsExtra = 0 ; winClass.cbWndExtra = 0 ; RegisterClassEx ( & winClass) ; HWND hWnd = CreateWindowEx(NULL, winClass.lpszClassName, // window class name L " Teapot " , // window caption WS_OVERLAPPEDWINDOW, // window style 32 , // initial x position 32 , // initial y position 600 , // initial window width 600 , // initial window height NULL, // parent window handle NULL, // window menu handle hInstance, // program instance handle NULL) ; // creation parameters // Create window failed if (hWnd == NULL) { MessageBoxA(hWnd, " Create Window failed! " , " Error " , 0 ) ; return - 1 ; } // Initialize Direct3D if ( SUCCEEDED(InitD3D(hWnd))) { // Show the window ShowWindow( hWnd, SW_SHOWDEFAULT ); UpdateWindow( hWnd ); // Enter the message loop MSG msg ; ZeroMemory( & msg, sizeof (msg) ); PeekMessage( & msg, NULL, 0U , 0U , PM_NOREMOVE ); // Get last time static DWORD lastTime = timeGetTime(); while (msg.message != WM_QUIT) { if ( PeekMessage( & msg, NULL, 0U , 0U , PM_REMOVE) != 0 ) { TranslateMessage ( & msg) ; DispatchMessage ( & msg) ; } else // Render the game if there is no message to process { // Get current time DWORD currTime = timeGetTime(); // Calculate time elapsed float timeDelta = (currTime - lastTime) * 0.001f ; // Render Render() ; // Update last time to current time for next loop lastTime = currTime; } } } UnregisterClass(winClass.lpszClassName, hInstance) ; return 0 ; }
    复制代码

     

    如何查看显卡所支持的Vertex Shader版本

    1 使用DirectX Caps Viewer查看

    2 使用下面的代码查看

    复制代码
         
    1 // Check shader version 2   bool CheckShaderVersion(LPDIRECT3DDEVICE9 g_pd3dDevice) 3 { 4 // Get device capabilities 5   D3DCAPS9 caps ; 6 g_pd3dDevice -> GetDeviceCaps( & caps); 7 8 // Make sure vertex shader version greater than 2.0 9   if (caps.VertexShaderVersion < D3DVS_VERSION( 2 , 0 )) 10 { 11 return false ; 12 } 13 14 // Make sure pixel shader version greater than 2.0 15   if (caps.PixelShaderVersion < D3DPS_VERSION( 2 , 0 )) 16 { 17 return false ; 18 } 19 20 return true ; 21 };
    复制代码

     

     

    作者: zdd
    出处: http://www.cnblogs.com/graphics/
    本文版权归作者和博客园共有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出原文连接,否则保留追究法律责任的权利.
    展开全文
  • Vertex-6配置手册

    2014-08-10 22:39:01
    Xilinx Vertex-6系列芯片配置文档
  • Vertex-distinguishing total colorings of 2Cn
  • Constraints for geodesic network interpolation at a vertex
  • vertex programs, theMesh vertex data is passed as inputs to the vertexshader function. Each input needs to have semantic speficied for it: for example, POSITION input is the vertex po
  • it implement a kind of adaptive vertex clustering algorithm in Mesh simplification.
  • Vertex常用操作

    千次阅读 2019-06-01 16:11:27
    1.缩放顶点位置,原位置+ Normal向量*变量实现。...v.vertex.xyz += v.normal * _Extrusion * abs(_SinTime.w); 可用于双Pass实现基本的Outline功能,但是需要注意将Outline的Pass设为透明且不写入深度 2. ...
  • Vertex-distinguishing I-total colorings of graphs
  • Vertex-Distinguishing E-Total Colorings of Graphs
  • An Approximation Algorithm for the Minimum Vertex Cover Problem
  • The problem of finding a minimum vertex cover (MVC) is a classical optimization problem in computer science and is a typical example of an NP-complete optimization problem that has attracted a great ...
  • 2019c++课设-vertex3d.zip

    2019-08-11 02:30:21
    2019c++课设-vertex3d.zip。xiachuan

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 104,888
精华内容 41,955
关键字:

vertex