A little crazy experiment with MPlug::setValue function

[seila]

hi, all

I try to implement a curious situation to make me more clear with what happen when i use MPlug::setValue in compute function. Here are two custom nodes: NodeA take input from a "inputFloat1" Plug and have a output plug "outputFloat1", and NodeB take input from a "inputFloat2" Plug and have a output plug "outputFloat2", And NodeA's output will connect to NodeB's input, NodeB's output will connect to a object's transformX plug. The special thing i do for NodeB is in its compute function i will set NodeA's inputFloat1 value, and in NodeB's compute function i will do this AFTER data.setClean (ya, i do this intentionally).

Ok, when i implement this in maya and use isDirty to chech each plug's dirty state, the last one is not as my expect.

isDirty -d TestNodeA1.inputFloat1;        -> Clean (as expect) 
isDirty -d TestNodeA1.outputFloat1;      -> Dirty   (as expect)
isDirty -d TestNodeB1.inputFloat2;        -> Dirty   (as expect)
isDirty -d TestNodeB1.outputFloat2;      -> Dirty   (as expect)
isDirty -d transform.translateX;            -> Clean  (why not dirty ??)

as dirty will propagate, i don't sure what's the actual reason that cause the last one is clean? (I know transform.translateX must be Clean because i need to show it in attribute editor\channel box, just this reason maya cease the dirty propagation to last node ?)

Thanks for any suggetion !

[joojaa]

Like I told you maya nodes dont loop, it has nothing to do with connections they just dont loop in most circumstances. If they would haev ythen your maya would have hanged instead.

See most maya nodes look like following pseudocode

If( this plug is accessed){
  getTheValueOfRelevantInput();
  makeRelevantPlugsClean();
}

As a result your code would end up looking like:

If( this plug TX is accessed){
  If( this plug Node2.output is accessed){
    If( this Node1.output is accessed){
       getTheValueOfinputFloat1();
       value=assigned;
    }
    // you are not cleaning your plugs after the fact, 
    //up to you really. You may break maya in the process.
    feedbackSomeStuffToThePlug().
    value=assigned;
  }
  makeTranslateXClean(); //its a input output plug!
}
If( this plug matrixis accessed){
  //for clarity how the other plugs are cleaned
  getRelevantInternalAttribs()
  makeMatrixClean();
}

See last thing the node does is mark itself clean. So if it was just accessed it will BE CLEAN, it will only ask the other nodes ONCE no matter how dirty they get in the process unless they are downsteram it dont matter, with no other exception that a total design fumble.

Which is fortunate as youd end up in a infinite loop otherwise. So any dirtying that happens during the update is going to not go forward. Ist just simply blocked out by most nodes.

SECOND reason.

transofrms are a dag nodes and they draw your screen, they will automatically fire when a dirty propagates tothem IF they are visible and have shapes to draw. In any case asking for the value makes it implicitly clean no matter how much you loop. If you want to loop your node needs to ask the value in a loop.

[seila]

Thanks your reply, Joojaa. I have some detail question about the pseudocode you provide:

If(this plug is accessed){                  <--- the plug you mention only limited to output plug or all possible in&out plug ?
  getTheValueOfRelevantInput();
  makeRelevantPlugsClean();            
  <--- the relevant plug not only defined by attributeAffect, but also plugs that has connections with accessed plug ?
}

To simply the situation this time i use only two node for testing(The same as before, just free you from review the post):
NodeA  with  "inputFloat1" as Input.  ""OutputFloat1" as Output
NodeB  with  "inputFloat2" as Input.  ""OutputFloat2" as Output
In NodeB compute it will set  NodeA's inputFloat1

1. First I connect NodeA.OutputFloat1 to NodeB.inputFloat2
2. Use MEL Command : getAttr NodeA.OutputFloat1
    NodeA's compute Called 
3. Use MEL Command : getAttr NodeB.OutputFloat2
    NodeB's compute Called

Until now everything works well. However if I add one more translate after NodeB's OutputFloat2, connect it with TranslateX

1. First I connect NodeA.OutputFloat1 to NodeB.inputFloat2
2. Then connect NodeB.outputFloat2 to Transform.tx
    NodeA's compute Called     
    NodeB's compute Called 
3. Use MEL Command : setAttr NodeA.InputFloat1
4. Use MEL Command : getAttr NodeA.OutputFloat1
    NodeA's compute Called 
5. Use MEL Command : getAttr NodeB.OutputFloat2
    NodeB's compute Called     (when this called, NodeA's input is set and dirty propagate, I sure this one)   
    NodeA's compute Called     (Need to clean relevant plug, but now NodeB's output become dirty, so contine call NodeA ?)    
    NodeB's compute Called     (Inherit operation from above)

The last step is unexpect to me. I think only NodeB's compute will be called once. I am not sure this is what you mean  "make relevant plug clean" so the last two compute call to NodeA and NodeB is mean to make Transform.tx
 plug clean (and it should response for cleaning plugs connecting from this plug)? Because the last operation i do is only query NodeB's output Attribute and if i not connect transform node after NodeB the last two compute call won't happen. Any thing wrong about my conclusion ?

[seila]

Addition question please ~

In NodeB's compute i monitor the NodeB's input & output clean state

stat = setNodeAInputPlug(3.0);     
// Here NodeB's input and output's isClean() is dirty, that's ok because i set NodeA's input and dirty propagate
MDataHandle inputData = data.inputValue(inputFloat2, &stat);
// But Here NodeB's input become clean and output still dirty, what's the magic in data.inputValue ? I don't see NodeA's compute is called ?

Sorry have so many questions, I still struggle with these detail and want to get more clear about this issue. Thanks your patient again !!

[joojaa]

Most nodes are programmed one way doesnt mean your nodes are.

Are you still doing the painting thing? Dont do it as a node do it as a context, thats what your supposed to do since you ARE using a context you jst want to extend it.

the plug you mention only limited to output plug or all possible in&out plug ?

Most nodes are programmed in a way thet has if clause separately for each different output. They act as if the ndoe would have separate nodes.

the relevant plug not only defined by attributeAffect, but also plugs that has connections with accessed plug ?

Has nothing to do with attribute affects. The programmer explicitly states that the nodoe is clean at the end of their update. As tho what at is is up to the node developper. Usually its just what they refreshed. Nothings is automatic this is code.

The idea is that you follow the design or suffer and at the end of the day follow the design.

what's the magic in data.inputValue ?

Whhen you ask for a value your end is clean, you just asked for it its clean. The data as far as your node is concerned is clean at this point.

?) NodeB's compute Called     (Inherit operation from above)

Ah but seee is the trasform connected to something thats visible in the viewports?

[seila]

Thanks for your detailed reply. Now i just do some testing to rebuild the problems that i encountered before. I think these concept should be very important and i've to make them as clear as possible to construct more robust node in future.