Code: VertexPos = record
X : Double;
Y : Double;
end;
Die Grafikkarte kann nur floats, dürfte einer der Gründe sein warum du nix siehst.
Der andere Grund ist das bei glInterleavedArrays die letzten beiden Argumente 0 sein sollten. Wenn ein VBO gebunden ist (über glBindBuffer) , wird dieses als Quelle für Vertexdaten benutzt. In diesem Fall wird das letzte Argument von glInterleavedArrays als Offset interpretiert, deine Daten liegen am Anfang des Buffers, also sollte der Offset 0 sein. Genauso liegen deine Daten direkt hintereinander im Buffer, daher kann auch der stride 0 sein. (du kannst auch die Vertexgröße nehmen, sollte äquivalent sein)
Letztlich musst du irgendwie eine Fläche von 64x64 Quads rendern bei denen die Vertexkoordinaten eben einfach der X/Z-Position entsprechen. Ich verwende zusätzlich zum VBO noch ein IBO (IndexbufferObject) um zu sagen welche Vertices zusammen Dreiecke bilden.
Code: #define TERRAIN_LEAFSIZE 64
// create vertex buffer object
{
glGenBuffers(1, &m_vboLeaf);
glBindBuffer(GL_ARRAY_BUFFER, m_vboLeaf);
int m_verts = TERRAIN_LEAFSIZE+1;
int data_size = m_verts*m_verts*2*sizeof(float);
glBufferData(GL_ARRAY_BUFFER, data_size, NULL, GL_STATIC_DRAW);
float* data = (float*)glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
int pos = 0;
for (int y=0; y<m_verts; ++y) {
for (int x=0; x<m_verts; ++x) {
data[pos++] = x;
data[pos++] = y;
}
}
glUnmapBuffer(GL_ARRAY_BUFFER);
}
// create index buffer object
{
glGenBuffers(1, &m_iboLeaf);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_iboLeaf);
int m_verts = TERRAIN_LEAFSIZE+1;
int data_size = TERRAIN_LEAFSIZE*TERRAIN_LEAFSIZE*2*3*sizeof(GLushort);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, data_size, NULL, GL_STATIC_DRAW);
GLushort* data = (GLushort*)glMapBuffer(GL_ELEMENT_ARRAY_BUFFER, GL_WRITE_ONLY);
int pos = 0;
for (int y=0; y<TERRAIN_LEAFSIZE; ++y) {
for (int x=0; x<TERRAIN_LEAFSIZE; ++x) {
data[pos++] = (x+0) + (y+0) * m_verts;
data[pos++] = (x+0) + (y+1) * m_verts;
data[pos++] = (x+1) + (y+1) * m_verts;
data[pos++] = (x+1) + (y+1) * m_verts;
data[pos++] = (x+1) + (y+0) * m_verts;
data[pos++] = (x+0) + (y+0) * m_verts;
}
}
glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
}
Zitat: dann sagter einfach nix, und in welcher form der shader die punkte haben will? keine ahnung der shader will die ja gar nicht haben das is ja das was ich nicht verstehe
Wenn man Shader benutzt ist es sinnvoll zu wissen wie die Rendering-Pipeline funktioniert. Der Vertexshader erhält sämtliche Vertices die du der Grafikkarte zum rendern gibst und modifiziert diese. Es spielt hier keine Rolle ob du Punkte, Linien oder Dreiecke renderst. Mit Quads kann die Grafikkarte allerdings gar nicht umgehen, diese werden durch Dreiecke emuliert.
Erst im Primitive-Assembly-Schritt werden die einzelnen Vertices zu Linien oder Dreiecken zusammengesetzt. Wenn es einen Indexbuffer gibt kommt dieser auch erst hier zum tragen. Bei der Rasterisierung wird dann die Linie oder das Dreieck in Pixel zerlegt und für jedes Fragment (Pixel) der Fragmentshader aufgerufen.
|
ähm, was nimmt dein shader als Input? Wenn der jetzt nämlich points will, und du gibst ihm Quads, wird der nicht viel Ahnung haben, was er damit machen soll. 
an sowas denkt man nicht gleich wenn man lange mit delphi arbeitet