def __createTransform(slotParams, slotData): worldTransform = math_utils.createRTMatrix(slotParams.rotation, slotParams.position) objectTransform = math_utils.createRTMatrix( Math.Vector3(slotData.component.rotation), Math.Vector3(slotData.component.position)) worldTransform.postMultiply(objectTransform) return worldTransform
def attachModels(assembler, vehicleDesc, modelsSetParams, isTurretDetached, renderMode=None, overlayCollision=False): collisionState = renderMode in (TankRenderMode.CLIENT_COLLISION, TankRenderMode.SERVER_COLLISION, TankRenderMode.CRASH_COLLISION, TankRenderMode.ARMOR_WIDTH_COLLISION) if collisionState: partModels = getCollisionModelsFromDesc(vehicleDesc, renderMode) else: partModels = getPartModelsFromDesc(vehicleDesc, modelsSetParams) chassis, hull, turret, gun = partModels partNames = TankPartNames if overlayCollision: partNames = TankCollisionPartNames if not overlayCollision: assembler.addRootPart(chassis, TankPartNames.CHASSIS) else: assembler.addPart(chassis, TankPartNames.CHASSIS, TankCollisionPartNames.CHASSIS) if collisionState: trackPairs = vehicleDesc.chassis.trackPairs[1:] for idx, trackPair in enumerate(trackPairs): assembler.addPart(trackPair.hitTester.bspModelName, partNames.CHASSIS, 'trackPair' + str(idx + 1)) if collisionState and vehicleDesc.isWheeledVehicle: for i, wheel in enumerate(vehicleDesc.chassis.wheels.wheels): bspPath = '' if renderMode == TankRenderMode.CLIENT_COLLISION: bspPath = wheel.hitTesterManager.edClientBspModel elif renderMode in (TankRenderMode.SERVER_COLLISION, TankRenderMode.ARMOR_WIDTH_COLLISION): bspPath = wheel.hitTesterManager.edServerBspModel if bspPath: assembler.addNode(wheel.nodeName, partNames.CHASSIS, math_utils.createTranslationMatrix(wheel.position)) assembler.emplacePart(bspPath, wheel.nodeName, TankCollisionPartNames.WHEEL + str(i)) if collisionState and not overlayCollision: assembler.addNode('V', TankPartNames.CHASSIS, math_utils.createTranslationMatrix(vehicleDesc.chassis.hullPosition)) if not overlayCollision: assembler.emplacePart(hull, 'V', partNames.HULL) else: assembler.addPart(hull, 'V', partNames.HULL) turretJointName = vehicleDesc.hull.turretHardPoints[0] assembler.addNodeAlias(turretJointName, TankNodeNames.TURRET_JOINT) if not isTurretDetached: if collisionState and not overlayCollision: assembler.addNode(turretJointName, 'V', math_utils.createRTMatrix(Math.Vector3(0, vehicleDesc.hull.turretPitches[0], 0), vehicleDesc.hull.turretPositions[0])) assembler.addPart(turret, turretJointName, partNames.TURRET) if collisionState and not overlayCollision: assembler.addNode(TankNodeNames.GUN_JOINT, TankPartNames.TURRET, math_utils.createRTMatrix(Math.Vector3(0, vehicleDesc.turret.gunJointPitch, 0), vehicleDesc.turret.gunPosition)) assembler.addPart(gun, TankNodeNames.GUN_JOINT, partNames.GUN) if modelsSetParams.state == 'undamaged': for attachment in modelsSetParams.attachments: if attachment.attachmentLogic == 'prefab': continue assembler.addPart(attachment.modelName, attachment.attachNode, attachment.partNodeAlias, attachment.transform)
def getTurretJointMat(vehicleTypeDescriptor, vehicleMatrix, turretYaw=0.0, overrideTurretLocalZ=None): turretOffset = getTurretJointOffset(vehicleTypeDescriptor) if overrideTurretLocalZ is not None: turretOffset.z = overrideTurretLocalZ turretJointMat = math_utils.createRTMatrix(Vector3(turretYaw, 0, 0), turretOffset) turretJointMat.postMultiply(vehicleMatrix) return turretJointMat
def getGunJointMat(vehicleTypeDescriptor, turretMatrix, gunPitch, overrideTurretLocalZ=None): gunOffset = Vector3(vehicleTypeDescriptor.activeGunShotPosition) if overrideTurretLocalZ is not None: offset = getTurretJointOffset(vehicleTypeDescriptor) yOffset = math.tan(gunPitch) * offset.z gunOffset.y += yOffset gunMat = math_utils.createRTMatrix(Vector3(0, gunPitch, 0), gunOffset) gunMat.postMultiply(turretMatrix) return gunMat
def onEntityComponentAdded(self, entityComponent, transformComponent): scaleMatrix = math_utils.createRTMatrix( transformComponent.worldRotation, transformComponent.worldPosition) scaleMatrix.invert() scaleMatrix.preMultiply(transformComponent.worldTransform) scaleCoeffs = scaleMatrix.applyVector((1, 1, 1)) state = {'scale': scaleCoeffs} state.update(entityComponent.state) rotationRPY = Math.Vector3(transformComponent.worldTransform.roll, transformComponent.worldTransform.pitch, transformComponent.worldTransform.yaw) entityComponent.entityID = BigWorld.createEntity( entityComponent.entityClass.__name__, self.spaceID, 0, transformComponent.worldPosition, rotationRPY, state)
def __correctTurretYaw(self, anchorHelper, defaultYaw): if not _SHOULD_CHECK_DECAL_UNDER_GUN: return defaultYaw else: partMatrix = Math.Matrix( self.__vEntity.model.node( TankPartIndexes.getName(anchorHelper.partIdx))) turretMat = Math.Matrix( self.compoundModel.node(TankPartNames.TURRET)) transformMatrix = math_utils.createRTMatrix( (turretMat.yaw, partMatrix.pitch, partMatrix.roll), partMatrix.translation) anchorLocationWS = self.__applyToAnchorLocation( anchorHelper.location, transformMatrix) position = anchorLocationWS.position direction = anchorLocationWS.normal up = anchorLocationWS.up fromTurretToHit = position - turretMat.translation if fromTurretToHit.dot(turretMat.applyVector((0, 0, 1))) < 0: return defaultYaw checkDirWorld = direction * 10.0 cornersWorldSpace = self.__getDecalCorners(position, direction, up, anchorHelper.descriptor) if cornersWorldSpace is None: return defaultYaw slotType = ANCHOR_TYPE_TO_SLOT_TYPE_MAP[ anchorHelper.descriptor.type] if slotType == GUI_ITEM_TYPE.PROJECTION_DECAL: turretLeftDir = turretMat.applyVector((1, 0, 0)) turretLeftDir.normalise() gunJoin = self.__vEntity.model.node('HP_gunJoint') fromGunJointToAnchor = gunJoin.position - position decalDiags = (cornersWorldSpace[0] - cornersWorldSpace[2], cornersWorldSpace[1] - cornersWorldSpace[3]) fromGunToHit = abs(fromGunJointToAnchor.dot(turretLeftDir)) halfDecalWidth = max((abs(decalDiag.dot(turretLeftDir)) for decalDiag in decalDiags)) * 0.5 if fromGunToHit > halfDecalWidth * _PROJECTION_DECAL_OVERLAPPING_FACTOR: return defaultYaw result = self.collisions.collideShape(TankPartIndexes.GUN, cornersWorldSpace, checkDirWorld) if result < 0.0: return defaultYaw turretYaw = _HANGAR_TURRET_SHIFT gunDir = turretMat.applyVector(Math.Vector3(0, 0, 1)) if Math.Vector3(0, 1, 0).dot(gunDir * fromTurretToHit) > 0.0: turretYaw = -turretYaw return turretYaw
def __init__(self): BigWorld.UserDataObject.__init__(self) self.__gameObject = CGF.GameObject(BigWorld.player().spaceID, 'SoundZoneTrigger') self.__gameObject.setStatic(True) position = math_utils.createRTMatrix(Math.Vector3(self.direction.z, self.direction.y, self.direction.x), self.position) self.__gameObject.createComponent(TransformComponent, position) self.__gameObject.createComponent(SoundZoneComponent, self.ZoneEnter, self.ZoneExit, self.Reverb, '', self.ReverbLevel, self.VolumeDeviation) v = Math.Vector3(self.Size.x, self.Size.y, self.Size.z) * 0.5 self.__gameObject.createComponent(SquareAreaComponent, -v, v) self.__gameObject.activate() if VISUALISE_ZONE: self.model = BigWorld.Model('objects/misc/bbox/unit_cube_1m_proxy.model') BigWorld.player().addModel(self.model) motor = BigWorld.Servo(Math.Matrix()) self.model.addMotor(motor) motor.signal = math_utils.createSRTMatrix(Math.Vector3(self.Size.x, self.Size.y, self.Size.z), Math.Vector3(self.direction.z, self.direction.y, self.direction.x), self.position)
def _update(self): worldMatrix = Matrix(self._cam.invViewMatrix) desiredPosition = self.__basisMProv.checkTurretDetachment( worldMatrix.translation) if desiredPosition is not None: self.__position = desiredPosition prevPos = Math.Vector3(self.__position) delta = self.__calcCurrentDeltaAdjusted() self.__updateSenses(delta) if self._targetRadiusSensor: self.__rotationRadius += self._targetRadiusSensor.currentVelocity * delta if self.__isVerticalVelocitySeparated: self._verticalMovementSensor.update(delta) else: self._verticalMovementSensor.currentVelocity = self._movementSensor.currentVelocity.y self._verticalMovementSensor.sensitivity = self._movementSensor.sensitivity if self._inertiaEnabled: self.__inertialMovement(delta) else: self.__simpleMovement(delta) self.__ypr += self.__yprVelocity * delta self.__position += self.__velocity * delta if self.__rotateAroundPointEnabled: self.__position = self.__getAlignedToPointPosition( math_utils.createRotationMatrix(self.__ypr)) if self._alignerToLand.enabled and not self.__basisMProv.isBound: if abs(self.__velocity.y) > 0.1: self._alignerToLand.enable(self.__position, self._alignerToLand.ignoreTerrain) self.__position = self._alignerToLand.getAlignedPosition( self.__position) lookAtPosition = self.__basisMProv.lookAtPosition if lookAtPosition is not None: self.__ypr = self.__getLookAtYPR(lookAtPosition) if BigWorld.camera( ) == self.__cameraTransition and self.__cameraTransition.isInTransition( ): self.__ypr = self.__clampPR(self.__ypr) else: self.__ypr = self.__clampYPR(self.__ypr) self.__position = self._checkSpaceBounds(prevPos, self.__position) self._cam.invViewProvider.a = math_utils.createRTMatrix( self.__ypr, self.__position) self._cam.invViewProvider.b = self.__basisMProv.matrix BigWorld.projection().fov = self.__calcFov() self.__resetSenses() return 0.0
def tick(self): player = BigWorld.player() if player is None or isPlayerAccount(): return else: if hasattr(player, 'getVehicleAttached'): vehicle = player.getVehicleAttached() if vehicle is None: return for hmodifier in self.queryCamera: transfComp = hmodifier.cameraTransform() direction = vehicle.position - transfComp.worldTransform.translation matrix = transfComp.transform transfComp.transform = math_utils.createRTMatrix( (direction.yaw, direction.pitch, 0.0), matrix.translation) return
def setSelectingDirection(self, value=False): if value and self.__terrainRotatedArea is None: objectSize = Math.Vector2(10.0, 10.0) self.__rotateModelNode = self.__fakeModel.node( '', math_utils.createRTMatrix( Math.Vector3(-self.__matrix.yaw, 0.0, 0.0), Math.Vector3((-self.__size.x - objectSize.x) * 0.5, 0.0, (self.__size.y + objectSize.y) * 0.5))) self.__terrainRotatedArea = area = BigWorld.PyTerrainSelectedArea() area.setup(DEFAULT_ROTATE_MODEL, objectSize, self.__overTerrainHeight, self.__color) area.enableAccurateCollision(True) area.setYCutOffDistance(MARKER_HEIGHT) self.__rotateModelNode.attach(area) elif not value and self.__terrainRotatedArea is not None: self.__rotateModelNode.detach(self.__terrainRotatedArea) self.__terrainRotatedArea = None return
def __updateVehicleMarker(self, vehicleID, params): self._vehiclesCallback[vehicleID] = None markerIDs = self._vehiclesAreaMarker['ID'] if vehicleID not in markerIDs: return else: vehicle = BigWorld.entities.get(vehicleID) vehiclesMatrix = self._vehiclesAreaMarker['matrix'] markerIDs = markerIDs[vehicleID].values() prevDataByVehID = self._vehiclesAreaMarker['prevData'][vehicleID] lastCheckTime = self._vehiclesAreaMarker['lastCheckTime'] if vehicle: matrix = vehicle.matrix if not vehiclesMatrix[vehicleID]['inAoI']: vehiclesMatrix.update({vehicleID: {'matrix': matrix, 'inAoI': True}}) for markerID in markerIDs: self._parent.setMarkerMatrix(markerID, matrix) else: positionData = params['positionData'] position = positionData['position'] ypr = positionData['ypr'] if vehiclesMatrix[vehicleID]['inAoI']: vehiclesMatrix.update({vehicleID: {'matrix': math_utils.createRTMatrix(ypr, position), 'inAoI': False}}) for markerID in markerIDs: self._parent.setMarkerMatrix(markerID, vehiclesMatrix[vehicleID]['matrix']) else: matrix = vehiclesMatrix[vehicleID]['matrix'] if (prevDataByVehID['position'] - position).length < self._TELEPORT_DISTANCE: dt = BigWorld.time() - lastCheckTime[vehicleID] position = matrix.translation + positionData['velocity'] * dt if prevDataByVehID['position'] != ypr: matrix.setRotateYPR(ypr) prevDataByVehID['ypr'] = ypr matrix.translation = position prevDataByVehID['position'] = position lastCheckTime[vehicleID] = BigWorld.time() self._vehiclesCallback[vehicleID] = BigWorld.callback(self._TICK_UPDATE, partial(self.__updateVehicleMarker, vehicleID, params)) return
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 = math_utils.createRTMatrix((self.__direction.yaw, -self.__direction.pitch, 0.0), hitPoint[1]) self.__aimMatrix.setTranslate(aimPoint) return
def __multipositionSpawn(self, go, multivisualizer, influenceZone, equipment, radius): for zonePosition in influenceZone.zonesPosition: localPosition = zonePosition - influenceZone.position if multivisualizer.rotateFromCenter: transform = math_utils.createRTMatrix( (localPosition.yaw, 0, 0), localPosition) else: transform = math_utils.createTranslationMatrix(localPosition) def postloadSetup(go): areaVisualizer = go.findComponentByType(AreaAbilityVisualizer) if areaVisualizer is not None: areaVisualizer.radius = equipment.zoneRadius eqComponent = go.createComponent( InfluenceZoneEquipmentComponent) eqComponent.setupEquipment(equipment) return CGF.loadGameObjectIntoHierarchy(multivisualizer.influencePrefab, go, transform, postloadSetup)
def __addVehicleMarker(self, markerData, vehicleID, params, createMatrix=True): vehicle = BigWorld.entities.get(vehicleID) vehiclesMatrix = self._vehiclesAreaMarker['matrix'] positionData = params['positionData'] position = positionData['position'] ypr = positionData['ypr'] parent = self._parent if createMatrix: vehiclePrevData = self._vehiclesAreaMarker['prevData'] lastCheckTime = self._vehiclesAreaMarker['lastCheckTime'] if vehicle: vehiclesMatrix.update({vehicleID: {'matrix': vehicle.matrix, 'inAoI': True}}) else: vehiclesMatrix.update({vehicleID: {'matrix': math_utils.createRTMatrix(ypr, position), 'inAoI': False}}) vehiclePrevData.update({vehicleID: {'position': position, 'ypr': Math.Vector3(ypr)}}) lastCheckTime.update({vehicleID: BigWorld.time()}) marker = parent.createMarker(vehiclesMatrix[vehicleID]['matrix'], markerData['markerType']) markerID = parent.addMarker(marker) self._vehiclesAreaMarker['ID'].setdefault(vehicleID, {}).update({markerData['markerID']: markerID})
def _updateMatrix(self): self._clampMinimalAimingRadius() 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 = math_utils.createRTMatrix( (self.__direction.yaw, -self.__direction.pitch, 0.0), hitPoint[1]) self.__aimMatrix.setTranslate(aimPoint) return
def __gunJointMat(self, turretMat, gunPitch, vehicleDescr): gunShotOffset = self.gunShotOffset(vehicleDescr, self.__currentGun) gunMat = math_utils.createRTMatrix(Vector3(0.0, gunPitch, 0.0), gunShotOffset) gunMat.postMultiply(turretMat) return gunMat
def __turretJointMat(self, vehicleMat, turretYaw, vehicleDescr): turretOffset = self.turretOffset(vehicleDescr) turretMat = math_utils.createRTMatrix(Vector3(turretYaw, 0.0, 0.0), turretOffset) turretMat.postMultiply(vehicleMat) return turretMat
def __updateCameraLocation(self): position, yaw, pitch = self.__updateCalculateParams(self.__curTime) mat = math_utils.createRTMatrix(Math.Vector3(yaw, pitch, 0.0), position) self.__camera.setWorldMatrix(mat) self.__updateDynamicFOV(self.__curTime)