Change the argument orders to match OpenGL's in GraphicsContext3D functions
[WebKit-https.git] / Source / WebCore / platform / graphics / efl / GraphicsContext3DEfl.cpp
1 /*
2     Copyright (C) 2012 Samsung Electronics
3
4     This library is free software; you can redistribute it and/or
5     modify it under the terms of the GNU Library General Public
6     License as published by the Free Software Foundation; either
7     version 2 of the License, or (at your option) any later version.
8
9     This library is distributed in the hope that it will be useful,
10     but WITHOUT ANY WARRANTY; without even the implied warranty of
11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12     Library General Public License for more details.
13
14     You should have received a copy of the GNU Library General Public License
15     along with this library; see the file COPYING.LIB.  If not, write to
16     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17     Boston, MA 02110-1301, USA.
18 */
19
20 #include "config.h"
21
22 #if ENABLE(WEBGL) || USE(ACCELERATED_COMPOSITING)
23
24 #include "GraphicsContext3DPrivate.h"
25
26 #include "ImageData.h"
27 #include "NotImplemented.h"
28
29 namespace WebCore {
30
31 PassRefPtr<GraphicsContext3D> GraphicsContext3D::create(GraphicsContext3D::Attributes attrs, HostWindow* hostWindow, RenderStyle renderStyle)
32 {
33     bool renderDirectlyToEvasGLObject = (renderStyle == RenderDirectlyToHostWindow);
34
35     OwnPtr<GraphicsContext3DPrivate> internal = GraphicsContext3DPrivate::create(attrs, hostWindow, renderDirectlyToEvasGLObject);
36     if (!internal)
37         return 0;
38
39     RefPtr<GraphicsContext3D> context = adoptRef(new GraphicsContext3D(attrs, hostWindow, renderDirectlyToEvasGLObject));
40     context->m_private = internal.release();
41     return context.release();
42 }
43
44 GraphicsContext3D::GraphicsContext3D(GraphicsContext3D::Attributes attrs, HostWindow* hostWindow, bool renderDirectlyToHostWindow)
45     : m_currentWidth(0)
46     , m_currentHeight(0)
47 {
48 }
49
50 GraphicsContext3D::~GraphicsContext3D()
51 {
52 }
53
54 PlatformGraphicsContext3D GraphicsContext3D::platformGraphicsContext3D() const
55 {
56     return m_private->platformGraphicsContext3D();
57 }
58
59 #if USE(ACCELERATED_COMPOSITING)
60 PlatformLayer* GraphicsContext3D::platformLayer() const
61 {
62     notImplemented();
63     return 0;
64 }
65 #endif
66
67 bool GraphicsContext3D::makeContextCurrent()
68 {
69     return m_private->makeContextCurrent();
70 }
71
72 bool GraphicsContext3D::isGLES2Compliant() const
73 {
74     return m_private->isGLES2Compliant();
75 }
76
77 void GraphicsContext3D::activeTexture(GC3Denum texture)
78 {
79     m_private->activeTexture(texture);
80 }
81
82 void GraphicsContext3D::attachShader(Platform3DObject program, Platform3DObject shader)
83 {
84     m_private->attachShader(program, shader);
85 }
86
87 void GraphicsContext3D::bindAttribLocation(Platform3DObject program, GC3Duint index, const String& name)
88 {
89     m_private->bindAttribLocation(program, index, name);
90 }
91
92 void GraphicsContext3D::bindBuffer(GC3Denum target, Platform3DObject buffer)
93 {
94     m_private->bindBuffer(target, buffer);
95 }
96
97 void GraphicsContext3D::bindFramebuffer(GC3Denum target, Platform3DObject buffer)
98 {
99     m_private->bindFramebuffer(target, buffer);
100 }
101
102 void GraphicsContext3D::bindRenderbuffer(GC3Denum target, Platform3DObject renderbuffer)
103 {
104     m_private->bindRenderbuffer(target, renderbuffer);
105 }
106
107 void GraphicsContext3D::bindTexture(GC3Denum target, Platform3DObject texture)
108 {
109     m_private->bindTexture(target, texture);
110 }
111
112 void GraphicsContext3D::blendColor(GC3Dclampf red, GC3Dclampf green, GC3Dclampf blue, GC3Dclampf alpha)
113 {
114     m_private->blendColor(red, green, blue, alpha);
115 }
116
117 void GraphicsContext3D::blendEquation(GC3Denum mode)
118 {
119     m_private->blendEquation(mode);
120 }
121
122 void GraphicsContext3D::blendEquationSeparate(GC3Denum modeRGB, GC3Denum modeAlpha)
123 {
124     m_private->blendEquationSeparate(modeRGB, modeAlpha);
125 }
126
127 void GraphicsContext3D::blendFunc(GC3Denum srcFactor, GC3Denum dstFactor)
128 {
129     m_private->blendFunc(srcFactor, dstFactor);
130 }
131
132 void GraphicsContext3D::blendFuncSeparate(GC3Denum srcRGB, GC3Denum dstRGB, GC3Denum srcAlpha, GC3Denum dstAlpha)
133 {
134     m_private->blendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
135 }
136
137 void GraphicsContext3D::bufferData(GC3Denum target, GC3Dsizeiptr size, GC3Denum usage)
138 {
139     m_private->bufferData(target, size, 0, usage);
140 }
141
142 void GraphicsContext3D::bufferData(GC3Denum target, GC3Dsizeiptr size, const void* data, GC3Denum usage)
143 {
144     m_private->bufferData(target, size, data, usage);
145 }
146
147 void GraphicsContext3D::bufferSubData(GC3Denum target, GC3Dintptr offset, GC3Dsizeiptr size, const void* data)
148 {
149     m_private->bufferSubData(target, offset, size, data);
150 }
151
152 GC3Denum GraphicsContext3D::checkFramebufferStatus(GC3Denum target)
153 {
154     return m_private->checkFramebufferStatus(target);
155 }
156
157 void GraphicsContext3D::clear(GC3Dbitfield mask)
158 {
159     m_private->clear(mask);
160 }
161
162 void GraphicsContext3D::clearColor(GC3Dclampf red, GC3Dclampf green, GC3Dclampf blue, GC3Dclampf alpha)
163 {
164     m_private->clearColor(red, green, blue, alpha);
165 }
166
167 void GraphicsContext3D::clearDepth(GC3Dclampf depth)
168 {
169     m_private->clearDepth(depth);
170 }
171
172 void GraphicsContext3D::clearStencil(GC3Dint clearValue)
173 {
174     m_private->clearStencil(clearValue);
175 }
176
177 void GraphicsContext3D::colorMask(GC3Dboolean red, GC3Dboolean green, GC3Dboolean blue, GC3Dboolean alpha)
178 {
179     m_private->colorMask(red, green, blue, alpha);
180 }
181
182 void GraphicsContext3D::compileShader(Platform3DObject shader)
183 {
184     m_private->compileShader(shader);
185 }
186
187 void GraphicsContext3D::copyTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Dint border)
188 {
189     m_private->copyTexImage2D(target, level, internalformat, x, y, width, height, border);
190 }
191
192 void GraphicsContext3D::copyTexSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xOffset, GC3Dint yOffset, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height)
193 {
194     m_private->copyTexSubImage2D(target, level, xOffset, yOffset, x, y, width, height);
195 }
196
197 void GraphicsContext3D::cullFace(GC3Denum mode)
198 {
199     m_private->cullFace(mode);
200 }
201
202 void GraphicsContext3D::depthFunc(GC3Denum func)
203 {
204     m_private->depthFunc(func);
205 }
206
207 void GraphicsContext3D::depthMask(GC3Dboolean flag)
208 {
209     m_private->depthMask(flag);
210 }
211
212 void GraphicsContext3D::depthRange(GC3Dclampf zNear, GC3Dclampf zFar)
213 {
214     m_private->depthRange(zNear, zFar);
215 }
216
217 void GraphicsContext3D::detachShader(Platform3DObject program, Platform3DObject shader)
218 {
219     m_private->detachShader(program, shader);
220 }
221
222 void GraphicsContext3D::disable(GC3Denum cap)
223 {
224     m_private->disable(cap);
225 }
226
227 void GraphicsContext3D::disableVertexAttribArray(GC3Duint index)
228 {
229     m_private->disableVertexAttribArray(index);
230 }
231
232 void GraphicsContext3D::drawArrays(GC3Denum mode, GC3Dint first, GC3Dsizei count)
233 {
234     m_private->drawArrays(mode, first, count);
235 }
236
237 void GraphicsContext3D::drawElements(GC3Denum mode, GC3Dsizei count, GC3Denum type, GC3Dintptr offset)
238 {
239     m_private->drawElements(mode, count, type, offset);
240 }
241
242 void GraphicsContext3D::enable(GC3Denum cap)
243 {
244     m_private->enable(cap);
245 }
246
247 void GraphicsContext3D::enableVertexAttribArray(GC3Duint index)
248 {
249     m_private->enableVertexAttribArray(index);
250 }
251
252 void GraphicsContext3D::finish()
253 {
254     m_private->finish();
255 }
256
257 void GraphicsContext3D::flush()
258 {
259     m_private->flush();
260 }
261
262 void GraphicsContext3D::framebufferRenderbuffer(GC3Denum target, GC3Denum attachment, GC3Denum renderbufferTarget, Platform3DObject buffer)
263 {
264     m_private->framebufferRenderbuffer(target, attachment, renderbufferTarget, buffer);
265 }
266
267 void GraphicsContext3D::framebufferTexture2D(GC3Denum target, GC3Denum attachment, GC3Denum texTarget, Platform3DObject texture, GC3Dint level)
268 {
269     m_private->framebufferTexture2D(target, attachment, texTarget, texture, level);
270 }
271
272 void GraphicsContext3D::frontFace(GC3Denum mode)
273 {
274     m_private->frontFace(mode);
275 }
276
277 void GraphicsContext3D::generateMipmap(GC3Denum target)
278 {
279     m_private->generateMipmap(target);
280 }
281
282 bool GraphicsContext3D::getActiveAttrib(Platform3DObject program, GC3Duint index, ActiveInfo& info)
283 {
284     return m_private->getActiveAttrib(program, index, info);
285 }
286
287 bool GraphicsContext3D::getActiveUniform(Platform3DObject program, GC3Duint index, ActiveInfo& info)
288 {
289     return m_private->getActiveUniform(program, index, info);
290 }
291
292 void GraphicsContext3D::getAttachedShaders(Platform3DObject program, GC3Dsizei maxCount, GC3Dsizei* count, Platform3DObject* shaders)
293 {
294     m_private->getAttachedShaders(program, maxCount, count, shaders);
295 }
296
297 int GraphicsContext3D::getAttribLocation(Platform3DObject program, const String& name)
298 {
299     return m_private->getAttribLocation(program, name);
300 }
301
302 void GraphicsContext3D::getBooleanv(GC3Denum paramName, GC3Dboolean* value)
303 {
304     m_private->getBooleanv(paramName, value);
305 }
306
307 void GraphicsContext3D::getBufferParameteriv(GC3Denum target, GC3Denum paramName, GC3Dint* value)
308 {
309     m_private->getBufferParameteriv(target, paramName, value);
310 }
311
312 GraphicsContext3D::Attributes GraphicsContext3D::getContextAttributes()
313 {
314     return m_private->getContextAttributes();
315 }
316
317 GC3Denum GraphicsContext3D::getError()
318 {
319     return m_private->getError();
320 }
321
322 void GraphicsContext3D::getFloatv(GC3Denum paramName, GC3Dfloat* value)
323 {
324     m_private->getFloatv(paramName, value);
325 }
326
327 void GraphicsContext3D::getFramebufferAttachmentParameteriv(GC3Denum target, GC3Denum attachment, GC3Denum paramName, GC3Dint* value)
328 {
329     m_private->getFramebufferAttachmentParameteriv(target, attachment, paramName, value);
330 }
331
332 void GraphicsContext3D::getIntegerv(GC3Denum paramName, GC3Dint* value)
333 {
334     m_private->getIntegerv(paramName, value);
335 }
336
337 void GraphicsContext3D::getProgramiv(Platform3DObject program, GC3Denum paramName, GC3Dint* value)
338 {
339     m_private->getProgramiv(program, paramName, value);
340 }
341
342 String GraphicsContext3D::getProgramInfoLog(Platform3DObject program)
343 {
344     return m_private->getProgramInfoLog(program);
345 }
346
347 void GraphicsContext3D::getRenderbufferParameteriv(GC3Denum target, GC3Denum paramName, GC3Dint* value)
348 {
349     m_private->getRenderbufferParameteriv(target, paramName, value);
350 }
351
352 void GraphicsContext3D::getShaderiv(Platform3DObject shader, GC3Denum paramName, GC3Dint* value)
353 {
354     m_private->getShaderiv(shader, paramName, value);
355 }
356
357 String GraphicsContext3D::getShaderInfoLog(Platform3DObject shader)
358 {
359     return m_private->getShaderInfoLog(shader);
360 }
361
362 String GraphicsContext3D::getShaderSource(Platform3DObject shader)
363 {
364     return m_private->getShaderSource(shader);
365 }
366
367 String GraphicsContext3D::getString(GC3Denum name)
368 {
369     return m_private->getString(name);
370 }
371
372 void GraphicsContext3D::getTexParameterfv(GC3Denum target, GC3Denum paramName, GC3Dfloat* value)
373 {
374     m_private->getTexParameterfv(target, paramName, value);
375 }
376
377 void GraphicsContext3D::getTexParameteriv(GC3Denum target, GC3Denum paramName, GC3Dint* value)
378 {
379     m_private->getTexParameteriv(target, paramName, value);
380 }
381
382 void GraphicsContext3D::getUniformfv(Platform3DObject program, GC3Dint location, GC3Dfloat* value)
383 {
384     m_private->getUniformfv(program, location, value);
385 }
386
387 void GraphicsContext3D::getUniformiv(Platform3DObject program, GC3Dint location, GC3Dint* value)
388 {
389     m_private->getUniformiv(program, location, value);
390 }
391
392 GC3Dint GraphicsContext3D::getUniformLocation(Platform3DObject program, const String& name)
393 {
394     return m_private->getUniformLocation(program, name);
395 }
396
397 void GraphicsContext3D::getVertexAttribfv(GC3Duint index, GC3Denum paramName, GC3Dfloat* value)
398 {
399     m_private->getVertexAttribfv(index, paramName, value);
400 }
401
402 void GraphicsContext3D::getVertexAttribiv(GC3Duint index, GC3Denum paramName, GC3Dint* value)
403 {
404     m_private->getVertexAttribiv(index, paramName, value);
405 }
406
407 long GraphicsContext3D::getVertexAttribOffset(GC3Duint index, GC3Denum paramName)
408 {
409     return m_private->getVertexAttribOffset(index, paramName);
410 }
411
412 void GraphicsContext3D::hint(GC3Denum target, GC3Denum mode)
413 {
414     m_private->hint(target, mode);
415 }
416
417 GC3Dboolean GraphicsContext3D::isBuffer(Platform3DObject obj)
418 {
419     return m_private->isBuffer(obj);
420 }
421
422 GC3Dboolean GraphicsContext3D::isEnabled(GC3Denum cap)
423 {
424     return m_private->isEnabled(cap);
425 }
426
427 GC3Dboolean GraphicsContext3D::isFramebuffer(Platform3DObject obj)
428 {
429     return m_private->isFramebuffer(obj);
430 }
431
432 GC3Dboolean GraphicsContext3D::isProgram(Platform3DObject obj)
433 {
434     return m_private->isProgram(obj);
435 }
436
437 GC3Dboolean GraphicsContext3D::isRenderbuffer(Platform3DObject obj)
438 {
439     return m_private->isRenderbuffer(obj);
440 }
441
442 GC3Dboolean GraphicsContext3D::isShader(Platform3DObject obj)
443 {
444     return m_private->isShader(obj);
445 }
446
447 GC3Dboolean GraphicsContext3D::isTexture(Platform3DObject obj)
448 {
449     return m_private->isTexture(obj);
450 }
451
452 void GraphicsContext3D::lineWidth(GC3Dfloat width)
453 {
454     m_private->lineWidth(width);
455 }
456
457 void GraphicsContext3D::linkProgram(Platform3DObject program)
458 {
459     m_private->linkProgram(program);
460 }
461
462 void GraphicsContext3D::pixelStorei(GC3Denum paramName, GC3Dint param)
463 {
464     m_private->pixelStorei(paramName, param);
465 }
466
467 void GraphicsContext3D::polygonOffset(GC3Dfloat factor, GC3Dfloat units)
468 {
469     m_private->polygonOffset(factor, units);
470 }
471
472 void GraphicsContext3D::readPixels(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, void* data)
473 {
474     m_private->readPixels(x, y, width, height, format, type, data);
475 }
476
477 void GraphicsContext3D::releaseShaderCompiler()
478 {
479     notImplemented();
480 }
481
482 void GraphicsContext3D::renderbufferStorage(GC3Denum target, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height)
483 {
484     m_private->renderbufferStorage(target, internalformat, width, height);
485 }
486
487 void GraphicsContext3D::sampleCoverage(GC3Dclampf value, GC3Dboolean invert)
488 {
489     m_private->sampleCoverage(value, invert);
490 }
491
492 void GraphicsContext3D::scissor(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height)
493 {
494     m_private->scissor(x, y, width, height);
495 }
496
497 void GraphicsContext3D::shaderSource(Platform3DObject program, const String& string)
498 {
499     m_private->shaderSource(program, string);
500 }
501
502 void GraphicsContext3D::stencilFunc(GC3Denum func, GC3Dint ref, GC3Duint mask)
503 {
504     m_private->stencilFunc(func, ref, mask);
505 }
506
507 void GraphicsContext3D::stencilFuncSeparate(GC3Denum face, GC3Denum func, GC3Dint ref, GC3Duint mask)
508 {
509     m_private->stencilFuncSeparate(face, func, ref, mask);
510 }
511
512 void GraphicsContext3D::stencilMask(GC3Duint mask)
513 {
514     m_private->stencilMask(mask);
515 }
516
517 void GraphicsContext3D::stencilMaskSeparate(GC3Denum face, GC3Duint mask)
518 {
519     m_private->stencilMaskSeparate(face, mask);
520 }
521
522 void GraphicsContext3D::stencilOp(GC3Denum fail, GC3Denum zfail, GC3Denum zpass)
523 {
524     m_private->stencilOp(fail, zfail, zpass);
525 }
526
527 void GraphicsContext3D::stencilOpSeparate(GC3Denum face, GC3Denum fail, GC3Denum zfail, GC3Denum zpass)
528 {
529     m_private->stencilOpSeparate(face, fail, zfail, zpass);
530 }
531
532 bool GraphicsContext3D::texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, const void* pixels)
533 {
534     return m_private->texImage2D(target, level, internalformat, width, height, border, format, type, pixels);
535 }
536
537 void GraphicsContext3D::texParameterf(GC3Denum target, GC3Denum paramName, GC3Dfloat param)
538 {
539     m_private->texParameterf(target, paramName, param);
540 }
541
542 void GraphicsContext3D::texParameteri(GC3Denum target, GC3Denum paramName, GC3Dint param)
543 {
544     m_private->texParameteri(target, paramName, param);
545 }
546
547 void GraphicsContext3D::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xOffset, GC3Dint yOffset, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, const void* pixels)
548 {
549     m_private->texSubImage2D(target, level, xOffset, yOffset, width, height, format, type, pixels);
550 }
551
552 void GraphicsContext3D::uniform1f(GC3Dint location, GC3Dfloat x)
553 {
554     m_private->uniform1f(location, x);
555 }
556
557 void GraphicsContext3D::uniform1fv(GC3Dint location, GGC3Dsizei size, C3Dfloat* v)
558 {
559     m_private->uniform1fv(location, size, v);
560 }
561
562 void GraphicsContext3D::uniform1i(GC3Dint location, GC3Dint x)
563 {
564     m_private->uniform1i(location, x);
565 }
566
567 void GraphicsContext3D::uniform1iv(GC3Dint location, GGC3Dsizei size, C3Dint* v)
568 {
569     m_private->uniform1iv(location, size, v);
570 }
571
572 void GraphicsContext3D::uniform2f(GC3Dint location, GC3Dfloat x, float y)
573 {
574     m_private->uniform2f(location, x, y);
575 }
576
577 void GraphicsContext3D::uniform2fv(GC3Dint location, GC3Dsizei size, GC3Dfloat* v)
578 {
579     m_private->uniform2fv(location, size, v);
580 }
581
582 void GraphicsContext3D::uniform2i(GC3Dint location, GC3Dint x, GC3Dint y)
583 {
584     m_private->uniform2i(location, x, y);
585 }
586
587 void GraphicsContext3D::uniform2iv(GC3Dint location, GC3Dsizei size, GC3Dint* v)
588 {
589     m_private->uniform2iv(location, size, v);
590 }
591
592 void GraphicsContext3D::uniform3f(GC3Dint location, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z)
593 {
594     m_private->uniform3f(location, x, y, z);
595 }
596
597 void GraphicsContext3D::uniform3fv(GC3Dint location, GC3Dsizei size, GC3Dfloat* v)
598 {
599     m_private->uniform3fv(location, size, v);
600 }
601
602 void GraphicsContext3D::uniform3i(GC3Dint location, GC3Dint x, GC3Dint y, GC3Dint z)
603 {
604     m_private->uniform3i(location, x, y, z);
605 }
606
607 void GraphicsContext3D::uniform3iv(GC3Dint location, GC3Dsizei size, GC3Dint* v)
608 {
609     m_private->uniform3iv(location, size, v);
610 }
611
612 void GraphicsContext3D::uniform4f(GC3Dint location, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, GC3Dfloat w)
613 {
614     m_private->uniform4f(location, x, y, z, w);
615 }
616
617 void GraphicsContext3D::uniform4fv(GC3Dint location, GC3Dsizei size, GC3Dfloat* v)
618 {
619     m_private->uniform4fv(location, size, v);
620 }
621
622 void GraphicsContext3D::uniform4i(GC3Dint location, GC3Dint x, GC3Dint y, GC3Dint z, GC3Dint w)
623 {
624     m_private->uniform4i(location, x, y, z, w);
625 }
626
627 void GraphicsContext3D::uniform4iv(GC3Dint location, GC3Dsizei size, GC3Dint* v)
628 {
629     m_private->uniform4iv(location, size, v);
630 }
631
632 void GraphicsContext3D::uniformMatrix2fv(GC3Dint location, GC3Dsizei size, GC3Dboolean transpose, GC3Dfloat* value)
633 {
634     m_private->uniformMatrix2fv(location, size, transpose, value);
635 }
636
637 void GraphicsContext3D::uniformMatrix3fv(GC3Dint location, GC3Dsizei size, GC3Dboolean transpose, GC3Dfloat* value)
638 {
639     m_private->uniformMatrix3fv(location, size, transpose, value);
640 }
641
642 void GraphicsContext3D::uniformMatrix4fv(GC3Dint location, GC3Dsizei size, GC3Dboolean transpose, GC3Dfloat* value)
643 {
644     m_private->uniformMatrix4fv(location, size, transpose, value);
645 }
646
647 void GraphicsContext3D::useProgram(Platform3DObject program)
648 {
649     m_private->useProgram(program);
650 }
651
652 void GraphicsContext3D::validateProgram(Platform3DObject program)
653 {
654     m_private->validateProgram(program);
655 }
656
657 void GraphicsContext3D::vertexAttrib1f(GC3Duint index, GC3Dfloat x)
658 {
659     m_private->vertexAttrib1f(index, x);
660 }
661
662 void GraphicsContext3D::vertexAttrib1fv(GC3Duint index, GC3Dfloat* values)
663 {
664     m_private->vertexAttrib1fv(index, values);
665 }
666
667 void GraphicsContext3D::vertexAttrib2f(GC3Duint index, GC3Dfloat x, GC3Dfloat y)
668 {
669     m_private->vertexAttrib2f(index, x, y);
670 }
671
672 void GraphicsContext3D::vertexAttrib2fv(GC3Duint index, GC3Dfloat* values)
673 {
674     m_private->vertexAttrib2fv(index, values);
675 }
676
677 void GraphicsContext3D::vertexAttrib3f(GC3Duint index, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z)
678 {
679     m_private->vertexAttrib3f(index, x, y, z);
680 }
681
682 void GraphicsContext3D::vertexAttrib3fv(GC3Duint index, GC3Dfloat* values)
683 {
684     m_private->vertexAttrib3fv(index, values);
685 }
686
687 void GraphicsContext3D::vertexAttrib4f(GC3Duint index, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, GC3Dfloat w)
688 {
689     m_private->vertexAttrib4f(index, x, y, z, w);
690 }
691
692 void GraphicsContext3D::vertexAttrib4fv(GC3Duint index, GC3Dfloat* values)
693 {
694     m_private->vertexAttrib4fv(index, values);
695 }
696
697 void GraphicsContext3D::vertexAttribPointer(GC3Duint index, GC3Dint size, GC3Denum type, GC3Dboolean normalized, GC3Dsizei stride, GC3Dintptr offset)
698 {
699     m_private->vertexAttribPointer(index, size, type, normalized, stride, offset);
700 }
701
702 void GraphicsContext3D::viewport(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height)
703 {
704     m_private->viewport(x, y, width, height);
705 }
706
707 void GraphicsContext3D::reshape(int width, int height)
708 {
709     notImplemented();
710 }
711
712 void GraphicsContext3D::markContextChanged()
713 {
714     notImplemented();
715 }
716
717 void GraphicsContext3D::markLayerComposited()
718 {
719     notImplemented();
720 }
721
722 bool GraphicsContext3D::layerComposited() const
723 {
724     notImplemented();
725     return false;
726 }
727
728 void GraphicsContext3D::paintRenderingResultsToCanvas(CanvasRenderingContext* context, DrawingBuffer* drawingBuffer)
729 {
730     notImplemented();
731 }
732
733 PassRefPtr<ImageData> GraphicsContext3D::paintRenderingResultsToImageData(DrawingBuffer* drawingBuffer)
734 {
735     notImplemented();
736     return 0;
737 }
738
739 bool GraphicsContext3D::paintCompositedResultsToCanvas(CanvasRenderingContext*)
740 {
741     return false;
742 }
743
744 Platform3DObject GraphicsContext3D::createBuffer()
745 {
746     return m_private->createBuffer();
747 }
748
749 Platform3DObject GraphicsContext3D::createFramebuffer()
750 {
751     return m_private->createFramebuffer();
752 }
753
754 Platform3DObject GraphicsContext3D::createProgram()
755 {
756     return m_private->createProgram();
757 }
758
759 Platform3DObject GraphicsContext3D::createRenderbuffer()
760 {
761     return m_private->createRenderbuffer();
762 }
763
764 Platform3DObject GraphicsContext3D::createShader(GC3Denum type)
765 {
766     return m_private->createShader(type);
767 }
768
769 Platform3DObject GraphicsContext3D::createTexture()
770 {
771     return m_private->createTexture();
772 }
773
774 void GraphicsContext3D::deleteBuffer(Platform3DObject buffer)
775 {
776     m_private->deleteBuffer(buffer);
777 }
778
779 void GraphicsContext3D::deleteFramebuffer(Platform3DObject buffer)
780 {
781     m_private->deleteFramebuffer(buffer);
782 }
783
784 void GraphicsContext3D::deleteProgram(Platform3DObject program)
785 {
786     m_private->deleteProgram(program);
787 }
788
789 void GraphicsContext3D::deleteRenderbuffer(Platform3DObject buffer)
790 {
791     m_private->deleteRenderbuffer(buffer);
792 }
793
794 void GraphicsContext3D::deleteShader(Platform3DObject shader)
795 {
796     m_private->deleteShader(shader);
797 }
798
799 void GraphicsContext3D::deleteTexture(Platform3DObject texture)
800 {
801     m_private->deleteTexture(texture);
802 }
803
804 void GraphicsContext3D::synthesizeGLError(GC3Denum error)
805 {
806     m_private->synthesizeGLError(error);
807 }
808
809 Extensions3D* GraphicsContext3D::getExtensions()
810 {
811     return m_private->getExtensions();
812 }
813
814 IntSize GraphicsContext3D::getInternalFramebufferSize() const
815 {
816     notImplemented();
817     return IntSize();
818 }
819
820 void GraphicsContext3D::setContextLostCallback(PassOwnPtr<ContextLostCallback>)
821 {
822     notImplemented();
823 }
824
825 bool GraphicsContext3D::getImageData(Image* image, GC3Denum format, GC3Denum type, bool premultiplyAlpha,
826                                      bool ignoreGammaAndColorProfile, Vector<uint8_t>& outputVector)
827 {
828     notImplemented();
829     return false;
830 }
831
832 void GraphicsContext3D::validateAttributes()
833 {
834     notImplemented();
835 }
836
837 void GraphicsContext3D::readRenderingResults(unsigned char* pixels, int pixelsSize)
838 {
839     notImplemented();
840 }
841
842 bool GraphicsContext3D::reshapeFBOs(const IntSize&)
843 {
844     notImplemented();
845 }
846
847 void GraphicsContext3D::resolveMultisamplingIfNecessary(const IntRect&)
848 {
849     notImplemented();
850 }
851
852 bool GraphicsContext3D::isResourceSafe()
853 {
854     notImplemented();
855     return false;
856 }
857
858 } // namespace WebCore
859
860 #endif // ENABLE(WEBGL)