def __init__(self,
parent,
offset=(0, 0, 0),
value=1,
fgColor=(1, 1, 1, 1),
bgColor=(0, 0, 0, 1)):
self.scale = UI_BAR_SCALE
NodePath.__init__(self, 'bar')
# Create the foreground rect:
cmfg = CardMaker('fg')
cmfg.setFrame(-self.scale, self.scale, -0.1 * self.scale,
0.1 * self.scale)
self.fg = self.attachNewNode(cmfg.generate())
# Create the background rect:
cmbg = CardMaker('bg')
cmbg.setFrame(-self.scale, self.scale, -0.1 * self.scale,
0.1 * self.scale)
self.bg = self.attachNewNode(cmbg.generate())
"""# Create the preview rect:
cmpv = CardMaker('pv')
cmpv.setFrame(-self.scale, self.scale,
-0.1 * self.scale, 0.1 * self.scale)
self.pv = self.attachNewNode(cmpv.generate())"""
# Set colors and values:
self.fg.setColor(*fgColor)
self.bg.setColor(*bgColor)
"""self.pv.setColor(*pvColor)"""
self.setValue(value)
# Set this bar to follow the transform of the parent.
self.reparentTo(parent)
# Offset this bar (most likely to above the parent)
self.setPos(parent, offset)
# Make this bar face the camera at all times (bill-boarding):
self.setBillboardPointEye()
def __init__(self, world, app):
self.world = world
self.image = PNMImage(self.world.width, 256)
for z in self.world.zlevels():
for x in range(self.world.height):
mix = sum([ZMap.COLORS[self.world.get_block(x, y, z).substance]
for y in range(self.world.height)], VBase3F(0.0))
self.image.setXel(x, z, mix / float(self.world.height))
self.texture = Texture()
self.texture.load(self.image)
self.texture.setMagfilter(Texture.FTNearest)
self.texture.setMinfilter(Texture.FTNearest)
cm = CardMaker('zmap')
cm.setFrame(0.95, 1, -1, 1)
cm.setUvRange(Point2(1.0, 1.0), Point2(0.0, 1.0 - self.world.depth / 256.0))
self.zcard = app.render2d.attachNewNode(cm.generate())
self.zcard.setTexture(self.texture)
cm = CardMaker('zpointer')
cm.setFrame(0, 0.05, 0, 1.0 / self.world.depth)
self.zpointer = app.render2d.attachNewNode(cm.generate())
self.zpointer.setColorScale(1.0, 0.0, 0.0, 0.4)
self.accept('slice-changed', self.slice_changed)
def __init__(self, scale=1, value=0, r=10, g=0, b=0):
NodePath.__init__(self, 'healthbar')
self.value = value
self.scale = scale
self.range = 1.0
self.buff = 0
cmbg = CardMaker('bg')
cmbg.setFrame(-scale, scale, -0.1 * scale, 0.1 * scale)
self.bg = self.attachNewNode(cmbg.generate())
self.bg.setColor(0.2, 0.2, 0.2, 1)
self.bg.setPos(0, 0, 5.8)
cmfg = CardMaker('fg')
cmfg.setFrame(-scale, scale, -0.1 * scale, 0.1 * scale)
self.fg = self.bg.attachNewNode(cmfg.generate())
self.fg.setColor(r, g, b, 1)
self.fg.setPos(0, -0.1, 0)
self.fg.setBillboardPointWorld()
self.bg.setBillboardPointWorld()
self.fg.clearShader()
self.bg.clearShader()
self.setValue(0)
def __init__(self, pg_world: PGWorld):
if pg_world.win is None:
return
self.aspect2d_np = NodePath(PGTop("aspect2d"))
self.aspect2d_np.show(self.CAM_MASK)
self.para_vis_np = {}
# make_buffer_func, make_camera_func = pg_world.win.makeTextureBuffer, pg_world.makeCamera
# don't delete the space in word, it is used to set a proper position
for i, np_name in enumerate(
["Steering", " Throttle", " Brake", " Speed"]):
text = TextNode(np_name)
text.setText(np_name)
text.setSlant(0.1)
textNodePath = self.aspect2d_np.attachNewNode(text)
textNodePath.setScale(0.052)
text.setFrameColor(0, 0, 0, 1)
text.setTextColor(0, 0, 0, 1)
text.setFrameAsMargin(-self.GAP, self.PARA_VIS_LENGTH, 0, 0)
text.setAlign(TextNode.ARight)
textNodePath.setPos(-1.125111, 0, 0.9 - i * 0.08)
if i != 0:
cm = CardMaker(np_name)
cm.setFrame(0, self.PARA_VIS_LENGTH - 0.21,
-self.PARA_VIS_HEIGHT / 2 + 0.1,
self.PARA_VIS_HEIGHT / 2)
cm.setHasNormals(True)
card = textNodePath.attachNewNode(cm.generate())
card.setPos(0.21, 0, 0.22)
self.para_vis_np[np_name.lstrip()] = card
else:
# left
name = "Left"
cm = CardMaker(name)
cm.setFrame(0, (self.PARA_VIS_LENGTH - 0.4) / 2,
-self.PARA_VIS_HEIGHT / 2 + 0.1,
self.PARA_VIS_HEIGHT / 2)
cm.setHasNormals(True)
card = textNodePath.attachNewNode(cm.generate())
card.setPos(0.2 + self.PARA_VIS_LENGTH / 2, 0, 0.22)
self.para_vis_np[name] = card
# right
name = "Right"
cm = CardMaker(np_name)
cm.setFrame(-(self.PARA_VIS_LENGTH - 0.1) / 2, 0,
-self.PARA_VIS_HEIGHT / 2 + 0.1,
self.PARA_VIS_HEIGHT / 2)
cm.setHasNormals(True)
card = textNodePath.attachNewNode(cm.generate())
card.setPos(0.2 + self.PARA_VIS_LENGTH / 2, 0, 0.22)
self.para_vis_np[name] = card
super(VehiclePanel, self).__init__(self.BUFFER_W,
self.BUFFER_H,
Vec3(-0.9, -1.01, 0.78),
self.BKG_COLOR,
pg_world=pg_world,
parent_node=self.aspect2d_np)
self.add_to_display(pg_world,
[2 / 3, 1, self.display_bottom, self.display_top])
def setup_skybox(self,
terrctr=645.0,
boxsz=1000.0,
aspect=1.0,
uplift=0.0):
vsz = boxsz / aspect
self.bckgtx = []
self.bckgtx.append(self.loader.loadTexture('sky/Back2.png'))
self.bckgtx.append(self.loader.loadTexture('sky/Right2.png'))
self.bckgtx.append(self.loader.loadTexture('sky/Front2.png'))
self.bckgtx.append(self.loader.loadTexture('sky/Left2.png'))
self.bckgtx.append(self.loader.loadTexture('sky/Up.png'))
for a in range(4):
self.bckg = CardMaker('bkcard')
lr = Point3(0.5 * boxsz, 0.5 * boxsz, -0.5 * vsz)
ur = Point3(0.5 * boxsz, 0.5 * boxsz, 0.5 * vsz)
ul = Point3(-0.5 * boxsz, 0.5 * boxsz, 0.5 * vsz)
ll = Point3(-0.5 * boxsz, 0.5 * boxsz, -0.5 * vsz)
self.bckg.setFrame(ll, lr, ur, ul)
self.bckg.setHasNormals(0)
self.bckg.setHasUvs(1)
#self.bckg.setUvRange(self.bckgtx[a])
bkcrd = self.render.attachNewNode(self.bckg.generate())
bkcrd.setTexture(self.bckgtx[a])
self.bckgtx[a].setWrapU(Texture.WMClamp)
self.bckgtx[a].setWrapV(Texture.WMClamp)
bkcrd.setLightOff()
bkcrd.setFogOff()
bkcrd.setHpr(90.0 * a, 0, 0)
cz = 0.5 * boxsz * uplift
#print 'set card at:', terrctr,terrctr,cz, ' with points: ', lr,ur,ul,ll
bkcrd.setPos(terrctr, terrctr, cz)
self.top = CardMaker('bkcard')
lr = Point3(0.5 * boxsz, -0.5 * boxsz, 0)
ur = Point3(0.5 * boxsz, 0.5 * boxsz, 0)
ul = Point3(-0.5 * boxsz, 0.5 * boxsz, 0)
ll = Point3(-0.5 * boxsz, -0.5 * boxsz, 0)
self.top.setFrame(ll, lr, ur, ul)
self.top.setHasNormals(0)
self.top.setHasUvs(1)
#self.top.setUvRange(self.bckgtx[4])
bkcrd = self.render.attachNewNode(self.bckg.generate())
bkcrd.setTexture(self.bckgtx[4])
self.bckgtx[4].setWrapU(Texture.WMClamp)
self.bckgtx[4].setWrapV(Texture.WMClamp)
bkcrd.setLightOff()
bkcrd.setFogOff()
bkcrd.setHpr(0, 90, 90)
bkcrd.setPos(terrctr, terrctr, 0.5 * vsz + 0.5 * boxsz * uplift)
def _initModel(self):
baseName = '**/tt_t_gui_cmg_miniMap_'
cardModel = CogdoUtil.loadMazeModel('miniMap_cards', group='gui')
cm = CardMaker('bg')
cm.setFrame(-1.1, 1.1, -1.1, 1.1)
bg = self.attachNewNode(cm.generate())
bg.setColor(*self._bgColor)
bg.setBin('fixed', 0)
frame = cardModel.find(baseName + 'frame')
frame.reparentTo(self)
frame.setScale(2.5)
frame.setPos(0.01, 0, -0.01)
self._entrance = cardModel.find(baseName + 'entrance')
self._entrance.reparentTo(self)
self._entrance.setScale(0.35)
self._entrance.hide()
self._exit = NodePath('exit')
self._exit.setScale(0.35)
self._exit.reparentTo(self)
self._exitOpen = cardModel.find(baseName + 'exitOpen')
self._exitOpen.reparentTo(self._exit)
self._exitClosed = cardModel.find(baseName + 'exitClosed')
self._exitClosed.reparentTo(self._exit)
self._suitMarkerTemplate = cardModel.find(baseName + 'cogIcon')
self._suitMarkerTemplate.detachNode()
self._suitMarkerTemplate.setScale(0.225)
self._waterCoolerTemplate = cardModel.find(baseName + 'waterDrop')
self._waterCoolerTemplate.detachNode()
self._waterCoolerTemplate.setScale(0.225)
self._exit.hide()
cardModel.removeNode()
def announceGenerate(self):
DistributedObject.DistributedObject.announceGenerate(self)
self.sendUpdate('avIdEnteredParty', [base.localAvatar.doId])
globalClock.syncFrameTime()
self.startPartyClock()
base.localAvatar.chatMgr.chatInputSpeedChat.addInsidePartiesMenu()
self.spawnTitleText()
messenger.send(self.generatedEvent)
if config.GetBool('show-debug-party-grid', 0):
self.testGrid = NodePath('test_grid')
self.testGrid.reparentTo(base.cr.playGame.hood.loader.geom)
for i in xrange(len(self.grid)):
for j in xrange(len(self.grid[i])):
cm = CardMaker('gridsquare')
np = NodePath(cm.generate())
np.setScale(12)
np.setP(-90.0)
np.setPos(
PartyUtils.convertDistanceFromPartyGrid(j, 0) - 6.0,
PartyUtils.convertDistanceFromPartyGrid(i, 1) - 6.0,
0.1)
np.reparentTo(self.testGrid)
if self.grid[i][j]:
np.setColorScale(0.0, 1.0, 0.0, 1.0)
else:
np.setColorScale(1.0, 0.0, 0.0, 1.0)
def __init__(self, texture_cube, window_size=512, texture_size=512):
super().__init__()
self.cube_ind = 0
self.num_slices = texture_cube.shape[0]
self.cube = texture_cube
# SET Frame rate
ShowBaseGlobal.globalClock.setMode(ClockObject.MLimited)
ShowBaseGlobal.globalClock.setFrameRate(40) #can lock this at
#Create texture stage
self.texture = Texture("Stimulus")
# self.texture.setMagfilter(SamplerState.FT_nearest)
# self.texture.setMinfilter(SamplerState.FT_nearest)
self.texture.setup2dTexture(texture_size, texture_size,
Texture.T_unsigned_byte,
Texture.F_luminance)
self.texture.setRamImageAs(self.cube[0, :, :], "L")
self.textureStage = TextureStage("Stimulus")
#Create scenegraph
cm = CardMaker('card1')
cm.setFrameFullscreenQuad()
self.card1 = self.aspect2d.attachNewNode(cm.generate())
self.card1.setTexture(self.textureStage, self.texture) #ts, tx
ShowBaseGlobal.base.setFrameRateMeter(True)
self.taskMgr.add(self.setTextureTask, "setTextureTask")
def loadVideo(videoFileName, loop=False):
videoPathStr = 'Video/{}'
videoPathStr = videoPathStr.format(videoFileName)
try:
tex = MovieTexture(videoFileName)
success = tex.read(videoPathStr)
assert success, "Failed to load video!"
# Set up a fullscreen card to set the video texture on.
cm = CardMaker("My Fullscreen Card")
cm.setFrameFullscreenQuad()
# Tell the CardMaker to create texture coordinates that take into
# account the padding region of the texture.
cm.setUvRange(tex)
# Now place the card in the scene graph and apply the texture to it.
card = render2d.attachNewNode(cm.generate())
card.setTexture(tex)
card.hide()
sound = loader.loadMusic(videoPathStr)
# set loop false
sound.setLoop(loop)
# Synchronize the video to the sound.
tex.synchronizeTo(sound)
return sound, card
except Exception as e:
#logging.debug("loadvideo: {}".format(traceback.format_exc()))
pass
return sound, card
def _createMapTextureCard(self):
mapImage = PNMImage(MAP_RESOLUTION, MAP_RESOLUTION)
mapImage.fill(*self._bgColor)
fgColor = VBase4D(*self._fgColor)
for x in range(self._mazeHeight):
for y in range(self._mazeWidth):
if self._mazeCollTable[y][x] == 1:
ax = float(x) / self._mazeWidth * MAP_RESOLUTION
invertedY = self._mazeHeight - 1 - y
ay = float(invertedY) / self._mazeHeight * MAP_RESOLUTION
self._drawSquare(mapImage, int(ax), int(ay), 10, fgColor)
mapTexture = Texture('mapTexture')
mapTexture.setupTexture(Texture.TT2dTexture, self._maskResolution,
self._maskResolution, 1, Texture.TUnsignedByte,
Texture.FRgba)
mapTexture.setMinfilter(Texture.FTLinear)
mapTexture.load(mapImage)
mapTexture.setWrapU(Texture.WMClamp)
mapTexture.setWrapV(Texture.WMClamp)
mapImage.clear()
del mapImage
cm = CardMaker('map_cardMaker')
cm.setFrame(-1.0, 1.0, -1.0, 1.0)
map = self.attachNewNode(cm.generate())
map.setTexture(mapTexture, 1)
return map
def cardmaker_debug(self):
for node in render2d.find_all_matches("pfm"):
node.remove_node()
for text in base.a2dBottomLeft.find_all_matches("*"):
text.remove_node()
width = 0.2 # render2d coordinates range: [-1..1]
# Pseudo-normalize our PfmFile for better contrast.
normalized_pfm = PfmFile(self.RotorPFM)
max_p = LVector3()
normalized_pfm.calc_min_max(LVector3(), max_p)
normalized_pfm *= 1.0 / max_p.x
# Put it in a texture
tex = Texture()
tex.load(normalized_pfm)
# Apply the texture to a quad and put it in the lower left corner.
cm = CardMaker("pfm")
cm.set_frame(0, width, 0,
width / normalized_pfm.get_x_size() * normalized_pfm.get_y_size())
card = base.render2d.attach_new_node(cm.generate())
card.set_pos(-1, 0, -1)
card.set_texture(tex)
# Display max value text
self.genLabelText(-3,
"Max value: {:.3f} == {:.2f}m".format(max_p.x,
max_p.x * self.terrain_scale.z),
parent="a2dBottomLeft")
def create_geom(self, loader):
"""Creates self.geom_node from self.terrain_map."""
# geom_builder = GeomBuilder('floor')
map_size = len(self.terrain_map)
unit_size = map_params.unit_size
start_pos = -map_size*unit_size/2
# colors = map_params.colors
# geom_builder.add_rect(
# colors.floor,
# start_pos, start_pos, 0,
# -start_pos, -start_pos, 0
# )
card_maker = CardMaker("cm")
card_maker.setFrame(
Point3(-start_pos, -start_pos, 0),
Point3(+start_pos, -start_pos, 0),
Point3(+start_pos, +start_pos, 0),
Point3(-start_pos, +start_pos, 0)
)
card_maker.setColor(map_params.colors.floor)
floor_node = NodePath(card_maker.generate())
floor_node.reparentTo(self.geom_node)
# floor_node.setHpr(0, 90, 0)
# floor_node.setPos(0, 0, 0)
tex = loader.loadTexture('models/floor.png')
floor_node.setTexture(tex, 1)
floor_node.setTexScale(TextureStage.getDefault(), map_size, map_size)
def get(i, j):
return isinstance(self.get_tile(i, j), Wall)
wall_count = 0
for i in range(map_size-1):
for j in range(map_size-1):
if any([get(i, j), get(i+1, j), get(i+1, j+1), get(i, j+1)]):
wall_count += 1
def callback():
self.geom_node.clearModelNodes()
self.geom_node.flattenStrong()
threads = Threads(wall_count, callback)
for i in range(map_size-1):
for j in range(map_size-1):
current_position = (
start_pos+i*unit_size,
start_pos+j*unit_size, 0
)
render_wall(
current_position,
[get(i, j), get(i+1, j),
get(i+1, j+1), get(i, j+1)],
((i+j) & 1)+1,
self.geom_node,
loader,
threads
)
def scene_init(self, render, loader):
# self.scene = self.loader.loadModel("models/environment")
# self.scene.reparentTo(self.render)
# region texture
floor_texture = loader.loadTexture("models/maps/envir-ground.jpg")
floor_texture.setMinfilter(SamplerState.FT_linear_mipmap_linear)
wall_texture = loader.loadTexture("models/maps/envir-reeds.png")
# endregion
# region floor
floor_card_maker = CardMaker("floor")
floor_card_maker.setUvRange((0, 0), (self.size / 10, self.size / 10))
floor_gfx = render.attachNewNode(CardMaker.generate(floor_card_maker))
floor_gfx.setP(-90) # This rotates the card to face upwards
floor_gfx.setPos(-self.size / 2, -self.size / 2, 0)
floor_gfx.setScale(self.size)
floor_gfx.setTexture(floor_texture)
# endregion
# region walls
self.create_wall(render, wall_texture, -90, 0, 0)
self.create_wall_collider(render, 0, 1, -180)
self.create_wall(render, wall_texture, 0, 90, -90)
self.create_wall_collider(render, 0, -1, 0)
self.create_wall(render, wall_texture, 90, -90, -180)
self.create_wall_collider(render, 1, 0, 90)
self.create_wall(render, wall_texture, -90, -90, -270)
self.create_wall_collider(render, -1, 0, -90)
def renderQuadInto(self, mul=1, div=1, align=1, depthtex=None, colortex=None, auxtex0=None, auxtex1=None):
texgroup = (
depthtex, colortex, auxtex0, auxtex1)
winx, winy = self.getScaledSize(mul, div, align)
depthbits = bool(depthtex != None)
buffer = self.createBuffer('filter-stage', winx, winy, texgroup, depthbits)
if buffer == None:
return
cm = CardMaker('filter-stage-quad')
cm.setFrameFullscreenQuad()
quad = NodePath(cm.generate())
quad.setDepthTest(0)
quad.setDepthWrite(0)
quad.setColor(1, 0.5, 0.5, 1)
quadcamnode = Camera('filter-quad-cam')
lens = OrthographicLens()
lens.setFilmSize(2, 2)
lens.setFilmOffset(0, 0)
lens.setNearFar(-1000, 1000)
quadcamnode.setLens(lens)
quadcam = quad.attachNewNode(quadcamnode)
dr = buffer.makeDisplayRegion((0, 1, 0, 1))
dr.disableClears()
dr.setCamera(quadcam)
dr.setActive(True)
dr.setScissorEnabled(False)
buffer.setClearColor((0, 0, 0, 1))
buffer.setClearColorActive(True)
self.buffers.append(buffer)
self.sizes.append((mul, div, align))
return quad
def buildShadow(self):
self.cleanupShadow()
if not self.dropShadowPath or not self.avatar: return
self.dropShadow = NodePath('locationIndicatorRoot')
cm = CardMaker('locationIndicator')
cm.setFrame(-1, 1, -1, 1)
indicatorNP = self.dropShadow.attachNewNode(cm.generate())
indicatorNP.setBSPMaterial(self.crosshairMaterial, 1)
indicatorNP.setScale(self.shadowScale * 2.5)
indicatorNP.setDepthOffset(16)
indicatorNP.setTransparency(1)
indicatorNP.setP(-90)
indicatorNP.flattenStrong()
self.confirmIndTrack = Sequence(
Parallel(
LerpHprInterval(self.dropShadow,
duration=0.2,
hpr=(360, 0, 0),
startHpr=(0, 0, 0)),
LerpScaleInterval(self.dropShadow,
duration=0.2,
scale=0.01,
startScale=1)),
Func(self.gag.cleanupLocationSeeker))
def __init__(self, experiment_structure, profile_on=False):
super().__init__()
self.current_stim_num = 0
self.stim_classes = experiment_structure['stim_classes']
self.stim_values = experiment_structure['stim_values']
self.stim_durations = experiment_structure['stim_durations']
self.stim_change_times = np.cumsum(
self.stim_durations) #times to switch
self.bgcolor = (1, 1, 1, 1)
#Set up profiling if desired
if profile_on:
PStatClient.connect()
#Window properties
self.windowProps = WindowProperties()
self.windowProps.setSize(512, 512)
#Create scenegraph
cm = CardMaker('card')
cm.setFrameFullscreenQuad()
self.card = self.aspect2d.attachNewNode(cm.generate())
self.card.setScale(np.sqrt(8))
self.card.setColor(self.bgcolor) #make this an add mode
#Set initial texture
self.taskMgr.add(self.set_stim_task, "set_stimulus_class")
def __init__(self, startSize, endSize, roll, color, duration):
NodePath.__init__(self, 'muzzleParticle')
cm = CardMaker("muzzleSpriteCard")
cm.setFrame(-1, 1, -1, 1)
cm.setHasUvs(True)
cm.setUvRange((0, 0), (1, 1))
cmnp = self.attachNewNode(cm.generate())
cmnp.setBillboardAxis()
self.setTexture(loader.loadTexture(self.muzzleroot.format(random.randint(*self.muzzles))), 1)
#self.setShaderOff(1)
self.setLightOff(1)
self.setMaterialOff(1)
self.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.OOne, ColorBlendAttrib.OOne), 1)
self.setDepthWrite(False, 1)
#self.setTransparency(1)
self.startAlpha = 0.5
self.endAlpha = 0.0
self.duration = duration
self.startSize = startSize
self.endSize = endSize
self.color = color
self.startTime = globalClock.getFrameTime()
self.roll = roll
taskMgr.add(self.particleUpdate, "muzzleParticleUpdate-" + str(id(self)))
def draw_floor(self):
# Load the scene.
# if self.box.dimensions < 3:
# return
floorTex = self.loader.loadTexture('maps/grid.jpg')
cm = CardMaker('')
# cm.setFrame(-2, 2, -2, 2)
X = self.box.box_sizes[0]
if self.box.dimensions > 1:
Y = self.box.box_sizes[1]
else:
Y = X
cm.setFrame(0, X, 0, Y)
# cm.setFrame(0, 0, self.box.box_sizes[0], self.box.box_sizes[1])
floor = self.render.attachNewNode(PandaNode("floor"))
floor.reparentTo(self.boxnode)
for y in range(1):
for x in range(1):
nn = floor.attachNewNode(cm.generate())
nn.setP(-90)
# nn.setPos((x - 6) * 4, (y - 6) * 4, 0)
nn.setPos((x - 0) * 4, (y - 0) * 4, 0)
floor.setTexture(floorTex)
floor.flattenStrong()
floor.setTwoSided(True)
def setupTexture(self):
cm = CardMaker('quadMaker')
cm.setColor(1.0, 1.0, 1.0, 1.0)
aspect = base.camLens.getAspectRatio()
htmlWidth = 2.0 * aspect * WEB_WIDTH_PIXELS / float(WIN_WIDTH)
htmlHeight = 2.0 * float(WEB_HEIGHT_PIXELS) / float(WIN_HEIGHT)
cm.setFrame(-htmlWidth / 2.0, htmlWidth / 2.0, -htmlHeight / 2.0, htmlHeight / 2.0)
bottomRightX = WEB_WIDTH_PIXELS / float(WEB_WIDTH + 1)
bottomRightY = WEB_HEIGHT_PIXELS / float(WEB_HEIGHT + 1)
cm.setUvRange(Point2(0, 1 - bottomRightY), Point2(bottomRightX, 1))
card = cm.generate()
self.quad = NodePath(card)
self.quad.reparentTo(self.parent_)
self.guiTex = Texture('guiTex')
self.guiTex.setupTexture(Texture.TT2dTexture, WEB_WIDTH, WEB_HEIGHT, 1, Texture.TUnsignedByte, Texture.FRgba)
self.guiTex.setMinfilter(Texture.FTLinear)
self.guiTex.setKeepRamImage(True)
self.guiTex.makeRamImage()
self.guiTex.setWrapU(Texture.WMRepeat)
self.guiTex.setWrapV(Texture.WMRepeat)
ts = TextureStage('webTS')
self.quad.setTexture(ts, self.guiTex)
self.quad.setTexScale(ts, 1.0, -1.0)
self.quad.setTransparency(0)
self.quad.setTwoSided(True)
self.quad.setColor(1.0, 1.0, 1.0, 1.0)
self.calcMouseLimits()
def enterShow(self, ts=0):
self.darkenInterior()
self.cr.playGame.hood.loader.interiorMusic.stop()
videoFile = CinemaGlobals.Cinemas[self.cinemaIndex][0]
audioFile = CinemaGlobals.Cinemas[self.cinemaIndex][1]
self.movieTex = MovieTexture(self.uniqueName("movieTex"))
self.movieTex.read(videoFile)
card = CardMaker(self.uniqueName('movieCard'))
card.setFrame(-1.5, 1.5, -1, 1)
self.movieCard = NodePath(card.generate())
self.movieCard.reparentTo(render)
self.movieCard.setPos(
self.interior.find('**/sign_origin;+s').getPos(render))
#self.movieCard.setX(self.movieCard, -0.05)
self.movieCard.setHpr(
self.interior.find('**/sign_origin;+s').getHpr(render))
self.movieCard.setDepthWrite(1, 1)
self.movieCard.setTwoSided(True)
self.movieCard.setTexture(self.movieTex)
self.movieCard.setTexScale(TextureStage.getDefault(),
self.movieTex.getTexScale())
self.movieCard.setScale(2.5)
self.movieSound = base.loadSfx(audioFile)
self.movieTex.synchronizeTo(self.movieSound)
self.movieTrack = SoundInterval(self.movieSound,
name=self.uniqueName('movieTrack'))
self.movieTrack.setDoneEvent(self.movieTrack.getName())
self.acceptOnce(self.movieTrack.getDoneEvent(), self.fsm.request,
['off'])
self.movieTrack.start(ts)
def load(self):
Entity.load(self)
scale = self.getEntityValueFloat("spriteScale")
color = self.getEntityValueColor("spriteColor")
sunVec = base.shaderGenerator.getSunVector()
self.pivotNode = camera.attachNewNode('env_sun-pivot')
self.pivotNode.lookAt(sunVec)
self.pivotNode.setCompass()
cm = CardMaker('sun_sprite')
cm.setFrame(-0.5, 0.5, -0.5, 0.5)
self.sunSprite = self.pivotNode.attachNewNode(
GlowNode(cm.generate(), 32.0 * scale))
self.sunSprite.setAttrib(
ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.OOne,
ColorBlendAttrib.OOne), 1)
self.sunSprite.setBSPMaterial("phase_14/materials/sun/sunsprite.mat",
1)
self.sunSprite.setFogOff(10)
self.sunSprite.setBillboardPointEye()
self.sunSprite.setDepthTest(False)
self.sunSprite.setDepthWrite(False)
self.sunSprite.setScale(scale * 100)
self.sunSprite.setColorScale(color, 1)
self.sunSprite.setY(1000)
self.sunSprite.node().setBounds(OmniBoundingVolume())
self.sunSprite.node().setFinal(True)
def __init__(self, startSize, endSize, roll, color, duration):
NodePath.__init__(self, 'muzzleParticle')
muzzles = [1, 4]
muzzleroot = "phase_14/hl2/muzzleflash{0}.png"
cm = CardMaker("muzzleSpriteCard")
cm.setFrame(-1, 1, -1, 1)
cm.setHasUvs(True)
cm.setUvRange((0, 0), (1, 1))
cmnp = self.attachNewNode(cm.generate())
cmnp.setBillboardAxis()
self.setTexture(loader.loadTexture(muzzleroot.format(random.randint(*muzzles))), 1)
#self.setShaderOff(1)
self.setLightOff(1)
self.setMaterialOff(1)
self.setTransparency(1)
self.startAlpha = 0.5
self.endAlpha = 0.0
self.duration = duration
self.startSize = startSize
self.endSize = endSize
self.color = color
self.startTime = globalClock.getFrameTime()
self.roll = roll
taskMgr.add(self.particleUpdate, "muzzleParticleUpdate-" + str(id(self)))
def _createSimpleMarker(self, size, color=(1, 1, 1)):
halfSize = size * 0.5
cm = CardMaker('mazemap_simple_marker')
cm.setFrame(-halfSize, halfSize, -halfSize, halfSize)
markerNP = self.maskedLayer.attachNewNode(cm.generate())
markerNP.setColor(*color)
return markerNP
def genArrow(self, pos, hpr, id):
factory = CardMaker('factory')
factory.setFrame(-0.5, 0.5, -0.5, 0.5)
arrowNode = factory.generate()
arrowRoot = NodePath('root')
baseArrow = NodePath(arrowNode)
baseArrow.setTransparency(1)
baseArrow.setTexture(self.boostArrowTexture)
baseArrow.reparentTo(arrowRoot)
arrow2 = baseArrow.copyTo(baseArrow)
arrow2.setPos(0, 0, 1)
arrow3 = arrow2.copyTo(arrow2)
arrowRoot.setPos(*pos)
arrowRoot.setHpr(*hpr)
baseArrow.setHpr(0, -90, 0)
baseArrow.setScale(24)
arrowRoot.reparentTo(self.geom)
trigger = 'boostArrow' + str(id)
cs = CollisionTube(Point3(0.6, -6, 0), Point3(0.6, 54, 0), 4.8)
cs.setTangible(0)
triggerEvent = 'imIn-' + trigger
cn = CollisionNode(trigger)
cn.addSolid(cs)
cn.setIntoCollideMask(BitMask32(32768))
cn.setFromCollideMask(BitMask32(32768))
cnp = NodePath(cn)
cnp.reparentTo(arrowRoot)
self.accept(triggerEvent, self.hitBoostArrow)
arrowVec = arrow2.getPos(self.geom) - baseArrow.getPos(self.geom)
arrowVec.normalize()
idStr = str(id)
cnp.setTag('boostId', idStr)
self.boostDir[idStr] = arrowVec
base.arrows.append(arrowRoot)
def generate(self, helperInfo):
MapHelper.generate(self)
# Check for a color255 to tint the sprite
color255Props = self.mapObject.getPropsWithValueType(
['color255', 'color1'])
# If we have a color255 property, select the first one.
color255Prop = color255Props[0] if len(color255Props) > 0 else None
if color255Prop:
color = self.mapObject.getPropertyValue(color255Prop)
color = LEGlobals.colorFromRGBScalar255(color)
else:
color = Vec4(1)
spritePath = helperInfo['args'][0].replace("\"", "")
cm = CardMaker("sprite")
cm.setFrame(-0.75, 0.75, -0.75, 0.75)
np = NodePath(cm.generate())
#np.setBSPMaterial(spritePath)
np.setTexture(base.loader.loadTexture(spritePath))
np.setColorScale(color)
np.setLightOff(1)
np.setFogOff(1)
np.setBillboardPointEye()
np.setTransparency(True)
np.hide(~VIEWPORT_3D_MASK)
np.reparentTo(self.mapObject.helperRoot)
self.sprite = np
def rebuild(self, view_size):
self.view_size = view_size
props = base.win.getProperties()
y = props.getYSize()
pxm = float(y) / self.view_size
hsize = 12 / pxm
vsize = 40 / pxm
#print(hsize, vsize)
cm = CardMaker('card')
cm.setFrame(LPoint3(-hsize, 0, 0), LPoint3(hsize, 0, 0),
LPoint3(hsize, vsize, 0), LPoint3(-hsize, vsize, 0))
for n in self.nodes:
n.removeNode()
self.nodes = []
for m in self.markers:
node = NodePath(cm.generate())
node.setTexture(self.icon, 1)
node.setTransparency(TransparencyAttrib.MAlpha)
node.setDepthTest(False)
node.setDepthWrite(False)
node.setBin("unsorted", 1)
ned = m['ned']
node.setPos(ned[1], ned[0], 0)
node.reparentTo(self.render)
self.nodes.append(node)
def loadFlatQuad(self, fullFilename):
cm = CardMaker('cm-%s' % fullFilename)
cm.setColor(1.0, 1.0, 1.0, 1.0)
aspect = base.camLens.getAspectRatio()
htmlWidth = 2.0 * aspect * WEB_WIDTH_PIXELS / float(WIN_WIDTH)
htmlHeight = 2.0 * float(WEB_HEIGHT_PIXELS) / float(WIN_HEIGHT)
cm.setFrame(-htmlWidth / 2.0, htmlWidth / 2.0, -htmlHeight / 2.0,
htmlHeight / 2.0)
bottomRightX = WEB_WIDTH_PIXELS / float(WEB_WIDTH + 1)
bottomRightY = WEB_HEIGHT_PIXELS / float(WEB_HEIGHT + 1)
cm.setUvRange(Point2(0, 1 - bottomRightY), Point2(bottomRightX, 1))
card = cm.generate()
quad = NodePath(card)
jpgFile = PNMImage(WEB_WIDTH, WEB_HEIGHT)
smallerJpgFile = PNMImage()
readFile = smallerJpgFile.read(Filename(fullFilename))
if readFile:
jpgFile.copySubImage(smallerJpgFile, 0, 0)
guiTex = Texture('guiTex')
guiTex.setupTexture(Texture.TT2dTexture, WEB_WIDTH, WEB_HEIGHT, 1,
Texture.TUnsignedByte, Texture.FRgba)
guiTex.setMinfilter(Texture.FTLinear)
guiTex.load(jpgFile)
guiTex.setWrapU(Texture.WMClamp)
guiTex.setWrapV(Texture.WMClamp)
ts = TextureStage('webTS')
quad.setTexture(ts, guiTex)
quad.setTransparency(0)
quad.setTwoSided(True)
quad.setColor(1.0, 1.0, 1.0, 1.0)
result = quad
else:
result = None
Texture.setTexturesPower2(1)
return result
def generateAnalysis(self):
if self.analyzeMode:
self.cleanupAnalysis()
self.analyzeMode = True
cm = CardMaker('cm')
self.analysisBar.show()
loadingTime = self.loadingEnd - self.loadingStart
for stepName in self.stepInfo:
(startTime, duration, color, ticks, startPercent, percent, expectedTicks) = self.stepInfo[stepName]
cm.setName(stepName)
cm.setColor(color)
cm.setFrame((startTime / loadingTime) * 1.8 - 0.90000000000000002, ((startTime + duration) / loadingTime) * 1.8 - 0.90000000000000002, -0.5, -0.10000000000000001)
self.analysisBarRoot.attachNewNode(cm.generate())
button = DirectFrame(parent = self.analysisBarRoot, geom = NodePath('empty'), image = NodePath('empty'), state = DGG.NORMAL, relief = None, frameSize = ((startTime / loadingTime) * 1.8 - 0.90000000000000002, ((startTime + duration) / loadingTime) * 1.8 - 0.90000000000000002, -0.5, -0.10000000000000001))
button.bind(DGG.ENTER, self.showInfo, extraArgs = [
stepName])
self.analysisButtons.append(button)
button = DirectFrame(parent = self.analysisBarRoot, geom = NodePath('empty'), image = NodePath('empty'), state = DGG.NORMAL, relief = None, frameSize = ((startPercent / self.loadScale / 100.0) * 1.8 - 0.90000000000000002, ((startPercent + percent) / self.loadScale / 100.0) * 1.8 - 0.90000000000000002, 0.10000000000000001, 0.5))
button.bind(DGG.ENTER, self.showInfo, extraArgs = [
stepName])
self.analysisButtons.append(button)
for tick in ticks:
self.line.moveTo(VBase3((tick / loadingTime) * 1.8 - 0.90000000000000002, 0, -0.5))
self.line.drawTo(VBase3((tick / loadingTime) * 1.8 - 0.90000000000000002, 0, -0.55000000000000004))
for tick in self.unmappedTicks:
self.line.moveTo(VBase3((tick / loadingTime) * 1.8 - 0.90000000000000002, 0, -0.5))
self.line.drawTo(VBase3((tick / loadingTime) * 1.8 - 0.90000000000000002, 0, -0.55000000000000004))
self.analysisSegs = self.analysisBarRoot.attachNewNode(self.line.create())
def create_cards(self):
"""
Create cards: these are panda3d objects that are required for displaying textures.
You can't just have a disembodied texture. In pandastim (at least for now) we are
only showing 2d projections of textures, so we use cards.
"""
cardmaker = CardMaker("stimcard")
cardmaker.setFrameFullscreenQuad()
#Binocular cards
if self.current_stim_params['stim_type'] == 'b':
self.setBackgroundColor(
(0, 0, 0, 1)) # without this the cards will appear washed out
self.left_card = self.aspect2d.attachNewNode(cardmaker.generate())
self.left_card.setAttrib(
ColorBlendAttrib.make(
ColorBlendAttrib.M_add)) # otherwise only right card shows
self.right_card = self.aspect2d.attachNewNode(cardmaker.generate())
self.right_card.setAttrib(
ColorBlendAttrib.make(ColorBlendAttrib.M_add))
if self.profile_on:
self.center_indicator = OnscreenText(
"x",
style=1,
fg=(1, 1, 1, 1),
bg=(0, 0, 0, .8),
pos=self.current_stim_params['position'],
scale=0.05)
# Tex card
elif self.current_stim_params['stim_type'] == 's':
self.card = self.aspect2d.attachNewNode(cardmaker.generate())
self.card.setColor((1, 1, 1, 1)) #?
self.card.setScale(self.scale)
return
def create_instance(self):
self.create_buffer()
# Water surface
maker = CardMaker('water')
maker.setFrame(self.x1, self.x2, self.y1, self.y2)
self.waterNP = self.parent.instance.attachNewNode(maker.generate())
self.waterNP.setHpr(0, -90, 0)
self.waterNP.setPos(0, 0, self.z)
self.waterNP.setTransparency(TransparencyAttrib.MAlpha)
self.waterNP.setShader(Shader.load(Shader.SL_GLSL,
vertex=defaultDirContext.find_shader('water-vertex.glsl'),
fragment=defaultDirContext.find_shader('water-fragment.glsl')))
self.waterNP.setShaderInput('wateranim', Vec4(0.03, -0.015, self.scale, 0)) # vx, vy, scale, skip
# offset, strength, refraction factor (0=perfect mirror, 1=total refraction), refractivity
self.waterNP.setShaderInput('waterdistort', Vec4(0.4, 4.0, 0.25, 0.45))
self.waterNP.setShaderInput('time', 0)
# Reflection plane
self.waterPlane = Plane(Vec3(0, 0, self.z + 1), Point3(0, 0, self.z))
planeNode = PlaneNode('waterPlane')
planeNode.setPlane(self.waterPlane)
# reflection texture, created in realtime by the 'water camera'
tex0 = self.buffer.getTexture()
tex0.setWrapU(Texture.WMClamp)
tex0.setWrapV(Texture.WMClamp)
ts0 = TextureStage('reflection')
self.waterNP.setTexture(ts0, tex0)
# distortion texture
tex1 = loader.loadTexture('textures/water.png')
ts1 = TextureStage('distortion')
self.waterNP.setTexture(ts1, tex1)
self.task = taskMgr.add(self.update, "waterTask")