Example #1
0
 def transform(self, xform):
     transl = Mat4(Mat4.identMat())
     transl.setRow(3, xform.getRow3(3))
     self.path.setMat(render, transl * self.originalMat)
     self._fixScale()
     xform.setRow(3, Vec3())
     for client, originalMat in self.clients:
         #client.setMat(self.path, originalMat * xform)
         client.setMat(originalMat * xform * transl * self.originalMat)
Example #2
0
 def transform(self, xform):
     transl = Mat4(Mat4.identMat())
     transl.setRow(3, xform.getRow3(3))
     self.path.setMat(render, transl * self.originalMat)
     self._fixScale()
     xform.setRow(3, Vec3())
     for client, originalMat in self.clients:
         #client.setMat(self.path, originalMat * xform)
         client.setMat(originalMat * xform * transl * self.originalMat)
Example #3
0
 def __init__(self, water_options):
     self.water_options = water_options
     self.water_level = 0.0
     self.model = Globals.base.loader.load_model(
         "/$$rp/data/builtin_models/water/water_grid.bam")
     self.model.reparent_to(Globals.base.render)
     self.model.node().set_final(True)
     self.model.node().set_bounds(OmniBoundingVolume())
     self.model.set_two_sided(True)
     self.model.set_shader_input("waterHeight", self.water_level)
     self.model.set_mat(Mat4.identMat())
     self.model.clear_transform()
    def __init__(self, pipeline):
        DebugObject.__init__(self, "ProjectedWaterGrid")
        self.debug("Creating water grid")

        self.waterLevel = 0.0

        self.model = Globals.loader.loadModel(
            "Data/InternalModels/ScreenSpaceGrid.bam")
        self.model.reparentTo(Globals.base.render)
        self.model.node().setFinal(True)
        self.model.node().setBounds(OmniBoundingVolume())
        self.model.setTwoSided(True)
        self.model.setShaderInput("waterHeight", self.waterLevel)
        self.model.setMat(Mat4.identMat())
        self.model.clearTransform()

        foam = Globals.loader.loadTexture("Data/Textures/WaterFoam.png")
        self.model.setShaderInput("waterFoam", foam)

        self.manager = WaterManager()
        self.manager.setup()
        self.manager.update()

        self.model.setShaderInput("waterHeightfield",
                                  self.manager.getDisplacementTexture())
        self.model.setShaderInput("waterNormal",
                                  self.manager.getNormalTexture())

        # Set texture filter modes
        for tex in [
                foam,
                self.manager.getDisplacementTexture(),
                self.manager.getNormalTexture()
        ]:
            tex.setWrapU(SamplerState.WMRepeat)
            tex.setWrapU(SamplerState.WMRepeat)
            tex.setMinfilter(SamplerState.FTLinearMipmapLinear)
            tex.setMagfilter(SamplerState.FTLinearMipmapLinear)

        self.pipeline = pipeline

        self.pipeline.setEffect(
            self.model,
            "Effects/Water/ProjectedWater.effect",
            {
                # "transparent": True
                "castShadows": False
                # "tesselated": True
            })

        # pipeline.convertToPatches(self.model)
        pipeline.showbase.addTask(self.updateTask, "updateWater")
Example #5
0
 def beginTransformation(self):
     self.originalMat = Mat4(Mat4.identMat())
     self.originalMat.setRow(3, self.path.getMat(render).getRow(3))
     self.originalMatInv = Mat4()
     self.originalMatInv.invertAffineFrom(self.originalMat)
     for i in xrange(len(self.clients)):
         print 'Their matrix * My matrix'
         print self.clients[i][0].getMat(self.path) * self.path.getMat()
         print 'Total matrix:'
         print self.clients[i][0].getMat()
         #self.clients[i][1] = self.clients[i][0].getMat(self.path)
         self.clients[i][1] = (self.clients[i][0].getMat() *
                 self.originalMatInv)
Example #6
0
 def beginTransformation(self):
     self.originalMat = Mat4(Mat4.identMat())
     self.originalMat.setRow(3, self.path.getMat(render).getRow(3))
     self.originalMatInv = Mat4()
     self.originalMatInv.invertAffineFrom(self.originalMat)
     for i in xrange(len(self.clients)):
         print 'Their matrix * My matrix'
         print self.clients[i][0].getMat(self.path) * self.path.getMat()
         print 'Total matrix:'
         print self.clients[i][0].getMat()
         #self.clients[i][1] = self.clients[i][0].getMat(self.path)
         self.clients[i][1] = (self.clients[i][0].getMat() *
                               self.originalMatInv)
    def __init__(self, pipeline):
        DebugObject.__init__(self, "ProjectedWaterGrid")
        self.debug("Creating water grid")

        self.waterLevel = 0.0

        self.model = Globals.loader.loadModel("Data/InternalModels/ScreenSpaceGrid.bam")
        self.model.reparentTo(Globals.base.render)
        self.model.node().setFinal(True)
        self.model.node().setBounds(OmniBoundingVolume())
        self.model.setTwoSided(True)
        self.model.setShaderInput("waterHeight", self.waterLevel)
        self.model.setMat(Mat4.identMat())
        self.model.clearTransform()

        foam = Globals.loader.loadTexture("Data/Textures/WaterFoam.png")
        self.model.setShaderInput("waterFoam", foam)       

        self.manager = WaterManager()
        self.manager.setup()
        self.manager.update()
        
        self.model.setShaderInput("waterHeightfield", self.manager.getDisplacementTexture())       
        self.model.setShaderInput("waterNormal", self.manager.getNormalTexture())       

        # Set texture filter modes
        for tex in [foam, self.manager.getDisplacementTexture(), self.manager.getNormalTexture()]:
            tex.setWrapU(SamplerState.WMRepeat)
            tex.setWrapU(SamplerState.WMRepeat)
            tex.setMinfilter(SamplerState.FTLinearMipmapLinear)
            tex.setMagfilter(SamplerState.FTLinearMipmapLinear)

        self.pipeline = pipeline

        self.pipeline.setEffect(self.model, "Effects/Water/ProjectedWater.effect", {
            # "transparent": True
            "castShadows": False
            # "tesselated": True
        })

        # pipeline.convertToPatches(self.model)
        pipeline.showbase.addTask(self.updateTask, "updateWater")
Example #8
0
    def check_mouse1drag_trackball(self):
        """
        This function uses the stereographic projection
        introduced in https://en.wikipedia.org/wiki/Stereographic_projection to track the rotational mouse motion
        Equations:
        [e, f] -> [x, y, z] = [2e/(1+e^2+f^2), 2f/(1+e^2+f^2), (-1+e^2+f^2)/(2+2e^2+2f^2)]

        :return:

        author: weiwei
        date: 20200315
        """
        def cvtvirtualtrackball(screenx, screeny, psec_squared=1 / 4):
            """
            convert a screen point to virtual trackball coordinate
            psec indicates the size of the spherical section to be mapped to
            default radius = 1

            :param screenx:
            :param screeny:
            :param psec_squared:
            :return:

            author: weiwei
            date: 20200315
            """

            screenpoint_squaredsum = screenx**2 + screeny**2
            trackballx = 2 * psec_squared * screenx / (psec_squared +
                                                       screenpoint_squaredsum)
            trackballz = 2 * psec_squared * screeny / (psec_squared +
                                                       screenpoint_squaredsum)
            trackbally = -math.sqrt(1 - trackballx**2 - trackballz**2)
            returnvec = Vec3(trackballx, trackbally, trackballz)
            returnvec.normalize()
            return returnvec

        currentmouse = self.base.mouseWatcherNode.getMouse()
        curm1pos = [currentmouse.getX(), currentmouse.getY()]
        if curm1pos is None:
            if self.lastm1pos is not None:
                self.lastm1pos = None
            return
        if self.lastm1pos is None:
            # first time click
            self.lastm1pos = curm1pos
            return
        curm1vec_pdv3 = cvtvirtualtrackball(curm1pos[0], curm1pos[1])
        lastm1vec_pdv3 = cvtvirtualtrackball(self.lastm1pos[0],
                                             self.lastm1pos[1])
        rotatevec_pdv3 = curm1vec_pdv3.cross(lastm1vec_pdv3)
        rotateangle = curm1vec_pdv3.signedAngleDeg(lastm1vec_pdv3,
                                                   rotatevec_pdv3)
        if rotateangle > .02 or rotateangle < -.02:
            rotateangle = rotateangle * 5
            camrotmat_pd = self.base.cam.getMat().getUpper3()
            calibrated_camrotmat_pd = Mat3.rotateMat(
                rotateangle, camrotmat_pd.xformVec(rotatevec_pdv3))
            posvec_pd = self.base.cam.getPos()
            self.base.cam.setMat(Mat4.identMat())
            self.base.cam.setMat(camrotmat_pd * calibrated_camrotmat_pd)
            self.base.cam.setPos(
                calibrated_camrotmat_pd.xform(posvec_pd -
                                              self.lookatpos_pdv3) +
                self.lookatpos_pdv3)
            self.lastm1pos = curm1pos[:]