def InitTrinityTransforms(self):
self.pinTransform = trinity.EveTransform()
self.pinTransform.name = 'myPins'
self.pinOthersTransform = trinity.EveTransform()
self.pinOthersTransform.name = 'othersPins'
self.planetTransform.children.append(self.pinTransform)
self.planetTransform.children.append(self.pinOthersTransform)
def CreateSun(self, sunGraphic):
def GetEffectParameter(effect, parameterName):
for each in effect.parameters:
if each.name == parameterName:
return each
scaling = 1.0 / mapViewConst.SOLARSYSTEM_SCALE * 16
sunTransform = trinity.EveTransform()
sunTransform.name = 'Sun'
sunTransform.scaling = (scaling, scaling, scaling)
sunTransform.useDistanceBasedScale = True
sunTransform.distanceBasedScaleArg1 = 0.02
sunTransform.distanceBasedScaleArg2 = 0.1
self.systemMapTransform.children.append(sunTransform)
for each in sunGraphic.mesh.additiveAreas:
if 'flare' not in each.name.lower() and 'rainbow' not in each.name.lower():
transform = trinity.EveTransform()
try:
size = GetEffectParameter(each.effect, 'Size')
transform.scaling = (size.x, size.y, size.z)
except:
continue
transform.mesh = trinity.Tr2Mesh()
transform.mesh.geometryResPath = 'res:/Model/Global/zsprite.gr2'
transform.modifier = 1
transform.name = each.name
area = trinity.Tr2MeshArea()
transform.mesh.additiveAreas.append(area)
effect = trinity.Tr2Effect()
effect.effectFilePath = 'res:/Graphics/Effect/Managed/Space/SpecialFX/TextureColor.fx'
area.effect = effect
diffuseColor = trinity.Tr2Vector4Parameter()
diffuseColor.name = 'DiffuseColor'
effect.parameters.append(diffuseColor)
diffuseColor = diffuseColor
diffuseMap = trinity.TriTextureParameter()
diffuseMap.name = 'DiffuseMap'
diffuseMap.resourcePath = each.effect.resources[0].resourcePath
effect.resources.append(diffuseMap)
try:
color = GetEffectParameter(each.effect, 'Color')
diffuseColor.value = color.value
except:
continue
sunTransform.children.append(transform)
def __init__(self, text, parent, size=72, shadow=0, hspace=8, font=None):
self.transform = trinity.EveTransform()
self.transform.mesh = trinity.Tr2Mesh()
self.transform.mesh.geometryResPath = 'res:/Model/Global/zsprite.gr2'
self.transform.modifier = 1
self.measurer = trinity.Tr2FontMeasurer()
self.measurer.limit = 0
if font is None:
font = _GetDefaultFont()
self.measurer.font = font
self.measurer.fontSize = size
self.measurer.letterSpace = hspace
area = trinity.Tr2MeshArea()
self.transform.mesh.transparentAreas.append(area)
area.effect = self.effect = trinity.Tr2Effect()
sampler = list(self.effect.samplerOverrides.GetDefaultValue())
sampler[0] = 'DiffuseMapSampler'
sampler[1] = trinity.TRITADDRESS_CLAMP
sampler[2] = trinity.TRITADDRESS_CLAMP
self.effect.samplerOverrides.append(tuple(sampler))
self.effect.effectFilePath = 'res:/Graphics/Effect/Managed/Space/SpecialFX/TextureColor.fx'
diffuseColor = trinity.Tr2Vector4Parameter()
diffuseColor.name = 'DiffuseColor'
self.effect.parameters.append(diffuseColor)
self.diffuseColor = diffuseColor
self.diffuseMap = trinity.TriTextureParameter()
self.diffuseMap.name = 'DiffuseMap'
self.effect.resources.append(self.diffuseMap)
parent.children.append(self.transform)
trinity.device.RegisterResource(self)
self.SetText(text)
def LoadPlanet(self):
self.LogInfo('LoadPlanet planet', self.planetID, 'type', self.typeID,
'system', self.solarSystemID)
planet = Planet()
graphicFile = inventorycommon.typeHelpers.GetGraphicFile(self.typeID)
planet.typeData['graphicFile'] = graphicFile
planet.typeID = self.typeID
planet.LoadPlanet(self.planetID,
forPhotoService=True,
rotate=False,
hiTextures=True)
self.trinityPlanet = planet
if planet.model is None or planet.model.highDetail is None:
return
planetTransform = trinity.EveTransform()
planetTransform.name = 'planet'
planetTransform.scaling = (PLANET_SCALE, PLANET_SCALE, PLANET_SCALE)
planetTransform.children.append(planet.model.highDetail)
self.PreProcessPlanet()
scene = self.planetScene
trinity.WaitForResourceLoads()
for t in planet.model.highDetail.children:
if t.mesh is not None:
if len(t.mesh.transparentAreas) > 0:
t.sortValueMultiplier = 2.0
scene.sunDirection = (0.0, 0.0, 1.0)
scene.sunDiffuseColor = (1.0, 1.0, 1.0, 1.0)
self.planetTransform = planetTransform
self.planetRoot.children.append(self.planetTransform)
def CreateParticles():
particleTransform = trinity.EveTransform()
particleTransform.name = 'particleTransform'
tex = trinity.TriTextureParameter()
tex.name = 'TexMap'
tex.resourcePath = PARTICLE_SPRITE_TEXTURE
heattex = trinity.TriTextureParameter()
heattex.name = 'HeatTexture'
heattex.resourcePath = PARTICLE_SPRITE_HEAT_TEXTURE
distanceFadeControl = trinity.Tr2Vector4Parameter()
distanceFadeControl.name = DISTANCE_RANGE
distanceFadeControl.value = (0, 1, 0, 0)
particles = trinity.Tr2RuntimeInstanceData()
particles.SetElementLayout([(trinity.PARTICLE_ELEMENT_TYPE.POSITION, 0, 3),
(trinity.PARTICLE_ELEMENT_TYPE.POSITION, 1, 3),
(trinity.PARTICLE_ELEMENT_TYPE.CUSTOM, 0, 1),
(trinity.PARTICLE_ELEMENT_TYPE.CUSTOM, 1, 4)])
mesh = trinity.Tr2InstancedMesh()
mesh.geometryResPath = 'res:/Graphics/Generic/UnitPlane/UnitPlane.gr2'
mesh.instanceGeometryResource = particles
particleTransform.mesh = mesh
area = trinity.Tr2MeshArea()
area.effect = trinity.Tr2Effect()
area.effect.effectFilePath = PARTICLE_EFFECT
area.effect.resources.append(tex)
area.effect.resources.append(heattex)
area.effect.parameters.append(distanceFadeControl)
mesh.additiveAreas.append(area)
return (particleTransform, particles, distanceFadeControl)
def LoadPlanet(self, planetTypeID, planetID):
planet = Planet()
objType = cfg.invtypes.Get(planetTypeID)
graphicFile = objType.GraphicFile()
planet.typeData['graphicFile'] = graphicFile
planet.typeID = planetTypeID
planet.LoadPlanet(planetID,
forPhotoService=True,
rotate=False,
hiTextures=True)
if planet.model is None or planet.model.highDetail is None:
return
planetTransform = trinity.EveTransform()
planetTransform.name = 'planet'
planetTransform.children.append(planet.model.highDetail)
renderTarget, size = self.CreateRenderTarget()
planet.DoPreProcessEffect(size, None, renderTarget)
trinity.WaitForResourceLoads()
for t in planet.model.highDetail.children:
if t.mesh is not None:
if len(t.mesh.transparentAreas) > 0:
t.sortValueMultiplier = 2.0
self.systemMapTransform.children.append(planetTransform)
return planetTransform
def __init__(self):
spaceObject.SpaceObject.__init__(self)
self.textureSet = None
self.loaded = False
self.forceLOD = True
self.attributes = None
self.modelRes = []
self.heightMapResPath1 = ''
self.heightMapResPath2 = ''
self.largeTextures = False
self.districts = {}
self.districtsInfo = {}
self.districtContainer = trinity.EveTransform()
self.districtContainer.name = 'Districts'
self.districtExplosions = trinity.EveTransform()
self.districtExplosions.name = 'Explosions'
def GetPlanetPhoto(self, itemID, typeID, size=512):
graphicID = evetypes.GetGraphicID(typeID)
outPath = GetCachePath(typeID, graphicID, size, itemID)
planet = Planet()
planet.GetPlanetByID(itemID, typeID)
if planet.model is None or planet.model.highDetail is None:
return NOT_AVAILABLE_PATH
planetTransform = trinity.EveTransform()
planetTransform.scaling = (100.0, 100.0, 100.0)
planetTransform.children.append(planet.model.highDetail)
scene = self.GetPlanetScene()
try:
planet.DoPreProcessEffectForPhotoSvc(size)
except:
del planetTransform.children[:]
return NOT_AVAILABLE_PATH
trinity.WaitForResourceLoads()
scene.sunDirection = (-1.0, 0.0, 0.0)
scene.sunDiffuseColor = (1.0, 1.0, 1.0, 1.0)
scene.objects.append(planetTransform)
view, projection = camera_util.GetViewAndProjectionUsingBoundingSphere(
boundingSphereRadius=130)
bitmap = photo.RenderToSurface(view,
projection,
size,
scene,
transparent=False)
bitmap.Save(outPath)
del planetTransform.children[:]
self._RemovePathFromNotAvailList(outPath)
return outPath
def LoadPlanet(self,
itemID=None,
forPhotoService=False,
rotate=True,
hiTextures=False):
if itemID is None:
itemID = self.id
self.itemID = itemID
self.largeTextures = hiTextures
self.rotatePlanet = self.typeID != const.typePlanetEarthlike and rotate
self.isInflightPlanet = not forPhotoService
self.model = trinity.EvePlanet()
if self.model is None:
self.LogError('Could not create model for planet with id', itemID)
return
self.model.translationCurve = self
self.model.highDetail = trinity.EveTransform()
self.model.scaling = self.radius
self.model.radius = self.radius
self.model.name = '%d' % itemID
if self.isInflightPlanet:
self.model.resourceCallback = self.ResourceCallback
scene = self.spaceMgr.GetScene()
if scene is not None:
scene.planets.append(self.model)
def CreatePlanet(self, planetPosition):
scaling = 0.01 / mapViewConst.SOLARSYSTEM_SCALE
planetTransform = trinity.EveTransform()
planetTransform.name = 'planetTransform'
planetTransform.scaling = (scaling, scaling, scaling)
planetTransform.translation = planetPosition
self.systemMapTransform.children.append(planetTransform)
planetTransform.useDistanceBasedScale = True
planetTransform.distanceBasedScaleArg1 = 1.0
planetTransform.distanceBasedScaleArg2 = 0.0
planetTransform.mesh = trinity.Tr2Mesh()
planetTransform.mesh.geometryResPath = 'res:/Model/Global/zsprite.gr2'
planetTransform.modifier = 1
area = trinity.Tr2MeshArea()
planetTransform.mesh.additiveAreas.append(area)
effect = trinity.Tr2Effect()
effect.effectFilePath = 'res:/Graphics/Effect/Managed/Space/SpecialFX/TextureColor.fx'
area.effect = effect
diffuseColor = trinity.Tr2Vector4Parameter()
diffuseColor.name = 'DiffuseColor'
effect.parameters.append(diffuseColor)
diffuseMap = trinity.TriTextureParameter()
diffuseMap.name = 'DiffuseMap'
diffuseMap.resourcePath = 'res:/UI/Texture/Classes/MapView/spotSprite.dds'
effect.resources.append(diffuseMap)
def _LoadModel(self):
path = GetGraphicFile(20984)
model = blue.resMan.LoadObject(path)
self.model = trinity.EveTransform()
self.model.scaling = (10000.0, 10000.0, 10000.0)
self.model.modifier = 2
self.model.name = 'Supernova'
self.model.children.append(model)
def LoadPlanet(self,
itemID=None,
forPhotoService=False,
rotate=True,
hiTextures=False):
if itemID is None:
itemID = self.id
self.itemID = itemID
if type(cfg.invtypes.Get(self.typeID).graphicID) != type(0):
raise RuntimeError('NeedGraphicIDNotMoniker', itemID)
self.modelPath = cfg.invtypes.Get(self.typeID).GraphicFile()
if hiTextures:
self.largeTextures = True
self.modelPath = self.modelPath.replace('.red', '_HI.red')
self.model = trinity.EvePlanet()
if self.model is None:
self.LogError('Could not create model for planet with id', itemID)
return
self.model.translationCurve = self
self.model.highDetail = trinity.EveTransform()
self.model.scaling = self.radius
self.model.radius = self.radius
self.model.name = '%d' % itemID
if self.typeID != const.typePlanetEarthlike:
if rotate:
rotationDirection = 1
if self.id % 2:
rotationDirection = -1
random.seed(self.id)
rotationTime = random.random() * 2000 + 3000
yCurve = trinity.TriScalarCurve()
yCurve.extrapolation = trinity.TRIEXT_CYCLE
yCurve.AddKey(0.0, 1.0, 0.0, 0.0, trinity.TRIINT_LINEAR)
yCurve.AddKey(rotationTime, rotationDirection * 360.0, 0.0,
0.0, trinity.TRIINT_LINEAR)
yCurve.Sort()
tilt = random.random() * 60.0 - 30.0
pCurve = trinity.TriScalarCurve()
pCurve.extrapolation = trinity.TRIEXT_CYCLE
pCurve.AddKey(0.0, 1.0, 0.0, 0.0, trinity.TRIINT_HERMITE)
pCurve.AddKey(6000.0, tilt, 0.0, 0.0, trinity.TRIINT_HERMITE)
pCurve.AddKey(12000.0, 0.0, 0.0, 0.0, trinity.TRIINT_HERMITE)
pCurve.Sort()
self.model.rotationCurve = trinity.TriYPRSequencer()
self.model.rotationCurve.YawCurve = yCurve
self.model.rotationCurve.PitchCurve = pCurve
if self.typeID == const.typeMoon:
self.model.zOnlyModel = trinity.Load(
'res:/dx9/model/worldobject/planet/planetzonly.red')
if self.attributes is None:
self.attributes = cfg.fsdPlanetAttributes[itemID]
if not forPhotoService:
self.model.resourceCallback = self.ResourceCallback
scene = sm.GetService('sceneManager').GetRegisteredScene('default')
if scene is not None:
scene.planets.append(self.model)
self.SetupAmbientAudio()
def SetDungeonOrigin(self):
bp = sm.StartService('michelle').GetBallpark()
if not bp or not bp.ego:
return
ego = bp.balls[bp.ego]
self.dungeonOrigin = trinity.EveTransform()
self.dungeonOrigin.translation = geo2.Vector(ego.x, ego.y, ego.z)
self.dungeonOrigin.rotation = geo2.QuaternionRotationSetYawPitchRoll(
ego.yaw, ego.pitch, ego.roll)
def LoadSolarSystemMap(self):
self.maxRadius = 0.0
solarsystemID = self.solarsystemID
parent = self.systemMapTransform
solarSystemData = self.systemMapSvc.GetSolarsystemData(solarsystemID)
planets = []
childrenToParentByID = {}
sunID = None
maxRadius = 0.0
for celestialObject in solarSystemData:
if celestialObject.groupID == const.groupPlanet:
planets.append(
(celestialObject.itemID,
geo2.Vector(celestialObject.x, celestialObject.y,
celestialObject.z)))
elif celestialObject.groupID == const.groupSun:
sunID = celestialObject.itemID
for each in solarSystemData:
if each.groupID in (const.groupPlanet, const.groupStargate):
childrenToParentByID[each.itemID] = sunID
continue
closest = []
eachPosition = geo2.Vector(each.x, each.y, each.z)
for planetID, planetPos in planets:
diffPos = planetPos - eachPosition
diffVector = geo2.Vec3Length(diffPos)
closest.append((diffVector, planetID))
maxRadius = max(maxRadius, diffVector)
closest.sort()
childrenToParentByID[each.itemID] = planets[0][1]
self.maxRadius = maxRadius
orbits = []
objectTransforms = {}
pm = (const.groupPlanet, const.groupMoon)
for each in solarSystemData:
if each.itemID == each.locationID:
continue
if each.groupID == const.groupSecondarySun:
continue
if each.groupID in pm:
parentID = childrenToParentByID.get(each.itemID, None)
if parentID:
orbits.append([each.itemID, parentID])
transform = trinity.EveTransform()
transform.translation = (each.x, each.y, each.z)
transform.name = str(each.itemID)
parent.children.append(transform)
objectTransforms[each.itemID] = transform
uthread.new(self.CreateOrbits, orbits, objectTransforms)
self.solarSystemRadius = maxRadius
cfg.evelocations.Prime(objectTransforms.keys(), 0)
def __init__(self):
SpaceObject.__init__(self)
self.textureSet = None
self.loaded = False
self.isInflightPlanet = True
self.rotatePlanet = False
self.rotationApplied = False
self.audioStarted = False
self.attributes = None
self.modelRes = []
self.modelPath = None
self.heightMapResPath1 = ''
self.heightMapResPath2 = ''
self.largeTextures = False
self.districts = {}
self.districtsInfo = {}
self.districtContainer = trinity.EveTransform()
self.districtContainer.name = 'Districts'
self.districtExplosions = trinity.EveTransform()
self.districtExplosions.name = 'Explosions'
def _LoadModel(self):
"""
Loads the model and sets up the proper transform hierarchy for camera relative positions.
"""
graphic = cfg.graphics.get(20984, None)
path = graphic.graphicFile
model = blue.resMan.LoadObject(path)
self.model = trinity.EveTransform()
self.model.scaling = (10000.0, 10000.0, 10000.0)
self.model.modifier = 2
self.model.name = 'Supernova'
self.model.children.append(model)
def ShowScanRanges(self):
if self.scanrangeCircles is None:
par = trinity.EveTransform()
self.scanrangeCircles = par
par.modifier = TR2TM_LOOK_AT_CAMERA
self.locator.children.append(par)
for r in self.scanRanges:
r *= 100.0
sr = trinity.Load('res:/Model/UI/probeRange.red')
sr.scaling = (r, r, r)
par.children.append(sr)
self.scanrangeCircles.display = True
def __init__(self, mapView, solarsystemID, scaling = 1.0, position = None):
if mapView:
self.mapView = mapView
self.scene = mapView.scene
self.solarsystemID = solarsystemID
self.scaling = scaling
self.systemMapSvc = sm.GetService('systemmap')
self.localMarkerIDs = set()
parent = trinity.EveTransform()
parent.name = 'solarsystem_%s' % solarsystemID
self.systemMapTransform = parent
if mapView:
mapView.mapRoot.children.append(self.systemMapTransform)
if position:
self.SetPosition(position)
def __init__(self, uniqueID, parent):
locator = trinity.EveTransform()
locator.name = 'spherePar_%s' % uniqueID
parent.children.append(locator)
cursor = trinity.Load('res:/Model/UI/probeCursor.red')
cursor.scaling = (CURSOR_SCALE, CURSOR_SCALE, CURSOR_SCALE)
cursor.useDistanceBasedScale = True
cursor.distanceBasedScaleArg1 = 1500000.0
cursor.distanceBasedScaleArg2 = 0.0
cursor.translation = (0.0, 0.0, 0.0)
for c in cursor.children:
c.name += '_' + str(uniqueID)
locator.children.append(cursor)
self.uniqueID = uniqueID
self.cursor = cursor
self.locator = locator
def UpdatePartitionDisplay(self):
if getattr(self, 'partitionTF', None) is None:
scene = sm.GetService('sceneManager').GetRegisteredScene('default')
self.partitionTF = trinity.EveTransform()
scene.objects.append(self.partitionTF)
boxRange = settings.user.ui.Get('partition_box_size', 7)
allboxes = settings.user.ui.Get('partition_box_showall', 1)
ballpark = sm.GetService('michelle').GetBallpark()
if not ballpark:
self.StopPartitionDisplayTimer()
return
egoball = ballpark.GetBall(ballpark.ego)
if allboxes == 1:
boxRange = range(boxRange, 8)
else:
boxRange = [boxRange]
numChildren = len(self.partitionTF.children)
count = [0]
def GetTransform():
if count[0] >= numChildren:
tf = blue.resMan.LoadObject(
'res:/model/global/partitionBox.red')
self.partitionTF.children.append(tf)
count[0] += 1
return tf
tf = self.partitionTF.children[count[0]]
count[0] += 1
return tf
for boxSize in boxRange:
boxes = ballpark.GetActiveBoxes(boxSize)
width, coords = boxes
if not boxes:
continue
for x, y, z in coords:
tf = GetTransform()
x = x - egoball.x + width / 2
y = y - egoball.y + width / 2
z = z - egoball.z + width / 2
tf.scaling = (width, width, width)
tf.translation = (x, y, z)
while count[0] < numChildren:
numChildren -= 1
self.partitionTF.children.removeAt(numChildren)
def __init__(self,
text,
parent,
scaling=1.0,
size=72,
shadow=0,
hspace=8,
font=None):
self.parent = parent
self.extraTransform = trinity.EveTransform()
self.extraTransform.useDistanceBasedScale = True
self.extraTransform.distanceBasedScaleArg1 = 1.0
self.extraTransform.distanceBasedScaleArg2 = 0.05
self.extraTransform.scaling = (scaling, scaling, scaling)
parent.children.append(self.extraTransform)
TransformableLabel.__init__(self, text, self.extraTransform, size,
shadow, hspace, font)
self.transform.translation = (0, self.transform.scaling[1] * 0.5, 0)
def __init__(self, parentTransform = None, rangeSteps = None, contextScaling = 1.0):
rangeCircles = trinity.EveTransform()
rangeCircles.name = 'RangeIndicator'
if parentTransform:
parentTransform.children.append(rangeCircles)
self.rootTransform = rangeCircles
self.contextScaling = contextScaling
rangeSteps = rangeSteps or self.defaultRangeSteps
prevRadius = None
color = self.circleColor
for i, radius in enumerate(rangeSteps):
drawRadius = radius * self.contextScaling
if i == 0:
label = GetByLabel('UI/Inflight/Scanner/UnitAU')
else:
if radius >= const.AU:
label = FmtAmt(radius / const.AU)
else:
label = FmtDist(radius, maxdemicals=0)
baseAngle = math.pi / 2
circum = drawRadius * baseAngle
gapSize = 0.8 / circum
gapAngle = gapSize * baseAngle
for startAngle in (0.0,
math.pi * 0.5,
math.pi,
math.pi * 1.5):
lineSet = mapViewUtil.CreatePlanarLineSet()
rangeCircles.children.append(lineSet)
lineIDs = mapViewUtil.DrawCircularArc(lineSet, (0.0, 0.0, 0.0), drawRadius, startAngle=startAngle + gapAngle, angle=baseAngle - gapAngle * 2, lineWidth=0.1, startColor=color, endColor=color)
if prevRadius:
cos = math.cos(startAngle)
sin = math.sin(startAngle)
p1 = ((prevRadius - 0.5) * sin, 0.0, (prevRadius - 0.5) * cos)
p2 = ((drawRadius + 0.5) * sin, 0.0, (drawRadius + 0.5) * cos)
lineID = lineSet.AddStraightLine(p1, color, p2, color, 0.02)
lineSet.SubmitChanges()
prevRadius = drawRadius
self.AddRangeLabel(label, drawRadius)
lineSet.SubmitChanges()
def Create3DRender(self):
self.renderTexture = trinity.TriTextureParameter()
self.renderTexture.name = 'DiffuseMap'
self.renderColor = trinity.Tr2Vector4Parameter()
self.renderColor.name = 'DiffuseColor'
self.renderColor.value = (1, 1, 1, 1)
self.renderEffect = trinity.Tr2Effect()
self.renderEffect.effectFilePath = 'res:/Graphics/Effect/Managed/Space/SpecialFX/TextureColor.fx'
self.renderEffect.resources.append(self.renderTexture)
self.renderEffect.parameters.append(self.renderColor)
self.renderArea = trinity.Tr2MeshArea()
self.renderArea.effect = self.renderEffect
self.renderMesh = trinity.Tr2Mesh()
self.renderMesh.name = 'orbitalBombardmentTarget'
self.renderMesh.geometryResPath = 'res:/Graphics/Generic/UnitPlane/UnitPlane.gr2'
self.renderMesh.transparentAreas.append(self.renderArea)
if self.trackType == self.TRACKTYPE_BALL:
self.transform = trinity.EveRootTransform()
else:
self.transform = trinity.EveTransform()
if self.faceCamera:
self.transform.modifier = 1
self.transform.mesh = self.renderMesh
self.sceneParent.append(self.transform)
self.renderJob = trinity.CreateRenderJob()
self.renderJob.Update(self.renderScene)
self.renderObject = self.GetRenderObject()
self.renderObject.is2dPick = False
self.renderTarget = trinity.Tr2RenderTarget(
self.width, self.height, 1, trinity.PIXEL_FORMAT.B8G8R8A8_UNORM)
self.renderJob.PushRenderTarget(self.renderTarget)
self.renderJob.RenderScene(self.renderObject)
self.renderJob.PopRenderTarget()
self.renderJob.ScheduleRecurring(insertFront=True)
self.renderTexture.SetResource(trinity.TriTextureRes(
self.renderTarget))
self.renderSteps[-1].enabled = False
return self.transform
def __init__(self, rootContainer, rangeContainer, discContainer):
self.lineSet = trinity.Load(_LINESET_SMOOTH_PATH)
self.rootContainer = rootContainer
rootContainer.children.append(self.lineSet)
self.rangeLineSet = trinity.Load(_LINESET_SMOOTH_PATH)
self.rangeContainer = rangeContainer
rangeContainer.children.append(self.rangeLineSet)
self.optimalQuad = trinity.Load(_OPTIMAL_GRADIENT_PATH)
self.falloffQuad = trinity.Load(_FALLOFF_GRADIENT_PATH)
self.firingRangeLines = []
self.rangeLines = []
self.rangeLabels = {}
self.rangeLabelsTF = trinity.EveTransform()
rootContainer.children.append(self.rangeLabelsTF)
self.arcLines = []
self.discContainer = discContainer
self.darkDisc = trinity.Load(_DARK_DISK_PATH)
self.discContainer.children.append(self.darkDisc)
self.activeRange = _DEFAULT_ACTIVE_RANGE
self._activeRangeMeters = 0
self.targetingRange = 0
self._baseRadius = 0
self.targetingRangeLines = []
self.SetActiveRange(self.activeRange)
def __init__(self, text, parent, size=72, shadow=0, hspace=8):
self.transform = trinity.EveTransform()
self.transform.mesh = trinity.Tr2Mesh()
self.transform.mesh.geometryResPath = 'res:/Model/Global/zsprite.gr2'
self.transform.modifier = 1
self.measurer = trinity.Tr2FontMeasurer()
self.measurer.limit = 0
fontFamily = uicore.font.GetFontFamilyBasedOnClientLanguageID()[
fontConst.STYLE_DEFAULT]
self.measurer.font = fontFamily[2]
self.measurer.fontSize = size
self.measurer.letterSpace = hspace
self.measurer.AddText(text.upper())
height = self.measurer.ascender - self.measurer.descender
width = self.measurer.cursorX
self.measurer.CommitText(0, self.measurer.ascender)
self.transform.scaling = (width, height, 0)
area = trinity.Tr2MeshArea()
self.transform.mesh.transparentAreas.append(area)
area.effect = self.effect = trinity.Tr2Effect()
sampler = list(self.effect.samplerOverrides.GetDefaultValue())
sampler[0] = 'DiffuseMapSampler'
sampler[1] = trinity.TRITADDRESS_CLAMP
sampler[2] = trinity.TRITADDRESS_CLAMP
self.effect.samplerOverrides.append(tuple(sampler))
self.effect.effectFilePath = 'res:/Graphics/Effect/Managed/Space/SpecialFX/TextureColor.fx'
diffuseColor = trinity.Tr2Vector4Parameter()
diffuseColor.name = 'DiffuseColor'
self.effect.parameters.append(diffuseColor)
self.diffuseColor = diffuseColor
self.diffuseMap = trinity.TriTextureParameter()
self.diffuseMap.name = 'DiffuseMap'
self.effect.resources.append(self.diffuseMap)
parent.children.append(self.transform)
trinity.device.RegisterResource(self)
self.OnCreate(trinity.device)
def LoadOrbitalObjects(self, scene):
orbitalObjects = sm.GetService('planetInfo').GetOrbitalsForPlanet(
self.planetID, const.groupPlanetaryCustomsOffices)
park = sm.GetService('michelle').GetBallpark()
addedObjects = []
for orbitalObjectID in orbitalObjects:
invItem = park.GetInvItem(orbitalObjectID)
fileName = None
if evetypes.GetGraphicID(invItem.typeID) is not None:
if type(evetypes.GetGraphicID(invItem.typeID)) != type(0):
raise RuntimeError('NeedGraphicIDNotMoniker',
invItem.itemID)
if inventorycommon.typeHelpers.GetGraphic(invItem.typeID):
fileName = inventorycommon.typeHelpers.GetGraphicFile(
invItem.typeID)
if not (fileName.lower().endswith('.red')
or fileName.lower().endswith('.blue')):
filenameAndTurretType = fileName.split(' ')
fileName = filenameAndTurretType[0]
if fileName is None:
self.LogError(
'Error: Object type %s has invalid graphicFile, using graphicID: %s'
% (invItem.typeID, evetypes.GetGraphicID(invItem.typeID)))
continue
tryFileName = fileName.replace(':/Model', ':/dx9/Model').replace(
'.blue', '.red')
tryFileName = tryFileName.replace('.red', '_UI.red')
model = None
if tryFileName is not None:
try:
model = blue.resMan.LoadObject(tryFileName)
except:
model = None
if model is None:
self.LogError('Was looking for:', tryFileName,
'but it does not exist!')
if model is None:
try:
model = blue.resMan.LoadObject(fileName)
except:
model = None
if not model:
log.LogError(
'Could not load model for orbital object. FileName:',
fileName, ' id:', invItem.itemID, ' typeID:',
getattr(invItem, 'typeID', '?unknown?'))
if invItem is not None and hasattr(invItem, 'typeID'):
log.LogError('Type is:', evetypes.GetName(invItem.typeID))
continue
model.name = '%s' % invItem.itemID
model.display = 0
model.scaling = (0.002, 0.002, 0.002)
addedObjects.append(model)
orbitRoot = trinity.EveTransform()
orbitRoot.children.append(model)
inclinationRoot = trinity.EveTransform()
inclinationRoot.children.append(orbitRoot)
orbitalInclination = orbitalObjectID / math.pi % (
math.pi / 4.0) - math.pi / 8.0
if orbitalInclination <= 0.0:
orbitalInclination -= math.pi / 8.0
else:
orbitalInclination += math.pi / 8.0
inclinationRoot.rotation = geo2.QuaternionRotationSetYawPitchRoll(
0.0, orbitalInclination, 0.0)
rotationCurveSet = trinity.TriCurveSet()
rotationCurveSet.playOnLoad = False
rotationCurveSet.Stop()
rotationCurveSet.scaledTime = 0.0
rotationCurveSet.scale = 0.25
orbitRoot.curveSets.append(rotationCurveSet)
ypr = trinity.TriYPRSequencer()
ypr.YawCurve = trinity.TriScalarCurve()
ypr.YawCurve.extrapolation = trinity.TRIEXT_CYCLE
ypr.YawCurve.AddKey(0.0, 0.0, 0.0, 0.0, trinity.TRIINT_LINEAR)
ypr.YawCurve.AddKey(200.0, 360.0, 0.0, 0.0, trinity.TRIINT_LINEAR)
ypr.YawCurve.Sort()
rotationCurveSet.curves.append(ypr)
binding = trinity.TriValueBinding()
binding.sourceObject = ypr
binding.sourceAttribute = 'value'
binding.destinationObject = orbitRoot
binding.destinationAttribute = 'rotation'
rotationCurveSet.bindings.append(binding)
rotationCurveSet.Play()
model.translation = (0.0, 0.0, 1500.0)
model.rotation = geo2.QuaternionRotationSetYawPitchRoll(
math.pi, 0.0, 0.0)
scene.objects.append(inclinationRoot)
ls = trinity.EveCurveLineSet()
ls.scaling = (1.0, 1.0, 1.0)
tex2D1 = trinity.TriTextureParameter()
tex2D1.name = 'TexMap'
tex2D1.resourcePath = 'res:/UI/Texture/Planet/link.dds'
ls.lineEffect.resources.append(tex2D1)
tex2D2 = trinity.TriTextureParameter()
tex2D2.name = 'OverlayTexMap'
tex2D2.resourcePath = 'res:/UI/Texture/Planet/link.dds'
ls.lineEffect.resources.append(tex2D2)
lineColor = (1.0, 1.0, 1.0, 0.05)
p1 = SurfacePoint(0.0, 0.0, -1500.0, 1000.0)
p2 = SurfacePoint(5.0, 0.0, 1498.0, 1000.0)
l1 = ls.AddSpheredLineCrt(p1.GetAsXYZTuple(), lineColor,
p2.GetAsXYZTuple(), lineColor,
(0.0, 0.0, 0.0), 3.0)
p1 = SurfacePoint(0.0, 0.0, -1500.0, 1000.0)
p2 = SurfacePoint(-5.0, 0.0, 1498.0, 1000.0)
l2 = ls.AddSpheredLineCrt(p1.GetAsXYZTuple(), lineColor,
p2.GetAsXYZTuple(), lineColor,
(0.0, 0.0, 0.0), 3.0)
animationColor = (0.3, 0.3, 0.3, 0.5)
ls.ChangeLineAnimation(l1, animationColor, 0.25, 1.0)
ls.ChangeLineAnimation(l2, animationColor, -0.25, 1.0)
ls.ChangeLineSegmentation(l1, 100)
ls.ChangeLineSegmentation(l2, 100)
ls.SubmitChanges()
orbitRoot.children.append(ls)
trinity.WaitForResourceLoads()
for model in addedObjects:
model.display = 1
def DrawDirectionalScanCone(self):
scanAngle = self.scanAngle
scanRange = float(self.scanRange)
systemMapHandler = self.systemMapHandler
if not systemMapHandler:
return
if self.dScanLineSet is None:
self.dScanTransform = trinity.EveTransform()
self.dScanTransform.name = 'dScanTransform'
systemMapHandler.systemMapTransform.children.append(self.dScanTransform)
systemMapHandler.SetupMyPositionTracker(self.dScanTransform)
self.dScanSubTransform = trinity.EveTransform()
self.dScanSubTransform.name = 'dScanSubTransform'
self.dScanSubTransform.display = GetScanConeDisplayState()
self.dScanTransform.children.append(self.dScanSubTransform)
scanCone = trinity.Load('res:/dx9/model/UI/scancone.red')
scanCone.rotation = geo2.QuaternionRotationSetYawPitchRoll(0.0, -math.pi / 2, 0.0)
self.dScanSubTransform.children.append(scanCone)
self.scanConeTransform = scanCone
scanConeHalf = trinity.Load('res:/dx9/model/UI/scanconehalfsphere.red')
self.dScanSubTransform.children.append(scanConeHalf)
self.scanConeHalfTransform = scanConeHalf
scanConeFull = trinity.Load('res:/dx9/model/UI/scanconesphere.red')
self.dScanSubTransform.children.append(scanConeFull)
self.scanConeFullTransform = scanConeFull
lineSet = CreatePlanarLineSet(texturePath='res:/dx9/texture/ui/linePlanarSmoothAdditive.dds')
lineSet.scaling = (self.lineSetScaling, self.lineSetScaling, self.lineSetScaling)
lineSet.rotation = geo2.QuaternionRotationSetYawPitchRoll(0.0, -math.pi / 2, 0.0)
lineSet.additive = True
self.dScanSubTransform.children.append(lineSet)
self.dScanLineSet = lineSet
blue.synchro.Yield()
self.SwitchToScanMode(GetActiveScanMode(), initing=True)
else:
lineSet = self.dScanLineSet
lineSet.ClearLines()
if scanAngle < 180.0:
scanAngleRad = math.radians(scanAngle)
scanAngleCos = math.cos(scanAngleRad * 0.5)
lineWidth = 5000.0
color = (0.1, 0.4, 0.6, 0.125)
centerLineDistance = AU
while centerLineDistance < scanRange:
step = centerLineDistance * scanAngleCos
radius = math.tan(scanAngleRad * 0.5) * step
lineIDs = mapViewUtil.DrawCircle(lineSet, (0, step / self.lineSetScaling, 0), radius / self.lineSetScaling, lineWidth=lineWidth, startColor=color, endColor=color)
centerLineDistance += const.AU
self.scanConeHalfTransform.display = False
self.scanConeFullTransform.display = False
z = scanRange * scanAngleCos
endCapAngle = scanAngleRad * 0.5
radius = scanRange * math.sin(endCapAngle)
self.scanConeTransform.scaling = (radius * 2, z, radius * 2)
self.scanConeTransform.display = True
elif scanAngle < 360.0:
self.scanConeTransform.display = False
self.scanConeFullTransform.display = False
self.scanConeHalfTransform.scaling = (-scanRange, -scanRange, -scanRange)
self.scanConeHalfTransform.display = True
else:
self.scanConeTransform.display = False
self.scanConeHalfTransform.display = False
self.scanConeFullTransform.scaling = (-scanRange, -scanRange, -scanRange)
self.scanConeFullTransform.display = True
lineSet.SubmitChanges()
def CreateLineSet(self):
scene = self.GetScene()
if not hasattr(scene, 'backgroundObjects'):
return
if not scene:
log.LogWarn('RouteVisualizer - No scene')
return
waypoints = sm.GetService('starmap').GetDestinationPath()
if None in waypoints:
return
lineSet = trinity.EveCurveLineSet()
lineSet.scaling = (1.0, 1.0, 1.0)
tex2D1 = trinity.TriTexture2DParameter()
tex2D1.name = 'TexMap'
tex2D1.resourcePath = 'res:/texture/global/lineSolid.dds'
lineSet.lineEffect.resources.append(tex2D1)
tex2D2 = trinity.TriTexture2DParameter()
tex2D2.name = 'OverlayTexMap'
tex2D2.resourcePath = 'res:/UI/Texture/Planet/link.dds'
lineSet.lineEffect.resources.append(tex2D2)
topTransform = trinity.EveTransform()
topTransform.name = 'Route'
topTransform.modifier = 2
transform = trinity.EveTransform()
topTransform.children.append(transform)
transform.name = 'AutoPilotRoute'
transform.children.append(lineSet)
scene.backgroundObjects.append(topTransform)
waypointDisplayCount = 15
here = sm.StartService('map').GetItem(session.solarsystemid)
if not here:
log.LogWarn('RouteVisualizer - No _here_')
return
itemInfo = []
for sid in waypoints:
if not util.IsSolarSystem(sid):
continue
item = sm.StartService('map').GetItem(sid)
position = (-item.x + here.x, -item.y + here.y, item.z - here.z)
position = geo2.Vec3Normalize(position)
position = geo2.Vec3Scale(position, 1000)
security = item.security
itemInfo.append((position, security))
waypointDisplayCount = 15
itemInfo = itemInfo[0:min(waypointDisplayCount, len(itemInfo))]
securityColors = sm.GetService('map').GetSecColorList()
baseAlpha = 0.25
for i, each in enumerate(itemInfo):
length = len(itemInfo)
if i < length - 1:
colorIndex1 = int(round(max(itemInfo[i][1], 0), 1) * 10)
color1 = securityColors[colorIndex1]
alpha1 = 1 - float(i) / len(itemInfo)
alpha1 *= baseAlpha
lineColor1 = (color1.r, color1.g, color1.b, alpha1)
colorIndex2 = int(round(max(itemInfo[i + 1][1], 0), 1) * 10)
color2 = securityColors[colorIndex2]
alpha2 = 1 - float(i + 1) / len(itemInfo)
alpha2 *= baseAlpha
lineColor2 = (color2.r, color2.g, color2.b, alpha2)
lineWidth = 3
l1 = lineSet.AddStraightLine(itemInfo[i][0], lineColor1,
itemInfo[i + 1][0], lineColor2,
lineWidth)
animationColor = (0.12, 0.12, 0.12, 0.6)
lineSet.ChangeLineAnimation(l1, animationColor, -0.35, 1)
lineSet.SubmitChanges()
self.route = topTransform
def __init__(self, probeID, probe, parent, scanner):
"""
Construct and load all graphic elements and resources
probeID: id of probe
probe: probe data KeyVal struct
parent: parent EveTransform to attach probe control to
"""
scanSvc = sm.GetService('scanSvc')
BaseProbeControl.__init__(self, probeID, parent)
sphereBracket = Bracket()
sphereBracket.align = uiconst.NOALIGN
sphereBracket.width = sphereBracket.height = 2
sphereBracket.state = uiconst.UI_DISABLED
sphereBracket.name = '__probeSphereBracket'
sphereBracket.trackTransform = self.locator
sphereBracket.probeID = probeID
sphereBracket.positionProbeID = probeID
uicore.layer.systemMapBrackets.children.insert(0, sphereBracket)
sphere = trinity.Load('res:/dx9/model/UI/Scanbubble.red')
sphere.name = 'Scanbubble'
sphere.children[0].scaling = (2.0, 2.0, 2.0)
sphere.children[0].children[0].scaling = (-50.0, 50.0, 50.0)
sphere.children[0].children[1].scaling = (50.0, 50.0, 50.0)
sphere.children[0].children[2].scaling = (50.0, 50.0, 50.0)
sphere.children[0].curveSets[1].curves[0].keys[1].time = 0.0625
sphere.children[0].curveSets[1].curves[0].Sort()
self.locator.children.append(sphere)
cal = trinity.EveTransform()
cal.name = 'cameraAlignedLocation'
cal.modifier = TR2TM_LOOK_AT_CAMERA
sphere.children.append(cal)
tracker = trinity.EveTransform()
tracker.name = 'pr_%d' % probe.probeID
val = math.sin(DegToRad(45.0)) * 0.2
translation = (val, val, 0.0)
tracker.translation = translation
cal.children.append(tracker)
bracket = ProbeBracket()
bracket.name = '__probeSphereBracket'
bracket.align = uiconst.NOALIGN
bracket.state = uiconst.UI_HIDDEN
bracket.width = bracket.height = 16
bracket.dock = False
bracket.minDispRange = 0.0
bracket.maxDispRange = 1e+32
bracket.inflight = False
bracket.color = None
bracket.invisible = False
bracket.fadeColor = False
bracket.showLabel = 2
bracket.probe = probe
bracket.probeID = probeID
bracket.displayName = scanSvc.GetProbeLabel(probeID)
bracket.showDistance = 0
bracket.noIcon = True
bracket.Startup(probeID, probe.typeID, None)
bracket.trackTransform = tracker
uicore.layer.systemMapBrackets.children.insert(0, bracket)
bracket.ShowLabel()
bracket.label.OnClick = None
bracket.label.state = uiconst.UI_HIDDEN
intersection = trinity.Load('res:/Model/UI/probeIntersection.red')
intersection.display = False
intersection.scaling = (2.0, 2.0, 2.0)
sphere.children.append(intersection)
self.bracket = bracket
self.scanRanges = scanSvc.GetScanRangeStepsByTypeID(probe.typeID)
self.intersection = intersection
self.sphere = sphere
self.cameraAlignedLocation = cal
self.probeID = probeID
self.scanrangeCircles = None
self._highlighted = True
self.HighlightBorder(0)
def CreateBracketTransform(self, translation):
tr = trinity.EveTransform()
tr.translation = translation
self.transform.children.append(tr)
return tr
