framebuffer_object.py :  » Game-2D-3D » PyOpenGL » PyOpenGL-3.0.1 » OpenGL » GL » EXT » Python Open Source

Home
Python Open Source
1.3.1.2 Python
2.Ajax
3.Aspect Oriented
4.Blog
5.Build
6.Business Application
7.Chart Report
8.Content Management Systems
9.Cryptographic
10.Database
11.Development
12.Editor
13.Email
14.ERP
15.Game 2D 3D
16.GIS
17.GUI
18.IDE
19.Installer
20.IRC
21.Issue Tracker
22.Language Interface
23.Log
24.Math
25.Media Sound Audio
26.Mobile
27.Network
28.Parser
29.PDF
30.Project Management
31.RSS
32.Search
33.Security
34.Template Engines
35.Test
36.UML
37.USB Serial
38.Web Frameworks
39.Web Server
40.Web Services
41.Web Unit
42.Wiki
43.Windows
44.XML
Python Open Source » Game 2D 3D » PyOpenGL 
PyOpenGL » PyOpenGL 3.0.1 » OpenGL » GL » EXT » framebuffer_object.py
'''OpenGL extension EXT.framebuffer_object

This module customises the behaviour of the 
OpenGL.raw.GL.EXT.framebuffer_object to provide a more 
Python-friendly API

Overview (from thespec import 
  
  This extension defines a simple interface for drawing to rendering
  destinations other than the buffers provided to the GL by the
  window-system.
  
  In this extension, these newly defined rendering destinations are
  known collectively as "framebuffer-attachable images".  This
  extension provides a mechanism for attaching framebuffer-attachable
  images to the GL framebuffer as one of the standard GL logical
  buffers: color, depth, and stencil.  (Attaching a
  framebuffer-attachable image to the accum logical buffer is left for
  a future extension to define).  When a framebuffer-attachable image
  is attached to the framebuffer, it is used as the source and
  destination of fragment operations as described in Chapter 4.
  
  By allowing the use of a framebuffer-attachable image as a rendering
  destination, this extension enables a form of "offscreen" rendering.
  Furthermore, "render to texture" is supported by allowing the images
  of a texture to be used as framebuffer-attachable images.  A
  particular image of a texture object is selected for use as a
  framebuffer-attachable image by specifying the mipmap level, cube
  map face (for a cube map texture), and z-offset (for a 3D texture)
  that identifies the image.  The "render to texture" semantics of
  this extension are similar to performing traditional rendering to
  the framebuffer, followed immediately by a call to CopyTexSubImage.
  However, by using this extension instead, an application can achieve
  the same effect, but with the advantage that the GL can usually
  eliminate the data copy that would have been incurred by calling
  CopyTexSubImage.
  
  This extension also defines a new GL object type, called a
  "renderbuffer", which encapsulates a single 2D pixel image.  The
  image of renderbuffer can be used as a framebuffer-attachable image
  for generalized offscreen rendering and it also provides a means to
  support rendering to GL logical buffer types which have no
  corresponding texture format (stencil, accum, etc).  A renderbuffer
  is similar to a texture in that both renderbuffers and textures can
  be independently allocated and shared among multiple contexts.  The
  framework defined by this extension is general enough that support
  for attaching images from GLobjectsotherthantextures import 
  renderbuffers could be added by layered extensions.
  
  To facilitate efficient switching between collections of
  framebuffer-attachable images, this extension introduces another new
  GL object, called a framebuffer object.  A framebuffer object
  contains the state that defines the traditional GL framebuffer,
  including its set of images.  Prior to this extension, it was the
  window-system which defined and managed this collection of images,
  traditionally by grouping them into a "drawable".  The window-system
  API's would also provide a function (i.e., wglMakeCurrent,
  glXMakeCurrent, aglSetDrawable, etc.) to bind a drawable with a GL
  context (as is done in the WGL_ARB_pbuffer extension).  In this
  extension however, this functionality is subsumed by the GL and the
  GL provides the function BindFramebufferEXT to bind a framebuffer
  object to the current context.  Later, the context can bind back to
  the window-system-provided framebuffer in order to display rendered
  content.
  
  Previous extensions that enabled rendering to a texture have been
  much more complicated.  One example is the combination of
  ARB_pbuffer and ARB_render_texture, both of which are window-system
  extensions.  This combination requires calling MakeCurrent, an
  operation that may be expensive, to switch between the window and
  the pbuffer drawables.  An application must create one pbuffer per
  renderable texture in order to portably use ARB_render_texture.  An
  application must maintain at least one GL context per texture
  format, because each context can only operate on a single
  pixelformat or FBConfig.  All of these characteristics make
  ARB_render_texture both inefficient and cumbersome to use.
  
  EXT_framebuffer_object, on the other hand, is both simpler to use
  and more efficient than ARB_render_texture.  The
  EXT_framebuffer_object API is contained wholly within the GL API and
  has no (non-portable) window-system components.  Under
  EXT_framebuffer_object, it is not necessary to create a second GL
  context when rendering to a texture image whose format differs from  import 
  that of the window.  Finally, unlike the pbuffers of
  ARB_render_texture, a single framebuffer object can facilitate
  rendering to an unlimited number of texture objects.

The official definition of this extension is available here:
http://www.opengl.org/registry/specs/EXT/framebuffer_object.txt
'''
from OpenGL import platform,constants,constant,arrays
from OpenGL import extensions,wrapper
from OpenGL.GL import glget
import ctypes
from OpenGL.raw.GL.EXT.framebuffer_object import *
### END AUTOGENERATED SECTION
from OpenGL.lazywrapper import lazy

glGenFramebuffersEXT = wrapper.wrapper(glGenFramebuffersEXT).setOutput(
                'framebuffers', 
                lambda x: (x,), 
                'n')
                
glGenRenderbuffersEXT = wrapper.wrapper(glGenRenderbuffersEXT).setOutput(
                'renderbuffers', 
                lambda x: (x,), 
                'n')

@lazy( glDeleteFramebuffersEXT )
def glDeleteFramebuffersEXT( baseOperation, n, framebuffers=None ):
    """glDeleteFramebuffersEXT( framebuffers ) -> None 
    """
    if framebuffers is None:
        framebuffers = arrays.GLuintArray.asArray( n )
        n = arrays.GLuintArray.arraySize( framebuffers )
    return baseOperation( n, framebuffers )

#glBindRenderbufferEXT # doesn't require wrapping
#glBindFramebufferEXT  # doesn't require wrapping
#glBindRenderbufferEXT # doesn't require wrapping
#glCheckFramebufferStatusEXT
#glDeleteFramebuffersEXT # should be wrapped to eliminate 'length'
#glDeleteRenderbuffersEXT # should be wrapped to eliminate 'length'
#glFramebufferRenderbufferEXT
#glFramebufferTexture1DEXT
#glFramebufferTexture2DEXT
#glFramebufferTexture3DEXT
#glGenFramebuffersEXT  # wrapped
#glGenRenderbuffersEXT # wrapped
#glGenerateMipmapEXT
#glGetFramebufferAttachmentParameterivEXT
#glGetRenderbufferParameterivEXT
#glInitFramebufferObjectEXT
#glIsFramebufferEXT
#glIsRenderbufferEXT
#glRenderbufferStorageEXT # doesn't require wrapping                                          
#glget.addGLGetConstant( GL_MAX_COLOR_ATTACHMENTS_EXT, (1,))
#glget.addGLGetConstant( GL_FRAMEBUFFER_BINDING_EXT, (1,))
#glget.addGLGetConstant( GL_RENDERBUFFER_BINDING_EXT, (1,))
#glget.addGLGetConstant( GL_MAX_RENDERBUFFER_SIZE_EXT, (1,))
www.java2java.com | Contact Us
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.