Générer des sommets pour une sphère

Dans le DirectX mobile de l'éclairage de l'échantillon, un cylindre est généré de la manière suivante:

for( DWORD i=0; i<50; i++ )
            {
                FLOAT theta = (2*D3DMX_PI*i)/(50-1);
                pVertices[2*i+0].position = D3DMXVECTOR3( (float)sin(theta),-1.0f, (float)cos(theta) );
                pVertices[2*i+0].normal   = D3DMXVECTOR3( (float)sin(theta), 0.0f, (float)cos(theta) );
                pVertices[2*i+1].position = D3DMXVECTOR3( (float)sin(theta), 1.0f, (float)cos(theta) );
                pVertices[2*i+1].normal   = D3DMXVECTOR3( (float)sin(theta), 0.0f, (float)cos(theta) );
            }

Est-il une manière similaire à générer des sommets pour une sphère en DirectX Mobile(comme un triangle strip ou autre)? (Autant que je sache, il n'y a pas D3DMXCreateSphere méthode)


La solution finale .Grâce à quarternion pour l'ensemble de son aide.

void CreateSphere()
{
const int iFactor = 20;
int iPos = 0;
arr_Vertices = new CUSTOMVERTEX[ui_VCount];
ui_ShapeCount = iFactor *iFactor * 2; //use when rendering
float arrV[iFactor* iFactor][3];
for (DWORD j= 0; j < iFactor; j ++)
{
FLOAT theta = (D3DMX_PI*j)/(iFactor);
for( DWORD i=0; i<iFactor; i++ )
{
iPos = j*iFactor+i;
FLOAT phi = (2*D3DMX_PI*i)/(iFactor);
arrV[iPos][0] = (float)(sin(theta)*cos(phi));
arrV[iPos][1] = (float)(sin(theta)*sin(phi));
arrV[iPos][2] = (float)(cos(theta));
/*std::cout << "[" << j <<"][" << i << "] = " << arrV[iPos][0]  
<< "," << arrV[iPos][1] << "," << arrV[iPos][2] <<std::endl;*/
}
}
int iNext = 0;
for (DWORD j= 0; j < iFactor; j ++)
{ 
for( DWORD i=0; i<iFactor; i++ )
{
if (i == iFactor - 1)
iNext = 0;
else iNext = i +1;
iPos = (j*iFactor*6)+(i*6);
arr_Vertices[iPos].position = D3DMXVECTOR3( arrV[j*iFactor+i][0], arrV[j*iFactor+i][1], arrV[j*iFactor+i][2]);
arr_Vertices[iPos + 1].position = D3DMXVECTOR3( arrV[j*iFactor+iNext][0], arrV[j*iFactor+iNext][1], arrV[j*iFactor+iNext][2]);
if (j != iFactor -1)
arr_Vertices[iPos + 2].position = D3DMXVECTOR3( arrV[((j+1)*iFactor)+i][0], arrV[((j+1)*iFactor)+i][1], arrV[((j+1)*iFactor)+i][2]);
else
arr_Vertices[iPos + 2].position = D3DMXVECTOR3( 0, 0, -1); //Create a pseudo triangle fan for the last set of triangles
arr_Vertices[iPos].normal = D3DMXVECTOR3( arr_Vertices[iPos].position.x, arr_Vertices[iPos].position.y, arr_Vertices[iPos].position.z);
arr_Vertices[iPos + 1].normal = D3DMXVECTOR3( arr_Vertices[iPos+1].position.x, arr_Vertices[iPos+1].position.y, arr_Vertices[iPos+1].position.z);
arr_Vertices[iPos + 2].normal = D3DMXVECTOR3( arr_Vertices[iPos+2].position.x, arr_Vertices[iPos+2].position.y, arr_Vertices[iPos+2].position.z);
arr_Vertices[iPos + 3].position = D3DMXVECTOR3( arr_Vertices[iPos+2].position.x, arr_Vertices[iPos+2].position.y, arr_Vertices[iPos+2].position.z);
arr_Vertices[iPos + 4].position = D3DMXVECTOR3( arr_Vertices[iPos+1].position.x, arr_Vertices[iPos+1].position.y, arr_Vertices[iPos+1].position.z);
if (j != iFactor - 1)
arr_Vertices[iPos + 5].position = D3DMXVECTOR3( arrV[((j+1)*iFactor)+iNext][0], arrV[((j+1)*iFactor)+iNext][1], arrV[((j+1)*iFactor)+iNext][2]);
else
arr_Vertices[iPos + 5].position = D3DMXVECTOR3( 0,0,-1);
arr_Vertices[iPos + 3].normal = D3DMXVECTOR3( arr_Vertices[iPos+3].position.x, arr_Vertices[iPos+3].position.y, arr_Vertices[iPos+3].position.z);
arr_Vertices[iPos + 4].normal = D3DMXVECTOR3( arr_Vertices[iPos+4].position.x, arr_Vertices[iPos+4].position.y, arr_Vertices[iPos+4].position.z);
arr_Vertices[iPos + 5].normal = D3DMXVECTOR3( arr_Vertices[iPos+5].position.x, arr_Vertices[iPos+5].position.y, arr_Vertices[iPos+5].position.z);
//std::cout << "[" << iPos <<"] = " << arr_Vertices[iPos].position.x << 
// "," << arr_Vertices[iPos].position.y <<
// "," << arr_Vertices[iPos].position.z <<std::endl;
//std::cout << "[" << iPos + 1 <<"] = " << arr_Vertices[iPos + 1].position.x << 
// "," << arr_Vertices[iPos+ 1].position.y <<
// "," << arr_Vertices[iPos+ 1].position.z <<std::endl;
//std::cout << "[" << iPos + 2 <<"] = " << arr_Vertices[iPos].position.x << 
// "," << arr_Vertices[iPos + 2].position.y <<
// "," << arr_Vertices[iPos + 2].position.z <<std::endl;
}
}
}

Devrait être utilisable avec seulement quelques ajustements. Cela crée un TRIANGLELIST mais pourrait être modifié à la sortie d'un jeu de triangle bandes

Avez-vous des exigences en ce qui concerne, par exemple, la distance minimale entre deux sommets?
Non, il n'y a pas une telle exigence. J'ai essayé de trouver une formule pour cela un moment mais a échoué. Si je pouvais obtenir un blocage de la base, je pense que je serais capable de le tordre pour la performance
Est-il quelque chose de mal avec l'aide de D3DXCreateSphere()? À tout le moins, vous pouvez copier les sommets, il crée un autre endroit si vous ne voulez pas le ID3DXMesh objet. La Documentation MSDN ici: msdn.microsoft.com/en-us/library/bb172795(SV.85).aspx
Désolé tbridge. Je devrais avoir mentionné que c'était pour le directx mobile api. Il n'y a pas de méthode similaire de D3DXCreateSphere().
Il y a un statique Mesh.Sphere() méthode pour le Mobile de l'API DirectX trop? Ou suis-je toujours pas la compréhension :)? msdn.microsoft.com/en-us/library/...

OriginalL'auteur Gayan | 2010-12-10