def LoadModel(self, fileName=None, loadedModel=None):
if self.typeID in ENVIRONMENTS:
self.LogInfo(
'Not loading dungeon environment (%s), since rework is pending.'
% self.typeID)
return
if not gfxsettings.Get(gfxsettings.UI_EFFECTS_ENABLED):
return
SpaceObject.LoadModel(self, fileName, loadedModel)
def Explode(self):
if not gfxsettings.Get(gfxsettings.UI_EXPLOSION_EFFECTS_ENABLED):
return False
explosionURL, (delay, scaling) = self.GetExplosionInfo()
return SpaceObject.Explode(self,
explosionURL=explosionURL,
managed=True,
delay=delay,
scaling=scaling)
def IsDroneModelEnabled(self):
"""
returns if we show this drone model
"""
groupID = self.typeData.get('groupID', None)
droneGroup = eveSpaceObject.droneGroupFromTypeGroup.get(groupID, None)
if droneGroup == eveSpaceObject.gfxDroneGroupNpc:
return True
return gfxsettings.Get(gfxsettings.UI_DRONE_MODELS_ENABLED)
def GetSpaceCamera(self):
if self.spaceCamera is None:
camera = blue.resMan.LoadObject('res:/dx9/scene/camera.red')
self._CreateErrorHandler(camera)
camera.noise = gfxsettings.Get(gfxsettings.UI_CAMERA_SHAKE_ENABLED)
evecamera.ApplyCameraDefaults(camera)
camera.audio2Listener = audio2.GetListener(0)
self.spaceCamera = camera
return self.spaceCamera
def _GetStationView(self):
view = settings.user.ui.Get('defaultDockingView', 'hangar')
if view == 'station' and not gfxsettings.Get(
gfxsettings.MISC_LOAD_STATION_ENV):
self.LogInfo(
'Docking into hangar because we have disabled the station environments'
)
view = 'hangar'
return view
def CreateDevice(self):
self.LogInfo('CreateDevice')
if '/safemode' in blue.pyos.GetArg():
self.SetToSafeMode()
triapp = trinity.app
triapp.title = uicore.triappargs['title']
triapp.minimumWidth = self.minimumSize['width']
triapp.minimumHeight = self.minimumSize['height']
triapp.width = triapp.minimumWidth
triapp.height = triapp.minimumHeight
triapp.hideTitle = 1
triapp.fullscreen = 0
triapp.Create()
dev = trinity.device
while not dev.DoesD3DDeviceExist():
try:
self.Initialize()
triapp = trinity.app
trinity.device.disableAsyncLoad = not bool(
settings.public.generic.Get('asyncLoad', 1))
self.SetResourceCacheSize()
dev.mipLevelSkipCount = gfxsettings.Get(
gfxsettings.GFX_TEXTURE_QUALITY)
trinity.SetShaderModel(self.GetAppShaderModel())
if not self.PrepareMain(True):
blue.os.Pump()
time.sleep(0.5)
continue
if trinity.adapters.SupportsDepthStencilFormat(
trinity.adapters.DEFAULT_ADAPTER,
trinity.adapters.GetCurrentDisplayMode(
trinity.adapters.DEFAULT_ADAPTER).format,
trinity.DEPTH_STENCIL_FORMAT.READABLE):
trinity.AddGlobalSituationFlags(['OPT_INTZ'])
else:
trinity.RemoveGlobalSituationFlags(['OPT_INTZ'])
try:
trinity.RebindAllShaderMaterials()
except:
pass
except trinity.D3DERR_NOTAVAILABLE as e:
sys.exc_clear()
trinity.adapters.Refresh()
except trinity.ALDeviceNotAvailable as e:
sys.exc_clear()
trinity.adapters.Refresh()
if not blue.sysinfo.isTransgaming:
resizeEventHandler = blue.BlueEventToPython()
resizeEventHandler.handler = self.HandleResizeEvent
triapp.resizeEventListener = resizeEventHandler
for k, v in self.GetAppSettings().iteritems():
trinity.settings.SetValue(k, v)
for dir in self.GetAppMipLevelSkipExclusionDirectories():
trinity.AddMipLevelSkipExclusionDirectory(dir)
def Assemble(self):
timecurves.ScaleTime(self.model, 0.9 + random.random() * 0.2)
self.SetStaticRotation()
raceName = self.typeData.get('sofRaceName', None)
if raceName is not None:
self.turretTypeID = TURRET_TYPE_ID.get(raceName,
TURRET_FALLBACK_TYPE_ID)
if gfxsettings.Get(gfxsettings.UI_TURRETS_ENABLED):
self.FitHardpoints()
def UpdateCameraOffset(self):
offset = gfxsettings.Get(gfxsettings.UI_CAMERA_OFFSET) / 10.0
offsetBehaviors = []
for cam in self.cameraStack:
offsetBehavior = cam.GetBehavior(cameras.CharacterOffsetBehavior)
if offsetBehavior:
offsetBehaviors.append(offsetBehavior)
for offsetBehavior in offsetBehaviors:
offsetBehavior.AdjustOffset(offset)
def Run(self, memStream=None):
service.Service.Run(self, memStream)
self.lock = locks.RLock()
self.disabledGuids = settings.user.ui.Get('disabledGuids', {})
self.sequencerTasklet = uthread.new(self.SequencerLoop)
self.sequencerTasklet.context = 'FxSequencer::SequencerLoop'
if gfxsettings.Get(gfxsettings.UI_TURRETS_ENABLED):
self.EnableGuids(FX_TURRET_EFFECT_GUIDS)
else:
self.DisableGuids(FX_TURRET_EFFECT_GUIDS)
candidateEffects = []
for guid in cfg.GetEffectGuids():
if guid not in FX_TURRET_EFFECT_GUIDS and guid not in FX_PROTECTED_EFFECT_GUIDS:
candidateEffects.append(guid)
if gfxsettings.Get(gfxsettings.UI_EFFECTS_ENABLED):
self.EnableGuids(candidateEffects)
else:
self.DisableGuids(candidateEffects)
def GetCameraLeftOffset(self, width, align=None, left=0, *args):
try:
offsetUI = gfxsettings.Get(gfxsettings.UI_OFFSET_UI_WITH_CAMERA)
except gfxsettings.UninitializedSettingsGroupError:
offsetUI = False
if not offsetUI:
return 0
offset = int(gfxsettings.Get(gfxsettings.UI_CAMERA_OFFSET))
if not offset:
return 0
if align in [uiconst.CENTER, uiconst.CENTERTOP, uiconst.CENTERBOTTOM]:
camerapush = int(offset / 100.0 * uicore.desktop.width / 3.0)
allowedOffset = int((uicore.desktop.width - width) / 2) - 10
if camerapush < 0:
return max(camerapush, -allowedOffset - left)
if camerapush > 0:
return min(camerapush, allowedOffset + left)
return 0
def SetCameraOffset(self, camera):
cameraOffsetOverride = self.cameraOffsetOverride
if cameraOffsetOverride:
camera.centerOffset = cameraOffsetOverride * -0.01
else:
camera.centerOffset = gfxsettings.Get(
gfxsettings.UI_CAMERA_OFFSET) * -0.01
defaultCamera = self.GetRegisteredCamera('default')
if defaultCamera and camera is defaultCamera:
sm.ScatterEvent('OnSetCameraOffset', camera, camera.centerOffset)
def EnableGodRays(self, enable):
self.useGodRays = enable
if self.godRaysLoaded == enable and gfxsettings.Get(gfxsettings.UI_GODRAYS) == self.godRaysLoaded:
return
if self.lensflare is None:
return
if not self.released:
self.ReleaseSun()
self.LoadModel()
self.Assemble()
def _GetSettings(self):
"""
Returns a dictionary of settings keys and their values.
The required keys and value combinations are:
- hdrEnabled : True, False
- postProcessingQuality : 0 to 2
- shadowQuality : 0 to 2
- aaQuality : 0 to 3
"""
currentSettings = {}
currentSettings['hdrEnabled'] = gfxsettings.Get(
gfxsettings.GFX_HDR_ENABLED)
currentSettings['postProcessingQuality'] = gfxsettings.Get(
gfxsettings.GFX_POST_PROCESSING_QUALITY)
currentSettings['shadowQuality'] = gfxsettings.Get(
gfxsettings.GFX_SHADOW_QUALITY)
currentSettings['aaQuality'] = gfxsettings.Get(
gfxsettings.GFX_ANTI_ALIASING)
return currentSettings
def CheckCameraOffsets(self):
offset = gfxsettings.Get(gfxsettings.UI_INCARNA_CAMERA_OFFSET)
offsetBehaviors = []
for cam in self.cameraStack:
offsetBehavior = cam.GetBehavior(cameras.CharacterOffsetBehavior)
if offsetBehavior:
offsetBehaviors.append(offsetBehavior)
for offsetBehavior in offsetBehaviors:
offsetBehavior.AdjustOffset(offset)
def Assemble(self):
slimItem = sm.StartService('michelle').GetBallpark().GetInvItem(
self.id)
godmaStateManager = sm.StartService('godma').GetStateManager()
godmaType = godmaStateManager.GetType(slimItem.typeID)
self.turretTypeID = godmaType.gfxTurretID
self.typeID = slimItem.typeID
if gfxsettings.Get(
gfxsettings.UI_TURRETS_ENABLED) and self.IsAnchored():
self.FitHardpoints()
def _RefreshAntiAliasing(self):
if 'aaQuality' not in self.overrideSettings:
self.antiAliasingQuality = self.aaQuality = gfxsettings.Get(
gfxsettings.GFX_ANTI_ALIASING)
self.msaaType = self._GetMSAATypeFromQuality(self.antiAliasingQuality)
self.fxaaQuality = self._GetFXAAQuality(self.antiAliasingQuality)
if self.useFXAA:
self.EnableFXAA(self.antiAliasingEnabled)
else:
self.EnableMSAA(self.antiAliasingEnabled)
def _SetupUniverseStars(self, scene, solarsystemID):
if gfxsettings.Get(
gfxsettings.UI_EFFECTS_ENABLED) and solarsystemID is not None:
universe = self._GetSharedResource(
'res:/dx9/scene/starfield/universe.red')
scene.backgroundObjects.append(universe)
here = sm.GetService('map').GetItem(solarsystemID)
if here:
scale = 10000000000.0
position = (here.x / scale, here.y / scale, -here.z / scale)
universe.children[0].translation = position
def Run(self, *etc):
PaperDollClient.Run(self, *etc)
doKick = False
try:
self.LogInfo('Early loading of paperDoll asset data requested, station environments enabled')
doKick = gfxsettings.Get(gfxsettings.MISC_LOAD_STATION_ENV)
except NameError:
doKick = True
if doKick:
kicker = self.dollFactory
def Orbit(self, dx=0, dy=0):
if not self.orbitTarget:
self.orbitTarget = (0, self.GetAngleLookAtToUpDirection())
if gfxsettings.Get(gfxsettings.UI_CAMERA_INVERT_Y):
dy *= -1
yaw = self.orbitTarget[0] - dx
pitch = self.orbitTarget[1] - dy / 2.0
pitch = self.ClampPitch(pitch)
self.orbitTarget = [yaw, pitch]
if not self.orbitUpdateThread:
self.orbitUpdateThread = uthread.new(self.OrbitUpdateThread)
def LoadScene(self, sceneContainer):
sceneContainer.PrepareInteriorScene(backgroundImage=self.background)
apparel = GetPaperDollResource(self.typeID, gender=self.gender)
if apparel is None:
raise InvalidPreviewType(
'%s (%s) does not have an associated paper doll resource' %
(evetypes.GetName(self.typeID), self.typeID))
factory = pd.Factory()
mannequin = pd.PaperDollCharacter(factory)
self.mannequin = mannequin
dollGender = GenderIDToPaperDollGender(apparel.resGender)
mannequin.doll = pd.Doll('mannequin', gender=dollGender)
mannequin.doll.Load(MANNEQUIN_RES_BY_GENDER[dollGender], factory)
mannequin.WaitForUpdate()
textureQuality = gfxsettings.Get(gfxsettings.GFX_CHAR_TEXTURE_QUALITY)
resolution = ccConst.TEXTURE_RESOLUTIONS[textureQuality]
mannequin.doll.textureResolution = resolution
mannequin.doll.overrideLod = 0
mannequin.Spawn(sceneContainer.scene, usePrepass=False)
mannequin.WaitForUpdate()
with CaptureDollMeshChanges(mannequin.doll) as meshes:
mannequin.doll.SetItemType(factory, apparel.resPath)
typeData = factory.GetItemType(apparel.resPath, gender=dollGender)
apparelCategory = sm.GetService(
'character').GetCategoryFromResPath(typeData[0])
coveringCategories = PAPERDOLL_CATEGORIES_COVERING.get(
apparelCategory, [])
for category in coveringCategories:
mannequin.doll.buildDataManager.RemoveMeshContainingModifiers(
category)
mannequin.Update()
mannequin.WaitForUpdate()
newMeshes = set(filter(lambda m: m not in meshes.before, meshes.after))
assetGroupID = evetypes.GetGroupID(self.typeID)
meshNameCheck = lambda mesh: any(
map(lambda name: mesh.name.startswith(name), MESH_NAMES_BY_GROUPID[
assetGroupID]))
groupMeshes = set(filter(meshNameCheck, meshes.after))
boundingBoxes = map(lambda m: m.geometry.GetBoundingBox(0),
newMeshes | groupMeshes)
if len(boundingBoxes) == 0:
aabb = mannequin.visualModel.GetBoundingBoxInLocalSpace()
else:
aabb = reduce(MergeBoundingBoxes, boundingBoxes)
animationRes = 'res:/Animation/MorphemeIncarna/Export/Mannequin/Mannequin.mor'
animationUpdater = GWAnimation(animationRes)
if animationUpdater is not None:
animationSetIndex = 0 if dollGender == pd.GENDER.FEMALE else 1
animationUpdater.network.SetAnimationSetIndex(animationSetIndex)
mannequin.avatar.animationUpdater = animationUpdater
floorShadow = trinity.Load(ccConst.CUSTOMIZATION_FLOOR)
sceneContainer.scene.dynamics.append(floorShadow)
SetupInteriourCamera(sceneContainer, aabb)
def CreateSteps(self):
"""
Rebuild this renderjob. If the job has not been prepared it will be empty.
"""
if not self.prepared:
return
self.ClearSteps()
if self.liveCount < 1:
return
if self.source.width < 1 or self.source.height < 1:
return
postProcesses = []
for each in self.postProcesses:
ppKey = getattr(each, 'key', None)
if each is not None and each.name == PP_GROUP_FOG:
if gfxsettings.Get(gfxsettings.GFX_SHADER_QUALITY
) != gfxsettings.SHADER_MODEL_HIGH:
continue
if each is not None and (ppKey is None or ppKey == self.key):
postProcesses.append(each)
if self.destination is not None:
self._AppendStep('Push Destination RT',
trinity.TriStepPushRenderTarget(self.destination))
if len(postProcesses) > 1:
self._AppendStep('Push Source RT',
trinity.TriStepPushRenderTarget(self.source))
self._AppendStep('Push null depth stencil',
trinity.TriStepPushDepthStencil(None))
if self.resolveTarget is not None:
self._AppendStep(
'Resolve render target',
trinity.TriStepResolve(self.resolveTarget, self.source))
self._AppendStep('Set render states',
trinity.TriStepSetStdRndStates(trinity.RM_FULLSCREEN))
value = (1.0 / self.source.width, 1.0 / self.source.height,
self.source.width, self.source.height)
self._AppendStep('Set var texelSize',
trinity.TriStepSetVariableStore('g_texelSize', value))
for pp in postProcesses:
if pp == postProcesses[-1] and len(postProcesses) > 1:
self._AppendStep('Pop source RT',
trinity.TriStepPopRenderTarget())
self._DoPostProcess(pp, self.resolveTarget)
if pp != postProcesses[-1] and self.resolveTarget is not None:
self._AppendStep(
'Resolve render target',
trinity.TriStepResolve(self.resolveTarget, self.source))
if self.destination is not None:
self._AppendStep('Pop destination RT',
trinity.TriStepPopRenderTarget())
self._AppendStep('Restore depth stencil',
trinity.TriStepPopDepthStencil())
def __init__(self):
CameraBase.__init__(self)
sm.RegisterNotify(self)
self.ResetConfiguration()
self.noise = gfxsettings.Get(gfxsettings.UI_CAMERA_SHAKE_ENABLED)
self.UpdateCameraBobbing()
self.checkDistToEgoThread = None
self.cachedCameraTranslation = -1
self.shakeController = shaker.ShakeController(self)
self.animationController = camanim.AnimationController(self)
self.lookingAt = None
def OnGraphicSettingsChanged(self, changes):
self.incarnaRenderJob.SetSettingsBasedOnPerformancePreferences()
self.fisRenderJob.SetSettingsBasedOnPerformancePreferences()
self.characterRenderJob.SetSettingsBasedOnPerformancePreferences()
if self.secondaryJob is not None:
self.secondaryJob.renderJob.SetSettingsBasedOnPerformancePreferences(
)
for each in self.registeredJobs:
each.object.SetSettingsBasedOnPerformancePreferences()
if gfxsettings.GFX_INTERIOR_GRAPHICS_QUALITY in changes or gfxsettings.GFX_CHAR_CLOTH_SIMULATION in changes:
self.ApplyClothSimulationSettings()
if gfxsettings.GFX_LOD_QUALITY in changes:
limit = gfxsettings.Get(gfxsettings.GFX_LOD_QUALITY) * 30
self.explosionManager.SetLimit(limit)
if gfxsettings.UI_CAMERA_OFFSET in changes:
self.CheckCameraOffsets()
if gfxsettings.UI_INCARNA_CAMERA_OFFSET in changes:
sm.GetService('cameraClient').CheckCameraOffsets()
if gfxsettings.UI_INCARNA_CAMERA_MOUSE_LOOK_SPEED in changes:
sm.GetService('cameraClient').CheckMouseLookSpeed()
if gfxsettings.MISC_LOAD_STATION_ENV in changes:
val = gfxsettings.Get(gfxsettings.MISC_LOAD_STATION_ENV)
if sm.GetService('viewState').IsViewActive('hangar') and not val:
sm.GetService('station').ReloadLobby()
if session.userid is not None:
effectsEnabled = gfxsettings.Get(gfxsettings.UI_EFFECTS_ENABLED)
if gfxsettings.UI_TRAILS_ENABLED in changes or gfxsettings.UI_EFFECTS_ENABLED in changes:
trailsEnabled = effectsEnabled and gfxsettings.Get(
gfxsettings.UI_TRAILS_ENABLED)
trinity.settings.SetValue('eveSpaceObjectTrailsEnabled',
trailsEnabled)
if gfxsettings.UI_GPU_PARTICLES_ENABLED in changes or gfxsettings.UI_EFFECTS_ENABLED in changes:
gpuParticlesEnabled = effectsEnabled and gfxsettings.Get(
gfxsettings.UI_GPU_PARTICLES_ENABLED)
trinity.settings.SetValue('gpuParticlesEnabled',
gpuParticlesEnabled)
if gfxsettings.UI_GODRAYS in changes:
scene = self.GetRegisteredScene('default')
if scene is not None and scene.sunBall is not None:
scene.sunBall.HandleGodraySetting()
def SetResourceCacheSize(self):
"""
Sets the resource cache size according to prefs settings providing it has been turned on by the user
* Texture Quality: Low -> OFF
* Texture Quality: Medium -> 32 MB
* Texture Quality: High -> 128 MB
"""
cacheSize = 1
if gfxsettings.Get(gfxsettings.MISC_RESOURCE_CACHE_ENABLED):
textureQuality = gfxsettings.Get(gfxsettings.GFX_TEXTURE_QUALITY)
if textureQuality == 2:
cacheSize = 1
elif textureQuality == 1:
cacheSize = 32
else:
cacheSize = 128
self.LogInfo('Setting resource cache size to', cacheSize, 'MB')
MEG = 1048576
finalSize = cacheSize * MEG
blue.motherLode.maxMemUsage = finalSize
return finalSize
def GetGodRaysIntensityParam(self):
if not self.useGodRays:
return
if self.lensflare is None:
return
if not gfxsettings.Get(gfxsettings.UI_GODRAYS):
return
for area in self.lensflare.mesh.additiveAreas:
if area.effect.effectFilePath.endswith('godrays.fx'):
for param in area.effect.parameters:
if param.name == 'Intensity':
return param
def Explode(self):
if not self.IsDroneModelEnabled() or not gfxsettings.Get(
gfxsettings.UI_EXPLOSION_EFFECTS_ENABLED):
return False
if self.exploded:
return
while self.squadronSize > 0:
self.DestroyFighter()
self.squadronSize -= 1
self.exploded = True
return False
def Assemble(self):
if self.ballpark is None:
return
registry = self._GetComponentRegistry()
if not IsActiveComponent(registry, self.typeID, self.id):
self.TriggerAnimation('idle')
registry.SubscribeToItemMessage(self.id, MSG_ON_ACTIVATE_TIMER_UPDATED, self.ActivateTimerUpdate)
else:
self.TriggerAnimation('active')
if gfxsettings.Get(gfxsettings.UI_TURRETS_ENABLED):
self.FitHardpoints()
self.SetupSharedAmbientAudio()
def HandleAsteroidParticles(self):
if not (gfxsettings.Get(gfxsettings.UI_ASTEROID_ATMOSPHERICS)
and gfxsettings.Get(gfxsettings.UI_ASTEROID_PARTICLES)):
return
scene = self.GetScene()
if scene is None:
return
if len(self.asteroids) == 0:
scene.staticParticles.ClearClusters()
return
particles = scene.staticParticles
if particles.transform is None:
particles.transform = trinity.Load(
'res:/dx9/scene/asteroidrockfield.red')
particles.maxParticleCount = 50000
particles.maxSize = 100.0
particles.minSize = 5.0
particles.clusterParticleDensity = 1.0
for id, asteroid in self.asteroids.iteritems():
ball, slimItem, isAdded = asteroid
if isAdded:
continue
self.asteroids[id] = (ball, slimItem, True)
groupData = cfg.groupGraphics.get(int(slimItem.groupID), None)
color = getattr(groupData, 'color', None)
baseColor = (0.13, 0.13, 0.12, 1.0)
if color is None:
if hasattr(groupData, 'typeIDs'):
typeData = groupData.typeIDs.get(int(slimItem.typeID),
None)
color = typeData.color
baseColor = (0.4, 0.6, 0.7, 1.0)
if color is None:
continue
seed = int(id % 123456)
particles.AddCluster((ball.x, ball.y, ball.z), ball.radius,
(color.r, color.g, color.b, color.a),
baseColor, seed)
particles.Rebuild()
def CreateRenderTarget(self):
textureQuality = gfxsettings.Get(gfxsettings.GFX_TEXTURE_QUALITY)
self.maxSizeLimit = size = self.maxSize >> textureQuality
rt = None
while rt is None or not rt.isValid:
rt = trinity.Tr2RenderTarget(2 * size, size, 0, self.format)
if not rt.isValid:
if size < 2:
return
self.maxSizeLimit = size = size / 2
rt = None
return rt
def CreateRenderTarget(self):
textureQuality = gfxsettings.Get(gfxsettings.GFX_TEXTURE_QUALITY)
size = PLANET_TEXTURE_SIZE >> textureQuality
rt = None
while rt is None or not rt.isValid:
rt = trinity.Tr2RenderTarget(2 * size, size, 0, trinity.PIXEL_FORMAT.B8G8R8A8_UNORM)
if not rt.isValid:
if size < 2:
return
size = size / 2
rt = None
return (rt, size)
