def __init__(self):
# The basics
ShowBase.__init__(self)
base.disableMouse()
base.setBackgroundColor(0.1, 0.1, 0.1)
base.setFrameRateMeter(True)
PStatClient.connect()
self.accept("escape", sys.exit)
# Camera
self.camera_orbit = base.render.attach_new_node("Camera orbit")
self.camera_pitch = self.camera_orbit.attach_new_node("Camera pitch")
base.camera.reparent_to(self.camera_pitch)
base.camera.set_pos(0, -30, 0)
# Camera control
self.camera_movement = (0, 0)
self.accept("arrow_up", self.change_camera_movement, [ 0, -1])
self.accept("arrow_up-up", self.change_camera_movement, [ 0, 1])
self.accept("arrow_down", self.change_camera_movement, [ 0, 1])
self.accept("arrow_down-up", self.change_camera_movement, [ 0, -1])
self.accept("arrow_left", self.change_camera_movement, [-1, 0])
self.accept("arrow_left-up", self.change_camera_movement, [ 1, 0])
self.accept("arrow_right", self.change_camera_movement, [ 1, 0])
self.accept("arrow_right-up", self.change_camera_movement, [-1, 0])
base.taskMgr.add(self.move_camera, "Move camera")
# Object
self.model = self.create_model()
self.model.reparent_to(base.render)
taskMgr.add(self.refresh_shader_vars, "Refresh shaders variables", sort = 49)
self.accept("r", self.reload_shader)
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 main():
"""Console script for LayerView."""
args = _get_parser().parse_args()
# PStats
pstat_host: str = args.pstat_host
if pstat_host:
if args.pstat_port:
pstat_port: int = args.pstat_port
else:
pstat_port: int = _PSTAT_PORT_DEFAULT
print(f"PStats port not specified, falling back to {pstat_port}")
print(f"Connecting to PStats server at {pstat_host}:{pstat_port}")
# noinspection PyArgumentList
PStatClient.connect(pstat_host, pstat_port)
elif not pstat_host and args.pstat_port:
print("--pstats-port was specified without --pstats-host")
return 1
gcode_path: Optional[Path] = None
if args.gcode_path:
gcode_path = Path(args.gcode_path).absolute()
# Run app
app = App(argv=sys.argv, gcode_path=gcode_path)
app.show()
return app.exec_()
def __init__(self):
# The basics
ShowBase.__init__(self)
base.disableMouse()
base.setBackgroundColor(0.1, 0.1, 0.1)
base.setFrameRateMeter(True)
PStatClient.connect()
self.accept("escape", sys.exit)
# Camera
self.camera_orbit = base.render.attach_new_node("Camera orbit")
self.camera_pitch = self.camera_orbit.attach_new_node("Camera pitch")
base.camera.reparent_to(self.camera_pitch)
base.camera.set_pos(0, -30, 0)
# Camera control
self.camera_movement = (0, 0)
self.accept("arrow_up", self.change_camera_movement, [0, -1])
self.accept("arrow_up-up", self.change_camera_movement, [0, 1])
self.accept("arrow_down", self.change_camera_movement, [0, 1])
self.accept("arrow_down-up", self.change_camera_movement, [0, -1])
self.accept("arrow_left", self.change_camera_movement, [-1, 0])
self.accept("arrow_left-up", self.change_camera_movement, [1, 0])
self.accept("arrow_right", self.change_camera_movement, [1, 0])
self.accept("arrow_right-up", self.change_camera_movement, [-1, 0])
base.taskMgr.add(self.move_camera, "Move camera")
# Object
self.model = self.create_model()
self.model.reparent_to(base.render)
taskMgr.add(self.refresh_shader_vars,
"Refresh shaders variables",
sort=49)
self.accept("r", self.reload_shader)
def main():
from time import time
from direct.showbase.ShowBase import ShowBase
from panda3d.core import loadPrcFileData
from panda3d.core import PStatClient
from .selection import BoxSel
from .util.util import ui_text, console, exit_cleanup
from .ui import CameraControl, Axis3d, Grid3d
from test_objects import makeSimpleGeom
import sys
sys.modules['core'] = sys.modules['panda3d.core']
PStatClient.connect() #run pstats in console
loadPrcFileData('', 'view-frustum-cull 0')
base = ShowBase()
uiRoot = render.attachNewNode("uiRoot")
level2Root = render.attachNewNode('collideRoot')
base.setBackgroundColor(0, 0, 0)
ut = ui_text()
grid = Grid3d()
axis = Axis3d()
cc = CameraControl()
base.disableMouse()
con = console()
exit_cleanup()
#profileOctit()
#counts = [1,250,510,511,512,513,1000,2000,10000]
#counts = [1000,1000]
counts = [999 for _ in range(99)]
for i in range(len(counts)):
nnodes = counts[i]
#positions = np.random.uniform(-nnodes/10,nnodes/10,size=(nnodes,3))
positions = np.cumsum(np.random.randint(-1, 2, (nnodes, 3)), axis=0)
#positions = []
#for j in np.linspace(-10,10,512):
#positions += [[0,v+j,0] for v in np.arange(-1000,1000,100)]
#positions = np.array(positions)
#nnodes = len(positions)
#uuids = np.arange(0,nnodes) * (i + 1)
uuids = np.array(["%s" % uuid4() for _ in range(nnodes)])
geomCollide = np.ones(nnodes) * .5
out = treeMe(level2Root, positions, uuids, geomCollide)
#print(out)
render.attachNewNode(makeSimpleGeom(positions, np.random.rand(4)))
#uiRoot = render.find('uiRoot')
#uiRoot.detach()
bs = BoxSel(
False
) # TODO make it so that all the "root" nodes for the secen are initialized in their own space, probably in with defaults or something globalValues.py?
#base.camLens.setFov(150)
base.run()
def __init__(self):
self.loadDefaultConfig()
self.loadLocalConfig()
if ConfigVariableBool("want-pstats", False):
PStatClient.connect()
# Set up some global objects
self.globalClock = ClockObject.getGlobalClock()
# We will manually manage the clock
self.globalClock.setMode(ClockObject.MSlave)
builtins.globalClock = self.globalClock
self.vfs = VirtualFileSystem.getGlobalPtr()
# For tasks that run every application frame
self.taskMgr = TaskManagerGlobal.taskMgr
builtins.taskMgr = self.taskMgr
# For tasks that run every simulation tick
self.simTaskMgr = Task.TaskManager()
self.simTaskMgr.mgr = AsyncTaskManager("sim")
builtins.simTaskmgr = self.simTaskMgr
self.eventMgr = EventManagerGlobal.eventMgr
builtins.eventMgr = self.eventMgr
self.messenger = MessengerGlobal.messenger
builtins.messenger = self.messenger
self.loader = Loader(self)
builtins.loader = self.loader
builtins.base = self
# What is the current frame number?
self.frameCount = 0
# Time at beginning of current frame
self.frameTime = self.globalClock.getRealTime()
# How long did the last frame take.
self.deltaTime = 0
#
# Variables pertaining to simulation ticks.
#
self.prevRemainder = 0
self.remainder = 0
# What is the current overall simulation tick?
self.tickCount = 0
# How many ticks are we going to run this frame?
self.totalTicksThisFrame = 0
# How many ticks have we run so far this frame?
self.currentTicksThisFrame = 0
# What tick are we currently on this frame?
self.currentFrameTick = 0
# How many simulations ticks are we running per-second?
self.ticksPerSec = 60
self.intervalPerTick = 1.0 / self.ticksPerSec
def main():
from time import time
from direct.showbase.ShowBase import ShowBase
from panda3d.core import loadPrcFileData
from panda3d.core import PStatClient
from .selection import BoxSel
from .util.util import ui_text, console, exit_cleanup
from .ui import CameraControl, Axis3d, Grid3d
from test_objects import makeSimpleGeom
import sys
sys.modules['core'] = sys.modules['panda3d.core']
PStatClient.connect() #run pstats in console
loadPrcFileData('','view-frustum-cull 0')
base = ShowBase()
uiRoot = render.attachNewNode("uiRoot")
level2Root = render.attachNewNode('collideRoot')
base.setBackgroundColor(0,0,0)
ut = ui_text()
grid = Grid3d()
axis = Axis3d()
cc = CameraControl()
base.disableMouse()
con = console()
exit_cleanup()
#profileOctit()
#counts = [1,250,510,511,512,513,1000,2000,10000]
#counts = [1000,1000]
counts = [999 for _ in range(99)]
for i in range(len(counts)):
nnodes = counts[i]
#positions = np.random.uniform(-nnodes/10,nnodes/10,size=(nnodes,3))
positions = np.cumsum(np.random.randint(-1,2,(nnodes,3)), axis=0)
#positions = []
#for j in np.linspace(-10,10,512):
#positions += [[0,v+j,0] for v in np.arange(-1000,1000,100)]
#positions = np.array(positions)
#nnodes = len(positions)
#uuids = np.arange(0,nnodes) * (i + 1)
uuids = np.array(["%s"%uuid4() for _ in range(nnodes)])
geomCollide = np.ones(nnodes) * .5
out = treeMe(level2Root, positions, uuids, geomCollide)
#print(out)
render.attachNewNode(makeSimpleGeom(positions,np.random.rand(4)))
#uiRoot = render.find('uiRoot')
#uiRoot.detach()
bs = BoxSel(False) # TODO make it so that all the "root" nodes for the secen are initialized in their own space, probably in with defaults or something globalValues.py?
#base.camLens.setFov(150)
base.run()
def enterInit(self):
'''
init of main/global structures
'''
self.screen = Screen()
if ConfigVariableBool('stats').getValue():
self.update_gaming=pstat(self.update_gaming)
PStatClient.connect()
taskMgr.add(self.update, 'GameClient.update')
self.acceptOnce('escape',self.demand,extraArgs=['Quit'])
self.demand('Intro')
def __init__(self):
"""Setup this app."""
ShowBase.__init__(self)
#Setup window
wnd_props = WindowProperties()
wnd_props.set_title("Neo Impressive Title")
#wnd_props.set_origin(0, 0)
wnd_props.set_size(1024, 768)
self.win.request_properties(wnd_props)
self.set_background_color(0, .5, 1, 1)
#Init GUI sub-system
self.gui = GUI(self)
self.gui.run()
#Init app state
self.state = APP_STATE_LOGO
self.logo_delay = 600
#Start title music
self.title_music = loader.loadMusic("./data/sounds/title.ogg")
self.title_music.set_loop(True)
self.title_music.play()
#Setup collision detection
self.cTrav = CollisionTraverser()
self.portal_handler = CollisionHandlerEvent()
self.portal_handler.add_in_pattern("%fn-entered-%in")
#Init other sub-systems
self.cam_mgr = CameraManager()
self.world_mgr = WorldManager()
#Setup lighting
self.ambient = AmbientLight("Ambient Light")
self.ambient.set_color(Vec4(.5, .5, .5, 1))
self.ambient_np = self.render.attach_new_node(self.ambient)
self.render.set_light(self.ambient_np)
self.sun = DirectionalLight("Sun")
self.sun_np = self.render.attach_new_node(self.sun)
self.sun_np.set_p(-135)
self.render.set_light(self.sun_np)
#Setup auto-shaders
self.render.set_shader_auto()
#Debug stats
#self.messenger.toggle_verbose()
PStatClient.connect()
def __init__(self,
tex_classes,
stim_params,
initial_tex_ind=0,
window_size=512,
window_name="InputControlStim",
profile_on=False,
fps=30,
save_path=None):
super().__init__()
self.current_tex_num = initial_tex_ind
self.previous_tex_num = None
self.tex_classes = tex_classes
self.stim_params = stim_params
self.window_size = window_size
self.stimulus_initialized = False # for setting up first stim (don't clear cards they don't exist)
self.fps = fps
self.profile_on = profile_on
self.save_path = save_path
if self.save_path:
self.filestream = utils.save_initialize(save_path, tex_classes,
stim_params)
else:
self.filestream = None
self.scale = np.sqrt(
8) #so it can handle arbitrary rotations and shifts
self.window_name = window_name
#Window properties
self.window_props = WindowProperties()
self.window_props.setSize(self.window_size, self.window_size)
self.set_title(self.window_name)
# Set frame rate
ShowBaseGlobal.globalClock.setMode(ClockObject.MLimited)
ShowBaseGlobal.globalClock.setFrameRate(self.fps)
#Set up profiling if desired
if self.profile_on:
PStatClient.connect() # this will only work if pstats is running
ShowBaseGlobal.base.setFrameRateMeter(True) #Show frame rate
#Set initial texture(s)
self.set_stimulus(str(self.current_tex_num))
# Set up event handlers (accept) and tasks (taskMgr) for dynamics
self.accept('stim0', self.set_stimulus, ['0'])
self.accept('stim1', self.set_stimulus, ['1'])
self.accept('stim2', self.set_stimulus, ['2'])
# Wrinkle: should we set this here or there?
self.taskMgr.add(self.move_textures, "move textures")
def __igLoop(self):
if self.renderRequested:
self.graphicsEngine.renderFrame()
#self.graphicsEngine.syncFrame()
#self.graphicsEngine.readyFlip()
self.graphicsEngine.flipFrame()
#self.graphicsEngine.openWindows()
self.renderRequested = False
else:
#self.graphicsEngine.flipFrame()
self.globalClock.tick()
PStatClient.mainTick()
throwNewFrame()
def tryStartPstats(self):
""" Starts the 'text-stats' PStatClient and connects to that client, in order
to make pstats generate timings """
self.procHandle = None
if not PStatClient.getGlobalPstats().isConnected() and self.startDummyPstats:
self.debug("Starting dummy pstats (text-stats)")
nullFile = open(os.devnull, 'w')
self.procHandle = subprocess.Popen(["text-stats"], stdout=nullFile, stderr=nullFile)
atexit.register(self.stopPstats)
PStatClient.connect()
else:
self.debug("PStats already running")
def __init__(self,
tex,
angle=0,
velocity=0.1,
fps=30,
window_name="ShowTexMoving",
window_size=None,
profile_on=False):
super().__init__()
self.tex = tex
if window_size is None:
self.window_size = self.tex.texture_size
else:
self.window_size = window_size
self.angle = angle
self.velocity = velocity
self.texture_stage = TextureStage("texture_stage")
self.window_name = window_name
# Set frame rate (fps)
ShowBaseGlobal.globalClock.setMode(ClockObject.MLimited)
ShowBaseGlobal.globalClock.setFrameRate(fps)
#Set up profiling if desired
if profile_on:
PStatClient.connect(
) # this will only work if pstats is running: see readme
ShowBaseGlobal.base.setFrameRateMeter(True) #Show frame rate
self.center_indicator = None
#Window properties set up
self.window_properties = WindowProperties()
self.window_properties.setSize(self.window_size, self.window_size)
self.window_properties.setTitle(window_name)
ShowBaseGlobal.base.win.requestProperties(self.window_properties)
#Create scenegraph, attach stimulus to card.
cm = CardMaker('card')
cm.setFrameFullscreenQuad()
self.card = self.aspect2d.attachNewNode(cm.generate())
# Scale is so it can handle arbitrary rotations and shifts in binocular case
self.card.setScale(np.sqrt(8))
self.card.setColor(
(1, 1, 1, 1)
) # makes it bright when bright (default combination with card is add)
self.card.setTexture(self.texture_stage, self.tex.texture)
self.card.setTexRotate(self.texture_stage, self.angle)
if self.velocity != 0:
#Add task to taskmgr to translate texture
self.taskMgr.add(self.moveTextureTask, "moveTextureTask")
def __init__(self,
tex_classes,
stim_params,
window_size=512,
profile_on=False,
fps=30,
save_path=None):
super().__init__()
self.tex_classes = tex_classes
self.current_tex_num = 0
self.stim_params = stim_params
self.window_size = window_size
self.stimulus_initialized = False #to handle case from -1 (uninitalize) to 0 (first stim)
self.fps = fps
self.save_path = save_path
if self.save_path:
self.filestream = utils.save_initialize(save_path, tex_classes,
stim_params)
else:
self.filestream = None
#Window properties
self.windowProps = WindowProperties()
self.windowProps.setSize(self.window_size, self.window_size)
self.set_title("Initializing")
#Create scenegraph
cm = CardMaker('card')
cm.setFrameFullscreenQuad()
self.card = self.aspect2d.attachNewNode(cm.generate())
self.card.setScale(np.sqrt(8))
self.texture_stage = TextureStage("texture_stage")
# Set frame rate
ShowBaseGlobal.globalClock.setMode(ClockObject.MLimited)
ShowBaseGlobal.globalClock.setFrameRate(
self.fps) #can lock this at whatever
if profile_on:
PStatClient.connect()
ShowBaseGlobal.base.setFrameRateMeter(True)
#Set initial texture
self.set_stimulus(str(self.current_tex_num))
# Set up event handlers and tasks
self.accept('0', self.set_stimulus, ['0']) #event handler
self.accept('1', self.set_stimulus, ['1'])
self.taskMgr.add(self.move_texture_task, "move_texture") #task
def __init__(self):
ShowBase.__init__(self)
logging.basicConfig(level=logging.DEBUG)
log.info("initializing...")
#
self.disableMouse()
self.setFrameRateMeter(True)
self.render.setShaderAuto()
#
gameplay=Gameplay(self)
gameplay.start()
#
PStatClient.connect()
#
log.info("done initializing")
def pstats(host='localhost', port=5185):
""" Tell the AI to connect a PStatsClient to the server specified. """
conn = PStatClient.connect(host, port)
if conn:
return "%s has successfully opened a PStat connection to %s:%d" % (
simbase.air.distributedDistrict.getName(), host, port)
return "%s was unable to open a PStat connection to %s:%d." % (
simbase.air.distributedDistrict.getName(), host, port)
def main():
from panda3d.core import PStatClient
from panda3d.core import loadPrcFileData
from .ui import CameraControl, Axis3d, Grid3d
#loadPrcFileData('','threading-model Cull/Draw') #XXX wow, not good for this use case...
base = ShowBase()
base.disableMouse()
base.setBackgroundColor(0, 0, 0)
cc = CameraControl()
ax = Axis3d()
gd = Grid3d()
#nt = emptyTest(2000)
gt = geomTest(2000)
PStatClient.connect()
base.run()
def __pstats(self, event):
box = event.GetEventObject()
box.Disable()
if box.GetValue():
if not self.getProcesses('pstats'):
subprocess.Popen([self.getPStatsPath()])
PStatClient.connect()
else:
PStatClient.disconnect()
for process in self.getProcesses('pstats'):
process.kill()
taskMgr.doMethodLater(1, lambda task: box.Enable(),
'enableElement-%d' % id(box))
def main():
from panda3d.core import PStatClient
from panda3d.core import loadPrcFileData
from .ui import CameraControl, Axis3d, Grid3d
#loadPrcFileData('','threading-model Cull/Draw') #XXX wow, not good for this use case...
base = ShowBase()
base.disableMouse()
base.setBackgroundColor(0,0,0)
cc = CameraControl()
ax = Axis3d()
gd = Grid3d()
#nt = emptyTest(2000)
gt = geomTest(2000)
PStatClient.connect()
base.run()
def pstats(host='localhost', port=5185):
""" Tell the AI to connect a PStatsClient to the server specified. """
conn = PStatClient.connect(host, port)
if conn:
return "%s has successfully opened a PStat connection to %s:%d" % (
simbase.air.distributedDistrict.getName(), host, port)
return "%s was unable to open a PStat connection to %s:%d." % (
simbase.air.distributedDistrict.getName(), host, port)
def go(self):
if (PStatClient.connect() == 0):
# No pstat server - create it, then try and connect again...
self.pstats = subprocess.Popen(['pstats'])
# Need to give pstats some time to warm up - use a do latter task...
def tryAgain(task):
PStatClient.connect()
taskMgr.doMethodLater(0.5, tryAgain, 'pstats again')
def run_with_profiling(self, *args, **kwargs):
import cProfile
from trosnoth.utils.profiling import KCacheGrindOutputter
try:
from panda3d.core import PStatClient
PStatClient.connect()
except ImportError:
pass
prof = cProfile.Profile()
try:
prof.runcall(self.run_twisted, *args, **kwargs)
except SystemExit:
pass
finally:
kg = KCacheGrindOutputter(prof)
with open('trosnoth.log', 'w') as f:
kg.output(f)
def _main():
from .util.util import ui_text
from .ui import CameraControl, Axis3d, Grid3d
#from panda3d.core import ConfigVariableBool
#ConfigVariableString('view-frustum-cull',False)
from panda3d.core import loadPrcFileData
from time import time
from panda3d.core import PStatClient
from dragsel import BoxSel
PStatClient.connect()
loadPrcFileData('', 'view-frustum-cull 0')
#loadPrcFileData('','threading-model Cull/Draw') #bad for lots of nodes
base = ShowBase()
base.setBackgroundColor(0, 0, 0)
ut = ui_text()
grid = Grid3d()
axis = Axis3d()
cc = CameraControl()
base.disableMouse()
#pt = PointsTest(999,99999)
#pt = PointsTest(1,9999999)
#pt = PointsTest(1,999999) #SLOW AS BALLS: IDEA: render faraway nodes as static meshes and transform them to live as we get closer!
#pt = PointsTest(9999999,1)
#pt = PointsTest(99999,100) #runs fine when there is only 1 node >_<
#pt = PointsTest(999,10) #runs fine when there is only 1 node >_<
#pt = PointsTest(1,99999) #still slow :/
#pt = PointsTest(1,9999) #still slow :/ #deep trees segfault!
#pt = PointsTest(1,4000) #still slow :/ #this one is ok
#pt = PointsTest(1,999) #still slow
#pt = PointsTest(1,499) #still slow 15 fps with 0,0,0 positioned geom points
#pt = PointsTest(1,249) #about 45fps :/
bins = 1 #999=.057, below 200 ~.044 so hard to tell (for n = 99)
#FIXME low numbers of points causes major problems!
#nt = NodeTest(999999,bins) #the inscreased time is more pronounced with larger numbers of nodes... is it the serialization?
#ct = CollTest(9999,bins) #the inscreased time is more pronounced with larger numbers of nodes... is it the serialization?
#nt = NodeTest(999,5)
#base.camLens.setFar(9E12) #view-frustum-cull 0
bs = BoxSel() #some stuff
ft = FullTest(999, bins)
base.run(
) #looks like this is the slow case... probably should look into non blocking model loading?
def togglePStats(self):
if PStatClient.isConnected():
PStatClient.disconnect()
else:
# in production, show stats viewer on the server
if base.config.GetBool("pstats-view-on-server", False):
PStatClient.connect("127.0.0.1" if not metadata.IS_PRODUCTION
else "gameserver.coginvasion.online")
else:
PStatClient.connect("127.0.0.1")
def _main():
from .util.util import ui_text
from .ui import CameraControl, Axis3d, Grid3d
#from panda3d.core import ConfigVariableBool
#ConfigVariableString('view-frustum-cull',False)
from panda3d.core import loadPrcFileData
from time import time
from panda3d.core import PStatClient
from dragsel import BoxSel
PStatClient.connect()
loadPrcFileData('','view-frustum-cull 0')
#loadPrcFileData('','threading-model Cull/Draw') #bad for lots of nodes
base = ShowBase()
base.setBackgroundColor(0,0,0)
ut = ui_text()
grid = Grid3d()
axis = Axis3d()
cc = CameraControl()
base.disableMouse()
#pt = PointsTest(999,99999)
#pt = PointsTest(1,9999999)
#pt = PointsTest(1,999999) #SLOW AS BALLS: IDEA: render faraway nodes as static meshes and transform them to live as we get closer!
#pt = PointsTest(9999999,1)
#pt = PointsTest(99999,100) #runs fine when there is only 1 node >_<
#pt = PointsTest(999,10) #runs fine when there is only 1 node >_<
#pt = PointsTest(1,99999) #still slow :/
#pt = PointsTest(1,9999) #still slow :/ #deep trees segfault!
#pt = PointsTest(1,4000) #still slow :/ #this one is ok
#pt = PointsTest(1,999) #still slow
#pt = PointsTest(1,499) #still slow 15 fps with 0,0,0 positioned geom points
#pt = PointsTest(1,249) #about 45fps :/
bins = 1 #999=.057, below 200 ~.044 so hard to tell (for n = 99)
#FIXME low numbers of points causes major problems!
#nt = NodeTest(999999,bins) #the inscreased time is more pronounced with larger numbers of nodes... is it the serialization?
#ct = CollTest(9999,bins) #the inscreased time is more pronounced with larger numbers of nodes... is it the serialization?
#nt = NodeTest(999,5)
#base.camLens.setFar(9E12) #view-frustum-cull 0
bs = BoxSel() #some stuff
ft = FullTest(999,bins)
base.run() #looks like this is the slow case... probably should look into non blocking model loading?
def run(self):
while self.running:
# Manually advance the clock
now = self.globalClock.getRealTime()
self.deltaTime = now - self.frameTime
self.frameTime = now
self.globalClock.setFrameTime(self.frameTime)
self.globalClock.setDt(self.deltaTime)
self.globalClock.setFrameCount(self.frameCount)
# Tick PStats if we are connected
PStatClient.mainTick()
self.preRunFrame()
self.runFrame()
self.postRunFrame()
self.frameCount += 1
def update(self, entities_by_filter):
context = base.device_listener.read_context('debug')
if context['quit']:
sys.exit()
if context['pdb']:
import pdb
pdb.set_trace()
if context['pstats']:
base.pstats = True
PStatClient.connect()
if context['frame_rate_meter']:
self.frame_rate_meter = not self.frame_rate_meter
base.set_frame_rate_meter(self.frame_rate_meter)
if context['console']:
if not hasattr(base, 'console'):
print("No console present.")
return
self.console_open = not self.console_open
if self.console_open:
base.console.node().show()
else:
base.console.node().hide()
def __init__(self, create_model=True):
# The basics
ShowBase.__init__(self)
base.disableMouse()
base.setBackgroundColor(0, 0, 0)
base.setFrameRateMeter(True)
PStatClient.connect()
self.accept("escape", sys.exit)
# Camera
self.camera_orbit = base.render.attach_new_node("Camera orbit")
self.camera_pitch = self.camera_orbit.attach_new_node("Camera pitch")
base.camera.reparent_to(self.camera_pitch)
base.camera.set_pos(0, -10, 0)
self.rotation_mode = False
self.mouse_pos = None
self.accept("mouse3", self.set_rotation_mode, [True])
self.accept("mouse3-up", self.set_rotation_mode, [False])
self.accept("wheel_up", self.move_camera_distance, [-1])
self.accept("wheel_down", self.move_camera_distance, [1])
base.taskMgr.add(self.move_camera, "Move camera")
# Object
if create_model:
self.create_model()
def __init__(self, create_model=True):
# The basics
ShowBase.__init__(self)
base.disableMouse()
base.setBackgroundColor(0, 0, 0)
base.setFrameRateMeter(True)
PStatClient.connect()
self.accept("escape", sys.exit)
# Camera
self.camera_orbit = base.render.attach_new_node("Camera orbit")
self.camera_pitch = self.camera_orbit.attach_new_node("Camera pitch")
base.camera.reparent_to(self.camera_pitch)
base.camera.set_pos(0, -10, 0)
self.rotation_mode = False
self.mouse_pos = None
self.accept("mouse3", self.set_rotation_mode, [True])
self.accept("mouse3-up", self.set_rotation_mode, [False])
self.accept("wheel_up", self.move_camera_distance, [-1])
self.accept("wheel_down", self.move_camera_distance, [1])
base.taskMgr.add(self.move_camera, "Move camera")
# Object
if create_model:
self.create_model()
def main():
from .util.util import ui_text, frame_rate, exit_cleanup, startup_data
from .ui import CameraControl, Axis3d, Grid3d
from panda3d.core import loadPrcFileData
from time import time
from panda3d.core import PStatClient
from .selection import BoxSel
from .render_manager import renderManager
PStatClient.connect()
loadPrcFileData('','view-frustum-cull 0')
base = ShowBase()
base.setBackgroundColor(0,0,0)
ut = ui_text()
grid = Grid3d()
axis = Axis3d()
cc = CameraControl()
base.disableMouse()
frame_rate()
startup_data()
#render something
#ct = CollTest(2000)
#ft = FullTest(99,1)
renderManager()
frames = {'data':GuiFrame('data','f')}
bs = BoxSel(frames) # FIXME must be started after renderManager >_<
dnd = dond()
#d4d = do4d()
ec = exit_cleanup()
ac = AcceptKeys()
base.run() # we don't need threading for this since panda has a builtin events interface
def main():
from .util.util import ui_text, frame_rate, exit_cleanup, startup_data
from .ui import CameraControl, Axis3d, Grid3d
from panda3d.core import loadPrcFileData
from time import time
from panda3d.core import PStatClient
from .selection import BoxSel
from .render_manager import renderManager
PStatClient.connect()
loadPrcFileData('', 'view-frustum-cull 0')
base = ShowBase()
base.setBackgroundColor(0, 0, 0)
ut = ui_text()
grid = Grid3d()
axis = Axis3d()
cc = CameraControl()
base.disableMouse()
frame_rate()
startup_data()
#render something
#ct = CollTest(2000)
#ft = FullTest(99,1)
renderManager()
frames = {'data': GuiFrame('data', 'f')}
bs = BoxSel(frames) # FIXME must be started after renderManager >_<
#dnd = dond()
d4d = do4d()
ec = exit_cleanup()
ac = AcceptKeys()
base.run(
) # we don't need threading for this since panda has a builtin events interface
def __init__(self):
ShowBase.__init__(self)
#input setup
self.keys = {"w": 0, "t": 0}
#socket init
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.socket.connect((host, port))
self.toSend = Queue.Queue(1000)
self.toProcess = Queue.Queue(1000)
self.level = None
self.socket.setblocking(False)
self.taskMgr.add(self.play, "play")
self.keyboardSetup()
self.msg()
self.requestLevel()
self.msg()
print "PStatClient.connect:", PStatClient.connect("localhost", 5185)
def __init__(self):
ShowBase.__init__(self)
#input setup
self.keys={"w" :0,
"t" :0
}
#socket init
self.socket= socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.socket.connect((host,port))
self.toSend =Queue.Queue(1000)
self.toProcess =Queue.Queue(1000)
self.level=None
self.socket.setblocking(False)
self.taskMgr.add(self.play,"play")
self.keyboardSetup()
self.msg()
self.requestLevel()
self.msg()
print "PStatClient.connect:",PStatClient.connect("localhost" ,5185)
def __init__(self):
DirectObject.__init__(self)
if ConfigVariableBool("want-pstats", False):
PStatClient.connect()
self.docTitle = ""
self.viewportName = ""
self.renderRequested = False
###################################################################
# Minimal emulation of ShowBase glue code. Note we're not using
# ShowBase because there's too much going on in there that assumes
# too much (one camera, one lens, one aspect2d, lots of bloat).
self.graphicsEngine = GraphicsEngine.getGlobalPtr()
self.pipe = GraphicsPipeSelection.getGlobalPtr().makeDefaultPipe()
if not self.pipe:
self.notify.error("No graphics pipe is available!")
return
self.globalClock = ClockObject.getGlobalClock()
# Since we have already started up a TaskManager, and probably
# a number of tasks; and since the TaskManager had to use the
# TrueClock to tell time until this moment, make sure the
# globalClock object is exactly in sync with the TrueClock.
trueClock = TrueClock.getGlobalPtr()
self.globalClock.setRealTime(trueClock.getShortTime())
self.globalClock.tick()
builtins.globalClock = self.globalClock
self.loader = CogInvasionLoader(self)
self.graphicsEngine.setDefaultLoader(self.loader.loader)
builtins.loader = self.loader
self.taskMgr = taskMgr
builtins.taskMgr = self.taskMgr
self.dgTrav = DataGraphTraverser()
self.dataRoot = NodePath("data")
self.hidden = NodePath("hidden")
self.aspect2d = NodePath("aspect2d")
builtins.aspect2d = self.aspect2d
# Messages that are sent regardless of the active document.
self.messenger = messenger
builtins.messenger = self.messenger
builtins.base = self
builtins.hidden = self.hidden
###################################################################
self.clickTrav = CollisionTraverser()
# All open documents.
self.documents = []
# The focused document.
self.document = None
TextNode.setDefaultFont(
loader.loadFont("resources/models/fonts/consolas.ttf"))
self.initialize()
def _showDebugOutput(self):
""" Lists the available debug options """
print "\n" * 5
print "DEBUG MENU"
print "-" * 50
print "Select an option:"
print "\t(1) Connect to pstats"
print "\t(2) Toggle frame rate meter"
print "\t(3) Reset to initial position"
print "\t(4) Display camera position"
print "\t(5) Show scene graph"
print "\t(6) Open placement window"
print "\t(7) Analyze VRAM"
print
selectedOption = raw_input("Which do you want to choose?: ")
try:
selectedOption = int(selectedOption.strip())
except:
print "Option has to be a valid number!"
return False
if selectedOption < 1 or selectedOption > 7:
print "Invalid option!"
return False
# pstats
if selectedOption == 1:
print "Connecting to pstats .."
print "If you have no pstats running, this will take 5 seconds to timeout .."
PStatClient.connect()
# frame rate meter
elif selectedOption == 2:
print "Toggling frame rate meter .."
self.showbase.setFrameRateMeter(not self.showbase.frameRateMeter)
# initial position
elif selectedOption == 3:
print "Reseting camera position / hpr .."
self._resetToInitial()
# display camera pos
elif selectedOption == 4:
print "Debug information:"
print "\tCamera is at", self.showbase.cam.getPos(self.showbase.render)
print "\tCamera hpr is", self.showbase.cam.getHpr(self.showbase.render)
# show scene graph
elif selectedOption == 5:
print "SCENE GRAPH:"
print "-" * 50
self.showbase.render.ls()
print "-" * 50
print
print "ANALYZED:"
print "-" * 50
self.showbase.render.analyze()
print "-" * 50
# placement window
elif selectedOption == 6:
print "Opening placement window. You need tkinter installed to be able to use it"
self.showbase.render.place()
# print "It seems .place() is currently not working. Sorry!!"
# vram analyszs
elif selectedOption == 7:
print "Analyzing VRAM ..."
MemoryMonitor.analyzeMemory()
def updateTimings(self):
client = PStatClient.getGlobalPstats()
gpuData = Globals.base.win.getGsg().getPstatsGpuData()
numEvents = gpuData.getNumEvents()
# gpuData.sortTime()
if numEvents < 1:
# Somehow pstats didn't start, nothing we can do about that
self.numSamples = 0
self.averagedEntries = [("~Please start & connect to pstats!", 0)]
return
dataset = {}
lastStarts = {}
for eventIdx in xrange(gpuData.getNumEvents()):
collectorIdx = gpuData.getTimeCollector(eventIdx)
collector = client.getCollector(collectorIdx)
fname = collector.getFullname()
if fname.count(":") >= 2:
eventTime = gpuData.getTime(eventIdx)
isStart = gpuData.isStart(eventIdx)
if isStart:
lastStarts[fname] = eventTime
else:
if fname not in lastStarts or lastStarts[fname] < 0:
print "ERROR: Overlapping time"
start = lastStarts[fname]
dur = eventTime - start
if fname in dataset:
dataset[fname] += dur
else:
dataset[fname] = dur
lastStarts[fname] = -1
entries = []
for key, val in dataset.iteritems():
entries.append((key, val))
# Create sum
ftime = 0.0
for key, dur in entries:
ftime += dur
entries.append(("~Total GPU Time", ftime))
# Compute averages
for name, dur in entries:
if name in self.averages:
self.averages[name] = self.averages[name][1:] + [dur]
else:
self.averages[name] = [0.0] * self.avgSamples
# Generate list
self.averagedEntries = []
for key, val in self.averages.iteritems():
avg = sum(val) / float(self.avgSamples)
self.averagedEntries.append((key, avg))
self.averagedEntries.sort(key=lambda x: -x[1])
def main():
PStatClient.connect() #run pstats in console
loadPrcFileData('','view-frustum-cull 0')
base = ShowBase()
print('welp')
base.setBackgroundColor(0,0,0)
base.disableMouse()
# TODO init all these into a dict or summat?
startup_data()
frame_rate()
ut = ui_text()
grid = Grid3d()
axis = Axis3d()
cc = CameraControl()
# TODO make it so that all the "root" nodes for the secen are initialized in their own space, probably in with defaults or something globalValues.py?
# roots
# frames XXX FIXME TODO this is a terrible way to pass this around...
frames = {
'data':GuiFrame('Data view','f')
}
frames['data'].toggle_vis()
#asyncio and network setup
clientLoop = get_event_loop()
#ppe = ProcessPoolExecutor(4) # not sure if 4 is better...
ppe = False # serilization is currently broken so we can't use pipes for this
#clientLoop.set_default_executor(ppe)
rendMan = renderManager(clientLoop, ppe)
bs = BoxSel(frames)#, BoxSel.VIS_ALL)
# TODO ssl contexts
conContext = ssl.create_default_context(purpose=ssl.Purpose.SERVER_AUTH, cadata=None) # TODO cadata should allow ONLY our self signed, severly annoying to develop...
dataContext = ssl.create_default_context(purpose=ssl.Purpose.CLIENT_AUTH)
#datCli_base = type('dataClientProtocol',(dataClientProtocol,),
#{'set_nodes':rendMan.set_nodes, # FIXME this needs to go through make_nodes
#'render_set_send_request':rendMan.set_send_request,
#'cache':rendMan.cache,
#'event_loop':clientLoop }) # FIXME we could move event_loop to __new__?
datCli_base = dataClientProtocol(rendMan.render_callback, rendMan.set_send_request, rendMan.cache, clientLoop)
datCli = datCli_base()
datCli.connection_lost('START')
#rendMan.fake_request()
load_points = rendMan.load_points
asyncThread = Thread(target=clientLoop.run_forever)
asyncThread.start()
#make sure we can exit
el = exit_cleanup(clientLoop, ppe, datCli.transport) #use this to call stop() on run_forever
con = console(locals(), True)
ak = AcceptKeys() # this needs to go last after all the classes init
base.run() # this MUST be called last because we use sys.exit() to terminate
print('I AM THE GREATEST')
def main():
from asyncio import get_event_loop
from threading import Thread
# server bits
from server import tokenManager, requestCacheManager, responseMaker, make_shutdown
from .defaults import CONNECTION_PORT, DATA_PORT
# render setup
from direct.showbase.ShowBase import ShowBase
from panda3d.core import loadPrcFileData
from panda3d.core import PStatClient
from .render_manager import renderManager
from .selection import BoxSel
from .util.util import ui_text, console, exit_cleanup, frame_rate, startup_data
from .ui import CameraControl, Axis3d, Grid3d, GuiFrame
from .protocols import connectionServerProtocol, dataServerProtocol
from .protocols import dataClientProtocol
from .util.process_fixed import ProcessPoolExecutor_fixed as ProcessPoolExecutor
from .keys import AcceptKeys
# common
event_loop = get_event_loop()
ppe = ProcessPoolExecutor()
# server
tm = tokenManager()
rcm = requestCacheManager(0)
conServ = connectionServerProtocol(tm)
datServ = dataServerProtocol(event_loop, responseMaker, rcm, tm, ppe)
coro_conServer = event_loop.create_server(conServ, '127.0.0.1', CONNECTION_PORT, ssl=None) # TODO ssl
coro_dataServer = event_loop.create_server(datServ, '127.0.0.1', DATA_PORT, ssl=None) # TODO ssl and this can be another box
serverCon = event_loop.run_until_complete(coro_conServer)
serverData = event_loop.run_until_complete(coro_dataServer)
# client
PStatClient.connect() #run pstats in console
loadPrcFileData('','view-frustum-cull 0')
base = ShowBase()
base.setBackgroundColor(0,0,0)
base.disableMouse()
# TODO init all these into a dict or summat?
startup_data()
frame_rate()
ut = ui_text()
grid = Grid3d()
axis = Axis3d()
cc = CameraControl()
frames = {
'data':GuiFrame('Data view')
}
rendMan = renderManager(event_loop, ppe)
bs = BoxSel(frames)
datCli_base = dataClientProtocol(rendMan.render_callback, rendMan.set_send_request, rendMan.cache, event_loop)
datCli = datCli_base()
datCli.connection_lost('START')
eventThread = Thread(target=event_loop.run_forever)
eventThread.start()
con = console(locals(), True)
shutdown = make_shutdown(event_loop, eventThread, serverCon, serverData, ppe)
el = exit_cleanup(event_loop, ppe, datCli.transport, shutdown)
ac = AcceptKeys()
base.run()
def _showDebugOutput(self):
print "\n" * 5
print "DEBUG MENU"
print "-" * 50
print "Select an option:"
print "\t(1) Connect to pstats"
print "\t(2) Toggle frame rate meter"
print "\t(3) Reset to initial position"
print "\t(4) Display camera position"
print "\t(5) Show scene graph"
print "\t(6) Open placement window"
print
selectedOption = raw_input("Which do you want to choose?: ")
try:
selectedOption = int(selectedOption.strip())
except:
print "Option has to be a valid number!"
return False
if selectedOption < 1 or selectedOption > 6:
print "Invalid option!"
return False
# pstats
if selectedOption == 1:
print "Connecting to pstats .."
print "If you have no pstats running, this will take 5 seconds to timeout .."
PStatClient.connect()
# frame rate meter
elif selectedOption == 2:
print "Toggling frame rate meter .."
self.showbase.setFrameRateMeter(not self.showbase.frameRateMeter)
# initial position
elif selectedOption == 3:
print "Reseting camera position / hpr .."
self._resetToInitial()
# display camera pos
elif selectedOption == 4:
print "Debug information:"
print "\tCamera is at", self.showbase.cam.getPos(
self.showbase.render)
print "\tCamera hpr is", self.showbase.cam.getHpr(
self.showbase.render)
# show scene graph
elif selectedOption == 5:
print "SCENE GRAPH:"
print "-" * 50
self.showbase.render.ls()
print "-" * 50
print
print "ANALYZED:"
print "-" * 50
self.showbase.render.analyze()
print "-" * 50
# placement window
elif selectedOption == 6:
print "Opening placement window. You need tkinter installed to be able to use it"
self.showbase.render.place()
def __init__(self,
tex,
stim_angles=(0, 0),
strip_angle=0,
position=(0, 0),
velocities=(0, 0),
strip_width=4,
fps=30,
window_size=None,
window_name='BinocularDrift',
profile_on=False):
super().__init__()
self.tex = tex
if window_size == None:
self.window_size = tex.texture_size
else:
self.window_size = window_size
self.mask_position_card = position
self.mask_position_uv = (utils.card2uv(self.mask_position_card[0]),
utils.card2uv(self.mask_position_card[1]))
self.scale = np.sqrt(
8) #so it can handle arbitrary rotations and shifts
self.left_texture_angle = stim_angles[0]
self.right_texture_angle = stim_angles[1]
self.left_velocity = velocities[0]
self.right_velocity = velocities[1]
self.strip_angle = strip_angle #this will change fairly frequently
self.fps = fps
self.window_name = window_name
self.profile_on = profile_on
#Set window title and size
self.window_properties = WindowProperties()
self.window_properties.setSize(self.window_size, self.window_size)
self.window_properties.setTitle(self.window_name)
ShowBaseGlobal.base.win.requestProperties(
self.window_properties) #base is a panda3d global
#CREATE MASK ARRAYS
self.left_mask_array = 255 * np.ones(
(self.tex.texture_size, self.tex.texture_size), dtype=np.uint8)
self.left_mask_array[:, self.tex.texture_size // 2 -
strip_width // 2:] = 0
self.right_mask_array = 255 * np.ones(
(self.tex.texture_size, self.tex.texture_size), dtype=np.uint8)
self.right_mask_array[:, :self.tex.texture_size // 2 +
strip_width // 2] = 0
#TEXTURE STAGES FOR LEFT CARD
self.left_texture_stage = TextureStage('left_texture_stage')
#Mask
self.left_mask = Texture("left_mask_texture")
self.left_mask.setup2dTexture(self.tex.texture_size,
self.tex.texture_size,
Texture.T_unsigned_byte,
Texture.F_luminance)
self.left_mask.setRamImage(self.left_mask_array)
self.left_mask_stage = TextureStage('left_mask_array')
#Multiply the texture stages together
self.left_mask_stage.setCombineRgb(TextureStage.CMModulate,
TextureStage.CSTexture,
TextureStage.COSrcColor,
TextureStage.CSPrevious,
TextureStage.COSrcColor)
#TEXTURE STAGES FOR RIGHT CARD
self.right_texture_stage = TextureStage('right_texture_stage')
#Mask
self.right_mask = Texture("right_mask_texture")
self.right_mask.setup2dTexture(self.tex.texture_size,
self.tex.texture_size,
Texture.T_unsigned_byte,
Texture.F_luminance)
self.right_mask.setRamImage(self.right_mask_array)
self.right_mask_stage = TextureStage('right_mask_stage')
#Multiply the texture stages together
self.right_mask_stage.setCombineRgb(TextureStage.CMModulate,
TextureStage.CSTexture,
TextureStage.COSrcColor,
TextureStage.CSPrevious,
TextureStage.COSrcColor)
#CREATE CARDS/SCENEGRAPH
cm = CardMaker('stimcard')
cm.setFrameFullscreenQuad()
#self.setBackgroundColor((0,0,0,1))
self.left_card = self.aspect2d.attachNewNode(cm.generate())
self.right_card = self.aspect2d.attachNewNode(cm.generate())
self.left_card.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.M_add))
self.right_card.setAttrib(ColorBlendAttrib.make(
ColorBlendAttrib.M_add))
#ADD TEXTURE STAGES TO CARDS
self.left_card.setTexture(self.left_texture_stage, self.tex.texture)
self.left_card.setTexture(self.left_mask_stage, self.left_mask)
self.right_card.setTexture(self.right_texture_stage, self.tex.texture)
self.right_card.setTexture(self.right_mask_stage, self.right_mask)
self.setBackgroundColor(
(0, 0, 0, 1)) # without this the cards will appear washed out
#TRANSFORMS
#Masks
self.mask_transform = self.trs_transform()
self.left_card.setTexTransform(self.left_mask_stage,
self.mask_transform)
self.right_card.setTexTransform(self.right_mask_stage,
self.mask_transform)
#Left texture
self.left_card.setTexScale(self.left_texture_stage, 1 / self.scale)
self.left_card.setTexRotate(self.left_texture_stage,
self.left_texture_angle)
#Right texture
self.right_card.setTexScale(self.right_texture_stage, 1 / self.scale)
self.right_card.setTexRotate(self.right_texture_stage,
self.right_texture_angle)
#Set dynamic transforms
if self.left_velocity != 0 and self.right_velocity != 0:
self.taskMgr.add(self.textures_update, "move_both")
elif self.left_velocity != 0 and self.right_velocity == 0:
self.taskMgr.add(self.left_texture_update, "move_left")
elif self.left_velocity == 0 and self.right_velocity != 0:
self.taskMgr.add(self.right_texture_update, "move_right")
# Set frame rate
ShowBaseGlobal.globalClock.setMode(ClockObject.MLimited)
ShowBaseGlobal.globalClock.setFrameRate(
self.fps) #can lock this at whatever
#Set up profiling if desired
if profile_on:
PStatClient.connect() # this will only work if pstats is running
ShowBaseGlobal.base.setFrameRateMeter(True) #Show frame rate
# Following will show a small x at the center
self.title = OnscreenText("x",
style=1,
fg=(1, 1, 1, 1),
bg=(0, 0, 0, .8),
pos=self.mask_position_card,
scale=0.05)
def __init__(self,
tex,
stim_angles=(0, 0),
initial_angle=0,
initial_position=(0, 0),
velocities=(0, 0),
strip_width=4,
fps=30,
window_size=None,
window_name='position control',
profile_on=False,
save_path=None):
super().__init__()
self.render.setAntialias(AntialiasAttrib.MMultisample)
self.aspect2d.prepareScene(
ShowBaseGlobal.base.win.getGsg()) # pre-loads world
self.tex = tex
if window_size == None:
self.window_size = tex.texture_size
else:
self.window_size = window_size
self.mask_position_card = initial_position
self.strip_width = strip_width
self.scale = np.sqrt(
8) #so it can handle arbitrary rotations and shifts
self.strip_angle = initial_angle #this will change fairly frequently
self.stim_angles = stim_angles
self.left_texture_angle = self.stim_angles[
0] + self.strip_angle #make this a property
self.right_texture_angle = self.stim_angles[1] + self.strip_angle
self.left_velocity = velocities[0]
self.right_velocity = velocities[1]
self.fps = fps
self.window_name = window_name
self.profile_on = profile_on
print(save_path)
self.save_path = save_path
if self.save_path:
initial_params = {
'angles': stim_angles,
'initial_angle': self.strip_angle,
'velocities': velocities,
'strip_width': self.strip_width,
'initial_position': initial_position
}
print(tex, initial_params)
self.filestream = utils.save_initialize(self.save_path, [tex],
[initial_params])
print(self.filestream)
else:
self.filestream = None
#Set window title and size
self.window_properties = WindowProperties()
self.window_properties.setSize(self.window_size, self.window_size)
self.window_properties.setTitle(self.window_name)
ShowBaseGlobal.base.win.requestProperties(
self.window_properties) #base is a panda3d global
# Set frame rate
ShowBaseGlobal.globalClock.setMode(ClockObject.MLimited)
ShowBaseGlobal.globalClock.setFrameRate(
self.fps) #can lock this at whatever
#CREATE MASK ARRAYS
self.left_mask_array = 255 * np.ones(
(self.tex.texture_size, self.tex.texture_size), dtype=np.uint8)
self.left_mask_array[:, self.tex.texture_size // 2 -
self.strip_width // 2:] = 0
self.right_mask_array = 255 * np.ones(
(self.tex.texture_size, self.tex.texture_size), dtype=np.uint8)
self.right_mask_array[:, :self.tex.texture_size // 2 +
self.strip_width // 2] = 0
#TEXTURE STAGES FOR LEFT CARD
self.left_texture_stage = TextureStage('left_texture_stage')
#Mask
self.left_mask = Texture("left_mask_texture")
self.left_mask.setup2dTexture(self.tex.texture_size,
self.tex.texture_size,
Texture.T_unsigned_byte,
Texture.F_luminance)
self.left_mask.setRamImage(self.left_mask_array)
self.left_mask_stage = TextureStage('left_mask_array')
#Multiply the texture stages together
self.left_mask_stage.setCombineRgb(TextureStage.CMModulate,
TextureStage.CSTexture,
TextureStage.COSrcColor,
TextureStage.CSPrevious,
TextureStage.COSrcColor)
#TEXTURE STAGES FOR RIGHT CARD
self.right_texture_stage = TextureStage('right_texture_stage')
#Mask
self.right_mask = Texture("right_mask_texture")
self.right_mask.setup2dTexture(self.tex.texture_size,
self.tex.texture_size,
Texture.T_unsigned_byte,
Texture.F_luminance)
self.right_mask.setRamImage(self.right_mask_array)
self.right_mask_stage = TextureStage('right_mask_stage')
#Multiply the texture stages together
self.right_mask_stage.setCombineRgb(TextureStage.CMModulate,
TextureStage.CSTexture,
TextureStage.COSrcColor,
TextureStage.CSPrevious,
TextureStage.COSrcColor)
#CREATE CARDS/SCENEGRAPH
cm = CardMaker('stimcard')
cm.setFrameFullscreenQuad()
#self.setBackgroundColor((0,0,0,1))
self.left_card = self.aspect2d.attachNewNode(cm.generate())
self.right_card = self.aspect2d.attachNewNode(cm.generate())
self.left_card.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.M_add))
self.right_card.setAttrib(ColorBlendAttrib.make(
ColorBlendAttrib.M_add))
#ADD TEXTURE STAGES TO CARDS
self.left_card.setTexture(self.left_texture_stage, self.tex.texture)
self.left_card.setTexture(self.left_mask_stage, self.left_mask)
self.right_card.setTexture(self.right_texture_stage, self.tex.texture)
self.right_card.setTexture(self.right_mask_stage, self.right_mask)
self.setBackgroundColor(
(0, 0, 0, 1)) # without this the cards will appear washed out
#self.left_card.setAntialias(AntialiasAttrib.MMultisample)
#self.right_card.setAntialias(AntialiasAttrib.MMultisample)
#TRANSFORMS
# Masks
self.mask_transform = self.trs_transform()
self.left_card.setTexTransform(self.left_mask_stage,
self.mask_transform)
self.right_card.setTexTransform(self.right_mask_stage,
self.mask_transform)
# Textures
# Left
self.left_card.setTexScale(self.left_texture_stage, 1 / self.scale)
self.left_card.setTexRotate(self.left_texture_stage,
self.left_texture_angle)
# Right
self.right_card.setTexScale(self.right_texture_stage, 1 / self.scale)
self.right_card.setTexRotate(self.right_texture_stage,
self.right_texture_angle)
#Set task manager(s) for textures
if self.left_velocity != 0 and self.right_velocity != 0:
self.taskMgr.add(self.textures_update, "move_both")
elif self.left_velocity != 0 and self.right_velocity == 0:
self.taskMgr.add(self.left_texture_update, "move_left")
elif self.left_velocity == 0 and self.right_velocity != 0:
self.taskMgr.add(self.right_texture_update, "move_right")
# Event handler to process the messages
self.accept("stim", self.process_stim, [])
#Set up profiling if desired
if profile_on:
PStatClient.connect() # this will only work if pstats is running
ShowBaseGlobal.base.setFrameRateMeter(True) #Show frame rate
def main():
PStatClient.connect() #run pstats in console
loadPrcFileData('', 'view-frustum-cull 0')
base = ShowBase()
print('welp')
base.setBackgroundColor(0, 0, 0)
base.disableMouse()
# TODO init all these into a dict or summat?
startup_data()
frame_rate()
ut = ui_text()
grid = Grid3d()
axis = Axis3d()
cc = CameraControl()
# TODO make it so that all the "root" nodes for the secen are initialized in their own space, probably in with defaults or something globalValues.py?
# roots
# frames XXX FIXME TODO this is a terrible way to pass this around...
frames = {'data': GuiFrame('Data view', 'f')}
frames['data'].toggle_vis()
#asyncio and network setup
clientLoop = get_event_loop()
#ppe = ProcessPoolExecutor(4) # not sure if 4 is better...
ppe = False # serilization is currently broken so we can't use pipes for this
#clientLoop.set_default_executor(ppe)
rendMan = renderManager(clientLoop, ppe)
bs = BoxSel(frames) #, BoxSel.VIS_ALL)
# TODO ssl contexts
conContext = ssl.create_default_context(
purpose=ssl.Purpose.SERVER_AUTH, cadata=None
) # TODO cadata should allow ONLY our self signed, severly annoying to develop...
dataContext = ssl.create_default_context(purpose=ssl.Purpose.CLIENT_AUTH)
#datCli_base = type('dataClientProtocol',(dataClientProtocol,),
#{'set_nodes':rendMan.set_nodes, # FIXME this needs to go through make_nodes
#'render_set_send_request':rendMan.set_send_request,
#'cache':rendMan.cache,
#'event_loop':clientLoop }) # FIXME we could move event_loop to __new__?
datCli_base = dataClientProtocol(rendMan.render_callback,
rendMan.set_send_request, rendMan.cache,
clientLoop)
datCli = datCli_base()
datCli.connection_lost('START')
#rendMan.fake_request()
load_points = rendMan.load_points
asyncThread = Thread(target=clientLoop.run_forever)
asyncThread.start()
#make sure we can exit
el = exit_cleanup(
clientLoop, ppe,
datCli.transport) #use this to call stop() on run_forever
con = console(locals(), True)
ak = AcceptKeys() # this needs to go last after all the classes init
base.run(
) # this MUST be called last because we use sys.exit() to terminate
print('I AM THE GREATEST')
def connect_pstats(self):
PStatClient.connect()
def pstats():
base.pstats = True
PStatClient.connect()