'); img.document.close(); pos++; } //-->  
 Blender
Python 
Fonctions non documentées 
de Blender 2.23 (1)
"New"
    Début   Index
précédentScript Python
python: GetRawFromObject Suivant
- Exemple: Créer une lampe
      Application
- Créer une rampe de spot à partir de n'importe quel mesh
      Le script
- Fonction documentée de B2.25,  importeur light_gen
- Hdrshop Lightgen  Importer (Blender 2.48)
- Mise à jour pour la fonction documentée de l'API 228/241
- Mise à jour pour blender 232
- Mise à jour non documentée pour  les modifications de l'API 2.32
- Script de duplicopie avec options variées
-Utiliser la fonction __copy__

Exemple: Créer une lampe.
 

import Blender

Blender.Object.New(Blender.Object.Types['LAMP'])
L=Blender.Object.GetSelected()[0]
lampe=Blender.Lamp.Get(L.data.name)

# test de validation de la création
print lampe.name

# Il ne reste plus qu''a modifier ce qui est modifiable
# avec le module Lamp...
#...
 

      Application:
 

import Blender

for X in range(10):
  for  Y in range(10):

   Blender.Object.New(Blender.Object.Types['LAMP'])
   L=Blender.Object.GetSelected()[0]
   lampe=Blender.Lamp.Get(L.data.name)

   L.LocX=X 
   L.LocY=Y

   print lampe.name
Blender.Redraw()

Créer une rampe de spot à partir de n'importe quel mesh:

Un peu plus compliqué: utiliser un maillage de face et orienter les lampes par rapport au vecteur normal moyen qui se trouve sur chaque sommet. Un grand merci à  Xavier Ligey  à qui l'on doit la procédure de calcul des angles de rotation (récuper le script pour b233)


# ----------------------------------------
# Jm Soler et Xavier Ligey
# ce script est proposé sous licence GPL.
# ----------------------------------------

import Blender
import math
from math import *
from Blender import Object,NMesh

def multmat(M,x,y,z):

    x1 = (x * M[0][0]) + (y * M[1][0]) + (z * M[2][0]) + M[3][0]
    y1 = (x * M[0][1]) + (y * M[1][1]) + (z * M[2][1]) + M[3][1]
    z1 = (x * M[0][2]) + (y * M[1][2]) + (z * M[2][2]) + M[3][2]
    return x1,y1,z1

Me=Object.GetSelected()
if len(Me)>=0:
       me=NMesh.GetRaw(Me[0].data.name)

       for s in me.verts:
         Blender.Object.New(Blender.Object.Types['LAMP'])

         L=Blender.Object.GetSelected()[0] 
         # ------------------------------
         #  le dernier objet 
         # crée est toujours selectionné,
         #  plus facile pour recuperer . Il est aussi 
         #  possible de lier l'objet à la scene . Cette
         # methose étant plus sure pour identifier 
         # l'objet dans la base de données de 
         # Blender .
         # ------------------------------
         lampe=Blender.Lamp.Get(L.data.name) 
         # ------------------------------
         #...nom, qui donnera 
         # acces a l'objet lui-même.
         # ------------------------------

         lampe.type=2           # type spot
         lampe.Dist=15.0       # distance sur  laquelle le spot projette sa lumière
         lampe.Energ=0.05    # énergie, plutôt basse pour ne pas saturer
         lampe.SpoSi=120.0  # angle d'ouverture du cone lumineux
         lampe.SpoBl=0.7      # largeur de la frange de pénombre

         # commencer à modifier l'emplacement de l'objet
         L=Blender.Object.Get(L.name)

         # replacer les coordonnées du sommet dans l'espace de la scène
         x,y,z=multmat(Me[0].mat,s.co[0],s.co[1],s.co[2]) # pour resituer la position
                                                                                     # réelle du point
         # positionner l'objet lampe sur le 
         L.LocX=x
         L.LocY=y
         L.LocZ=z

         # positionner la normale sur le sommet
         xa=s.no[0]+s.co[0]
         da=s.no[1]+s.co[1]
         wi=s.no[2]+s.co[2]

         # recalculer la position de la normale par rapport à l'espace de la scène
         al,be,ga=multmat(Me[0].mat,xa,da,wi)

         # renvoyer la normale vers l'origine
         s.no[0]=al-x
         s.no[1]=be-y
         s.no[2]=ga-z

         # calculer la longueur du vecteur 
         norm=sqrt(s.no[0]**2+s.no[1]**2+s.no[2]**2)

         # normaliser
         s.no[0]=s.no[0]/norm
         s.no[1]=s.no[1]/norm
         s.no[2]=s.no[2]/norm

         # print s.no[0], s.no[1], s.no[2]

         if abs(s.no[1])<0.0001:
          s.no[1]=0.0
         L.RotX=0
         teta=-acos(s.no[2])
         L.RotY=-pi+teta

         if s.no[1]!=0:
          L.RotZ=-acos(s.no[0]/sin(teta))*s.no[1]/abs(s.no[1])
         else:
          L.RotZ=0
          if s.no[0]>0:
           L.RotY=-L.RotY

Blender.Redraw()

"New"  fonction  documentée de B2.25

A partir de la version Publisher, l'API python n'utilise plus NEW de la même façon.

Les données sont crées dans un premier temps au niveau des modules spécialisés comme le Blender.Lamp.  Puis connectées à un Objet qui a lui même été créé au niveau du module  Blender.Object. Enfin l'objet est lui-même associé à la scène désirée en créant d'abord la scène (ou en récupérant la scène courante) avec le module Blender.Scene.
 

# ----------------------------------------
# Hdrshop Light Importer v0.1 
# Jm Soler 03/2003
#
# Ce script est proposé sous licence GPL.
# this script is under GPL licence.
#
# ----------------------------------------
#
#  pour fonctionner ce script doit pouvoir acceder
#  a un fichier texte contenant les informations
#  exportees par le LightGen_plugin de HdrShop
#
# ----------------------------------------

import Blender
from Blender import *

#--------------------------
#  distance a laquelle seront placees les lampes
#--------------------------
rayon=15.0

#--------------------------
# controle du numero de version
#--------------------------
version=Blender.Get('version')

#--------------------------
# adresse du fichier
#--------------------------
filename="G:/stock_logiciel_et_plugin/hdrshop/test.txt"

if version>=225: 
   #--------------------------
   #  recuperation de la scene
   #--------------------------
   scene=Scene.getCurrent()

f=open(filename,"r")
tableau=f.readlines()
f.close()

for n in range(len(tableau)):
    if tableau[n].find('Color:')!=-1:
       c=tableau[n].split(' ')
       print c
       if version>=225:
          #--------------------------
          # creation de l'objet
          #--------------------------
          objet=Object.New(Object.Types['LAMP'])
          # -->  utilisation des champs de couleurs RVB
          if tableau[n+1].find('Direction:')!=-1:
             d=tableau[n+1].split(' ')
             objet.loc=(float(d[1])*rayon,float(d[2])*rayon,float(d[3])*rayon)

          #--------------------------
          # creation des donnes
          #--------------------------
          lampe=Lamp.New('Lamp')
          # -->  utilisation des champs de couleurs RVB
          lampe.R=float(c[2])/256.0
          lampe.G=float(c[3])/256.0
          lampe.B=float(c[4])/256.0

          #--------------------------
          # connexion des donnes a l'objet
          #-------------------------- 
          objet.link(lampe)
          #
          #--------------------------
          # connexion de l'objet a la scene
          #-------------------------- 
          scene.link(objet) 


 

Hdrshop Lightgen  Importer, 
Adaptation pour Blender 2.48a : le script
 

# ----------------------------------------
# Hdrshop Light Importer v0.3
# Jm Soler 04/2004 update 10/01/2009
#
# Ce script est proposé sous licence GPL.
# this script is under GPL licence.
#
# ----------------------------------------
#
#  pour fonctionner ce script doit pouvoir acceder
#  a un fichier texte contenant les informations
#  exportees par le LightGen_plugin de HdrShop
#
# ----------------------------------------

import Blender
from math import *

def oriente(s,ori):
                  xyz=Blender.Mathutils.Vector(ori.mat*s)
                  xadawi=Blender.Mathutils.Vector(s+s) 
                  albega=Blender.Mathutils.Vector(ori.mat*xadawi)
                  s= albega-xyz
                  s.normalize()
                  if abs(s[1])<0.0001:
                   s[1]=0.0
                  RotX=0
                  teta=-acos(s[2])
                  RotY=-pi+teta
                  if s[1]!=0:
                   RotZ=-acos(s[0]/sin(teta))*s[1]/abs(s[1])
                  else:
                   RotZ=0
                   if s[0]>0:
                    RotY=-RotY
                  return [RotX, RotY, RotZ] 

def cree_objet(ob,col,pos, rad, ori , energy, cmax):
     O = Blender.Object.New (ob)
     obj= O.getData()
     O.link (obj)
     if ob=='Lamp':
                  obj.setType('Spot') 
                  obj.type=2 
                  # type spot
                  obj.dist=rad*2.5
                  # ------------------------------
                  # distance sur  laquelle le spot projette sa lumière
                  # ------------------------------
                  obj.energy=energy 
                  # ------------------------------
                  # energie, plutôt basse pour ne pas saturer
                  # ------------------------------
                  obj.spotSize=120.0 
                  # ------------------------------
                  # angle d'ouverture du cone lumineux
                  # ------------------------------
                  obj.spotBlend=0.7 
                  # ------------------------------
                  # largeur de la frange de penombre
                  # ------------------------------
                  obj.setMode('Shadows') 
                  # ------------------------------
                  # utilisation des ombres 
                  # ------------------------------
                  for m in [0,1,2]:
                      col[m]/=cmax
                  # ------------
                  #  Champs de reglage des couleurs
                  # -------------
                  obj.col=col[:]

                  print col[0], obj.col[0] 

     O.setEuler(oriente(Blender.Mathutils.Vector([-pos[0],-pos[1],-pos[2]]),ori))
     for m in [0,1,2]:
        pos[m]*=rad
     O.setLocation(pos)

     return O

#--------------------------
#  distance a laquelle seront placees les lampes
#--------------------------
rayon=30.0

#--------------------------
# controle du numero de version
#--------------------------
version=Blender.Get('version')
 

def cree_leslampes(filename):

    f=open(filename,"r")
    tableau=f.readlines()
    f.close()

    c=[[],[]]
    cmax=[0.0,0.0,0.0]

    for n in range(len(tableau)):

        if tableau[n].find('Color:')!=-1:
           c[0].append(tableau[n].split(' '))
           C=c[0][-1]
           print 'C   :  ', C 
           C[-1]=C[-1][:-1] 
           del C[0:2]
           print 'C   :  ', C 
           for m in [0,1,2]:
              C[m]=round(float(C[m]),8)
              print 'm :',m,' , ',C[m] 
              if C[m]>cmax[m]:
                 cmax[m]=C[m]

           if tableau[n+1].find('Direction:')!=-1:
               c[1].append(tableau[n+1].split(' '))
               D=c[1][-1]
               D[-1]=D[-1][:-1] 
               del D[0:1]
               D[-1]=D[-1][:-1]
               for m in [0,1,2]:
                   D[m]=round(float(D[m]),5)

           print c[0][-1],c[1][-1]

    cmax.sort()
    print cmax
    energy=1.0
    intensite=1.0

    energy=1000.0/cmax[2]*intensite

    n=0
    scene = Blender.Scene.getCurrent ()

    try:
      ori=Blender.Object.Get('origine')
    except:
      object=Blender.Object.New('Empty','origine')
      object.LocX=0.0
      object.LocZ=0.0
      object.LocY=0.0
      object.RotX=0.0
      object.RotZ=0.0
      object.RotY=0.0
      scene.link (object)
      ori=Blender.Object.Get('origine')

    for L in c[0]:
        scene.link (cree_objet('Lamp',
                   L,
                   c[1][n],
                   rayon, 
                   ori, 
                   energy, cmax[2]) )
        n+=1 
    Blender.Redraw()

Blender.Window.FileSelector(cree_leslampes,'SELECT LIGHTS FILE')

Créer une rampe de spot à partir de n'importe quel mesh,
mise à jour pour la nouvelle API Python 2.28 et corrigée pour blender 2.41 :
 

# ----------------------------------------
# Jm Soler et Xavier Ligey
# ce script est proposé sous licence GPL.
# (correction pour l'API 2.28-2.41 ) 
# ----------------------------------------

import Blender
import math
from math import *
from Blender import Object,NMesh

def multmat(M,x,y,z):

    x1 = (x * M[0][0]) + (y * M[1][0]) + (z * M[2][0]) + M[3][0]
    y1 = (x * M[0][1]) + (y * M[1][1]) + (z * M[2][1]) + M[3][1]
    z1 = (x * M[0][2]) + (y * M[1][2]) + (z * M[2][2]) + M[3][2]
    return x1,y1,z1

Me=Object.GetSelected()
 

scene = Blender.Scene.getCurrent ()

if len(Me)>0:
       me=NMesh.GetRawFromObject(Me[0].name)

       for s in me.verts:
         L=Blender.Object.New('Lamp')
         scene.link (L)

         lampe = Blender.Lamp.New ('Spot')
         L.link (lampe) 

         # ------------
         # type spot
         # ------------
         lampe.type=2 
         # ------------
         #distance sur  laquelle le spot projette sa lumière
         # ------------
         lampe.dist=15.0
         # ------------ 
         # energie, plutôt basse pour ne pas saturer 
         # ------------
         lampe.energy=0.05 
         # ------------
         # angle d'ouverture du cone lumineux 
         # ------------
         lampe.spotSize=120.0 
         # ------------
         # largeur de la frange de penombre
         # ------------
         lampe.spotBlend=0.7
         # ------------
         # pour resituer la position reelle du point
         # il est aussi possible d'utiliser la fonction transform
         # ------------
         x,y,z=multmat(Me[0].mat,s.co[0],s.co[1],s.co[2])
 

         L.LocX=x
         L.LocY=y
         L.LocZ=z

         xa=s.no[0]+s.co[0]
         da=s.no[1]+s.co[1]
         wi=s.no[2]+s.co[2]

         al,be,ga=multmat(Me[0].mat,xa,da,wi)

         s.no[0]=al-x
         s.no[1]=be-y
         s.no[2]=ga-z

         norm=sqrt(s.no[0]**2+s.no[1]**2+s.no[2]**2)

         s.no[0]=s.no[0]/norm
         s.no[1]=s.no[1]/norm
         s.no[2]=s.no[2]/norm

         #print s.no[0], s.no[1], s.no[2]

         if abs(s.no[1])<0.0001:
          s.no[1]=0.0
         L.RotX=0
         teta=-acos(s.no[2])
         L.RotY=-pi+teta

         if s.no[1]!=0:
           if s.no[0]/sin(teta)>1.0 :
             AC= acos(1.0)
           elif s.no[0]/sin(teta)<1.0 :
             AC= acos(-1.0)
           else :
             AC= acos(s.no[0]/sin(teta)) 
           L.RotZ=-AC*s.no[1]/abs(s.no[1])
         else:
          L.RotZ=0
          if s.no[0]>0:
           L.RotY=-L.RotY
 
 

Blender.Redraw()

Créer et Dupliquer des objets (lamp, mesh, courbes...) sur n'importe quel mesh  en utilisant les sommets pour localiser les copies . Acceptes des listes d'objet variés . Le mesh de base est l'objet actif .

plus mise à jour du script de création de rampe pour la nouvelle API Python 2.32:
Télécharger le script
 

#!BPY

""" Registration info for Blender menus: <- these words are ignored
Name: 'Dupli Object'
Blender: 242
Group: 'Object'
Tip: 'Duplicate Object on mesh vertices with various options'
"""
#----------------------------------------------
# jm soler  05/2004 :   'Dupli Object' v0.8
# last update 09/04/2007
#----------------------------------------------
# Page officielle :
#   http://jmsoler.free.fr/didacticiel/blender/tutor/cpl_b223new.htm#duplicopy232
# Communiquer les problemes et erreurs sur:
#   http://www.zoo-logique.org/3D.Blender/newsportal/thread.php?group=3D.Blender
#--------------------------------------------- 
import Blender
import math
from math import *
from Blender import Object, NMesh, Noise
from Blender.Draw import *
from Blender.BGL import *

#  -------------------
#   Definitions par defaut 
#  -------------------
# default definitions
#  -------------------

#  -------------------
#  duplique les donnees du second objet selectionne 
#  sur la position de chaque sommet du premier
#  si c'est un mesh . Ne fait rien si c'est un 
#  autre type d'objet. 
#  -------------------
#  dupli data of the second selected object
#  on vert pos of the first one if it is
#  a real mesh, otherwize nothing
#  -------------------
DUPLI=1

#  -------------------
#  Cree completement l'objet et les donnees
#  -------------------
#   create complete object with data 
#  -------------------
NEW=0
NONE=-1
#  -------------------
#  gere la valeur de NEW et DUPLI
#  -------------------
#  NEW et DUPLI value
#  -------------------
Type=[DUPLI,NEW,NONE]
TYPE=Type[0]

#  -------------------
#  modifier aussi les valeurs de taillle
#  -------------------
#  change size too
#  -------------------
SIZE=0

# Choisir MODE in ['random','normal','none', 'color']
mode=['normal','random', 'color','none']
MODE=mode[0]

objettype=['Armature', 'Camera', 'Curve', 'Lamp', 'Mesh','Empty']
OBJET=objettype[3]

Ob=None
 

def multmat(M,x,y,z):
 x1 = (x * M[0][0]) + (y * M[1][0]) + (z * M[2][0]) + M[3][0]
 y1 = (x * M[0][1]) + (y * M[1][1]) + (z * M[2][1]) + M[3][1]
 z1 = (x * M[0][2]) + (y * M[1][2]) + (z * M[2][2]) + M[3][2]
 return x1,y1,z1

def dupli_objet(TYPE,obj,Ob):
      global SELMenu
      scene = Blender.Scene.getCurrent() 

      if TYPE==DUPLI and Ob!=None:
         O = Blender.Object.New (obj)
         scene = Blender.Scene.getCurrent() 
         scene.link (O)
         O.shareFrom(Ob)
         objet=Ob.getData()

      elif TYPE==NEW and Ob!=None: 
         if obj in objettype and obj!='Empty' and obj!='Mesh':
            O = Blender.Object.New (obj)
            scene.link (O)
            objet=Ob.getData()
            O.link (objet)
            if SELMenu.val==2 and obj=='Lamp': 
               O.getData().setType('Spot') 
            #exec "objet = Blender.%s.New ('%s')"%(obj,obj)
         elif  obj!='Mesh' :
               O = Blender.Object.New (obj)
               scene.link (O)
               O.link (objet)
         elif  obj=='Mesh':
               O = Blender.Object.New (obj)
               scene.link (O)
               objet=Blender.NMesh.GetRaw(Ob.data.name)
               O.link (objet)
         else:
            objet=None

      elif TYPE==NEW:
         O = Blender.Object.New ('Lamp')
         objet = Blender.Lamp.New ('Spot')
         O.link (objet)
      else:
          O=None
          objet=None

      if O!=None:
         O.Layer = 2**(CAMenu.val-1) 
         #scene.link (O)

      return O,objet
 
 

def obj2mesh():
    global MODE,ob,Ob,TYPE, SELvert,SELMenu 
 

    Me=Object.GetSelected()

    if len(Me)>=0:
      if Me[0].getType()=='Mesh':
        me=NMesh.GetRaw(Me[0].getData().name)

        if TYPE==DUPLI and len(Me)>1:
            Ob=Me[1]
            ob=Ob.getType()

        elif TYPE==NEW and len(Me)>1:
            Ob=Me[1]
            ob=Ob.getType()
        else:
            Ob=None
            ob=None

        if Ob!=None and ob!=None:
          for s in me.verts:
            numb=-1 
            while numb==-1 or numb==0 or numb==len(Me):
                 numb=int( round(Noise.random()*len(Me)))
            print numb 

            Ob=Me[numb]
            ob=Ob.getType()

            ok=1

            if SELvert.val :
              if s.sel==1:
                 ok=1
              else:
                 ok=0

            if ok==1: 
              O,obj=dupli_objet(TYPE,ob,Ob) 
              if ob=='Lamp':
                  obj.type=2       # type spot
                  obj.dist=15.0    # distance sur  laquelle le spot projette sa lumière
                  obj.energy=0.5   # energie, plutôt basse pour ne pas saturer
                  obj.spotSize=120.0  # angle d'ouverture du cone lumineux
                  obj.spotBlend=0.7    # largeur de la frange de penombre
                  obj.mode=9
                  #try:
                  if me.hasVertexColours()==1:
                     for d in me.faces:
                       if s in d.v:
                          print d.col[d.v.index(s)].r/255.0
                          obj.R=d.col[d.v.index(s)].r/255.0 
                          obj.G=d.col[d.v.index(s)].g/255.0
                          obj.B=d.col[d.v.index(s)].b/255.0
                          break

              #except:
              #     pass 

              if MODE!='none': 
                  x,y,z=multmat(Me[0].mat,s.co[0],s.co[1],s.co[2])
                  # pour resituer la position
                  # reelle du point

                  O.LocX=x
                  O.LocY=y
                  O.LocZ=z

                  xa=s.no[0]+s.co[0]
                  da=s.no[1]+s.co[1]
                  wi=s.no[2]+s.co[2]

                  al,be,ga=multmat(Me[0].mat,xa,da,wi)

                  s.no[0]=al-x
                  s.no[1]=be-y
                  s.no[2]=ga-z

                  norm=sqrt(s.no[0]**2+s.no[1]**2+s.no[2]**2)

                  s.no[0]=s.no[0]/norm
                  s.no[1]=s.no[1]/norm
                  s.no[2]=s.no[2]/norm

                  #print s.no[0], s.no[1], s.no[2]

                  if abs(s.no[1])<0.0001:
                   s.no[1]=0.0
                  O.RotX=0
                  teta=-acos(s.no[2])
                  O.RotY=-pi+teta

                  if s.no[1]!=0:
                     if s.no[0]/sin(teta)>1.0 :
                       AC=acos(1.0)
                     elif s.no[0]/sin(teta)<1.0 :
                       AC=acos(-1.0)
                     else :
                       AC=acos(s.no[0]/sin(teta))

                     O.RotZ=-acos(s.no[0]/sin(teta))*s.no[1]/abs(s.no[1])
                  else:
                   O.RotZ=0
                   if s.no[0]>0:
                    O.RotY=-O.RotY

                  if MODE=='random':
                     #print O.RotY 
                     O.RotX=Noise.random()*2*math.pi
                     O.RotY=Noise.random()*2*math.pi
                     O.RotZ=Noise.random()*2*math.pi

                  if MODE=='color':
                     if me.hasVertexColours()==1:
                        for d in me.faces:
                          if s in d.v:
                            #print d.col[d.v.index(s)].r/255.0*2*math.pi
                            O.RotX=d.col[d.v.index(s)].r/255.0*2*math.pi
                            O.RotY=d.col[d.v.index(s)].g/255.0*2*math.pi
                            O.RotZ=d.col[d.v.index(s)].b/255.0*2*math.pi
                            break
MOname = "MODE MENU %t|Normal %x1|Random %x2|color %x3|None %x4"

CAname="LAYER %t"
for n in range(20):
    CAname=CAname+"|%s %%x%s"%(n,n+1)

SELname="OBJET %t|Selected %x1|STND LAMP %x2|NOTHING %x3"

MODEMenu = Create(1)
CAMenu = Create(1)
SELMenu = Create(1)

SELvert = Create(0)
TTYPE  =  Create(1)
TSIZE  =  Create(0)

def draw():
    global MODEMenu, TSIZE, TTYPE,CAMenu ,MOMenu ,SELMenu, SELvert

    size=Buffer(GL_FLOAT, 4)
    glGetFloatv(GL_SCISSOR_BOX, size)
    size= size.list
    for s in [0,1,2,3]: size[s]=int(size[s])

    glClear(GL_COLOR_BUFFER_BIT)

    glColor3f(0.0,0.0,0.0)
    glRectf(4,size[3],534,size[3]-32 )
    glColor3f(1.0,1.0,1.0)

    glRasterPos2f(20, size[3]-15)
    Text("Script Python de duplication d'objet")
    glRasterPos2f(20, size[3]-28)
    Text("Jean-michel Soler, avril 2004")
 

    n0=78
    n1=55

    Button("Exit"                  ,1  ,140  ,size[3]-n0 ,60 ,20) 
    Button("Action"                ,16  ,200  ,size[3]-n0 ,60 ,20) 

    MODEMenu= Menu(MOname,            2  ,20  ,size[3]-n0-20 ,100,20, MODEMenu.val, "MODE menu.")
    CAMenu= Menu(CAname,              2  ,150  ,size[3]-n0-20 ,40,20, CAMenu.val, "LAYER menu.")
    SELMenu= Menu(SELname,            2  ,220  ,size[3]-n0-20 ,100,20, SELMenu.val, "SELECTED OBJECT menu.")

    if TTYPE.val==1:
        ttname='Dupli'
    else:
        ttname='New'

    TTYPE= Toggle(ttname,           3, 20, size[3]-n0+20 ,120  ,20, TTYPE.val, "Type de Copie")

    if SELvert.val==1:
        tvname='Sel Verts'
    else:
        tvname='All Verts'

    SELvert= Toggle(tvname,           4, 200, size[3]-n0+20 ,120  ,20, SELvert.val, "Type de Copie")
 

def event(evt, val): 
    if (evt== QKEY and not val): Exit()

def bevent(evt):
    global MODEMenu, TSIZE, TTYPE, MODE, TYPE

    if   (evt== 1):
        Exit()

    elif (evt== 2):
        MODE=mode[MODEMenu.val-1]
        #print MODE

    elif (evt== 3):
       if TTYPE.val==1:
            TYPE=DUPLI
       else:
            TYPE=NEW

    elif   (evt== 16):
       MODE=mode[MODEMenu.val-1]
       if TTYPE.val==1:
            TYPE=DUPLI
       else:
            TYPE=NEW
       obj2mesh()

    Blender.Redraw()

Register(draw, event, bevent)


 

Créer et Dupliquer avec __copy__ , qui est reservé aux maillages
 

# -------------------------
# Projet : 
# dupliquer un objet  mesh selectionne sur l'objet mesh actif
# -------------------------
import Blender
from Blender import *

# -------------------------
# on doit avoir acces a la scene courante 
# -------------------------
scn=Scene.GetCurrent()

# -------------------------
# On se branche sur la liste des objets selectionnes
# -------------------------
ob = Object.GetSelected()[0]

# -------------------------
# On doit recupérer la forme du mesh après modifications et
# animations diverses et pour cela on doit effectuer les operations 
# suivantes :
# 1/ creation d'un nouveau mesh
# -------------------------
me0 = Mesh.New() 

# -------------------------
# 2/ copie sur ce mesh de l'etat de l'objet mesh a cet instant
# -------------------------
me0.getFromObject(ob.name)

# -------------------------
# 3/ les sommets étants situes dans l'espace local 
#   il faut les transfere dans lespace global de la scene
# ------------------------- 
me0.transform(ob.matrix)

ob2 = Object.GetSelected()[1]
me2 = ob2.getData(name_only=False, mesh=True)

objects=[]
for v in me0.verts :
    ob3 = Object.New('Mesh', "result")
    me3 = me2.__copy__() 
    ob3.link(me3)
    ob3.setLocation (v.co[0],v.co[1],v.co[2])
    scn.objects.link(ob3)
    objects.append(ob3)

ob3.join(objects) 
for o in objects[:-1]:
    scn.objects.unlink(o)

Redraw()


 
précédentScript Python
 python: GetRawFromObject Suivant
Vers le  Haut de page

Les questions concernant cette page  peuvent être posées sur  :
 news://news.zoo-logique.org/3D.Blender


 

 

Livre en français
Blender : apprenez, pratiquez, Créez, livre, Ed. Campus Press, coll. Starter Kit
Blender Starter Kit

Forum
FAQ
Lexique
Didacticiels
Compilations
Blender2KT
Débuter
Modelage
Blender python
Materiaux
Lumière
Animation
API python (eng)
Archives nzn
Statistiques
Doc flash Sculptris
Galerie Sculptris

Les Fralibos sur youtube, soutien au personnel de Fralib de Gémenos