3D-Diablotine.com
Nous sommes actuellement le Sam 20 Oct 2018, 00:57




Publier un nouveau sujet Répondre au sujet  [ 70 messages ]  Aller à la page Précédent  1, 2, 3, 4, 5  Suivant
 DAZ Scripting 
Auteur Message
Petit Diablotin(ine)
Petit Diablotin(ine)

Inscrit le: Mer 29 Mar 2017, 21:07
Messages: 52
Message Re: DAZ Scripting
Ce que tu écrit est très intéressant.
Juste une question, je croyais que les fichiers .dsf de DAZ étaient du Python ?
Je me trompe ?


Ven 1 Déc 2017, 22:42
Profil
Super Diablotin(ine)
Super Diablotin(ine)

Inscrit le: Lun 7 Déc 2015, 16:53
Messages: 504
Localisation: Hauts de seine
Message Re: DAZ Scripting
Honnêtement, je ne sais pas si les fichiers dsf sont du python. Je sais que pour programmer des scripts sous Poser, il faut écrire en Python. Il y a plusieurs manières d'écrire pour DAZ: en C++ avec le SDK qui est offert gratuitement (je crois, je l'ai eu gratuitement en tout cas) SDK pour DAZ 4.5 ou en langage Qt (qui ressemble à du javascript).

Le problème, c'est de trouver des infos pour certaines classes. Il est évident que DAZ Studio fonctionne avec les classes Action puisqu'en les lançant, on lance les mêmes fenêtres.

Grâce au site asiatique que j'ai trouvé, on peut savoir quels effets auront certaines classes, mais depuis il en a été ajouté. Il faudrait les lancer et comparer avec ce que l'on obtient directement par le menu par DAZ Studio. Déjà avec de la documentation ça serait long, alors sans .....

Donc j'ai laissé tomber


Sam 2 Déc 2017, 09:32
Profil
Administrateur
Administrateur
Avatar de l’utilisateur

Inscrit le: Lun 26 Mai 2008, 16:38
Messages: 12788
Localisation: Isère - Jura
Message Re: DAZ Scripting
j'y connais rien en Python.
mais de ce que j'ai lu des scripts proposés ici par Alinal, on dirait du javascript.

_________________
Image     Image
Image  Image


Dim 3 Déc 2017, 20:17
Profil Site Internet
Super Diablotin(ine)
Super Diablotin(ine)

Inscrit le: Lun 7 Déc 2015, 16:53
Messages: 504
Localisation: Hauts de seine
Message Re: DAZ Scripting
Les scripts sous Poser sont en Python mais l'interface de DAZ Studio et la fenêtre de script de DAZ ont été écrites en Qt script, langage qui ressemble à du javascript. On peut obtenir les mêmes résultats par le menu ou par un script utilisant une classe "action". Ces classes sont nombreuses et pas très documentées.

Quant aux duf et dsf, vu qu'ils sont généralement cryptés ce n'est pas facile à savoir.


Lun 4 Déc 2017, 08:04
Profil
Super Diablotin(ine)
Super Diablotin(ine)

Inscrit le: Lun 7 Déc 2015, 16:53
Messages: 504
Localisation: Hauts de seine
Message Re: DAZ Scripting
Presqu'un an que j'avais laissé cette rubrique de côté. La documentation sur les scripts a l'air d'avoir été étoffée par DAZ puisque l'on trouve beaucoup plus d'exemples qu'au moment où j'avais commencé ce fil.

On y trouve une liste d'actions incluant le phénomène dforce et dans objects index un lien "global" indiquant les propriétés et les méthodes globales. On y trouve la confirmation que App est une variable de la classe dzApp correspondant au programme 3D Studio avec en dessous une variable MainWindow de la classe dzMainWindow pour la partie graphique.

Chaque classe définit en général des signaux dont on peut se servir dans ses propres fonctions. Pour ceux qui ont programmé en java c'est un equivalent des listeners.

Certaines parties de la documentation sont des liens morts (en cours d'ecriture?) ou réservés WIP (?).


Ven 24 Aoû 2018, 15:06
Profil
Super Diablotin(ine)
Super Diablotin(ine)

Inscrit le: Lun 7 Déc 2015, 16:53
Messages: 504
Localisation: Hauts de seine
Message Re: DAZ Scripting
Il peut être intéressant de télécharger également les exemples prévus pour DAZ Studio 3. On les trouve à cette adresse: http://docs.daz3d.com/doku.php/public/software/dazstudio/3/start avec le lien API de script. Cela fournit d'autres exemples en plus de ceux prévus pour DAZ 4 et dont le nombre a été visiblement augmenté. Outre la définition des classes (mais ayant probablement des différences avec celle de DAZ Studio 4) on trouve des exemples dans 2 formats: le format actuel en .dsa et l'ancien format en .ds.
Si on prend comme exemple SimpleDialog.ds et SingleDialog.dsa, on voit des différences dans l'écriture du script (exemple les & précédant le texte pour les boutons ou l'enregistrement dans l'actionMgr). A l'éxécution sous DAZ Studio, dans scriptIDE, on note aussi quelques différences comme le bouton "?" qui n'a pas d'action avec le .ds mais fonctionne avec le .dsa. Bref, pour DAZ Studio 4, il importe d'utiliser les classes de DAZ Studio 4 et des fichiers .dsa.


Lun 27 Aoû 2018, 10:59
Profil
Super Diablotin(ine)
Super Diablotin(ine)

Inscrit le: Lun 7 Déc 2015, 16:53
Messages: 504
Localisation: Hauts de seine
Message Re: DAZ Scripting
On va s'intéresser à un script que j'ai trouvé amusant. Il faut qu'un personnage soit chargé ainsi que des morphs et les script va générer une animation qui va appliquer à chaque frame un nouveau morph.
Je donnerai les commentaires en indiquant les numéros de lignes correspondants quand le script est dans le scripIDE.
Il s'exécute malgré une erreur que signale scriptIDE et quelques façons de programmer qui viennent de DS3 et qu'il faudra modifier.

Ce script a pour base un script que l'auteur a trouvé sur le forum de MArvelous Designer et a modifié et étoffé. Qu'il en soit remercié.

Vu qu'il n'est autorisé que 10000 lignes, je vais tronçonner en 2 le script
Code:
// DAZ Studio version 4.10.0.123 filetype DAZ Script

/*******************************************************************************************************************************
DAZ Studio 4.x Pro - filetype : DAZ Script (.dsa = ascii | .dsb = binary) 
File Name of this Script : animMorph.ds(a|b) - Released on July 30, 2013 GMT

This new version is replacing the previous versions of
  - animMorph (for Daz Studio 4.0 Pro)
  - animMorph2 (for Daz Studio 4.5 Pro)
  both of them were released on May 2012
  and published on Marvelous Designer Website (in the freestuff's pages).

The purpose of this new version of the script animMorph is to make it compatible with each version
of Daz Studio 4.x Pro. 
It has been developed for Daz Studio 4.x Pro (PC version)
and tested with Daz Studio 4.0 Pro, Daz Studio 4.5 Pro and Daz Studio 4.6 Pro (versions 64-bit).

This script was inspired by a script published by DREDMARK in Marvelous Designer's Forum.
However, the script  animMorph is based upon a new algorithm with enhanced performances.
The algorithm provided in this script is the result of my own research on Animate 2.

Before running this script, a Wavefront Object (.OBJ) sequence needs to be loaded  in the scene
with the plugin "Morph Loader Pro".
Then this script creates automatically an animation with the sequence of morphs.
 
I am grateful to DREDMARK for having shown his solution.
I put lots of comments to explain the process in this script. :-)

This script is secure :
- it doesn't write or read any data on your disks.
- it doesn't interact with any other applications outside Daz Studio 4.x Pro.
- it doesn't send or receive any data to or from Internet.

However, I would recommend you to save your Daz Scene and to save your active works running
in other applications before the execution of this script.
A programmer can NEVER predict everything.

You may use this script for every purposes. No copyright is bound to my contribution.
 
********************************************************************************************************************************/

/******************************************************************************************************************************
Variables for the detection of Daz Manager's Actions used by this script : useful for the compatibility
of this script with existing (and probably future) subversions of Daz Studio 4 Pro
******************************************************************************************************************************/

var oAction ;                             // variable used to store the value of each Daz Manager Action to be tested
var nActionNextFrame ;                                       // variable used to store the index number of the Action Next Frame
var nActionAddKeys ;                          // variable used to store the index number of the Action Add Keys
var sActionText ;                          // variable used to store and compare sequentially each Daz Manager Action Text


/**************************************************************************************************************
Settings for a RichTextPad DialogBox that will help debugging inside Daz Studio 4.x Pro
**************************************************************************************************************/

var clrWHITE = new Color( 255, 255, 255 );                  // color is white for the output in the RichTextPad
var clrBKD = new Color( 100, 140, 250 );                           // color is a discreet blue for some backgrounds
var nMargin = 10;
var nSpacing = 10;                                 

var wDlgRTP = new DzDialog;                       // it is the Dialog Box which contains the RichTextPad
wDlgRTP.caption = "My Little Debugger :-)";                 // :-)
wDlgRTP.paletteBackgroundColor = clrBKD                  // the background has a light blue color
wDlgRTP.sizeGripEnabled = 1;                        // Dialog Box is resizable by the user (grip is on Bottom Right)

var wDlgRTPLyt = new DzVBoxLayout( wDlgRTP );                      // Layout of this Dialog Box
wDlgRTPLyt.autoAdd = true;                       // Dialog Box Container may extend automatically
wDlgRTPLyt.margin = nMargin;                       // to set the margin inside the Dialog Box
wDlgRTPLyt.spacing = nSpacing;                       // perhaps useful, not sure in this case

var wRichTxt = new DzTextEdit( wDlgRTP );                 // it is the RichTextPad itself

wRichTxt.documentTitle = "MyLittleDebugger";                      // why not ?
wRichTxt.clear();                          // let's start with a blank page
wRichTxt.color = clrWHITE;                       // text in white
wRichTxt.pointSize = 8;                          // the value 8 seems to be a good size for the text

/*****************************************************************
Setting of the variables for the Dialog with the user
*****************************************************************/

var wDlg = new DzDialog;                       // it is the Dialog Box to interact with the user
wDlg.paletteBackgroundColor = clrBKD ;                    // the background has a light blue color      
wDlg.caption = "ANIMATION WITH A SEQUENCE OF MORPHS - DAZ Studio 4.x Pro" ;

var wDlgLyt = new DzVBoxLayout( wDlg );                    // Layout of this Dialog Box               
wDlgLyt.autoAdd = true;                          // Dialog Box Container may extend automatically
wDlgLyt.margin = nMargin;                       // to set the margin inside the Dialog Box
wDlgLyt.spacing = nSpacing;                       // perhaps useful, not sure in this case

var wComment = new DzGroupBox( wDlg );                    // to store a comment in this Dialog Box

wComment.title = "This script is inspired by a script "
+ "that DREDMARK published in Marvelous Designer's Forum";

var wLineEdit1 = new DzLabel (wDlg);                      // initialisation of some lines in the DialogBox   
var wLineEdit2 = new DzLabel (wDlg);
var wLineEdit3 = new DzLabel (wDlg);
var wLineEdit4 = new DzLabel (wDlg);

/*********************************************************************
Warning Message when the user tries to run this script
IF no OBJECT is selected in the Scene                                                                                                              
*********************************************************************/
var oNode = Scene.getPrimarySelection();

if( ! oNode ){                             // the warning message if the user forgot to select the Object
   MessageBox.information( "Please select an Object in the Scene",
      "NOTHING IS SELECTED", "&Click this button to continue" )
}




Lun 27 Aoû 2018, 13:27
Profil
Super Diablotin(ine)
Super Diablotin(ine)

Inscrit le: Lun 7 Déc 2015, 16:53
Messages: 504
Localisation: Hauts de seine
Message Re: DAZ Scripting
Code:
/*****************************************************
Setting of the variables for the Animation
*****************************************************/
var i, j, k;                              // iterators for the main function

var oObject = oNode.getObject();                      // to locate the Selected Object
var oNodeLabel = oNode.getLabel();                      // to get the Label of the Selected Object
var nModifiers = oObject.getNumModifiers();                   // to get the number of morphs loaded for this object
var oModifier = undefined;                       // to find and get the Object Modifiers

var mgr = MainWindow.getActionMgr();                    // to get the available actions in Daz Studio 4 Pro's Window
var nLastFrame = oObject.getNumModifiers() ;                    // the Last Frame of the animation = the number of Loaded Morphs
var nTimeStep = Scene.getTimeStep();                          // the Time Step applied by Daz Studio : a value of 160 is awaited
                                // please read comment #1 at the end of this script
var oTimeRange =  DzTimeRange(0, nTimeStep * nLastFrame);                 // to determine the Time Range to apply to the Scene

Scene.setAnimRange( oTimeRange );                    // Animation Range : the number of frames = the Sequence of Morphs + 1
var nFirstFrame = Scene.getAnimRange().start / nTimeStep;           // to determine the first frame : a value of 0 is awaited
                 
wRichTxt.append ("Time Step = " + nTimeStep);                 // Output to help for debugging   
wRichTxt.append ("First Frame = " + nFirstFrame);
wRichTxt.append ("Last Frame = " + nLastFrame);

// wDlgRTP.exec();                          // a first launch of my little debugger :-)   
                                     // please read comment #2 at the end of this script
                                                                                    
/***************************************************************************************
Output of comments and instructions in the DialogBox with the user
***************************************************************************************/
wLineEdit1.text = "You selected this object : "+ oNodeLabel ;
wLineEdit2.text = "if valid, the sequence of morphs "
+ "will be used to create an animation for your selection";
wLineEdit3.text = "The animation starts on frame [ "
+ nFirstFrame + " ] and ends on frame [ " + nLastFrame + " ]";
wLineEdit4.text = "If you don't want to proceed, please click on CANCEL";

var wDlgAcceptCancel = new DzGroupBox( wDlg );                          // creation of the Group Accept / Cancel
wDlgAcceptCancel.flat = true;                           // Daz Script Sample "Widget Test" in the DOC was very useful :-)
var wDlgBtnsLyt = new DzGridLayout( wDlgAcceptCancel );
var wAcceptBtn = new DzPushButton( wDlgAcceptCancel );
wAcceptBtn.text = "&ACCEPT = PROCEED";
wAcceptBtn.minWidth = 100;
wAcceptBtn.minHeight = 80;
wDlg.setAcceptButton( wAcceptBtn );
wDlgBtnsLyt.addWidget( wAcceptBtn, 0, 2 );
var wCancelBtn = new DzPushButton( wDlgAcceptCancel );
wCancelBtn.text = "&CANCEL = DON'T PROCEED";
wCancelBtn.minWidth = 100;
wCancelBtn.minHeight = 80;
wDlg.setRejectButton( wCancelBtn );
wDlgBtnsLyt.addWidget( wCancelBtn, 0, 3 );


//°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°
if( wDlg.exec() )                              // the user clicked on the "ACCEPT = PROCEED" button
{                                    // let's load the sequence of morphs  to convert it into an animation
   load_morphs();                             // the function [ load_morphs() ] is called
   // wDlgRTP.exec();                            // a second launch of my little debugger to see the script's termination
   wRichTxt.append ("Script Terminated");                     // This last output for a happy end :-)
   // wDlgRTP.exec();
}
//°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°

//__________________________________________________________END OF THE MAIN SECTION___________________________________________________________________________________________


//__________________________________________________________FUNCTION(S) IN THIS SECTION ______________________________________________________________________________________


function load_morphs()                                 
{
   n = mgr.getNumActions();
       for( i = 0; i < n; i++ ){
            oAction = mgr.getAction( i );                     // Daz Manager Actions are scanned sequentially
         wRichTxt.append ( oAction.text + ": " +  i );                 // script line for debugging purpose
     
      sActionText = oAction.text ;
     
                 if ( sActionText == "Step to Next Frame" ){
                 nActionNextFrame = i ;                     // the action "Step to Next Frame" is found and its index is stored
                wRichTxt.append ("OK action " + i);                        // script line for debugging purpose
                
                   }
                else if ( sActionText == "Create Keyframe" ) {
                nActionAddKeys = i ;                     // the action "Create Keyframe" is found and its index is stored
                wRichTxt.append ("OK action " + i);                        // script line for debugging purpose
                   
                }   
        }
   
   
   wRichTxt.append ("Number of Modifiers for this Object "             // output to my little debugger :-)
   + nModifiers);

   oStepNextFrame = mgr.getAction(nActionNextFrame);                 //   The Action "Step to Next Frame" (DzNextFrameAction) is identified
   oCreateKeyFrame = mgr.getAction(nActionAddKeys);                //   The Action "Create KeyFrame" (AddKeysAction) is identified
   
                  
   
   /************************************************************
    It is here that the serious job begins
    This algorithm is executing a very tedious task
    ***********************************************************/
   
   Scene.setFrame (0) ;                           // Frame #0 is created (no other step required for this frame)
   oCreateKeyFrame.trigger();                        // Parameters of the selected Object are recorded in this frame
   
   for( i = 1; i <= nLastFrame  ; i++){                     // The iterative process of this algorithm is controlled by the variable i
                                    // The variable i is incremented by 1 unit with each iteration until its value reaches the Last Frame's value
   oStepNextFrame.trigger (i) ;                        // The first action is to move to the next frame in the animation
   
    j = i - 1 ;                                 // The variable j is used to locate the Morph in position (i-1) in the sequence of Morphs
   k = i - 2 ;                              // The variable k is used to locate the Morph in position (i-2) in the sequence of Morphs

      if ( i >= 2) {                                    
                                    // The variable k starts playing its role when frame #2 is reached
      oModifier = oObject.getModifier(k);                  // oModifier gets the Modifier #k in the sequence of Morphs
      oModifier.getValueChannel().setValue(0);               // The Morph #k recorded in the previous frame is reset to 0 (0%) to disable its useless interpolation
      }
                                    // This last part of the algorithm is executed for each frame ranging from 1 to the end of the animation
   oModifier = oObject.getModifier(j);                     // oModifier gets the Modifier #j in the sequence of Morphs
   oModifier.getValueChannel().setValue(1);                  // The Morph #j is set to 1 (= 100%)
                                                
   Scene.setFrame (i);                           // The Morphs #j and #k are recorded in each frame #i within the iteration
   oCreateKeyFrame.trigger();                        // THAT'S THE MAGIC ACTION !  Without this action, this script would be a nonsense,
                                    // because simply "moving to the next step" enables the interpolation process between the morphs            
   }
}
//______________________________________________________________________________________________________________________________________________________________________________

/**************************************** COMMENTS **************************************************
#1 / Time references  in Daz Studio are stored in ticks. There are 4800 ticks per second. Therefore the default setting of 30 FPS (frames per second) in Daz Timeline
will create  4800/30 =160 ticks between each frame. The choice of that time format by Daz Studio Developers is clever ! Because the value of 4800 ticks can be divided
by many values (10, 15, 20, 25, 30, 50, 100, 120 frames per second).
The adjustment of the setting "FPS" in Daz Timeline's pane provides a way to synchronize imported morphs sequence created with a different "FPS".
Please consult the document "2013-03-20-v4-animation.pdf " : "a particular approach of Marvelous Designer's Animation Editor" to learn more about the
synchronization of garment's animation with avatar's animation.

#2 / some lines of this script were disabled ("// wDlgRTP.exec();" = considered as comments ). They are relative to "my little debugger".
It is not useful for the user.
***************************************************************************************************/


Lun 27 Aoû 2018, 13:40
Profil
Super Diablotin(ine)
Super Diablotin(ine)

Inscrit le: Lun 7 Déc 2015, 16:53
Messages: 504
Localisation: Hauts de seine
Message Re: DAZ Scripting
Premiers commentaires sur le script animeMorph:
Les lignes 53 à 78 permettent d'avoir un débuggueur indépendant qui n'affiche ni dans le fichier log, ni dans le scriptIDE. Il est réutilisable pour d'autres applications, et modifiable. Dans le script l'auteur a mis son éxecution en commentaires, il suffit de les retirer pour le voir fonctionner (exemple ligne 136).
La syntaxe pour écrire dans ce mini-débuggueur est celle utilisée par exemple aux lignes 132 à 134.
Les lignes 79 à 102 fabrique une autre boite de dialogue, celle qui permettra la création de l'animation.
Les lignes 97 à 100 réservent de la place pour écrire un texte qui ne sera créé que plus loin dans le script.
Lignes 106 à 112, le script vérifie que l'utilisateur a bien sélectionné un node valide dans la scène (probablement un personnage, mais certains habits disposant de morphs, ça marche sûrement aussi je n'ai pas essayé). Si l'utilisateur n'a rien sélectionné, on affiche un message d'erreur.
Ligne 118, on récupère dans une variable l'objet à partir du node. Les deux classes héritent de DzBase et de DzElement mais n'ont pas les mêmes fonctions DzObject a l'air plutôt orientée shape et DzNode peut-être orienté DOM
ligne 119, on récupère le nom du node (VYK dans mon cas), c'est à dire ce sur quoi j'ai cliqué dans l'onglet scene.
Ligne 120, on récupère le nombre de modifiers (le nombre de morphs associés à l'objet)
Ligne 121 on définit une variable en lui affectant la valeur undefined, ce qui provoquera un message du débuggueur de scriptIDE mais n'empêchera pas le programme de se dérouler, Il faudra que je fasse du pas à pas sur les lignes 227 à 234 pour comprendre pourquoi. Message obtenu
Script Error: Line 234
TypeError: Result of expression 'oModifier.getValueChannel' [undefined] is not a function.
Ligne 123, on récupère de la MainWindow l'actionMGR. L'actionMGR (MGR pour manager) contient toutes les actions possibles au sein de DAZ Studio, y compris certains plugins payants comme Decimator. Faire un file open à l'aide du menu correspond à une action? Le liste des actions semble avoir été remise à jour dans la documentation: http://docs.daz3d.com/doku.php/public/s ... ndex/start
En script, on déclenche une action avec la méthode trigger().
Ligne 124, on affecte la dernière frame au dernier morph, ce qui est vrai puisque je constate en pratique que la frame 0 est le personnage sans modification.
Ligne 125 le Little Debuggueur m'indique 160 pour le timeStep. A la fin du script, on trouve une explication. Le timer se déclenche 4800 fois par seconde. 160 est un diviseur. 4800/160 =30 qui correspond au nombre de FPS (frames par seconde).
Ligne 127, on voit que la programmation du temps se fait en ticks puisqu'on multiplie 160*nombre de frames. Il se trouve que l'indication d'unité de DzTimeRange est inexistante dans la documentation.
Ligne 129 on applique ce temps à l'animation
Ligne 130 la première frame sera la frame 0.
Lignes 139 à 165, définition de la boite de dialogue qui va lancer la création de l'animation. Ligne 153 et 159, vous pouvez supprimer le & qui avait peut-être une utilité en script DAZ 3 mais pas en script DAZ 4.

On revient sur "Little debuggueur". Problème une fois qu'il affiche ses valeurs, il faut le fermer pour que le reste du programme se déroule, ce qui explique pourquoi on a 3 appels différents à la méthode exec() et pourquoi l'auteur a mis cette méthode en commentaire.
Ligne 167 si le bouton accept est cliqué, on lance la fonction load_morphs,
Ligne 183 à 202, on balaie le tableau de l'actionMGR pour trouver les index des actions "Step to Next Frame" et "Create Keyframe". Se servir des actions revient à faire plus ou moins la même chose qu'en manuel, Les deux actions correspondent à ce que l'on fait dans la timeline pour enregistrer une frame.
Ligne 207 et 208 on enregistre l'action sous forme objet à l'aide des indices relevés au-dessus.
Ligne 217 on se positionne sur la frame 0 de l'animation.
Ligne 218 on enregistre la frame.
Ligne 220 on va ensuite balayer les frames de 1 à LastFrame (équivalent au nombre de morphs)
Ligne 221 on se positionne sur la frame d'indice i
Ligne 224 j=i-1, ceci pour se positionner sur le morph précédent pour le remettre sa valeur à 0
Ligne 225 k= i-2, pour localiser le morph à la position -2 du morph en cours, ce dont je ne vois pas l'intérêt?

J'ai donc modifié une partie du code (ligne 227 à 234):
Code:
// if ( i >= 2) {
// The variable k starts playing its role when frame #2 is reached
// oModifier = oObject.getModifier(k); // oModifier gets the Modifier #k in the sequence of Morphs
// oModifier.getValueChannel().setValue(0); // The Morph #k recorded in the previous frame is reset to 0 (0%) to disable its useless interpolation
// }
// This last part of the algorithm is executed for each frame ranging from 1 to the end of the animation
// oModifier = oObject.getModifier(j); // oModifier gets the Modifier #j in the sequence of Morphs
// oModifier.getValueChannel().setValue(1); // The Morph #j is set to 1 (= 100%)
if(i>1)
{
oModifier = oObject.getModifier(j);
oModifier.getValueChannel().setValue(0);
}
oModifier = oObject.getModifier(i);
oModifier.getValueChannel().setValue(1);

Reste qu'il y a une partie que je ne comprends pas puisque oObject.getModifier() est censé renvoyer un DzModifier qui n'a pas la méthode getValueChannel(). Pourtant cette partie est citée dans le forum script de DAZ3D. Je vais chercher.....


Lun 27 Aoû 2018, 17:09
Profil
Super Diablotin(ine)
Super Diablotin(ine)

Inscrit le: Lun 7 Déc 2015, 16:53
Messages: 504
Localisation: Hauts de seine
Message Re: DAZ Scripting
Code:
   for( i = 1; i < nLastFrame  ; i++){                     // The iterative process of this algorithm is controlled by the variable i
                                    // The variable i is incremented by 1 unit with each iteration until its value reaches the Last Frame's value
   oStepNextFrame.trigger (i) ;                        // The first action is to move to the next frame in the animation
   
    j = i - 1 ;                                 // The variable j is used to locate the Morph in position (i-1) in the sequence of Morphs
   k = i - 2 ;                              // The variable k is used to locate the Morph in position (i-2) in the sequence of Morphs

//      if ( i >= 2) {                                    
                                    // The variable k starts playing its role when frame #2 is reached
//      oModifier = oObject.getModifier(k);                  // oModifier gets the Modifier #k in the sequence of Morphs
//      oModifier.getValueChannel().setValue(0);               // The Morph #k recorded in the previous frame is reset to 0 (0%) to disable its useless interpolation
//      }
                                    // This last part of the algorithm is executed for each frame ranging from 1 to the end of the animation
//   oModifier = oObject.getModifier(j);                     // oModifier gets the Modifier #j in the sequence of Morphs
//   oModifier.getValueChannel().setValue(1);                  // The Morph #j is set to 1 (= 100%)
if(i>1)                                                
{
oModifier = oObject.getModifier(j);
if(oModifier){
if(oModifier.inherits("DzMorph")){
oModifier.getValueChannel().setValue(0);
}
}
}
oModifier = oObject.getModifier(i);
if(oModifier){
if(oModifier.inherits("DzMorph")){
oModifier.getValueChannel().setValue(1);
}
}
}


Partie de code réécrite qui ne génère cette fois-ci aucune erreur, contrairement au script de base. Le fait que DzModifier hérite de DzMorph n'est pas marqué dans la doc.


Lun 27 Aoû 2018, 17:55
Profil
Super Diablotin(ine)
Super Diablotin(ine)

Inscrit le: Lun 7 Déc 2015, 16:53
Messages: 504
Localisation: Hauts de seine
Message Re: DAZ Scripting
J'ai oublié de préciser q'une fois le script lancé, il fabrique une animation avec le personnage qui subit un morph par frame poussé à son maximum, puis en passant à la frame suivante remet ce morph à zéro et passe le suivant au maximum, etc.. L'animation est placée dans la timeline. Il suffit de la lancer.


Mar 28 Aoû 2018, 06:46
Profil
Super Diablotin(ine)
Super Diablotin(ine)

Inscrit le: Lun 7 Déc 2015, 16:53
Messages: 504
Localisation: Hauts de seine
Message Re: DAZ Scripting
intéressons-nous au ds3_daz_script_development_kit_3.0.1.144_docs fourni par DAZ dans sa documentation.
On peut voir des différences notables entre les déclarations style DS3 et style DS4. Si vous regardez dans les scripts calculator.ds et calculator.dsa, la calculatrice est définie sous forme de classe. Dans le fichier .ds, la déclaration se fait par le mot-clé class; dans le fichier dsa on définit une fonction. Faire savoir qu'il s'agit d'une classe se fait par: DsCalculator.superclass = Object; Ensuite, toutes les méthodes se rapportant à la classe utilisent le mot-clé prototype. Exemple: DsCalculator.prototype.doDialog = function()

et les méthodes qui s'y rapportent.
Un rappel pour le debuggueur de scriptIDE: la fonction print () affiche dans la fenêtre du debuggueur, la fonction debug imprime dans le fichier log et affiche dans la fenêtre du debuggueur. Le fichier log enregistrant des informations quasiment à chaque opération de DAZ Studio, il faut le vider de temps en temps. Quant au Textpad que nous avons vu dans AnimateMorph, il faut prendre en compte que son lancement bloque le déroulement du script jusqu'à ce qu'on le ferme.
Notez qu'il ne faut pas oublier de sauver le script après ajout d'un print ou d'un débug, sinon il ne se passera rien.
Ligne 23 et 24 le script récupère le nom du script avec son extension. Le script ne plante pas, que l'on ait chargé un script extérieur ou qu'on l'ait tapé directement dans le scriptIDE. Dans un cas, il stockera le nom du script; dans l'autre il le considérera comme anonymous.
On retrouve aussi souvent les lignes 26 et 27 dans la plupart des scripts. Les lignes 29 à 32 définissent la largeur des marges, des espaces et de la taille des boutons.
Le script proprement dit ne commence vraiment qu'à la ligne 35 où l'on définit les différents modes de la calculatrice.
La déclaration du constructeur (puisqu'il s'agit d'une classe) commence en ligne 44. On notera que les variables et constantes internes commence toutes par This. Ce qui veut dire qu'elles sont attachées à l'instance de l'objet.
Ligne 53, on définit la boite de dialogue dans laquelle tout sera englobé.
Ligne 55 définition de la ligne d'affichage
Ligne 59 à 90 définition des boutons de la calculatrice.
Ligne 94: la nouvelle façon de déclarer une classe?
Ligne 97: on voit comment déclarer avec le mot-clé prototype les différentes méthodes de cette nouvelle classe.

à suivre


Ven 7 Sep 2018, 09:05
Profil
Super Diablotin(ine)
Super Diablotin(ine)

Inscrit le: Lun 7 Déc 2015, 16:53
Messages: 504
Localisation: Hauts de seine
Message Re: DAZ Scripting
Je reviens sur la ligne 94 pour préciser que toutes les classes dérivent de la classe objet.
Ligne 99 récupération du HelpMgr (manager des fichiers d'aide) à partir de App
Ligne 101 et 102 place en quelque sorte un pointeur sur l'action "DzWhatsThisAction" de l'actionMgr. Cette action a probablement été définie pour y engranger les actions utilisateur.
Ligne 104 à 113 commencement de définition de la calculatrice
Ligne 114 à 118 on ajoute des widgets à la boite de dialogue principale. En gros, on ajoute des boutons qui sont eux-mêmes des boites de dialogue au sein de la boite de dialogue principale.

Ligne 121 à 230 on définit chaque bouton avec son affichage, la fonction d'écoute du signal "clicked" et l'ajout de ce bouton à la boite de dialogue principale.
Si vous allez regarder dans la définition des classes vous verrez qu'outre les méthodes, on y définit des signaux. Un signal est envoyé à chaque objet qui s'est inscrit comme écouteur de cet objet par la méthode connect. Prenons comme exemple la ligne 229. Le widget (ici la touche = de la calculatrice) envoie un signal "clicked" chaque fois que l'on clique dans la zone qu'il occupe. La ligne 229 demande qu'à chaque fois qu'il y aura un click dans la zone de la touche = on déroule la méthode "result".
Lignes 241 à 249 on définit ce qui se passera si on clique sur l'aide de la calculatrice, La ligne 245 ressemble à ce que je viens de dire sur l'éxécution d'une méthode par l'écoute d'un signal sauf que la méthode appelée est "trigger" que nous avoins déjà vu et qui fait partie des méthodes de DzAction.
Ligne 263 lancement de la boite de dialogue
Lignes 267 à 499 définition des méthodes "écouteurs" des signaux envoyés par un click dans la zone correspondant à une touche.

Ligne 501 définition d'une instance de la classe DsCalculator
Ligne 502 lancement de la calculatrice proprement dite par l'appel de la méthode doDialog


Lun 10 Sep 2018, 10:46
Profil
Super Diablotin(ine)
Super Diablotin(ine)

Inscrit le: Lun 7 Déc 2015, 16:53
Messages: 504
Localisation: Hauts de seine
Message Re: DAZ Scripting
Partie effacee parce que doublon


Dernière édition par alinal le Ven 14 Sep 2018, 19:19, édité 1 fois au total.



Ven 14 Sep 2018, 10:24
Profil
Super Diablotin(ine)
Super Diablotin(ine)

Inscrit le: Lun 7 Déc 2015, 16:53
Messages: 504
Localisation: Hauts de seine
Message Re: DAZ Scripting
Comme indiqué dans "astuces des autres" le but du script qui suit est de permettre un déplacement rapide dans les axes X, Y et Z. Quand je crée une scène, j'ai l'habitude de regrouper tous les éléments qui la compose dans un objet null qui devient le parent de tout le monde,

Avantage, en sélectionnant cet objet null, on peut se déplacer rapidement dans la scène sans risquer de modifier l'emplacement d'un élémen.

Inconvénient, les éléments parentés à ce null n'ont plus des coordonnées "world" mais des coordonnées locales.

Evidemment, cela n'a d'intérêt que pour des scènes de paysages où l'étendue en X, Y ou Z est particulèrement grande. Cela n'a aucune utilité pour une scène où tous les éléments sont concentrés dans le wiewport.

Le script sera écrit dans une fonction anonyme
Code:
(function(){
})();


dans laquelle on va venir ajouter les lignes au fur et à mesure. La première chose que le script doit vérifier, c'est si l'utilisateur a sélectionné l'objet null au sommet de la hiérarchie. C'est pourquoi on va ajouter les ligne suivantes:

Code:
var oNode = Scene.getPrimarySelection();

if (!oNode){
MessageBox.critical ("rien n'a ete selectionne","Selection null a faire", "OK");
return;
}


On déclare une variable uqi devra contenir un objet, Cet objet sera un node que l'on récupère à partir de Scene, variable globale de type DzScene.

On teste si la récupération a réussie. Si oui, le progamme continue (à ca stade, on sort), si non, on affiche un message disant que l'utilisateur n'a pas sélectionné quoi que ce soit dans la hiérarchie.

Comme le script ne va pas s'arrêter là, le return est présent pour plus tard, Sans lui, dès le clic sur OK du message d'erreurs le script continuerait à se dérouler alors que rien n'est sélectionné. Autre point, oNode contiendra quelque chose, quel que soit le (ou les éléments) sélectionné(s), il faudra donc ajouter un test pour vérifier qu'il s'agit bien du node null.

Chaque élément de la scène est considéré comme un node, que cela soit un personnage ou un objet.

A noter que si l'on met des caractères accentués dans les messages, on a des surprises parce que DAZ utilise l'ASCII américain donc sans accent.

Le test à ajouter à la suite est:

Code:
if (oNode.name !="Null 1"){
MessageBox.critical ("Ce n'est pas null qui est selectionne","rate","OK");
return;
}

Le node en question s'appelle en effet Null 1, même si on le renomme dans l'onglet scene. Je le sais pour avoir ajouté une ligne
print(oNode.name);

Evidemment, il ne faut pas qu'il y ait un autre null créé précédemment dans la hiérarchie ou à vous de faire le test pour savoir comment il s'appelle et changer le script en conséquence,

Le script deveant utile que si on ne bouge la position que sur un axe à la fois, on va commencer par l'axe des X. Il suffira de copier le même script en changeant X par Y ou Z pour avoir 3 scripts, un pour chaque axe.

Il n'y a pas de méthode directe pour connaitre la position X ou Y. On utilise la méthode getWSPos() qui renvoie un DzVec3, tableau à 3 éléments contenant les positions de X, Y et Z. On utilise ensuite une méthode de DzVec3 pour extraire la position qui nous intéresse.

On ajoute donc la déclaration de 2 variables.

Code:
var oPositionNull = new DzVec3();
var nPositionX = undefined;

Ce qui donne le script complet:
Code:
// DAZ Studio version 4.10.0.123 filetype DAZ Script

(function(){
var oNode = Scene.getPrimarySelection();
var oPositionNull = new DzVec3();
var nPositionX = undefined;

if (!oNode){
MessageBox.critical ("rien n'a ete selectionne","Selection null a faire", "OK");
return;
}
print(oNode.name);
if (oNode.name !="Null 1"){
MessageBox.critical ("Ce n'est pas null qui est selectionne","rate","OK");
return;
}
oPositionNull = oNode.getWSPos();
nPositionX = oPositionNull.x;
oPositionNull.x = oPositionNull.x+500;
oNode.setWSPos(oPositionNull);
})();

Chaque fois que vous lancerez le script, la position X de tout ce qui est sous le null se décalera de 500. Il est donc facile de faire d'autres scripts en changeant la valeur, ex 1000 et de remplacer X par Y et par Z.

N'hésitez pas à poser des question si vous en avez

Un fois vos scripts écrits, il suffit de les appeler Xplus500, etc.. et de fabriquer une image qui deviendra cliquable et appellera le script. Les règles sont que l'image est au format png (ça marche peut-être avec du jpg mais je n'ai pas essayé), faire une taille de 91*91 et avoir le même nom que le script (là, Xplus500.png). C'est facile et rapide à faire sous Paint.Net (j'ai vérifié). Ainsi vous pourrez avoir ces scripts comme outils supplémentaires dans DAZ Studio.


Ven 14 Sep 2018, 10:28
Profil
Afficher les messages depuis:  Trier par  
Publier un nouveau sujet Répondre au sujet  [ 70 messages ]  Aller à la page Précédent  1, 2, 3, 4, 5  Suivant


Qui est en ligne ?

Utilisateurs parcourant actuellement ce forum : Aucun utilisateur inscrit et 1 invité


Vous ne pouvez pas publier de nouveaux sujets dans ce forum
Vous ne pouvez pas répondre aux sujets dans ce forum
Vous ne pouvez pas éditer vos messages dans ce forum
Vous ne pouvez pas supprimer vos messages dans ce forum

Rechercher pour:
Sauter vers:  
cron

3D-DIABLOTINE.COM © 2002 - 2018 | Reproduction totale ou partielle interdite



Powered by phpBB © phpBB Group | Translated by phpBB.fr © 2007, 2008 | Designed by Vjacheslav Trushkin