glesmodule.cpp

python s60 1.4.5版本的源代码

  
  RETURN_IF_GLERROR;
  RETURN_PYNONE;
}

extern "C" PyObject *gles_glSampleCoverage(PyObject *self, PyObject *args) {
  GLclampf value;
  GLboolean invert;
  
  if ( !PyArg_ParseTuple(args, "fi:glSampleCoverage", &value, &invert) ) {
    return NULL;
  }
  
  if(invert) {
    invert = GL_TRUE;
  } else {
    invert = GL_FALSE;
  }
  
  glSampleCoverage(value, invert);
  
  RETURN_IF_GLERROR;
  RETURN_PYNONE;
}

extern "C" PyObject *gles_glSampleCoveragex(PyObject *self, PyObject *args) {
  GLclampx value;
  GLboolean invert;
  
  if ( !PyArg_ParseTuple(args, "ii:glSampleCoverage", &value, &invert) ) {
    return NULL;
  }
  
  if(invert) {
    invert = GL_TRUE;
  } else {
    invert = GL_FALSE;
  }
  
  glSampleCoveragex(value, invert);
  
  RETURN_IF_GLERROR;
  RETURN_PYNONE;
}

extern "C" PyObject *gles_glScalef (PyObject *self, PyObject *args) {
  GLfloat x;
  GLfloat y;
  GLfloat z;
  
  if ( !PyArg_ParseTuple(args, "fff:glScalef", &x, &y, &z) ) {
    return NULL;
  }
  glScalef(x, y, z);
  
  RETURN_IF_GLERROR;
  RETURN_PYNONE;
}

extern "C" PyObject *gles_glScalex(PyObject *self, PyObject *args) {
  GLfixed x;
  GLfixed y;
  GLfixed z;

  if ( !PyArg_ParseTuple(args, "iii:glScalex", &x, &y, &z) ) {
    return NULL;
  }
  glScalex(x, y, z);
  
  RETURN_IF_GLERROR;
  RETURN_PYNONE;
}

extern "C" PyObject *gles_glScissor(PyObject *self, PyObject *args) {
  GLint x;
  GLint y;
  GLsizei width;
  GLsizei height;
  
  if ( !PyArg_ParseTuple(args, "iiii:glScissor", &x, &y, &width, &height) ) {
    return NULL;
  }
  glScissor(x, y, width, height);
  
  RETURN_IF_GLERROR;
  RETURN_PYNONE;
}

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

extern "C" PyObject *gles_glStencilFunc(PyObject *self, PyObject *args) {
  GLenum func;
  GLint ref;
  GLuint mask;
  
  if ( !PyArg_ParseTuple(args, "iii:glStencilFunc", &func, &ref, &mask) ) {
    return NULL;
  }
  glStencilFunc(func, ref, mask);
  
  RETURN_IF_GLERROR;
  RETURN_PYNONE;
}

extern "C" PyObject *gles_glStencilMask(PyObject *self, PyObject *args) {
  GLuint mask;
  
  if ( !PyArg_ParseTuple(args, "i:glStencilMask", &mask) ) {
    return NULL;
  }
  glStencilMask(mask);
  
  RETURN_IF_GLERROR;
  RETURN_PYNONE;
}

extern "C" PyObject *gles_glStencilOp(PyObject *self, PyObject *args) {
  GLenum fail;
  GLenum zfail;
  GLenum zpass;
  
  if ( !PyArg_ParseTuple(args, "iii:glStencilOp", &fail, &zfail, &zpass) ) {
    return NULL;
  }
  glStencilOp(fail, zfail, zpass);
  
  RETURN_IF_GLERROR;
  RETURN_PYNONE;
}

PyObject *gles_wrap_glTexCoordPointer(GLint size, GLenum type, GLsizei stride, PyObject *pointerPy) {
  void *tcptr = NULL;
  array_object *arrobj=NULL;
  
  // We can use either the array type or a sequence
  // Check the array type first
  if(PyObject_TypeCheck(pointerPy, GLES_ARRAY_TYPE) ) {
    arrobj = (array_object*)pointerPy;
    tcptr = arrobj->arrdata;
  } 
#ifdef GL_OES_VERSION_1_1
  else if(pointerPy == Py_None) {
    tcptr = NULL;
  }
#endif
  // Try to convert it as a sequence
  else {
    pointerPy = gles_PySequence_Collapse(type, pointerPy, NULL);
    if(pointerPy == NULL) {
      assert(PyErr_Occurred() != NULL);
      return NULL;
    }
    // glTexCoordPointer accepts only GL_BYTE, GL_SHORT, GL_FIXED or GL_FLOAT types
    switch(type) {
      case GL_BYTE:
        tcptr = gles_PySequence_AsGLbyteArray(pointerPy);
        break;
      case GL_SHORT:
        tcptr = gles_PySequence_AsGLshortArray(pointerPy);
        break;
      case GL_FIXED:
        tcptr = gles_PySequence_AsGLfixedArray(pointerPy);
        break;
      case GL_FLOAT:
        tcptr = gles_PySequence_AsGLfloatArray(pointerPy);
        break;
      default:
        PyErr_SetString(PyExc_ValueError, "Invalid array type");
        return NULL;
    }
    if(tcptr == NULL) {
      assert(PyErr_Occurred() != NULL);
      return NULL;
    }
  }
  
#ifndef GL_OES_VERSION_1_1
  if(tcptr == NULL) {
    // Something went horribly wrong
    // However, we should have an exception already
    assert(PyErr_Occurred() != NULL);
    return NULL;
  }
#endif
  gles_assign_array(GL_TEXTURE_COORD_ARRAY, tcptr, arrobj);
  glTexCoordPointer(size, type, stride, tcptr);
  
  RETURN_IF_GLERROR;
  RETURN_PYNONE;
}

extern "C" PyObject *gles_glTexCoordPointer(PyObject *self, PyObject *args) {
  GLint size;
  GLenum type;
  GLsizei stride = 0;
  
  PyObject *pointerPy;
  if ( !PyArg_ParseTuple(args, "iiiO:glTexCoordPointer", &size, &type, &stride, &pointerPy) ) {
    return NULL;
  }
  
  if(pointerPy == Py_None) {
    gles_free_array(GL_TEXTURE_COORD_ARRAY);
    RETURN_PYNONE;
  }
  
  return gles_wrap_glTexCoordPointer(size, type, stride, pointerPy);
}

extern "C" PyObject *gles_glTexCoordPointerb(PyObject *self, PyObject *args) {
  GLint size;
  PyObject *pointerPy;
  
  if ( !PyArg_ParseTuple(args, "O:glTexCoordPointerb", &pointerPy) ) {
    return NULL;
  }
  
  if(pointerPy == Py_None) {
    gles_free_array(GL_TEXTURE_COORD_ARRAY);
    RETURN_PYNONE;
  }
  
  if(PyObject_TypeCheck(pointerPy, GLES_ARRAY_TYPE) ) {
    size = ((array_object*)pointerPy)->dimension;
  } else {
    size = gles_PySequence_Dimension(pointerPy);
  }
  return gles_wrap_glTexCoordPointer(size, /*type*/GL_BYTE, /*stride*/0, pointerPy);
}

extern "C" PyObject *gles_glTexCoordPointers(PyObject *self, PyObject *args) {
  GLint size;
  PyObject *pointerPy;
  
  if ( !PyArg_ParseTuple(args, "O:glTexCoordPointers", &pointerPy) ) {
    return NULL;
  }
  
  if(pointerPy == Py_None) {
    gles_free_array(GL_TEXTURE_COORD_ARRAY);
    RETURN_PYNONE;
  }
  
  if(PyObject_TypeCheck(pointerPy, GLES_ARRAY_TYPE) ) {
    size = ((array_object*)pointerPy)->dimension;
  } else {
    size = gles_PySequence_Dimension(pointerPy);
  }
  return gles_wrap_glTexCoordPointer(size, /*type*/GL_SHORT, /*stride*/0, pointerPy);
}

extern "C" PyObject *gles_glTexCoordPointerf(PyObject *self, PyObject *args) {
  GLint size;
  PyObject *pointerPy;
  
  if ( !PyArg_ParseTuple(args, "O:glTexCoordPointerf", &pointerPy) ) {
    return NULL;
  }
  
  if(pointerPy == Py_None) {
    gles_free_array(GL_TEXTURE_COORD_ARRAY);
    RETURN_PYNONE;
  }
  
  if(PyObject_TypeCheck(pointerPy, GLES_ARRAY_TYPE) ) {
    size = ((array_object*)pointerPy)->dimension;
  } else {
    size = gles_PySequence_Dimension(pointerPy);
  }
  return gles_wrap_glTexCoordPointer(size, /*type*/GL_FLOAT, /*stride*/0, pointerPy);
}

extern "C" PyObject *gles_glTexCoordPointerx(PyObject *self, PyObject *args) {
  GLint size;
  PyObject *pointerPy;
  
  if ( !PyArg_ParseTuple(args, "O:glTexCoordPointerx", &pointerPy) ) {
    return NULL;
  }
  
  if(pointerPy == Py_None) {
    gles_free_array(GL_TEXTURE_COORD_ARRAY);
    RETURN_PYNONE;
  }
  
  if(PyObject_TypeCheck(pointerPy, GLES_ARRAY_TYPE) ) {
    size = ((array_object*)pointerPy)->dimension;
  } else {
    size = gles_PySequence_Dimension(pointerPy);
  }
  return gles_wrap_glTexCoordPointer(size, /*type*/GL_FIXED, /*stride*/0, pointerPy);
}

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

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

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

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

PyObject *gles_wrap_glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, PyObject *pixelsPy) {
  GLvoid *pixels;
  
  // Indicates if the pixel data should be freed after the call to glTexImage2D.
  int free_pixels = 0;
  
  if( PyObject_TypeCheck(pixelsPy, GLES_ARRAY_TYPE) ) {
    array_object *arr = (array_object*)pixelsPy;
    pixels = arr->arrdata;
  } else if( PyString_Check(pixelsPy) ) {
    // "Convert" the string object into an array.
    // The returned pointer points to the raw C string
    // data held by the object, so no actual conversion needed.
    pixels = PyString_AsString(pixelsPy);
    if(pixels == NULL) {
      assert(PyErr_Occurred() != NULL);
      return NULL;
    }
  } // The last resort is to check if the given object is an Image object
  else {
    CFbsBitmap *bitmap=Bitmap_AsFbsBitmap(pixelsPy);
#ifdef DEBUG_GLES
    DEBUGMSG1("Image: %x", bitmap);
#endif
    if(bitmap == NULL) {
      PyErr_SetString(PyExc_TypeError, "Unsupported object type");
      return NULL;
    }
    free_pixels = 1;
    pixels = gles_convert_fbsbitmap(bitmap, format, type, NULL);
    if(pixels == NULL) {
      assert(PyErr_Occurred() != NULL);
      return NULL;
    }
  }
  
  glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels );
  if(free_pixels == 1) {
    gles_free(pixels);
  }
  RETURN_IF_GLERROR;
  RETURN_PYNONE;
}

extern "C" PyObject *gles_glTexImage2D(PyObject *self, PyObject *args) {
  GLenum target;
  GLint level;
  GLint internalformat;
  GLsizei width;
  GLsizei height;
  GLint border;
  GLenum format;
  GLenum type;
  
  PyObject *pixelsPy = NULL;
  
  if( !PyArg_ParseTuple(args, "iiiiiiiiO:glTexImage2D", &target, &level, &internalformat, &width, &height, &border, &format, &type, &pixelsPy) ) {
    return NULL;
  }
  
  return gles_wrap_glTexImage2D(target, level, internalformat, width, height, border, format, type, pixelsPy);
}

extern "C" PyObject *gles_glTexImage2DIO(PyObject *self, PyObject *args) {
  GLenum target;
  GLint level;
  GLsizei width;
  GLsizei height;
  GLint border;
  GLenum format;
  GLenum type;
  PyObject *image_object;
  TSize imgsize;
  
  if( !PyArg_ParseTuple(args, "iiiiiO:glTexImage2DIO", &target, &level, &format, &border, &type, &image_object) ) {
    return NULL;
  }
  
  CFbsBitmap *bitmap=Bitmap_AsFbsBitmap(image_object);
  if(bitmap == NULL) {
    PyErr_SetString(PyExc_TypeError, "Expecting a graphics.Image object");
    return NULL;
  }
  
  imgsize = bitmap->SizeInPixels();
  width = imgsize.iWidth;
  height = imgsize.iHeight;
  
  return gles_wrap_glTexImage2D(target, level, /*internalformat*/format, width, height, border, format, type, image_object);
}

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

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

PyObject *gles_wrap_glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, PyObject *pixelsPy) {
  GLvoid *pixels;
  
  // Indicates if the pixel data should be freed after the call to glTexSubImage2D.
  int free_pixels = 0;
  
  if( PyObject_TypeCheck(pixelsPy, GLES_ARRAY_TYPE) ) {
    array_object *arr = (array_object*)pixelsPy;
    pixels = arr->arrdata;
  } else if( PyString_Check(pixelsPy) ) {
    // "Convert" the string object into an array.
    // The returned pointer points to the raw C string
    // data held by the object, so no actual conversion needed.
    pixels = PyString_AsString(pixelsPy);
    if(pixels == NULL) {
      assert(PyErr_Occurred() != NULL);
      return NULL;
    }
  } // The last resort is to check if the given object is an Image object
  else {
    CFbsBitmap *bitmap=Bitmap_AsFbsBitmap(pixelsPy);
#ifdef DEBUG_GLES
    DEBUGMSG1("Image: %x", bitmap);
#endif
    if(bitmap == NULL) {
      PyErr_SetString(PyEx