[ pygame ] polygons ( vr ) - Programmers Heaven

#### Howdy, Stranger!

It looks like you're new here. If you want to get involved, click one of these buttons!

#### Categories

Welcome to the new platform of Programmer's Heaven! We apologize for the inconvenience caused, if you visited us from a broken link of the previous version. The main reason to move to a new platform is to provide more effective and collaborative experience to you all. Please feel free to experience the new platform and use its exciting features. Contact us for any issue that you need to get clarified. We are more than happy to help you.

# [ pygame ] polygons ( vr )

Posts: 2Member
this is a try at a VR world
whitout opengl
but whit OOP

error :
- i get only a black screen

sugestions or improvement are welkom to

basic3d.py
[code]
import pygame
from pygame.locals import *
import sys
from cVector3 import *
import math
from cColor import *

pygame.init()
winx , winy = 640 , 480
screen = pygame.display.set_mode( ( winx , winy ) , 0 , 32 )

class Matrix( object ) :

def __init__( self ) :

self.m = [ [ 1. , 0. , 0. , 0. ] ,
[ 0. , 1. , 0. , 0. ] ,
[ 0. , 0. , 1. , 0. ] ,
[ 0. , 0. , 0. , 1. ] ]

def __mul__( self , r ) :

uit = Matrix()
for i in xrange( 3 ) :
for j in xrange( 3 ) :
uit.m[ i ][ j ] = 0
for k in xrange( 3 ) :
uit.m[ i ][ j ] += self.m[ i ][ k ] * r.m[ k ][ j ]

return uit

lv = []
for i in xrange( 64 ) :
lv.append( Matrix() )

lsk = []
for i in xrange( 64 ) :
lsk.append( Vector3() )

number = 0

return x * math.pi / 180.

XYZ , XZY , YXZ , YZX , ZXY , ZYX = 1 , 2 , 3 , 4 , 5 , 6

def link( no , x , y , z , xz , yz , xy , ax , p ) :

if no < 1 or no > len( lv ) - 1 : return
if p < 0 or p > len( lv ) - 1 : return
if no == p : return

rotx = Matrix()
roty = Matrix()
rotz = Matrix()
trans = Matrix()

m = lv[ p ]

rotx.m[ 0 ][ 0 ] = math.cos( rad( yz ) )
rotx.m[ 0 ][ 1 ] = -math.sin( rad( yz ) )
rotx.m[ 1 ][ 0 ] = math.sin( rad( yz ) )
rotx.m[ 1 ][ 1 ] = math.cos( rad( yz ) )

roty.m[ 0 ][ 0 ] = math.cos( rad( xz ) )
roty.m[ 0 ][ 2 ] = -math.sin( rad( xz ) )
roty.m[ 2 ][ 0 ] = math.sin( rad( xz ) )
roty.m[ 2 ][ 2 ] = math.cos( rad( xz ) )

rotz.m[ 1 ][ 1 ] = math.cos( rad( xy ) )
rotz.m[ 1 ][ 2 ] = -math.sin( rad( xy ) )
rotz.m[ 2 ][ 1 ] = math.sin( rad( xy ) )
rotz.m[ 2 ][ 2 ] = math.cos( rad( xy ) )

trans.m[ 3 ][ 0 ] = x
trans.m[ 3 ][ 1 ] = y
trans.m[ 3 ][ 2 ] = z

if ax == XYZ :
lv[ no ] = m * rotx * roty * rotz * trans
elif ax == XZY :
lv[ no ] = m * rotx * rotz * roty * trans
elif ax == YXZ :
lv[ no ] = m * roty * rotx * rotz * trans
elif ax == YZX :
lv[ no ] = m * roty * rotz * rotx * trans
elif ax == ZXY :
lv[ no ] = m * rotz * rotz * roty * trans
elif ax == ZYX :
lv[ no ] = m * rotz * roty * rotx * trans
else :
lv[ no ] = m
number = no

def child( no , x , y , z , lim , ax , p ) :

if lim < 0 or lim > len( lsk ) - 1 : return

link( no , x , y , z ,
lsk[ lim ].y ,
lsk[ lim ].x ,
lsk[ lim ].z , ax , p )

def skelet( lim , x , y , z ) :

if lim < 0 or lim > len( lsk ) - 1 : return

lsk[ lim ].x = x
lsk[ lim ].y = y
lsk[ lim ].z = z

def spot( x , y , z ) :

m = lv[ number ]
hx = x * m.m[ 0 ][ 0 ]
+ y * m.m[ 1 ][ 0 ]
+ z * m.m[ 2 ][ 0 ]
+ m.m[ 3 ][ 0 ]
hy = x * m.m[ 0 ][ 1 ]
+ y * m.m[ 1 ][ 1 ]
+ z * m.m[ 2 ][ 1 ]
+ m.m[ 3 ][ 1 ]
hz = x * m.m[ 0 ][ 2 ]
+ y * m.m[ 1 ][ 2 ]
+ z * m.m[ 2 ][ 2 ]
+ m.m[ 3 ][ 2 ]

return ( hx , hy , hz )
[/code]
cColor.py
[code]
import math

# primary colors
black = ( 0 , 0 , 0 )
red = ( 255 , 0 , 0 )
green = ( 0 , 255 , 0 )
yellow = ( 255 , 255 , 0 )
blue = ( 0 , 0 , 255 )
magenta = ( 255 , 0 , 255 )
cyan = ( 0 , 255 , 255 )
white = ( 255 , 255 , 255 )
# mixed colors
orange = ( 255 , 127 , 0 )
pink = ( 255 , 127 , 127 )
gray = ( 127 , 127 , 127 )
purple = ( 127 , 0 , 127 )

def mix( kla , f , klb ) :
r1 , g1 , b1 = kla
r2 , g2 , b2 = klb
r = r1 + ( r2 - r1 ) * f
g = g1 + ( g2 - g1 ) * f
b = b1 + ( b2 - b1 ) * f
return int( r ) , int( g ) , int( b )

def rainbow( deg ) :
r = math.sin( deg * math.pi / 180 ) * 127 + 128
g = math.sin( ( deg - 120 ) * math.pi / 180 ) * 127 + 128
b = math.sin( ( deg + 120 ) * math.pi / 180 ) * 127 + 128
return int( r ) , int( g ) , int( b )
[/code]
cVector3.py
[code]
import math

class Vector3 :

def __init__( self , x = 0.0 , y = 0.0 , z = 0.0 ) :
self.x = x
self.y = y
self.z = z

@classmethod
def from_points( self , p1 , p2 ) :
return Vector3( p2[ 0 ] - p1[ 0 ] ,
p2[ 1 ] - p1[ 1 ] ,
p2[ 2 ] - p1[ 2 ] )

def lenght( self ) :
return math.sqrt( self.x**2 + self.y**2 + self.z**2 )

def normalize( self ) :
self.x /= self.lenght() + 1e-7
self.y /= self.lenght() + 1e-7
self.z /= self.lenght() + 1e-7

def __add__( self , r ) :
return Vector3( self.x + r.x ,
self.y + r.y ,
self.z + r.z )

def __sub__( self , r ) :
return Vector3( self.x - r.x ,
self.y - r.y ,
self.z - r.z )

def __neg__( self ) :
return Vector3( -self.x , -self.y , -self.z )

def __mul__( self , f ) :
return Vector3( self.x * f , self.y * f , self.z * f )

def __div__( self , f ) :
return Vector3( self.x / f , self.y / f , self.x / f )

def angle( self , v ) :
return math.acos( ( self.lenght() * v.lenght() ) /
dot( self , v ) )

def cross( a , b ) :
return Vector3( a.y * b.z - a.z * b.y ,
a.z * b.x - a.x * b.z ,
a.x * b.y - a.y * b.x )

def dot( a , b ) :
return a.x * b.x + a.y * b.y + a.z * b.z + 1e-7
[/code]
main
[code]
from basic3d import *

class Triangle( object ) :

def __init__( self , p1 , p2 , p3 , clr ) :

p1.x , p1.y , p1.z = spot( p1.x , p1.y , p1.z )
p2.x , p2.y , p2.z = spot( p2.x , p2.y , p2.z )
p3.x , p3.y , p3.z = spot( p3.x , p3.y , p3.z )

self.p1 = p1
self.p2 = p2
self.p3 = p3

self.led = ( self.p1 + self.p2 + self.p3 ) / 3

self.normal = self.led + cross( self.p2 - self.p1 ,
self.p3 - self.p1 )

self.clr = clr

def draw( self , light ) :

points = []
points.append(
( winx / 2 + self.p1.x / ( self.p1.z + 1000 ) * 1000 ,
winy / 2 - self.p1.y / ( self.p1.z + 1000 ) * 1000 ) )
points.append(
( winx / 2 + self.p2.x / ( self.p2.z + 1000 ) * 1000 ,
winy / 2 - self.p2.y / ( self.p2.z + 1000 ) * 1000 ) )
points.append(
( winx / 2 + self.p3.x / ( self.p3.z + 1000 ) * 1000 ,
winy / 2 - self.p3.y / ( self.p3.z + 1000 ) * 1000 ) )
# normal = self.normal - self.led
# normal.normalize()
# light.normalize()
# angle = normal.angle( light )
# self.clr = mix( self.clr , math.cos( angle ) / 2 + .5 , black )

pygame.draw.polygon( screen , self.clr , points )

class World( object ) :

def __init__( self ) :

self.tri = []
self.pnt = []
for i in xrange( 256 ) :
self.pnt.append( Vector3() )

def point( self , no , x , y , z ) :

if no < 0 or no > len( self.pnt ) - 1 : return

self.pnt[ no ].x = x
self.pnt[ no ].y = y
self.pnt[ no ].z = z

def tri( self , p1 , p2 , p3 , clr ) :

self.tri.append( Triangle( self.pnt[ p1 ] ,
self.pnt[ p2 ] ,
self.pnt[ p3 ] ,
clr ) )

def quad( self , p1 , p2 , p3 , p4 , clr ) :

self.tri.append( Triangle( self.pnt[ p1 ] ,
self.pnt[ p2 ] ,
self.pnt[ p3 ] ,
clr ) )
self.tri.append( Triangle( self.pnt[ p4 ] ,
self.pnt[ p2 ] ,
self.pnt[ p3 ] ,
clr ) )

def draw( self , light ) :

# sort trianlges
for h in range( 1 , len( self.tri ) - 1 ) :
for l in range( 0 , h - 1) :
if self.tri[ h ].led.z < self.tri[ l ].led.z :
htri = self.tri[ h ]
self.tri[ h ] = self.tri[ l ]
self.tri[ l ] = htri

for i in xrange( len( self.tri ) - 1 ) :
self.tri[ i ].draw( light )

def color_cube( self , m , d ) :

self.point( 0 , m.x + d.x , m.y + d.y , m.z + d.z )
self.point( 1 , m.x + d.x , m.y + d.y , m.z - d.z )
self.point( 2 , m.x + d.x , m.y - d.y , m.z + d.z )
self.point( 3 , m.x + d.x , m.y - d.y , m.z - d.z )
self.point( 4 , m.x - d.x , m.y + d.y , m.z + d.z )
self.point( 5 , m.x - d.x , m.y + d.y , m.z - d.z )
self.point( 6 , m.x - d.x , m.y - d.y , m.z + d.z )
self.point( 7 , m.x - d.x , m.y - d.y , m.z - d.z )

self.quad( 0 , 1 , 3 , 2 , red )
self.quad( 7 , 6 , 4 , 5 , cyan )
self.quad( 0 , 1 , 5 , 4 , green )
self.quad( 7 , 6 , 3 , 2 , magenta )
self.quad( 0 , 2 , 6 , 4 , blue )
self.quad( 7 , 5 , 1 , 3 , yellow )

def clear( self ) :
self.tri[ : ] = []

world = World()

angle = 0.
angle_speed = 180. / 25.

clock = pygame.time.Clock()

pygame.display.set_caption( "VR 3D 1.0" )
while True :

for event in pygame.event.get() :
if event.type == QUIT :
sys.exit()
elif event.type == KEYDOWN :
if event.key == K_ESCAPE :
sys.exit()

screen.fill( black )
world.clear()

link( 1 , 0 , 0 , 0 , angle , angle , 0 , XYZ , 0 )
world.color_cube( Vector3( 0 , 0 , 0 ) , Vector3( 100 , 100 , 100 ) )

world.draw( Vector3( 0 , 200 , 0 ) )

clock.tick( 25 )
angle += angle_speed

pygame.display.update()
[/code]