def __updatePrism(self, mesh, o, e, index, p):
            
        dir = aljabr.vsub(e, o) # direction vector from o to e
        len = aljabr.vlen(dir) # distance from o to e
        scale = 0.5 # the thickness is 10% of the length
        i = aljabr.vadd(o, aljabr.vmul(dir, 0.25)) # the thickest part is 25% from o
        n = aljabr.vmul(dir, 1.0 / len) # the normalized direction
        q = aljabr.axisAngleToQuaternion(n, pi / 2.0) # a quaternion to rotate the point p1 to obtain the other points
        p1 = p # a random point in the plane defined by 0,0,0 and n
        p1 = aljabr.vmul(aljabr.vnorm(p1), scale) # the point scaled to the thickness
        p2 = aljabr.quaternionVectorTransform(q, p1) # the other points
        p3 = aljabr.quaternionVectorTransform(q, p2)
        p4 = aljabr.quaternionVectorTransform(q, p3)
        
        p1 = aljabr.vadd(i, p1) # translate by i since we were working in the origin
        p2 = aljabr.vadd(i, p2)
        p3 = aljabr.vadd(i, p3)
        p4 = aljabr.vadd(i, p4)

        # The 6 vertices
        mesh.verts[index].co = o
        mesh.verts[index+1].co = p1
        mesh.verts[index+2].co = p2
        mesh.verts[index+3].co = p3
        mesh.verts[index+4].co = p4
        mesh.verts[index+5].co = e
Exemple #2
0
def updatePrism(mesh, o, e, index, p):
    dir = aljabr.vsub(e, o)  # direction vector from o to e
    if dir == [0.0, 0.0, 0.0]:
        dir = [0.0, 1.0, 0.0]
    len = aljabr.vlen(dir)  # distance from o to e
    if len == 0:
        len = 1
    scale = 0.5  # the thickness is 10% of the length
    i = aljabr.vadd(o, aljabr.vmul(dir,
                                   0.25))  # the thickest part is 25% from o
    n = aljabr.vmul(dir, 1.0 / len)  # the normalized direction
    q = aljabr.axisAngleToQuaternion(
        n, pi /
        2.0)  # a quaternion to rotate the point p1 to obtain the other points
    p1 = p  # a random point in the plane defined by 0,0,0 and n
    p1 = aljabr.vmul(aljabr.vnorm(p1),
                     scale)  # the point scaled to the thickness
    p2 = aljabr.quaternionVectorTransform(q, p1)  # the other points
    p3 = aljabr.quaternionVectorTransform(q, p2)
    p4 = aljabr.quaternionVectorTransform(q, p3)

    p1 = aljabr.vadd(i,
                     p1)  # translate by i since we were working in the origin
    p2 = aljabr.vadd(i, p2)
    p3 = aljabr.vadd(i, p3)
    p4 = aljabr.vadd(i, p4)

    # The 6 vertices
    mesh.verts[index].co = o
    mesh.verts[index + 1].co = p1
    mesh.verts[index + 2].co = p2
    mesh.verts[index + 3].co = p3
    mesh.verts[index + 4].co = p4
    mesh.verts[index + 5].co = e
    def __readJoint(self, joint, scale=0.25):
        
        self.__expectKeyword('{')

        items = self.__expectKeyword('OFFSET')
        joint.offset = [scale*float(x) for x in items[1:]]
        
        if joint.parent:
            joint.position = vadd(joint.parent.position, joint.offset)
        else:
            joint.position = joint.offset[:]
        
        items = self.__expectKeyword('CHANNELS')
        joint.channels = items[2:]
        
        if int(items[1]) != len(joint.channels):
            RuntimeError('Expected %d channels found %d' % (items[1], len(joint.channels)))
        
        # Read child joints
        while 1:
            line = self.file.readline()
            items = line.split()
            
            if items[0] == 'JOINT':
                
                child = bvhJoint(items[1])
                joint.children.append(child)
                child.parent = joint
                self.__readJoint(child)
                
            elif items[0] == 'End': # Site
                
                child = bvhJoint('End effector')
                joint.children.append(child)
                child.channels = []
                child.parent = joint
                
                self.__expectKeyword('{')
                
                items = self.__expectKeyword('OFFSET')
                child.offset = [scale*float(x) for x in items[1:]]
                child.position = vadd(joint.position, child.offset)
                
                self.__expectKeyword('}')
                
            elif items[0] == '}':
                
                break
                
            else:
                
                raise RuntimeError('Expected %s found %s' % ('JOINT, End Site or }', items[0]))
Exemple #4
0
def addPrism(mesh, o=[0.0, 0.0, 0.0], e=[0.0, 1.0, 0.0], name='prism'):
    fg = mesh.createFaceGroup(name)

    dir = aljabr.vsub(e, o)  # direction vector from o to e
    if dir == [0.0, 0.0, 0.0]:
        dir = [0.0, 1.0, 0.0]
    len = aljabr.vlen(dir)  # distance from o to e
    if len == 0:
        len = 1
    scale = 0.5  # the thickness is 10% of the length
    i = aljabr.vadd(o, aljabr.vmul(dir,
                                   0.25))  # the thickest part is 25% from o
    n = aljabr.vmul(dir, 1.0 / len)  # the normalized direction
    q = aljabr.axisAngleToQuaternion(
        n, pi /
        2.0)  # a quaternion to rotate the point p1 to obtain the other points
    p = p1 = aljabr.randomPointFromNormal(
        n)  # a random point in the plane defined by 0,0,0 and n
    p1 = aljabr.vmul(aljabr.vnorm(p1),
                     scale)  # the point scaled to the thickness
    p2 = aljabr.quaternionVectorTransform(q, p1)  # the other points
    p3 = aljabr.quaternionVectorTransform(q, p2)
    p4 = aljabr.quaternionVectorTransform(q, p3)

    p1 = aljabr.vadd(i,
                     p1)  # translate by i since we were working in the origin
    p2 = aljabr.vadd(i, p2)
    p3 = aljabr.vadd(i, p3)
    p4 = aljabr.vadd(i, p4)

    # The 6 vertices
    v = []
    v.append(mesh.createVertex(o))  # 0             0
    v.append(mesh.createVertex(p1))  # 1            /|\
    v.append(mesh.createVertex(p2))  # 2           /.2.\
    v.append(mesh.createVertex(p3))  # 3          1` | `3
    v.append(mesh.createVertex(p4))  # 4          \`.4.`/
    v.append(mesh.createVertex(e))  # 5           \ | /
    #              \|/
    #               5

    # The 8 faces
    fg.createFace((v[0], v[1], v[4], v[0]))
    fg.createFace((v[0], v[4], v[3], v[0]))
    fg.createFace((v[0], v[3], v[2], v[0]))
    fg.createFace((v[0], v[2], v[1], v[0]))
    fg.createFace((v[5], v[4], v[1], v[5]))
    fg.createFace((v[5], v[1], v[2], v[5]))
    fg.createFace((v[5], v[2], v[3], v[5]))
    fg.createFace((v[5], v[3], v[4], v[5]))

    return p
Exemple #5
0
def addCube(mesh, position=[0.0, 0.0, 0.0], scale=1.0, name='cube'):
    fg = mesh.createFaceGroup(name)

    # The 8 vertices
    v = []
    v.append(mesh.createVertex(aljabr.vadd(
        position, [-scale, -scale, -scale])))  # 0         /0-----1\
    v.append(mesh.createVertex(aljabr.vadd(
        position, [scale, -scale, -scale])))  # 1        / |     | \
    v.append(mesh.createVertex(aljabr.vadd(
        position, [scale, scale, -scale])))  # 2       |4---------5|
    v.append(mesh.createVertex(aljabr.vadd(
        position, [-scale, scale, -scale])))  # 3       |  |     |  |
    v.append(mesh.createVertex(aljabr.vadd(
        position, [-scale, -scale, scale])))  # 4       |  3-----2  |
    v.append(mesh.createVertex(aljabr.vadd(
        position, [scale, -scale, scale])))  # 5       | /       \ |
    v.append(mesh.createVertex(aljabr.vadd(
        position, [scale, scale, scale])))  # 6       |/         \|
    v.append(mesh.createVertex(aljabr.vadd(
        position, [-scale, scale, scale])))  # 7       |7---------6|

    # The 6 faces
    fg.createFace((v[4], v[5], v[6], v[7]))  # front
    fg.createFace((v[1], v[0], v[3], v[2]))  # back
    fg.createFace((v[0], v[4], v[7], v[3]))  # left
    fg.createFace((v[5], v[1], v[2], v[6]))  # right
    fg.createFace((v[0], v[1], v[5], v[4]))  # top
    fg.createFace((v[7], v[6], v[2], v[3]))  # bottom
 def getSkeleton(self):
     
     human = gui3d.app.selectedHuman
     
     if not self.__skeletonObject:
         
         self.__buildSkeletonMesh()
         self.__skeletonObject = self.addObject(gui3d.Object(aljabr.vadd(human.getPosition(), [0.0, -20.0, 0.0]), self.__skeletonMesh))
         
     else:
         
         self.__skeletonObject.setPosition(aljabr.vadd(human.getPosition(), [0.0, -20.0, 0.0]))
     
     self.__skeletonObject.setRotation(human.getRotation())
     
     return self.__skeletonObject
def addPrism(mesh, o=[0.0, 0.0, 0.0], e=[0.0, 1.0, 0.0], name='prism'):
    fg = mesh.createFaceGroup(name)

    dir = aljabr.vsub(e, o) # direction vector from o to e
    if dir == [0.0, 0.0, 0.0]:
        dir = [0.0, 1.0, 0.0]
    len = aljabr.vlen(dir) # distance from o to e
    if len == 0:
        len = 1
    scale = 0.5 # the thickness is 10% of the length
    i = aljabr.vadd(o, aljabr.vmul(dir, 0.25)) # the thickest part is 25% from o
    n = aljabr.vmul(dir, 1.0 / len) # the normalized direction
    q = aljabr.axisAngleToQuaternion(n, pi / 2.0) # a quaternion to rotate the point p1 to obtain the other points
    p = p1 = aljabr.randomPointFromNormal(n) # a random point in the plane defined by 0,0,0 and n
    p1 = aljabr.vmul(aljabr.vnorm(p1), scale) # the point scaled to the thickness
    p2 = aljabr.quaternionVectorTransform(q, p1) # the other points
    p3 = aljabr.quaternionVectorTransform(q, p2)
    p4 = aljabr.quaternionVectorTransform(q, p3)
    
    p1 = aljabr.vadd(i, p1) # translate by i since we were working in the origin
    p2 = aljabr.vadd(i, p2)
    p3 = aljabr.vadd(i, p3)
    p4 = aljabr.vadd(i, p4)

    # The 6 vertices
    v = []
    v.append(mesh.createVertex(o))      # 0             0
    v.append(mesh.createVertex(p1))     # 1            /|\
    v.append(mesh.createVertex(p2))     # 2           /.2.\
    v.append(mesh.createVertex(p3))     # 3          1` | `3
    v.append(mesh.createVertex(p4))     # 4          \`.4.`/ 
    v.append(mesh.createVertex(e))      # 5           \ | /
                                        #              \|/
                                        #               5
    
    # The 8 faces
    fg.createFace((v[0], v[1], v[4], v[0]))
    fg.createFace((v[0], v[4], v[3], v[0]))
    fg.createFace((v[0], v[3], v[2], v[0]))
    fg.createFace((v[0], v[2], v[1], v[0]))
    fg.createFace((v[5], v[4], v[1], v[5]))
    fg.createFace((v[5], v[1], v[2], v[5]))
    fg.createFace((v[5], v[2], v[3], v[5]))
    fg.createFace((v[5], v[3], v[4], v[5]))
    
    return p
Exemple #8
0
def setupBones(obj):
    global boneHead, boneTail, locations
    setupLocations(obj)
    locations["origin"] = (-2.0, 10.0, 0.0)
    boneHead = {}
    boneTail = {}
    for (bone, par, hjoint, hoffs, tjoint, toffs, flags, layers, dispOb, ikFlags) in armature + colladaBones:
        if hoffs:
            x = getOffs(hoffs)
            boneHead[bone] = aljabr.vadd(locations[hjoint], x)
        else:
            boneHead[bone] = locations[hjoint]
        if toffs:
            x = getOffs(toffs)
            boneTail[bone] = aljabr.vadd(locations[tjoint], x)
        else:
            boneTail[bone] = locations[tjoint]
Exemple #9
0
def setupBones(obj):
    global boneHead, boneTail, locations
    setupLocations(obj)
    locations['origin'] = (-2.0, 10.0, 0.0)
    boneHead = {}
    boneTail = {}
    for (bone, par, hjoint, hoffs, tjoint, toffs, flags, layers, dispOb,
         ikFlags) in armature + colladaBones:
        if hoffs:
            x = getOffs(hoffs)
            boneHead[bone] = aljabr.vadd(locations[hjoint], x)
        else:
            boneHead[bone] = locations[hjoint]
        if toffs:
            x = getOffs(toffs)
            boneTail[bone] = aljabr.vadd(locations[tjoint], x)
        else:
            boneTail[bone] = locations[tjoint]
    def updateBackground(self):

        if self.backgroundImage.hasTexture():

            reference = gui3d.app.selectedHuman.getPosition()
            diff = vsub(reference, self.reference)
            self.leftTop = vadd(self.leftTop, diff)
            self.rightBottom = vadd(self.rightBottom, diff)

            leftTop = gui3d.app.modelCamera.convertToScreen(*self.leftTop)
            rightBottom = gui3d.app.modelCamera.convertToScreen(*self.rightBottom)

            self.backgroundImage.setPosition([leftTop[0], leftTop[1], 8])
            self.backgroundWidth = rightBottom[0]-leftTop[0]
            self.backgroundHeight = rightBottom[1]-leftTop[1]
            self.backgroundImage.mesh.resize(self.backgroundWidth, self.backgroundHeight)

            self.reference = reference
def hairWidthUpdate(scn, obj,res=0.04, widthFactor=1.0): #luckily both normal and vertex index of object remains the same!
  N=len(obj.verts)
  origWidth = vdist(obj.verts[1].co,obj.verts[0].co)/res
  diff= (widthFactor-origWidth)*res/2
  for i in xrange(0,N/2):
      vec=vmul(vnorm(vsub(obj.verts[i*2+1].co,obj.verts[i*2].co)), diff) 
      obj.verts[i*2].co=vsub(obj.verts[i*2].co,vec)
      obj.verts[i*2+1].co=vadd(obj.verts[i*2+1].co,vec)
      obj.verts[i*2].update(updateNor=0)
      obj.verts[i*2+1].update(updateNor=0)
Exemple #12
0
 def build(self, human):
     for bone in self.armature.boneList:
         for n in self.getLayers(bone.layers):
             if not self.layers[n]:
                 self.layers[n] = CLayerObject('Layer%2d' % n, self.view.prismType)
             self.layers[n].buildBoneMesh(bone)
         
     for layer in self.layers.values():
         if layer:
             location = aljabr.vadd(human.getPosition(), [0.0, 0.0, 0.0])
             ob = layer.finishBuild(location)            
Exemple #13
0
    def build(self, human):
        for bone in self.armature.boneList:
            for n in self.getLayers(bone.layers):
                if not self.layers[n]:
                    self.layers[n] = CLayerObject('Layer%2d' % n,
                                                  self.view.prismType)
                self.layers[n].buildBoneMesh(bone)

        for layer in self.layers.values():
            if layer:
                location = aljabr.vadd(human.getPosition(), [0.0, 0.0, 0.0])
                ob = layer.finishBuild(location)
Exemple #14
0
 def getArmature(self):
     
     human = gui3d.app.selectedHuman
     #self.armature.update()
     
     if not self.armatureObject:            
         self.armatureObject = CArmatureObject(self.armature, self)
         self.armatureObject.build(human)
         self.armatureObject.setRotation(human.getRotation())        
     else:            
         self.armatureObject.update()
         self.armatureObject.setPosition(aljabr.vadd(human.getPosition(), [0.0, 0.0, 0.0]))             
         self.armatureObject.setRotation(human.getRotation())        
     return self.armatureObject
Exemple #15
0
    def getArmature(self):

        human = gui3d.app.selectedHuman
        #self.armature.update()

        if not self.armatureObject:
            self.armatureObject = CArmatureObject(self.armature, self)
            self.armatureObject.build(human)
            self.armatureObject.setRotation(human.getRotation())
        else:
            self.armatureObject.update()
            self.armatureObject.setPosition(
                aljabr.vadd(human.getPosition(), [0.0, 0.0, 0.0]))
            self.armatureObject.setRotation(human.getRotation())
        return self.armatureObject
Exemple #16
0
def setupRigJoint(words, obj, verts, locations):
    key = words[0]
    typ = words[1]
    if typ == 'joint':
        loc = mh2proxy.calcJointPos(obj, words[2])
        locations[key] = loc
    elif typ == 'vertex':
        v = int(words[2])
        locations[key] = verts[v].co
    elif typ == 'position':
        x = locations[words[2]]
        y = locations[words[3]]
        z = locations[words[4]]
        locations[key] = [x[0], y[1], z[2]]
    elif typ == 'line':
        k1 = float(words[2])
        k2 = float(words[4])
        locations[key] = vadd(vmul(locations[words[3]], k1),
                              vmul(locations[words[5]], k2))
    elif typ == 'offset':
        x = float(words[3])
        y = float(words[4])
        z = float(words[5])
        locations[key] = vadd(locations[words[2]], [x, y, z])
    elif typ == 'voffset':
        v = int(words[2])
        x = float(words[3])
        y = float(words[4])
        z = float(words[5])
        try:
            loc = verts[v].co
        except:
            loc = verts[v]
        locations[key] = vadd(loc, [x, y, z])
    elif typ == 'front':
        raw = locations[words[2]]
        head = locations[words[3]]
        tail = locations[words[4]]
        offs = map(float, words[5].strip().lstrip('[').rstrip(']').split(','))
        vec = aljabr.vsub(tail, head)
        vec2 = aljabr.vdot(vec, vec)
        vraw = aljabr.vsub(raw, head)
        x = aljabr.vdot(vec, vraw) / vec2
        rvec = aljabr.vmul(vec, x)
        nloc = aljabr.vadd(head, rvec, offs)
        locations[key] = nloc
    else:
        raise NameError("Unknown %s" % typ)
Exemple #17
0
def setupRigJoint (words, obj, verts, locations):
    key = words[0]
    typ = words[1]
    if typ == 'joint':
        loc = mh2proxy.calcJointPos(obj, words[2])
        locations[key] = loc
    elif typ == 'vertex':
        v = int(words[2])
        locations[key] = verts[v].co
    elif typ == 'position':
        x = locations[words[2]]
        y = locations[words[3]]
        z = locations[words[4]]
        locations[key] = [x[0],y[1],z[2]]
    elif typ == 'line':
        k1 = float(words[2])
        k2 = float(words[4])
        locations[key] = vadd(vmul(locations[words[3]], k1), vmul(locations[words[5]], k2))
    elif typ == 'offset':
        x = float(words[3])
        y = float(words[4])
        z = float(words[5])
        locations[key] = vadd(locations[words[2]], [x,y,z])
    elif typ == 'voffset':
        v = int(words[2])
        x = float(words[3])
        y = float(words[4])
        z = float(words[5])
        try:
            loc = verts[v].co
        except:
            loc = verts[v]         
        locations[key] = vadd(loc, [x,y,z])
    elif typ == 'front':
        raw = locations[words[2]]
        head = locations[words[3]]
        tail = locations[words[4]]
        offs = map(float, words[5].strip().lstrip('[').rstrip(']').split(','))
        vec = aljabr.vsub(tail, head)
        vec2 = aljabr.vdot(vec, vec)
        vraw = aljabr.vsub(raw, head)
        x = aljabr.vdot(vec, vraw) / vec2
        rvec = aljabr.vmul(vec, x)
        nloc = aljabr.vadd(head, rvec, offs)
        locations[key] = nloc
    else:
        raise NameError("Unknown %s" % typ)
    def draw(self):
        skeletonMesh = module3d.Object3D('skeleton')
        skeletonMesh.uvValues = []
        skeletonMesh.indexBuffer = []

        self.root.draw(skeletonMesh)

        skeletonMesh.setCameraProjection(0)
        skeletonMesh.setShadeless(0)
        skeletonMesh.setSolid(0)
        skeletonMesh.calcNormals()
        skeletonMesh.updateIndexBuffer()

        skeletonObject = gui3d.Object(vadd(self.human.getPosition(), [0.0, 0.0, 0.0]), skeletonMesh)
        skeletonObject.mesh.setCameraProjection(0)
        skeletonObject.setRotation(self.human.getRotation())
        return skeletonObject
def drawBVHSkeleton(skeleton, human):
    bvhMesh = module3d.Object3D('bvhskeleton')
    bvhMesh.uvValues = []
    bvhMesh.indexBuffer = []

    _drawBVHJoint(skeleton.root, bvhMesh)

    bvhMesh.setCameraProjection(0)
    bvhMesh.setShadeless(0)
    bvhMesh.setSolid(0)
    bvhMesh.calcNormals()
    bvhMesh.updateIndexBuffer()

    bvhObject = gui3d.Object(aljabr.vadd(human.getPosition(), [0.0, 0.0, 0.0]), bvhMesh)
    bvhObject.setRotation(human.getRotation())

    return bvhObject
def drawBVHSkeleton(skeleton, human):
    bvhMesh = module3d.Object3D('bvhskeleton')
    bvhMesh.uvValues = []
    bvhMesh.indexBuffer = []

    _drawBVHJoint(skeleton.root, bvhMesh)

    bvhMesh.setCameraProjection(0)
    bvhMesh.setShadeless(0)
    bvhMesh.setSolid(0)
    bvhMesh.calcNormals()
    bvhMesh.updateIndexBuffer()

    bvhObject = gui3d.Object(aljabr.vadd(human.getPosition(), [0.0, 0.0, 0.0]),
                             bvhMesh)
    bvhObject.setRotation(human.getRotation())

    return bvhObject
Exemple #21
0
    def draw(self):
        skeletonMesh = module3d.Object3D('skeleton')
        skeletonMesh.uvValues = []
        skeletonMesh.indexBuffer = []

        self.root.draw(skeletonMesh)

        skeletonMesh.setCameraProjection(0)
        skeletonMesh.setShadeless(0)
        skeletonMesh.setSolid(0)
        skeletonMesh.calcNormals()
        skeletonMesh.updateIndexBuffer()

        skeletonObject = gui3d.Object(
            vadd(self.human.getPosition(), [0.0, 0.0, 0.0]), skeletonMesh)
        skeletonObject.mesh.setCameraProjection(0)
        skeletonObject.setRotation(self.human.getRotation())
        return skeletonObject
def addInvBones(hier, heads, tails):
    newHier = []
    for (bone, children) in hier:
        newChildren = addInvBones(children, heads, tails)
        n = len(children)
        if n == 1:
            (child, subChildren) = children[0]
            offs = vsub(tails[bone], heads[child])
        if n > 1 or (n == 1 and vlen(offs) > 1e-4):
            boneInv = bone + "Inv"
            heads[boneInv] = tails[bone]
            #tails[boneInv] = heads[bone]
            tails[boneInv] = aljabr.vadd(tails[bone], Delta)
            newHier.append((bone, [(boneInv, newChildren)]))
        else:
            newHier.append((bone, newChildren))

    return newHier
def addInvBones(hier, heads, tails):
    newHier = []
    for (bone, children) in hier:
        newChildren = addInvBones(children, heads, tails)
        n = len(children)
        if n == 1:
            (child, subChildren) = children[0]
            offs = vsub(tails[bone], heads[child])
        if n > 1 or (n == 1 and vlen(offs) > 1e-4):
            boneInv = bone+"Inv"
            heads[boneInv] = tails[bone]
            #tails[boneInv] = heads[bone]
            tails[boneInv] = aljabr.vadd(tails[bone], Delta)
            newHier.append( (bone, [(boneInv, newChildren)]) )
        else:
            newHier.append( (bone, newChildren) )

    return newHier
    def __calcPosition(self, joint, scale):
        # Get OFFSET
        items = self.__expectKeyword('OFFSET')
        joint.offset = [scale*float(x) for x in items[1:]]
        joint.strans = joint.offset[:]
        joint.stransmat[0,3] = joint.strans[0]
        joint.stransmat[1,3] = joint.strans[1]
        joint.stransmat[2,3] = joint.strans[2]
        
        if joint.parent:
            joint.position = vadd(joint.parent.position, joint.offset)
        else:
            joint.position = joint.offset[:]

        # Calculate static transformation matrix
        joint.stransmat = array([ [1.,0.,0.,0.],[0.,1.,0.,0.],[0.,0.,1.,0.],[0.,0.,0.,1.] ])
        joint.stransmat[0,3] = joint.offset[0]
        joint.stransmat[1,3] = joint.offset[1]
        joint.stransmat[2,3] = joint.offset[2]
def addCube(mesh, position=[0.0, 0.0, 0.0], scale=1.0, name='cube'):
    fg = mesh.createFaceGroup(name)

    # The 8 vertices
    v = []
    v.append(mesh.createVertex(aljabr.vadd(position, [-scale, -scale, -scale]))) # 0         /0-----1\
    v.append(mesh.createVertex(aljabr.vadd(position, [scale, -scale, -scale])))  # 1        / |     | \
    v.append(mesh.createVertex(aljabr.vadd(position, [scale, scale, -scale])))   # 2       |4---------5|
    v.append(mesh.createVertex(aljabr.vadd(position, [-scale, scale, -scale])))  # 3       |  |     |  |
    v.append(mesh.createVertex(aljabr.vadd(position, [-scale, -scale, scale])))  # 4       |  3-----2  |  
    v.append(mesh.createVertex(aljabr.vadd(position, [scale, -scale, scale])))   # 5       | /       \ |
    v.append(mesh.createVertex(aljabr.vadd(position, [scale, scale, scale])))    # 6       |/         \|
    v.append(mesh.createVertex(aljabr.vadd(position, [-scale, scale, scale])))   # 7       |7---------6|
    
    # The 6 faces
    fg.createFace((v[4], v[5], v[6], v[7])) # front
    fg.createFace((v[1], v[0], v[3], v[2])) # back
    fg.createFace((v[0], v[4], v[7], v[3])) # left
    fg.createFace((v[5], v[1], v[2], v[6])) # right
    fg.createFace((v[0], v[1], v[5], v[4])) # top
    fg.createFace((v[7], v[6], v[2], v[3])) # bottom
    def generateHairInterpolation2(self,guide1,guide2,humanMesh,isCollision,startIndex=9,gravity=True):
        if isCollision: octree = simpleoctree.SimpleOctree(humanMesh.getData().verts,0.08)
        hairName = "strand%s-%s"%(guide1.name,guide2.name)
        hSet = HairGroup(hairName)

        if len(guide1.controlPoints)>= len(guide2.controlPoints):
            longerGuide = guide1
            shorterGuide = guide2
        else:
            longerGuide = guide2
            shorterGuide = guide1

        nVerts = min([len(guide1.controlPoints),len(guide2.controlPoints)])
        interpFactor = 0
        vertsListToModify1 = []
        vertsListToModify2 = []

        for n in range (self.numberOfHairsMultiStrand):
            h = Hair()
            interpFactor += 1.0/self.numberOfHairsMultiStrand
            for i in range(len(longerGuide.controlPoints)):
                if random.random() < self.randomPercentage:
                    xRand = self.sizeMultiStrand*random.random()*self.randomFactMultiStrand
                    yRand = self.sizeMultiStrand*random.random()*self.randomFactMultiStrand
                    zRand = self.sizeMultiStrand*random.random()*self.randomFactMultiStrand
                    randomVect = [xRand,yRand,zRand]
                else:
                    randomVect = [0,0,0]

                if i == 0:
                    i2 = 0
                if i == len(longerGuide.controlPoints)-1:
                    i2 = len(shorterGuide.controlPoints)-1
                else:
                    i2 = int(round(i*len(shorterGuide.controlPoints)/len(longerGuide.controlPoints)))

                vert1 = longerGuide.controlPoints[i]
                vert2 = shorterGuide.controlPoints[i2]

                #Slerp
                dotProd = aljabr.vdot(aljabr.vnorm(vert1),aljabr.vnorm(vert2))
                #Python has a very very bad numerical accuracy.. we need to do this for very small angle between guides 
                #this occurs when we do collision detection
                if dotProd>1: 
                    angleBetweenGuides = 0.0
                else:
                    angleBetweenGuides = math.acos(aljabr.vdot(aljabr.vnorm(vert1),aljabr.vnorm(vert2)))
                denom = math.sin(angleBetweenGuides)
                if denom == 0.0: #controlpoints of some guides coincide
                    vert1[0] = self.randomPercentage*self.sizeMultiStrand*random.random()*self.randomFactMultiStrand+vert1[0]
                    vert1[1] = self.randomPercentage*self.sizeMultiStrand*random.random()*self.randomFactMultiStrand+vert1[1]
                    vert1[2] = self.randomPercentage*self.sizeMultiStrand*random.random()*self.randomFactMultiStrand+vert1[2]
                    vert1= aljabr.vadd(vert1,randomVect)
                    angleBetweenGuides = math.acos(aljabr.vdot(aljabr.vnorm(vert1),aljabr.vnorm(vert2)))
                    denom = math.sin(angleBetweenGuides)
                f1 = math.sin((1-interpFactor)*angleBetweenGuides)/denom
                f2 = math.sin(interpFactor*angleBetweenGuides)/denom
                newVert = aljabr.vadd(aljabr.vmul(vert1,f1),aljabr.vmul(vert2,f2))

                #Uncomment the following line we use lerp instead slerp
                #newVert = aljabr.vadd(aljabr.vmul(vert1,(1-interpFactor)),aljabr.vmul(vert2,interpFactor))
                h.controlPoints.append([newVert[0]+randomVect[0],\
                                                newVert[1]+randomVect[1],\
                                                newVert[2]+randomVect[2]])
            if isCollision:
                print "h is: ", h.controlPoints
                for j in (0,len(h.controlPoints)):
                    #print "h.controlPts is : ", h.controlPoints[i]
                    #print "h.controlPts[i] length is: ", len(h.controlPoints[i])
                    h.controlPoints[i][2] = -h.controlPoints[i][2] #Renderman to Blender coordinates!
                collision(h.controlPoints,humanMesh,octree.minsize,startIndex,gravity)
                for j in (0,len(h.controlPoints)):
                    h.controlPoints[i][2] = -h.controlPoints[i][2] #Blender to Renderman coordinates!
            hSet.hairs.append(h)
        self.hairStyle.append(hSet)
Exemple #27
0
def newSetupJoints(obj, joints):
    the.Locations = {}
    for (key, typ, data) in joints:
        #print(key)
        if typ == 'j':
            loc = mh2proxy.calcJointPos(obj, data)
            the.Locations[key] = loc
            the.Locations[data] = loc
        elif typ == 'v':
            v = int(data)
            the.Locations[key] = obj.verts[v].co
        elif typ == 'x':
            the.Locations[key] = [
                float(data[0]),
                float(data[2]), -float(data[1])
            ]
        elif typ == 'vo':
            v = int(data[0])
            loc = obj.verts[v].co
            the.Locations[key] = [
                loc[0] + float(data[1]), loc[1] + float(data[3]),
                loc[2] - float(data[2])
            ]
        elif typ == 'vl':
            ((k1, v1), (k2, v2)) = data
            loc1 = obj.verts[int(v1)].co
            loc2 = obj.verts[int(v2)].co
            the.Locations[key] = vadd(vmul(loc1, k1), vmul(loc2, k2))
        elif typ == 'f':
            (raw, head, tail, offs) = data
            rloc = the.Locations[raw]
            hloc = the.Locations[head]
            tloc = the.Locations[tail]
            #print(raw, rloc)
            vec = aljabr.vsub(tloc, hloc)
            vec2 = aljabr.vdot(vec, vec)
            vraw = aljabr.vsub(rloc, hloc)
            x = aljabr.vdot(vec, vraw) / vec2
            rvec = aljabr.vmul(vec, x)
            nloc = aljabr.vadd(hloc, rvec, offs)
            #print(key, nloc)
            the.Locations[key] = nloc
        elif typ == 'b':
            the.Locations[key] = the.Locations[data]
        elif typ == 'p':
            x = the.Locations[data[0]]
            y = the.Locations[data[1]]
            z = the.Locations[data[2]]
            the.Locations[key] = [x[0], y[1], z[2]]
        elif typ == 'vz':
            v = int(data[0])
            z = obj.verts[v].co[2]
            loc = the.Locations[data[1]]
            the.Locations[key] = [loc[0], loc[1], z]
        elif typ == 'X':
            r = the.Locations[data[0]]
            (x, y, z) = data[1]
            r1 = [float(x), float(y), float(z)]
            the.Locations[key] = aljabr.vcross(r, r1)
        elif typ == 'l':
            ((k1, joint1), (k2, joint2)) = data
            the.Locations[key] = vadd(vmul(the.Locations[joint1], k1),
                                      vmul(the.Locations[joint2], k2))
        elif typ == 'o':
            (joint, offsSym) = data
            if type(offsSym) == str:
                offs = the.Locations[offsSym]
            else:
                offs = offsSym
            the.Locations[key] = vadd(the.Locations[joint], offs)
        else:
            raise NameError("Unknown %s" % typ)
    return
def readProxyFile(obj, file, evalOnLoad):
    if not file:
        return CProxy(None, 'Proxy', 2)
    elif type(file) == str or type(file) == unicode:
        pfile = export_config.CProxyFile()
        pfile.file = file
    else:
        pfile = file
    #print "Loading", pfile
    folder = os.path.dirname(pfile.file)
    objfile = None
    
    try:
        tmpl = open(pfile.file, "rU")
    except:
        tmpl = None
    if tmpl == None:
        print ("*** Cannot open", pfile.file)
        return None
        return CProxy(None, pfile.type, pfile.layer)

    verts = obj.verts
    locations = {}
    tails = {}
    proxy = CProxy(pfile.file, pfile.type, pfile.layer)
    proxy.name = "MyProxy"

    useProjection = True
    ignoreOffset = False
    xScale = 1.0
    yScale = 1.0
    zScale = 1.0
    
    status = 0

    vn = 0
    for line in tmpl:
        words= line.split()
        if len(words) == 0:
            pass
        elif words[0] == '#':
            theGroup = None
            if len(words) == 1:
                continue
            key = words[1]
            if key == 'verts':
                if evalOnLoad:
                    status = doVerts
                else:
                    status = doRefVerts
            elif key == 'faces':
                status = doFaces
            elif key == 'weights':
                status = doWeights
                if proxy.weights == None:
                    proxy.weights = {}
                weights = []
                proxy.weights[words[2]] = weights
            elif key == 'material':
                status = doMaterial
                proxy.material.name = stringFromWords(words[2:])
            elif key == 'useBaseMaterials':
                proxy.useBaseMaterials = True
            elif key == 'faceNumbers':
                status = doFaceNumbers
            elif key == 'texVerts':
                status = doTexVerts
                if len(words) > 2:
                    layer = int(words[2])
                else:
                    layer = 0
                proxy.texVerts = []
                proxy.texVertsLayers[layer] = proxy.texVerts
            elif key == 'texFaces':
                status = doTexFaces
                if len(words) > 2:
                    layer = int(words[2])
                else:
                    layer = 0
                proxy.texFaces = []
                proxy.texFacesLayers[layer] = proxy.texFaces
            elif key == 'obj_data':
                status = doObjData
                proxy.texVerts = []
                proxy.texFaces = []
                proxy.texVertsLayers[0] = proxy.texVerts
                proxy.texFacesLayers[0] = proxy.texFaces                
            elif key == 'name':
                proxy.name = stringFromWords(words[2:])
            elif key == 'uuid':
                proxy.uuid = stringFromWords(words[2:])
            elif key == 'tag':
                proxy.tags.append( stringFromWords(words[2:]) )
            elif key == 'z_depth':
                proxy.z_depth = int(words[2])
            elif key == 'wire':
                proxy.wire = True
            elif key == 'cage':
                proxy.cage = True
            elif key == 'x_scale':
                proxy.xScaleData = getScaleData(words)
                xScale = getScale(proxy.xScaleData, verts, 0)
            elif key == 'y_scale':
                proxy.yScaleData = getScaleData(words)
                yScale = getScale(proxy.yScaleData, verts, 1)
            elif key == 'z_scale':
                proxy.zScaleData = getScaleData(words)
                zScale = getScale(proxy.zScaleData, verts, 2)
            elif key == 'use_projection':
                useProjection = int(words[2])
            elif key == 'ignoreOffset':
                ignoreOffset = int(words[2])
            elif key == 'delete':
                proxy.deleteGroups.append(words[2])
            elif key == 'delete_connected':
                selectConnected(proxy, obj, int(words[2]))
            elif key == 'rig':
                proxy.rig = getFileName(folder, words[2], ".rig")
            elif key == 'mask':
                proxy.mask = getFileName(folder, words[2], ".png")
                if len(words) > 3:
                    proxy.maskLayer = int(words[3])
            elif key == 'bump':
                proxy.bump = getFileName(folder, words[2], ".tif")
                if len(words) > 4:
                    proxy.bumpStrength = float(words[4])
            elif key == 'normal':
                proxy.normal = getFileName(folder, words[2], ".tif")
                if len(words) > 4:
                    proxy.normalStrength = float(words[4])
            elif key == 'transparency':
                proxy.transparency = getFileName(folder, words[2], ".tif")
            elif key == 'displacement':
                proxy.displacement = getFileName(folder, words[2], ".tif")
                if len(words) > 4:
                    proxy.dispStrength = float(words[4])
            elif key == 'texture':
                proxy.texture = getFileName(folder, words[2], ".tif")
                if len(words) > 3:
                    proxy.textureLayer = int(words[3])
            elif key == 'objfile_layer':
                proxy.objFileLayer = int(words[2])
            elif key == 'uvtex_layer':
                proxy.uvtexLayerName[int(words[2])] = words[3]
            elif key == 'material_file':
                proxy.material_file = getFileName(folder, words[2], ".mhx")
            elif key == 'obj_file':
                proxy.obj_file = getFileName(folder, words[2], ".obj")
            elif key == 'clothing':
                proxy.clothings.append(words[2])
            elif key == 'subsurf':
                levels = int(words[2])
                if len(words) > 3:
                    render = int(words[3])
                else:
                    render = levels+1
                proxy.modifiers.append( ['subsurf', levels, render] )
            elif key == 'shrinkwrap':
                offset = float(words[2])
                proxy.modifiers.append( ['shrinkwrap', offset] )
            elif key == 'solidify':
                thickness = float(words[2])
                offset = float(words[3])
                proxy.modifiers.append( ['solidify', thickness, offset] )
            elif key == 'shapekey':
                proxy.shapekeys.append( words[2] )
            elif key == 'basemesh':
                proxy.basemesh = words[2]
            else:
                pass
                #print "Ignored proxy keyword", key
        elif status == doObjData:
            if words[0] == 'vt':
                newTexVert(1, words, proxy)
            elif words[0] == 'f':
                newFace(1, words, theGroup, proxy)
            elif words[0] == 'g':
                theGroup = words[1]
        elif status == doFaceNumbers:
            proxy.faceNumbers.append(line)
        elif status == doRefVerts:
            if len(words) == 1:
                v = int(words[0])
                proxy.refVerts.append(v)
            else:                
                v0 = int(words[0])
                v1 = int(words[1])
                v2 = int(words[2])
                w0 = float(words[3])
                w1 = float(words[4])
                w2 = float(words[5])            
                if len(words) > 6:
                    d0 = float(words[6])
                    d1 = float(words[7])
                    d2 = float(words[8])
                else:
                    (d0,d1,d2) = (0,0,0)
                proxy.refVerts.append( (v0,v1,v2,w0,w1,w2,d0,d1,d2) )
        elif status == doVerts:
            if len(words) == 1:
                v = int(words[0])
                proxy.realVerts.append(verts[v])
                addProxyVert(v, vn, 1, proxy)
            else:                
                v0 = int(words[0])
                v1 = int(words[1])
                v2 = int(words[2])
                w0 = float(words[3])
                w1 = float(words[4])
                w2 = float(words[5])            

                if len(words) < 7 or ignoreOffset:
                    (d0, d1, d2) = (0, 0, 0)
                elif useProjection:
                    proj = float(words[6])
                    n0 = aljabr.vmul(verts[v0].no, w0)
                    n1 = aljabr.vmul(verts[v1].no, w1)
                    n2 = aljabr.vmul(verts[v2].no, w2)
                    norm = aljabr.vadd(n0, n1)
                    norm = aljabr.vadd(norm, n2)
                    d0 = proj * norm[0] * xScale
                    d1 = proj * norm[1] * yScale
                    d2 = proj * norm[2] * zScale
                else:
                    d0 = float(words[6]) * xScale
                    d1 = float(words[7]) * yScale
                    d2 = float(words[8]) * zScale

                proxy.realVerts.append((verts[v0], verts[v1], verts[v2], w0, w1, w2, d0, d1, d2))
                addProxyVert(v0, vn, w0, proxy)
                addProxyVert(v1, vn, w1, proxy)
                addProxyVert(v2, vn, w2, proxy)
            vn += 1
        elif status == doFaces:
            newFace(0, words, theGroup, proxy)
        elif status == doTexVerts:
            newTexVert(0, words, proxy)
        elif status == doTexFaces:
            newTexFace(words, proxy)
        elif status == doMaterial:
            readMaterial(line, proxy.material, proxy, False)
        elif status == doWeights:
            v = int(words[0])
            w = float(words[1])
            weights.append((v,w))
            
    if evalOnLoad and proxy.obj_file:
        if not copyObjFile(proxy):
            return None

    if pfile.name:
        proxy.name = pfile.name
    return proxy
Exemple #29
0
def readProxyFile(obj, file, evalOnLoad):
    if not file:
        return CProxy(None, 'Proxy', 2)
    elif type(file) == str or type(file) == unicode:
        pfile = export_config.CProxyFile()
        pfile.file = file
    else:
        pfile = file
    #print "Loading", pfile
    folder = os.path.dirname(pfile.file)
    objfile = None
    
    try:
        tmpl = open(pfile.file, "rU")
    except:
        tmpl = None
    if tmpl == None:
        log.error("*** Cannot open %s", pfile.file)
        return None
        return CProxy(None, pfile.type, pfile.layer)

    verts = obj.verts
    locations = {}
    tails = {}
    proxy = CProxy(pfile.file, pfile.type, pfile.layer)
    proxy.deleteVerts = np.zeros(len(verts), bool)
    proxy.name = "MyProxy"

    useProjection = True
    ignoreOffset = False
    xScale = 1.0
    yScale = 1.0
    zScale = 1.0
    
    status = 0

    vn = 0
    for line in tmpl:
        words= line.split()
        if len(words) == 0:
            pass
        elif words[0] == '#':
            theGroup = None
            if len(words) == 1:
                continue
            key = words[1]
            if key == 'verts':
                if evalOnLoad:
                    status = doVerts
                else:
                    status = doRefVerts
            elif key == 'faces':
                status = doFaces
            elif key == 'weights':
                status = doWeights
                if proxy.weights == None:
                    proxy.weights = {}
                weights = []
                proxy.weights[words[2]] = weights
            elif key == 'material':
                status = doMaterial
                proxy.material.name = stringFromWords(words[2:])
            elif key == 'useBaseMaterials':
                proxy.useBaseMaterials = True
            elif key == 'faceNumbers':
                status = doFaceNumbers
            elif key == 'texVerts':
                status = doTexVerts
                if len(words) > 2:
                    layer = int(words[2])
                else:
                    layer = 0
                proxy.texVerts = []
                proxy.texVertsLayers[layer] = proxy.texVerts
            elif key == 'texFaces':
                status = doTexFaces
                if len(words) > 2:
                    layer = int(words[2])
                else:
                    layer = 0
                proxy.texFaces = []
                proxy.texFacesLayers[layer] = proxy.texFaces
            elif key == 'obj_data':
                status = doObjData
                proxy.texVerts = []
                proxy.texFaces = []
                proxy.texVertsLayers[0] = proxy.texVerts
                proxy.texFacesLayers[0] = proxy.texFaces     
            elif key == 'name':
                proxy.name = stringFromWords(words[2:])
            elif key == 'uuid':
                proxy.uuid = stringFromWords(words[2:])
            elif key == 'tag':
                proxy.tags.append( stringFromWords(words[2:]) )
            elif key == 'z_depth':
                proxy.z_depth = int(words[2])
            elif key == 'wire':
                proxy.wire = True
            elif key == 'cage':
                proxy.cage = True
            elif key == 'x_scale':
                proxy.xScaleData = getScaleData(words)
                xScale = getScale(proxy.xScaleData, verts, 0)
            elif key == 'y_scale':
                proxy.yScaleData = getScaleData(words)
                yScale = getScale(proxy.yScaleData, verts, 1)
            elif key == 'z_scale':
                proxy.zScaleData = getScaleData(words)
                zScale = getScale(proxy.zScaleData, verts, 2)
            elif key == 'use_projection':
                useProjection = int(words[2])
            elif key == 'ignoreOffset':
                ignoreOffset = int(words[2])
            elif key == 'delete':
                proxy.deleteGroups.append(words[2])
            elif key == 'delete_connected':
                selectConnected(proxy, obj, int(words[2]))
            elif key == "delete_verts":
                status = doDeleteVerts
            elif key == 'rig':
                proxy.rig = getFileName(folder, words[2], ".rig")
            elif key == 'mask':
                proxy.mask = getFileName(folder, words[2], ".png")
                if len(words) > 3:
                    proxy.maskLayer = int(words[3])
            elif key == 'specular':
                proxy.specular = getFileName(folder, words[2], ".png")
                if len(words) > 4:
                    proxy.specularStrength = float(words[4])
            elif key == 'bump':
                proxy.bump = getFileName(folder, words[2], ".png")
                if len(words) > 4:
                    proxy.bumpStrength = float(words[4])
            elif key == 'normal':
                proxy.normal = getFileName(folder, words[2], ".png")
                if len(words) > 4:
                    proxy.normalStrength = float(words[4])
            elif key == 'transparency':
                proxy.transparency = getFileName(folder, words[2], ".png")
            elif key == 'displacement':
                proxy.displacement = getFileName(folder, words[2], ".png")
                if len(words) > 4:
                    proxy.dispStrength = float(words[4])
            elif key == 'texture':
                proxy.texture = getFileName(folder, words[2], ".png")
                if len(words) > 3:
                    proxy.textureLayer = int(words[3])
            elif key == 'objfile_layer':
                proxy.objFileLayer = int(words[2])
            elif key == 'uvtex_layer':
                proxy.uvtexLayerName[int(words[2])] = words[3]
            elif key == 'material_file':
                pass
                #proxy.material_file = getFileName(folder, words[2], ".mhx")
            elif key == 'obj_file':
                proxy.obj_file = getFileName(folder, words[2], ".obj")
            elif key == 'backface_culling':
                proxy.cull = words[2].lower() in ["1", "yes", "true", "enable", "enabled"]
            elif key == 'transparent':
                proxy.transparent = words[2].lower() in ["1", "yes", "true", "enable", "enabled"]
            elif key == 'clothing':
                if len(words) > 3:
                    clothingPiece = (words[2], words[3])
                else:
                    clothingPiece = (words[2], None)
                proxy.clothings.append(clothingPiece)
            elif key == 'transparencies':
                uuid = words[2]
                proxy.transparencies[uuid] = words[3].lower() in ["1", "yes", "true", "enable", "enabled"]
            elif key == 'textures':
                proxy.textures.append( (words[2], words[3]) )
            elif key == 'subsurf':
                levels = int(words[2])
                if len(words) > 3:
                    render = int(words[3])
                else:
                    render = levels+1
                proxy.modifiers.append( ['subsurf', levels, render] )
            elif key == 'shrinkwrap':
                offset = float(words[2])
                proxy.modifiers.append( ['shrinkwrap', offset] )
            elif key == 'solidify':
                thickness = float(words[2])
                offset = float(words[3])
                proxy.modifiers.append( ['solidify', thickness, offset] )
            elif key == 'shapekey':
                proxy.shapekeys.append( words[2] )
            elif key == 'basemesh':
                proxy.basemesh = words[2]
            else:
                pass
                #print "Ignored proxy keyword", key
        elif status == doObjData:
            if words[0] == 'vt':
                newTexVert(1, words, proxy)
            elif words[0] == 'f':
                newFace(1, words, theGroup, proxy)
            elif words[0] == 'g':
                theGroup = words[1]
        elif status == doFaceNumbers:
            proxy.faceNumbers.append(line)
        elif status == doRefVerts:
            if len(words) == 1:
                v = int(words[0])
                proxy.refVerts.append(v)
            else:                
                v0 = int(words[0])
                v1 = int(words[1])
                v2 = int(words[2])
                w0 = float(words[3])
                w1 = float(words[4])
                w2 = float(words[5])            
                if len(words) > 6:
                    d0 = float(words[6])
                    d1 = float(words[7])
                    d2 = float(words[8])
                else:
                    (d0,d1,d2) = (0,0,0)
                proxy.refVerts.append( (v0,v1,v2,w0,w1,w2,d0,d1,d2) )
        elif status == doVerts:
            if len(words) == 1:
                v = int(words[0])
                proxy.realVerts.append(verts[v])
                addProxyVert(v, vn, 1, proxy)
            else:                
                v0 = int(words[0])
                v1 = int(words[1])
                v2 = int(words[2])
                w0 = float(words[3])
                w1 = float(words[4])
                w2 = float(words[5])            

                if len(words) < 7 or ignoreOffset:
                    (d0, d1, d2) = (0, 0, 0)
                elif useProjection:
                    proj = float(words[6])
                    n0 = aljabr.vmul(verts[v0].no, w0)
                    n1 = aljabr.vmul(verts[v1].no, w1)
                    n2 = aljabr.vmul(verts[v2].no, w2)
                    norm = aljabr.vadd(n0, n1)
                    norm = aljabr.vadd(norm, n2)
                    d0 = proj * norm[0] * xScale
                    d1 = proj * norm[1] * yScale
                    d2 = proj * norm[2] * zScale
                else:
                    d0 = float(words[6]) * xScale
                    d1 = float(words[7]) * yScale
                    d2 = float(words[8]) * zScale

                proxy.realVerts.append((verts[v0], verts[v1], verts[v2], w0, w1, w2, d0, d1, d2))
                addProxyVert(v0, vn, w0, proxy)
                addProxyVert(v1, vn, w1, proxy)
                addProxyVert(v2, vn, w2, proxy)
            vn += 1
        elif status == doFaces:
            newFace(0, words, theGroup, proxy)
        elif status == doTexVerts:
            newTexVert(0, words, proxy)
        elif status == doTexFaces:
            newTexFace(words, proxy)
        elif status == doMaterial:
            readMaterial(line, proxy.material, proxy, False)
        elif status == doWeights:
            v = int(words[0])
            w = float(words[1])
            weights.append((v,w))
        elif status == doDeleteVerts:
            sequence = False
            for v in words:            
                if v == "-":
                    sequence = True
                else:
                    v1 = int(v)
                    if sequence:
                        for vn in range(v0,v1+1):
                            proxy.deleteVerts[vn] = True
                        sequence = False                            
                    else:
                        proxy.deleteVerts[v1] = True
                    v0 = v1
                        
            
    if evalOnLoad and proxy.obj_file:
        if not copyObjFile(proxy):
            return None

    if pfile.name:
        proxy.name = pfile.name
    return proxy
Exemple #30
0
def newSetupJoints (obj, joints):
    the.Locations = {}
    for (key, typ, data) in joints:
        #print(key)
        if typ == 'j':
            loc = mh2proxy.calcJointPos(obj, data)
            the.Locations[key] = loc
            the.Locations[data] = loc
        elif typ == 'v':
            v = int(data)
            the.Locations[key] = obj.verts[v].co
        elif typ == 'x':
            the.Locations[key] = [float(data[0]), float(data[2]), -float(data[1])]
        elif typ == 'vo':
            v = int(data[0])
            loc = obj.verts[v].co
            the.Locations[key] = [loc[0]+float(data[1]), loc[1]+float(data[3]), loc[2]-float(data[2])]
        elif typ == 'vl':
            ((k1, v1), (k2, v2)) = data
            loc1 = obj.verts[int(v1)].co
            loc2 = obj.verts[int(v2)].co
            the.Locations[key] = vadd(vmul(loc1, k1), vmul(loc2, k2))
        elif typ == 'f':
            (raw, head, tail, offs) = data
            rloc = the.Locations[raw]
            hloc = the.Locations[head]
            tloc = the.Locations[tail]
            #print(raw, rloc)
            vec = aljabr.vsub(tloc, hloc)
            vec2 = aljabr.vdot(vec, vec)
            vraw = aljabr.vsub(rloc, hloc)
            x = aljabr.vdot(vec, vraw) / vec2
            rvec = aljabr.vmul(vec, x)
            nloc = aljabr.vadd(hloc, rvec, offs)
            #print(key, nloc)
            the.Locations[key] = nloc
        elif typ == 'b':
            the.Locations[key] = the.Locations[data]
        elif typ == 'p':
            x = the.Locations[data[0]]
            y = the.Locations[data[1]]
            z = the.Locations[data[2]]
            the.Locations[key] = [x[0],y[1],z[2]]
        elif typ == 'vz':
            v = int(data[0])
            z = obj.verts[v].co[2]
            loc = the.Locations[data[1]]
            the.Locations[key] = [loc[0],loc[1],z]
        elif typ == 'X':
            r = the.Locations[data[0]]
            (x,y,z) = data[1]
            r1 = [float(x), float(y), float(z)]
            the.Locations[key] = aljabr.vcross(r, r1)
        elif typ == 'l':
            ((k1, joint1), (k2, joint2)) = data
            the.Locations[key] = vadd(vmul(the.Locations[joint1], k1), vmul(the.Locations[joint2], k2))
        elif typ == 'o':
            (joint, offsSym) = data
            if type(offsSym) == str:
                offs = the.Locations[offsSym]
            else:
                offs = offsSym
            the.Locations[key] = vadd(the.Locations[joint], offs)
        else:
            raise NameError("Unknown %s" % typ)
    return