Changeset 48325 in webkit


Ignore:
Timestamp:
Sep 11, 2009 5:13:32 PM (15 years ago)
Author:
cmarrin@apple.com
Message:

Added variants to uniform* and vertexAttrib* calls which take sequence<> in place of CanvasArray
​https://bugs.webkit.org/show_bug.cgi?id=29139


I also added a data() call to each of the CanvasArray subclasses to give back a types pointer
to the baseAddress().

Location:
trunk/WebCore
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • trunk/WebCore/ChangeLog

    r48323 r48325  
     12009-09-11  Chris Marrin  <cmarrin@apple.com>
     2
     3        Reviewed by Oliver Hunt.
     4
     5        Added variants to uniform* and vertexAttrib* calls which take sequence<> in place of CanvasArray
     6        https://bugs.webkit.org/show_bug.cgi?id=29139
     7       
     8        I also added a data() call to each of the CanvasArray subclasses to give back a types pointer
     9        to the baseAddress().
     10
     11        * Configurations/FeatureDefines.xcconfig:
     12        * bindings/js/JSCanvasRenderingContext3DCustom.cpp:
     13        (WebCore::toArray):
     14        (WebCore::):
     15        (WebCore::dataFunctionf):
     16        (WebCore::dataFunctioni):
     17        (WebCore::dataFunctionMatrix):
     18        (WebCore::JSCanvasRenderingContext3D::uniform1fv):
     19        (WebCore::JSCanvasRenderingContext3D::uniform1iv):
     20        (WebCore::JSCanvasRenderingContext3D::uniform2fv):
     21        (WebCore::JSCanvasRenderingContext3D::uniform2iv):
     22        (WebCore::JSCanvasRenderingContext3D::uniform3fv):
     23        (WebCore::JSCanvasRenderingContext3D::uniform3iv):
     24        (WebCore::JSCanvasRenderingContext3D::uniform4fv):
     25        (WebCore::JSCanvasRenderingContext3D::uniform4iv):
     26        (WebCore::JSCanvasRenderingContext3D::uniformMatrix2fv):
     27        (WebCore::JSCanvasRenderingContext3D::uniformMatrix3fv):
     28        (WebCore::JSCanvasRenderingContext3D::uniformMatrix4fv):
     29        (WebCore::JSCanvasRenderingContext3D::vertexAttrib1fv):
     30        (WebCore::JSCanvasRenderingContext3D::vertexAttrib2fv):
     31        (WebCore::JSCanvasRenderingContext3D::vertexAttrib3fv):
     32        (WebCore::JSCanvasRenderingContext3D::vertexAttrib4fv):
     33        * html/canvas/CanvasByteArray.h:
     34        (WebCore::CanvasByteArray::data):
     35        * html/canvas/CanvasFloatArray.h:
     36        (WebCore::CanvasFloatArray::data):
     37        * html/canvas/CanvasIntArray.h:
     38        (WebCore::CanvasIntArray::data):
     39        * html/canvas/CanvasRenderingContext3D.cpp:
     40        (WebCore::CanvasRenderingContext3D::uniform1fv):
     41        (WebCore::CanvasRenderingContext3D::uniform1iv):
     42        (WebCore::CanvasRenderingContext3D::uniform2fv):
     43        (WebCore::CanvasRenderingContext3D::uniform2iv):
     44        (WebCore::CanvasRenderingContext3D::uniform3fv):
     45        (WebCore::CanvasRenderingContext3D::uniform3iv):
     46        (WebCore::CanvasRenderingContext3D::uniform4fv):
     47        (WebCore::CanvasRenderingContext3D::uniform4iv):
     48        (WebCore::CanvasRenderingContext3D::uniformMatrix2fv):
     49        (WebCore::CanvasRenderingContext3D::uniformMatrix3fv):
     50        (WebCore::CanvasRenderingContext3D::uniformMatrix4fv):
     51        (WebCore::CanvasRenderingContext3D::vertexAttrib1fv):
     52        (WebCore::CanvasRenderingContext3D::vertexAttrib2fv):
     53        (WebCore::CanvasRenderingContext3D::vertexAttrib3fv):
     54        (WebCore::CanvasRenderingContext3D::vertexAttrib4fv):
     55        * html/canvas/CanvasRenderingContext3D.h:
     56        * html/canvas/CanvasRenderingContext3D.idl:
     57        * html/canvas/CanvasShortArray.h:
     58        (WebCore::CanvasShortArray::data):
     59        * html/canvas/CanvasUnsignedByteArray.h:
     60        (WebCore::CanvasUnsignedByteArray::data):
     61        * html/canvas/CanvasUnsignedIntArray.h:
     62        (WebCore::CanvasUnsignedIntArray::data):
     63        * html/canvas/CanvasUnsignedShortArray.h:
     64        (WebCore::CanvasUnsignedShortArray::data):
     65        * platform/graphics/GraphicsContext3D.h:
     66        * platform/graphics/mac/GraphicsContext3DMac.cpp:
     67        (WebCore::GraphicsContext3D::uniform1fv):
     68        (WebCore::GraphicsContext3D::uniform2fv):
     69        (WebCore::GraphicsContext3D::uniform3fv):
     70        (WebCore::GraphicsContext3D::uniform4fv):
     71        (WebCore::GraphicsContext3D::uniform1iv):
     72        (WebCore::GraphicsContext3D::uniform2iv):
     73        (WebCore::GraphicsContext3D::uniform3iv):
     74        (WebCore::GraphicsContext3D::uniform4iv):
     75        (WebCore::GraphicsContext3D::uniformMatrix2fv):
     76        (WebCore::GraphicsContext3D::uniformMatrix3fv):
     77        (WebCore::GraphicsContext3D::uniformMatrix4fv):
     78        (WebCore::GraphicsContext3D::vertexAttrib1fv):
     79        (WebCore::GraphicsContext3D::vertexAttrib2fv):
     80        (WebCore::GraphicsContext3D::vertexAttrib3fv):
     81        (WebCore::GraphicsContext3D::vertexAttrib4fv):
     82
    1832009-09-11  Fumitoshi Ukai  <ukai@chromium.org>
    284

  • trunk/WebCore/bindings/js/JSCanvasRenderingContext3DCustom.cpp

    r48310 r48325  
    3434#include "HTMLCanvasElement.h"
    3535#include "HTMLImageElement.h"
    36 #include "JSCanvasArray.h"
     36#include "JSCanvasFloatArray.h"
     37#include "JSCanvasIntArray.h"
    3738#include "JSHTMLCanvasElement.h"
    3839#include "JSHTMLImageElement.h"
    … …  
    199200}
    200201
     202template<typename T>
     203void toArray(JSC::ExecState* exec, JSC::JSValue value, T*& array, int& size)
     204{
     205    array = 0;
     206   
     207    if (!value.isObject())
     208        return;
     209       
     210    JSC::JSObject* object = asObject(value);
     211    int length = object->get(exec, JSC::Identifier(exec, "length")).toInt32(exec);
     212    void* tempValues;
     213    if (!tryFastMalloc(length * sizeof(T)).getValue(tempValues))
     214        return;
     215   
     216    T* values = static_cast<T*>(tempValues);
     217    for (int i = 0; i < length; ++i) {
     218        JSC::JSValue v = object->get(exec, i);
     219        if (exec->hadException())
     220            return;
     221        values[i] = static_cast<T>(v.toNumber(exec));
     222    }
     223
     224    array = values;
     225    size = length;
     226}
     227
     228enum DataFunctionToCall {
     229    f_uniform1v, f_uniform2v, f_uniform3v, f_uniform4v,
     230    f_vertexAttrib1v, f_vertexAttrib2v, f_vertexAttrib3v, f_vertexAttrib4v
     231};
     232
     233enum DataFunctionMatrixToCall {
     234    f_uniformMatrix2fv, f_uniformMatrix3fv, f_uniformMatrix4fv
     235};
     236
     237static JSC::JSValue dataFunctionf(DataFunctionToCall f, JSC::ExecState* exec, const JSC::ArgList& args, CanvasRenderingContext3D* context)
     238{
     239    if (args.size() != 2)
     240        return throwError(exec, SyntaxError);
     241
     242    long location = args.at(0).toInt32(exec);
     243    if (exec->hadException())   
     244        return jsUndefined();
     245       
     246    RefPtr<CanvasFloatArray> canvasArray = toCanvasFloatArray(args.at(1));
     247    if (exec->hadException())   
     248        return jsUndefined();
     249       
     250    if (canvasArray) {
     251        switch(f) {
     252            case f_uniform1v: context->uniform1fv(location, canvasArray.get()); break;
     253            case f_uniform2v: context->uniform2fv(location, canvasArray.get()); break;
     254            case f_uniform3v: context->uniform3fv(location, canvasArray.get()); break;
     255            case f_uniform4v: context->uniform4fv(location, canvasArray.get()); break;
     256            case f_vertexAttrib1v: context->vertexAttrib1fv(location, canvasArray.get()); break;
     257            case f_vertexAttrib2v: context->vertexAttrib2fv(location, canvasArray.get()); break;
     258            case f_vertexAttrib3v: context->vertexAttrib3fv(location, canvasArray.get()); break;
     259            case f_vertexAttrib4v: context->vertexAttrib4fv(location, canvasArray.get()); break;
     260        }
     261        return jsUndefined();
     262    }
     263   
     264    float* array;
     265    int size;
     266    toArray<float>(exec, args.at(1), array, size);
     267   
     268    if (!array)
     269        return throwError(exec, TypeError);
     270
     271    switch(f) {
     272        case f_uniform1v: context->uniform1fv(location, array, size); break;
     273        case f_uniform2v: context->uniform2fv(location, array, size); break;
     274        case f_uniform3v: context->uniform3fv(location, array, size); break;
     275        case f_uniform4v: context->uniform4fv(location, array, size); break;
     276        case f_vertexAttrib1v: context->vertexAttrib1fv(location, array, size); break;
     277        case f_vertexAttrib2v: context->vertexAttrib2fv(location, array, size); break;
     278        case f_vertexAttrib3v: context->vertexAttrib3fv(location, array, size); break;
     279        case f_vertexAttrib4v: context->vertexAttrib4fv(location, array, size); break;
     280    }
     281    return jsUndefined();
     282}
     283
     284static JSC::JSValue dataFunctioni(DataFunctionToCall f, JSC::ExecState* exec, const JSC::ArgList& args, CanvasRenderingContext3D* context)
     285{
     286    if (args.size() != 2)
     287        return throwError(exec, SyntaxError);
     288
     289    long location = args.at(0).toInt32(exec);
     290    if (exec->hadException())   
     291        return jsUndefined();
     292       
     293    RefPtr<CanvasIntArray> canvasArray = toCanvasIntArray(args.at(1));
     294    if (exec->hadException())   
     295        return jsUndefined();
     296       
     297    if (canvasArray) {
     298        switch(f) {
     299            case f_uniform1v: context->uniform1iv(location, canvasArray.get()); break;
     300            case f_uniform2v: context->uniform2iv(location, canvasArray.get()); break;
     301            case f_uniform3v: context->uniform3iv(location, canvasArray.get()); break;
     302            case f_uniform4v: context->uniform4iv(location, canvasArray.get()); break;
     303            default: break;
     304        }
     305        return jsUndefined();
     306    }
     307   
     308    int* array;
     309    int size;
     310    toArray<int>(exec, args.at(1), array, size);
     311   
     312    if (!array)
     313        return throwError(exec, TypeError);
     314
     315    switch(f) {
     316        case f_uniform1v: context->uniform1iv(location, array, size); break;
     317        case f_uniform2v: context->uniform2iv(location, array, size); break;
     318        case f_uniform3v: context->uniform3iv(location, array, size); break;
     319        case f_uniform4v: context->uniform4iv(location, array, size); break;
     320        default: break;
     321    }
     322    return jsUndefined();
     323}
     324
     325static JSC::JSValue dataFunctionMatrix(DataFunctionMatrixToCall f, JSC::ExecState* exec, const JSC::ArgList& args, CanvasRenderingContext3D* context)
     326{
     327    if (args.size() != 3)
     328        return throwError(exec, SyntaxError);
     329
     330    long location = args.at(0).toInt32(exec);
     331    if (exec->hadException())   
     332        return jsUndefined();
     333       
     334    bool transpose = args.at(1).toBoolean(exec);
     335    if (exec->hadException())   
     336        return jsUndefined();
     337       
     338    RefPtr<CanvasFloatArray> canvasArray = toCanvasFloatArray(args.at(2));
     339    if (exec->hadException())   
     340        return jsUndefined();
     341       
     342    if (canvasArray) {
     343        switch(f) {
     344            case f_uniformMatrix2fv: context->uniformMatrix2fv(location, transpose, canvasArray.get()); break;
     345            case f_uniformMatrix3fv: context->uniformMatrix3fv(location, transpose, canvasArray.get()); break;
     346            case f_uniformMatrix4fv: context->uniformMatrix4fv(location, transpose, canvasArray.get()); break;
     347        }
     348        return jsUndefined();
     349    }
     350   
     351    float* array;
     352    int size;
     353    toArray<float>(exec, args.at(2), array, size);
     354   
     355    if (!array)
     356        return throwError(exec, TypeError);
     357
     358    switch(f) {
     359        case f_uniformMatrix2fv: context->uniformMatrix2fv(location, transpose, array, size); break;
     360        case f_uniformMatrix3fv: context->uniformMatrix3fv(location, transpose, array, size); break;
     361        case f_uniformMatrix4fv: context->uniformMatrix4fv(location, transpose, array, size); break;
     362    }
     363    return jsUndefined();
     364}
     365
     366JSC::JSValue JSCanvasRenderingContext3D::uniform1fv(JSC::ExecState* exec, const JSC::ArgList& args)
     367{
     368    return dataFunctionf(f_uniform1v, exec, args, static_cast<CanvasRenderingContext3D*>(impl()));
     369}
     370
     371JSC::JSValue JSCanvasRenderingContext3D::uniform1iv(JSC::ExecState* exec, const JSC::ArgList& args)
     372{
     373    return dataFunctioni(f_uniform1v, exec, args, static_cast<CanvasRenderingContext3D*>(impl()));
     374}
     375
     376JSC::JSValue JSCanvasRenderingContext3D::uniform2fv(JSC::ExecState* exec, const JSC::ArgList& args)
     377{
     378    return dataFunctionf(f_uniform2v, exec, args, static_cast<CanvasRenderingContext3D*>(impl()));
     379}
     380
     381JSC::JSValue JSCanvasRenderingContext3D::uniform2iv(JSC::ExecState* exec, const JSC::ArgList& args)
     382{
     383    return dataFunctioni(f_uniform2v, exec, args, static_cast<CanvasRenderingContext3D*>(impl()));
     384}
     385
     386JSC::JSValue JSCanvasRenderingContext3D::uniform3fv(JSC::ExecState* exec, const JSC::ArgList& args)
     387{
     388    return dataFunctionf(f_uniform3v, exec, args, static_cast<CanvasRenderingContext3D*>(impl()));
     389}
     390
     391JSC::JSValue JSCanvasRenderingContext3D::uniform3iv(JSC::ExecState* exec, const JSC::ArgList& args)
     392{
     393    return dataFunctioni(f_uniform3v, exec, args, static_cast<CanvasRenderingContext3D*>(impl()));
     394}
     395
     396JSC::JSValue JSCanvasRenderingContext3D::uniform4fv(JSC::ExecState* exec, const JSC::ArgList& args)
     397{
     398    return dataFunctionf(f_uniform4v, exec, args, static_cast<CanvasRenderingContext3D*>(impl()));
     399}
     400
     401JSC::JSValue JSCanvasRenderingContext3D::uniform4iv(JSC::ExecState* exec, const JSC::ArgList& args)
     402{
     403    return dataFunctioni(f_uniform4v, exec, args, static_cast<CanvasRenderingContext3D*>(impl()));
     404}
     405
     406JSC::JSValue JSCanvasRenderingContext3D::uniformMatrix2fv(JSC::ExecState* exec, const JSC::ArgList& args)
     407{
     408    return dataFunctionMatrix(f_uniformMatrix2fv, exec, args, static_cast<CanvasRenderingContext3D*>(impl()));
     409}
     410
     411JSC::JSValue JSCanvasRenderingContext3D::uniformMatrix3fv(JSC::ExecState* exec, const JSC::ArgList& args)
     412{
     413    return dataFunctionMatrix(f_uniformMatrix3fv, exec, args, static_cast<CanvasRenderingContext3D*>(impl()));
     414}
     415
     416JSC::JSValue JSCanvasRenderingContext3D::uniformMatrix4fv(JSC::ExecState* exec, const JSC::ArgList& args)
     417{
     418    return dataFunctionMatrix(f_uniformMatrix4fv, exec, args, static_cast<CanvasRenderingContext3D*>(impl()));
     419}
     420
     421JSC::JSValue JSCanvasRenderingContext3D::vertexAttrib1fv(JSC::ExecState* exec, const JSC::ArgList& args)
     422{
     423    return dataFunctionf(f_vertexAttrib1v, exec, args, static_cast<CanvasRenderingContext3D*>(impl()));
     424}
     425
     426JSC::JSValue JSCanvasRenderingContext3D::vertexAttrib2fv(JSC::ExecState* exec, const JSC::ArgList& args)
     427{
     428    return dataFunctionf(f_vertexAttrib2v, exec, args, static_cast<CanvasRenderingContext3D*>(impl()));
     429}
     430
     431JSC::JSValue JSCanvasRenderingContext3D::vertexAttrib3fv(JSC::ExecState* exec, const JSC::ArgList& args)
     432{
     433    return dataFunctionf(f_vertexAttrib3v, exec, args, static_cast<CanvasRenderingContext3D*>(impl()));
     434}
     435
     436JSC::JSValue JSCanvasRenderingContext3D::vertexAttrib4fv(JSC::ExecState* exec, const JSC::ArgList& args)
     437{
     438    return dataFunctionf(f_vertexAttrib4v, exec, args, static_cast<CanvasRenderingContext3D*>(impl()));
     439}
     440
    201441} // namespace WebCore
    202442

  • trunk/WebCore/html/canvas/CanvasByteArray.h

    r48200 r48325  
    4242        static PassRefPtr<CanvasByteArray> create(PassRefPtr<CanvasArrayBuffer> buffer, int offset, unsigned length);
    4343
     44        char* data() { return static_cast<char*>(baseAddress()); }
     45
    4446        virtual unsigned length() const;
    4547        virtual unsigned sizeInBytes() const;

  • trunk/WebCore/html/canvas/CanvasFloatArray.h

    r48200 r48325  
    3939        static PassRefPtr<CanvasFloatArray> create(float* array, unsigned length);
    4040        static PassRefPtr<CanvasFloatArray> create(PassRefPtr<CanvasArrayBuffer> buffer, int offset, unsigned length);
     41
     42        float* data() { return static_cast<float*>(baseAddress()); }
    4143
    4244        virtual unsigned length() const;

  • trunk/WebCore/html/canvas/CanvasIntArray.h

    r48200 r48325  
    3939        static PassRefPtr<CanvasIntArray> create(int* array, unsigned length);
    4040        static PassRefPtr<CanvasIntArray> create(PassRefPtr<CanvasArrayBuffer> buffer, int offset, unsigned length);
     41
     42        int* data() { return static_cast<int*>(baseAddress()); }
    4143
    4244        virtual unsigned length() const;

  • trunk/WebCore/html/canvas/CanvasRenderingContext3D.cpp

    r48150 r48325  
    982982        return;
    983983       
    984     m_context.uniform1fv(location, v);
     984    m_context.uniform1fv(location, v->data(), v->length());
     985    cleanupAfterGraphicsCall(false);
     986}
     987
     988void CanvasRenderingContext3D::uniform1fv(long location, float* v, int size)
     989{
     990    // FIXME: we need to throw if no array passed in
     991    if (!v)
     992        return;
     993       
     994    m_context.uniform1fv(location, v, size);
    985995    cleanupAfterGraphicsCall(false);
    986996}
    … …  
    9981008        return;
    9991009       
    1000     m_context.uniform1iv(location, v);
     1010    m_context.uniform1iv(location, v->data(), v->length());
     1011    cleanupAfterGraphicsCall(false);
     1012}
     1013
     1014void CanvasRenderingContext3D::uniform1iv(long location, int* v, int size)
     1015{
     1016    // FIXME: we need to throw if no array passed in
     1017    if (!v)
     1018        return;
     1019       
     1020    m_context.uniform1iv(location, v, size);
    10011021    cleanupAfterGraphicsCall(false);
    10021022}
    … …  
    10141034        return;
    10151035       
    1016     m_context.uniform2fv(location, v);
     1036    // FIXME: length needs to be a multiple of 2
     1037    m_context.uniform2fv(location, v->data(), v->length() / 2);
     1038    cleanupAfterGraphicsCall(false);
     1039}
     1040
     1041void CanvasRenderingContext3D::uniform2fv(long location, float* v, int size)
     1042{
     1043    // FIXME: we need to throw if no array passed in
     1044    if (!v)
     1045        return;
     1046       
     1047    // FIXME: length needs to be a multiple of 2
     1048    m_context.uniform2fv(location, v, size / 2);
    10171049    cleanupAfterGraphicsCall(false);
    10181050}
    … …  
    10301062        return;
    10311063       
    1032     m_context.uniform2iv(location, v);
     1064    // FIXME: length needs to be a multiple of 2
     1065    m_context.uniform2iv(location, v->data(), v->length() / 2);
     1066    cleanupAfterGraphicsCall(false);
     1067}
     1068
     1069void CanvasRenderingContext3D::uniform2iv(long location, int* v, int size)
     1070{
     1071    // FIXME: we need to throw if no array passed in
     1072    if (!v)
     1073        return;
     1074       
     1075    // FIXME: length needs to be a multiple of 2
     1076    m_context.uniform2iv(location, v, size / 2);
    10331077    cleanupAfterGraphicsCall(false);
    10341078}
    … …  
    10461090        return;
    10471091       
    1048     m_context.uniform3fv(location, v);
     1092    // FIXME: length needs to be a multiple of 3
     1093    m_context.uniform3fv(location, v->data(), v->length() / 3);
     1094    cleanupAfterGraphicsCall(false);
     1095}
     1096
     1097void CanvasRenderingContext3D::uniform3fv(long location, float* v, int size)
     1098{
     1099    // FIXME: we need to throw if no array passed in
     1100    if (!v)
     1101        return;
     1102       
     1103    // FIXME: length needs to be a multiple of 3
     1104    m_context.uniform3fv(location, v, size / 3);
    10491105    cleanupAfterGraphicsCall(false);
    10501106}
    … …  
    10621118        return;
    10631119       
    1064     m_context.uniform3iv(location, v);
     1120    // FIXME: length needs to be a multiple of 3
     1121    m_context.uniform3iv(location, v->data(), v->length() / 3);
     1122    cleanupAfterGraphicsCall(false);
     1123}
     1124
     1125void CanvasRenderingContext3D::uniform3iv(long location, int* v, int size)
     1126{
     1127    // FIXME: we need to throw if no array passed in
     1128    if (!v)
     1129        return;
     1130       
     1131    // FIXME: length needs to be a multiple of 3
     1132    m_context.uniform3iv(location, v, size / 3);
    10651133    cleanupAfterGraphicsCall(false);
    10661134}
    … …  
    10781146        return;
    10791147       
    1080     m_context.uniform4fv(location, v);
     1148    // FIXME: length needs to be a multiple of 4
     1149    m_context.uniform4fv(location, v->data(), v->length() / 4);
     1150    cleanupAfterGraphicsCall(false);
     1151}
     1152
     1153void CanvasRenderingContext3D::uniform4fv(long location, float* v, int size)
     1154{
     1155    // FIXME: we need to throw if no array passed in
     1156    if (!v)
     1157        return;
     1158       
     1159    // FIXME: length needs to be a multiple of 4
     1160    m_context.uniform4fv(location, v, size / 4);
    10811161    cleanupAfterGraphicsCall(false);
    10821162}
    … …  
    10941174        return;
    10951175       
    1096     m_context.uniform4iv(location, v);
    1097     cleanupAfterGraphicsCall(false);
    1098 }
    1099 
    1100 void CanvasRenderingContext3D::uniformMatrix2fv(long location, bool transpose, CanvasFloatArray* value)
    1101 {
    1102     // FIXME: we need to throw if no array passed in
    1103     if (!value)
    1104         return;
    1105        
    1106     m_context.uniformMatrix2fv(location, transpose, value);
    1107     cleanupAfterGraphicsCall(false);
    1108 }
    1109 
    1110 void CanvasRenderingContext3D::uniformMatrix3fv(long location, bool transpose, CanvasFloatArray* value)
    1111 {
    1112     // FIXME: we need to throw if no array passed in
    1113     if (!value)
    1114         return;
    1115        
    1116     m_context.uniformMatrix3fv(location, transpose, value);
    1117     cleanupAfterGraphicsCall(false);
    1118 }
    1119 
    1120 void CanvasRenderingContext3D::uniformMatrix4fv(long location, bool transpose, CanvasFloatArray* value)
    1121 {
    1122     // FIXME: we need to throw if no array passed in
    1123     if (!value)
    1124         return;
    1125        
    1126     m_context.uniformMatrix4fv(location, transpose, value);
     1176    // FIXME: length needs to be a multiple of 4
     1177    m_context.uniform4iv(location, v->data(), v->length() / 4);
     1178    cleanupAfterGraphicsCall(false);
     1179}
     1180
     1181void CanvasRenderingContext3D::uniform4iv(long location, int* v, int size)
     1182{
     1183    // FIXME: we need to throw if no array passed in
     1184    if (!v)
     1185        return;
     1186       
     1187    // FIXME: length needs to be a multiple of 4
     1188    m_context.uniform4iv(location, v, size / 4);
     1189    cleanupAfterGraphicsCall(false);
     1190}
     1191
     1192void CanvasRenderingContext3D::uniformMatrix2fv(long location, bool transpose, CanvasFloatArray* v)
     1193{
     1194    // FIXME: we need to throw if no array passed in
     1195    if (!v)
     1196        return;
     1197       
     1198    // FIXME: length needs to be a multiple of 4
     1199    m_context.uniformMatrix2fv(location, transpose, v->data(), v->length() / 4);
     1200    cleanupAfterGraphicsCall(false);
     1201}
     1202
     1203void CanvasRenderingContext3D::uniformMatrix2fv(long location, bool transpose, float* v, int size)
     1204{
     1205    // FIXME: we need to throw if no array passed in
     1206    if (!v)
     1207        return;
     1208       
     1209    // FIXME: length needs to be a multiple of 4
     1210    m_context.uniformMatrix2fv(location, transpose, v, size / 4);
     1211    cleanupAfterGraphicsCall(false);
     1212}
     1213
     1214void CanvasRenderingContext3D::uniformMatrix3fv(long location, bool transpose, CanvasFloatArray* v)
     1215{
     1216    // FIXME: we need to throw if no array passed in
     1217    if (!v)
     1218        return;
     1219       
     1220    // FIXME: length needs to be a multiple of 9
     1221    m_context.uniformMatrix3fv(location, transpose, v->data(), v->length() / 9);
     1222    cleanupAfterGraphicsCall(false);
     1223}
     1224
     1225void CanvasRenderingContext3D::uniformMatrix3fv(long location, bool transpose, float* v, int size)
     1226{
     1227    // FIXME: we need to throw if no array passed in
     1228    if (!v)
     1229        return;
     1230       
     1231    // FIXME: length needs to be a multiple of 9
     1232    m_context.uniformMatrix3fv(location, transpose, v, size / 9);
     1233    cleanupAfterGraphicsCall(false);
     1234}
     1235
     1236void CanvasRenderingContext3D::uniformMatrix4fv(long location, bool transpose, CanvasFloatArray* v)
     1237{
     1238    // FIXME: we need to throw if no array passed in
     1239    if (!v)
     1240        return;
     1241       
     1242    // FIXME: length needs to be a multiple of 16
     1243    m_context.uniformMatrix4fv(location, transpose, v->data(), v->length() / 16);
     1244    cleanupAfterGraphicsCall(false);
     1245}
     1246
     1247void CanvasRenderingContext3D::uniformMatrix4fv(long location, bool transpose, float* v, int size)
     1248{
     1249    // FIXME: we need to throw if no array passed in
     1250    if (!v)
     1251        return;
     1252       
     1253    // FIXME: length needs to be a multiple of 16
     1254    m_context.uniformMatrix4fv(location, transpose, v, size / 16);
    11271255    cleanupAfterGraphicsCall(false);
    11281256}
    … …  
    11461274}
    11471275
    1148 void CanvasRenderingContext3D::vertexAttrib1fv(unsigned long indx, CanvasFloatArray* values)
    1149 {
    1150     m_context.vertexAttrib1fv(indx, values);
     1276void CanvasRenderingContext3D::vertexAttrib1fv(unsigned long indx, CanvasFloatArray* v)
     1277{
     1278    // FIXME: Need to make sure array is big enough for attribute being set
     1279    m_context.vertexAttrib1fv(indx, v->data());
     1280    cleanupAfterGraphicsCall(false);
     1281}
     1282
     1283void CanvasRenderingContext3D::vertexAttrib1fv(unsigned long indx, float* v, int size)
     1284{
     1285    // FIXME: Need to make sure array is big enough for attribute being set
     1286    UNUSED_PARAM(size);
     1287   
     1288    m_context.vertexAttrib1fv(indx, v);
    11511289    cleanupAfterGraphicsCall(false);
    11521290}
    … …  
    11581296}
    11591297
    1160 void CanvasRenderingContext3D::vertexAttrib2fv(unsigned long indx, CanvasFloatArray* values)
    1161 {
    1162     m_context.vertexAttrib2fv(indx, values);
     1298void CanvasRenderingContext3D::vertexAttrib2fv(unsigned long indx, CanvasFloatArray* v)
     1299{
     1300    // FIXME: Need to make sure array is big enough for attribute being set
     1301    m_context.vertexAttrib2fv(indx, v->data());
     1302    cleanupAfterGraphicsCall(false);
     1303}
     1304
     1305void CanvasRenderingContext3D::vertexAttrib2fv(unsigned long indx, float* v, int size)
     1306{
     1307    // FIXME: Need to make sure array is big enough for attribute being set
     1308    UNUSED_PARAM(size);
     1309   
     1310    m_context.vertexAttrib2fv(indx, v);
    11631311    cleanupAfterGraphicsCall(false);
    11641312}
    … …  
    11701318}
    11711319
    1172 void CanvasRenderingContext3D::vertexAttrib3fv(unsigned long indx, CanvasFloatArray* values)
    1173 {
    1174     m_context.vertexAttrib3fv(indx, values);
     1320void CanvasRenderingContext3D::vertexAttrib3fv(unsigned long indx, CanvasFloatArray* v)
     1321{
     1322    // FIXME: Need to make sure array is big enough for attribute being set
     1323    m_context.vertexAttrib3fv(indx, v->data());
     1324    cleanupAfterGraphicsCall(false);
     1325}
     1326
     1327void CanvasRenderingContext3D::vertexAttrib3fv(unsigned long indx, float* v, int size)
     1328{
     1329    // FIXME: Need to make sure array is big enough for attribute being set
     1330    UNUSED_PARAM(size);
     1331   
     1332    m_context.vertexAttrib3fv(indx, v);
    11751333    cleanupAfterGraphicsCall(false);
    11761334}
    … …  
    11821340}
    11831341
    1184 void CanvasRenderingContext3D::vertexAttrib4fv(unsigned long indx, CanvasFloatArray* values)
    1185 {
    1186     m_context.vertexAttrib4fv(indx, values);
     1342void CanvasRenderingContext3D::vertexAttrib4fv(unsigned long indx, CanvasFloatArray* v)
     1343{
     1344    // FIXME: Need to make sure array is big enough for attribute being set
     1345    m_context.vertexAttrib4fv(indx, v->data());
     1346    cleanupAfterGraphicsCall(false);
     1347}
     1348
     1349void CanvasRenderingContext3D::vertexAttrib4fv(unsigned long indx, float* v, int size)
     1350{
     1351    // FIXME: Need to make sure array is big enough for attribute being set
     1352    UNUSED_PARAM(size);
     1353   
     1354    m_context.vertexAttrib4fv(indx, v);
    11871355    cleanupAfterGraphicsCall(false);
    11881356}

  • trunk/WebCore/html/canvas/CanvasRenderingContext3D.h

    r48150 r48325  
    237237        void uniform1f(long location, float x);
    238238        void uniform1fv(long location, CanvasFloatArray* v);
     239        void uniform1fv(long location, float* v, int size);
    239240        void uniform1i(long location, int x);
    240241        void uniform1iv(long location, CanvasIntArray* v);
     242        void uniform1iv(long location, int* v, int size);
    241243        void uniform2f(long location, float x, float y);
    242244        void uniform2fv(long location, CanvasFloatArray* v);
     245        void uniform2fv(long location, float* v, int size);
    243246        void uniform2i(long location, int x, int y);
    244247        void uniform2iv(long location, CanvasIntArray* v);
     248        void uniform2iv(long location, int* v, int size);
    245249        void uniform3f(long location, float x, float y, float z);
    246250        void uniform3fv(long location, CanvasFloatArray* v);
     251        void uniform3fv(long location, float* v, int size);
    247252        void uniform3i(long location, int x, int y, int z);
    248253        void uniform3iv(long location, CanvasIntArray* v);
     254        void uniform3iv(long location, int* v, int size);
    249255        void uniform4f(long location, float x, float y, float z, float w);
    250256        void uniform4fv(long location, CanvasFloatArray* v);
     257        void uniform4fv(long location, float* v, int size);
    251258        void uniform4i(long location, int x, int y, int z, int w);
    252259        void uniform4iv(long location, CanvasIntArray* v);
     260        void uniform4iv(long location, int* v, int size);
    253261        void uniformMatrix2fv(long location, bool transpose, CanvasFloatArray* value);
     262        void uniformMatrix2fv(long location, bool transpose, float* value, int size);
    254263        void uniformMatrix3fv(long location, bool transpose, CanvasFloatArray* value);
     264        void uniformMatrix3fv(long location, bool transpose, float* value, int size);
    255265        void uniformMatrix4fv(long location, bool transpose, CanvasFloatArray* value);
     266        void uniformMatrix4fv(long location, bool transpose, float* value, int size);
    256267
    257268        void useProgram(CanvasProgram*);
    … …  
    260271        void vertexAttrib1f(unsigned long indx, float x);
    261272        void vertexAttrib1fv(unsigned long indx, CanvasFloatArray* values);
     273        void vertexAttrib1fv(unsigned long indx, float* values, int size);
    262274        void vertexAttrib2f(unsigned long indx, float x, float y);
    263275        void vertexAttrib2fv(unsigned long indx, CanvasFloatArray* values);
     276        void vertexAttrib2fv(unsigned long indx, float* values, int size);
    264277        void vertexAttrib3f(unsigned long indx, float x, float y, float z);
    265278        void vertexAttrib3fv(unsigned long indx, CanvasFloatArray* values);
     279        void vertexAttrib3fv(unsigned long indx, float* values, int size);
    266280        void vertexAttrib4f(unsigned long indx, float x, float y, float z, float w);
    267281        void vertexAttrib4fv(unsigned long indx, CanvasFloatArray* values);
     282        void vertexAttrib4fv(unsigned long indx, float* values, int size);
    268283        void vertexAttribPointer(unsigned long indx, long size, unsigned long type, bool normalized,
    269284                                 unsigned long stride, unsigned long offset);

  • trunk/WebCore/html/canvas/CanvasRenderingContext3D.idl

    r48150 r48325  
    648648
    649649        void uniform1f(in long location, in float x);
    650         void uniform1fv(in long location, in CanvasFloatArray v);
     650        [Custom] void uniform1fv(in long location, in CanvasFloatArray v);
    651651        void uniform1i(in long location, in long x);
    652         void uniform1iv(in long location, in CanvasIntArray v);
     652        [Custom] void uniform1iv(in long location, in CanvasIntArray v);
    653653        void uniform2f(in long location, in float x, in float y);
    654         void uniform2fv(in long location, in CanvasFloatArray v);
     654        [Custom] void uniform2fv(in long location, in CanvasFloatArray v);
    655655        void uniform2i(in long location, in long x, in long y);
    656         void uniform2iv(in long location, in CanvasIntArray v);
     656        [Custom] void uniform2iv(in long location, in CanvasIntArray v);
    657657        void uniform3f(in long location, in float x, in float y, in float z);
    658         void uniform3fv(in long location, in CanvasFloatArray v);
     658        [Custom] void uniform3fv(in long location, in CanvasFloatArray v);
    659659        void uniform3i(in long location, in long x, in long y, in long z);
    660         void uniform3iv(in long location, in CanvasIntArray v);
     660        [Custom] void uniform3iv(in long location, in CanvasIntArray v);
    661661        void uniform4f(in long location, in float x, in float y, in float z, in float w);
    662         void uniform4fv(in long location, in CanvasFloatArray v);
     662        [Custom] void uniform4fv(in long location, in CanvasFloatArray v);
    663663        void uniform4i(in long location, in long x, in long y, in long z, in long w);
    664         void uniform4iv(in long location, in CanvasIntArray v);
    665 
    666         void uniformMatrix2fv(in long location, in boolean transpose, in CanvasFloatArray array);
    667         void uniformMatrix3fv(in long location, in boolean transpose, in CanvasFloatArray array);
    668         void uniformMatrix4fv(in long location, in boolean transpose, in CanvasFloatArray array);
     664        [Custom] void uniform4iv(in long location, in CanvasIntArray v);
     665
     666        [Custom] void uniformMatrix2fv(in long location, in boolean transpose, in CanvasFloatArray array);
     667        [Custom] void uniformMatrix3fv(in long location, in boolean transpose, in CanvasFloatArray array);
     668        [Custom] void uniformMatrix4fv(in long location, in boolean transpose, in CanvasFloatArray array);
    669669
    670670        void         useProgram(in CanvasProgram program);
    … …  
    672672
    673673        void         vertexAttrib1f(in unsigned long indx, in float x);
    674         void         vertexAttrib1fv(in unsigned long indx, in CanvasFloatArray values);
     674        [Custom] void         vertexAttrib1fv(in unsigned long indx, in CanvasFloatArray values);
    675675        void         vertexAttrib2f(in unsigned long indx, in float x, in float y);
    676         void         vertexAttrib2fv(in unsigned long indx, in CanvasFloatArray values);
     676        [Custom] void         vertexAttrib2fv(in unsigned long indx, in CanvasFloatArray values);
    677677        void         vertexAttrib3f(in unsigned long indx, in float x, in float y, in float z);
    678         void         vertexAttrib3fv(in unsigned long indx, in CanvasFloatArray values);
     678        [Custom] void         vertexAttrib3fv(in unsigned long indx, in CanvasFloatArray values);
    679679        void         vertexAttrib4f(in unsigned long indx, in float x, in float y, in float z, in float w);
    680         void         vertexAttrib4fv(in unsigned long indx, in CanvasFloatArray values);
     680        [Custom] void         vertexAttrib4fv(in unsigned long indx, in CanvasFloatArray values);
    681681        void         vertexAttribPointer(in unsigned long indx, in long size, in unsigned long type, in boolean normalized,
    682682                                         in long stride, in unsigned long offset);

  • trunk/WebCore/html/canvas/CanvasShortArray.h

    r48200 r48325  
    4040        static PassRefPtr<CanvasShortArray> create(PassRefPtr<CanvasArrayBuffer> buffer, int offset, unsigned length);
    4141
     42        short* data() { return static_cast<short*>(baseAddress()); }
     43
    4244        virtual unsigned length() const;
    4345        virtual unsigned sizeInBytes() const;

  • trunk/WebCore/html/canvas/CanvasUnsignedByteArray.h

    r48200 r48325  
    4040        static PassRefPtr<CanvasUnsignedByteArray> create(PassRefPtr<CanvasArrayBuffer> buffer, int offset, unsigned length);
    4141
     42        unsigned char* data() { return static_cast<unsigned char*>(baseAddress()); }
     43       
    4244        virtual unsigned length() const;
    4345        virtual unsigned sizeInBytes() const;

  • trunk/WebCore/html/canvas/CanvasUnsignedIntArray.h

    r48200 r48325  
    4040        static PassRefPtr<CanvasUnsignedIntArray> create(PassRefPtr<CanvasArrayBuffer> buffer, int offset, unsigned length);
    4141
     42        unsigned int* data() { return static_cast<unsigned int*>(baseAddress()); }
     43       
    4244        virtual unsigned length() const;
    4345        virtual unsigned sizeInBytes() const;

  • trunk/WebCore/html/canvas/CanvasUnsignedShortArray.h

    r48200 r48325  
    4040        static PassRefPtr<CanvasUnsignedShortArray> create(PassRefPtr<CanvasArrayBuffer> buffer, int offset, unsigned length);
    4141
     42        unsigned short* data() { return static_cast<unsigned short*>(baseAddress()); }
     43       
    4244        virtual unsigned length() const;
    4345        virtual unsigned sizeInBytes() const;

  • trunk/WebCore/platform/graphics/GraphicsContext3D.h

    r48150 r48325  
    250250
    251251        void uniform1f(long location, float x);
    252         void uniform1fv(long location, CanvasFloatArray* v);
     252        void uniform1fv(long location, float* v, int size);
    253253        void uniform1i(long location, int x);
    254         void uniform1iv(long location, CanvasIntArray* v);
     254        void uniform1iv(long location, int* v, int size);
    255255        void uniform2f(long location, float x, float y);
    256         void uniform2fv(long location, CanvasFloatArray* v);
     256        void uniform2fv(long location, float* v, int size);
    257257        void uniform2i(long location, int x, int y);
    258         void uniform2iv(long location, CanvasIntArray* v);
     258        void uniform2iv(long location, int* v, int size);
    259259        void uniform3f(long location, float x, float y, float z);
    260         void uniform3fv(long location, CanvasFloatArray* v);
     260        void uniform3fv(long location, float* v, int size);
    261261        void uniform3i(long location, int x, int y, int z);
    262         void uniform3iv(long location, CanvasIntArray* v);
     262        void uniform3iv(long location, int* v, int size);
    263263        void uniform4f(long location, float x, float y, float z, float w);
    264         void uniform4fv(long location, CanvasFloatArray* v);
     264        void uniform4fv(long location, float* v, int size);
    265265        void uniform4i(long location, int x, int y, int z, int w);
    266         void uniform4iv(long location, CanvasIntArray* v);
    267         void uniformMatrix2fv(long location, bool transpose, CanvasFloatArray* value);
    268         void uniformMatrix3fv(long location, bool transpose, CanvasFloatArray* value);
    269         void uniformMatrix4fv(long location, bool transpose, CanvasFloatArray* value);
     266        void uniform4iv(long location, int* v, int size);
     267        void uniformMatrix2fv(long location, bool transpose, float* value, int size);
     268        void uniformMatrix3fv(long location, bool transpose, float* value, int size);
     269        void uniformMatrix4fv(long location, bool transpose, float* value, int size);
    270270
    271271        void useProgram(CanvasProgram*);
    … …  
    273273
    274274        void vertexAttrib1f(unsigned long indx, float x);
    275         void vertexAttrib1fv(unsigned long indx, CanvasFloatArray* values);
     275        void vertexAttrib1fv(unsigned long indx, float* values);
    276276        void vertexAttrib2f(unsigned long indx, float x, float y);
    277         void vertexAttrib2fv(unsigned long indx, CanvasFloatArray* values);
     277        void vertexAttrib2fv(unsigned long indx, float* values);
    278278        void vertexAttrib3f(unsigned long indx, float x, float y, float z);
    279         void vertexAttrib3fv(unsigned long indx, CanvasFloatArray* values);
     279        void vertexAttrib3fv(unsigned long indx, float* values);
    280280        void vertexAttrib4f(unsigned long indx, float x, float y, float z, float w);
    281         void vertexAttrib4fv(unsigned long indx, CanvasFloatArray* values);
     281        void vertexAttrib4fv(unsigned long indx, float* values);
    282282        void vertexAttribPointer(unsigned long indx, int size, int type, bool normalized,
    283283                                 unsigned long stride, unsigned long offset);

  • trunk/WebCore/platform/graphics/mac/GraphicsContext3DMac.cpp

    r48310 r48325  
    649649}
    650650
    651 void GraphicsContext3D::uniform1fv(long location, CanvasFloatArray* array)
    652 {
    653     ensureContext(m_contextObj);
    654     ::glUniform1fv(location, array->length(), static_cast<GLfloat*>(array->baseAddress()));
     651void GraphicsContext3D::uniform1fv(long location, float* array, int size)
     652{
     653    ensureContext(m_contextObj);
     654    ::glUniform1fv(location, size, array);
    655655}
    656656
    … …  
    661661}
    662662
    663 void GraphicsContext3D::uniform2fv(long location, CanvasFloatArray* array)
     663void GraphicsContext3D::uniform2fv(long location, float* array, int size)
    664664{
    665665    // FIXME: length needs to be a multiple of 2
    666666    ensureContext(m_contextObj);
    667     ::glUniform2fv(location, array->length() / 2, static_cast<GLfloat*>(array->baseAddress()));
     667    ::glUniform2fv(location, size, array);
    668668}
    669669
    … …  
    674674}
    675675
    676 void GraphicsContext3D::uniform3fv(long location, CanvasFloatArray* array)
     676void GraphicsContext3D::uniform3fv(long location, float* array, int size)
    677677{
    678678    // FIXME: length needs to be a multiple of 3
    679679    ensureContext(m_contextObj);
    680     ::glUniform3fv(location, array->length() / 3, static_cast<GLfloat*>(array->baseAddress()));
     680    ::glUniform3fv(location, size, array);
    681681}
    682682
    … …  
    687687}
    688688
    689 void GraphicsContext3D::uniform4fv(long location, CanvasFloatArray* array)
     689void GraphicsContext3D::uniform4fv(long location, float* array, int size)
    690690{
    691691    // FIXME: length needs to be a multiple of 4
    692692    ensureContext(m_contextObj);
    693     ::glUniform4fv(location, array->length() / 4, static_cast<GLfloat*>(array->baseAddress()));
     693    ::glUniform4fv(location, size, array);
    694694}
    695695
    … …  
    700700}
    701701
    702 void GraphicsContext3D::uniform1iv(long location, CanvasIntArray* array)
    703 {
    704     ensureContext(m_contextObj);
    705     ::glUniform1iv(location, array->length(), static_cast<GLint*>(array->baseAddress()));
     702void GraphicsContext3D::uniform1iv(long location, int* array, int size)
     703{
     704    ensureContext(m_contextObj);
     705    ::glUniform1iv(location, size, array);
    706706}
    707707
    … …  
    712712}
    713713
    714 void GraphicsContext3D::uniform2iv(long location, CanvasIntArray* array)
     714void GraphicsContext3D::uniform2iv(long location, int* array, int size)
    715715{
    716716    // FIXME: length needs to be a multiple of 2
    717717    ensureContext(m_contextObj);
    718     ::glUniform2iv(location, array->length() / 2, static_cast<GLint*>(array->baseAddress()));
     718    ::glUniform2iv(location, size, array);
    719719}
    720720
    … …  
    725725}
    726726
    727 void GraphicsContext3D::uniform3iv(long location, CanvasIntArray* array)
     727void GraphicsContext3D::uniform3iv(long location, int* array, int size)
    728728{
    729729    // FIXME: length needs to be a multiple of 3
    730730    ensureContext(m_contextObj);
    731     ::glUniform3iv(location, array->length() / 3, static_cast<GLint*>(array->baseAddress()));
     731    ::glUniform3iv(location, size, array);
    732732}
    733733
    … …  
    738738}
    739739
    740 void GraphicsContext3D::uniform4iv(long location, CanvasIntArray* array)
     740void GraphicsContext3D::uniform4iv(long location, int* array, int size)
    741741{
    742742    // FIXME: length needs to be a multiple of 4
    743743    ensureContext(m_contextObj);
    744     ::glUniform4iv(location, array->length() / 4, static_cast<GLint*>(array->baseAddress()));
    745 }
    746 
    747 void GraphicsContext3D::uniformMatrix2fv(long location, bool transpose, CanvasFloatArray* array)
     744    ::glUniform4iv(location, size, array);
     745}
     746
     747void GraphicsContext3D::uniformMatrix2fv(long location, bool transpose, float* array, int size)
    748748{
    749749    // FIXME: length needs to be a multiple of 4
    750750    ensureContext(m_contextObj);
    751     ::glUniformMatrix2fv(location, array->length() / 4, transpose, static_cast<GLfloat*>(array->baseAddress()));
    752 }
    753 
    754 void GraphicsContext3D::uniformMatrix3fv(long location, bool transpose, CanvasFloatArray* array)
     751    ::glUniformMatrix2fv(location, size, transpose, array);
     752}
     753
     754void GraphicsContext3D::uniformMatrix3fv(long location, bool transpose, float* array, int size)
    755755{
    756756    // FIXME: length needs to be a multiple of 9
    757757    ensureContext(m_contextObj);
    758     ::glUniformMatrix3fv(location, array->length() / 9, transpose, static_cast<GLfloat*>(array->baseAddress()));
    759 }
    760 
    761 void GraphicsContext3D::uniformMatrix4fv(long location, bool transpose, CanvasFloatArray* array)
     758    ::glUniformMatrix3fv(location, size, transpose, array);
     759}
     760
     761void GraphicsContext3D::uniformMatrix4fv(long location, bool transpose, float* array, int size)
    762762{
    763763    // FIXME: length needs to be a multiple of 16
    764764    ensureContext(m_contextObj);
    765     ::glUniformMatrix4fv(location, array->length() / 16, transpose, static_cast<GLfloat*>(array->baseAddress()));
     765    ::glUniformMatrix4fv(location, size, transpose, array);
    766766}
    767767
    … …  
    790790}
    791791
    792 void GraphicsContext3D::vertexAttrib1fv(unsigned long indx, CanvasFloatArray* array)
    793 {
    794     ensureContext(m_contextObj);
    795     ::glVertexAttrib1fv(indx, static_cast<GLfloat*>(array->baseAddress()));
     792void GraphicsContext3D::vertexAttrib1fv(unsigned long indx, float* array)
     793{
     794    ensureContext(m_contextObj);
     795    ::glVertexAttrib1fv(indx, array);
    796796}
    797797
    … …  
    802802}
    803803
    804 void GraphicsContext3D::vertexAttrib2fv(unsigned long indx, CanvasFloatArray* array)
    805 {
    806     ensureContext(m_contextObj);
    807     ::glVertexAttrib2fv(indx, static_cast<GLfloat*>(array->baseAddress()));
     804void GraphicsContext3D::vertexAttrib2fv(unsigned long indx, float* array)
     805{
     806    ensureContext(m_contextObj);
     807    ::glVertexAttrib2fv(indx, array);
    808808}
    809809
    … …  
    814814}
    815815
    816 void GraphicsContext3D::vertexAttrib3fv(unsigned long indx, CanvasFloatArray* array)
    817 {
    818     ensureContext(m_contextObj);
    819     ::glVertexAttrib3fv(indx, static_cast<GLfloat*>(array->baseAddress()));
     816void GraphicsContext3D::vertexAttrib3fv(unsigned long indx, float* array)
     817{
     818    ensureContext(m_contextObj);
     819    ::glVertexAttrib3fv(indx, array);
    820820}
    821821
    … …  
    826826}
    827827
    828 void GraphicsContext3D::vertexAttrib4fv(unsigned long indx, CanvasFloatArray* array)
    829 {
    830     ensureContext(m_contextObj);
    831     ::glVertexAttrib4fv(indx, static_cast<GLfloat*>(array->baseAddress()));
     828void GraphicsContext3D::vertexAttrib4fv(unsigned long indx, float* array)
     829{
     830    ensureContext(m_contextObj);
     831    ::glVertexAttrib4fv(indx, array);
    832832}
    833833
Note: See TracChangeset for help on using the changeset viewer.