Java a 3D grafika - Geometry (GeometryStripArray)
Vrcholy t∞les, kterß jsme vytvo°ili v p°edchozφm Φlßnku, nebyly sdφleny mezi jednotliv²mi troj·helnφky, p°esto₧e se troj·helnφky vzßjemn∞ dot²kaly. Z hlediska nßrok∙ na pam∞¥ je takov² zp∙sob ulo₧enφ pom∞rn∞ neefektivnφ. V tomto Φlßnku se seznßmφme se t°φdami pro vytvß°enφ troj·helnφkov²ch trs∙ a pßs∙, jejich₧ vyu₧itφ tento problΘm zΦßsti °eÜφ. V druhΘ Φßsti Φlßnku pak trochu odboΦφme a ukß₧eme si jeden docela zajφmav² algoritmus pro generovßnφ "krajin".
Na nßsledujφcφm obrßzku je zobrazen p°φklad trsu troj·helnφk∙ a pßsu troj·helnφk∙. ╚φsla v obrßzku udßvajφ po°adφ, v jakΘm do t∞chto objekt∙ vklßdßme vrcholy.
T°φdy pro prßci s trsy a pßsy jsou vÜechny odvozeny od abstraktnφ t°φdy GeometryStripArray, kterß je odvozena od t°φdy GeometryArray. V tΘto t°φd∞ je definovßn konstruktor, s nφm₧ budeme v tomto Φlßnku pracovat, a to GeometryStripArray(int vtxCount, int vertexFormat, int stripVertexCount[]). Tento konstruktor p°ebφrß t°i parametry. Prvnφ z nich, vtxCount, urΦuje celkov² poΦet vrchol∙, kterΘ budou ulo₧eny v tomto objektu, druh² parametr mß stejn² v²znam jako u konstruktoru t°φdy GeometryArray a urΦuje tedy, co vÜechno bude v tomto objektu ulo₧eno (sou°adnice vrchol∙, barvy, normßlovΘ vektory a dalÜφ). Poslednφm parametrem je pole Φφsel typu int, kterß udßvajφ poΦet vrchol∙ v jednotliv²ch pßsech, pop°φpad∞ trsech, proto₧e do objektu GeometryStripArray jich m∙₧eme ulo₧it i vφce.
Pro nastavovßnφ vrchol∙, barev a pro ostatnφ Φinnosti, jako je nap°φklad dotazovßnφ se "getter" metodami, se pou₧φvajφ metody definovanΘ ve t°φd∞ GeometryArray, s nφ₧ jsme se ji₧ seznßmili.
Nynφ m∙₧eme p°ejφt k prvnφmu p°φkladu, jφm₧ bude vytvo°enφ ÜroubovΘ plochy pomocφ pßsu troj·helnφk∙. Pßsy troj·helnφk∙ se v Jav∞ 3D vytvß°ejφ pomocφ instancφ t°φdy TriangleStripArray. NßÜ program, kter² vytvß°φ Üroubovou plochu, nenφ p°φliÜ efektivnφ kv∙li p°φliÜ velkΘmu poΦtu volßnφ funkcφ sinus a kosinus. Tato volßnφ by Üla nahradit pou₧itφm rotace o konstantnφ ·hel, ale kv∙li Φitelnosti jsem je ponechal v tomto tvaru.
TriangleStripArray tsa = new TriangleStripArray(300, GeometryArray.COORDINATES | GeometryArray.NORMALS, vertexCounts);
float r = 0.5f;
for (int i = 0; i < 300; i+=2){
float x = r*(float)Math.cos(i/20f);
float y = r*(float)Math.sin(i/20f);
float z = i/300f;
tsa.setCoordinate(i, new Point3f(0, 0, z));
tsa.setCoordinate(i+1, new Point3f(x, y, z));
}
Zdrojov² k≤d zde neuvßdφm cel², proto₧e k vypoΦφtßnφ normßlov²ch vektor∙ je v n∞m pou₧ita t°φda NormalGenerator, s nφ₧ jsme se jeÜt∞ nesetkali.
V dalÜφm p°φkladu vytvo°φme pro zm∞nu ku₧elovou plochu pomocφ trsu troj·helnφk∙. Pro vytvß°enφ trs∙ troj·helnφk∙ budeme pot°ebovat t°φdu TriangleFanArray. Pro efektivitu tohoto programu platφ totΘ₧, co jsme si °ekli u p°edchozφho programu.
TriangleFanArray tfa = new TriangleFanArray(32, GeometryArray.COORDINATES | GeometryArray.NORMALS, vertexCount);
tfa.setCoordinate(0, new Point3f(0,0,1));
float r = 0.5f;
for (int i = 1; i < 32; i++){
float x = r*(float)Math.cos(Math.PI*i/15f);
float y = r*(float)Math.sin(Math.PI*i/15f);
tfa.setCoordinate(i, new Point3f(x,y,0));
}
To je zatφm vÜe, co se t²Φe t°φd odvozen²ch od t°φdy GeometryArray. P°φÜt∞ se zaΦneme zab²vat indexovanou geometriφ. Nynφ se podφvßme na jeden docela zajφmav² algoritmus pro generovßnφ terΘn∙.
Generovßnφ terΘn∙
Pro generovßnφ terΘn∙ existuje celß °ada algoritm∙, z nich₧ asi nejpopulßrn∞jÜφ jsou ty vyu₧φvajφcφ fraktßly (pokud vßs tato problematika zajφmß, tak na Rootu vyÜel Φlßnek o mid-point displacement algoritmu). My se v tomto Φlßnku nebudeme zab²vat ₧ßdn²m algoritmem vyu₧φvajφcφm fraktßly, ale ukß₧eme si modifikaci "kopeΦkovΘho" algoritmu popsanou na robot frog.
Zßkladnφ myÜlenka tohoto algoritmu je velice prostß. Na nßhodn∞ vybranß mφsta umφstφme kopeΦky s nßhodn²mi velikostmi. P°i dostateΦn∞ velkΘm mno₧stvφ kopeΦk∙ zaΦne nßÜ terΘn p°ipomφnat skuteΦnou krajinu, by¥ ne tak realistickou, jako bychom zφskali p°i pou₧itφ n∞jakΘho algoritmu vyu₧φvajφcφho fraktßl∙, ale i to m∙₧e b²t mnohdy p°φnosem.
V programu to ud∞lßme nßsledovn∞. ZaΦneme s height-mapou, jejφ₧ v²Üky nastavφme na nulu. Nßhodn∞ vybereme bod le₧φcφ na naÜφ ploÜe, co₧ bude st°ed kopeΦku, a k n∞mu nßhodn∞ vybereme dalÜφ Φφslo û polom∞r. Ke ka₧dΘmu bodu uvnit° kruhu danΘho polom∞rem a st°edem p°iΦteme hodnotu polom∞r*polom∞r - (k-x)*(k-x) - (j-y)*(j-y), co₧ je vzorec pro rotaΦnφ paraboloid "p°eklopen² sm∞rem dol∙". Tento postup zopakujeme, kolikrßt budeme chtφt. Potom cel² terΘn posuneme, aby jeho nejni₧Üφ bod m∞l z-ovou sou°adnici rovnou nule. Dßle vynßsobφme vÜechny body hodnotou 1/(max-min), dφky Φemu₧ budou vÜechny v²Üky v intervalu od 0 do 1. V²Üky vÜech bod∙ potom m∙₧eme umocnit na druhou. Tento krok sice nenφ nezbytn², jeho vyu₧itφm ale m∙₧eme zφskat krajinu s hezk²mi ·dolφΦky. Nakonec vÜechny v²Üky vynßsobφme parametrem maxVyska, udßvajφcφm maximßlnφ v²Üku naÜeho terΘnu. Zdrojov² k≤d, kter² toto vÜechno d∞lß, je na nßsledujφcφm v²pisu:
import java.util.Random;
public class Hills {
// vytvß°et tuto t°φdu by mohlo b²t zbyteΦnΘ
private Hills() {
}
//tato metoda nßm naplnφ pole data hodnotami odpovφdajφcφmi
//v²Ükßm jednotliv²ch bod∙ v naÜem terΘnu
public static void generateTerrain(float data[][], int minPolomer, int maxPolomer, int pocetIteraci, float maxVyska){
int rozmerY = data.length;
int rozmerX = data[0].length;
float max = 0;
float min = 0;
//vytvo°φme generßtor nßhodn²ch Φφsel
Random rand = new Random(System.currentTimeMillis());
//tato smyΦka provßdφ postup, kter² jsme si popsali v Φlßnku
for (int i = 0; i < pocetIteraci; i++){
//vybereme sou°adnice st°edu novΘho kopeΦku...
int x = rand.nextInt(rozmerX);
int y = rand.nextInt(rozmerY);
//... a polom∞r
int polomer = minPolomer + rand.nextInt(maxPolomer-minPolomer+1);
int j0, k0, maxJ, maxK;
//dßle se musφme vypo°ßdat s body, kterΘ sice jsou na kladnΘ Φßsti
//rotaΦnφho paraboloidu (kopeΦku), ale le₧φ mimo stanovenΘ hodnoty x,y
if (y-polomer >= 0)
j0 = y-polomer;
else
j0 = 0;
if (y+polomer < rozmerY)
maxJ = y+polomer;
else
maxJ = rozmerY;
if (x-polomer >= 0)
k0 = x-polomer;
else
k0 = 0;
if (x+polomer < rozmerX)
maxK = x+polomer;
else
maxK = rozmerX;
//v t∞chto cyklech vytvß°φme naÜe kopeΦky
//p°iΦtenφm hodnoty polomer*polomer - (k-x)*(k-x) - (j-y)*(j-y)
//k Φφslu na data[j][k]
for (int j = j0; j < maxJ; j++){
for (int k = k0; k < maxK; k++){
float z = polomer*polomer - (k-x)*(k-x) - (j-y)*(j-y);
if (z > 0){
data[j][k] += z;
max = Math.max(data[j][k], max);
min = Math.min(data[j][k], min);
}
}
}
}
//musφme upravit v²Üku, aby byla v rozumn²ch mezφch
scale(data, min, max, maxVyska);
}
protected static void scale(float data[][], float min, float max, float vyska){System.out.println(min+" "+max);
for (int i = 0; i < data.length; i++){
for (int j = 0; j < data[0].length; j++){
data[i][j] -= min;
data[i][j] *= (1/(max-min));
data[i][j] *= data[i][j];
data[i][j] *= vyska;
}
}
}
}
Objekt Shape3D, obsahujφcφ nßÜ terΘn, pak vytvo°φme snadno s vyu₧itφm t°φdy HeightMap z p°edchozφho Φlßnku, jak m∙₧eme vid∞t dßle. (T°φdu HeightMap lze snadno upravit tak, aby pou₧φvala pßsy troj·helnφk∙.)
Hills.generateTerrain(heights, 0, 20, 800, 0.3f);
HeightMap hm = new HeightMap(heights, 1.2f, 1.2f);
Pokud nastavφme p°φliÜ mal² poΦet iteracφ, nebude nßÜ terΘn vypadat v∙bec reßln∞. S velkou pravd∞podobnostφ to bude pouze n∞kolik osamocen²ch Φßstφ rotaΦnφch paraboloid∙ trΦφcφch z roviny. P°esv∞dΦit se o tom m∙₧eme na nßsledujφcφm obrßzku, kter² byl vytvo°en s poΦtem iteracφ rovn²m deseti:
DalÜφ obrßzek u₧ ukazuje terΘn, u n∞ho₧ jsme poΦet iteracφ nastavili na mnohem v∞tÜφ hodnotu, konkrΘtn∞ 800:
Poslednφ obrßzek jeÜt∞ ukazuje, jak by vypadal terΘn, pokud bychom v²Üky nejprve neumocnili. Zßle₧φ samoz°ejm∞ jen na vßs, kterou variantu si zvolφte.
Tento algoritmus je pochopiteln∞ mo₧nΘ r∙zn∞ obm∞≥ovat. Nap°φklad m∙₧eme zm∞nit funkci generujφcφ kopeΦky. TaktΘ₧ m∙₧eme nßhodn∞ jednou vytvo°it kopeΦek a jindy zase ·dolφ. Zm∞nit se dß takΘ rozlo₧enφ nßhodn²ch Φφsel, nap°φklad je mo₧nΘ pou₧φt gaussovskΘ rozlo₧enφ. Zkrßtka, mo₧nostφ je nep°ebern∞.
