def Torus(mNumSegSection=64, mNumSegCircle=64, mRadius=1.0,
          mSectionRadius=0.2):
    (gvw, prim, geom, path) = empty('t')

    deltaSection = (pi * 2 / mNumSegSection)
    deltaCircle = (pi * 2 / mNumSegCircle)

    offset = 0

    for i in range(0, mNumSegCircle + 1):
        for j in range(0, mNumSegSection + 1):
            v0 = Vec3(mRadius + mSectionRadius * cos(j * deltaSection),
                      mSectionRadius * sin(j * deltaSection), 0.0)
            q = Quat()
            q.setFromAxisAngleRad(i * deltaCircle, Vec3(0, 1, 0))
            v = q.xform(v0)

            gvw.addData3f(v)

            if i != mNumSegCircle:
                prim.addVertices(offset + mNumSegSection + 1, offset,
                                 offset + mNumSegSection)
                prim.addVertices(offset + mNumSegSection + 1, offset + 1,
                                 offset)
            offset += 1

    prim.closePrimitive()
    geom.addPrimitive(prim)

    return path
    def drawItem(self, drawResourcesFactories, x, y, tileCenter, collision, seed=True, scale=1.0):
        v = drawResourcesFactories.values()
        if len(v) < 1:
            return
        tile = v[0].getTile()

        if seed:
            random.seed((x, y))
        exists = random.random()
        if exists < 0.9:
            return

        quat = Quat()
        quat.setHpr((random.random() * 360, 0, 0))

        height = tile.height(x, y)
        if height is None:
            return

        heightOffset = -0.4  # make sure whole bottom of tree is in ground
        pos = Vec3(x, y, height + heightOffset) - tileCenter

        self.drawTree(
            (pos, quat, 0, list(0 for x in drawResourcesFactories.iterkeys()), 0),
            drawResourcesFactories,
            collision,
            scale=scale,
        )
示例#3
0
 def __quatFromTo(self, v0, v1):
     print (v0, v1)
     q = Quat(
         sqrt(v0.length()**2 * v1.length()**2) + v0.dot(v1),
         v0.cross(v1))
     q.normalize()
     return q
def _randomBend(inQuat, maxAngle=20):
    q=Quat()
    angle=random.random()*2*math.pi
    
    #power of 1/2 here makes distrobution even withint a circle
    # (makes larger bends are more likley as they are further spread) 
    ammount=(math.sqrt(random.random()))*maxAngle
    q.setHpr((math.sin(angle)*ammount,math.cos(angle)*ammount,0))
    return inQuat*q
def _angleRandomAxis(inQuat, angle, maxAngle): 
    q=Quat()
    angleRange=0.125
    nangle = angle + math.pi * (angleRange * random.random() - angleRange/2) 
    #power of 1/2 here makes distrobution even withint a circle
    # (makes larger bends are more likley as they are further spread) 
    ammount=(random.random()**(1.0/2))*maxAngle
    q.setHpr((math.sin(nangle)*ammount,math.cos(nangle)*ammount,0))
    return inQuat*q
def create_colliders(root, pose_rig, joints_config):
    for node, parent in pose_rig.exposed_joints:
        if node.getName() not in joints_config:
            continue

        joint_config = joints_config[node.getName()]
        if "joints" not in joint_config:
            continue

        joints = joint_config["joints"]
        if len(joints) == 0:
            continue

        mass = joint_config["mass"] if "mass" in joint_config else 1

        box_rb = BulletRigidBodyNode(node.getName())
        box_rb.setMass(1.0)
        # box_rb.setLinearDamping(0.2)
        # box_rb.setAngularDamping(0.9)
        # box_rb.setFriction(1.0)
        # box_rb.setAnisotropicFriction(1.0)
        # box_rb.setRestitution(0.0)

        for joint in joints:
            child_node, child_parent = next(
                (child_node, child_parent)
                for child_node, child_parent in pose_rig.exposed_joints
                if child_node.getName() == joint
            )

            pos = child_node.getPos(child_parent)
            width = pos.length() / 2.0
            scale = Vec3(3, width, 3)

            shape = BulletBoxShape(scale)

            quat = Quat()
            lookAt(quat, child_node.getPos(child_parent), Vec3.up())
            if len(joints) > 1:
                transform = TransformState.makePosHpr(child_node.getPos(child_parent) / 2.0, quat.getHpr())
            else:
                transform = TransformState.makeHpr(quat.getHpr())

            box_rb.addShape(shape, transform)

        box_np = root.attachNewNode(box_rb)

        if len(joints) > 1:
            pos = node.getPos(pose_rig.actor)
            hpr = node.getHpr(pose_rig.actor)
            box_np.setPosHpr(root, pos, hpr)
        else:
            box_np.setPos(child_parent, child_node.getPos(child_parent) / 2.0)
            box_np.lookAt(child_parent, child_node.getPos(child_parent))

        yield box_np
示例#7
0
 def rotateAround(self, node, point, axis, angle, relative):
     quat = Quat()
     quat.setFromAxisAngle(angle, render.getRelativeVector(relative, axis))
     
     relativePos = node.getPos(render) - point
     relativePosRotated = quat.xform(relativePos)
     absolutePosRotated = relativePosRotated + point
     
     node.setPos(render, absolutePosRotated)
     node.setQuat(render, node.getQuat(render) * quat)
示例#8
0
文件: animation.py 项目: buguen/minf
  def checkSocket(self, task):
      r_read, r_write, r_error = select.select([self.udpSocket],[],[],0)

      while r_read:
          msg = self.udpSocket.recv(1024)
          #print msg
          msg_list = msg.split(',')
          node_id = int(msg_list[0])
          [w, x, y, z] = [float(val) for val in msg_list[1:5]]
          seqNum = int(msg_list[5])
          #print seqNum
          q = Quat()
          q.setR(w)
          q.setI(x)
          q.setJ(y)
          q.setK(z)

          self.jointCur[mapping[node_id]] = q

          # update root
          root = jointNames[0]
          self.joints[root].setQuat(self.modelQ[root]*(self.jointCal[root]*self.jointCur[root]))

          #other joints
          for name in jointNames[1:]:
              parentName = parents[name]
              _q = self.jointCal[parentName]*self.jointCur[parentName]
              _q = _q.conjugate()
              self.joints[name].setQuat((self.jointCal[name]*self.jointCur[name])*_q*self.modelQ[name])

          r_read, r_write, r_error = select.select([self.udpSocket],[],[],0)
      return Task.cont
示例#9
0
 def guide_missile(self, task):
     try:
         quat = Quat()
         lookAt(quat, self.target.np.getPos() - self.missile.anp.getPos(), Vec3.up())
         self.missile.anp.setQuat(quat)
         fwd = quat.getForward()
         fwd.normalize()
         mvel = self.missile.anpo.getVelocity().length()
         self.missile.anpo.setVelocity(fwd*mvel)
     except:
         return task.done
     return task.cont
示例#10
0
文件: net2.py 项目: wezu/a3p-koparka
class EntitySnapshot(net.Object):
    def __init__(self):
        self.pos = Vec3()
        self.quat = Quat()
        self.time = 0
        self.empty = True

    def takeSnapshot(self, entity):
        self.pos = entity.getPosition()
        self.quat = Quat(entity.getQuaternion())
        self.time = engine.clock.time
        self.empty = False

    def addTo(self, datagram):
        pos = HighResVec3(self.pos)
        quat = StandardQuat(self.quat)
        pos.addTo(datagram)
        quat.addTo(datagram)
        
    @staticmethod
    def getFrom(iterator):
        es = EntitySnapshot()
        es.pos = HighResVec3.getFrom(iterator)
        es.quat = StandardQuat.getFrom(iterator)
        es.time = engine.clock.time
        es.empty = False
        return es
    
    def commitTo(self, entity):
        entity.setQuaternion(self.quat)
        entity.setPosition(self.pos)
    
    def lerp(self, snapshot, scale):
        result = EntitySnapshot()
        result.pos = self.pos + ((snapshot.pos - self.pos) * scale)
        result.quat = self.quat + ((snapshot.quat - self.quat) * scale)
        result.empty = False
        return result

    def setFrom(self, snapshot):
        self.pos = Vec3(snapshot.pos)
        self.quat = Quat(snapshot.quat)
        self.time = engine.clock.time
        self.empty = snapshot.empty
    
    def almostEquals(self, snapshot):
        return self.quat.almostEqual(snapshot.quat, 2) and self.pos.almostEqual(snapshot.pos, 0.2)
示例#11
0
    def drawItem(self,
                 LOD,
                 x,
                 y,
                 drawResourcesFactory,
                 tile,
                 tileCenter,
                 collision,
                 seed=True,
                 scale=1.0):
        if seed: random.seed((x, y))
        exists = random.random()
        if exists < .6: return
        quat = Quat()

        height = tile.height(x, y)
        if height is None: return

        pos = Vec3(x, y, height) - tileCenter
        self.drawFern(LOD, pos, quat, drawResourcesFactory, scale=scale)
示例#12
0
 def drag(self, task):
     if not base.mouseWatcherNode.hasMouse():
         return Task.cont
     
     curMouseCoord = (base.mouseWatcherNode.getMouseX(), base.mouseWatcherNode.getMouseY())
     delta = (curMouseCoord[0] - self.initialMouseCoord[0], curMouseCoord[1] - self.initialMouseCoord[1])
     
     xQuat = Quat()
     xQuat.setFromAxisAngle(delta[0] * self.SCALE, Vec3(0,0,1))
     
     yQuat = Quat()
     yQuat.setFromAxisAngle(delta[1] * self.SCALE * -1, Vec3(1,0,0))
     
     self.node.setQuat(base.cam, self.initialQuat * xQuat * yQuat)
     
     return Task.cont
示例#13
0
    def solve(self, task):
        self.H_base = self.objH_base.H_abs
        # based on current calue of H_body, calculate the homogeneous coordinates in the next step 
        # via the 4x4 exponential map.
        self.H_body = Lib.expm.SE3_TO_SE3(self.H_body, Lib.adjoint.ad_mul(self.H_body, self.Twist), self.timestep)
        #self.H_body = Lib.expm.SE3_TO_SE3(self.H_body, self.Twist, self.timestep)
        #calculate the h-matrix as a product of its internal mapping and the base coordinat frame
        self.H_abs =     self.H_body * self.H_base  # ToDo: implement with inverse hom. coordinates? mapping back to world observer?????

        if self.initialize:
            print("Name: ", self.name)
            print("\tH_base: from '{}' to '{}'".format(self.H_base.low, self.H_base.upp))
            print("\tH_body: from '{}' to '{}'".format(self.H_body.low, self.H_body.upp))
            print("\tH_abs: from '{}' to '{}'".format(self.H_abs.low, self.H_abs.upp))
            self.initialize = False

        RotMat, p = Lib.h2rp(self.H_abs.mat)
        R = Rot.from_matrix(RotMat)
        quat = R.as_quat()
        self.body.setQuat(Quat(quat[3], quat[0], quat[1], quat[2]))
        self.body.setPos(p[0], p[1], p[2])
        return Task.cont
 def SetCamera(self, pos, targ=chrono.ChVectorD()):
     
     delta = targ - pos
     q0 = chrono.ChQuaternionD()
     q0.Q_from_AngAxis(-math.pi/2, chrono.VECT_X)
     
     alpha = 0   
     if (delta.z <= 0 and delta.x != 0):
            alpha = -math.asin(delta.x/math.hypot(delta.x, delta.z))
     if (delta.z > 0):
            alpha = math.asin(delta.x/math.hypot(delta.x, delta.z)) + math.pi
     q1 = chrono.ChQuaternionD()
     q1.Q_from_AngAxis(alpha, q0.GetZaxis())
     q2 = chrono.ChQuaternionD()
     q2 = q1*q0
     beta = math.asin(delta.y/delta.Length())
     q3 = chrono.ChQuaternionD()
     q3.Q_from_AngAxis(beta, q2.GetXaxis())
     qc = chrono.ChQuaternionD()
     qc = q3*q2
     q = Quat(qc.e0, qc.e1, qc.e2, qc.e3)
     camera.setQuat(q)
     camera.setPos(pos.x, pos.y, pos.z)
示例#15
0
    def update_scene(self, scene_graph, materials_only):
        """Update a scene using scene_graph description

        Arguments:
            scene_graph {SceneGraph} -- scene description
            materials_only {bool} -- update only shape materials
        """
        for k, v in scene_graph.nodes.items():
            node = self.render.attachNewNode(f'node_{k:02d}')
            self.nodes[k] = node

            for j, shape in enumerate(v.shapes):
                if shape.type == ShapeType.Mesh:
                    filename = shape.mesh.filename
                elif shape.type == ShapeType.Cube:
                    filename = 'cube.obj'
                else:
                    print('Unknown shape type: {}'.format(shape.type))
                    continue

                # load model
                model = self.loader.load_model(filename)

                if shape.material is not None:
                    # set material
                    material = Material()
                    material.setAmbient(Vec4(*shape.material.diffuse_color))
                    material.setDiffuse(Vec4(*shape.material.diffuse_color))
                    material.setSpecular(Vec3(*shape.material.specular_color))
                    material.setShininess(5.0)
                    model.setMaterial(material, 1)

                # set relative position
                model.reparentTo(node)
                model.setPos(*shape.pose.origin)
                model.setQuat(Quat(*shape.pose.quat))
                model.setScale(*shape.pose.scale)
示例#16
0
 def make_fixed(np0, np1, type_=BulletGenericConstraint, cfm=0.01, erp=.99):
     """ Make a joint and return it."""
     t0 = np0.getTop()
     t1 = np1.getTop()
     p0 = np0.getPos(t0)
     p1 = np1.getPos(t1)
     q0 = np0.getQuat(t0)
     q1 = np1.getQuat(t1)
     pivot = Point3((p0 + p1) / 2.)
     disp = Point3((p1 - p0) / 2.)
     pivot_np = t0.attachNewNode("pivot-node")
     pivot_np.setPos(pivot)
     s = Vec3(1, 1, 1)
     q = Quat.identQuat()  # pivot_np.getQuat(t0)  #
     #BP()
     # q0 = pivot_np.getQuat(np0)
     # q1 = pivot_np.getQuat(np1)
     q0i = Quat(q0)
     q1i = Quat(q1)
     #BP()
     q0i.invertInPlace()
     q1i.invertInPlace()
     q0i *= q
     q1i *= q
     #BP()
     ts0 = TransformState.makePosQuatScale(disp, q0i, s)
     ts1 = TransformState.makePosQuatScale(-disp, q1i, s)
     pivot_np.removeNode()
     # Create the joint.
     joint = type_(np0.node(), np1.node(), ts0, ts1, False)
     for ax in xrange(4):
         joint.setAngularLimit(ax, 0, 0)
         joint.setLinearLimit(ax, 0, 0)
     joint.setParam(type_.CPErp, erp)
     joint.setParam(type_.CPCfm, cfm)
     joint.setDebugDrawSize(2)
     return joint
示例#17
0
def getUnitCircle():
    global UnitCircle
    if not UnitCircle:
        segs = LineSegs('unitCircle')
        vertices = LEUtils.circle(0, 0, 1, 64)
        angles = [Vec3(0, 0, 0), Vec3(90, 0, 0), Vec3(0, 90, 0)]
        for angle in angles:
            quat = Quat()
            quat.setHpr(angle)
            for i in range(len(vertices)):
                x1, y1 = vertices[i]
                x2, y2 = vertices[(i + 1) % len(vertices)]
                pFrom = quat.xform(Vec3(x1, 0, y1))
                pTo = quat.xform(Vec3(x2, 0, y2))
                segs.moveTo(pFrom)
                segs.drawTo(pTo)
        UnitCircle = NodePath(segs.create())
        UnitCircle.setAntialias(AntialiasAttrib.MLine)
        UnitCircle.setLightOff(1)
        UnitCircle.setFogOff(1)
        UnitCircle.hide(DirectRender.ShadowCameraBitmask
                        | DirectRender.ReflectionCameraBitmask)
    return UnitCircle
示例#18
0
    def drawFern(self, LOD, pos, quat, drawResourcesFactory, scale=1.0):
        scalar = random.random()
        scale *= scalar

        if scale < .3: return

        count = int((scalar**.7) * 12)

        if scale < .8:
            if LOD == self.lowLOD: return
        else:
            if LOD == self.midLOD: return

        leafResources = drawResourcesFactory.getDrawResources(
            self.leafDataIndex[LOD])
        leafTri = leafResources.getGeomTriangles()
        vertexWriter = leafResources.getWriter("vertex")
        normalWriter = leafResources.getWriter("normal")

        if self.leafTexture:
            texcoordWriter = leafResources.getWriter("texcoord")

        scale *= self.scalar * 3

        q2 = Quat()
        q3 = Quat()

        for i in xrange(count):
            p = (random.random()**2) * 60 + 20
            h = random.random() * 360
            q2.setHpr((h, p, 0))
            q3.setHpr((h, p - 20 - p / 4, 0))

            length1 = scale * 4
            length2 = scale * 3

            f = q2.getForward() * length1
            r = q2.getRight() * scale * .5
            f2 = q3.getForward() * length2 + f
            norm0 = q2.getUp()
            norm2 = q3.getUp()
            norm1 = norm0 + norm2
            norm1.normalize()

            for x in range(2):
                leafRow = vertexWriter.getWriteRow()

                vertexWriter.addData3f(pos)
                vertexWriter.addData3f(pos + f + r)
                vertexWriter.addData3f(pos + f - r)
                vertexWriter.addData3f(pos + f2)

                if self.leafTexture:
                    texcoordWriter.addData2f(0, 0)
                    texcoordWriter.addData2f(0, 1)
                    texcoordWriter.addData2f(1, 0)
                    texcoordWriter.addData2f(1, 1)

                if x == 1:
                    # back sides
                    norm0 = -norm0
                    norm1 = -norm1
                    norm2 = -norm2
                    leafTri.addVertices(leafRow + 1, leafRow, leafRow + 2)
                    leafTri.addVertices(leafRow + 3, leafRow + 1, leafRow + 2)
                else:
                    leafTri.addVertices(leafRow, leafRow + 1, leafRow + 2)
                    leafTri.addVertices(leafRow + 1, leafRow + 3, leafRow + 2)

                normalWriter.addData3f(norm0)
                normalWriter.addData3f(norm1)
                normalWriter.addData3f(norm1)
                normalWriter.addData3f(norm2)
def getRotationTo(src, dest, fallbackAxis=Vec3_ZERO):
    # Quaternion q;
    # Vector3 v0 = *this;
    # Vector3 v1 = dest;
    # v0.normalise();
    # v1.normalise();
    q = Quat()
    v0 = Vec3(src)
    v1 = Vec3(dest)
    v0.normalize()
    v1.normalize()

    # Real d = v0.dotProduct(v1);
    d = v0.dot(v1)

    # if (d >= 1.0f)
    # {
    # return Quaternion::IDENTITY;
    # }
    if d >= 1.0:
        return Quat(1, 0, 0, 0)

    # if (d < (1e-6f - 1.0f))
    if d < (1.0e-6 - 1.0):
        # if (fallbackAxis != Vector3::ZERO)
        # {
        # // rotate 180 degrees about the fallback axis
        # q.FromAngleAxis(Radian(Math::PI), fallbackAxis);
        # }
        if fallbackAxis != Vec3_ZERO:
            q.setFromAxisAngleRad(pi, fallbackAxis)
        # else
        # {
        # // Generate an axis
        # Vector3 axis = Vector3::UNIT_X.crossProduct(*this);
        # if (axis.isZeroLength()) // pick another if colinear
        # axis = Vector3::UNIT_Y.crossProduct(*this);
        # axis.normalise();
        # q.FromAngleAxis(Radian(Math::PI), axis);
        # }
        else:
            axis = Vec3(1, 0, 0).cross(src)
            if axis.almostEqual(Vec3.zero()):
                axis = Vec3(0, 1, 0).cross(src)
            axis.normalize()
            q.setFromAxisAngleRad(pi, axis)
        # else
        # {
        # Real s = Math::Sqrt( (1+d)*2 );
        # Real invs = 1 / s;

        # Vector3 c = v0.crossProduct(v1);

        # q.x = c.x * invs;
        # q.y = c.y * invs;
        # q.z = c.z * invs;
        # q.w = s * 0.5f;
        # q.normalise();
    # }
    else:
        s = sqrt((1 + d) * 2)
        invs = 1 / s
        c = v0.cross(v1)
        q.setI(c.x * invs)
        q.setJ(c.y * invs)
        q.setK(c.z * invs)
        q.setR(s * .5)
        q.normalize()
    return q
示例#20
0
    def alignCarTowardsForceField(self, dt, p0, p1):
        modelPos = self.model.getPos()
        path = self.pointSegmentShortestPath(modelPos,
                                             p1,
                                             p0,
                                             bounds=True,
                                             boundsNone=True)

        if path is None:
            return None

        Len = path.length()

        if Len < 0.2:
            Len = 0.2

        delta = 100.0
        vec = (p1 - p0).normalized()
        vec *= delta

        originalQuat = self.model.getQuat()
        quat = Quat(originalQuat)
        other_quat = Quat(originalQuat)
        lookAt(quat, vec, Vec3().up())
        lookAt(other_quat, -vec, Vec3().up())

        if not quat.almostSameDirection(originalQuat, 0.5):
            [p0, p1] = [p1, p0]
            vec = (p0 - p1).normalized() * delta
            quat = other_quat

        if not quat.almostSameDirection(originalQuat, 0.5):
            return None

        # Make car go more towards the selected path at intersection
        angleSimilarityFactor = abs(
            self.direction.normalized().dot(vec.normalized()) + path.length())

        # Go closer to road
        pos_strength = dt * angleSimilarityFactor
        pos_strength /= (Len * Len) if Len > 1.0 else 1.0

        pos_strength *= ROAD_POS_STRENGTH
        pos_strength = sorted([0, pos_strength, 1])[1]

        position = modelPos - path * pos_strength

        strength = ALIGN_STRENGTH * dt / ((Len * Len) if Len > 1 else 1)
        strength = sorted([0, strength, 1])[1]
        self.car_shadow.setPos(self.model.getPos())
        self.car_shadow.setHpr(self.model.getHpr())
        self.model.setQuat(quat)
        targetHpr = self.model.getHpr(self.car_shadow)
        self.model.setQuat(originalQuat)
        currentHpr = self.model.getHpr(self.car_shadow)
        self.model.setHpr(self.car_shadow,
                          targetHpr * strength + currentHpr * (1.0 - strength))
        quat = self.model.getQuat()

        # Put velocity in direction of road
        blend_velocity = BLEND_VELOCITY_FAC_TOWARDS_ROAD * dt
        velocity = self.velocity.project(vec) * (
            blend_velocity) + self.velocity * (1.0 - blend_velocity)

        self.model.setPos(position)
        self.model.setQuat(quat)
        self.velocity = velocity
示例#21
0
def fixQuat(quat):

    quat = (-quat[0], quat[1], quat[2], quat[3])
    return Quat(*quat)
示例#22
0
 def takeSnapshot(self, entity):
     self.pos = entity.getPosition()
     self.quat = Quat(entity.getQuaternion())
     self.time = engine.clock.time
     self.empty = False
示例#23
0
 def getFrom(iterator):
     return Quat(net.StandardFloat.getFrom(iterator),
                 net.StandardFloat.getFrom(iterator),
                 net.StandardFloat.getFrom(iterator),
                 net.StandardFloat.getFrom(iterator))
示例#24
0
    def __init__(self):
        DirectObject.__init__(self)

        self.mouseEnabled = False

        self.lastCamRoot2Quat = Quat(Quat.identQuat())

        self.punchAngleVel = Vec3(0)
        self.punchAngle = Vec3(0)

        self.lastFacing = Vec3(0)

        self.lastMousePos = Point2(0)
        self.currMousePos = Point2(0)

        self.bobTime = 0
        self.lastBobTime = 0

        self.lastVMPos = Point3(0)

        self.camRoot = NodePath("camRoot")
        self.camRoot2 = self.camRoot.attachNewNode("camRoot2")
        self.lastPitch = 0

        self.lastEyeHeight = 0.0

        # Updates to the transform of camRoot
        self.vmRender = NodePath(
            BSPRender('vmRender', BSPLoader.getGlobalPtr()))
        self.vmRender.setShaderAuto()
        self.vmRoot = self.vmRender.attachNewNode('vmRoot')
        self.vmRoot2 = self.vmRoot.attachNewNode(ModelRoot('vmRoot2'))
        self.viewModel = Actor(
            "phase_14/models/char/v_toon_arms.bam",
            {
                "zero": "phase_14/models/char/v_toon_arms.egg",

                # Squirt gun viewmodel animations
                "sg_draw": "phase_14/models/char/v_toon_arms-draw.egg",
                "sg_idle": "phase_14/models/char/v_toon_arms-idle.egg",
                "sg_inspect": "phase_14/models/char/v_toon_arms-inspect.egg",
                "sg_shoot_begin":
                "phase_14/models/char/v_toon_arms-shoot_begin.egg",
                "sg_shoot_loop":
                "phase_14/models/char/v_toon_arms-shoot_loop.egg",
                "sg_shoot_end":
                "phase_14/models/char/v_toon_arms-shoot_end.egg",
                "pie_draw": "phase_14/models/char/v_toon_arms-pie_draw.egg",
                "pie_idle": "phase_14/models/char/v_toon_arms-pie_idle.egg",
                "button_draw":
                "phase_14/models/char/v_toon_arms-button_draw.egg",
                "button_idle":
                "phase_14/models/char/v_toon_arms-button_idle.egg",
                "button_press":
                "phase_14/models/char/v_toon_arms-button_press.egg",
                "gumball_draw":
                "phase_14/models/char/v_toon_arms-gumball_draw.egg",
                "gumball_idle":
                "phase_14/models/char/v_toon_arms-gumball_idle.egg",
                "gumball_fire":
                "phase_14/models/char/v_toon_arms-gumball_fire.egg",
                "hose_draw": "phase_14/models/char/v_toon_arms-hose_draw.egg",
                "hose_idle": "phase_14/models/char/v_toon_arms-hose_idle.egg",
                "hose_shoot_begin":
                "phase_14/models/char/v_toon_arms-hose_shoot_begin.egg",
                "hose_shoot_loop":
                "phase_14/models/char/v_toon_arms-hose_shoot_loop.egg",
                "hose_shoot_end":
                "phase_14/models/char/v_toon_arms-hose_shoot_end.egg",
                "tnt_draw": "phase_14/models/char/v_toon_arms-tnt_draw.egg",
                "tnt_idle": "phase_14/models/char/v_toon_arms-tnt_idle.egg",
                "tnt_throw": "phase_14/models/char/v_toon_arms-tnt_throw.egg",
                "slap_idle": "phase_14/models/char/v_toon_arms-slap_idle.egg",
                "slap_hit": "phase_14/models/char/v_toon_arms-slap_hit.egg",
                "sound": "phase_14/models/char/v_toon_arms-sound.egg"
            })
        self.viewModel.setBlend(
            frameBlend=base.config.GetBool("interpolate-frames", False))
        self.viewModel.reparentTo(self.vmRoot2)
        self.viewModel.find("**/hands").setTwoSided(True)
        self.viewModel.hide()

        self.defaultViewModel = self.viewModel
        self.idealFov = self.ViewModelFOV

        precacheActor(self.viewModel)
        #self.viewModel.clearMaterial()
        #self.viewModel.setMaterial(CIGlobals.getCharacterMaterial(specular = (0, 0, 0, 1)), 1)
        self.viewportLens = PerspectiveLens()
        self.viewportLens.setMinFov(self.ViewModelFOV / (4. / 3.))
        self.viewportLens.setNear(0.3)
        # Updates to the transform of base.camera
        self.viewportCam = base.makeCamera(base.win,
                                           clearDepth=True,
                                           camName='fpsViewport',
                                           mask=CIGlobals.ViewModelCamMask,
                                           lens=self.viewportLens)
        # Pretend to be the main camera so the viewmodel gets ambient probes updated
        self.viewportCam.node().setTag("__mainpass__", "1")
        self.viewportCam.reparentTo(self.vmRoot)

        self.vmGag = None
        self.vmAnimTrack = None
        self.dmgFade = OnscreenImage(image="phase_14/maps/damage_effect.png",
                                     parent=render2d)
        self.dmgFade.setBin('gui-popup', 100)
        self.dmgFade.setTransparency(1)
        self.dmgFade.setColorScale(1, 1, 1, 0)
        self.dmgFadeIval = None

        #self.accept('v', self.vmRender.ls)

        #base.bspLoader.addDynamicNode(self.vmRoot)

        if self.PrintAnimLengths:
            print "v_toon_arms animation lengths:"
            for anim in self.viewModel.getAnimNames():
                print "\t{0}\t:\t{1}".format(anim,
                                             self.viewModel.getDuration(anim))

        taskMgr.add(self.__vpDebugTask, "vpdebutask", sort=-100)
示例#25
0
def getUpHPR(hpr):
    q = Quat()
    q.setHpr(VBase3(math.degrees(hpr.h), math.degrees(hpr.p),
                math.degrees(hpr.r)))
    v = q.getUp()
    return SP3(v.x, v.y, v.z)
示例#26
0
 def maj_physique(self):
     self.modele.setPosQuat(self.app.render, self.corps.getPosition(),
                            Quat(self.corps.getQuaternion()))
示例#27
0
    def update(self, keys, dt):
        GameObject.update(self, dt)

        self.updateSpeedometer()

        self.walking = False

        quat = self.root.getQuat(Common.framework.showBase.render)
        forward = quat.getForward()
        right = quat.getRight()
        up = quat.getUp()

        if keys["up"]:
            self.walking = True
            self.velocity += forward * self.acceleration * dt
        if keys["down"]:
            self.walking = True
            self.velocity -= forward * self.acceleration * dt
        if keys["left"]:
            self.walking = True
            self.velocity -= right * self.acceleration * dt
        if keys["right"]:
            self.walking = True
            self.velocity += right * self.acceleration * dt
        if self.walking:
            self.inControl = True

        mouseWatcher = base.mouseWatcherNode
        if mouseWatcher.hasMouse():
            xSize = base.win.getXSize()
            ySize = base.win.getYSize()
            xPix = float(xSize % 2) / xSize
            yPix = float(ySize % 2) / ySize
            mousePos = Vec2(base.mouseWatcherNode.getMouse())
            mousePos.addX(-xPix)
            mousePos.addY(-yPix)
            if abs(mousePos.x) < xPix:
                mousePos.x = 0
            if abs(mousePos.y) < yPix:
                mousePos.y = 0

        else:
            mousePos = self.lastMousePos

        if mousePos.length() > 0.01:
            axis = right * (mousePos.y) + up * (-mousePos.x)
            axis.normalize()
            angle = mousePos.length() * self.turnRate * dt

            rotQuat = Quat()
            rotQuat.setFromAxisAngle(angle, axis)

            self.root.setQuat(quat * rotQuat)

        if not self.weaponSets[0][0].active:
            self.alterEnergy(
                math.sin(1.071 * self.energy / self.maxEnergy + 0.5) *
                self.energyRechargeRate * dt)

        self.updateEnergyUI()
        self.updateHealthUI()
        self.updateRadar()

        #self.root.setH(self.root.getH() - mousePos.x*self.mouseSpeedHori*self.mouseSensitivity)
        #self.actor.setP(self.actor.getP() + mousePos.y*self.mouseSpeedVert*self.mouseSensitivity)

        if keys["shoot"]:
            self.startFiringSet(0)
        else:
            self.ceaseFiringSet(0)

        if keys["shootSecondary"]:
            self.startFiringSet(self.missileSetIndex + 1)
        else:
            for i in range(self.numMissileSets):
                self.ceaseFiringSet(i + 1)

        [effect.update(self, dt) for effect in self.updatingEffects]
        [
            effect.cleanup() for effect in self.updatingEffects
            if not effect.active
        ]
        self.updatingEffects = [
            effect for effect in self.updatingEffects if effect.active
        ]

        if self.targetingQueue.getNumEntries() > 0:
            self.targetingQueue.sortEntries()
            entry = self.targetingQueue.getEntry(0)
            intoNP = entry.getIntoNodePath()
            if intoNP.hasPythonTag(TAG_OWNER):
                other = intoNP.getPythonTag(TAG_OWNER)
                if other is self.prospectiveLockTarget and other is not self.lockedTarget:
                    self.lockTargetTimer += dt
                    if self.lockTargetTimer >= self.lockDuration:
                        self.lockedTarget = other
                else:
                    self.lockTargetTimer = 0
                self.prospectiveLockTarget = other
            else:
                self.lockTargetTimer = 0
        else:
            self.lockTargetTimer = 0

        perc = self.lockTargetTimer / self.lockDuration
        self.lockBar.setTexOffset(TextureStage.getDefault(), 0, -perc * 1.1)

        if self.lockedTarget is not None:
            if self.lockedTarget.health <= 0:
                self.lockedTarget = None
            else:
                relPos = self.lockedTarget.root.getPos(self.root)
                planarVec = relPos.getXz()
                relDist = relPos.length()

                if relDist == 0:
                    angle = 0
                else:
                    angle = math.acos(relPos.y / relDist)

                if relDist > 200 or angle > 1.7453:
                    self.lockedTarget = None
                else:

                    if self.lockMarkerRoot.isHidden():
                        self.lockMarkerRoot.show()

                    camPt = Point2()
                    convertedPt = Common.framework.showBase.cam.getRelativePoint(
                        Common.framework.showBase.render,
                        self.lockedTarget.root.getPos(
                            Common.framework.showBase.render))
                    if Common.framework.showBase.camLens.project(
                            convertedPt, camPt):
                        self.lockMarkerRoot.setPos(
                            Common.framework.showBase.render2d, camPt.x, 0,
                            camPt.y)
                        if self.lockMarkerRoot.isHidden():
                            self.lockMarkerRoot.show()
                        for child in self.lockMarkerRoot.getChildren():
                            child.getChild(0).setZ(
                                (1.0 - min(1, relDist / 100)) * 5 + 0.2)
                    elif not self.lockMarkerRoot.isHidden():
                        self.lockMarkerRoot.hide()

                    if relPos.y < 0 or angle > 0.6:
                        planarVec.normalize()

                        self.directionIndicator.setPos(planarVec.x * 0.4, 0,
                                                       planarVec.y * 0.4)

                        angle = math.degrees(
                            math.atan2(planarVec.x, planarVec.y))
                        self.directionIndicator.setR(angle)

                        if self.directionIndicator.isHidden():
                            self.directionIndicator.show()
                    elif not self.directionIndicator.isHidden():
                        self.directionIndicator.hide()
        else:
            if not self.directionIndicator.isHidden():
                self.directionIndicator.hide()
            if not self.lockMarkerRoot.isHidden():
                self.lockMarkerRoot.hide()
 def cameraLerp(self, i):
     pos, hpr = cameraLerps[i]
     quat = Quat()
     quat.setHpr(hpr)
     camera.posQuatInterval(1.2, pos, quat).start()
示例#29
0
文件: net2.py 项目: wezu/a3p-koparka
 def takeSnapshot(self, entity):
     self.pos = entity.getPosition()
     self.quat = Quat(entity.getQuaternion())
     self.time = engine.clock.time
     self.empty = False
示例#30
0
文件: net2.py 项目: wezu/a3p-koparka
 def __init__(self):
     self.pos = Vec3()
     self.quat = Quat()
     self.time = 0
     self.empty = True
 def drawFern(self,LOD,pos,quat,drawResourcesFactory,scale=1.0):
     scalar=random.random()
     scale*=scalar
     
     if scale<.3: return
     
     count=int((scalar**.7)*12)
     
     if scale<.8:
         if LOD==self.lowLOD: return
     else:
         if LOD==self.midLOD: return
     
     
     leafResources=drawResourcesFactory.getDrawResources(self.leafDataIndex[LOD])
     leafTri=leafResources.getGeomTriangles()
     vertexWriter=leafResources.getWriter("vertex")
     normalWriter=leafResources.getWriter("normal")
     
     if self.leafTexture:
         texcoordWriter = leafResources.getWriter("texcoord")
     
     
     
     scale*=self.scalar*3
     
     q2=Quat()
     q3=Quat()
     
     for i in xrange(count):
         p=(random.random()**2)*60+20
         h=random.random()*360
         q2.setHpr((h,p,0))
         q3.setHpr((h,p-20-p/4,0))
         
         length1=scale*4
         length2=scale*3
         
         f=q2.getForward()*length1
         r=q2.getRight()*scale*.5
         f2=q3.getForward()*length2+f
         norm0=q2.getUp()
         norm2=q3.getUp()
         norm1=norm0+norm2
         norm1.normalize()
         
         for x in range(2):
             leafRow = vertexWriter.getWriteRow()
         
             vertexWriter.addData3f(pos)
             vertexWriter.addData3f(pos+f+r)
             vertexWriter.addData3f(pos+f-r)
             vertexWriter.addData3f(pos+f2)
             
             
             if self.leafTexture:
                 texcoordWriter.addData2f(0,0)
                 texcoordWriter.addData2f(0,1)
                 texcoordWriter.addData2f(1,0)
                 texcoordWriter.addData2f(1,1)
         
             if x==1:
                 # back sides
                 norm0=-norm0
                 norm1=-norm1
                 norm2=-norm2
                 leafTri.addVertices(leafRow+1,leafRow,leafRow+2)
                 leafTri.addVertices(leafRow+3,leafRow+1,leafRow+2)
             else:
                 leafTri.addVertices(leafRow,leafRow+1,leafRow+2)
                 leafTri.addVertices(leafRow+1,leafRow+3,leafRow+2)
                 
             normalWriter.addData3f(norm0)
             normalWriter.addData3f(norm1) 
             normalWriter.addData3f(norm1) 
             normalWriter.addData3f(norm2)
示例#32
0
文件: net2.py 项目: wezu/a3p-koparka
 def setFrom(self, snapshot):
     self.pos = Vec3(snapshot.pos)
     self.quat = Quat(snapshot.quat)
     self.time = engine.clock.time
     self.empty = snapshot.empty
def getUpHPR(hpr):
    q = Quat()
    q.setHpr(VBase3(math.degrees(hpr.h), math.degrees(hpr.p), math.degrees(hpr.r)))
    v = q.getUp()
    return SP3(v.x, v.y, v.z)
    def release(self):
        Gag.release(self)
        base.audio3d.attachSoundToObject(self.woosh, self.gag)
        base.playSfx(self.woosh, node=self.gag)

        if self.isLocal() and base.localAvatar.battleControls:
            if base.localAvatar.isFirstPerson():
                # Add a small kick to the camera to give more feedback
                self.getFPSCam().addViewPunch(
                    Vec3(random.uniform(.5, 1), random.uniform(-.5, -1), 0))

                startPos = camera.getPos(render) + camera.getQuat(
                    render).xform(Vec3.right())
                push = 0.0
            else:
                startPos = self.handJoint.getPos(render)
                push = (startPos - camera.getPos(render)).length()
            hitPos = PhysicsUtils.getHitPosFromCamera()
        else:
            startPos = self.handJoint.getPos(render)
            quat = Quat()
            quat.setHpr(
                self.avatar.getHpr(render) + (0, self.avatar.lookPitch, 0))
            hitPos = quat.xform(Vec3.forward() * self.power)
            hit = PhysicsUtils.rayTestClosestNotMe(
                self.avatar, startPos, hitPos,
                CIGlobals.WorldGroup | CIGlobals.LocalAvGroup)
            if hit is not None:
                hitPos = hit.getHitPos()

        throwDir = (hitPos - startPos).normalized()
        endPos = startPos + (throwDir * self.power) - (0, 0, 90)

        entity = self.gag

        if not entity:
            entity = self.build()

        gagRoot = render.attachNewNode('gagRoot')
        gagRoot.setPos(startPos)

        entity.reparentTo(render)
        entity.setPos(0, 0, 0)
        entity.headsUp(throwDir)
        rot = entity.getHpr(render)
        entity.reparentTo(gagRoot)
        entity.setHpr(rot[0], -90, 0)
        self.gag = None

        if not self.handJoint:
            self.handJoint = self.avatar.find('**/def_joint_right_hold')

        track = FlightProjectileInterval(gagRoot,
                                         startPos=startPos,
                                         endPos=endPos,
                                         gravityMult=1.07,
                                         duration=2.5)
        event = self.avatar.uniqueName('throwIvalDone') + '-' + str(
            hash(entity))
        track.setDoneEvent(event)
        base.acceptOnce(event, self.__handlePieIvalDone, [entity])
        track.start()

        if self.isLocal():
            collider = self.buildCollisions(entity)
            self.entities.append([gagRoot, track, collider])
            base.localAvatar.sendUpdate('usedGag', [self.id])
        else:
            self.entities.append([gagRoot, track, NodePath()])
        self.reset()
示例#35
0
    def __updateTask(self, task):
        # TODO -- This function does a lot of math, I measured it to take .5 ms on my laptop
        #         That's a lot of time for something miniscule like sway and bob.

        dt = globalClock.getDt()
        time = globalClock.getFrameTime()

        if base.localAvatar.isFirstPerson():
            eyePoint = base.localAvatar.getEyePoint()
            if base.localAvatar.walkControls.crouching:
                eyePoint[2] = eyePoint[2] / 2.0
            eyePoint[2] = CIGlobals.lerpWithRatio(eyePoint[2],
                                                  self.lastEyeHeight, 0.4)
            self.lastEyeHeight = eyePoint[2]

        camRootAngles = Vec3(0)

        # Mouse look around
        mw = base.mouseWatcherNode
        if mw.hasMouse():
            md = base.win.getPointer(0)
            center = Point2(base.win.getXSize() / 2, base.win.getYSize() / 2)

            xDist = md.getX() - center.getX()
            yDist = md.getY() - center.getY()

            sens = self.__getMouseSensitivity()

            angular = -(xDist * sens) / dt
            base.localAvatar.walkControls.controller.setAngularMovement(
                angular)
            camRootAngles.setY(self.lastPitch - yDist * sens)

            if camRootAngles.getY() > FPSCamera.MaxP:
                camRootAngles.setY(FPSCamera.MaxP)
                yDist = 0
            elif camRootAngles.getY() < FPSCamera.MinP:
                yDist = 0
                camRootAngles.setY(FPSCamera.MinP)

            base.win.movePointer(0, int(center.getX()), int(center.getY()))

        if base.localAvatar.isFirstPerson():
            # Camera / viewmodel bobbing
            vmBob = Point3(0)
            vmAngles = Vec3(0)
            vmRaise = Point3(0)
            camBob = Point3(0)

            maxSpeed = base.localAvatar.walkControls.BattleRunSpeed * 16.0

            speed = base.localAvatar.walkControls.speeds.length() * 16.0
            speed = max(-maxSpeed, min(maxSpeed, speed))

            bobOffset = CIGlobals.remapVal(speed, 0, maxSpeed, 0.0, 1.0)

            self.bobTime += (time - self.lastBobTime) * bobOffset
            self.lastBobTime = time

            # Calculate the vertical bob
            cycle = self.bobTime - int(
                self.bobTime / self.BobCycleMax) * self.BobCycleMax
            cycle /= self.BobCycleMax
            if cycle < self.BobUp:
                cycle = math.pi * cycle / self.BobUp
            else:
                cycle = math.pi + math.pi * (cycle - self.BobUp) / (1.0 -
                                                                    self.BobUp)

            verticalBob = speed * 0.005
            verticalBob = verticalBob * 0.3 + verticalBob * 0.7 * math.sin(
                cycle)
            verticalBob = max(-7.0, min(4.0, verticalBob))
            verticalBob /= 16.0

            # Calculate the lateral bob
            cycle = self.bobTime - int(
                self.bobTime / self.BobCycleMax * 2) * self.BobCycleMax * 2
            cycle /= self.BobCycleMax * 2
            if cycle < self.BobUp:
                cycle = math.pi * cycle / self.BobUp
            else:
                cycle = math.pi + math.pi * (cycle - self.BobUp) / (1.0 -
                                                                    self.BobUp)

            lateralBob = speed * 0.005
            lateralBob = lateralBob * 0.3 + lateralBob * 0.7 * math.sin(cycle)
            lateralBob = max(-7.0, min(4.0, lateralBob))
            lateralBob /= 16.0

            # Apply bob, but scaled down a bit
            vmBob.set(lateralBob * 0.8, 0, verticalBob * 0.1)
            # Z bob a bit more
            vmBob[2] += verticalBob * 0.1
            # Bob the angles
            vmAngles[2] += verticalBob * 0.5
            vmAngles[1] -= verticalBob * 0.4
            vmAngles[0] -= lateralBob * 0.3

            # ================================================================
            # Viewmodel lag/sway

            angles = self.camRoot.getHpr(render)
            quat = Quat()
            quat.setHpr(angles)
            invQuat = Quat()
            invQuat.invertFrom(quat)

            maxVMLag = 1.5
            lagforward = quat.getForward()
            if dt != 0.0:
                lagdifference = lagforward - self.lastFacing
                lagspeed = 5.0
                lagdiff = lagdifference.length()
                if (lagdiff > maxVMLag) and (maxVMLag > 0.0):
                    lagscale = lagdiff / maxVMLag
                    lagspeed *= lagscale

                self.lastFacing = CIGlobals.extrude(self.lastFacing,
                                                    lagspeed * dt,
                                                    lagdifference)
                self.lastFacing.normalize()
                lfLocal = invQuat.xform(lagdifference)
                vmBob = CIGlobals.extrude(vmBob, 5.0 / 16.0, lfLocal * -1.0)

            pitch = angles[1]
            if pitch > 180:
                pitch -= 360
            elif pitch < -180:
                pitch += 360

            vmBob = CIGlobals.extrude(vmBob, pitch * (0.035 / 16),
                                      Vec3.forward())
            vmBob = CIGlobals.extrude(vmBob, pitch * (0.03 / 16), Vec3.right())
            vmBob = CIGlobals.extrude(vmBob, pitch * (0.02 / 16), Vec3.up())

            # ================================================================

            vmRaise.set(
                0, 0, 0
            )  #(0, abs(camRootAngles.getY()) * -0.002, camRootAngles.getY() * 0.002)
            camBob.set(0, 0, 0)

            # Apply bob, raise, and sway to the viewmodel.
            self.viewModel.setPos(vmBob + vmRaise + self.lastVMPos)
            self.vmRoot2.setHpr(vmAngles)
            self.camRoot.setPos(eyePoint + camBob)

        newPitch = camRootAngles.getY()

        if abs(newPitch - self.lastPitch) > self.PitchUpdateEpsilon:
            # Broadcast where our head is looking
            head = base.localAvatar.getPart("head")
            if head and not head.isEmpty():
                # Constrain the head pitch a little bit so it doesn't look like their head snapped
                headPitch = max(-47, newPitch)
                headPitch = min(75, headPitch)
                base.localAvatar.b_setLookPitch(headPitch)

        self.lastPitch = newPitch

        if base.localAvatar.isFirstPerson():
            # Apply punch angle
            self.decayPunchAngle()
            camRootAngles += self.punchAngle

        self.camRoot.setHpr(camRootAngles)

        return task.cont
    def drawTree(self,base,drawResourcesFactories,collision,scale=1.0):
        age=random.random()**3.5
        to = 12*age
        if to<3: return
        
        leafScaler=age**.5
        leafSize=10.0*self.scalar*leafScaler*scale
        
        
        maxbend=40+random.random()*20
            
        forks=int(to/2-1)
        lengthList=[]
        numCopiesList=[]
        radiusList=[]
        currR=age*1.0*(random.random()*2+1)
        forkCount=0
        
        lengthScale=2.0*scale
        
        for i in xrange(forks+1):
            currR*=1/math.sqrt(2)
            endR=currR*.9*.9
            if i==forks:
                endR=0
                forkCount=0
            if i<2:
                lengthList.extend([lengthScale,lengthScale,lengthScale])
                numCopiesList.extend([forkCount,0,0])
                radiusList.extend([currR,currR*.9,endR])
            else:
                lengthList.extend([lengthScale*3])
                numCopiesList.extend([forkCount])
                radiusList.extend([endR])
            forkCount=2+(i%2)
        
        doLeaves=True
        dotCount=1
        
                
        stack = [base]
        

        LODs=list(drawResourcesFactories.keys())

        angleDatas=[]
        for LODnum,LOD in enumerate(LODs):
            drawResourcesFactory=drawResourcesFactories[LOD]
            
            if LOD==self.minLOD:
                numVertices=2
            elif LOD==self.lowLOD:
                numVertices=3
            elif LOD==self.midLOD:
                numVertices=4
            else:
                numVertices=6
            
            
            
            #cache some info needed for placeing the vertexes
            angleData=[]
            if self.barkTexture:
                vNum=numVertices+1
            else:
                vNum=numVertices
            
            for i in xrange(vNum):  #doubles the last vertex to fix UV seam
                angle=-2 * i * math.pi / numVertices
                angleData.append((math.cos(angle),math.sin(angle),1.0*i / numVertices))
        
            angleDatas.append(angleData)
        
        bottom=True
        
        if collision:
            cNode=CollisionNode('cnode')
            cnodePath = NodePath(cNode)
            cnodePath.reparentTo(collision)
            cnodePath.setCollideMask(collisionUtil.groundMask)
            #cnodePath.show()
            
        
        while stack: 
            pos, quat, depth, previousRows, sCoord = stack.pop() 
            length = lengthList[depth]
            sCoord += length/4.0
            
            radius=radiusList[depth]
            
            
            
            perp1 = quat.getRight() 
            perp2 = quat.getForward() 
            
            startRows=[]
            for LODnum,LOD in enumerate(LODs):
                drawResourcesFactory=drawResourcesFactories[LOD]
                previousRow=previousRows[LODnum]
                angleData=angleDatas[LODnum]
                vNum=len(angleData)
                
                if LOD==self.minLOD:
                    cutoffRadius=.7
                elif LOD==self.lowLOD:
                    cutoffRadius=.5
                elif LOD==self.midLOD:
                    cutoffRadius=.1
                else:
                    cutoffRadius=-1
                
                trunkResources=drawResourcesFactory.getDrawResources(self.trunkDataIndex[LOD])
                lines = trunkResources.getGeomTristrips()
                vertWriter = trunkResources.getWriter("vertex")
                normalWriter = trunkResources.getWriter("normal")
                if self.barkTexture:
                    texWriter = trunkResources.getWriter("texcoord")
#                 else:
#                     colorWriter = trunkResources.getWriter("color")


                startRow = vertWriter.getWriteRow()
                startRows.append(startRow)
                if radius>cutoffRadius:
                
                    #this draws the body of the tree. This draws a ring of vertices and connects the rings with 
                    #triangles to form the body. 
                      
                    #vertex information is written here 
                    for cos,sin,tex in angleData:
                        adjCircle = pos + (perp1 * cos + perp2 * sin) * radius * self.scalar
                        normal = perp1 * cos + perp2 * sin        
                        normalWriter.addData3f(normal) 
                        vertWriter.addData3f(adjCircle) 
                        if self.barkTexture is not None:
                            texWriter.addData2f(tex,sCoord) 
#                         else:
#                             colorWriter.addData4f(.4,.3,.3,1)
                    #we cant draw quads directly so we use Tristrips 
                    
                    if not bottom:
                        for i in xrange(vNum): 
                            lines.addVertices(i + previousRow,i + startRow)
                        if not self.barkTexture: lines.addVertices(previousRow,startRow)
                        lines.closePrimitive()
                
                
            
            
            bottom=False
            if depth + 1 < len(lengthList):
                #move foward along the correct axis 
                newPos = pos + quat.getUp() * length * self.scalar
#                if makeColl: 
#                    self.makeColl(pos, newPos, radiusList[depth]) 
                
                numCopies = numCopiesList[depth]  
                if numCopies:
                    angleOffset=random.random()*2*math.pi
                    
                    for i in xrange(numCopies): 
                        newQuat= _angleRandomAxis(quat, 2 * math.pi * i / numCopies+angleOffset, maxbend)
                        newPos2=pos + newQuat.getUp() * length * self.scalar
                        stack.append((newPos2,newQuat, depth + 1, startRows, sCoord))
                        
                        if collision:
                            tube = CollisionTube(Point3(pos),Point3(newPos2),radius)
                            cNode.addSolid(tube)
                
                else: 
                    #just make another branch connected to this one with a small variation in direction 
                    stack.append((newPos, _randomBend(quat, 20), depth + 1, startRows, sCoord))
                    if collision:
                        tube = CollisionTube(Point3(pos),Point3(newPos),radius)
                        cNode.addSolid(tube)
            elif doLeaves:
                q=Quat()
                q.setHpr((random.random()*2*math.pi,0,0))
                quat=quat*q
                up=quat.getUp()
                down=-up
                
                # size
                
                s=leafSize
                dir1=perp1*s
                dir2=perp2*s
                bend=-up*(s/4.0)
                
                v0=pos+dir1
                v1=pos+dir2+bend
                v2=pos-dir1
                v3=pos-dir2+bend
                
                norm1=dir1.cross(dir2+bend)
                norm1.normalize()
                norm2=dir1.cross(dir2-bend)
                norm2.normalize()
                
                
                for LOD,drawResourcesFactory in drawResourcesFactories.iteritems():
                    leafResources=drawResourcesFactory.getDrawResources(self.leafDataIndex[LOD])
                    leafTri=leafResources.getGeomTriangles()
            
                    n1=norm1
                    n2=norm2
                    upVec=up
                    
                    leafVertexWriter=leafResources.getWriter("vertex")
                    leafNormalWriter=leafResources.getWriter("normal")
                    
                    if self.leafTexture:
                        leafTexcoordWriter = leafResources.getWriter("texcoord")
                    else:
                        leafColorWriter = leafResources.getWriter("color")
                    
                    
                    for x in range(2):
                        leafRow = leafVertexWriter.getWriteRow()
                        leafVertexWriter.addData3f(v0)
                        leafVertexWriter.addData3f(v1)
                        leafVertexWriter.addData3f(v2)
                        leafVertexWriter.addData3f(v3)
                        if self.leafTexture is not None:
                            n=dotCount
                            leafTexcoordWriter.addData2f(0,0)
                            leafTexcoordWriter.addData2f(0,n)
                            leafTexcoordWriter.addData2f(n,n)
                            leafTexcoordWriter.addData2f(n,0)
                        else:
                            leafColorWriter.addData4f(.5,.4,.0,1)
                            leafColorWriter.addData4f(.0,.4,.0,1)
                            leafColorWriter.addData4f(.5,.4,.0,1)
                            leafColorWriter.addData4f(.0,.4,.0,1)
                        
                        if x==1:
                            # back sides
                            upVec=-up
                            n1=-norm1
                            n2=-norm2
                            leafTri.addVertices(leafRow+1,leafRow,leafRow+2)
                            leafTri.addVertices(leafRow+2,leafRow,leafRow+3)
                        else:
                            leafTri.addVertices(leafRow,leafRow+1,leafRow+2)
                            leafTri.addVertices(leafRow,leafRow+2,leafRow+3)
                            
                        leafNormalWriter.addData3f(upVec)
                        leafNormalWriter.addData3f(n1) 
                        leafNormalWriter.addData3f(upVec) 
                        leafNormalWriter.addData3f(n2)
示例#37
0
def get_unit(hpr):
    q = Quat()
    q.setHpr(hpr)
    return q.xform(Vec3(0, 1, 0))
示例#38
0
 def getViewMatrix(self):
     quat = Quat()
     quat.setHpr(self.getViewHpr())
     mat = Mat4()
     quat.extractToMatrix(mat)
     return mat
示例#39
0
 def __init__(self):
     self.pos = Vec3()
     self.quat = Quat()
     self.time = 0
     self.empty = True
示例#40
0
    def rotate(self, point):
        quat = Quat()
        quat.setHpr(self.getViewHpr())

        return quat.xform(point)
示例#41
0
 def setFrom(self, snapshot):
     self.pos = Vec3(snapshot.pos)
     self.quat = Quat(snapshot.quat)
     self.time = engine.clock.time
     self.empty = snapshot.empty
示例#42
0
 def invRotate(self, point):
     quat = Quat()
     quat.setHpr(self.getViewHpr())
     return LEUtils.makeForwardAxis(point, quat)
示例#43
0
def simulationTask(task):
    global deltaTimeAccumulator
    # Add the deltaTime for the task to the accumulator
    deltaTimeAccumulator += globalClock.getDt()
    while deltaTimeAccumulator > stepSize:
        # Remove a stepSize from the accumulator until
        # the accumulated time is less than the stepsize
        deltaTimeAccumulator -= stepSize
        # Step the simulation
        world.quickStep(stepSize)
    # set the new positions
    Counter.setText('Electron Pairs: ' + str(len(electrons)))
    drawLines()
    global strafe
    global elevation
    global cameradistance
    strafe += 0.00
    #handles the keyboard inputs
    if keyboard.is_pressed('w') and elevation < 3.12 / 2.0:
        elevation += 0.02
    if keyboard.is_pressed('s') and elevation > -3.12 / 2.0:
        elevation -= 0.02
    if keyboard.is_pressed('d'):
        strafe += 0.02
    if keyboard.is_pressed('a'):
        strafe -= 0.02
    if keyboard.is_pressed('+'):
        cameradistance -= 1
    if keyboard.is_pressed('-'):
        cameradistance += 1
    if keyboard.is_pressed('esc'):
        hideHelp()
    for x in range(len(bodies)):
        electrons[x].model.setPosQuat(render, bodies[x].getPosition(),
                                      Quat(bodies[x].getQuaternion()))
    setCamera()
    # takes care of all the repulsive forces
    for a in electrons:
        xAccum = 0
        yAccum = 0
        zAccum = 0
        for b in electrons:
            distance = math.sqrt(
                math.pow(a.model.getX() - b.model.getX(), 2) +
                math.pow(a.model.getY() - b.model.getY(), 2) +
                math.pow(a.model.getZ() - b.model.getZ(), 2))
            try:
                xAccum += 10 * (a.model.getX() - b.model.getX()) / math.pow(
                    distance, 3)
            except:
                xAccum += 0
            try:
                yAccum += 10 * (a.model.getY() - b.model.getY()) / math.pow(
                    distance, 3)
            except:
                yAccum += 0
            try:
                zAccum += 10 * (a.model.getZ() - b.model.getZ()) / math.pow(
                    distance, 3)
            except:
                zAccum += 0
        a.setX(a.getX() + xAccum)
        a.setY(a.getY() + yAccum)
        a.setZ(a.getZ() + zAccum)
    for e in electrons:
        e.updatePos()
    for a in range(len(bodies)):
        bodies[a].setPosition(electrons[a].model.getPos(render))
    return task.cont
示例#44
0
def makeForwardAxis(vec, quat):
    invQuat = Quat()
    invQuat.invertFrom(quat)
    result = invQuat.xform(vec)
    result.setY(0.0)
    return result
示例#45
0
    def __updateParticleParent(self, task=None):
        time = globalClock.getFrameTime()

        streamPos = self.waterStreamParent.getPos(render)
        distance = self.sprayParticleDist

        if self.isLocal():
            if base.localAvatar.backpack.getSupply(self.id) <= 0:
                base.localAvatar.b_gagThrow(self.id)
                return task.done

            camQuat = camera.getQuat(render)
            pFrom = camera.getPos(render)
            push = (streamPos - pFrom).length()
            pFrom += camQuat.xform(Vec3.forward()) * push
            pTo = pFrom + camQuat.xform(
                Vec3.forward()) * (self.sprayParticleDist +
                                   (pFrom - streamPos).length())
            hitPos = Point3(pTo)
            result = base.physicsWorld.rayTestClosest(pFrom, pTo,
                                                      CIGlobals.WorldGroup)
            if result.hasHit():
                node = result.getNode()
                hitPos = result.getHitPos()
                distance = (hitPos - streamPos).length()
                if time - self.lastDmgTime >= self.dmgIval:
                    self._handleSprayCollision(NodePath(node), hitPos,
                                               distance)
                    self.lastDmgTime = time

            if time - self.lastSprayTime >= self.dmgIval:
                self.getFPSCam().addViewPunch(
                    Vec3(random.uniform(-0.6, 0.6), random.uniform(0.25, 1.0),
                         0.0))
                base.localAvatar.sendUpdate('usedGag', [self.id])
                self.lastSprayTime = time

        else:
            pFrom = self.avatar.getPos(render) + self.avatar.getEyePoint() + (
                1, 0, 0)
            quat = Quat()
            quat.setHpr(
                self.avatar.getHpr(render) + (0, self.avatar.lookPitch, 0))
            pTo = pFrom + quat.xform(
                Vec3.forward()) * (self.sprayParticleDist +
                                   (pFrom - streamPos).length())
            hitPos = Point3(pTo)
            hit = PhysicsUtils.rayTestClosestNotMe(
                self.avatar, pFrom, pTo,
                CIGlobals.WorldGroup | CIGlobals.LocalAvGroup)
            if hit is not None:
                hitPos = hit.getHitPos()
                distance = (hitPos - streamPos).length()

        self.waterStreamParent.lookAt(render, hitPos)

        if self.sprayParticle:
            system = self.sprayParticle.getParticlesNamed('particles-1')
            # Make the particles die off at the hit point.
            lifespan = min(
                1, distance / self.sprayParticleDist) * self.sprayParticleLife
            system.factory.setLifespanBase(lifespan)

        if task:
            return task.cont
示例#46
0
def generate_roads(models, terrain, map, json_out):
    numroads = 0
    for center in progress.bar(map.centers.values(), label='Generating roads... '):
        road_edges = [e for e in center.edges if e.is_road and e.corner0 is not None and e.corner1 is not None]
        if len(road_edges) != 2:
            continue
        
        e1, e2 = road_edges
        e1_0 = numpy.array([e1.corner0.x, e1.corner0.y, e1.corner0.elevation * Z_SCALE], dtype=numpy.float32)
        e1_1 = numpy.array([e1.corner1.x, e1.corner1.y, e1.corner1.elevation * Z_SCALE], dtype=numpy.float32)
        e2_0 = numpy.array([e2.corner0.x, e2.corner0.y, e2.corner0.elevation * Z_SCALE], dtype=numpy.float32)
        e2_1 = numpy.array([e2.corner1.x, e2.corner1.y, e2.corner1.elevation * Z_SCALE], dtype=numpy.float32)
        
        region_center = numpy.array([center.x, center.y, center.elevation * Z_SCALE])
        
        for end1, edge1, edge2 in [(region_center, e1_0, e1_1), (region_center, e2_0, e2_1)]:
            end2 = v3mid(edge1, edge2)
            
            midpt = v3mid(end1, end2)
            midpt = scene.mapgen_coords_to_sirikata(midpt, terrain)
            
            kata_pt1 = scene.mapgen_coords_to_sirikata(end1, terrain)
            kata_pt2 = scene.mapgen_coords_to_sirikata(end2, terrain)
            
            scale = v3dist(kata_pt1, kata_pt2) / 2
            
            m = scene.SceneModel(ROAD_PATH,
                           x=float(midpt[0]),
                           y=float(midpt[1]),
                           z=float(midpt[2]),
                           scale=scale,
                           model_type='road')
            
            kataboundmin, kataboundmax = scene.sirikata_bounds(m.boundsInfo)
            scenemin = kataboundmin * scale + midpt
            scenemax = kataboundmax * scale + midpt
            xmid = (scenemax[0] - scenemin[0]) / 2.0 + scenemin[0]
            road_edge1 = numpy.array([xmid, scenemin[1], scenemin[2]], dtype=numpy.float32)
            road_edge2 = numpy.array([xmid, scenemax[1], scenemin[2]], dtype=numpy.float32)
            
            midv3 = Vec3(midpt[0], midpt[1], midpt[2])
            src = Vec3(road_edge2[0], road_edge2[1], road_edge2[2])
            src -= midv3
            src_copy = Vec3(src)
            target = Vec3(kata_pt1[0], kata_pt1[1], kata_pt1[2])
            target -= midv3
            cross = src.cross(target)
            w = math.sqrt(src.lengthSquared() * target.lengthSquared()) + src.dot(target)
            q = Quat(w, cross)
            q.normalize()
            
            orig_up = q.getUp()
            orig_up.normalize()
            
            edge1_kata = scene.mapgen_coords_to_sirikata(edge1, terrain)
            edge2_kata = scene.mapgen_coords_to_sirikata(edge2, terrain)
            new_up = normal_vector(kata_pt1, edge1_kata, edge2_kata)
            new_up = Vec3(new_up[0], new_up[1], new_up[2])
            rotate_about = orig_up.cross(new_up)
            rotate_about.normalize()
            angle_between = orig_up.angleDeg(new_up)
            r = Quat()
            r.setFromAxisAngle(angle_between, rotate_about)
            r.normalize()
            q *= r
            q.normalize()
            
            m.orient_x = q.getI()
            m.orient_y = q.getJ()
            m.orient_z = q.getK()
            m.orient_w = q.getR()
            
            numroads += 1
            json_out.append(m.to_json())
    
    print 'Generated (%d) road objects' % numroads
示例#47
0
    def generate(self, Params, baseFlair=[]):
        # defines a "branch" as a list of BranchNodes and then calls branchfromNodes
        # Creates a scaled length,width, height geometry to be later
        # otherwise can not maintain UV per unit length (if that's desired)
        # returns non-rotated, unpositioned geom node

        #        branchlen = Params['L']
        #        branchSegs = Params['nSegs']
        Params.update({'iSeg': 0})
        # Base flair: nice to flair out the first segment on a "trunk" branch sometimes
        if baseFlair:
            bff = baseFlair
        else:
            bff = 1
        rootPos = Vec3(
            0, 0, 0
        )  # + self.PositionFunc(**Params) #add noise to root node; same as others in loop
        rootNode = BranchNode._make([
            rootPos, bff * self.R0,
            Vec3(0, 0, 0),
            Quat(), _uvScale, 0, self.length
        ])  # initial node      # make a starting node flat at 0,0,0
        self.nodeList = [rootNode
                         ]  # start new branch list with newly created rootNode
        prevNode = rootNode

        for i in range(1, self.nSeg +
                       1):  # start a 1, 0 is root node, now previous
            Params.update({'iSeg': i})
            newPos = self.PositionFunc(**Params)
            fromVec = newPos - prevNode.pos  # point
            dL = (
                prevNode.deltaL + fromVec.length()
            )  # cumulative length accounts for off axis node lengths; percent of total branch length
            radius = self.RadiusFunc(
                position=dL / self.length, **Params
            )  # pos.length() wrt to root. if really curvy branch, may want the sum of segment lengths instead..

            # MOVE TO UVfunc
            #            perim = 2*_polySize*radius*sin(pi/_polySize) # use perimeter to calc texture length/scale
            # if going to use above perim calc, probably want a high number of BranchNodes to minimuze the Ushift at the nodes
            perim = 1  # integer tiling of uScale; looks better; avoids U shifts at nodes
            UVcoord = (
                _uvScale[0] * perim,
                rootNode.texUV[1] + dL * float(_uvScale[1])
            )  # This will keep the texture scale per unit length constant
            ##

            newNode = BranchNode._make([
                newPos, radius, fromVec, rootNode.quat, UVcoord, dL,
                self.length - dL
            ])  # i*Lseg = distance from root
            self.nodeList.append(newNode)
            prevNode = newNode  # this is now the starting point on the next iteration

        # sends the BranchNode list to the drawBody function to generate the
        # actual geometry
        for i, node in enumerate(self.nodeList):
            #            if i == 0: isRoot = True
            #            else: isRoot = False
            #            if i == len(nodeList)-1: keepDrawing = True
            #            else:
            self.drawBody(node.pos, node.quat, node.radius, node.texUV)
        return self.nodeList
示例#48
0
def generate_roads(models, terrain, map, json_out):
    numroads = 0
    for center in progress.bar(map.centers.values(),
                               label='Generating roads... '):
        road_edges = [
            e for e in center.edges
            if e.is_road and e.corner0 is not None and e.corner1 is not None
        ]
        if len(road_edges) != 2:
            continue

        e1, e2 = road_edges
        e1_0 = numpy.array(
            [e1.corner0.x, e1.corner0.y, e1.corner0.elevation * Z_SCALE],
            dtype=numpy.float32)
        e1_1 = numpy.array(
            [e1.corner1.x, e1.corner1.y, e1.corner1.elevation * Z_SCALE],
            dtype=numpy.float32)
        e2_0 = numpy.array(
            [e2.corner0.x, e2.corner0.y, e2.corner0.elevation * Z_SCALE],
            dtype=numpy.float32)
        e2_1 = numpy.array(
            [e2.corner1.x, e2.corner1.y, e2.corner1.elevation * Z_SCALE],
            dtype=numpy.float32)

        region_center = numpy.array(
            [center.x, center.y, center.elevation * Z_SCALE])

        for end1, edge1, edge2 in [(region_center, e1_0, e1_1),
                                   (region_center, e2_0, e2_1)]:
            end2 = v3mid(edge1, edge2)

            midpt = v3mid(end1, end2)
            midpt = scene.mapgen_coords_to_sirikata(midpt, terrain)

            kata_pt1 = scene.mapgen_coords_to_sirikata(end1, terrain)
            kata_pt2 = scene.mapgen_coords_to_sirikata(end2, terrain)

            scale = v3dist(kata_pt1, kata_pt2) / 2

            m = scene.SceneModel(ROAD_PATH,
                                 x=float(midpt[0]),
                                 y=float(midpt[1]),
                                 z=float(midpt[2]),
                                 scale=scale,
                                 model_type='road')

            kataboundmin, kataboundmax = scene.sirikata_bounds(m.boundsInfo)
            scenemin = kataboundmin * scale + midpt
            scenemax = kataboundmax * scale + midpt
            xmid = (scenemax[0] - scenemin[0]) / 2.0 + scenemin[0]
            road_edge1 = numpy.array([xmid, scenemin[1], scenemin[2]],
                                     dtype=numpy.float32)
            road_edge2 = numpy.array([xmid, scenemax[1], scenemin[2]],
                                     dtype=numpy.float32)

            midv3 = Vec3(midpt[0], midpt[1], midpt[2])
            src = Vec3(road_edge2[0], road_edge2[1], road_edge2[2])
            src -= midv3
            src_copy = Vec3(src)
            target = Vec3(kata_pt1[0], kata_pt1[1], kata_pt1[2])
            target -= midv3
            cross = src.cross(target)
            w = math.sqrt(
                src.lengthSquared() * target.lengthSquared()) + src.dot(target)
            q = Quat(w, cross)
            q.normalize()

            orig_up = q.getUp()
            orig_up.normalize()

            edge1_kata = scene.mapgen_coords_to_sirikata(edge1, terrain)
            edge2_kata = scene.mapgen_coords_to_sirikata(edge2, terrain)
            new_up = normal_vector(kata_pt1, edge1_kata, edge2_kata)
            new_up = Vec3(new_up[0], new_up[1], new_up[2])
            rotate_about = orig_up.cross(new_up)
            rotate_about.normalize()
            angle_between = orig_up.angleDeg(new_up)
            r = Quat()
            r.setFromAxisAngle(angle_between, rotate_about)
            r.normalize()
            q *= r
            q.normalize()

            m.orient_x = q.getI()
            m.orient_y = q.getJ()
            m.orient_z = q.getK()
            m.orient_w = q.getR()

            numroads += 1
            json_out.append(m.to_json())

    print 'Generated (%d) road objects' % numroads
示例#49
0
 def __quatFromTo(self, v0, v1):
     print(v0, v1)
     q = Quat(
         sqrt(v0.length()**2 * v1.length()**2) + v0.dot(v1), v0.cross(v1))
     q.normalize()
     return q
示例#50
0
 def getViewQuat(self):
     quat = Quat()
     quat.setHpr(self.getViewHpr())