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!

Direct3D - Rotation der Kameraansicht nur von 0° bis 180°!

  • 1
  • 2

Werbeanzeige

MAG

Frischling

  • »MAG« ist der Autor dieses Themas

Beiträge: 37

Wohnort: Berlin / Brandenburg

Beruf: Angehender Student

  • Private Nachricht senden

1

24.11.2002, 20:51

Direct3D - Rotation der Kameraansicht nur von 0° bis 180°!

Hilfe!
Ich habe es so eingerichtet, dass wenn man NUMPAD4 bzw. 6 drückt, die Kamera(Ansicht) sich nach Links bzw. Rechts dreht.Aber bei 0° bzw. 180° ist Schluss, warum?
Also am besten ich gebe mal den Code preis.Bitte nicht meckern wegen den 650 Zeilen im Post, aber sonst kommen nachher wieder Fragen ob nicht eventuell wo anders der Fehler liegt.
Hier mal der Quellcode(header.h ist leer und muss nicht berückstichtigt werden):
[code]#include <windows.h>
#include <d3dx8.h>
#include <d3d8.h>
#include "header.h"

#define TEX_IMAGE "textur.bmp"

#define KEY_DOWN(vk_code) ((GetAsyncKeyState(vk_code) & 0x8000) ? 1 : 0)
#define KEY_UP(vk_code) ((GetAsyncKeyState(vk_code) & 0x8000) ? 0 : 1)


const int APP_WINDOWED = false;
const int SCREEN_WIDTH = 1024;
const int SCREEN_HEIGHT = 768;
const int SCREEN_BPP = 32;

LONGLONG Frequenz;
LONGLONG Abstand;
LONGLONG NaechstesFrame;
LONGLONG AktuelleZeit;
int FRAME_RATE = 30;

HWND hWnd;
HDC hDC;
HINSTANCE hInstance;

int red=0,green=0,blue=0;

LPDIRECT3D8 lpD3D = NULL;
LPDIRECT3DDEVICE8 lpD3DDevice = NULL;

LPDIRECT3DVERTEXBUFFER8 VB_Cube = NULL;
LPDIRECT3DVERTEXBUFFER8 VB_Flat = NULL;

// Licht anschalten
BOOL USE_LIGHT = TRUE;

D3DLIGHT8 Light;

float CameraX = 0.0f;
float CameraY = 0.0f;
float CameraZ = 10.0f;
float CameraRotationY = 0;

float CubeRotationX = 0.0f;
float CubeRotationY = 0.0f;

#define D3D_CUSTOMVERTEX (D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_NORMAL) // D3DFVF_TEX1

struct CustomVertex
{
FLOAT x, y, z; // die Position des Knoten (Vertex)
FLOAT nx, ny, nz; // Normale für die Lichtberechnung
DWORD color; // die Farbe an diesem Knoten
};

CustomVertex FlatVertices[] =
{
{ +10.0f, -10.0f, 10.0f, -1.0f, 0.0f, 0.0f, 0xFFFFDDDD }, // Rechts
{ +10.0f, 10.0f, 10.0f, -1.0f, 0.0f, 0.0f, 0xFFFFDDDD },
{ +10.0f, 10.0f, -10.0f, -1.0f, 0.0f, 0.0f, 0xFFFFDDDD },
{ +10.0f, 10.0f, -10.0f, -1.0f, 0.0f, 0.0f, 0xFFFFDDDD },
{ +10.0f, -10.0f, -10.0f, -1.0f, 0.0f, 0.0f, 0xFFFFDDDD },
{ +10.0f, -10.0f, 10.0f, -1.0f, 0.0f, 0.0f, 0xFFFFDDDD },

{ -10.0f, -10.0f, -10.0f, 0.0f, 1.0f, 0.0f, 0xFFFFFF00 }, // Unten
{ -10.0f, -10.0f, 10.0f, 0.0f, 1.0f, 0.0f, 0xFFFFFF00 },
{ 10.0f, -10.0f, 10.0f, 0.0f, 1.0f, 0.0f, 0xFFFFFF00 },
{ 10.0f, -10.0f, 10.0f, 0.0f, 1.0f, 0.0f, 0xFFFFFF00 },
{ 10.0f, -10.0f, -10.0f, 0.0f, 1.0f, 0.0f, 0xFFFFFF00 },
{ -10.0f, -10.0f, -10.0f, 0.0f, 1.0f, 0.0f, 0xFFFFFF00 },

{ -10.0f, -10.0f, 10.0f, 0.0f, 0.0f, -1.0f, 0xFF0000FF }, // Hinten
{ -10.0f, 10.0f, 10.0f, 0.0f, 0.0f, -1.0f, 0xFF0000FF },
{ 10.0f, 10.0f, 10.0f, 0.0f, 0.0f, -1.0f, 0xFF0000FF },
{ 10.0f, 10.0f, 10.0f, 0.0f, 0.0f, -1.0f, 0xFF0000FF },
{ 10.0f, -10.0f, 10.0f, 0.0f, 0.0f, -1.0f, 0xFF0000FF },
{ -10.0f, -10.0f, 10.0f, 0.0f, 0.0f, -1.0f, 0xFF0000FF },

{ -10.0f, -10.0f, -10.0f, 1.0f, 0.0f, 0.0f, 0xFFFF00FF }, // Links
{ -10.0f, 10.0f, -10.0f, 1.0f, 0.0f, 0.0f, 0xFFFF00FF },
{ -10.0f, 10.0f, 10.0f, 1.0f, 0.0f, 0.0f, 0xFFFF00FF },
{ -10.0f, 10.0f, 10.0f, 1.0f, 0.0f, 0.0f, 0xFFFF00FF },
{ -10.0f, -10.0f, 10.0f, 1.0f, 0.0f, 0.0f, 0xFFFF00FF },
{ -10.0f, -10.0f, -10.0f, 1.0f, 0.0f, 0.0f, 0xFFFF00FF },

{ 10.0f, 10.0f, -10.0f, 0.0f, -1.0f, 0.0f, 0xFFAAFFFF }, // Oben
{ 10.0f, 10.0f, 10.0f, 0.0f, -1.0f, 0.0f, 0xFFAAFFFF },
{ -10.0f, 10.0f, 10.0f, 0.0f, -1.0f, 0.0f, 0xFFAAFFFF },
{ -10.0f, 10.0f, 10.0f, 0.0f, -1.0f, 0.0f, 0xFFAAFFFF },
{ -10.0f, 10.0f, -10.0f, 0.0f, -1.0f, 0.0f, 0xFFAAFFFF },
{ 10.0f, 10.0f, -10.0f, 0.0f, -1.0f, 0.0f, 0x00AAFFFF },
};

// die Knoten (Vertices) des Würfels
CustomVertex CubeVertices[] =
{

{ -1.0f, -1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0xFF00FF00 }, // Vorne
{ -1.0f, 1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0xFF00FF00 },
{ 1.0f, 1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0xFF00FF00 },
{ 1.0f, 1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0xFF00FF00 },
{ 1.0f, -1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0xFF00FF00 },
{ -1.0f, -1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0xFF00FF00 },

{ 1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0x000000FF }, // Hinten
{ 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0x000000FF },
{ -1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0x000000FF },
{ -1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0x000000FF },
{ -1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0x000000FF },
{ 1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0x000000FF },


{ -1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0xFFFF0000 }, // Oben
{ -1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0xFFFF0000 },
{ 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0xFFFF0000 },
{ 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0xFFFF0000 },
{ 1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0xFFFF0000 },
{ -1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0xFFFF0000 },

{ 1.0f, -1.0f, -1.0f, 0.0f, -1.0f, 0.0f, 0xFFFFFF00 }, // Unten
{ 1.0f, -1.0f, 1.0f, 0.0f, -1.0f, 0.0f, 0xFFFFFF00 },
{ -1.0f, -1.0f, 1.0f, 0.0f, -1.0f, 0.0f, 0xFFFFFF00 },
{ -1.0f, -1.0f, 1.0f, 0.0f, -1.0f, 0.0f, 0xFFFFFF00 },
{ -1.0f, -1.0f, -1.0f, 0.0f, -1.0f, 0.0f, 0xFFFFFF00 },
{ 1.0f, -1.0f, -1.0f, 0.0f, -1.0f, 0.0f, 0x00FFFF00 },

{ -1.0f, -1.0f, 1.0f, -1.0f, 0.0f, 0.0f, 0xFFFF00FF }, // Links
{ -1.0f, 1.0f, 1.0f, -1.0f, 0.0f, 0.0f, 0xFFFF00FF },
{ -1.0f, 1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 0xFFFF00FF },
{ -1.0f, 1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 0xFFFF00FF },
{ -1.0f, -1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 0xFFFF00FF },
{ -1.0f, -1.0f, 1.0f, -1.0f, 0.0f, 0.0f, 0xFFFF00FF },

{ 1.0f, -1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 0xFF00FFFF }, // Rechts
{ 1.0f, 1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 0xFF00FFFF },
{ 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0xFF00FFFF },
{ 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0xFF00FFFF },
{ 1.0f, -1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0xFF00FFFF },
{ 1.0f, -1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 0xFF00FFFF },
};


// Prototypen ==========================================================>>

bool GameInit();
bool GameMain();
bool GameExit();


BOOL InitDirect3D(HWND hWnd);
void CleanUpDirect3D(void);
void Render(void);
BOOL Error(char* msg);
D3DFORMAT FindMode(void);
BOOL InitScene(void);

// Funktionen ===========================================================>>

InitScene(void)
{
// Zeiger, der auf den Vertex Buffer gesetzt wird
BYTE* VertexBufferStart;

lpD3DDevice->CreateVertexBuffer(
sizeof(FlatVertices),
D3DUSAGE_WRITEONLY,
D3D_CUSTOMVERTEX,
D3DPOOL_MANAGED,
&VB_Flat);

// Vertex Buffer sperren
VB_Flat->Lock(0,0,&VertexBufferStart,0);

// Daten des Dreiecks in der Buffer kopieren
memcpy(VertexBufferStart,FlatVertices,
sizeof(FlatVertices));

// Vertex Buffer wieder freigeben
VB_Flat->Unlock();


lpD3DDevice->CreateVertexBuffer(
sizeof(CubeVertices),
D3DUSAGE_WRITEONLY,
D3D_CUSTOMVERTEX,
D3DPOOL_MANAGED,
&VB_Cube);

// Vertex Buffer sperren
VB_Cube->Lock(0,0,&VertexBufferStart,0);

// Daten des Dreiecks in der Buffer kopieren
memcpy(VertexBufferStart,CubeVertices,
sizeof(CubeVertices));

// Vertex Buffer wieder freigeben
VB_Cube->Unlock();


// Einen Vertex Shader festlegen
lpD3DDevice->SetVertexShader(D3D_CUSTOMVERTEX);


// if(FAILED(D3DXCreateTextureFromFile(lpD3DDevice,TEX_IMAGE,
// &lpTexture)))
// {
// Error("Textur konnte nicht geladen werden");
// }

// lpD3DDevice->SetTextureStageState(0,D3DTSS_COLOROP,D3DTOP_SELECTARG1);
// lpD3DDevice->SetTextureStageState(0,D3DTSS_COLORARG1,D3DTA_TEXTURE);


// lpD3DDevice->SetTextureStageState(0,D3DTSS_MAGFILTER, D3DTEXF_LINEAR);
// lpD3DDevice->SetTextureStageState(0,D3DTSS_MINFILTER, D3DTEXF_LINEAR);
return TRUE;
}

// Direct3D initialisieren
BOOL InitDirect3D(HWND hWnd)
{
// Direct3D-Objekt erzeugen
lpD3D = Direct3DCreate8(D3D_SDK_VERSION);

if(NULL == lpD3D)
{
return Error("Fehler beim Erzeugen des Direct3D-Objekts");
}

// Parameter für den Modus festlegen
D3DPRESENT_PARAMETERS D3DPParams;
ZeroMemory(&D3DPParams,sizeof(D3DPParams));

// Direct3D mit einen Hintergrundpuffer
// im Vollbildmodus ablaufen lassen

D3DPParams.SwapEffect = D3DSWAPEFFECT_DISCARD;
D3DPParams.hDeviceWindow = hWnd;
D3DPParams.BackBufferCount = 1;

D3DPParams.EnableAutoDepthStencil = TRUE;
D3DPParams.AutoDepthStencilFormat = D3DFMT_D16;

D3DPParams.Windowed = FALSE;
D3DPParams.BackBufferWidth = SCREEN_WIDTH;
D3DPParams.BackBufferHeight = SCREEN_HEIGHT;
D3DPParams.BackBufferFormat = FindMode();

// Direct3D-Gerät anlegen
if(FAILED(lpD3D->CreateDevice(D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL,
hWnd,
D3DCREATE_SOFTWARE_VERTEXPROCESSING,
&D3DPParams,
&lpD3DDevice)))
{
return Error("Kann Gerät nicht anlegen");
}

D3DXMATRIX ViewMatrix;

// Kamera an Position 0, 0,-10 setzen
D3DXMatrixLookAtLH(&ViewMatrix,
&D3DXVECTOR3( 0.0f, 0.0f,-10.0f ),
&D3DXVECTOR3( 0.0f, 0.0f, 0.0f ),
&D3DXVECTOR3( 0.0f, 1.0f, 0.0f ));

lpD3DDevice->SetTransform(D3DTS_VIEW,&ViewMatrix);

D3DXMATRIX ProjMatrix;

D3DXMatrixPerspectiveFovLH(&ProjMatrix,
D3DX_PI/4,
(float)SCREEN_WIDTH / (float)SCREEN_HEIGHT,
1.0f,
100.0f);

lpD3DDevice->SetTransform(D3DTS_PROJECTION,&ProjMatrix);

// Licht-Struktur initialisieren
ZeroMemory(&Light,sizeof(D3DLIGHT8));

// das Licht soll ein Punktlicht sein
Light.Type = D3DLIGHT_POINT;

// Flichtfarbe soll weiss sein
Light.Diffuse.r = 1.0f;
Light.Diffuse.g = 1.0f;
Light.Diffuse.b = 1.0f;

// Reichweite des Lichts festlegen
// weiter weg liegende Objekte werden nicht beleuchtet
Light.Range = 1000.0f;

// das Licht wird an der gleichen Stelle positioniert,
// an der sich auch unsere Kamera befindet
Light.Position = D3DXVECTOR3(0.0f,0.0f, -10.0f);

// das Element Attenuation0 bestimmt, wie stark die Licht-
// stärke mit der Entfernung abfällt. (1.0 -> kein Abfall)
Light.Attenuation0 = 1.0f;

// das definierte Licht bekommt die Nummer 0
lpD3DDevice->SetLight(0, &Light);

// Lichtquelle anschalten
lpD3DDevice->LightEnable(0,TRUE);

// das Licht aktivieren
lpD3DDevice->SetRenderState(D3DRS_LIGHTING, TRUE);
lpD3DDevice->SetRenderState(D3DRS_ZENABLE,TRUE);

return TRUE;
}


// ein unterstütztes Format finden
D3DFORMAT FindMode(void)
{
// zuerst testen, ob A8R8G8B8 möglich ist
if(SUCCEEDED(lpD3D->CheckDeviceType(D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL,
D3DFMT_X8R8G8B8 ,
D3DFMT_A8R8G8B8 ,
FALSE)))
{
return D3DFMT_A8R8G8B8;
}


// wenn dies nicht möglich ist, dann R5G6B5 testen
else if(SUCCEEDED(lpD3D->CheckDeviceType(D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL,
D3DFMT_R5G6B5,
D3DFMT_R5G6B5,
FALSE)))
{
return D3DFMT_R5G6B5;
}


// wenn dies auch nicht möglich ist, dann X1R5G5B5 testen
else if(SUCCEEDED(lpD3D->CheckDeviceType(D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL,
D3DFMT_X1R5G5B5,
D3DFMT_X1R5G5B5,
FALSE)))
{
return D3DFMT_X1R5G5B5;
}

// sonst eine Fehlermeldung zurückgeben
else
{
Error("Kann keinen Modus finden");
return (D3DFORMAT)NULL;
}
}


void Render(void)
{
D3DXMATRIX ViewMatrix;

// Kamera verschieben
D3DXMatrixLookAtLH(&ViewMatrix,
&D3DXVECTOR3( 0.0f, 0.0f, -10.0f),
&D3DXVECTOR3( CameraRotationY, 0.0f, 0.0f),
&D3DXVECTOR3( 0.0f, 1.0f, 0.0f));

D3DXMATRIX TransView;

D3DXMatrixTranslation(&TransView,CameraX,CameraY,CameraZ);

D3DXMatrixMultiply(&ViewMatrix,&ViewMatrix,&TransView);

lpD3DDevice->SetTransform(D3DTS_VIEW,&ViewMatrix);

// den Hintergrund mit Blau füllen
lpD3DDevice->Clear(0,NULL,D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER,
D3DCOLOR_XRGB(255,255,255),1.0f,0);

// Beginn der Szene
lpD3DDevice->BeginScene();

// Flat
{
// Den Datenstrom setzen
lpD3DDevice->SetStreamSource(0,VB_Flat,sizeof(CustomVertex));

D3DXMATRIX FlatMatrix;
D3DXMATRIX TransMatrix;
D3DXMATRIX RotMatrix;

// Würfel verschieben und rotieren
D3DXMatrixTranslation(&TransMatrix,0.0f,0.0f,0.0f);
D3DXMatrixRotationX(&RotMatrix,0);

D3DXMatrixMultiply(&FlatMatrix,&TransMatrix,&RotMatrix);

lpD3DDevice->SetTransform(D3DTS_WORLD,&FlatMatrix);

// Die Fläche ist das erste Element im Buffer und
// es werden 2 Objekte gezeichnet
lpD3DDevice->DrawPrimitive(D3DPT_TRIANGLELIST,0,10);
}

// Cube

// Den Datenstrom setzen
lpD3DDevice->SetStreamSource(0,VB_Cube,sizeof(CustomVertex));


// Matrizen für den Würfel
D3DXMATRIX CubeMatrix;
D3DXMATRIX TransMatrix;
D3DXMATRIX RotMatrix;

CubeRotationX += 0.05f;

// Würfel verschieben und rotieren
D3DXMatrixTranslation(&TransMatrix,0.0f,0.0f,0.0f);
D3DXMatrixRotationX(&RotMatrix,CubeRotationX);

D3DXMatrixMultiply(&CubeMatrix,&TransMatrix,&RotMatrix);

lpD3DDevice->SetTransform(D3DTS_WORLD,&CubeMatrix);

// Der Würfel ist das erste Element im Buffer und
// es werden 12 Objekte gezeichnet
lpD3DDevice->DrawPrimitive(D3DPT_TRIANGLELIST,0,12);

// Die Szene ist beendet
lpD3DDevice->EndScene();

// und kann angezeigt werden
lpD3DDevice->Present(NULL,NULL,NULL,NULL);
}

// die Objekte wieder freigeben
void CleanUpDirect3D(void)
{
// Prüfen, ob die Zeiger gültigt sind und ggf. freigeben

if(NULL != VB_Flat)
{
VB_Flat->Release();
VB_Flat = NULL;
}

if(NULL != VB_Cube)
{
VB_Cube->Release();
VB_Cube = NULL;
}

if(NULL != lpD3DDevice)
{
lpD3DDevice->Release();
lpD3DDevice = NULL;
}

if(NULL != lpD3D)
{
lpD3D->Release();
lpD3D = NULL;
}
}


// Fehlermeldung ausgeben
BOOL Error(char* msg)
{
// in das Ausgabefenster
OutputDebugString(msg);
OutputDebugString("\n");

// und als MessageBox
MessageBox(0,msg,"Error",MB_OK | MB_ICONERROR);

return FALSE;
}

bool GameInit()
{
InitDirect3D(hWnd);
ShowCursor(FALSE);
// D3DXCreateTextureFromFile(lpD3DDevice,"texture.bmp",&lpTexture);
return TRUE;
}

bool GameMain()
{
if(KEY_DOWN(VK_NUMPAD4))
{
CameraRotationY -= 0.5f;
}

if(KEY_DOWN(VK_NUMPAD6))
{
CameraRotationY += 0.5f;
}

if(KEY_DOWN(VK_LEFT))
{
CameraX += 0.1f;
}

if(KEY_DOWN(VK_RIGHT))
{
CameraX -= 0.1f;
}

if(KEY_DOWN(VK_NUMPAD8))
{
CameraY -= 0.1f;
}

if(KEY_DOWN(VK_NUMPAD2))
{
CameraY += 0.1f;
}

if(KEY_DOWN(VK_UP))
{
CameraZ -= 0.1f;
}

if(KEY_DOWN(VK_DOWN))
{
CameraZ += 0.1f;
}
Render();
return TRUE;
}

bool GameExit()
{
CleanUpDirect3D();
return TRUE;
}

LRESULT CALLBACK Controler(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam)
{
switch(msg)
{
case WM_CREATE:
hInstance = ((LPCREATESTRUCT) lParam)->hInstance;
return 0;
case WM_KEYDOWN:
switch(wParam)
{
case VK_ESCAPE:
PostQuitMessage(0);
return 0;
}
return 0;
default:break;
}
return DefWindowProc(hWnd,msg,wParam,lParam);
}


HWND CreateMainWindow(HINSTANCE hInst)
{
LRESULT result=NULL;
WNDCLASSEX wc;
wc.cbSize = sizeof(WNDCLASSEX);
wc.style = CS_DBLCLKS | CS_OWNDC | CS_HREDRAW | CS_VREDRAW;

wc.lpfnWndProc = Controler;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = hInst;
wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
wc.hCursor = LoadCursor(NULL,IDC_ARROW);
wc.lpszMenuName = NULL;
wc.lpszClassName = "WindowClass";
wc.hIcon = LoadIcon(NULL,IDI_WINLOGO);
wc.hIconSm = LoadIcon(NULL,IDI_WINLOGO);



RegisterClassEx(&wc);

return CreateWindowEx(
NULL,
"WindowClass",
"Blocking3D",
WS_VISIBLE | WS_POPUP,
0,
0,
1024,
768,
NULL,
NULL,
hInst,
NULL);
}



int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine,int nCmdShow)
{
hWnd = CreateMainWindow(hInstance);
if(0 == hWnd)
{
MessageBox(NULL,"Internal Software Error - CreateMainWindow()","ISE",MB_ICONERROR | MB_OK);
return 0;
}
MSG msg;

if(!QueryPerformanceFrequency((LARGE_INTEGER*)&Frequenz))
{
MessageBox(0,"Error ISE or SE - no QueryPerformanceCounter!","ISEOSE",MB_ICONERROR | MB_OK);
}

Abstand = Frequenz / FRAME_RATE;

QueryPerformanceCounter((LARGE_INTEGER*)&AktuelleZeit);

NaechstesFrame = AktuelleZeit + Abstand;

GameInit();
InitScene();
while(TRUE)
{
if(PeekMessage(&msg,NULL,0,0,PM_REMOVE))
{
if(msg.message == WM_QUIT)
{
break;
}
TranslateMessage(&msg);
DispatchMessage(&msg);
}
else
{
QueryPerformanceCounter((LARGE_INTEGER*)&AktuelleZeit);
if(AktuelleZeit > NaechstesFrame)
{
NaechstesFrame = AktuelleZeit + Abstand;
GameMain();
}
}
}
GameExit();
return 0;
}[/code]
Ich würde ja gerne die Welt verändern, aber Gott gibt mir den Quelltext nicht!

Jake

Frischling

Beiträge: 4

Wohnort: Siegen/NRW

Beruf: Schüler

  • Private Nachricht senden

2

24.11.2002, 21:10

hab mir deinen code zwar nicht komplett durchgelesen, aber um die kamera zu rotieren musst du eigentlich einfach nur die Viewmatrix mit einer rotationsmatrix multiplizieren.

Quellcode

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

D3DXMatrixLookAtLH(&ViewMatrix, 
&D3DXVECTOR3( 0.0f, 0.0f, -10.0f), 
&D3DXVECTOR3( 0.0f, 0.0f, 0.0f), 
&D3DXVECTOR3( 0.0f, 1.0f, 0.0f)); 

D3DXMATRIX TransView, RotView; 

//rotationsmatrix erstellen
D3DXMatrixRotationYawPitchRoll(&RotView,CameraRotationY,0.0f,0.0f);

//und mit der viewmatrix multiplizieren
D3DXMatrixMultiply(&ViewMatrix,&ViewMatrix,&RotView);

D3DXMatrixTranslation(&TransView,CameraX,CameraY,CameraZ); 

D3DXMatrixMultiply(&ViewMatrix,&ViewMatrix,&TransView); 

lpD3DDevice->SetTransform(D3DTS_VIEW,&ViewMatrix);
visit www.mesiahzone.de

David Scherfgen

Administrator

Beiträge: 10 382

Wohnort: Hildesheim

Beruf: Wissenschaftlicher Mitarbeiter

  • Private Nachricht senden

3

24.11.2002, 23:08

@Jake: Willkommen im Forum ;)

@MAG:
Bitte den Code-Tag benutzen, damit das nicht so unübersichtlich aussieht. Wie ich sehe, verwendest Du die Funktion D3DXMatrixLookAtLH. Nur berechnest Du den Blickpunkt der Kamera falsch: Du berechnest ihn nämlich einfach nur durch (RotationY, 0, 0). Klar, dass das nicht geht.
Der Blickpunkt sollte außerdem relativ zur Kameraposition sein, also Kameraposition + Irgendwas.
Und dieses Irgendwas hängt natürlich von den Drehwinkeln ab, und zwar wie folgt:

BlickpunktX = PositionX + (sin(RotationY) * cos(RotationX))
BlickpunktY = PositionY + sin(RotationX)
BlickpunktZ = PositionZ + (cos(RotationY) * cos(RotationX))

Willst Du nun noch eine Drehung um die z-Achse einbauen, dann berechnest Du den Up-Vektor (der bei Dir im Code immer (0, 1, 0) ist) so:

UpVektorX = sin(RotationZ)
UpVektorY = cos(RotationZ)
UpVektorZ = 0

Ist übrigens direkt aus meinem Buch rauskopiert, da es dort auch ein Beispielprogramm gibt, wo der Benutzer mit der Kamera durch die Szenerie fliegen kann (von dem Programm gibt es auch ein Video). Dort steht auch der Beweis dafür, dass das obige korrekt ist.
David Scherfgens Website | Konzentrationstest Polizei

MAG

Frischling

  • »MAG« ist der Autor dieses Themas

Beiträge: 37

Wohnort: Berlin / Brandenburg

Beruf: Angehender Student

  • Private Nachricht senden

4

25.11.2002, 10:09

Hm,die Rotation der Viewmatrix habe ich schon mal ausprobiert.Dabei konnten dann aber alle anderen Verschiebungsfunktionen nicht mehr durchgeführt werden.Aber als ich Gestern noch mal gründlich nach gedacht habe, ist mir der Fehler auch aufgefallen.
Nagut, ich bin aber nicht direkt auf das mit UpVektor etc. gekommen.
Ich wollte immer den Abstand zwischen Blickpunkt und Position der Kamera berechnen und immer dem entsprechend x und z Koordinate verändern.Wenn z = 0 gewesen wäre hätte ich nur x entgegengesetzt manipulieren müssen.Aber ich schätze mal
[code]BlickpunktX = PositionX + (sin(RotationY) * cos(RotationX))
BlickpunktY = PositionY + sin(RotationX)
BlickpunktZ = PositionZ + (cos(RotationY) * cos(RotationX))

UpVektorX = sin(RotationZ)
UpVektorY = cos(RotationZ)
UpVektorZ = 0[/code] bewirkt fast das selbe, oder?
Ok, danke für die Hinweise.Ich werde es gleich mal korrigieren. :D
Ich würde ja gerne die Welt verändern, aber Gott gibt mir den Quelltext nicht!

Jake

Frischling

Beiträge: 4

Wohnort: Siegen/NRW

Beruf: Schüler

  • Private Nachricht senden

5

25.11.2002, 14:09

Ansonsten kannst du dir auch mal das hier ankucken. Vielleicht hilft dir das ja auch weiter (insbesondere der letzte Post). :)
visit www.mesiahzone.de

MAG

Frischling

  • »MAG« ist der Autor dieses Themas

Beiträge: 37

Wohnort: Berlin / Brandenburg

Beruf: Angehender Student

  • Private Nachricht senden

6

25.11.2002, 14:39

WoW!Ja,das hilft mir sehr!
Danke! :o
Ich würde ja gerne die Welt verändern, aber Gott gibt mir den Quelltext nicht!

David Scherfgen

Administrator

Beiträge: 10 382

Wohnort: Hildesheim

Beruf: Wissenschaftlicher Mitarbeiter

  • Private Nachricht senden

7

25.11.2002, 15:53

Hat Dir mein Code auch geholfen?
Ja, im Prinzip macht er das, was Du beschreibst. Wenn Du es aber nach dem Prinzip machst, wie Du es ganz am Anfang gemacht hast, dann haben die Rotationsangaben ja nicht die Einheit Grad oder so (sind also keine Winkel) und später wird es sehr seltsam aussehen. Komplizierter zu rechnen ist es ebenfalls.
David Scherfgens Website | Konzentrationstest Polizei

MAG

Frischling

  • »MAG« ist der Autor dieses Themas

Beiträge: 37

Wohnort: Berlin / Brandenburg

Beruf: Angehender Student

  • Private Nachricht senden

8

25.11.2002, 17:32

Ja klar.Ich konnte beides zu meinen Gunsten verwenden(deine Hinweise und den Post aus dem JLI-Board).
Komischer Weise sind jetzt aber alle Flächen doppelt so breit wie vorher!
Das wird irgendwie durch die Multiplikation der Rotations- und die Viewmatrix verursacht glaube ich.Aber das werde ich schon noch regeln.
Ich würde ja gerne die Welt verändern, aber Gott gibt mir den Quelltext nicht!

rulzmaker

Frischling

Beiträge: 11

  • Private Nachricht senden

9

24.03.2006, 12:30

Zitat

BlickpunktX = PositionX + (sin(RotationY) * cos(RotationX))


Wie kommt man auf so eine Formel :crying:

Steven77

Alter Hase

Beiträge: 515

Wohnort: Münster - Gievenbeach

Beruf: Wissenschaftlicher Mitarbeiter

  • Private Nachricht senden

10

24.03.2006, 13:00

Wenn Du die Winkelfunktionen verstanden hast, ist das eigentlich kein Problem...

Werbeanzeige

  • 1
  • 2