void setupTransforms_MainColor(void)
{
LoadIdentity(modelView);
LookAt(modelView, eyeposition[0],
eyeposition[1],
eyeposition[2],
lookAt[0],
lookAt[1],
lookAt[2],
upVector[0],
upVector[1],
upVector[2]);
Rotate(modelView, 0.0, 1.0, 0.0, turnTable);
Rotate(modelView, 1.0, 0.0, 0.0, audioRotation[3]);
//--------------------------------------------------------------------------------------
LoadIdentity(viewMatrix);
AssignMatrix(viewMatrix, modelView);
InvertMatrix(viewMatrix, viewMatrix);
//--------------------------------------------------------------------------------------
Translate(modelView, moveSet[0] , moveSet[1] , moveSet[2] );
Rotate(modelView, 1.0, 0.0, 0.0, rotateModelWithLeftMouse[0]);
Rotate(modelView, 0.0, 1.0, 0.0, rotateModelWithLeftMouse[1]);
}
//=======================================================================================================================
//============================================================================================================================
void setupTransforms_MainColor(void)
{
LoadIdentity(viewMatrix);
Translate(viewMatrix, eyePosition[0],
eyePosition[1],
eyePosition[2]);
LoadIdentity(viewRotateMatrix);
//-----------------------------
Rotate(viewRotateMatrix, 1.0, 0.0, 0.0, rotateModelWithMiddleMouse[0] -60.0);//-60.0 - 00.0
Rotate(viewRotateMatrix, 0.0, 0.0, 1.0, -rotateModelWithMiddleMouse[1]);
}
//////////////////////////////////////////////////////////////////////////
// Public
//////////////////////////////////////////////////////////////////////////
MatrixStack::MatrixStack()
: m_isPerspectiveInit(false),
m_isOrthoInit(false),
m_currentProjectionMode(CL_PROJECTION)
{
LoadIdentity();
}
void setupTransforms_Shadows(void)
{
LoadIdentity(LightModelViewMatrix);
LookAt(LightModelViewMatrix, eyeposition[0] + eyeposition_SHADOW[0] - eyeposition[0] * adjustLookAtMove[0],
eyeposition[1] + eyeposition_SHADOW[1] - eyeposition[1] * adjustLookAtMove[1],
eyeposition[2] + eyeposition_SHADOW[2] - eyeposition[2] * adjustLookAtMove[2],
lookAt[0] + lookAt_SHADOW[0],
lookAt[1] + lookAt_SHADOW[1],
lookAt[2] + lookAt_SHADOW[2],
upVector[0],
upVector[1],
upVector[2]);
Rotate(LightModelViewMatrix, 0.0, 1.0, 0.0, turnTable);
Rotate(modelView, 1.0, 0.0, 0.0, audioRotation[3]);
//--------------------------------------------------------------------------------------
AssignMatrix(modelViewShadow, LightModelViewMatrix);
//--------------------------------------------------------------------------------------
Translate(LightModelViewMatrix, moveSet[0] + moveShadow[0] , moveSet[1] + moveShadow[1] , moveSet[2] + moveShadow[2]);
Rotate(LightModelViewMatrix, 1.0, 0.0, 0.0, rotateModelWithLeftMouse[0]);
Rotate(LightModelViewMatrix, 0.0, 1.0, 0.0, rotateModelWithLeftMouse[1]);
}
void Matrix44::operator =(Vector3 v)
{
LoadIdentity();
m[0][3] = v.x;
m[1][3] = v.y;
m[2][3] = v.z;
}
//! generalized inverse for non-orthonormal 4x4 matrices
//! A^-1 = (1 / det(A)) (C^T)_{ij} = (1 / det(A)) C_{ji}
bool CMatrix44f::InvertInPlace()
{
float cofac[4][4];
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
cofac[i][j] = CalculateCofactor(md, i, j);
}
}
const float det =
(md[0][0] * cofac[0][0]) +
(md[0][1] * cofac[0][1]) +
(md[0][2] * cofac[0][2]) +
(md[0][3] * cofac[0][3]);
if (det == 0.0f) {
//! singular matrix, set to identity?
LoadIdentity();
return false;
}
const float scale = 1.0f / det;
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
//! (adjoint / determinant)
//! (note the transposition in 'cofac')
md[i][j] = cofac[j][i] * scale;
}
}
return true;
}
void Matrix44::Translate(Matrix44 &mtx, const float vec[3])
{
LoadIdentity(mtx);
mtx.data[3] = vec[0];
mtx.data[7] = vec[1];
mtx.data[11] = vec[2];
}
/**
* \param type bit 0: render OSD, bit 1: render EOSD
*/
static void do_render_osd(int type) {
if (((type & 1) && osdtexCnt > 0) || ((type & 2) && eosdDispList)) {
// set special rendering parameters
if (!scaled_osd) {
MatrixMode(GL_PROJECTION);
PushMatrix();
LoadIdentity();
Ortho(0, vo_dwidth, vo_dheight, 0, -1, 1);
}
Enable(GL_BLEND);
if ((type & 2) && eosdDispList) {
BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
CallList(eosdDispList);
}
if ((type & 1) && osdtexCnt > 0) {
Color4ub((osd_color >> 16) & 0xff, (osd_color >> 8) & 0xff, osd_color & 0xff, 0xff - (osd_color >> 24));
// draw OSD
#ifndef FAST_OSD
BlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_ALPHA);
CallLists(osdtexCnt, GL_UNSIGNED_INT, osdaDispList);
#endif
BlendFunc(GL_SRC_ALPHA, GL_ONE);
CallLists(osdtexCnt, GL_UNSIGNED_INT, osdDispList);
}
// set rendering parameters back to defaults
Disable(GL_BLEND);
if (!scaled_osd)
PopMatrix();
BindTexture(gl_target, 0);
}
void xdMatrix4f::SetTranslate(float tx, float ty, float tz)
{
LoadIdentity();
data[12] = tx;
data[13] = ty;
data[14] = tz;
}
void CBaseShader::SetFixedFunctionTextureScale( MaterialMatrixMode_t textureTransform, int scaleVar )
{
Assert( !IsSnapshotting() );
// handle scrolling of base texture
Vector2D vScale;
s_ppParams[scaleVar]->GetVecValue( vScale.Base(), 2 );
if( vScale[0] != 0.0f || vScale[1] != 0.0f )
{
s_pShaderAPI->MatrixMode( textureTransform );
// only do the upper 3x3 since this is a 2D matrix
float mat[16];
mat[0] = vScale[0]; mat[1] = 0.0f; mat[2] = 0.0f;
mat[4] = 0.0f; mat[5] = vScale[1]; mat[6] = 0.0f;
mat[8] = 0.0f; mat[9] = 0.0f; mat[10] = 1.0f;
// Better set the stuff we don't set with some sort of value!
mat[3] = mat[7] = mat[11] = 0;
mat[12] = mat[13] = mat[14] = 0;
mat[15] = 1;
s_pShaderAPI->LoadMatrix( mat );
}
else
{
LoadIdentity( textureTransform );
}
}
CMatrix44f::CMatrix44f(const float& rotX, const float& rotY, const float& rotZ)
{
LoadIdentity();
RotateX(rotX);
RotateY(rotY);
RotateZ(rotZ);
}
void CBaseShader::SetFixedFunctionTextureTransform( MaterialMatrixMode_t textureTransform, int transformVar )
{
Assert( !IsSnapshotting() );
IMaterialVar* pTransformationVar = s_ppParams[transformVar];
if (pTransformationVar && (pTransformationVar->GetType() == MATERIAL_VAR_TYPE_MATRIX))
{
s_pShaderAPI->MatrixMode( textureTransform );
const VMatrix &transformation = pTransformationVar->GetMatrixValue();
// only do the upper 3x3 since this is a 2D matrix
float mat[16];
mat[0] = transformation[0][0]; mat[1] = transformation[1][0]; mat[2] = transformation[3][0];
mat[4] = transformation[0][1]; mat[5] = transformation[1][1]; mat[6] = transformation[3][1];
mat[8] = transformation[0][3]; mat[9] = transformation[1][3]; mat[10] = transformation[3][3];
// Better set the stuff we don't set with some sort of value!
mat[3] = mat[7] = mat[11] = 0;
mat[12] = mat[13] = mat[14] = 0;
mat[15] = 1;
s_pShaderAPI->LoadMatrix( mat );
}
else
{
LoadIdentity( textureTransform );
}
}
void xdMatrix4f::SetScale(float kx, float ky, float kz, float kw/* =0 */)
{
LoadIdentity();
data[0] = kx;
data[5] = ky;
data[10] = kz;
data[15] = kw;
}
void xdMatrix3f::SetScale(float kx, float ky, float kz)
{
LoadIdentity();
data[0] = kx;
data[4] = ky;
data[8] = kz;
}
void ColorRenderMatrixFunctions(void)
{
MultiplyMatrix(modelViewMatrix, viewMatrix, modelWorldMatrix);
//------------------------------------------------------------
LoadIdentity(tempMatrix_A);
MultiplyMatrix(tempMatrix_A, viewMatrix, viewRotateMatrix);
//---------------------------------------------------------------------
MultiplyMatrix(moveSet_x_modelWorldMatrix, moveSetMatrix, modelWorldMatrix);
//---------------------------------------------------------------------
LoadIdentity(tempMatrix_B);
MultiplyMatrix(tempMatrix_B, shadowTextureMatrix, moveSet_x_modelWorldMatrix);
//---------------------------------------------------------------------
LoadIdentity(tempMatrix_C);
MultiplyMatrix(tempMatrix_C, projectionMatrix, tempMatrix_A);
//---------------------------------------------------------------------
LoadIdentity(tempMatrix_D);
MultiplyMatrix(tempMatrix_D, tempMatrix_C, moveSet_x_modelWorldMatrix);
//----------------------------------------------------------------------------------------------------------
LoadIdentity(shadowTextureMatrix);
MultiplyMatrix(shadowTextureMatrix, shadowBiasMatrix, shadowProjectionMatrix);
MultiplyMatrix(shadowTextureMatrix, shadowTextureMatrix, shadowViewMatrix); //_MULTIPLY THESE TO A TEMP MATRIX TO AVOID ROUND OFF ERRORS //USES MORE CODE WITH INCREASED PRECISION
//----------------------------------------------------------------------------------------------------------
LoadIdentity(tempMatrix_E);
MultiplyMatrix(tempMatrix_E, viewRotateMatrix, modelRotationMatrix);
//----------------------------------------------------------------------------------------------------------
LoadIdentity(modelRotationINVmatrix);
InvertMatrix(modelRotationINVmatrix, tempMatrix_E);
//----------------------------------------------------------------------------------------------------------
}
bool
SipccSdpAttributeList::Load(sdp_t* sdp, uint16_t level,
SdpErrorHolder& errorHolder)
{
LoadSimpleStrings(sdp, level, errorHolder);
LoadSimpleNumbers(sdp, level, errorHolder);
LoadFlags(sdp, level);
LoadDirection(sdp, level, errorHolder);
if (AtSessionLevel()) {
if (!LoadGroups(sdp, level, errorHolder)) {
return false;
}
if (!LoadMsidSemantics(sdp, level, errorHolder)) {
return false;
}
LoadIdentity(sdp, level);
} else {
sdp_media_e mtype = sdp_get_media_type(sdp, level);
if (mtype == SDP_MEDIA_APPLICATION) {
if (!LoadSctpmap(sdp, level, errorHolder)) {
return false;
}
} else {
if (!LoadRtpmap(sdp, level, errorHolder)) {
return false;
}
}
LoadCandidate(sdp, level);
LoadFmtp(sdp, level);
LoadMsids(sdp, level, errorHolder);
LoadRtcpFb(sdp, level, errorHolder);
LoadRtcp(sdp, level, errorHolder);
LoadSsrc(sdp, level);
if (!LoadImageattr(sdp, level, errorHolder)) {
return false;
}
if (!LoadSimulcast(sdp, level, errorHolder)) {
return false;
}
if (!LoadRid(sdp, level, errorHolder)) {
return false;
}
}
LoadIceAttributes(sdp, level);
if (!LoadFingerprint(sdp, level, errorHolder)) {
return false;
}
LoadSetup(sdp, level);
LoadExtmap(sdp, level, errorHolder);
return true;
}
//===============================================================================================================
//===============================================================================================================
void setupTransforms_MainColor(void)
{
LoadIdentity(view);
Translate(view, eyePosition[0],
eyePosition[1],
eyePosition[2]);
//===========================================
LoadIdentity(invertView);
InvertMatrix(invertView, view);
//=============================
LoadIdentity(view_rotate);
//--------------------
Rotate(view_rotate, 1.0, 0.0, 0.0, rotateModelWithMiddleMouse[0]);
Rotate(view_rotate, 0.0, 1.0, 0.0, rotateModelWithMiddleMouse[1]);
}
ofxObject::ofxObject(){
id = numObjects++;
//transformation matrix
matrix = (float*)malloc(sizeof(float)*16);
LoadIdentity(matrix);
//matrixTmp = (float*)malloc(sizeof(float)*16);
localMatrix = (float*)malloc(sizeof(float)*16);
LoadIdentity(localMatrix);
material = new ofxObjectMaterial();
drawMaterial = new ofxObjectMaterial();
inheritColor = false; // SK Added color inheritence defaults to false
//rotationMatrix = NULL;
//rotationMatrixTmp = NULL;
xyzRot.set(0., 0., 0.);
xyz.set(0.,0.,0.);
scale.set(1.,1.,1.);
isLit = true;
hasSpecialTransparency = false; //this is used for objects with transparent textures
renderOntop = false;
shown = true;
renderDirty = true;
matrixDirty = true;
localMatrixDirty = true;
displayList = glGenLists(1);
displayListFlag = false;
isSortedObject = false;
sortedObjectsWindowZ = 0;
timePrev = ofGetElapsedTimef(); //ofGetSystemTime()/1000.0f;
timeElapsed = 0;
//shader info
shader = new ofShader();
shaderEnabled = true; // Enabled by default
}
int CMarkerDisplay::SetupWebCam(const char* cparam_names, char* vconfs)
{
ARTCparam.xsize = 640;
ARTCparam.ysize = 480;
LoadIdentity(projectionMat);
projectionMat[0] = (double) ARTCparam.ysize / (double) ARTCparam.xsize;
return(1);
}
void Translate(double *result, double x, double y, double z){
double matrix[16], resultMatrix[16];
LoadIdentity(matrix);
matrix[12] = x;
matrix[13] = y;
matrix[14] = z;
MultiplyMatrices(resultMatrix, result, matrix);
memcpy(result, resultMatrix, 16*sizeof(double));
}
CMatrixGLES::CMatrixGLES()
{
for (int i=0; i<(int)MM_MATRIXSIZE; i++)
{
m_matrices[i].push_back(new GLfloat[16]);
MatrixMode((EMATRIXMODE)i);
LoadIdentity();
}
m_matrixMode = (EMATRIXMODE)-1;
m_pMatrix = NULL;
}
//===============================================================================================================
void setupTransforms_Shadows(void)
{
LoadIdentity(light_view);
//-------------------------------------------------
Translate(light_view, eyePosition[0] + eyePosition_SHADOW[0],
eyePosition[1] + eyePosition_SHADOW[1],
eyePosition[2] + eyePosition_SHADOW[2]);
//LookAt(light_View, eyePosition_SHADOW[0] + eyePosition[0] * scaleViewMovement[0], eyePosition_SHADOW[1], eyePosition_SHADOW[2] , 0 + eyePosition[0] * scaleViewMovement[0], 0, 0, 0.0f, 1.0f, 0.0f);
}
//============================================================================================================================
void setupTransforms_Shadows(void)
{
LoadIdentity(shadowViewMatrix);
//-------------------------------------------------
/* Translate(shadowViewMatrix, eyePosition_SHADOW[0],
eyePosition_SHADOW[1],
eyePosition_SHADOW[2]);
*/
LookAt(shadowViewMatrix, eyePosition_SHADOW[0], eyePosition_SHADOW[1], eyePosition_SHADOW[2] , 0, 0, 0, 0.0f, 1.0f, 0.0f);
}
static void resize(int x,int y){
mp_msg(MSGT_VO, MSGL_V, "[gl] Resize: %dx%d\n",x,y);
if (WinID >= 0) {
int top = 0, left = 0, w = x, h = y;
geometry(&top, &left, &w, &h, vo_screenwidth, vo_screenheight);
Viewport(top, left, w, h);
} else
Viewport( 0, 0, x, y );
MatrixMode(GL_PROJECTION);
LoadIdentity();
ass_border_x = ass_border_y = 0;
if (aspect_scaling() && use_aspect) {
int new_w, new_h;
GLdouble scale_x, scale_y;
aspect(&new_w, &new_h, A_WINZOOM);
panscan_calc_windowed();
new_w += vo_panscan_x;
new_h += vo_panscan_y;
scale_x = (GLdouble)new_w / (GLdouble)x;
scale_y = (GLdouble)new_h / (GLdouble)y;
Scaled(scale_x, scale_y, 1);
ass_border_x = (vo_dwidth - new_w) / 2;
ass_border_y = (vo_dheight - new_h) / 2;
}
Ortho(0, image_width, image_height, 0, -1,1);
MatrixMode(GL_MODELVIEW);
LoadIdentity();
if (!scaled_osd) {
#ifdef CONFIG_FREETYPE
// adjust font size to display size
force_load_font = 1;
#endif
vo_osd_changed(OSDTYPE_OSD);
}
Clear(GL_COLOR_BUFFER_BIT);
redraw();
}
//===============================================================================================================
//===============================================================================================================
void setupTransforms_MainColor(void)
{
LoadIdentity(view);
LookAt(view, eyePosition[0] - moveModelWithMiddleMouse[0],
eyePosition[1] - moveModelWithMiddleMouse[1],
eyePosition[2] - zoomModelWithMiddleMouse ,
0.0 - moveModelWithMiddleMouse[0] ,
0.0 - moveModelWithMiddleMouse[1] ,
0.0 ,
0.0, 1.0, 0.0);
/*
Translate(view, eyePosition[0] + moveModelWithMiddleMouse[0]
eyePosition[1] + moveModelWithMiddleMouse[1],
eyePosition[2] + zoomModelWithMiddleMouse);
*/
LoadIdentity(view_rotate);
//--------------------
Rotate(view, 1.0, 0.0, 0.0, rotateModelWithMiddleMouse[0]);
Rotate(view, 0.0, 1.0, 0.0, rotateModelWithMiddleMouse[1]);
Translate(view_rotate, moveScenePivot[0],
moveScenePivot[1],
moveScenePivot[2]);
//===========================================
LoadIdentity(invertView);
InvertMatrix(invertView, view);
//=============================
}
void RenderableTexture::Setup(bool useStencilBuffer){
glGenFramebuffers(1, &fbo);
if (fbo == 0){
DEBUG_LOG("failed to glGenFramebuffers\n");
return;
}
glBindFramebuffer(GL_FRAMEBUFFER, fbo);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex->GetID(), 0);
if (useStencilBuffer){
GLuint depth_stencil_rb;
glGenRenderbuffers(1, &depth_stencil_rb);
glBindRenderbuffer(GL_RENDERBUFFER, depth_stencil_rb);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, tex->GetWidth(), tex->GetHeight());
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depth_stencil_rb);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, depth_stencil_rb);
glBindRenderbuffer(GL_RENDERBUFFER, 0);
}
auto result = glCheckFramebufferStatus(GL_FRAMEBUFFER);
if (result != GL_FRAMEBUFFER_COMPLETE){
DEBUG_LOG("FBO error!\n");
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
transform = make_shared<Transform>();
Begin();
Viewport(0, 0, tex->GetWidth(), tex->GetHeight());
MatrixMode(PROJECTION_MATRIX);
LoadIdentity();
Ortho(0, tex->GetWidth(), 0, tex->GetHeight(), -1, 1);
MatrixMode(MODELVIEW_MATRIX);
LoadIdentity();
End();
}
void UpdateZTiMatrices(CLink *Skelet) {
/* **************************************************************************************************************************** */
int i;
MDFloat tempT[4][4];
MDFloat tempZTi[4][4];
MDFloat *ptrZTi = (MDFloat*)tempZTi;
MDFloat *ptrtempT = (MDFloat*)tempT;
/* **************************************************************************************************************************** */
LoadIdentity(ptrZTi);
for (i=0; i<_NO_OF_LINKS_; i++) {
MultMatrix4x4((MDFloat(*)[4])Skelet[i].Get_im1Ti(), tempZTi, tempT);
CopyMatrix4x4(ptrtempT, ptrZTi);
Skelet[i].Set_ZTi(tempZTi);
}
/* **************************************************************************************************************************** */
}
void RenderGL(void)
{
glClearColor(0.0, 0.0, 0.0, 0.5);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glViewport(0, 0, viewWidth, viewHeight);
LoadIdentity(projection);
PerspectiveMatrix(projection, fieldOfView, (GLfloat)viewWidth / (GLfloat)viewHeight, adjustNearFar[0], adjustNearFar[1]);
//Rotate(projection, 0.0, 0.0, 1.0, 90.0);//_____FOR_iOS_LANDSCAPE_VIEW
//====================================================================================
shaderNumber = 46;
#include "_MODEL_FOLDERS_/sphere/sphere_RENDER.cpp"
//====================================================================================
}
void CPictureRing::SetSize(double pWidth, double pHeight, double pDepth)
{
int h, v, i, hNum, vNum, degree;
CComponent3D* object;
double dAngle, rAngel, pos[3];
xMargin = 10.0;
yMargin = 10.0;
degree = objectList.GetDegree();
if(degree == 1) return;
hNum = (pWidth - pictureDepth * 2.0) * PI / (pictureSize + xMargin);
vNum = (degree - 1) / (double) hNum;
if((double) vNum != (double) (degree - 1) / (double) hNum) vNum++;
CFrame::SetSize(pWidth, (double) vNum * (pictureSize + yMargin), pWidth);
dAngle = 360.0 / hNum;
rAngel = 2.0 * PI / hNum;
pos[0] = 0.0;
pos[1] = (double) (vNum - 1) * (pictureSize + yMargin) * 0.5;
pos[2] = 0.0;
//z軸まわりにリング状にオブジェクトを並べる
i = 1;
objectList.GoToFirst();
objectList.GoToNext(); //最初のオブジェクはフレーム
for(v = 0; v < vNum; v++) {
for(h = 0; h < hNum; h++) {
object = (CComponent3D*) objectList.GetKey();
LoadIdentity(object->matrix);
object->Rotate(dAngle * (double) h, 0.0, 1.0, 0.0);
pos[0] = -(width - pictureDepth * 2.0) * 0.5 * sin(rAngel * (double) h);
pos[2] = -(width - pictureDepth * 2.0) * 0.5 * cos(rAngel * (double) h); //反時計周り
object->SetPosition(pos);
if(++i == degree) return;
objectList.GoToNext();
}
pos[1] -= pictureSize + xMargin;
}
}
# Dessin du squelette
############################################################################################################################ */
void DrawSkelet(void)
{
/* **************************************************************************************************************************** */
int i;
MDFloat tempT[4][4];
MDFloat ZTi[4][4];
MDFloat *ptrZTi = (MDFloat*)ZTi;
MDFloat *ptrtempT = (MDFloat*)tempT;
/* **************************************************************************************************************************** */
MoveToOrigin();
/* **************************************************************************************************************************** */
glLoadName(_DESIRED_EE_ID_);
glDisable(GL_LIGHTING);
glMatrixMode(GL_MODELVIEW);
glBegin(GL_POINTS);
glColor3f(1.0f, 1.0f, 0.2f);
glVertex3dv(PNew);
glEnd();
glEnable(GL_LIGHTING);
/* **************************************************************************************************************************** */
glMatrixMode(GL_MODELVIEW);
/* **************************************************************************************************************************** */
glPushMatrix();
/* **************************************************************************************************************************** */
LoadIdentity(ptrZTi);
for (i=0; i<_NO_OF_LINKS_; i++) {
Skelet[i].Draw();
glPopMatrix();
glPushMatrix();
MultMatrix4x4((MDFloat(*)[4])Skelet[i].Get_im1Ti(), ZTi, tempT);
CopyMatrix4x4(ptrtempT, ptrZTi);
glMultTransposeMatrixd(ptrZTi);
}
/* **************************************************************************************************************************** */
DrawEE();
/* **************************************************************************************************************************** */
