Changeset 829


Ignore:
Timestamp:
Aug 16, 2011, 7:02:24 PM (8 years ago)
Author:
sam
Message:

debug: add new shader tests and write some Cg equivalents on the PS3.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/debug/quad.cpp

    r823 r829  
    1515#include <cmath>
    1616#include <cstdio>
     17#include <cstring>
    1718
    1819#include "core.h"
     
    2930 */
    3031
    31 static int const NUM_ARRAYS = 2;
    32 static int const NUM_BUFFERS = 9;
    33 static int const NUM_ATTRS = 6;
    34 static int const NUM_SHADERS = 6;
    35 static int const NUM_TEXTURES = 1;
     32static int const NUM_ARRAYS = 10;
     33static int const NUM_BUFFERS = 20;
     34static int const NUM_ATTRS = 20;
     35static int const NUM_UNIFORMS = 20;
     36static int const NUM_SHADERS = 20;
     37static int const NUM_TEXTURES = 10;
    3638
    3739static int const TEX_SIZE = 32;
     
    5254    Shader *shader[NUM_SHADERS];
    5355    GLuint attr[NUM_ATTRS];
     56    GLuint uni[NUM_UNIFORMS];
    5457    GLuint texture[NUM_TEXTURES];
    5558    uint8_t image[1][TEX_SIZE * TEX_SIZE * 4];
     59
     60    GLfloat const *GetVertexArray()
     61    {
     62        GLfloat tmp[18] = { aa.x, bb.y, 0, bb.x, bb.y, 0, bb.x, aa.y, 0,
     63                            bb.x, aa.y, 0, aa.x, aa.y, 0, aa.x, bb.y, 0 };
     64        memcpy(vertices, tmp, sizeof(tmp));
     65        return vertices;
     66    }
     67    GLfloat vertices[18]; /* To cache quad coordinates */
    5668};
    5769
     
    126138
    127139    /* Prepare our quad coordinates */
    128     vec2i const layout(4, 3);
     140    vec2i const layout(5, 4);
    129141    data->step = vec2(2.0f, -2.0f) / (4 * layout + vec2i(1));
    130142    data->orig = vec2(-1.0f, 1.0f) + data->step;
     
    150162    Shader **shader = data->shader;
    151163    GLuint *attr = data->attr;
    152 
    153     ResetState();
    154 
     164    GLuint *uni = data->uni;
     165
     166    ResetState();
     167
     168    /*
     169     * Test #1: simple glBegin code
     170     *
     171     * Renders an orange square.
     172     */
    155173#if defined HAVE_GLBEGIN || defined USE_GLEW
    156     /*
    157      * Test #1: simple glBegin code
    158      *
    159      * Renders an orange square.
    160      */
    161174    glColor3f(0.8f, 0.5f, 0.2f);
    162175    glBegin(GL_TRIANGLES);
     
    169182        glVertex3f(data->aa.x, data->bb.y, 0.0f);
    170183    glEnd();
     184#endif
    171185
    172186    Advance();
     
    178192     * Renders a multicoloured square with varying colors.
    179193     */
    180 
     194#if defined HAVE_GLBEGIN || defined USE_GLEW
    181195    glBegin(GL_TRIANGLES);
    182196        glColor3f(f1, f2, f3);
     
    193207        glVertex3f(data->aa.x, data->bb.y, 0.0f);
    194208    glEnd();
     209#endif
    195210
    196211    Advance();
     
    203218     * animated distorted checkerboard.
    204219     */
     220#if defined HAVE_GLBEGIN || defined USE_GLEW
    205221    glEnable(GL_TEXTURE_2D);
    206222    glBindTexture(GL_TEXTURE_2D, data->texture[0]);
     
    227243    glEnd();
    228244    glDisable(GL_TEXTURE_2D);
     245#endif
    229246
    230247    Advance();
     
    236253     * Renders a static, coloured and tiled pattern.
    237254     */
     255#if defined HAVE_GLBEGIN || defined USE_GLEW
    238256    if (!shader[0])
    239257        shader[0] = Shader::Create(
     
    264282        glVertex3f(data->aa.x, data->bb.y, 0.0f);
    265283    glEnd();
    266     glUseProgram(0);
     284#endif
    267285
    268286    Advance();
     
    275293     * Renders a multicoloured square with varying colors.
    276294     */
     295#if defined HAVE_GLBEGIN || defined USE_GLEW
    277296    if (!shader[0])
    278297        shader[0] = Shader::Create(
     
    311330        glVertex3f(data->aa.x, data->bb.y, 0.0f);
    312331    glEnd();
    313     glUseProgram(0);
     332#endif
    314333
    315334    Advance();
     
    325344     * texture lookup is done in a shader.
    326345     */
     346#if defined HAVE_GLBEGIN || defined USE_GLEW
    327347    if (!shader[0])
    328348        shader[0] = Shader::Create(
     
    359379        glVertex3f(data->aa.x, data->bb.y, 0.0f);
    360380    glEnd();
    361     glUseProgram(0);
    362 
    363     Advance();
    364     ResetState();
    365 #endif
     381#endif
     382
     383    Advance();
     384    ResetState();
    366385
    367386    /*
     
    371390     */
    372391#if !defined ANDROID_NDK
    373     GLfloat const vertices1[] = { data->aa.x, data->bb.y, 0.0f,
    374                                   data->bb.x, data->bb.y, 0.0f,
    375                                   data->bb.x, data->aa.y, 0.0f,
    376                                   data->bb.x, data->aa.y, 0.0f,
    377                                   data->aa.x, data->aa.y, 0.0f,
    378                                   data->aa.x, data->bb.y, 0.0f };
    379 
    380392    glColor4f(0.8f, 0.5f, 0.2f, 1.0f);
    381393    glEnableClientState(GL_VERTEX_ARRAY);
    382394
    383     glVertexPointer(3, GL_FLOAT, 0, vertices1);
     395    glVertexPointer(3, GL_FLOAT, 0, data->GetVertexArray());
    384396    glDrawArrays(GL_TRIANGLES, 0, 6);
    385397
    386398    glDisableClientState(GL_VERTEX_ARRAY);
    387 
    388     Advance();
    389     ResetState();
    390 #endif
     399#endif
     400
     401    Advance();
     402    ResetState();
    391403
    392404    /*
     
    396408     */
    397409#if !defined ANDROID_NDK
    398     GLfloat const vertices2[] = { data->aa.x, data->bb.y, 0.0f,
    399                                   data->bb.x, data->bb.y, 0.0f,
    400                                   data->bb.x, data->aa.y, 0.0f,
    401                                   data->bb.x, data->aa.y, 0.0f,
    402                                   data->aa.x, data->aa.y, 0.0f,
    403                                   data->aa.x, data->bb.y, 0.0f };
    404 
    405410    glEnableClientState(GL_VERTEX_ARRAY);
    406411    glEnableClientState(GL_COLOR_ARRAY);
    407412
    408     glVertexPointer(3, GL_FLOAT, 0, vertices2);
     413    glVertexPointer(3, GL_FLOAT, 0, data->GetVertexArray());
    409414    glColorPointer(3, GL_FLOAT, 0, colors);
    410415    glDrawArrays(GL_TRIANGLES, 0, 6);
     
    412417    glDisableClientState(GL_VERTEX_ARRAY);
    413418    glDisableClientState(GL_COLOR_ARRAY);
    414 
    415     Advance();
    416     ResetState();
    417 #endif
     419#endif
     420
     421    Advance();
     422    ResetState();
    418423
    419424    /*
     
    424429     */
    425430#if !defined ANDROID_NDK
    426     GLfloat const vertices3[] = { data->aa.x, data->bb.y, 0.0f,
    427                                   data->bb.x, data->bb.y, 0.0f,
    428                                   data->bb.x, data->aa.y, 0.0f,
    429                                   data->bb.x, data->aa.y, 0.0f,
    430                                   data->aa.x, data->aa.y, 0.0f,
    431                                   data->aa.x, data->bb.y, 0.0f };
    432 
    433431    glEnable(GL_TEXTURE_2D);
    434432    glBindTexture(GL_TEXTURE_2D, data->texture[0]);
     
    437435    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
    438436
    439     glVertexPointer(3, GL_FLOAT, 0, vertices3);
     437    glVertexPointer(3, GL_FLOAT, 0, data->GetVertexArray());
    440438    glColorPointer(3, GL_FLOAT, 0, colors);
    441439    glTexCoordPointer(2, GL_FLOAT, 0, texcoords);
     
    447445    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
    448446    glDisable(GL_TEXTURE_2D);
    449 
    450     Advance();
    451     ResetState();
    452 #endif
    453 
    454     /*
    455      * Test #10: vertex buffer + texture & color in 1.10 fragment shader
     447#endif
     448
     449    Advance();
     450    ResetState();
     451
     452    /*
     453     * Test #10: vertex buffer + hardcoded color in 1.10 fragment shader
     454     * (GLSL) or in Cg fragment shader (PS3)
     455     *
     456     * Renders an orange square.
     457     */
     458#if !defined ANDROID_NDK
     459    if (!shader[0])
     460#if !defined __CELLOS_LV2__
     461        shader[0] = Shader::Create(
     462            "#version 110\n"
     463            "void main()"
     464            "{"
     465            "    gl_Position = gl_Vertex;"
     466            "}",
     467
     468            "#version 110\n"
     469            "void main()"
     470            "{"
     471            "    gl_FragColor = vec4(0.8, 0.5, 0.2, 1.0);"
     472            "}");
     473#else
     474        shader[0] = Shader::Create(
     475            "void main(float4 in_Position : POSITION,"
     476            "          out float4 out_Position : POSITION)"
     477            "{"
     478            "    out_Position = in_Position;"
     479            "}",
     480
     481            "void main(out float4 out_FragColor : COLOR)"
     482            "{"
     483            "    out_FragColor = float4(0.8, 0.5, 0.2, 1.0);"
     484            "}");
     485#endif
     486    shader[0]->Bind();
     487    shader++;
     488
     489    glEnableClientState(GL_VERTEX_ARRAY);
     490    glVertexPointer(3, GL_FLOAT, 0, data->GetVertexArray());
     491    glDrawArrays(GL_TRIANGLES, 0, 6);
     492    glDisableClientState(GL_VERTEX_ARRAY);
     493#endif
     494
     495    Advance();
     496    ResetState();
     497
     498    /*
     499     * Test #11: vertex buffer + uniform color in 1.10 fragment shader
     500     * (GLSL) or in Cg fragment shader (PS3)
     501     *
     502     * Renders an orange square.
     503     */
     504#if !defined ANDROID_NDK
     505    if (!shader[0])
     506    {
     507#if !defined __CELLOS_LV2__
     508        shader[0] = Shader::Create(
     509            "#version 110\n"
     510            "void main()"
     511            "{"
     512            "    gl_Position = gl_Vertex;"
     513            "}",
     514
     515            "#version 110\n"
     516            "uniform vec4 in_Color;"
     517            "void main()"
     518            "{"
     519            "    gl_FragColor = in_Color;"
     520            "}");
     521#else
     522        shader[0] = Shader::Create(
     523            "void main(float4 in_Position : POSITION,"
     524            "          out float4 out_Position : POSITION)"
     525            "{"
     526            "    out_Position = in_Position;"
     527            "}",
     528
     529            "uniform float4 in_Color;"
     530            "void main(out float4 out_FragColor : COLOR)"
     531            "{"
     532            "    out_FragColor = in_Color;"
     533            "}");
     534#endif
     535        uni[0] = shader[0]->GetUniformLocation("in_Color");
     536    }
     537    shader[0]->Bind();
     538    shader++;
     539#if !defined __CELLOS_LV2__
     540    glUniform4f(uni[0], 0.8f, 0.5f, 0.2f, 1.0f);
     541#else
     542    cgGLSetParameter4f((CGparameter)(intptr_t)uni[0], 0.8f, 0.5f, 0.2f, 1.0f);
     543#endif
     544    uni++;
     545
     546    glEnableClientState(GL_VERTEX_ARRAY);
     547    glVertexPointer(3, GL_FLOAT, 0, data->GetVertexArray());
     548    glDrawArrays(GL_TRIANGLES, 0, 6);
     549    glDisableClientState(GL_VERTEX_ARRAY);
     550#endif
     551
     552    Advance();
     553    ResetState();
     554
     555    /*
     556     * Test #12: vertex buffer + color in 1.10 fragment shader (GLSL) or
     557     * in Cg fragment shader (PS3)
     558     *
     559     * Renders a static, coloured and tiled pattern.
     560     */
     561#if !defined ANDROID_NDK
     562    if (!shader[0])
     563#if !defined __CELLOS_LV2__
     564        shader[0] = Shader::Create(
     565            "#version 110\n"
     566            "void main()"
     567            "{"
     568            "    gl_Position = gl_Vertex;"
     569            "}",
     570
     571            "#version 110\n"
     572            "void main()"
     573            "{"
     574            "    float dx = mod(gl_FragCoord.x * gl_FragCoord.y, 2.0);"
     575            "    float dy = mod(gl_FragCoord.x * 0.125, 1.0);"
     576            "    float dz = mod(gl_FragCoord.y * 0.125, 1.0);"
     577            "    gl_FragColor = vec4(dx, dy, dz, 1.0);"
     578            "}");
     579#else
     580        shader[0] = Shader::Create(
     581            "void main(float4 in_Position : POSITION,"
     582            "          out float4 out_Position : POSITION)"
     583            "{"
     584            "    out_Position = in_Position;"
     585            "}",
     586
     587            "void main(float4 in_FragCoord : WPOS,"
     588            "          out float4 out_FragColor : COLOR)"
     589            "{"
     590            "    float dx = frac(in_FragCoord.x * in_FragCoord.y * 0.5) * 2.0;"
     591            "    float dy = frac(in_FragCoord.x * 0.125);"
     592            "    float dz = frac(in_FragCoord.y * 0.125);"
     593            "    out_FragColor = float4(dx, dy, dz, 1.0);"
     594            "}");
     595#endif
     596    shader[0]->Bind();
     597    shader++;
     598
     599    glEnableClientState(GL_VERTEX_ARRAY);
     600    glVertexPointer(3, GL_FLOAT, 0, data->GetVertexArray());
     601    glDrawArrays(GL_TRIANGLES, 0, 6);
     602    glDisableClientState(GL_VERTEX_ARRAY);
     603#endif
     604
     605    Advance();
     606    ResetState();
     607
     608    /*
     609     * Test #13: vertex buffer + texture & color in 1.10 fragment shader
    456610     *
    457611     * Renders a multicoloured square with varying colors xored with an
    458612     * animated distorted checkerboard.
    459613     */
    460 #if !defined __CELLOS_LV2__ && !defined ANDROID_NDK
     614#if !defined ANDROID_NDK
    461615    if (!shader[0])
     616#if !defined __CELLOS_LV2__
    462617        shader[0] = Shader::Create(
    463618            "#version 110\n"
     
    478633            "    gl_FragColor = vec4(abs(tmp.xyz - pass_Color.xyz), 1.0);"
    479634            "}");
     635#else
     636        shader[0] = Shader::Create(
     637            "void main(float4 in_Position : POSITION,"
     638            "          float2 in_TexCoord : TEXCOORD0,"
     639            "          float4 in_Color : COLOR,"
     640            "          out float4 out_Color : COLOR,"
     641            "          out float4 out_Position : POSITION,"
     642            "          out float2 out_TexCoord : TEXCOORD0)"
     643            "{"
     644            "    out_TexCoord = in_TexCoord;"
     645            "    out_Color = in_Color;"
     646            "    out_Position = in_Position;"
     647            "}",
     648
     649            "void main(float2 in_TexCoord : TEXCOORD0,"
     650            "          float4 in_Color : COLOR,"
     651            "          uniform sampler2D tex,"
     652            "          out float4 out_FragColor : COLOR)"
     653            "{"
     654            "    float4 tmp = tex2D(tex, in_TexCoord * 0.25);"
     655            "    out_FragColor = float4(abs(tmp.xyz - in_Color.xyz), 1);"
     656            "}");
     657#endif
    480658
    481659    shader[0]->Bind();
    482660    shader++;
    483     GLfloat const vertices4[] = { data->aa.x, data->bb.y, 0.0f,
    484                                   data->bb.x, data->bb.y, 0.0f,
    485                                   data->bb.x, data->aa.y, 0.0f,
    486                                   data->bb.x, data->aa.y, 0.0f,
    487                                   data->aa.x, data->aa.y, 0.0f,
    488                                   data->aa.x, data->bb.y, 0.0f };
    489661
    490662    glBindTexture(GL_TEXTURE_2D, data->texture[0]);
     
    494666    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
    495667
    496     glVertexPointer(3, GL_FLOAT, 0, vertices4);
     668    glVertexPointer(3, GL_FLOAT, 0, data->GetVertexArray());
    497669    glColorPointer(3, GL_FLOAT, 0, colors);
    498670    glTexCoordPointer(2, GL_FLOAT, 0, texcoords);
     
    502674    glDisableClientState(GL_COLOR_ARRAY);
    503675    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
    504     glUseProgram(0);
    505 
    506     Advance();
    507     ResetState();
    508 #endif
    509 
    510     /*
    511      * Test #11: vertex buffer + texture & color in 1.20 fragment shader
     676#endif
     677
     678    Advance();
     679    ResetState();
     680
     681    /*
     682     * Test #14: vertex buffer + texture & color in 1.20 fragment shader
    512683     *
    513684     * Renders a multicoloured square with varying colors xored with an
     
    544715    shader[0]->Bind();
    545716    shader++;
    546     GLfloat const vertices5[] = { data->aa.x, data->bb.y, 0.0f,
    547                                   data->bb.x, data->bb.y, 0.0f,
    548                                   data->bb.x, data->aa.y, 0.0f,
    549                                   data->bb.x, data->aa.y, 0.0f,
    550                                   data->aa.x, data->aa.y, 0.0f,
    551                                   data->aa.x, data->bb.y, 0.0f };
    552717
    553718    glBindTexture(GL_TEXTURE_2D, data->texture[0]);
     
    556721
    557722    glBindBuffer(GL_ARRAY_BUFFER, *buffer++);
    558     glBufferData(GL_ARRAY_BUFFER, sizeof(vertices5), vertices5,
    559                  GL_DYNAMIC_DRAW);
     723    glBufferData(GL_ARRAY_BUFFER, 3 * 6 * sizeof(GLfloat),
     724                 data->GetVertexArray(), GL_DYNAMIC_DRAW);
    560725    glVertexAttribPointer(attr[0], 3, GL_FLOAT, GL_FALSE, 0, 0);
    561726    glEnableVertexAttribArray(attr[0]);
     
    579744    glDisableVertexAttribArray(*attr++);
    580745    glDisableVertexAttribArray(*attr++);
    581     glUseProgram(0);
    582 
    583     Advance();
    584     ResetState();
    585 #endif
    586 
    587     /*
    588      * Test #12: vertex buffer + texture & color in 1.30 fragment shader
     746#endif
     747
     748    Advance();
     749    ResetState();
     750
     751    /*
     752     * Test #15: vertex buffer + texture & color in 1.30 fragment shader
    589753     *
    590754     * Renders a multicoloured square with varying colors xored with an
     
    621785    shader[0]->Bind();
    622786    shader++;
    623     GLfloat const vertices6[] = { data->aa.x, data->bb.y, 0.0f,
    624                                   data->bb.x, data->bb.y, 0.0f,
    625                                   data->bb.x, data->aa.y, 0.0f,
    626                                   data->bb.x, data->aa.y, 0.0f,
    627                                   data->aa.x, data->aa.y, 0.0f,
    628                                   data->aa.x, data->bb.y, 0.0f };
    629787
    630788    glBindTexture(GL_TEXTURE_2D, data->texture[0]);
     
    633791
    634792    glBindBuffer(GL_ARRAY_BUFFER, *buffer++);
    635     glBufferData(GL_ARRAY_BUFFER, sizeof(vertices6), vertices6,
    636                  GL_DYNAMIC_DRAW);
     793    glBufferData(GL_ARRAY_BUFFER, 3 * 6 * sizeof(GLfloat),
     794                 data->GetVertexArray(), GL_DYNAMIC_DRAW);
    637795    glVertexAttribPointer(attr[0], 3, GL_FLOAT, GL_FALSE, 0, 0);
    638796    glEnableVertexAttribArray(attr[0]);
     
    656814    glDisableVertexAttribArray(*attr++);
    657815    glDisableVertexAttribArray(*attr++);
    658     glUseProgram(0);
    659 
    660     Advance();
    661     ResetState();
    662 #endif
     816#endif
     817
     818    Advance();
     819    ResetState();
    663820
    664821    /* Check that we didn't overflow our list */
     
    678835{
    679836    /* Reset GL states to something reasonably safe */
     837
    680838#if defined HAVE_GLBEGIN || defined USE_GLEW || defined __CELLOS_LV2__
    681839    glMatrixMode(GL_PROJECTION);
     
    685843#endif
    686844
     845    glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
     846
    687847    glEnable(GL_TEXTURE_2D);
    688848    glBindTexture(GL_TEXTURE_2D, 0);
     
    695855#if !defined __CELLOS_LV2__
    696856    glUseProgram(0);
     857#else
     858    cgGLDisableProfile(cgGLGetLatestProfile(CG_GL_VERTEX));
     859    cgGLDisableProfile(cgGLGetLatestProfile(CG_GL_FRAGMENT));
    697860#endif
    698861}
Note: See TracChangeset for help on using the changeset viewer.