void TexturedLine::Render()
{
if(!lineTexture) return;
Vect lineDir = (pointB-pointA).Norm();
float halfWidth = width*0.5f;
Camera *viewCam = level->GetCurrentCamera();
Vect camPos = viewCam->GetWorldPos();
Vect crossLine;
DepthWriteEnable(FALSE);
EnableBlending(TRUE);
if(lineTexture->HasAlpha())
BlendFunction(GS_BLEND_SRCALPHA, GS_BLEND_INVSRCALPHA);
else
BlendFunction(GS_BLEND_ONE, GS_BLEND_ONE);
LoadTexture(lineTexture);
LoadDefault3DSampler();
MatrixPush();
MatrixTranslate(GetWorldPos());
MatrixRotate(GetWorldRot());
RenderStart();
Vect endAdjust = (lineDir*halfWidth);
Vect backEnd = (pointA-endAdjust);
Vect frontEnd = (pointB+endAdjust);
Color(color);
crossLine = (camPos-backEnd).Cross(lineDir).Norm() * halfWidth;
Vertex(backEnd+crossLine); TexCoord(1.0f, 0.0f);
Vertex(backEnd-crossLine); TexCoord(0.0f, 0.0f);
crossLine = (camPos-pointA).Cross(lineDir).Norm() * halfWidth;
Vertex(pointA+crossLine); TexCoord(1.0f, 0.5f);
Vertex(pointA-crossLine); TexCoord(0.0f, 0.5f);
crossLine = (camPos-pointB).Cross(lineDir).Norm() * halfWidth;
Vertex(pointB+crossLine); TexCoord(1.0f, 0.5f);
Vertex(pointB-crossLine); TexCoord(0.0f, 0.5f);
crossLine = (camPos-frontEnd).Cross(lineDir).Norm() * halfWidth;
Vertex(frontEnd+crossLine); TexCoord(1.0f, 1.0f);
Vertex(frontEnd-crossLine); TexCoord(0.0f, 1.0f);
RenderStop(GS_TRIANGLESTRIP);
MatrixPop();
LoadTexture(NULL);
}
/*
* D3DParticleAddToRenderer: Adds a particle to be rendered.
*/
void D3DParticleAddToRenderer(d3d_render_pool_new *pPool, Draw3DParams *params,
particle_system *pParticleSystem, particle *pParticle)
{
d3d_render_packet_new *pPacket;
d3d_render_chunk_new *pChunk;
pPacket = D3DRenderPacketFindMatch(pPool, pParticleSystem->pTexture, NULL, 0, 0, 0);
assert(pPacket);
pPacket->pMaterialFctn = &D3DMaterialParticlePacket;
pChunk = D3DRenderChunkNew(pPacket);
assert(pChunk);
pChunk->numIndices = pParticleSystem->numIndices;
pChunk->numVertices = pParticleSystem->numVertices;
pChunk->numPrimitives = pParticleSystem->numPrimitives;
pChunk->pMaterialFctn = &D3DMaterialParticleChunk;
MatrixTranslate(&pChunk->xForm, pParticle->pos.x, pParticle->pos.z, pParticle->pos.y);
if (pParticleSystem->pTexture)
{
MatrixMultiply(&pChunk->xForm, &mPlayerHeadingTrans, &pChunk->xForm);
for (u_int i = 0; i < pChunk->numVertices; i++)
{
pChunk->indices[i] = pParticleSystem->pParticleIndices[i];
pChunk->xyz[i] = pParticleSystem->pParticleXYZ[i];
pChunk->st0[i] = pParticleSystem->pParticleST[i];
pChunk->bgra[i].b = pParticle->bgra.b;
pChunk->bgra[i].g = pParticle->bgra.g;
pChunk->bgra[i].r = pParticle->bgra.r;
pChunk->bgra[i].a = pParticle->bgra.a;
}
}
else
{
CHUNK_XYZ_SET(pChunk, 0, 0, 0, 0);
CHUNK_XYZ_SET(pChunk, 1, -pParticle->velocity.x, -pParticle->velocity.y,
-pParticle->velocity.z);
CHUNK_BGRA_SET(pChunk, 0, (pParticle->bgra.b), pParticle->bgra.g, pParticle->bgra.r,
pParticle->bgra.a);
CHUNK_BGRA_SET(pChunk, 1, pParticle->bgra.b, pParticle->bgra.g, pParticle->bgra.r,
0);
CHUNK_INDEX_SET(pChunk, 0, 0);
CHUNK_INDEX_SET(pChunk, 1, 1);
}
}
void skinnedmesh_frame(skinnedmesh_t *sm,float frame) {
int i,frame1,frame2;
frame1 = (int)frame;
frame -= frame1;
if(frame1 >= sm->num_frame) frame1 %= sm->num_frame;
frame2 = frame1 + 1;
if(frame2 >= sm->num_frame) frame2 = 0;
for(i = 0; i < sm->num_bone; i++) {
float matrix_xyz[16],matrix_rot[16];
float xyz[3],rot[4],a[3],b[3];
VectorScale(sm->frame[frame1][i].xyz,1.0 - frame,a);
VectorScale(sm->frame[frame2][i].xyz,frame,b);
VectorAdd(a,b,xyz);
QuaternionSlerp(sm->frame[frame1][i].rot,
sm->frame[frame2][i].rot,frame,rot);
MatrixTranslate(xyz[0],xyz[1],xyz[2],matrix_xyz);
QuaternionToMatrix(rot,matrix_rot);
MatrixMultiply(matrix_xyz,matrix_rot,sm->bone[i].matrix);
}
for(i = 0; i < sm->num_surface; i++) {
int j;
surface_t *surface = sm->surface[i];
for(j = 0; j < surface->num_vertex; j++) {
int k;
VectorSet(0,0,0,surface->vertex[j].xyz);
VectorSet(0,0,0,surface->vertex[j].normal);
for(k = 0; k < surface->vertex[j].num_weight; k++) {
float v[3];
weight_t *weight = &surface->vertex[j].weight[k];
VectorTransform(weight->xyz,
sm->bone[weight->bone].matrix,v);
VectorScale(v,weight->weight,v);
VectorAdd(surface->vertex[j].xyz,v,
surface->vertex[j].xyz);
VectorTransformNormal(weight->normal,
sm->bone[weight->bone].matrix,v);
VectorScale(v,weight->weight,v);
VectorAdd(surface->vertex[j].normal,v,
surface->vertex[j].normal);
}
}
}
}
void KGEDevice::transformVertexes()
{
_mat = MatrixScale(0.02, 0.02, 0.02)*MatrixTranslate(Vector4(0, -20, 0, 0))*MatrixRotation(Vector4(1, 0, 0, 0), -90 * M_PI / 180);
int vertexCount = (int)_transformMesh->positionList.size();
for (int i = 0; i < vertexCount; ++i)
{
KGEVertex v = _transformMesh->GetVertex(i);
KGEVertex tranformedV = VertexShaderProgram(_mat, _camera, _light, _transformMesh->materialList[v.materialID], v);
_transformMesh->SetVertex(i, tranformedV);
}
vertexCount = _transformMesh->positionList.size();
for (int i = 0; i < vertexCount; ++i)
{
_transformMesh->positionList[i].persDiv();
_transformMesh->positionList[i] = _viewportMat * _transformMesh->positionList[i];
}
}
DGLE_RESULT DGLE_API CBitmapFont::Draw2D(float fX, float fY, const char *pcTxt, const TColor4 &stColor, float fAngle, bool bVerticesColors)
{
uint length = strlen(pcTxt);
if (length == 0)
return S_FALSE;
bool b_need_update;
_pRender2D->NeedToUpdateBatchData(b_need_update);
if (!b_need_update)
{
_pRender2D->Draw(_pTex, TDrawDataDesc(), CRDM_TRIANGLES, length * 6, TRectF(), (E_EFFECT2D_FLAGS)(EF_BLEND | (bVerticesColors ? EF_DEFAULT : EF_COLOR_MIX)));
return S_OK;
}
uint width, height;
GetTextDimensions(pcTxt, width, height);
float quad[] = {fX, fY, fX + (float)width, fY, fX + (float)width, fY + (float)height, fX, fY + (float)height};
TMatrix4 transform;
if (fAngle != 0.f)
{
TMatrix4 rot = MatrixIdentity();
const float s = sinf(-fAngle * (float)M_PI/180.f), c = cosf(-fAngle * (float)M_PI/180.f);
rot._2D[0][0] = c;
rot._2D[0][1] = -s;
rot._2D[1][0] = s;
rot._2D[1][1] = c;
transform = MatrixTranslate(TVector3(-(fX + width / 2.f), -(fY + height / 2.f), 0.f)) * rot * MatrixTranslate(TVector3(fX + width / 2.f, fY + height / 2.f, 0.f));
float x = quad[0], y = quad[1];
quad[0] = transform._2D[0][0] * x + transform._2D[1][0] * y + transform._2D[3][0];
quad[1] = transform._2D[0][1] * x + transform._2D[1][1] * y + transform._2D[3][1];
x = quad[2]; y = quad[3];
quad[2] = transform._2D[0][0] * x + transform._2D[1][0] * y + transform._2D[3][0];
quad[3] = transform._2D[0][1] * x + transform._2D[1][1] * y + transform._2D[3][1];
x = quad[4]; y = quad[5];
quad[4] = transform._2D[0][0] * x + transform._2D[1][0] * y + transform._2D[3][0];
quad[5] = transform._2D[0][1] * x + transform._2D[1][1] * y + transform._2D[3][1];
x = quad[6]; y = quad[7];
quad[6] = transform._2D[0][0] * x + transform._2D[1][0] * y + transform._2D[3][0];
quad[7] = transform._2D[0][1] * x + transform._2D[1][1] * y + transform._2D[3][1];
}
if (!_pRender2D->BBoxInScreen(quad, fAngle != 0.f))
return S_OK;
float xoffset = 0.f;
uint t_w, t_h;
_pTex->GetDimensions(t_w, t_h);
TColor4 prev_color, verts_colors[4];
_pRender2D->GetColorMix(prev_color);
_pRender2D->SetColorMix(stColor);
if (bVerticesColors)
_pRender2D->GetVerticesColors(verts_colors[0], verts_colors[1], verts_colors[2], verts_colors[3]);
uint size = length * 12 * 2;
if (bVerticesColors)
size = length * 24 * 2;
if (_uiBufferSize < size)
{
_uiBufferSize = size;
delete[] _pBuffer;
_pBuffer = new float[_uiBufferSize];
}
for (uint i = 0; i < length; ++i)
{
const uchar ch = static_cast<const uchar>(pcTxt[i]) - 32;
const int
&curb_x = _astChars[ch].x,
&curb_y = _astChars[ch].y,
&curb_w = _astChars[ch].w,
&curb_h = _astChars[ch].h;
const uint idx = i * 24;
_pBuffer[idx] = fX + xoffset; _pBuffer[idx + 1] = fY; _pBuffer[idx + 2] = (float)curb_x / (float)t_w; _pBuffer[idx + 3] = (float)curb_y / (float)t_h;
_pBuffer[idx + 4] = fX + xoffset + (float)curb_w * _fScale; _pBuffer[idx + 5] = fY; _pBuffer[idx + 6] = (float)(curb_x + curb_w) / (float)t_w; _pBuffer[idx + 7] = (float)curb_y / (float)t_h;
_pBuffer[idx + 8] = fX + xoffset + (float)curb_w * _fScale; _pBuffer[idx + 9] = fY + (float)curb_h * _fScale; _pBuffer[idx + 10] = (float)(curb_x + curb_w) / (float)t_w; _pBuffer[idx + 11] = (float)(curb_y + curb_h) / (float)t_h;
_pBuffer[idx + 12] = _pBuffer[idx]; _pBuffer[idx + 13] = _pBuffer[idx + 1]; _pBuffer[idx + 14] = _pBuffer[idx + 2]; _pBuffer[idx + 15] = _pBuffer[idx + 3];
_pBuffer[idx + 16] = _pBuffer[idx + 8]; _pBuffer[idx + 17] = _pBuffer[idx + 9]; _pBuffer[idx + 18] = _pBuffer[idx + 10]; _pBuffer[idx + 19] = _pBuffer[idx + 11];
_pBuffer[idx + 20] = fX + xoffset; _pBuffer[idx + 21] = fY + (float)curb_h * _fScale; _pBuffer[idx + 22] = (float)curb_x / (float)t_w; _pBuffer[idx + 23] = (float)(curb_y + curb_h) / (float)t_h;
if (fAngle != 0.f)
{
float x = _pBuffer[idx], y = _pBuffer[idx + 1];
_pBuffer[idx] = transform._2D[0][0] * x + transform._2D[1][0] * y + transform._2D[3][0];
_pBuffer[idx + 1] = transform._2D[0][1] * x + transform._2D[1][1] * y + transform._2D[3][1];
x = _pBuffer[idx + 4]; y = _pBuffer[idx + 5];
_pBuffer[idx + 4] = transform._2D[0][0] * x + transform._2D[1][0] * y + transform._2D[3][0];
_pBuffer[idx + 5] = transform._2D[0][1] * x + transform._2D[1][1] * y + transform._2D[3][1];
x = _pBuffer[idx + 8]; y = _pBuffer[idx + 9];
_pBuffer[idx + 8] = transform._2D[0][0] * x + transform._2D[1][0] * y + transform._2D[3][0];
_pBuffer[idx + 9] = transform._2D[0][1] * x + transform._2D[1][1] * y + transform._2D[3][1];
x = _pBuffer[idx + 20]; y = _pBuffer[idx + 21];
_pBuffer[idx + 20] = transform._2D[0][0] * x + transform._2D[1][0] * y + transform._2D[3][0];
_pBuffer[idx + 21] = transform._2D[0][1] * x + transform._2D[1][1] * y + transform._2D[3][1];
_pBuffer[idx + 12] = _pBuffer[idx]; _pBuffer[idx + 13] = _pBuffer[idx + 1];
_pBuffer[idx + 16] = _pBuffer[idx + 8]; _pBuffer[idx + 17] = _pBuffer[idx + 9];
}
if (bVerticesColors)
{
const uint idx = length * 24 + i * 24;
memcpy(&_pBuffer[idx], verts_colors[0], 12 * sizeof(float));
memcpy(&_pBuffer[idx + 12], verts_colors[0], 4 * sizeof(float));
memcpy(&_pBuffer[idx + 16], verts_colors[2], 8 * sizeof(float));
}
xoffset += (float)curb_w * _fScale;
}
TDrawDataDesc desc;
desc.pData = (uint8 *)_pBuffer;
desc.uiVertexStride = 4 * sizeof(float);
desc.bVertices2D = true;
desc.uiTextureVertexOffset = 2 * sizeof(float);
desc.uiTextureVertexStride = desc.uiVertexStride;
if (bVerticesColors)
desc.uiColorOffset = length * 24 * sizeof(float);
_pRender2D->Draw(_pTex, desc, CRDM_TRIANGLES, length*6, TRectF(), (E_EFFECT2D_FLAGS)(EF_BLEND | (bVerticesColors ? EF_DEFAULT : EF_COLOR_MIX)));
_pRender2D->SetColorMix(prev_color);
return S_OK;
}
void RotationManipulator::RenderScaled(const Vect &cameraDir, float scale)
{
traceInFast(RotationManipulator::RenderScaled);
DWORD i;
Shader *rotManipShader = GetVertexShader(TEXT("Editor:RotationManipulator.vShader"));
LoadVertexShader(rotManipShader);
LoadPixelShader(GetPixelShader(TEXT("Base:SolidColor.pShader")));
rotManipShader->SetVector(rotManipShader->GetParameter(2), cameraDir);
MatrixPush();
MatrixTranslate(GetWorldPos());
MatrixScale(scale, scale, scale);
for(i=0; i<3; i++)
{
Vect axisColor(0.0f, 0.0f, 0.0f);
axisColor.ptr[i] = 1.0f;
if(i == activeAxis)
axisColor.Set(1.0f, 1.0f, 0.0f);
else
axisColor.ptr[i] = 1.0f;
rotManipShader->SetVector(rotManipShader->GetParameter(1), axisColor);
LoadVertexBuffer(axisBuffers[i]);
LoadIndexBuffer(NULL);
Draw(GS_LINESTRIP);
}
LoadVertexBuffer(NULL);
//----------------------------------------------------
Shader *solidShader = GetVertexShader(TEXT("Base:SolidColor.vShader"));
LoadVertexShader(solidShader);
MatrixPush();
MatrixRotate(Quat().SetLookDirection(cameraDir));
LoadVertexBuffer(axisBuffers[2]);
LoadIndexBuffer(NULL);
solidShader->SetColor(solidShader->GetParameter(1), 0.5, 0.5, 0.5, 0.5);
Draw(GS_LINESTRIP);
MatrixScale(1.25f, 1.25f, 1.25f);
//---------------
if(activeAxis == 4)
solidShader->SetColor(solidShader->GetParameter(1), 1.0f, 1.0f, 0.0, 1.0f);
else
solidShader->SetColor(solidShader->GetParameter(1), 0.8, 0.8, 0.8, 0.8);
Draw(GS_LINESTRIP);
MatrixPop();
MatrixPop();
LoadVertexShader(NULL);
LoadPixelShader(NULL);
traceOutFast;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CParticleProperty::UpdateControlPoint( ParticleEffectList_t *pEffect, int iPoint, bool bInitializing )
{
ParticleControlPoint_t *pPoint = &pEffect->pControlPoints[iPoint];
if ( !pPoint->hEntity.Get() )
{
if ( pPoint->iAttachType == PATTACH_WORLDORIGIN && bInitializing )
{
pEffect->pParticleEffect->SetControlPointOrientation( pPoint->iControlPoint, Vector(1,0,0), Vector(0,1,0), Vector(0,0,1) );
pEffect->pParticleEffect->SetControlPoint( pPoint->iControlPoint, pPoint->vecOriginOffset );
pEffect->pParticleEffect->SetSortOrigin( pPoint->vecOriginOffset );
}
pEffect->pParticleEffect->SetControlPointEntity( pPoint->iControlPoint, NULL );
return;
}
// Only update non-follow particles when we're initializing,
// unless we're parented to something, in which case we should always update
if ( !bInitializing && !pPoint->hEntity->GetMoveParent() && (pPoint->iAttachType == PATTACH_ABSORIGIN || pPoint->iAttachType == PATTACH_POINT ) )
return;
if ( pPoint->iAttachType == PATTACH_CUSTOMORIGIN )
return;
Vector vecOrigin, vecForward, vecRight, vecUp;
float flOffset = 0.0f;
bool bUsingHeadOrigin = false;
#ifdef TF_CLIENT_DLL
CBaseEntity *pWearable = (CBaseEntity*) pPoint->hEntity.Get();
if ( pWearable && dynamic_cast<IHasAttributes*>( pWearable ) && !pWearable->IsPlayer() )
{
C_BaseAnimating *pAnimating = pPoint->hEntity->GetBaseAnimating();
if ( pAnimating )
{
int bUseHeadOrigin = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pPoint->hEntity.Get(), bUseHeadOrigin, particle_effect_use_head_origin );
if ( bUseHeadOrigin > 0 )
{
int iBone = Studio_BoneIndexByName( pAnimating->GetModelPtr(), "bip_head" );
if ( iBone < 0 )
{
iBone = Studio_BoneIndexByName( pAnimating->GetModelPtr(), "prp_helmet" );
if ( iBone < 0 )
{
iBone = Studio_BoneIndexByName( pAnimating->GetModelPtr(), "prp_hat" );
}
}
if ( iBone >= 0 )
{
bUsingHeadOrigin = true;
const matrix3x4_t headBone = pAnimating->GetBone( iBone );
MatrixVectors( headBone, &vecForward, &vecRight, &vecUp );
MatrixPosition( headBone, vecOrigin );
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pPoint->hEntity.Get(), flOffset, particle_effect_vertical_offset );
}
}
}
}
#endif
if ( !bUsingHeadOrigin )
{
switch ( pPoint->iAttachType )
{
case PATTACH_POINT:
case PATTACH_POINT_FOLLOW:
{
C_BaseAnimating *pAnimating = pPoint->hEntity->GetBaseAnimating();
Assert( pAnimating );
if ( pAnimating )
{
matrix3x4_t attachmentToWorld;
if ( !pAnimating->GetAttachment( pPoint->iAttachmentPoint, attachmentToWorld ) )
{
// try C_BaseAnimating if attach point is not on the weapon
if ( !pAnimating->C_BaseAnimating::GetAttachment( pPoint->iAttachmentPoint, attachmentToWorld ) )
{
Warning( "Cannot update control point %d for effect '%s'.\n", pPoint->iAttachmentPoint, pEffect->pParticleEffect->GetEffectName() );
attachmentToWorld = pAnimating->RenderableToWorldTransform();
}
}
VMatrix vMat(attachmentToWorld);
MatrixTranslate( vMat, pPoint->vecOriginOffset );
MatrixVectors( vMat.As3x4(), &vecForward, &vecRight, &vecUp );
MatrixPosition( vMat.As3x4(), vecOrigin );
if ( pEffect->pParticleEffect->m_pDef->IsViewModelEffect() )
{
FormatViewModelAttachment( vecOrigin, true );
}
}
}
break;
case PATTACH_ABSORIGIN:
case PATTACH_ABSORIGIN_FOLLOW:
default:
{
vecOrigin = pPoint->hEntity->GetAbsOrigin() + pPoint->vecOriginOffset;
pPoint->hEntity->GetVectors( &vecForward, &vecRight, &vecUp );
}
break;
case PATTACH_ROOTBONE_FOLLOW:
{
C_BaseAnimating *pAnimating = pPoint->hEntity->GetBaseAnimating();
Assert( pAnimating );
if ( pAnimating )
{
matrix3x4_t rootBone;
if ( pAnimating->GetRootBone( rootBone ) )
{
MatrixVectors( rootBone, &vecForward, &vecRight, &vecUp );
MatrixPosition( rootBone, vecOrigin );
}
}
}
break;
}
}
Vector vecForcedOriginOffset( 0, 0, flOffset );
pEffect->pParticleEffect->SetControlPointOrientation( pPoint->iControlPoint, vecForward, vecRight, vecUp );
pEffect->pParticleEffect->SetControlPointEntity( pPoint->iControlPoint, pPoint->hEntity );
pEffect->pParticleEffect->SetControlPoint( pPoint->iControlPoint, vecOrigin + vecForcedOriginOffset );
pEffect->pParticleEffect->SetSortOrigin( vecOrigin + vecForcedOriginOffset);
}
void ArmGLWidget::drawArm(ArmShovelAngles A)
{
// Rover!
glColor3f (.5, .5, .5);
glTranslatef (-35, 5, 15);
drawBox(45, 15, 45);
glTranslatef (35, -5, -15);
glColor3f (1, 1, 1);
// Testing
matrix m = MatrixTranslate(0, 0, 0);
//m = MatrixRotateY(A.base.rotation) * m;
m = MatrixTranslate (-ArmController::BASE_OFFSET, 0, 0) * m;
m = MatrixRotateZ(A.base.shoulder) * m;
m = MatrixTranslate(ArmController::SEG1_LEN, 0, 0) * m;
//m = MatrixTranslate(0, 0, -OFFSET) * m;
m = MatrixRotateZ(A.base.elbow - 180) * m;
m = MatrixTranslate(40, 0, 0) * m;
glPushMatrix();
glMultMatrixf (*(m.array));
drawBox(1, 1, 1);
glPopMatrix();
glColor3f (1, 0, 0);
// Draw arm box
drawBox(15, 5, 15);
// Draw box to drop samples into
glPushMatrix();
// x = front to back, y = up and down, z = side to side
glTranslatef(0, - 2.5 + (4 + 5 - 2) * 2.54 , (23) * 2.54);
drawBox(7.25 * 2.54, 4 * 2.54, 6.5 * 2.54);
glPopMatrix();
glRotatef(A.base.rotation, 0, 1, 0);
glTranslatef(0, 3.5, 0);
drawCylinderY(3, 2);
glTranslatef(-ArmController::BASE_OFFSET, 2, 0);
drawCylinderZ(2, 6);
glColor3f (0, 1, 0);
glRotatef (A.base.shoulder, 0, 0, 1);//g.RotateTransform(-A.thetaS, System..Drawing2D.MatrixOrder.Prepend);
glTranslatef(ArmController::SEG1_LEN/2, 0, 0);
drawCylinderX(2, ArmController::SEG1_LEN);
glTranslatef(ArmController::SEG1_LEN/2, 0, -ArmController::OFFSET/2);
drawCylinderZ(2, ArmController::OFFSET + 4);
glTranslatef(0, 0, -ArmController::OFFSET/2);
glColor3f (1, 1, 0);
// Elbow to wrist elevation
glRotatef (A.base.elbow - 180, 0, 0, 1);//g.RotateTransform(180 - A.thetaE, System.Drawing.Drawing2D.MatrixOrder.Prepend);
float elbowToEnd = 35;
glTranslatef (elbowToEnd/2, 0, 0);
drawCylinderX(2, elbowToEnd);
glTranslatef (elbowToEnd/2, 0, 0);
drawCylinderZ(2, 4);
glColor3f (1, 0, 1);
glPushMatrix();
glRotatef(((float)A.head - 1000.0f) * 160.0f / 1024.0f, 0, 0, 1);
glPushMatrix();
glRotatef(((float)A.lid - 600.0f) * 300.0f / 1024.0f, 0, 0, 1);
this->drawBox(4, 1, 6);
glPopMatrix();
glRotatef(90, 0, 0, 1);
glTranslatef(2, 0, 0);
this->drawBox(4, 1, 8);
glTranslatef(2, 0, 0);
glRotatef(-90, 0, 0, 1);
glTranslatef(4, 0, 0);
this->drawBox(7, 1, 8);
glTranslatef(4, 0, 0);
glRotatef(-70, 0, 0, 1);
glTranslatef(2.5, 0, 0);
this->drawBox(5, 1, 8);
glPopMatrix();
/* float GRIPPER_ARM_LEN = 8;
static float r = 0;
r += 7;
//glRotatef (A.wristRotation, 1, 0, 0);
// CLAMPY CLAMPY!
static float a = 0;
a = sind(r) * 15;
drawCylinderX(4, 1);
glPushMatrix();
glTranslatef(0, 0, -4);
drawCylinderY(1, 2);
glRotatef(a, 0, 1, 0);
glTranslatef (GRIPPER_ARM_LEN/2, 0, 0);
drawCylinderX(1, GRIPPER_ARM_LEN);
glTranslatef (GRIPPER_ARM_LEN/2, 0, 0);
glRotatef(-a - 90, 0, 1, 0);
drawCylinderY(1, 2);
glTranslatef(1, 0, 0);
drawCylinderX(1, 2);
glPopMatrix();
glPushMatrix();
glTranslatef(0, 0, 4);
drawCylinderY(1, 2);
glRotatef(-a, 0, 1, 0);
glTranslatef (GRIPPER_ARM_LEN/2, 0, 0);
drawCylinderX(1, GRIPPER_ARM_LEN);
glTranslatef (GRIPPER_ARM_LEN/2, 0, 0);
glRotatef(a + 90, 0, 1, 0);
drawCylinderY(1, 2);
glTranslatef(1, 0, 0);
drawCylinderX(1, 2);
glPopMatrix();*/
}
void ArmGLWidget::drawArm(ArmAstroAngles A)
{
// Rover!
glColor3f (.5, .5, .5);
glTranslatef (-35, 5, 15);
drawBox(45, 15, 45);
glTranslatef (35, -5, -15);
glColor3f (1, 1, 1);
// Testing
matrix m = MatrixTranslate(0, 0, 0);
//m = MatrixRotateY(A.base.rotation) * m;
m = MatrixTranslate (-ArmController::BASE_OFFSET, 0, 0) * m;
m = MatrixRotateZ(A.base.shoulder) * m;
m = MatrixTranslate(ArmController::SEG1_LEN, 0, 0) * m;
//m = MatrixTranslate(0, 0, -OFFSET) * m;
m = MatrixRotateZ(A.base.elbow - 180) * m;
m = MatrixTranslate(40, 0, 0) * m;
glPushMatrix();
glMultMatrixf (*(m.array));
drawBox(1, 1, 1);
glPopMatrix();
glColor3f (1, 0, 0);
// Draw arm box
drawBox(15, 5, 15);
glRotatef(A.base.rotation, 0, 1, 0);
glTranslatef(0, 3.5, 0);
drawCylinderY(3, 2);
glTranslatef(-ArmController::BASE_OFFSET, 2, 0);
drawCylinderZ(2, 6);
glColor3f (0, 1, 0);
glRotatef (A.base.shoulder, 0, 0, 1);//g.RotateTransform(-A.thetaS, System..Drawing2D.MatrixOrder.Prepend);
glTranslatef(ArmController::SEG1_LEN/2, 0, 0);
drawCylinderX(2, ArmController::SEG1_LEN);
glTranslatef(ArmController::SEG1_LEN/2, 0, -ArmController::OFFSET/2);
drawCylinderZ(2, ArmController::OFFSET + 4);
glTranslatef(0, 0, -ArmController::OFFSET/2);
glColor3f (1, 1, 0);
// Elbow to wrist elevation
glRotatef (A.base.elbow - 180, 0, 0, 1);//g.RotateTransform(180 - A.thetaE, System.Drawing.Drawing2D.MatrixOrder.Prepend);
float elbowToEnd = 20;
glTranslatef (elbowToEnd/2, 0, 0);
drawCylinderX(2, elbowToEnd);
glTranslatef (elbowToEnd/2, 0, 0);
drawCylinderZ(2, 4);
//glColor3f (0, 0, 1);
// Wirst elevation to wrist rotate
//glRotatef(-A.wristElevation, 0, 0, 1);//g.RotateTransform(A.thetaW, System.Drawing.Drawing2D.MatrixOrder.Prepend);
//glTranslatef(ArmController::END_EFFECTOR_MID/2, 0, 0);
//drawCylinderX(2, ArmController::END_EFFECTOR_MID);
//glTranslatef(ArmController::END_EFFECTOR_MID/2, 0, 0);
//drawCylinderY(2, 4);
glColor3f (1, 0, 1);
float GRIPPER_ARM_LEN = 8;
//float HALF = ArmController::END_EFFECTOR_END - GRIPPER_ARM_LEN; // Point of rotation servo
//glRotatef(A.writsTip, 0, 1, 0);
//glTranslatef(HALF/2, 0, 0);
//drawCylinderX(2, HALF);
//glTranslatef(HALF/2, 0, 0);
//glColor3f (0, 1, 1);
static float r = 0;
r += 7;
//glRotatef (A.wristRotation, 1, 0, 0);
// CLAMPY CLAMPY!
static float a = 0;
a = sind(r) * 15;
drawCylinderX(4, 1);
glPushMatrix();
glTranslatef(0, 0, -4);
drawCylinderY(1, 2);
glRotatef(a, 0, 1, 0);
glTranslatef (GRIPPER_ARM_LEN/2, 0, 0);
drawCylinderX(1, GRIPPER_ARM_LEN);
glTranslatef (GRIPPER_ARM_LEN/2, 0, 0);
glRotatef(-a - 90, 0, 1, 0);
drawCylinderY(1, 2);
glTranslatef(1, 0, 0);
drawCylinderX(1, 2);
glPopMatrix();
glPushMatrix();
glTranslatef(0, 0, 4);
drawCylinderY(1, 2);
glRotatef(-a, 0, 1, 0);
glTranslatef (GRIPPER_ARM_LEN/2, 0, 0);
drawCylinderX(1, GRIPPER_ARM_LEN);
glTranslatef (GRIPPER_ARM_LEN/2, 0, 0);
glRotatef(a + 90, 0, 1, 0);
drawCylinderY(1, 2);
glTranslatef(1, 0, 0);
drawCylinderX(1, 2);
glPopMatrix();
}
static int vmatrix_MatrixTranslate (lua_State *L) {
MatrixTranslate(luaL_checkvmatrix(L, 1), luaL_checkvector(L, 2));
return 0;
}
