def updateDrawbridges(self):
for drawbridge in self.drawbridges:
if self.hp <= 0:
if base.options.getSpecialEffectsSetting() >= base.options.SpecialEffectsHigh:
smokeEffect = SmokeExplosion.getEffect()
if smokeEffect:
smokeEffect.reparentTo(render)
smokeEffect.setPos(drawbridge, 0, 0, 0)
smokeEffect.spriteScale = 1.0
smokeEffect.play()
posHprIval = LerpPosHprInterval(drawbridge, 1.0, Vec3(drawbridge.getX(), drawbridge.getY(), drawbridge.getZ() - 130.0), Vec3(drawbridge.getH(), drawbridge.getP() - 360.0, drawbridge.getR() + 15))
posHprIval.start()
continue
def updateDrawbridges(self):
for drawbridge in self.drawbridges:
if self.hp <= 0:
if base.options.getSpecialEffectsSetting(
) >= base.options.SpecialEffectsHigh:
smokeEffect = SmokeExplosion.getEffect()
if smokeEffect:
smokeEffect.reparentTo(render)
smokeEffect.setPos(drawbridge, 0, 0, 0)
smokeEffect.spriteScale = 1.0
smokeEffect.play()
posHprIval = LerpPosHprInterval(
drawbridge, 1.0,
Vec3(drawbridge.getX(), drawbridge.getY(),
drawbridge.getZ() - 130.0),
Vec3(drawbridge.getH(),
drawbridge.getP() - 360.0,
drawbridge.getR() + 15))
posHprIval.start()
def startCrashEffect(self):
if not self.getLocationSeeker() or self.crashBegun:
return
self.cleanupCrashIval()
self.crashBegun = True
if self.crashSite is None:
self.crashSite = loader.loadModel('phase_6/models/props/piano.bam')
self.crashSite.setScale(0.5)
self.crashSite.setTransparency(TransparencyAttrib.MAlpha)
self.crashSite.setColorScale(1.0, 1.0, 1.0, 0.25)
self.crashSite.reparentTo(render)
self.crashSiteGag = self.crashSite.find('**/crashed_piano')
self.crashSiteGag.setTransparency(TransparencyAttrib.MAlpha)
self.crashSiteShadow = self.crashSite.find('**/shadow_crack')
# Clean up the collision nodes.
for node in self.crashSite.findAllMatches('**/*coll*'):
node.removeNode()
self.crashSite.show()
dropShadow = self.getLocationSeeker().getDropShadow()
if not dropShadow:
return
location = self.getLocationSeeker().getDropShadow().getPos(render)
self.crashSite.setPos(location.getX(), location.getY(),
location.getZ())
self.crashEndPos = self.crashSiteShadow.getPos()
self.crashStartPos = Point3(self.crashEndPos.getX(),
self.crashEndPos.getY(),
self.crashEndPos.getZ() + 8.5)
self.crashSiteIval = Sequence(
Func(self.crashSiteShadow.hide),
Func(self.crashSiteGag.headsUp, base.localAvatar),
Parallel(
Sequence(
LerpPosHprInterval(self.crashSiteGag,
duration=0.75,
pos=self.crashEndPos,
startPos=self.crashStartPos,
startHpr=Point3(0.0, 15.0, 21.30),
hpr=Point3(0.0, 0.0, 0.0)),
Func(self.crashSiteShadow.show)), ),
LerpColorScaleInterval(self.crashSiteShadow,
duration=0.75,
colorScale=Vec4(1.0, 1.0, 1.0, 0.0),
startColorScale=Vec4(1.0, 1.0, 1.0, 1.0)),
Func(self.crashSiteShadow.hide),
Func(self.crashSiteShadow.setColorScale, 1.0, 1.0, 1.0, 1.0))
self.crashSiteIval.loop()
def move(self, task):
diffPos = self.target.getPos() - self.entity.getPos()
diffH = (self.target.getH() - self.entity.getH()) % 360
if diffPos.lengthSquared() < 0.001 and -0.1 < diffH < 0.1:
if self.isMoving:
self.model.stop()
self.model.pose("walk", 5)
self.isMoving = False
else:
if not self.isMoving:
self.model.loop("run")
self.isMoving = True
interval = LerpPosHprInterval(
self.entity,
duration=task.getDelay(),
pos=self.target.getPos(),
hpr=self.target.getHpr(),
name="Character[" + str(self.id) + "].move.interval",
)
interval.start()
return task.again
def startgame(self):
# Transition to the game start state
taskMgr.add(self.transition, 'transition')
interval = LerpPosHprInterval(self.boxnode, TRANSITIONPERIOD, Point3(0, 0, 0), Point3(0, 0, 0),
other=self.worldnode, blendType='easeInOut')
interval.start()
class Bot(object):
def __init__(self, team, position, direction):
self._orders = Actions.DoNothing
self._hp = 5
self._death_played = False
self._interval = None
self.kills = 0
self.team = team
self._model = NodePath('bot')
self._model.reparentTo(render)
self._model.setPos(position)
self._model.setHpr(direction, 0, 0)
self._model.setColorScale(*self.team)
self._model.setScale(.2, .2, .2)
# Load the animations
self._actor = Actor("models/RockGolem", {
'idle': 'models/RockGolem-idle',
'walk': 'models/RockGolem-walk',
'reverse-walk': 'models/RockGolem-walk',
'punch': 'models/RockGolem-punch',
'death': 'models/RockGolem-death',
'throw': 'models/RockGolem-throw',
})
self._actor.setPlayRate(2.65, 'walk')
self._actor.setPlayRate(-2.65, 'reverse-walk')
self._actor.setPlayRate(4, 'punch')
self._actor.setPlayRate(5.25, 'throw')
self._actor.setBlend(frameBlend=True)
self._actor.reparentTo(self._model)
self._actor.loop('idle')
self._actor.setH(180)
# Floating Label
text = TextNode('node name')
text.setText(self.__class__.__name__)
text.setAlign(TextNode.ACenter)
self._name_label = self._model.attachNewNode(text)
self._name_label.setBillboardPointEye()
self._name_label.setPos(Vec3(0, 0, 6))
self._name_label.setScale(3, 3, 3)
# Debug Field of View Cones
# fov = make_fov()
# fov.reparentTo(self._model)
def update(self, tick_number, visible_objects):
return Actions.DoNothing
def get_position(self):
"""Return a rounded version of the position vector."""
p = self._model.getPos()
return Vec3(round(p.x, 0), round(p.y, 0), round(p.z, 0))
def get_direction(self):
"""Return a rounded version of the direction vector."""
v = render.getRelativeVector(self._model, Vec3(0, 1, 0))
v.normalize()
return Vec3(round(v.x, 0), round(v.y, 0), round(v.z, 0))
def get_name(self):
return self.__class__.__name__
def _get_orders(self, tick_number, visible_objects):
# If the health is too low, die.
if self._hp <= 0:
self._orders = Actions.Suicide
return
# noinspection PyBroadException
try:
self._orders = self.update(tick_number, visible_objects)
except Exception as e:
print(type(self), e)
self._orders = None
def _execute_orders(self, tick_length, battle):
# Pre-calculate some useful things
new_pos = self.get_position()
new_dir = self._model.getHpr() # TODO: Getting rounding errors here
velocity = self.get_direction()
# If we're outside of the arena, take damage
ARENA_SIZE = 13
if new_pos.length() > ARENA_SIZE:
battle.announce("{} fled the battle!".format(self.get_name()))
self.take_damage(999)
# Execute the order
if self._orders == Actions.MoveForward:
new_pos += velocity
self.safe_loop('walk')
elif self._orders == Actions.MoveBackward:
new_pos -= velocity
self.safe_loop('reverse-walk')
elif self._orders == Actions.StrafeLeft:
v = render.getRelativeVector(self._model, Vec3(-1, 0, 0))
v.normalize()
v = Vec3(round(v.x, 0), round(v.y, 0), round(v.z, 0))
new_pos += v
self.safe_loop('walk')
elif self._orders == Actions.StrafeRight:
v = render.getRelativeVector(self._model, Vec3(1, 0, 0))
v.normalize()
v = Vec3(round(v.x, 0), round(v.y, 0), round(v.z, 0))
new_pos += v
self.safe_loop('walk')
elif self._orders == Actions.TurnLeft:
new_dir.x += 90
self.safe_loop('walk')
elif self._orders == Actions.TurnAround:
new_dir.x += 180
self.safe_loop('walk')
elif self._orders == Actions.TurnRight:
new_dir.x -= 90
self.safe_loop('walk')
elif self._orders == Actions.Punch:
self.punch(battle)
elif self._orders == Actions.DoNothing:
self.safe_loop('idle')
elif self._orders == Actions.Suicide:
self._hp = 0
battle.announce("{} killed itself.".format(self.get_name()))
self.take_damage(999)
else: # Bad orders detected! Kill this bot.
self._hp = 0
battle.announce("{} made an illegal move and died.".format(self.get_name()))
self.take_damage(999)
# Animate the motion
if self._hp <= 0:
return
self._interval = LerpPosHprInterval(
self._model, tick_length-0.05, new_pos, new_dir)
self._interval.start()
def safe_loop(self, animation):
if self._death_played:
return
if self._actor.getCurrentAnim() != animation:
self._actor.loop(animation)
def punch(self, battle):
if not self._death_played:
self._actor.play('punch')
hazard = self.get_direction() + self.get_position()
bot = battle.get_object_at_position(hazard)
if isinstance(bot, Bot):
bot.take_damage(5) # TODO: This is fun as 1
if bot._hp > 0:
return
if bot.team == self.team:
message = "{self} killed its teammate {target}!"
self.kills -= 1
else:
message = "{self} just pwned {target}!"
self.kills += 1
battle.announce(message.format(self=self.get_name(),
target=bot.get_name()),
color=self.team,
sfx="Ownage" if self.kills == 1 else None)
if self.kills == 2:
battle.announce("{} is ON FIRE!".format(self.get_name()),
color=(1.0, 0.5, 0.0, 1.0), sfx="DoubleKill")
elif self.kills == 3:
battle.announce("{} is UNSTOPPABLE!".format(self.get_name()),
color=(1.0, 0.5, 0.0, 1.0), sfx="TripleKill")
elif self.kills == 4:
battle.announce("{} is DOMINATING!".format(self.get_name()),
color=(1.0, 0.5, 0.0, 1.0), sfx="Dominating")
elif self.kills > 4:
battle.announce("{} is GODLIKE!".format(self.get_name()),
color=(1.0, 0.5, 0.0, 1.0), sfx="Godlike")
def take_damage(self, amount):
self._hp -= amount
if self._hp <= 0:
self._name_label.hide()
if self._interval:
self._interval.pause()
if not self._death_played:
self._actor.play('death')
self._death_played = True
def delete(self):
self._model.removeNode()
self._actor.cleanup()
self._name_label.removeNode()
def _execute_orders(self, tick_length, battle):
# Pre-calculate some useful things
new_pos = self.get_position()
new_dir = self._model.getHpr() # TODO: Getting rounding errors here
velocity = self.get_direction()
# If we're outside of the arena, take damage
ARENA_SIZE = 13
if new_pos.length() > ARENA_SIZE:
battle.announce("{} fled the battle!".format(self.get_name()))
self.take_damage(999)
# Execute the order
if self._orders == Actions.MoveForward:
new_pos += velocity
self.safe_loop('walk')
elif self._orders == Actions.MoveBackward:
new_pos -= velocity
self.safe_loop('reverse-walk')
elif self._orders == Actions.StrafeLeft:
v = render.getRelativeVector(self._model, Vec3(-1, 0, 0))
v.normalize()
v = Vec3(round(v.x, 0), round(v.y, 0), round(v.z, 0))
new_pos += v
self.safe_loop('walk')
elif self._orders == Actions.StrafeRight:
v = render.getRelativeVector(self._model, Vec3(1, 0, 0))
v.normalize()
v = Vec3(round(v.x, 0), round(v.y, 0), round(v.z, 0))
new_pos += v
self.safe_loop('walk')
elif self._orders == Actions.TurnLeft:
new_dir.x += 90
self.safe_loop('walk')
elif self._orders == Actions.TurnAround:
new_dir.x += 180
self.safe_loop('walk')
elif self._orders == Actions.TurnRight:
new_dir.x -= 90
self.safe_loop('walk')
elif self._orders == Actions.Punch:
self.punch(battle)
elif self._orders == Actions.DoNothing:
self.safe_loop('idle')
elif self._orders == Actions.Suicide:
self._hp = 0
battle.announce("{} killed itself.".format(self.get_name()))
self.take_damage(999)
else: # Bad orders detected! Kill this bot.
self._hp = 0
battle.announce("{} made an illegal move and died.".format(self.get_name()))
self.take_damage(999)
# Animate the motion
if self._hp <= 0:
return
self._interval = LerpPosHprInterval(
self._model, tick_length-0.05, new_pos, new_dir)
self._interval.start()
def __init__(self):
load_prc_file_data(
"", """
win-size 1680 1050
window-title P3D Space Tech Demo Skybox Test 1
show-frame-rate-meter #t
framebuffer-multisample 1
multisamples 4
view-frustum-cull 0
textures-power-2 none
hardware-animated-vertices #t
gl-depth-zero-to-one true
clock-frame-rate 60
interpolate-frames 1
cursor-hidden #t
fullscreen #f
""")
# Initialize the showbase
super().__init__()
gltf.patch_loader(self.loader)
props = WindowProperties()
props.set_mouse_mode(WindowProperties.M_relative)
base.win.request_properties(props)
base.set_background_color(0.5, 0.5, 0.8)
self.camLens.set_fov(80)
self.camLens.set_near_far(0.01, 90000)
self.camLens.set_focal_length(7)
self.camera.set_pos(-300, -300, 0)
# ConfigVariableManager.getGlobalPtr().listVariables()
# point light generator
for x in range(0, 3):
plight_1 = PointLight('plight')
# add plight props here
plight_1_node = self.render.attach_new_node(plight_1)
# group the lights close to each other to create a sun effect
plight_1_node.set_pos(random.uniform(-21, -20),
random.uniform(-21, -20),
random.uniform(20, 21))
self.render.set_light(plight_1_node)
# point light for volumetric lighting filter
plight_1 = PointLight('plight')
# add plight props here
plight_1_node = self.render.attach_new_node(plight_1)
# group the lights close to each other to create a sun effect
plight_1_node.set_pos(random.uniform(-21, -20),
random.uniform(-21, -20), random.uniform(20, 21))
self.render.set_light(plight_1_node)
scene_filters = CommonFilters(base.win, base.cam)
scene_filters.set_bloom()
scene_filters.set_high_dynamic_range()
scene_filters.set_exposure_adjust(0.6)
scene_filters.set_gamma_adjust(1.1)
# scene_filters.set_volumetric_lighting(plight_1_node, 32, 0.5, 0.7, 0.1)
# scene_filters.set_blur_sharpen(0.9)
# scene_filters.set_ambient_occlusion(32, 0.05, 2.0, 0.01, 0.000002)
self.accept("f3", self.toggle_wireframe)
self.accept("escape", sys.exit, [0])
exponential_fog = Fog('world_fog')
exponential_fog.set_color(0.6, 0.7, 0.7)
# this is a very low fog value, set it higher for a greater effect
exponential_fog.set_exp_density(0.00009)
# self.render.set_fog(exponential_fog)
self.game_start = 0
skybox = self.loader.load_model('skyboxes/40k_test.gltf')
skybox.reparent_to(self.camera)
skybox.setCompass()
skybox.setBin("background", 1)
skybox.setDepthWrite(False)
aster_bool = False
# add some asteroids
for x in range(100):
ran_pos = Vec3(random.uniform(-300,
300), random.uniform(-300, 300),
random.uniform(-300, 300))
if not aster_bool:
asteroid = self.loader.load_model('models/asteroid_1.gltf')
aster_bool = True
if aster_bool:
asteroid = self.loader.load_model('models/asteroid_2.gltf')
aster_bool = False
asteroid.reparent_to(self.render)
asteroid.set_pos(ran_pos)
asteroid.set_scale(random.uniform(0.1, 10))
a_pos = asteroid.get_pos()
ran_inter = random.uniform(-20, 20)
ran_h = random.uniform(-180, 180)
asteroid.set_h(ran_h)
a_rotate = LerpPosHprInterval(asteroid, 100,
(a_pos[0] + ran_inter, a_pos[1] +
ran_inter, a_pos[2] + ran_inter),
(360, 360, 0)).loop()
# load the scene shader
scene_shader = Shader.load(Shader.SL_GLSL,
"shaders/simplepbr_vert_mod_1.vert",
"shaders/simplepbr_frag_mod_1.frag")
self.render.set_shader(scene_shader)
self.render.set_antialias(AntialiasAttrib.MMultisample)
scene_shader = ShaderAttrib.make(scene_shader)
scene_shader = scene_shader.setFlag(ShaderAttrib.F_hardware_skinning,
True)
# directly make a text node to display text
text_2 = TextNode('text_2_node')
text_2.set_text("P3D Space Tech Demo Skybox Test")
text_2_node = self.aspect2d.attach_new_node(text_2)
text_2_node.set_scale(0.04)
text_2_node.set_pos(-1.4, 0, 0.8)
# import font and set pixels per unit font quality
nunito_font = self.loader.load_font('fonts/Nunito/Nunito-Light.ttf')
nunito_font.set_pixels_per_unit(100)
nunito_font.set_page_size(512, 512)
# apply font
text_2.set_font(nunito_font)
text_2.set_text_color(0.1, 0.1, 0.1, 1)
# 3D player movement system begins
self.keyMap = {
"left": 0,
"right": 0,
"forward": 0,
"backward": 0,
"run": 0,
"jump": 0,
"up": 0,
"down": 0
}
def setKey(key, value):
self.keyMap[key] = value
# define button map
self.accept("a", setKey, ["left", 1])
self.accept("a-up", setKey, ["left", 0])
self.accept("d", setKey, ["right", 1])
self.accept("d-up", setKey, ["right", 0])
self.accept("w", setKey, ["forward", 1])
self.accept("w-up", setKey, ["forward", 0])
self.accept("s", setKey, ["backward", 1])
self.accept("s-up", setKey, ["backward", 0])
self.accept("lshift", setKey, ["up", 1])
self.accept("lshift-up", setKey, ["up", 0])
self.accept("lcontrol", setKey, ["down", 1])
self.accept("lcontrol-up", setKey, ["down", 0])
self.accept("space", setKey, ["jump", 1])
self.accept("space-up", setKey, ["jump", 0])
# disable mouse
self.disable_mouse()
# the player movement speed
self.inc_var = 1
self.max_speed_inc = 0.02
self.max_abs_speed = 0.2
self.inertia_x = 0
self.inertia_y = 0
self.inertia_z = 0
def move(Task):
if self.game_start > 0:
# get mouse data
mouse_watch = base.mouseWatcherNode
if mouse_watch.has_mouse():
pointer = base.win.get_pointer(0)
mouseX = pointer.get_x()
mouseY = pointer.get_y()
# screen sizes
window_Xcoord_halved = base.win.get_x_size() // 2
window_Ycoord_halved = base.win.get_y_size() // 2
# mouse speed
mouseSpeedX = 0.2
mouseSpeedY = 0.2
# maximum and minimum pitch
maxPitch = 90
minPitch = -50
# cam view target initialization
camViewTarget = LVecBase3f()
# clock
dt = globalClock.get_dt()
if base.win.movePointer(0, window_Xcoord_halved,
window_Ycoord_halved):
p = 0
if mouse_watch.has_mouse():
# calculate the pitch of camera
p = self.camera.get_p() - (
mouseY - window_Ycoord_halved) * mouseSpeedY
# sanity checking
if p < minPitch:
p = minPitch
elif p > maxPitch:
p = maxPitch
if mouse_watch.has_mouse():
# directly set the camera pitch
self.camera.set_p(p)
camViewTarget.set_y(p)
# rotate the self.player's heading according to the mouse x-axis movement
if mouse_watch.has_mouse():
h = self.camera.get_h() - (
mouseX - window_Xcoord_halved) * mouseSpeedX
if mouse_watch.has_mouse():
# sanity checking
if h < -360:
h += 360
elif h > 360:
h -= 360
self.camera.set_h(h)
camViewTarget.set_x(h)
if self.inertia_x > self.max_abs_speed:
self.inertia_x = self.max_abs_speed
if self.inertia_y > self.max_abs_speed:
self.inertia_y = self.max_abs_speed
if self.inertia_z > self.max_abs_speed:
self.inertia_z = self.max_abs_speed
if self.keyMap["right"]:
if self.inertia_x > 0:
self.inertia_x += self.inc_var * dt
else:
self.inertia_x = self.max_speed_inc
self.camera.set_x(self.camera, self.inertia_x)
if self.keyMap["left"]:
if self.inertia_x < 0:
self.inertia_x -= self.inc_var * dt
else:
self.inertia_x = -self.max_speed_inc
self.camera.set_x(self.camera, self.inertia_x)
if self.keyMap["forward"]:
# print(self.inertia_y)
if self.inertia_y > 0:
self.inertia_y += self.inc_var * dt
else:
self.inertia_y = self.max_speed_inc
self.camera.set_y(self.camera, self.inertia_y)
if self.keyMap["backward"]:
if self.inertia_y < 0:
self.inertia_y -= self.inc_var * dt
else:
self.inertia_y = -self.max_speed_inc
self.camera.set_y(self.camera, self.inertia_y)
if self.keyMap["up"]:
if self.inertia_z > 0:
self.inertia_z += self.inc_var * dt
else:
self.inertia_z = self.max_speed_inc
self.camera.set_z(self.camera, self.inertia_z)
if self.keyMap["down"]:
if self.inertia_z < 0:
self.inertia_z -= self.inc_var * dt
else:
self.inertia_z = -self.max_speed_inc
self.camera.set_z(self.camera, self.inertia_z)
else:
self.camera.set_x(self.camera, self.inertia_x)
self.camera.set_y(self.camera, self.inertia_y)
self.camera.set_z(self.camera, self.inertia_z)
return Task.cont
def update(Task):
if self.game_start < 1:
self.game_start = 1
return Task.cont
self.task_mgr.add(move)
self.task_mgr.add(update)
def SetupModel(self, VUTProject):
source = osr.SpatialReference()
source.ImportFromEPSG(4326)
target = osr.SpatialReference()
target.ImportFromEPSG(int(self.OutEPSG))
transform = osr.CoordinateTransformation(source, target)
BBxMin = float(self.VRTBoundingBox.split(':')[0].split(',')[0])
BByMin = float(self.VRTBoundingBox.split(':')[0].split(',')[1])
BBxMax = float(self.VRTBoundingBox.split(':')[1].split(',')[0])
BByMax = float(self.VRTBoundingBox.split(':')[1].split(',')[1])
XLenght = BBxMax - BBxMin
YLenght = BByMax - BByMin
NewBBxMax = BBxMax + XLenght / 2
NewBBxMin = BBxMin - XLenght / 2
NewBByMax = BByMax + YLenght / 2
NewBByMin = BByMin - YLenght / 2
pointMax = ogr.Geometry(ogr.wkbPoint)
pointMax.AddPoint(NewBBxMax, NewBByMax)
pointMax.Transform(transform)
pointMin = ogr.Geometry(ogr.wkbPoint)
pointMin.AddPoint(NewBBxMin, NewBByMin)
pointMin.Transform(transform)
self.BoundingBoxStr = '-te ' + str(pointMin.GetX()) + ' ' + str(
pointMin.GetY()) + ' ' + str(pointMax.GetX()) + ' ' + str(
pointMax.GetY()) + ' '
self.Moves = Sequence()
Line = LineSegs('Path')
with open(VUTProject, 'r') as File:
Counter = 0
i = 0
PrevCourse = None
PrevPos = None
PrevHPr = None
for line in File:
if Counter < 6:
pass
else:
line = line.split()
lat = float(line[0])
lon = float(line[1])
ele = float(line[2])
course = float(line[4])
pitch = float(line[5])
roll = float(line[6])
if course < 180:
course = -course
elif course > 180:
course = abs(course - 360)
point = ogr.Geometry(ogr.wkbPoint)
point.AddPoint(lon, lat)
point.Transform(transform)
if i == 0:
FirstPos = (point.GetX() - self.Origin[0],
point.GetY() - self.Origin[1], ele)
FirstHpr = (course, pitch, roll)
self.cam.setPos(FirstPos)
self.cam.setHpr(FirstHpr)
Line.move_to(point.GetX() - self.Origin[0],
point.GetY() - self.Origin[1], ele)
elif i == 1:
self.Moves.append(
LerpPosHprInterval(
self.cam,
1, (point.GetX() - self.Origin[0],
point.GetY() - self.Origin[1], ele),
(fitDestAngle2Src(PrevCourse,
course), pitch, roll),
startPos=FirstPos,
startHpr=FirstHpr,
name='Interval',
other=self.render))
Line.draw_to(point.GetX() - self.Origin[0],
point.GetY() - self.Origin[1], ele)
else:
self.Moves.append(
LerpPosHprInterval(
self.cam,
1, (point.GetX() - self.Origin[0],
point.GetY() - self.Origin[1], ele),
(fitDestAngle2Src(PrevCourse,
course), pitch, roll),
startPos=PrevPos,
startHpr=PrevHPr,
name='Interval',
other=self.render))
Line.draw_to(point.GetX() - self.Origin[0],
point.GetY() - self.Origin[1], ele)
i = i + 1
PrevCourse = course
PrevPos = (point.GetX() - self.Origin[0],
point.GetY() - self.Origin[1], ele)
PrevHPr = (course, pitch, roll)
Counter = Counter + 1
Line.setColor(1, 0.5, 0.5, 1)
Line.setThickness(3)
node = Line.create(False)
nodePath = self.render.attachNewNode(node)