void FPSCamera::LoadMatrix() const
{
// load identity matrix
glLoadIdentity();
MultMatrix();
}
void DrawJSONMesh(PP_Resource context,
PPB_OpenGLES2* gl,
Transformations* psMatrices,
int iNumVertices,
int iNumIndices,
GLuint uiVBO,
GLuint uiIBO)
{
float afTransform[4][4];//The final matrix
float modelview[4][4];
gl->UseProgram(context, psDemoContext->hDisplacementMapShader);
Identity(afTransform);
Identity(modelview);
MultMatrix(modelview, psMatrices->rot, psMatrices->camera);
MultMatrix(modelview, psMatrices->scale, modelview);
MultMatrix(modelview, psMatrices->xform, modelview);
MultMatrix(afTransform, modelview, psMatrices->projection);
gl->UniformMatrix4fv(context, gl->GetUniformLocation(context, psDemoContext->hDisplacementMapShader, "Transform"), 1, GL_FALSE, (float*)&afTransform[0][0]);
gl->Uniform1i(context, gl->GetUniformLocation(context, psDemoContext->hDisplacementMapShader, "TextureBase"), 0);
gl->Uniform1i(context, gl->GetUniformLocation(context, psDemoContext->hDisplacementMapShader, "DispMap"), 1);
gl->Uniform1f(context, gl->GetUniformLocation(context, psDemoContext->hDisplacementMapShader, "DISPLACEMENT_COEFFICIENT"), psDemoContext->fDispCoeff);
gl->ActiveTexture(context, GL_TEXTURE0+1);
gl->BindTexture(context, GL_TEXTURE_2D, psDemoContext->sDisplacementMap.hTextureGL);
gl->ActiveTexture(context, GL_TEXTURE0);
gl->BindTexture(context, GL_TEXTURE_2D, psDemoContext->sBaseMap.hTextureGL);
gl->BindBuffer(context, GL_ARRAY_BUFFER, uiVBO);
gl->BindBuffer(context, GL_ELEMENT_ARRAY_BUFFER, uiIBO);
gl->EnableVertexAttribArray(context, VA_POSITION_INDEX);
gl->EnableVertexAttribArray(context, VA_TEXCOORD_INDEX);
gl->EnableVertexAttribArray(context, VA_NORMAL_INDEX);
gl->VertexAttribPointer(context, VA_POSITION_INDEX, 3, GL_FLOAT, GL_FALSE, 0, 0);
gl->VertexAttribPointer(context, VA_TEXCOORD_INDEX, 3, GL_FLOAT, GL_FALSE, 0, (char*)(sizeof(GLfloat)*(iNumVertices*3)));
gl->VertexAttribPointer(context, VA_NORMAL_INDEX, 3, GL_FLOAT, GL_FALSE, 0, (char*)(sizeof(GLfloat)*(iNumVertices*6)));
gl->DrawElements(context, GL_TRIANGLES, iNumIndices, GL_UNSIGNED_SHORT, 0);
}
void MatrixStack::Scale(float x, float y, float z)
{
MultMatrix(Matrix4Df
(x, 0.0f, 0.0f, 0.0f,
0.0f, y, 0.0f, 0.0f,
0.0f, 0.0f, z, 0.0f,
0.0f, 0.0f, 0.0f, 1.0f));
}
void nuiDrawContext::Translate(nuiSize X, nuiSize Y, nuiSize Z)
{
if (X == 0 && Y == 0 && Z == 0)
return;
nuiMatrix m;
m.SetTranslation(X, Y, Z);
MultMatrix(m);
}
void nuiDrawContext::Scale(nuiSize X, nuiSize Y, nuiSize Z)
{
if (X == 1.0 && Y == 1.0 && Z == 1.0)
return;
nuiMatrix m;
m.SetScaling(X, Y, Z);
MultMatrix(m);
}
void main(){
//0,0不能为0
TriSeqMatrix M,N,Q;
CreateMatrix(&M);
PrintMatrix(M);
CreateMatrix(&N);
PrintMatrix(N);
printf("矩阵M和N的乘积为:\n");
MultMatrix(M,N,&Q);
PrintMatrix(Q);
system("pause");
}
void SGCanvasMouseHandler::LoadMatrix() const
{
glLoadIdentity();
if (canvas->GetFrame()->IsChecked(Id::ViewPerspective))
{
glTranslatef(0.0f, 0.0f, SGCanvas::CameraZ - 1.0f);
}
else
{
glTranslatef(0.0f, 0.0f, SGCanvas::CameraZ);
}
glRotatef(20.0f, 1.0f, 0.0f, 0.0f);
MultMatrix();
}
/*------------------------------------------------*/
int main(int argc,int** argv)
{
int i,j,k,l;
int length,width;
float tau_L;
float tau_H;
float p_H;
float sigma;
/* Entrer des valeurs */
printf("Entrez la valeur de tau_L: ");
scanf("%f",&tau_L);
printf("Entrez la valeur de tau_H: ");
scanf("%f",&tau_H);
printf("Entrez l'ecart type du filter Gaussien: ");
scanf("%f",&sigma);
// Chargement de l'image
float** MatriceImgR=LoadImagePgm(NAME_IMG_IN,&length,&width);
float** MatriceImgI=fmatrix_allocate_2d(length,width);
float** gaussMaskI=fmatrix_allocate_2d(length,width);
// Initialisation a zero de la partie imaginaire
for(i=0;i<length;i++)
{
for(j=0;j<width;j++)
{
MatriceImgI[i][j]=0.0;
gaussMaskI[i][j]=0.0;
}
}
/* Implementer detecteur de Canny */
int halfMaskWidth = 16;
int maskSize = halfMaskWidth*2 + 1;
////////////////////////////////////////////
// Etape 1: application d'un filtre Gaussien
//
float** mask = gaussianMask(halfMaskWidth, sigma);
float** gaussMaskR = padWithZeros(mask, maskSize, maskSize, length, width);
// Convolution
float** convR = fmatrix_allocate_2d(length,width);
float** convI = fmatrix_allocate_2d(length,width);
FFTDD(MatriceImgR,MatriceImgI,length,width);
FFTDD(gaussMaskR,gaussMaskI,length,width);
MultMatrix(convR,convI,MatriceImgR,MatriceImgI,gaussMaskR,gaussMaskI,length,width);
IFFTDD(convR,convI,length,width);
// Sauvegarde de l'image filtree
SaveImagePgm(NAME_IMG_CANNY,convR,length,width);
/////////////////////////////////////////////
// Etape 2: calcul du gradient a chaque pixel
//
float** gradientX = fmatrix_allocate_2d(length,width);
float** gradientY = fmatrix_allocate_2d(length,width);
float** gradientMagn = fmatrix_allocate_2d(length,width);
float** gradientAngles = fmatrix_allocate_2d(length,width);
float** contourAngles = fmatrix_allocate_2d(length,width);
gradient(convR, gradientX, gradientY, length, width);
gradientMagnitude(gradientX, gradientY, gradientMagn, length, width);
gradientAngle(gradientX, gradientY, gradientAngles, contourAngles, length, width);
// Sauvegarde de l'image du gradient
SaveImagePgm(NAME_IMG_GRADIENT,gradientMagn,length,width);
// Suppression des non-maximums
deleteNonMaximums(gradientMagn,contourAngles,length,width);
// Sauvegarde de l'image des non-maximum supprimes
SaveImagePgm(NAME_IMG_SUPPRESSION,gradientMagn,length,width);
/* Sauvegarder les images
TpIFT6150-2-gradient.pgm
TpIFT6150-2-suppression.pgm
TpIFT6150-2-canny.pgm */
printf("Entrez la valeur de p_H: ");
scanf("%f",&p_H);
/* Implementer detecteur de Canny semi-automatique */
/* Sauvegarder l'image TpIFT6150-2-cannySemiAuto.pgm */
/*retour sans probleme*/
printf("\n C'est fini ... \n\n\n");
return 0;
}
void MultMatrix2(float m0[4][4], float m1[4][4])
{
float dst[4][4];
MultMatrix(m0, m1, dst);
memcpy( m0, dst, sizeof(float) * 16 );
}
void MatrixStack::Translate(float x, float y, float z)
{
MultMatrix(Matrix4Df(x, y, z));
}
void LoadMeshDataFromDisk( const char* fileName, SlabSubsection_Stack* allocater, MeshGeometryData* storage, Armature* armature ) {
tinyxml2::XMLDocument colladaDoc;
colladaDoc.LoadFile( fileName );
//if( colladaDoc == NULL ) {
//printf( "Could not load mesh: %s\n", fileName );
//return;
//}
tinyxml2::XMLElement* meshNode = colladaDoc.FirstChildElement( "COLLADA" )->FirstChildElement( "library_geometries" )
->FirstChildElement( "geometry" )->FirstChildElement( "mesh" );
char* colladaTextBuffer = NULL;
size_t textBufferLen = 0;
uint16 vCount = 0;
uint16 nCount = 0;
uint16 uvCount = 0;
uint16 indexCount = 0;
float* rawColladaVertexData;
float* rawColladaNormalData;
float* rawColladaUVData;
float* rawIndexData;
///Basic Mesh Geometry Data
{
tinyxml2::XMLNode* colladaVertexArray = meshNode->FirstChildElement( "source" );
tinyxml2::XMLElement* vertexFloatArray = colladaVertexArray->FirstChildElement( "float_array" );
tinyxml2::XMLNode* colladaNormalArray = colladaVertexArray->NextSibling();
tinyxml2::XMLElement* normalFloatArray = colladaNormalArray->FirstChildElement( "float_array" );
tinyxml2::XMLNode* colladaUVMapArray = colladaNormalArray->NextSibling();
tinyxml2::XMLElement* uvMapFloatArray = colladaUVMapArray->FirstChildElement( "float_array" );
tinyxml2::XMLElement* meshSrc = meshNode->FirstChildElement( "polylist" );
tinyxml2::XMLElement* colladaIndexArray = meshSrc->FirstChildElement( "p" );
int count;
const char* colladaVertArrayVal = vertexFloatArray->FirstChild()->Value();
vertexFloatArray->QueryAttribute( "count", &count );
vCount = count;
const char* colladaNormArrayVal = normalFloatArray->FirstChild()->Value();
normalFloatArray->QueryAttribute( "count", &count );
nCount = count;
const char* colladaUVMapArrayVal = uvMapFloatArray->FirstChild()->Value();
uvMapFloatArray->QueryAttribute( "count", &count );
uvCount = count;
const char* colladaIndexArrayVal = colladaIndexArray->FirstChild()->Value();
meshSrc->QueryAttribute( "count", &count );
//Assume this is already triangulated
indexCount = count * 3 * 3;
///TODO: replace this with fmaxf?
std::function< size_t (size_t, size_t) > sizeComparison = []( size_t size1, size_t size2 ) -> size_t {
if( size1 >= size2 ) return size1;
return size2;
};
textBufferLen = strlen( colladaVertArrayVal );
textBufferLen = sizeComparison( strlen( colladaNormArrayVal ), textBufferLen );
textBufferLen = sizeComparison( strlen( colladaUVMapArrayVal ), textBufferLen );
textBufferLen = sizeComparison( strlen( colladaIndexArrayVal ), textBufferLen );
colladaTextBuffer = (char*)alloca( textBufferLen );
memset( colladaTextBuffer, 0, textBufferLen );
rawColladaVertexData = (float*)alloca( sizeof(float) * vCount );
rawColladaNormalData = (float*)alloca( sizeof(float) * nCount );
rawColladaUVData = (float*)alloca( sizeof(float) * uvCount );
rawIndexData = (float*)alloca( sizeof(float) * indexCount );
memset( rawColladaVertexData, 0, sizeof(float) * vCount );
memset( rawColladaNormalData, 0, sizeof(float) * nCount );
memset( rawColladaUVData, 0, sizeof(float) * uvCount );
memset( rawIndexData, 0, sizeof(float) * indexCount );
//Reading Vertex position data
strcpy( colladaTextBuffer, colladaVertArrayVal );
TextToNumberConversion( colladaTextBuffer, rawColladaVertexData );
//Reading Normals data
memset( colladaTextBuffer, 0, textBufferLen );
strcpy( colladaTextBuffer, colladaNormArrayVal );
TextToNumberConversion( colladaTextBuffer, rawColladaNormalData );
//Reading UV map data
memset( colladaTextBuffer, 0, textBufferLen );
strcpy( colladaTextBuffer, colladaUVMapArrayVal );
TextToNumberConversion( colladaTextBuffer, rawColladaUVData );
//Reading index data
memset( colladaTextBuffer, 0, textBufferLen );
strcpy( colladaTextBuffer, colladaIndexArrayVal );
TextToNumberConversion( colladaTextBuffer, rawIndexData );
}
float* rawBoneWeightData = NULL;
float* rawBoneIndexData = NULL;
//Skinning Data
{
tinyxml2::XMLElement* libControllers = colladaDoc.FirstChildElement( "COLLADA" )->FirstChildElement( "library_controllers" );
if( libControllers == NULL ) goto skinningExit;
tinyxml2::XMLElement* controllerElement = libControllers->FirstChildElement( "controller" );
if( controllerElement == NULL ) goto skinningExit;
tinyxml2::XMLNode* vertexWeightDataArray = controllerElement->FirstChild()->FirstChild()->NextSibling()->NextSibling()->NextSibling();
tinyxml2::XMLNode* vertexBoneIndexDataArray = vertexWeightDataArray->NextSibling()->NextSibling();
tinyxml2::XMLNode* vCountArray = vertexBoneIndexDataArray->FirstChildElement( "vcount" );
tinyxml2::XMLNode* vArray = vertexBoneIndexDataArray->FirstChildElement( "v" );
const char* boneWeightsData = vertexWeightDataArray->FirstChild()->FirstChild()->Value();
const char* vCountArrayData = vCountArray->FirstChild()->Value();
const char* vArrayData = vArray->FirstChild()->Value();
float* colladaBoneWeightData = NULL;
float* colladaBoneIndexData = NULL;
float* colladaBoneInfluenceCounts = NULL;
///This is overkill, Collada stores ways less data usually, plus this still doesn't account for very complex models
///(e.g, lots of verts with more than MAXBONESPERVERT influencing position )
colladaBoneWeightData = (float*)alloca( sizeof(float) * MAXBONESPERVERT * vCount );
colladaBoneIndexData = (float*)alloca( sizeof(float) * MAXBONESPERVERT * vCount );
colladaBoneInfluenceCounts = (float*)alloca( sizeof(float) * MAXBONESPERVERT * vCount );
//Read bone weights data
memset( colladaTextBuffer, 0, textBufferLen );
strcpy( colladaTextBuffer, boneWeightsData );
TextToNumberConversion( colladaTextBuffer, colladaBoneWeightData );
//Read bone index data
memset( colladaTextBuffer, 0, textBufferLen );
strcpy( colladaTextBuffer, vArrayData );
TextToNumberConversion( colladaTextBuffer, colladaBoneIndexData );
//Read bone influence counts
memset( colladaTextBuffer, 0, textBufferLen );
strcpy( colladaTextBuffer, vCountArrayData );
TextToNumberConversion( colladaTextBuffer, colladaBoneInfluenceCounts );
rawBoneWeightData = (float*)alloca( sizeof(float) * MAXBONESPERVERT * vCount );
rawBoneIndexData = (float*)alloca( sizeof(float) * MAXBONESPERVERT * vCount );
memset( rawBoneWeightData, 0, sizeof(float) * MAXBONESPERVERT * vCount );
memset( rawBoneIndexData, 0, sizeof(float) * MAXBONESPERVERT * vCount );
int colladaIndexIndirection = 0;
int verticiesInfluenced = 0;
vCountArray->Parent()->ToElement()->QueryAttribute( "count", &verticiesInfluenced );
for( uint16 i = 0; i < verticiesInfluenced; i++ ) {
uint8 influenceCount = colladaBoneInfluenceCounts[i];
for( uint16 j = 0; j < influenceCount; j++ ) {
uint16 boneIndex = colladaBoneIndexData[ colladaIndexIndirection++ ];
uint16 weightIndex = colladaBoneIndexData[ colladaIndexIndirection++ ];
rawBoneWeightData[ i * MAXBONESPERVERT + j ] = colladaBoneWeightData[ weightIndex ];
rawBoneIndexData[ i * MAXBONESPERVERT + j ] = boneIndex;
}
}
}
skinningExit:
//Armature
if( armature != NULL ) {
tinyxml2::XMLElement* visualScenesNode = colladaDoc.FirstChildElement( "COLLADA" )->FirstChildElement( "library_visual_scenes" )
->FirstChildElement( "visual_scene" )->FirstChildElement( "node" );
tinyxml2::XMLElement* armatureNode = NULL;
//Step through scene heirarchy until start of armature is found
while( visualScenesNode != NULL ) {
if( visualScenesNode->FirstChildElement( "node" ) != NULL &&
visualScenesNode->FirstChildElement( "node" )->Attribute( "type", "JOINT" ) != NULL ) {
armatureNode = visualScenesNode;
break;
} else {
visualScenesNode = visualScenesNode->NextSibling()->ToElement();
}
}
if( armatureNode == NULL ) return;
//Parsing basic bone data from XML
std::function< Bone* ( tinyxml2::XMLElement*, Armature*, Bone* ) > ParseColladaBoneData =
[&]( tinyxml2::XMLElement* boneElement, Armature* armature, Bone* parentBone ) -> Bone* {
Bone* bone = &armature->bones[ armature->boneCount ];
bone->parent = parentBone;
bone->currentTransform = &armature->boneTransforms[ armature->boneCount ];
SetToIdentity( bone->currentTransform );
bone->boneIndex = armature->boneCount;
armature->boneCount++;
strcpy( &bone->name[0], boneElement->Attribute( "sid" ) );
float matrixData[16];
char matrixTextData [512];
tinyxml2::XMLNode* matrixElement = boneElement->FirstChildElement("matrix");
strcpy( &matrixTextData[0], matrixElement->FirstChild()->ToText()->Value() );
TextToNumberConversion( matrixTextData, matrixData );
//Note: this is only local transform data, but its being saved in bind matrix for now
Mat4 m;
memcpy( &m.m[0][0], &matrixData[0], sizeof(float) * 16 );
bone->bindPose = TransposeMatrix( m );
if( parentBone == NULL ) {
armature->rootBone = bone;
} else {
bone->bindPose = MultMatrix( parentBone->bindPose, bone->bindPose );
}
bone->childCount = 0;
tinyxml2::XMLElement* childBoneElement = boneElement->FirstChildElement( "node" );
while( childBoneElement != NULL ) {
Bone* childBone = ParseColladaBoneData( childBoneElement, armature, bone );
bone->children[ bone->childCount++ ] = childBone;
tinyxml2::XMLNode* siblingNode = childBoneElement->NextSibling();
if( siblingNode != NULL ) {
childBoneElement = siblingNode->ToElement();
} else {
childBoneElement = NULL;
}
};
return bone;
};
armature->boneCount = 0;
tinyxml2::XMLElement* boneElement = armatureNode->FirstChildElement( "node" );
ParseColladaBoneData( boneElement, armature, NULL );
//Parse inverse bind pose data from skinning section of XML
{
tinyxml2::XMLElement* boneNamesSource = colladaDoc.FirstChildElement( "COLLADA" )->FirstChildElement( "library_controllers" )
->FirstChildElement( "controller" )->FirstChildElement( "skin" )->FirstChildElement( "source" );
tinyxml2::XMLElement* boneBindPoseSource = boneNamesSource->NextSibling()->ToElement();
char* boneNamesLocalCopy = NULL;
float* boneMatriciesData = (float*)alloca( sizeof(float) * 16 * armature->boneCount );
const char* boneNameArrayData = boneNamesSource->FirstChild()->FirstChild()->Value();
const char* boneMatrixTextData = boneBindPoseSource->FirstChild()->FirstChild()->Value();
size_t nameDataLen = strlen( boneNameArrayData );
size_t matrixDataLen = strlen( boneMatrixTextData );
boneNamesLocalCopy = (char*)alloca( nameDataLen + 1 );
memset( boneNamesLocalCopy, 0, nameDataLen + 1 );
assert( textBufferLen > matrixDataLen );
memcpy( boneNamesLocalCopy, boneNameArrayData, nameDataLen );
memcpy( colladaTextBuffer, boneMatrixTextData, matrixDataLen );
TextToNumberConversion( colladaTextBuffer, boneMatriciesData );
char* nextBoneName = &boneNamesLocalCopy[0];
for( uint8 matrixIndex = 0; matrixIndex < armature->boneCount; matrixIndex++ ) {
Mat4 matrix;
memcpy( &matrix.m[0], &boneMatriciesData[matrixIndex * 16], sizeof(float) * 16 );
char boneName [32];
char* boneNameEnd = nextBoneName;
do {
boneNameEnd++;
} while( *boneNameEnd != ' ' && *boneNameEnd != 0 );
size_t charCount = boneNameEnd - nextBoneName;
memset( boneName, 0, sizeof( char ) * 32 );
memcpy( boneName, nextBoneName, charCount );
nextBoneName = boneNameEnd + 1;
Bone* targetBone = NULL;
for( uint8 boneIndex = 0; boneIndex < armature->boneCount; boneIndex++ ) {
Bone* bone = &armature->bones[ boneIndex ];
if( strcmp( bone->name, boneName ) == 0 ) {
targetBone = bone;
break;
}
}
Mat4 correction;
correction.m[0][0] = 1.0f; correction.m[0][1] = 0.0f; correction.m[0][2] = 0.0f; correction.m[0][3] = 0.0f;
correction.m[1][0] = 0.0f; correction.m[1][1] = 0.0f; correction.m[1][2] = 1.0f; correction.m[1][3] = 0.0f;
correction.m[2][0] = 0.0f; correction.m[2][1] = -1.0f; correction.m[2][2] = 0.0f; correction.m[2][3] = 0.0f;
correction.m[3][0] = 0.0f; correction.m[3][1] = 0.0f; correction.m[3][2] = 0.0f; correction.m[3][3] = 1.0f;
targetBone->invBindPose = TransposeMatrix( matrix );
targetBone->invBindPose = MultMatrix( correction, targetBone->invBindPose );
}
}
}
//output to my version of storage
storage->dataCount = 0;
uint16 counter = 0;
const uint32 vertCount = indexCount / 3;
storage->vData = (Vec3*)AllocOnSubStack_Aligned( allocater, vertCount * sizeof( Vec3 ), 16 );
storage->uvData = (float*)AllocOnSubStack_Aligned( allocater, vertCount * 2 * sizeof( float ), 4 );
storage->normalData = (Vec3*)AllocOnSubStack_Aligned( allocater, vertCount * sizeof( Vec3 ), 4 );
storage->iData = (uint32*)AllocOnSubStack_Aligned( allocater, vertCount * sizeof( uint32 ), 4 );
if( rawBoneWeightData != NULL ) {
storage->boneWeightData = (float*)AllocOnSubStack_Aligned( allocater, sizeof(float) * vertCount * MAXBONESPERVERT, 4 );
storage->boneIndexData = (uint32*)AllocOnSubStack_Aligned( allocater, sizeof(uint32) * vertCount * MAXBONESPERVERT, 4 );
} else {
storage->boneWeightData = NULL;
storage->boneIndexData = NULL;
}
while( counter < indexCount ) {
Vec3 v, n;
float uv_x, uv_y;
uint16 vertIndex = rawIndexData[ counter++ ];
uint16 normalIndex = rawIndexData[ counter++ ];
uint16 uvIndex = rawIndexData[ counter++ ];
v.x = rawColladaVertexData[ vertIndex * 3 + 0 ];
v.z = -rawColladaVertexData[ vertIndex * 3 + 1 ];
v.y = rawColladaVertexData[ vertIndex * 3 + 2 ];
n.x = rawColladaNormalData[ normalIndex * 3 + 0 ];
n.z = -rawColladaNormalData[ normalIndex * 3 + 1 ];
n.y = rawColladaNormalData[ normalIndex * 3 + 2 ];
uv_x = rawColladaUVData[ uvIndex * 2 ];
uv_y = rawColladaUVData[ uvIndex * 2 + 1 ];
///TODO: check for exact copies of data, use to index to first instance instead
uint32 storageIndex = storage->dataCount;
storage->vData[ storageIndex ] = v;
storage->normalData[ storageIndex ] = n;
storage->uvData[ storageIndex * 2 ] = uv_x;
storage->uvData[ storageIndex * 2 + 1 ] = uv_y;
if( rawBoneWeightData != NULL ) {
uint16 boneDataIndex = storage->dataCount * MAXBONESPERVERT;
uint16 boneVertexIndex = vertIndex * MAXBONESPERVERT;
for( uint8 i = 0; i < MAXBONESPERVERT; i++ ) {
storage->boneWeightData[ boneDataIndex + i ] = rawBoneWeightData[ boneVertexIndex + i ];
storage->boneIndexData[ boneDataIndex + i ] = rawBoneIndexData[ boneVertexIndex + i ];
}
}
storage->iData[ storageIndex ] = storageIndex;
storage->dataCount++;
};
}
void TTrackball::LoadMatrix() const
{
SetMatrix();
MultMatrix();
}
void DemoRender(NaCLContext* psNaCLContext)
{
PP_Resource context = psNaCLContext->hRenderContext;
PPB_OpenGLES2* gl = psNaCLContext->psGL;
float rotY[4][4];
float rotX[4][4];
uint64_t ui64ElapsedTime = GetElapsedTimeMS();
uint64_t ui64DeltaTimeMS = ui64ElapsedTime - psDemoContext->ui64BaseTimeMS;
gl->Viewport(context, 0, 0, psNaCLContext->i32PluginWidth, psNaCLContext->i32PluginHeight);
gl->Enable(context, GL_DEPTH_TEST);
psDemoContext->ui64BaseTimeMS = ui64ElapsedTime;
if(!psDemoContext->sDownloadBaseTexture.iDownloaded ||
!psDemoContext->sDownloadMesh.iDownloaded)
{
gl->ClearColor(context, 0.0, 0.0, 1.0, 1.0f);
gl->Clear(context, GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
#ifdef ENABLE_LOADING_ICON
if(psDemoContext->sDownloadLoadingTexture.iDownloaded == 1)
{
unsigned char* jpeg = 0;
int jpegWidth = 0;
int jpegHeight = 0;
int iNumComponents = 0;
GLenum eFormat;
gl->BindTexture(context, GL_TEXTURE_2D, psDemoContext->sLoadingMap.hTextureGL);
jpeg = jpgd::decompress_jpeg_image_from_memory((unsigned char*)psDemoContext->sDownloadLoadingTexture.data.c_str(),
psDemoContext->sDownloadLoadingTexture.data.length(),
&jpegWidth,
&jpegHeight,
&iNumComponents,
3);
if(!jpeg)
{
DBG_LOG(DBG_LOG_PREFIX"Bad jpeg texture");
return;
}
switch(iNumComponents)
{
case 3:
{
eFormat = GL_RGB;
break;
}
case 4:
{
eFormat = GL_RGBA;
break;
}
default:
{
eFormat = GL_LUMINANCE;
break;
}
}
gl->TexImage2D(context, GL_TEXTURE_2D, 0, eFormat, jpegWidth, jpegHeight, 0, eFormat, GL_UNSIGNED_BYTE, jpeg);
gl->TexParameteri(context, GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
gl->TexParameteri(context, GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
psDemoContext->sDownloadLoadingTexture.iDownloaded = 2;
}
if(psDemoContext->sDownloadLoadingTexture.iDownloaded == 2)
{
DrawQuad(context,
gl,
psDemoContext->sQuad.iVtxCount,
psDemoContext->sQuad.iIdxCount,
psDemoContext->sQuad.hVBO,
psDemoContext->sQuad.hIBO);
}
#endif
return;
}
if(psDemoContext->sDownloadMesh.iDownloaded == 1)
{
LoadJSONMesh(context,
gl,
psDemoContext->sDownloadMesh.data.c_str(),
&psDemoContext->sMeshTransform,
&psDemoContext->sMesh.iIdxCount,
&psDemoContext->sMesh.iVtxCount,
&psDemoContext->sMesh.hVBO,
&psDemoContext->sMesh.hIBO);
psDemoContext->sDownloadMesh.iDownloaded = 2;
}
if(psDemoContext->sDownloadBaseTexture.iDownloaded == 1)
{
unsigned char* jpeg = 0;
int jpegWidth = 0;
int jpegHeight = 0;
int iNumComponents = 0;
GLenum eFormat;
gl->BindTexture(context, GL_TEXTURE_2D, psDemoContext->sBaseMap.hTextureGL);
jpeg = jpgd::decompress_jpeg_image_from_memory((unsigned char*)psDemoContext->sDownloadBaseTexture.data.c_str(),
psDemoContext->sDownloadBaseTexture.data.length(),
&jpegWidth,
&jpegHeight,
&iNumComponents,
3);
if(!jpeg)
{
DBG_LOG(DBG_LOG_PREFIX"Bad jpeg texture");
return;
}
switch(iNumComponents)
{
case 3:
{
eFormat = GL_RGB;
break;
}
case 4:
{
eFormat = GL_RGBA;
break;
}
default:
{
eFormat = GL_LUMINANCE;
break;
}
}
gl->TexImage2D(context, GL_TEXTURE_2D, 0, eFormat, jpegWidth, jpegHeight, 0, eFormat, GL_UNSIGNED_BYTE, jpeg);
gl->TexParameteri(context, GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
gl->TexParameteri(context, GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
psDemoContext->sDownloadBaseTexture.iDownloaded = 2;
}
gl->ClearColor(context, 0.5, 0.5, 0.5, 1.0f);
gl->Clear(context, GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
Identity(psDemoContext->sMeshTransform.rot);
Identity(rotX);
Identity(rotY);
psDemoContext->fAngleY += psDemoContext->fAngleModY * ui64DeltaTimeMS;
psDemoContext->fAngleX += psDemoContext->fAngleModX * ui64DeltaTimeMS;
Rotate(rotY, 0.f,1.f,0.f, psDemoContext->fAngleY);
Rotate(rotX, 1.f,0.f,0.f, psDemoContext->fAngleX);
MultMatrix(psDemoContext->sMeshTransform.rot, rotY, rotX);
gl->BindTexture(context, GL_TEXTURE_2D, psDemoContext->sDisplacementMap.hTextureGL);
gl->UseProgram(context, psDemoContext->hDisplacementMapShader);
gl->Uniform1f(context, gl->GetUniformLocation(context, psDemoContext->hDisplacementMapShader, "HighlightEnabled"), psDemoContext->iHighlightEnabled);
DrawJSONMesh(context,
gl,
&psDemoContext->sMeshTransform,
psDemoContext->sMesh.iVtxCount,
psDemoContext->sMesh.iIdxCount,
psDemoContext->sMesh.hVBO,
psDemoContext->sMesh.hIBO);
}
void MatrixStack::RotateRad(float radians, float x, float y, float z)
{
MultMatrix(Matrix4Df(radians, x, y, z));
}
void RotateZ( float degrees )
{
RageMatrix m;
RageMatrixRotationZ( &m, degrees );
MultMatrix( m );
}
/////////////////////////////////
// cv3dTrackerCalibrateCameras //
/////////////////////////////////
CV_IMPL CvBool cv3dTrackerCalibrateCameras(int num_cameras,
const Cv3dTrackerCameraIntrinsics camera_intrinsics[], // size is num_cameras
CvSize etalon_size,
float square_size,
IplImage *samples[], // size is num_cameras
Cv3dTrackerCameraInfo camera_info[]) // size is num_cameras
{
CV_FUNCNAME("cv3dTrackerCalibrateCameras");
const int num_points = etalon_size.width * etalon_size.height;
int cameras_done = 0; // the number of cameras whose positions have been determined
CvPoint3D32f *object_points = NULL; // real-world coordinates of checkerboard points
CvPoint2D32f *points = NULL; // 2d coordinates of checkerboard points as seen by a camera
IplImage *gray_img = NULL; // temporary image for color conversion
IplImage *tmp_img = NULL; // temporary image used by FindChessboardCornerGuesses
int c, i, j;
if (etalon_size.width < 3 || etalon_size.height < 3)
CV_ERROR(CV_StsBadArg, "Chess board size is invalid");
for (c = 0; c < num_cameras; c++)
{
// CV_CHECK_IMAGE is not available in the cvaux library
// so perform the checks inline.
//CV_CALL(CV_CHECK_IMAGE(samples[c]));
if( samples[c] == NULL )
CV_ERROR( CV_HeaderIsNull, "Null image" );
if( samples[c]->dataOrder != IPL_DATA_ORDER_PIXEL && samples[c]->nChannels > 1 )
CV_ERROR( CV_BadOrder, "Unsupported image format" );
if( samples[c]->maskROI != 0 || samples[c]->tileInfo != 0 )
CV_ERROR( CV_StsBadArg, "Unsupported image format" );
if( samples[c]->imageData == 0 )
CV_ERROR( CV_BadDataPtr, "Null image data" );
if( samples[c]->roi &&
((samples[c]->roi->xOffset | samples[c]->roi->yOffset
| samples[c]->roi->width | samples[c]->roi->height) < 0 ||
samples[c]->roi->xOffset + samples[c]->roi->width > samples[c]->width ||
samples[c]->roi->yOffset + samples[c]->roi->height > samples[c]->height ||
(unsigned) (samples[c]->roi->coi) > (unsigned) (samples[c]->nChannels)))
CV_ERROR( CV_BadROISize, "Invalid ROI" );
// End of CV_CHECK_IMAGE inline expansion
if (samples[c]->depth != IPL_DEPTH_8U)
CV_ERROR(CV_BadDepth, "Channel depth of source image must be 8");
if (samples[c]->nChannels != 3 && samples[c]->nChannels != 1)
CV_ERROR(CV_BadNumChannels, "Source image must have 1 or 3 channels");
}
CV_CALL(object_points = (CvPoint3D32f *)cvAlloc(num_points * sizeof(CvPoint3D32f)));
CV_CALL(points = (CvPoint2D32f *)cvAlloc(num_points * sizeof(CvPoint2D32f)));
// fill in the real-world coordinates of the checkerboard points
FillObjectPoints(object_points, etalon_size, square_size);
for (c = 0; c < num_cameras; c++)
{
CvSize image_size = cvSize(samples[c]->width, samples[c]->height);
IplImage *img;
// The input samples are not required to all have the same size or color
// format. If they have different sizes, the temporary images are
// reallocated as necessary.
if (samples[c]->nChannels == 3)
{
// convert to gray
if (gray_img == NULL || gray_img->width != samples[c]->width ||
gray_img->height != samples[c]->height )
{
if (gray_img != NULL)
cvReleaseImage(&gray_img);
CV_CALL(gray_img = cvCreateImage(image_size, IPL_DEPTH_8U, 1));
}
CV_CALL(cvCvtColor(samples[c], gray_img, CV_BGR2GRAY));
img = gray_img;
}
else
{
// no color conversion required
img = samples[c];
}
if (tmp_img == NULL || tmp_img->width != samples[c]->width ||
tmp_img->height != samples[c]->height )
{
if (tmp_img != NULL)
cvReleaseImage(&tmp_img);
CV_CALL(tmp_img = cvCreateImage(image_size, IPL_DEPTH_8U, 1));
}
int count = num_points;
bool found = cvFindChessBoardCornerGuesses(img, tmp_img, 0,
etalon_size, points, &count) != 0;
if (count == 0)
continue;
// If found is true, it means all the points were found (count = num_points).
// If found is false but count is non-zero, it means that not all points were found.
cvFindCornerSubPix(img, points, count, cvSize(5,5), cvSize(-1,-1),
cvTermCriteria(CV_TERMCRIT_ITER|CV_TERMCRIT_EPS, 10, 0.01f));
// If the image origin is BL (bottom-left), fix the y coordinates
// so they are relative to the true top of the image.
if (samples[c]->origin == IPL_ORIGIN_BL)
{
for (i = 0; i < count; i++)
points[i].y = samples[c]->height - 1 - points[i].y;
}
if (found)
{
// Make sure x coordinates are increasing and y coordinates are decreasing.
// (The y coordinate of point (0,0) should be the greatest, because the point
// on the checkerboard that is the origin is nearest the bottom of the image.)
// This is done after adjusting the y coordinates according to the image origin.
if (points[0].x > points[1].x)
{
// reverse points in each row
for (j = 0; j < etalon_size.height; j++)
{
CvPoint2D32f *row = &points[j*etalon_size.width];
for (i = 0; i < etalon_size.width/2; i++)
std::swap(row[i], row[etalon_size.width-i-1]);
}
}
if (points[0].y < points[etalon_size.width].y)
{
// reverse points in each column
for (i = 0; i < etalon_size.width; i++)
{
for (j = 0; j < etalon_size.height/2; j++)
std::swap(points[i+j*etalon_size.width],
points[i+(etalon_size.height-j-1)*etalon_size.width]);
}
}
}
DrawEtalon(samples[c], points, count, etalon_size, found);
if (!found)
continue;
float rotVect[3];
float rotMatr[9];
float transVect[3];
cvFindExtrinsicCameraParams(count,
image_size,
points,
object_points,
const_cast<float *>(camera_intrinsics[c].focal_length),
camera_intrinsics[c].principal_point,
const_cast<float *>(camera_intrinsics[c].distortion),
rotVect,
transVect);
// Check result against an arbitrary limit to eliminate impossible values.
// (If the chess board were truly that far away, the camera wouldn't be able to
// see the squares.)
if (transVect[0] > 1000*square_size
|| transVect[1] > 1000*square_size
|| transVect[2] > 1000*square_size)
{
// ignore impossible results
continue;
}
CvMat rotMatrDescr = cvMat(3, 3, CV_32FC1, rotMatr);
CvMat rotVectDescr = cvMat(3, 1, CV_32FC1, rotVect);
/* Calc rotation matrix by Rodrigues Transform */
cvRodrigues2( &rotVectDescr, &rotMatrDescr );
//combine the two transformations into one matrix
//order is important! rotations are not commutative
float tmat[4][4] = { { 1.f, 0.f, 0.f, 0.f },
{ 0.f, 1.f, 0.f, 0.f },
{ 0.f, 0.f, 1.f, 0.f },
{ transVect[0], transVect[1], transVect[2], 1.f } };
float rmat[4][4] = { { rotMatr[0], rotMatr[1], rotMatr[2], 0.f },
{ rotMatr[3], rotMatr[4], rotMatr[5], 0.f },
{ rotMatr[6], rotMatr[7], rotMatr[8], 0.f },
{ 0.f, 0.f, 0.f, 1.f } };
MultMatrix(camera_info[c].mat, tmat, rmat);
// change the transformation of the cameras to put them in the world coordinate
// system we want to work with.
// Start with an identity matrix; then fill in the values to accomplish
// the desired transformation.
float smat[4][4] = { { 1.f, 0.f, 0.f, 0.f },
{ 0.f, 1.f, 0.f, 0.f },
{ 0.f, 0.f, 1.f, 0.f },
{ 0.f, 0.f, 0.f, 1.f } };
// First, reflect through the origin by inverting all three axes.
smat[0][0] = -1.f;
smat[1][1] = -1.f;
smat[2][2] = -1.f;
MultMatrix(tmat, camera_info[c].mat, smat);
// Scale x and y coordinates by the focal length (allowing for non-square pixels
// and/or non-symmetrical lenses).
smat[0][0] = 1.0f / camera_intrinsics[c].focal_length[0];
smat[1][1] = 1.0f / camera_intrinsics[c].focal_length[1];
smat[2][2] = 1.0f;
MultMatrix(camera_info[c].mat, smat, tmat);
camera_info[c].principal_point = camera_intrinsics[c].principal_point;
camera_info[c].valid = true;
cameras_done++;
}
exit:
cvReleaseImage(&gray_img);
cvReleaseImage(&tmp_img);
cvFree(&object_points);
cvFree(&points);
return cameras_done == num_cameras;
}
// Right multiply the current matrix with the computed scale
// matrix. (transformation is about the current world origin)
void Scale( float x, float y, float z )
{
RageMatrix m;
RageMatrixScaling( &m, x, y, z );
MultMatrix( m );
}
void SpinCamera::LoadMatrix()
{
glLoadIdentity();
MultMatrix();
}
// Right multiply the current matrix with the computed translation
// matrix. (transformation is about the current world origin)
void Translate( float x, float y, float z )
{
RageMatrix m;
RageMatrixTranslation( &m, x, y, z );
MultMatrix( m );
}
void LoadAnimationDataFromCollada( const char* fileName, ArmatureKeyFrame* keyframe, Armature* armature ) {
tinyxml2::XMLDocument colladaDoc;
colladaDoc.LoadFile( fileName );
tinyxml2::XMLNode* animationNode = colladaDoc.FirstChildElement( "COLLADA" )->FirstChildElement( "library_animations" )->FirstChild();
while( animationNode != NULL ) {
//Desired data: what bone, and what local transform to it occurs
Mat4 boneLocalTransform;
Bone* targetBone = NULL;
//Parse the target attribute from the XMLElement for channel, and get the bone it corresponds to
const char* transformName = animationNode->FirstChildElement( "channel" )->Attribute( "target" );
size_t nameLen = strlen( transformName );
char* transformNameCopy = (char*)alloca( nameLen );
strcpy( transformNameCopy, transformName );
char* nameEnd = transformNameCopy;
while( *nameEnd != '/' && *nameEnd != 0 ) {
nameEnd++;
}
memset( transformNameCopy, 0, nameLen );
nameLen = nameEnd - transformNameCopy;
memcpy( transformNameCopy, transformName, nameLen );
for( uint8 boneIndex = 0; boneIndex < armature->boneCount; boneIndex++ ) {
if( strcmp( armature->bones[ boneIndex ].name, transformNameCopy ) == 0 ) {
targetBone = &armature->bones[ boneIndex ];
break;
}
}
//Parse matrix data, and extract first keyframe data
tinyxml2::XMLNode* transformMatrixElement = animationNode->FirstChild()->NextSibling();
const char* matrixTransformData = transformMatrixElement->FirstChild()->FirstChild()->Value();
size_t transformDataLen = strlen( matrixTransformData ) + 1;
char* transformDataCopy = (char*)alloca( transformDataLen * sizeof( char ) );
memset( transformDataCopy, 0, transformDataLen );
memcpy( transformDataCopy, matrixTransformData, transformDataLen );
int count = 0;
transformMatrixElement->FirstChildElement()->QueryAttribute( "count", &count );
float* rawTransformData = (float*)alloca( count * sizeof(float) );
memset( rawTransformData, 0, count * sizeof(float) );
TextToNumberConversion( transformDataCopy, rawTransformData );
memcpy( &boneLocalTransform.m[0][0], &rawTransformData[0], 16 * sizeof(float) );
//Save data in BoneKeyFrame struct
boneLocalTransform = TransposeMatrix( boneLocalTransform );
if( targetBone == armature->rootBone ) {
Mat4 correction;
correction.m[0][0] = 1.0f; correction.m[0][1] = 0.0f; correction.m[0][2] = 0.0f; correction.m[0][3] = 0.0f;
correction.m[1][0] = 0.0f; correction.m[1][1] = 0.0f; correction.m[1][2] = -1.0f; correction.m[1][3] = 0.0f;
correction.m[2][0] = 0.0f; correction.m[2][1] = 1.0f; correction.m[2][2] = 0.0f; correction.m[2][3] = 0.0f;
correction.m[3][0] = 0.0f; correction.m[3][1] = 0.0f; correction.m[3][2] = 0.0f; correction.m[3][3] = 1.0f;
boneLocalTransform = MultMatrix( boneLocalTransform, correction );
}
BoneKeyFrame* key = &keyframe->targetBoneTransforms[ targetBone->boneIndex ];
key->combinedMatrix = boneLocalTransform;
DecomposeMat4( boneLocalTransform, &key->scale, &key->rotation, &key->translation );
Mat4 m = Mat4FromComponents( key->scale, key->rotation, key->translation );
animationNode = animationNode->NextSibling();
}
//Pre multiply bones with parents to save doing it during runtime
struct {
ArmatureKeyFrame* keyframe;
void PremultiplyKeyFrame( Bone* target, Mat4 parentTransform ) {
BoneKeyFrame* boneKey = &keyframe->targetBoneTransforms[ target->boneIndex ];
Mat4 netMatrix = MultMatrix( boneKey->combinedMatrix, parentTransform );
for( uint8 boneIndex = 0; boneIndex < target->childCount; boneIndex++ ) {
PremultiplyKeyFrame( target->children[ boneIndex ], netMatrix );
}
boneKey->combinedMatrix = netMatrix;
DecomposeMat4( boneKey->combinedMatrix, &boneKey->scale, &boneKey->rotation, &boneKey->translation );
}
}LocalRecursiveScope;
LocalRecursiveScope.keyframe = keyframe;
Mat4 i; SetToIdentity( &i );
LocalRecursiveScope.PremultiplyKeyFrame( armature->rootBone, i );
}
void LocationSelect:: Draw () {
Matrix transformation;
local_transformation.to_matrix(transformation);
GFXLoadIdentity(MODEL);
GFXMultMatrixModel (transformation);
/*
GFXEnable(DEPTHWRITE);
GFXEnable(DEPTHTEST);
GFXDisable(TEXTURE0);
GFXDisable(TEXTURE1);
GFXDisable(LIGHTING);
GFXPushBlendMode();
// GFXBlendMode(SRCALPHA,INVSRCALPHA);
//GFXColor4f (parentScene->HUDColor.r, parentScene->HUDColor.g, parentScene->HUDColor.b, parentScene->HUDColor.a);
GFXColor4f (0,.5,0,.3);
*/
#ifdef DELTA_MOVEMENT
if (vert) {
LocalPosition.k=0;
}
vert=false;
if (DeltaPosition.k) {
LocalPosition.k-=DeltaPosition.k*.3;
DeltaPosition.k=0;
}
#endif
if (changed||vert) {
Matrix t,m;
Matrix v;
GFXGetMatrixView (v);
GFXGetMatrixModel (m);
MultMatrix(t,v,m);
//following translates 'z'...not sure it's necessary
// Translate (v,0,0,LocalPosition.k);
// MultMatrix (m,t,v);
//the location in camera coordinates of the beginning of the location select
Vector tLocation (t.p.Cast());
Vector tP (t.getP());//the p vector of the plane being selected on
Vector tQ (t.getQ());//the q vector of the plane being selected on
///unused Vector tR (t[8],t[9],t[10]);//the q vector of the plane being selected on
//VSFileSystem::Fprintf (stderr,"<%f,%f,%f>",t[0],t[1],t[2]);
//VSFileSystem::Fprintf (stderr,"<%f,%f,%f>",t[4],t[5],t[6]);
//VSFileSystem::Fprintf (stderr,"<%f,%f,%f>",t[8],t[9],t[10]);
#ifdef DELTA_MOVEMENT
float zvalueXY = tLocation.k+LocalPosition.i*tP.k+LocalPosition.j*tQ.k; // z val of the parallelogram
#else
float zvalueXY = tLocation.k+LocalPosition.i*tP.k+LocalPosition.j*tQ.k+LocalPosition.k*tR.k; //zvalue of the cursor
#endif
if (changed&&!vert) { //planar movement
if (zvalueXY >1000) /// zfar
zvalueXY = 1000;
if (zvalueXY<-1000)
zvalueXY = -1000;
LocalPosition.i= fabs(zvalueXY)*(((2*DeltaPosition.i/g_game.x_resolution - 1)*g_game.MouseSensitivityX*GFXGetXInvPerspective()*tP.i)-(1-(2*DeltaPosition.j/g_game.y_resolution)*g_game.MouseSensitivityY*GFXGetYInvPerspective()*tP.j));
LocalPosition.j= fabs(zvalueXY)*(((2*DeltaPosition.i/g_game.x_resolution - 1)*g_game.MouseSensitivityX*GFXGetXInvPerspective()*tQ.i)-(1-(2*DeltaPosition.j/g_game.y_resolution)*tQ.j*g_game.MouseSensitivityY*GFXGetYInvPerspective()));
DeltaPosition= Vector(0,0,0);
// Vector TransPQR (t[0]*i+t[4]*LocalPosition.j+t[8]*LocalPosition.k+t[12],t[1]*LocalPosition.i+t[5]*LocalPosition.j+t[9]*LocalPosition.k+t[13],t[2]*LocalPosition.i+t[6]*LocalPosition.j+t[10]*LocalPosition.k+t[14]);
changed=false;
}
#ifndef DELTA_MOVEMENT
else { //vertical movement
if (zvalueXY >1000) /// zfar
zvalueXY = 1000;
if (zvalueXY<-1000)
zvalueXY = -1000;
LocalPosition.k= fabs(zvalueXY)*(((2*DeltaPosition.i/g_game.x_resolution - 1)*g_game.MouseSensitivityX*GFXGetXInvPerspective()*tR.i)-((2*DeltaPosition.j/g_game.y_resolution -1)*g_game.MouseSensitivityY*GFXGetYInvPerspective()*tR.j));
if (DeltaPosition.k) {
LocalPosition.k=0;
DeltaPosition.k=0;
}
vert =false;
changed=false;
}
#endif
}
//draw the animation
LocSelUpAni.SetPosition (QVector (LocalPosition.i,LocalPosition.j,0));
LocSelUpAni.Draw();
LocSelAni.SetPosition(LocalPosition);
LocSelAni.Draw();
/*
GFXBegin(TRIANGLES);
if (fabs(LocalPosition.k-CrosshairSize)>CrosshairSize) {
int tmp;
if (LocalPosition.k>=0)
tmp =1;
else
tmp =-1;
GFXVertex3f (LocalPosition.i,LocalPosition.j,LocalPosition.k-tmp*CrosshairSize);
GFXVertex3f (LocalPosition.i,LocalPosition.j+CrosshairSize*.125,0);
GFXVertex3f (LocalPosition.i,LocalPosition.j-CrosshairSize*.125,0);
GFXVertex3f (LocalPosition.i,LocalPosition.j-CrosshairSize*.125,0);
GFXVertex3f (LocalPosition.i,LocalPosition.j+CrosshairSize*.125,0);
GFXVertex3f (LocalPosition.i,LocalPosition.j,LocalPosition.k-tmp*CrosshairSize);
GFXVertex3f (LocalPosition.i,LocalPosition.j,LocalPosition.k-tmp*CrosshairSize);
GFXVertex3f (LocalPosition.i+.125*CrosshairSize,LocalPosition.j,0);
GFXVertex3f (LocalPosition.i-CrosshairSize*.125,LocalPosition.j,0);
GFXVertex3f (LocalPosition.i-CrosshairSize*.125,LocalPosition.j,0);
GFXVertex3f (LocalPosition.i+CrosshairSize*.125,LocalPosition.j,0);
GFXVertex3f (LocalPosition.i,LocalPosition.j,LocalPosition.k-tmp*CrosshairSize);
}
if (fabs(LocalPosition.i)+fabs(LocalPosition.j)>CrosshairSize) {
GFXVertex3f (0,0,0);
GFXVertex3f (LocalPosition.i,LocalPosition.j,CrosshairSize*.125);
GFXVertex3f (LocalPosition.i,LocalPosition.j,CrosshairSize*-.125);
GFXVertex3f (LocalPosition.i,LocalPosition.j,CrosshairSize*-.125);
GFXVertex3f (LocalPosition.i,LocalPosition.j,CrosshairSize*.125);
GFXVertex3f (0,0,0);
}
POSITION_GFXVertex (0,0,0);
POSITION_GFXVertex (1,.1,.1);
POSITION_GFXVertex (1,.1,-.1);
POSITION_GFXVertex (0,0,0);
POSITION_GFXVertex (1,-.1,-.1);
POSITION_GFXVertex (1,-.1,.1);
POSITION_GFXVertex (0,0,0);
POSITION_GFXVertex (1,-.1,.1);
POSITION_GFXVertex (1,.1,.1);
POSITION_GFXVertex (0,0,0);
POSITION_GFXVertex (1,.1,-.1);
POSITION_GFXVertex (1,-.1,-.1);//one of the arrows to point
POSITION_GFXVertex (0,0,0);
POSITION_GFXVertex (-1,.1,-.1);
POSITION_GFXVertex (-1,.1,.1);
POSITION_GFXVertex (0,0,0);
POSITION_GFXVertex (-1,-.1,.1);
POSITION_GFXVertex (-1,-.1,-.1);
POSITION_GFXVertex (0,0,0);
POSITION_GFXVertex (-1,.1,.1);
POSITION_GFXVertex (-1,-.1,.1);
POSITION_GFXVertex (0,0,0);
POSITION_GFXVertex (-1,-.1,-.1);
POSITION_GFXVertex (-1,.1,-.1);//one of the arrows to point
//vertical
POSITION_GFXVertex (0,0,0);
POSITION_GFXVertex (.1,.1,1);
POSITION_GFXVertex (.1,-.1,1);
POSITION_GFXVertex (0,0,0);
POSITION_GFXVertex (-.1,-.1,1);
POSITION_GFXVertex (-.1,.1,1);
POSITION_GFXVertex (0,0,0);
POSITION_GFXVertex (-.1,.1,1);
POSITION_GFXVertex (.1,.1,1);
POSITION_GFXVertex (0,0,0);
POSITION_GFXVertex (.1,-.1,1);
POSITION_GFXVertex(-.1,-.1,1);//one of the arrows to point
POSITION_GFXVertex (0,0,0);
POSITION_GFXVertex (.1,-.1,-1);
POSITION_GFXVertex (.1,.1,-1);
POSITION_GFXVertex (0,0,0);
POSITION_GFXVertex (-.1,.1,-1);
POSITION_GFXVertex (-.1,-.1,-1);
POSITION_GFXVertex (0,0,0);
POSITION_GFXVertex (.1,.1,-1);
POSITION_GFXVertex (-.1,.1,-1);
POSITION_GFXVertex (0,0,0);
POSITION_GFXVertex (-.1,-.1,-1);
POSITION_GFXVertex (.1,-.1,-1);//one of the arrows to point
POSITION_GFXVertex (0,0,0);
POSITION_GFXVertex (.1,-1,.1);
POSITION_GFXVertex (.1,-1,-.1);
POSITION_GFXVertex (0,0,0);
POSITION_GFXVertex (-.1,-1,-.1);
POSITION_GFXVertex (-.1,-1,.1);
POSITION_GFXVertex (0,0,0);
POSITION_GFXVertex (-.1,-1,.1);
POSITION_GFXVertex (.1,-1,.1);
POSITION_GFXVertex (0,0,0);
POSITION_GFXVertex (.1,-1,-.1);
POSITION_GFXVertex (-.1,-1,-.1);//one of the arrows to point
POSITION_GFXVertex (0,0,0);
POSITION_GFXVertex (.1,1,-.1);
POSITION_GFXVertex (.1,1,.1);
POSITION_GFXVertex (0,0,0);
POSITION_GFXVertex (-.1,1,.1);
POSITION_GFXVertex (-.1,1,-.1);
POSITION_GFXVertex (0,0,0);
POSITION_GFXVertex (.1,1,.1);
POSITION_GFXVertex (-.1,1,.1);
POSITION_GFXVertex (0,0,0);
POSITION_GFXVertex (-.1,1,-.1);
POSITION_GFXVertex (.1,1,-.1);//one of the arrows to point
GFXEnd();
GFXBegin (QUADS);
//GFXColor4f (parentScene->HUDColor.r, parentScene->HUDColor.g, parentScene->HUDColor.b, 1.5*parentScene->HUDColor.a);
GFXVertex3f(.5*CrosshairSize +LocalPosition.i,LocalPosition.j,0);
GFXVertex3f(LocalPosition.i,.5*CrosshairSize+LocalPosition.j,0);
GFXVertex3f(-.5*CrosshairSize +LocalPosition.i,LocalPosition.j,0);
GFXVertex3f(LocalPosition.i,-.5*CrosshairSize+LocalPosition.j,0);
GFXVertex3f(LocalPosition.i,-.5*CrosshairSize+LocalPosition.j,0);
GFXVertex3f(-.5*CrosshairSize +LocalPosition.i,LocalPosition.j,0);
GFXVertex3f(LocalPosition.i,.5*CrosshairSize+LocalPosition.j,0);
GFXVertex3f(.5*CrosshairSize +LocalPosition.i,LocalPosition.j,0);
GFXColor4f (0,.5,0,.5);
POSITION_GFXVertex (1,.1,.1); //cap
POSITION_GFXVertex (1,-.1,.1);
POSITION_GFXVertex (1,-.1,-.1);
POSITION_GFXVertex (1,.1,-.1);
POSITION_GFXVertex (-1,.1,-.1);
POSITION_GFXVertex (-1,-.1,-.1);
POSITION_GFXVertex (-1,-.1,.1);
POSITION_GFXVertex (-1,.1,.1); //cap
POSITION_GFXVertex (.1,-1,.1); //cap
POSITION_GFXVertex (-.1,-1,.1);
POSITION_GFXVertex (-.1,-1,-.1);
POSITION_GFXVertex (.1,-1,-.1);
POSITION_GFXVertex (.1,1,-.1);
POSITION_GFXVertex (-.1,1,-.1);
POSITION_GFXVertex (-.1,1,.1);
POSITION_GFXVertex (.1,1,.1); //cap
POSITION_GFXVertex (.1,.1,1); //cap
POSITION_GFXVertex (-.1,.1,1);
POSITION_GFXVertex (-.1,-.1,1);
POSITION_GFXVertex (.1,-.1,1);
POSITION_GFXVertex (.1,-.1,-1);
POSITION_GFXVertex (-.1,-.1,-1);
POSITION_GFXVertex (-.1,.1,-1);
POSITION_GFXVertex (.1,.1,-1); //cap
GFXEnd();
*/
GFXPopBlendMode();
}
