Renderowanie terenu

[Toster]

Ok kilka pytan.
Czy ma ktos (i moze mi podrzucic linki) do tutoriali jak zrobic renderowanie terenu na podstawie tablicy wysokosci ?

Wiem jak narysowac trojkat za pomoca scanline ale nie moge znalezc nic na temat polaczenia tego z z-bufforem (wszystko bedzie robione recznie, bez GL i DX ipt), jakby ktos mial jakies materialy to bylbym wdzieczny.

ogolnie problem jest tego typu:
1. mamy mape z wysokosciami
2. mamy punkt w ktorym stoi obserwator, znamy wektor w ktorym kierunku patrzy
3. trzeba wygenerowac landscape.

zrobilem swoja wersje alb ale straszna kupa z tego wyszla, na googlu jest full tutkow ale pod gl albo dx a to mi niepotrzebne

[DarkAndrew]

to nie google <-powinno sie przydać

[Jason]

Pascal// dane terenu
float g_terrain[MAP_X * MAP_Z][3]; // mapa wysokości terenu (0-255); 256x256
GLuint g_indexArray[MAP_X * MAP_Z * 2]; // tablica wierzchołków
float g_colorArray[MAP_X * MAP_Z][3]; // tablica kolorów
float g_texcoordArray[MAP_X * MAP_Z][2]; // tablica współrzędnych tekstury
//.....
void InitializeTerrain()
{

int index = 0;
int currentVertex;

// generuje losowo ukształtowany teren
for (int z = 0; z < MAP_Z; z++)
{
for (int x = 0; x < MAP_X; x++)
{

g_terrain[x + z * MAP_X][0] = float(x)*MAP_SCALE;
g_terrain[x + z * MAP_X][1] = 5.0f + FRAND * 5.0f;
g_terrain[x + z * MAP_X][2] = -float(z)*MAP_SCALE;

// wierzchołki uporządkowane od lewej do prawej, z góry w dół
currentVertex = z * MAP_X + x;

// określa kolor
g_colorArray[currentVertex][0] = g_colorArray[currentVertex][1] =
g_colorArray[currentVertex][2] = g_terrain[x + z * MAP_X][1] / 20.0f + 0.5f;

// określa współrzędne tekstury
g_texcoordArray[currentVertex][0] = (float) x;
g_texcoordArray[currentVertex][1] = (float) z;

}
}


for (z = 0; z < MAP_Z-1; z++)
{
for (int x = 0; x < MAP_X; x++)
{

currentVertex = z * MAP_X + x;
g_indexArray[index++] = currentVertex + MAP_X;
g_indexArray[index++] = currentVertex;
}
}


glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);


glVertexPointer(3, GL_FLOAT, 0, g_terrain);
glColorPointer(3, GL_FLOAT, 0, g_colorArray);
glTexCoordPointer(2, GL_FLOAT, 0, g_texcoordArray);
} // InitializeArrays()
/*****************************************************************************
GetHeight()

Zwraca wysokość terenu w punkcie (x, z)
*****************************************************************************/
float GetHeight(float x, float z)
{

float projCameraX = x / MAP_SCALE;
float projCameraZ = -z / MAP_SCALE;

// oblicza wspołrzędne punktów (hflCol0, hflRow0) oraz (hflCol1, hflRow1)
// identyfikujące komórkę znajdującą się bezpośrednio pod kamerą
int hflCol0 = int(projCameraX);
int hflRow0 = int(projCameraZ);
int hflCol1 = hflCol0 + 1;
int hflRow1 = hflRow0 + 1;

// pobiera wysokości dla czterech wierzchołków komórki
float h00 = g_terrain[hflCol0 + hflRow0*MAP_X][1];
float h01 = g_terrain[hflCol1 + hflRow0*MAP_X][1];
float h11 = g_terrain[hflCol1 + hflRow1*MAP_X][1];
float h10 = g_terrain[hflCol0 + hflRow1*MAP_X][1];

// wyznacza położenie kamery w obrębie komórki
// 0 <= tx, ty <= 1.
float tx = projCameraX - float(hflCol0);
float ty = projCameraZ - float(hflRow0);

// interpoluje wysokość kamery

float txty = tx * ty;

return h00 * (1.0f - ty - tx + txty)
+ h01 * (tx - txty)
+ h11 * txty
+ h10 * (ty - txty);
} // GetHeight()
/****************************************************************************
DrawSand()

Rysuje teren.
*****************************************************************************/
void DrawSand()
{
// wybiera teksturę piasku
glBindTexture(GL_TEXTURE_2D, g_sand);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
if (glLockArraysEXT)
glLockArraysEXT(0, MAP_X * MAP_Z);

// przegląda w pętli łańcuchy trójkątów
for (int z = 0; z < MAP_Z-1; z++)
{
// rysuje trójkąty bieżącego łańcucha
glDrawElements(GL_TRIANGLE_STRIP, MAP_X * 2, GL_UNSIGNED_INT, &g_indexArray[z * MAP_X * 2]);
}

// odblokowuje tablice (jeśli dostępne jest rozszrzenie tablic kompilowanych)
if (glUnlockArraysEXT)
glUnlockArraysEXT();
} // DrawSand()



No to są chyba wszystkie procedury do tego,
oczywiście C++ + OpenGL.
Powodzenia
Tak wygląda generowanie terenu z książki OpenGL, Programowanie Gier, rozdział 15, źródło cacti.

[KKKas]

"na googlu jest full tutkow ale pod gl albo dx a to mi niepotrzebne"

Jason, DarkAndrew: Toster zaznaczył, że nie potrzebuje tego do OGL ani DX.

[Toster]

spoko, tamte artsy tez sie przydaly. ogolnie po 8 h kombinowania zrobilem:
rysowanie trojkatow przez scanline
generowanie terenu na podstawie map wysokosci
rzutowanie + pseudo cieniowanie + losowy szum
bez gl bez dx i bez innych smieci.
jak znajde chwile czasu to zrobie z tego tutka.
w kazdym badz razie jeszcze duzo nie kminie ale jestem na dobrej drodze, jtro wkleje kod jakby ktos chcial sobie zerknac ;)

[krajew4]

Może pochwal się screenami

[Jason]

Hmmmm, a jak to renderujesz :>
Bo bez rendererów chyba nie osiągasz najwyżyszch fps'ów, no nie ?
Ale zawsze można się pobawić w kreowanie grafiki 3d

[Toster]

nie chodzi o predkosc, zalozenia sa zupelnie inne nie chce mi sie wchodzic w szczegolu. tak czy siak kod wyglada tak (od razu mowie ze nie tlumacze kazdy musi sam zrozumiec) screeny tez postaram sie dzisiaj podpiac.

[delphi]cH-->