def __init__(self, font, camera, max_chars=100, point_size=48): """ Arguments: *font*: A PointFont object. *camera*: camera to use for drawing the text. Normally a fixed 2d camera. *max_chars*: maximum number of chars, which determines the number of points in the buffer *point_size*: size of "default" characters created using the Points class and the font. This is further scaled by the TextBlock.size This refinement is needed to allow pointsize to be different in Points from Font to avoid clipping or overlap of corners when rotation some truetype fonts """ self.max_chars = max_chars self.font = font self.shader = Shader.create("uv_pointsprite") self.locations = np.zeros((max_chars, 3)) # :,2 for size and z offset. # size=fract(location[2] range 0.0 to 0.999) # zoffset = (location[2] - size)*0.1 self.normals = np.zeros((max_chars, 3)) # :,0 for rotation # :,1 for red and green, red=normal[1]/999, green=fract(normal[1]) # :,2 for blue and alpha, blue=normal[2]/999, alpha=fract(normal[2]) self.normals[:, 1] = 0.0 self.normals[:, 2] = 0.0 self.uv = np.zeros((max_chars, 2)) # u picnum.u v self.text_blocks = [] self._first_free_char = 0 self._do_buffer_reinit = False self.point_size = point_size self.text = Points(camera=camera, vertices=self.locations, normals=self.normals, tex_coords=self.uv, point_size=self.point_size) self.text.set_draw_details(self.shader, [self.font]) self.text.unif[ 48] = 0.928 / self.font.grid_size # used to hold "patch size" passed to shader - margin to allow rotating #Reset all characters to space so there are no false character shadows try: glyph = self.font.glyph_table[ ' '] #u' ' doesn't work on python3.2!! except: glyph = list( self.font.glyph_table.values())[0] #in case ' ' isn't there self.uv[:] = glyph[0:2]
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 if type(shader) == Shader: self.shader = shader else: self.shader = Shader.create(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(camera=self.camera, z=20.0, w=self.ix, h=self.iy, n=divide) self.sprite.set_2d_size(w=self.ix, h=self.iy) self.tex_list = [ self.color, self.depth ] # TODO check if this self reference causes graphics memory leaks if add_tex: self.tex_list.extend(add_tex) self.sprite.set_draw_details(self.shader, self.tex_list, 0.0, 0.0) 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
def __init__(self, pex_file, emission_rate=10, scale=1.0, rot_rate=None, rot_var=0.0, new_batch=0.1, hardness=2.0, **kwargs): ''' has to be supplied with a pex xml type file to parse. The results are loaded into new attributes of the instance of this class with identifiers matching the Elements of the pex file. There is zero checking for the correct file format. pex_file: file name. if "circle" then lite option doesn't use texture lookup and used mat_pointsprite shader emission_rate: new particles per second scale: scale the point size and location rot_rate: UV mapping rotates rot_var: variance in rotation rate new_batch: proportion of emission_rate to batch (for efficiency) hardness: for lite version The following attributes are created from the pex file and can be subsequently altered. i.e. self.sourcePosition['x'] += 2.0 self.texture={name:'particle.png'} self.sourcePosition={x:160.00,y:369.01} self.sourcePositionVariance={x:60.00,y:0.00} self.speed=138.16 self.speedVariance=0.00 self.particleLifeSpan=0.7000 self.particleLifespanVariance=0.0000 self.angle=224.38 self.angleVariance=360.00 self.gravity={x:0.00,y:-1400.00} self.radialAcceleration=0.00 self.tangentialAcceleration=0.00 self.radialAccelVariance=0.00 self.tangentialAccelVariance=-0.00 self.startColor={red:0.15,green:0.06,blue:1.00,alpha:1.00} self.startColorVariance={red:0.00,green:0.00,blue:0.00,alpha:0.00} self.finishColor={red:0.00,green:0.14,blue:0.23,alpha:0.00} self.finishColorVariance={red:0.00,green:0.00,blue:0.00,alpha:0.00} self.maxParticles=300 self.startParticleSize=43.79 self.startParticleSizeVariance=0.00 self.finishParticleSize=138.11 self.FinishParticleSizeVariance=0.00 self.duration=-1.00 self.emitterType=0 self.maxRadius=100.00 self.maxRadiusVariance=0.00 self.minRadius=0.00 self.rotatePerSecond=0.00 self.rotatePerSecondVariance=0.00 self.blendFuncSource=770 self.blendFuncDestination=772 self.rotationStart=0.00 self.rotationStartVariance=0.00 self.rotationEnd=0.00 self.rotationEndVariance=0.00 ''' # first parse the pex file, json would have been nicer than xml! _config = parse(pex_file).childNodes[0].childNodes for c in _config: if c.localName is not None: key = c.localName val = {} for v in c.attributes.items(): try: v_tp = int(v[1]) # try int first except ValueError: try: v_tp = float(v[1]) # if not try float except ValueError: v_tp = v[1] # otherwise leave as string if v[0] == 'value': # single value 'value' don't use dictionary val = v_tp break else: val[v[0]] = v_tp # not just a value self.__setattr__(key, val) self._emission_rate = emission_rate # particles per second self._last_emission_time = None self._last_time = None self._new_batch = emission_rate * new_batch # to clump new particles self.scale = scale self.rot_rate = rot_rate self.rot_var = rot_var # make a flag to avoid this expensive operation if no accelerators self.any_acceleration = (self.gravity['x'] != 0.0 or self.gravity['y'] != 0.0 or self.radialAcceleration != 0.0 or self.tangentialAcceleration != 0.0) self.any_colorchange = any(self.startColor[i] != self.finishColor[i] for i in ('red', 'green', 'blue', 'alpha')) ''' Buffer.array_buffer holds [0] vertices[0] x position of centre of point relative to centre of screen in pixels [1] vertices[1] y position [2] vertices[2] z depth but fract(z) is used as a multiplier for point size [3] normals[0] rotation in radians [4] normals[1] red and green values to multiply with the texture [5] normals[2] blue and alph values to multiply with the texture. The values are packed into the whole number and fractional parts of the float i.e. where R and G are between 0.0 and 0.999 normals[:,2] = floor(999 * R) + G [6] tex_coords[0] distance of left side of sprite square from left side of texture in uv scale 0.0 to 1.0 [7] tex_coords[1] distance of top of sprite square from top of texture for lite version using the mat_pointsprite shader [3:7] hold RGBA in simple float form make additional numpy array to hold the particle info arr[0] x velocity arr[1] y velocity arr[2] lifespan arr[3] lifespan remaining arr[4:8] rgba target values arr[8:12] rgba difference arr[12] size delta (finish size - start size) / full_lifespan arr[13] radial acceleration arr[14] tangential acceleration ''' self.arr = np.zeros((self.maxParticles, 15), dtype='float32') self.point_size = max(self.startParticleSize + self.startParticleSizeVariance, self.finishParticleSize + self.FinishParticleSizeVariance) #NB capital F! super(PexParticles, self).__init__(vertices=np.zeros((self.maxParticles, 3), dtype='float32'), normals=np.zeros((self.maxParticles, 3), dtype='float32'), tex_coords=np.zeros((self.maxParticles, 2), dtype='float32'), point_size=self.point_size * self.scale, **kwargs) # pass to Points.__init__() if self.texture['name'] == 'circle': # TODO alternative geometries self.lite = True shader = Shader.create('mat_pointsprite') self.set_shader(shader) self.buf[0].unib[0] = hardness else: self.lite = False shader = Shader.create('uv_pointsprite') try: tex = Texture(self.texture['name']) # obvious first! except: import os tex = Texture( os.path.join( os.path.split(pex_file)[0], self.texture['name'])) self.set_draw_details(shader, [tex]) self.unif[48] = 1.0 # sprite uses whole image
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)