NovaBryan/EVE_Dump
Log | Files | 📦 下载最新源码 (.zip) | Refs | README

desktop.py (16708B)


      1 #Embedded file name: C:\BuildAgent\work\20d73f1b24eed06e\eve\release\V24.01\packages\carbonui\primitives\desktop.py
      2 import blue
      3 import geo2
      4 import trinity
      5 from carbonui import uiconst
      6 from carbonui.control.layer import LayerCore
      7 from carbonui.primitives.container import Container
      8 from carbonui.uicore import uicore
      9 
     10 class UIRoot(Container):
     11     __renderObject__ = trinity.Tr2Sprite2dScene
     12     default_name = 'root'
     13     default_clearBackground = False
     14     default_backgroundColor = (0, 0, 0, 1)
     15     default_isFullscreen = True
     16     default_align = uiconst.ABSOLUTE
     17     default_state = uiconst.UI_NORMAL
     18     default_dpiScaling = 1.0
     19     default_doesTakeFocus = True
     20     default_glowEnabled = False
     21     default_glowBrightness = 1.0
     22     default_glowDistortion = 0.0
     23     default_glowHighlightRadius = 200.0
     24     default_glowHighlightBrightness = 3.0
     25     _rotationX = 0.0
     26     _rotationY = 0.0
     27     _rotationZ = 0.0
     28 
     29     def ApplyAttributes(self, attributes):
     30         Container.ApplyAttributes(self, attributes)
     31         renderTarget = attributes.renderTarget
     32         depthMax = attributes.depthMax
     33         depthMin = attributes.depthMin
     34         if depthMax or depthMin:
     35             self.depthMin = depthMin
     36             self.depthMax = depthMax
     37             myScene = self.GetRenderObject()
     38             myScene.is2dRender = False
     39             myScene.is2dPick = False
     40             self.InitCamera()
     41         else:
     42             self.depthMin = 0
     43             self.depthMax = 0
     44             self.camera = None
     45         self.isFullscreen = attributes.isFullscreen if attributes.isFullscreen is not None else self.default_isFullscreen
     46         self.clearBackground = attributes.clearBackground if attributes.clearBackground is not None else self.default_clearBackground
     47         self.backgroundColor = attributes.backgroundColor or self.default_backgroundColor
     48         self._dpiScaling = attributes.dpiScaling or self.default_dpiScaling
     49         self.doesTakeFocus = attributes.doesTakeFocus if attributes.doesTakeFocus is not None else self.default_doesTakeFocus
     50         self.sceneObject = None
     51         self.renderTargetStep = None
     52         self.generateMipsStep = None
     53         self.renderSteps = []
     54         self._glowRenderTarget = None
     55         self._blurRenderTarget0 = None
     56         self._blurRenderTarget1 = None
     57         self._glowProcessStep = None
     58         self._glowTransform = None
     59         self._glowTargetSteps = []
     60         self._glowEnabled = attributes.glowEnabled if attributes.glowEnabled is not None else self.default_glowEnabled
     61         self._glowBrightness = self.default_glowBrightness
     62         self._glowDistortion = self.default_glowDistortion
     63         self._glowHighlightRadius = self.default_glowHighlightRadius
     64         self._glowHighlightBrightness = self.default_glowHighlightBrightness
     65         self._glowHighlightCoords = (0, 0)
     66         self._renderJob = attributes.renderJob
     67         if self._renderJob:
     68             self.ConstructRenderSteps(depthMax, self._renderJob, renderTarget)
     69 
     70     def _GetRenderTarget(self):
     71         if self.renderTargetStep:
     72             return self.renderTargetStep.renderTarget
     73 
     74     def _RefreshGlowTargets(self, renderTarget):
     75         self._ConstructGlowTargets(renderTarget)
     76         if self._glowProcessStep:
     77             self._glowProcessStep.job = self._ConstructGlowRenderJob()
     78         for each in self._glowTargetSteps:
     79             each.renderTarget = self._glowRenderTarget
     80 
     81     def _ConstructGlowTargets(self, renderTarget):
     82         if not self._glowEnabled:
     83             self._glowRenderTarget = None
     84             self._blurRenderTarget0 = None
     85             self._blurRenderTarget1 = None
     86             return
     87         if renderTarget:
     88             width, height = renderTarget.width, renderTarget.height
     89             fmt = renderTarget.format
     90         else:
     91             width, height = trinity.device.width, trinity.device.height
     92             fmt = trinity.PIXEL_FORMAT.B8G8R8A8_UNORM
     93         self._glowRenderTarget = trinity.Tr2RenderTarget(width, height, 1, fmt)
     94         self._glowRenderTarget.name = 'UI Glow Target'
     95         self._blurRenderTarget0 = trinity.Tr2RenderTarget(width / 2, height / 2, 1, trinity.PIXEL_FORMAT.B8G8R8A8_UNORM)
     96         self._blurRenderTarget0.name = 'UI Glow Blur Target 0'
     97         self._blurRenderTarget1 = trinity.Tr2RenderTarget(width / 2, height / 2, 1, trinity.PIXEL_FORMAT.B8G8R8A8_UNORM)
     98         self._blurRenderTarget1.name = 'UI Glow Blur Target 1'
     99 
    100     def _ConstructGlowRenderJob(self):
    101         targets = [self._blurRenderTarget0, self._blurRenderTarget1]
    102         glowRJ = trinity.CreateRenderJob()
    103         glowRJ.name = 'Glow'
    104         glowRJ.PushRenderTarget().name = 'Save RT'
    105         glowRJ.SetStdRndStates(trinity.RM_FULLSCREEN)
    106         glowRJ.SetRenderTarget(targets[0])
    107 
    108         def param(name, value):
    109             if isinstance(value, float):
    110                 p = trinity.Tr2FloatParameter()
    111             else:
    112                 p = trinity.Tr2Vector2Parameter()
    113             p.name = name
    114             p.value = value
    115             return p
    116 
    117         glow = trinity.Tr2Effect()
    118         glow.StartUpdate()
    119         glow.effectFilePath = 'res:/graphics/effect/ui/glowtransform.fx'
    120         glow.resources.append(trinity.Tr2RuntimeTextureParameter('GlowMap', self._glowRenderTarget))
    121         glow.parameters.append(param('GlowSize', (self._glowRenderTarget.width, self._glowRenderTarget.height)))
    122         glow.parameters.append(param('DistortionStrength', self._glowDistortion))
    123         glow.parameters.append(param('Brightness', self._glowBrightness))
    124         glow.parameters.append(param('HighlightRadius', self._glowHighlightRadius))
    125         glow.parameters.append(param('HighlightBrightness', self._glowHighlightBrightness))
    126         glow.parameters.append(param('HighlightCoords', self._glowHighlightCoords))
    127         glow.EndUpdate()
    128         self._glowTransform = glow
    129         glowRJ.RenderEffect(glow).name = 'Transform Glow'
    130         glowRJ.SetRenderTarget(targets[1])
    131         blur = trinity.Tr2Effect()
    132         blur.StartUpdate()
    133         blur.effectFilePath = 'res:/graphics/effect/ui/glowblur.fx'
    134         blur.resources.append(trinity.Tr2RuntimeTextureParameter('InputMap', targets[0]))
    135         blur.constParameters.append(('InputMapSize', (targets[0].width,
    136           targets[0].height,
    137           0,
    138           0)))
    139         blur.EndUpdate()
    140         glowRJ.RenderEffect(blur).name = 'Blur Horiz'
    141         glowRJ.SetRenderTarget(targets[0])
    142         blur = trinity.Tr2Effect()
    143         blur.StartUpdate()
    144         blur.effectFilePath = 'res:/graphics/effect/ui/glowblur.fx'
    145         blur.resources.append(trinity.Tr2RuntimeTextureParameter('InputMap', targets[1]))
    146         blur.constParameters.append(('InputMapSize', (targets[1].width,
    147           targets[1].height,
    148           0,
    149           0)))
    150         blur.constParameters.append(('Direction', (0, 1, 0, 0)))
    151         blur.EndUpdate()
    152         glowRJ.RenderEffect(blur).name = 'Blur Vert'
    153         glowRJ.PopRenderTarget().name = 'Restore RT'
    154         composite = trinity.Tr2Effect()
    155         composite.StartUpdate()
    156         composite.effectFilePath = 'res:/graphics/effect/ui/glowcomposite.fx'
    157         composite.resources.append(trinity.Tr2RuntimeTextureParameter('GlowMap', targets[0]))
    158         composite.EndUpdate()
    159         glowRJ.RenderEffect(composite).name = 'Composite Glow'
    160         return glowRJ
    161 
    162     def ConstructRenderSteps(self, depthMax, renderJob, renderTarget):
    163         myScene = self.GetRenderObject()
    164         viewportStep = renderJob.SetViewport()
    165         viewportStep.name = 'Set fullscreen viewport'
    166         updateStep = renderJob.Update(myScene)
    167         updateStep.name = self.name + ' Update'
    168         renderSteps = [viewportStep, updateStep]
    169         self._ConstructGlowTargets(renderTarget)
    170         if depthMax:
    171             cameraUpdateStep = renderJob.PythonCB(self.camera)
    172             cameraUpdateStep.name = self.name + ' Camera Update'
    173             self.viewStep = renderJob.SetView(self.camera.viewMatrix)
    174             self.projStep = renderJob.SetProjection(self.camera.projectionMatrix)
    175             renderSteps.append(cameraUpdateStep)
    176             renderSteps.append(self.viewStep)
    177             renderSteps.append(self.projStep)
    178         if renderTarget:
    179             self.renderTargetStep = renderJob.PushRenderTarget(renderTarget)
    180             renderSteps.append(self.renderTargetStep)
    181             myScene.clearBackground = True
    182             myScene.backgroundColor = (0, 0, 0, 1)
    183         if self._glowRenderTarget:
    184             push = renderJob.PushRenderTarget(self._glowRenderTarget)
    185             renderSteps.append(push)
    186             self._glowTargetSteps.append(push)
    187             renderSteps.append(renderJob.Clear((0, 0, 0, 0)))
    188             renderSteps.append(renderJob.PopRenderTarget())
    189             push = renderJob.PushRenderTarget(self._glowRenderTarget, 1)
    190             renderSteps.append(push)
    191             self._glowTargetSteps.append(push)
    192         renderStep = renderJob.RenderScene(myScene)
    193         renderStep.name = self.name + ' Render'
    194         renderSteps.append(renderStep)
    195         if self._glowRenderTarget:
    196             renderSteps.append(renderJob.PopRenderTarget(1))
    197             glowRJ = self._ConstructGlowRenderJob()
    198             self._glowProcessStep = renderJob.RunJob(glowRJ)
    199             self._glowProcessStep.name = 'Process Glow'
    200             renderSteps.append(self._glowProcessStep)
    201         if renderTarget and type(renderTarget) is trinity.Tr2RenderTarget:
    202             renderSteps.append(renderJob.PopRenderTarget())
    203             self.generateMipsStep = renderJob.GenerateMipMaps(renderTarget)
    204             renderSteps.append(self.generateMipsStep)
    205         self.renderSteps = renderSteps
    206 
    207     def SetRenderTarget(self, renderTarget):
    208         if self.renderTargetStep is not None:
    209             self.renderTargetStep.renderTarget = renderTarget
    210         if self.generateMipsStep is not None:
    211             self.generateMipsStep.renderTarget = renderTarget
    212         self._RefreshGlowTargets(renderTarget)
    213 
    214     def InitCamera(self):
    215         pass
    216 
    217     def GetCamera(self):
    218         return self.camera
    219 
    220     def Create3DRenderTarget(self, destscene):
    221         sprite = blue.resMan.LoadObject('res:/uicore/uiInSpace.red')
    222         area = sprite.mesh.opaqueAreas[0]
    223         texture = area.effect.resources[0]
    224         destscene.objects.append(sprite)
    225         rj = trinity.CreateRenderJob()
    226         rj.Update(destscene)
    227         myScene = self.GetRenderObject()
    228         renderTarget = trinity.Tr2RenderTarget(self.width, self.height, 1, trinity.PIXEL_FORMAT.B8G8R8A8_UNORM)
    229         rj.PushRenderTarget(renderTarget)
    230         rj.RenderScene(myScene).name = 'Render 2D scene'
    231         rj.PopRenderTarget()
    232         rj.ScheduleRecurring(insertFront=True)
    233         texture.SetResource(trinity.TriTextureRes(renderTarget))
    234         myScene.is2dRender = True
    235         self.sceneObject = blue.BluePythonWeakRef(sprite)
    236         self.renderSteps[-1].enabled = False
    237 
    238     def GetInSceneObject(self):
    239         if self.sceneObject:
    240             return self.sceneObject.object
    241 
    242     def CheckMouseMove(self, *args):
    243         if uicore.uilib.leftbtn and uicore.uilib.Key(uiconst.VK_MENU):
    244             if uicore.uilib.rightbtn:
    245                 self.camera.distance -= uicore.uilib.dy
    246             else:
    247                 self.camera.AdjustYaw(-uicore.uilib.dx * 0.1)
    248                 self.camera.AdjustPitch(-uicore.uilib.dy * 0.1)
    249         return 1
    250 
    251     def _CleanUpRenderJob(self):
    252         if self.renderSteps:
    253             renderJob = uicore.uilib.GetRenderJob()
    254             if renderJob:
    255                 for each in self.renderSteps:
    256                     if each in renderJob.steps:
    257                         renderJob.steps.remove(each)
    258 
    259         self.renderSteps = None
    260         self.renderTargetStep = None
    261         self.generateMipsStep = None
    262         self._glowRenderTarget = None
    263         self._blurRenderTarget0 = None
    264         self._blurRenderTarget1 = None
    265         self._glowProcessStep = None
    266         self._glowTransform = None
    267         self._glowTargetSteps = []
    268 
    269     def _OnClose(self, *args, **kwds):
    270         self._CleanUpRenderJob()
    271         uicore.uilib.RemoveRootObject(self)
    272         Container._OnClose(self, *args, **kwds)
    273 
    274     def AddLayer(self, name, decoClass = None, subLayers = None, idx = -1, loadLayerClass = False):
    275         useClass = decoClass or LayerCore
    276         layer = useClass(parent=self, name=name, idx=idx, align=uiconst.TOALL, state=uiconst.UI_PICKCHILDREN)
    277         layer.decoClass = decoClass
    278         uicore.layerData[name] = (useClass, subLayers)
    279         if name.startswith('l_'):
    280             setattr(uicore.layer, name[2:].lower(), layer)
    281         else:
    282             setattr(uicore.layer, name.lower(), layer)
    283         if subLayers is not None:
    284             for _layerName, _decoClass, _subLayers in subLayers:
    285                 layer.AddLayer(_layerName, _decoClass, _subLayers)
    286 
    287         return layer
    288 
    289     def UpdateSize(self):
    290         if self.isFullscreen and not self.renderTargetStep:
    291             preSize = (self.width, self.height)
    292             self.width = int(float(trinity.device.width) / self.dpiScaling)
    293             self.height = int(float(trinity.device.height) / self.dpiScaling)
    294             self.renderObject.isFullscreen = True
    295             if preSize != (self.width, self.height):
    296                 self.FlagForceUpdateAlignment()
    297         self._RefreshGlowTargets(self._GetRenderTarget())
    298         if self.camera:
    299             self.camera.AdjustForDesktop()
    300 
    301     def GetAbsoluteSize(self):
    302         return (self.width, self.height)
    303 
    304     def GetAbsolutePosition(self):
    305         return (0, 0)
    306 
    307     @property
    308     def dpiScaling(self):
    309         return self._dpiScaling
    310 
    311     @dpiScaling.setter
    312     def dpiScaling(self, value):
    313         self._dpiScaling = value
    314         uicore.dpiScaling = value
    315         self.UpdateSize()
    316         for each in uicore.textObjects:
    317             each.OnCreate(trinity.device)
    318 
    319     @property
    320     def rotationY(self):
    321         return self._rotationY
    322 
    323     @rotationY.setter
    324     def rotationY(self, value):
    325         self._rotationY = value
    326         ro = self.renderObject
    327         if ro:
    328             ro.rotation = geo2.QuaternionRotationSetYawPitchRoll(self._rotationY, self._rotationX, self._rotationZ)
    329 
    330     @property
    331     def clearBackground(self):
    332         return self.renderObject.clearBackground
    333 
    334     @clearBackground.setter
    335     def clearBackground(self, value):
    336         self.renderObject.clearBackground = value
    337 
    338     @property
    339     def backgroundColor(self):
    340         return self.renderObject.backgroundColor
    341 
    342     @backgroundColor.setter
    343     def backgroundColor(self, value):
    344         self.renderObject.backgroundColor = value
    345 
    346     def UpdateUIScaling(self, value, oldValue):
    347         self.dpiScaling = value
    348         self.UpdateSize()
    349         super(UIRoot, self).UpdateUIScaling(value, oldValue)
    350 
    351     @property
    352     def glowEnabled(self):
    353         return self._glowEnabled
    354 
    355     @glowEnabled.setter
    356     def glowEnabled(self, value):
    357         if self._glowEnabled == value:
    358             return
    359         self._glowEnabled = value
    360         rt = self._GetRenderTarget()
    361         self._CleanUpRenderJob()
    362         self.ConstructRenderSteps(self.depthMax, self._renderJob, rt)
    363 
    364     @property
    365     def glowBrightness(self):
    366         return self._glowBrightness
    367 
    368     @glowBrightness.setter
    369     def glowBrightness(self, value):
    370         self._glowBrightness = value
    371         if self._glowTransform:
    372             self._glowTransform.parameters.FindByName('Brightness').value = value
    373 
    374     @property
    375     def glowDistortion(self):
    376         return self._glowDistortion
    377 
    378     @glowDistortion.setter
    379     def glowDistortion(self, value):
    380         self._glowDistortion = value
    381         if self._glowTransform:
    382             self._glowTransform.parameters.FindByName('DistortionStrength').value = value
    383 
    384     @property
    385     def glowHighlightRadius(self):
    386         return self._glowHighlightRadius
    387 
    388     @glowHighlightRadius.setter
    389     def glowHighlightRadius(self, value):
    390         self._glowHighlightRadius = value
    391         if self._glowTransform:
    392             self._glowTransform.parameters.FindByName('HighlightRadius').value = value
    393 
    394     @property
    395     def glowHighlightBrightness(self):
    396         return self._glowHighlightBrightness
    397 
    398     @glowHighlightBrightness.setter
    399     def glowHighlightBrightness(self, value):
    400         self._glowHighlightBrightness = value
    401         if self._glowTransform:
    402             self._glowTransform.parameters.FindByName('HighlightBrightness').value = value
    403 
    404     @property
    405     def glowHighlightCoords(self):
    406         return self._glowHighlightCoords
    407 
    408     @glowHighlightCoords.setter
    409     def glowHighlightCoords(self, value):
    410         self._glowHighlightCoords = value
    411         if self._glowTransform:
    412             self._glowTransform.parameters.FindByName('HighlightCoords').value = value