Game Engine-t próbálok készíteni, és nem tudom, hogy melyik séma a jobb?

Ha jól értem a kérdésedet, a válaszom az, hogy nem szabad ezeket kihúzni külön osztályba. Amit leírtál (legalábbis ahogyan értettem), azt anemic domain modelnek hívják és antipattern.

Emellett ott van a Law of Demeter is, miszerint "Talk to your friends, not strangers" - párhuzamban a "Tell, don't ask" elvvel.

Ezek alapján én nem javasolnám, hogy a transzformációkat kiemeld egy Transform osztályba (egyébként már a neve sem jó: helyesen Transformation/-s lehetne talán). Ha valami transzformálható, akkor a transzformálódás a saját felelőssége kell, hogy legyen.

Nézd meg, hogy a vektor osztály implementál-e valamilyen "Transformable" interfészt (helyesen megtervezve illene neki, de tartok tőle, hogy nem lesz kéznél ilyen).

Az összes transzformálható game objectnek (közvetve, vagy közvetlenül) implementálnia kellene ugyanezt az interfészt, és delegálnia a műveletet az összes tartalmazott vektornak.

Quick and dirty példa (értelemszerűen pseudo és ez így még gatyába is rázandó):

interface Transformable {

˙˙˙˙void Rotate(Vector3D origin, double angle);

˙˙˙˙void Scale(double factor);

˙˙˙˙void Translate(Vector3D displacement);

}

class GroupRotation {

˙˙˙˙// mondjuk ez akár lehetne a vektor statikus metódusa is

˙˙˙˙void RotateAll(List<Vector3D> vectors, Vector3D origin, double angle) {

˙˙˙˙˙˙˙˙for (Vector3D current in vectors) {

˙˙˙˙˙˙˙˙˙˙˙˙current.rotate(origin, angle);

˙˙˙˙˙˙˙˙}

˙˙˙˙}

}

// a többi transzformáció szintén zenész...

class MyGameObject : Transformable {

˙˙˙˙Vector3D oneVertex;

˙˙˙˙Vector3D anotherVertex;

˙˙˙˙Vector3D yetAnotherVertex;

˙˙˙˙// egyre inkább úgy érzem, hogy ezek a Vector3D statikus metódusaként jobb helyen lennének

˙˙˙˙GroupRotation rotation;

˙˙˙˙GroupScaling scaling;

˙˙˙˙GroupTranslation;

˙˙˙˙void Rotate(Vector3D origin, double angle) {

˙˙˙˙˙˙˙˙rotation.RotateAll(new Vector3D[] { oneVertex, anotherVertex, yetAnotherVertex }, origin, angle);

˙˙˙˙}

˙˙˙˙void Scale(double factor) {

˙˙˙˙˙˙˙˙rotation.ScaleAll(new Vector3D[] { oneVertex, anotherVertex, yetAnotherVertex }, factor);

˙˙˙˙}

˙˙˙˙void Translate(Vector3D displacement) {

˙˙˙˙˙˙˙˙rotation.TranslateAll(new Vector3D[] { oneVertex, anotherVertex, yetAnotherVertex }, displacement);

˙˙˙˙}

˙˙˙˙// blablabla

}

esetleg (immáron static group transformationnel)

class TotallyGenericTransformableGameObject : Transformable {

˙˙˙˙List<Vector3D> vertices;

˙˙˙˙void Rotate(Vector3D origin, double angle) {

˙˙˙˙˙˙˙˙Vector3D.RotateAll(vertices, origin, angle);

˙˙˙˙}

˙˙˙˙void Scale(double factor) {

˙˙˙˙˙˙˙˙Vector3D.ScaleAll(vertices, factor);

˙˙˙˙}

˙˙˙˙void Translate(Vector3D displacement) {

˙˙˙˙˙˙˙˙Vector3D.TranslateAll(vertices, displacement);

˙˙˙˙}

}

Ha még esetleg nem volt meg, Bob Martinnak van egy "Clean Code: A Handbook of Agile Software Craftsmanship" című eposza, abban egész jól le van írva, mikor merrefelé érdemes tapogatózni.

Ha nem erre vonatkozott a kérdés, akkor mea culpa.