glesmodule.cpp

python s60 1.4.5版本的源代码

  RETURN_PYNONE;
}

extern "C" PyObject *gles_glFogf(PyObject *self, PyObject *args) {
  GLenum pname;
  GLfloat param;
  
  if ( !PyArg_ParseTuple(args, "if:glFogf", &pname, &param) ) {
    return NULL;
  }
  glFogf(pname, param);
  
  RETURN_IF_GLERROR;
  RETURN_PYNONE;
}

extern "C" PyObject *gles_glFogfv(PyObject *self, PyObject *args) {
  GLenum pname;
  GLfloat *params;
  
  PyObject *paramsPy;
  if ( !PyArg_ParseTuple(args, "iO:glFogfv", &pname, &paramsPy) ) {
    return NULL;
  }
  params = gles_PySequence_AsGLfloatArray(paramsPy);
  if(params == NULL) {
    assert(PyErr_Occurred() != NULL);
    return NULL;
  }
  glFogfv(pname, params);
  gles_free(params);
  
  RETURN_IF_GLERROR;
  RETURN_PYNONE;
}

extern "C" PyObject *gles_glFogx(PyObject *self, PyObject *args) {
  GLenum pname;
  GLfixed param;
  
  if ( !PyArg_ParseTuple(args, "ii:glFogx", &pname, &param) ) {
    return NULL;
  }
  glFogx(pname, param);
  
  RETURN_IF_GLERROR;
  RETURN_PYNONE;
}

extern "C" PyObject *gles_glFogxv(PyObject *self, PyObject *args) {
  GLenum pname;
  GLfixed *params;
  
  PyObject *paramsPy;
  if ( !PyArg_ParseTuple(args, "iO:glFogxv", &pname, &paramsPy) ) {
    return NULL;
  }
  params = gles_PySequence_AsGLfixedArray(paramsPy);
  if(params == NULL) {
    assert(PyErr_Occurred() != NULL);
    return NULL;
  }
  glFogxv(pname, params);
  gles_free(params);
  
  RETURN_IF_GLERROR;
  RETURN_PYNONE;
}

extern "C" PyObject *gles_glFrontFace(PyObject *self, PyObject *args) {
  GLenum mode;
  
  if ( !PyArg_ParseTuple(args, "i:glFrontFace", &mode) ) {
    return NULL;
  }
  glFrontFace(mode);
  
  RETURN_IF_GLERROR;
  RETURN_PYNONE;
}

extern "C" PyObject *gles_glFrustumf(PyObject *self, PyObject *args) {
  GLfloat left;
  GLfloat right;
  GLfloat bottom;
  GLfloat top;
  GLfloat zNear;
  GLfloat zFar;
  
  if ( !PyArg_ParseTuple(args, "ffffff:glFrustumf", &left, &right, &bottom, &top, &zNear, &zFar) ) {
    return NULL;
  }
  glFrustumf(left, right, bottom, top, zNear, zFar);
  
  RETURN_IF_GLERROR;
  RETURN_PYNONE;
}

extern "C" PyObject *gles_glFrustumx(PyObject *self, PyObject *args) {
  GLfixed left;
  GLfixed right;
  GLfixed bottom;
  GLfixed top;
  GLfixed zNear;
  GLfixed zFar;
  
  if ( !PyArg_ParseTuple(args, "iiiiii:glFrustumx", &left, &right, &bottom, &top, &zNear, &zFar) ) {
    return NULL;
  }
  glFrustumx(left, right, bottom, top, zNear, zFar);
  
  RETURN_IF_GLERROR;
  RETURN_PYNONE;
}

extern "C" PyObject *gles_glGenTextures(PyObject *self, PyObject *args) {
  GLuint *textures = NULL;
  GLuint n;
  unsigned int i;
  PyObject *ret;
  
  if( !PyArg_ParseTuple(args, "i:glGenTextures", &n) ) {
    return NULL;
  }
  
  if(n < 1) {
    PyErr_SetString(PyExc_ValueError, "Value must be positive");
    return NULL;
  }
  
  textures = (GLuint*)gles_alloc( sizeof(GLuint)*n );
  
  glGenTextures( n, textures);
  if(n > 1) {
    ret = PyTuple_New(n);
  
    for(i=0;i<n;i++) {
      PyTuple_SetItem(ret, i, Py_BuildValue("i", textures[i]));
    }
  } else {
    ret = Py_BuildValue("i", textures[0]);
  }
  gles_free(textures);
  
  RETURN_IF_GLERROR;
  Py_INCREF(ret);
  return ret;
}

extern "C" PyObject *gles_glGetIntegerv(PyObject *self, PyObject *args) {
  GLenum pname;
  GLint *params = NULL;
  int values = 1;
  int i;
  
  PyObject *paramsPy;
  if ( !PyArg_ParseTuple(args, "i:glGetIntegerv", &pname) ) {
    return NULL;
  }
  
  switch(pname) {
    // 2 elements
    case GL_ALIASED_POINT_SIZE_RANGE:
    case GL_ALIASED_LINE_WIDTH_RANGE:
    case GL_MAX_VIEWPORT_DIMS:
    case GL_SMOOTH_LINE_WIDTH_RANGE:
    case GL_SMOOTH_POINT_SIZE_RANGE:
      values = 2;
      break;
    // Special cases
    case GL_COMPRESSED_TEXTURE_FORMATS:
      glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &values);
      break;
    // 1 element
    case GL_ALPHA_BITS:
    case GL_BLUE_BITS:
    case GL_DEPTH_BITS:
    case GL_GREEN_BITS:
    case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES:
    case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES:
    case GL_MAX_ELEMENTS_INDICES:
    case GL_MAX_ELEMENTS_VERTICES:
    case GL_MAX_LIGHTS:
    case GL_MAX_MODELVIEW_STACK_DEPTH:
    case GL_MAX_PROJECTION_STACK_DEPTH:
    case GL_MAX_TEXTURE_SIZE:
    case GL_MAX_TEXTURE_STACK_DEPTH:
    case GL_MAX_TEXTURE_UNITS:
    case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
    case GL_RED_BITS:
    case GL_STENCIL_BITS:
    case GL_SUBPIXEL_BITS:
    default:
      values = 1;
      break;
  }
  
  params = (int*)gles_alloc(values*sizeof(int));
  if(params == NULL) {
    return PyErr_NoMemory();
  }
  glGetIntegerv(pname, params);
  
  paramsPy = PyTuple_New(values);
  if(paramsPy == NULL) {
    assert(PyErr_Occurred() != NULL);
    gles_free(params);
    return NULL;
  }
  
  for(i = 0; i < values; i++) {
    PyTuple_SetItem(paramsPy, i, Py_BuildValue("i", params[i]));
  }
  
  gles_free(params);
  RETURN_IF_GLERROR;
  return paramsPy;
}

extern "C" PyObject *gles_glGetString(PyObject *self, PyObject *args) {
  GLenum name;
  GLubyte *s;
  PyObject *ret;
  
  if ( !PyArg_ParseTuple(args, "i:glGetString", &name) ) {
    return NULL;
  }
  
  s = (GLubyte*)glGetString(name);
  if(s == NULL) {
    RETURN_IF_GLERROR;
    RETURN_PYNONE;
  }
  
  RETURN_IF_GLERROR;
  ret = PyString_FromString((const char*)s);
  Py_INCREF(ret);
  return ret;
}

extern "C" PyObject *gles_glHint(PyObject *self, PyObject *args) {
  GLenum target;
  GLenum mode;
  
  if ( !PyArg_ParseTuple(args, "ii:glHint", &target, &mode) ) {
    return NULL;
  }
  glHint(target, mode);
  
  RETURN_IF_GLERROR;
  RETURN_PYNONE;
}

extern "C" PyObject *gles_glLightModelf(PyObject *self, PyObject *args) {
  GLenum pname;
  GLfloat param;
  
  if( !PyArg_ParseTuple(args, "if:glLightModelf", &pname, &param) ) {
    return NULL;
  }
  
  glLightModelf(pname, param);
  
  RETURN_IF_GLERROR;
  RETURN_PYNONE;
}

extern "C" PyObject *gles_glLightModelfv(PyObject *self, PyObject *args) {
  GLenum pname;
  GLfloat *params;
  
  PyObject *paramsPy;
  if ( !PyArg_ParseTuple(args, "iO:glLightModelfv", &pname, &paramsPy) ) {
    return NULL;
  }
  
  params = (GLfloat*)gles_PySequence_AsGLfloatArray(paramsPy);
  if(params == NULL) {
    assert(PyErr_Occurred() != NULL);
    return NULL;
  }
  glLightModelfv(pname, params);
  gles_free(params);
  
  RETURN_IF_GLERROR;
  RETURN_PYNONE;
}

extern "C" PyObject *gles_glLightModelx(PyObject *self, PyObject *args) {
  GLenum pname;
  GLfixed param;
  
  if( !PyArg_ParseTuple(args, "ii:glLightModelx", &pname, &param) ) {
    return NULL;
  }
  
  glLightModelx(pname, param);
  
  RETURN_IF_GLERROR;
  RETURN_PYNONE;
}

extern "C" PyObject *gles_glLightModelxv(PyObject *self, PyObject *args) {
  GLenum pname;
  GLfixed *params;
  
  PyObject *paramsPy;
  if ( !PyArg_ParseTuple(args, "iO:glLightModelxv", &pname, &paramsPy) ) {
    return NULL;
  }
  
  params = (GLfixed*)gles_PySequence_AsGLfixedArray(paramsPy);
  if(params == NULL) {
    assert(PyErr_Occurred() != NULL);
    return NULL;
  }
  glLightModelxv(pname, params);
  gles_free(params);
  
  RETURN_IF_GLERROR;
  RETURN_PYNONE;
}

extern "C" PyObject *gles_glLightf(PyObject *self, PyObject *args) {
  GLenum light;
  GLenum pname;
  GLfloat param;
  
  if ( !PyArg_ParseTuple(args, "iif:glLightf", &light, &pname, &param) ) {
    return NULL;
  }
  
  glLightf(light, pname, param);
  
  RETURN_IF_GLERROR;
  RETURN_PYNONE;
}

extern "C" PyObject *gles_glLightfv(PyObject *self, PyObject *args) {
  GLenum light;
  GLenum pname;
  GLfloat *params;
  
  PyObject *paramsPy;
  if ( !PyArg_ParseTuple(args, "iiO:glLightfv", &light, &pname, &paramsPy) ) {
    return NULL;
  }
  
  params = (GLfloat*)gles_PySequence_AsGLfloatArray(paramsPy);
  if(params == NULL) {
    assert(PyErr_Occurred() != NULL);
    return NULL;
  }
  glLightfv(light, pname, params);
  gles_free(params);
  
  RETURN_IF_GLERROR;
  RETURN_PYNONE;
}

extern "C" PyObject *gles_glLightx(PyObject *self, PyObject *args) {
  GLenum light;
  GLenum pname;
  GLfixed param;
  
  if ( !PyArg_ParseTuple(args, "iii:glLightx", &light, &pname, &param) ) {
    return NULL;
  }
  
  glLightx(light, pname, param);
  
  RETURN_IF_GLERROR;
  RETURN_PYNONE;
}

extern "C" PyObject *gles_glLightxv (PyObject *self, PyObject *args) {
  GLenum light;
  GLenum pname;
  GLfixed *params;
  
  PyObject *paramsPy;
  if ( !PyArg_ParseTuple(args, "iiO:glLightxv", &light, &pname, &paramsPy) ) {
    return NULL;
  }
  
  params = (GLfixed*)gles_PySequence_AsGLfixedArray(paramsPy);
  if(params == NULL) {
    assert(PyErr_Occurred() != NULL);
    return NULL;
  }
  glLightxv(light, pname, params);
  gles_free(params);
  
  RETURN_IF_GLERROR;
  RETURN_PYNONE;
}

extern "C" PyObject *gles_glLineWidth(PyObject *self, PyObject *args) {
  GLfloat width;
  
  if ( !PyArg_ParseTuple(args, "f:glLineWidth", &width) ) {
    return NULL;
  }
  glLineWidth(width);
  
  RETURN_IF_GLERROR;
  RETURN_PYNONE;
}

extern "C" PyObject *gles_glLineWidthx(PyObject *self, PyObject *args) {
  GLfixed width;
  
  if ( !PyArg_ParseTuple(args, "i:glLineWidthx", &width) ) {
    return NULL;
  }
  glLineWidthx(width);
  
  RETURN_IF_GLERROR;
  RETURN_PYNONE;
}

extern "C" PyObject *gles_glLoadIdentity (PyObject *self, PyObject */*args*/) { 
  glLoadIdentity();
  
  RETURN_IF_GLERROR;
  RETURN_PYNONE;
}

extern "C" PyObject *gles_glLoadMatrixf(PyObject *self, PyObject *args) {
  GLfloat *m;
  
  PyObject *mPy;
  if ( !PyArg_ParseTuple(args, "O:glLoadMatrixf", &mPy) ) {
    return NULL;
  }
  mPy = gles_PySequence_Collapse(GL_FLOAT, mPy, NULL);
  if(mPy == NULL) {
    assert(PyErr_Occurred() != NULL);
    return NULL;
  }
  
  if(PySequence_Length(mPy) != 16) {
    PyErr_SetString(PyExc_ValueError, "Expecting a sequence of 16 floats");
    return NULL;
  }
  
  m = gles_PySequence_AsGLfloatArray(mPy);
  if(m == NULL) {
    assert(PyErr_Occurred() != NULL);
    return NULL;
  }
  
  glLoadMatrixf(m);
  gles_free(m);
  
  RETURN_IF_GLERROR;
  RETURN_PYNONE;
}

extern "C" PyObject *gles_glLoadMatrixx(PyObject *self, PyObject *args) {
  GLfixed *m;
  
  PyObject *mPy;
  if ( !PyArg_ParseTuple(args, "O:glLoadMatrixx", &mPy) ) {
    return NULL;
  }
  mPy = gles_PySequence_Collapse(GL_FIXED, mPy, NULL);
  if(mPy == NULL) {
    assert(PyErr_Occurred() != NULL);
    return NULL;
  }
  
  if(PySequence_Length(mPy) != 16) {
    PyErr_SetString(PyExc_ValueError, "Expecting a sequence of 16 ints");
    return NULL;
  }
  
  m = gles_PySequence_AsGLfixedArray(mPy);
  if(m == NULL) {
    assert(PyErr_Occurred() != NULL);
    return NULL;
  }
  
  glLoadMatrixx(m);
  gles_free(m);
  
  RETURN_IF_GLERROR;
  RETURN_PYNONE;
}

extern "C" PyObject *gles_glLogicOp(PyObject *self, PyObject *args) {
  GLenum opcode;
  
  if ( !PyArg_ParseTuple(args, "i:glLogicOp", &opcode) ) {
    return NULL;
  }
  glLogicOp(opcode);
  
  RETURN_IF_GLERROR;
  RETURN_PYNONE;
}

extern "C" PyObject *gles_glMaterialf(PyObject *self, PyObject *args) {
  GLenum face;
  GLenum pname;
  GLfloat param;
  
  if ( !PyArg_ParseTuple(args, "iif:glMaterialf", &face, &pname, &param) ) {
    return NULL;
  }
  
  glMaterialf(face, pname, param);
  
  RETURN_IF_GLERROR;
  RETURN_PYNONE;
}

extern "C" PyObject *gles_glMaterialfv (PyObject *self, PyObject *args) {