Changeset 223833 in webkit


Ignore:
Timestamp:
Oct 23, 2017 3:11:12 AM (7 years ago)
Author:
magomez@igalia.com
Message:

[TexMap] Remove GraphicsContext3D usage from TextureMapperShaderProgram
​https://bugs.webkit.org/show_bug.cgi?id=175425

Reviewed by Žan Doberšek.

Remove usage of the GraphicsContext3D class in TextureMapperShaderProgram.
Direct OpenGL API calls, types and constants are used instead.

By removing GraphicsContext3D, we don't use ANGLE anymore to perform the
shader adaptation to the used OpenGL/GLES2 version, so we need to do that
inside TextureMapperShaderProgram. The main changes required for this are
adding the #version directive and use in/out to define input/output parameters
when using OpenGL >= 3.2, and defining the default precision only when using
GLES2.

Besides that, now that VideoTextureCopierGStreamer doesn't have its own
GraphicsContext3D, we need to add a VAO to it when using OpenGL >= 3.2.

Based on a previous patch by Žan Doberšek <​zdobersek@igalia.com>.

No behavior change.

  • platform/graphics/gstreamer/VideoTextureCopierGStreamer.cpp:

(WebCore::VideoTextureCopierGStreamer::VideoTextureCopierGStreamer):
(WebCore::VideoTextureCopierGStreamer::~VideoTextureCopierGStreamer):
(WebCore::VideoTextureCopierGStreamer::copyVideoTextureToPlatformTexture):

  • platform/graphics/gstreamer/VideoTextureCopierGStreamer.h:
  • platform/graphics/texmap/TextureMapperGL.cpp:

(WebCore::TextureMapperGLData::getShaderProgram):
(WebCore::prepareFilterProgram):
(WebCore::TextureMapperGL::drawTexture):
(WebCore::TextureMapperGL::drawFiltered):

  • platform/graphics/texmap/TextureMapperShaderProgram.cpp:

(WebCore::TextureMapperShaderProgram::create):
(WebCore::getShaderLog):
(WebCore::getProgramLog):
(WebCore::TextureMapperShaderProgram::TextureMapperShaderProgram):
(WebCore::TextureMapperShaderProgram::~TextureMapperShaderProgram):
(WebCore::TextureMapperShaderProgram::setMatrix):
(WebCore::TextureMapperShaderProgram::getLocation):

  • platform/graphics/texmap/TextureMapperShaderProgram.h:

(WebCore::TextureMapperShaderProgram::programID const):

Location:
trunk/Source/WebCore
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r223828 r223833  
     12017-10-23  Miguel Gomez  <magomez@igalia.com>
     2
     3        [TexMap] Remove GraphicsContext3D usage from TextureMapperShaderProgram
     4        https://bugs.webkit.org/show_bug.cgi?id=175425
     5
     6        Reviewed by Žan Doberšek.
     7
     8        Remove usage of the GraphicsContext3D class in TextureMapperShaderProgram.
     9        Direct OpenGL API calls, types and constants are used instead.
     10
     11        By removing GraphicsContext3D, we don't use ANGLE anymore to perform the
     12        shader adaptation to the used OpenGL/GLES2 version, so we need to do that
     13        inside TextureMapperShaderProgram. The main changes required for this are
     14        adding the #version directive and use in/out to define input/output parameters
     15        when using OpenGL >= 3.2, and defining the default precision only when using
     16        GLES2.
     17
     18        Besides that, now that VideoTextureCopierGStreamer doesn't have its own
     19        GraphicsContext3D, we need to add a VAO to it when using OpenGL >= 3.2.
     20
     21        Based on a previous patch by Žan Doberšek <zdobersek@igalia.com>.
     22
     23        No behavior change.
     24
     25        * platform/graphics/gstreamer/VideoTextureCopierGStreamer.cpp:
     26        (WebCore::VideoTextureCopierGStreamer::VideoTextureCopierGStreamer):
     27        (WebCore::VideoTextureCopierGStreamer::~VideoTextureCopierGStreamer):
     28        (WebCore::VideoTextureCopierGStreamer::copyVideoTextureToPlatformTexture):
     29        * platform/graphics/gstreamer/VideoTextureCopierGStreamer.h:
     30        * platform/graphics/texmap/TextureMapperGL.cpp:
     31        (WebCore::TextureMapperGLData::getShaderProgram):
     32        (WebCore::prepareFilterProgram):
     33        (WebCore::TextureMapperGL::drawTexture):
     34        (WebCore::TextureMapperGL::drawFiltered):
     35        * platform/graphics/texmap/TextureMapperShaderProgram.cpp:
     36        (WebCore::TextureMapperShaderProgram::create):
     37        (WebCore::getShaderLog):
     38        (WebCore::getProgramLog):
     39        (WebCore::TextureMapperShaderProgram::TextureMapperShaderProgram):
     40        (WebCore::TextureMapperShaderProgram::~TextureMapperShaderProgram):
     41        (WebCore::TextureMapperShaderProgram::setMatrix):
     42        (WebCore::TextureMapperShaderProgram::getLocation):
     43        * platform/graphics/texmap/TextureMapperShaderProgram.h:
     44        (WebCore::TextureMapperShaderProgram::programID const):
     45
    1462017-10-22  Sam Weinig  <sam@webkit.org>
    247

  • trunk/Source/WebCore/platform/graphics/gstreamer/VideoTextureCopierGStreamer.cpp

    r220402 r223833  
    2828#include "TextureMapperShaderProgram.h"
    2929
    30 // FIXME: Remove after TextureMapperShaderProgram drops GraphicsContext3D usage.
    31 #include "GraphicsContext3D.h"
    32 
    3330namespace WebCore {
    3431
    … …  
    3936    PlatformDisplay::sharedDisplayForCompositing().sharingGLContext()->makeContextCurrent();
    4037
    41     {
    42         // FIXME: Remove after TextureMapperShaderProgram drops GraphicsContext3D usage.
    43         auto context3D = GraphicsContext3D::createForCurrentGLContext();
    44         m_shaderProgram = TextureMapperShaderProgram::create(*context3D, TextureMapperShaderProgram::Texture);
    45     }
     38    m_shaderProgram = TextureMapperShaderProgram::create(TextureMapperShaderProgram::Texture);
    4639
    4740    glGenFramebuffers(1, &m_framebuffer);
    4841    glGenTextures(1, &m_resultTexture);
     42
     43#if !USE(OPENGL_ES_2)
     44    // For OpenGL > 3.2 we need to have a VAO.
     45    if (GLContext::current()->version() >= 320)
     46        glGenVertexArrays(1, &m_vao);
     47#endif
    4948
    5049    static const GLfloat vertices[] = { 0, 0, 1, 0, 1, 1, 0, 1 };
    … …  
    6766    glDeleteBuffers(1, &m_vbo);
    6867    glDeleteTextures(1, &m_resultTexture);
     68#if !USE(OPENGL_ES_2)
     69    if (m_vao)
     70        glDeleteVertexArrays(1, &m_vao);
     71#endif
    6972    m_shaderProgram = nullptr;
    7073
    … …  
    194197
    195198    // Perform the copy.
     199#if !USE(OPENGL_ES_2)
     200    if (GLContext::current()->version() >= 320 && m_vao)
     201        glBindVertexArray(m_vao);
     202#endif
    196203    glEnableVertexAttribArray(m_shaderProgram->vertexLocation());
    197204    glBindBuffer(GL_ARRAY_BUFFER, m_vbo);

  • trunk/Source/WebCore/platform/graphics/gstreamer/VideoTextureCopierGStreamer.h

    r220402 r223833  
    5353    GLuint m_framebuffer { 0 };
    5454    GLuint m_vbo { 0 };
     55#if !USE(OPENGL_ES_2)
     56    GLuint m_vao { 0 };
     57#endif
    5558    bool m_flipY { false };
    5659    ImageOrientation m_orientation;

  • trunk/Source/WebCore/platform/graphics/texmap/TextureMapperGL.cpp

    r220699 r223833  
    159159{
    160160    auto addResult = m_sharedGLData->m_programs.ensure(options,
    161         [this, options] { return TextureMapperShaderProgram::create(Ref<GraphicsContext3D>(m_context), options); });
     161        [this, options] { return TextureMapperShaderProgram::create(options); });
    162162    return *addResult.iterator->value;
    163163}
    … …  
    353353}
    354354
    355 static void prepareFilterProgram(TextureMapperShaderProgram& program, const FilterOperation& operation, unsigned pass, const IntSize& size, GC3Duint contentTexture)
    356 {
    357     Ref<GraphicsContext3D> context = program.context();
     355static void prepareFilterProgram(GraphicsContext3D* context, TextureMapperShaderProgram& program, const FilterOperation& operation, unsigned pass, const IntSize& size, GC3Duint contentTexture)
     356{
    358357    context->useProgram(program.programID());
    359358
    … …  
    475474
    476475    if (filter)
    477         prepareFilterProgram(program.get(), *filter.get(), data().filterInfo->pass, textureSize, filterContentTextureID);
     476        prepareFilterProgram(m_context3D.get(), program.get(), *filter.get(), data().filterInfo->pass, textureSize, filterContentTextureID);
    478477
    479478    drawTexturedQuadWithProgram(program.get(), texture, flags, textureSize, targetRect, modelViewMatrix, opacity);
    … …  
    627626    Ref<TextureMapperShaderProgram> program = data().getShaderProgram(options);
    628627
    629     prepareFilterProgram(program.get(), filter, pass, sampler.contentSize(), contentTexture ? static_cast<const BitmapTextureGL*>(contentTexture)->id() : 0);
     628    prepareFilterProgram(m_context3D.get(), program.get(), filter, pass, sampler.contentSize(), contentTexture ? static_cast<const BitmapTextureGL*>(contentTexture)->id() : 0);
    630629    FloatRect targetRect(IntPoint::zero(), sampler.contentSize());
    631630    drawTexturedQuadWithProgram(program.get(), static_cast<const BitmapTextureGL&>(sampler).id(), 0, IntSize(1, 1), targetRect, TransformationMatrix(), 1);

  • trunk/Source/WebCore/platform/graphics/texmap/TextureMapperShaderProgram.cpp

    r217706 r223833  
    2525#if USE(TEXTURE_MAPPER_GL)
    2626
     27#include "GLContext.h"
    2728#include "Logging.h"
    2829#include "TextureMapperGL.h"
    … …  
    5152    GLSL_DIRECTIVE(endif)
    5253
    53 static const char* vertexTemplate =
     54
     55// Input/output variables definition for both GLES and OpenGL < 3.2.
     56// The default precision directive is only needed for GLES.
     57static const char* vertexTemplateLT320Vars =
     58#if USE(OPENGL_ES_2)
    5459    TEXTURE_SPACE_MATRIX_PRECISION_DIRECTIVE
    55     STRINGIFY(
     60#endif
     61    STRINGIFY(
     62#if USE(OPENGL_ES_2)
    5663        precision TextureSpaceMatrixPrecision float;
     64#endif
    5765        attribute vec4 a_vertex;
     66        varying vec2 v_texCoord;
     67        varying vec2 v_transformedTexCoord;
     68        varying float v_antialias;
     69    );
     70
     71// Input/output variables definition for OpenGL >= 3.2.
     72static const char* vertexTemplateGE320Vars =
     73    STRINGIFY(
     74        in vec4 a_vertex;
     75        out vec2 v_texCoord;
     76        out vec2 v_transformedTexCoord;
     77        out float v_antialias;
     78    );
     79
     80static const char* vertexTemplateCommon =
     81    STRINGIFY(
    5882        uniform mat4 u_modelViewMatrix;
    5983        uniform mat4 u_projectionMatrix;
    6084        uniform mat4 u_textureSpaceMatrix;
    61 
    62         varying vec2 v_texCoord;
    63         varying vec2 v_transformedTexCoord;
    64         varying float v_antialias;
    6585
    6686        void noop(inout vec2 dummyParameter) { }
    … …  
    137157
    138158
    139 static const char* fragmentTemplate =
     159// Common header for all versions. We define the matrices variables here to keep the precision
     160// directives scope: the first one applies to the matrices variables and the next one to the
     161// rest of them. The precision is only used in GLES.
     162static const char* fragmentTemplateHeaderCommon =
    140163    RECT_TEXTURE_DIRECTIVE
    141164    ANTIALIASING_TEX_COORD_DIRECTIVE
    142165    BLUR_CONSTANTS
     166#if USE(OPENGL_ES_2)
    143167    TEXTURE_SPACE_MATRIX_PRECISION_DIRECTIVE
    144     STRINGIFY(
     168#endif
     169    STRINGIFY(
     170#if USE(OPENGL_ES_2)
    145171        precision TextureSpaceMatrixPrecision float;
     172#endif
    146173        uniform mat4 u_textureSpaceMatrix;
    147174        uniform mat4 u_textureColorSpaceMatrix;
     175#if USE(OPENGL_ES_2)
    148176        precision mediump float;
     177#endif
     178    );
     179
     180// Input/output variables definition for both GLES and OpenGL < 3.2.
     181static const char* fragmentTemplateLT320Vars =
     182    STRINGIFY(
     183        varying float v_antialias;
     184        varying vec2 v_texCoord;
     185        varying vec2 v_transformedTexCoord;
     186    );
     187
     188// Input/output variables definition for OpenGL >= 3.2.
     189static const char* fragmentTemplateGE320Vars =
     190    STRINGIFY(
     191        in float v_antialias;
     192        in vec2 v_texCoord;
     193        in vec2 v_transformedTexCoord;
     194    );
     195
     196static const char* fragmentTemplateCommon =
     197    STRINGIFY(
    149198        uniform SamplerType s_sampler;
    150199        uniform sampler2D s_contentTexture;
    151200        uniform float u_opacity;
    152         varying float v_antialias;
    153         varying vec2 v_texCoord;
    154         varying vec2 v_transformedTexCoord;
    155201        uniform float u_filterAmount;
    156202        uniform vec2 u_blurRadius;
    … …  
    306352    );
    307353
    308 Ref<TextureMapperShaderProgram> TextureMapperShaderProgram::create(Ref<GraphicsContext3D>&& context, TextureMapperShaderProgram::Options options)
     354Ref<TextureMapperShaderProgram> TextureMapperShaderProgram::create(TextureMapperShaderProgram::Options options)
    309355{
    310356#define SET_APPLIER_FROM_OPTIONS(Applier) \
    … …  
    331377    SET_APPLIER_FROM_OPTIONS(ManualRepeat);
    332378
     379    unsigned glVersion = GLContext::current()->version();
    333380    StringBuilder vertexShaderBuilder;
     381
     382    // OpenGL >= 3.2 requires a #version directive at the beginning of the code.
     383#if !USE(OPENGL_ES_2)
     384    if (glVersion >= 320)
     385        vertexShaderBuilder.append(GLSL_DIRECTIVE(version 150));
     386#endif
     387
     388    // Append the options.
    334389    vertexShaderBuilder.append(optionsApplierBuilder.toString());
    335     vertexShaderBuilder.append(vertexTemplate);
     390
     391    // Append the appropriate input/output variable definitions.
     392#if USE(OPENGL_ES_2)
     393    vertexShaderBuilder.append(vertexTemplateLT320Vars);
     394#else
     395    if (glVersion >= 320)
     396        vertexShaderBuilder.append(vertexTemplateGE320Vars);
     397    else
     398        vertexShaderBuilder.append(vertexTemplateLT320Vars);
     399#endif
     400
     401    // Append the common code.
     402    vertexShaderBuilder.append(vertexTemplateCommon);
    336403
    337404    StringBuilder fragmentShaderBuilder;
     405
     406    // OpenGL >= 3.2 requires a #version directive at the beginning of the code.
     407#if !USE(OPENGL_ES_2)
     408    if (glVersion >= 320)
     409        fragmentShaderBuilder.append(GLSL_DIRECTIVE(version 150));
     410#endif
     411
     412    // Append the options.
    338413    fragmentShaderBuilder.append(optionsApplierBuilder.toString());
    339     fragmentShaderBuilder.append(fragmentTemplate);
    340 
    341     return adoptRef(*new TextureMapperShaderProgram(WTFMove(context), vertexShaderBuilder.toString(), fragmentShaderBuilder.toString()));
    342 }
    343 
    344 TextureMapperShaderProgram::TextureMapperShaderProgram(Ref<GraphicsContext3D>&& context, const String& vertex, const String& fragment)
    345     : m_context(WTFMove(context))
    346 {
    347     m_vertexShader = m_context->createShader(GraphicsContext3D::VERTEX_SHADER);
    348     m_context->shaderSource(m_vertexShader, vertex);
    349 
    350     m_fragmentShader = m_context->createShader(GraphicsContext3D::FRAGMENT_SHADER);
    351     m_context->shaderSource(m_fragmentShader, fragment);
    352 
    353     m_id = m_context->createProgram();
    354     m_context->compileShader(m_vertexShader);
    355     m_context->compileShader(m_fragmentShader);
    356     m_context->attachShader(m_id, m_vertexShader);
    357     m_context->attachShader(m_id, m_fragmentShader);
    358     m_context->linkProgram(m_id);
    359 
    360     if (!compositingLogEnabled())
     414
     415    // Append the common header.
     416    fragmentShaderBuilder.append(fragmentTemplateHeaderCommon);
     417
     418    // Append the appropriate input/output variable definitions.
     419#if USE(OPENGL_ES_2)
     420    fragmentShaderBuilder.append(fragmentTemplateLT320Vars);
     421#else
     422    if (glVersion >= 320)
     423        fragmentShaderBuilder.append(fragmentTemplateGE320Vars);
     424    else
     425        fragmentShaderBuilder.append(fragmentTemplateLT320Vars);
     426#endif
     427
     428    // Append the common code.
     429    fragmentShaderBuilder.append(fragmentTemplateCommon);
     430
     431    return adoptRef(*new TextureMapperShaderProgram(vertexShaderBuilder.toString(), fragmentShaderBuilder.toString()));
     432}
     433
     434#if !LOG_DISABLED
     435static CString getShaderLog(GLuint shader)
     436{
     437    GLint logLength = 0;
     438    glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &logLength);
     439    if (!logLength)
     440        return { };
     441
     442    auto info = std::make_unique<GLchar[]>(logLength);
     443    GLsizei infoLength = 0;
     444    glGetShaderInfoLog(shader, logLength, &infoLength, info.get());
     445
     446    size_t stringLength = std::max(infoLength, 0);
     447    return { info.get(), stringLength };
     448}
     449
     450static CString getProgramLog(GLuint program)
     451{
     452    GLint logLength = 0;
     453    glGetProgramiv(program, GL_INFO_LOG_LENGTH, &logLength);
     454    if (!logLength)
     455        return { };
     456
     457    auto info = std::make_unique<GLchar[]>(logLength);
     458    GLsizei infoLength = 0;
     459    glGetProgramInfoLog(program, logLength, &infoLength, info.get());
     460
     461    size_t stringLength = std::max(infoLength, 0);
     462    return { info.get(), stringLength };
     463}
     464#endif
     465
     466TextureMapperShaderProgram::TextureMapperShaderProgram(const String& vertex, const String& fragment)
     467{
     468    m_vertexShader = glCreateShader(GL_VERTEX_SHADER);
     469    {
     470        CString vertexCString = vertex.utf8();
     471        const char* data = vertexCString.data();
     472        int length = vertexCString.length();
     473        glShaderSource(m_vertexShader, 1, &data, &length);
     474    }
     475    glCompileShader(m_vertexShader);
     476
     477    m_fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
     478    {
     479        CString fragmentCString = fragment.utf8();
     480        const char* data = fragmentCString.data();
     481        int length = fragmentCString.length();
     482        glShaderSource(m_fragmentShader, 1, &data, &length);
     483    }
     484    glCompileShader(m_fragmentShader);
     485
     486    m_id = glCreateProgram();
     487    glAttachShader(m_id, m_vertexShader);
     488    glAttachShader(m_id, m_fragmentShader);
     489    glLinkProgram(m_id);
     490
     491    if (!compositingLogEnabled() || glGetError() == GL_NO_ERROR)
    361492        return;
    362493
    363     if (m_context->getError() == GraphicsContext3D::NO_ERROR)
    364         return;
    365 
    366     String log = m_context->getShaderInfoLog(m_vertexShader);
    367     LOG(Compositing, "Vertex shader log: %s\n", log.utf8().data());
    368     log = m_context->getShaderInfoLog(m_fragmentShader);
    369     LOG(Compositing, "Fragment shader log: %s\n", log.utf8().data());
    370     log = m_context->getProgramInfoLog(m_id);
    371     LOG(Compositing, "Program log: %s\n", log.utf8().data());
     494    LOG(Compositing, "Vertex shader log: %s\n", getShaderLog(m_vertexShader).data());
     495    LOG(Compositing, "Fragment shader log: %s\n", getShaderLog(m_fragmentShader).data());
     496    LOG(Compositing, "Program log: %s\n", getProgramLog(m_id).data());
    372497}
    373498
    … …  
    377502        return;
    378503
    379     m_context->detachShader(m_id, m_vertexShader);
    380     m_context->deleteShader(m_vertexShader);
    381     m_context->detachShader(m_id, m_fragmentShader);
    382     m_context->deleteShader(m_fragmentShader);
    383     m_context->deleteProgram(m_id);
    384 }
    385 
    386 void TextureMapperShaderProgram::setMatrix(GC3Duint location, const TransformationMatrix& matrix)
     504    glDetachShader(m_id, m_vertexShader);
     505    glDeleteShader(m_vertexShader);
     506    glDetachShader(m_id, m_fragmentShader);
     507    glDeleteShader(m_fragmentShader);
     508    glDeleteProgram(m_id);
     509}
     510
     511void TextureMapperShaderProgram::setMatrix(GLuint location, const TransformationMatrix& matrix)
    387512{
    388513    TransformationMatrix::FloatMatrix4 floatMatrix;
    389514    matrix.toColumnMajorFloatArray(floatMatrix);
    390     m_context->uniformMatrix4fv(location, 1, false, floatMatrix);
    391 }
    392 
    393 GC3Duint TextureMapperShaderProgram::getLocation(const AtomicString& name, VariableType type)
     515    glUniformMatrix4fv(location, 1, false, floatMatrix);
     516}
     517
     518GLuint TextureMapperShaderProgram::getLocation(const AtomicString& name, VariableType type)
    394519{
    395520    auto addResult = m_variables.ensure(name,
    396521        [this, &name, type] {
     522            CString nameCString = name.string().utf8();
    397523            switch (type) {
    398524            case UniformVariable:
    399                 return m_context->getUniformLocation(m_id, name);
     525                return glGetUniformLocation(m_id, nameCString.data());
    400526            case AttribVariable:
    401                 return m_context->getAttribLocation(m_id, name);
     527                return glGetAttribLocation(m_id, nameCString.data());
    402528            }
    403529            ASSERT_NOT_REACHED();

  • trunk/Source/WebCore/platform/graphics/texmap/TextureMapperShaderProgram.h

    r217706 r223833  
    2424#if USE(TEXTURE_MAPPER_GL)
    2525
    26 #include "GraphicsContext3D.h"
     26#include "TextureMapperGLHeaders.h"
    2727#include "TransformationMatrix.h"
    2828#include <wtf/HashMap.h>
    … …  
    3434
    3535#define TEXMAP_DECLARE_VARIABLE(Accessor, Name, Type) \
    36     GC3Duint Accessor##Location() { \
     36    GLuint Accessor##Location() { \
    3737        static NeverDestroyed<const AtomicString> name(Name, AtomicString::ConstructFromLiteral); \
    3838        return getLocation(name.get(), Type); \
    … …  
    6767    typedef unsigned Options;
    6868
    69     static Ref<TextureMapperShaderProgram> create(Ref<GraphicsContext3D>&&, Options);
     69    static Ref<TextureMapperShaderProgram> create(Options);
    7070    virtual ~TextureMapperShaderProgram();
    7171
    72     Platform3DObject programID() const { return m_id; }
    73     GraphicsContext3D& context() { return m_context; }
     72    GLuint programID() const { return m_id; }
    7473
    7574    TEXMAP_DECLARE_ATTRIBUTE(vertex)
    … …  
    9190    TEXMAP_DECLARE_SAMPLER(contentTexture)
    9291
    93     void setMatrix(GC3Duint, const TransformationMatrix&);
     92    void setMatrix(GLuint, const TransformationMatrix&);
    9493
    9594private:
    96     TextureMapperShaderProgram(Ref<GraphicsContext3D>&&, const String& vertexShaderSource, const String& fragmentShaderSource);
     95    TextureMapperShaderProgram(const String& vertexShaderSource, const String& fragmentShaderSource);
    9796
    98     Platform3DObject m_vertexShader;
    99     Platform3DObject m_fragmentShader;
     97    GLuint m_vertexShader;
     98    GLuint m_fragmentShader;
    10099
    101100    enum VariableType { UniformVariable, AttribVariable };
    102     GC3Duint getLocation(const AtomicString&, VariableType);
     101    GLuint getLocation(const AtomicString&, VariableType);
    103102
    104     Ref<GraphicsContext3D> m_context;
    105     Platform3DObject m_id;
    106     HashMap<AtomicString, GC3Duint> m_variables;
     103    GLuint m_id;
     104    HashMap<AtomicString, GLuint> m_variables;
    107105};
    108106
Note: See TracChangeset for help on using the changeset viewer.