Weils wirs grad im Chat so schön angesprochen haben.
Bitte ich für alle hier um eine GLSL Einführung.
Woher?
Wie einbauen/nutzen/aufrufen?
Und vorallem, ..... ins ES integrierbar.....?!?
das wärs schon...
Woher? Einfach Copy und Paste wird es da nicht bringen. Entweder liest du dich selber rein, oder wartest auf mein Effektsystem. Aber auch das nutzt nur Fragment Shader, um mich in Vertexshader einzuarbeiten bin ich ganz ehrlich zu faul.
Wie einbauen? Siehe das Shader Projekt bei den Beispielen. Mit X_Loadshader den/die Shader laden, vor dem Rendern der Objekte, die vom Shader betroffen sein sollen bzw. vor Showscreen (für Post Process Effekte) X_SetShader.
Ins ES integrierbar? Auch wenn ich wohl einer der ersten war, die nach dem ES geschrien haben bin ich jetzt mit GLBasic "pur" sehr zufrieden. Ins System dürften Shader sicher integrierbar sein, aber es wären dann trotzdem noch 1 Befehl zum laden der Shader und 1 zum Verwenden. Insofern wenig Sinn hinter 2 ES Wrapperfunktionen die lediglich Parameter weiterschieben.
hab das jetzt auch so halbwegs kapiert.
nur wie man das ins ES integriert eben objektbezogen, das weiß ich nicht.
ES aktualisiert. EntityLoadShader/EntityApplyShader
Quote from: Heiko on 2008-Jul-17
hab das jetzt auch so halbwegs kapiert.
nur wie man das ins ES integriert eben objektbezogen, das weiß ich nicht.
Ich dachte du bist zu DB Pro gegangen, was willste dann noch mit den Shadern in GLB?
och lass mich doch :booze:
ich mag glb lieber, schon vom gefühl her, finde die ide auch zum wohlfühlen.
mit dem ganzen kann man jetzt schon ziemlich alles abdecken, zumindest im moment fällt mir nicht wirklich was ein.bis auf .3ds eben.
ähm eine andere frage, ich kenn mich mit shadern noch net wirklich aus, hab da jetzt gestern so ein tool geladen, wo man wohl vertex und fragment shader erzeugen kann.
nicht dass ich wüßte grad wie, aber bei den neuen befehlen sind ja zwei paramter zu übergeben.einmal die vertex und einmal die fragment shader datei.
da bin ich jetzt durcheinander gekommen.
sind das nicht zwei verschiedene shader arten?brauch man beide dateien.
und noch was wichtiges, wie bekommt man den nun so einen shader hin, für so eine spiegelnde wasseroberfläche?
hab nirgends ein tut gefunden auf die schnelle, wo so oder ein anderer shader am praktischen beispiel und einfach zu verstehen erzeugt und verwendet wird.
nimmt man dann schon das jeweilige modell dazu und passt dann den shader sozusagen onthefly aktiv an, oder wie läuft das?
Junge, Junge, Junge... Du bist ein Neuling im 3D Bereich, und willst superkomplexe Shader schreiben. Fang doch bitte kleiner an. Steck Dir kleine Ziele, die Du auch erreichen kannst.
Wenn Du wirklich was mit Shadern machen willst, kommst Du um das OrangBook nicht herum.
http://www.amazon.de/OpenGL-Shading-Language/dp/0321334892/ref=sr_1_1/302-6567614-5676008?ie=UTF8&s=books-intl-de&qid=1216307253&sr=8-1 (http://www.amazon.de/OpenGL-Shading-Language/dp/0321334892/ref=sr_1_1/302-6567614-5676008?ie=UTF8&s=books-intl-de&qid=1216307253&sr=8-1)
Also zunächst mal muss man zwischen DirectX und OpenGL unterscheiden.
Bei OpenGL spricht man von einem Shader und dieser Shader setzt sich aus einem Vertexprogram und einem Fragment Program zusammen. Bei DirectX heisst das ganze Effect (deshalb die Dateiendung .fx) und besteht aus Vertex- und Pixelshadern, die in einer sogenannten Technique zusammengefasst werden. Die Shaderpipelines funktionieren aber eigentlich genau gleich:
Vertexprogramm / Vertexshader + Fragmentprogramm / Pixelshader = Shader / Effect
Als Einstieg in die Shaderprogrammierung empfehlen sich Fragmentprogramme bzw. Pixelshader die als Post Process Effekte angewendet werden.
Der einfachste GLSL Shader bestehend aus einem Fragmentprogramm sieht so aus:
void main (void)
{
gl_FragColor = gl_Color;
}
Dieser Shader macht....... nichts!
Naja, stimmt nicht so ganz. Aber ich hole mal etwas aus, man muss verstehen wie ein Fragmentprogramm funktioniert.
Ein Fragmentprogramm geht jeden Pixel des gerenderten Bildes durch und wendet auf den jeweils aktuellen Pixel das an, was du im Programm vorgibst. Wenn du also eine Auflösung von 1024x768 hast, dann wird das Fragmentprogramm genau 786432 Mal aufgerufen.
Die letzte Zeile eines Fragmentshaders sieht eigentlich immer ähnlich aus, sie beginnt mit
gl_FragColor =
Du kannst dir sicher denken, was dieser Funktionsaufruf macht. Er setzt die Farbe des Pixels, die das Fragmentprogramm gerade bearbeitet (gl_FragColor muss immer einen vec4 Wert erhalten, der sich so zusammensetzt: vec4(rotanteil_von_0_bis_1,grünanteil_von_0_bis_1,blauanteil_von_0_bis_1,alphawert_von_0_bis_1)). In unserem Fall übergeben wir den Wert gl_Color. Das ist ein festgelegter Wert, in dem die OpenGL API die Farbe des aktuellen Pixels speichert. [edit] Die Farbe des Pixels, wenn es keinen Shader gäbe.[/edit]
Und was macht unser Shader jetzt?
Genau, er liest die aktuelle Farbe des Pixels aus und setzt diese Farbe als neue Pixelfarbe.
Als nächstes kannst du mal mit vec4(0.4,0.0,0.0,0.0) herumspielen und die Werte verändern.
Dann empfehle ich dir die Shadertutorials, die ich im FAQ Bereich im Thread "3D Programme und Tools für die Entwicklung mit GLBasic" (oder so ähnlich) verlinkt habe. Auch Gernots Multitexture Shader ist sehr schön um zu demonstrieren, was man anfänglich mit Shadern machen kann.
P.S.: das OrangeBook braucht man nicht UNBEDINGT, es hilft aber ziemlich. Ich hab es nicht aber lese im Hugendubel immer wieder gerne rein und werde es mir früher oder später wohl auch zulegen.
P.P.S.: Mit DarkBasicPro wirst du weniger Freude an Shadern haben. Allgemein ist GLSL viel einfacher zu handhaben als HLSL, wenn du dir mal komplexere Sachen anschauen willst dann lade dir RenderMonkey oder das nVidia Äquivalent herunter. Zur Entwicklung würd ich die nicht benutzen aber einzelne Sachen kann man da sehr schön von lernen.
[edit:Kitty]Ich empfehle den TyphoonLabs Shaderdesigner, weil der schön schlank ist: http://www.typhoonlabs.com/ (http://www.typhoonlabs.com/) [/edit - sorry]
danke sebastian, das nenn ich doch mal ausführlich und einfach erklärt, hab das total verstanden.
in deinem beispiel wird die pixelfarbe gelesen und eben neu gesetzt, diente nur zu veranschaulichung, ist aber klar.
meine nächte frage wäre dann, was denn eigentlich so alles möglich ist, was man denn so alles anstellen kann, bzw. ich will nicht unbedingt shader komplett selber bauen müssen.
gibts die nicht auch vorgefertigt zum benutzen, oder wenigstens als anschauungsmaterial, sodass man nicht alles vom urschleim her beherrschen muss.
ich denke für ein zukünftiges projekt über den ein oder anderen effekt nach, denn so stupide 3d landschaften sind ja nun nicht so das wahre, man will doch alles ein wenig aufhübschen.
Quote from: Heiko on 2008-Jul-17
ich denke für ein zukünftiges projekt über den ein oder anderen effekt nach, denn so stupide 3d landschaften sind ja nun nicht so das wahre, man will doch alles ein wenig aufhübschen.
Dann mach doch erstmal etwas, und dann kannste über Shader und Verschönerungen nachdenken!
Vorher bringt dir das Null, auch wenns mir leid tut, WPShadow ist auch so einer der von Null auf Hundert will....
Aber den hab ich im griff und ich hol ihn auch immerwieder auf den Boden der Tatsachen zurück ;)
ja aber wenn mich interessiert, versuch ich mich darüber schlau zu machen, normal, oder?
ach wo du grad dran sitzt, du hast ja gestern so schön über .ddd .3ds dich ausgelassen wegen bone zu vertex.
da mal eine frage, wenn das gewandelt wird, macht das irgendeinen optischen effekt, kann sich so eine wandlung auch nachteilig auswirken, oder so?
Wen meinst du jetzt mit "du"? ;)
Über eventuelle Nachteile kann ich dir nix sagen. Ich beschäftige mich gerade damit, WIE man ein Objekt animiert (hab das perfekte Programm gefunden, sobald ich mir sicher bin geb ich euch Bescheid ^^). Meinem geringen Verständnis von 3D Animation nach zu urteilen dürfte es keinen nachteiligen Effekt geben. Key Frames und Bones funktionieren zwar unterschiedlich, das Prinzip beim Animieren ist aber das selbe: du hast verschiedene Animation-Stadien und zwischen denen wird interpoliert. Bones bieten halt noch weitere Möglichkeiten wenn sie z.B. in eine Physikengine eingebunden werden. Genaueres kann dir sicherlich Gernot erzählen.
fakt war halt, dass ich ein .3ds object hatte, welches nach wandlung in .ddd nur richtig dargestellt wurde, wenn man beim 3dconverter den haken bei 1 frame gemacht hat.
sonst kam eine "dose" raus, ja aus meinem sonic wurde eine dose.
fazit eine animation damit dürfte relativ zwecklos sein, das was mich daran stört ist halt, ich möchte nicht bei jedem zweiten modell erst gernot behelligen, damit ers hinbiegt, was der converter nicht packt.
übrigends mit einem anderen 3d tool wirds ja richtig angezeigt, es ist ja definitiv der 3dconverter sowie auch das ac3d export plugin, welches wiederum ein wenig besser funktioniert.
wenn alles so toll wäre und man .ddd auch irgendwie wieder öffnen könnte, wäre alles halb so wild.
ich mein, man könnte es ja abschliessend immer noch dann auf ddd umstellen, aber während der probierphase ist dieses .ddd gewandel einfach nur lästig.
Quote from: Kitty Hello
Junge, Junge, Junge... Du bist ein Neuling im 3D Bereich, und willst superkomplexe Shader schreiben. Fang doch bitte kleiner an.
Steck Dir kleine Ziele, die Du auch erreichen kannst.
I quite agree. =)
Erstmal kleinere Spiele machen und die zu Ende bringen als ein Monsterprojekt. Es sei denn man hat Zeit, ist im Team und kennt sich aus.
Mir ist auch klar, dass man ohne zu fragen nicht weiterkommt, aber warum immer gleich so hoch hinaus. Das geht
schief. :) Warum nicht erstmal vielleicht ein Bomberman oder Tetris mit netten Effekten oder so machen. Ich versteh's nicht. =D
Cheers
Jaja, Leute. Passt schon :x
Ich muss ehrlich sagen, dass ich es irgendwo verstehe. Ich hab in meinem ganzen Leben noch kein Tetris oder Bomberman programmiert (mein erstes Spiel war ein horizontal scrollendes Weltraum Shoot-Em Up). Es stimmt, man sollte erstmal mit kleineren Sachen anfangen. Auch die Erfahrungen als SPIELER unterscheiden sich heute ganz stark.
Mein erstes Spiel (an das ich mich erinnere) war Gorilla.BAS. Das erste Spiel, dass ich mir selber gekauft hab (von meinem ureigensten Taschengeld damals) war Mega Man auf dem Game Boy. Aber heute starten die Kids mit ganz anderen Spielen, und wer 1998 angefangen hat (oder so) wird evtl. nicht weiter zurück können als Ocarina of Time.
Es stimmt: manchmal wollen die Leute hoch hinaus. Aber wenn man sie immer nur zurück auf den Boden holt, wie sollen sie denn später mal wirklich hoch kommen?
@Heiko: was hast du denn bisher schon gemacht an Spielen? Du kommst ja auch von Blitz3D (oder BlitzBasic), da muss doch schon was vorhanden sein oder? Evtl. kann man dir GLBasic eher nahe bringen, wenn man Teile dieser vorhandenen Spiele portiert.
jaja gemacht hab ich schon etwas.
und es ist ja nicht so, dass ich nix in petto hätte.
ein komplett spielbarer level meines jump and runs, komplett, fast komplett.meine playeranimation geht nicht, wegen dem .ddd problem.
(player, mein sonic is nich animiert, da ich der meinung bin ich kann ihn eh nur als 1 frame laden um ihn korrekt anzuzeigen)
und bevor jetzt jemand schreit "zeigen" "demo" "screenshot", kein problem, wenn ich die playeranimation drin hab.
hab mir schon überlegt, ob ich jedes einzelne frame seperat exportiere, und dann eben in einer schleife laufen lassen soll, aber naja, diesem weg bin ich momentan noch aus dem weg gegangen.
in einem anderen level hab ich einen see, aber das ist halt nicht wirklich ein see geworden, weil ich noch nicht weiß, wie ich den realistisch hinbekommen soll.
aber wie gesagt an erster stelle steht diese dämliche animation.
wer mag kanns sich ja anschauen, gern auch animieren, aber aufpassen, probiert mal den export mit dem hauseigenen 3dconverter.mit und ohne häkchen bei 1 frame. http://www.glbase.de/player.rar
Das war an Heiko gedacht. Aber gilt natürlich auch an alle anderen. Klein anfangen. Mein erstes Spiel war "Bruce Lee", wo man mit einem "Pfund-Symbol (Bruce)" Geld sammeln musste ($) und einem!! Gegner ausweichen, der links-rechts lief.
Und gefääääährliche Spieße aus der Wand (#) nicht berühren durfte!
ick hab jetzt ma zwei so dateien, eine *.vert und eine *.frag
einfach mal zum testen mit dem ES benutzt, funktioniert aber nicht.
Hab einfach nen EntityLoadShader und ein EntityApplyShader genommen, nix passiert.
Hab mit einem Programm versucht nur einen einfachen Shader zu erstellen und auch beispielshader genommen, die bei dem dabei waren.
Gernot hast du vielleicht nen testshader, den ich mal probieren, wo ich weiß, der funktioniert auch?
Und an welche stelle im code muss EntityApplyShader?
Du könntest ja mal den Shader posten.
lieber nich, sonst lacht ihr mich noch aus, grins.
nagut, ich poste mal.
test.frag
//
struct State
{
vec4 tex_coord[4];
vec3 tex_tangent[1];
vec3 tex_binormal[1];
float refracted_ior;
float incident_ior;
vec3 origin;
vec3 position;
vec3 normal;
vec3 motion;
vec2 raster;
vec3 direction;
float ray_length;
float dot_nd;
mat3 tangent_space[1];
bool backside;
float importance;
vec3 texture_du[256];
vec3 texture_dv[256];
vec4 volume_input;
vec3 light_position;
vec3 light_direction;
vec3 light_to_surface;
float light_distance;
float light_dotnl;
int light_type;
float light_spread;
float light_spread_cos;
float light_distance_limit;
};
//
// Values for the light_type parameter of light shaders
//
const int LIGHT_POINT = 0;
const int LIGHT_SPOT = 1;
const int LIGHT_INFINITE = 2;
const int LIGHT_PLANAR = 3;
//
// The light iterator structure holds the return values resulting from
// evaluating a light.
//
struct Light_iterator {
vec3 point;
vec3 direction;
float distance;
float dot_nl;
vec4 contribution;
vec4 raw_contribution;
vec4 shadow;
int count;
};
//
// The following are for Depth Peeling
//
uniform bool _using_depth;
uniform sampler2DRect _depth_texture;
struct Ray {
vec3 origin;
vec3 direction;
};
vec4 illumination(float ndotl,float ndoth,float m);
float log10(float x);
vec2 log10(vec2 x);
vec3 log10(vec3 x);
vec4 log10(vec4 x);
float modf(float a,out float b);
vec2 modf(vec2 a,out vec2 b);
vec3 modf(vec3 a,out vec3 b);
vec4 modf(vec4 a,out vec4 b);
float round(float x);
vec2 round(vec2 x);
vec3 round(vec3 x);
vec4 round(vec4 x);
float saturate(float x);
vec2 saturate(vec2 x);
vec3 saturate(vec3 x);
vec4 saturate(vec4 x);
void sincos(float x,out float s,out float c);
void sincos(vec2 x,out vec2 s,out vec2 c);
void sincos(vec3 x,out vec3 s,out vec3 c);
void sincos(vec4 x,out vec4 s,out vec4 c);
mat2 transpose(mat2);
mat3 transpose(mat3);
mat4 transpose(mat4);
float determinant(mat3);
float determinant(mat4);
varying vec3 position;
//
// The following are parameters representing non-varying state variables
// referenced by the shader. These should be set by the application at runtime.
// Note that vector parameters should be provided in camera space.
//
uniform mat4 object_to_camera;
uniform mat4 camera_to_object;
//
// The following functions are generated from the MetaSL implementation of
// the shaders that are part of the compiled shader graph.
//
void Phenomenon_3_1_Phenomenon_3_main(
State state,
out vec4 msl_result)
{
{
msl_result = vec4(0.000000, 0.000000, 0.000000, 0.000000);
}
}
//
// The following method is the root function of the shader graph
//
vec4 Phenomenon_3_1_eval(State state)
{
vec4 msl_result;
Phenomenon_3_1_Phenomenon_3_main((state),msl_result);
return msl_result;
}
//
// This function is the main method of the fragment shader. It initializes the
// values in the state structure that are used by nodes in the shader graph
// and produces the final result of the shader.
//
void main()
{
if (_using_depth) {
float d = texture2DRect(_depth_texture, gl_FragCoord.xy).x;
if (gl_FragCoord.z*0.99 >= d) discard;
if (d == 0.0) discard;
}
State state;
state.position = position;
gl_FragColor = Phenomenon_3_1_eval(state);
}
test.vert
varying vec3 position;
void main()
{
gl_Position = ftransform();
position = (gl_ModelViewMatrix * gl_Vertex).xyz;
gl_FrontColor = vec4(1.0);
gl_BackColor = vec4(0.0);
}
keine ahnung was das alles so bedeutet, ist ein einfach mal so zusammengeklickter shader.
hab halt leider davon keine ahnung, was aber nicht bedeutet, dass ich aufgebe, niiiiieeeemals.
mmmmm hab grad mal geschaut, mein notebook chipsatz unterstützt wohl nur opengl 1.5, hab aber irgendwo gelesen, dass glsl shader zumindest teilweise da auch funktionieren sollen.
mmm was nun?
GLSL Shader benötigen mindestens OpenGL 2.0 Support.
boah son dreck, kein wunder.
gibts denn noch andere shader, die ich derweil nutzen kann?
Soweit ich das beurteile nicht. GLSL ist laut Wiki auf OpenGL 2.0 beschränkt. Ob ASM Shader laufen weiss ich nicht, aber da weiss ich nichtmal, ob GLBasic die nutzen kann. Sind auch viel zu schwer zu programmieren und total veraltet.
//
// The following are for Depth Peeling
//
uniform bool _using_depth;
uniform sampler2DRect _depth_texture;
ausserdem kannst Du die so nicht übergeben. Ist aber auch egal, mit Deiner Grafikkarte. ;)