예제 #1
0
    def setup_scene(self) :
        h3dres = self._h3dres

        # Add environment
        self._env = h3d.addNodes(h3d.RootNode, h3dres.env)
        h3d.setNodeTransform(self._env, 0, 0, 0, 0, 0, 0, 0.23, 0.23, 0.23)
        # Add skybox
        self._sky = h3d.addNodes(h3d.RootNode, h3dres.skyBox)
        h3d.setNodeTransform(self._sky, 0, 0, 0, 0, 0, 0, 100, 50, 100)
        # Add light source
        self._light = h3d.addLightNode(h3d.RootNode, 'Light1', h3dres.lightMat, 'LIGHTING', 'SHADOWMAP')
        h3d.setNodeTransform(self._light, 50, 40, -50, -60, 130, 0, 1, 1, 1)
        h3d.setNodeParamF(self._light, h3d.Light.RadiusF, 0, 250)
        h3d.setNodeParamF(self._light, h3d.Light.FovF, 0, 90)
        h3d.setNodeParamI(self._light, h3d.Light.ShadowMapCountI, 3)
        h3d.setNodeParamF(self._light, h3d.Light.ShadowSplitLambdaF, 0, 0.9)
        h3d.setNodeParamF(self._light, h3d.Light.ShadowMapBiasF, 0, 0.001)
        h3d.setNodeParamF(self._light, h3d.Light.ColorF3, 0, 0.9)
        h3d.setNodeParamF(self._light, h3d.Light.ColorF3, 1, 0.9)
        h3d.setNodeParamF(self._light, h3d.Light.ColorF3, 2, 0.9)
        # Create volume data
        self._vol = h3d.addNodes(h3d.RootNode, h3dres.volBox)
        h3d.setNodeTransform(self._vol, 0, 3, 0, 0, 0, 0, 3, 3, 3)

        # Add a camera
        self.add_camera("MainCamera", h3dres.deferredPipe)
        h3d.setNodeTransform(self.camera, 9, 6.0, -14, -15, 145, 0, 1, 1, 1)
예제 #2
0
    def _h3dSetupScene(self):
        h3dres = self._h3dres

        self._env = h3d.addNodes(h3d.RootNode, h3dres.env)
        h3d.setNodeTransform(self._env, 0, -20, 0, 0, 0, 0, 20, 20, 20)

        self._knight = h3d.addNodes(h3d.RootNode, h3dres.knight)
        h3d.setNodeTransform(self._knight, 0, 0, 0, 0, 180, 0, 0.1, 0.1, 0.1)
        h3d.setupModelAnimStage(self._knight, 0, h3dres.knightAnim1, 0, '', False)
        h3d.setupModelAnimStage(self._knight, 1, h3dres.knightAnim2, 0, '', False)

        # Attach particle system to hand joint
        h3d.findNodes(self._knight, 'Bip01_R_Hand', h3d.NodeTypes.Joint)
        hand = h3d.getNodeFindResult(0)
        self._particleSystem = h3d.addNodes(hand, h3dres.particleSys)
        h3d.setNodeTransform(self._particleSystem, 0, 40, 0, 90, 0, 0, 1, 1, 1)

        self._light = h3d.addLightNode(h3d.RootNode, 'Light1', 0, 'LIGHTING', 'SHADOWMAP')
        h3d.setNodeTransform(self._light, 0, 15, 10, -60, 0, 0, 1, 1, 1)
        h3d.setNodeParamF(self._light, h3d.Light.RadiusF, 0, 30)
        h3d.setNodeParamF(self._light, h3d.Light.FovF, 0, 90)
        h3d.setNodeParamI(self._light, h3d.Light.ShadowMapCountI, 1)
        h3d.setNodeParamF(self._light, h3d.Light.ShadowMapBiasF, 0, 0.01)
        h3d.setNodeParamF(self._light, h3d.Light.ColorF3, 0, 1.0)
        h3d.setNodeParamF(self._light, h3d.Light.ColorF3, 1, 0.8)
        h3d.setNodeParamF(self._light, h3d.Light.ColorF3, 2, 0.7)

        # Customize post processing effects
        mat = h3d.findResource(h3d.ResTypes.Material, 'pipelines/postHDR.material.xml')
        # hdrParams: exposure, brightpass threshold, brightpass offset (see shader for description)
        h3d.setMaterialUniform(mat, 'hdrExposure', 2.5, 0.0, 0.0, 0.0)
        h3d.setMaterialUniform(mat, 'hdrBrightThres', 0.5, 0.0, 0.0, 0.0)
        h3d.setMaterialUniform(mat, 'hdrBrightOffset', 0.08, 0.0, 0.0, 0.0)
예제 #3
0
    def start(self):
        self.cmap_size = 1024
        self.light_fov = 0.0
        self.light_mat_res = 0
        self.light_shader_res = 0
        self.sph1_shader_res = 0
        self.fov_slot = -1
        self.cmap = None
        self.cmap_mat = {
            'cmat_r1':0,
            'cmat_r2':0,
            'cmat_r3':0,
            'cmat_r4':0,
        }
        self.create_cmap = True
        
        obj3d = self.gocBehavior('Object3D')
        self._light_camera = obj3d.horde_id

        # Create a caustic renderable texture
        if self.create_cmap :
            self.cmap = h3d.createTexture("caustic_map", self.cmap_size, self.cmap_size, 
                                        h3d.Formats.TEX_RGBA16F, h3d.ResFlags.TexRenderable)
            # Set camera output texture
            h3d.setNodeParamI(self._light_camera, h3d.Camera.OutTexResI, self.cmap)
            # Get shader uniform locations
            self.get_cmap_res()
예제 #4
0
    def graphic_update(self, cur_fps, ani_time, weight):
        forward = h3d.getNodeParamI(
            self.camera, h3d.Camera.PipeResI) == self._h3dres.forwardPipe

        if (PIWIO.key_clicked() and PIWIO.clicked_key() == Qt.Key_F5):
            self.__mode += 1

        if self.__mode > 0:
            if forward:
                h3d.utils.showText("Pipeline: forward", 0.03, 0.24, 0.026, 1,
                                   1, 1, self._h3dres.fontMat)
            else:
                h3d.utils.showText("Pipeline: deferred", 0.03, 0.24, 0.026, 1,
                                   1, 1, self._h3dres.fontMat)

        if self.__mode == 3: self.__mode = 0

        if PIWIO.key_clicked() and PIWIO.clicked_key() == Qt.Key_F3:
            if forward:
                h3d.setNodeParamI(self.camera, h3d.Camera.PipeResI,
                                  self._h3dres.deferredPipe)
            else:
                h3d.setNodeParamI(self.camera, h3d.Camera.PipeResI,
                                  self._h3dres.forwardPipe)
            SetCamera(self.camera)
        self._crowdSim.update(1.0 / cur_fps)
예제 #5
0
    def setup_scene(self):
        h3dres = self._h3dres

        # Add environment
        self._env = h3d.addNodes(h3d.RootNode, h3dres.env)
        h3d.setNodeTransform(self._env, 0, 0, 0, 0, 0, 0, 0.23, 0.23, 0.23)
        # Add skybox
        self._sky = h3d.addNodes(h3d.RootNode, h3dres.skyBox)
        h3d.setNodeTransform(self._sky, 0, 0, 0, 0, 0, 0, 100, 50, 100)
        # Add light source
        self._light = h3d.addLightNode(h3d.RootNode, 'Light1', h3dres.lightMat,
                                       'LIGHTING', 'SHADOWMAP')
        h3d.setNodeTransform(self._light, 50, 40, -50, -60, 130, 0, 1, 1, 1)
        h3d.setNodeParamF(self._light, h3d.Light.RadiusF, 0, 250)
        h3d.setNodeParamF(self._light, h3d.Light.FovF, 0, 90)
        h3d.setNodeParamI(self._light, h3d.Light.ShadowMapCountI, 3)
        h3d.setNodeParamF(self._light, h3d.Light.ShadowSplitLambdaF, 0, 0.9)
        h3d.setNodeParamF(self._light, h3d.Light.ShadowMapBiasF, 0, 0.001)
        h3d.setNodeParamF(self._light, h3d.Light.ColorF3, 0, 0.9)
        h3d.setNodeParamF(self._light, h3d.Light.ColorF3, 1, 0.9)
        h3d.setNodeParamF(self._light, h3d.Light.ColorF3, 2, 0.9)
        # Init character positions
        self._crowdSim.init()
        self.add_camera("MainCamera", h3dres.deferredPipe)
        h3d.setNodeTransform(self.camera, 15, 3.3, -16, 0, 130, 0, 1, 1, 1)
예제 #6
0
    def graphic_update(self, cur_fps, ani_time, weight):
        forward = h3d.getNodeParamI( self.camera, h3d.Camera.PipeResI ) == self._h3dres.forwardPipe 
        
        if (PIWIO.key_clicked() and PIWIO.clicked_key() == Qt.Key_F5) :self.__mode += 1
        
        if self.__mode > 0 :
            if forward:
                h3d.utils.showText( "Pipeline: forward", 0.03, 0.24, 0.026, 1, 1, 1, self._h3dres.fontMat )
            else:
                h3d.utils.showText( "Pipeline: deferred", 0.03, 0.24, 0.026, 1, 1, 1, self._h3dres.fontMat )
        
        if self.__mode == 3 : self.__mode = 0

        if PIWIO.key_clicked():
            if PIWIO.clicked_key() == Qt.Key_F3 :
                if forward :
                    h3d.setNodeParamI( self.camera, h3d.Camera.PipeResI, self._h3dres.deferredPipe )
                else :
                    h3d.setNodeParamI( self.camera, h3d.Camera.PipeResI, self._h3dres.forwardPipe )
                SetCamera(self.camera)

            elif PIWIO.clicked_key() == Qt.Key_1 :
                self.change_skybox(self._h3dres.skyBox)
            elif PIWIO.clicked_key() == Qt.Key_2 :
                self.change_skybox(self._h3dres.skyBox2)

            elif PIWIO.clicked_key() == Qt.Key_3 :
                mtl = h3d.getNodeParamI(self._vol, 20001)
                h3d.setMaterialUniform(mtl, "FluidColor", 0.59, 0.69, 0.99, 1.0)
                h3d.setMaterialUniform(mtl, "absorptionIdx", 2.0, 1.1, 0.45, 0.0)
            elif PIWIO.clicked_key() == Qt.Key_4 :
                mtl = h3d.getNodeParamI(self._vol, 20001)
                h3d.setMaterialUniform(mtl, "FluidColor", 0.0, 0.0, 0.0, 0.0)
                h3d.setMaterialUniform(mtl, "absorptionIdx", 0.0, 0.0, 0.0, 0.0)

        if self.animation :
            self.__rotate += 30.0/cur_fps 
            anchor = h3d.getNodeParent(self.camera)
            t,r,s = h3d.getNodeTransform(anchor)
            h3d.setNodeTransform(anchor, t[0], t[1], t[2], r[0], self.__rotate, r[2], s[0], s[1], s[2])

        if len(self.__data_list) > 0:
            self.__file_ptr += self.__skip
            self.__file_ptr %= len(self.__data_list)
            fn = self.__data_list[self.__file_ptr]
            if not SPH.UpdateSphData(self._sphdata, fn) :
                print "can not load file {}".format(fn)
            else :
                SPH.AdvanceSph(self._vol)

        if not forward and self.create_cmap :
            self.update_shader_fov(self.light_fov)
            h3d.render(self._light_camera)
            # restore
            self.update_shader_fov(45.0)
예제 #7
0
    def graphic_update(self, cur_fps, ani_time, weight):
        forward = h3d.getNodeParamI( self.camera, h3d.Camera.PipeResI ) == self._h3dres.forwardPipe 
        
        if (PIWIO.key_clicked() and PIWIO.clicked_key() == Qt.Key_F5) :self.__mode += 1
        
        if self.__mode > 0 :
            if forward:
                h3d.utils.showText( "Pipeline: forward", 0.03, 0.24, 0.026, 1, 1, 1, self._h3dres.fontMat )
            else:
                h3d.utils.showText( "Pipeline: deferred", 0.03, 0.24, 0.026, 1, 1, 1, self._h3dres.fontMat )
        
        if self.__mode == 3 : self.__mode = 0

        if PIWIO.key_clicked() and PIWIO.clicked_key() == Qt.Key_F3 :
            if forward :
                h3d.setNodeParamI( self.camera, h3d.Camera.PipeResI, self._h3dres.deferredPipe )
            else :
                h3d.setNodeParamI( self.camera, h3d.Camera.PipeResI, self._h3dres.forwardPipe )
            SetCamera(self.camera)
        self._crowdSim.update(1.0/cur_fps)
예제 #8
0
    def on_key_press(self, symbol, modifiers):
        key = pyglet.window.key

        if symbol == key.ESCAPE:
            self.has_exit = True
        elif symbol == key.SPACE:
            self._app._freeze = not self._app._freeze
        elif symbol == key.F3:
            p = h3d.getNodeParamI(self.camera, h3d.Camera.PipeResI)
            if p == self._app._h3dres.hdrPipe:
                h3d.setNodeParamI(self.camera, h3d.Camera.PipeResI, self._app._h3dres.forwardPipe)
            else:
                h3d.setNodeParamI(self.camera, h3d.Camera.PipeResI, self._app._h3dres.hdrPipe)
        elif symbol == key.F7:
            self._app._debugViewMode = not self._app._debugViewMode
        elif symbol == key.F8:
            self._app._wireframeMode = not self._app._wireframeMode
        elif symbol == key.F9:
            self._app._showStats = True
            self._app._statMode = 1 - self._app._statMode
예제 #9
0
    def change_render_mode(self, mode):
        if mode == self.__render_mode: return

        # for safe
        mode = mode % len(self.__rmode_dict)
        # get pipeline and name
        name, pipeline = self.__rmode_dict[mode % 4]
        h3d.setNodeParamI(self.camera, h3d.Camera.PipeResI, pipeline)

        if mode < 3 and self.__render_mode >= 3:
            # reset default particle system
            self.set_particlesys(self._h3dres.particleSys)

        # sph pipeline
        if mode == 3:
            self.set_particlesys(self._h3dres.particleSys2)

        # reset camera, force to resize buffers
        SetCamera(self.camera)
        self.__render_mode = mode
        return name
예제 #10
0
    def setup_scene(self) :
        h3dres = self._h3dres

        # Add skybox
        self._sky = h3d.addNodes(h3d.RootNode, h3dres.skyBox)
        h3d.setNodeTransform(self._sky, 0, 0, 0, 0, 0, 0, 500, 500, 500)
        # Add light source
        self._light = h3d.addLightNode(h3d.RootNode, 'Light1', h3dres.lightMat, 'LIGHTING', 'SHADOWMAP')
        h3d.setNodeTransform(self._light, 0, 20, 50, -30, 0, 0, 1, 1, 1)
        h3d.setNodeParamF(self._light, h3d.Light.RadiusF, 0, 200)
        h3d.setNodeParamF(self._light, h3d.Light.FovF, 0, 90)
        h3d.setNodeParamI(self._light, h3d.Light.ShadowMapCountI, 3)
        h3d.setNodeParamF(self._light, h3d.Light.ShadowSplitLambdaF, 0, 0.9)
        h3d.setNodeParamF(self._light, h3d.Light.ShadowMapBiasF, 0, 0.001)
        h3d.setNodeParamF(self._light, h3d.Light.ColorF3, 0, 0.9)
        h3d.setNodeParamF(self._light, h3d.Light.ColorF3, 1, 0.7)
        h3d.setNodeParamF(self._light, h3d.Light.ColorF3, 2, 0.75)
        # Add domino scene
        self._domino = h3d.addNodes(h3d.RootNode, h3dres.dominoRes )
        # Add particle effects
        h3d.findNodes(self._domino, 'sphere', h3d.NodeTypes.Mesh)
        sphere = h3d.getNodeFindResult(0)
        self._particleSystem = h3d.addNodes(sphere, h3dres.particleSys)
        # Set particle parameter
        count = h3d.findNodes(self._particleSystem, '', h3d.NodeTypes.Emitter)
        for i in range(count):
            node = h3d.getNodeFindResult(i)
            h3d.setNodeParamF(node, h3d.Emitter.ForceF3, 1, 1.5)
            h3d.setNodeParamF(node, h3d.Emitter.EmissionRateF, 0, 200)
            h3d.setNodeParamF(node, h3d.Emitter.SpreadAngleF, 0, 45)

        # Customize post processing effects
        mat = h3d.findResource(h3d.ResTypes.Material, 'pipelines/postHDR.material.xml')
        # hdrParams: exposure, brightpass threshold, brightpass offset (see shader for description)
        h3d.setMaterialUniform(mat, 'hdrExposure', 2.5, 0.0, 0.0, 0.0)
        h3d.setMaterialUniform(mat, 'hdrBrightThres', 0.5, 0.0, 0.0, 0.0)
        h3d.setMaterialUniform(mat, 'hdrBrightOffset', 0.08, 0.0, 0.0, 0.0)

        self.add_camera("MainCamera", h3dres.hdrPipe)
        h3d.setNodeTransform(self.camera, -14.0, 40.0, 24.0, -50.0, -20, 1.3, 1, 1, 1)
예제 #11
0
    def setup_scene(self):
        h3dres = self._h3dres

        self._env = h3d.addNodes(h3d.RootNode, h3dres.env)
        #h3d.setNodeTransform(self._env, 0, 0, 0, 0, 0, 0, 0.23, 0.23, 0.23)
        h3d.setNodeTransform(self._env, 0, -20, 0, 0, 0, 0, 20, 20, 20)
        # Add skybox
        self._sky = h3d.addNodes(h3d.RootNode, h3dres.skyBox)
        h3d.setNodeTransform(self._sky, 0, 0, 0, 90, 0, 0, 50, 50, 50)

        self._knight = h3d.addNodes(h3d.RootNode, h3dres.knight)
        h3d.setNodeTransform(self._knight, 0, 0, 0, 0, 180, 0, 0.1, 0.1, 0.1)
        h3d.setupModelAnimStage(self._knight, 0, h3dres.knightAnim1, 0, '',
                                False)
        h3d.setupModelAnimStage(self._knight, 1, h3dres.knightAnim2, 0, '',
                                False)

        self._light = h3d.addLightNode(h3d.RootNode, 'Light1', h3dres.lightMat,
                                       'LIGHTING', 'SHADOWMAP')
        h3d.setNodeTransform(self._light, 0, 15, 10, -60, 0, 0, 1, 1, 1)
        h3d.setNodeParamF(self._light, h3d.Light.RadiusF, 0, 30)
        h3d.setNodeParamF(self._light, h3d.Light.FovF, 0, 90)
        h3d.setNodeParamI(self._light, h3d.Light.ShadowMapCountI, 1)
        h3d.setNodeParamF(self._light, h3d.Light.ShadowMapBiasF, 0, 0.01)
        h3d.setNodeParamF(self._light, h3d.Light.ColorF3, 0, 1.0)
        h3d.setNodeParamF(self._light, h3d.Light.ColorF3, 1, 0.8)
        h3d.setNodeParamF(self._light, h3d.Light.ColorF3, 2, 0.7)

        # Customize post processing effects
        mat = h3d.findResource(h3d.ResTypes.Material,
                               'pipelines/postHDR.material.xml')
        # hdrParams: exposure, brightpass threshold, brightpass offset (see shader for description)
        h3d.setMaterialUniform(mat, 'hdrExposure', 2.5, 0.0, 0.0, 0.0)
        h3d.setMaterialUniform(mat, 'hdrBrightThres', 0.5, 0.0, 0.0, 0.0)
        h3d.setMaterialUniform(mat, 'hdrBrightOffset', 0.08, 0.0, 0.0, 0.0)

        # Attach particle system to hand joint
        self.set_particlesys(h3dres.particleSys2)
        self.add_camera("MainCamera", self.__rmode_dict[3][1])
        h3d.setNodeTransform(self.camera, -25, 14, 9, -30, -60, 5, 1, 1, 1)
예제 #12
0
    def graphic_update(self, cur_fps, ani_time, weight):
        hdr = h3d.getNodeParamI( self.camera, h3d.Camera.PipeResI ) == self._h3dres.hdrPipe 
        
        if (PIWIO.key_clicked() and PIWIO.clicked_key() == Qt.Key_F5) :self.__mode += 1
        
        if self.__mode > 0 :
            if hdr:
                h3d.utils.showText( "Pipeline: hdr", 0.03, 0.24, 0.026, 1, 1, 1, self._h3dres.fontMat )
            else:
                h3d.utils.showText( "Pipeline: deferred", 0.03, 0.24, 0.026, 1, 1, 1, self._h3dres.fontMat )
        
        if self.__mode == 3 : self.__mode = 0

        if PIWIO.key_clicked() and PIWIO.clicked_key() == Qt.Key_F3 :
            if hdr :
                h3d.setNodeParamI( self.camera, h3d.Camera.PipeResI, self._h3dres.deferredPipe )
            else :
                h3d.setNodeParamI( self.camera, h3d.Camera.PipeResI, self._h3dres.hdrPipe )
            SetCamera(self.camera)

        count = h3d.findNodes(self._particleSystem, '', h3d.NodeTypes.Emitter)
        for i in range(count):
            h3d.updateEmitter(h3d.getNodeFindResult(i), 1.0/cur_fps)
예제 #13
0
    def setup_scene(self) :
        h3dres = self._h3dres

        # Add environment
        self._env = h3d.addNodes(h3d.RootNode, h3dres.env)
        h3d.setNodeTransform(self._env, 0, 0, 0, 0, 0, 0, 0.23, 0.23, 0.23)
        # Add skybox
        self._sky = h3d.addNodes(h3d.RootNode, h3dres.skyBox)
        h3d.setNodeTransform(self._sky, 0, 0, 0, 0, 0, 0, 100, 50, 100)
        # Add light source
        self._light = h3d.addLightNode(h3d.RootNode, 'Light1', h3dres.lightMat, 'LIGHTING', 'SHADOWMAP')
        h3d.setNodeTransform(self._light, 50, 40, -50, -60, 130, 0, 1, 1, 1)
        h3d.setNodeParamF(self._light, h3d.Light.RadiusF, 0, 250)
        h3d.setNodeParamF(self._light, h3d.Light.FovF, 0, 90)
        h3d.setNodeParamI(self._light, h3d.Light.ShadowMapCountI, 3)
        h3d.setNodeParamF(self._light, h3d.Light.ShadowSplitLambdaF, 0, 0.9)
        h3d.setNodeParamF(self._light, h3d.Light.ShadowMapBiasF, 0, 0.001)
        h3d.setNodeParamF(self._light, h3d.Light.ColorF3, 0, 0.9)
        h3d.setNodeParamF(self._light, h3d.Light.ColorF3, 1, 0.9)
        h3d.setNodeParamF(self._light, h3d.Light.ColorF3, 2, 0.9)
        # Init character positions
        self._crowdSim.init()
        self.add_camera("MainCamera", h3dres.deferredPipe)
        h3d.setNodeTransform(self.camera, 15, 3.3, -16, 0, 130, 0, 1, 1, 1)
예제 #14
0
    def graphic_update(self, cur_fps, ani_time, weight):
        forward = h3d.getNodeParamI(
            self.camera, h3d.Camera.PipeResI) == self._h3dres.forwardPipe

        if (PIWIO.key_clicked() and PIWIO.clicked_key() == Qt.Key_F5):
            self.__mode += 1

        if self.__mode > 0:
            if forward:
                h3d.utils.showText("Pipeline: forward", 0.03, 0.24, 0.026, 1,
                                   1, 1, self._h3dres.fontMat)
            else:
                h3d.utils.showText("Pipeline: deferred", 0.03, 0.24, 0.026, 1,
                                   1, 1, self._h3dres.fontMat)

        if self.__mode == 3: self.__mode = 0

        if PIWIO.key_clicked():
            if PIWIO.clicked_key() == Qt.Key_F3:
                if forward:
                    h3d.setNodeParamI(self.camera, h3d.Camera.PipeResI,
                                      self._h3dres.deferredPipe)
                else:
                    h3d.setNodeParamI(self.camera, h3d.Camera.PipeResI,
                                      self._h3dres.forwardPipe)
                SetCamera(self.camera)

            elif PIWIO.clicked_key() == Qt.Key_1:
                self.change_skybox(self._h3dres.skyBox)
            elif PIWIO.clicked_key() == Qt.Key_2:
                self.change_skybox(self._h3dres.skyBox2)

            elif PIWIO.clicked_key() == Qt.Key_3:
                mtl = h3d.getNodeParamI(self._vol, 20001)
                h3d.setMaterialUniform(mtl, "FluidColor", 0.59, 0.69, 0.99,
                                       1.0)
                h3d.setMaterialUniform(mtl, "absorptionIdx", 2.0, 1.1, 0.45,
                                       0.0)
            elif PIWIO.clicked_key() == Qt.Key_4:
                mtl = h3d.getNodeParamI(self._vol, 20001)
                h3d.setMaterialUniform(mtl, "FluidColor", 0.0, 0.0, 0.0, 0.0)
                h3d.setMaterialUniform(mtl, "absorptionIdx", 2.0, 1.1, 0.45,
                                       0.0)

        if self.animation:
            self.__rotate += 30.0 / cur_fps
            anchor = h3d.getNodeParent(self.camera)
            t, r, s = h3d.getNodeTransform(anchor)
            h3d.setNodeTransform(anchor, t[0], t[1], t[2], r[0], self.__rotate,
                                 r[2], s[0], s[1], s[2])

        if len(self.__data_list) > 0:
            self.__file_ptr += self.__skip
            self.__file_ptr %= len(self.__data_list)
            fn = self.__data_list[self.__file_ptr]
            if not SPH.UpdateSphData(self._sphdata, fn):
                print "can not load file {}".format(fn)
            else:
                SPH.AdvanceSph(self._vol)
                if self.__shot_dir != '' and self.__file_ptr > 0:
                    fn = self.__data_list[self.__file_ptr - 1]
                    fn = os.path.join(self.__shot_dir,
                                      '{}.tga'.format(os.path.split(fn)[-1]))
                    utils.screenshot(fn)

        if not forward and self.create_cmap:
            self.update_shader_fov(self.light_fov)
            h3d.render(self._light_camera)
            # restore
            self.update_shader_fov(45.0)
예제 #15
0
    def setup_scene(self):
        h3dres = self._h3dres

        # Add environment
        #self._env = h3d.addNodes(h3d.RootNode, h3dres.env)
        #h3d.setNodeTransform(self._env, 0, 0, 0, 0, 0, 0, 0.08, 0.08, 0.08)
        # Add skybox
        self.change_skybox(h3dres.skyBox)
        # Add light source
        self._light = h3d.addLightNode(h3d.RootNode, 'Light1', h3dres.lightMat,
                                       'LIGHTING', 'SHADOWMAP')
        h3d.setNodeTransform(self._light, 15, 10, -5, -40, 120, 0, 1, 1, 1)
        h3d.setNodeParamF(self._light, h3d.Light.RadiusF, 0, 100)
        h3d.setNodeParamF(self._light, h3d.Light.FovF, 0, self.light_fov)
        h3d.setNodeParamI(self._light, h3d.Light.ShadowMapCountI, 1)
        h3d.setNodeParamF(self._light, h3d.Light.ShadowSplitLambdaF, 0, 0.9)
        h3d.setNodeParamF(self._light, h3d.Light.ShadowMapBiasF, 0, 0.001)
        h3d.setNodeParamF(self._light, h3d.Light.ColorF3, 0, 0.95)
        h3d.setNodeParamF(self._light, h3d.Light.ColorF3, 1, 0.95)
        h3d.setNodeParamF(self._light, h3d.Light.ColorF3, 2, 0.85)
        if self.create_cmap:
            # Light camera
            self._light_camera = h3d.addCameraNode(self._light, "light_camera",
                                                   h3dres.deferredPipe2)
            h3d.setNodeParamI(self._light_camera, h3d.Camera.OutTexResI,
                              h3dres.cmap)
            h3d.setNodeParamI(self._light_camera, h3d.Camera.ViewportXI, 0)
            h3d.setNodeParamI(self._light_camera, h3d.Camera.ViewportXI, 0)
            h3d.setNodeParamI(self._light_camera, h3d.Camera.ViewportWidthI,
                              self.cmap_size)
            h3d.setNodeParamI(self._light_camera, h3d.Camera.ViewportHeightI,
                              self.cmap_size)
            h3d.resizePipelineBuffers(h3dres.deferredPipe2, self.cmap_size,
                                      self.cmap_size)
            h3d.setupCameraView(self._light_camera, self.light_fov, 1.0, 0.1,
                                1000.0)
            # Update ligth shader uniforms
            self.update_cmap_res()

        # Create volume data
        self._vol = h3d.addNodes(h3d.RootNode, h3dres.volBox)
        self._sphdata = h3d.getNodeParamI(self._vol,
                                          20000)  # for VolumeResI = 20000

        self._room = h3d.addNodes(h3d.RootNode, h3dres.roomBox)
        h3d.setNodeTransform(self._room, 0, -0.01, 0, 0, 0, 0, 20, 20, 20)

        self._plane = h3d.addNodes(h3d.RootNode, h3dres.plane)
        h3d.setNodeTransform(self._plane, 0, 0, 0, 0, 0, 0, 0.2, 0.2, 0.2)

        # Add a camera
        self.add_camera("MainCamera", h3dres.deferredPipe)
        h3d.setNodeTransform(self.camera, -2.0, 1.2, -6.5, -13, -170, 0, 1, 1,
                             1)
        #h3d.setNodeTransform(self.camera, -0.8, 1.06, -1.08, -41, -154, -6.4, 1, 1, 1)
        #h3d.setNodeTransform(self.camera, -0.32, 0.23, -0.54, -19, -174, -0.01, 1, 1, 1)
        self.__mode = 0
예제 #16
0
    def setup_scene(self) :
        h3dres = self._h3dres

        # Add environment
        self._env = h3d.addNodes(h3d.RootNode, h3dres.env)
        h3d.setNodeTransform(self._env, 0, 0, 0, 0, 0, 0, 0.08, 0.08, 0.08)
        # Add skybox
        self.change_skybox(h3dres.skyBox)
        # Add light source
        self._light = h3d.addLightNode(h3d.RootNode, 'Light1', h3dres.lightMat, 'LIGHTING', 'SHADOWMAP')
        h3d.setNodeTransform(self._light, 15, 10, -5, -40, 120, 0, 1, 1, 1)
        h3d.setNodeParamF(self._light, h3d.Light.RadiusF, 0, 100)
        h3d.setNodeParamF(self._light, h3d.Light.FovF, 0, self.light_fov)
        h3d.setNodeParamI(self._light, h3d.Light.ShadowMapCountI, 1)
        h3d.setNodeParamF(self._light, h3d.Light.ShadowSplitLambdaF, 0, 0.9)
        h3d.setNodeParamF(self._light, h3d.Light.ShadowMapBiasF, 0, 0.001)
        h3d.setNodeParamF(self._light, h3d.Light.ColorF3, 0, 0.95)
        h3d.setNodeParamF(self._light, h3d.Light.ColorF3, 1, 0.95)
        h3d.setNodeParamF(self._light, h3d.Light.ColorF3, 2, 0.85)
        if self.create_cmap :
            # Light camera
            self._light_camera = h3d.addCameraNode(self._light, "light_camera", h3dres.deferredPipe2)
            h3d.setNodeParamI(self._light_camera, h3d.Camera.OutTexResI, h3dres.cmap)
            h3d.setNodeParamI(self._light_camera, h3d.Camera.ViewportXI, 0)
            h3d.setNodeParamI(self._light_camera, h3d.Camera.ViewportXI, 0)
            h3d.setNodeParamI(self._light_camera, h3d.Camera.ViewportWidthI, self.cmap_size)
            h3d.setNodeParamI(self._light_camera, h3d.Camera.ViewportHeightI, self.cmap_size)
            h3d.resizePipelineBuffers(h3dres.deferredPipe2, self.cmap_size, self.cmap_size )
            h3d.setupCameraView(self._light_camera, self.light_fov, 1.0, 0.1, 1000.0)
            # Update ligth shader uniforms
            self.update_cmap_res()

        # Create volume data
        self._vol = h3d.addNodes(h3d.RootNode, h3dres.volBox)
        self._sphdata = h3d.getNodeParamI(self._vol, 20000) # for VolumeResI = 20000

        # Add a camera
        self.add_camera("MainCamera", h3dres.deferredPipe)
        h3d.setNodeTransform(self.camera, 0.68, 5.14, -4.56, -51, 160, 3.88, 1, 1, 1)
        # h3d.setNodeTransform(self.camera, -2.0, 1.2, -6.5, -13, -170, 0, 1, 1, 1)
        #h3d.setNodeTransform(self.camera, -0.8, 1.06, -1.08, -41, -154, -6.4, 1, 1, 1)
        #h3d.setNodeTransform(self.camera, -0.32, 0.23, -0.54, -19, -174, -0.01, 1, 1, 1)
        self.__mode = 0