def __init__(self, name):
self.name = name
self.position = vector3()
self.rotation = quaternion(1, 0, 0, 0)
self.scale = vector3(1, 1, 1)
self.mesh = None
self.material = None
self.children = []
def create_childlegend(size, mesh = None):
if (mesh == None):
mesh = Mesh("LegendaryLegend")
Mesh.create_triangle(vector3(0, 0, -size[0] * 0.5), vector3(size[1] * 0.5 , 0, 0), vector3(0, -size[2] * 0.5, 0), mesh)
Mesh.create_triangle(vector3(0, 0, size[0] * 0.5), vector3(size[1] * 0.5, 0, 0), vector3(0, -size[2] * 0.5, 0), mesh)
Mesh.create_square(vector3(-size[0] * 0.5, 0, 0), vector3(0, -size[1] * 0.5, 0), vector3(0, 0, -size[2] * 0.5), mesh)
Mesh.create_square(vector3(0, size[0] * 0.5, 0), vector3(size[1] * 0.5, 0, 0), vector3(0, 0, -size[2] * 0.5), mesh)
Mesh.create_square(vector3(0, 0, 0), vector3(-size[1] * 0.5, -size[1] * 0.5, 0), vector3(0,0, -size[2] * 0.5), mesh)
return mesh
def __init__(self, game_object):
self.game_object = game_object
self.local_position = vector3()
self.local_rotation = quaternion(1, 0, 0, 0)
self.local_scale = vector3.one()
self._parent = None
self.children = []
def create_sphere( self, rel_pos, radius, mat ):
self.m = mat
rel_pos /= voxel_tree.voxel_world_size
radius /= voxel_tree.voxel_world_size
radius_sq = radius * radius
for x in range( int(self.dim.x * voxel_tree.mask_block_dim) ):
for y in range( int(self.dim.y * voxel_tree.mask_block_dim) ):
for z in range( int(self.dim.z * voxel_tree.mask_block_dim) ):
print x,y,z
ptsq = ( (x-rel_pos.x)*(x-rel_pos.x) +
(y-rel_pos.y)*(y-rel_pos.y) +
(z-rel_pos.z)*(z-rel_pos.z) )
if ptsq < radius_sq:
mask = ( 1 << ( (x % voxel_tree.dim.x) +
(y % voxel_tree.dim.y) * mask_block_dim
(z % voxel_tree.dim.z) * mask_block_dim_sq ) )
pos = vector3(x,y,z) / voxel_tree.mask_block_dim
mask_pos = int( (pos.x / voxel_tree.pos.x +
pos.y * voxel_tree.dim.x +
pos.z * voxel_tree.dim.x * voxel_tree.dim.y ) )
self.mask[ mask_pos ] |= mask
def create_Cube(size, mesh = None):
if (mesh == None):
mesh = Mesh("Cube2")
Mesh.create_square(vector3(-size[0] * 0.5, 0, 0), vector3(0, 0, size[2] * 0.5), vector3(0, size[1] * 0.5, 0), mesh)
Mesh.create_square(vector3(size[0] * 0.5, 0, 0), vector3(0, 0, size[2] * 0.5), vector3(0, size[1] * 0.5, 0), mesh)
Mesh.create_square(vector3(0, 0, size[2] * 0.5), vector3(-size[0] * 0.5, 0, 0), vector3(0, size[1] * 0.5, 0), mesh)
Mesh.create_square(vector3(0, 0, -size[2] * 0.5), vector3(size[0] * 0.5, 0), vector3(0, size[1] * 0.5, 0), mesh)
return mesh
def create_piramide(size, mesh=None):
if (mesh == None):
mesh = Mesh("UnknownCube")
Mesh.create_triangulo(vector3(size[0] * 0.5, 0, 0),
vector3(0, size[1] * 0.5, 0),
vector3(0, 0, size[2] * 0.5), mesh)
Mesh.create_triangulo(vector3(0, size[1] * 0.5, 0),
vector3(size[0] * 0.5, 0),
vector3(0, 0, size[2] * 0.5), mesh)
Mesh.create_triangulo(vector3(0, 0, size[2] * 0.5),
vector3(size[0] * 0.5, 0),
vector3(0, size[1] * 0.5, 0), mesh)
return mesh
def __init__( self, out, screen, tile_size, generator ):
#avoid our attribute management system
self.recurse_attributes = False
self.screen = screen
self.window = screen.get_size()
self.tile_size = tile_size
self.tile_dim = ( self.window[0]/tile_size[0],
self.window[1]/tile_size[1] )
self.window = ( self.tile_dim[0] * tile_size[0],
self.tile_dim[1] * tile_size[1] )
self.start_rect = Rect( (0,0), tile_size)
self.ts = ts = tile_size
self.hts = hts = (ts[0]/2, ts[1]/2)
self.areas = [ [ area.area( vector3( x*ts[0] + hts[0],
y*ts[1] + hts[1],
0 ),
ts,
potential = resource.resource(
food = generator(x, y),
wood = generator(x, y),
gold = generator(x, y),
stone = generator(x, y)
)
) for y in range( self.tile_dim[1] )
] for x in range( self.tile_dim[0] )
]
self.cities = [ city.city( vector3( x + (hts[0]-5) * random.random(),
y + (hts[1]-5) * random.random(),
0.0 ),
out,
area = self.get_area_at( x/ts[0], y/ts[1] ) )
for x in range(0, self.window[0], hts[0])
for y in range(0, self.window[1], ts[1])
]
def render(self, screen, matrix, material, obj, camarapos, light):
i=-1
for poly in self.polygons:
i=i+1
tpoly = []
for v in poly:
vtemp = v + vector3(0,0,0)
if(vtemp.z<camarapos.z):
vtemp.z=camarapos.z
vout=vtemp.to_np4()
vout = vout @ matrix
tpoly.append( ( screen.get_width() * 0.5 + vout[0] / vout[3], screen.get_height() * 0.5 - vout[1] / vout[3]) )
tpoly.append( ( screen.get_width() * 0.5 + vout[0] / vout[3], screen.get_height() * 0.5 - vout[1] / vout[3]) )
ab=(poly[1].to_np4() @ obj.get_matrix())-(poly[0].to_np4() @ obj.get_matrix())
abvec=vector3(0,0,0)
abvec.x=ab[0]
abvec.y=ab[1]
abvec.z=ab[2]
bc=(poly[2].to_np4() @ obj.get_matrix())-(poly[1].to_np4() @ obj.get_matrix())
bcvec=vector3(0,0,0)
bcvec.x=bc[0]
bcvec.y=bc[1]
bcvec.z=bc[2]
n = vector3.cross(abvec, bcvec)
np.cross
centro = self.origins[i].to_np4()
centro = centro @ obj.get_matrix()
v=centro-camarapos.to_np4()
normal=n.to_np4()
if(np.dot( v, normal) < 0.0):
if(centro[2] >= camarapos.z):
l= centro - light.to_np4()
li_intensity=max(0.05,-np.dot(l, normal))
li_intensity=min(li_intensity, 1)
cpoly=material.color
cpoly = cpoly.__mul__(li_intensity)
c = cpoly.tuple3()
pygame.draw.polygon(screen, c, tpoly, material.line_width)
def __init__( self, screen_dim ):
self.dim = screen_dim
self.pos = vector3()
self.look = vector3( 0., 0., -1. )
self.up = vector3( 0., 1., 0. )
self.fov = 70.0
self.nearz = 0.1
self.farz = 100.0
self.render_start = pygame.time.get_ticks()
d = pygame.display
self.screen = d.set_mode( ( int(self.dim.x), int(self.dim.y) ),
pygame.OPENGL | pygame.DOUBLEBUF, 32 )
self.default_settings()
self.perspective()
self.world()
def draw( self ):
"Draw the grid as a background for other rendering"
ts = self.tile_size
rect = Rect( self.start_rect )
for y in range( self.tile_dim[1] ):
for x in range( self.tile_dim[0] ):
area = self.areas[x][y]
# sum of faction colors scaled by faction control in area
color = vector3()
for i in range( global_info.num_factions ):
color += (global_info.faction_colors[i] *
(area.faction_control[i]/100.0))
pygame.draw.rect( self.screen, color.raw, rect )
rect.move_ip( ts[0], 0 )
rect.move_ip( -ts[0] * self.tile_dim[0] , ts[1] )
for city in self.cities:
#draw an outer white band
pos = Rect( (city.pos.x, city.pos.y), (6,6) )
pygame.draw.rect( self.screen, (255,255,255), pos )
#select a ligher version of faction color
if city.faction_ident == -1:
color = (0,0,0)
else:
color = global_info.faction_colors[ city.faction_ident ]
color = color + vector3(150, 150, 150)
color.cut_max(255)
color = color.raw
#move the rect inside our outline
pos.inflate_ip(-2,-2)
pygame.draw.rect( self.screen, color, pos )
def __init__(self, scene):
"Arguments: scene object containing geometry"
self.scene = scene
# define screen dimensions
self.w = 800
self.h = 600
self.hw = self.w/2
self.hh = self.h/2
self.distort = float(self.w) / float(self.h)
#define viewing angle
self.fov = 70.0 * math.pi / 180.0
self.tanfov = math.tan( self.fov / 2.0 )
#base at origin looking down z axis for now
self.pos = vector3()
self.look = vector3(0.0, 0.0, -1.0)
self.up = vector3(0.0, 1.0, 0.0)
self.right = self.look.crossp( self.up )
self.screen = pygame.display.set_mode( (self.w,self.h), 0, 24 )
self.screen.fill( (0,0,0) )
def _create_mask( self, v ):
"""Returns: long representing bit mask of all the points the vector
touches in crossing a mask block. v should be normalized"""
mask = 0L
start = vector3(0,0,0)
if v.x < 0.0: start.x = voxel_tree.mask_block_dim
if v.y < 0.0: start.y = voxel_tree.mask_block_dim
if v.z < 0.0: start.z = voxel_tree.mask_block_dim
for i in range( 7 ):
pos = start + (v * i);
if pos.x < 4 and pos.x >=0 and pos.y < 4 and pos.y >=0 and pos.z < 4 and pos.z >= 0:
shift = pos.x + pos.y * voxel_tree.mask_block_dim + pos.z * voxel_tree.mask_block_dim_sq
mask = mask | ( 1 << int(shift) )
return mask
def create_cube(size, mesh = None):
if (mesh == None):
mesh = Mesh("UnknownCube")
# face da direita e da esquerda
#Mesh.create_quad(vector3( size[0] * 0.5, 0, 0), vector3(0, -size[1] * 0.5, 0), vector3(0, 0, size[2] * 0.5), mesh)
#Mesh.create_quad(vector3(-size[0] * 0.5, 0, 0), vector3(0, size[1] * 0.5, 0), vector3(0, 0, size[2] * 0.5), mesh)
Mesh.create_quad(vector3(size[0] * 0.5, 0, 0), vector3(0, size[1] * 0.5, 0), vector3(0, 0, size[2] * 0.5), mesh)
#face de cima e de baixo
#Mesh.create_quad(vector3(0, size[1] * 0.5, 0), vector3(size[0] * 0.5, 0), vector3(0, 0, size[2] * 0.5), mesh)
Mesh.create_quad(vector3(0, -size[1] * 0.5, 0), vector3(-size[0] * 0.5, 0), vector3(0, 0, size[2] * 0.5), mesh)
#face da frente e de trás
#Mesh.create_quad(vector3(0, 0, size[2] * 0.5), vector3(-size[0] * 0.5, 0), vector3(0, size[1] * 0.5, 0), mesh)
Mesh.create_quad(vector3(0, 0, -size[2] * 0.5), vector3(-size[0] * 0.5, 0), vector3(0, size[1] * 0.5, 0), mesh)
return mesh
def get_shade(self, scene, point):
"""Returns: shade factor that should be used for all contributions
from this light
"""
shade = 0.0
#use eccentricities to determine if we're likely to hit anything
self_ecc = math.sqrt( self.w**2 + self.d**2 )
eccs = scene.get_augmented_eccentricities(point, self.p)
#try to get out of here quickly
min_eccs = min(eccs)
#if the minimum eccentricity is less than ours then no part
#of the light will be blocked
if min_eccs[0] > self_ecc:
return 1.0
#if the minimum eccentricity is less than the negation of ours
#we'll never make it positive, all light will be blocked
if min_eccs[0] < -self_ecc:
return 0.0
#regardless we only need to collide our many light rays with
#geometry that could possibly intersect them
necessary = [x[1] for x in eccs if x[0] < self_ecc and x[0] > -self_ecc]
scene.select_collides( necessary )
#compute some points around out point intervals based on a random factor
points = [ self.p + vector3( self.dx*x + random() * self.dx,
0.0,
self.dz*z + random() * self.dz )
for z in range(square_light.dimension_shade)
for x in range(square_light.dimension_shade) ]
#check each precomputed point to see if have sight of point
#get approximate fraction of light visible from point
for light_point in points:
if not scene.is_blocked( point, light_point ):
shade += self.contribution
#reset scene to collide with everything
scene.select_collides()
return shade
def unpack( data ):
l = len( data )
s = struct.calcsize( '!i' )
if s > l:
return None, data
length, = struct.unpack( '!i', data[:s] )
if length > l:
return None, data
header_data = data[:action.header_length]
l,code,r,g,b = struct.unpack( action.header_format, header_data )
try:
act = action.actions[ code ]( code, vector3(r,g,b) )
except KeyError, e:
print "Unknown action code, error: ", e
def __init__( self, leader, **keys ):
self.leader = leader
self.pos = vector3()
# set initial values
self.deviance = 0
self.size = 0
self.military = 0
# update based on passed parameter
super(party, self).__init__( keys )
self.possible_actions[ "build_city" ] = [ (self.build_city,
None,
[ faction.faction,
city.city ]) ]
def render_ray(self, xfactor, yfactor):
"Renders a single ray at the fraction of the screen specified"
#generate ray for this pixel
d = ( self.look + self.right * xfactor * self.tanfov +
self.up * -yfactor * self.tanfov )
r = shapes.ray(self.pos, d)
intersect = self.scene.collide( r )
#see if we managed to hit anything
if not intersect:
self.intersect_info = ()
return vector3()
color = intersect.surf.m.color( self.scene, intersect, self.pos )
self.intersect_info = intersect.surf.m.info
return color
def create_cube(size, mesh=None):
if (mesh == None):
mesh = Mesh("UnknownCube")
#Mesh.create_quad(vector3( size[0] * 0.5, 0, 0), vector3(0, -size[1] * 0.5, 0), vector3(0, 0, size[2] * 0.5), mesh)
#Mesh.create_quad(vector3(-size[0] * 0.5, 0, 0), vector3(0, size[1] * 0.5, 0), vector3(0, 0, size[2] * 0.5), mesh)
#Mesh.create_quad(vector3(0, size[1] * 0.5, 0), vector3(size[0] * 0.5, 0), vector3(0, 0, size[2] * 0.5), mesh)
#Mesh.create_quad(vector3(0, -size[1] * 0.5, 0), vector3(-size[0] * 0.5, 0), vector3(0, 0, size[2] * 0.5), mesh)
#Mesh.create_quad(vector3(0, 0, size[2] * 0.5), vector3(-size[0] * 0.5, 0), vector3(0, size[1] * 0.5, 0), mesh)
#Mesh.create_quad(vector3(0, 0, -size[2] * 0.5), vector3( size[0] * 0.5, 0), vector3(0, size[1] * 0.5, 0), mesh)
Mesh.create_quad(vector3(0, 0, -size[2] * 0.5),
vector3(-size[0] * 0.5, 0),
vector3(0, size[1] * 0.5, 0), mesh)
Mesh.create_quad(vector3(size[0] * 0.5, 0, 0),
vector3(0, size[1] * 0.5, 0),
vector3(0, 0, size[2] * 0.5), mesh)
Mesh.create_quad(vector3(0, -size[1] * 0.5, 0),
vector3(-size[0] * 0.5, 0),
vector3(0, 0, size[2] * 0.5), mesh)
return mesh
def __init__( self, **keys ):
self.pos = vector3()
# set initial values
self.faction_ident = 0
self.morality = 0
self.ambition = 0
self.goals = []
self.actions = []
self.possible_actions = {}
self.possible_actions[ "move" ] = [ (self.move,
None,
[ vector3 ]) ]
self.actions = []
# update based on passed parameter
super(person, self).__init__( keys )
def back(self):
return vector3.from_np(vector3(0,0,-1).to_np4(0) @ self.get_matrix())
from vector3 import *
#create a random number generator
class random_generator:
def __init__(self, minimum, maximum):
self.mi = minimum
self.ma = maximum
def __call__(self, *args):
return (random.random() * (self.ma-self.mi)) + self.mi
#create some information about the factions we're going to create
info = global_info.global_info()
info.num_factions = 4
info.faction_colors = [ vector3(255,0,0), vector3(0,0,255),
vector3(255,255,0), vector3(0,255,255) ]
info.faction_names = [ "orcs", "humans", "elves", "fairies" ]
grid.global_info = info
area.global_info = info
#initialize pygame
pygame.init()
screen = pygame.display.set_mode( (800,600), 0, 24 )
screen.fill( (0,0,0) )
#create information display structures
out = output.output( screen, 14 )
world = grid.grid( out, screen, (64,64), random_generator(10000, 15000) )
import event_handler
import network
import world
server = False
for arg in sys.argv:
if arg == '-s' or arg == '-server':
server = True
try:
if server: net = network.server( constants.port )
else: net = network.client( "pymud.no-ip.org", constants.port )
except AttributeError, e:
print "ERROR: in connection, %s" % e
sys.exit(-1)
pygame.init()
rend = renderer.renderer( vector3( constants.width, constants.height ) )
hand = event_handler.handler()
scene = world.world( rend, hand, net )
while True:
event = hand.process()
if event and event.type == pygame.QUIT:
break
scene.update()
pygame.quit()
def test_one(self):
p = vector3()
d = vector3(0.0, 0.0, -1.0)
self.scene.collide( shapes.ray(p, d) )
return
def right(self):
return vector3.from_np(vector3(1, 0, 0).to_np4(0) @ self.get_matrix())
def forward(self):
return vector3.from_np(vector3(0, 0, 1).to_np4(0) @ self.get_matrix())
def create_pyramid(size, mesh = None):
if (mesh == None):
mesh = Mesh("UnknownPyramid")
Mesh.create_quad(vector3(0, -size[1] * 0.5, 0), vector3(-size[0] * 0.5, 0), vector3(0, 0, size[2] * 0.5), vector3(0,0,0), mesh)
#traz/frente
Mesh.create_tria(vector3(0, 0, size[2] * 0.5), vector3(-size[0] * 0.5, 0), vector3(0, size[1] * 0.5, 0), vector3(0, 0, -size[2] * 0.5), mesh)
Mesh.create_tria(vector3(0, 0, -size[2] * 0.5), vector3( size[0] * 0.5, 0), vector3(0, size[1] * 0.5, 0), vector3(0, 0, size[2] * 0.5), mesh)
#direita/esquerda
Mesh.create_tria(vector3( size[0] * 0.5, 0, 0), vector3( 0, 0, size[2] * 0.5), vector3(0, size[1] * 0.5, 0), vector3(-size[0] * 0.5, 0, 0), mesh)
Mesh.create_tria(vector3(-size[0] * 0.5, 0, 0), vector3( 0, 0, -size[2] * 0.5), vector3(0, size[1] * 0.5, 0), vector3( size[0] * 0.5, 0, 0), mesh)
return mesh
def create_pyr(size, mesh=None):
if (mesh == None):
mesh = Mesh("UnknownPyr")
Mesh.create_trig(vector3(0, size[1] * 0.5, 0),
vector3(size[0] * 0.5, 0, 0),
vector3(-size[0] * 0.5, 0, 0), mesh) # ACB
Mesh.create_trig(vector3(0, size[1] * 0.5, 0),
vector3(-size[0] * 0.5, 0, 0),
vector3(0, 0, size[2] * 0.5), mesh) # ABD
Mesh.create_trig(vector3(0, size[1] * 0.5, 0),
vector3(size[0] * 0.5, 0, 0),
vector3(0, 0, size[2] * 0.5), mesh) # ACD
Mesh.create_trig(vector3(-size[0] * 0.5, 0, 0),
vector3(size[0] * 0.5, 0, 0),
vector3(0, 0, size[2] * 0.5), mesh) # BCD
return mesh
def create_pol(size, mesh = None):
if (mesh == None):
mesh = Mesh("UnknownPol")
#quadrados direita
Mesh.create_quad(vector3( size[0] * 0.5, 0, 0), vector3(0, -size[1] * 0.25, 0), vector3(0, 0, size[2] * 0.5), vector3(0,0,0), mesh)
Mesh.create_quad(vector3( size[0] * 0.25, size[1] * 0.40, 0), vector3(0, size[1] * 0.125, 0), vector3(0, 0, -size[2] * 0.5), vector3(size[0] * 0.25,0,0), mesh)
Mesh.create_quad(vector3( size[0] * 0.5, -size[1] * 0.40, 0),vector3(0, size[1] * 0.125, 0), vector3(0, 0, -size[2] * 0.5), vector3(-size[0] * 0.25,0,0), mesh)
#quadrados esquerda
Mesh.create_quad(vector3(-size[0] * 0.5, 0, 0), vector3(0, size[1] * 0.25, 0), vector3(0, 0, size[2] * 0.5), vector3(0,0,0), mesh)
Mesh.create_quad(vector3(-size[0] * 0.25, size[1] * 0.40, 0), vector3(0, size[1] * 0.125, 0), vector3(0, 0, size[2] * 0.5), vector3(-size[0] * 0.25,0,0),mesh)
Mesh.create_quad(vector3(-size[0] * 0.5, -size[1] * 0.40, 0), vector3(0, size[1] * 0.125, 0), vector3(0, 0, size[2] * 0.5), vector3(size[0] * 0.25,0,0),mesh)
#quadrados baixo e cima
Mesh.create_quad(vector3(0, size[1] * 0.5, 0), vector3(size[0] * 0.25, 0), vector3(0, 0, size[2] * 0.5), vector3(0,0,0), mesh)
Mesh.create_quad(vector3(0, -size[1] * 0.5, 0), vector3(-size[0] * 0.25, 0), vector3(0, 0, size[2] * 0.5), vector3(0,0,0), mesh)
#quadrados frente e traz
Mesh.create_hex(vector3(0, 0, size[2] * 0.5), vector3(-size[0] * 0.5, 0), vector3(0, size[1] * 0.5, 0), mesh)
Mesh.create_hex(vector3(0, 0, -size[2] * 0.5), vector3( size[0] * 0.5, 0), vector3(0, size[1] * 0.5, 0), mesh)
return mesh
def __init__(self, name):
self.name = name
self.position = vector3()
def create_cube(size, mesh = None):
if (mesh == None):
mesh = Mesh("UnknownCube")
#quadrados esquerda e direita
Mesh.create_quad(vector3( size[0] * 0.5, 0, 0), vector3(0, -size[1] * 0.5, 0), vector3(0, 0, size[2] * 0.5), vector3(0,0,0), mesh)
Mesh.create_quad(vector3(-size[0] * 0.5, 0, 0), vector3(0, size[1] * 0.5, 0), vector3(0, 0, size[2] * 0.5), vector3(0,0,0), mesh)
#quadrados baixo e cima
Mesh.create_quad(vector3(0, size[1] * 0.5, 0), vector3(size[0] * 0.5, 0), vector3(0, 0, size[2] * 0.5), vector3(0,0,0), mesh)
Mesh.create_quad(vector3(0, -size[1] * 0.5, 0), vector3(-size[0] * 0.5, 0), vector3(0, 0, size[2] * 0.5), vector3(0,0,0), mesh)
#quadrados frente e traz
Mesh.create_quad(vector3(0, 0, size[2] * 0.5), vector3(-size[0] * 0.5, 0), vector3(0, size[1] * 0.5, 0), vector3(0,0,0), mesh)
Mesh.create_quad(vector3(0, 0, -size[2] * 0.5), vector3( size[0] * 0.5, 0), vector3(0, size[1] * 0.5, 0), vector3(0,0,0), mesh)
return mesh
import pygame
from pygame.locals import *
from vector3 import *
colors = [ vector3( r, g, b )
for r in range(0, 256, 64)
for g in range(0, 256, 64)
for b in range(0, 256, 64) ]
image = pygame.image.load( "run.bmp" )
size = image.get_size()
screen = pygame.display.set_mode( size )
screen.blit( image, (0,0) )
for x in range( size[0] ):
for y in range( size[1] ):
pixel = raw_to_vec3( screen.get_at( (x,y) ) )
closest = None
distsqd = 1000000000000.0
for c in colors:
ds = ( pixel - c ).mag_squared()
if ds < distsqd:
distsqd = ds
closest = c
def collide( self, ray ):
coll = collision( ray )
ray_d = ray.d
start = ray.s - self.pos
if not self.dim.contains( start ):
#compute distance ray must travel in each direction and divide by speed in that dir
minbounds = -start
maxbounds = -start + vector3( self.dim.x, self.dim.y, self.dim.z )
t = minbounds.component_div(ray_d).raw_list
t.extend( maxbounds.component_div(ray_d).raw_list )
#cut out all t values behind start point and that aren't actually in voxel space
t = [ i for i in t if i > 0.0 ]
t = [ i for i in t if self.dim.contains( ray.s + ray_d * i ) ]
if not len(t): return coll()
# take closest t value
t.sort()
t = t.pop()
start = ray.s + ray_d * t
diff = start - self.pos
mask = self._create_mask( ray.d )
#scale d so direction of maximum increase increases in steps of mask_block_dim
m = max( enumerate( ray.d.raw ) , key = lambda t: t.__getitem__(1) )
scale = voxel_tree.mask_block_dim / m[ 1 ]
d = ray_d * scale
#create pos as integer coordinate in mask, dp as sub position
p = diff / voxel_tree.voxel_world_size / voxel_tree.mask_block_dim
pos = vector3( int(p.x), int(p.y), int(p.z) )
dp = ( pos - p ) * voxel_tree.mask_block_dim
while self.dim.contains( pos ):
#find the shift for the ray's mask and the mask-block that we're at
mask_shift = int(dp.x + dp.y * voxel_tree.mask_block_dim + dp.z * voxel_tree.mask_block_dim_sq )
mask_pos = int(pos.x + pos.y * voxel_tree.dim.x + pos.z * voxel_tree.dim.x * voxel_tree.dim.y )
#find the actual two masks
ray_mask = mask >> mask_shift
geo_mask = self.mask[ mask_pos ]
#if there is any overlap, there is a collision here
if ray_mask & geo_mask:
overlap = ray_mask & geo_mask
p = 0
while overlap:
p += 1
overlap = overlap >> 1
z = p / voxel_tree.mask_block_dim_sq
y = (p - z*voxel_tree.mask_block_dim_sq) / voxel_tree.mask_block_dim
x = (p - z*voxel_tree.mask_block_dim_sq - y*voxel_tree.mask_block_dim) / voxel_tree.mask_block_dim
hit = pos*voxel_tree.mask_block_dim*voxel_tree.voxel_world_size
hit += vector3(x,y,z)*voxel_tree.voxel-world_size
t = (hit - ray.s).mag()
return coll( True, self, t )
#increase along ray direction and then find the direction that
#it moved out of this mask block first
new_dp = dp + d
out_of_bounds = (new_dp - mask_dim).component_div( d )
m = max( enumerate( out_of_bounds.raw ), key = lambda t: t.__getitem__(1) )
#position dp at the edge of the mask block
t = ( voxel_tree.mask_block_dim - dp.raw[ m[0] ] ) / ld
dp += d * t
#increase pos which control with mask block we're looking at
# then reset the submask-block index in that direction
pos.modify( m[0], 1 )
dp.modify( m[0], -voxel_tree.mask_block_dim )
#passed outside of voxel space, no collision
return coll()
def get_position(self):
return vector3.from_np(vector3(0, 0, 0).to_np4(1) @ self.get_matrix())
def create_Pyramid(size, mesh=None):
if (mesh == None):
mesh = Mesh("Pyramid")
Mesh.create_triangle(vector3(-size[0] * 0.5, 0, 0),
vector3(0, 0, size[2] * 0.5),
vector3(0, size[1] * 0.5, 0), mesh)
Mesh.create_triangle(vector3(size[0] * 0.5, 0, 0),
vector3(0, 0, size[2] * 0.5),
vector3(0, size[1] * 0.5, 0), mesh)
Mesh.create_triangle(vector3(0, 0, size[2] * 0.5),
vector3(-size[0] * 0.5, 0),
vector3(0, size[1] * 0.5, 0), mesh)
Mesh.create_triangle(vector3(0, 0, -size[2] * 0.5),
vector3(size[0] * 0.5, 0),
vector3(0, size[1] * 0.5, 0), mesh)
Mesh.create_square(vector3(0, -size[1] * 0.5, 0),
vector3(-size[0] * 0.5, 0),
vector3(0, 0, size[2] * 0.5), mesh)
return mesh
def up(self):
return vector3.from_np(vector3(0, 1, 0).to_np4(0) @ self.get_matrix())
import pygame
from vector3 import *
import shapes, voxel, scene, render, material
#create some materials
red_mat = material.material( vector3(), #emissive
vector3(96.0, 66.0, 66.0), #ambient
vector3(96.0, 66.0, 66.0), #diffuse
vector3(), #specular
20.0, #shininess
0.0 ) #reflectivity
grey_mat = material.material( vector3(),
vector3(96.0, 96.0, 96.0),
vector3(96.0, 96.0, 96.0),
vector3(),
20.0,
0.0 )
bluegrey_mat = material.material( vector3(),
vector3(66.0, 66.0, 96.0),
vector3(66.0, 66.0, 96.0),
vector3(),
20.0,
0.0 )
orange_mat = material.material( vector3(),
vector3(238.0, 154.0, 73.0),
vector3(238.0, 154.0, 73.0),
vector3(255.0, 255.0, 255.0),
def create_Cube(size, mesh=None):
if (mesh == None):
mesh = Mesh("Cube")
#lados
Mesh.create_square(vector3(size[0] * 0.5, 0, 0),
vector3(0, -size[1] * 0.5, 0),
vector3(0, 0, size[2] * 0.5), mesh)
Mesh.create_square(vector3(-size[0] * 0.5, 0, 0),
vector3(0, size[1] * 0.5, 0),
vector3(0, 0, size[2] * 0.5), mesh)
#cima baixo
Mesh.create_square(vector3(0, size[1] * 0.5, 0),
vector3(size[0] * 0.5, 0),
vector3(0, 0, size[2] * 0.5), mesh)
Mesh.create_square(vector3(0, -size[1] * 0.5, 0),
vector3(-size[0] * 0.5, 0),
vector3(0, 0, size[2] * 0.5), mesh)
#frente tras
Mesh.create_square(vector3(0, 0, size[2] * 0.5),
vector3(-size[0] * 0.5, 0),
vector3(0, size[1] * 0.5, 0), mesh)
Mesh.create_square(vector3(0, 0, -size[2] * 0.5),
vector3(size[0] * 0.5, 0),
vector3(0, size[1] * 0.5, 0), mesh)
return mesh
def left(self):
return vector3.from_np(vector3(-1,0,0).to_np4(0) @ self.get_matrix())
