[Solved]Transform... a class? or maybe an struct?

[NinjaFighter]

yesterday I saw that Transform is a Class instead of a Struct. Is this ok? I mean, there are lot of moments where we use a new Transform (for example, on a DisplayObject hierarchy), or store previous transforms, etc. Maybe, this could be much more efficiently if can Transform be an structure. (for example, in XNA, there are Matrix structures, that can be combined (just like SFML's Transform), but if there are structures instead classes, the GarbageCollector don't be affected at all)

[Laurent]

I don't know

[Ceylo]

I didn't understand what would be the advantages of a struct over a class 

[Laurent]

Instances of classes are allocated on the heap and managed by the garbage collector. Structures are more lightweight: they are allocated on the stack and their lifetime is thus managed automatically without bothering the garbage collector.

Another important difference is that structures are handled by value while classes are handled by reference (without a visible difference in the syntax like there is in C++).

(correct me if I'm wrong, I'm not a .Net programmer)

[NinjaFighter]

Yeah =)
Then, I think that could be good to make them a struct instead of a class. There's no reason to be a class... even, various methods return "this", for example "Rotate,Scale or Translate", so.. in a class, this doesn't make sense.

[Ceylo]

Oh, I didn't even notice I was in the C# section . But still good to know, thanks .

[NinjaFighter]

Simply consider that: "There's no good practice, to use new classes during updates or renders."
This should be on the front of the book of CSharp's good practices.
These practices will overload the GarbageCollector in a unnecessary way.

[Laurent]

If you're absolutely sure that I should do the modification, then I'm ready to trust you. Remember, I'm not an experienced .Net programmer at all.

even, various methods return "this", for example "Rotate,Scale or Translate", so.. in a class, this doesn't make sense

May I ask why?

[NinjaFighter]

Because, if you call: "myTransformation.Rotate(45f)" you don't need to know "myTransformation".
The same rule is logic for Structs too... but! in some cases this is specially useful with structs.
For example, if you have a List<Transformation>, or array.

Imagine that:

Code: [Select]

//Rotate 45 all transformations
for(int i = 0; i<mTransList.Count; i++){
   mTransList[i].Rotate(45f);
}

//Note: if Transform is struct, this is like do nothing, otherwise, if is a class, all Transformations will be succesfully rotated.

The correct code to modify all Translation if they are structs, is more short if you returns "this" on all modification functions.

Code: [Select]

//Rotate 45 all STRUCT transformations
for(int i = 0; i<mTransList.Count; i++){
   mTransList[i] = mTransList[i].Rotate(45f);
}

In that case, returns "this" make sense for structs, and not for classes. 

 Anyway, I prefer not returning "this" in these methods and solve by this way:

Code: [Select]

//Rotate 45 all STRUCT transformations
Translation t;
for(int i = 0; i<mTransList.Count; i++){
   t = mTransList[i];
   t.Rotate(45f);
   mTransList[i] = t;
}

And problem solved... never copy unnesesary data (becase return "this" on struct, returns a copy).

[Laurent]

But this is returned so that you can chain calls:

transform.Rotate(45).Translate(10, 20).Scale(2, 2);

So this wouldn't work with structs, because "this" would be returned as a copy and not as a reference? If so, then Transform definitely needs to be a class.

[NinjaFighter]

I figured what you say, but keep in mind that Transform not need to be a class.
You can do:

Code: [Select]

transform = transform.Rotate(45).Translate(10, 20).Scale(2, 2);

That is the way with structs =)

Any way, returning "this" or not, could be great if transform can be structs, and be copied more freely.
For example:

Code: [Select]

//Basic DisplayObjects hierarchy
Transform parentTransform = mySprite.Transform;
Transform childTransform;

foreach(Sprite child in mySpriteChilds){
   childTransform = parentTransform * child.Transform;
   //TODO: Draw child with childTransform
}

If Transform is a class, this practice is much more complicated, and you will loss a lot of versatility.

[Laurent]

If Transform is a class, this practice is much more complicated, and you will loss a lot of versatility.

You're right... And it's true that the "chained calls" syntax can be slightly modified accordingly.

[NinjaFighter]

Please, consider that if you make Transform a struct:
If you return this on modification methods, all data has been copied, but if you no use it... there are a minimal waste of processes. Personally I recomend you to do some classic methods, for example, SetRST, SetSRT, etc

Another thing to remember is (this is very important for classes too), when you contains an array, this array will not be copied with a structure (or a class).
For example:

Code: [Select]

struct Matrix{
   float[] Values{get;set;}
   float NotArrayValue{get;set;}
}

If you copy the Matrix structure... "Values" is like a pointer, so... if you make this:

Code: [Select]

Matrix m1 = new Matrix{ Values = new float[]{ 1f, 2f, 3f }, NotArrayValue = 25f };
Matrix m2 = m1;

m1.Values[0] += 100f;
m1.NotArrayValue += 100f;

Console.Writeline(m2.Values[0]);
Console.Writeline(m2.NotArrayValue);


the result is:

Code: [Select]

101
25

So, is like with arrays, C# manages a pointer to array, so, please consider that if you make Transformations be structures, remember to do a Marshal.Copy (or Clone) with this array, I recommend you to make a "Clone" function. (this is the standar that c# use with arrays)

Instead of write "m2 = m1;" you must write "m2 = m1.Clone();" (only needed if you want to modify internal matrix values.)

[Laurent]

I think it's ok because internally, a Transform has just a pointer to the C API object (like all other classes). There's no managed member.

[NinjaFighter]

Ok.. anyway... do you agree to make Transform a struct instead of a class?