Changeset bfad34229eccba8d964a27a0fb3a2084c612a7b9

Timestamp:

09/24/08 06:28:06 (3 years ago)

Author:

flupke <flupke@…>

Children:

1b0cdd33d70957213349cfa0cae373c7350c73a5

Parents:

206d95c9b3331ad20b32a8ff1c5e9666a2029a28

git-committer:

flupke <flupke@…> (09/24/08 06:28:06)

Message:

palette:

• corrigé l'init de GLUT pour que la fenêtre soit créée avec la taille spécifiée dans le plugin
• les classes pour utilisers les FBO fonctionnent
• fait un test d'encodage d'animation en moiré

git-svn-id:  http://kawa.selfip.org/svn/projects@503 532e76a9-45ae-c241-9c6d-8309ac6440cd

Location:

palette/trunk/palette

Files:

• canvas/backends/glut_backend.py (modified) (2 diffs)
• gl/offscreen.py (modified) (1 diff)
• gl/texture.py (modified) (1 diff)
• plugins/moire/__init__.py (moved) (moved from palette/trunk/palette/plugins/moire.py) (7 diffs)
• plugins/moire/encode.py (added)

palette/trunk/palette/canvas/backends/glut_backend.py

@@ -19 +19 @@
         glutInit()
         glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH)
+        glutInitWindowSize(*self.size)        
         self.window_id = glutCreateWindow("Palette")
         glutDisplayFunc(self.update)
@@ -31 +32 @@
     def resize(self, size):
         super(Canvas, self).resize(size)
-        glutInitWindowSize(*self.size)
         glViewport(0, 0, *size)
         

palette/trunk/palette/gl/offscreen.py

@@ -1 +1 @@
 """Wrapper objects to work with offscreen rendering"""
 
-from OpenGL.EXT.framebuffer_object import *
-
+from OpenGL.GL.EXT.framebuffer_object import *
+from OpenGL.GL import *
+from texture import Texture2D
 
 class FrameBuffer(object):
     def __init__(self, size):
+        self.size = size
         # Initialise extension
         if not glInitFramebufferObjectEXT():
-            raise Exception("Framebuffer object extension is not supporte")
+            raise Exception("Framebuffer object extension is not supported")
         # Create the framebuffer
-        self.framebuffer_id = glGenFramebuffersEXT(1)
-        self.render_buffer_id = glGenRenderbuffersEXT(1)
-        glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, self.render_buffer_id)
-        glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24,
-            size[0], size[1])
+        self.framebuffer_id = glGenFramebuffersEXT(1)
+
+    def bind(self):
+        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, self.framebuffer_id)
+        glPushAttrib(GL_VIEWPORT_BIT)
+        glViewport(0, 0, *self.size)
+
+    def unbind(self):
+        glPopAttrib()
+        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0)
+ 
+    def __del__(self):
+        glDeleteFramebuffersEXT(1, [self.framebuffer_id])
+
+
+class RenderBuffer(FrameBuffer, Texture2D):
+    def __init__(self, size):
+        FrameBuffer.__init__(self, size)
+        self.bind()
+        # Create the colour (texture) buffer
+        Texture2D.__init__(self, size)
+        glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
+                GL_TEXTURE_2D, self.texture_id, 0)
+        # Create the depth buffer
+        self.depth_buffer_id = glGenRenderbuffersEXT(1)
+        glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, self.depth_buffer_id)
+        glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT,
+            *size)
+        glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, 
+                GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT,
+                self.depth_buffer_id)
+        # Check framebuffer completeness
+        glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT)
+        status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT)
+        if status != GL_FRAMEBUFFER_COMPLETE_EXT:
+            raise Exception("Error in framebuffer activation %s" % hex(status))
+        # Unbind buffer
+        self.unbind()
+
+    def bind(self):
+        FrameBuffer.bind(self)
+
+    def unbind(self):
+        FrameBuffer.unbind(self)
+        glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0)
+
+    def bind_texture(self):
+        Texture2D.bind(self)
 
     def __del__(self):
-        super(FrameBuffer, self).__del__()
-        glDeleteFramebuffersEXT(1, self.framebuffer_id)
-        glDeleteRenderbuffersEXT(1, self.render_buffer_id)
-        
+        FrameBuffer.__del__(self)
+        Texture2D.__del__(self)
+        glDeleteRenderbuffersEXT(1, [self.depth_buffer_id])

palette/trunk/palette/gl/texture.py

@@ -1 +1 @@
 from OpenGL.GL import *
-from OpenGL import GL
-
-
-texture_types = {}
-for i in range(1, 4):
-    texture_types[i] = getattr(GL, "GL_TEXTURE_%iD" % i)
-    
+import Image
 
 
 class Texture(object):
-    def __init__(self, size, type):
-        self.texture_id = glGenTextures(1)
-        glBindTexture(type, self.texture_id)
-        glTexImage2D(type, 0, GL_RGB, size[0], size[1], 0, GL_RGB,
-            GL_UNSIGNED_BYTE, 0)
-        glTexParameteri(type, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
-        glTexParameteri(type, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
-        
+    teximage_func = None
+    target = None
+
+    def __init__(self, size, min_filter=GL_LINEAR, mag_filter=GL_LINEAR):
+        self.texture_id = glGenTextures(1)
+        glBindTexture(self.target, self.texture_id)
+        glTexParameteri(self.target, GL_TEXTURE_MAG_FILTER, mag_filter)
+        glTexParameteri(self.target, GL_TEXTURE_MIN_FILTER, min_filter)
+        teximage_args = [self.target, 0, GL_RGB] + list(size) + [0, GL_RGB,
+                GL_UNSIGNED_BYTE, None]
+        self.teximage_func(*teximage_args)
+
+    def bind(self):
+        glBindTexture(self.target, self.texture_id)        
+        
     def __del__(self):
-        super(Texture, self).__del__()
-        glDeleteTextures(1, self.texture_id)
+        glDeleteTextures([self.texture_id])
         
         
 class Texture3D(Texture):
-    def __init__(self, size, min_filter=GL_LINEAR, mag_filter=GL_LINEAR):
-        super(Texture3D, self).__init__(size, GL_TEXTURE_3D, min_filter,
-            mag_filter)
+    teximage_func = glTexImage3D
+    target = GL_TEXTURE_3D
+
                     
 class Texture2D(Texture):
-    def __init__(self, size, min_filter=GL_LINEAR, mag_filter=GL_LINEAR):
-        super(Texture2D, self).__init__(size, GL_TEXTURE_2D, min_filter, 
-            mag_filter)
-            
+    teximage_func = glTexImage2D
+    target = GL_TEXTURE_2D
+
+
 class Texture1D(Texture):
-    def __init__(self, size, min_filter=GL_LINEAR, mag_filter=GL_LINEAR):
-        super(Texture1D, self).__init__(size, GL_TEXTURE_1D, min_filter,
-            mag_filter)
+    teximage_func = glTexImage1D
+    target = GL_TEXTURE_1D

palette/trunk/palette/plugins/moire/__init__.py

@@ -2 +2 @@
 from OpenGL.GL import *
 from OpenGL.GLU import *
+from encode import ScreenEncoder
 
 
@@ -20 +21 @@
     "elements_resolution": "integer(from=3, to=1024, default=256)",
     "line_width": "float(from=0.05, to=150.0, increment=0.1, default=3.4)",
-    "mode": "enum(values=lines|circles|spiral, default=lines)",
+    "mode": "enum(values=lines|circles|spiral|dynamic, default=dynamic)",
+    "encoder_steps": "integer(from=2, to=50, default=5)",
 }
 
@@ -29 +31 @@
     "spiral": None,
 }
+encoder = None
 
 
 def setup():
-    global display_lists_base, display_lists
+    global display_lists_base, display_lists, encoder
     display_lists_base = glGenLists(len(display_lists))
     for i, dl_id in enumerate(display_lists):
@@ -39 +42 @@
 
 def tear_down():
-    global display_lists_base, display_lists
     glDeleteLists(display_lists_base, len(display_lists))
 
 
 def parameters_changed(parameters):
-    global display_lists_base, display_lists
+    global encoder
     glNewList(display_lists["circle"], GL_COMPILE)
     glBegin(GL_LINE_LOOP)
@@ -62 +64 @@
     glEnd()    
     glEndList()
+    encoder = ScreenEncoder(parameters["encoder_steps"], (512, 512))
 
 
 def render(p, canvas, parameters, frame, time):
-    global display_lists_base, display_lists
     # Setup a 2D transformation
     glMatrixMode(GL_PROJECTION)
@@ -73 +75 @@
     # Enable antialiasing
     glEnable(GL_LINE_SMOOTH)
-    glEnable(GL_BLEND);
+    glEnable(GL_BLEND)
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
     glHint(GL_LINE_SMOOTH_HINT, GL_NICEST)
+    glShadeModel(GL_SMOOTH)
+    glDisable(GL_TEXTURE_2D)
     # Clear screen
     glClearColor(1, 1, 1, 0)
@@ -99 +103 @@
                 parameters["elements_resolution"])
     elif parameters["mode"] == "spiral":
+        #scale = canvas.size[0] *0.9
         glLoadIdentity()
+        glTranslate(canvas.center[0], canvas.center[0])
+        #glScale(scale, scale, scale)
         spiral()
         glLoadIdentity()
         amp_x = sin(time * 0.7657) * parameters["amplitude"]
         amp_y = cos(time * 0.25687) * parameters["amplitude"]
-        glTranslate(cos(time) * amp_x, sin(time) * amp_y, 0)
+        glTranslate(canvas.center[0] + cos(time) * amp_x, 
+                canvas.center[1] + sin(time) * amp_y, 0)
+        #glScale(scale, scale, scale)
         spiral()
-        
+    elif parameters["mode"] == "dynamic":
+        encoder.begin_frame()
+        glLoadIdentity()
+        frame = frame % encoder.num_frames
+        a = float(frame) / encoder.num_frames * 2.0 * pi
+        x = parameters["amplitude"] * cos(a) + canvas.center[0]
+        y = parameters["amplitude"] * sin(a) + canvas.center[1]
+        glTranslate(x, y, 0)
+        glScale(100, 100, 1)
+        glBegin(GL_TRIANGLE_FAN)
+        glVertex2f(0, 0)
+        for i in range(10):
+            alpha = float(i) / 5.0 * pi
+            x = cos(alpha)
+            y = sin(alpha)
+            glVertex2f(x, y)
+        glVertex2f(1, 0)
+        glEnd()
+        encoder.end_frame()
+        if encoder.complete:
+            encoder.render_base()
+            glLoadIdentity()            
+            glTranslate((time * 30.0) % encoder.num_frames, 0, 0)
+            encoder.render_mask()