Space conversion code, which is quite concise and elegant

Class eiobject
{
Public:
Eistring name;

Eiobjecttype type;

Eimaterial * material;
Eiuint mtl_id;

Eibound box;
Eifloat width; // delta x
Eifloat height; // Delta y
Eifloat length; // Delta Z
Eifloat radius;

Public:
Eiobject ();
~ Eiobject ();

Virtual eivoid inherit_transform (const eimatrix &);

Virtual eivoid triangulate ();
};
//-------------------------------------------------
Class eipolympus Gon: Public eiobject
{
Public:
STD: vector <eitri> trilist;
STD: vector <eivtx> vtxlist;
STD: vector <eiedge> edgelist;

......

Public:
Eipolympus Gon ();
~ Eipolympus Gon ();

Eivoid inherit_transform (const eimatrix &);
};
//-------------------------------------------------
Class eigroup
{
Public:
Eistring name;

Eivector Pos;
Eivector x_axis, y_axis, z_axis;

STD: List <eigroup> children;
Eigroup * parent;

Eiobject * object;

Public:
Eigroup ();
~ Eigroup ();

Virtual eivoid translate (const eivector &);
Virtual eivoid rotate (const eivector &);
Virtual eivoid Scale (const eivector &);

Virtual eivoid apply_transform ();
Virtual eivoid inherit_transform (const eimatrix &);
};

/*************************************** ***********************************
Transform
**************************************** **********************************/

# Include "stdafx. H"
# Include "head. H"

//-------------------------------------------------------------------------
Eivoid eiobject: inherit_transform (const eimatrix & MX)
{
Return;
}
//-------------------------------------------------------------------------
Eivoid eiobject: Triangulate ()
{
Return;
}
//-------------------------------------------------------------------------
Eivoid eipolympus Gon: inherit_transform (const eimatrix & MX)
{
If (! Vtxlist. Empty ())
{
For (eiint I = 0; I <vtxlist. Size (); I ++)
{
Vtxlist [I]. v_pos = mulvm (vtxlist [I]. Pos, inverse (MX ));
}
}
}
//-------------------------------------------------------------------------
Eivoid eigroup: eigroup ()
{
Pos = newvec ();
X_axis = newvec (1.0, 0.0, 0.0 );
Y_axis = newvec (0.0, 1.0, 0.0 );
Z_axis = newvec (0.0, 0.0, 1.0 );

Parent = NULL;
Object = NULL;
}
//-------------------------------------------------------------------------
Eivoid eigroup: apply_transform ()
{
Eimatrix TM, Rm;

TM = newmx (1.0, 0.0, 0.0, 0.0,
0.0, 1.0, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0,
-Pos. X,-pos. Y,-pos. Z, 1.0 );

Rm = newmx (x_axis.x, y_axis.x, z_axis.x, 0.0,
X_axis.y, y_axis.y, z_axis.y, 0.0,
X_axis.z, y_axis.z, z_axis.z, 0.0,
0.0, 0.0, 0.0, 1.0 );

TM = mulmm (TM, RM );

If (object! = NULL)
{
Object-> inherit_transform (TM );
}

If (! Children. Empty ())
{
For (STD: List <eigroup>: iterator iter = children. Begin (); iter! = Children. End (); ++ ITER)
{
ITER-> inherit_transform (TM );
}
}
}
//-------------------------------------------------------------------------
Eivoid eigroup: inherit_transform (const eimatrix & MX)
{
Eimatrix TM, Rm;

TM = newmx (1.0, 0.0, 0.0, 0.0,
0.0, 1.0, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0,
-Pos. X,-pos. Y,-pos. Z, 1.0 );

Rm = newmx (x_axis.x, y_axis.x, z_axis.x, 0.0,
X_axis.y, y_axis.y, z_axis.y, 0.0,
X_axis.z, y_axis.z, z_axis.z, 0.0,
0.0, 0.0, 0.0, 1.0 );

TM = mulmm (TM, RM );
TM = mulmm (MX, Tm );

If (object! = NULL)
{
Object-> inherit_transform (TM );
}

If (! Children. Empty ())
{
For (STD: List <eigroup>: iterator iter = children. Begin (); iter! = Children. End (); ++ ITER)
{
ITER-> inherit_transform (TM );
}
}
}
//-------------------------------------------------------------------------
Eivoid eigroup: translate (const eivector & VEC)
{
Pos = add (Pos, VEC );
}
//-------------------------------------------------------------------------
Eivoid eigroup: Rotate (const eivector & VEC)
{
If (VEC. y! = 0.0f)
{
X_axis = mulvm (x_axis, roty (VEC. y ));
Y_axis = mulvm (y_axis, roty (VEC. y ));
Z_axis = mulvm (z_axis, roty (VEC. y ));
}

If (VEC. X! = 0.0f)
{
X_axis = mulvm (x_axis, rotx (VEC. X ));
Y_axis = mulvm (y_axis, rotx (VEC. X ));
Z_axis = mulvm (z_axis, rotx (VEC. X ));
}

If (VEC. Z! = 0.0f)
{
X_axis = mulvm (x_axis, Rotz (VEC. z ));
Y_axis = mulvm (y_axis, Rotz (VEC. z ));
Z_axis = mulvm (z_axis, Rotz (VEC. z ));
}
}
//-------------------------------------------------------------------------
Eivoid eigroup: Scale (const eivector & VEC)
{
X_axis = mulvf (x_axis, VEC. X );
Y_axis = mulvf (y_axis, VEC. y );
Z_axis = mulvf (z_axis, VEC. z );
}