Hallöle ich schreibsel grad an meinem Editor rum und hab da drei Fragen :

1.) Wenn ich eine DisplayList erstellt habe, kann ich die Koodinaten des darin erstellten Objekts mit Hilfe der Addition von globalen Variablen (Single) verändern, um es zu verschieben ? (geht bei mir nicht)

2.) Ich wollte eine Textur über eine Reihe von QUAD_STRIP spannen und habe mir folgenden Code aus der OGL-Hilfe von MS geschrieben :
<!--pas--></span><table border='0' align='center' width='95%' cellpadding='3' cellspacing='1'><tr><td>Delphi-Source </td></tr><tr><td id='CODE'><!--pas1--><pre>glNewList(<span class='integer'>401</span>,GL_COMPILE);
<span class='reserved'>if</span> <span class='reserved'>not</span> glisEnabled(GL_TEXTURE_2D) <span class='reserved'>then</span> glEnable(GL_TEXTURE_2D);
glBegin(GL_QUAD_STRIP);
glBindTexture(GL_TEXTURE_2D,mappe.texnummer[<span class='integer'>2</span>]);
glTexGeni(GL_S,GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
glTexGeni(GL_T,GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
glVertex3f(sect1_koords1[<span class='integer'>0</span>,<span class='integer'>0</span>]+mappe.diff_x[<span class='integer'>1</span>],sect1_koords1[<span class='integer'>0</span>,<span class='integer'>1</span>]+mappe.diff_y[<span class='integer'>1</span>],sect1_koords1[<span class='integer'>0</span>,<span class='integer'>2</span>]);
glVertex3f(sect1_koords1[<span class='integer'>1</span>,<span class='integer'>0</span>]+mappe.diff_x[<span class='integer'>1</span>],sect1_koords1[<span class='integer'>1</span>,<span class='integer'>1</span>]+mappe.diff_y[<span class='integer'>1</span>],sect1_koords1[<span class='integer'>1</span>,<span class='integer'>2</span>]);
glVertex3f(sect1_koords1[<span class='integer'>2</span>,<span class='integer'>0</span>]+mappe.diff_x[<span class='integer'>1</span>],sect1_koords1[<span class='integer'>2</span>,<span class='integer'>1</span>]+mappe.diff_y[<span class='integer'>1</span>],sect1_koords1[<span class='integer'>2</span>,<span class='integer'>2</span>]);
glVertex3f(sect1_koords1[<span class='integer'>3</span>,<span class='integer'>0</span>]+mappe.diff_x[<span class='integer'>1</span>],sect1_koords1[<span class='integer'>3</span>,<span class='integer'>1</span>]+mappe.diff_y[<span class='integer'>1</span>],sect1_koords1[<span class='integer'>3</span>,<span class='integer'>2</span>]);
glVertex3f(sect1_koords1[<span class='integer'>4</span>,<span class='integer'>0</span>]+mappe.diff_x[<span class='integer'>1</span>],sect1_koords1[<span class='integer'>4</span>,<span class='integer'>1</span>]+mappe.diff_y[<span class='integer'>1</span>],sect1_koords1[<span class='integer'>4</span>,<span class='integer'>2</span>]);
glVertex3f(sect1_koords1[<span class='integer'>5</span>,<span class='integer'>0</span>]+mappe.diff_x[<span class='integer'>1</span>],sect1_koords1[<span class='integer'>5</span>,<span class='integer'>1</span>]+mappe.diff_y[<span class='integer'>1</span>],sect1_koords1[<span class='integer'>5</span>,<span class='integer'>2</span>]);
glVertex3f(sect1_koords1[<span class='integer'>6</span>,<span class='integer'>0</span>]+mappe.diff_x[<span class='integer'>1</span>],sect1_koords1[<span class='integer'>6</span>,<span class='integer'>1</span>]+mappe.diff_y[<span class='integer'>1</span>],sect1_koords1[<span class='integer'>6</span>,<span class='integer'>2</span>]);
glVertex3f(sect1_koords1[<span class='integer'>7</span>,<span class='integer'>0</span>]+mappe.diff_x[<span class='integer'>1</span>],sect1_koords1[<span class='integer'>7</span>,<span class='integer'>1</span>]+mappe.diff_y[<span class='integer'>1</span>],sect1_koords1[<span class='integer'>7</span>,<span class='integer'>2</span>]);
glVertex3f(sect1_koords1[<span class='integer'>8</span>,<span class='integer'>0</span>]+mappe.diff_x[<span class='integer'>1</span>],sect1_koords1[<span class='integer'>8</span>,<span class='integer'>1</span>]+mappe.diff_y[<span class='integer'>1</span>],sect1_koords1[<span class='integer'>8</span>,<span class='integer'>2</span>]);
glVertex3f(sect1_koords1[<span class='integer'>9</span>,<span class='integer'>0</span>]+mappe.diff_x[<span class='integer'>1</span>],sect1_koords1[<span class='integer'>9</span>,<span class='integer'>1</span>]+mappe.diff_y[<span class='integer'>1</span>],sect1_koords1[<span class='integer'>9</span>,<span class='integer'>2</span>]);
glEnd;
glEndList;</pre><!--pas2--></td></tr></table><span class='postcolor'><!--pas3-->
Er zeigt die Textur zwar an, aber nur einen Bruchteil davon. Wenn ich mit
<!--pas--></span><table border='0' align='center' width='95%' cellpadding='3' cellspacing='1'><tr><td>Delphi-Source </td></tr><tr><td id='CODE'><!--pas1--><pre>glMatrixMode(GL_TEXTURE);
glLoadIdentity;
glScalef(<span class='integer'>0.5</span>,<span class='integer'>0.5</span>,<span class='integer'>0.0</span>);
glMatrixMode(GL_MODELVIEW);</pre><!--pas2--></td></tr></table><span class='postcolor'><!--pas3-->
rangehe, wird das ganze verzerrt. Wo liegt der Fehler ?

3.) Gibt es eigentlich ein Tut bzw. ein Interface für OGL mit Assembler ?

_________________
http://www.onkeltorty.net
http://sourceforge.net/projects/simpleassembler

Die Vertexdaten der DisplayListe kann man im Nachhinein natürlich nicht mehr ändern.Allerdings kannst du diese doch ganz einfach mittels glTranslatef bzw. glRotatef dort hinbringen, wo du sie gerne haben willst.Wenn du sowas *ähnliches* wie eine Displayliste brauchst, aber die Vertexdaten permanent ändern musst, dann schau dir mal VertexArrays an.


Beschreib mal genauer was du mit verzerrt meinst (am besten mittels eines Screenshots).Evtl. musst du mit folgendem Code nämlich noch die S/T-Generierungsparameter für die Texturkoordinategenerierung angeben :

Wobei sg und tg 4-Komponenten-Vektor im Format x/y/z/w sind.Setz sg mal = (0,0,S-Faktor,0) und tg = (T-Faktor,0,0,0).Wenn du nicht genau weisst was diese Parameter machen, oder wie automatische Texturkoordinategenerierung funzt, schau die mal das entsprechende Kapitel im RedBook an.


Das gibts, und ich hab auch schon in Assembler geschriebene GL-Anwendungen gesehen.Allerdings hab ich leider keinen Link...davon aber mal abgesehen, wirste dadurch keinen Geschwindigkeitsvorteil haben, und das wäre ja der einzige Nutzen von Assembler...

_________________
www.SaschaWillems.de | GitHub | Twitter | GPU Datenbanken (Vulkan, GL, GLES)

Dateigröße?

_________________
www.las.eu.tc

Dateigröße ist eigentlich in der heutigen Zeit wirklich kein Argument mehr. Mahl erhlich: den Ärger den Du Dir mit Assemblerprogramierung einhandelst, und der Mehraufwand an Zeit steht in keinem Verhälltniss zur erstellten Dateigröße!

_________________
Und was würdest Du tun, wenn Du wüsstest, dass morgen Dein letzter Tag auf dieser Erde ist?

Romka Graphics hatte einige OpenGL und Assembler Demos. Aber irgendwie geht der Link zu der Seite nicht mehr.

Sodala das Texturproblem hab ich gelöst, indem ich die Textur einfach gesplittet hab und mittels glTexCoord2f(x,y) auf mehreren Quads fixierte. Leider kann ich jetzt keinen Screenshot mehr machen, aber soviel dazu :
Es war ein QUAD_STRIP, der drei Reihen nach +x verlief. Wenn man die Textur skaliert hat, hat sich die Textur im mittleren Quad "über Kreuz gespannt". Es entstanden also im mittleren Quad vier "Texturdreiecke", von denen das linke und das rechte eine erkennbare Textur enthielten. Das obere und das untere zeigten ein "Rauschen", das sich mit zunehmender Skalierung bewegte.

@Assembler: Wenn man keinen Geschwindigkeitsvorteil mit OGL erreicht, dann lohnt sich der Aufwand wirklich nicht. Bei den heutigen HD´s auf die Größe zu achten macht doch wenig Sinn.

@Displaylist: Habs auf VertexArrays umgestellt, da eine Oberflächenschwingung (Wasser) drinnen ist

Danke ...

_________________
http://www.onkeltorty.net
http://sourceforge.net/projects/simpleassembler

@VertexArray
Eventuell kannst du für dein VertexArray ein hardwareunterstützes Array verwenden. So etwas wie NV_vertex_array_range, ATI_vertext_array_object oder ARB_vertex_buffer_object benutzen. Da diese im Vergleich zu einem normalen VertexArray einen erheblichen Geschwindigkeitsvorteil aufweisen.

@Assembler
Das einzige was in der heutigen Zeit wirklich Sinn machen würde. Wäre Berechnungen oder Ähnlich verzwickte Aufgaben. Dort kann man teilweise gegenüber einer Hochsprache noch mal anständig Geschwindigkeit herausholen. Da eine Hochsprache viel zu viel macht. (puschen und poppen der Register) Bzw man kann auch Technologien (MMX, etc) einbinden die normalerweise nicht berührt werden würden.
Allerdings ist das keine Aufgabe die man einfach mal so machen kann weil man Lust hat. Man muss sehr viel wissen über die Microprozessorstruktur mitbringen bzw einfach zu viel Zeit haben.

Viel wichtiger als Assembler sind aber immer noch die Optimierungen im Quellcode. Es nützt ja bekanntlich nichts, wenn man hochoptimierte Assemblerberechnungen verwendet aber an anderen Stellen MB weise Speicher hin und her kopiert. So etwas zu optimieren ist teilwese schon verzwickt genug. (Pointer )

Ich hab jetzt paar mal versucht, ein NV_vertex_array_range in mein Prog einzubinden, aber der Compi erkennt es nicht. Welche Header braucht man dazu oder muss man dazu eine Klasse aus der OpenGl12.pas ableiten ?

Gibt es ein Tutorial zu NV_vertex_array_range, GL_NV_fence,glGenFencesNV usw ... ?

_________________
http://www.onkeltorty.net
http://sourceforge.net/projects/simpleassembler

Also wenn du die OpenGL12.pas von Mike Lische verwendest, dann musst du die Methoden
<!--pas--></span><table border='0' align='center' width='95%' cellpadding='3' cellspacing='1'><tr><td>Delphi-Source </td></tr><tr><td id='CODE'><!--pas1--><pre>ReadImplementedProperties;
ReadExtensions;</pre><!--pas2--></td></tr></table><span class='postcolor'><!--pas3-->
aufrufen. Das darf aber nur bei aktiviertem Renderkontext geschehen.
Anschließend solltest du schauen ob die Extension überhaupt existiert.
<!--pas--></span><table border='0' align='center' width='95%' cellpadding='3' cellspacing='1'><tr><td>Delphi-Source </td></tr><tr><td id='CODE'><!--pas1--><pre><span class='reserved'>if</span> (GL_NV_vertex_array_range) <span class='reserved'>then</span> <span class='reserved'>begin</span>
// Mach was
<span class='reserved'>end</span>;</pre><!--pas2--></td></tr></table><span class='postcolor'><!--pas3-->

Ein Demo zu vertext_array_range gibts auf <a href='http://www.delphi3d.net/listfiles.php?category=3' target='_blank'>www.delphi3d.net</a>. Fast ganz unten (var_cem.zip).

In der OpenGL12.pas sind die Fences allerdings nicht mit eingebunden. Dazu kannst du die folgende Erweiterung verwenden. <a href='http://www.dev-center.de/index.php?cat=header&file=openglext' target='_blank'>http://www.dev-center.de/index.php?cat=hea...&file=openglext</a>
Diese bindest du genau so ein wie die opengl12.pas und rufst die Methoden
<!--pas--></span><table border='0' align='center' width='95%' cellpadding='3' cellspacing='1'><tr><td>Delphi-Source </td></tr><tr><td id='CODE'><!--pas1--><pre>ReadImplementedPropertiesEXT;
ReadExtensionsEXT;</pre><!--pas2--></td></tr></table><span class='postcolor'><!--pas3-->
auf.
Logischerweise an der selben Stelle wie die Methoden von der opengl12.pas.

Ein pdf und Demo zu fences (und var) gibt es bei nvidia.
<a href='http://developer.nvidia.com/view.asp?IO=var_fence' target='_blank'>http://developer.nvidia.com/view.asp?IO=var_fence</a>
<a href='http://developer.nvidia.com/view.asp?IO=var_memory_management' target='_blank'>http://developer.nvidia.com/view.asp?IO=va...mory_management</a>

Oki ich werd mich da erstmal durchschmökern ... danke für die Tips

_________________
http://www.onkeltorty.net
http://sourceforge.net/projects/simpleassembler

Ich würd' mir aber überlegen, gleich auf VBOs (Vertex-Buffer-Objects) umzusteigen, da diese vom ARB abgesegnet und soomit vereinheitlicht sind! Aber auch dazu gibt's entsprechende Demos bei Delphi3D!

_________________
Und was würdest Du tun, wenn Du wüsstest, dass morgen Dein letzter Tag auf dieser Erde ist?

Also grundlegend muss ich sagen : Ich werd mir 3 Sachen beibringen wollen : NV_GL_Extensions, dann die Extensions von ATI (SoS forscht ja schon fleissig ) und vorrangig jetzt mal VOB.

An dieser Stelle tun sich Fragen zu NV_Vertex_Array_Range :

Also, ich prüfe in meiner Anwendung mit
<!--pas--></span><table border='0' align='center' width='95%' cellpadding='3' cellspacing='1'><tr><td>Delphi-Source </td></tr><tr><td id='CODE'><!--pas1--><pre>Optionen.Nvidia_vertex_array_range := GL_NV_vertex_array_range; //NV_Vertex_<span class='reserved'>Array</span> verfügbar ?</pre><!--pas2--></td></tr></table><span class='postcolor'><!--pas3-->
ob NV_Vertex_Array_Range verfügbar ist. Bei mir steht das ganze auf "True", da ich ne GeForce4 128 eingebaut habe. Ich habe mir folgenden Code aus der NVExt_min.pas rausgeschnippselt und umgeschreibselt, um auf die Ext´s zugreiffen zu können :
<!--pas--></span><table border='0' align='center' width='95%' cellpadding='3' cellspacing='1'><tr><td>Delphi-Source </td></tr><tr><td id='CODE'><!--pas1--><pre><span class='reserved'>var</span>
// WGL_EXT_swap_control
wglSwapIntervalEXT : <span class='reserved'>function</span> (interval : integer) : integer; stdcall;

//NV_vertex_array_range -- wglext.h
wglAllocateMemoryNV : <span class='reserved'>function</span> (bufSize : integer; readfreq, writefreq, priority : TGLFloat) : pointer; stdcall;
wglFreeMemoryNV : <span class='reserved'>procedure</span> (NVMem : pointer); stdcall;
glVertexArrayRangeNV : <span class='reserved'>procedure</span> (size : TGLsizei; NVMem : pointer); stdcall;
<span class='reserved'>const</span>
//NV_vertex_array_range -- wglext.h
GL_VERTEX_ARRAY_RANGE_NV = $851D;
GL_VERTEX_ARRAY_RANGE_LENGTH_NV = $851E;
[...]

<span class='reserved'>function</span> wglGetProcAddress (ProcName: PChar): Pointer; stdcall; external 'OPENGL32.DLL';

<span class='reserved'>procedure</span> Init_glExt_add;
<span class='reserved'>begin</span>
wglSwapIntervalEXT := wglGetProcAddress('wglSwapIntervalEXT');
wglAllocateMemoryNV := wglGetProcAddress('wglAllocateMemoryNV');
wglFreeMemoryNV := wglGetProcAddress('wglFreeMemoryNV');
glVertexArrayRangeNV := wglGetProcAddress('glVertexArrayRangeNV');
<span class='reserved'>end</span>;</pre><!--pas2--></td></tr></table><span class='postcolor'><!--pas3-->

Mein Prog verwendet DisplayLists, welche einmal bei Form.Create aufgerufen werden. Darin wird auch die Prozedur<!--pas--></span><table border='0' align='center' width='95%' cellpadding='3' cellspacing='1'><tr><td>Delphi-Source </td></tr><tr><td id='CODE'><!--pas1--><pre><span class='reserved'>procedure</span> Init_glExt_add;</pre><!--pas2--></td></tr></table><span class='postcolor'><!--pas3--> und <!--pas--></span><table border='0' align='center' width='95%' cellpadding='3' cellspacing='1'><tr><td>Delphi-Source </td></tr><tr><td id='CODE'><!--pas1--><pre>wglAllocateMemoryNV(<span class='integer'>512</span>,<span class='integer'>12</span>,<span class='integer'>12</span>,<span class='integer'>25</span>);
glEnableClientState(GL_VERTEX_ARRAY_RANGE_NV);</pre><!--pas2--></td></tr></table><span class='postcolor'><!--pas3--> aufgerufen. Und jetzt kommt mein Problem : Nvidia schreibt ja folgende Reihenfolge vor :
1.) Allocate Memory (also mit wglAllocateMemory)
2.) Allocate Fences (optional)
3.) Enable Memory (glEnableClientState(GL_VERTEX_ARRAY_RANGE_NV))
4.) Define Vertex Arrays
5.) Finish Fences (optional)
6.) Copy Data into arrays
7.) Draw indexed Primitives
8.) Set Fences (optional)

Bei Punkt 4 haperts bei mir im Moment, weil ich nicht sonderlich weiter weis. Momentan verwende ich "stinknormale" Arrays in Verbindung mit glVertex3f(x,y,z). Nvidia schreibt, dass man
<!--pas--></span><table border='0' align='center' width='95%' cellpadding='3' cellspacing='1'><tr><td>Delphi-Source </td></tr><tr><td id='CODE'><!--pas1--><pre>glInterleavedArrays(format : cardinal, stride: integer, data: pointer)</pre><!--pas2--></td></tr></table><span class='postcolor'><!--pas3-->
oder
<!--pas--></span><table border='0' align='center' width='95%' cellpadding='3' cellspacing='1'><tr><td>Delphi-Source </td></tr><tr><td id='CODE'><!--pas1--><pre>glVertexPointer(size: integer, atype: cardinal, stride: integer, data: pointer)</pre><!--pas2--></td></tr></table><span class='postcolor'><!--pas3-->
oder
<!--pas--></span><table border='0' align='center' width='95%' cellpadding='3' cellspacing='1'><tr><td>Delphi-Source </td></tr><tr><td id='CODE'><!--pas1--><pre>glNormalPointer(atype: cardinal, stride: integer, data: pointer)</pre><!--pas2--></td></tr></table><span class='postcolor'><!--pas3-->
verwenden soll. glVertexPointer fällt bei mir aus, da ich DisplayLists verwende.

Dazu habe ich 3 Fragen :

1.) Welche Methode ist bei statischen Vertex, die nur mit glPushMatrix, glTranslatef,glPopMatrix verschoben werden, die beste ?
2.) Zeigt der Pointer in den 3 Prozeduren (data: pointer) auf einen stinknormalen Array ?
3.) Zu Punkt 5 (Copy Data into Arrays) : Kopieren ist recht und schön, wenn man weis wie und mit wohin ? Bisher wird nur beschrieben, dass man mit glFlushVertexArrayRangeNV() das ganze wieder löschen kann.

_________________
http://www.onkeltorty.net
http://sourceforge.net/projects/simpleassembler

1) Ich würde die ganzen Vertex in das Vertex Array Range hineinschreiben und dann mit glvertexpointer einen Zeiger darauf setzen.
2) Mit wglallocateMemory kann man Speicher direkt auf der Grafikkarte belegen. Dort schreibt man das Array auch dann hin. Der Zeiger bei glvertexpointer zeigt dann auf dieses Array.
3) Man kann z.B. das Vertex Array mit move zu der Addresse im Grafikspeicher kopieren, die man mit wglallocateMemory erhalten hat.
Die Parameter von wglAllocateMemory bestimmen, ob man eine Addresse im normalen Systemspeicher, AGP Speicher oder Grafikspeicher zurüch bekommt. glFlushVertexArrayRangeNV() löscht nicht das Vertex Array, sondern syncronisiert die CPU und die Grafikkarte. Es wird gewartet, bis die Grafikkarte nicht mehr aus dem Vertex Array Range rendert. Wenn man in das VAR schreibt, während daraus gerendert wird, kommt es zu Darstellungsfehlern. Anstelle von glFlushVertexArrayRangeNV() sollte man aber die fence benutzen, weil man damit genauer feststellen kann, welche Bereiche des VAR gerade von der Grafikkarte gelesen werden.
So kann man ein Vertex Array initialisieren.
Dabei ist zu beachten, daß der Zugriff auf AGP und Grafikspeicher langsamer ist als auf normalen Speicher.



Ich kann aber auch nur vorschlagen ARB_VBO zu benutzen. Das ist weitaus einfacher, weil man den Speicher nicht selber verwalten muß und die CPU und Grafikkarte nicht mit den fence selber abstimmen muß. Man kann außerdem nur einmal mit wglAllocateMemory Speicher belegen.

Oki dann werd ich mich mal da durch stöbern ... gibts da sowas wie n Whitepaper oder nur das Tut (zu ARB_VBO) auf D3dnet ?

_________________
http://www.onkeltorty.net
http://sourceforge.net/projects/simpleassembler

Ein PDF zum Thema gibt es unter:
<a href='http://developer.nvidia.com/docs/IO/4449/SUPP/GDC2003_OGL_BufferObjects.pdf' target='_blank'>http://developer.nvidia.com/docs/IO/4449/S...fferObjects.pdf</a>