Problem DX & C++

Hi habe ein problem!

Habe versucht mit DX11 und C++ ein Viereck zu Zeichnen, habe dazu n framework gemacht! _Nun wenn ich kompiliere krieg ich keinen error und keine warnung. nur schwarzes bild selbst im windowed sehe ich nur schwarz. in der theorie sollte halt ein tolles rotes viereck zu sehen sein. pls help!

weiss nicht obs ok ist jetzt so viele zeilen code zu posten

LePwnerer schrieb:

Hi habe ein problem!

Habe versucht mit DX11 und C++ ein Viereck zu Zeichnen, habe dazu n framework gemacht! _Nun wenn ich kompiliere krieg ich keinen error und keine warnung. nur schwarzes bild selbst im windowed sehe ich nur schwarz. in der theorie sollte halt ein tolles rotes viereck zu sehen sein. pls help!

weiss nicht obs ok ist jetzt so viele zeilen code zu posten

ALTER!!!! Natürlich ist das Ok. Ich kann dir vielleicht auch Helfen (hab selber vor kurzem angefangen). Zeig mal her (das wird den Server schon nicht überlasten).

ok hier die source:

PS: Ich habe Gewarnt ^^

HEADERS:

d3dklasse.h

#ifndef _D3DKLASSE_H_
#define _D3DKLASSE_H_

#pragma comment(lib, "dxgi.lib")
#pragma comment(lib, "d3d11.lib")
#pragma comment(lib, "d3dx11.lib")
#pragma comment(lib, "d3dx10.lib")

#include <dxgi.h>
#include <d3dcommon.h>
#include <d3d11.h>
#include <d3dx10math.h>

class D3DKlasse
{
public:
	D3DKlasse();
	D3DKlasse(const D3DKlasse&);
	~D3DKlasse();

	bool Hochfahren(int, int, bool, HWND, bool, float, float);
	void Schließen();

	void StarteSzene(float, float, float, float);
	void BeendeSzene();

	ID3D11Device* GetDevice();
	ID3D11DeviceContext* GetDeviceContext();

	void GetProjectionMatrix(D3DXMATRIX&);
	void GetWorldMatrix(D3DXMATRIX&);
	void GetOrthoMatrix(D3DXMATRIX&);

	void GetVideoCardInfo(char*, int&);

private:
	bool m_vsync_enabled;
	int m_videoCardMemory;
	char m_videoCardDescription[128];
	IDXGISwapChain* m_swapChain;
	ID3D11Device* m_device;
	ID3D11DeviceContext* m_deviceContext;
	ID3D11RenderTargetView* m_renderTargetView;
	ID3D11Texture2D* m_depthStencilBuffer;
	ID3D11DepthStencilState* m_depthStencilState;
	ID3D11DepthStencilView* m_depthStencilView;
	ID3D11RasterizerState* m_rasterState;
	D3DXMATRIX m_projectionMatrix;
	D3DXMATRIX m_worldMatrix;
	D3DXMATRIX m_orthoMatrix;
};

#endif

###############################################################################

eingabeklasse.h

#ifndef _EINGABEKLASSE_H_
#define _EINGABEKLASSE_H_

class EingabeKlasse
{
public:
	EingabeKlasse();
	EingabeKlasse(const EingabeKlasse&);
	~EingabeKlasse();

	void Hochfahren();
	void KeyDown(unsigned int);
	void KeyUp(unsigned int);

	bool isKeyDown(unsigned int);

private:
	bool m_Keys[256];
};

#endif

###############################################################################

farbshaderklasse.h

#ifndef _FARBSHADERKLASSE_H_
#define _FARBSHADERKLASSE_H_

#include <d3d11.h>
#include <D3DX10math.h>
#include <D3DX11async.h>
#include <fstream>

using namespace std;

class FarbshaderKlasse
{
private:
	struct MatrixBufferType
	{
		D3DXMATRIX world;
		D3DXMATRIX view;
		D3DXMATRIX projection;
	};

public:

	FarbshaderKlasse();
	FarbshaderKlasse(const FarbshaderKlasse&);
	~FarbshaderKlasse();

	bool Hochfahren(ID3D11Device*, HWND);
	void Schließen();
	bool Rendern(ID3D11DeviceContext*, int, D3DXMATRIX, D3DXMATRIX, D3DXMATRIX);

private:

	bool ShaderHochfahren(ID3D11Device*, HWND, WCHAR*, WCHAR*);
	void ShaderSchließen();
	void ShaderFehlerNachrichtAusgeben(ID3D10Blob*, HWND, WCHAR*);

	bool ShaderParameterSetzen(ID3D11DeviceContext*, D3DXMATRIX, D3DXMATRIX, D3DXMATRIX);
	void ShaderRendern(ID3D11DeviceContext*, int);

private:
	ID3D11VertexShader* m_vertexShader;
	ID3D11PixelShader* m_pixelShader;
	ID3D11InputLayout* m_layout;
	ID3D11Buffer* m_matrixBuffer;
};

#endif

################################################################################

grafikklasse.h

#ifndef _GRAFIKKLASSE_H_
#define _GRAFIKKLASSE_H_

#include "d3dklasse.h"
#include "kameraklasse.h"
#include "modellklasse.h"
#include "farbshaderklasse.h"

const bool FULL_SCREEN =  false;
const bool VSYNC_ENABLED = true;
const float SCREEN_DEPTH = 1000.0f;
const float SCREEN_NEAR = 0.1f;

class GrafikKlasse
{
public:
	GrafikKlasse();
	GrafikKlasse(const GrafikKlasse&);
	~GrafikKlasse();

	bool Hochfahren(int, int, HWND);
	void Schließen();
	bool Bild();

private:

	bool Rendern();

private:

	D3DKlasse* m_D3D;
	KameraKlasse* m_Camera;
	ModellKlasse* m_Model;
	FarbshaderKlasse* m_ColorShader;
};

#endif

################################################################################

kameraklasse.h

#ifndef _KAMERAKLASSE_H_
#define _KAMERAKLASSE_H_

#include <D3DX10math.h>

class KameraKlasse
{
public:
	KameraKlasse();
	KameraKlasse(const KameraKlasse&);
	~KameraKlasse();

	void SetPosition(float, float, float);
	void SetRoation(float, float, float);;

	D3DXVECTOR3 GetPosition();
	D3DXVECTOR3 GetRotation();

	void Rendern();
	void GetViewMatrix(D3DXMATRIX&);

private:
	float m_positionX, m_positionY, m_positionZ;
	float m_rotationX, m_rotationY, m_rotationZ;
	D3DXMATRIX m_viewMatrix;
};

#endif

################################################################################

modellklasse.h

#ifndef _MODELLKLASSE_H_
#define _MODELLKLASSE_H_

#include <d3d11.h>
#include <d3dx10math.h>

class ModellKlasse
{
private:
	struct VertexType
	{
		D3DXVECTOR3 position;
		D3DXVECTOR4 color;
	};

public:
	ModellKlasse();
	ModellKlasse(const ModellKlasse&);
	~ModellKlasse();

	bool Hochfahren(ID3D11Device*);
	void Schließen();
	void Rendern(ID3D11DeviceContext*);

	int GetIndexCount();

private:
	bool BufferHochfahren(ID3D11Device*);
	void BufferSchließen();
	void BufferRendern(ID3D11DeviceContext*);

private:
	ID3D11Buffer *m_vertexBuffer, *m_indexBuffer;
	int m_vertexCount, m_indexCount;
};

#endif

################################################################################

#ifndef _SYSTEMKLASSE_H_
#define _SYSTEMKLASSE_H_
#define WIN32_LEAN_AND_MEAN

#include <Windows.h>
#include "grafikklasse.h"
#include "eingabeklasse.h"

class SystemKlasse
{
public:
	SystemKlasse();
	SystemKlasse(const SystemKlasse&);
	~SystemKlasse();

	bool Hochfahren();
	void Schließen();
	void Ausführen();

	LRESULT CALLBACK NachrichtenVerwalter(HWND, UINT, WPARAM, LPARAM);

private:
	bool Bild();
	void StarteFenster(int&, int&);
	void SchließeFenster();

private:
	LPCWSTR m_applicationName;
	HINSTANCE m_hauptfenster;
	HWND m_hwnd;
	EingabeKlasse* m_Eingabe;
	GrafikKlasse* m_Grafik;

};

static LRESULT CALLBACK WndProc(HWND,UINT,WPARAM,LPARAM);

static SystemKlasse* ApplicationHandle = 0;

#endif

################################################################################

SOURCEFILES

--------------------------------------------------------------------------------

d3dklasse.cpp

#include "d3dklasse.h"

D3DKlasse::D3DKlasse()
{
	m_swapChain = 0;
	m_device = 0;
	m_deviceContext = 0;
	m_renderTargetView = 0;
	m_depthStencilBuffer = 0;
	m_depthStencilState = 0;
	m_depthStencilView = 0;
	m_rasterState = 0;
}

D3DKlasse::D3DKlasse(const D3DKlasse& other)
{
}

D3DKlasse::~D3DKlasse()
{
}

bool D3DKlasse::Hochfahren(int Breite, int Höhe, bool vsync, HWND hwnd, bool fullscreen, float screenDepth, float screenNear)
{
	HRESULT ergebnis;
	IDXGIFactory* factory;
	IDXGIAdapter* adapter;
	IDXGIOutput* adapterOutput;
	unsigned int numModes, i, numerator, denominator, stringLength;
	DXGI_MODE_DESC* displayModeList;
	DXGI_ADAPTER_DESC adapterDesc;
	int fehler;
	DXGI_SWAP_CHAIN_DESC swapChainDesc;
	D3D_FEATURE_LEVEL featureLevel;
	ID3D11Texture2D* backBufferPtr;
	D3D11_TEXTURE2D_DESC depthBufferDesc;
	D3D11_DEPTH_STENCIL_DESC depthStencilDesc;
	D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc;
	D3D11_RASTERIZER_DESC rasterDesc;
	D3D11_VIEWPORT viewport;
	float fieldOfView, screenAspect;

	m_vsync_enabled = vsync;

	ergebnis = CreateDXGIFactory(__uuidof(IDXGIFactory),(void**)&factory);
	if(FAILED(ergebnis))
	{
		return false;
	}

	ergebnis = factory->EnumAdapters(0, &adapter);
	if(FAILED(ergebnis))
	{
		return false;
	}

	ergebnis = adapter->EnumOutputs(0, &adapterOutput);
	if(FAILED(ergebnis))
	{
		return false;
	}

	ergebnis = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, NULL);
	if(FAILED(ergebnis))
	{
		return false;
	}

	displayModeList = new DXGI_MODE_DESC[numModes];
	if(!displayModeList)
	{
		return false;
	}

	ergebnis = adapterOutput->GetDisplayModeList (DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, displayModeList);
	if(FAILED(ergebnis))
	{
		return false;
	}

	for(i = 0; i<numModes; i++)
	{
		if(displayModeList[i].Width == (unsigned int)Breite)
		{
			if(displayModeList[i].Height == (unsigned int)Höhe)
			{
				numerator = displayModeList[i].RefreshRate.Numerator;
				denominator = displayModeList[i].RefreshRate.Denominator;
			}
		}
	}

	ergebnis = adapter->GetDesc(&adapterDesc);
	if(FAILED(ergebnis))
	{
		return false;
	}

	m_videoCardMemory = (int)(adapterDesc.DedicatedVideoMemory / 1024 / 1024);

	fehler = wcstombs_s(&stringLength, m_videoCardDescription, 128, adapterDesc.Description, 128);
	if(fehler != 0)
	{
		return false;
	}

	delete [] displayModeList;
	displayModeList = 0;

	adapterOutput->Release();
	adapterOutput = 0;

	adapter->Release();
	adapter = 0;

	factory->Release();
	factory = 0;

	ZeroMemory(&swapChainDesc, sizeof(swapChainDesc));

	swapChainDesc.BufferCount = 1;
	swapChainDesc.BufferDesc.Width = Breite;
	swapChainDesc.BufferDesc.Height = Höhe;
	swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;

	if(m_vsync_enabled)
	{
		swapChainDesc.BufferDesc.RefreshRate.Numerator = numerator;
		swapChainDesc.BufferDesc.RefreshRate.Denominator = denominator;
	}
	else
	{
		swapChainDesc.BufferDesc.RefreshRate.Numerator = 0;
		swapChainDesc.BufferDesc.RefreshRate.Denominator = 1;
	}

	swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
	swapChainDesc.OutputWindow = hwnd;
	swapChainDesc.SampleDesc.Count = 1;
	swapChainDesc.SampleDesc.Quality = 0;

	if(fullscreen)
	{
		swapChainDesc.Windowed = false;
	}
	else
	{
		swapChainDesc.Windowed = true;
	}

	swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
	swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
	swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
	swapChainDesc.Flags = 0;
	featureLevel = D3D_FEATURE_LEVEL_11_0;

	ergebnis = D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, 0, &featureLevel, 1,D3D11_SDK_VERSION, &swapChainDesc, &m_swapChain, &m_device, NULL, &m_deviceContext);
	if(FAILED(ergebnis))
	{
		return false;
	}

	ergebnis = m_swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&backBufferPtr);
	if(FAILED(ergebnis))
	{
		return false;
	}

	ergebnis = m_device->CreateRenderTargetView(backBufferPtr, NULL, &m_renderTargetView);
	if(FAILED(ergebnis))
	{
		return false;
	}

	backBufferPtr->Release();
	backBufferPtr = 0;

	ZeroMemory(&depthBufferDesc, sizeof(depthBufferDesc));

	depthBufferDesc.Width = Breite;
	depthBufferDesc.Height = Höhe;
	depthBufferDesc.MipLevels = 1;
	depthBufferDesc.ArraySize = 1;
	depthBufferDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
	depthBufferDesc.SampleDesc.Count = 1;
	depthBufferDesc.SampleDesc.Quality = 0;
	depthBufferDesc.Usage = D3D11_USAGE_DEFAULT;
	depthBufferDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
	depthBufferDesc.CPUAccessFlags = 0;
	depthBufferDesc.MiscFlags = 0;

	ergebnis = m_device->CreateTexture2D(&depthBufferDesc, NULL, &m_depthStencilBuffer);
	if(FAILED(ergebnis))
	{
		return false;
	}

	ZeroMemory(&depthStencilDesc, sizeof(depthStencilDesc));

	depthStencilDesc.DepthEnable = true;
	depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
	depthStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
	depthStencilDesc.StencilEnable = true;
	depthStencilDesc.StencilReadMask = 0xFF;
	depthStencilDesc.StencilWriteMask = 0xFF;
	depthStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
	depthStencilDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR;
	depthStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
	depthStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
	depthStencilDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
	depthStencilDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
	depthStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
	depthStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;

	ergebnis = m_device->CreateDepthStencilState (&depthStencilDesc, &m_depthStencilState);
	if(FAILED(ergebnis))
	{
		return false;
	}

	m_deviceContext->OMSetDepthStencilState(m_depthStencilState, 1);

	ZeroMemory(&depthStencilViewDesc, sizeof(depthStencilViewDesc));

	depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
	depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
	depthStencilViewDesc.Texture2D.MipSlice = 0;

	ergebnis = m_device->CreateDepthStencilView(m_depthStencilBuffer, &depthStencilViewDesc, &m_depthStencilView);
	if(FAILED(ergebnis))
	{
		return false;
	}

	m_deviceContext->OMSetRenderTargets(1, &m_renderTargetView, m_depthStencilView);

	rasterDesc.AntialiasedLineEnable = false;
	rasterDesc.CullMode = D3D11_CULL_BACK;
	rasterDesc.DepthBias = 0;
	rasterDesc.DepthBiasClamp = 0.0f;
	rasterDesc.DepthClipEnable = true;
	rasterDesc.FillMode = D3D11_FILL_SOLID;
	rasterDesc.FrontCounterClockwise = false;
	rasterDesc.MultisampleEnable = false;
	rasterDesc.ScissorEnable = false;
	rasterDesc.SlopeScaledDepthBias = 0.0f;

	ergebnis = m_device->CreateRasterizerState(&rasterDesc, &m_rasterState);
	if(FAILED(ergebnis))
	{
		return false;
	}

	m_deviceContext->RSSetState(m_rasterState);

	viewport.Width = (float)Breite;
	viewport.Height = (float)Höhe;
	viewport.MaxDepth = 1.0f;
	viewport.TopLeftX = 0.0f;
	viewport.TopLeftY = 0.0f;

	m_deviceContext->RSSetViewports(1, &viewport);
	fieldOfView = (float)D3DX_PI / 4.0f;
	screenAspect = (float)Breite / (float)Höhe;

	D3DXMatrixPerspectiveFovLH(&m_projectionMatrix, fieldOfView, screenAspect, screenNear, screenDepth);
	D3DXMatrixIdentity(&m_worldMatrix);
	D3DXMatrixOrthoLH(&m_orthoMatrix, (float)Breite, (float)Höhe, screenNear, screenDepth);

	return true;
}

void D3DKlasse::Schließen()
{
	if(m_swapChain)
	{
		m_swapChain->SetFullscreenState(false,NULL);
	}

	if(m_rasterState)
	{
		m_rasterState->Release();
		m_rasterState = 0;
	}

	if(m_depthStencilView)
	{
		m_depthStencilView->Release();
		m_depthStencilView = 0;
	}

	if(m_depthStencilState)
	{
		m_depthStencilState->Release();
		m_depthStencilState = 0;
	}

	if(m_depthStencilBuffer)
	{
		m_depthStencilBuffer->Release();
		m_depthStencilBuffer = 0;
	}

	if(m_renderTargetView)
	{
		m_renderTargetView->Release();
		m_renderTargetView = 0;
	}

	if(m_deviceContext)
	{
		m_deviceContext->Release();
		m_deviceContext = 0;
	}

	if(m_device)
	{
		m_device->Release();
		m_device = 0;
	}

	if(m_swapChain)
	{
		m_swapChain->Release();
		m_swapChain = 0;
	}

	return;
}

void D3DKlasse::StarteSzene(float red, float green, float blue, float alpha)
{
	float color[4];

	color[0] = red;
	color[1] = green;
	color[2] = blue;
	color[3] = alpha;

	m_deviceContext->ClearRenderTargetView(m_renderTargetView, color);
	m_deviceContext->ClearDepthStencilView(m_depthStencilView, D3D11_CLEAR_DEPTH, 1.0f, 0);

	return;
}

void D3DKlasse::BeendeSzene()
{
	if(m_vsync_enabled)
	{
		m_swapChain->Present(1, 0);
	}
	else
	{
		m_swapChain->Present(0, 0);
	}

	return;
}

ID3D11Device* D3DKlasse::GetDevice()
{
	return m_device;
}

ID3D11DeviceContext* D3DKlasse::GetDeviceContext()
{
	return m_deviceContext;
}

void D3DKlasse::GetProjectionMatrix(D3DXMATRIX& projectionMatrix)
{
	projectionMatrix = m_projectionMatrix;
	return;
}

void D3DKlasse::GetWorldMatrix(D3DXMATRIX& worldMatrix)
{
	worldMatrix = m_worldMatrix;
	return;
}

void D3DKlasse::GetOrthoMatrix(D3DXMATRIX& orthoMatrix)
{
	orthoMatrix = m_orthoMatrix;
	return;
}

void D3DKlasse::GetVideoCardInfo(char* cardName, int& memory)
{
	strcpy_s(cardName, 128, m_videoCardDescription);
	memory = m_videoCardMemory;
	return;
}

################################################################################

eingabeklasse.cpp

#include "eingabeklasse.h"

EingabeKlasse::EingabeKlasse()
{
}

EingabeKlasse::EingabeKlasse(const EingabeKlasse& other)
{
}

EingabeKlasse::~EingabeKlasse()
{
}

void EingabeKlasse::Hochfahren()
{
	int i;

	for(i=0; i<256; i++)
	{
		m_Keys[i] = false;
	}

	return;
}

void EingabeKlasse::KeyDown(unsigned int eingabe)
{
	m_Keys[eingabe] = true;
	return;
}

void EingabeKlasse::KeyUp(unsigned int eingabe)
{
	m_Keys[eingabe] = false;
	return;
}

bool EingabeKlasse::isKeyDown(unsigned int key)
{
	return m_Keys[key];
}

################################################################################

farbshaderklasse.cpp

#include "farbshaderklasse.h"

FarbshaderKlasse::FarbshaderKlasse()
{
	m_vertexShader = 0;
	m_pixelShader = 0;
	m_layout = 0;
	m_matrixBuffer = 0;
}

FarbshaderKlasse::FarbshaderKlasse(const FarbshaderKlasse& other)
{
}

FarbshaderKlasse::~FarbshaderKlasse()
{
}

bool FarbshaderKlasse::Hochfahren(ID3D11Device* device, HWND hwnd)
{
	bool ergebnis;

	ergebnis =  ShaderHochfahren(device, hwnd, L"../OverClockedEngine/Color.vs", L"../OverClockedEngine/Color.ps");
	if(!ergebnis)
	{
		return false;
	}

	return true;
}

void FarbshaderKlasse::Schließen()
{
	ShaderSchließen();

	return;
}

bool FarbshaderKlasse::Rendern(ID3D11DeviceContext* deviceContext, int indexCount, D3DXMATRIX worldMatrix, D3DXMATRIX viewMatrix, D3DXMATRIX projectionMatrix)
{
	bool ergebnis;

	ergebnis = ShaderParameterSetzen(deviceContext, worldMatrix, viewMatrix, projectionMatrix);
	if(!ergebnis)
	{
		return false;
	}

	ShaderRendern(deviceContext, indexCount);

	return true;
}

bool FarbshaderKlasse::ShaderHochfahren(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename)
{
	HRESULT ergebnis;
	ID3D10Blob* fehlerNachricht;
	ID3D10Blob* vertexShaderBuffer;
	ID3D10Blob* pixelShaderBuffer;
	D3D11_INPUT_ELEMENT_DESC polygonLayout[2];
	unsigned int numElements;
	D3D11_BUFFER_DESC matrixBufferDesc;

	fehlerNachricht = 0;
	vertexShaderBuffer = 0;
	pixelShaderBuffer = 0;

	ergebnis = D3DX11CompileFromFile(vsFilename, NULL,NULL, "ColorVertexShader", "vs_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL, &vertexShaderBuffer, &fehlerNachricht, NULL);
	if(FAILED(ergebnis))
	{
		if(fehlerNachricht)
		{
			ShaderFehlerNachrichtAusgeben(fehlerNachricht, hwnd, vsFilename);
		}
		else
		{
			MessageBox(hwnd, vsFilename, L"Datei fehlt: VertexShader", MB_OK);
		}

		return false;
	}

	ergebnis = D3DX11CompileFromFile(psFilename, NULL, NULL, "ColorPixelShader", "ps_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL, &pixelShaderBuffer, &fehlerNachricht, NULL);
	if(FAILED(ergebnis))
	{
		if(fehlerNachricht)
		{
			ShaderFehlerNachrichtAusgeben(fehlerNachricht, hwnd, psFilename);
		}
		else
		{
			MessageBox(hwnd, psFilename, L"Datei fehlt: PixelShader", MB_OK);
		}

		return false;
	}

	ergebnis = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &m_vertexShader);
	if(FAILED(ergebnis))
	{
		return false;
	}

	ergebnis = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &m_pixelShader);
	if(FAILED(ergebnis))
	{
		return false;
	}

	polygonLayout[0].SemanticName = "POSITION";
	polygonLayout[0].SemanticIndex = 0;
	polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT;
	polygonLayout[0].InputSlot = 0;
	polygonLayout[0].AlignedByteOffset = 0;
	polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
	polygonLayout[0].InstanceDataStepRate = 0;

	polygonLayout[1].SemanticName = "COLOR";
	polygonLayout[1].SemanticIndex = 0;
	polygonLayout[1].Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
	polygonLayout[1].InputSlot = 0;
	polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
	polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
	polygonLayout[1].InstanceDataStepRate = 0;

	numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);

	ergebnis = device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), &m_layout);
	if(FAILED(ergebnis))
	{
		return false;
	}

	vertexShaderBuffer->Release();
	vertexShaderBuffer = 0;

	pixelShaderBuffer->Release();
	pixelShaderBuffer = 0;

	matrixBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
	matrixBufferDesc.ByteWidth = sizeof(MatrixBufferType);
	matrixBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
	matrixBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
	matrixBufferDesc.MiscFlags = 0;
	matrixBufferDesc.StructureByteStride = 0;

	ergebnis = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer);
	if(FAILED(ergebnis))
	{
		return false;
	}

	return true;
}

void FarbshaderKlasse::ShaderSchließen()
{
	if(m_matrixBuffer)
	{
		m_matrixBuffer->Release();
		m_matrixBuffer = 0;
	}

	if(m_layout)
	{
		m_layout->Release();
		m_layout = 0;
	}

	if(m_vertexShader)
	{
		m_vertexShader->Release();
		m_vertexShader = 0;
	}

	if(m_pixelShader)
	{
		m_pixelShader->Release();
		m_pixelShader = 0;
	}

	return;
}

void FarbshaderKlasse::ShaderFehlerNachrichtAusgeben(ID3D10Blob* fehlerNachricht, HWND hwnd, WCHAR* shaderFilename)
{
	char* compileErrors;
	unsigned long bufferSize, i;
	ofstream fout;

	compileErrors = (char*)(fehlerNachricht->GetBufferPointer());
	bufferSize = fehlerNachricht->GetBufferSize();

	fout.open("shader-error.txt");

	for(i=0; i<bufferSize; i++)
	{
		fout << compileErrors[i];
	}

	fout.close();

	fehlerNachricht->Release();
	fehlerNachricht = 0;

	MessageBox(hwnd, L"Fehler beim Kompilieren der Shader! shader-error.txt wurde erstellt.", shaderFilename, MB_OK);

	return;
}

bool FarbshaderKlasse::ShaderParameterSetzen(ID3D11DeviceContext* deviceContext, D3DXMATRIX worldMatrix, D3DXMATRIX viewMatrix, D3DXMATRIX projectionMatrix)
{
	HRESULT ergebnis;
	D3D11_MAPPED_SUBRESOURCE mappedResource;
	MatrixBufferType* dataPtr;
	unsigned int bufferNumber;

	D3DXMatrixTranspose(&worldMatrix, &worldMatrix);
	D3DXMatrixTranspose(&viewMatrix, &viewMatrix);
	D3DXMatrixTranspose(&projectionMatrix, &projectionMatrix);

	ergebnis = deviceContext->Map(m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
	if(FAILED(ergebnis))
	{
		return false;
	}

	dataPtr = (MatrixBufferType*)mappedResource.pData;

	dataPtr->world = worldMatrix;
	dataPtr->view = viewMatrix;
	dataPtr->projection = projectionMatrix;

	deviceContext->Unmap(m_matrixBuffer, 0);

	bufferNumber = 0;

	deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_matrixBuffer);

	return true;
}

void FarbshaderKlasse::ShaderRendern(ID3D11DeviceContext* deviceContext, int indexCount)
{
	deviceContext->IASetInputLayout(m_layout);
	deviceContext->VSSetShader(m_vertexShader, NULL, 0);
	deviceContext->PSSetShader(m_pixelShader, NULL, 0);
	deviceContext->DrawIndexed(indexCount, 0, 0);

	return;
}

################################################################################

grafikklasse.cpp

#include "grafikklasse.h"

GrafikKlasse::GrafikKlasse()
{
	m_D3D = 0;
	m_Camera = 0;
	m_Model = 0;
	m_ColorShader = 0;
}

GrafikKlasse::GrafikKlasse(const GrafikKlasse&)
{
}

GrafikKlasse::~GrafikKlasse()
{
}

bool GrafikKlasse::Hochfahren(int Breite, int Höhe, HWND hwnd)
{
	bool ergebnis;

	m_D3D = new D3DKlasse;
	if(!m_D3D)
	{
		return false;
	}

	ergebnis = m_D3D->Hochfahren(Breite, Höhe, VSYNC_ENABLED, hwnd, FULL_SCREEN, SCREEN_DEPTH, SCREEN_NEAR);

	if(!ergebnis)
	{
		MessageBox(hwnd, L"Konnte Direct3D nicht Initialisieren!", L"Fehler", MB_OK);
		return false;
	}

	m_Camera = new KameraKlasse;
	if(!m_Camera)
	{
		return false;
	}

	m_Camera->SetPosition(0.0f, 0.0f, -10.0f);

	m_Model = new ModellKlasse;
	if(!m_Model)
	{
		return false;
	}

	ergebnis = m_Model->Hochfahren(m_D3D->GetDevice());
	if(!ergebnis)
	{
		MessageBox(hwnd, L"Konnte das ModellObjekt nicht initialisieren!",  L"Fehler", MB_OK);
		return false;
	}

	m_ColorShader = new FarbshaderKlasse;
	if(!m_ColorShader)
	{
		return false;
	}

	ergebnis = m_ColorShader->Hochfahren(m_D3D->GetDevice(), hwnd);
	if(!ergebnis)
	{
		MessageBox(hwnd, L"Konnte das ShaderObjekt nicht initialisieren!!", L"Fehler", MB_OK);
		return false;
	}

	return true;
}

void GrafikKlasse::Schließen()
{
	if(m_ColorShader)
	{
		m_ColorShader->Schließen();
		delete m_ColorShader;
		m_ColorShader = 0;
	}

	if(m_Model)
	{
		m_Model->Schließen();
		delete m_Model;
		m_Model = 0;
	}

	if(m_Camera)
	{
		delete m_Camera;
		m_Camera = 0;
	}

	if(m_D3D)
	{
		m_D3D->Schließen();
		delete m_D3D;
		m_D3D = 0;
	}
	return;
}

bool GrafikKlasse::Bild()
{
	bool ergebnis;

	ergebnis = Rendern();
	if(!ergebnis)
	{
		return false;
	}

	return true;
}

bool GrafikKlasse::Rendern()
{
	D3DXMATRIX viewMatrix, projectionMatrix, worldMatrix;
	bool ergebnis;

	m_D3D->StarteSzene(0.0f, 0.0f, 0.0f, 1.0f);

	m_Camera->Rendern();
	m_Camera->GetViewMatrix(viewMatrix);

	m_D3D->GetWorldMatrix(worldMatrix);
	m_D3D->GetProjectionMatrix(projectionMatrix);

	m_Model->Rendern(m_D3D->GetDeviceContext());

	ergebnis = m_ColorShader->Rendern(m_D3D->GetDeviceContext(), m_Model->GetIndexCount(), worldMatrix, viewMatrix, projectionMatrix);
	if(!ergebnis)
	{
		return false;
	}

	m_D3D->BeendeSzene();

	return true;
}

################################################################################

kameraklasse.cpp

#include "kameraklasse.h"

KameraKlasse::KameraKlasse()
{
	m_positionX = 0.0f;
	m_positionY = 0.0f;
	m_positionZ = 0.0f;

	m_rotationX = 0.0f;
	m_rotationY = 0.0f;
	m_rotationZ = 0.0f;
}

KameraKlasse::KameraKlasse(const KameraKlasse& other)
{
}

KameraKlasse::~KameraKlasse()
{
}

void KameraKlasse::SetPosition(float x, float y, float z)
{
	m_positionX = x;
	m_positionY = y;
	m_positionZ = z;

	return;
}

void KameraKlasse::SetRoation(float x, float y, float z)
{
	m_rotationX = x;
	m_rotationY = y;
	m_rotationZ = z;

	return;
}

D3DXVECTOR3 KameraKlasse::GetPosition()
{
	return D3DXVECTOR3(m_positionX, m_positionY, m_positionZ);
}

D3DXVECTOR3 KameraKlasse::GetRotation()
{
	return D3DXVECTOR3(m_rotationX, m_rotationY, m_rotationZ);
}

void KameraKlasse::Rendern()
{
	D3DXVECTOR3 up, position, lookAt;
	float yaw, pitch, roll;
	D3DXMATRIX rotationMatrix;

	up.x = 0.0f;
	up.y = 1.0f;
	up.z = 0.0f;

	position.x = m_positionX;
	position.y = m_positionY;
	position.z = m_positionZ;

	lookAt.x = 0.0f;
	lookAt.y = 0.0f;
	lookAt.z = 1.0f;

	pitch = m_rotationX * 0.0174532925f;
	yaw   = m_rotationY * 0.0174532925f;
	roll  = m_rotationZ * 0.0174532925f;

	D3DXMatrixRotationYawPitchRoll(&rotationMatrix, yaw, pitch, roll);
	D3DXVec3TransformCoord(&lookAt, &lookAt, &rotationMatrix);
	D3DXVec3TransformCoord(&up, &up, &rotationMatrix);

	lookAt = position + lookAt;

	D3DXMatrixLookAtLH(&m_viewMatrix, &position, &lookAt, &up);

	return;
}

void KameraKlasse::GetViewMatrix(D3DXMATRIX& viewMatrix)
{
	viewMatrix = m_viewMatrix;
	return;
}

################################################################################

Main.cpp

#include "systemklasse.h"

int WINAPI WinMain(HINSTANCE hauptfenster, HINSTANCE Konsole, PSTR pScmdline, int iCmdShow)
{
	SystemKlasse* System;
	bool ergebnis;

	System = new SystemKlasse;
	if(!System)
	{
		return 0;
	}

	ergebnis = System->Hochfahren();
	if(ergebnis)
	{
		System->Ausführen();
	}

	System->Schließen();
	delete System;
	System = 0;

	return 0;
}

################################################################################

modellklasse.cpp

#include "modellklasse.h"

ModellKlasse::ModellKlasse()
{
	m_vertexBuffer = 0;
	m_indexBuffer = 0;
}

ModellKlasse::ModellKlasse(const ModellKlasse& other)
{
}

ModellKlasse::~ModellKlasse()
{
}

bool ModellKlasse::Hochfahren(ID3D11Device* device)
{
	bool ergebnis;

	ergebnis = BufferHochfahren(device);
	if(FAILED(ergebnis))
	{
		return false;
	}

	return true;
}

void ModellKlasse::Schließen()
{
	BufferSchließen();

	return;
}

void ModellKlasse::Rendern(ID3D11DeviceContext* deviceContext)
{
	BufferRendern(deviceContext);

	return;
}

int ModellKlasse::GetIndexCount()
{
	return m_indexCount;
}

bool ModellKlasse::BufferHochfahren(ID3D11Device* device)
{
	VertexType* vertices;
	unsigned long* indices;
	D3D11_BUFFER_DESC vertexBufferDesc, indexBufferDesc;
	D3D11_SUBRESOURCE_DATA vertexData, indexData;
	HRESULT ergebnis;

	m_vertexCount = 4;
	m_indexCount = 4;

	vertices = new VertexType[m_vertexCount];
	if(!vertices)
	{
		return false;
	}

	indices = new unsigned long[m_indexCount];
	if(!indices)
	{
		return false;
	}

	vertices[0].position = D3DXVECTOR3(-1.0f, -1.0f, 0.0f);
	vertices[0].color = D3DXVECTOR4(1.0f, 1.0f, 0.0f, 1.0f);

	vertices[1].position = D3DXVECTOR3(0.0f, 1.0f, 0.0f);
	vertices[1].color = D3DXVECTOR4(1.0f, 1.0f, 0.0f, 1.0f);

	vertices[2].position = D3DXVECTOR3(1.0f, -1.0f, 0.0f);
	vertices[2].color = D3DXVECTOR4(1.0f, 1.0f, 0.0f, 1.0f);

	vertices[3].position = D3DXVECTOR3(0.0f, 1.0f, 1.0f);
	vertices[3].color = D3DXVECTOR4(1.0f, 1.0f, 0.0f, 1.0f);

	indices[0] = 0;
	indices[1] = 1;
	indices[2] = 2;
	indices[3] = 3;

	vertexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
	vertexBufferDesc.ByteWidth = sizeof(VertexType) * m_vertexCount;
	vertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
	vertexBufferDesc.CPUAccessFlags = 0;
	vertexBufferDesc.MiscFlags = 0;
	vertexBufferDesc.StructureByteStride = 0;

	vertexData.pSysMem = vertices;
	vertexData.SysMemPitch = 0;
	vertexData.SysMemSlicePitch = 0;

	ergebnis = device->CreateBuffer(&vertexBufferDesc, &vertexData, &m_vertexBuffer);
	if(FAILED(ergebnis))
	{
		return false;
	}

	indexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
	indexBufferDesc.ByteWidth = sizeof(unsigned long) * m_indexCount;
	indexBufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER;
	indexBufferDesc.CPUAccessFlags = 0;
	indexBufferDesc.MiscFlags = 0;
	indexBufferDesc.StructureByteStride = 0;

	indexData.pSysMem = indices;
	indexData.SysMemPitch = 0;
	indexData.SysMemSlicePitch = 0;

	ergebnis = device->CreateBuffer(&indexBufferDesc, &indexData, &m_indexBuffer);
	if(FAILED(ergebnis))
	{
		return false;
	}

	delete [] vertices;
	vertices = 0;

	delete [] indices;
	indices = 0;

	return true;
}

void ModellKlasse::BufferSchließen()
{
	if(m_indexBuffer)
	{
		m_indexBuffer->Release();
		m_indexBuffer = 0;
	}

	if(m_vertexBuffer)
	{
		m_vertexBuffer->Release();
		m_vertexBuffer = 0;
	}

	return;
}

void ModellKlasse::BufferRendern(ID3D11DeviceContext* deviceContext)
{
	unsigned int stride;
	unsigned int offset;

	stride = sizeof(VertexType); 
	offset = 0;

	deviceContext->IASetVertexBuffers(0, 1, &m_vertexBuffer, &stride, &offset);
	deviceContext->IASetIndexBuffer(m_indexBuffer, DXGI_FORMAT_R32_UINT, 0);
	deviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);

	return;
}

################################################################################

systemklasse.cpp

#include "systemklasse.h"

SystemKlasse::SystemKlasse()
{
	m_Eingabe = 0;
	m_Grafik = 0;
}

SystemKlasse::SystemKlasse(const SystemKlasse& other)
{
}

SystemKlasse::~SystemKlasse()
{
}

bool SystemKlasse::Hochfahren()
{
	int Breite,Höhe;
	bool ergebnis;

	Breite = 0;
	Höhe = 0;

	StarteFenster (Breite, Höhe);

	m_Eingabe = new EingabeKlasse;
	if(!m_Eingabe)
	{
		return false;
	}

	m_Eingabe->Hochfahren();

	m_Grafik = new GrafikKlasse;
	if (!m_Grafik)
	{
		return false;
	}

	ergebnis = m_Grafik->Hochfahren(Breite, Höhe, m_hwnd);
	if(!ergebnis)
	{
		return false;
	}

	return true;
}

void SystemKlasse::Schließen()
{
	if(m_Grafik)
	{
		m_Grafik->Schließen();
		delete m_Grafik;
		m_Grafik = 0;
	}

	if(m_Eingabe)
	{
		delete m_Eingabe;
		m_Eingabe = 0;
	}

	SchließeFenster();

	return;
}

void SystemKlasse::Ausführen()
{
	MSG nachricht;
	bool fertig, ergebnis;

	ZeroMemory(&nachricht, NULL);

	fertig = false;
	while(!fertig)
	{
		if(PeekMessage(&nachricht, NULL, 0,0, PM_REMOVE))
		{
			TranslateMessage(&nachricht);
			DispatchMessage(&nachricht);
		}

		if(nachricht.message == WM_QUIT)
		{
			fertig = true;
		}
		else
		{
			ergebnis = Bild();
			if(!ergebnis)
			{
				fertig = true;
			}
		}
	}

	return;
}

bool SystemKlasse::Bild()
{
	bool ergebnis;

	if(m_Eingabe->isKeyDown(VK_ESCAPE))
	{
		return false;
	}

	ergebnis = m_Grafik->Bild();
	if(!ergebnis)
	{
		return false;
	}

	return true;
}

LRESULT CALLBACK SystemKlasse::NachrichtenVerwalter(HWND hwnd, UINT umsg, WPARAM wparam, LPARAM lparam)
{
	switch(umsg)
	{
	case WM_KEYDOWN:
		{
			m_Eingabe->KeyDown((unsigned int)wparam);
			return 0;
		}

	case WM_KEYUP:
		{
			m_Eingabe->KeyUp((unsigned int)wparam);
			return 0;
		}
	default:
		{
			return DefWindowProc(hwnd, umsg, wparam, lparam);
		}
	}
}

void SystemKlasse::StarteFenster(int& Breite, int& Höhe)
{
	WNDCLASSEX wc;
	DEVMODE dmBildschirmEinstellung;
	int PosX, PosY;

	ApplicationHandle = this;

	m_hauptfenster = GetModuleHandle(NULL);

	m_applicationName = L"OverClockedEngine";

	wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
	wc.lpfnWndProc = WndProc;
	wc.cbClsExtra = 0;
	wc.cbWndExtra = 0;
	wc.hInstance = m_hauptfenster;
	wc.hIcon = LoadIcon(NULL, IDI_WINLOGO);
	wc.hIconSm = wc.hIcon;
	wc.hCursor = LoadCursor(NULL, IDC_ARROW);
	wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
	wc.lpszMenuName = NULL;
	wc.lpszClassName = m_applicationName;
	wc.cbSize = sizeof(WNDCLASSEX);

	RegisterClassEx(&wc);

	Breite = GetSystemMetrics(SM_CXSCREEN);
	Höhe = GetSystemMetrics(SM_CYSCREEN);

	if(FULL_SCREEN)
	{
		memset(&dmBildschirmEinstellung, 0, sizeof(dmBildschirmEinstellung));
		dmBildschirmEinstellung.dmSize = sizeof(dmBildschirmEinstellung);
		dmBildschirmEinstellung.dmPelsWidth = (unsigned long)Breite;
		dmBildschirmEinstellung.dmPelsHeight = (unsigned long)Höhe;
		dmBildschirmEinstellung.dmBitsPerPel = 32;
		dmBildschirmEinstellung.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;

		ChangeDisplaySettings(&dmBildschirmEinstellung, CDS_FULLSCREEN);

		PosX = PosY = 0;
	}
	else
	{
		Breite = 800;
		Höhe = 600;

		PosX = (GetSystemMetrics(SM_CXSCREEN)- Breite) /2;
		PosY = (GetSystemMetrics(SM_CYSCREEN)- Höhe) /2;
	}

	m_hwnd = CreateWindowEx(WS_EX_APPWINDOW, m_applicationName, m_applicationName, WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_POPUP, PosX, PosY, Breite, Höhe, NULL, NULL, m_hauptfenster, NULL);
	ShowWindow(m_hwnd, SW_SHOW);
	SetForegroundWindow (m_hwnd);
	SetFocus(m_hwnd);

	ShowCursor(false);

	return;
}

void SystemKlasse::SchließeFenster()
{
	ShowCursor(true);
	if(FULL_SCREEN)
	{
		ChangeDisplaySettings(NULL,0);
	}

	DestroyWindow(m_hwnd);
	m_hwnd = NULL;

	UnregisterClass(m_applicationName, m_hauptfenster);
	m_hauptfenster = NULL;

	ApplicationHandle = NULL;

	return;
}

LRESULT CALLBACK WndProc(HWND hwnd, UINT umessage, WPARAM wparam, LPARAM lparam)
{
	switch(umessage)
	{
	case WM_DESTROY:
		{
			PostQuitMessage(0);
			return 0;
		}

	case WM_CLOSE:
		{
			PostQuitMessage (0);
			return 0;
		}
	default:
		{
			return ApplicationHandle->NachrichtenVerwalter(hwnd, umessage, wparam, lparam);
		}
	}
}

################################################################################

SHADERFILES
--------------------------------------------------------------------------------

Color.vs

cbuffer MatrixBuffer
{
	matrix worldMatrix;
	matrix viewMatrix;
	matrix projectionMatrix;
};

struct VertexInputType
{
    float4 position : POSITION;
    float4 color : COLOR;
};

struct PixelInputType
{
    float4 position : SV_POSITION;
    float4 color : COLOR;
};

PixelInputType ColorVertexShader(VertexInputType input)
{
    PixelInputType output;

    input.position.w = 1.0f;

    output.position = mul(input.position, worldMatrix);
    output.position = mul(output.position, viewMatrix);
    output.position = mul(output.position, projectionMatrix);
    output.color = input.color;

    return output;
}

################################################################################

Color.ps

struct PixelInputType
{
    float4 position : SV_POSITION;
    float4 color : COLOR;
};

float4 ColorPixelShader(PixelInputType input) : SV_TARGET
{
    return input.color;
}

################################################################################

C++ Forumbot

Dieser Thread wurde von Moderator/in SeppJ aus dem Forum C++ (auch C++0x, bzw. C++11) in das Forum Spiele-/Grafikprogrammierung verschoben.

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

314159265358979

Ich bin mir nicht sicher, aber ich glaube, du hast damit einen Rekord gebrochen. Das ist übrigens nichts, worüber man sich freuen sollte.

huh?

Alter,um ein Viereck zu malen brauchst du indizierte vertices (also Buffer für beides). Der Code den ich dafür schrieb erzeugte einen Würfel, und der Code war 300 Zeilen lang. WO ZUM TEUFEL LERNST DU DAS?

Ich lerne erst DirectX 11 und C++

7xCore

Wenn du erst am lernen bist musst du doch nicht gleich dein eigenes framework bauen :xmas1:

Ich muss so schnell wie möglich lernen wie ein profi zu proggen wo kann ich das am besten lernen? sorry das der code so lang ist aber ich hab halt noch wenig ahnung

hustbaer

@LePwnerer
Der Code ist halt Overkill für jmd. der gerade erst lernt die ersten Schritte zu machen.
Vergiss die ganze Aufteilung in verschiedene Objekte/Klassen, und spiel dich erstmal mit den D3D Funktionen. Lern erstmal gehen, bevor du versucht nen Marathon zu laufen.

Und der Code ist wirklich etwas gross um ihn hier zu posten.

Wenn du es nicht auf das Wesentliche zusammenkürzen kannst (z.B. weil du überhaupt gar keinen Anhaltspunkt hast wo der Fehler liegen könnte), dann ist es vermutlich besser wenn du einfach ein ZIP File irgendwo hochlädst, wo das ganze Projekt drinnen ist. (Inklusive .vcproj/.sln Files, halt alles was man braucht um das Ding zu bauen.)

ja danke!

NAja ich versuchs aber alle tuts hauen einem das und das vor selbst beginner guides sind so derb, beispiel: " Nun erstellen wri die klasse zum rendern ...bla bla bla... dafür binden wir dxd3whatever ein und erstellen D3DXMATRIX und blah und blah und ich hba keinen plan was was bewirkt oder wie ich was zusammenbasteln soll... =_= *headspin*

dot

hustbaer schrieb:

Der Code ist halt Overkill für jmd. der gerade erst lernt die ersten Schritte zu machen.
Vergiss die ganze Aufteilung in verschiedene Objekte/Klassen, und spiel dich erstmal mit den D3D Funktionen.

+1

Bevor du genug Erfahrung hast, ist es dir sowieso unmöglich zu entscheiden, wie du so ein System am besten entwerfen solltest. Allerdings ist deine Aufteilung imo gar nicht so verkehrt.

Ein paar generelle Anmerkungen aber vielleicht zum Code:

Warum überall diese Hochfahren() Methoden und nicht einfach den Konstruktor verwenden?
Macht der public Copy-Ctor dort überall wirklich Sinn? Wenn schon ein Copy-Ctor warum dann nicht auch gleich ein operator =() ?
Verwend Initialisierungslisten statt Zuweisungen im Konstruktor.
Verwend den Destruktor statt dieser Schließen() Methode, genau dafür ist er da. Dann brauchst du die Pointer auch nichtmehr alle auf 0 setzen.
libs gehören imo in den Projekteigenschaften gelinkt und nicht per #pragma im Code.
Ich rat sehr davon ab Deutsch und Englisch zu mischen, aber gut, das ist am Ende Geschmackssache.

DNKpp

dot schrieb:

[*] Verwend Initialisierungslisten statt Zuweisungen im Konstruktor.

welchen vorteil hat das, das nicht im konstruktor selbst zu tun? der konstruktor geht ja bei vererbung an sich nicht verloren, und ansonsten würde mir dazu nichts einfallen, was dagegen spräche, das alles im konstruktor direkt zu schreiben.

dot

Die Init-Liste gehört doch zum Konstruktor!?
Über die Init-Liste gibst du direkt an welche Konstruktoren für die einzelnen Member aufgerufen werden sollen, gibst also eben direkt an wie die Member initialisiert werden sollen. Im Body des Konstruktors sind sie bereits initialisiert, d.h. ihre Konstruktoren wurden bereits ausgeführt und durch die Zuweisungen dort überschreibst du nun die Werte die initialen Werte.
Init-Liste vs. Zuweisung im Konstruktor sind also zwei fundamental verschiedene Dinge!
Bei primitiven Typen wie int, float etc. macht das natürlich keinen Unterschied, aber viele Klassen z.B. bieten gar keinen Zuweisungsoperator, die Init-Liste ist somit der einzige Weg um solche Member zu initialisieren.
Auch wenn es einen operator =() gibt, so ist es potentiell effizienter die Member direkt richtig zu initialisieren, als sie zu initialisieren (wenn es keinen Eintrag in der Init-Liste gibt wird einfach der Default-Ctor aufgerufen) nur um dann diese Werte gleich zu überschreiben.

hustbaer

@anti-freak:
Nochmal Beispielhaft...

Init-Liste ist vergleichbar mit

std::string m_string("123");
Foo m_foo(1, 2, 3);

Keine Init-Liste und dann im Konstruktor zuweisen ist vergleichbar mit

std::string m_string;
Foo m_foo;

m_string = "123";
m_foo = Foo(1, 2, 3);

DNKpp

ok, dankeschön
klar gehört die init liste zum konstruktor, nur war mir bisher nicht bewusst, welche vorteile diese mit sich bringt.
gelesen, verstanden, akzeptiert und zukünftig auch umgesetzt

Problem DX &amp; C++

Problem DX & C++