mirror of https://github.com/axmolengine/axmol.git
1947 lines
70 KiB
C++
1947 lines
70 KiB
C++
/****************************************************************************
|
|
Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
|
|
|
|
http://www.cocos2d-x.org
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
in the Software without restriction, including without limitation the rights
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be included in
|
|
all copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
THE SOFTWARE.
|
|
****************************************************************************/
|
|
|
|
/*
|
|
* AUTOGENERATED FILE. DO NOT EDIT IT
|
|
* Generated by "generate_jsb.py -c opengl_jsb.ini" on 2013-03-05
|
|
* Script version: v0.6
|
|
*/
|
|
#include "scripting/js-bindings/manual/js_bindings_config.h"
|
|
#ifdef JSB_INCLUDE_OPENGL
|
|
|
|
#include "scripting/js-bindings/manual/jsb_opengl_manual.h"
|
|
|
|
#include "jsfriendapi.h"
|
|
//#include "jsb_config.h"
|
|
#include "scripting/js-bindings/manual/js_bindings_core.h"
|
|
#include "scripting/js-bindings/manual/js_manual_conversions.h"
|
|
#include "scripting/js-bindings/manual/jsb_opengl_functions.h"
|
|
#include "platform/CCGL.h"
|
|
|
|
// Arguments: GLenum
|
|
// Ret value: void
|
|
bool JSB_glActiveTexture(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 1, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glActiveTexture((GLenum)arg0 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLuint, GLuint
|
|
// Ret value: void
|
|
bool JSB_glAttachShader(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 2, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; uint32_t arg1;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_uint32( cx, args.get(1), &arg1 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glAttachShader((GLuint)arg0 , (GLuint)arg1 );
|
|
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLuint, GLuint, char*
|
|
// Ret value: void
|
|
bool JSB_glBindAttribLocation(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 3, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; uint32_t arg1; const char* arg2;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_uint32( cx, args.get(1), &arg1 );
|
|
ok &= jsval_to_charptr(cx, args.get(2), &arg2 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glBindAttribLocation((GLuint)arg0 , (GLuint)arg1 , (char*)arg2 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLenum, GLuint
|
|
// Ret value: void
|
|
bool JSB_glBindBuffer(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 2, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; uint32_t arg1;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_uint32( cx, args.get(1), &arg1 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glBindBuffer((GLenum)arg0 , (GLuint)arg1 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLenum, GLuint
|
|
// Ret value: void
|
|
bool JSB_glBindFramebuffer(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 2, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; uint32_t arg1;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_uint32( cx, args.get(1), &arg1 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glBindFramebuffer((GLenum)arg0 , (GLuint)arg1 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLenum, GLuint
|
|
// Ret value: void
|
|
bool JSB_glBindRenderbuffer(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 2, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; uint32_t arg1;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_uint32( cx, args.get(1), &arg1 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glBindRenderbuffer((GLenum)arg0 , (GLuint)arg1 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLenum, GLuint
|
|
// Ret value: void
|
|
bool JSB_glBindTexture(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 2, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; uint32_t arg1;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_uint32( cx, args.get(1), &arg1 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glBindTexture((GLenum)arg0 , (GLuint)arg1 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLclampf, GLclampf, GLclampf, GLclampf
|
|
// Ret value: void
|
|
bool JSB_glBlendColor(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 4, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
int32_t arg0; int32_t arg1; int32_t arg2; int32_t arg3;
|
|
|
|
ok &= jsval_to_int32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_int32( cx, args.get(1), &arg1 );
|
|
ok &= jsval_to_int32( cx, args.get(2), &arg2 );
|
|
ok &= jsval_to_int32( cx, args.get(3), &arg3 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glBlendColor((GLclampf)arg0 , (GLclampf)arg1 , (GLclampf)arg2 , (GLclampf)arg3 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLenum
|
|
// Ret value: void
|
|
bool JSB_glBlendEquation(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 1, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glBlendEquation((GLenum)arg0 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLenum, GLenum
|
|
// Ret value: void
|
|
bool JSB_glBlendEquationSeparate(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 2, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; uint32_t arg1;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_uint32( cx, args.get(1), &arg1 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glBlendEquationSeparate((GLenum)arg0 , (GLenum)arg1 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLenum, GLenum
|
|
// Ret value: void
|
|
bool JSB_glBlendFunc(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 2, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; uint32_t arg1;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_uint32( cx, args.get(1), &arg1 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glBlendFunc((GLenum)arg0 , (GLenum)arg1 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLenum, GLenum, GLenum, GLenum
|
|
// Ret value: void
|
|
bool JSB_glBlendFuncSeparate(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 4, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; uint32_t arg1; uint32_t arg2; uint32_t arg3;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_uint32( cx, args.get(1), &arg1 );
|
|
ok &= jsval_to_uint32( cx, args.get(2), &arg2 );
|
|
ok &= jsval_to_uint32( cx, args.get(3), &arg3 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glBlendFuncSeparate((GLenum)arg0 , (GLenum)arg1 , (GLenum)arg2 , (GLenum)arg3 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLenum, ArrayBufferView, GLenum
|
|
// Ret value: void
|
|
bool JSB_glBufferData(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 3, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; void* arg1; uint32_t arg2;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
GLsizei count;
|
|
ok &= JSB_get_arraybufferview_dataptr( cx, args.get(1), &count, &arg1);
|
|
ok &= jsval_to_uint32( cx, args.get(2), &arg2 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glBufferData((GLenum)arg0 , count, (GLvoid*)arg1 , (GLenum)arg2 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLenum, GLintptr, ArrayBufferView
|
|
// Ret value: void
|
|
bool JSB_glBufferSubData(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 3, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; int32_t arg1; void* arg2;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_int32( cx, args.get(1), &arg1 );
|
|
GLsizei count;
|
|
ok &= JSB_get_arraybufferview_dataptr( cx, args.get(2), &count, &arg2);
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glBufferSubData((GLenum)arg0 , (GLintptr)arg1 , count, (GLvoid*)arg2 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLenum
|
|
// Ret value: GLenum
|
|
bool JSB_glCheckFramebufferStatus(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 1, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
GLenum ret_val;
|
|
|
|
ret_val = glCheckFramebufferStatus((GLenum)arg0 );
|
|
args.rval().set(UINT_TO_JSVAL((uint32_t)ret_val));
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLbitfield
|
|
// Ret value: void
|
|
bool JSB_glClear(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 1, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glClear((GLbitfield)arg0 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLclampf, GLclampf, GLclampf, GLclampf
|
|
// Ret value: void
|
|
bool JSB_glClearColor(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 4, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
int32_t arg0; int32_t arg1; int32_t arg2; int32_t arg3;
|
|
|
|
ok &= jsval_to_int32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_int32( cx, args.get(1), &arg1 );
|
|
ok &= jsval_to_int32( cx, args.get(2), &arg2 );
|
|
ok &= jsval_to_int32( cx, args.get(3), &arg3 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glClearColor((GLclampf)arg0 , (GLclampf)arg1 , (GLclampf)arg2 , (GLclampf)arg3 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLclampf
|
|
// Ret value: void
|
|
bool JSB_glClearDepthf(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 1, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
int32_t arg0;
|
|
|
|
ok &= jsval_to_int32( cx, args.get(0), &arg0 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glClearDepthf((GLclampf)arg0 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLint
|
|
// Ret value: void
|
|
bool JSB_glClearStencil(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 1, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
int32_t arg0;
|
|
|
|
ok &= jsval_to_int32( cx, args.get(0), &arg0 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glClearStencil((GLint)arg0 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLboolean, GLboolean, GLboolean, GLboolean
|
|
// Ret value: void
|
|
bool JSB_glColorMask(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 4, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint16_t arg0; uint16_t arg1; uint16_t arg2; uint16_t arg3;
|
|
|
|
ok &= jsval_to_uint16( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_uint16( cx, args.get(1), &arg1 );
|
|
ok &= jsval_to_uint16( cx, args.get(2), &arg2 );
|
|
ok &= jsval_to_uint16( cx, args.get(3), &arg3 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glColorMask((GLboolean)arg0 , (GLboolean)arg1 , (GLboolean)arg2 , (GLboolean)arg3 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLuint
|
|
// Ret value: void
|
|
bool JSB_glCompileShader(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 1, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glCompileShader((GLuint)arg0 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, ArrayBufferView
|
|
// Ret value: void
|
|
bool JSB_glCompressedTexImage2D(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 8, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; int32_t arg1; uint32_t arg2; int32_t arg3; int32_t arg4; int32_t arg5; int32_t arg6; void* arg7;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_int32( cx, args.get(1), &arg1 );
|
|
ok &= jsval_to_uint32( cx, args.get(2), &arg2 );
|
|
ok &= jsval_to_int32( cx, args.get(3), &arg3 );
|
|
ok &= jsval_to_int32( cx, args.get(4), &arg4 );
|
|
ok &= jsval_to_int32( cx, args.get(5), &arg5 );
|
|
ok &= jsval_to_int32( cx, args.get(6), &arg6 );
|
|
GLsizei count;
|
|
ok &= JSB_get_arraybufferview_dataptr( cx, args.get(7), &count, &arg7);
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glCompressedTexImage2D((GLenum)arg0 , (GLint)arg1 , (GLenum)arg2 , (GLsizei)arg3 , (GLsizei)arg4 , (GLint)arg5 , (GLsizei)arg6 , (GLvoid*)arg7 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, ArrayBufferView
|
|
// Ret value: void
|
|
bool JSB_glCompressedTexSubImage2D(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 9, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; int32_t arg1; int32_t arg2; int32_t arg3; int32_t arg4; int32_t arg5; uint32_t arg6; int32_t arg7; void* arg8;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_int32( cx, args.get(1), &arg1 );
|
|
ok &= jsval_to_int32( cx, args.get(2), &arg2 );
|
|
ok &= jsval_to_int32( cx, args.get(3), &arg3 );
|
|
ok &= jsval_to_int32( cx, args.get(4), &arg4 );
|
|
ok &= jsval_to_int32( cx, args.get(5), &arg5 );
|
|
ok &= jsval_to_uint32( cx, args.get(6), &arg6 );
|
|
ok &= jsval_to_int32( cx, args.get(7), &arg7 );
|
|
GLsizei count;
|
|
ok &= JSB_get_arraybufferview_dataptr( cx, args.get(8), &count, &arg8);
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glCompressedTexSubImage2D((GLenum)arg0 , (GLint)arg1 , (GLint)arg2 , (GLint)arg3 , (GLsizei)arg4 , (GLsizei)arg5 , (GLenum)arg6 , (GLsizei)arg7 , (GLvoid*)arg8 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint
|
|
// Ret value: void
|
|
bool JSB_glCopyTexImage2D(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 8, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; int32_t arg1; uint32_t arg2; int32_t arg3; int32_t arg4; int32_t arg5; int32_t arg6; int32_t arg7;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_int32( cx, args.get(1), &arg1 );
|
|
ok &= jsval_to_uint32( cx, args.get(2), &arg2 );
|
|
ok &= jsval_to_int32( cx, args.get(3), &arg3 );
|
|
ok &= jsval_to_int32( cx, args.get(4), &arg4 );
|
|
ok &= jsval_to_int32( cx, args.get(5), &arg5 );
|
|
ok &= jsval_to_int32( cx, args.get(6), &arg6 );
|
|
ok &= jsval_to_int32( cx, args.get(7), &arg7 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glCopyTexImage2D((GLenum)arg0 , (GLint)arg1 , (GLenum)arg2 , (GLint)arg3 , (GLint)arg4 , (GLsizei)arg5 , (GLsizei)arg6 , (GLint)arg7 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei
|
|
// Ret value: void
|
|
bool JSB_glCopyTexSubImage2D(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 8, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; int32_t arg1; int32_t arg2; int32_t arg3; int32_t arg4; int32_t arg5; int32_t arg6; int32_t arg7;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_int32( cx, args.get(1), &arg1 );
|
|
ok &= jsval_to_int32( cx, args.get(2), &arg2 );
|
|
ok &= jsval_to_int32( cx, args.get(3), &arg3 );
|
|
ok &= jsval_to_int32( cx, args.get(4), &arg4 );
|
|
ok &= jsval_to_int32( cx, args.get(5), &arg5 );
|
|
ok &= jsval_to_int32( cx, args.get(6), &arg6 );
|
|
ok &= jsval_to_int32( cx, args.get(7), &arg7 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glCopyTexSubImage2D((GLenum)arg0 , (GLint)arg1 , (GLint)arg2 , (GLint)arg3 , (GLint)arg4 , (GLint)arg5 , (GLsizei)arg6 , (GLsizei)arg7 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments:
|
|
// Ret value: GLuint
|
|
bool JSB_glCreateProgram(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 0, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
GLuint ret_val;
|
|
|
|
ret_val = glCreateProgram( );
|
|
args.rval().set(UINT_TO_JSVAL((uint32_t)ret_val));
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLenum
|
|
// Ret value: GLuint
|
|
bool JSB_glCreateShader(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 1, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
GLuint ret_val;
|
|
|
|
ret_val = glCreateShader((GLenum)arg0 );
|
|
args.rval().set(UINT_TO_JSVAL((uint32_t)ret_val));
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLenum
|
|
// Ret value: void
|
|
bool JSB_glCullFace(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 1, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glCullFace((GLenum)arg0 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLuint
|
|
// Ret value: void
|
|
bool JSB_glDeleteProgram(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 1, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glDeleteProgram((GLuint)arg0 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLuint
|
|
// Ret value: void
|
|
bool JSB_glDeleteShader(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 1, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glDeleteShader((GLuint)arg0 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLenum
|
|
// Ret value: void
|
|
bool JSB_glDepthFunc(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 1, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glDepthFunc((GLenum)arg0 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLboolean
|
|
// Ret value: void
|
|
bool JSB_glDepthMask(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 1, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint16_t arg0;
|
|
|
|
ok &= jsval_to_uint16( cx, args.get(0), &arg0 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glDepthMask((GLboolean)arg0 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLclampf, GLclampf
|
|
// Ret value: void
|
|
bool JSB_glDepthRangef(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 2, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
int32_t arg0; int32_t arg1;
|
|
|
|
ok &= jsval_to_int32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_int32( cx, args.get(1), &arg1 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glDepthRangef((GLclampf)arg0 , (GLclampf)arg1 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLuint, GLuint
|
|
// Ret value: void
|
|
bool JSB_glDetachShader(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 2, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; uint32_t arg1;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_uint32( cx, args.get(1), &arg1 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glDetachShader((GLuint)arg0 , (GLuint)arg1 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLenum
|
|
// Ret value: void
|
|
bool JSB_glDisable(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 1, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glDisable((GLenum)arg0 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLuint
|
|
// Ret value: void
|
|
bool JSB_glDisableVertexAttribArray(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 1, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glDisableVertexAttribArray((GLuint)arg0 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLenum, GLint, GLsizei
|
|
// Ret value: void
|
|
bool JSB_glDrawArrays(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 3, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; int32_t arg1; int32_t arg2;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_int32( cx, args.get(1), &arg1 );
|
|
ok &= jsval_to_int32( cx, args.get(2), &arg2 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glDrawArrays((GLenum)arg0 , (GLint)arg1 , (GLsizei)arg2 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLenum, GLsizei, GLenum, ArrayBufferView
|
|
// Ret value: void
|
|
bool JSB_glDrawElements(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 4, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; int32_t arg1; uint32_t arg2; void* arg3;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_int32( cx, args.get(1), &arg1 );
|
|
ok &= jsval_to_uint32( cx, args.get(2), &arg2 );
|
|
GLsizei count;
|
|
ok &= JSB_get_arraybufferview_dataptr( cx, args.get(3), &count, &arg3);
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glDrawElements((GLenum)arg0 , (GLsizei)arg1 , (GLenum)arg2 , (GLvoid*)arg3 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLenum
|
|
// Ret value: void
|
|
bool JSB_glEnable(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 1, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glEnable((GLenum)arg0 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLuint
|
|
// Ret value: void
|
|
bool JSB_glEnableVertexAttribArray(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 1, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glEnableVertexAttribArray((GLuint)arg0 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments:
|
|
// Ret value: void
|
|
bool JSB_glFinish(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 0, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
glFinish( );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments:
|
|
// Ret value: void
|
|
bool JSB_glFlush(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 0, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
glFlush( );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLenum, GLenum, GLenum, GLuint
|
|
// Ret value: void
|
|
bool JSB_glFramebufferRenderbuffer(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 4, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; uint32_t arg1; uint32_t arg2; uint32_t arg3;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_uint32( cx, args.get(1), &arg1 );
|
|
ok &= jsval_to_uint32( cx, args.get(2), &arg2 );
|
|
ok &= jsval_to_uint32( cx, args.get(3), &arg3 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glFramebufferRenderbuffer((GLenum)arg0 , (GLenum)arg1 , (GLenum)arg2 , (GLuint)arg3 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLenum, GLenum, GLenum, GLuint, GLint
|
|
// Ret value: void
|
|
bool JSB_glFramebufferTexture2D(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 5, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; uint32_t arg1; uint32_t arg2; uint32_t arg3; int32_t arg4;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_uint32( cx, args.get(1), &arg1 );
|
|
ok &= jsval_to_uint32( cx, args.get(2), &arg2 );
|
|
ok &= jsval_to_uint32( cx, args.get(3), &arg3 );
|
|
ok &= jsval_to_int32( cx, args.get(4), &arg4 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glFramebufferTexture2D((GLenum)arg0 , (GLenum)arg1 , (GLenum)arg2 , (GLuint)arg3 , (GLint)arg4 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLenum
|
|
// Ret value: void
|
|
bool JSB_glFrontFace(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 1, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glFrontFace((GLenum)arg0 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLenum
|
|
// Ret value: void
|
|
bool JSB_glGenerateMipmap(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 1, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glGenerateMipmap((GLenum)arg0 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLuint, char*
|
|
// Ret value: int
|
|
bool JSB_glGetAttribLocation(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 2, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; const char* arg1;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_charptr( cx, args.get(1), &arg1 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
int ret_val;
|
|
|
|
ret_val = glGetAttribLocation((GLuint)arg0 , (char*)arg1 );
|
|
args.rval().set(INT_TO_JSVAL((int32_t)ret_val));
|
|
return true;
|
|
}
|
|
|
|
// Arguments:
|
|
// Ret value: GLenum
|
|
bool JSB_glGetError(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 0, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
GLenum ret_val;
|
|
|
|
ret_val = glGetError( );
|
|
args.rval().set(UINT_TO_JSVAL((uint32_t)ret_val));
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLuint, char*
|
|
// Ret value: int
|
|
bool JSB_glGetUniformLocation(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 2, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; const char* arg1;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_charptr( cx, args.get(1), &arg1 );
|
|
printf("%s ", arg1);
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
int ret_val;
|
|
|
|
ret_val = glGetUniformLocation((GLuint)arg0 , (char*)arg1 );
|
|
args.rval().set(INT_TO_JSVAL((int32_t)ret_val));
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLenum, GLenum
|
|
// Ret value: void
|
|
bool JSB_glHint(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 2, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; uint32_t arg1;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_uint32( cx, args.get(1), &arg1 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glHint((GLenum)arg0 , (GLenum)arg1 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLuint
|
|
// Ret value: GLboolean
|
|
bool JSB_glIsBuffer(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 1, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
GLboolean ret_val;
|
|
|
|
ret_val = glIsBuffer((GLuint)arg0 );
|
|
args.rval().set(INT_TO_JSVAL((int32_t)ret_val));
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLenum
|
|
// Ret value: GLboolean
|
|
bool JSB_glIsEnabled(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 1, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
GLboolean ret_val;
|
|
|
|
ret_val = glIsEnabled((GLenum)arg0 );
|
|
args.rval().set(INT_TO_JSVAL((int32_t)ret_val));
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLuint
|
|
// Ret value: GLboolean
|
|
bool JSB_glIsFramebuffer(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 1, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
GLboolean ret_val;
|
|
|
|
ret_val = glIsFramebuffer((GLuint)arg0 );
|
|
args.rval().set(INT_TO_JSVAL((int32_t)ret_val));
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLuint
|
|
// Ret value: GLboolean
|
|
bool JSB_glIsProgram(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 1, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
GLboolean ret_val;
|
|
|
|
ret_val = glIsProgram((GLuint)arg0 );
|
|
args.rval().set(INT_TO_JSVAL((int32_t)ret_val));
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLuint
|
|
// Ret value: GLboolean
|
|
bool JSB_glIsRenderbuffer(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 1, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
GLboolean ret_val;
|
|
|
|
ret_val = glIsRenderbuffer((GLuint)arg0 );
|
|
args.rval().set(INT_TO_JSVAL((int32_t)ret_val));
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLuint
|
|
// Ret value: GLboolean
|
|
bool JSB_glIsShader(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 1, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
GLboolean ret_val;
|
|
|
|
ret_val = glIsShader((GLuint)arg0 );
|
|
args.rval().set(INT_TO_JSVAL((int32_t)ret_val));
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLuint
|
|
// Ret value: GLboolean
|
|
bool JSB_glIsTexture(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 1, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
GLboolean ret_val;
|
|
|
|
ret_val = glIsTexture((GLuint)arg0 );
|
|
args.rval().set(INT_TO_JSVAL((int32_t)ret_val));
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLfloat
|
|
// Ret value: void
|
|
bool JSB_glLineWidth(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 1, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
int32_t arg0;
|
|
|
|
ok &= jsval_to_int32( cx, args.get(0), &arg0 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glLineWidth((GLfloat)arg0 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLuint
|
|
// Ret value: void
|
|
bool JSB_glLinkProgram(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 1, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glLinkProgram((GLuint)arg0 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLenum, GLint
|
|
// Ret value: void
|
|
bool JSB_glPixelStorei(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 2, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; int32_t arg1;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_int32( cx, args.get(1), &arg1 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glPixelStorei((GLenum)arg0 , (GLint)arg1 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLfloat, GLfloat
|
|
// Ret value: void
|
|
bool JSB_glPolygonOffset(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 2, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
int32_t arg0; int32_t arg1;
|
|
|
|
ok &= jsval_to_int32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_int32( cx, args.get(1), &arg1 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glPolygonOffset((GLfloat)arg0 , (GLfloat)arg1 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, ArrayBufferView
|
|
// Ret value: void
|
|
bool JSB_glReadPixels(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 7, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
int32_t arg0; int32_t arg1; int32_t arg2; int32_t arg3; uint32_t arg4; uint32_t arg5; void* arg6;
|
|
|
|
ok &= jsval_to_int32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_int32( cx, args.get(1), &arg1 );
|
|
ok &= jsval_to_int32( cx, args.get(2), &arg2 );
|
|
ok &= jsval_to_int32( cx, args.get(3), &arg3 );
|
|
ok &= jsval_to_uint32( cx, args.get(4), &arg4 );
|
|
ok &= jsval_to_uint32( cx, args.get(5), &arg5 );
|
|
GLsizei count;
|
|
ok &= JSB_get_arraybufferview_dataptr( cx, args.get(6), &count, &arg6);
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glReadPixels((GLint)arg0 , (GLint)arg1 , (GLsizei)arg2 , (GLsizei)arg3 , (GLenum)arg4 , (GLenum)arg5 , (GLvoid*)arg6 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments:
|
|
// Ret value: void
|
|
bool JSB_glReleaseShaderCompiler(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 0, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
glReleaseShaderCompiler( );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLenum, GLenum, GLsizei, GLsizei
|
|
// Ret value: void
|
|
bool JSB_glRenderbufferStorage(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 4, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; uint32_t arg1; int32_t arg2; int32_t arg3;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_uint32( cx, args.get(1), &arg1 );
|
|
ok &= jsval_to_int32( cx, args.get(2), &arg2 );
|
|
ok &= jsval_to_int32( cx, args.get(3), &arg3 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glRenderbufferStorage((GLenum)arg0 , (GLenum)arg1 , (GLsizei)arg2 , (GLsizei)arg3 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLclampf, GLboolean
|
|
// Ret value: void
|
|
bool JSB_glSampleCoverage(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 2, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
int32_t arg0; uint16_t arg1;
|
|
|
|
ok &= jsval_to_int32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_uint16( cx, args.get(1), &arg1 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glSampleCoverage((GLclampf)arg0 , (GLboolean)arg1 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLint, GLint, GLsizei, GLsizei
|
|
// Ret value: void
|
|
bool JSB_glScissor(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 4, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
int32_t arg0; int32_t arg1; int32_t arg2; int32_t arg3;
|
|
|
|
ok &= jsval_to_int32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_int32( cx, args.get(1), &arg1 );
|
|
ok &= jsval_to_int32( cx, args.get(2), &arg2 );
|
|
ok &= jsval_to_int32( cx, args.get(3), &arg3 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glScissor((GLint)arg0 , (GLint)arg1 , (GLsizei)arg2 , (GLsizei)arg3 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLenum, GLint, GLuint
|
|
// Ret value: void
|
|
bool JSB_glStencilFunc(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 3, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; int32_t arg1; uint32_t arg2;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_int32( cx, args.get(1), &arg1 );
|
|
ok &= jsval_to_uint32( cx, args.get(2), &arg2 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glStencilFunc((GLenum)arg0 , (GLint)arg1 , (GLuint)arg2 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLenum, GLenum, GLint, GLuint
|
|
// Ret value: void
|
|
bool JSB_glStencilFuncSeparate(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 4, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; uint32_t arg1; int32_t arg2; uint32_t arg3;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_uint32( cx, args.get(1), &arg1 );
|
|
ok &= jsval_to_int32( cx, args.get(2), &arg2 );
|
|
ok &= jsval_to_uint32( cx, args.get(3), &arg3 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glStencilFuncSeparate((GLenum)arg0 , (GLenum)arg1 , (GLint)arg2 , (GLuint)arg3 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLuint
|
|
// Ret value: void
|
|
bool JSB_glStencilMask(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 1, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glStencilMask((GLuint)arg0 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLenum, GLuint
|
|
// Ret value: void
|
|
bool JSB_glStencilMaskSeparate(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 2, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; uint32_t arg1;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_uint32( cx, args.get(1), &arg1 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glStencilMaskSeparate((GLenum)arg0 , (GLuint)arg1 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLenum, GLenum, GLenum
|
|
// Ret value: void
|
|
bool JSB_glStencilOp(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 3, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; uint32_t arg1; uint32_t arg2;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_uint32( cx, args.get(1), &arg1 );
|
|
ok &= jsval_to_uint32( cx, args.get(2), &arg2 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glStencilOp((GLenum)arg0 , (GLenum)arg1 , (GLenum)arg2 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLenum, GLenum, GLenum, GLenum
|
|
// Ret value: void
|
|
bool JSB_glStencilOpSeparate(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 4, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; uint32_t arg1; uint32_t arg2; uint32_t arg3;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_uint32( cx, args.get(1), &arg1 );
|
|
ok &= jsval_to_uint32( cx, args.get(2), &arg2 );
|
|
ok &= jsval_to_uint32( cx, args.get(3), &arg3 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glStencilOpSeparate((GLenum)arg0 , (GLenum)arg1 , (GLenum)arg2 , (GLenum)arg3 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, ArrayBufferView
|
|
// Ret value: void
|
|
bool JSB_glTexImage2D(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 9, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; int32_t arg1; int32_t arg2; int32_t arg3; int32_t arg4; int32_t arg5; uint32_t arg6; uint32_t arg7; void* arg8;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_int32( cx, args.get(1), &arg1 );
|
|
ok &= jsval_to_int32( cx, args.get(2), &arg2 );
|
|
ok &= jsval_to_int32( cx, args.get(3), &arg3 );
|
|
ok &= jsval_to_int32( cx, args.get(4), &arg4 );
|
|
ok &= jsval_to_int32( cx, args.get(5), &arg5 );
|
|
ok &= jsval_to_uint32( cx, args.get(6), &arg6 );
|
|
ok &= jsval_to_uint32( cx, args.get(7), &arg7 );
|
|
GLsizei count;
|
|
ok &= JSB_get_arraybufferview_dataptr( cx, args.get(8), &count, &arg8);
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glTexImage2D((GLenum)arg0 , (GLint)arg1 , (GLint)arg2 , (GLsizei)arg3 , (GLsizei)arg4 , (GLint)arg5 , (GLenum)arg6 , (GLenum)arg7 , (GLvoid*)arg8 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLenum, GLenum, GLfloat
|
|
// Ret value: void
|
|
bool JSB_glTexParameterf(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 3, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; uint32_t arg1; int32_t arg2;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_uint32( cx, args.get(1), &arg1 );
|
|
ok &= jsval_to_int32( cx, args.get(2), &arg2 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glTexParameterf((GLenum)arg0 , (GLenum)arg1 , (GLfloat)arg2 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLenum, GLenum, GLint
|
|
// Ret value: void
|
|
bool JSB_glTexParameteri(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 3, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; uint32_t arg1; int32_t arg2;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_uint32( cx, args.get(1), &arg1 );
|
|
ok &= jsval_to_int32( cx, args.get(2), &arg2 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glTexParameteri((GLenum)arg0 , (GLenum)arg1 , (GLint)arg2 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, ArrayBufferView
|
|
// Ret value: void
|
|
bool JSB_glTexSubImage2D(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 9, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; int32_t arg1; int32_t arg2; int32_t arg3; int32_t arg4; int32_t arg5; uint32_t arg6; uint32_t arg7; void* arg8;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_int32( cx, args.get(1), &arg1 );
|
|
ok &= jsval_to_int32( cx, args.get(2), &arg2 );
|
|
ok &= jsval_to_int32( cx, args.get(3), &arg3 );
|
|
ok &= jsval_to_int32( cx, args.get(4), &arg4 );
|
|
ok &= jsval_to_int32( cx, args.get(5), &arg5 );
|
|
ok &= jsval_to_uint32( cx, args.get(6), &arg6 );
|
|
ok &= jsval_to_uint32( cx, args.get(7), &arg7 );
|
|
GLsizei count;
|
|
ok &= JSB_get_arraybufferview_dataptr( cx, args.get(8), &count, &arg8);
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glTexSubImage2D((GLenum)arg0 , (GLint)arg1 , (GLint)arg2 , (GLint)arg3 , (GLsizei)arg4 , (GLsizei)arg5 , (GLenum)arg6 , (GLenum)arg7 , (GLvoid*)arg8 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLint, GLfloat
|
|
// Ret value: void
|
|
bool JSB_glUniform1f(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 2, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
int32_t arg0; int32_t arg1;
|
|
|
|
ok &= jsval_to_int32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_int32( cx, args.get(1), &arg1 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glUniform1f((GLint)arg0 , (GLfloat)arg1 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLint, GLsizei, TypedArray/Sequence
|
|
// Ret value: void
|
|
bool JSB_glUniform1fv(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 3, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
int32_t arg0; int32_t arg1; void* arg2;
|
|
|
|
ok &= jsval_to_int32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_int32( cx, args.get(1), &arg1 );
|
|
GLsizei count;
|
|
ok &= JSB_jsval_typedarray_to_dataptr( cx, args.get(2), &count, &arg2, js::Scalar::Float32);
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glUniform1fv((GLint)arg0 , (GLsizei)arg1 , (GLfloat*)arg2 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLint, GLint
|
|
// Ret value: void
|
|
bool JSB_glUniform1i(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 2, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
int32_t arg0; int32_t arg1;
|
|
|
|
ok &= jsval_to_int32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_int32( cx, args.get(1), &arg1 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glUniform1i((GLint)arg0 , (GLint)arg1 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLint, GLsizei, TypedArray/Sequence
|
|
// Ret value: void
|
|
bool JSB_glUniform1iv(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 3, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
int32_t arg0; int32_t arg1; void* arg2;
|
|
|
|
ok &= jsval_to_int32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_int32( cx, args.get(1), &arg1 );
|
|
GLsizei count;
|
|
ok &= JSB_jsval_typedarray_to_dataptr( cx, args.get(2), &count, &arg2, js::Scalar::Int32);
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glUniform1iv((GLint)arg0 , (GLsizei)arg1 , (GLint*)arg2 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLint, GLfloat, GLfloat
|
|
// Ret value: void
|
|
bool JSB_glUniform2f(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 3, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
int32_t arg0; int32_t arg1; int32_t arg2;
|
|
|
|
ok &= jsval_to_int32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_int32( cx, args.get(1), &arg1 );
|
|
ok &= jsval_to_int32( cx, args.get(2), &arg2 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glUniform2f((GLint)arg0 , (GLfloat)arg1 , (GLfloat)arg2 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLint, GLsizei, TypedArray/Sequence
|
|
// Ret value: void
|
|
bool JSB_glUniform2fv(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 3, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
int32_t arg0; int32_t arg1; void* arg2;
|
|
|
|
ok &= jsval_to_int32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_int32( cx, args.get(1), &arg1 );
|
|
GLsizei count;
|
|
ok &= JSB_jsval_typedarray_to_dataptr( cx, args.get(2), &count, &arg2, js::Scalar::Float32);
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glUniform2fv((GLint)arg0 , (GLsizei)arg1 , (GLfloat*)arg2 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLint, GLint, GLint
|
|
// Ret value: void
|
|
bool JSB_glUniform2i(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 3, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
int32_t arg0; int32_t arg1; int32_t arg2;
|
|
|
|
ok &= jsval_to_int32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_int32( cx, args.get(1), &arg1 );
|
|
ok &= jsval_to_int32( cx, args.get(2), &arg2 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glUniform2i((GLint)arg0 , (GLint)arg1 , (GLint)arg2 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLint, GLsizei, TypedArray/Sequence
|
|
// Ret value: void
|
|
bool JSB_glUniform2iv(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 3, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
int32_t arg0; int32_t arg1; void* arg2;
|
|
|
|
ok &= jsval_to_int32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_int32( cx, args.get(1), &arg1 );
|
|
GLsizei count;
|
|
ok &= JSB_jsval_typedarray_to_dataptr( cx, args.get(2), &count, &arg2, js::Scalar::Int32);
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glUniform2iv((GLint)arg0 , (GLsizei)arg1 , (GLint*)arg2 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLint, GLfloat, GLfloat, GLfloat
|
|
// Ret value: void
|
|
bool JSB_glUniform3f(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 4, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
int32_t arg0; int32_t arg1; int32_t arg2; int32_t arg3;
|
|
|
|
ok &= jsval_to_int32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_int32( cx, args.get(1), &arg1 );
|
|
ok &= jsval_to_int32( cx, args.get(2), &arg2 );
|
|
ok &= jsval_to_int32( cx, args.get(3), &arg3 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glUniform3f((GLint)arg0 , (GLfloat)arg1 , (GLfloat)arg2 , (GLfloat)arg3 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLint, GLsizei, TypedArray/Sequence
|
|
// Ret value: void
|
|
bool JSB_glUniform3fv(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 3, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
int32_t arg0; int32_t arg1; void* arg2;
|
|
|
|
ok &= jsval_to_int32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_int32( cx, args.get(1), &arg1 );
|
|
GLsizei count;
|
|
ok &= JSB_jsval_typedarray_to_dataptr( cx, args.get(2), &count, &arg2, js::Scalar::Float32);
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glUniform3fv((GLint)arg0 , (GLsizei)arg1 , (GLfloat*)arg2 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLint, GLint, GLint, GLint
|
|
// Ret value: void
|
|
bool JSB_glUniform3i(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 4, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
int32_t arg0; int32_t arg1; int32_t arg2; int32_t arg3;
|
|
|
|
ok &= jsval_to_int32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_int32( cx, args.get(1), &arg1 );
|
|
ok &= jsval_to_int32( cx, args.get(2), &arg2 );
|
|
ok &= jsval_to_int32( cx, args.get(3), &arg3 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glUniform3i((GLint)arg0 , (GLint)arg1 , (GLint)arg2 , (GLint)arg3 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLint, GLsizei, TypedArray/Sequence
|
|
// Ret value: void
|
|
bool JSB_glUniform3iv(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 3, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
int32_t arg0; int32_t arg1; void* arg2;
|
|
|
|
ok &= jsval_to_int32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_int32( cx, args.get(1), &arg1 );
|
|
GLsizei count;
|
|
ok &= JSB_jsval_typedarray_to_dataptr( cx, args.get(2), &count, &arg2, js::Scalar::Int32);
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glUniform3iv((GLint)arg0 , (GLsizei)arg1 , (GLint*)arg2 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLint, GLfloat, GLfloat, GLfloat, GLfloat
|
|
// Ret value: void
|
|
bool JSB_glUniform4f(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 5, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
int32_t arg0; int32_t arg1; int32_t arg2; int32_t arg3; int32_t arg4;
|
|
|
|
ok &= jsval_to_int32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_int32( cx, args.get(1), &arg1 );
|
|
ok &= jsval_to_int32( cx, args.get(2), &arg2 );
|
|
ok &= jsval_to_int32( cx, args.get(3), &arg3 );
|
|
ok &= jsval_to_int32( cx, args.get(4), &arg4 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glUniform4f((GLint)arg0 , (GLfloat)arg1 , (GLfloat)arg2 , (GLfloat)arg3 , (GLfloat)arg4 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLint, GLsizei, TypedArray/Sequence
|
|
// Ret value: void
|
|
bool JSB_glUniform4fv(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 3, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
int32_t arg0; int32_t arg1; void* arg2;
|
|
|
|
ok &= jsval_to_int32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_int32( cx, args.get(1), &arg1 );
|
|
GLsizei count;
|
|
ok &= JSB_jsval_typedarray_to_dataptr( cx, args.get(2), &count, &arg2, js::Scalar::Float32);
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glUniform4fv((GLint)arg0 , (GLsizei)arg1 , (GLfloat*)arg2 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLint, GLint, GLint, GLint, GLint
|
|
// Ret value: void
|
|
bool JSB_glUniform4i(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 5, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
int32_t arg0; int32_t arg1; int32_t arg2; int32_t arg3; int32_t arg4;
|
|
|
|
ok &= jsval_to_int32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_int32( cx, args.get(1), &arg1 );
|
|
ok &= jsval_to_int32( cx, args.get(2), &arg2 );
|
|
ok &= jsval_to_int32( cx, args.get(3), &arg3 );
|
|
ok &= jsval_to_int32( cx, args.get(4), &arg4 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glUniform4i((GLint)arg0 , (GLint)arg1 , (GLint)arg2 , (GLint)arg3 , (GLint)arg4 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLint, GLsizei, TypedArray/Sequence
|
|
// Ret value: void
|
|
bool JSB_glUniform4iv(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 3, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
int32_t arg0; int32_t arg1; void* arg2;
|
|
|
|
ok &= jsval_to_int32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_int32( cx, args.get(1), &arg1 );
|
|
GLsizei count;
|
|
ok &= JSB_jsval_typedarray_to_dataptr( cx, args.get(2), &count, &arg2, js::Scalar::Int32);
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glUniform4iv((GLint)arg0 , (GLsizei)arg1 , (GLint*)arg2 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLint, GLboolean, TypedArray/Sequence
|
|
// Ret value: void
|
|
bool JSB_glUniformMatrix2fv(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 3, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
int32_t arg0; uint16_t arg1; void* arg2;
|
|
|
|
ok &= jsval_to_int32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_uint16( cx, args.get(1), &arg1 );
|
|
GLsizei count;
|
|
ok &= JSB_jsval_typedarray_to_dataptr( cx, args.get(2), &count, &arg2, js::Scalar::Float32);
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glUniformMatrix2fv(arg0, 1, (GLboolean)arg1 , (GLfloat*)arg2 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLint, GLboolean, TypedArray/Sequence
|
|
// Ret value: void
|
|
bool JSB_glUniformMatrix3fv(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 3, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
int32_t arg0; uint16_t arg1; void* arg2;
|
|
|
|
ok &= jsval_to_int32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_uint16( cx, args.get(1), &arg1 );
|
|
GLsizei count;
|
|
ok &= JSB_jsval_typedarray_to_dataptr( cx, args.get(2), &count, &arg2, js::Scalar::Float32);
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glUniformMatrix3fv(arg0, 1, (GLboolean)arg1 , (GLfloat*)arg2 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLint, GLboolean, TypedArray/Sequence
|
|
// Ret value: void
|
|
bool JSB_glUniformMatrix4fv(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 3, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
int32_t arg0; uint16_t arg1; void* arg2;
|
|
|
|
ok &= jsval_to_int32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_uint16( cx, args.get(1), &arg1 );
|
|
GLsizei count;
|
|
ok &= JSB_jsval_typedarray_to_dataptr( cx, args.get(2), &count, &arg2, js::Scalar::Float32);
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glUniformMatrix4fv(arg0, 1, (GLboolean)arg1 , (GLfloat*)arg2 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLuint
|
|
// Ret value: void
|
|
bool JSB_glUseProgram(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 1, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glUseProgram((GLuint)arg0 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLuint
|
|
// Ret value: void
|
|
bool JSB_glValidateProgram(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 1, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glValidateProgram((GLuint)arg0 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLuint, GLfloat
|
|
// Ret value: void
|
|
bool JSB_glVertexAttrib1f(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 2, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; int32_t arg1;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_int32( cx, args.get(1), &arg1 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glVertexAttrib1f((GLuint)arg0 , (GLfloat)arg1 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLuint, TypedArray/Sequence
|
|
// Ret value: void
|
|
bool JSB_glVertexAttrib1fv(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 2, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; void* arg1;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
GLsizei count;
|
|
ok &= JSB_jsval_typedarray_to_dataptr( cx, args.get(1), &count, &arg1, js::Scalar::Float32);
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glVertexAttrib1fv((GLuint)arg0 , (GLfloat*)arg1 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLuint, GLfloat, GLfloat
|
|
// Ret value: void
|
|
bool JSB_glVertexAttrib2f(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 3, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; int32_t arg1; int32_t arg2;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_int32( cx, args.get(1), &arg1 );
|
|
ok &= jsval_to_int32( cx, args.get(2), &arg2 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glVertexAttrib2f((GLuint)arg0 , (GLfloat)arg1 , (GLfloat)arg2 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLuint, TypedArray/Sequence
|
|
// Ret value: void
|
|
bool JSB_glVertexAttrib2fv(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 2, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; void* arg1;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
GLsizei count;
|
|
ok &= JSB_jsval_typedarray_to_dataptr( cx, args.get(1), &count, &arg1, js::Scalar::Float32);
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glVertexAttrib2fv((GLuint)arg0 , (GLfloat*)arg1 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLuint, GLfloat, GLfloat, GLfloat
|
|
// Ret value: void
|
|
bool JSB_glVertexAttrib3f(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 4, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; int32_t arg1; int32_t arg2; int32_t arg3;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_int32( cx, args.get(1), &arg1 );
|
|
ok &= jsval_to_int32( cx, args.get(2), &arg2 );
|
|
ok &= jsval_to_int32( cx, args.get(3), &arg3 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glVertexAttrib3f((GLuint)arg0 , (GLfloat)arg1 , (GLfloat)arg2 , (GLfloat)arg3 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLuint, TypedArray/Sequence
|
|
// Ret value: void
|
|
bool JSB_glVertexAttrib3fv(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 2, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; void* arg1;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
GLsizei count;
|
|
ok &= JSB_jsval_typedarray_to_dataptr( cx, args.get(1), &count, &arg1, js::Scalar::Float32);
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glVertexAttrib3fv((GLuint)arg0 , (GLfloat*)arg1 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLuint, GLfloat, GLfloat, GLfloat, GLfloat
|
|
// Ret value: void
|
|
bool JSB_glVertexAttrib4f(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 5, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; int32_t arg1; int32_t arg2; int32_t arg3; int32_t arg4;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_int32( cx, args.get(1), &arg1 );
|
|
ok &= jsval_to_int32( cx, args.get(2), &arg2 );
|
|
ok &= jsval_to_int32( cx, args.get(3), &arg3 );
|
|
ok &= jsval_to_int32( cx, args.get(4), &arg4 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glVertexAttrib4f((GLuint)arg0 , (GLfloat)arg1 , (GLfloat)arg2 , (GLfloat)arg3 , (GLfloat)arg4 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLuint, TypedArray/Sequence
|
|
// Ret value: void
|
|
bool JSB_glVertexAttrib4fv(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 2, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; void* arg1;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
GLsizei count;
|
|
ok &= JSB_jsval_typedarray_to_dataptr( cx, args.get(1), &count, &arg1, js::Scalar::Float32);
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glVertexAttrib4fv((GLuint)arg0 , (GLfloat*)arg1 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLuint, GLint, GLenum, GLboolean, GLsizei, GLvoid*
|
|
// Ret value: void
|
|
bool JSB_glVertexAttribPointer(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 6, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
uint32_t arg0; int32_t arg1; uint32_t arg2; uint16_t arg3; int32_t arg4; int32_t arg5;
|
|
|
|
ok &= jsval_to_uint32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_int32( cx, args.get(1), &arg1 );
|
|
ok &= jsval_to_uint32( cx, args.get(2), &arg2 );
|
|
ok &= jsval_to_uint16( cx, args.get(3), &arg3 );
|
|
ok &= jsval_to_int32( cx, args.get(4), &arg4 );
|
|
ok &= jsval_to_int32( cx, args.get(5), &arg5 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glVertexAttribPointer((GLuint)arg0 , (GLint)arg1 , (GLenum)arg2 , (GLboolean)arg3 , (GLsizei)arg4 , (GLvoid*)arg5 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
// Arguments: GLint, GLint, GLsizei, GLsizei
|
|
// Ret value: void
|
|
bool JSB_glViewport(JSContext *cx, uint32_t argc, jsval *vp) {
|
|
JSB_PRECONDITION2( argc == 4, cx, false, "Invalid number of arguments" );
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
bool ok = true;
|
|
int32_t arg0; int32_t arg1; int32_t arg2; int32_t arg3;
|
|
|
|
ok &= jsval_to_int32( cx, args.get(0), &arg0 );
|
|
ok &= jsval_to_int32( cx, args.get(1), &arg1 );
|
|
ok &= jsval_to_int32( cx, args.get(2), &arg2 );
|
|
ok &= jsval_to_int32( cx, args.get(3), &arg3 );
|
|
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
|
|
|
|
glViewport((GLint)arg0 , (GLint)arg1 , (GLsizei)arg2 , (GLsizei)arg3 );
|
|
args.rval().setUndefined();
|
|
return true;
|
|
}
|
|
|
|
|
|
#endif // JSB_INCLUDE_OPENGL
|