def MatrixCallback(self): matr = self.ui.MatrixIn.toPlainText() matr = str(matr).split() matr = [float(element) for element in matr] dt = self.ui.DTIn.text() dt = str(dt).split(" ") dt = [float(element) for element in dt] if sqrt(len(matr)) - int(sqrt(len(matr))) != 0 or matr[0] == '': self.ui.textBrowser.append( "Girilen matris kare ve bos olmayan bir matris olmalidir.") return matr = Matrix(int(sqrt(len(matr))), matr) try: if self.ui.radioMatrix.isChecked(): self.ui.textBrowser.append("Cozum takimi : " + str(matr.gaussElimination(dt))) elif self.ui.radioMatrix2.isChecked(): self.ui.textBrowser.append("Invers Matris :") for row in matr.inverse().matrix: self.ui.textBrowser.append(str(row)) elif self.ui.radioMatrix3.isChecked(): self.ui.textBrowser.append("Determinant : " + str(matr.determinant())) except Exception as exc: self.ui.textBrowser.append(exc.args[0])
def __init__(self): self.__flagModel = None self.__flagFashion = None self.__flagScaleMatrix = Matrix() self.__flagStaffModel = None self.__flagStaffFashion = None return
def __update(self): self.__updateCallbackId = None self.__updateCallbackId = BigWorld.callback(0.0, self.__update) curTime = BigWorld.time() dt = curTime - self.__prevTime self.__prevTime = curTime self.__currentAngle += self.__angularVelocity * dt if self.__currentAngle > 2 * math.pi: self.__currentAngle -= 2 * math.pi elif self.__currentAngle < -2 * math.pi: self.__currentAngle += 2 * math.pi radialPosition = Vector3(self.radius * math.sin(self.__currentAngle), 0, self.radius * math.cos(self.__currentAngle)) modelYaw = self.__currentAngle if self.rotateClockwise: modelYaw += math.pi / 2 else: modelYaw -= math.pi / 2 localMatrix = Matrix() localMatrix.setRotateY(modelYaw) localMatrix.translation = radialPosition self.__modelMatrix.setRotateYPR((self.yaw, self.pitch, self.roll)) self.__modelMatrix.translation = self.position self.__modelMatrix.preMultiply(localMatrix) return
def __onDebugInfoReceived(self, argStr): from Math import Matrix, Vector3 positions = wgPickle.loads(wgPickle.FromServerToClient, argStr) for planeID, pos in positions: m = Matrix() m.setTranslate(pos) BigWorld.addPoint('spawnPoint%d' % planeID, m, 4278190335L, False)
def __addEntryLit(self, id, matrix, visible = True): battleCtx = g_sessionProvider.getCtx() if battleCtx.isObserver(id): return if matrix is None: return mp = Math.WGReplayAwaredSmoothTranslationOnlyMP() mp.source = matrix scaledMatrix = None if self.__markerScale is not None: scaleMatrix = Matrix() scaleMatrix.setScale(Vector3(self.__markerScale, self.__markerScale, self.__markerScale)) scaledMatrix = mathUtils.MatrixProviders.product(scaleMatrix, mp) if scaledMatrix is None: handle = self.__ownUI.addEntry(mp, self.zIndexManager.getVehicleIndex(id)) else: handle = self.__ownUI.addEntry(scaledMatrix, self.zIndexManager.getVehicleIndex(id)) entry = {'matrix': mp, 'handle': handle} arena = BigWorld.player().arena entryVehicle = arena.vehicles[id] entityName = battleCtx.getPlayerEntityName(id, entryVehicle.get('team')) markerType = entityName.base entryName = entityName.name() self.__entrieLits[id] = entry vName = entryVehicle['vehicleType'].type.shortUserString self.__ownUI.entryInvoke(entry['handle'], ('init', [markerType, entryName, 'lastLit', '', vName])) if not visible: self.__ownUI.entryInvoke(entry['handle'], ('setVisible', [visible])) if self.__markerScale is None: self.__parentUI.call('minimap.entryInited', [])
def __addDeadEntry(self, entry, id): """ adding death animation to minimap (WOTD-5884) """ if id in BigWorld.entities.keys(): m = self.__getEntryMatrixByLocation(id, entry['location']) scaledMatrix = None if self.__markerScale is not None: scaleMatrix = Matrix() scaleMatrix.setScale(Vector3(self.__markerScale, self.__markerScale, self.__markerScale)) scaledMatrix = mathUtils.MatrixProviders.product(scaleMatrix, m) if scaledMatrix is None: entry['handle'] = self.__ownUI.addEntry(m, self.zIndexManager.getDeadVehicleIndex(id)) else: entry['handle'] = self.__ownUI.addEntry(scaledMatrix, self.zIndexManager.getVehicleIndex(id)) self.__entries[id] = entry if not GUI_SETTINGS.permanentMinimapDeath: self.__deadCallbacks[id] = BigWorld.callback(GUI_SETTINGS.minimapDeathDuration / 1000, partial(self.__delEntry, id)) self.__callEntryFlash(id, 'setDead', [GUI_SETTINGS.permanentMinimapDeath]) self.__callEntryFlash(id, 'init', [entry['markerType'], entry['entryName'], entry['vClass'], '']) if self.__markerScale is None: self.__parentUI.call('minimap.entryInited', [])
def scaleMarker(self, handle, originalMatrix, scale): if handle is not None and originalMatrix is not None: scaleMatrix = Matrix() scaleMatrix.setScale(Vector3(scale, scale, scale)) mp = mathUtils.MatrixProviders.product(scaleMatrix, originalMatrix) self.__ownUI.entrySetMatrix(handle, mp) return
def __addEntryMarker(self, marker, matrix): if matrix is None: return else: mp = Math.WGReplayAwaredSmoothTranslationOnlyMP() mp.source = matrix scaledMatrix = None if self.__markerScale is not None: scaleMatrix = Matrix() scaleMatrix.setScale(Vector3(self.__markerScale, self.__markerScale, self.__markerScale)) scaledMatrix = mathUtils.MatrixProviders.product(scaleMatrix, mp) zIndex = self.zIndexManager.getMarkerIndex(marker) if scaledMatrix is None: handle = self.__ownUI.addEntry(mp, zIndex) else: handle = self.__ownUI.addEntry(scaledMatrix, zIndex) entry = {'matrix': mp, 'handle': handle} self.__entrieMarkers[marker] = entry self.__ownUI.entryInvoke(entry['handle'], ('init', ['fortConsumables', marker, '', '', 'empty'])) if self.__markerScale is None: self.__parentUI.call('minimap.entryInited', []) return handle
def __calcCurOscillatorAcceleration(self, deltaTime): vehicle = BigWorld.player().vehicle if vehicle is None or not vehicle.isAlive(): return Vector3(0, 0, 0) else: curVelocity = vehicle.filter.velocity relativeSpeed = curVelocity.length / vehicle.typeDescriptor.physics[ 'speedLimits'][0] if relativeSpeed >= SniperCamera._MIN_REL_SPEED_ACC_SMOOTHING: self.__accelerationSmoother.maxAllowedAcceleration = self.__dynamicCfg[ 'accelerationThreshold'] else: self.__accelerationSmoother.maxAllowedAcceleration = self.__dynamicCfg[ 'accelerationMax'] acceleration = self.__accelerationSmoother.update( vehicle, deltaTime) camMat = Matrix(self.__cam.matrix) acceleration = camMat.applyVector(-acceleration) accelSensitivity = self.__dynamicCfg['accelerationSensitivity'] acceleration.x *= accelSensitivity.x acceleration.y *= accelSensitivity.y acceleration.z *= accelSensitivity.z oscillatorAcceleration = Vector3(0, -acceleration.y + acceleration.z, -acceleration.x) return oscillatorAcceleration
def __update(self, dx, dy, dz, rotateMode = True, zoomMode = True, isCallback = False): prevPos = self.__inputInertia.calcWorldPos(self.__aimingSystem.matrix) distChanged = False if zoomMode and dz != 0: prevDist = self.__aimingSystem.distanceFromFocus distDelta = dz * float(self.__curScrollSense) distMinMax = self.__cfg['distRange'] newDist = mathUtils.clamp(distMinMax.min, distMinMax.max, prevDist - distDelta) if abs(newDist - prevDist) > 0.001: self.__aimingSystem.distanceFromFocus = newDist self.__userCfg['startDist'] = newDist self.__inputInertia.glideFov(self.__calcRelativeDist()) self.__aimingSystem.aimMatrix = self.__calcAimMatrix() distChanged = True changeControlMode = prevDist == newDist and mathUtils.almostZero(newDist - distMinMax.min) if changeControlMode and self.__onChangeControlMode is not None: self.__onChangeControlMode() return if rotateMode: self.__updateAngles(dx, dy) if ENABLE_INPUT_ROTATION_INERTIA and not distChanged: self.__aimingSystem.update(0.0) if ENABLE_INPUT_ROTATION_INERTIA or distChanged: worldDeltaPos = prevPos - self.__aimingSystem.matrix.translation matInv = Matrix(self.__aimingSystem.matrix) matInv.invert() self.__inputInertia.glide(matInv.applyVector(worldDeltaPos)) return
def collideSegment(self, startPoint, endPoint, skipGun=False): res = None filterMethod = getattr(self.filter, 'segmentMayHitEntity', lambda: True) if not filterMethod(startPoint, endPoint, 0): return res else: matricesToCheck = [Matrix(self.model.matrix)] if not skipGun: matricesToCheck.append( Matrix(self.model.node(TankPartNames.GUN))) for matrix, desc in zip(matricesToCheck, self.__componentsDesc): toModel = matrix toModel.invert() collisions = desc.hitTester.localHitTest( toModel.applyPoint(startPoint), toModel.applyPoint(endPoint)) if collisions is None: continue for dist, _, hitAngleCos, matKind in collisions: if res is None or res.dist >= dist: matInfo = desc.materials.get(matKind) res = SegmentCollisionResult( dist, hitAngleCos, matInfo.armor if matInfo is not None else 0) return res
def setControlMtx(self, mtx): translation = Matrix() translation.translation = Vector3(0, 0, BigWorld.player().reductionPoint) self._controlMtx = MatrixProduct() self._controlMtx.b = mtx self._controlMtx.a = translation
def MatrixCallback(self): matr=self.ui.MatrixIn.toPlainText() matr=str(matr).split() matr=[float(element) for element in matr] dt=self.ui.DTIn.text() dt=str(dt).split(" ") dt=[float(element) for element in dt] if sqrt(len(matr))-int(sqrt(len(matr)))!=0 or matr[0]=='': self.ui.textBrowser.append("Girilen matris kare ve bos olmayan bir matris olmalidir.") return matr=Matrix(int(sqrt(len(matr))), matr) try: if self.ui.radioMatrix.isChecked(): self.ui.textBrowser.append("Cozum takimi : " + str(matr.gaussElimination(dt))) elif self.ui.radioMatrix2.isChecked(): self.ui.textBrowser.append("Invers Matris :") for row in matr.inverse().matrix: self.ui.textBrowser.append(str(row)) elif self.ui.radioMatrix3.isChecked(): self.ui.textBrowser.append("Determinant : " + str(matr.determinant())) except Exception as exc: self.ui.textBrowser.append(exc.args[0])
def __update(self, dx, dy, dz, rotateMode = True, zoomMode = True, isCallback = False): prevPos = self.__inputInertia.calcWorldPos(self.__aimingSystem.matrix) distChanged = False if zoomMode and dz != 0: prevDist = self.__aimingSystem.distanceFromFocus distDelta = dz * float(self.__curScrollSense) distMinMax = self.__cfg['distRange'] newDist = mathUtils.clamp(distMinMax.min, distMinMax.max, prevDist - distDelta) if abs(newDist - prevDist) > 0.001: self.__aimingSystem.distanceFromFocus = newDist self.__userCfg['startDist'] = newDist self.__inputInertia.glideFov(self.__calcRelativeDist()) self.__aimingSystem.aimMatrix = self.__calcAimMatrix() distChanged = True changeControlMode = prevDist == newDist and mathUtils.almostZero(newDist - distMinMax.min) if changeControlMode and self.__onChangeControlMode is not None: self.__onChangeControlMode() return if rotateMode: self.__updateAngles(dx, dy) if ENABLE_INPUT_ROTATION_INERTIA and not distChanged: self.__aimingSystem.update(0.0) if ENABLE_INPUT_ROTATION_INERTIA or distChanged: worldDeltaPos = prevPos - self.__aimingSystem.matrix.translation matInv = Matrix(self.__aimingSystem.matrix) matInv.invert() self.__inputInertia.glide(matInv.applyVector(worldDeltaPos))
def __onResourcesLoaded(self, resourceRefs): if self.guid not in BigWorld.userDataObjects: return else: self.__clear() if self.modelName in resourceRefs.failedIDs: return try: self.__model = resourceRefs[self.modelName] self.__modelMatrix = Matrix() self.__modelMatrix.setIdentity() servo = BigWorld.Servo(self.__modelMatrix) self.__model.addMotor(servo) BigWorld.addModel(self.__model) if self.actionName != '': action = self.__model.action(self.actionName) if action is not None: action() if self.pixieName != '' and self.pixieName not in resourceRefs.failedIDs: pixieNode = self.__model.node(self.pixieHardPoint) pixieNode.attach(resourceRefs[self.pixieName]) if self.soundName != '': self.__sound = SoundGroups.g_instance.getSound3D( self.__modelMatrix, self.soundName) except: LOG_CURRENT_EXCEPTION() self.__model = None return self.__prevTime = BigWorld.time() self.__update() return
def __getMarkerMatrix(self, destructibleEntity): guiNode = destructibleEntity.getGuiNode() if guiNode is not None: return guiNode else: m = Matrix() m.translation = destructibleEntity.position + settings.MARKER_POSITION_ADJUSTMENT return m
def __calcAimOffset(self, aimLocalTransform = None): worldCrosshair = Matrix(self.__crosshairMatrix) aimingSystemMatrix = self.__aimingSystem.matrix if aimLocalTransform is not None: worldCrosshair.postMultiply(aimLocalTransform) worldCrosshair.postMultiply(aimingSystemMatrix) aimOffset = cameras.projectPoint(worldCrosshair.translation) return Vector2(mathUtils.clamp(-0.95, 0.95, aimOffset.x), mathUtils.clamp(-0.95, 0.95, aimOffset.y))
def __getLookAtYPR(self, lookAtPosition): lookDir = lookAtPosition - self.__position camMat = Matrix() camMat.lookAt(self.__position, lookDir, Vector3(0, 1, 0)) camMat.invert() yaw = camMat.yaw pitch = camMat.pitch return Vector3(yaw, pitch, self.__ypr.z)
class FlagModel(object): model = property(lambda self: self.__flagStaffModel) def __init__(self): self.__flagModel = None self.__flagAnimator = None self.__flagFashion = None self.__flagScaleMatrix = Matrix() self.__flagStaffModel = None self.__flagStaffFashion = None return def setupFlag(self, position, flagSettings, color): self.__setupFlagStaff(flagSettings, position) self.__setupFlagModel(flagSettings, color) def changeFlagColor(self, color): if self.__flagFashion: self.__flagFashion.setColor(color) def startFlagAnimation(self): if self.__flagModel is not None: try: clipResource = self.__flagModel.deprecatedGetAnimationClipResource(self.__flagSettings.flagAnim) if clipResource: loader = AnimationSequence.Loader(clipResource, BigWorld.player().spaceID) self.__flagAnimator = loader.loadSync() self.__flagAnimator.bindTo(AnimationSequence.ModelWrapperContainer(self.__flagModel)) self.__flagAnimator.start() except Exception: LOG_WARNING('Unable to start "%s" animation action for model' % self.__flagSettings.flagAnim) return def __setupFlagStaff(self, flagSettings, position): self.__flagStaffModel = flagSettings.flagStaffModel self.__flagStaffModel.position = position self.__flagStaffFashion = BigWorld.WGAlphaFadeFashion() self.__flagStaffModel.fashion = self.__flagStaffFashion def __setupFlagModel(self, flagSettings, color): self.__flagSettings = flagSettings self.__flagScaleMatrix = Matrix() self.__flagScaleMatrix.setScale(flagSettings.flagScale) flagNode = self.__flagStaffModel.node(flagSettings.flagStaffFlagHP, self.__flagScaleMatrix) if self.__flagModel is not None: flagNode.detach(self.__flagModel) self.__flagModel = None self.__flagModel = flagSettings.flagModel self.__flagFashion = BigWorld.WGFlagAlphaFadeFashion() self.__flagFashion.setColor(color) self.__flagFashion.setFlagBackgroundTexture(flagSettings.flagBackgroundTex) self.__flagFashion.setEmblemTexture(flagSettings.flagEmblemTex, flagSettings.flagEmblemTexCoords) self.__flagModel.fashion = self.__flagFashion if self.__flagModel is not None: flagNode.attach(self.__flagModel) self.__flagFashion.overridePosition(self.__flagStaffModel.matrix) return
class FlagModel(object): model = property(lambda self: self.__flagStaffModel) def __init__(self): self.__flagModel = None self.__flagFashion = None self.__flagScaleMatrix = Matrix() self.__flagStaffModel = None self.__flagStaffFashion = None return def setupFlag(self, position, flagSettings, color): self.__setupFlagStaff(flagSettings, position) self.__setupFlagModel(flagSettings, color) def changeFlagColor(self, color): if self.__flagFashion: self.__flagFashion.setColor(color) def startFlagAnimation(self): if self.__flagModel is not None: try: animAction = self.__flagModel.action( self.__flagSettings.flagAnim) animAction() except Exception: LOG_WARNING('Unable to start "%s" animation action for model' % self.__flagSettings.flagAnim) return def __setupFlagStaff(self, flagSettings, position): self.__flagStaffModel = flagSettings.flagStaffModel self.__flagStaffModel.position = position self.__flagStaffFashion = BigWorld.WGAlphaFadeFashion() self.__flagStaffModel.fashion = self.__flagStaffFashion def __setupFlagModel(self, flagSettings, color): self.__flagSettings = flagSettings self.__flagScaleMatrix = Matrix() self.__flagScaleMatrix.setScale(flagSettings.flagScale) flagNode = self.__flagStaffModel.node(flagSettings.flagStaffFlagHP, self.__flagScaleMatrix) if self.__flagModel is not None: flagNode.detach(self.__flagModel) self.__flagModel = None self.__flagModel = flagSettings.flagModel self.__flagFashion = BigWorld.WGFlagAlphaFadeFashion() self.__flagFashion.setColor(color) self.__flagFashion.setFlagBackgroundTexture( flagSettings.flagBackgroundTex) self.__flagFashion.setEmblemTexture(flagSettings.flagEmblemTex, flagSettings.flagEmblemTexCoords) self.__flagModel.fashion = self.__flagFashion if self.__flagModel is not None: flagNode.attach(self.__flagModel) self.__flagFashion.overridePosition(self.__flagStaffModel.matrix) return
class ArtyAimingSystem(StrategicAimingSystem): def __init__(self): super(ArtyAimingSystem, self).__init__(0.0, 0.0) self.__direction = Vector3(0.0, 0.0, 0.0) self.__aimMatrix = Matrix() @property def aimMatrix(self): return self.__aimMatrix @property def aimPoint(self): return self.__aimMatrix.translation @aimPoint.setter def aimPoint(self, point): self.__aimMatrix.setTranslate(point) @property def hitPoint(self): return self._matrix.translation @property def direction(self): return self.__direction def getDesiredShotPoint(self, terrainOnlyCheck=False): return self.__aimMatrix.translation def _updateMatrix(self): vehiclePosition = Vector3( BigWorld.player().getVehicleAttached().position) vehiclePosition.y = self._planePosition.y diff = self._planePosition - vehiclePosition if diff.lengthSquared < _MINIMAL_AIMING_RADIUS_SQ: diff.normalise() self._planePosition = vehiclePosition + diff * _MINIMAL_AIMING_RADIUS self._clampToArenaBB() hitPoint = BigWorld.wg_collideSegment( BigWorld.player().spaceID, self._planePosition + Vector3(0.0, 1000.0, 0.0), self._planePosition + Vector3(0.0, -250.0, 0.0), 128, 8) aimPoint = Vector3(self._planePosition) if hitPoint is not None: aimPoint.y = hitPoint.closestPoint[1] r0, v0, g0 = BigWorld.player().gunRotator.getShotParams(aimPoint, True) hitPoint = BigWorld.wg_simulateProjectileTrajectory( r0, v0, g0, SERVER_TICK_LENGTH, SHELL_TRAJECTORY_EPSILON_CLIENT, 128) if hitPoint is not None: time = (aimPoint.x - r0.x) / v0.x self.__direction = v0 + g0 * time self.__direction.normalise() self._matrix = mathUtils.createRTMatrix( (self.__direction.yaw, -self.__direction.pitch, 0.0), hitPoint[1]) self.__aimMatrix.setTranslate(aimPoint) return
def update(self): global printedVehicle self.vehicle = BigWorld.entity(self.vehicleID) if self.vehicle is not None: if self.vehicle.health > 0 and self.vehicle.isAlive(): self.isAlive = True if self.isAlive is False or self.vehicle is None or (self.vehicle is not None and self.vehicle.health <= 0): print('[predictAim] enemy died or does not exists') self.hideVisible() return if not hasattr(BigWorld.player(), 'vehicleTypeDescriptor') or not hasattr(BigWorld.player(), 'gunRotator') or (hasattr(self.vehicle,"health") and self.vehicle.health <= 0): print('[predictAim] player has no vehicleTypeDescriptor or gunRotator OR enemy is has no health or health is lower/same as zero') self.hideVisible() return if self.modelDot is not None and self.modelDot._StaticObjectMarker3D__model: playerVehicleID = BigWorld.player().playerVehicleID if playerVehicleID: playerVehicle = BigWorld.entity(playerVehicleID) playerPosition = playerVehicle.model.node("hull").position self.vehicle = BigWorld.entity(self.vehicleID) shotSpeed = BigWorld.player().vehicleTypeDescriptor.shot.speed distance = playerPosition.flatDistTo(self.vehicle.model.node("hull").position) traveltime = distance / shotSpeed enemyCurrentSpeed = self.vehicle.speedInfo.value if self.lastSpeedValue is None or self.lastSpeedValue is enemyCurrentSpeed: self.lastSpeedValue = enemyCurrentSpeed enemyCurrentSpeed = (enemyCurrentSpeed + self.lastSpeedValue) / 2 self.lastSpeedValue = enemyCurrentSpeed centerFront = self.vehicle.model.node("hull").position cMin , cMax , _ = self.vehicle.getBounds(TankPartIndexes.CHASSIS) _ , hMax , _ = self.vehicle.getBounds(TankPartIndexes.HULL) hMax.y += cMax.y _ , tMax , _ =self.vehicle.getBounds(TankPartIndexes.TURRET) tMax.y += hMax.y cMax.y = tMax.y matrix = Matrix(self.vehicle.matrix) FRONT_RIGTH_BOTTOM = matrix.applyVector(Vector3(cMax.x , cMin.y , cMax.z )) + self.vehicle.position FRONT_LEFT_BOTTOM = matrix.applyVector(Vector3(cMin.x , cMin.y , cMax.z )) + self.vehicle.position centerFront = (FRONT_RIGTH_BOTTOM + FRONT_LEFT_BOTTOM)/2 #print("[predictAim]: center Front pos: %s" % centerFront) #print("[predictAim]: hull: %s" % self.vehicle.model.node("hull").position) #print("[predictAim]: center Back pos: %s" % centerBack) travel_distance_0 = enemyCurrentSpeed[0] * traveltime #travel_distance_2 = enemyCurrentSpeed[2] * traveltime v = centerFront - self.vehicle.model.node("hull").position v3 = Vector3(v) #v3.normalise() predPos_test = self.vehicle.model.node("hull").position + (v3*travel_distance_0) tmp_veh = BigWorld.entity(self.vehicleID) predPos_test[1] = tmp_veh.model.node("hull").position[1] self.modelDot._StaticObjectMarker3D__model.position = predPos_test self.modelDot._StaticObjectMarker3D__model.visible = True
def _setMarkerPosition(self, markerID, position): """Sets position of marker. :param markerID: integer containing unique ID of marker. :param position: Math.Vector3 containing new position. :return: """ matrix = Matrix() matrix.setTranslate(position) self._parentObj.setMarkerMatrix(markerID, matrix)
def decodeHitPoints(encodedPoints, collisionComponent): resultPoints = [] maxHitEffectCode = None maxDamagedComponentName = None for encodedPoint in encodedPoints: compIdx, hitEffectCode, startPoint, endPoint = DamageFromShotDecoder.decodeSegment( encodedPoint, collisionComponent) if startPoint == endPoint or compIdx < 0: continue if hitEffectCode > maxHitEffectCode: maxHitEffectCode = hitEffectCode maxDamagedComponentName = TankPartIndexes.getName(compIdx) hitTestRes = collisionComponent.collideLocal( compIdx, startPoint, endPoint) bbox = collisionComponent.getBoundingBox(compIdx) if not hitTestRes or hitTestRes < 0.0: width, height, depth = (bbox[1] - bbox[0]) / 256.0 directions = [ Math.Vector3(0.0, -height, 0.0), Math.Vector3(0.0, height, 0.0), Math.Vector3(-width, 0.0, 0.0), Math.Vector3(width, 0.0, 0.0), Math.Vector3(0.0, 0.0, -depth), Math.Vector3(0.0, 0.0, depth) ] for direction in directions: hitTestRes = collisionComponent.collideLocal( compIdx, startPoint + direction, endPoint + direction) if hitTestRes >= 0.0: break if hitTestRes is None or hitTestRes < 0.0: newPoint = collisionComponent.collideLocalPoint( compIdx, startPoint, MAX_FALLBACK_CHECK_DISTANCE) if newPoint.length > 0.0: hitRay = endPoint - startPoint hitTestRes = hitRay.length endPoint = newPoint startPoint = endPoint - hitRay if hitTestRes is None or hitTestRes < 0.0: continue minDist = hitTestRes hitDir = endPoint - startPoint hitDir.normalise() rot = Matrix() rot.setRotateYPR((hitDir.yaw, hitDir.pitch, 0.0)) matrix = Matrix() matrix.setTranslate(startPoint + hitDir * minDist) matrix.preMultiply(rot) effectGroup = DamageFromShotDecoder.__hitEffectCodeToEffectGroup[ hitEffectCode] componentName = TankPartIndexes.getName(compIdx) resultPoints.append( DamageFromShotDecoder.ShotPoint(componentName, matrix, effectGroup)) return (maxHitEffectCode, resultPoints, maxDamagedComponentName)
def applyImpulse(self, position, impulse, reason=ImpulseReason.ME_HIT): adjustedImpulse, noiseMagnitude = self.__dynamicCfg.adjustImpulse(impulse, reason) camMatrix = Matrix(self.__cam.matrix) impulseLocal = camMatrix.applyVector(adjustedImpulse) impulseAsYPR = Vector3(impulseLocal.x, -impulseLocal.y + impulseLocal.z, 0) rollPart = self.__dynamicCfg['impulsePartToRoll'] impulseAsYPR.z = -rollPart * impulseAsYPR.x impulseAsYPR.x *= 1 - rollPart self.__impulseOscillator.applyImpulse(impulseAsYPR) self.__applyNoiseImpulse(noiseMagnitude)
def _createMarkerWithPosition(self, symbol, position, active=True): """Creates 2D marker that has static position on world. :param symbol: string containing name of symbol to create desired UI component in the Flash. :param position: Math.Vector3 containing world position. :param active: True if marker is visible, otherwise - False. :return: integer containing unique ID of marker. """ matrixProvider = Matrix() matrixProvider.translation = position return self._parentObj.createMarker(symbol, matrixProvider, active)
def applyImpulse(self, position, impulse, reason = ImpulseReason.ME_HIT): adjustedImpulse, noiseMagnitude = self.__dynamicCfg.adjustImpulse(impulse, reason) camMatrix = Matrix(self.__cam.matrix) impulseLocal = camMatrix.applyVector(adjustedImpulse) impulseAsYPR = Vector3(impulseLocal.x, -impulseLocal.y + impulseLocal.z, 0) rollPart = self.__dynamicCfg['impulsePartToRoll'] impulseAsYPR.z = -rollPart * impulseAsYPR.x impulseAsYPR.x *= 1 - rollPart self.__impulseOscillator.applyImpulse(impulseAsYPR) self.__applyNoiseImpulse(noiseMagnitude)
def prerequisites(self): stepRepairPointComponent = BigWorld.player().arena.componentSystem.stepRepairPointComponent if stepRepairPointComponent is not None: stepRepairPointComponent.addStepRepairPoint(self) rv = [_g_stepRepairPointSettings.flagModel, _g_stepRepairPointSettings.radiusModel] mProv = Matrix() mProv.translation = self.position self.__stepRepairPointSoundObject = SoundGroups.g_instance.WWgetSoundObject('stepRepairPoint_' + str(self), mProv) self.__stepRepairPointSoundObject.play(_g_stepRepairPointSettings.attachedSoundEventName) return rv
def bind(self, vehicle, bindWorldPos = None): self.__vehicle = vehicle if vehicle is None: self.matrix = mathUtils.createIdentityMatrix() self.__lookAtProvider = None return toLocalMat = Matrix(vehicle.matrix) toLocalMat.invert() self.__boundLocalPos = None if bindWorldPos is None else toLocalMat.applyPoint(bindWorldPos) self.selectPlacement(_VehicleBounder.SELECT_CHASSIS)
def destroyFireball(owner, fireball, fx, explosionFXName, targetHitCallback, prereqs): m = Matrix(fireball.motors[0].target) fx.detach() owner.delModel(fireball) explosion = BigWorld.Model('') owner.addModel(explosion) explosion.position = m.applyToOrigin() fireballfx = FX.bufferedOneShotEffect(explosionFXName, explosion, explosion, lambda : owner.delModel(explosion), 10.0, prereqs) if targetHitCallback != None: targetHitCallback(owner, m) return
def createSRTMatrix(scale, rotation, translation): scaleMatrix = Matrix() scaleMatrix.setScale(scale) result = Matrix() result.setRotateYPR(rotation) result.translation = translation result.preMultiply(scaleMatrix) return result
def bind(self, vehicle, bindWorldPos = None): self.__vehicle = vehicle if vehicle is None: self.matrix = mathUtils.createIdentityMatrix() self.__lookAtProvider = None return else: toLocalMat = Matrix(vehicle.matrix) toLocalMat.invert() self.__boundLocalPos = None if bindWorldPos is None else toLocalMat.applyPoint(bindWorldPos) self.selectPlacement(_VehicleBounder.SELECT_CHASSIS) return
def __init__(self, zone): self._zone = zone self._matrix = None self._markerId = None areaMarkerCtrl = self.sessionProvider.shared.areaMarker if areaMarkerCtrl: self._matrix = Matrix() marker = areaMarkerCtrl.createMarker(self._matrix, MarkerItem.DEATHZONE) self._markerId = areaMarkerCtrl.addMarker(marker) areaMarkerCtrl.onTickUpdate += self._tickUpdate return
def decodeHitPoints(encodedPoints, vehicleDescr): resultPoints = [] maxHitEffectCode = None maxDamagedComponentName = None for encodedPoint in encodedPoints: compName, hitEffectCode, startPoint, endPoint = DamageFromShotDecoder.decodeSegment( encodedPoint, vehicleDescr) if startPoint == endPoint: continue if hitEffectCode > maxHitEffectCode: maxHitEffectCode = hitEffectCode maxDamagedComponentName = compName hitTester = getattr(vehicleDescr, compName).hitTester hitTestRes = hitTester.localHitTest(startPoint, endPoint) if not hitTestRes: width, height, depth = (hitTester.bbox[1] - hitTester.bbox[0]) / 256.0 directions = [ Math.Vector3(0.0, -height, 0.0), Math.Vector3(0.0, height, 0.0), Math.Vector3(-width, 0.0, 0.0), Math.Vector3(width, 0.0, 0.0), Math.Vector3(0.0, 0.0, -depth), Math.Vector3(0.0, 0.0, depth) ] for direction in directions: hitTestRes = hitTester.localHitTest( startPoint + direction, endPoint + direction) if hitTestRes is not None: break if hitTestRes is None: continue minDist = hitTestRes[0][0] for i in xrange(1, len(hitTestRes)): dist = hitTestRes[i][0] if dist < minDist: minDist = dist hitDir = endPoint - startPoint hitDir.normalise() rot = Matrix() rot.setRotateYPR((hitDir.yaw, hitDir.pitch, 0.0)) matrix = Matrix() matrix.setTranslate(startPoint + hitDir * minDist) matrix.preMultiply(rot) effectGroup = DamageFromShotDecoder.__hitEffectCodeToEffectGroup[ hitEffectCode] resultPoints.append( DamageFromShotDecoder.ShotPoint(compName, matrix, effectGroup)) return (maxHitEffectCode, resultPoints, maxDamagedComponentName)
def __processBindToVehicleKey(self): if BigWorld.isKeyDown(Keys.KEY_LSHIFT) or BigWorld.isKeyDown(Keys.KEY_RSHIFT): self.__toggleView() elif BigWorld.isKeyDown(Keys.KEY_LALT) or BigWorld.isKeyDown(Keys.KEY_RALT): worldMat = Math.Matrix(self.__cam.invViewProvider) self.__basisMProv.selectNextPlacement() boundMatrixInv = Matrix(self.__basisMProv.matrix) boundMatrixInv.invert() worldMat.postMultiply(boundMatrixInv) self.__position = worldMat.translation self.__ypr = Vector3(worldMat.yaw, worldMat.pitch, worldMat.roll) else: self.__switchBind()
def _getTurretYawGunPitch(self, targetPos, compensateGravity=False): vehicleMatrix = Matrix(self._vehicleMProv) turretOffset = GunMatCalc.turretOffset(self._vehicleTypeDescriptor) gunShotOffset = GunMatCalc.gunShotOffset(self._vehicleTypeDescriptor, self.__gunIndex) speed = self._vehicleTypeDescriptor.shot.speed gravity = self._vehicleTypeDescriptor.shot.gravity if not compensateGravity else 0.0 turretYaw, gunPitch = BigWorld.wg_getShotAngles(turretOffset, gunShotOffset, vehicleMatrix, speed, gravity, 0.0, 0.0, targetPos, False) rotation = math_utils.createRotationMatrix((turretYaw, gunPitch, 0.0)) rotation.postMultiply(vehicleMatrix) invertSteady = Matrix(self._vehicleMProv) invertSteady.invert() rotation.postMultiply(invertSteady) return (rotation.yaw, rotation.pitch)
def worldHitTest(self, start, stop, worldMatrix): worldToLocal = Matrix(worldMatrix) worldToLocal.invert() testRes = self.__bspModel.collideSegment(worldToLocal.applyPoint(start), worldToLocal.applyPoint(stop)) if testRes is None: return res = [] for dist, normal, hitAngleCos, matKind in testRes: res.append((dist, worldMatrix.applyVector(normal), hitAngleCos, matKind)) return res
def assembleCompoundModel(models, position, vehicleDesc): tank = BigWorld.createCompoundTank() chassis = BigWorld.ModelLite(models[0]) hull = BigWorld.ModelLite(models[1]) turret = BigWorld.ModelLite(models[2]) gun = BigWorld.ModelLite(models[3]) matrix = Matrix() matrix.translation = position tank.attachPart(0, chassis, '', matrix) tank.attachPart(1, hull, 'V') tank.attachPart(2, turret, 'HP_turretJoint') tank.attachPart(3, gun, 'HP_gunJoint') BigWorld.addModel(tank) return tank
def __pickVehicle(self): if self.__boundVehicleMProv is not None: return else: x, y = GUI.mcursor().position from AvatarInputHandler import cameras dir, start = cameras.getWorldRayAndPoint(x, y) end = start + dir.scale(100000.0) pos, colldata = collideDynamicAndStatic(start, end, (), 0) vehicle = None if colldata is not None: entity = colldata[0] from Vehicle import Vehicle if isinstance(entity, Vehicle): vehMatProv = entity.matrix vehMatInv = Matrix(vehMatProv) vehMatInv.invert() localPos = vehMatInv.applyPoint(pos) result = Math.MatrixProduct() localTransMat = Matrix() localTransMat.translation = localPos result.a = localTransMat result.b = vehMatProv return result return
def __drawDebugOutput(self, matrixProvider): self.__resetDebugOutput() if matrixProvider is None: return else: matrixProvider = Matrix(matrixProvider) pos = matrixProvider.translation endPos = matrixProvider.translation endPos.y += 70.0 self.__debugLine = Flock.DebugLine(pos, endPos) self.__debugLine.thickness = 1.0 matrixProvider.translation = pos self.__debugGizmo.setMatrix(matrixProvider) self.__callbackDelayer.delayCallback(4.0, self.__resetDebugOutput) return
def prerequisites(self): stepRepairPointComponent = BigWorld.player().arena.componentSystem.stepRepairPointComponent if stepRepairPointComponent is not None: stepRepairPointComponent.addStepRepairPoint(self) assembler = BigWorld.CompoundAssembler(_g_stepRepairPointSettings.flagModel, self.spaceID) assembler.addRootPart(_g_stepRepairPointSettings.flagModel, 'root') rv = [assembler, _g_stepRepairPointSettings.radiusModel] if _g_stepRepairPointSettings.flagAnim is not None: loader = AnimationSequence.Loader(_g_stepRepairPointSettings.flagAnim, self.spaceID) rv.append(loader) mProv = Matrix() mProv.translation = self.position self.__stepRepairPointSoundObject = SoundGroups.g_instance.WWgetSoundObject('stepRepairPoint_' + str(self), mProv) self.__stepRepairPointSoundObject.play(_g_stepRepairPointSettings.attachedSoundEventName) return rv
def enable(self, targetPos): player = BigWorld.player() self.__vehicleTypeDescriptor = player.vehicleTypeDescriptor self.__vehicleMProv = player.getOwnVehicleStabilisedMatrix() self.__vehiclePrevMat = Matrix(self.__vehicleMProv) IAimingSystem.enable(self, targetPos) self.__yawLimits = self.__vehicleTypeDescriptor.gun['turretYawLimits'] self.__pitchLimits = self.__vehicleTypeDescriptor.gun['pitchLimits'] self.__idealYaw, self.__idealPitch = AimingSystems.getTurretYawGunPitch(self.__vehicleTypeDescriptor, self.__vehicleMProv, targetPos, True) self.__idealYaw, self.__idealPitch = self.__clampToLimits(self.__idealYaw, self.__idealPitch) currentGunMat = AimingSystems.getPlayerGunMat(self.__idealYaw, self.__idealPitch) self.__g_curYaw = currentGunMat.yaw self.__g_curPitch = (targetPos - currentGunMat.translation).pitch self._matrix.set(currentGunMat) self.__idealYaw, self.__idealPitch = self.__worldYawPitchToTurret(self.__g_curYaw, self.__g_curPitch) self.__idealYaw, self.__idealPitch = self.__clampToLimits(self.__idealYaw, self.__idealPitch) self.__oscillator.reset() self.__pitchfilter.reset(currentGunMat.pitch) SniperAimingSystem.__activeSystem = self vehicle = player.getVehicleAttached() if vehicle is not None: if hasattr(vehicle.filter, 'placingOnGround') and not vehicle.filter.placingOnGround: vehicle.filter.calcPlacedMatrix(True) self.__baseMatrix = vehicle.filter.placingMatrix else: self.__baseMatrix = vehicle.matrix return
def __onResourcesLoaded(self, resourceRefs): if self.guid not in BigWorld.userDataObjects: return else: self.__clear() if self.modelName in resourceRefs.failedIDs: return try: self.__model = resourceRefs[self.modelName] self.__modelMatrix = Matrix() self.__modelMatrix.setIdentity() servo = BigWorld.Servo(self.__modelMatrix) self.__model.addMotor(servo) BigWorld.addModel(self.__model) if self.actionName != '': action = self.__model.action(self.actionName) if action is not None: action() if self.pixieName != '' and self.pixieName not in resourceRefs.failedIDs: pixieNode = self.__model.node(self.pixieHardPoint) pixieNode.attach(resourceRefs[self.pixieName]) if self.soundName != '': self.__sound = SoundGroups.g_instance.playSoundModel(self.__model, self.soundName) except: LOG_CURRENT_EXCEPTION() self.__model = None return self.__prevTime = BigWorld.time() self.__update() return
def collideSegment(self, startPoint, endPoint, skipGun = False): res = None filterMethod = getattr(self.filter, 'segmentMayHitEntity', lambda : True) if not filterMethod(startPoint, endPoint, 0): return res modelsToCheck = (self.model,) if skipGun else (self.model, self.__gunModel) for model, desc in zip(modelsToCheck, self.__componentsDesc): toModel = Matrix(model.matrix) toModel.invert() collisions = desc['hitTester'].localHitTest(toModel.applyPoint(startPoint), toModel.applyPoint(endPoint)) if collisions is None: continue for dist, _, hitAngleCos, matKind in collisions: if res is None or res.dist >= dist: matInfo = desc['materials'].get(matKind) res = SegmentCollisionResult(dist, hitAngleCos, matInfo.armor if matInfo is not None else 0) return res
def __calcCurOscillatorAcceleration(self, deltaTime): vehicle = BigWorld.player().vehicle if vehicle is None: return Vector3(0, 0, 0) curVelocity = vehicle.filter.velocity relativeSpeed = curVelocity.length / vehicle.typeDescriptor.physics['speedLimits'][0] if relativeSpeed >= SniperCamera._MIN_REL_SPEED_ACC_SMOOTHING: self.__accelerationSmoother.maxAllowedAcceleration = self.__dynamicCfg['accelerationThreshold'] else: self.__accelerationSmoother.maxAllowedAcceleration = self.__dynamicCfg['accelerationMax'] acceleration = self.__accelerationSmoother.update(vehicle, deltaTime) camMat = Matrix(self.__cam.matrix) acceleration = camMat.applyVector(-acceleration) accelSensitivity = self.__dynamicCfg['accelerationSensitivity'] acceleration.x *= accelSensitivity.x acceleration.y *= accelSensitivity.y acceleration.z *= accelSensitivity.z oscillatorAcceleration = Vector3(0, -acceleration.y + acceleration.z, -acceleration.x) return oscillatorAcceleration
def findTargets(self, actor, source, target): self.calculatedTargets = [] origin = source.position + Vector3(0, 0.5, 0) yaw = source.yaw + math.pi / 2.0 basis = Vector3(math.sin(yaw), 0, math.cos(yaw)) left = [] right = [] leftOver = self.maxNodes victims = [] if hasattr(self, 'victims'): victims = self.victims elif self.findTeam == 1: team = BigWorld.player().team() for i in team.members.keys(): entity = BigWorld.entity(i) if entity: if (entity.position - origin).length < self.maxRange: victims.append(entity) entity = BigWorld.player() if entity: if (entity.position - origin).length < self.maxRange: victims.append(entity) for e in victims: if e.inWorld: dpos = e.position - origin dpos.normalise() dotp = basis.dot(dpos) leftOver -= 2 try: self.calculatedTargets.append(e.model.node('biped Spine')) except: self.calculatedTargets.append(e.model.node('Scene Root')) while leftOver > 0: m = Matrix() if leftOver % 2 == 0: m.setTranslate(self.randomStrike(source, basis, origin, 1)) self.calculatedTargets.append(m) else: m.setTranslate(self.randomStrike(source, basis, origin, 0)) self.calculatedTargets.append(m) leftOver -= 1
def checkTurretDetachment(self, worldPos): if self.__vehicle is None: return if self.__vehicle.isTurretDetached and not self.__placement == _VehicleBounder.SELECT_DETACHED_TURRET: turretFound = None for turret in DetachedTurret.allTurrets: if turret.vehicleID == self.__vehicle.id and turret.model.visible: turretFound = turret break if turretFound is None: return turretToGoalShift = worldPos - turretFound.position toTurretMat = Matrix(turretFound.matrix) toTurretMat.invert() turretToGoalShift = toTurretMat.applyVector(turretToGoalShift) self.matrix = turretFound.matrix self.__lookAtProvider = None self.__placement = _VehicleBounder.SELECT_DETACHED_TURRET return turretToGoalShift
def update(self, vehicle, deltaTime): curVelocity = vehicle.filter.velocity acceleration = vehicle.filter.acceleration acceleration = self.__accelerationFilter.add(acceleration) movementFlags = vehicle.engineMode[1] moveMask = 3 self.__hasChangedDirection = movementFlags & moveMask ^ self.__prevMovementFlags & moveMask or curVelocity.dot(self.__prevVelocity) <= 0.01 self.__prevMovementFlags = movementFlags self.__prevVelocity = curVelocity self.__timeLapsedSinceDirChange += deltaTime if self.__hasChangedDirection: self.__timeLapsedSinceDirChange = 0.0 elif self.__timeLapsedSinceDirChange > self.__maxAccelerationDuration: invVehMat = Matrix(vehicle.matrix) invVehMat.invert() accelerationRelativeToVehicle = invVehMat.applyVector(acceleration) accelerationRelativeToVehicle.x = 0.0 accelerationRelativeToVehicle.z = 0.0 acceleration = Matrix(vehicle.matrix).applyVector(accelerationRelativeToVehicle) self.__acceleration = acceleration return acceleration
def plasmaExplode(owner, targetModel, delTargetModel): m = BigWorld.Model('objects/models/fx/03_pchangs/shockwave.model') targetModel.root.attach(m) m.Go() BigWorld.callback(1.0, partial(targetModel.root.detach, m)) m = targetModel.root m2 = Matrix() m2.setScale((5, 5, 5)) m2.postMultiply(m) v1 = Vector4(1.0, 100000, 0, 0) v2 = Vector4(0.0, 0, 0, 0) v = Vector4Animation() v.keyframes = [(0, v1), (0.5, v2)] v.duration = 1 v.time = 0 try: BigWorld.addWarp(0.5, m2, v) except: pass shake(targetModel) ps2 = Pixie.create('particles/plasma_blow.xml') targetModel.root.attach(ps2) ps2.system(0).actions[0].force(1) BigWorld.callback(5.0, partial(targetModel.root.detach, ps2)) if delTargetModel: BigWorld.callback(5.0, partial(owner.delModel, targetModel)) if BigWorld.player().flashBangCount == 0: fba = Vector4Animation() fba.keyframes = [(0, Vector4(0, 0, 0, 0)), (0.1, Vector4(0.1, 0.1, 0.2, 0.5)), (0.3, Vector4(0, 0, 0, 0))] fba.duration = 0.3 try: BigWorld.flashBangAnimation(fba) except: pass BigWorld.callback(fba.duration, partial(BigWorld.flashBangAnimation, None)) return
def __update(self): self.__updateCallbackId = None self.__updateCallbackId = BigWorld.callback(0.0, self.__update) curTime = BigWorld.time() dt = curTime - self.__prevTime self.__prevTime = curTime self.__currentAngle += self.__angularVelocity * dt if self.__currentAngle > 2 * math.pi: self.__currentAngle -= 2 * math.pi elif self.__currentAngle < -2 * math.pi: self.__currentAngle += 2 * math.pi radialPosition = Vector3(self.radius * math.sin(self.__currentAngle), 0, self.radius * math.cos(self.__currentAngle)) modelYaw = self.__currentAngle if self.rotateClockwise: modelYaw += math.pi / 2 else: modelYaw -= math.pi / 2 localMatrix = Matrix() localMatrix.setRotateY(modelYaw) localMatrix.translation = radialPosition self.__modelMatrix.setRotateYPR((self.yaw, self.pitch, self.roll)) self.__modelMatrix.translation = self.position self.__modelMatrix.preMultiply(localMatrix)
def decodeHitPoints(encodedPoints, vehicleDescr): resultPoints = [] maxHitEffectCode = None for encodedPoint in encodedPoints: compName, hitEffectCode, startPoint, endPoint = DamageFromShotDecoder.decodeSegment( encodedPoint, vehicleDescr ) if startPoint == endPoint: continue maxHitEffectCode = max(hitEffectCode, maxHitEffectCode) hitTester = getattr(vehicleDescr, compName)["hitTester"] hitTestRes = hitTester.localHitTest(startPoint, endPoint) if not hitTestRes: width, height, depth = (hitTester.bbox[1] - hitTester.bbox[0]) / 256.0 directions = [ Math.Vector3(0.0, -height, 0.0), Math.Vector3(0.0, height, 0.0), Math.Vector3(-width, 0.0, 0.0), Math.Vector3(width, 0.0, 0.0), Math.Vector3(0.0, 0.0, -depth), Math.Vector3(0.0, 0.0, depth), ] for direction in directions: hitTestRes = hitTester.localHitTest(startPoint + direction, endPoint + direction) if hitTestRes is not None: break if hitTestRes is None: continue minDist = hitTestRes[0][0] for i in xrange(1, len(hitTestRes)): dist = hitTestRes[i][0] if dist < minDist: minDist = dist hitDir = endPoint - startPoint hitDir.normalise() rot = Matrix() rot.setRotateYPR((hitDir.yaw, hitDir.pitch, 0.0)) matrix = Matrix() matrix.setTranslate(startPoint + hitDir * minDist) matrix.preMultiply(rot) effectGroup = DamageFromShotDecoder.__hitEffectCodeToEffectGroup[hitEffectCode] resultPoints.append(DamageFromShotDecoder.ShotPoint(compName, matrix, effectGroup)) return (maxHitEffectCode, resultPoints)
def __switchBind(self): if self.__basisMProv.isBound: self.__basisMProv.bind(None) else: self.__basisMProv.bind(*self.__entityPicker.pick()) localMat = Matrix(self.__cam.invViewMatrix) basisInv = Matrix(self.__basisMProv.matrix) basisInv.invert() localMat.postMultiply(basisInv) self.__position = localMat.translation self.__ypr.set(localMat.yaw, localMat.pitch, localMat.roll)
class CircularFlyer(BigWorld.UserDataObject): def __init__(self): BigWorld.UserDataObject.__init__(self) self.__prevTime = BigWorld.time() self.__angularVelocity = 2 * math.pi / self.rotationPeriod if not self.rotateClockwise: self.__angularVelocity *= -1 self.__currentAngle = 0.0 self.__updateCallbackId = None self.__model = None self.__modelMatrix = None self.__sound = None BigWorld.loadResourceListBG((self.modelName, self.pixieName), self.__onResourcesLoaded) return def __del__(self): self.__clear() def __clear(self): if self.__updateCallbackId is not None: BigWorld.cancelCallback(self.__updateCallbackId) self.__updateCallbackId = None if self.__sound is not None: self.__sound.stop() self.__sound = None if self.__model is not None: BigWorld.delModel(self.__model) self.__model = None return def __onResourcesLoaded(self, resourceRefs): if self.guid not in BigWorld.userDataObjects: return else: self.__clear() if self.modelName in resourceRefs.failedIDs: return try: self.__model = resourceRefs[self.modelName] self.__modelMatrix = Matrix() self.__modelMatrix.setIdentity() servo = BigWorld.Servo(self.__modelMatrix) self.__model.addMotor(servo) BigWorld.addModel(self.__model) if self.actionName != '': action = self.__model.action(self.actionName) if action is not None: action() if self.pixieName != '' and self.pixieName not in resourceRefs.failedIDs: pixieNode = self.__model.node(self.pixieHardPoint) pixieNode.attach(resourceRefs[self.pixieName]) if self.soundName != '': self.__sound = SoundGroups.g_instance.playSoundModel(self.__model, self.soundName) except: LOG_CURRENT_EXCEPTION() self.__model = None return self.__prevTime = BigWorld.time() self.__update() return def __update(self): self.__updateCallbackId = None self.__updateCallbackId = BigWorld.callback(0.0, self.__update) curTime = BigWorld.time() dt = curTime - self.__prevTime self.__prevTime = curTime self.__currentAngle += self.__angularVelocity * dt if self.__currentAngle > 2 * math.pi: self.__currentAngle -= 2 * math.pi elif self.__currentAngle < -2 * math.pi: self.__currentAngle += 2 * math.pi radialPosition = Vector3(self.radius * math.sin(self.__currentAngle), 0, self.radius * math.cos(self.__currentAngle)) modelYaw = self.__currentAngle if self.rotateClockwise: modelYaw += math.pi / 2 else: modelYaw -= math.pi / 2 localMatrix = Matrix() localMatrix.setRotateY(modelYaw) localMatrix.translation = radialPosition self.__modelMatrix.setRotateYPR((self.yaw, self.pitch, self.roll)) self.__modelMatrix.translation = self.position self.__modelMatrix.preMultiply(localMatrix) return
def __worldYawPitchToTurret(self, worldYaw, worldPitch): worldToTurret = Matrix(self.__vehicleMProv) worldToTurret.invert() worldToTurret.preMultiply(mathUtils.createRotationMatrix((worldYaw, worldPitch, 0.0))) return (worldToTurret.yaw, worldToTurret.pitch)
def createIdentityMatrix(): result = Matrix() result.setIdentity() return result
def createRTMatrix(rotation, translation): result = Matrix() result.setRotateYPR(rotation) result.translation = translation return result