def __init__(self, emap, light):
""" calls Texture.__init__ but doesn't need to set file name as
texture generated from the framebuffer
"""
super(ShadowCaster, self).__init__("shadow_caster")
# load shader for casting shadows and camera
self.cshader = Shader("uv_flat")
self.mshader = Shader("mat_flat")
# keep copy of ElevationMap
self.emap = emap
self.emap.set_material((0.0, 0.0, 0.0)) # hide bits below ground
#TODO doesn't cope with z light positions
self.eye = [-500.0 * i for i in light.lightpos] # good distance away
if self.eye[1] <= 0: # must have +ve y
self.eye[1] = 500.0
if abs(self.eye[0]) > abs(self.eye[2]): #x val is bigger than z val
#change scale so map just fits on screen
if self.eye[0] < 0:
su, sv = 1.0, 1.0
else:
su, sv = -1.0, -1.0
self.scaleu = float(self.iy) / self.emap.width
self.scalev = float(self.ix)/ self.emap.depth
self.eye[2] = 0
self.scaleu = self.scaleu / self.eye[1] * (self.eye[0]**2 + self.eye[1]**2)**0.5
self.emap.unif[50] = 1.0 #orientation flag
self.emap.unif[53] = -3.0 * su / self.emap.width * self.eye[0] / self.eye[1] #height adjustment
else:
#change scale so map just fits on screen
if self.eye[2] < 0:
su, sv = 1.0, -1.0
else:
su, sv = -1.0, 1.0
self.scaleu = float(self.iy) / self.emap.depth
self.scalev = float(self.ix)/ self.emap.width
self.eye[0] = 0
self.scaleu = self.scaleu / self.eye[1] * (self.eye[2]**2 + self.eye[1]**2)**0.5
self.emap.unif[50] = 0.0
self.emap.unif[53] = -3.0 * su / self.emap.width * self.eye[2] / self.eye[1]
if abs(self.scaleu) > abs(self.scalev):
self.scale = 3.0 * self.scalev # multiplication factor to reduce pixeliness
else:
self.scale = 3.0 * self.scaleu
self.scaleu = su * self.scale / self.scaleu # reused later in end_cast
self.scalev = sv * self.scale / self.scalev
self.camera0 = Camera() # default instance created as normal, just in case!
self.camera = Camera(is_3d=False, eye=self.eye, scale=self.scale)
# load shader for drawing map with shadows
self.dshader = Shader("shadowcast")
def __init__(self,
shader="post_base",
mipmap=False,
add_tex=None,
scale=1.0,
camera=None,
divide=1):
""" calls Texture.__init__ but doesn't need to set file name as
texture generated from the framebuffer. Keyword Arguments:
*shader*
to use when drawing sprite, defaults to post_base, a simple
3x3 convolution that does basic edge detection. Can be copied to
project directory and modified as required.
*mipmap*
can be set to True with slight cost to speed, or use fxaa shader
*add_tex*
list of textures. If additional textures can be used by the shader
then they can be added here.
*scale*
will only render this proportion of the full screen which will
then be mapped to the full uv of the Sprite. The camera object
passed (below) will need to have the same scale set to avoid
perspective distortion
*camera*
the camera to use for rendering to the offscreen texture
*divide*
allow the sprite to be created with intermediate vertices to allow
interesting vertex shader effects
"""
super(PostProcess, self).__init__("postprocess")
self.scale = scale
# load shader
self.shader = Shader(shader)
if camera is None:
self.viewcam = Camera.instance(
) # in case this is prior to one being created
else:
self.viewcam = camera
self.camera = Camera(is_3d=False)
self.sprite = LodSprite(z=20.0, w=self.ix, h=self.iy, n=divide)
self.sprite.set_2d_size(w=self.ix, h=self.iy)
for b in self.sprite.buf:
b.unib[6] = self.scale # ufact
b.unib[7] = self.scale # vfact
b.unib[9] = (1.0 - self.scale) * 0.5 # uoffset
b.unib[10] = (1.0 - self.scale) * 0.5 # voffset
self.blend = True
self.mipmap = mipmap
self.tex_list = [
self
] # TODO check if this self reference causes graphics memory leaks
if add_tex:
self.tex_list.extend(add_tex)
def __init__(self, position, light, scale=10.0):
""" calls Texture.__init__ but doesn't need to set file name as
texture generated from the framebuffer
"""
super(ShadowCaster, self).__init__("shadow_caster")
self.LIGHT_CAM = Camera(is_3d=False, scale=scale)
l_p = light.lightpos
l_len = (l_p[0]**2 + l_p[1]**2 + l_p[2]**2)**0.5
self.OFFSET = [200.0 * i / l_len for i in l_p]
self.LIGHT_CAM.position(
[position[i] - o for i, o in enumerate(self.OFFSET)])
self.tilt, self.rot = self.LIGHT_CAM.point_at(position)
self.cast_shader = Shader("shadowcast")
from pi3d.shape.Sphere import Sphere
from pi3d.util.String import String
from pi3d.util.Screenshot import screenshot
from pi3d.util.Defocus import Defocus
#helpful messages
print("############################################################")
print("Mouse to move left and right and up and down")
print("############################################################")
print()
# Setup display and initialise pi3d
DISPLAY = Display.create(x=200, y=200, frames_per_second=20)
DISPLAY.set_background(0.4, 0.8, 0.8, 1) # r,g,b,alpha
camera = Camera((0, 0, 0), (0, 0, -1),
(1, 1000, 30.0, DISPLAY.width / DISPLAY.height))
light = Light((10, -10, 20))
# load shader
shader = Shader("shaders/uv_reflect")
flatsh = Shader("shaders/uv_flat")
defocus = Defocus()
#========================================
# Setting 2nd param to True renders 'True' Blending
# (this can be changed later to 'False' with 'rockimg2.blend = False')
groundimg = Texture("textures/stripwood.jpg")
monstimg = Texture("textures/pong3.png")
ballimg = Texture("textures/pong2.jpg")
# environment cube
ectex = Texture("textures/ecubes/skybox_stormydays.jpg")
def __init__(self, shader="uv_flat", mipmap=False, separation=0.4, interlace=0):
""" calls Texture.__init__ but doesn't need to set file name as
texture generated from the framebuffer. Keyword Arguments:
*shader*
to use when drawing sprite, defaults to uv_flat.
*mipmap*
can be set to True with slight cost to speed, or use fxaa shader
*separation*
distance between the two camera positions - how wide apart the
eye views are.
*interlace*
if interlace > 0 then the images are not taken with glScissor and
must be drawn with a special interlacing shader.
"""
# load shader
if interlace <= 0: # i.e. default side by side behaviour
self.shader = Shader.create(shader)
else:
self.shader = Shader(vshader_source = """
precision mediump float;
attribute vec3 vertex;
attribute vec2 texcoord;
uniform mat4 modelviewmatrix[2];
varying vec2 texcoordout;
void main(void) {
texcoordout = texcoord;
gl_Position = modelviewmatrix[1] * vec4(vertex,1.0);
}
""", fshader_source = """
precision mediump float;
uniform sampler2D tex0;
uniform sampler2D tex1;
varying vec2 texcoordout;
void main(void) {{
vec4 texc0 = texture2D(tex0, texcoordout);
vec4 texc1 = texture2D(tex1, texcoordout);
vec2 coord = vec2(gl_FragCoord);
gl_FragColor = mix(texc0, texc1, step(0.5, fract(coord.x / {:f})));
}}
""".format(interlace * 2.0))
self.camera_3d = Camera() # create 3d cam first so it becomes default instance
self.forMtrx = np.identity(4, dtype='float32') # initially not rotated
self.position = [0.0, 0.0, 0.0]
self.camera_2d = Camera(is_3d=False)
self.offs = separation / 2.0
self.interlace = interlace
self.textures = []
self.sprites = []
self.tex_list = []
for i in range(2):
self.textures.append(OffScreenTexture(name="stereo"))
ix, iy = self.textures[i].ix, self.textures[i].iy
#two sprites full width but moved so that they are centred on the
#left and right edges. The offset values then move the uv mapping
#so the image is on the right of the left sprite and left of the
#right sprite
self.sprites.append(Sprite(z=20.0, w=ix, h=iy, flip=True))
if interlace <= 0:
self.sprites[i].positionX(-ix/2.0 + i*ix)
self.sprites[i].set_offset((i * 0.5 - 0.25, 0.0))
else:
self.sprites[i].set_2d_size(w=ix, h=iy)
self.textures[i].blend = True
self.textures[i].mipmap = mipmap
self.tex_list.append(self.textures[i])
opengles.glColorMask(1, 1, 1, 1)
def __init__(self, emap, light):
""" calls Texture.__init__ but doesn't need to set file name as
texture generated from the framebuffer
"""
super(ShadowCaster, self).__init__("shadow_caster")
from pi3d.Display import Display
self.ix, self.iy = Display.INSTANCE.width, Display.INSTANCE.height
self.im = Image.new("RGBA",(self.ix, self.iy))
self.image = self.im.convert("RGBA").tostring('raw', "RGBA")
self.alpha = True
self.blend = False
self._tex = ctypes.c_int()
self.framebuffer = (ctypes.c_int * 1)()
opengles.glGenFramebuffers(1, self.framebuffer)
self.depthbuffer = (ctypes.c_int * 1)()
opengles.glGenRenderbuffers(1, self.depthbuffer)
# load shader for casting shadows and camera
self.cshader = Shader("shaders/uv_flat")
self.mshader = Shader("shaders/mat_flat")
# keep copy of ElevationMap
self.emap = emap
self.emap.set_material((0.0, 0.0, 0.0)) # hide bits below ground
#TODO doesn't cope with z light positions
self.eye = [-500*i for i in light.lightpos] # good distance away
if self.eye[1] <= 0: # must have +ve y
self.eye[1] = 500.0
if abs(self.eye[0]) > abs(self.eye[2]): #x val is bigger than z val
#change scale so map just fits on screen
if self.eye[0] < 0:
su, sv = 1.0, 1.0
else:
su, sv = -1.0, -1.0
self.scaleu = float(self.iy) / self.emap.width
self.scalev = float(self.ix)/ self.emap.depth
self.eye[2] = 0
self.scaleu = self.scaleu / self.eye[1] * float(self.eye[0]**2 + self.eye[1]**2)**0.5
self.emap.unif[50] = 1.0 #orientation flag
self.emap.unif[53] = -3.0 * su / self.emap.width * self.eye[0] / float(self.eye[1]) #height adjustment
else:
#change scale so map just fits on screen
if self.eye[2] < 0:
su, sv = 1.0, -1.0
else:
su, sv = -1.0, 1.0
self.scaleu = float(self.iy) / self.emap.depth
self.scalev = float(self.ix)/ self.emap.width
self.eye[0] = 0
self.scaleu = self.scaleu / self.eye[1] * float(self.eye[2]**2 + self.eye[1]**2)**0.5
self.emap.unif[50] = 0.0
self.emap.unif[53] = -3.0 * su / self.emap.width * self.eye[2] / float(self.eye[1])
if abs(self.scaleu) > abs(self.scalev):
self.scale = 3.0 * self.scalev # multiplication factor to reduce pixeliness
else:
self.scale = 3.0 * self.scaleu
self.scaleu = su * self.scale / self.scaleu # reused later in end_cast
self.scalev = sv * self.scale / self.scalev
self.camera0 = Camera() # default instance created as normal, just in case!
self.camera = Camera(is_3d=False, eye=self.eye, scale=self.scale)
# load shader for drawing map with shadows
self.dshader = Shader("shaders/shadowcast")
from pi3d.Shader import Shader
from pi3d.util.String import String
from pi3d.util.Ttffont import Ttffont
from pi3d.util.Defocus import Defocus
from pi3d.util.Screenshot import screenshot
from pi3d.shape.MergeShape import MergeShape
from pi3d.shape.Sphere import Sphere
from pi3d.shape.Sprite import Sprite
# Setup display and initialise pi3d
DISPLAY = Display.create(x=10, y=10, w=900, h=600, frames_per_second=25)
DISPLAY.set_background(0.4, 0.6, 0.8, 1.0) # r,g,b,alpha
persp_cam = Camera.instance() # default instance camera perspecive view
ortho_cam = Camera(is_3d=False) # 2d orthographic view camera
#setup textures, light position and initial model position
Light((0, 5, 0))
#create shaders
shader = Shader("shaders/uv_reflect")
flatsh = Shader("shaders/uv_flat")
defocus = Defocus()
#Create textures
shapeimg = Texture("textures/straw1.jpg")
shapebump = Texture("textures/floor_nm.jpg", True)
shapeshine = Texture("textures/pong3.png")
#Create shape
myshape = MergeShape(camera=persp_cam) #specify perspective view
