e1963da5dd19838cd09edb78eeb5fbc2b28fa464
[WebKit-https.git] / WebCore / bindings / js / JSWebGLRenderingContextCustom.cpp
1 /*
2  * Copyright (C) 2009 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #include "config.h"
27
28 #if ENABLE(3D_CANVAS)
29
30 #include "JSWebGLRenderingContext.h"
31
32 #include "ExceptionCode.h"
33 #include "HTMLCanvasElement.h"
34 #include "HTMLImageElement.h"
35 #include "JSHTMLCanvasElement.h"
36 #include "JSHTMLImageElement.h"
37 #include "JSImageData.h"
38 #include "JSOESTextureFloat.h"
39 #include "JSWebGLBuffer.h"
40 #include "JSFloat32Array.h"
41 #include "JSWebGLFramebuffer.h"
42 #include "JSInt32Array.h"
43 #include "JSWebGLProgram.h"
44 #include "JSWebGLRenderbuffer.h"
45 #include "JSWebGLShader.h"
46 #include "JSWebGLTexture.h"
47 #include "JSWebGLUniformLocation.h"
48 #include "JSUint8Array.h"
49 #include "JSWebKitCSSMatrix.h"
50 #include "NotImplemented.h"
51 #include "OESTextureFloat.h"
52 #include "WebGLBuffer.h"
53 #include "Float32Array.h"
54 #include "WebGLExtension.h"
55 #include "WebGLFramebuffer.h"
56 #include "WebGLGetInfo.h"
57 #include "Int32Array.h"
58 #include "WebGLProgram.h"
59 #include "WebGLRenderingContext.h"
60 #include <runtime/Error.h>
61 #include <runtime/JSArray.h>
62 #include <wtf/FastMalloc.h>
63 #include <wtf/OwnFastMallocPtr.h>
64
65 #if ENABLE(VIDEO)
66 #include "HTMLVideoElement.h"
67 #include "JSHTMLVideoElement.h"
68 #endif
69
70 using namespace JSC;
71
72 namespace WebCore {
73
74 static JSValue toJS(ExecState* exec, JSDOMGlobalObject* globalObject, const WebGLGetInfo& info)
75 {
76     switch (info.getType()) {
77     case WebGLGetInfo::kTypeBool:
78         return jsBoolean(info.getBool());
79     case WebGLGetInfo::kTypeBoolArray: {
80         MarkedArgumentBuffer list;
81         const Vector<bool>& value = info.getBoolArray();
82         for (size_t ii = 0; ii < value.size(); ++ii)
83             list.append(jsBoolean(value[ii]));
84         return constructArray(exec, list);
85     }
86     case WebGLGetInfo::kTypeFloat:
87         return jsNumber(info.getFloat());
88     case WebGLGetInfo::kTypeLong:
89         return jsNumber(info.getLong());
90     case WebGLGetInfo::kTypeNull:
91         return jsNull();
92     case WebGLGetInfo::kTypeString:
93         return jsString(exec, info.getString());
94     case WebGLGetInfo::kTypeUnsignedLong:
95         return jsNumber(info.getUnsignedLong());
96     case WebGLGetInfo::kTypeWebGLBuffer:
97         return toJS(exec, globalObject, info.getWebGLBuffer());
98     case WebGLGetInfo::kTypeWebGLFloatArray:
99         return toJS(exec, globalObject, info.getWebGLFloatArray());
100     case WebGLGetInfo::kTypeWebGLFramebuffer:
101         return toJS(exec, globalObject, info.getWebGLFramebuffer());
102     case WebGLGetInfo::kTypeWebGLIntArray:
103         return toJS(exec, globalObject, info.getWebGLIntArray());
104     // FIXME: implement WebGLObjectArray
105     // case WebGLGetInfo::kTypeWebGLObjectArray:
106     case WebGLGetInfo::kTypeWebGLProgram:
107         return toJS(exec, globalObject, info.getWebGLProgram());
108     case WebGLGetInfo::kTypeWebGLRenderbuffer:
109         return toJS(exec, globalObject, info.getWebGLRenderbuffer());
110     case WebGLGetInfo::kTypeWebGLTexture:
111         return toJS(exec, globalObject, info.getWebGLTexture());
112     case WebGLGetInfo::kTypeWebGLUnsignedByteArray:
113         return toJS(exec, globalObject, info.getWebGLUnsignedByteArray());
114     default:
115         notImplemented();
116         return jsUndefined();
117     }
118 }
119
120 enum ObjectType {
121     kBuffer, kRenderbuffer, kTexture, kVertexAttrib
122 };
123
124 static JSValue getObjectParameter(JSWebGLRenderingContext* obj, ExecState* exec, ObjectType objectType)
125 {
126     if (exec->argumentCount() != 2)
127         return throwSyntaxError(exec);
128
129     ExceptionCode ec = 0;
130     WebGLRenderingContext* context = static_cast<WebGLRenderingContext*>(obj->impl());
131     unsigned target = exec->argument(0).toInt32(exec);
132     if (exec->hadException())
133         return jsUndefined();
134     unsigned pname = exec->argument(1).toInt32(exec);
135     if (exec->hadException())
136         return jsUndefined();
137     WebGLGetInfo info;
138     switch (objectType) {
139     case kBuffer:
140         info = context->getBufferParameter(target, pname, ec);
141         break;
142     case kRenderbuffer:
143         info = context->getRenderbufferParameter(target, pname, ec);
144         break;
145     case kTexture:
146         info = context->getTexParameter(target, pname, ec);
147         break;
148     case kVertexAttrib:
149         // target => index
150         info = context->getVertexAttrib(target, pname, ec);
151         break;
152     default:
153         notImplemented();
154         break;
155     }
156     if (ec) {
157         setDOMException(exec, ec);
158         return jsUndefined();
159     }
160     return toJS(exec, obj->globalObject(), info);
161 }
162
163 enum WhichProgramCall {
164     kProgramParameter, kUniform
165 };
166
167 static JSValue toJS(ExecState* exec, JSDOMGlobalObject* globalObject, WebGLExtension* extension)
168 {
169     if (!extension)
170         return jsNull();
171     switch (extension->getName()) {
172     case WebGLExtension::OESTextureFloatName:
173         return toJS(exec, globalObject, static_cast<OESTextureFloat*>(extension));
174     }
175     ASSERT_NOT_REACHED();
176     return jsNull();
177 }
178
179 void JSWebGLRenderingContext::markChildren(MarkStack& markStack)
180 {
181     Base::markChildren(markStack);
182
183     WebGLRenderingContext* context = static_cast<WebGLRenderingContext*>(impl());
184     for (int i = 0; i < context->getNumberOfExtensions(); ++i)
185         markDOMObjectWrapper(markStack, *Heap::heap(this)->globalData(), context->getExtensionNumber(i));
186 }
187
188 JSValue JSWebGLRenderingContext::getAttachedShaders(ExecState* exec)
189 {
190     if (exec->argumentCount() < 1)
191         return throwSyntaxError(exec);
192     ExceptionCode ec = 0;
193     WebGLRenderingContext* context = static_cast<WebGLRenderingContext*>(impl());
194     if (exec->argumentCount() > 0 && !exec->argument(0).isUndefinedOrNull() && !exec->argument(0).inherits(&JSWebGLProgram::s_info))
195         return throwTypeError(exec);
196     WebGLProgram* program = toWebGLProgram(exec->argument(0));
197     if (exec->hadException())
198         return jsNull();
199     Vector<WebGLShader*> shaders;
200     bool succeed = context->getAttachedShaders(program, shaders, ec);
201     if (ec) {
202         setDOMException(exec, ec);
203         return jsNull();
204     }
205     if (!succeed)
206         return jsNull();
207     MarkedArgumentBuffer list;
208     for (size_t ii = 0; ii < shaders.size(); ++ii)
209         list.append(toJS(exec, globalObject(), shaders[ii]));
210     return constructArray(exec, list);
211 }
212
213 JSValue JSWebGLRenderingContext::getExtension(ExecState* exec)
214 {
215     if (exec->argumentCount() < 1)
216         return throwSyntaxError(exec);
217
218     WebGLRenderingContext* context = static_cast<WebGLRenderingContext*>(impl());
219     const String& name = ustringToString(exec->argument(0).toString(exec));
220     if (exec->hadException())
221         return jsUndefined();
222     WebGLExtension* extension = context->getExtension(name);
223     return toJS(exec, globalObject(), extension);
224 }
225
226 JSValue JSWebGLRenderingContext::getBufferParameter(ExecState* exec)
227 {
228     return getObjectParameter(this, exec, kBuffer);
229 }
230
231 JSValue JSWebGLRenderingContext::getFramebufferAttachmentParameter(ExecState* exec)
232 {
233     if (exec->argumentCount() != 3)
234         return throwSyntaxError(exec);
235
236     ExceptionCode ec = 0;
237     WebGLRenderingContext* context = static_cast<WebGLRenderingContext*>(impl());
238     unsigned target = exec->argument(0).toInt32(exec);
239     if (exec->hadException())
240         return jsUndefined();
241     unsigned attachment = exec->argument(1).toInt32(exec);
242     if (exec->hadException())
243         return jsUndefined();
244     unsigned pname = exec->argument(2).toInt32(exec);
245     if (exec->hadException())
246         return jsUndefined();
247     WebGLGetInfo info = context->getFramebufferAttachmentParameter(target, attachment, pname, ec);
248     if (ec) {
249         setDOMException(exec, ec);
250         return jsUndefined();
251     }
252     return toJS(exec, globalObject(), info);
253 }
254
255 JSValue JSWebGLRenderingContext::getParameter(ExecState* exec)
256 {
257     if (exec->argumentCount() != 1)
258         return throwSyntaxError(exec);
259
260     ExceptionCode ec = 0;
261     WebGLRenderingContext* context = static_cast<WebGLRenderingContext*>(impl());
262     unsigned pname = exec->argument(0).toInt32(exec);
263     if (exec->hadException())
264         return jsUndefined();
265     WebGLGetInfo info = context->getParameter(pname, ec);
266     if (ec) {
267         setDOMException(exec, ec);
268         return jsUndefined();
269     }
270     return toJS(exec, globalObject(), info);
271 }
272
273 JSValue JSWebGLRenderingContext::getProgramParameter(ExecState* exec)
274 {
275     if (exec->argumentCount() != 2)
276         return throwSyntaxError(exec);
277
278     ExceptionCode ec = 0;
279     WebGLRenderingContext* context = static_cast<WebGLRenderingContext*>(impl());
280     if (exec->argumentCount() > 0 && !exec->argument(0).isUndefinedOrNull() && !exec->argument(0).inherits(&JSWebGLProgram::s_info))
281         return throwTypeError(exec);
282     WebGLProgram* program = toWebGLProgram(exec->argument(0));
283     unsigned pname = exec->argument(1).toInt32(exec);
284     if (exec->hadException())
285         return jsUndefined();
286     WebGLGetInfo info = context->getProgramParameter(program, pname, ec);
287     if (ec) {
288         setDOMException(exec, ec);
289         return jsUndefined();
290     }
291     return toJS(exec, globalObject(), info);
292 }
293
294 JSValue JSWebGLRenderingContext::getRenderbufferParameter(ExecState* exec)
295 {
296     return getObjectParameter(this, exec, kRenderbuffer);
297 }
298
299 JSValue JSWebGLRenderingContext::getShaderParameter(ExecState* exec)
300 {
301     if (exec->argumentCount() != 2)
302         return throwSyntaxError(exec);
303
304     ExceptionCode ec = 0;
305     WebGLRenderingContext* context = static_cast<WebGLRenderingContext*>(impl());
306     if (exec->argumentCount() > 0 && !exec->argument(0).isUndefinedOrNull() && !exec->argument(0).inherits(&JSWebGLShader::s_info))
307         return throwTypeError(exec);
308     WebGLShader* shader = toWebGLShader(exec->argument(0));
309     unsigned pname = exec->argument(1).toInt32(exec);
310     if (exec->hadException())
311         return jsUndefined();
312     WebGLGetInfo info = context->getShaderParameter(shader, pname, ec);
313     if (ec) {
314         setDOMException(exec, ec);
315         return jsUndefined();
316     }
317     return toJS(exec, globalObject(), info);
318 }
319
320 JSValue JSWebGLRenderingContext::getSupportedExtensions(ExecState* exec)
321 {
322     WebGLRenderingContext* context = static_cast<WebGLRenderingContext*>(impl());
323     Vector<String> value = context->getSupportedExtensions();
324     MarkedArgumentBuffer list;
325     for (size_t ii = 0; ii < value.size(); ++ii)
326         list.append(jsString(exec, value[ii]));
327     return constructArray(exec, list);
328 }
329
330 JSValue JSWebGLRenderingContext::getTexParameter(ExecState* exec)
331 {
332     return getObjectParameter(this, exec, kTexture);
333 }
334
335 JSValue JSWebGLRenderingContext::getUniform(ExecState* exec)
336 {
337     if (exec->argumentCount() != 2)
338         return throwSyntaxError(exec);
339
340     ExceptionCode ec = 0;
341     WebGLRenderingContext* context = static_cast<WebGLRenderingContext*>(impl());
342     if (exec->argumentCount() > 0 && !exec->argument(0).isUndefinedOrNull() && !exec->argument(0).inherits(&JSWebGLProgram::s_info))
343         return throwTypeError(exec);
344     WebGLProgram* program = toWebGLProgram(exec->argument(0));
345     if (exec->argumentCount() > 1 && !exec->argument(1).isUndefinedOrNull() && !exec->argument(1).inherits(&JSWebGLUniformLocation::s_info))
346         return throwTypeError(exec);
347     WebGLUniformLocation* loc = toWebGLUniformLocation(exec->argument(1));
348     if (exec->hadException())
349         return jsUndefined();
350     WebGLGetInfo info = context->getUniform(program, loc, ec);
351     if (ec) {
352         setDOMException(exec, ec);
353         return jsUndefined();
354     }
355     return toJS(exec, globalObject(), info);
356 }
357
358 JSValue JSWebGLRenderingContext::getVertexAttrib(ExecState* exec)
359 {
360     return getObjectParameter(this, exec, kVertexAttrib);
361 }
362
363 template<typename T, size_t inlineCapacity>
364 bool toVector(JSC::ExecState* exec, JSC::JSValue value, Vector<T, inlineCapacity>& vector)
365 {
366     if (!value.isObject())
367         return false;
368
369     JSC::JSObject* object = asObject(value);
370     int32_t length = object->get(exec, JSC::Identifier(exec, "length")).toInt32(exec);
371     vector.resize(length);
372
373     for (int32_t i = 0; i < length; ++i) {
374         JSC::JSValue v = object->get(exec, i);
375         if (exec->hadException())
376             return false;
377         vector[i] = static_cast<T>(v.toNumber(exec));
378     }
379
380     return true;
381 }
382
383 enum DataFunctionToCall {
384     f_uniform1v, f_uniform2v, f_uniform3v, f_uniform4v,
385     f_vertexAttrib1v, f_vertexAttrib2v, f_vertexAttrib3v, f_vertexAttrib4v
386 };
387
388 enum DataFunctionMatrixToCall {
389     f_uniformMatrix2fv, f_uniformMatrix3fv, f_uniformMatrix4fv
390 };
391
392 static bool functionForUniform(DataFunctionToCall f)
393 {
394     switch (f) {
395     case f_uniform1v:
396     case f_uniform2v:
397     case f_uniform3v:
398     case f_uniform4v:
399         return true;
400         break;
401     default: break;
402     }
403     return false;
404 }
405
406 static JSC::JSValue dataFunctionf(DataFunctionToCall f, JSC::ExecState* exec, WebGLRenderingContext* context)
407 {
408     if (exec->argumentCount() != 2)
409         return throwSyntaxError(exec);
410     
411     WebGLUniformLocation* location = 0;
412     long index = -1;
413     
414     if (functionForUniform(f)) {
415         if (exec->argumentCount() > 0 && !exec->argument(0).isUndefinedOrNull() && !exec->argument(0).inherits(&JSWebGLUniformLocation::s_info))
416             return throwTypeError(exec);
417         location = toWebGLUniformLocation(exec->argument(0));
418     } else
419         index = exec->argument(0).toInt32(exec);
420
421     if (exec->hadException())
422         return jsUndefined();
423         
424     RefPtr<Float32Array> webGLArray = toFloat32Array(exec->argument(1));
425     if (exec->hadException())    
426         return jsUndefined();
427         
428     ExceptionCode ec = 0;
429     if (webGLArray) {
430         switch (f) {
431         case f_uniform1v:
432             context->uniform1fv(location, webGLArray.get(), ec);
433             break;
434         case f_uniform2v:
435             context->uniform2fv(location, webGLArray.get(), ec);
436             break;
437         case f_uniform3v:
438             context->uniform3fv(location, webGLArray.get(), ec);
439             break;
440         case f_uniform4v:
441             context->uniform4fv(location, webGLArray.get(), ec);
442             break;
443         case f_vertexAttrib1v:
444             context->vertexAttrib1fv(index, webGLArray.get());
445             break;
446         case f_vertexAttrib2v:
447             context->vertexAttrib2fv(index, webGLArray.get());
448             break;
449         case f_vertexAttrib3v:
450             context->vertexAttrib3fv(index, webGLArray.get());
451             break;
452         case f_vertexAttrib4v:
453             context->vertexAttrib4fv(index, webGLArray.get());
454             break;
455         }
456         
457         setDOMException(exec, ec);
458         return jsUndefined();
459     }
460
461     Vector<float, 64> array;
462     if (!toVector(exec, exec->argument(1), array))
463         return throwTypeError(exec);
464
465     switch (f) {
466     case f_uniform1v:
467         context->uniform1fv(location, array.data(), array.size(), ec);
468         break;
469     case f_uniform2v:
470         context->uniform2fv(location, array.data(), array.size(), ec);
471         break;
472     case f_uniform3v:
473         context->uniform3fv(location, array.data(), array.size(), ec);
474         break;
475     case f_uniform4v:
476         context->uniform4fv(location, array.data(), array.size(), ec);
477         break;
478     case f_vertexAttrib1v:
479         context->vertexAttrib1fv(index, array.data(), array.size());
480         break;
481     case f_vertexAttrib2v:
482         context->vertexAttrib2fv(index, array.data(), array.size());
483         break;
484     case f_vertexAttrib3v:
485         context->vertexAttrib3fv(index, array.data(), array.size());
486         break;
487     case f_vertexAttrib4v:
488         context->vertexAttrib4fv(index, array.data(), array.size());
489         break;
490     }
491     
492     setDOMException(exec, ec);
493     return jsUndefined();
494 }
495
496 static JSC::JSValue dataFunctioni(DataFunctionToCall f, JSC::ExecState* exec, WebGLRenderingContext* context)
497 {
498     if (exec->argumentCount() != 2)
499         return throwSyntaxError(exec);
500
501     if (exec->argumentCount() > 0 && !exec->argument(0).isUndefinedOrNull() && !exec->argument(0).inherits(&JSWebGLUniformLocation::s_info))
502         return throwTypeError(exec);
503     WebGLUniformLocation* location = toWebGLUniformLocation(exec->argument(0));
504   
505     if (exec->hadException())
506         return jsUndefined();
507         
508     RefPtr<Int32Array> webGLArray = toInt32Array(exec->argument(1));
509     if (exec->hadException())    
510         return jsUndefined();
511         
512     ExceptionCode ec = 0;
513     if (webGLArray) {
514         switch (f) {
515         case f_uniform1v:
516             context->uniform1iv(location, webGLArray.get(), ec);
517             break;
518         case f_uniform2v:
519             context->uniform2iv(location, webGLArray.get(), ec);
520             break;
521         case f_uniform3v:
522             context->uniform3iv(location, webGLArray.get(), ec);
523             break;
524         case f_uniform4v:
525             context->uniform4iv(location, webGLArray.get(), ec);
526             break;
527         default:
528             break;
529         }
530         
531         setDOMException(exec, ec);
532         return jsUndefined();
533     }
534
535
536     Vector<int, 64> array;
537     if (!toVector(exec, exec->argument(1), array))
538         return throwTypeError(exec);
539
540     switch (f) {
541     case f_uniform1v:
542         context->uniform1iv(location, array.data(), array.size(), ec);
543         break;
544     case f_uniform2v:
545         context->uniform2iv(location, array.data(), array.size(), ec);
546         break;
547     case f_uniform3v:
548         context->uniform3iv(location, array.data(), array.size(), ec);
549         break;
550     case f_uniform4v:
551         context->uniform4iv(location, array.data(), array.size(), ec);
552         break;
553     default:
554         break;
555     }
556     
557     setDOMException(exec, ec);
558     return jsUndefined();
559 }
560
561 static JSC::JSValue dataFunctionMatrix(DataFunctionMatrixToCall f, JSC::ExecState* exec, WebGLRenderingContext* context)
562 {
563     if (exec->argumentCount() != 3)
564         return throwSyntaxError(exec);
565
566     if (exec->argumentCount() > 0 && !exec->argument(0).isUndefinedOrNull() && !exec->argument(0).inherits(&JSWebGLUniformLocation::s_info))
567         return throwTypeError(exec);
568     WebGLUniformLocation* location = toWebGLUniformLocation(exec->argument(0));
569
570     if (exec->hadException())    
571         return jsUndefined();
572         
573     bool transpose = exec->argument(1).toBoolean(exec);
574     if (exec->hadException())    
575         return jsUndefined();
576         
577     RefPtr<Float32Array> webGLArray = toFloat32Array(exec->argument(2));
578     if (exec->hadException())    
579         return jsUndefined();
580         
581     ExceptionCode ec = 0;
582     if (webGLArray) {
583         switch (f) {
584         case f_uniformMatrix2fv:
585             context->uniformMatrix2fv(location, transpose, webGLArray.get(), ec);
586             break;
587         case f_uniformMatrix3fv:
588             context->uniformMatrix3fv(location, transpose, webGLArray.get(), ec);
589             break;
590         case f_uniformMatrix4fv:
591             context->uniformMatrix4fv(location, transpose, webGLArray.get(), ec);
592             break;
593         }
594         
595         setDOMException(exec, ec);
596         return jsUndefined();
597     }
598
599     Vector<float, 64> array;
600     if (!toVector(exec, exec->argument(2), array))
601         return throwTypeError(exec);
602
603     switch (f) {
604     case f_uniformMatrix2fv:
605         context->uniformMatrix2fv(location, transpose, array.data(), array.size(), ec);
606         break;
607     case f_uniformMatrix3fv:
608         context->uniformMatrix3fv(location, transpose, array.data(), array.size(), ec);
609         break;
610     case f_uniformMatrix4fv:
611         context->uniformMatrix4fv(location, transpose, array.data(), array.size(), ec);
612         break;
613     }
614
615     setDOMException(exec, ec);
616     return jsUndefined();
617 }
618
619 JSC::JSValue JSWebGLRenderingContext::uniform1fv(JSC::ExecState* exec)
620 {
621     return dataFunctionf(f_uniform1v, exec, static_cast<WebGLRenderingContext*>(impl()));
622 }
623
624 JSC::JSValue JSWebGLRenderingContext::uniform1iv(JSC::ExecState* exec)
625 {
626     return dataFunctioni(f_uniform1v, exec, static_cast<WebGLRenderingContext*>(impl()));
627 }
628
629 JSC::JSValue JSWebGLRenderingContext::uniform2fv(JSC::ExecState* exec)
630 {
631     return dataFunctionf(f_uniform2v, exec, static_cast<WebGLRenderingContext*>(impl()));
632 }
633
634 JSC::JSValue JSWebGLRenderingContext::uniform2iv(JSC::ExecState* exec)
635 {
636     return dataFunctioni(f_uniform2v, exec, static_cast<WebGLRenderingContext*>(impl()));
637 }
638
639 JSC::JSValue JSWebGLRenderingContext::uniform3fv(JSC::ExecState* exec)
640 {
641     return dataFunctionf(f_uniform3v, exec, static_cast<WebGLRenderingContext*>(impl()));
642 }
643
644 JSC::JSValue JSWebGLRenderingContext::uniform3iv(JSC::ExecState* exec)
645 {
646     return dataFunctioni(f_uniform3v, exec, static_cast<WebGLRenderingContext*>(impl()));
647 }
648
649 JSC::JSValue JSWebGLRenderingContext::uniform4fv(JSC::ExecState* exec)
650 {
651     return dataFunctionf(f_uniform4v, exec, static_cast<WebGLRenderingContext*>(impl()));
652 }
653
654 JSC::JSValue JSWebGLRenderingContext::uniform4iv(JSC::ExecState* exec)
655 {
656     return dataFunctioni(f_uniform4v, exec, static_cast<WebGLRenderingContext*>(impl()));
657 }
658
659 JSC::JSValue JSWebGLRenderingContext::uniformMatrix2fv(JSC::ExecState* exec)
660 {
661     return dataFunctionMatrix(f_uniformMatrix2fv, exec, static_cast<WebGLRenderingContext*>(impl()));
662 }
663
664 JSC::JSValue JSWebGLRenderingContext::uniformMatrix3fv(JSC::ExecState* exec)
665 {
666     return dataFunctionMatrix(f_uniformMatrix3fv, exec, static_cast<WebGLRenderingContext*>(impl()));
667 }
668
669 JSC::JSValue JSWebGLRenderingContext::uniformMatrix4fv(JSC::ExecState* exec)
670 {
671     return dataFunctionMatrix(f_uniformMatrix4fv, exec, static_cast<WebGLRenderingContext*>(impl()));
672 }
673
674 JSC::JSValue JSWebGLRenderingContext::vertexAttrib1fv(JSC::ExecState* exec)
675 {
676     return dataFunctionf(f_vertexAttrib1v, exec, static_cast<WebGLRenderingContext*>(impl()));
677 }
678
679 JSC::JSValue JSWebGLRenderingContext::vertexAttrib2fv(JSC::ExecState* exec)
680 {
681     return dataFunctionf(f_vertexAttrib2v, exec, static_cast<WebGLRenderingContext*>(impl()));
682 }
683
684 JSC::JSValue JSWebGLRenderingContext::vertexAttrib3fv(JSC::ExecState* exec)
685 {
686     return dataFunctionf(f_vertexAttrib3v, exec, static_cast<WebGLRenderingContext*>(impl()));
687 }
688
689 JSC::JSValue JSWebGLRenderingContext::vertexAttrib4fv(JSC::ExecState* exec)
690 {
691     return dataFunctionf(f_vertexAttrib4v, exec, static_cast<WebGLRenderingContext*>(impl()));
692 }
693
694 } // namespace WebCore
695
696 #endif // ENABLE(3D_CANVAS)