C4D逆向细分插件：Python : Subdivision inverse（原版+汉化版） 

2014-11-21 22:42 发布 | 作品版权归原作者所有，仅供参考学习，禁止商业使用！

插件脚本 /[系统辅助]
797 0 0
C4D逆向细分插件：Python : Subdivision inverse（原版+汉化版）
C4D逆向细分插件：Python : Subdivision inverse（原版+汉化版） - C4D之家 - image_01.png

Calcule une approximation de l'objet original subdivisé selon la méthode Catmull-Clark.
经测试，支持WIN/MAC r13-r16
v 1.1 :
- Correction d'un problème de rafraîchissement.

Copier le dossier « vonc_subdinv » dans le dossier « plugins » du répertoire de Cinéma 4D.
Le module utilise un point de départ pour traiter l'objet. Ce point doit être commun entre le modèle original et subdivisé. Par défaut, ce point est celui d'indice 0, mais il est possible de le changer manuellement, ou de sélectionner le ou les points de départ puis de cocher la case « Sélection » dans les paramètres du module. Cliquez sur le bouton « Act. » pour actualiser la sélection. à utiliser si vous obtenez des résultats bizarres.
Fichier vonc_subdinv.PYP :
  1. # Subdivision inverse - César Vonc - code.vonc.fr
  2. # v 1.1

  4. import os
  5. import c4d
  6. import webbrowser
  7. from c4d import plugins, utils, bitmaps, Vector
  8. from c4d.utils import Neighbor, VectorAngle

  10. MODULE_ID = 1029594
  11. VONC_SUBDINV_NOM = 1000
  12. VONC_SUBDINV_TYPE = 1000
  13. VONC_SUBDINV_TYPE_CC1 = 0
  14. VONC_SUBDINV_TYPE_CC2 = 1
  15. VONC_SUBDINV_TYPE_CC3 = 3
  16. VONC_SUBDINV_TYPE_CCA = 2
  17. VONC_SUBDINV_SUBD = 1002
  18. VONC_SUBDINV_DEPA = 1003
  19. VONC_SUBDINV_INFO = 1004
  20. VONC_SUBDINV_SELP = 1005
  21. VONC_SUBDINV_INVN = 1006
  22. VONC_SUBDINV_DON = 1007
  23. VONC_SUBDINV_ACTU = 1008

  25. class SubdivisionInverse() :
  26.         obj = None
  27.         doc = None
  28.         obj_nbpts = 0
  29.         obj_nbpol = 0
  30.         obj_n = None
  31.         pts_traites = []
  32.         pol_traites = []
  33.         nouv_polys = []
  34.         pts_orig = []
  35.         nouv_pts = []
  36.         nouv_pts_inv = []
  37.         nouv_coor = []
  38.         pts_corres = []
  39.         pol_corres = []
  40.         cor_poly_polynet = [] # Correspondance [id nouv_polys] = id nouv_polys nettoyé
  41.         cor_polynet_poly = [] # Correspondance [id nouv_polys nettoyé] = id nouv_polys
  42.         _GetAllPolygons = []
  43.         _GetPointPolys = []
  44.         
  45.         def _NettoieTab(self, tab) :
  46.                 tab_net = []
  47.                 j = 0
  48.                 i = 0
  49.                 for val in tab :
  50.                         if val and len(val) > 2 :
  51.                                 tab_net.append(val)
  52.                                 self.cor_poly_polynet.append(j)
  53.                                 self.cor_polynet_poly.append(i)
  54.                                 j += 1
  55.                         else : self.cor_poly_polynet.append(-1)
  56.                         i += 1
  57.                 return tab_net
  58.         
  59.         def _SommeVecteur(self, obj, vecs) :
  60.                 if not vecs : return Vector()
  61.                 s = Vector()
  62.                 for v in vecs :
  63.                         s += obj.GetPoint(v)
  64.                 return s
  65.         
  66.         def _MoyenneVecteur(self, obj, vecs) :
  67.                 q = len(vecs)
  68.                 if not q : return Vector()
  69.                 m = Vector()
  70.                 for v in vecs :
  71.                         m += obj.GetPoint(v)
  72.                 m /= float(q)
  73.                 return m
  74.         
  75.         def _RempliCoorArete(self, i, pa, ps, nb) :
  76.                 obj = self.obj
  77.                 n = self.obj_n
  78.                
  79.                 for arete in pa :
  80.                         pass
  81.         
  82.         def _RempliCoor(self, i, pa, ps, nb, mode) :
  83.                 obj = self.obj
  84.                 Po = obj.GetPoint(i)
  85.                
  86.                 if mode == 2 :
  87.                         self.nouv_coor[i] = Po
  88.                         return
  89.                
  90.                 if nb < len(pa) : # Bordure
  91.                         n = self.obj_n
  92.                         pa_bor = []
  93.                         pa_nb = 0
  94.                         for arete in pa :
  95.                                 if pa_nb == 2 : break
  96.                                 a, b = n.GetEdgePolys(i, arete)
  97.                                 if a == -1 or b == -1 :
  98.                                         pa_bor.append(arete)
  99.                                         pa_nb += 1
  100.                         
  101.                         Mpa = self._MoyenneVecteur(obj, pa_bor)
  102.                         pos = 2.0 * Po - Mpa
  103.                
  104.                 elif nb == 3 :
  105.                         if mode == 0 :
  106.                                 Mps = self._MoyenneVecteur(obj, ps)
  107.                                 pos = Po + (Po - Mps) * 2.0
  108.                         
  109.                         elif mode == 1 or mode == 3 :
  110.                                 # Calcul des coordonnées PA fictives
  111.                                 Mpa = Vector()
  112.                                 Mps = self._MoyenneVecteur(obj, ps)
  113.                                 for arete in pa :
  114.                                         if not self.nouv_coor[arete] :
  115.                                                 paA, psA, nbA = self._RecupPaPs(arete, False)
  116.                                                 if nbA == 3 : continue
  117.                                                 self._RempliCoor(arete, paA, psA, nbA, mode)
  118.                                         Mpa += self.nouv_coor[arete]
  119.                                 Mpa /= float(len(pa))
  120.                                 
  121.                                 pos = (Mpa-Po) * 2.0 + Po - (Po-Mps) * 0.75 #0.58335
  122.                                 
  123.                                 if mode == 3 :
  124.                                         pos = (pos + Po + (Po - Mps) * 2.0) * 0.5
  125.                                 #return (i, pa, ps, nb)
  126.                
  127.                 else :
  128.                         Spa = self._SommeVecteur(obj, pa)
  129.                         Sps = self._SommeVecteur(obj, ps)
  130.                         pos = (Po*nb)/(nb-3.0) + (-4.0*Spa)/(nb*(nb-3.0)) + Sps/(nb*(nb-3.0))
  131.                
  132.                 self.nouv_coor[i] = pos
  133.                
  134.         
  135.         def _RempliPolys(self, i, pts_surf) :
  136.                 for p in pts_surf :
  137.                         poly = self.nouv_polys[p]
  138.                         if not poly : self.nouv_polys[p] = [i]
  139.                         else : self.nouv_polys[p].append(i)
  140.                         
  141.                         # Correspondance polys subdivisés > nouv polys
  142.                         pointpolys = self._GetPointPolys[p] #self.obj_n.GetPointPolys(p)
  143.                         for pointpoly in pointpolys :
  144.                                 self.pol_corres[pointpoly] = p
  145.                         
  146.         def _RecupPo(self, po, pa) :
  147.                 obj = self.obj
  148.                 n = self.obj_n
  149.                 pts_traites = self.pts_traites
  150.                 pol_traites = self.pol_traites
  151.                 pos = []
  152.                
  153.                 for a in pa :
  154.                         polys = self._GetPointPolys[a] #n.GetPointPolys(a)
  155.                         points = []
  156.                         
  157.                         for pol in polys :
  158.                                 if pol_traites[pol] : continue
  159.                                 p = self._GetAllPolygons[pol] #obj.GetPolygon(pol)
  160.                                 points.extend([p.a, p.b, p.c, p.d])
  161.                                 pol_traites[pol] = True
  162.                         points = list(set(points))
  163.                         
  164.                         for pt in points :
  165.                                 if pts_traites[pt] : continue
  166.                                 arete = n.GetEdgePolys(a, pt)
  167.                                 if arete != (-1, -1) :
  168.                                         pos.append(pt)
  169.                                         break
  170.                
  171.                 return pos
  172.         
  173.         def _RecupPaPs(self, po, traiteur=True) :
  174.                 obj = self.obj
  175.                 n = self.obj_n
  176.                 pts_traites = self.pts_traites
  177.                 pol_traites = self.pol_traites
  178.                
  179.                 polys = self._GetPointPolys[po] #n.GetPointPolys(po)
  180.                 nb = len(polys)
  181.                 points = []
  182.                 ps = []
  183.                 pa = []
  184.                
  185.                 for p in polys :
  186.                         if traiteur : pol_traites[p] = True
  187.                         p = self._GetAllPolygons[p] #obj.GetPolygon(p)
  188.                         points.extend([p.a, p.b, p.c, p.d])
  189.                 points = list(set(points))
  190.                
  191.                 for pt in points :
  192.                         if traiteur :
  193.                                 self.pts_corres[pt].append(po)
  194.                                 pts_traites[pt] = True
  195.                         if pt == po : continue
  196.                         arete = n.GetEdgePolys(po, pt)
  197.                         if arete == (-1, -1) :
  198.                                 ps.append(pt)
  199.                         else :
  200.                                 pa.append(pt)
  201.                
  202.                 return pa, ps, nb
  203.         
  204.         def Execute(self, mode, depart, selp, invn) :
  205.                 if not self.Initialise(depart) : return
  206.                 obj = self.obj
  207.                 doc = self.doc
  208.                 n = self.obj_n
  209.                 pts_traites = self.pts_traites
  210.                 pts_orig = self.pts_orig
  211.                 nouv_pts = self.nouv_pts
  212.                 nouv_pts_inv = self.nouv_pts_inv
  213.                 nouv_polys = self.nouv_polys
  214.                 nouv_coor = self.nouv_coor
  215.                 _RecupPaPs = self._RecupPaPs
  216.                 _RecupPo = self._RecupPo
  217.                 _RempliPolys = self._RempliPolys
  218.                 _RempliCoor = self._RempliCoor
  219.                
  220.                 bs = obj.GetPointS()
  221.                 pts_a_calc = []
  222.                
  223.                 j = 0
  224.                 i_n = 0
  225.                 i_tot = 1
  226.                 for i in pts_orig : # Points de départ pour la recherche des Points Originaux
  227.                         i_n += 1
  228.                         i_p = 0
  229.                         if not pts_traites[i] : # Si le point n'a pas été traité
  230.                                 pts_traites[i] = True
  231.                                 # Récupère les points d'arête, de surface et le nombre de polys autour du point original
  232.                                 pts_arete, pts_surf, nb_poly_cote = _RecupPaPs(i)
  233.                                 
  234.                                 # Calcule les nouvelles coordonnées du PO  # ou renvoie a_calc pour les calculer plus tard
  235.                                 _RempliCoor(i, pts_arete, pts_surf, nb_poly_cote, mode)
  236.                                 # a_calc = _RempliCoor(i, pts_arete, pts_surf, nb_poly_cote, mode)
  237.                                 # if a_calc : pts_a_calc.append(a_calc)
  238.                                 
  239.                                 # Ajoute PO aux futurs nouveaux polys
  240.                                 _RempliPolys(i, pts_surf)
  241.                                 
  242.                                 # Récupère les points originaux aux alentours des points d'arête
  243.                                 pts_orig_tour = _RecupPo(i, pts_arete)
  244.                                 pts_orig.extend(pts_orig_tour)
  245.                                 
  246.                                 nouv_pts_inv[i] = j # Tableau [PO sur l'obj. subdivisé] = PO de l'obj. non subd.
  247.                                 nouv_pts.append(i) # Liste des PO sur l'obj. subdivisé
  248.                                 
  249.                                 i_tot += len(pts_orig_tour)
  250.                                 i_p = 1
  251.                                 j += 1
  252.                         
  253.                         if i_n+i_p >= i_tot : # Si on atteint le bout de pts_orig
  254.                                 if 0 in pts_traites : # S'il reste des points à traiter
  255.                                         nouv_depart = pts_traites.index(0)
  256.                                         pts_orig.append(nouv_depart) # Ajouter le non traité à traiter
  257.                                         i_tot += 1
  258.                
  259.                
  260.                 ### -- Création de l'objet -- ###
  261.                
  262.                 ### -- Récupération des propriétés et sélections -- ###
  263.                 proprietes = obj.GetTags()
  264.                 _Spolsels = []
  265.                 _Npolsels = []
  266.                 _Sptnsels = []
  267.                 _Nptnsels = []
  268.                 _Suvws = []
  269.                 _Nuvws = []
  270.                 for prop in proprietes :
  271.                         if prop.CheckType(c4d.Tpolygonselection) :
  272.                                 _Npolsels.append(prop)
  273.                                 _Spolsels.append(prop.GetClone())
  274.                         elif prop.CheckType(c4d.Tpointselection) :
  275.                                 _Nptnsels.append(prop)
  276.                                 _Sptnsels.append(prop.GetClone())
  277.                         elif prop.CheckType(c4d.Tuvw) :
  278.                                 _Nuvws.append(prop)
  279.                                 _Suvws.append(prop.GetClone())
  280.                 _ASptnsel = obj.GetPointS().GetClone()
  281.                 _ANptnsel = obj.GetPointS()
  282.                 _ASpolsel = obj.GetPolygonS().GetClone()
  283.                 _ANpolsel = obj.GetPolygonS()
  284.                
  285.                 ### -- Création de l'objet -- ###
  286.                
  287.                 nouv_polys_sale = nouv_polys[:]
  288.                 nouv_polys = self._NettoieTab(nouv_polys)
  289.                 nouv_nbpts = len(nouv_pts)
  290.                 nouv_nbpolys = len(nouv_polys)
  291.                
  292.                 # objet  = c4d.BaseObject(c4d.Opolygon)
  293.                 obj.ResizeObject(nouv_nbpts, nouv_nbpolys)
  294.                
  295.                 for pti in xrange(nouv_nbpts) :
  296.                         ans_id = nouv_pts[pti]
  297.                         nouv_id = nouv_pts_inv[ans_id]
  298.                         position = nouv_coor[ans_id]
  299.                         obj.SetPoint(pti, position)
  300.                
  301.                 posi = obj.GetPoint
  302.                 for poli in xrange(nouv_nbpolys) :
  303.                         poly = nouv_polys[poli]
  304.                         pa = nouv_pts_inv[poly[0]]
  305.                         pb = nouv_pts_inv[poly[1]]
  306.                         pd = nouv_pts_inv[poly[2]]
  307.                         if len(poly) != 3 :
  308.                                 pc = nouv_pts_inv[poly[3]]
  309.                                 posa = posi(pa)
  310.                                 posb = posi(pb)
  311.                                 posc = posi(pc)
  312.                                 posd = posi(pd)
  313.                                 vAB = posa - posb
  314.                                 vAC = posa - posc
  315.                                 vAD = posa - posd
  316.                                 vBA = posb - posa
  317.                                 vBC = posb - posc
  318.                                 vCA = posc - posa
  319.                                 vCD = posc - posd
  320.                                 # Dénoue les polys si le point D est à l'ouest
  321.                                 if VectorAngle(vCA, -vAD) < VectorAngle(vCA, -vAB) :
  322.                                         if VectorAngle(vBA, -vAD) < VectorAngle(vBA, -vAC) :
  323.                                                 pc, pd = pd, pc
  324.                                 else :
  325.                                         if VectorAngle(vBC, -vCD) < VectorAngle(vBC, -vCA) :
  326.                                                 pa, pd = pd, pa
  327.                         else : pc = pd
  328.                         
  329.                         cpoly = c4d.CPolygon(pa, pb, pc, pd)
  330.                         obj.SetPolygon(poli, cpoly)
  331.                
  332.                 obj.Message(c4d.MSG_UPDATE)
  333.                 commande = utils.SendModelingCommand(command = c4d.MCOMMAND_ALIGNNORMALS, list = [obj], doc = doc)
  334.                
  335.                 if invn : commande = utils.SendModelingCommand(command = c4d.MCOMMAND_REVERSENORMALS, list = [obj], doc = doc)
  336.                
  337.                 ### -- Modifs des propriétés -- #
  338.                
  339.                 cor_polyS_polyN = [] # Correspondance [polys subdivisés] = nouveaux polys NETTOYé
  340.                 for _p in self.pol_corres : cor_polyS_polyN.append(self.cor_poly_polynet[_p])
  341.                
  342.                 for _i, _Npolsel in enumerate(_Npolsels) : # Sélection de polygones
  343.                         _Spolsel = _Spolsels[_i]
  344.                         _Sbs = _Spolsel.GetBaseSelect()
  345.                         _Nbs = _Npolsel.GetBaseSelect()
  346.                         _Nbs.DeselectAll()
  347.                         for i, sel in enumerate(_Sbs.GetAll(self.obj_nbpol)) :
  348.                                 if not sel : continue
  349.                                 _p = cor_polyS_polyN[i]
  350.                                 if _p != -1 : _Nbs.Select(_p)
  351.                
  352.                 for _i, _Nptnsel in enumerate(_Nptnsels) : # Sélection de points
  353.                         _Sptnsel = _Sptnsels[_i]
  354.                         _Sbs = _Sptnsel.GetBaseSelect()
  355.                         _Nbs = _Nptnsel.GetBaseSelect()
  356.                         _Nbs.DeselectAll()
  357.                         for i, sel in enumerate(_Sbs.GetAll(self.obj_nbpts)) :
  358.                                 if not sel : continue
  359.                                 _p = nouv_pts_inv[i]
  360.                                 if _p != -1 and _p < self.obj_nbpts : _Nbs.Select(_p)
  361.                
  362.                 _ANpolsel.DeselectAll() # Sélection de polygones active
  363.                 for i, sel in enumerate(_ASpolsel.GetAll(self.obj_nbpol)) :
  364.                         if not sel : continue
  365.                         _p = cor_polyS_polyN[i]
  366.                         if _p != -1 : _ANpolsel.Select(_p)
  367.                
  368.                 _ANptnsel.DeselectAll() # Sélection de points active
  369.                 for i, sel in enumerate(_ASptnsel.GetAll(self.obj_nbpts)) :
  370.                         if not sel : continue
  371.                         _p = nouv_pts_inv[i]
  372.                         if _p != -1 and _p < self.obj_nbpts : _ANptnsel.Select(_p)
  373.                
  374.                
  375.                 for _i, _Nuvw in enumerate(_Nuvws) : # UVW
  376.                         _Suvw = _Suvws[_i]
  377.                         for i in xrange(_Nuvw.GetDataCount()):
  378.                                 
  379.                                 k = self.cor_polynet_poly[i]
  380.                                 polys = self._GetPointPolys[k]
  381.                                 # points = nouv_polys[i]
  382.                                 points = []
  383.                                 Npoly = obj.GetPolygon(i)
  384.                                 points.append(nouv_pts[Npoly.a])
  385.                                 points.append(nouv_pts[Npoly.b])
  386.                                 points.append(nouv_pts[Npoly.c])
  387.                                 points.append(nouv_pts[Npoly.d])
  388.                                 
  389.                                 abcd = [Vector(), Vector(), Vector(), Vector()]
  390.                                 for poly in polys :
  391.                                         pol = self._GetAllPolygons[poly]
  392.                                         for j, pt in enumerate(points) :
  393.                                                 if pol.a == pt :
  394.                                                         abcd[j] = _Suvw.GetSlow(poly)["a"]
  395.                                                         break
  396.                                                 elif pol.b == pt :
  397.                                                         abcd[j] = _Suvw.GetSlow(poly)["b"]
  398.                                                         break
  399.                                                 elif pol.c == pt :
  400.                                                         abcd[j] = _Suvw.GetSlow(poly)["c"]
  401.                                                         break
  402.                                                 elif pol.d == pt :
  403.                                                         abcd[j] = _Suvw.GetSlow(poly)["d"]
  404.                                                         break
  405.                                                         
  406.                                 _Nuvw.SetSlow(i, abcd[0], abcd[1], abcd[2], abcd[3])
  407.                
  408.                 # c4d.EventAdd()
  409.         
  410.         def Initialise(self, depart) :
  411.                 if not self.obj : return
  412.                 if not self.doc : return
  413.                 obj = self.obj
  414.                 if not obj.CheckType(c4d.Opolygon) : return
  415.                 self.obj_nbpts = obj.GetPointCount()
  416.                 self.obj_nbpol = obj.GetPolygonCount()
  417.                 if not self.obj_nbpts or not self.obj_nbpol : return
  418.                 self.obj_n = Neighbor()
  419.                 self.obj_n.Init(obj)
  420.                 self.pts_orig = depart
  421.                 self.pts_traites = [False] * self.obj_nbpts
  422.                 self.pol_traites = [False] * self.obj_nbpol
  423.                 self.nouv_polys = [0] * self.obj_nbpts
  424.                 self.nouv_pts = []
  425.                 self.nouv_pts_inv = [-1] * self.obj_nbpts
  426.                 self.nouv_coor = [0] * self.obj_nbpts
  427.                 self.pol_corres = [0] * self.obj_nbpol
  428.                 self.pts_corres = [[] for a in range(self.obj_nbpts)]
  429.                 self.cor_poly_polynet = []
  430.                 self.cor_polynet_poly = []
  431.                 self._GetAllPolygons = obj.GetAllPolygons()
  432.                 self._GetPointPolys = []
  433.                 for i in xrange(self.obj_nbpts) : self._GetPointPolys.append(self.obj_n.GetPointPolys(i))
  434.                 return True
  435.         
  436.         def __init__(self, doc, obj) :
  437.                 self.obj = obj
  438.                 self.doc = doc


  441. class SubdivisionInverseObjet(c4d.plugins.ObjectData):
  442.         subdinv = None
  443.         type = 0
  444.         subd = 1
  445.         depa = 0
  446.         selp = False
  447.         invn = False
  448.         
  449.         def Message(self, node, type, data) :
  450.                 if type == c4d.MSG_MENUPREPARE :
  451.                         node.SetDeformMode(True)
  452.                
  453.                 if type == c4d.MSG_DESCRIPTION_COMMAND :
  454.                         id = data['id'][0].id
  455.                         if id == VONC_SUBDINV_DON : webbrowser.open("http://code.vonc.fr/", 2, True)
  456.                         elif id == VONC_SUBDINV_ACTU : node.SetDirty(c4d.DIRTY_DATA)
  457.                
  458.                 return True
  459.         
  460.         
  461.         def Init(self, op) :
  462.                 donnees = op.GetDataInstance()
  463.                 self.InitAttr(op, int, [VONC_SUBDINV_TYPE])
  464.                 self.InitAttr(op, int, [VONC_SUBDINV_SUBD])
  465.                 self.InitAttr(op, int, [VONC_SUBDINV_DEPA])
  466.                 self.InitAttr(op, bool, [VONC_SUBDINV_SELP])
  467.                 self.InitAttr(op, bool, [VONC_SUBDINV_INVN])
  468.                 op[VONC_SUBDINV_TYPE] = self.type
  469.                 op[VONC_SUBDINV_SUBD] = self.subd
  470.                 op[VONC_SUBDINV_DEPA] = self.depa
  471.                 op[VONC_SUBDINV_SELP] = self.selp
  472.                 op[VONC_SUBDINV_INVN] = self.invn
  473.                 return True
  474.         
  475.         def ModifyObject(self, mod, doc, op, op_mg, mod_mg, lod, flags, thread):
  476.                 if not op.CheckType(c4d.Opolygon) : return True
  477.                 if not op.GetPointCount() : return True
  478.                 if not op.GetPolygonCount() : return True
  479.                
  480.                 self.type = mod[VONC_SUBDINV_TYPE]
  481.                 self.subd = mod[VONC_SUBDINV_SUBD]
  482.                 self.depa = mod[VONC_SUBDINV_DEPA]
  483.                 self.selp = mod[VONC_SUBDINV_SELP]
  484.                 self.invn = mod[VONC_SUBDINV_INVN]
  485.                 self.subdinv = SubdivisionInverse(doc, op)
  486.                
  487.                 for k in xrange(self.subd) :
  488.                         nbp = op.GetPointCount()
  489.                         depart = [self.depa % nbp]
  490.                         if self.selp :
  491.                                 depart = []
  492.                                 bs = op.GetPointS()
  493.                                 for i, sel in enumerate(bs.GetAll(nbp)) :
  494.                                         if not sel : continue
  495.                                         depart.append(i)
  496.                         if not depart : depart = [0]
  497.                         
  498.                         self.subdinv.Execute(self.type, depart, self.selp, self.invn)
  499.                
  500.                 return True
  501.                

  503. if __name__ == "__main__":
  504.          bmp = bitmaps.BaseBitmap()
  505.          dir, f = os.path.split(__file__)
  506.          fn = os.path.join(dir, "res", "vonc_subdinv.tif")
  507.          bmp.InitWith(fn)
  508.          c4d.plugins.RegisterObjectPlugin(id=MODULE_ID, str=c4d.plugins.GeLoadString(VONC_SUBDINV_NOM),
  509.                                                                                 g=SubdivisionInverseObjet,
  510.                                                                                 description="vonc_subdinv",
  511.                                                                                 icon=bmp,
  512.                                                                                 info=c4d.OBJECT_MODIFIER)
复制代码
Fichier c4d_symbols.H :
  1. enum
  2. {
  3.     VONC_SUBDINV_NOM        = 1000,
  4.         
  5.     _DUMMY_ELEMENT_
  6. };
复制代码
Fichier vonc_subdinv.H :
  1. #ifndef _vonc_subdinv_H_
  2. #define _vonc_subdinv_H_

  4. enum
  5. {
  6.         VONC_SUBDINV_TYPE                        = 1000,
  7.         VONC_SUBDINV_TYPE_CC1                = 0,
  8.         VONC_SUBDINV_TYPE_CC2                = 1,
  9.         VONC_SUBDINV_TYPE_CC3                = 3,
  10.         VONC_SUBDINV_TYPE_CCA                = 2,
  11.         VONC_SUBDINV_SUBD                        = 1002,
  12.         VONC_SUBDINV_DEPA                        = 1003,
  13.         VONC_SUBDINV_INFO                        = 1004,
  14.         VONC_SUBDINV_SELP                        = 1005,
  15.         VONC_SUBDINV_INVN                        = 1006,
  16.         VONC_SUBDINV_DON                        = 1007,
  17.         VONC_SUBDINV_ACTU                        = 1008
  18. };

  20. #endif
复制代码

Fichier vonc_subdinv.RES :
  1. CONTAINER vonc_subdinv
  2. {
  3.         NAME vonc_subdinv;
  4.         INCLUDE Obase;

  6.         GROUP ID_OBJECTPROPERTIES
  7.         {
  8.                 LONG VONC_SUBDINV_TYPE
  9.                 {
  10.                         CYCLE
  11.                         {
  12.                                 VONC_SUBDINV_TYPE_CC1;
  13.                                 VONC_SUBDINV_TYPE_CC2;
  14.                                 VONC_SUBDINV_TYPE_CC3;
  15.                                 VONC_SUBDINV_TYPE_CCA;
  16.                         }
  17.                         FIT_H;
  18.                 }
  19.                 LONG VONC_SUBDINV_SUBD { MIN 0; }
  20.                
  21.                 GROUP {
  22.                         COLUMNS 3;
  23.                         LONG VONC_SUBDINV_DEPA { MIN 0; }
  24.                         BOOL VONC_SUBDINV_SELP { }
  25.                         BUTTON VONC_SUBDINV_ACTU { }
  26.                 }
  27.                 BOOL VONC_SUBDINV_INVN { }
  28.                
  29.                 SEPARATOR { LINE; }
  30.                
  31.                 GROUP {
  32.                         STATICTEXT VONC_SUBDINV_INFO { }
  33.                         BUTTON VONC_SUBDINV_DON { }
  34.                 }
  35.         }
  36. }
复制代码
Fichier c4d_strings.STR :
  1. STRINGTABLE
  2. {
  3.         VONC_SUBDINV_NOM "Subdivision inverse";
  4. }
复制代码
Fichier vonc_subdinv.STR :
  1. STRINGTABLE vonc_subdinv
  2. {
  3.         vonc_subdinv "Subdivision inverse";
  4.         
  5.         VONC_SUBDINV_TYPE                        "Type";
  6.         VONC_SUBDINV_TYPE_CC1                "Catmull-Clark (estimation 1)";
  7.         VONC_SUBDINV_TYPE_CC2                "Catmull-Clark (estimation 2)";
  8.         VONC_SUBDINV_TYPE_CC3                "Catmull-Clark (estimation 3)";
  9.         VONC_SUBDINV_TYPE_CCA                "Catmull-Clark (adoucie)";
  10.         VONC_SUBDINV_SUBD                        "Subdivisions";
  11.         VONC_SUBDINV_DEPA                        "Point de d\u00E9part";
  12.         VONC_SUBDINV_INFO                        "v 1.1 - C\u00E9sar Vonc - http://code.vonc.fr";
  13.         VONC_SUBDINV_SELP                        "S\u00E9lection";
  14.         VONC_SUBDINV_INVN                        "Inverser les normales";
  15.         VONC_SUBDINV_DON                        "Faire un don";
  16.         VONC_SUBDINV_ACTU                        "Act.";
  17. }
复制代码

点击下载图标
下载等级
C8D
登录后下载
点击登录
C4D VIP会员赞助图标赞助会员
版权声明图标禁止商用
下载帮助图标下载帮助
0
举报
0
插件脚本
软件性质:  
适用版本: C4D R15 - C4D R16 - C4D R17 - C4D R18 - C4D R19 - C4D R20 - C4D R21 - C4D S22 - C4D R23 - C4D S24 - C4D R25 - C4D S26 - C4D 2023 - C4D 2024 - C4D 2025
软件版本: Subdivision inverse - v 1.1（R13+R16）
系统平台: Win MAC 
软件语言: 汉化 
插件来源: https://www.c4d.cn/c4dsoft.html

相关推荐

百套精美Kitbash3D模型专题合集下载

楼主新帖

Subdivision inverse Subdivision
时尚卡通办公室人物C4D立体图标工程下载Cinema 4D Fashion Cartoon Office Character 3D Icon Project Download
C4D科技新闻片头电视栏目频道包装动画工程下载Cinema 4D Technology News Headline TV Program Channel Packaging Animation Project Download
关闭

C4D精选推荐 上一条 /10 下一条

智能
客服
快速回复 返回顶部 返回列表