Code Vonc

Déformateur Utilitaires

v 1.0

R15+ Win OSX

TéléchargerDownload
Faire un donMake a donation
Comment installer ?How to install ?
CommentairesComments

Le déformateur Utilitaires applique des commandes de base sur un objet :

- Optimiser.
- Aligner, inverser les normales.
- Fermer les trous de l'objet.
- Trianguler, supprimer les triangles.
The Utils deformer apply some basics commands to the mesh :

- Optimize.
- Align, reverse normals.
- Close object's holes.
- Triangulate, untriangulate.






Codes sourcesSources code

Ovoncdefutils.pyp

import os
import sys
import math
import hashlib
import c4d
import random
import time
from c4d import plugins, utils, bitmaps, gui, Vector, Matrix, CPolygon
from c4d.utils import HPBToMatrix, MatrixScale, Neighbor, SendModelingCommand, Clamp, MatrixRotX
from c4d.plugins import GeLoadString

MODULE_ID = 1039562
VERSION = "1.0"

VONC_DEFUTILS_NOM = 1000
VONC_DEFUTILS_ETAT_0 = 1001
VONC_DEFUTILS_ETAT_1 = 1002
VONC_DEFUTILS_DEMO = 1003

VONC_DEFUTILS_INVERSE = 1000
VONC_DEFUTILS_ALIGNER = 1001
VONC_DEFUTILS_FERMERTROUS = 1002
VONC_DEFUTILS_OPTIMISER = 1003
VONC_DEFUTILS_QUADRANGULER = 1004
VONC_DEFUTILS_TRIANGULER = 1005
VONC_DEFUTILS_OPTIMISER_POLYS = 1006
VONC_DEFUTILS_OPTIMISER_POINTS_ISOLES = 1007
VONC_DEFUTILS_OPTIMISER_POINTS = 1008
VONC_DEFUTILS_OPTIMISER_TOL = 1009

class Utils() :
    
    """
        Auteur : César Vonc
        http://code.vonc.fr
    """
    
    @staticmethod
    def Optimiser(obj, doc, polys = True, pts = True, ptsiso = True, tolerance = 0.01) :
        
        """Optimiser."""
        
        params = c4d.BaseContainer()
        params[c4d.MDATA_OPTIMIZE_TOLERANCE] = tolerance
        params[c4d.MDATA_OPTIMIZE_POINTS] = pts
        params[c4d.MDATA_OPTIMIZE_POLYGONS] = polys
        params[c4d.MDATA_OPTIMIZE_UNUSEDPOINTS] = ptsiso
        c4d.utils.SendModelingCommand(command=c4d.MCOMMAND_OPTIMIZE, list=[obj], bc=params, doc=doc)
        
    
    @staticmethod
    def AlignerNormales(obj, doc) :
        
        """Aligner les normales."""
        
        c4d.utils.SendModelingCommand(command=c4d.MCOMMAND_ALIGNNORMALS, list=[obj], doc=doc)
    
    
    @staticmethod
    def InverserNormales(obj, doc) :
        
        """Inverser les normales."""
        
        c4d.utils.SendModelingCommand(command=c4d.MCOMMAND_REVERSENORMALS, list=[obj], doc=doc)
    
    
    @staticmethod
    def Trianguler(obj, doc) :
        
        """Convertit les polygones en triangles."""
        
        c4d.utils.SendModelingCommand(command=c4d.MCOMMAND_TRIANGULATE, list=[obj], doc=doc)
    
    
    @staticmethod
    def Quadranguler(obj, doc) :
        
        """Convertit les triangles en quadrangles."""
        
        bc = c4d.BaseContainer()
        bc[c4d.MDATA_UNTRIANGULATE_NGONS] = False
        bc[c4d.MDATA_UNTRIANGULATE_ANGLE_RAD] = c4d.utils.DegToRad(0.1)
        bc[c4d.MDATA_UNTRIANGULATE_ANGLE] = False
        
        return c4d.utils.SendModelingCommand(command=c4d.MCOMMAND_UNTRIANGULATE, list=[obj], bc=bc, doc=doc)
    
    
    @staticmethod
    def FermerTrous(obj, doc) :
        
        """Ferme tous les trous d'un objet."""
        
        polys = obj.GetAllPolygons()
        n = Neighbor()
        n.Init(obj)
        params = c4d.BaseContainer()
        params[c4d.MDATA_CLOSEHOLE_INDEX] = obj
        params[c4d.MDATA_CLOSEHOLE_TRI] = True
        mode = c4d.MODELINGCOMMANDMODE_EDGESELECTION
        commande = c4d.ID_MODELING_CLOSEHOLE_TOOL
        
        for i, pol in enumerate(polys) :
            
            nab = n.GetNeighbor(pol.a, pol.b, i)
            nbc = n.GetNeighbor(pol.b, pol.c, i)
            ncd = n.GetNeighbor(pol.c, pol.d, i)
            nda = n.GetNeighbor(pol.d, pol.a, i)
            cotes = n.GetPolyInfo(i)["edge"]
            
            if nab == c4d.NOTOK :
                params[c4d.MDATA_CLOSEHOLE_EDGE] = cotes[0]
                SendModelingCommand(command=commande, list=[obj], mode=mode, bc=params, doc=doc)
                n.Init(obj)
                
            if nbc == c4d.NOTOK :
                params[c4d.MDATA_CLOSEHOLE_EDGE] = cotes[1]
                SendModelingCommand(command=commande, list=[obj], mode=mode, bc=params, doc=doc)
                n.Init(obj)
                
            if ((ncd == c4d.NOTOK) and (pol.c != pol.d)) :
                params[c4d.MDATA_CLOSEHOLE_EDGE] = cotes[2]
                SendModelingCommand(command=commande, list=[obj], mode=mode, bc=params, doc=doc)
                n.Init(obj)
                
            if nda == c4d.NOTOK :
                params[c4d.MDATA_CLOSEHOLE_EDGE] = cotes[3]
                SendModelingCommand(command=commande, list=[obj], mode=mode, bc=params, doc=doc)
                n.Init(obj)
        
        obj.Message(c4d.MSG_UPDATE)
   
      

class DefUtils(plugins.ObjectData) :
    
    
    def __init__(soi) :
    
        pass
    
    
    def Message(soi, node, type, data):
    
        if type == c4d.MSG_MENUPREPARE :
        
            node.SetDeformMode(True)
            
        return True
        
        
    def Init(soi, op) :
    
        donnees = op.GetDataInstance()
        
        donnees.SetBool(VONC_DEFUTILS_OPTIMISER_POLYS, True)
        donnees.SetBool(VONC_DEFUTILS_OPTIMISER_POINTS, True)
        donnees.SetBool(VONC_DEFUTILS_OPTIMISER_POINTS_ISOLES, True)
        donnees.SetFloat(VONC_DEFUTILS_OPTIMISER_TOL, 0.01)
        
        return True
    
    
    def ModifyObject(soi, mod, doc, op, op_mg, mod_mg, lod, flags, thread) :
        
        if not op.CheckType(c4d.Opolygon) : return True
        
        donnees = mod.GetDataInstance()
        
        if donnees.GetBool(VONC_DEFUTILS_OPTIMISER) :
            polys = donnees.GetBool(VONC_DEFUTILS_OPTIMISER_POLYS)
            pts = donnees.GetBool(VONC_DEFUTILS_OPTIMISER_POINTS)
            ptsiso = donnees.GetBool(VONC_DEFUTILS_OPTIMISER_POINTS_ISOLES)
            tolerance = donnees.GetFloat(VONC_DEFUTILS_OPTIMISER_TOL)
            Utils.Optimiser(op, doc, polys, pts, ptsiso, tolerance)
        
        if donnees.GetBool(VONC_DEFUTILS_ALIGNER) :
            Utils.AlignerNormales(op, doc)
        
        if donnees.GetBool(VONC_DEFUTILS_INVERSE) :
            Utils.InverserNormales(op, doc)
        
        if donnees.GetBool(VONC_DEFUTILS_FERMERTROUS) :
            Utils.FermerTrous(op, doc)
        
        if donnees.GetBool(VONC_DEFUTILS_TRIANGULER) :
            Utils.Trianguler(op, doc)
        
        if donnees.GetBool(VONC_DEFUTILS_QUADRANGULER) :
            Utils.Quadranguler(op, doc)
        
        op.Message(c4d.MSG_UPDATE)
        
        return True


    def GetDEnabling(soi, node, id, t_data, flags, itemdesc):
    
        data = node.GetDataInstance()
        if data is None: return
        
        _id = id[0].id
        
        if _id == VONC_DEFUTILS_OPTIMISER_POLYS or _id == VONC_DEFUTILS_OPTIMISER_POINTS or _id == VONC_DEFUTILS_OPTIMISER_POINTS_ISOLES or _id == VONC_DEFUTILS_OPTIMISER_TOL :
            
            if not data.GetBool(VONC_DEFUTILS_OPTIMISER) :
                return False
        
        return True
        
        

if __name__ == "__main__":
    path, fn = os.path.split(__file__)
    bmp = bitmaps.BaseBitmap()
    bmp.InitWith(os.path.join(path, "res", "Ovoncdefutils.tif"))
    plugins.RegisterObjectPlugin(id=MODULE_ID, str=c4d.plugins.GeLoadString(VONC_DEFUTILS_NOM),
                                g=DefUtils,
                                description="Ovoncdefutils", icon=bmp,
                                info=c4d.OBJECT_MODIFIER)

res/c4d_symbols.h

enum
{
	VONC_DEFUTILS_NOM		= 1000,
	
    _DUMMY_ELEMENT_
};

res/description/Ovoncdefutils.h

#ifndef _Ovoncdefutils_H_
#define _Ovoncdefutils_H_

enum
{
	VONC_DEFUTILS_INVERSE					= 1000,
	VONC_DEFUTILS_ALIGNER					= 1001,
	VONC_DEFUTILS_FERMERTROUS				= 1002,
	VONC_DEFUTILS_OPTIMISER					= 1003,
	VONC_DEFUTILS_QUADRANGULER				= 1004,
	VONC_DEFUTILS_TRIANGULER				= 1005,
	VONC_DEFUTILS_OPTIMISER_POLYS			= 1006,
	VONC_DEFUTILS_OPTIMISER_POINTS_ISOLES	= 1007,
	VONC_DEFUTILS_OPTIMISER_POINTS			= 1008,
	VONC_DEFUTILS_OPTIMISER_TOL				= 1009,
	
	_DUMMY_ELEMENT_
};

#endif

res/description/Ovoncdefutils.res

CONTAINER Ovoncdefutils
{
	NAME Ovoncdefutils;
	INCLUDE Obase;

	GROUP ID_OBJECTPROPERTIES
	{
		BOOL VONC_DEFUTILS_OPTIMISER {}
		BOOL VONC_DEFUTILS_OPTIMISER_POLYS {}
		BOOL VONC_DEFUTILS_OPTIMISER_POINTS_ISOLES {}
		BOOL VONC_DEFUTILS_OPTIMISER_POINTS {}
		REAL VONC_DEFUTILS_OPTIMISER_TOL { UNIT METER; MIN 0.0; STEP 0.01; }
		SEPARATOR { LINE; }
		BOOL VONC_DEFUTILS_ALIGNER {}
		BOOL VONC_DEFUTILS_INVERSE {}
		SEPARATOR { LINE; }
		BOOL VONC_DEFUTILS_FERMERTROUS {}
		SEPARATOR { LINE; }
		BOOL VONC_DEFUTILS_TRIANGULER {}
		BOOL VONC_DEFUTILS_QUADRANGULER {}
	}
}

res/strings_fr/c4d_strings.str

STRINGTABLE
{
	VONC_DEFUTILS_NOM "D\u00E9formateur Utilitaires";
}

res/strings_fr/description/Ovoncdefutils.str

STRINGTABLE Ovoncdefutils
{
	Ovoncdefutils "D\u00E9formateur Utilitaires";
	
	VONC_DEFUTILS_INVERSE					"Inverser les normales";
	VONC_DEFUTILS_ALIGNER					"Aligner les normales";
	VONC_DEFUTILS_FERMERTROUS				"Fermer les trous";
	VONC_DEFUTILS_OPTIMISER					"Optimiser";
	VONC_DEFUTILS_TRIANGULER				"Trianguler";
	VONC_DEFUTILS_QUADRANGULER				"D\u00E9trianguler";
	VONC_DEFUTILS_OPTIMISER_POLYS			"Polygones d\u00E9g\u00E9n\u00E9r\u00E9s";
	VONC_DEFUTILS_OPTIMISER_POINTS_ISOLES	"Points isol\u00E9s";
	VONC_DEFUTILS_OPTIMISER_POINTS			"Points proches";
	VONC_DEFUTILS_OPTIMISER_TOL				"Tol\u00E9rance";
}

res/strings_us/c4d_strings.str

STRINGTABLE
{
	VONC_DEFUTILS_NOM "Utils Deform";
}

res/strings_us/description/Ovoncdefutils.str

STRINGTABLE Ovoncdefutils
{
	Ovoncdefutils "Utils Deform";
	
	VONC_DEFUTILS_INVERSE					"Invert normals";
	VONC_DEFUTILS_ALIGNER					"Align normals";
	VONC_DEFUTILS_FERMERTROUS				"Close holes";
	VONC_DEFUTILS_OPTIMISER					"Optimize";
	VONC_DEFUTILS_TRIANGULER				"Triangulate";
	VONC_DEFUTILS_QUADRANGULER				"Untriangulate";
	VONC_DEFUTILS_OPTIMISER_POLYS			"Polygons";
	VONC_DEFUTILS_OPTIMISER_POINTS_ISOLES	"Unused Points";
	VONC_DEFUTILS_OPTIMISER_POINTS			"Points";
	VONC_DEFUTILS_OPTIMISER_TOL				"Tolerance";
}