def __initialize(self): # Load data from json file with open(self.filePath) as f: data = json.load(f) # Create background object self.position = data['position'] self.scale = data['scale'] self.background = pyxie.figure(data['background']['path']) self.background.position = vmath.vec3(self.position) self.background.scale = vmath.vec3(self.scale) self.showcase.add(self.background) # Spawn all objects inside this cell if len(data['objects']) > 0: for obj in data['objects']: actual_obj = self.__spawnDependOnObjectType(obj) if actual_obj is not None: self.objects.append(actual_obj) # Create col box for background for check, will delete this part later col_scale = [self.scale[0] / 2, self.scale[1] / 2, self.scale[2] / 2] colId = p.createCollisionShape(p.GEOM_BOX, halfExtents=col_scale) p.createMultiBody(baseMass=0, baseCollisionShapeIndex=colId, basePosition=self.position)
def replaceMesh(self, meshData): self.meshName = meshData self.mesh = pyxie.figure(meshData) self.mesh.position = vmath.vec3(self.gameObject.transform.position) self.mesh.rotation = vmath.quat( helperFunction.fromEulerToQuaternion( self.gameObject.transform.rotation)) self.mesh.scale = vmath.vec3(self.gameObject.transform.scale)
def __init__(self, centerPos, boardScale, clearStageTextScale, starScale, buttonScale, boardPath, clearStageTextPath, whiteStarPath, yellowStarPath, nextButtonPath, retryButtonPath, showcase, camera, ui_manager): # Support attribute self.centerPos = centerPos self.isDisable = True self.showcase = showcase self.camera = camera self.ui_manager = ui_manager self.tapped = False # Board self.boardScale = boardScale self.boardPath = boardPath self.board = graphicsHelper.createSprite(self.boardScale[0], self.boardScale[1], self.boardPath) self.board.position = vmath.vec3(self.centerPos) # Clear Stage Text self.clearTextPos = [ self.centerPos[0], self.centerPos[1] + 170, self.centerPos[2] ] self.clearTextScale = clearStageTextScale self.clearTextPath = clearStageTextPath self.clearText = graphicsHelper.createSprite(self.clearTextScale[0], self.clearTextScale[1], self.clearTextPath) self.clearText.position = vmath.vec3(self.clearTextPos) # Star self.starScale = starScale self.whiteStarPath = whiteStarPath self.yellowStarPath = yellowStarPath self.listStar = list() # Next Button self.nextButtonPos = [ self.centerPos[0] + 60, self.centerPos[1] - 100, self.centerPos[2] ] self.nextButtonScale = buttonScale self.nextButtonPath = nextButtonPath self.nextButton = graphicsHelper.createSprite(self.nextButtonScale[0], self.nextButtonScale[1], self.nextButtonPath) self.nextButton.position = vmath.vec3(self.nextButtonPos) # Next Button self.retryButtonPos = [ self.centerPos[0] - 60, self.centerPos[1] - 100, self.centerPos[2] ] self.retryButtonScale = buttonScale self.retryButtonPath = retryButtonPath self.retryButton = graphicsHelper.createSprite( self.retryButtonScale[0], self.retryButtonScale[1], self.retryButtonPath) self.retryButton.position = vmath.vec3(self.retryButtonPos)
def DisplayCurrentCompleteProgress(self): self.sliderBarPos = [ 1.4 + self.backgroundBarPos[0] - self.backgroundBarScale[0] / 2 + (self.sliderBarScale[0] * self.percentComplete) / 2, self.backgroundBarPos[1] - 0.7, self.backgroundBarPos[2] + 1.0 ] sliderBarPercentScale = [self.percentComplete, 1] self.sliderBar.position = vmath.vec3(self.sliderBarPos) self.sliderBar.scale = vmath.vec3(sliderBarPercentScale)
def __autoRePosition(self): pos, orn = p.getBasePositionAndOrientation(self.colId) quat = self.__autoReRotation(orn) self.model.rotation = quat local_v = vmath.rotate(vmath.vec3(self.col_local_pos), vmath.quat(orn)) pos_x = pos[0] - local_v.x pos_y = pos[1] - local_v.y pos_z = pos[2] - local_v.z model_pos = (pos_x, pos_y, pos_z) self.model.position = vmath.vec3(model_pos)
def __init__(self, gameObject, meshData): super().__init__(gameObject) self.meshName = meshData self.showOnInspector("meshName") self.mesh = pyxie.figure(meshData) self.mesh.position = vmath.vec3(self.gameObject.transform.position) self.mesh.rotation = vmath.quat( helperFunction.fromEulerToQuaternion( self.gameObject.transform.rotation)) self.mesh.scale = vmath.vec3(self.gameObject.transform.scale)
def __init__(self, skyboxPath, gameCamera, skyboxCamera, skyboxShowcase): self.skyboxPath = skyboxPath self.skybox = pyxie.figure(self.skyboxPath) self.skybox.scale = vmath.vec3([600.0, 600.0, 600.0]) self.skybox.position = vmath.vec3([0.0, -300, 100.0]) # self.skybox.rotation = vmath.quat([ 0.7071068, 0, 0, 0.7071068 ]) self.skyboxShowcase = skyboxShowcase self.skyboxShowcase.add(self.skybox) self.gameCamera = gameCamera self.skyboxCamera = skyboxCamera
def CameraOnFinal(self, player): if player.cam.position.z < self.maxHighCam: newPos = [ player.cam.position.x, player.cam.position.y, player.cam.position.z + 0.1 ] player.cam.position = vmath.vec3(newPos) if player.cam.position.y > self.minFarCam: newPos = [ player.cam.position.x, player.cam.position.y - 0.2, player.cam.position.z ] player.cam.position = vmath.vec3(newPos) player.cam.target = vmath.vec3(self.finalCamTarget)
def __autoRePosition(self): pos, orn = p.getBasePositionAndOrientation(self.colId) quat = self.__autoReRotation(orn) self.model.rotation = quat local_v = vmath.rotate(vmath.vec3(self.col_local_pos), vmath.quat(orn)) pos_x = pos[0] - local_v.x pos_y = pos[1] - local_v.y pos_z = pos[2] - local_v.z model_pos = (pos_x, pos_y, pos_z) self.model.position = vmath.vec3(model_pos) # If this character have camfollow, make camera follow it if self.camFollow: self.cam.position = vmath.vec3(pos) + vmath.vec3(self.camDis) self.cam.target = vmath.vec3(pos)
def DisplayStarRate(self, rateType): self.leftBasePos = [ self.centerPos[0] - 90, self.centerPos[1] + 102, self.centerPos[2] ] clearRate = -1 if rateType == UNCLEAR: clearRate = -1 elif rateType == ONE_STAR_RATE: clearRate = 1 elif rateType == TWO_STAR_RATE: clearRate = 2 elif rateType == THREE_STAR_RATE: clearRate = 3 for i in range(1, 4): if i > clearRate: displayStar = self.whiteStarPath else: displayStar = self.yellowStarPath star = graphicsHelper.createSprite(self.starScale[0], self.starScale[1], displayStar) star.position = vmath.vec3([ self.leftBasePos[0] + i * 45, self.leftBasePos[1], self.leftBasePos[2] ]) self.showcase.add(star) self.listStar.append(star)
def OnClickExcute(self, player): linearVelocity, angularVelocity = p.getBaseVelocity(player.colId) boostVelocity = vmath.length(vmath.vec3(linearVelocity)) if boostVelocity < 500: boostVelocity = 500 newVelocity = [0, boostVelocity, 0] p.resetBaseVelocity(player.colId, newVelocity, angularVelocity) self.Hide()
def __init__(self, gameObject, colliderPath, showcase): super().__init__(gameObject) self.colType = "BOX COLLIDER" self.showOnInspector("colType") self.scale = self.gameObject.transform.scale self.showOnInspector("scale") self.isDisplay = True self.showOnInspector("isDisplay") self.showcase = showcase self.mesh = pyxie.figure(colliderPath) self.mesh.position = vmath.vec3(self.gameObject.transform.position) self.mesh.rotation = vmath.quat( helperFunction.fromEulerToQuaternion( self.gameObject.transform.rotation)) self.mesh.scale = vmath.vec3(self.gameObject.transform.scale) self.showcase.add(self.mesh)
def CheckDistance(self): pos, orn = p.getBasePositionAndOrientation(self.obj.colId) disVector = [ self.currentTargetPos[0] - pos[0], self.currentTargetPos[1] - pos[1], self.currentTargetPos[2] - pos[2] ] dis = vmath.length(vmath.vec3(disVector)) if dis <= self.reverseDistance: self.ReverseTargetPosition()
def __init__(self, pos, scale, filePath, showcase, camera, ui_manager): self.position = pos self.scale = scale self.filePath = filePath self.camera = camera self.showcase = showcase self.model = graphicsHelper.createSprite(self.scale[0], self.scale[1], self.filePath) self.model.position = vmath.vec3(self.position) self.ui_manager = ui_manager self.tapped = False self.isDisable = True
def SimulateProcess(self): index = 1 for bd in self.bodies: if not bd: index += 1 continue if not self.firstTimeActive and bd not in self.activatedBodies: index += 1 continue pos, rot = p.getBasePositionAndOrientation(bd) self.model.setJoint(index, position=vmath.vec3(pos), rotation=vmath.quat(rot), scale=vmath.vec3(self.sizeMulti, self.sizeMulti, self.sizeMulti)) index += 1 if self.firstTimeActive: self.firstTimeActive = False
def CalculateVelocity(self, pos): direction = [ self.currentTargetPos[0] - pos[0], self.currentTargetPos[1] - pos[1], self.currentTargetPos[2] - pos[2] ] normalizeDirection = vmath.normalize(vmath.vec3(direction)) newVelocity = [ normalizeDirection.x * self.move_speed, normalizeDirection.y * self.move_speed, normalizeDirection.z * self.move_speed ] return newVelocity
def HandleRemovedBodies(self): if not os.path.exists("TestVoxel/activatedBodies.pickle"): return with open("TestVoxel/activatedBodies.pickle", "rb") as f: removedIndex = pickle.load(f) self.removedBodies = removedIndex for removedBody in removedIndex: body = self.bodies[removedBody] p.removeBody(body) self.bodies[removedBody] = None self.model.setJoint(removedBody + 1, position=vmath.vec3(0, 0, 0)) self.activatedBodies.append(body)
def __initialize(self): for i in range(0, self.matrix_scale): for j in range(0, self.matrix_scale): position = self.__getPositionAndScaleOfCube(i, j) scale = [ self.unit_scale.x / 2, self.unit_scale.y / 2, self.unit_scale.z / 2 ] pos_v3 = vmath.vec3(position) cube = Cube(pos_v3, self.unit_scale, self.texture_path, scale, [0, 0, 0], [0, 0, 0, 1], True) cube.model.rotation = vmath.quat([0, 0, 0, 1]) self.showcase.add(cube.model) self.cube_list.append(cube)
def CheckInsideActiveRange(self, player): player_pos, player_orn = p.getBasePositionAndOrientation(player.colId) for bd in self.finalScene.bodies: if not bd or bd in self.finalScene.activatedBodies: continue pos, orn = p.getBasePositionAndOrientation(bd) distanceVec = [ player_pos[0] - pos[0], player_pos[1] - pos[1], player_pos[2] - pos[2] ] distance = vmath.length(vmath.vec3(distanceVec)) if distance < self.activeRange: # Then activate bd p.changeDynamics(bodyUniqueId=bd, linkIndex=-1, mass=5) self.finalScene.activatedBodies.append(bd)
def ResetPlayer(self, player): pos, orn = p.getBasePositionAndOrientation(player.colId) linearVelocity, angularVelocity = p.getBaseVelocity(player.colId) newPos = [0, 0, pos[2]] p.resetBasePositionAndOrientation(player.colId, newPos, orn) #Target target = [0, 30, 2] direction = [ target[0] - newPos[0], target[1] - newPos[1], target[2] - newPos[2] ] multiVelocity = vmath.length(vmath.vec3(linearVelocity)) self.finalVelocity = newVelocity = [ direction[0] * multiVelocity * 0.05, direction[1] * multiVelocity * 0.05, direction[2] * multiVelocity * 0.05 ] p.resetBaseVelocity(player.colId, newVelocity, angularVelocity)
def _create_device_objects(self): self.camera = pyxie.camera('2dcamera') self.camera.orthographicProjection = True self.camera.position = pyvmath.vec3(0, 0, 1) self.camera.screenScale = (1, -1) w, h = pyxie.viewSize() self.camera.screenOffset = -w, h gen = pyxie.shaderGenerator() gen.setColorTexture(True) gen.setVertexColor(True) self.editableFigure = pyxie.editableFigure('font') self.editableFigure.addMaterial("mate01", gen) self.editableFigure.setMaterialParam("mate01", "DiffuseColor", (1.0, 1.0, 1.0, 1.0)) self.editableFigure.setMaterialRenderState("mate01", "blend_enable", True) self.editableFigure.addJoint('joint') self.showcase = pyxie.showcase('imgui') self.showcase.add(self.editableFigure)
def ConstructPybulletProcess(self): boxinfo = [] with open("TestVoxel/boxinfo.pickle", "rb") as f: boxinfo = pickle.load(f) self.bodies = [] box1 = boxinfo[0] SCALE = 0.98 shape = p.createCollisionShape(p.GEOM_BOX, halfExtents=[ self.size / 2 * SCALE, self.size / 2 * SCALE, self.size / 2 * SCALE ]) for data in self.newBoxData: quat = [0.7071068, 0, 0, 0.7071068] vec = [ data[0] - self.center[0], data[1] - self.center[1], data[2] - self.center[2] ] newVec = vmath.rotate(vmath.vec3(vec), vmath.quat(quat)) newPos = [ newVec.x + self.center[0], newVec.y + self.center[1], newVec.z + self.center[2] ] body = p.createMultiBody(baseMass=0, baseCollisionShapeIndex=shape, basePosition=newPos) p.changeDynamics( bodyUniqueId=body, linkIndex=-1, mass=0, linearDamping=0.4, angularDamping=1, restitution=0.8, ) self.bodies.append(body)
def __init__(self, pos, backgroundBarScale, sliderBarScale, tickScale, backgroundBarPath, sliderBarPath, tickPath, showcase): # Supporting attribute self.percentComplete = 0.05 self.onAlert = False self.oneStarPercent = 0.5 self.twoStarPercent = 0.6 self.threeStarPercent = 0.8 self.isDisable = True # Background bar self.backgroundBarPos = pos self.backgroundBarScale = backgroundBarScale self.backgroundBarPath = backgroundBarPath self.backgroundBar = graphicsHelper.createSprite( self.backgroundBarScale[0], self.backgroundBarScale[1], self.backgroundBarPath) self.backgroundBar.position = vmath.vec3(self.backgroundBarPos) # Slider bar self.sliderBarPos = [ self.backgroundBarPos[0] - self.backgroundBarScale[0] / 2 + (sliderBarScale[0] * self.percentComplete) / 2, self.backgroundBarPos[1], self.backgroundBarPos[2] + 1.0 ] self.sliderBarScale = sliderBarScale self.sliderBarPath = sliderBarPath self.sliderBar = graphicsHelper.createSprite(self.sliderBarScale[0], self.sliderBarScale[1], self.sliderBarPath) self.sliderBar.position = vmath.vec3(self.sliderBarPos) # Tick self.oneStarTickPos = [ self.backgroundBarPos[0] - self.backgroundBarScale[0] / 2 + self.backgroundBarScale[0] * self.oneStarPercent, self.backgroundBarPos[1], self.backgroundBarPos[2] + 2.0 ] self.twoStarTickPos = [ self.backgroundBarPos[0] - self.backgroundBarScale[0] / 2 + self.backgroundBarScale[0] * self.twoStarPercent, self.backgroundBarPos[1], self.backgroundBarPos[2] + 2.0 ] self.threeStarTickPos = [ self.backgroundBarPos[0] - self.backgroundBarScale[0] / 2 + self.backgroundBarScale[0] * self.threeStarPercent, self.backgroundBarPos[1], self.backgroundBarPos[2] + 2.0 ] self.tickScale = tickScale self.tickPath = tickPath self.oneStarTick = graphicsHelper.createSprite(self.tickScale[0], self.tickScale[1], self.tickPath) self.oneStarTick.position = vmath.vec3(self.oneStarTickPos) self.twoStarTick = graphicsHelper.createSprite(self.tickScale[0], self.tickScale[1], self.tickPath) self.twoStarTick.position = vmath.vec3(self.twoStarTickPos) self.threeStarTick = graphicsHelper.createSprite( self.tickScale[0], self.tickScale[1], self.tickPath) self.threeStarTick.position = vmath.vec3(self.threeStarTickPos) # UI parts self.showcase = showcase
def __autoReTransform(self): self.mesh.position = vmath.vec3(self.gameObject.transform.position) self.mesh.rotation = vmath.quat( helperFunction.fromEulerToQuaternion( self.gameObject.transform.rotation)) self.mesh.scale = vmath.vec3(self.gameObject.transform.scale)
restitution=0.8, ) bodies.append(body) # bodies = [] # for data in boxinfo: # body = p.createMultiBody( # baseMass=1, baseCollisionShapeIndex=shape, basePosition=data[0] # ) # bodies.append(body) figure = pyxie.figure("Castle_standard") cam = pyxie.camera() cam.position = (0, -2, 1) cam.target = vmath.vec3(0, 0, 0) showcase = pyxie.showcase("case") showcase.add(figure) FPS = 240 p.setPhysicsEngineParameter( fixedTimeStep=1.0 / FPS, numSolverIterations=12, numSubSteps=3, # 8 is smooth but not sure abt performance. Lowered substeps actually raise fps contactBreakingThreshold=0.00000002, useSplitImpulse=0, splitImpulsePenetrationThreshold=9999999, enableConeFriction=0, deterministicOverlappingPairs=0, solverResidualThreshold=0.1,
def CheckDeath(self): linearVelocity, angularVelocity = p.getBaseVelocity(self.colId) velocity = vmath.length(vmath.vec3(linearVelocity)) if velocity < self.kEpsilon: self.isDeath = True # p.changeDynamics(self.colId, -1, mass=0)
def CameraFollow(self): # If this character have camfollow, make camera follow it if self.camFollow: self.cam.position = self.model.position + vmath.vec3(self.camDis) self.cam.target = self.model.position
def __init__(self): super().__init__() self.position = pm.vec3(0, 0, 0) self.rotation = pm.vec3(0, 0, 0) self.scale = pm.vec3(1, 1, 1)
pyxie.window(True, SCREEN_WIDTH, SCREEN_HEIGHT) physicsClient = p.connect(p.GUI) p.setAdditionalSearchPath(pybullet_data.getDataPath()) boxHalfLength = 0.5 boxHalfWidth = 0.5 boxHalfHeight = 0.5 segmentLength = 5 # Create dictionary to store collision collision_objects = dict() # PYXIE SETTING REGION # ============================================================================================================= cam = pyxie.camera('maincam') cam.lockon = True cam.position = vmath.vec3(0.0, -3.0, 3) cam.target = vmath.vec3(0.0, 0.0, 0.0) showcase = pyxie.showcase("case01") scale = vmath.vec3(1, 1, 1) position = vmath.vec3(0.0, 0.0, 3) player_col_scale = [0.1, 0.1, 1] player_col_local_pos = [0.0, 0.0, 1.1] player = Player(position, scale, [0, 0.7071068, 0.7071068, 0], 'asset/Sapphiart', cam, player_col_scale, player_col_local_pos, True) p.changeDynamics(player.colId, -1, linearDamping=100.0, lateralFriction=1, restitution=0.0)