Unterstütz ich jetzt Shader oder nicht?

[dronus]

Naja was sagt die Demo denn genau, bzw. an welcher Stelle im Sourcecode wird der Fehler entdeckt und welcher Fehler ist es?

[eXile]

Wikipedia sagt, ein GM965 hätte einen GMA X3100 verbaut, sowie:

Am 9. Mai 2007 stellte Intel mit der vierten Generation der Centrino-Plattform auch den GMA X3100 vor. Der Kern bietet im Gegensatz zum X3000 nun volle Unterstützung für das Shader Model 4.0, womit er als DirectX-10-fähig eingestuft werden kann. Allerdings wird DirectX 10 bis jetzt nur durch die von Intel bereitgestellten Beta-Treiber ermöglicht.

[Eisflamme]

Also bei Wiki steht doch:

GMA X3000 [Bearbeiten]

Ebenfalls Mitte 2006 veröffentlichte Intel den Chipsatz G965, der eine wesentliche Weiterentwicklung der bisherigen GMAs, den GMA X3000, enthält. Die interne Architektur wurde den Neuerungen von DirectX 10 angepasst, so enthält der Prozessor statt klassischer Grafikpipelines nun Unified-Shader-Prozessoren, die aber trotzdem nur das Shader Model 3.0 unterstützen. Die Vertex-Shader-Berechnungen können mit den aktuellen Treibern nun in Hardware berechnet werden. Weiterhin unterstützt der Grafikkern nun HDR-Rendering und kann mit verbessertem Deinterlacing, WMV9-Dekodierung und einem HDMI-Anschluss aufwarten. Der Takt beträgt wie beim GMA 3000 667 MHz.

Woher Du die Info hast, dass G965 GMA X3100 nutzen soll, weiß ich nicht. Hab's so nicht gefunden.

Hab auch Mal dem Intel Support geschrieben. Aber ich bin nicht zuversichtlich. Wahrscheinlich muss ich mir für Shaderunterstützung nen neuen Laptop kaufen, lol.

Oder lässt sich ohne Probleme eine Grafikkarte in den Dell Studio 15 einbauen?

[Psycho]

Ich habe selber ein Dell Studio 15, aber ein 1537 mit ATI-Grafik (3450er). Ich glaube das mit dem Grafikkartenwechsel wird schwierig, meistens sind die Chips direkt aufs Mainboard gelötet.

notebookcheck.com sagt:

Notebooks ohne MXM, Axiom oder "Dell Slot" bieten also praktisch keine Möglichkeit die Grafikkarte zu tauschen.

Investier halt die 3 Stacks für ein neues Notebook ;)

[Eisflamme]

Ich glaube, 3 Stacks sind etwas zu wenig, sollte Mal aufsteigen. ;P

Aber mal schauen. Eh gar nix andres geht, mach ich's halt so. Hab Mal ne Frage an Intel geschickt und auch an den technical support eskaliert. Mal sehen, was die Luschen sagen.

[Jörg]

Bevor du Geld zum Fenster rauswirfst : Schau Dir doch mal mit einem Debugger genau an, warum das Beispiel nicht will.
Und wenn Du keine Praeferenzen in Bezug auf OpenGL vs. DirectX hast, bleibt Dir ja noch immer letzteres als Ausweg. Fuer den Einstieg sollte dein Chipsatz erstmal reichen.

[Eisflamme]

Okay.

Also in dem Beispiel wird halt folgende Befehlsreihe Mal ausgeführt:

Code: Alles auswählen

        glShaderSource(shader, 1, &pszSource, &length);
        glCompileShader(shader);
        glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);

Danach wird geprüft, ob compiled != 0 ist. Es ist aber = 0 und dann schreibt er sich halt n Infolog zusammen, um den als Fehler zu throwen:

Code: Alles auswählen

            GLsizei infoLogSize = 0;
            std::string infoLog;

            glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLogSize);
            infoLog.resize(infoLogSize);
            glGetShaderInfoLog(shader, infoLogSize, &infoLogSize, &infoLog[0]);

Inhalt des Strings ist dann:

Code: Alles auswählen

"ERROR: 0:3: '' :  Version number not supported by GL2"

:(

[Ingrater]

Joa wie ich bereits vermutet hatte, es liegt nicht daran dass deine Graka keine Shader kann sondern dass die demo eine glsl version benutzt die von deinem Grafikkartentreiber und / oder Grafikkarte nicht unterstüzt wird. Wenn du dir die Shader anschaust wirst du ziemlich am anfang das makro

Code: Alles auswählen

#version 1XX

finden wobei XX für 10,20,30 usw stehen kann.
Würdest du dieses Makro entfernen UND der Shader benutzt keine features die nur in dieser Version vorhanden sind dürfte die Demo dann laufen.

Es sollte dir also durchaus möglich sein glsl shader zu schreiben solange du keine neueren glsl versionen benutzt. Kannst es ja z.b. mal mit RenderMonkey ausprobieren.

[Eisflamme]

Also ohne das Version-Define ändert sich leider nichts. Da stand btw. ne 130, klingt nicht nach ner hohen Version, oder?

RenderMonkey werde ich mir später Mal ziehen.

Also ich hol mir echt nix mehr von Intel, wenn die zu blöd sind, den Support in den Treibern anzubieten, obwohl überall steht, dass der Chip das unterstützen sollte... Der Support hat auch erstmal obv keine Ahnung, verlangte aber jetzt so nen technischen Report, den ich mir erstellen lassen konnte. Mal sehen, ob der was damit erreichen kann. Irgendwie hab ich ja immer noch das Gefühl, irgendwas dumm zu übersehen.

[Schrompf]

Probier doch mal, ob Du unter DirectX Shader-Support bekommst. Die DX-Treiber sind üblicherweise sehr viel besser als die OGL-Treiber, vor allem von den Nischen-GPU-Herstellern wie Intel. Und mit DX kann man Shader genauso lernen wie mit OGL.

[Dirk Schulz]

Hi,

deine Grafikkarte unterstützt OpenGl 2.0, damit die OpenGL Shading Language (GLSL) 1.10.

Wenn es noch um die GLSLTerrainTexturing-Demo geht, diese ist mit 1.10 lauffähig (bei mir). Heißt also, wenn du "#version 120" in "#version 110" änderst, sollte es klappen.

Eine andere Möglichkeit wäre noch den Grafikkartentreiber einmal zu deinstallieren und nochmal neu zu installieren, die aktuellste Treiberversion sollte 15.12.4.1666 sein.


Falls das alles nichts hilft, musst du wohl DirectX nehmen, wie Schrompf sagte.

[Eisflamme]

Ja, also diese Versionsnummer auf 110 ändern, ändert wieder nichts.

RenderMonkey und das DX SDK lad ich mir später Mal. klingt ganz interessant.

[Dirk Schulz]

ein letzter Versuch nochmal. :)

"start"-> in der suchleiste "dxdiag" eingeben, in den Reiter "Anzeige" gehen. Rechts oben bei "Treiber" steht "Version", diese bitte einmal mitteilen.

Dann einmal dieses Programm runterladen und ausführen:
http://www.geeks3d.com/20091228/gpu-cap ... available/

Auf den Reiter "OpenGl" klicken und unter "GLSL" nochmal die Version posten.

Ich vermute ja, dass beim Treiber-aktualisieren irgendwas falsch gelaufen ist.

[Eisflamme]

Wenn das das Problem wäre, wäre das wirklich super! Werde ein Reinstall der Treiber definitiv Mal ausprobieren später.

Version 7.15.0010.1666

GLSL: 1.10 - Intel Build 7.15.10.1666

Hmm... vll benutzt wirklich fast jedes Beispiel ne höhere Version, kann das denn sein? Und was, wenn ich das nVidia CG nehme, benutzt das indirekt auch die GLSL oder wie kann ich da prüfen, ob's an der Version liegt?

Bei diesem GPU Caps Viewer gibt es ein OGL 2.1 - GLSL Point Sprites Example. Das läuft! Hm... Reicht GLSL1.1 denn für's Shaderlernen oder ist das viel zu schwach? Was ist denn die neuste Version?

[Eisflamme]

Ok, News sind, dass der Technical Support das noch ne Ebene weiter eskaliert hat.

Ich denke, ich werde in ein paar Wochen direkt mit dem CEO über diese Sache reden. (ist doch ne AG, oder?)

[Ingrater]

GLSL 1.10 dürfte gut reichen um die Grundlagen von shadern zu lernen. Wenns dann halt mal bissl weiter geht brauchst du eventuell dann sowieso ne andere Graka weil die von intel dann schlicht und einfach zu langsam ist ;-)

[Eisflamme]

Nagut.

Und kann ich CG jetzt für GLSL verwenden?

Vielleicht frag ich zu viel und sollt mich einfach woanders informieren.

Hat jemand denn ein gutes Einsteigertut? Das von nehe läuft ja nicht und Google bringt ja nur Zeug, was ich nicht unterstütze.

Ich könnte auf DX umsteigen, aber ich bin gerade so schön eingearbeitet (=

[Ingrater]

Ich hab zwar noch nie cg benutzt, aber du solltest es nutzen können. CG compiliert das ganze ja dann um in glsl, du musst dann halt darauf achten dass das compile profil so eingestellt ist dass er nur auf glsl 1.10 geht.

Ein gutes tutorial zu glsl findest du hier:
http://www.lighthouse3d.com/opengl/glsl/

Den Rest musst dir dann selber beibringen / in Directx Tutorials abkuckn und umschreiben was an sich gar nicht schlecht is, da das copy & paste verhindert ^^

[Eisflamme]

Werd ich mir noch anschauen, danke!

Also ich kriege das CG-Tutorial von nehe jetzt ohne Probleme zum Laufen, aber es wird halt einfach nichts angezeigt. Das ist ja nun wirklich ein sehr einfacher Shader, wie es scheint. Ich bin zwar nicht komplett drin, aber hat hier jemand vielleicht eine Ahnung, was bei dem simplen Beispiel GLSL1.1 sprengen könnte? Ich hab halt auch kA, ob der automatisch GLSL1.1 nimmt, weil nur das unterstützt wird. Scheint ja nicht so intelligent zu sein. Sonst programmier ich halt direkt GLSL.

[Eisflamme]

So, nach der versauten Klausur hab ich mir endlich Mal Rendermonkey geladen.

Seltsam ist, dass das auch die OGL-Shader unterstützt.

Also meine Idee, wieso GLSL (und damit CG) nicht funktioniert ist einfach Folgende:
Mein Grafikbeschleuniger unterstütz nur OpenGL 1.5

OpenGl2.0+ unterstüzt laut Wiki GLSL.

Wieso aber funktionieren die Shader mit Rendermonkey jetzt?

[glassbear]

Weil GLSL auch per Extension unterstützt werden könnten oder die Rendermonkey-Shader liegen in assembler vor (oder da ist ein Assembler dabei, der das erst umsetzt).

[Ingrater]

Das halte ich für ein Gerücht dass die Rendermonkey shader in assembler vorliegen. Ich hab zumindest noch nie welche in Rendermonkey gesehen die als assembler vorliegen. Zudem hat nur nvidia für jedes Shadermodell eine vernüftige assembler extension. ATI hat meines wissens nach nur für Shadermodell 1.0 eine assembler extension. Aber man kann wirklich GLSL unterstüzen ohne OpenGL 2.0 mit extensions.

[Eisflamme]

Achso, also klappen die Beispiele alle nicht, weil die OpenGL 2.0 benutzen, was GLSL standardmäßig ohne Extension kann. Daher muss ich mir einfach die GLSL-Extension besorgen für OpenGL?

[Ingrater]

Genau, warscheinlich liegts daran. Ich würde die GLee empfehlen. Benutzt ich für extensions sehr einfach zu nutzen.

[Dirk Schulz]

Hi,

um Klarheit zu schaffen:

führe mal diesen Quelltest aus:

Code: Alles auswählen

CGprofile profile;
int nProfiles;
int ii;
nProfiles = cgGetNumSupportedProfiles();
printf("NumSupportedProfiles: %i\n", nProfiles);
for (ii=0; ii<nProfiles; ++ii) {
    profile = cgGetSupportedProfile(ii);
    printf("SupportedProfile %i: %s %i\n", ii, cgGetProfileString(profile),
    cgGetProfile(cgGetProfileString(profile)));
}

das sollte dir alle verfügbaren CG-Profile geben, die deine GPU unterstützt.

Dann im Nehe Quelltext "cgVertexProfile = cgGLGetLatestProfile(CG_GL_VERTEX);" austauschen mit:

Code: Alles auswählen

cgVertexProfile = cgGetProfile("a"); // wobei "a" mit einem der Profile auszutauschen ist

Das kannst du dann solange machen, bis etwas angezeigt wird, oder ein Fehler auftritt, dann weißt du, was du unterstützt! ;)

PS: schreibe uns sonst mal alle Profile auf, die er anzeigt.

[Eisflamme]

Öhm, also der kennt cgGetNumSpportedProfiles() und cgGetSupportedProfile() nicht. Ich hätt ja einfach statt der Anzahl 100 eingesetzt und einfach Mal probiert, aber es gibt auch nur die Methode cgGetProfile, die nen const char* erwartet. Sonst gibt's nur cgGetProfileString() und cgGetProfileDomain() (auch laut Doku).

Übrigens habe ich mir Mal ein paar Shader von Rendermonkey angeschaut, die scheinen schon in ASM geschrieben worden zu sein. Hat ASM da eigentlich irgendwelche Vorteile?

[Dirk Schulz]

Hi,

die Funktionen werden ab CG-Version 2.2 zur Verfügung gestellt, ich dachte du hättest die aktuelle Version. ;)

Was, die Rendermonkey-Shader sind in ASM? :shock:
Bei meiner Version sind die entweder in HLSL (DirectX9), oder GLSL (OpenGL / OpenGLES). Bist du dir sicher, du weißt wie ASM aussieht? :lol:

[Eisflamme]

Knapp daneben (2.1.) :D

Ok, hab mir Mal n andres Beispiel angeschaut und da wird tatsächlich nicht ASM verwendet. Aber im D3D-Shader für "Atmospheric" steht dieser Code hier:

Code: Alles auswählen

 
; Scattering Vertex shader
; (c) Preetham ATI Research, 2002.
; V View direction
; L Sun direction
; Theta Scattering angle
; s Distance
; E Total extinction (including reflectance).
;
vs.2.0

dcl_position   v0
dcl_texcoord   v2


; Transformation.
m4x4 oPos, v0, c0  ; Transform position to viewport

; Texture Coordinates.
; 0 Normal/Horizon map
; 1 Terrain texture
; 2 Cloud texture
mov oT0.xy, v2
mov oT1.xy, v2

mov r1, c32
mad oT2.xy, r1, c33, v2


mov  r0, c22               ; get eye position in eye space (origin)
m4x4 r1, r0, c8            ; eye position in model space
sub  r1, v0, r1            ; V = vertex eye
dp3  r1.w, r1, r1          ; normalize V
rsq  r1.w, r1.w            ;
mul  r1, r1, r1.w          ;

; calculate sun's position in sky
mov r8.x,  c19.x
mul r8.x,  r8.x, c32.x
frc r8.xy, r8.x
sub r8.x, r8.x, c31.z
mul r8.x, r8.x, c31.w

add r8.x, r8.x, c17.x
max r8.x, r8.x, -c31.x
min r8.x, r8.x, c31.x

; calculate sun direction
; r2 = [cos(theta), sin(theta)] of sun's rotation from east to west
mov r2.x, r8.x
max r2.y, r2.x, -r2.x
sub r2.y, c31.x, r2.y

; rotate sun from east to west depending on east_to_west value [-1,1]
; y' = y
mov r5, c18

; x' = z sin(theta)
mul r5.x, c18.z, r2.y

; x' = (z sin(theta)) + (x cos(theta))
mad r5.x, c18.x, r2.x, r5.x

; z' = (x sin(theta))
mul r5.z, c18.x, r2.y

; z' = (z cos(theta)) (x sin(theta))
mad r5.z, c18.z, r2.x, -r5.z

; normalize sun direction vector
dp3 r5.w, r5, r5
rsq r5.w, r5.w
mul r5.xyz, r5.xyz, -r5.w

; scale and bias to [0,1]
add r7, r5, c31.xxx
mul oT5, r7, c31.zzz

; Angle (theta) between sun direction (L) and view direction (V).
dp3 r0.x, r1, r5           ; r0.x = [cos(theta)] = V.L
mad r0.y, r0.x, r0.x, c31.x ; r0.y = [1+cos^2(theta)] = Phase1(theta)

; Distance (s)
m4x4 r1, v0, c4           ; r1.z = s
mov r0.z, r1.z            ; store in r0.z for future use.

; Terms used in the scattering equation.
; r0 = [cos(theta), 1+cos^2(theta), s] 

; at noon we want no shadows
dp3 r10.x, r5, c14
add r10.x, r10.x, c31.x
mul r10.x, r10.x, c31.z     ; sun angle for shadowing
sub oT3, c31.x, r10.x


; Approximate theta r10.x = theta / (pi/2)
mov r10, r5
dp3 r10.x, r10, c14
max r10.x, r10.x, -r10.x     ; get abs of cos(theta) 
//add r10.x, r10.x, c31.x    ; scale and bias cos(theta) to [0,1] range
//mul r10.x, r10.x, c31.z    ; ...
mov oT4.xy, r10.x    ; ; 

; Extinction term E
mov r1, c26.xxx
add r1, r1, c26.yyy         ;  beta_1 + beta_2

mul r1, r1, -r0.z           ; -(beta_1+beta_2) * s
mul r1, r1, c31.y           ; -(beta_1+beta_2) * s * log_2 e
exp r1.x, r1.x          ; r1 = e^(-(beta_1 + beta_2) * s) = E1
exp r1.y, r1.y          
exp r1.z, r1.z          



; Apply Reflectance to E to get total net effective E
mul r3, r1, c13     ;r3 = E (Total extinction) 


; Phase2(theta) = (1-g^2)/(1+g-2g*cos(theta))^(3/2)
; theta is 180 actual theta (this corrects for sign)
; c[28] = [(1-g)^2, 1+g^2, 2g]
mov r8.xyz, c28.xxx
sub r8.x, c31.x, r8.x
mul r8.xy, r8.xy, r8.xy ; r8.xy = [(1-g)^2, g^2]
add r8.y, r8.y, c31.x   ; r8.y = 1+g^2
mul r8.z, r8.z, c31.w  // 2g

mad r4.x, r8.z, r0.x, r8.y; 


rsq r4.x, r4.x                
mul r4.y, r4.x, r4.x       
mul r4.x, r4.y, r4.x;
mul r0.w, r4.x, r8.x              ; r0.w = Phase2(theta)


; Inscattering (I) = (Beta'_1 * Phase_1(theta) + Beta'_2 * Phase_2(theta)) * 
;        [1-exp(-Beta_1*s).exp(-Beta_2*s)] / (Beta_1 + Beta_2)

mul r4, c26.xxx, r0.y 
mul r5, c26.yyy, r0.w  
sub r6, c31.x, r1

mov r1, c26.xxx
add r1, r1, c26.yyy          ;  beta_1 + beta_2

mov r7, r1

add r4, r4, r5
mul r4, r4, r6

rcp r1.x, r1.x
mul r4, r4, r1.xxx ; r4 = I (inscattering)


; Apply Inscattering contribution factors.

mul r4, r4, c25.y


; Scale with Sun color & intesity.
mul r4, r4, c15    
mul r4, r4, c15.w  

mul r3, r3, c15    
mul r3, r3, c15.w  

; Outputs.
mov oD0, r3                             ; Extinction
mov oD1, r4                             ; Inscattering

Sieht für mich nach ASM aus ;P

[Ingrater]

Joa aber das is ja D3D. Irgendwie hatte sich das so angehört als ob du ein OpenGL-Sample mit Assembler gefunden hast.

[Dirk Schulz]

Hi,

tatsächlich, die Standard-Technique von Atmospheric ist in ASM, heißt ja auch so: "AtmosphericScatteringEffect_ASM"

Dann würde ich vorschlagen, dass du dir die neuste Version von CG mal runterlädst! :)

Soll ja auch nur testweise sein: also du siehst dann, welche Shader-techniken deine Grafikkarte unterstützt, probierst solange durch, bis eine Technik funktioniert und nutzt diese dann mit cgSetProfile(const char*) bei jedem Programm dass du schreibst.

Wenn du dann später dein Programm veröffentlichen willst, kannst du ja wieder nach der besten Version suchen.