def __init__(self):
ShowBase.__init__(self)
properties = WindowProperties()
properties.setSize(1000, 750)
self.win.requestProperties(properties)
base.setBackgroundColor(0.5,1,0.5)
self.textObject = OnscreenText(text ='shape-boi', pos = (0.925,0.925), scale = 0.075)
#self.thread = threading.Thread(target=self.udpConnect)
#self.thread2 = threading.Thread(target=self.runColorTrack)
#self.connectButton = DirectButton(text=('Open Connection'),pos=(-0.3,0,-0.98), scale=0.090, command=self.openConnection, frameColor=(255,255,255,0.15))
#self.trackButton = DirectButton(text=('Color Track'),pos=(-1,0,-0.98), scale=0.090, command=self.thread2.start,frameColor=(255,255,255,0.15),state=0)
self.scoreUI = OnscreenText(text = "0",
pos = (-1.3, 0.825),
mayChange = True,
align = TextNode.ALeft)
#loader.loadModel("Models/Misc/environment")
self.environment = loader.loadModel("MorgansModels/terst")
self.environment.setPos(0,54,-3)
self.environment.setH(90)
self.environment.setP(0)
nodePath = NodePath(self.environment)
nodePath.setTransparency(TransparencyAttrib.MAlpha)
nodePath.reparentTo(render)
#render.setShaderAuto()
ambientLight = AmbientLight("ambient light")
ambientLight.setColor(Vec4(0.2, 0.2, 0.2, 1))
self.ambientLightNodePath = render.attachNewNode(ambientLight)
render.setLight(self.ambientLightNodePath)
# In the body of your code
mainLight = DirectionalLight("main light")
self.mainLightNodePath = render.attachNewNode(mainLight)
# Turn it around by 45 degrees, and tilt it down by 45 degrees
self.mainLightNodePath.setHpr(45, -45, 0)
render.setLight(self.mainLightNodePath)
def handleInCollisions(self, entry):
cogCollNames = ['coll_body', 'coll_crit']
intoNode = entry.getIntoNodePath()
fromNode = entry.getFromNodePath()
if (self.called):
return
self.called = True
splatColor = Vec4(0.7, 0.7, 0.8, 1.0)
splatScale = 0.7
if (intoNode.getName() in cogCollNames):
cog = intoNode.getParent().getPythonTag('Cog')
gag = fromNode.getParent().getPythonTag('Stats')
splatColor = gag.getSplatColor()
splatScale = gag.getSplatScale()
if not cog.wasHit():
cog.setHit(True)
if (cog.getLevel() > 1):
exp = int(
math.ceil(float(cog.getLevel()) / 2.0) *
gag.getLevel())
else:
exp = int(gag.getLevel())
render.getPythonTag("LevelManager").addEXP(exp)
dmg = gag.getDamageCurve()[0]
if (intoNode.getName() == cogCollNames[1]):
dmg = (dmg * 2) * 0.4
cog.setHealth(cog.getHealth() - int(dmg))
if (cog.getHealth() <= 0):
maxHp = float((cog.getLevel() + 1) * (cog.getLevel() + 2))
if (cog.getHealth() <= (-1 * (maxHp * 0.2))):
h = cog.getCog().getHpr(fromNode.getParent()).getX()
if (h > 0 and h < 90 or h < 270 and h > 0):
cog.getCog().play('slip-backward')
else:
cog.getCog().play('slip-forward')
else:
cog.getCog().play('pie-small')
SoundBank.getSound('pie_coll').play()
Splat(fromNode.getParent().getPos(), splatColor, splatScale).generate()
fromNode.getParent().removeNode()
def _create_components(self):
""" Internal method to init the widgets components """
self._node.hide()
# Create the texture where the gui component is rendered inside
self._storage_tex = Image.create_2d("ExposureDisplay", 140, 20,
"RGBA8")
self._storage_tex.set_clear_color(Vec4(0.2, 0.6, 1.0, 1.0))
self._storage_tex.clear_image()
self._bg_frame = DirectFrame(parent=self._node,
frameColor=(0.1, 0.1, 0.1, 1.0),
frameSize=(200, 0, -10, -85),
pos=(0, 0, 0))
self._display_img = Sprite(image=self._storage_tex,
parent=self._node,
w=140,
h=20,
x=20,
y=50)
self._display_txt = Text(text="Current Exposure".upper(),
parent=self._node,
x=160,
y=40,
size=13,
color=Vec3(0.8),
align="right")
# Create the shader which generates the visualization texture
self._cshader_node = ComputeNode("ExposureWidget")
self._cshader_node.add_dispatch(140 // 10, 20 // 4, 1)
self._cshader_np = self._node.attach_new_node(self._cshader_node)
# Defer the further loading
Globals.base.taskMgr.doMethodLater(1.0, self._late_init,
"ExposureLateInit")
def startCredits(self):
self.creditsSequence = Sequence(
LerpColorScaleInterval(self.screenCover,
1,
Vec4(1, 1, 1, 1),
startColorScale=Vec4(1, 1, 1, 0)),
LerpColorScaleInterval(self.text,
1,
Vec4(1, 1, 1, 1),
startColorScale=Vec4(1, 1, 1, 0)), Wait(1),
self.text.posInterval(35, Point3(0, 0, 6)), Wait(1),
LerpColorScaleInterval(self.screenCover,
1,
Vec4(1, 1, 1, 0),
startColorScale=Vec4(1, 1, 1, 1)),
Func(self.removeCredits)).start()
def getDropIval(self):
shadow = self.shadow
drop = self.drop
id = self.id
hangTime = Globals.ShadowTime
dropTime = Globals.DropTime
dropHeight = Globals.DropHeight
targetShadowScale = 0.5
targetShadowAlpha = 0.4
shadowScaleIval = LerpScaleInterval(shadow, dropTime, targetShadowScale, startScale=0)
shadowAlphaIval = LerpColorScaleInterval(shadow, hangTime, Point4(1, 1, 1, targetShadowAlpha), startColorScale=Point4(1, 1, 1, 0))
shadowIval = Parallel(shadowScaleIval, shadowAlphaIval)
startPos = Point3(0, 0, dropHeight)
drop.setPos(startPos)
dropIval = LerpPosInterval(drop, dropTime, Point3(0, 0, 0), startPos=startPos, blendType='easeIn')
dropSoundIval = self._dropSfx
dropSoundIval.node = self
self.drop.setTransparency(1)
def _setRandScale(t):
self.drop.setScale(self, 1 - random.random() / 16, 1 - random.random() / 16, 1 - random.random() / 4)
scaleChange = 0.4 + random.random() / 4
dropShakeSeq = Sequence(
LerpScaleInterval(self.drop, 0.25, Vec3(1.0 + scaleChange, 1.0 + scaleChange / 2, 1.0 - scaleChange), blendType='easeInOut'),
LerpScaleInterval(self.drop, 0.25, Vec3(1.0, 1.0, 1.0), blendType='easeInOut'), Func(self.disableCollisionDamage),
LerpScaleInterval(self.drop, 0.2, Vec3(1.0 + scaleChange / 8, 1.0 + scaleChange / 8, 1.0 - scaleChange / 8), blendType='easeInOut'),
LerpScaleInterval(self.drop, 0.2, Vec3(1.0, 1.0, 1.0), blendType='easeInOut'),
LerpScaleInterval(self.drop, 0.15, Vec3(1.0 + scaleChange / 16, 1.0 + scaleChange / 16, 1.0 - scaleChange / 16), blendType='easeInOut'),
LerpScaleInterval(self.drop, 0.15, Vec3(1.0, 1.0, 1.0), blendType='easeInOut'),
LerpScaleInterval(self.drop, 0.1, Vec3(1.0 + scaleChange / 16, 1.0 + scaleChange / 8, 1.0 - scaleChange / 16), blendType='easeInOut'),
LerpColorScaleInterval(self.drop, Globals.DropFadeTime, Vec4(1.0, 1.0, 1.0, 0.0)))
ival = Sequence(
Func(self.reparentTo, render),
Parallel(Sequence(WaitInterval(hangTime), dropIval), shadowIval),
Parallel(Func(self.game.dropHit, self, id), dropSoundIval, dropShakeSeq),
Func(self.game.cleanupDrop, id), name='drop%s' % id)
self.ival = ival
return ival
def cuboid(origin, bounds, direction, color=Vec4(1), normal_as_color=NAC):
"""
Return GeomNode of the cuboid,
Args:
origin: center of the cuboid
bounds: 3-Tuple of length, width and height
direction: normal vector of the up face
color: Vec4
normal_as_color: whether to use vertex normal as color
"""
dfl = Vec3(-bounds[0], -bounds[1], -bounds[2])
dfr = Vec3(bounds[0], -bounds[1], -bounds[2])
dbr = Vec3(bounds[0], bounds[1], -bounds[2])
dbl = Vec3(-bounds[0], bounds[1], -bounds[2])
ufl = Vec3(-bounds[0], -bounds[1], bounds[2])
ufr = Vec3(bounds[0], -bounds[1], bounds[2])
ubr = Vec3(bounds[0], bounds[1], bounds[2])
ubl = Vec3(-bounds[0], bounds[1], bounds[2])
faces = [
(ufl, ufr, ubr, ubl), # Up
(dfl, dbl, dbr, dfr), # Down
(dfr, dbr, ubr, ufr), # Right
(dfl, ufl, ubl, dbl), # Left
(dfl, dfr, ufr, ufl), # Front
(dbl, ubl, ubr, dbr), # Back
]
D.setup(origin, direction)
m = mesh.Mesh('cuboid')
for f in faces:
pts = []
for p in f:
D.set_pos_hp_d(p.x, p.y, p.z, 0, 0, 0)
pts.append(m.add_vertex(D.pos, color))
m.add_triangle(*reversed(pts[:3]))
m.add_triangle(pts[0], *reversed(pts[2:]))
return m.export(normal_as_color=normal_as_color)
def draw_leaf(nodePath,
vdata,
pos=Vec3(0, 0, 0),
vecList=[Vec3(0, 0, 1),
Vec3(1, 0, 0),
Vec3(0, -1, 0)],
scale=0.125):
#use the vectors that describe the direction the branch grows to make the right
#rotation matrix
newCs = Mat4(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
newCs.setRow(0, vecList[2]) #right
newCs.setRow(1, vecList[1]) #up
newCs.setRow(2, vecList[0]) #forward
newCs.setRow(3, Vec3(0, 0, 0))
newCs.setCol(3, Vec4(0, 0, 0, 1))
try:
axisAdj = Mat4.scaleMat(scale) * newCs * Mat4.translateMat(pos)
except TypeError, e:
print e
print scale, pos
def __init__(self, isServer, name, ip, port, log):
self.log = log
self.config = Config()
#set up world
base.win.setClearColor(Vec4(0, 0, 0, 1))
self.environ = loader.loadModel('resources/models/world')
self.environ.reparentTo(render)
self.environ.setPos(0, 0, 0)
Character.startPosition = self.environ.find('**/start_point').getPos()
#set up collisions
Character.collisionTraverser = CollisionTraverser()
if SHOW_COLLISIONS:
Character.collisionTraverser.showCollisions(render)
#set up networking
mode = network.MODE_SERVER if isServer else network.MODE_CLIENT
self.connection = network.Connection(mode,
name,
ip,
port,
log=self.log)
self.sendDeltaT = 0
#set up local client
self.control = Controller(self.connection.localUser.char,
self.config.controlDict)
taskMgr.add(self.step, 'world-step')
#set up characters
if network.mode == network.MODE_SERVER:
self.ai = []
for i in range(1):
c = Character(name='Zombie')
self.ai.append(AIController(c))
print 'INITIALIZING SERVER WITH', len(self.ai), 'ZOMBIES'
else:
self.controlList = []
def __init__(self, ship, bulletPos, bulletVelocityVec, collisionHandler):
self.model = game.loader.loadModel("Models/bullet.egg.pz")
self.model.setPos(bulletPos)
self.model.setScale(BULLET_SIZE)
self.model.reparentTo(render)
self.model.setPythonTag("owner", self)
self.ship = ship
finalPosition = bulletPos + (bulletVelocityVec * BULLET_TRAVEL_TIME)
self.trajectory = self.model.posInterval(BULLET_TRAVEL_TIME,
finalPosition).start()
self.collisionNode = self.model.attachNewNode(CollisionNode("bullet"))
self.collisionNode.node().addSolid(CollisionSphere(0, 0, 0, 1))
base.cTrav.addCollider(self.collisionNode, collisionHandler)
# Add Point Light to the bullet
self.plight = PointLight('plight' + str(random()))
self.plight.setColor(Vec4(1, 1, 1, 1))
self.plight.setAttenuation(Vec3(0.7, 0.05, 0))
self.plnp = self.model.attachNewNode(self.plight)
render.setLight(self.plnp)
render.setShaderInput("light", self.plnp)
def __makeGagButton(self, gagName, trackName):
gui = loader.loadModel('phase_3.5/models/gui/inventory_gui.bam')
icons = loader.loadModel('phase_3.5/models/gui/inventory_icons.bam')
icon = icons.find(GagGlobals.InventoryIconByName[gagName])
index = GagGlobals.TrackGagNamesByTrackName[trackName].index(gagName)
xValue = GagButtonXValues[index]
button = DirectButton(
relief=None,
image=(gui.find('**/InventoryButtonUp'),
gui.find('**/InventoryButtonDown'),
gui.find('**/InventoryButtonRollover'),
gui.find('**/InventoryButtonFlat')),
geom=icon,
geom_scale=0.6,
parent=self.trackByName[trackName],
text=str(base.localAvatar.getBackpack().getSupply(gagName)),
text_align=TextNode.ARight,
text_scale=0.04,
text_fg=Vec4(1, 1, 1, 1),
text_pos=(0.07, -0.04))
button.setX(xValue)
self.gagButtonByName[gagName] = button
def doAttack(self, ts):
texturesList = [
'jargon-brow',
'jargon-deep',
'jargon-hoop',
'jargon-ipo']
reds = [1, 0, 1, 0]
particleList = []
for i in xrange(0, 4):
particleList.append('phase_5/etc/jargonSpray.ptf')
ParticleAttack.doAttack(self, particleList, 'doJargon', 'jargonSphere', 'speak', 1.5, 1.5, None, None, False, ts)
for i in xrange(0, 4):
effect = self.particles[i]
setEffectTexture(effect, texturesList[i], Vec4(reds[i], 0, 0, 1))
for particle in self.particles:
particle.setZ(self.suit.find('**/joint_head').getZ(render))
self.suitTrack.append(Wait(self.afterIvalDur))
self.suitTrack.start(ts)
return
def __init__(self, world, app):
self.world = world
self.app = app
self.picker = app.loader.loadModel('media/models/picked.egg')
self.picker.reparentTo(app.render)
shader = Shader.load(Shader.SLGLSL, 'media/shaders/vertex.glsl',
'media/shaders/flat.glsl')
self.picker.setShader(shader)
self.picker.setShaderInput('color', Vec4(0.3, 0.3, 1.0, 0.5))
self.picking_planes = [
Plane(Vec3(0, 0, 1), Point3(0, 0, z + 1))
for z in self.world.zlevels()
]
self.picked = None
self.mouse = app.mouseWatcherNode
self.constraint = BlockPicker.SURFACE
self.slice = None
self.addTask(self.pick_block, "Pick block")
self.accept('slice-changed', self.slice_changed)
def add_points(self, player):
"""
updating score after game end
"""
if player == 2:
self.blueScore += 1
Sequence(
LerpColorScaleInterval(self.text_blue_np,
0.4,
Vec4(0, 0, 1, 0),
Vec4(1),
blendType="easeInOut"),
Func(lambda *args: self.text_blue.set_text("BLUE: " + str(
self.blueScore))),
LerpColorScaleInterval(self.text_blue_np,
0.4,
Vec4(1),
Vec4(0, 0, 1, 0),
blendType="easeInOut"),
).start()
elif player == 1:
self.redScore += 1
Sequence(
LerpColorScaleInterval(self.text_red_np,
0.4,
Vec4(1, 0, 0, 0),
Vec4(1),
blendType="easeInOut"),
Func(lambda *args: self.text_red.set_text("RED: " + str(
self.redScore))),
LerpColorScaleInterval(self.text_red_np,
0.4,
Vec4(1),
Vec4(1, 0, 0, 0),
blendType="easeInOut"),
).start()
def create(self):
self.target = RenderTarget("ApplyLights")
self.target.addColorTexture()
self.target.setColorBits(16)
self.target.prepareOffscreenBuffer()
self.target.setClearColor(True)
self.target.getQuad().removeNode()
self.target.getNode().setAttrib(
TransparencyAttrib.make(TransparencyAttrib.MNone), 1000)
self.target.getNode().setAttrib(
ColorBlendAttrib.make(ColorBlendAttrib.MAdd), 1000)
self.quads = {}
numInstances = self.tileCount.x * self.tileCount.y
for lightType in ["DirectionalLightShadow"]:
cm = CardMaker("BufferQuad-" + lightType)
cm.setFrameFullscreenQuad()
quad = NodePath(cm.generate())
quad.setDepthTest(0)
quad.setDepthWrite(0)
quad.setAttrib(TransparencyAttrib.make(TransparencyAttrib.MNone),
1000)
quad.setColor(Vec4(1, 0.5, 0.5, 1))
# Disable culling
quad.node().setFinal(True)
quad.node().setBounds(OmniBoundingVolume())
quad.setBin("unsorted", 10)
quad.setInstanceCount(numInstances)
quad.reparentTo(self.target.getNode())
self.quads[lightType] = quad
self.target.getNode().setShaderInput("tileCount", self.tileCount)
def __init__(self, game: Game, path) -> None:
super().__init__()
self.render = game.render
self.origin = Vec4()
self.basis = Mat4()
self.actions = {}
shader = Shader.load(
Shader.SL_GLSL,
vertex=path / "slicer.vert",
geometry=path / "slicer.geom",
fragment=path / "slicer.frag",
)
game.render.set_shader(shader)
game.render.set_two_sided(True)
game.render.set_shader_input("plane_origin", self.origin)
game.render.set_shader_input("plane_basis", self.basis)
for action in "turn-ana", "turn-kata":
self.accept(action, self.actions.update, [{action: True}])
self.accept(action + "-up", self.actions.update, [{action: False}])
def __init__(self, tabType=2, parent=None, **kw):
loadModels()
if parent is None:
parent = aspect2d
if tabType == 1:
image = Preloaded['tab1']
elif tabType == 2:
image = Preloaded['tab2']
else:
image = None
optiondefs = (('relief', None, None), ('text_align', TextNode.ALeft,
None),
('text_fg', Vec4(0.2, 0.1, 0,
1), None), ('image', image, None),
('image_color', normalColor,
None), ('image1_color', clickColor,
None), ('image2_color', rolloverColor, None),
('image3_color', diabledColor,
None), ('image_scale', (0.033, 0.033, 0.035),
None), ('image_hpr', (0, 0, -90), None))
self.defineoptions(kw, optiondefs)
DirectButton.__init__(self, parent)
self.initialiseoptions(OptionTab)
def enterExitDialog(self,
text,
exitButtonCommand=None,
exitButtonExtraArgs=[]):
self.label.setText(text)
sy = self.label.getScale()[1]
bottom = self.label.textNode.getBottom() * sy
lineHeight = self.label.textNode.getLineHeight() * sy
self.exitButton.setPos(0, 0, bottom - (lineHeight * 2))
self.exitButton['command'] = exitButtonCommand
self.exitButton['extraArgs'] = exitButtonExtraArgs
labelY = self.calcLabelY()
self.label.setPos(0, labelY)
self.exitButton.setZ(self.exitButton, labelY)
self.exitButton.reparentTo(aspect2d)
self.label.reparentTo(aspect2d)
self.label.setColorScale(Vec4(1, 1, 1, 1))
def makePickableQuests(self, list):
quests = []
for questId in list:
quests.append(Quests.Quest(questId, 0, 0, list.index(questId)))
positions = [(0, 0, 0.6), (0, 0, 0), (0, 0, -0.6)]
self.questNotes = base.localAvatar.questManager.makeQuestNotes(quests = quests)
self.questFrame = DirectFrame(parent = base.a2dLeftCenter, relief = None, pos = (0.5, 0, 0),
geom = DGG.getDefaultDialogGeom(), geom_color=Vec4(0.8, 0.6, 0.4, 1),
geom_scale=(1.85, 1, 0.9), geom_hpr=(0, 0, -90))
self.questBtns = []
for i in xrange(len(self.questNotes)):
note = self.questNotes[i]
note.setPos(0, 0, 0)
if quests[i].currentObjective.type in Quests.DefeatObjectives:
note.progressText.hide()
btn = DirectButton(geom = note, parent = self.questFrame,
pos = positions[i], command = self.d_pickedQuest, extraArgs = [quests[i]], relief = None)
btn.setScale(1.15)
note.reparentTo(btn.stateNodePath[0], 20)
note.instanceTo(btn.stateNodePath[1], 20)
note.instanceTo(btn.stateNodePath[2], 20)
note.show()
self.questBtns.append(btn)
def createColoredParametricCurveGeomNode(
func=(lambda t: np.array([t, t, t])),
param_interv=np.array([0, 1]),
thickness=5., color=Vec4(1., 1., 1., 1.),
howmany_points=50):
ls = LineSegs()
ls.setThickness(thickness)
ls.setColor(color)
t = np.linspace(param_interv[0], param_interv[1], num=howmany_points, endpoint=True)
for i, c_t in enumerate(t):
xyz_arr = func(c_t)
if i > 0:
ls.drawTo(*tuple(xyz_arr))
ls.moveTo(*tuple(xyz_arr))
geomnode = ls.create()
# nodepath = NodePath(geomnode)
return geomnode
def __init__(self, phone, doneEvent=None):
NodePath.__init__(self, aspect2d.attachNewNode('CatalogGUI'))
DirectObject.__init__(self)
CatalogGlobals.CatalogNodePath.find('**/CATALOG_GUI_BKGD').copyTo(self)
self.setScale(CatalogGlobals.CatalogBKGDScale)
self.phone = phone
self.doneEvent = doneEvent
self.arrowButtons = {}
self.createArrowButtons()
self.currentTab = None
self.tabButtons = {}
self.createTabButtons()
self.radioButtons = []
# self.createRadioButtons()
self.activePage = 0
self.gifting = -1
guiItems = loader.loadModel('phase_5.5/models/gui/catalog_gui')
hangupGui = guiItems.find('**/hangup')
hangupRolloverGui = guiItems.find('**/hangup_rollover')
self.hangup = DirectButton(
self,
relief=None,
pos=(2.28, 0, -1.3),
image=[hangupGui, hangupRolloverGui, hangupRolloverGui, hangupGui],
text=['', TTLocalizer.CatalogHangUp, TTLocalizer.CatalogHangUp],
text_fg=Vec4(1),
text_scale=0.07,
text_pos=(0.0, 0.14),
command=self.hangUp)
guiItems.removeNode()
def __init__(self):
ShowBase.__init__(self)
self.win.setClearColor(Vec4(0.2, 0.2, 0.2, 1))
self.disableMouse()
self.render.setShaderAuto()
dlight = DirectionalLight('dlight')
alight = AmbientLight('alight')
dlnp = self.render.attachNewNode(dlight)
alnp = self.render.attachNewNode(alight)
dlight.setColor((0.8, 0.8, 0.5, 1))
alight.setColor((0.2, 0.2, 0.2, 1))
dlnp.setHpr(0, -60, 0)
self.render.setLight(dlnp)
self.render.setLight(alnp)
# Put lighting on the main scene
plight = PointLight('plight')
plnp = self.render.attachNewNode(plight)
plnp.setPos(0, 0, 10)
self.render.setLight(plnp)
self.render.setLight(alnp)
self.loadRocketFonts()
self.loadingTask = None
#self.startModelLoadingAsync()
self.startModelLoading()
self.inputHandler = RocketInputHandler()
self.mouseWatcher.attachNewNode(self.inputHandler)
self.openLoadingDialog()
def _setup_camera_rig(self):
""" Setups the cameras to render a cubemap """
directions = (Vec3(1, 0, 0), Vec3(-1, 0, 0), Vec3(0, 1, 0),
Vec3(0, -1, 0), Vec3(0, 0, 1), Vec3(0, 0, -1))
# Prepare the display regions
for i in range(6):
region = self.target.internal_buffer.make_display_region(
i / 6, i / 6 + 1 / 6, 0, 1)
region.set_sort(25 + i)
region.set_active(True)
region.disable_clears()
# Set the correct clears
region.set_clear_depth_active(True)
region.set_clear_depth(1.0)
region.set_clear_color_active(True)
region.set_clear_color(Vec4(0))
lens = PerspectiveLens()
lens.set_fov(90)
lens.set_near_far(0.001, 1.0)
camera = Camera("EnvmapCam-" + str(i), lens)
camera_np = self.rig_node.attach_new_node(camera)
camera_np.look_at(camera_np, directions[i])
region.set_camera(camera_np)
self.regions.append(region)
self.cameras.append(camera_np)
self.cameras[0].set_r(90)
self.cameras[1].set_r(-90)
self.cameras[3].set_r(180)
self.cameras[5].set_r(180)
# Register cameras
for camera_np in self.cameras:
self._pipeline.tag_mgr.register_camera("envmap", camera_np.node())
def __init__(self):
ShowBase.__init__(self)
self.cc = CentralController()
self.gameTask = taskMgr.add(self.flyCircles, "circles")
base.disableMouse()
base.camera.setPos(-50, 00, 200)
base.camera.lookAt(0, 0, -10)
slight = Spotlight('slight')
slight.setColor(VBase4(1, 1, 1, 1))
lens = PerspectiveLens()
slight.setLens(lens)
self.shipList = [Xwing("xwing1")]
lightColors = [Vec4(0.9, 0.9, 0.9, 1)]
for i, ship in enumerate(self.shipList):
ship.reparentTo(render)
ship.setScale(2)
ship.setPos(Point3(i * 10, 0, 0))
directionalLight = DirectionalLight('directionalLight')
directionalLight.setColor(lightColors[i])
directionalLightNP = render.attachNewNode(directionalLight)
directionalLightNP.setHpr(180, -20, 0)
ship.setLight(directionalLightNP)
self.cc.addObject(ship)
self.count = 0
def dome(origin,
direction,
polygon,
radius,
color=Vec4(1),
normal_as_color=NAC):
"""
Return a Node of a dome/half-sphere.
Args:
origin: Vec3
direction: Vec3
polygon: number of vertices
radius: float
color: Vec4
normal_as_color: whether to use the vertex normal as color
"""
return sphere(origin,
direction,
polygon,
radius,
p_from_deg=0,
color=color,
normal_as_color=normal_as_color)
def createColoredSegmentedSmooth2dLineGeomNode(
coords,
thickness=5.,
color=Vec4(1., 1., 1., 1.)):
""" Plot a series of solid lines, connected to each other.
Args:
coords: list of 3d np.array """
# thickness = 100.
ls = LineSegs()
ls.setThickness(thickness)
ls.setColor(color)
# import ipdb; ipdb.set_trace() # noqa BREAKPOINT
ls.moveTo(*tuple(coords[0]))
for i, coord in enumerate(coords):
ls.drawTo(*tuple(coord))
ls.moveTo(*tuple(coord))
geomnode = ls.create()
# nodepath = NodePath(geomnode)
return geomnode
def setup_glow_shader(self):
glow_shader = self.base.loader.loadShader("shader/glowShader.cg")
glow_buffer = self.base.win.makeTextureBuffer("Glow scene", 512, 512)
glow_buffer.setSort(-3)
glow_buffer.setClearColor(Vec4(0, 0, 0, 1))
self.glowcam = self.base.makeCamera(
glow_buffer, lens=self.base.cam.node().getLens())
tempnode = NodePath(PandaNode("temp node"))
tempnode.setShader(glow_shader)
self.glowcam.node().setInitialState(tempnode.getState())
self.glowcam.reparentTo(self.base.camera)
blurXBuffer = self.makeFilterBuffer(glow_buffer, "Blur X", -2,
"shader/XBlurShader.cg")
blurYBuffer = self.makeFilterBuffer(blurXBuffer, "Blur Y", -1,
"shader/YBlurShader.cg")
self.finalcard = blurYBuffer.getTextureCard()
self.finalcard.reparentTo(self.base.render2d)
self.finalcard.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd))
self.base.accept("v", self.base.bufferViewer.toggleEnable)
self.base.accept("V", self.base.bufferViewer.toggleEnable)
self.base.bufferViewer.setPosition("llcorner")
self.base.bufferViewer.setLayout("hline")
self.base.bufferViewer.setCardSize(0.652, 0)
def __init__(self, x_lowerleft, y_lowerleft, box_height=1.0, box_width=2.0, **kwargs):
if 'color' in kwargs:
self.color = kwargs.get('color')
else:
self.color = Vec4(.5, .5, .5, 1)
self.x_lowerleft = x_lowerleft
self.y_lowerleft = y_lowerleft
self.box_height = box_height
self.box_width = box_width
self.scale = 1.
# draw the box
for cur_x, cur_y, cur_z in zip(self.x_lowerleft, self.y_lowerleft, self.z):
cur_point = PointPrimitive()
cur_point.setPos(cur_x, 0, cur_y)
cur_point.setColor(*self.color)
self.set_bbox.append(cur_point)
self.group_node = GroupNode()
self.group_node.addChildNodePaths(
[point.nodepath for point in self.set_bbox])
def announceGenerate(self):
self.plotType = GardenGlobals.whatCanBePlanted(self.ownerIndex, self.plot)
self.stickUp = 0.0
if self.getOwnerId() != localAvatar.doId:
self.defaultModel = None
elif self.plotType == GardenGlobals.FLOWER_TYPE:
self.collSphereRadius = 2.0
self.collSphereOffset = 0.0
self.plotScale = 0.7
self.stickUp = 1.1
elif self.plotType == GardenGlobals.GAG_TREE_TYPE:
self.collSphereRadius = 3.0
self.plotScale = 1.5
self.colorScaler = Vec4(1.0, 1.0, 1.0, 1)
elif self.plotType == GardenGlobals.STATUARY_TYPE:
self.collSphereRadius = 3.0
self.plotScale = 0.075
self.stickUp = -0.0
self.defaultModel = 'phase_5.5/models/estate/garden_slab'
else:
self.collSphereOffset = 0.0
self.notify.debug('announceGenerate')
DistributedLawnDecor.DistributedLawnDecor.announceGenerate(self)
return
def stop(self):
self.ignore('mouse1')
if self.labelPosTrack is not None:
self.labelPosTrack.finish()
self.labelPosTrack = None
if self.labelColorScaleTrack is not None:
self.labelColorScaleTrack.finish()
self.labelColorScaleTrack = None
if self.logoPosTrack is not None:
self.logoPosTrack.finish()
self.logoPosTrack = None
if self.logoScaleTrack is not None:
self.logoScaleTrack.finish()
self.logoScaleTrack = None
if self.fadeTrack is not None:
self.fadeTrack.finish()
self.fadeTrack = None
self.setColorScale(Vec4(0, 0, 0, 0))
def create(self):
# Construct the voxel texture
self._cloud_voxels = Image.create_3d("CloudVoxels", self._voxel_res_xy,
self._voxel_res_xy,
self._voxel_res_z, "RGBA8")
self._cloud_voxels.set_wrap_u(SamplerState.WM_repeat)
self._cloud_voxels.set_wrap_v(SamplerState.WM_repeat)
self._cloud_voxels.set_wrap_w(SamplerState.WM_border_color)
self._cloud_voxels.set_border_color(Vec4(0, 0, 0, 0))
# Construct the target which populates the voxel texture
self._grid_target = self.create_target("CreateVoxels")
self._grid_target.size = self._voxel_res_xy, self._voxel_res_xy
self._grid_target.prepare_buffer()
self._grid_target.quad.set_instance_count(self._voxel_res_z)
self._grid_target.set_shader_input("CloudVoxels", self._cloud_voxels)
# Construct the target which shades the voxels
self._shade_target = self.create_target("ShadeVoxels")
self._shade_target.size = self._voxel_res_xy, self._voxel_res_xy
self._shade_target.prepare_buffer()
self._shade_target.quad.set_instance_count(self._voxel_res_z)
self._shade_target.set_shader_inputs(
CloudVoxels=self._cloud_voxels, CloudVoxelsDest=self._cloud_voxels)
