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