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
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
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).aspxDé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
Vous devez vous connecter pour publier un commentaire.
Moyen de base de réflexion à ce sujet:
Première méthode pas à l'aide d'un continu triangle strip...
Il a été un moment donc je risque de faire une erreur...
Un cercle unité définie paramétriquement:
Maintenant que nous pouvons définir un cercle unique, imaginez anneaux concentriques sur le x,y de l'avion.
Maintenant, imaginez la levée de l'intérieur la plupart cercle et comme vous le porter, il tire vers le haut le côté de l'anneau, comme un slinky... Ce visuel ne fonctionne que pour une demi-sphère.
De sorte que la forme qui produit la forme d'une sphère à partir d'anneaux concentriques est bien sûr un autre cercle qui est orthogonale à la anneaux, le (z,y) avion... bien sûr, nous sommes uniquement intéressés à trouver le décalage de l'anneau (élevé ou faible, il doit être compensé par la (x,y) d'avion.
Parce que nous avons juste besoin de l'offset, nous avons seulement besoin d'un demi-cercle... et de plus les pôles ne seront qu'un seul point. L'utilisation d'un triangle de ventilateur dans les pôles et les bandes entre chaque anneau.
Après cet exercice mental voir http://en.wikipedia.org/wiki/Sphere
et de la recherche pour "Les points sur la sphère de rayon r peut être paramétrées via" et vous verrez la forme paramétrique après cette ligne.
Les normales sont très faciles la sphère devrait toujours être construit autour de (0,0,0) et de la sphère devrait toujours être construit avec un rayon de 1 (de sorte que vous pouvez simplement adapter à la taille souhaitée) et ensuite chaque sommet sur le cercle à la surface est égale à la normale.
La méthode ci-dessus utilise deux triangle de fans et une série de triangle bandes... une autre méthode qui produit une sphère avec une distribution uniforme des points et peuvent être tirées avec un seul triangle strip, bien que le moment j'irais fou en essayant de code, il implique l'idée suivante:
Imaginer un tétraèdre centré sur l'origine (les points sont 1 unité de 0,0,0). Il est assez pathétique de la représentation d'une sphère, mais c'est une approximation. Imaginons maintenant que nous ayons trouver le point milieu sur chacune des quatre faces, puis poussez ce point jusqu'à ce qu'il est sur la surface de la sphère. Ensuite, nous trouvons au milieu de ces visages et de les pousser hors de la surface de la sphère...
tetrahdralSphere(int récurrences){}
Trouver le point milieu est très simple, il est juste dans la moyenne de chacun des x,y,z les composants. Alors, étant donné que la sphère est une sphère unité déplaçant à la surface est aussi simple que la normalisation de ce nouveau vecteur.
Méthode que l'on produit un point de distribution qui regarde les lignes de longitude et de latitude et produit une non distribution uniforme (il ressemble à un globe si l'utilisation de quads et d'un fil de trame), il est assez facile à mettre en œuvre. La seconde méthode implique la récursivité il est donc un peu plus difficile, mais de plus en plus uniforme. Si vous souhaitez obtenir vraiment compliqué et nuire à votre tête... puis essayez de la distribution de n points et puis de simuler une force répulsive entre les points qui se déplace en dehors, puis de les normaliser à travers la surface. Il y a toutes sortes de maux de tête qui doivent être pris en compte pour faire ce travail efficacement, mais alors vous avez assez uniformément distribué des points et vous pouvez contrôler le nombre de sommets et vous devrez avoir le début de l'appréciation de ce qu'il faut pour les outils de modélisation pour trouver le minimum de la géométrie de représenter un modèle.
Aller avec la première méthode.
Dessiner un point (0,0,1), alors vous avez besoin de votre premier anneau concentrique (chaque anneau comporte le même nombre de points pour des raisons de simplicité).
Permet de dessiner 10 points par anneau... donc phi étape par incréments de 2pi/10
et permet de dessiner des 10 anneaux concentriques
et que nous allons tirer 10 anneaux + 2 pôles afin de thêta va augmenter par incréments de pi/12.
Oh permet de bien avez-vous écrire cette équation sur le papier... tout d'abord vous allez centrer sur l'origine parce que vous pouvez toujours traduire c'était vous voulez... afin de se débarrasser de l'x0, y0 et z0 composants(ils sont juste la traduction des composants), ensuite, nous avons convenu que vous pouvez simplement mettre à l'échelle votre sphère aussi grand que vous avez besoin afin de se débarrasser de la "r" sur chaque ligne... que vous devriez être plus propre. Prochaine savons que thêta et phi sont aucun valeur qui se trouve dans les plages indiquées. Je sais qu'il existe un moyen de faire cela très facile... je vais revenir.
Bon... pour en revenir à l'équation (sur le wiki sans les variables inutiles)... Cette forme paramétrique est plus facile à visualiser en anneaux concentriques vu comme si vous regardiez dans l' (x,y) de l'avion ou à la surface de l'écran, et z d'aller dans l'écran de sorte qu'il est comme regarder la terre depuis le pôle nord. Nous pouvons voir que z = cos(theta) donc il y a deux axes dans une sphère, et avec l'axe z déjà prises en compte, cela signifie que le péché (les) composante (la largeur ou un anneau) est déterminé à être sin (), c'est pourquoi les variables x et y ont un supplément de sin() de mélange de ce qui serait l'égaliseur d'un cercle (z part).
Merci. Suivi de votre pseudo code et génère une belle sphère composée de répartie uniformément points. Pourriez-vous me donner quelques conseils sur la façon de faire correctement ce point de la liste dans un triangle strip ou un triangle fan? Je sais que je devrais ajouter des points supplémentaires pour faire des triangles, mais ne savent pas exactement comment
et riemers.net/eng/Tutorials/DirectX/Csharp/Series3/... puis poing allouer les sommets dans la mémoire probablement un couple de variables pour les pôles et un tableau de tableaux pour les anneaux, puis de les attirer dans une autre étape.
OriginalL'auteur Quaternion
La façon habituelle de trianguler une sphère unité est de construire un tétraèdre ou un l'icosaèdre et
Pour éviter de dupliquer les sommets au milieux des bords, vous avez besoin pour suivre l'existant sommets pour le réutiliser.
OriginalL'auteur Alexandre C.
Je l'explique dans un peu de détail dans mon post en réponse à cette question.
solution complète et commentaire stackoverflow.com/questions/4558311/...
OriginalL'auteur Goz