Files |  Tutorials |  Articles |  Links |  Home |  Team |  Forum |  Wiki |  Impressum

Aktuelle Zeit: Sa Jul 05, 2025 19:40

Foren-Übersicht » Programmierung » Allgemein
Unbeantwortete Themen | Aktive Themen



Ein neues Thema erstellen Auf das Thema antworten  [ 4 Beiträge ] 
Autor Nachricht
BeitragVerfasst: Do Apr 30, 2009 03:39 
Offline
DGL Member
Benutzeravatar

Registriert: Di Mai 18, 2004 16:45
Beiträge: 2623
Wohnort: Berlin
Programmiersprache: Go, C/C++
Ich bin heute wieder auf ein recht unangenehmes Thema gestossen.
Die rede ist von Scriptsprachen, es ist schlicht weg notwendig Scripte zu verwenden, wenn man ein Material, Szenen Objekte oder ganze Level verwalten und schalten will.
Wenn man ein Material hat, dann enthält dieses Informationen von zu ladenen Texturen, Shadern und benötigt oft auch bestimmte fähigkeiten, um z.B. eine Zeitkonstante oder ähnliches zu ändern.
Die ganze Sache kann aber wesentlich komplexer werden, wenn man z.B. mehrere Passes hat, OpenGL3 verwendet oder schlicht weg keine statische Engine haben will.
Ich und Oc2k1 haben dieses Thema schon 1-2 mal aufgegriffen und wieder verworfen.
Wärend ich bei Lua geblieben bin hat Oc2k1 javascript verwendet und es ist nicht schwer fest zu stellen, dass Materials dann nicht kompatibel zueinander sind.
Heute haben wir wieder überlegt und sind auf die Idee gestossen eine art CG für Scriptsprache, sprich ein compiler und mehrere plugins, welche eine generische einfache scriptsprache in verschiedene andere Scriptsprachen konvertieren kann. So wäre es möglich, in einer Engine 2-3 Scriptanbindungen zu entwickeln und je nach Entwickler, kann dieser dann die Materials, Modelscript, Levelscripts dann in die entsprechenden Scriptsprache konvertieren und in dieser weiter arbeiten.

So könnte eine mögliche Variante aussehen.
Code:
  1. // Definitions Datei
  2. //function ist ein Tag für eine funktion, die eine funktion im externen code aufruft und beim init des Script gesetzt wurde oder leitet eine Scriptinterne funktion ein.
  3. //Script internal ID
  4. typedef unsigned int TLocation;//0 = error
  5.  
  6. struct TClass
  7. {
  8.   TString ClassName;
  9. };
  10.  
  11. struct TMaterial
  12. {
  13.   TLocation Draw;
  14.   TLocation EndDraw;
  15.   TLocation BeginDraw;
  16.   function LoadTexture;
  17. };
  18.  
  19. struct TShader
  20. {
  21.   function Load;
  22.   function Bind;
  23.   function SetVariable;
  24.   function EnableAttribute;
  25.   function DisableAttribute;
  26.   function SetAttribute;
  27. };
  28.  
  29. struct TTexture
  30. {
  31.   function Load;
  32.   function Bind;
  33. };
  34.  
  35. struct TMesh
  36. {
  37.   function Draw
  38. };
  39.  
  40. struct TMesh
  41. {
  42.   function GetFaceCount;
  43.   function Draw;
  44. };
  45.  
  46. struct TRenderer
  47. {
  48.   function GetPass;
  49.  
  50. };
  51.  
  52. #define ZPASS      1
  53. #define RENDERPASS 2
  54.  
  55. #define MESHVERTEX 1
  56. #define MESHCOLOR  2
  57.  
  58. TClass Owner;
  59. // Definitions Datei Ende
  60.  
  61. //Beispiel Datei: Material
  62. TMaterial Material;
  63. TTexture SkyTex;
  64. TShader SkyShader;
  65. TMesh Mesh;
  66. TRenderer Renderer;
  67. TMesh Mesh;
  68.  
  69. function EndDraw()
  70. {
  71.   switch(Renderer.GetPass())
  72.   {
  73.     case RENDERPASS:
  74.       SkyShader.DisableAttribute(MESHVERTEX);
  75.       SkyShader.DisableAttribute(MESHCOLOR);
  76.       SkyShader.Unbind();
  77.       SkyTex.Unbind();
  78.       Mesh.Unbind();
  79.       break;
  80.   }
  81. }
  82.  
  83. function Draw()
  84. {
  85.   switch(Renderer.GetPass())
  86.   {
  87.     case ZPASS:
  88.     case RENDERPASS:
  89.       for (int f=0;f<Mesh.GetFaceCount();f++)
  90.         Mesh.Draw(f);
  91.       break;
  92.   }
  93. }
  94.  
  95. function BeginDraw()
  96. {
  97.   switch(Renderer.GetPass())
  98.   {
  99.     case ZPASS:
  100.       Mesh.Bind();
  101.       break;
  102.     case RENDERPASS:
  103.       SkyShader.Bind();
  104.       SkyShader.SetVariable("ProjectionviewMatrix",Renderer.GetProjectionviewMatrix());
  105.       SkyShader.SetVariable("ModelviewMatrix",Renderer.GetModelviewMatrix());
  106.       Mesh.BindBuffer(MESHVERTEX);
  107.       SkyShader.EnableAttribute("Vertex");
  108.       SkyShader.SetAttribute("Vertex",3,float,false,0,0);
  109.       Mesh.BindBuffer(MESHCOLOR);
  110.       SkyShader.EnableAttribute("Color");
  111.       SkyShader.SetAttribute("Color",3,float,false,0,0);
  112.       SkyTex.Bind(0);
  113.       break;
  114.   }
  115. }
  116.  
  117. function main()
  118. {
  119.   if (Owner.ClassName!="TMaterial")
  120.   {
  121.     Error("Wrong Classtype");
  122.     Exit();
  123.   }
  124.   Material.Draw=Draw();
  125.   Material.BeginDraw=BeginDraw();
  126.   Material.EndDraw=EndDraw();
  127.   SkyTex.Load("file://media/textures/clearSky.dds");
  128.   SkyShader.Load("file://media/shader/sky.frag","file://media/shader/sky.vert");
  129. }


Ich hab den Thread gestartet und will einfach mal gucken, ob sich wer anderes noch mit dem Thema befasst hat, weitere Ideen oder sogar interessierte Entwickler hier rum geistern.

_________________
"Wer die Freiheit aufgibt um Sicherheit zu gewinnen, der wird am Ende beides verlieren"
Benjamin Franklin

Projekte: https://github.com/tak2004


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Do Apr 30, 2009 19:12 
Offline
Forenkatze
Benutzeravatar

Registriert: Mi Okt 22, 2003 18:30
Beiträge: 1945
Wohnort: Närnberch
Programmiersprache: Scala, Java, C*
Overkill. Absoluter Overkill :)
Universelle Skriptsprache, die in andere Skriptsprachen übersetzt werden kann... Dann mal viel Spaß mit den schlaflosen Nächten :D

_________________
"Für kein Tier wird so viel gearbeitet wie für die Katz'."


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Fr Mai 01, 2009 00:37 
Offline
DGL Member
Benutzeravatar

Registriert: Di Mai 18, 2004 16:45
Beiträge: 2623
Wohnort: Berlin
Programmiersprache: Go, C/C++
Ich habe mit Oc2k1 noch ein bischen zusammen gearbeitet und das ganze mal ein bischen weiter runter abstrahiert.
Code:
  1. <!DOCTYPE meshdata>
  2. <meshdata version="xxxx">
  3.   <node name="Node">
  4.     <buffer name="Vertex">
  5.       <struct>
  6.         <component name="Position" type="float" dim="3"/>
  7.         <component name="Color" type="float" dim="3"/>
  8.         <component name="Normal" type="short" dim="3"/>
  9.       </struct>
  10.       <data size="9999">
  11.         BASE64 encoded data
  12.       </data>
  13.     </buffer>
  14.     <buffer name=Face">
  15.       <struct>
  16.         <component name="Start" type="uint" dim="1"/>
  17.         <component name="Count" type="uint" dim="1"/>
  18.         <component name="Materialname" type="string" dim="1"/>
  19.       </struct>
  20.       <data size="9999">
  21.         BASE64 encoded data
  22.       </data>
  23.     </buffer>
  24.   </node>
  25. </lumina>

Das wäre dann ein Klartext Datenformat, welches man auch einfach als Binäres format ablegen könnte.

Die Zuweisung, von Stream auf ein OpenGL Buffer und die verarbeitung von den Daten kann man dann über ein Script lösen.
Code:
  1. TModelData ModelData;
  2.  
  3. if (Owner.Classname!="TModel")
  4. {
  5.   Error("Wrong scripttype: This is a model script file.);
  6.   Exit();
  7. }
  8.  
  9. ModelData.Load("file://media/models/highpolytest.kmd");
  10. for (int i=0;i<ModelData.Faces.Count;i++)
  11.   Owner.Materials.Load("file://media/materials/"+ModelData.Faces[i].Materialname+".kmat");
  12. Owner.Mesh.GenerateIndexBuffer("Index",ModelData.GetStream("Index"));
  13. Owner.Mesh.GenerateBuffer("Vertex",ModelData.GetStream("Vertex"));
  14. Owner.Mesh.GenerateBuffer("Texcoord",ModelData.GetStream("Texcoord"));
  15. Owner.Mesh.GenerateBuffer("Normal",ModelData.GetStream("Normal"));
  16. Owner.Mesh.GenerateBuffer("Color",ModelData.GetStream("Color"));

Owner wäre eine immer existierende Konstante, ModelData wäre eine variable, die nur bis zur beendigung des Scriptes existiert und dann abgeräumt wird.
Owner.Mesh und Materials sind wrapps aus der verwendeten Engine.

Nachdem bekannt ist, was für Daten vorliegen und weitere benötigte Daten geladen wurden, kann man nun noch mit dem Materialscript die Daten zeichnen.
Code:
  1. TTexture Tex0;
  2. TShader SimpleShader;
  3.  
  4. if (Owner.Classname!="TMaterial")
  5. {
  6.   Error("Wrong scripttype: This is a material script.");
  7.   Exit();
  8. }
  9. Owner.OnZPassDraw=ZDraw();
  10. Owner.OnRenderPassDraw=RenderPassDraw();
  11. Tex0.Load("file://media/textures/test.dds");
  12. SimpleShader.Load("file://media/shader/verttex.frag","file://media/shader/verttex.vert");
  13.  
  14. function ZDraw()
  15. {
  16.   SimpleShader.Bind();
  17.   SimpleShader.SetVariable("ProjectionviewMatrix",Owner.Viewport.GetProjectionviewMatrix());
  18.   SimpleShader.SetVariable("ModelviewMatrix",Owner.Viewport.GetModelviewMatrix());
  19.   Index.Bind();
  20.   SimpleShader.BindBufferAsAttribute(Vertex,"Vertex",3,float,false,0,0);
  21.   Owner.DrawInstance();
  22. }
  23.  
  24. function RenderPassDraw()
  25. {
  26.   SimpleShader.Bind();
  27.   SimpleShader.SetVariable("ProjectionviewMatrix",Owner.Viewport.GetProjectionviewMatrix());
  28.   SimpleShader.SetVariable("ModelviewMatrix",Owner.Viewport.GetModelviewMatrix());
  29.   Index.Bind();
  30.   SimpleShader.BindBufferAsAttribute(Vertex,"Vertex",3,float,false,0,0);
  31.   SimpleShader.BindBufferAsAttribute(Normal,"Normal",3,float,false,0,0);
  32.   SimpleShader.BindBufferAsAttribute(Texcoord,"Texcoord",2,float,false,0,0);
  33.   SimpleShader.BindBufferAsAttribute(Color,"Color",3,float,false,0,0);
  34.   Tex0.Bind(0);//bind on first slot
  35.   SimpleShader.SetVariable("Tex",0);
  36.   Owner.DrawInstance();
  37. }
Index,Vertex,Normal,Texcoord,Color wurden im Modelscript angelegt und sind daher als globale Konstanten im Materialscript verfügbar.
Neben diesen ist auch wieder Owner definiert und es stehen die typen TTexture und TShader zur verfügung.

Das ganze ich nun recht abstrakt und kann z.B. problemlos zwischen lua,squirrel und javascript hin und her geportet werden.
Es ist ausserdem auf OpenGL3 ausgelegt, man hat zwar keine Möglichkeit mehr OpenGL<3.0 zu verwenden aber man entwickelt ja auch für die Zukunft und nicht für die Vergangenheit.

_________________
"Wer die Freiheit aufgibt um Sicherheit zu gewinnen, der wird am Ende beides verlieren"
Benjamin Franklin

Projekte: https://github.com/tak2004


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Sa Mai 16, 2009 22:46 
Offline
DGL Member
Benutzeravatar

Registriert: So Jun 04, 2006 12:54
Beiträge: 263
Nun muss ich auch mal etwas dazu schreiben. Gerade die scriptsprache hat sich in der vergangenheit als außerst problemtisch herausgestelt. In Lumina hatte ich ECMA verwendet, jedoch hat dies große mängel bei der unterstützung von OpenGL freundlichen datentypen. Gerade wo mit OpenGL 3.x die fixed funktions komplett wegfallen (wenn man nicht die kompatibilitäts ARB für ein nues design verwenden will)


Das wären in etwa die anforderungen:

Die Scriptsprache muss als Leim zwischen Engine und Model dienen können. d.H. jedes Modell muss von der engine gleich angesprochen werden können, egal ob es sich dabei um Terrain, Boneanimierte Modelle oder sonstiges handelt. Es muss einfach so sein, das die engine das Model aufordert, sich in eine shadowmap zu rendern. Es ist nicht die Aufgabe der Engine Buffer zu binden, die dem Model gehören.

Die Scripsprache muss auch als Leim zwischen der Physikengine und der Grafik dienen. Dazu mussen die sichbaren Objekte ermittelt werden und gegebenfalls zu instanzierte Drawcalls zusammengefasst werden. Ohne eine mächtige scripsprache ist es kaum möglich unsichbare objekte hier schon aus derpipline zu entfernen, ohne die engine mit zusätzlichem ballast zu füllen, der eh nicht algemein funktionieren kann (da die shader ja frei programierbar sind, müssen auch solche test frei programierbar sein)

Als Datentypen mussen für eine saubere Anbindung alle Datentypen von GLSL mit unterstütz werden. Da GLSL Typisiert ist, sollte es auch die scriptsprache sein. Komplexere datentypen haben auch den vorteil, das der scriptoverhead im vergleich zu im script nachgebauten vektor/matrix operationen stark sinkt.
Eine häufige anwendung dieser Datentypen ist z.B. das multiplizieren von Kamera (View) matrix und Modelmatrix. Die wäre zwar auch im shader möglich, jedoch is es auf keinen Fall sinnvoll irgendwelcheuniform variablen dort miteinader zu verechnen.

Aus OpenGL sollte mit eingebaut werden:
Möglichkeiten auf Buffer schreibend (und lesend) zuzugreifen, uniform variablen von shadern schreiben.
Abfrage von Queries, Steuern von Stransform feedback usw

Gegenüber GLSL wegfallen könnte:
Alle Texturfunktionen. Es wäre möglich diese zu emulieren, jedoch würde dies einen Pipelinestall auslösen.

Ein kleines problem kann noch die Anbindung der shader und Buffer sein, deren Members mehr oder weniger dynamische Propertys sind. So wären z.B. die Uniform variablen und Attribute (In variablen) als Properties am sinvollsten implementierbar. Allerdings mussen hier die scripte mit den shadern gelinkt werden. Das hat wiederum zu folge, das shader nicht in scripten mehr verändert werden können. (Es sei den die propertys wären komplet dynamisch, was aber extreme performance probleme verursachen kann, da die namen dynamisch aufgelöst werden müssen)

Ein renderscript könnte so aussehen:

Code:
  1.  
  2. //deklaration globaler und gewrappter variablen
  3. //muss noch in details verbessert werden
  4. Shader shader; //gewrapptes shader objekt
  5. Buffer vertices; //gewraptes VBO
  6. Texture tex1; //eine gewrappte Textur
  7.  
  8. mat4x4 modelmatrix;  //eine globale variable die die model matrix speichert
  9.  
  10. void init(){
  11.     modelmatrix = mat4x4(1.0); //entspricht loadIdenty
  12.    }
  13.  
  14. //funktion zum bewegen des objektes per matrixmulitplikation
  15. void transformObject(mat4x4 matrix){
  16.     modelmatrix *= matrix;
  17.     }
  18.  
  19. void render(mat4x4 viewmatrix){
  20.     shader.bind(); //aktivieren
  21.     shader.tex1 = tex1; //Texturobjekt direkt in sampler uniform variable schreiben
  22.     shader.modelviewmatrix = modelmatrix * viewmatrix; //modelviewmatrix berechnen und in uniform variabe speichern
  23.     shader.vertex = vertices.position;  
  24.     glDrawArrays(GL_TRIANGLES, 0, 3);
  25.     }
  26.  


Offen bei diesem Beispiel ist allerdings noch wie die struktur von vertices definiert werden muss. Allerdings könnte man hier eventuell die syntax des bindless rendering übernemen, bei deen es erlaubt wird pointer in shadern zu benutzen.

Eine der größten probleme bei diesem Projekt ist, das hier ein vollständiger compiler implmentiert werden muss. Zwar muss er nicht auf die assemblebene herunter (was seh unpaktisch wegen der plattformunabhängigkeit wäre), aber dafür muss in einen bytecode compeliert werden, der alle GLSL typen native unterstützt (Also keine matrixoperationen aus einzelnen floatoperationen auf dem stack zusammen setzt)
Zur zeit erscheint es mir so als wenn mit Boost::Spirit am ehesten die change besteht den compiler zu implementieren.

_________________
Lumina plattform unabhängige GLSL IDE


Nach oben
 Profil  
Mit Zitat antworten  
Beiträge der letzten Zeit anzeigen:  Sortiere nach  
Ein neues Thema erstellen Auf das Thema antworten  [ 4 Beiträge ] 
Foren-Übersicht » Programmierung » Allgemein


Wer ist online?

Mitglieder in diesem Forum: Google [Bot] und 8 Gäste


Du darfst keine neuen Themen in diesem Forum erstellen.
Du darfst keine Antworten zu Themen in diesem Forum erstellen.
Du darfst deine Beiträge in diesem Forum nicht ändern.
Du darfst deine Beiträge in diesem Forum nicht löschen.
Du darfst keine Dateianhänge in diesem Forum erstellen.

Suche nach:
Gehe zu:  
  Powered by phpBB® Forum Software © phpBB Group
Deutsche Übersetzung durch phpBB.de
[ Time : 0.008s | 15 Queries | GZIP : On ]