def __init__(self):
self.initWindow()
# window title
title = "ASTRO.SYNTH"
pygame.display.set_caption(title, title)
# screen scene manager
self.scene_mngr = SceneManager.SceneManager()
def __new__(cls):
if cls.__instance is None:
cls.__instance = super(Managers, cls).__new__(cls)
cls.__instance.app = QtWidgets.QApplication(sys.argv)
cls.__instance.input = inputManager.InputManager()
cls.__instance.scene = scene.SceneManager()
cls.__instance.scene.resize(1550, 1000)
cls.__instance.objects = objMan.ObjectManager(cls.__instance.scene)
cls.__instance.collisionDetection = collision.CollisionDetection(
cls.__instance.objects)
return cls.__instance
def start():
# disable logger warningss
logger = avango.gua.nodes.Logger(EnableWarning=False)
workspace_config = sys.argv[1]
if sys.argv[2] == "True":
start_clients = True
else:
start_clients = False
# preload materials and shading models
avango.gua.load_shading_models_from("data/materials")
avango.gua.load_materials_from("data/materials")
# initialize application manager
application_manager = ApplicationManager()
application_manager.my_constructor(WORKSPACE_CONFIG=workspace_config,
START_CLIENTS=start_clients)
# initialize scene
scene_manager = SceneManager()
# initialize touch devices
multi_touch_device = None
for _workspace in application_manager.workspaces:
for _display_group in _workspace.display_groups:
for _display in _display_group.displays:
if "TUIO" in _display.get_touch_protocols():
if None == multi_touch_device:
device = TUIODevice()
device.my_constructor(scenegraphs[0], _display,
scenegraphs[0]["/net"],
scene_manager,
application_manager)
multi_touch_device = device
# initialize animation manager
#animation_manager = AnimationManager()
#animation_manager.my_constructor([ graph["/net/platform_0"]]
# , [ application_manager.navigation_list[0]])
## distribute all nodes in the scenegraph
distribute_all_nodes(scenegraphs[0]["/net"], scenegraphs[0]["/net"])
# run application loop
application_manager.run(locals(), globals())
def __init__(self):
super(MainWindow, self).__init__()
centralWidget = QtGui.QWidget()
self.setCentralWidget(centralWidget)
self.glWidget = GLWidget()
self.glWidgetArea = QtGui.QScrollArea()
self.glWidgetArea.setWidget(self.glWidget)
self.glWidgetArea.setWidgetResizable(True)
self.glWidgetArea.setHorizontalScrollBarPolicy(
QtCore.Qt.ScrollBarAlwaysOff)
self.glWidgetArea.setVerticalScrollBarPolicy(
QtCore.Qt.ScrollBarAlwaysOff)
self.glWidgetArea.setSizePolicy(QtGui.QSizePolicy.Ignored,
QtGui.QSizePolicy.Ignored)
self.glWidgetArea.setMinimumSize(50, 50)
self.createActions()
self.createMenus()
centralLayout = QtGui.QGridLayout()
centralLayout.addWidget(self.glWidgetArea, 0, 0)
centralWidget.setLayout(centralLayout)
self.setWindowTitle("3D Brain Network Analysis Tool")
self.resize(800, 600)
self.renderSystem = RenderSystem()
self.sourceManager = SourceManager()
self.sceneManager = SceneManager()
self.renderSystem.setRenderWidget(self.glWidget)
self.renderSystem.setSceneManager(self.sceneManager)
self.sceneManager.addSource(self.sourceManager)
self.glWidget.addRenderSystem(self.renderSystem)
def __init__(self, parent=None, manager=None, printpreview=None):
qt.QWidget.__init__(self, parent)
self.mainLayout = qt.QGridLayout(self)
if printpreview is None:
self.printPreview = Object3DPrintPreview.Object3DPrintPreview(
modal=0)
else:
self.printPreview = printpreview
self.buildToolBar()
self.wheelSlider10 = WheelAndSpacer(self, orientation=qt.Qt.Vertical)
# Wheel
self.__applyingCube = False
#self.wheelSlider10.wheel.setMass(0.5)
self.wheelSlider10.wheel.setRange(-360., 360., 0.5)
self.wheelSlider10.wheel.setValue(0.0)
self.wheelSlider10.wheel.setTotalAngle(360.)
self.connect(self.wheelSlider10.wheel,
qt.SIGNAL("valueChanged(double)"), self.setTheta)
self.glWidget = SceneGLWidget.SceneGLWidget(self)
self.scene = weakref.proxy(self.glWidget.scene)
self.glWidget.setObjectSelectionMode(True)
self.wheelSlider12 = Qwt5.QwtSlider(self, qt.Qt.Vertical,
Qwt5.QwtSlider.NoScale,
Qwt5.QwtSlider.BgSlot)
#self.axesObject = BlissGLAxesObject.BlissGLAxesObject("3D Axes")
#self.glWidget.addObject3D(self.axesObject)
#self.wheelSlider12.setScaleEngine(Qwt5.QwtLog10ScaleEngine())
#self.wheelSlider12.setThumbWidth(20)
self.wheelSlider12.setRange(-10, 10, 0.05)
#self.wheelSlider12.setScale(0.01, 100)
self.wheelSlider12.setValue(0.0)
#self.wheelSlider12.setScaleMaxMinor(10)
self.connect(self.wheelSlider12, qt.SIGNAL("valueChanged(double)"),
self.setZoomFactor)
self.wheelSlider21 = WheelAndLineEdit(self,
orientation=qt.Qt.Horizontal)
#wheel
#self.wheelSlider21.wheel.setMass(0.5)
self.wheelSlider21.wheel.setRange(-360., 360., 0.5)
self.wheelSlider21.wheel.setValue(0.0)
self.wheelSlider21.wheel.setTotalAngle(360.)
self.infoLine = self.wheelSlider21.lineEdit
self.infoLine.setText("Scene is in object selection mode.")
self.connect(self.wheelSlider21.wheel,
qt.SIGNAL("valueChanged(double)"), self.setPhi)
self.mainLayout.addWidget(self.toolBar, 0, 1)
self.mainLayout.addWidget(self.wheelSlider10, 1, 0)
self.mainLayout.addWidget(self.glWidget, 1, 1)
self.mainLayout.addWidget(self.wheelSlider12, 1, 2)
self.mainLayout.addWidget(self.wheelSlider21, 2, 1)
if manager is None:
self.manager = SceneManager.SceneManager(None, glwindow=self)
self.sceneControl = self.manager.sceneControl
#self.sceneControl = SceneControl.SceneControl(None, self.glWidget.scene)
#self.manager.sceneControl
self.connectSceneControl()
#self.manager.show()
#self.sceneControl.show()
self.connect(self.manager, qt.SIGNAL('SceneManagerSignal'),
self.sceneManagerSlot)
else:
self.manager = weakref.proxy(manager)
self.activeObject = None
self.connect(self.glWidget, qt.SIGNAL('objectSelected'),
self.objectSelectedSlot)
self.connect(self.glWidget, qt.SIGNAL('vertexSelected'),
self.vertexSelectedSlot)
self.setWindowTitle(self.tr("Object3D Scene"))
##Dependencies:
##License:
######################################################################
# Pound Includes
import viz
import pregame
import SceneManager
import viztask
import Human
import GameWrap
import vizcam
import postgame
viz.go()
sceneManager = SceneManager.SceneManager()
#Game
def ZombieGame():
Status = True
while (Status):
print viz.MainScene
viz.scene(1)
ActiveProgram = pregame.Intro() #Destructions info
yield ActiveProgram.done.wait() #Wailt for intro screen to be done
sceneManager.switchtoScene('Charactor')
ActiveProgram = pregame.CharacterCreation()
playerName = yield ActiveProgram.done.wait(
) #Wailt for charactor creation to be done
#Inital stuff
pygame.init()
clock = pygame.time.Clock()
width = 800
height = 600
size = width, height
screen = pygame.display.set_mode(size)
bgColor = r,g,b = 0, 0, 0
font = pygame.font.Font(None,36)
player = Player([width/2, height-150])
UIManager = UIManager()
SceneManager = SceneManager()
scene = None
testItem = Item(screen, "weapon", "universal", "Health Potion", "*Description*", "Images/Other/Items/HealthPotion.png")
TextManager = TextManager(screen, scene)
newText = Text("Testing", [20,20])
p = PlayerAnimation([width/2, height/2])
#Move UI Elements
#UIManager.MBRect = UIManager.MBRect.move(UIManager.MBPose)
#UIManager.HBRect = UIManager.HBRect.move(UIManager.HBPose)
while True:
#if player.health <= 2:
def __init__ ( self, modname, mapname, is_server=False, graphics_enabled=True ):
"""Initialize the world from the given map"""
self.modname = modname
self.mapname = mapname
self.playerEnt = None
self.isServer = is_server
self.graphicsEnabled = graphics_enabled
self.idCounter = 0
self.ninjasKilled = 0
self.piratesKilled = 0
self.treasuresTaken = 0
self.deathBlotches = []
path = Mod.MapPath( modname, mapname)
hmap = path+"heightmap.bin"
projectdesc = ProjectDesc ( modname, mapname )
self.projectDesc = projectdesc
self.seaLevel = float(projectdesc.SeaLevel)
self.solver = Physics.Solver()
self.solver.setMinimumFramerate(10)
#create materials
self.materialMap = Materials.DefaultMaterialMap(self.solver)
#setup atmosphere
self.atmosphere = Atmosphere.Atmosphere(projectdesc)
self._extractShadowMap()
self.terrainMaterial = TerrainMaterial.TerrainMaterial( modname, mapname )
self.terrain = Terrain.TerrainPatch( None, self, Heightmap.fromFile(hmap), self.terrainMaterial, projectdesc.Spacing )
#if self.graphicsEnabled:
# self.terrain.initGraphics()
self.ocean = Ocean.Ocean(float(projectdesc.SeaLevel),
projectdesc.WaterTexture,
self.terrain.getextent() )
mx = self.terrain.getextent() / 2
mz = self.terrain.getextent() / 2
my = self.terrain.getWorldHeightValue( mx, mz ) + 2.0
#Set the world size (Newton will disable anything that's not
#within the world box
extent = float(self.terrain.getextent())
self.solver.setWorldSize( (-extent, -2000.0, -extent ), (extent, 2000.0, extent) )
#Create scene. This should load all the entities as well
self.scene = SceneManager.SceneManager(self, modname, mapname)
#set camera
if not self.graphicsEnabled:
self.playerEnt = None
self.camera = None
else:
if self.playerEnt == None or Settings.RunPhysics == False:
self.camera = Camera.Freecam()
self.camera.position = vec3( mx, my, mz)
self.camera.yaw = 0
self.camera.pitch = 0
else:
self.camera = Camera.AttachableCamera( self.playerEnt )
self.frustrum_camera = self.camera.asFreecam()
print "World loaded"
