Isclean Command

[frankr]

Hello.

I'm programming a lightNode which has, beneath others, the output attributes "WorldToLightPerspectiveMatrix" and "PointFromLightPerspective".
The second one is dependant of the Render Attribute "pointWorld" and of the first output, the WorldToLightPerspectiveMatrix.
To not recalculate the Matrix for every call of the compute function of "PointFromLightPerspective" I want to check the dirty state of "WorldToLightPerspectiveMatrix" to decide if I have to recalculate it or not. But "data.isClean(WorldToLightPerspectiveMatrix)" does not return what I expected. It always returns true.
I even tried...

MStatus LightNode::compute( const MPlug& plug, MDataBlock& data )
{
bool bIsClean = data.isClean(plug);
MGlobal::displayInfo( MString ("bIsClean: ") + bIsClean + "\n");
}

which returns "bIsClean: 1". As the compute function has been called because the plug is set dirty, I think there is something going wrong... What is the mistake? What's the workaround?

[joojaa]

its clean because the compute was called!

[frankr]

Why than calling data.setClean(plug) at the END of the compute function, when all plugs of the node ARE set clean automatically at the BEGINNING of it?
Furthermore I thought I could focus on the requested plug in my compute function by making a condition test like "if (plug == PointFromLightPerspective)" while the other plugs remain dirty. But if ALL plugs of the node are set clean, I cannot do so, right?
I'm just a little bit confused about it... Am I forced to always recalculate all my output-attributes if any of them is to be computed?

[joojaa]

because the act of changing the value makes plugs dirty*! You only set your outputs clean after you have changed them.

BUT thing is because the input is not computed by your node it then DOES and in general MAY not acces those. In a evaluation the inputs are allways asumed clean, if they arent then theres some BUG in the downstream node.

Offourse your outputs never get marked dirty uinless your plug says its dependent on input. With a attributeAffects call. But thing is its a bit pointless since you should be monitring tha change of yoru downstream nodes not their affects.

• And the idea with compute is to meake the node clean, so theres no point in leaving it diry or maya will call it again and again and again

[joojaa]

While its perfectly valid to selectivelycompute parts of the node its usualy a sign of bad design (or here atleast allmost inevitably). Since it implies Your in all actuality wanting to design 2 different nodes.

Edity:

Aslo note dirty propagation happens down up so just because your feed in node is dirty does not mena your nodes plug will be affected, it will not, only downstream nodes ever mark things in your node dirty. however nothing says you cant have a loop.

Edity 2: also you can ask wether or not the contxt is inside maya or in rendering, this will make it possible for you to KNOW that you dont need to update the matrix, because for all samples takenn it will be the same.

[frankr]

I had to think a time about your post, Joojaa. Thank you for it first.
Of course there are some Inputs which affect the Matrix and the Point. Say these are "InPosition" and "InRotation" of the Light. If InPosition or InRotation changes, the MatrixOut and the PointOut are set dirty. But "pointWorld" is one attribute more, that only affects PointOut but not the matrix.
The complete calculation for the PointOut is pointWorld * MatrixOut, which I have to calculate for every samplePoint. I want to reuse the MatrixOut and only recalculate it once after a change of "InPosition" or "InRotation".
So, when the compute function is called to get the PointOut, and it is set dirty only because of a change of the pointWorld Input, I don't need to recalculate the matrix, but could take the value hold by the MatrixOut plug because it is still correct. To know if it is, I thought I could use the isClean function.
I did not initialize any relationship between the MatrixOut Attribute and the PointOut Attribute. They are both outputs. I'm not sure if it's legal to reuse a value hold by an output in this way.
But in the end, the attribute of which I try to get the dirty state is an output of the node and the isClean function always tells me, my outputs are clean.

[joojaa]

well in this case its simple because you will need to cache the values yourself anyway inorder to reuse them you can just compare them?!?! Tough is clean should work in your case i concour.

But still sounds like you want a dag node light pair as opposed to one node that hnadles both. BEcause to be truuth the dag nodes provide you with the compouted values you need.

[frankr]

OK, it works by comparing the Input Values with some stored variables within the node. The problem is, that there are some more Inputs affecting the matrix than I mentioned earlier. So comparing them all is just as time consuming as recalculating the matrix for every samplePoint.

And I dont want to hold the matrix within an extra node in order to keep the DG clean for the user.

So I come back to my isClean function question. I created a node that does nothing more than checking the dirty state of one output (outB) during the computation of the other output (outA). Both are set to be affected by the input. The isClean function now always returns zero. So it always tell me my node is dirty even if it's not, what is just the opposite of the result before. What leads me to the conclusion, that I simply just don't understand the syntax of the command...

Could you Joojaa, or anyone else, look over these lines, especially line 59, and tell me what's wrong?

01 #include #include
02 #include #include
03 #include #include
04 #include #include
05 #include
06 class isCleanCheckNode : public MPxNode{
07 public:
08 isCleanCheckNode();
09 virtual ~isCleanCheckNode();
10 virtual MStatus compute( const MPlug&, MDataBlock&);
11 static void* creator();
12 static MStatus initialize();
13 static MTypeId id;
14 private:
15 static MObject aInput;
16 static MObject aOutA;
17 static MObject aOutB;
18 };
19 MTypeId isCleanCheckNode::id(0x0000000a);
20 MObject isCleanCheckNode::aInput;
21 MObject isCleanCheckNode::aOutA;
22 MObject isCleanCheckNode::aOutB;
23 isCleanCheckNode::isCleanCheckNode() {}
24 isCleanCheckNode::~isCleanCheckNode() {}
25 void* isCleanCheckNode::creator(){ return new isCleanCheckNode; }
26 MStatus isCleanCheckNode::initialize()
27 {
28 MFnNumericAttribute numFn;
29
30 aInput = numFn.create("input", "in", MFnNumericData::kInt );
31 numFn.setDefault(2);
32
33 aOutA = numFn.create("outA", "ota", MFnNumericData::kInt);
34 numFn.setWritable(false);
35 numFn.setDefault(5);
36
37 aOutB = numFn.create("outB", "otb", MFnNumericData::kInt);
38 numFn.setWritable(false);
39 numFn.setDefault(5);
40
41 addAttribute(aInput);
42 addAttribute(aOutA);
43 addAttribute(aOutB);
44
45 attributeAffects(aInput,aOutA);
46 attributeAffects(aInput,aOutB);
47
48 return MS::kSuccess;
49 }
50
51 MStatus isCleanCheckNode::compute( const MPlug& plug, MDataBlock& data )
52 {
53 MStatus stat;
54
55 if (plug == aOutA)
56 {
57 MDataHandle dhOutA = data.outputValue( aOutA );
58 int& outA = dhOutA.asInt();
59 outA = data.isClean( aOutB, &stat);
60 data.setClean(plug);
61 return MS::kSuccess;
62 }
63 else if (plug == aOutB)
64 {
65 MDataHandle dhOutB = data.outputValue( aOutB );
66 int& outB = dhOutB.asInt();
67 outB = data.inputValue( aInput ).asInt();
68 data.setClean(plug);
69 return MS::kSuccess;
70 }
71 else
72 return MS::kUnknownParameter;
73 }
74 MStatus initializePlugin( MObject obj ){
75 MStatus stat;
76 MFnPlugin plugin( obj, "FrankR", "1.0", "Any");
77 stat = plugin.registerNode("IsCleanCheck", isCleanCheckNode::id, isCleanCheckNode::creator, isCleanCheckNode::initialize );
78 return stat;
79 }
80 MStatus uninitializePlugin( MObject obj){
81 MStatus stat;
82 MFnPlugin plugin( obj );
83 stat = plugin.deregisterNode( isCleanCheckNode::id );
84 return stat;
85 }

Thank you...

[joojaa]

QUOTE
MStatus MPxNode:: compute ( const MPlug & plug, MDataBlock & block )

Description

This method should be overridden in user defined nodes.

Recompute the given output based on the nodes inputs. The plug represents the data value that needs to be recomputed, and the data block holds the storage for all of the node's attributes.

The MDataBlock will provide smart handles for reading and writing this node's attribute values. Only these values should be used when performing computations.

When evaluating the dependency graph, Maya will first call the compute method for this node. If the plug that is provided to the compute indicates that that the attribute was defined by the Maya parent node, the compute method should return MS::kUnknownParameter. When this occurs, Maya will call the internal Maya node from which the user-defined node is derived to compute the plug's value.

This means that a user defined node does not need to be concerned with computing inherited output attributes. However, if desired, these can be safely recomputed by this method to change the behaviour of the node.

this menas the costruct

55 if (plug == aOutA)
56 {
57 MDataHandle dhOutA = data.outputValue( aOutA );
58 int& outA = dhOutA.asInt();
59 outA = data.isClean( aOutB, &stat);
60 data.setClean(plug);
61 return MS::kSuccess;
62 }

is run only if AOut is dirty. each dirty is called separately in compute. So thus Auout is dirty. because thisis the aout eveluation block. adn outside this it may or may not be! THis isa also why its clean when it comes to the next iteration of the plug so if you try to acces this nodes cleanliness for a next call however. If you want to evaluete the Other construct you shoudl do so within this block! Or alternatively defining a overidden MPxNode:: setDependentsDirty, also if you mark the values storable you dont need to store them maya does so automaticaly for you, so you can use the cached values. read more about the mpxnode reference.

The compute is allways called in a loop thats external to your procedure. And thus things that are defined as comming after aOutA will allways se aOutA clean! (hence because compute was called).

[frankr]

Once more thank you very much to Joojaa for the extensive help.

My output names seam to be a little bit confusing. In the "if (plug == aOutA)" block I do NOT check the dirty state of aOutA, but of aOutB !
I have read once more the MPxNode, the MDataHandle and the MDataBlock chapters and I am really sure, the only thing that can be wrong is line 59, where the documentation says:

bool MDataBlock:: isClean ( const MObject & attribute, MStatus * ReturnStatus )

Description:
Queries the dependency graph to see whether the given attribute is clean.

Arguments:
attribute the attribute that is to be query

Return Value:
result boolean code, true if the attribute is clean, false otherwise.

Status Codes:
MS::kSuccess operation successful.
MS::kInvalidParameter The attribute is invalid.

---

The documentation line marked red in Joojaas last reply quote that MPlug& plug always holds only ONE attribute. The attribute currently computed. It is called, because it has been requested from within maya and had the dirty bit set.
If the value of the dirty attribute is not requested, it is not passed as plug to the compute function and will nerver be cleaned. Right?!

Here is what I did after loading the plugin in maya:

createNode IsCleanCheck;
// what returns me an instance of my node named
// IsCleanCheck1

setAttr IsCleanCheck1.input 8;
// what makes me shure that outA and outB are set dirty,
// because they are affected by the input

getAttr IsCleanCheck1.outB;
// it returns the input, 8, what shows me that the compute has been called
// correctly with plug == aOutB and outB is clean now.
// Because of my condition test "if (plug == aOutA)" has not been true until now,
// outA is still dirty.

getAttr IsCleanCheck1.outA
// the compute function is called with plug == aOutA.
// "data.isClean( aOutB, &stat);" should pass 1 to outA because outB must
// be always clean because I didn't change the input.
// But it returns 0.
// ( And by the way: if you ask for outA first after changing input
// it returns 0, too. But in this case it is the expected result of course... )

---

I only see three possibilities:
1. outA has been recomputed before it was called. But in any Maya Documentation you can read that Maya does not so.
2. The IsCleanCheck function does not work correctly (say: there is a bug).
3. "outA = data.isClean( aOutB, &stat);" is not the way the syntax works.

[joojaa]

No this ones clear! Its more because its extremely hard to ask maya to not force total recompute, from users actions.

QUOTE(FrankR @ 02/21/06, 12:08 PM) [snapback]228822[/snapback]
Once more thank you very much to Joojaa for the extensive help.

My output names seam to be a little bit confusing. In the "if (plug == aOutA)" block I do NOT check the dirty state of aOutA, but of aOutB !
I have read once more the MPxNode, the MDataHandle and the MDataBlock chapters and I am really sure, the only thing that can be wrong is line 59, where the documentation says:

Its a loop thing seboth A and B get marked dirty from the same thing. Now because maya proceed t fix theese things in same order in A -> B order Visualizzation:

step 1 [in] [otA] [otB]

step 2 [in *updates] -> [otA dirty] [otB dirty]

step 3 substep 1 [in] [otA updates] [otB dirty]
(durng A:s block B is dirty)
step 3 substep 2 [in] [otA] [otB updates]

NOTE compute gets called 2 times each time only one of the if blocks get computed. Also not the order is allways A then B.

Now because they both dirty fom the same thing then there will before B. However it is possible that if you make a chain of maya nodes were B is not connected further and if you do not indspect the node with getAttr (since getAttr forces recompute, often of the whole node), or inspect it in the gui wich forces update (thus be is dirty)! Then its possible A gets dirty while B is not, problem is that you can not usualy know this inside A block because the act of running code in A with will make B dirty, an al but the rarest cases!

Theres however a way you can make B report clean inside a A and that is to make a connection into in a connection out of B taht affects something that draws into the ogl (like a locators x axis) Now make sure A is not yet connected!!!!! change in value, now connect otA to something esle that affects ogl refresh, NOW and ONLY now would you get a report B is clean. However a connection might force full recompute. So heres another way to test hide the A:s connectee change in value (not to ot spoinl the fun thsi in vlue must be in another node form your computer), se B update. then UNHIDE A:s affectee

As you can se it is indeed quite hard to get A t reprot B clean! Much harder then you might think.

PS. not ethe idea o dirty messaging is not foolproof. If i mark a value dirty thenit will get recomputed even if my originaal value has not changed.

[frankr]

I'm so sorry. Forget my last post. By making some changes in the code I had inserted an mistake and I've repeated the test now. It is working the way Joojaa provided. It even works with getAttr.
Ok, Joojaa, thank you very much for the help.

[joojaa]

Yeh sometimes getattr dont cascade... i dont know isf thers some very big interoperqational things in some of the nodes. I supect they do the samekind of cheking as you do-