add: renderer

Author: fuyingdi

OpenGL_PlayGround.py

@@ -51,17 +51,6 @@ def draw_points(self):
         glFlush()
 
 
-# def point():
-#     glClear(GL_COLOR_BUFFER_BIT)
-#     glColor3f(1.0, 0, 0)
-#     glPointSize(1)
-#
-#     glBegin(GL_POINTS)
-#     glVertex2i(100, 300)
-#     glEnd()
-#     glFlush()
-
-
 points = Points()
 
 

pointset.py

@@ -0,0 +1,96 @@
+"""Geometry type for "point-arrays" w/ colour support"""
+from OpenGL.GL import *
+from vrml.vrml97 import basenodes
+from OpenGLContext.scenegraph import coordinatebounded
+from OpenGLContext.arrays import array
+from OpenGL.extensions import alternate
+from OpenGL.GL.ARB.point_parameters import *
+from OpenGL.GL.EXT.point_parameters import *
+import logging
+log = logging.getLogger( __name__ )
+
+glPointParameterf = alternate( 
+    glPointParameterf, glPointParameterfARB,glPointParameterfEXT 
+)
+glPointParameterfv = alternate( 
+    glPointParameterfv, glPointParameterfvARB, glPointParameterfEXT 
+)
+RESET_ATTENUATION = array( [1,0,0],'f')
+
+class PointSet(
+    coordinatebounded.CoordinateBounded,
+    basenodes.PointSet
+):
+    """VRML97-style Point-Set object
+
+    http://www.web3d.org/x3d/specifications/vrml/ISO-IEC-14772-IS-VRML97WithAmendment1/part1/nodesRef.html#PointSet
+    """
+    def render (
+            self,
+            visible = 1, # can skip normals and textures if not
+            lit = 1, # can skip normals if not
+            textured = 1, # can skip textureCoordinates if not
+            transparent = 0, # need to sort triangle geometry...
+            mode = None, # the renderpass object
+        ):
+        """Render the point-set, requires coord attribute be present
+
+        if color is present (and has the same length as coord), will
+        render using colors mapped 1:1, otherwise will use the current
+        color.color
+        """
+        if not self.coord:
+            # can't render nothing
+            return 1
+        points = self.coord.point
+        if not len(points):
+            # can't render nothing
+            return 1
+        glVertexPointerf(points)
+        glEnableClientState( GL_VERTEX_ARRAY )
+
+        if visible and self.color:
+            colors = self.color.color
+            if len(colors) != len(points):
+                # egads, a content error
+                if __debug__:
+                    log.warn(
+                        """PointSet %s has different number of point (%s) and color (%s) values""",
+                        str(self), 
+                        len(points), 
+                        len(colors),
+                    )
+            else:
+                glColorMaterial( GL_FRONT_AND_BACK, GL_DIFFUSE)
+                glEnable( GL_COLOR_MATERIAL )
+                glColorPointerf ( colors )
+                glEnableClientState( GL_COLOR_ARRAY )
+        glDisable( GL_LIGHTING )
+        if textured:
+            # TODO: check for version/extension first!
+            # point-sprites instead of regular points...
+            glEnable(GL_POINT_SPRITE);
+            glTexEnvi(GL_POINT_SPRITE, GL_COORD_REPLACE, GL_TRUE)
+        glPointSize( self.size )
+        if glPointParameterf:
+            glPointParameterf( GL_POINT_SIZE_MIN, self.minSize )
+            glPointParameterf( GL_POINT_SIZE_MAX, self.maxSize )
+            glPointParameterfv( GL_POINT_DISTANCE_ATTENUATION, self.attenuation )
+        glDrawArrays( GL_POINTS, 0, len(points))
+        glDisableClientState( GL_VERTEX_ARRAY )
+        glDisable( GL_COLOR_MATERIAL )
+        if textured:
+            glDisable( GL_POINT_SPRITE )
+        if glPointParameterf:
+            glPointParameterf( GL_POINT_SIZE_MIN, 0.0 )
+            glPointParameterf( GL_POINT_SIZE_MAX, 1.0 )
+            glPointParameterfv( GL_POINT_DISTANCE_ATTENUATION, RESET_ATTENUATION )
+        glPointSize( 1.0 )
+        glDisableClientState( GL_COLOR_ARRAY )
+        return 1
+    def boundingVolume( self, mode=None ):
+        """Create a bounding-volume object for this node"""
+        from OpenGLContext.scenegraph import boundingvolume
+        return boundingvolume.volumeFromCoordinate(
+            self.coord,
+        )

rednerer.py

@@ -0,0 +1,84 @@
+import sys
+from OpenGL.GL import *
+from OpenGL.GLU import *
+from OpenGL.GLUT import *
+
+class Renderer:
+    points = []
+    POINT_SIZE = 5
+    
+    def init(self):
+        glClearColor(0, 0, 0, 0)
+        gluOrtho2D(0,1000, 0, 1000)
+
+    def test(self):
+        glClear(GL_COLOR_BUFFER_BIT)
+        glColor3f(1, 0, 0)
+        glBegin(GL_TRIANGLES)
+
+        glColor3f(1, 0, 0)
+        glVertex2f(0, 0)
+
+        glColor3f(0, 1, 0)
+        glVertex2f(500, 1000)
+
+        glColor3f(0, 0, 1)
+        glVertex2f(1000, 0)
+
+        glEnd()
+        glFlush()
+
+    def set_points(self, point):
+        assert isinstance(point, Point)
+        self.points.append(point)
+
+        
+    def draw_points(self):
+        glClear(GL_COLOR_BUFFER_BIT)
+        glPointSize(self.POINT_SIZE)
+        glBegin(GL_POINTS)
+        for point in self.points:
+            assert isinstance(point , Point)
+            glColor3f(point.color[0], point.color[1], point.color[2])
+            glVertex2i(point.x * self.POINT_SIZE, point.y * self.POINT_SIZE)
+
+        glEnd()
+        glFlush()
+
+            
+
+    def draw_scene(self):
+        self.draw_points()
+        glutSwapBuffers()
+        
+
+    def main(self):
+        glutInit(sys.argv)
+        glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB)
+        glutInitWindowSize(1000, 1000)
+        glutInitWindowPosition(50, 50)
+        glutCreateWindow("FUCkCPP")
+        self.init()
+        glutDisplayFunc(self.draw_scene)
+        glutIdleFunc(self.draw_scene)
+        glutMainLoop()
+
+    def test_points(self):
+        for i in range(1000):
+            point = Point(i, i ,(1,0,1))
+            self.set_points(point)
+
+
+class Point:
+    def __init__(self, x, y, color):
+        self.x = x
+        self.y = y
+        self.color = color
+    x = 0
+    y = 0
+    color = (1,1,1)
+        
+if __name__ == "__main__":
+    render = Renderer()
+    render.main()
+    render.test_points()