def ShowDamageLocators(itemID):
ball = sm.StartService('michelle').GetBallpark().GetBall(itemID)
ship = ball.model
if not ship:
return
if getattr(ball, 'visualizingDamageLocators', False):
toRemove = []
for child in ship.children:
if child.name == 'DamageLocatorVisualization':
toRemove.append(child)
elif child.name == 'ImpactDirectionVisualization':
toRemove.append(child)
for tr in toRemove:
ship.children.remove(tr)
setattr(ball, 'visualizingDamageLocators', False)
else:
scale = ship.boundingSphereRadius / 10
for i in range(len(ship.damageLocators)):
damageLocator = ship.damageLocators[i]
sphere = trinity.Load('res:/model/global/damageLocator.red')
sphere.translation = damageLocator[0]
sphere.scaling = [scale, scale, scale]
ship.children.append(sphere)
impacDir = damageLocator[1]
direction = trinity.Load('res:/model/global/impactDirection.red')
direction.translation = damageLocator[0]
direction.scaling = [scale, scale, scale]
direction.rotation = impacDir
ship.children.append(direction)
setattr(ball, 'visualizingDamageLocators', True)
def CreateBackgroundLandscape(scene, medDetailThreshold = 0.0001, lowDetailThreshold = 0.0001, shaderModel = 'SM_3_0_DEPTH'):
m10 = trinity.Load('res:/dx9/scene/universe/m10_cube.red')
scene.backgroundEffect = m10.backgroundEffect
scene.envMapResPath = m10.envMapResPath
scene.envMap1ResPath = m10.envMap1ResPath
scene.envMap2ResPath = m10.envMap2ResPath
scene.envMap3ResPath = m10.envMap3ResPath
scene.backgroundEffect = scene.backgroundEffect
scene.sunDiffuseColor = (1.5, 1.5, 1.5, 1.0)
trinity.settings.SetValue('eveSpaceSceneVisibilityThreshold', 3.0)
trinity.settings.SetValue('eveSpaceSceneMediumDetailThreshold', medDetailThreshold)
trinity.settings.SetValue('eveSpaceSceneLowDetailThreshold', lowDetailThreshold)
trinity.SetShaderModel(shaderModel)
scene.starfield = trinity.Load('res:/dx9/scene/starfield/spritestars.red')
scene.starfield.minDist = 40
scene.starfield.maxDist = 80
scene.starfield.numStars = 500
universe = [ stars for stars in scene.backgroundObjects if stars.name == 'Neighboring Stars' ]
if not universe:
universe = trinity.Load('res:/dx9/scene/starfield/universe.red')
scene.backgroundObjects.append(universe)
systemX = -20474870.72500089
systemY = 4023837.993657142
systemZ = 5762127.890242104
universe.children[0].translation = (systemX, systemY, systemZ)
scene.backgroundRenderingEnabled = True
if jessica:
CreateFisRenderJob(scene)
def LoadModel(self):
graphicFile = self.typeData.get('graphicFile', None)
baseName = graphicFile.split('/')[-1]
self.godRaysLoaded = False
if self.useGodRays and gfxsettings.Get(gfxsettings.UI_GODRAYS):
graphicFile = graphicFile.replace('.red', '_godrays.red')
self.godRaysLoaded = True
self.lensflare = trinity.Load(graphicFile)
scene = self.spaceMgr.GetScene()
scene.sunBall = self
sunModelFile = 'res:/dx9/Model/WorldObject/Sun/' + baseName
self.sunmodel = trinity.Load(sunModelFile)
self.model = trinity.EvePlanet()
self.model.translationCurve = self
self.model.rotationCurve = self
self.model.name = '%d' % self.id
self.model.ready = True
self.sunmodel.name = self.model.name
self.model.highDetail = self.sunmodel
self.model.resourceCallback = self.ResourceCallback
if self.model is not None:
scene.planets.append(self.model)
if self.lensflare is not None:
self.lensflare.translationCurve = self
scene.lensflares.append(self.lensflare)
self.SetupAmbientAudio()
if self._audioEntity:
self._audioEntity.SetAttenuationScalingFactor(100.0)
def PrepareBackgroundLandscapes(self, scene):
starSeed = 0
securityStatus = 1
if eve.session.stationid is not None:
return
if scene is None:
return
if bool(eve.session.solarsystemid2):
starSeed = int(eve.session.constellationid)
securityStatus = sm.StartService('map').GetSecurityStatus(
eve.session.solarsystemid)
scene.starfield = trinity.Load(
'res:/dx9/scene/starfield/spritestars.red')
if scene.starfield is not None:
scene.starfield.seed = starSeed
scene.starfield.minDist = 40
scene.starfield.maxDist = 80
if util.IsWormholeSystem(eve.session.solarsystemid):
scene.starfield.numStars = 0
else:
scene.starfield.numStars = 500 + int(250 * securityStatus)
if scene.backgroundEffect is None:
scene.backgroundEffect = trinity.Load(
'res:/dx9/scene/starfield/starfieldNebula.red')
node = nodemanager.FindNode(scene.backgroundEffect.resources,
'NebulaMap',
'trinity.TriTexture2DParameter')
if node is not None:
node.resourcePath = scene.envMap1ResPath
if scene.starfield is None or scene.backgroundEffect is None:
return
scene.backgroundRenderingEnabled = True
def ShowCursor(self):
scene = sm.GetService('sceneManager').GetRegisteredScene('default')
if scene is None:
return
self.cursor = trinity.Load('res:/Model/UI/posCursor.red')
self.cube = trinity.Load('res:/Model/UI/posGlassCube.red')
s = float(boxSizes[7 - self.boxSize])
blue.pyos.synchro.SleepWallclock(1)
self.yCursor = [self.cursor.children[0], self.cursor.children[1]]
self.xCursor = [self.cursor.children[4], self.cursor.children[5]]
self.zCursor = [self.cursor.children[2], self.cursor.children[3]]
self.cube.scaling = (s, s, s)
newScale = s * 0.075 * 0.25
self.cursor.scaling = (newScale, newScale, newScale)
self.cursor.useDistanceBasedScale = True
self.cursor.distanceBasedScaleArg1 = 0.00015
self.cursor.distanceBasedScaleArg2 = 0
bp = sm.GetService('michelle').GetBallpark()
ball = bp.GetBall(self.posID)
pos = ball.GetVectorAt(blue.os.GetSimTime())
self.cursor.translation = (pos.x, pos.y, pos.z)
scene.objects.append(self.cursor)
scene.objects.append(self.cube)
self.Update()
self.active = 1
def Prepare(self, addToScene=True):
shipBall = self.GetEffectShipBall()
self.isShortWarp = self._IsShortWarp(shipBall)
if self.isShortWarp:
return
model = getattr(shipBall, 'model', None)
if model is None:
return
self.startPos = shipBall.GetVectorAt(blue.os.GetSimTime())
self.startPos = (self.startPos.x, self.startPos.y, self.startPos.z)
self.lastPos = self.startPos
def _sizeFunction(x):
return 0.0039 * x + 2.5
r = _sizeFunction(model.boundingSphereRadius)
self.gfx_trace = trinity.Load('res:/fisfx/jump/warp/warp_out.red')
self.gfxModel_trace = trinity.EveRootTransform()
self.gfxModel_trace.children.append(self.gfx_trace)
self.gfxModel_trace.scaling = (r, r, 8)
self.gfx_ship = trinity.Load('res:/fisfx/jump/warp/warp_glow.red')
self.gfxModel_ship = trinity.EveRootTransform()
self.gfxModel_ship.children.append(self.gfx_ship)
r *= 0.5
self.gfxModel_ship.scaling = (r, r, 6)
self.soundInsert = 'frig'
if model.boundingSphereRadius > 350:
self.soundInsert = 'battle'
self.gfx = self.gfx_trace
self.AddSoundToEffect(0.0007)
def SetModel(self, scale):
graphic = cfg.invtypes.Get(self.pinKv.typeID).Graphic()
self.model = None
if graphic and graphic.graphicFile:
graphicFile = str(graphic.graphicFile)
graphicFile = graphicFile.replace(':/model',
':/dx9/model').replace(
'.blue', '.red')
self.model = trinity.Load(graphicFile)
if not self.model or self.model.__bluetype__ != 'trinity.EveTransform':
self.model = trinity.Load(
'res:/dx9/model/worldobject/Orbital/UI/Terrestrial/Command/CommT_T1/CommT_T1.red'
)
if not self.model:
return
EXT = 1.026
self.model.scaling = (scale, scale, scale)
self.model.sortValueMultiplier = 0.5
self.model.translation = (EXT * self.surfacePoint.x,
EXT * self.surfacePoint.y,
EXT * self.surfacePoint.z)
plnSurfRotMat = geo2.MatrixRotationAxis(
geo2.Vec3Cross(
geo2.Vec3Normalize(self.surfacePoint.GetAsXYZTuple()),
(0.0, 1.0, 0.0)), -math.acos(
geo2.Vec3Dot(
geo2.Vec3Normalize(self.surfacePoint.GetAsXYZTuple()),
(0.0, 1.0, 0.0))))
rotQuat = geo2.QuaternionRotationMatrix(plnSurfRotMat)
self.model.rotation = rotQuat
self.model.name = '%s,%s' % (planetCommon.PINTYPE_NORMAL,
self.pinKv.id)
self.transform.children.append(self.model)
def Prepare(self, addToScene=True):
shipBall = self.GetEffectShipBall()
if WarpFlashIn._bigGlows < 5:
gfx = trinity.Load('res:/fisfx/jump/warp/warp_in_glow.red')
WarpFlashIn._bigGlows += 1
self.useBigGlow = True
else:
gfx = trinity.Load('res:/fisfx/jump/warp/warp_in_noglow.red')
self.useBigGlow = False
if gfx is None:
return
self.gfx = gfx
model = getattr(shipBall, 'model', None)
if model is None:
return
s = 0.7778 * model.GetBoundingSphereRadius()**0.3534
self.gfx.scaling = (s, s, s)
self.gfx_ship = trinity.Load('res:/fisfx/jump/warp/warp_glow.red')
def _glowScale(x):
return 9e-08 * x * x + 0.005 * x + 0.6898
self.gfxModel_ship = trinity.EveRootTransform()
self.gfxModel_ship.children.append(self.gfx_ship)
r = 0.125 * _glowScale(model.boundingSphereRadius)
self.gfxModel_ship.scaling = (r, r, r * 3)
self.soundEvent = 'warp_in_frig_play'
if model.GetBoundingSphereRadius() > 350:
self.soundEvent = 'warp_in_battle_play'
self.AddSoundToEffect(0.001)
def __init__(self):
self.rootPersistenceKey = (self, 'rootTransform')
self.rootCurve = OffsetPositionFunction(None)
self.sceneManager = sm.GetService('sceneManager')
self.rootTransform = trinity.EveRootTransform()
self.rootTransform.translationCurve = self.rootCurve.GetBlueFunction()
self.sceneManager.RegisterPersistentSpaceObject(self.rootPersistenceKey, self.rootTransform)
self.rootTransform.name = 'TacticalOverlayMain'
self.connectorPersistenceKey = (self, 'connectorContainer')
self.connectorContainer = trinity.Load('res:/ui/inflight/tactical/tacticalOverlay.red')
self.connectorContainer.translationCurve = self.rootCurve.GetBlueFunction()
self.sceneManager.RegisterPersistentSpaceObject(self.connectorPersistenceKey, self.connectorContainer)
self.anchorDiffuse = self.connectorContainer.anchorEffect.parameters.FindByName('DiffuseColor')
self.bombSphere = trinity.Load(_RANGE_SPHERE_PATH)
self.bombSpherePersistanceKey = (self, 'bombSphere')
self.sceneManager.RegisterPersistentSpaceObject(self.bombSpherePersistanceKey, self.bombSphere)
self.bombRangeAnchorConnector = None
self.firingRangePersistenceKey = (self, 'firingRange')
self.firingRangeRoot = trinity.EveRootTransform()
self.firingRangeRoot.name = 'TacticalOverlayRangeSphere'
self.sceneManager.RegisterPersistentSpaceObject(self.firingRangePersistenceKey, self.firingRangeRoot)
self.darkDiscPersistenceKey = (self, 'darkDisc')
self.darkDiscContainer = trinity.EveRootTransform()
self.darkDiscContainer.name = 'TacticalOverlayDarkDisc'
self.sceneManager.RegisterPersistentSpaceObject(self.darkDiscPersistenceKey, self.darkDiscContainer)
self.connectors = {}
self.selection = None
self.targetingRange = None
self.optimalRange = None
self.falloffRange = None
self.baseRadius = 0.0
self.compassDisc = CompassDisc(self.rootTransform, self.firingRangeRoot, self.darkDiscContainer)
def LoadScene(self, sceneContainer):
sceneContainer.PrepareSpaceScene(maxPitch=0.0,
scenePath=self.scenePath)
model = trinity.Load(
'res:/dx9/model/ship/IconPreview/PreviewAmmoShip.red')
sceneContainer.AddToScene(model)
ammoRedFile = inventorycommon.typeHelpers.GetGraphicFile(self.typeID)
ammoRedFile = ammoRedFile[:-4] + '_hi' + ammoRedFile[-4:]
ammo = trinity.Load(ammoRedFile)
if ammo.__bluetype__ != 'trinity.EveMissile':
raise InvalidPreviewType(
'{%s (%s) is not a trinity.EveMissile' %
(evetypes.GetName(self.typeID), self.typeID))
warhead = ammo.warheads[0]
floatHeight = ammo.boundingSphereRadius - ammo.boundingSphereCenter[2]
floatHeight += 0.2 * ammo.boundingSphereRadius
warhead.translation = (0.0, floatHeight, 0.0)
warhead.rotation = geo2.QuaternionRotationAxis((1.0, 0.0, 0.0),
-0.5 * math.pi)
warhead.startDataValid = True
model.children.append(warhead)
del warhead.children[:]
reflection = warhead.CopyTo()
reflection.translation = (0.0, -floatHeight, 0.0)
reflection.rotation = geo2.QuaternionRotationAxis((1.0, 0.0, 0.0),
0.5 * math.pi)
reflection.startDataValid = True
model.children.append(reflection)
boundingCenterY = ammo.boundingSphereRadius + 0.5 * floatHeight
model.boundingSphereCenter = (0.0, boundingCenterY, 0.0)
model.boundingSphereRadius = ammo.boundingSphereRadius + floatHeight
SetupSpaceCamera(sceneContainer, model)
def __init__(self, scene=None):
self._connectorContainer = trinity.Load(self._CONNECTOR_CONTAINER_PATH)
self._freeformLineSet = trinity.Load(self._FREEFORM_LINESET_PATH)
if scene is not None:
scene.objects.append(self._connectorContainer)
scene.objects.append(self._freeformLineSet)
else:
sm.GetService('sceneManager').RegisterPersistentSpaceObject(
(LineController, 0), self._connectorContainer)
sm.GetService('sceneManager').RegisterPersistentSpaceObject(
(LineController, 1), self._freeformLineSet)
def Explode(self,
explosionURL=None,
scaling=1.0,
managed=False,
delay=0.0):
self.LogInfo('Exploding')
if self.exploded:
return False
sm.ScatterEvent('OnObjectExplode', self.GetModel())
self.exploded = True
delayedRemove = delay
if settings.user.ui.Get('explosionEffectsEnabled', 1):
gfx = None
if managed:
gfx = self.explosionManager.GetExplosion(
explosionURL, callback=self.ClearExplosion)
else:
if explosionURL is None:
self.LogError(
'explosionURL not set when calling Explode. Possibly wrongly authored content. typeID:',
self.typeID)
explosionURL, (delay, scaling) = self.GetExplosionInfo()
explosionURL = explosionURL.replace('.blue', '.red').replace(
'/Effect/', '/Effect3/')
gfx = trinity.Load(explosionURL)
if not gfx:
self.LogError('Failed to load explosion: ', explosionURL,
' - using default')
gfx = trinity.Load(
'res:/Model/Effect/Explosion/entityExplode_large.red')
if gfx.__bluetype__ == 'trinity.EveEffectRoot':
self.LogWarn(
'EveEffectRoot explosion not managed for %s. ExplosionManager circumvented.'
% explosionURL)
gfx.Start()
elif gfx.__bluetype__ != 'trinity.EveRootTransform':
root = trinity.EveRootTransform()
root.children.append(gfx)
root.name = explosionURL
gfx = root
gfx.translationCurve = self
self.explosionModel = gfx
scale = scaling
gfx.scaling = (gfx.scaling[0] * scale, gfx.scaling[1] * scale,
gfx.scaling[2] * scale)
scene = sm.StartService('sceneManager').GetRegisteredScene(
'default')
scene.objects.append(gfx)
if self.wreckID is not None:
wreckBall = sm.StartService('michelle').GetBall(self.wreckID)
if wreckBall is not None:
uthread.pool('Wreck::DisplayWreck', wreckBall.DisplayWreck,
500)
return delayedRemove
def GetPlanetScene(self):
scenepath = sm.GetService('sceneManager').GetScene()
scene = trinity.Load(scenepath)
scene.backgroundEffect = trinity.Load(
'res:/dx9/scene/starfield/starfieldNebula.red')
if scene.backgroundEffect is not None:
for node in scene.backgroundEffect.resources.Find(
'trinity.TriTextureParameter'):
if node.name == 'NebulaMap':
node.resourcePath = scene.envMap1ResPath
scene.backgroundRenderingEnabled = True
return scene
def LoadScene(self):
self.camera = trinity.Load('res:/dx9/scene/login_screen_camera.red')
self.scene = trinity.Load('res:/dx9/scene/login_screen.red')
blue.resMan.Wait()
self.CheckHeightMaps()
stations = self.scene.Find('trinity.EveStation2')
for station in stations:
station.PlayAnimationEx('NormalLoop', 0, 0, 0.2)
self.camera.audio2Listener = audio2.GetListener(0)
sm.GetService('sceneManager').SetActiveCamera(self.camera)
sm.GetService('sceneManager').SetActiveScene(self.scene)
audioService = sm.GetService('audio')
audioService.UpdateDynamicMusic()
self.sceneLoadedEvent.set()
blue.pyos.synchro.Yield()
def PrepareComponent(self, sceneID, entityID, component):
if component.redFile == '':
return
if not sm.GetService('device').GetAppFeatureState(
'Interior.LensflaresEnabled', True):
return
component.trinityObject = trinity.Load(component.redFile)
def EnableResourceLayer(self):
if self.planetTransform is not None:
if self.resourceLayer is None:
self.LogInfo(
'_ShowResource no resourceLayer found. Loading resource layer'
)
self.resourceLayer = trinity.Load(
'res:/dx9/model/worldobject/planet/uiplanet.red')
trinity.WaitForResourceLoads()
effect = self.resourceLayer.mesh.transparentAreas[0].effect
for resource in effect.resources:
if resource.name == 'ColorRampMap':
resource.resourcePath = 'res:/dx9/model/worldobject/planet/resource_colorramp.dds'
for param in effect.parameters:
if param.name == 'MainColor':
param.value = RESOURCE_BASE_COLOR
elif param.name == 'ResourceTextureInfo':
param.value = (PLANET_RESOURCE_TEX_WIDTH,
PLANET_RESOURCE_TEX_HEIGHT, 0, 0)
offset = trinity.Tr2FloatParameter()
offset.name = 'HeatOffset'
offset.value = 0.0
effect.parameters.append(offset)
stretch = trinity.Tr2FloatParameter()
stretch.name = 'HeatStretch'
stretch.value = 1.0
effect.parameters.append(stretch)
self.planetTransform.children.append(self.resourceLayer)
else:
self.resourceLayer.display = True
low, hi = settings.char.ui.Get('planet_resource_display_range',
(0.0, 1.0))
self.SetResourceDisplayRange(low, hi)
def LoadScene(self, sceneContainer):
sceneContainer.PrepareSpaceScene(maxPitch=0.0,
scenePath=self.scenePath)
model = trinity.Load(
'res:/dx9/model/ship/IconPreview/PreviewTurretShip.red')
turretSet = TurretSet.FitTurret(model=model,
parentTypeID=None,
turretTypeID=self.typeID,
locatorID=1,
checkSettings=False)
if turretSet is None:
typeInfo = cfg.invtypes.Get(self.typeID)
raise RuntimeError(
'Failed to load preview for {0.name} ({0.typeID})'.format(
typeInfo))
boundingSphere = turretSet.turretSets[0].boundingSphere
model.boundingSphereRadius = boundingSphere[3]
model.boundingSphereCenter = boundingSphere[:3]
if model.boundingSphereCenter[1] < 2.0:
model.boundingSphereCenter = (boundingSphere[0], 2.0,
boundingSphere[2])
for turret in turretSet.turretSets:
turret.bottomClipHeight = 0.0
turret.FreezeHighDetailLOD()
turret.ForceStateDeactive()
turret.EnterStateIdle()
sceneContainer.AddToScene(model)
SetupSpaceCamera(sceneContainer, model)
def LoadScene(self, sceneContainer):
sceneContainer.PrepareSpaceScene(scenePath=self.scenePath)
typeInfo = cfg.invtypes.Get(self.typeID)
resFile = typeInfo.GraphicFile()
if typeInfo.categoryID == invconst.categoryStation and self.itemID:
stations = cfg.mapSolarSystemContentCache.npcStations
npcStation = stations.get(self.itemID, None)
if npcStation:
graphicID = npcStation.graphicID
resFile = cfg.graphics.Get(graphicID).graphicFile
modelDNA = gfxutils.BuildSOFDNAFromTypeID(self.typeID)
if modelDNA is not None:
spaceObjectFactory = sm.GetService('sofService').spaceObjectFactory
model = spaceObjectFactory.BuildFromDNA(modelDNA)
else:
model = trinity.Load(resFile)
if model is None:
raise InvalidPreviewType(
'{0.name} ({0.typeID}) failed to load associated model'.format(
typeInfo))
if getattr(model, 'boosters', None) is not None:
model.boosters = None
if getattr(model, 'modelRotationCurve', None) is not None:
model.modelRotationCurve = None
if getattr(model, 'modelTranslationCurve', None) is not None:
model.modelTranslationCurve = None
SetupAnimations(model, self.typeID)
sceneContainer.AddToScene(model)
SetupSpaceCamera(sceneContainer, model)
def AddDistrict(self, uniqueName, centerNormal, size, enableBattle):
if uniqueName in self.districts:
self.LogError('District ' + str(uniqueName) +
' already exists for planet with id ' +
str(self.itemID))
return
randomDistrictNum = len(self.districts) % 10 + 1
randomDistrictResPath = 'res:/dx9/model/worldobject/Planet/Terrestrial/district/District%02d.red' % randomDistrictNum
newDistrict = trinity.Load(randomDistrictResPath)
if newDistrict is None:
self.LogError('District ' + str(randomDistrictResPath) +
' not found for planet with id ' + str(self.itemID))
return
newDistrict.name = uniqueName
newDistrict.centerNormal = centerNormal
for param in newDistrict.pinEffect.parameters:
if param.name == 'AnimatedFactors2':
param.value = (param.value[0], float(enableBattle),
random.random(), param.value[3])
break
newDistrict.pinRadius = PLANET_DISTRICT_RADIUS_RATIO * size / self.radius
newDistrict.pinMaxRadius = PLANET_DISTRICT_RADIUS_RATIO * size / self.radius
newDistrict.pinRotation = 0.0
self.districts[uniqueName] = newDistrict
self.districtContainer.children.append(newDistrict)
self.districtsInfo[uniqueName] = {'num': randomDistrictNum}
self.__ApplyPlanetAttributesToDistricts()
def __init__(self, rootTransform):
self.rootTransform = rootTransform
self.baseTile = trinity.Load('res:/dx9/model/UI/HexTile.red')
self.tilePool = []
self.layoutCache = {}
self.systemInfoMap = {}
minx, miny, maxx, maxy = (0, 0, 0, 0)
self.aabb = AABB()
map = sm.GetService('map')
systems = []
self.mapHeight = 0.0
for systemID in map.IterateSolarSystemIDs():
item = map.GetItem(systemID)
x, y = item.x * STARMAP_SCALE, item.z * STARMAP_SCALE
systemInfo = HexSystemInfo(systemID, item.factionID, x, y)
self.systemInfoMap[systemID] = systemInfo
systems.append(systemInfo)
self.aabb.IncludePoint(systemInfo.point)
self.mapHeight = max(self.mapHeight, item.y * STARMAP_SCALE)
self.systemQuadTree = QuadTree(systems, depth=6, aabb=self.aabb)
self.centerPoint = self.systemQuadTree.center
self.mapHeight *= 1.1
self.legend = []
self.CalculateHexagonParameters()
self.nextTileNum = 0
self.firstUnusedTileNum = None
self.SetupScene()
def AddExplosion(self, uniqueName, explosionGfxID, spreadOut):
if uniqueName not in self.districts:
self.logger.error('Could not find district %s for planet with id %s', str(uniqueName), str(self.itemID))
graphics = GetGraphic(explosionGfxID)
if graphics is None:
self.logger.error("Explosion graphicsID %s doesn't exist!", str(explosionGfxID))
return
fx = trinity.Load(graphics.graphicFile)
if fx is None:
self.logger.error("Explosion %s doesn't exist!", str(graphics.graphicFile))
return
if len(fx.curveSets) == 0:
self.logger.error('Explosion %s has no curveSets! This is useless...', str(graphics.graphicFile))
return
direction = self.districts[uniqueName].centerNormal
rotMatrix1 = geo2.MatrixRotationAxis((direction[1], direction[2], direction[0]), random.random() * spreadOut * self.districts[uniqueName].pinRadius)
rotMatrix2 = geo2.MatrixRotationAxis(direction, random.uniform(0, 2.0 * math.pi))
direction = geo2.Vec3TransformNormal(direction, rotMatrix1)
direction = geo2.Vec3TransformNormal(direction, rotMatrix2)
fx.translation = direction
fx.scaling = (5000.0 / PLANET_SIZE_SCALE, 5000.0 / PLANET_SIZE_SCALE, 5000.0 / PLANET_SIZE_SCALE)
v1 = geo2.Vec3Cross(geo2.Vec3Normalize(direction), (0.0, 1.0, 0.0))
alpha = -math.acos(geo2.Vec3Dot(geo2.Vec3Normalize(direction), (0.0, 1.0, 0.0)))
fx.rotation = geo2.QuaternionRotationAxis(v1, alpha)
duration = fx.curveSets[0].GetMaxCurveDuration()
self.districtExplosions.children.append(fx)
uthread.new(self._RemoveExplosionFromDistrict, fx, duration)
def SetupStubble(meshes, name, stubblePath, adding = True):
ret = []
stubbleName = '{0}Stubble'.format(name)
stubbleMeshes = (mesh for mesh in meshes if mesh.name.startswith(pdDef.DOLL_PARTS.HEAD))
for mesh in stubbleMeshes:
if adding:
if any(map(lambda x: 'stubble' in x.name.lower(), mesh.decalAreas)):
ret.append(mesh)
continue
c_skin_areas = (area for area in mesh.opaqueAreas if area.effect.name.lower().startswith('c_skin_'))
for area in c_skin_areas:
stubbleArea = trinity.Tr2MeshArea()
stubbleArea.name = stubbleName
stubbleArea.index = area.index
stubbleArea.count = area.count
stubbleArea.effect = trinity.Load(stubblePath)
for resource in stubbleArea.effect.resources:
if resource.name == 'LengthTexture':
while resource.resource.IsLoading():
pdCf.Yield()
mesh.decalAreas.append(stubbleArea)
ret.append(mesh)
if SkinSpotLightShadows.instance:
SkinSpotLightShadows.instance.CreateEffectParamsForMesh(mesh, False)
for instance in SkinLightmapRenderer.instances:
if instance():
instance().BindLightmapShader(mesh)
else:
targetAreasToRemove = [ area for area in mesh.decalAreas if area.name == stubbleName ]
for ta in targetAreasToRemove:
mesh.decalAreas.remove(ta)
return ret
def Explode(self):
if self.exploded:
return False
self.fadeCurve = trinity.Load(
'res:/dx9/model/shipwrecks/FadeCurve.red')
self.model.curveSets.append(self.fadeCurve)
if self.model.mesh:
for area in self.model.mesh.opaqueAreas:
for par in area.effect.parameters:
if par.name == 'AlphaThreshold':
newBinding = self.fadeCurve.bindings[0].CopyTo()
newBinding.destinationObject = par
newBinding.sourceObject = self.fadeCurve.curves[0]
self.fadeCurve.bindings.append(newBinding)
self.fadeCurve.curves[0].Sort()
self.exploded = True
if self.model is None:
return False
curves = self.model.Find('trinity.TriColorCurve')
timecurves.ReverseTimeCurvesF(curves)
curves.extend(self.model.Find('audio.SoundNode'))
timecurves.ResetTimeAndSoundCurves(curves)
self.fadeCurve.Play()
blue.pyos.synchro.SleepSim(10000)
return False
def RenderNormalAssets(self, bloodlineID, camera, character, genderID,
scene, tryout):
doll = character.doll
for category in self.assetCategoriesToRender:
typeData = self.characterSvc.GetAvailableTypesByCategory(
category, genderID, bloodlineID)
lightScene = trinity.Load(NORMAL_LIGHT_COLOR)
ccUtil.SetupLighting(scene, lightScene, lightScene)
cameraSetup = self.SetUpCamera(camera, category, character, SETUP,
scene, genderID)
log.LogNotice('before dresscode')
if category in DRESSCODE:
removeDcModifers = self.EnforceDresscode(
bloodlineID, category, doll, genderID)
else:
removeDcModifers = []
log.LogNotice('go render type')
for itemType in typeData:
wasRendered = self.RenderNormalType(bloodlineID, camera,
category, character,
genderID, itemType, scene)
if tryout and wasRendered:
break
log.LogNotice('remove the dresscode')
for dcResPath in removeDcModifers:
doll.RemoveResource(dcResPath, self.factory)
log.LogNotice('done with category')
def _RenderLoop(self, tryout = False, fromWebtools = False):
self.FindWhatToRender()
self.characterSvc.characters = {}
self.characterSvc.TearDown()
uicore.layer.charactercreation.OpenView()
uicore.layer.charactercreation.Flush()
for layerName, layer in uicore.layer.__dict__.iteritems():
if isinstance(layer, LayerCore):
layer.display = False
renderSize = self.sizeCombo.GetValue()
uicore.device.ForceSize(renderSize, renderSize)
sm.GetService('sceneManager').SetSceneType(0)
uicore.layer.charactercreation.SetupScene(ccConst.SCENE_PATH_CUSTOMIZATION)
self.resolution = self.resolutionCombo.GetValue()
scene = uicore.layer.charactercreation.scene
lightScene = trinity.Load(NORMAL_LIGHT_SETTINGS)
ccUtil.SetupLighting(scene, lightScene, lightScene)
uicore.layer.charactercreation.cameraUpdateJob = None
uicore.layer.charactercreation.camera = CharCreationCamera(None)
uicore.layer.charactercreation.SetupCameraUpdateJob()
camera = uicore.layer.charactercreation.camera
self.SetupRenderJob()
blue.pyos.synchro.SleepWallclock(2000)
self.DoLightsAndPoses(camera, scene)
self.DoAssets(camera, scene, tryout)
def RenderSun(outPath,
objectPath,
scenePath,
size=512,
cameraAngle=(0, 0, 0),
postProcessingQuality=2,
antiAliasingQuality=3,
modifyScene=None):
scene = trinity.Load(scenePath)
blue.resMan.Wait()
lensflare = blue.resMan.LoadObject(objectPath)
blue.resMan.Wait()
blue.os.Pump()
scene.lensflares.append(lensflare)
SetupLensflare(lensflare)
fov = 1.0
boundingSphereRadius = 100.0
boundingSphereCenter = (0.0, 0.0, 0.0)
view, projection = camera_util.GetViewAndProjectionUsingBoundingSphere(
boundingSphereRadius,
boundingSphereCenter,
cameraAngle=cameraAngle,
fov=fov)
if modifyScene:
view, projection = modifyScene(scene, view, projection)
hostBitmap = RenderToSurface(scene=scene,
view=view,
projection=projection,
size=size,
postProcessingQuality=postProcessingQuality,
antiAliasingQuality=antiAliasingQuality)
hostBitmap.Save(outPath)
def LoadScene(self, sceneContainer):
sceneContainer.PrepareSpaceScene(maxPitch=0.0,
scenePath=self.scenePath)
model = trinity.Load(
'res:/dx9/model/ship/IconPreview/PreviewTurretShip.red')
turretSet = TurretSet.FitTurret(model,
self.typeID,
1,
evetypes.GetSofFactionNameOrNone(
self.typeID),
checkSettings=False)
if turretSet is None:
raise RuntimeError('Failed to load preview for %s (%s)' %
(evetypes.GetName(self.typeID), self.typeID))
boundingSphere = turretSet.turretSets[0].boundingSphere
model.boundingSphereRadius = boundingSphere[3]
model.boundingSphereCenter = boundingSphere[:3]
if model.boundingSphereCenter[1] < 2.0:
model.boundingSphereCenter = (boundingSphere[0], 2.0,
boundingSphere[2])
for turret in turretSet.turretSets:
turret.bottomClipHeight = 0.0
turret.FreezeHighDetailLOD()
turret.ForceStateDeactive()
turret.EnterStateIdle()
sceneContainer.AddToScene(model)
SetupSpaceCamera(sceneContainer, model)
def LoadScene(self,
scenefile,
inflight=0,
registerKey=None,
setupCamera=True,
applyScene=True):
scene = None
camera = None
try:
if registerKey:
self.sceneLoadedEvents[registerKey] = locks.Event(registerKey)
self.SetSceneType(SCENE_TYPE_SPACE)
sceneFromFile = trinity.Load(scenefile)
if sceneFromFile is None:
return
scene = sceneFromFile
camera = self._GetCamera(registerKey, setupCamera)
if inflight:
self.ApplySolarsystemAttributes(scene, camera)
self.ApplySceneInflightAttributes(scene, camera)
if applyScene:
self.ApplyScene(scene, camera, registerKey)
except Exception:
log.LogException('sceneManager::LoadScene')
sys.exc_clear()
finally:
if registerKey and registerKey in self.sceneLoadedEvents:
self.sceneLoadedEvents.pop(registerKey).set()
return (scene, camera)
def LoadScene(self, sceneContainer):
sceneContainer.PrepareSpaceScene(scenePath=self.scenePath)
resFile = inventorycommon.typeHelpers.GetGraphicFile(self.typeID)
modelDNA = None
if evetypes.GetCategoryID(
self.typeID) == invconst.categoryStation and self.itemID:
stations = cfg.mapSolarSystemContentCache.npcStations
npcStation = stations.get(self.itemID, None)
if npcStation:
graphicID = npcStation.graphicID
modelDNA = gfxutils.BuildSOFDNAFromGraphicID(graphicID)
if modelDNA is None:
modelDNA = gfxutils.BuildSOFDNAFromTypeID(
self.typeID, materialSetID=self.materialSetID)
if modelDNA is not None:
spaceObjectFactory = sm.GetService('sofService').spaceObjectFactory
model = spaceObjectFactory.BuildFromDNA(modelDNA)
else:
model = trinity.Load(resFile)
if model is None:
raise InvalidPreviewType(
'%s (%s) failed to load associated model' %
(evetypes.GetName(self.typeID), self.typeID))
if getattr(model, 'boosters', None) is not None:
model.boosters = None
if getattr(model, 'modelRotationCurve', None) is not None:
model.modelRotationCurve = None
if getattr(model, 'modelTranslationCurve', None) is not None:
model.modelTranslationCurve = None
SetupAnimations(model, self.typeID)
model.FreezeHighDetailMesh()
trinity.WaitForResourceLoads()
sceneContainer.AddToScene(model)
SetupSpaceCamera(sceneContainer, model)
def Prepare(self):
shipID = self.ballIDs[0]
shipBall = self.fxSequencer.GetBall(shipID)
if shipBall is None:
raise RuntimeError('EMPWave: no ball found')
if self.moduleTypeID == 0:
self.moduleTypeID = 15957
graphicID = cfg.invtypes.Get(self.moduleTypeID).graphicID
if graphicID is None:
raise RuntimeError('EMPWave: no graphic ID')
gfxString = util.GraphicFile(graphicID)
self.gfx = trinity.Load(gfxString)
if self.gfx is None:
raise RuntimeError('EMPWave: no effect found')
entity = audio2.AudEmitter('effect_' + str(shipID))
obs = trinity.TriObserverLocal()
obs.observer = entity
if self.gfx.__bluetype__ in ('trinity.EveTransform', ):
self.gfx.observers.append(obs)
for curveSet in self.gfx.curveSets:
for curve in curveSet.curves:
if curve.__typename__ == 'TriEventCurve' and curve.name == 'audioEvents':
curve.eventListener = entity
self.gfxModel = trinity.EveRootTransform()
radius = self.fxSequencer.GetTypeAttribute(
self.moduleTypeID, const.attributeEmpFieldRange)
self.gfxModel.scaling = (radius / 1000, radius / 1000, radius / 1000)
self.radius = radius
self.gfxModel.name = self.__guid__
self.gfxModel.children.append(self.gfx)
self.gfxModel.translationCurve = shipBall
scene = self.fxSequencer.GetScene()
scene.objects.append(self.gfxModel)
