def __init__(self, pipeline):
        DebugObject.__init__(self, "GlobalIllumnination")
        self.pipeline = pipeline

        # Fetch the scene data
        self.targetCamera = Globals.base.cam
        self.targetSpace = Globals.base.render

        # Store grid size in world space units
        # This is the half voxel grid size
        self.voxelGridSizeWS = Vec3(60)

        # When you change this resolution, you have to change it in Shader/GI/ConvertGrid.fragment aswell
        self.voxelGridResolution = LVecBase3i(256)

        self.targetLight = None
        self.helperLight = None
        self.ptaGridPos = PTALVecBase3f.emptyArray(1)
        self.gridPos = Vec3(0)

        # Create ptas 

        self.ptaLightUVStart = PTALVecBase2f.emptyArray(1)
        self.ptaLightMVP = PTAMat4.emptyArray(1)
        self.ptaVoxelGridStart = PTALVecBase3f.emptyArray(1)
        self.ptaVoxelGridEnd = PTALVecBase3f.emptyArray(1)
        self.ptaLightDirection = PTALVecBase3f.emptyArray(1)

        self.targetSpace.setShaderInput("giLightUVStart", self.ptaLightUVStart)
        self.targetSpace.setShaderInput("giLightMVP", self.ptaLightMVP)
        self.targetSpace.setShaderInput("giVoxelGridStart", self.ptaVoxelGridStart)
        self.targetSpace.setShaderInput("giVoxelGridEnd", self.ptaVoxelGridEnd)
        self.targetSpace.setShaderInput("giLightDirection", self.ptaLightDirection)
Example #2
0
    def __init__(self, pos=Vec2(0), rightAligned=False, color=Vec3(0, 0, 0),
                 size=0.04, parent=None):
        if parent is None:
            parent = Globals.base.aspect2d

        self.parent = parent

        self._loadCharset()
        self._prepareFontTextures()
        self._makeFontShader()
        self._makeSquare()

        self.data = PTAFloat.empty_array(100)
        self.lastText = ""
        self.size = 16.0 / base.win.getYSize() * 2.0

        self.square.setShaderInput("displData", self.data)

        self.rightAligned = rightAligned
        self.pos = pos
        self.posOffset = Vec2(0)
        self.color = PTALVecBase3f.emptyArray(1)
        self.color[0] = color

        self.posPTA = PTALVecBase2f.emptyArray(1)
        self.square.setShaderInput("pos", self.posPTA)

        self._updateInputs()
Example #3
0
 def _generatePTAs(self):
     """ Converts all settings to pta arrays, this is faster than using
     setShaderInput for every uniform """
     for settingName, settingValue in self.settings.iteritems():
         if type(settingValue) == float:
             self.settingsPTA[settingName] = PTAFloat.emptyArray(1)
             self.settingsPTA[settingName][0] = settingValue
         elif type(settingValue) == Vec3:
             self.settingsPTA[settingName] = PTALVecBase3f.emptyArray(1)
             self.settingsPTA[settingName][0] = settingValue
         elif type(settingValue) == bool:
             self.settingsPTA[settingName] = settingValue
         else:
             self.warn("Unkown type:", settingName, type(settingValue))
Example #4
0
 def _generatePTAs(self):
     self.debug("Generating PTAs ..")
     for settingName, settingValue in self.settings.items():
         if type(settingValue) == float:
             self.settingsPTA[settingName] = PTAFloat.emptyArray(1)
             self.settingsPTA[settingName][0] = settingValue
         elif type(settingValue) == Vec3:
             self.settingsPTA[settingName] = PTALVecBase3f.emptyArray(1)
             self.settingsPTA[settingName][0] = settingValue
         elif type(settingValue) == bool:
             # no pta bool yet
             self.settingsPTA[settingName] = settingValue
         else:
             self.warn("Unkown type:", settingName, type(settingValue))
Example #5
0
    def __init__(self, pipeline):
        DebugObject.__init__(self, "GlobalIllumnination")
        self.pipeline = pipeline

        self.targetCamera = Globals.base.cam
        self.targetSpace = Globals.base.render

        self.voxelBaseResolution = 512 * 4
        self.voxelGridSizeWS = Vec3(50, 50, 20)
        self.voxelGridResolution = LVecBase3i(512, 512, 128)
        self.targetLight = None
        self.helperLight = None
        self.ptaGridPos = PTALVecBase3f.emptyArray(1)
        self.gridPos = Vec3(0)
    def __init__(self, pipeline):
        DebugObject.__init__(self, "GlobalIllumnination")
        self.pipeline = pipeline

        self.qualityLevel = self.pipeline.settings.giQualityLevel

        if self.qualityLevel not in self.QualityLevels:
            self.fatal("Unsupported gi quality level:" + self.qualityLevel)

        self.qualityLevelIndex = self.QualityLevels.index(self.qualityLevel)

        # Grid size in world space units
        self.voxelGridSize = self.pipeline.settings.giVoxelGridSize

        # Grid resolution in pixels
        self.voxelGridResolution = [32, 64, 128, 192][self.qualityLevelIndex]

        # Has to be a multiple of 2
        self.distributionSteps = [16, 30, 60, 90][self.qualityLevelIndex]
        self.slideCount = int(self.voxelGridResolution / 8)
        self.slideVertCount = self.voxelGridResolution / self.slideCount

        self.bounds = BoundingBox()
        self.renderCount = 0

        # Create the task manager
        self.taskManager = DistributedTaskManager()

        self.gridPosLive = PTALVecBase3f.emptyArray(1)
        self.gridPosTemp = PTALVecBase3f.emptyArray(1)

        # Store ready state
        self.readyStateFlag = PTAFloat.emptyArray(1)
        self.readyStateFlag[0] = 0

        self.frameIndex = 0
        self.steps = []
    def __init__(self, pipeline):
        DebugObject.__init__(self, "GlobalIllumnination")
        self.pipeline = pipeline

        self.qualityLevel = self.pipeline.settings.giQualityLevel

        if self.qualityLevel not in self.QualityLevels:
            self.fatal("Unsupported gi quality level:" + self.qualityLevel)

        self.qualityLevelIndex = self.QualityLevels.index(self.qualityLevel)

        # Grid size in world space units
        self.voxelGridSize = self.pipeline.settings.giVoxelGridSize
        
        # Grid resolution in pixels
        self.voxelGridResolution = [32, 64, 128, 192][self.qualityLevelIndex]

        # Has to be a multiple of 2
        self.distributionSteps = [16, 30, 60, 90][self.qualityLevelIndex]
        self.slideCount = int(self.voxelGridResolution / 8) 
        self.slideVertCount = self.voxelGridResolution / self.slideCount       

        self.bounds = BoundingBox()
        self.renderCount = 0

        # Create the task manager
        self.taskManager = DistributedTaskManager()

        self.gridPosLive = PTALVecBase3f.emptyArray(1)
        self.gridPosTemp = PTALVecBase3f.emptyArray(1)

        # Store ready state
        self.readyStateFlag = PTAFloat.emptyArray(1)
        self.readyStateFlag[0] = 0

        self.frameIndex = 0
        self.steps = []
 def __init__(self, pipeline):
     RenderStage.__init__(self, pipeline)
     self.pta_position = PTALVecBase3f.empty_array(1)
Example #9
0
 def __init__(self, pipeline):
     RenderStage.__init__(self, pipeline)
     self.pta_position = PTALVecBase3f.empty_array(1)
Example #10
0
 def __init__(self, pipeline):
     RenderStage.__init__(self, pipeline)
     self.pta_position = PTALVecBase3f.empty_array(1)
     self.resolution = 512
     self.capture_height = 100.0
     self.max_radius = 100.0
Example #11
0
 def __init__(self, pipeline):
     RenderStage.__init__(self, pipeline)
     self.pta_position = PTALVecBase3f.empty_array(1)
     self.resolution = 512
     self.capture_height = 100.0
     self.max_radius = 100.0