← Back to branch summary

~siretart/ubuntu/utopic/blender/libav10

« back to all changes in this revision

Viewing changes to release/scripts/bpymodules/BPyObject.py

Tags: upstream-2.50~alpha~0~svn24834
Import upstream version 2.50~alpha~0~svn24834

Show diffs side-by-side

added added

removed removed

Lines of Context:
release/scripts/bpymodules/BPyObject.py
1
 
import Blender
2
 
 
3
 
def getObjectArmature(ob):
4
 
        '''
5
 
        This returns the first armature the mesh uses.
6
 
        remember there can be more then 1 armature but most people dont do that.
7
 
        '''
8
 
        if ob.type != 'Mesh':
9
 
                return None
10
 
        
11
 
        arm = ob.parent
12
 
        if arm and arm.type == 'Armature' and ob.parentType == Blender.Object.ParentTypes.ARMATURE:
13
 
                return arm
14
 
        
15
 
        for m in ob.modifiers:
16
 
                if m.type== Blender.Modifier.Types.ARMATURE:
17
 
                        arm = m[Blender.Modifier.Settings.OBJECT]
18
 
                        if arm:
19
 
                                return arm
20
 
        
21
 
        return None
22
 
 
23
 
 
24
 
def getDerivedObjects(ob, PARTICLES= True):
25
 
        '''
26
 
        Takes an objects and returnes a list of (ob, maxrix4x4) pairs
27
 
        that are derived from this object -
28
 
        This will include the object its self if it would be rendered.
29
 
        all dupli's for eg are not rendered themselves.
30
 
        
31
 
        currently supports
32
 
        * dupligroups
33
 
        * dupliverts
34
 
        * dupliframes
35
 
        * static particles as a mesh
36
 
        
37
 
        it is possible this function will return an empty list.
38
 
        '''
39
 
        
40
 
        ob_mtx_pairs = ob.DupObjects
41
 
        effects= ob.effects
42
 
        
43
 
        # Ignore self if were a dupli* or our parent is a duplivert.
44
 
        if ob.enableDupFrames or ob.enableDupGroup or ob.enableDupVerts:
45
 
                pass
46
 
        else:
47
 
                parent= ob.parent
48
 
                if parent and parent.enableDupVerts:
49
 
                        pass
50
 
                else:
51
 
                        if effects and (not effects[0].flag & Blender.Effect.Flags.EMESH):
52
 
                                # Particles mesh wont render
53
 
                                pass
54
 
                        else:
55
 
                                ob_mtx_pairs.append((ob, ob.matrixWorld))
56
 
        
57
 
        
58
 
        if PARTICLES:
59
 
                type_vec= type(Blender.Mathutils.Vector())
60
 
                type_tp= type((0,0))
61
 
                type_ls= type([])
62
 
                
63
 
                # TODO, particles per child object.
64
 
                # TODO Support materials
65
 
                me= Blender.Mesh.New()
66
 
                for eff in effects:
67
 
                        par= eff.getParticlesLoc()
68
 
                        
69
 
                        if par:
70
 
                                type_par= type(par[0])
71
 
                                
72
 
                                if type_par == type_vec:
73
 
                                        # point particles
74
 
                                        me.verts.extend(par)
75
 
                                        
76
 
                                elif type_par == type_tp:
77
 
                                        # edge pairs
78
 
                                        start_index= len(me.verts)
79
 
                                        me.verts.extend([v for p in par for v in p])
80
 
                                        me.edges.extend( [(i, i+1) for i in xrange(start_index, start_index + len(par) - 1 )] )
81
 
                                        
82
 
                                elif type_par == type_ls:
83
 
                                        # lines of edges
84
 
                                        start_index= len(me.verts)
85
 
                                        me.verts.extend([v for line in par for v in line])
86
 
                                        
87
 
                                        edges= []
88
 
                                        for line in par:
89
 
                                                edges.extend( [(i,i+1) for i in xrange(start_index, start_index+len(line)-1) ] )
90
 
                                                start_index+= len(line)
91
 
                                                
92
 
                                        me.edges.extend(edges)
93
 
                
94
 
                if me.verts:
95
 
                        # If we have verts, then add the mesh
96
 
                        ob_par = Blender.Object.New('Mesh')
97
 
                        ob_par.link( me ) 
98
 
                        
99
 
                        LOOSE= Blender.Mesh.EdgeFlags.LOOSE
100
 
                        for ed in me.edges:
101
 
                                ed.flag |= LOOSE
102
 
                        
103
 
                        # Particle's are in worldspace so an identity matrix is fine.
104
 
                        ob_mtx_pairs.append( (ob_par, Blender.Mathutils.Matrix()) )
105
 
        
106
 
        return ob_mtx_pairs
107
 
 
108