Author: DavidCzech
Date: 2008-07-09 21:37:18 -0400 (Wed, 09 Jul 2008)
New Revision: 1306
Modified:
trunk/pysoy/examples/LandScape.py
trunk/pysoy/include/soy.scenes.pxd
trunk/pysoy/src/scenes/Landscape.pym
Log:
Ticket #929 : Landscape VBOs almost working.
Modified: trunk/pysoy/examples/LandScape.py
===================================================================
--- trunk/pysoy/examples/LandScape.py 2008-06-19 17:01:51 UTC (rev 1305)
+++ trunk/pysoy/examples/LandScape.py 2008-07-10 01:37:18 UTC (rev 1306)
@@ -3,11 +3,47 @@
import soy
from time import sleep
-heightTex = soy.transports.File('media/heightmap.soy')['gimp']
-heightMap = soy.scenes.landscape(heightTex)
+### Start Heightmap Code
+heightTex = soy.transports.File('media/white.soy')['gimp']
+sleep(2) # HACK: this will wait while transportloop does his stuff
+heightScene = soy.scenes.Landscape(heightTex,soy.materials.Material())
+#sce = soy.scenes.Scene()
+#heightScene = soy.scenes.Scene();# with normal scene, everything is peachy
+### Start PySoy Code (Excerpt from pysoy-primer.py)
+# Initialize a window
+scr = soy.Screen()
+win = soy.Window(scr, "A Spinning Cube")
+
+# Create a cube with a shape, material and a body.
+cube = soy.shapes.Box(1, 1, 1) # Step 1: Shape
+mat = soy.materials.Material() # Step 2: Material
+mat.shininess = 5 # (Optional) Looks nicer (modifies the applied specular
lighting; play with this setting to see how it affects appearance)
+body = soy.bodies.Body(scene=heightScene, model=soy.models.Shape(mat),
shape=cube, position=(0,-2,0)) # Step 3: Body
+
+# Put a light and camera into the initialized screen
+light = soy.bodies.Light(heightScene)
+camera = soy.bodies.Camera(heightScene)
+#stx = soy.widgets.StackX(win)
+#pro = soy.widgets.Projector(stx, camera=camera)
+#cam2 = soy.bodies.Camera(sce)
+#cam2.position = (-0.3, 0.0, 15.0)
+#pro2 = soy.widgets.Projector(stx, camera=cam2)
+
+pro = soy.widgets.Projector(win, camera=camera)
+
+#lig = soy.bodies.Light(sce)
+#lig.position = (-10.0,10.0,2.0)
+
+camera.position = (0, -2, 5.0) #50?
+light.position = (0.5, 1.0, 5.0)
+#heightScene.gravity = (0,-1,0)
+#mat=soy.materials.Material()
+#a=soy.bodies.Body(scene=sce,model=soy.models.Shape(mat),shape=soy.shapes.Box(2,1,2),position=(0,-1.2,-1))
+
if __name__ == "__main__":
- #mainloop goes here
- while 1:
- sleep(0.1)
\ No newline at end of file
+ #mainloop goes here
+ while 1:
+ sleep(1)
+ #print body.position #annoying
Modified: trunk/pysoy/include/soy.scenes.pxd
===================================================================
--- trunk/pysoy/include/soy.scenes.pxd 2008-06-19 17:01:51 UTC (rev 1305)
+++ trunk/pysoy/include/soy.scenes.pxd 2008-07-10 01:37:18 UTC (rev 1306)
@@ -80,9 +80,15 @@
cdef ode.dHeightfieldDataID _heightmapID
cdef ode.dGeomID _heightmap
cdef int _width
+ cdef int _depth
cdef int _height
cdef gl.GLuint _buffer
+ cdef gl.GLuint _elementbuffer
cdef void _createBuffer ( self )
+ cdef int _verts
+ cdef Vert* _vertArray
+ cdef Face* _elementArray
+ cdef gl.GLfloat* vertices[72]
cdef class Planar (Scene) :
cdef ode.dGeomID _planeID
Modified: trunk/pysoy/src/scenes/Landscape.pym
===================================================================
--- trunk/pysoy/src/scenes/Landscape.pym 2008-06-19 17:01:51 UTC (rev
1305)
+++ trunk/pysoy/src/scenes/Landscape.pym 2008-07-10 01:37:18 UTC (rev
1306)
@@ -22,7 +22,7 @@
''' Landscape Scene
This is a scene based on a heightmap.
- Accepts a heightmap and the width, depth, and heigth of it.
+ Accepts a heightmap with the detail of it, the width, depth, and height of
it.
'''
############################################################################
@@ -30,12 +30,22 @@
# Python functions
#
- def __cinit__(self, heightmap, scale, width=1024, depth=1024, *args, **kw) :
- if not isinstance(soy.textures.Texture, heightmap) or heightmap._chans !=
1 :
- raise TypeError('heightmap must be of type soy.textures.Texture and 1
channel.')
- self._width = width
- self._depth = depth
+ def __cinit__(self, soy.textures.Texture heightmap,soy.materials.Material
mat, detail = 1, width=1024, depth=1024, height=1024, *args, **kw) :
+ cdef int _i, _j
+ cdef double _value
+ if not isinstance(heightmap, soy.textures.Texture) or heightmap._chans !=
1 :
+ raise TypeError('Heightmap must be of type soy.textures.Texture and 1
channel, not '+str(heightmap._chans))
+ #We need to make an array on the heap, and put the verts there
+ stdio.printf("Cinit Start!\n");
+ # Now we need to define the vars somehow (like px py pz, tx ty ...)
+ self._verts = 0
+ self._width = width
+ self._depth = depth
+ self._height = height
self._heightmapID = ode.dGeomHeightfieldDataCreate()
+ self._vertArray = <Vert *>
py.PyMem_Malloc((heightmap._width*heightmap._height/detail)*16*4)
+ self._elementArray = <Face *>
py.PyMem_Malloc(sizeof(Face)*((heightmap._width*heightmap._height/detail))/3)
#21k*Face
+ #for _i from 0 < _i < 72:
ode.dGeomHeightfieldDataBuildByte(self._heightmapID,
<unsigned char*> heightmap._texels, 0,
heightmap._width, heightmap._depth,
@@ -43,8 +53,36 @@
self._depth/heightmap._depth,
1, 0, 1, 0)
self._heightmap = ode.dCreateHeightfield(self._spaceID, self._heightmapID,
1)
-
-
+ ##Setup Arrays Here
+ for _i from 1 <= _i < heightmap._width :
+ for _j from 1 <= _j < heightmap._height :
+ self._verts +=1
+ # Get the y value here
+ _value = heightmap._texels[heightmap._width*(_i-1)+_j]
+ #stdio.printf("%d\n",value)
+ #yea, so now value*scale got
+ _value = _value/255.0 #255 is max, so if the value == 255(white) then
its a 1 for high, thats mul'ed by height
+ self._vertArray[heightmap._width*(_i-1)+_j].px = _i
+ self._vertArray[heightmap._width*(_i-1)+_j].pz = _j
+ self._vertArray[heightmap._width*(_i-1)+_j].py = _value
+ self._vertArray[heightmap._width*(_i-1)+_j].tx = 0
+ self._vertArray[heightmap._width*(_i-1)+_j].ty = 1
+ self._vertArray[heightmap._width*(_i-1)+_j].tz = 0
+ self._vertArray[heightmap._width*(_i-1)+_j].nx = 0
+ self._vertArray[heightmap._width*(_i-1)+_j].ny = 1
+ self._vertArray[heightmap._width*(_i-1)+_j].nz = 0
+ #stdio.printf("%f\n", _value);
+ #Make a Step for the above loops, or make a loop for making the faces
+ #I think we need to make the element array generation code here
+ _i = 0
+ for _i from 1 <= _i < ((heightmap._width*heightmap._height/detail))/3:
+
+ self._elementArray[_i].a = (_i*3)-2
+ self._elementArray[_i].b = (_i*3)-1
+ self._elementArray[_i].c = (_i*3)
+ #stdio.printf("index :%d, A: %d, B: %d, C:
%d\n",_i,self._elementArray[_i].a,self._elementArray[_i].b,self._elementArray[_i].c);
+ stdio.printf("Cinit Done!\n");
+
def __dealloc__(self) :
ode.dGeomHeightfieldDataDestroy(self._heightmapID)
#gl.glDeleteBuffersARB(1, &self._buffer);
@@ -56,13 +94,55 @@
#
cdef void _createBuffer(self) :
- pass
- #gl.glGenBuffersARB(1, &self._buffer)
- #gl.glBindBufferARB(gl.GL_ARRAY_BUFFER_ARB, self._buffer)
- #gl.glBufferDataARB(gl.GL_ARRAY_BUFFER_ARB,
(sizeof(Vert)+4+12)*self._bufferAlloc,
- # self._heightmap, gl.GL_STATIC_DRAW_ARB)
+ stdio.printf("createBuffer Start!\n");
-
cdef void _render(self) :
- pass
+ stdio.printf("%s","_render\n")
+ gl.glGenBuffersARB(1, <gl.GLuint*> &self._buffer) # Create the vertex
buffers?
+ gl.glBindBufferARB(gl.GL_ARRAY_BUFFER_ARB, <gl.GLuint> self._buffer)
+ gl.glBufferDataARB(gl.GL_ARRAY_BUFFER_ARB, (sizeof(Vert)*self._verts),
+ self._vertArray, gl.GL_STATIC_DRAW_ARB)
+ gl.glGenBuffersARB(1, &self._elementbuffer)
+ gl.glBindBufferARB(gl.GL_ELEMENT_ARRAY_BUFFER_ARB, self._elementbuffer) #
Create the elements buffers
+ gl.glBufferDataARB(gl.GL_ELEMENT_ARRAY_BUFFER_ARB, self._verts/3,
+ self._elementArray, gl.GL_STATIC_DRAW_ARB)
+ #gl.glGenBuffersARB(1, &self._buffer);
+ #gl.glBindBufferARB(gl.GL_ARRAY_BUFFER_ARB, self._buffer);
+ #gl.glBufferDataARB(gl.GL_ARRAY_BUFFER_ARB, sizeof(vertices),
<gl.GLvoid*>0, gl.GL_STATIC_DRAW_ARB);
+ #gl.glBufferSubDataARB(gl.GL_ARRAY_BUFFER_ARB, 0, sizeof(vertices),
vertices);
+ #gl.glBindBufferARB(gl.GL_ARRAY_BUFFER_ARB, _buffer)
+ gl.glVertexPointer (3, gl.GL_FLOAT, sizeof(Vert), <float*> 0)
+ gl.glNormalPointer ( gl.GL_FLOAT, sizeof(Vert), <float*> 12)
+ #gl.glNormalPointer(gl.GL_FLOAT, 0, <gl.GLvoid *>0);
+ gl.glTexCoordPointer(3, gl.GL_FLOAT, sizeof(Vert), <float*> 24)
+ #gl.glDrawArrays(gl.GL_QUADS, 0, 24);
+ stdio.printf("%s","glDrawElements\n")
+ gl.glDrawElements (gl.GL_TRIANGLES, 20,
+ gl.GL_UNSIGNED_SHORT, <Face*> 0)#self._elementArray)
+ gl.glBindBufferARB(gl.GL_ARRAY_BUFFER_ARB, 0);
+ Scene._render(self)
+ stdio.printf("Render Done!\n");
+"""
+TODO :
+- First Get it to render
+- Divide data in to sectors
+- get Sectors middle point
+- Relative to the sector distance to camera, calculate LOD value
+- Apply LOD algo using value
+yea
+ the size of the number of triangles times three
+its one big block to you since a landscape will have *one* material
+ Z texcoord can be used to change the terrain type
+this means that you can use the face array for LOD more easily
+ see basically you can "shift up" the array, adding one to both the offset and
length, such that the "base" face array is the lowest resolution and each time
you shift up one it removes one triangle and replaces it with two
+ is, if your array has four triangles in the low resolution, ABCD
+ and the second step is A split = EF, B=GH, C=IJ, D=KL, then it's arranged as:
+ ABCDEFGHIJKL
+if you're rendering the whole thing as step 1, then its offset 0 length 4
(ABCD)
+ if you want 50% of step2 then its offset 2, length 6, = CDEFGH
+ and then it's a matter of grouping these into geographic boundaries such that
depending on where your camera is within the terrain it can render them in
groups like this
+ if you try to do this on a one polygon basis you'll end up rendering too
many. its easier to group them
+ in each group give the most radical angles the highest priority - so a steep
angled triangle would be D in the above example
+ er, sorry, the steepest would be A
+"""
\ No newline at end of file
_______________________________________________
PySoy-SVN mailing list
PySoy-SVN@pysoy.org
http://www.pysoy.org/mailman/listinfo/pysoy-svn
