Verstädnissfrage zu Direct3D 11 (World View / Projection Space)



  • Hallo! Bin gerade dabei, mir DirectX 11 beizubringen (via Online-Tutorial).
    Es handelt sich bei meiner Frage nicht um einen Fehler, sondern lediglich um ein Verständnissproblem. Ich finde nämlich auf Teufel komm raus nicht die Verbindung zwischen den beiden Würfeln und der Rotationsrichtung. Was ich damit meine, könnt ihr natürlich so nicht wissen, daher hiereinmal der Code aus dem Online-Tutorial:

    main.cpp

    //Include and link appropriate libraries and headers//
    #pragma comment(lib, "d3d11.lib")
    #pragma comment(lib, "d3dx11.lib")
    #pragma comment(lib, "d3dx10.lib")
    
    #include <windows.h>
    #include <d3d11.h>
    #include <d3dx11.h>
    #include <d3dx10.h>
    #include <xnamath.h>
    
    //Global Declarations - Interfaces//
    IDXGISwapChain* SwapChain;
    ID3D11Device* d3d11Device;
    ID3D11DeviceContext* d3d11DevCon;
    ID3D11RenderTargetView* renderTargetView;
    ID3D11Buffer* squareIndexBuffer;
    ID3D11DepthStencilView* depthStencilView;
    ID3D11Texture2D* depthStencilBuffer;
    ID3D11Buffer* squareVertBuffer;
    ID3D11VertexShader* VS;
    ID3D11PixelShader* PS;
    ID3D10Blob* VS_Buffer;
    ID3D10Blob* PS_Buffer;
    ID3D11InputLayout* vertLayout;
    ID3D11Buffer* cbPerObjectBuffer;
    ///////////////**************new**************////////////////////
    ID3D11ShaderResourceView* CubesTexture;
    ID3D11SamplerState* CubesTexSamplerState;
    ///////////////**************new**************////////////////////
    
    //Global Declarations - Others//
    LPCTSTR WndClassName = L"firstwindow";
    HWND hwnd = NULL;
    HRESULT hr;
    
    const int Width  = 300;
    const int Height = 300;
    
    XMMATRIX WVP;
    XMMATRIX cube1World;
    XMMATRIX cube2World;
    XMMATRIX camView;
    XMMATRIX camProjection;
    
    XMVECTOR camPosition;
    XMVECTOR camTarget;
    XMVECTOR camUp;
    
    XMMATRIX Rotation;
    XMMATRIX Scale;
    XMMATRIX Translation;
    float rot = 0.01f;
    
    //Function Prototypes//
    bool InitializeDirect3d11App(HINSTANCE hInstance);
    void CleanUp();
    bool InitScene();
    void UpdateScene();
    void DrawScene();
    
    bool InitializeWindow(HINSTANCE hInstance,
    	int ShowWnd,
    	int width, int height,
    	bool windowed);
    int messageloop();
    
    LRESULT CALLBACK WndProc(HWND hWnd,
    	UINT msg,
    	WPARAM wParam,
    	LPARAM lParam);
    
    //Create effects constant buffer's structure//
    struct cbPerObject
    {
    	XMMATRIX  WVP;
    };
    
    cbPerObject cbPerObj;
    
    ///////////////**************new**************////////////////////
    //Vertex Structure and Vertex Layout (Input Layout)//
    struct Vertex	//Overloaded Vertex Structure
    {
    	Vertex(){}
    	Vertex(float x, float y, float z,
    		float u, float v)
    		: pos(x,y,z), texCoord(u, v){}
    
    	XMFLOAT3 pos;
    	XMFLOAT2 texCoord;
    };
    
    D3D11_INPUT_ELEMENT_DESC layout[] =
    {
    	{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },  
    	{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },  
    };
    UINT numElements = ARRAYSIZE(layout);
    ///////////////**************new**************////////////////////
    
    int WINAPI WinMain(HINSTANCE hInstance,	//Main windows function
    	HINSTANCE hPrevInstance, 
    	LPSTR lpCmdLine,
    	int nShowCmd)
    {
    
    	if(!InitializeWindow(hInstance, nShowCmd, Width, Height, true))
    	{
    		MessageBox(0, L"Window Initialization - Failed",
    			L"Error", MB_OK);
    		return 0;
    	}
    
    	if(!InitializeDirect3d11App(hInstance))	//Initialize Direct3D
    	{
    		MessageBox(0, L"Direct3D Initialization - Failed",
    			L"Error", MB_OK);
    		return 0;
    	}
    
    	if(!InitScene())	//Initialize our scene
    	{
    		MessageBox(0, L"Scene Initialization - Failed",
    			L"Error", MB_OK);
    		return 0;
    	}
    
    	messageloop();
    
    	CleanUp();    
    
    	return 0;
    }
    
    bool InitializeWindow(HINSTANCE hInstance,
    	int ShowWnd,
    	int width, int height,
    	bool windowed)
    {
    	typedef struct _WNDCLASS {
    		UINT cbSize;
    		UINT style;
    		WNDPROC lpfnWndProc;
    		int cbClsExtra;
    		int cbWndExtra;
    		HANDLE hInstance;
    		HICON hIcon;
    		HCURSOR hCursor;
    		HBRUSH hbrBackground;
    		LPCTSTR lpszMenuName;
    		LPCTSTR lpszClassName;
    	} WNDCLASS;
    
    	WNDCLASSEX wc;
    
    	wc.cbSize = sizeof(WNDCLASSEX);
    	wc.style = CS_HREDRAW | CS_VREDRAW;
    	wc.lpfnWndProc = WndProc;
    	wc.cbClsExtra = NULL;
    	wc.cbWndExtra = NULL;
    	wc.hInstance = hInstance;
    	wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    	wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    	wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 2);
    	wc.lpszMenuName = NULL;
    	wc.lpszClassName = WndClassName;
    	wc.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
    
    	if (!RegisterClassEx(&wc))
    	{
    		MessageBox(NULL, L"Error registering class",	
    			L"Error", MB_OK | MB_ICONERROR);
    		return 1;
    	}
    
    	hwnd = CreateWindowEx(
    		NULL,
    		WndClassName,
    		L"Lesson 4 - Begin Drawing",
    		WS_OVERLAPPEDWINDOW,
    		CW_USEDEFAULT, CW_USEDEFAULT,
    		width, height,
    		NULL,
    		NULL,
    		hInstance,
    		NULL
    		);
    
    	if (!hwnd)
    	{
    		MessageBox(NULL, L"Error creating window",
    			L"Error", MB_OK | MB_ICONERROR);
    		return 1;
    	}
    
    	ShowWindow(hwnd, ShowWnd);
    	UpdateWindow(hwnd);
    
    	return true;
    }
    
    bool InitializeDirect3d11App(HINSTANCE hInstance)
    {
    	//Describe our SwapChain Buffer
    	DXGI_MODE_DESC bufferDesc;
    
    	ZeroMemory(&bufferDesc, sizeof(DXGI_MODE_DESC));
    
    	bufferDesc.Width = Width;
    	bufferDesc.Height = Height;
    	bufferDesc.RefreshRate.Numerator = 60;
    	bufferDesc.RefreshRate.Denominator = 1;
    	bufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
    	bufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
    	bufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
    
    	//Describe our SwapChain
    	DXGI_SWAP_CHAIN_DESC swapChainDesc; 
    
    	ZeroMemory(&swapChainDesc, sizeof(DXGI_SWAP_CHAIN_DESC));
    
    	swapChainDesc.BufferDesc = bufferDesc;
    	swapChainDesc.SampleDesc.Count = 1;
    	swapChainDesc.SampleDesc.Quality = 0;
    	swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
    	swapChainDesc.BufferCount = 1;
    	swapChainDesc.OutputWindow = hwnd; 
    	swapChainDesc.Windowed = TRUE; 
    	swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
    
    	//Create our SwapChain
    	hr = D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, NULL, NULL, NULL,
    		D3D11_SDK_VERSION, &swapChainDesc, &SwapChain, &d3d11Device, NULL, &d3d11DevCon);
    
    	//Create our BackBuffer
    	ID3D11Texture2D* BackBuffer;
    	hr = SwapChain->GetBuffer( 0, __uuidof( ID3D11Texture2D ), (void**)&BackBuffer );
    
    	//Create our Render Target
    	hr = d3d11Device->CreateRenderTargetView( BackBuffer, NULL, &renderTargetView );
    	BackBuffer->Release();
    
    	//Describe our Depth/Stencil Buffer
    	D3D11_TEXTURE2D_DESC depthStencilDesc;
    
    	depthStencilDesc.Width     = Width;
    	depthStencilDesc.Height    = Height;
    	depthStencilDesc.MipLevels = 1;
    	depthStencilDesc.ArraySize = 1;
    	depthStencilDesc.Format    = DXGI_FORMAT_D24_UNORM_S8_UINT;
    	depthStencilDesc.SampleDesc.Count   = 1;
    	depthStencilDesc.SampleDesc.Quality = 0;
    	depthStencilDesc.Usage          = D3D11_USAGE_DEFAULT;
    	depthStencilDesc.BindFlags      = D3D11_BIND_DEPTH_STENCIL;
    	depthStencilDesc.CPUAccessFlags = 0; 
    	depthStencilDesc.MiscFlags      = 0;
    
    	//Create the Depth/Stencil View
    	d3d11Device->CreateTexture2D(&depthStencilDesc, NULL, &depthStencilBuffer);
    	d3d11Device->CreateDepthStencilView(depthStencilBuffer, NULL, &depthStencilView);
    
    	//Set our Render Target
    	d3d11DevCon->OMSetRenderTargets( 1, &renderTargetView, depthStencilView );
    
    	return true;
    }
    
    void CleanUp()
    {
    	//Release the COM Objects we created
    	SwapChain->Release();
    	d3d11Device->Release();
    	d3d11DevCon->Release();
    	renderTargetView->Release();
    	squareVertBuffer->Release();
    	squareIndexBuffer->Release();
    	VS->Release();
    	PS->Release();
    	VS_Buffer->Release();
    	PS_Buffer->Release();
    	vertLayout->Release();
    	depthStencilView->Release();
    	depthStencilBuffer->Release();
    	cbPerObjectBuffer->Release();
    }
    
    bool InitScene()
    {
    	//Compile Shaders from shader file
    	hr = D3DX11CompileFromFile(L"Effects.fx", 0, 0, "VS", "vs_4_0", 0, 0, 0, &VS_Buffer, 0, 0);
    	hr = D3DX11CompileFromFile(L"Effects.fx", 0, 0, "PS", "ps_4_0", 0, 0, 0, &PS_Buffer, 0, 0);
    
    	//Create the Shader Objects
    	hr = d3d11Device->CreateVertexShader(VS_Buffer->GetBufferPointer(), VS_Buffer->GetBufferSize(), NULL, &VS);
    	hr = d3d11Device->CreatePixelShader(PS_Buffer->GetBufferPointer(), PS_Buffer->GetBufferSize(), NULL, &PS);
    
    	//Set Vertex and Pixel Shaders
    	d3d11DevCon->VSSetShader(VS, 0, 0);
    	d3d11DevCon->PSSetShader(PS, 0, 0);
    
    	///////////////**************new**************////////////////////
    	//Create the vertex buffer
    	Vertex v[] =
    	{
    		// Front Face
    		Vertex(-1.0f, -1.0f, -1.0f, 0.0f, 1.0f),
    		Vertex(-1.0f,  1.0f, -1.0f, 0.0f, 0.0f),
    		Vertex( 1.0f,  1.0f, -1.0f, 1.0f, 0.0f),
    		Vertex( 1.0f, -1.0f, -1.0f, 1.0f, 1.0f),
    
    		// Back Face
    		Vertex(-1.0f, -1.0f, 1.0f, 1.0f, 1.0f),
    		Vertex( 1.0f, -1.0f, 1.0f, 0.0f, 1.0f),
    		Vertex( 1.0f,  1.0f, 1.0f, 0.0f, 0.0f),
    		Vertex(-1.0f,  1.0f, 1.0f, 1.0f, 0.0f),
    
    		// Top Face
    		Vertex(-1.0f, 1.0f, -1.0f, 0.0f, 1.0f),
    		Vertex(-1.0f, 1.0f,  1.0f, 0.0f, 0.0f),
    		Vertex( 1.0f, 1.0f,  1.0f, 1.0f, 0.0f),
    		Vertex( 1.0f, 1.0f, -1.0f, 1.0f, 1.0f),
    
    		// Bottom Face
    		Vertex(-1.0f, -1.0f, -1.0f, 1.0f, 1.0f),
    		Vertex( 1.0f, -1.0f, -1.0f, 0.0f, 1.0f),
    		Vertex( 1.0f, -1.0f,  1.0f, 0.0f, 0.0f),
    		Vertex(-1.0f, -1.0f,  1.0f, 1.0f, 0.0f),
    
    		// Left Face
    		Vertex(-1.0f, -1.0f,  1.0f, 0.0f, 1.0f),
    		Vertex(-1.0f,  1.0f,  1.0f, 0.0f, 0.0f),
    		Vertex(-1.0f,  1.0f, -1.0f, 1.0f, 0.0f),
    		Vertex(-1.0f, -1.0f, -1.0f, 1.0f, 1.0f),
    
    		// Right Face
    		Vertex( 1.0f, -1.0f, -1.0f, 0.0f, 1.0f),
    		Vertex( 1.0f,  1.0f, -1.0f, 0.0f, 0.0f),
    		Vertex( 1.0f,  1.0f,  1.0f, 1.0f, 0.0f),
    		Vertex( 1.0f, -1.0f,  1.0f, 1.0f, 1.0f),
    	};
    
    	DWORD indices[] = {
    		// Front Face
    		0,  1,  2,
    		0,  2,  3,
    
    		// Back Face
    		4,  5,  6,
    		4,  6,  7,
    
    		// Top Face
    		8,  9, 10,
    		8, 10, 11,
    
    		// Bottom Face
    		12, 13, 14,
    		12, 14, 15,
    
    		// Left Face
    		16, 17, 18,
    		16, 18, 19,
    
    		// Right Face
    		20, 21, 22,
    		20, 22, 23
    	};
    
    	D3D11_BUFFER_DESC indexBufferDesc;
    	ZeroMemory( &indexBufferDesc, sizeof(indexBufferDesc) );
    
    	indexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
    	indexBufferDesc.ByteWidth = sizeof(DWORD) * 12 * 3;
    	indexBufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER;
    	indexBufferDesc.CPUAccessFlags = 0;
    	indexBufferDesc.MiscFlags = 0;
    
    	D3D11_SUBRESOURCE_DATA iinitData;
    
    	iinitData.pSysMem = indices;
    	d3d11Device->CreateBuffer(&indexBufferDesc, &iinitData, &squareIndexBuffer);
    
    	d3d11DevCon->IASetIndexBuffer( squareIndexBuffer, DXGI_FORMAT_R32_UINT, 0);
    
    	D3D11_BUFFER_DESC vertexBufferDesc;
    	ZeroMemory( &vertexBufferDesc, sizeof(vertexBufferDesc) );
    
    	vertexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
    	vertexBufferDesc.ByteWidth = sizeof( Vertex ) * 24;
    	vertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
    	vertexBufferDesc.CPUAccessFlags = 0;
    	vertexBufferDesc.MiscFlags = 0;
    	///////////////**************new**************////////////////////
    
    	D3D11_SUBRESOURCE_DATA vertexBufferData; 
    
    	ZeroMemory( &vertexBufferData, sizeof(vertexBufferData) );
    	vertexBufferData.pSysMem = v;
    	hr = d3d11Device->CreateBuffer( &vertexBufferDesc, &vertexBufferData, &squareVertBuffer);
    
    	//Set the vertex buffer
    	UINT stride = sizeof( Vertex );
    	UINT offset = 0;
    	d3d11DevCon->IASetVertexBuffers( 0, 1, &squareVertBuffer, &stride, &offset );
    
    	//Create the Input Layout
    	hr = d3d11Device->CreateInputLayout( layout, numElements, VS_Buffer->GetBufferPointer(), 
    		VS_Buffer->GetBufferSize(), &vertLayout );
    
    	//Set the Input Layout
    	d3d11DevCon->IASetInputLayout( vertLayout );
    
    	//Set Primitive Topology
    	d3d11DevCon->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST );
    
    	//Create the Viewport
    	D3D11_VIEWPORT viewport;
    	ZeroMemory(&viewport, sizeof(D3D11_VIEWPORT));
    
    	viewport.TopLeftX = 0;
    	viewport.TopLeftY = 0;
    	viewport.Width = Width;
    	viewport.Height = Height;
    	viewport.MinDepth = 0.0f;
    	viewport.MaxDepth = 1.0f;
    
    	//Set the Viewport
    	d3d11DevCon->RSSetViewports(1, &viewport);
    
    	//Create the buffer to send to the cbuffer in effect file
    	D3D11_BUFFER_DESC cbbd;	
    	ZeroMemory(&cbbd, sizeof(D3D11_BUFFER_DESC));
    
    	cbbd.Usage = D3D11_USAGE_DEFAULT;
    	cbbd.ByteWidth = sizeof(cbPerObject);
    	cbbd.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
    	cbbd.CPUAccessFlags = 0;
    	cbbd.MiscFlags = 0;
    
    	hr = d3d11Device->CreateBuffer(&cbbd, NULL, &cbPerObjectBuffer);
    
    	//Camera information
    	camPosition = XMVectorSet( 0.0f, 3.0f, -8.0f, 0.0f );
    	camTarget = XMVectorSet( 0.0f, 0.0f, 0.0f, 0.0f );
    	camUp = XMVectorSet( 0.0f, 1.0f, 0.0f, 0.0f );
    
    	//Set the View matrix
    	camView = XMMatrixLookAtLH( camPosition, camTarget, camUp );
    
    	//Set the Projection matrix
    	camProjection = XMMatrixPerspectiveFovLH( 0.4f*3.14f, (float)Width/Height, 1.0f, 1000.0f);
    
    	///////////////**************new**************////////////////////
    	hr = D3DX11CreateShaderResourceViewFromFile( d3d11Device, L"braynzar.jpg",
    		NULL, NULL, &CubesTexture, NULL );
    
    	// Describe the Sample State
    	D3D11_SAMPLER_DESC sampDesc;
    	ZeroMemory( &sampDesc, sizeof(sampDesc) );
    	sampDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
    	sampDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
    	sampDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
        sampDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
        sampDesc.ComparisonFunc = D3D11_COMPARISON_NEVER;
        sampDesc.MinLOD = 0;
        sampDesc.MaxLOD = D3D11_FLOAT32_MAX;
    
    	//Create the Sample State
    	hr = d3d11Device->CreateSamplerState( &sampDesc, &CubesTexSamplerState );
    	///////////////**************new**************////////////////////
    
    	return true;
    }
    
    void UpdateScene()
    {
    	//Keep the cubes rotating
    	rot += .0005f;
    	if(rot > 6.26f)
    		rot = 0.0f;
    
    	//Reset cube1World
    	cube1World = XMMatrixIdentity();
    
    	//Define cube1's world space matrix
    	XMVECTOR rotaxis = XMVectorSet(2.0f, 2.0f, 8.0f, 4.0f);
    	Rotation = XMMatrixRotationAxis( rotaxis, rot);
    	Translation = XMMatrixTranslation( 0.0f, 0.0f, 14.0f );
    
    	//Set cube1's world space using the transformations
    	cube1World = Translation * Rotation;
    
    	//Reset cube2World
    	cube2World = XMMatrixIdentity();
    
    	//Define cube2's world space matrix
    	Rotation = XMMatrixRotationAxis( rotaxis, -rot);
    	Scale = XMMatrixScaling( 1.3f, 1.3f, 1.3f );
    
    	//Set cube2's world space matrix
    	cube2World = Rotation * Scale;
    }
    
    void DrawScene()
    {
    	//Clear our backbuffer
    	float bgColor[4] = {(0.0f, 0.0f, 0.0f, 0.0f)};
    	d3d11DevCon->ClearRenderTargetView(renderTargetView, bgColor);
    
    	//Refresh the Depth/Stencil view
    	d3d11DevCon->ClearDepthStencilView(depthStencilView, D3D11_CLEAR_DEPTH|D3D11_CLEAR_STENCIL, 1.0f, 0);
    
    	//Set the WVP matrix and send it to the constant buffer in effect file
    	WVP = cube1World * camView * camProjection;
    	cbPerObj.WVP = XMMatrixTranspose(WVP);	
    	d3d11DevCon->UpdateSubresource( cbPerObjectBuffer, 0, NULL, &cbPerObj, 0, 0 );
    	d3d11DevCon->VSSetConstantBuffers( 0, 1, &cbPerObjectBuffer );
    	///////////////**************new**************////////////////////
    	d3d11DevCon->PSSetShaderResources( 0, 1, &CubesTexture );
    	d3d11DevCon->PSSetSamplers( 0, 1, &CubesTexSamplerState );
    	///////////////**************new**************////////////////////
    
    	//Draw the first cube
    	d3d11DevCon->DrawIndexed( 36, 0, 0 );
    
    	WVP = cube2World * camView * camProjection;
    	cbPerObj.WVP = XMMatrixTranspose(WVP);	
    	d3d11DevCon->UpdateSubresource( cbPerObjectBuffer, 0, NULL, &cbPerObj, 0, 0 );
    	d3d11DevCon->VSSetConstantBuffers( 0, 1, &cbPerObjectBuffer );
    	///////////////**************new**************////////////////////
    	d3d11DevCon->PSSetShaderResources( 0, 1, &CubesTexture );
    	d3d11DevCon->PSSetSamplers( 0, 1, &CubesTexSamplerState );
    	///////////////**************new**************////////////////////
    
    	//Draw the second cube
    	d3d11DevCon->DrawIndexed( 36, 0, 0 );
    
    	//Present the backbuffer to the screen
    	SwapChain->Present(0, 0);
    }
    
    int messageloop(){
    	MSG msg;
    	ZeroMemory(&msg, sizeof(MSG));
    	while(true)
    	{
    		BOOL PeekMessageL( 
    			LPMSG lpMsg,
    			HWND hWnd,
    			UINT wMsgFilterMin,
    			UINT wMsgFilterMax,
    			UINT wRemoveMsg
    			);
    
    		if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
    		{
    			if (msg.message == WM_QUIT)
    				break;
    			TranslateMessage(&msg);	
    			DispatchMessage(&msg);
    		}
    		else{
    			// run game code            
    			UpdateScene();
    			DrawScene();
    		}
    	}
    	return msg.wParam;
    }
    
    LRESULT CALLBACK WndProc(HWND hwnd,
    	UINT msg,
    	WPARAM wParam,
    	LPARAM lParam)
    {
    	switch( msg )
    	{
    	case WM_KEYDOWN:
    		if( wParam == VK_ESCAPE ){
    			DestroyWindow(hwnd);
    		}
    		return 0;
    
    	case WM_DESTROY:
    		PostQuitMessage(0);
    		return 0;
    	}
    	return DefWindowProc(hwnd,
    		msg,
    		wParam,
    		lParam);
    }
    

    Effects.fx

    cbuffer cbPerObject
    {
    	float4x4 WVP;
    };
    
    Texture2D ObjTexture;
    SamplerState ObjSamplerState;
    
    struct VS_OUTPUT
    {
    	float4 Pos : SV_POSITION;
    	float2 TexCoord : TEXCOORD;
    };
    
    VS_OUTPUT VS(float4 inPos : POSITION, float2 inTexCoord : TEXCOORD)
    {
        VS_OUTPUT output;
    
        output.Pos = mul(inPos, WVP);
        output.TexCoord = inTexCoord;
    
        return output;
    }
    
    float4 PS(VS_OUTPUT input) : SV_TARGET
    {
        return ObjTexture.Sample( ObjSamplerState, input.TexCoord );
    }
    

    Bei dem Code klappt Alles wunderbar, doch frage ich mich nun, WO wird 'gesagt', dass die sechs Vierecke bzw die zwölf Dreieicke den Cube1 bilden und die Anderen Cube2. Und wo werden diese angesprochen? In der Zeile 499 wird die Roatationsrichtung

    rot
    

    ja negativ übergeben. Also muss in der Updatefunktion ja die Zuweisung stattfinden. Nur ich sehe sie nicht.
    Wie gesagt, ich suche keinen Fehler, sondern nur Verständniss. Also, wenn ihr so nett seit und antworten wollt, wäre es nett, wenn ihr mir nicht nur die Codezeile nennt, sondern vielleicht auch etwas über die Funktionsweise eben dieser loswerden könntet, damit ich es nicht nur weiß, sondern auch verstehe!

    Liebe Grüße und vielen Dank!



  • Ergänzung:

    Vielleicht ist meine Frage ein wenig schwammig: Die Programmausgabe leifert zwei Würfel. Der eine dreht sich um seinen Mittelpunkt, der andere dreht sich um den Ersten. Jetzt sehe ich aber nicht, woher das Programm 'weiß', dass es die Polygone X bis Y so drehen muss und die Polygone A bis B anders.



  • Wo ich mir grad das ganze Geömmel noch mal genauer ansehe, scheint es mir, dass ich da eher etwas grundlegend falsch verstanden habe. Mit den Vertices wird ja erst nur ein 'Würfel' erstellt. Der zweite wird dann ja erst... Ich glaube es hat sich erledigt...

    Das kommt davon, wenn man Code überspringt, weil man glaubt, man hat ihn verstanden....


Anmelden zum Antworten