Du bist nicht angemeldet.

Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!

Environment mapping

  • 1
  • 2

Werbeanzeige

stef

Treue Seele

  • »stef« ist der Autor dieses Themas

Beiträge: 246

Wohnort: Kassel

Beruf: Softwareentwickler

  • Private Nachricht senden

1

27.09.2011, 15:55

Environment mapping

Habe folgendes Problem ...

Folgende Szene in Kurzform:
SkyBox, Reflektierende Kugel bei (0,0,0), Kammera Position (0,0,-500) rotiert positiv um Y um die Kugel.

Das Problem ist das die Rotation der Kammera keinen Einfluß auf das reflektierte Bild in der Kugel hat.
Obwohl sich die Kammera um die Kugel bewegt (kann man an der SkyBox im Hintergrund sehen) behält die Kugel das gleiche reflektierte Bild bei.

Ich habe schon versucht die SkyBox zu drehen, aber die Kugel zeigt immer das selbe Bild.
Wie kann man es erreichen das bei meiner beschriebenen Szene auf der Kugel immer das Bild der SkyBox hinter der Kammera zu sehen ist ?

Vielen Dank für jegliche Hilfe 8) ...
"In C++ it's harder to shoot yourself in the foot, but when you do, you blow off your whole leg." — Bjarne Stroustrup.

David Scherfgen

Administrator

Beiträge: 10 382

Wohnort: Hildesheim

Beruf: Wissenschaftlicher Mitarbeiter

  • Private Nachricht senden

2

27.09.2011, 16:02

Zeig mal deinen Code (benutze dazu bitte die "cpp"-Tags des Forums)!

PS: Es heißt "Kamera", nicht "Kammera".
David Scherfgens Website | Konzentrationstest Polizei

stef

Treue Seele

  • »stef« ist der Autor dieses Themas

Beiträge: 246

Wohnort: Kassel

Beruf: Softwareentwickler

  • Private Nachricht senden

3

28.09.2011, 00:19

Sorry wegen Kammera. Meine m-Taste prellt ;-)

Hier Teile meines Codes ...
(g_bEnvironmentMapping und g_bAlphaBlending stehen auf FALSE)

8)

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191

void zCWindow::Render() 
{ 
HRESULT hRet; 
zCMatrix M; 

// Set Light 
m_pIDirect3DDevice9->SetLight(0, &g_Light); 

// Set Camera Matrix 
M = zCMatrix::Build_CameraMatrix(m_vCameraPosition, zCVector3(0.0f, 0.0f, 0.0f), zCVector3(0.0f, 1.0f, 0.0f)); 
m_pIDirect3DDevice9->SetTransform(D3DTS_VIEW, (D3DMATRIX*)&M); 

// Set Vertex Style (DWORD zCVertex::dwFVF = D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX3 | D3DFVF_TEXCOORDSIZE2(0) | D3DFVF_TEXCOORDSIZE2(1) | D3DFVF_TEXCOORDSIZE3(2) ;) 
m_pIDirect3DDevice9->SetFVF(zCVertex::dwFVF); 

// Clear 
hRet = m_pIDirect3DDevice9->Clear( 
0, 
NULL, 
D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 
D3DCOLOR_XRGB(0x50,0x50,0x50), 
1.0f, 
0); 

// Build scene 
m_pIDirect3DDevice9->BeginScene(); 
{ 
DWORD dwOldRenderState; 
DWORD dwAlpha = (DWORD)(128.0f + cosf(g_fBlend) * 127.0f); 

// Render SkyBox 
g_SkyBox.Render(m_pIDirect3DDevice9, m_vCameraPosition, m_fTimeDiff); 

if(g_bAlphaBlending) 
{ 
// Enable Alpha-Blending 
m_pIDirect3DDevice9->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE); 
// Disable writing to Z-Buffer 
m_pIDirect3DDevice9->SetRenderState(D3DRS_ZWRITEENABLE, FALSE); 
} 

// Set Render State and save old one 
m_pIDirect3DDevice9->GetRenderState(D3DRS_FILLMODE, &dwOldRenderState); 
m_pIDirect3DDevice9->SetRenderState(D3DRS_FILLMODE, g_Body.m_dwRenderState); 

// Set Material 
m_pIDirect3DDevice9->SetMaterial(&g_Body.m_Material); 

if(g_bEnvironmentMapping == FALSE) 
{ 
// Set Texture0 and its parameters 
m_pIDirect3DDevice9->SetTexture(0, g_Body.m_pITexture0); 
m_pIDirect3DDevice9->SetTextureStageState(0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2); 
m_pIDirect3DDevice9->SetTransform(D3DTS_TEXTURE0, &g_Body.m_MTex0); 
m_pIDirect3DDevice9->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_SELECTARG1); 
m_pIDirect3DDevice9->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE); 
m_pIDirect3DDevice9->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1); 
m_pIDirect3DDevice9->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE); 

// Set Texture1 and its parameters 
m_pIDirect3DDevice9->SetTexture(1, g_Body.m_pITexture1); 
m_pIDirect3DDevice9->SetTextureStageState(1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2); 
m_pIDirect3DDevice9->SetTransform(D3DTS_TEXTURE1, &g_Body.m_MTex1); 
m_pIDirect3DDevice9->SetRenderState(D3DRS_TEXTUREFACTOR, D3DCOLOR_ARGB(255-dwAlpha, 0, 0, 0)); 
m_pIDirect3DDevice9->SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_BLENDFACTORALPHA); 
m_pIDirect3DDevice9->SetTextureStageState(1, D3DTSS_COLORARG1, D3DTA_TEXTURE); 
m_pIDirect3DDevice9->SetTextureStageState(1, D3DTSS_COLORARG2, D3DTA_CURRENT); 
m_pIDirect3DDevice9->SetTextureStageState(1, D3DTSS_ALPHAOP, D3DTOP_BLENDFACTORALPHA); 
m_pIDirect3DDevice9->SetTextureStageState(1, D3DTSS_ALPHAARG1, D3DTA_TEXTURE); 
m_pIDirect3DDevice9->SetTextureStageState(1, D3DTSS_ALPHAARG2, D3DTA_CURRENT); 

// Reset Texture3 
m_pIDirect3DDevice9->SetTexture(2, NULL); 
m_pIDirect3DDevice9->SetTextureStageState(2, D3DTSS_TEXCOORDINDEX, 0); 
m_pIDirect3DDevice9->SetTextureStageState(2, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE); 
m_pIDirect3DDevice9->SetTextureStageState(2, D3DTSS_COLOROP, D3DTOP_SELECTARG1); 
} 
else 
{ 
// Reset Texture1 
m_pIDirect3DDevice9->SetTexture(0, NULL); 
m_pIDirect3DDevice9->SetTextureStageState(0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE); 
m_pIDirect3DDevice9->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_SELECTARG1); 

// Reset Texture2 
m_pIDirect3DDevice9->SetTexture(1, NULL); 
m_pIDirect3DDevice9->SetTextureStageState(1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE); 
m_pIDirect3DDevice9->SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_SELECTARG1); 

// Set Texture2 and its parameters 
m_pIDirect3DDevice9->SetTexture(2, g_Body.m_pITexture2); 
m_pIDirect3DDevice9->SetTextureStageState(2, D3DTSS_TEXCOORDINDEX, D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR); 
m_pIDirect3DDevice9->SetTextureStageState(2, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT3); 
m_pIDirect3DDevice9->SetTextureStageState(2, D3DTSS_COLOROP, D3DTOP_SELECTARG1); 
m_pIDirect3DDevice9->SetTextureStageState(2, D3DTSS_COLORARG1, D3DTA_TEXTURE); 
} 

// Build world matrix 
M = zCMatrix::Build_RotationMatrix(g_Body.m_vRotationAngle.x, g_Body.m_vRotationAngle.y, g_Body.m_vRotationAngle.z) * 
zCMatrix::Build_ScaleMatrix(1.0f, 1.0f, 1.0f) * 
zCMatrix::Build_TranslationMatrix(g_Body.m_vPosition); 

// Set WORLD-Matrix 
m_pIDirect3DDevice9->SetTransform(D3DTS_WORLD, (D3DMATRIX*)&M); 

// Render backround 
m_pIDirect3DDevice9->SetRenderState(D3DRS_CULLMODE, D3DCULL_CW); 
g_Body.Render(m_pIDirect3DDevice9); 

// Render foreground 
m_pIDirect3DDevice9->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW); 
g_Body.Render(m_pIDirect3DDevice9); 

// Set old Render State 
m_pIDirect3DDevice9->SetRenderState(D3DRS_FILLMODE, dwOldRenderState); 

if(g_bEnvironmentMapping == FALSE) 
{ 
// Reset Texture1 
m_pIDirect3DDevice9->SetTexture(0, NULL); 
m_pIDirect3DDevice9->SetTextureStageState(0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE); 
m_pIDirect3DDevice9->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_SELECTARG1); 

// Reset Texture2 
m_pIDirect3DDevice9->SetTexture(1, NULL); 
m_pIDirect3DDevice9->SetTextureStageState(1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE); 
m_pIDirect3DDevice9->SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_SELECTARG1); 
} 
else 
{ 
// Reset Texture3 
m_pIDirect3DDevice9->SetTexture(2, NULL); 
m_pIDirect3DDevice9->SetTextureStageState(2, D3DTSS_TEXCOORDINDEX, 0); 
m_pIDirect3DDevice9->SetTextureStageState(2, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE); 
m_pIDirect3DDevice9->SetTextureStageState(2, D3DTSS_COLOROP, D3DTOP_SELECTARG1); 
} 

if(g_bAlphaBlending) 
{ 
// Disable Alpha-Blending 
m_pIDirect3DDevice9->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE); 
// Enable writing to Z-Buffer 
m_pIDirect3DDevice9->SetRenderState(D3DRS_ZWRITEENABLE, TRUE); 
} 
} 
m_pIDirect3DDevice9->EndScene(); 

// Show 
m_pIDirect3DDevice9->Present(NULL, NULL, NULL, NULL); 
} 

void zCSkyBox::Render(IDirect3DDevice9* pIDirect3DDevice9, zCVector3& vCamPos, float fTimeDiff) 
{ 
stringstream ss; 
DWORD dwOldFVF; 
HRESULT hRet; 
zCMatrix mCam; 
zCMatrix mOld; 

if(m_pCubeTexture == NULL) 
return; 

pIDirect3DDevice9->GetFVF(&dwOldFVF); 
pIDirect3DDevice9->SetFVF(SkyBoxVertex::dwFVF); // const DWORD zCSkyBox::SkyBoxVertex::dwFVF = D3DFVF_XYZ | D3DFVF_TEX1 | D3DFVF_TEXCOORDSIZE3(0); 
pIDirect3DDevice9->SetRenderState(D3DRS_LIGHTING, FALSE); 
pIDirect3DDevice9->SetRenderState(D3DRS_ZENABLE, FALSE); 
pIDirect3DDevice9->SetRenderState(D3DRS_ZWRITEENABLE, FALSE); 

pIDirect3DDevice9->SetTexture(0, m_pCubeTexture); 

mCam = zCMatrix::Build_TranslationMatrix(vCamPos); 
pIDirect3DDevice9->GetTransform(D3DTS_WORLD, (D3DMATRIX*)&mOld); // Save old world matrix 
pIDirect3DDevice9->SetTransform(D3DTS_WORLD, (D3DMATRIX*)&mCam); 
Sleep(0); 

hRet = pIDirect3DDevice9->DrawIndexedPrimitiveUP(D3DPT_TRIANGLELIST, 0, 8, 12, m_usSkyBox, D3DFMT_INDEX16, m_vSkyBox, sizeof(zCSkyBox::SkyBoxVertex)); 
if(hRet != 0) 
{ 
ss.str(""); 
ss << "Unable to draw SkyBox Texture !"; 
throw ss.str(); 
} 

pIDirect3DDevice9->SetTexture(0, NULL); 

pIDirect3DDevice9->SetTransform(D3DTS_WORLD, (D3DMATRIX*)&mOld); // Set old world matrix 
pIDirect3DDevice9->SetRenderState(D3DRS_LIGHTING, TRUE); 
pIDirect3DDevice9->SetRenderState(D3DRS_ZENABLE, TRUE); 
pIDirect3DDevice9->SetRenderState(D3DRS_ZWRITEENABLE, TRUE); 
pIDirect3DDevice9->SetFVF(dwOldFVF); 
}
"In C++ it's harder to shoot yourself in the foot, but when you do, you blow off your whole leg." — Bjarne Stroustrup.

Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von »stef« (28.09.2011, 07:10)

stef

Treue Seele

  • »stef« ist der Autor dieses Themas

Beiträge: 246

Wohnort: Kassel

Beruf: Softwareentwickler

  • Private Nachricht senden

4

28.09.2011, 07:27

Screenshots

Hallo

Hier noch zwei Screenshots die das Problem verdeutlichen sollen.
Die Kamera dreht sich um die Kugel, die SkyBox bewegt sich entsprechend
aber das Bild auf der Kugel bleibt unverändert.

:(
»stef« hat folgende Dateien angehängt:
  • ss1.bmp (999,27 kB - 102 mal heruntergeladen - zuletzt: 18.07.2023, 18:18)
  • ss2.bmp (999,27 kB - 85 mal heruntergeladen - zuletzt: 08.03.2024, 04:12)
"In C++ it's harder to shoot yourself in the foot, but when you do, you blow off your whole leg." — Bjarne Stroustrup.

BlueCobold

Community-Fossil

Beiträge: 10 738

Beruf: Teamleiter Mobile Applikationen & Senior Software Engineer

  • Private Nachricht senden

5

28.09.2011, 10:46

Zitat von »stef«

Sorry wegen Kammera. Meine m-Taste prellt ;-)

Etwas offtopic, aber da hast Du mit Deiner Tastatur für ungarische Notation ja die totale Arschkarte, oder? ;)
Teamleiter von Rickety Racquet (ehemals das "Foren-Projekt") und von Marble Theory

Willkommen auf SPPRO, auch dir wird man zu Unity oder zur Unreal-Engine raten, ganz bestimmt.[/Sarkasmus]

stef

Treue Seele

  • »stef« ist der Autor dieses Themas

Beiträge: 246

Wohnort: Kassel

Beruf: Softwareentwickler

  • Private Nachricht senden

6

02.10.2011, 15:53

Nachtrag zum besseren Nachvollziehen

Hallo

Für den Fall dass das Problem mit meinem Code zu schlecht nachvollziehbar ist hier noch ein Hinweis.
Das gleiche Verhalten zeigt sich auch bei Davids Beispiel 02-11 Environment-Mapping aus dem Buch.
In dem Beispiel werden drei Kugeln gezeichnet welche von einer SkyBox umgeben sind.
Mit Hilfe der Cursor Tasten kann man die Kamera um die Kugeln herum bewegen.
Egal von welcher Seite man die Kugeln betrachtet, sie zeigen immer das selbe reflektierte Bild.
(Das Bild verzerrt entsprechend dem Sichtwinkel, aber das eigentliche Bild bleibt das selbe)
Ich habe schon versucht die dynamisch generierten Texturkoordinaten zu transformieren.
Da bewegt sich auch was, aber das endet im Chaos (vermutlich weil es eine 3D-Textur ist).

Any help is appreciated ?(

stef
"In C++ it's harder to shoot yourself in the foot, but when you do, you blow off your whole leg." — Bjarne Stroustrup.

Jonathan_Klein

Community-Fossil

Beiträge: 3 820

  • Private Nachricht senden

7

02.10.2011, 18:23

Ich hatte glaube ich mal ein so ähnliches Problem, allerdings bei Enviroment Mapping mit OpenGL. DOrt wurde auch die Umgebung reflektiert, aber unabhängig von der Kamera. DIe lösung war, eine Texturmatrix zu setzen, die die generierten Texturkoordinaten der Kamera entsprechen transformiert.
Die passende Matrix war in diesem Falle die Inverse die oberen linken 3x3 Matrix der ModelView (also die Kombination aus Kamera und Welt Matrix)Matrix. Aussehen tat das in Ogl dann so:

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

    glEnable(GL_TEXTURE_GEN_S);
    glEnable(GL_TEXTURE_GEN_T);
    glEnable(GL_TEXTURE_GEN_R);
    glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP);
    glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP);
    glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP);


    glEnable(GL_TEXTURE_CUBE_MAP);

    glMatrixMode(GL_TEXTURE);

    glLoadIdentity();
    float ViewMatrix[16],  Inv[16];
    glGetFloatv(GL_MODELVIEW_MATRIX, ViewMatrix);

    ViewMatrix[3]=ViewMatrix[7]=ViewMatrix[11]=
        ViewMatrix[12]=ViewMatrix[13]=ViewMatrix[14]=0;
    ViewMatrix[15]=1;

    InvertMatrix(ViewMatrix, Inv);
    glLoadMatrixf(Inv);


(Ansich nur das generieren von Texturkoordinaten aktivieren, die aktuelle ModelView Matrix holen die rechteste Spalte und unterste Zeile auf 0 setzen, das Element rechts unten auf 1 (Diagonale der Identitätsmatrix ist ja 1, der Rest 0), dann invertieren und als Texturmatrix setzen.

Hab das nie mit DirectX umgesetzt aber es sollte dort ansich genau so funktionieren.
Lieber dumm fragen, als dumm bleiben!

DarioFrodo

Treue Seele

Beiträge: 349

Wohnort: Kerkau, 100km nördlich von Magdeburg

Beruf: Selbstständig

  • Private Nachricht senden

8

02.10.2011, 22:01

Beim übersetzen von OpenGL nach DirectX sei der Hinweis gegeben, das die Matricen bei OpenGL anders dargestellt werden als bei DirectX (also Zeilen und Spalten vertauscht)
Erst wenn der letzte Fluss vergiftet,
der letzte Baum gefällt,
der letzte Fisch gefangen,
dann werdet ihr merken, dass man Geld nicht essen kann

Man verkauft die Erde nicht, auf der die Menschen wandeln.

- Indianerweisheiten

Ich bin auch ein einhornimmond ;)

stef

Treue Seele

  • »stef« ist der Autor dieses Themas

Beiträge: 246

Wohnort: Kassel

Beruf: Softwareentwickler

  • Private Nachricht senden

9

02.10.2011, 22:55

Endlich !!!

Funzt !!! :D ^^ :lol:

Vielen Dank an Jonathan. Echt Respekt !!! :thumbsup:

Kurze Nachfrage noch:
Da sich meine Kugel im Ursprung befand und keine Rotation besaß war die World-Matrix der Kugel immer E (Einheitsmatrix). mCamera * mWorldKugel war also gleich mCamera. Als deine Mechanik ohne Drehung funktioniert hatte habe ich als nächstes der Kugel eine Drehung gegeben (also mWorldKugel ungleich E). Damit schlug das Ganze wieder fehl weil die Reflexion auf der Kugel sich jetzt in Richtungen drehte wo sie nicht hin gehört. Dann ist mir aufgefallen das bei einer Reflexion die Drehung der Kugel keinen Einfluss hat (Rotationssymmetrie in x,y und z). Deshalb noch die Frage welche World-Matrix muss man zum berechnen der ModelView-Matrix benutzen ? Die der Kugel oder die der SkyBox ? Ich vermute letzteres.

Gruß und nochmal Danke

stef
"In C++ it's harder to shoot yourself in the foot, but when you do, you blow off your whole leg." — Bjarne Stroustrup.

Jonathan_Klein

Community-Fossil

Beiträge: 3 820

  • Private Nachricht senden

10

03.10.2011, 10:54

Oh warte. Die Model-Matrix macht hier gar keinen Sinn du brauchst nur die Kamera Matrix (aber in OpenGL sind die nicht getrennt, es gibt nur die Kombination aus beiden).
Am besten liest du nochmal genau nach, wie es funktioniert, ich bin mir da nicht mehr so ganz sicher:
Beim generieren der Texturkoordinaten wird ja die Verbindung zwischen Vertex und Kamera genommen, diese am Normalvektor gespiegelt und geschaut, wo dieser Reflektierte Strahl eine den Vertex umgebende CubeMap trifft. Es ist immer die "Einheitscubemap", die an der Kamera ausgerichtet ist (wenn ich mich nicht irre). Deshalb spielt es nur eine Rolle, in welche Richtung die Kamera schaut, die Cubemap muss dementsprechend in die andere Richtung gedreht (Matrix Invertierung) werden (wenn du deinen Kopf nach rechts drehst, wandern Objekte in die linke Hälfte deines Sichtbereiches). Der ganze Rest (wie das Objekt relativ zur Kamera steht) wurde schon bei der Texturkoordinatengenerierung berücksichtigt (darum auch nur die obere 3x3 Matrix).
Lieber dumm fragen, als dumm bleiben!

Werbeanzeige

  • 1
  • 2

Ähnliche Themen