[DX11] Probleme beim erstellen von Geometrie

[Grubenlord]

Hallo,
ich lerne mich zur Zeit in DirectX 11 und bin schon recht früh auf ein mir unverständliches Problem gestoßen. Ich möchte mir etwas Geometrie erzeugen um mir eine Box zu bauen. Für den bisherigen Code habe ich mir hauptächlich die Samples aus dem SDK angesehen.
Beim kompilieren bekomme ich die Fehlermeldung "Error Code: E_INVALIDARG (0x80070057) Calling: pd3dDevice -> CreateBuffer(&Desc, NULL, &g_pcbPerFrame)"
Ich poste hier im Anschluss mal die CreateDevice und die Framerender, da sich darin ja der Fehler befinden sollte. (ich habe die Stelle unterstrichen, ich hoffe es ist sonst leserlich)
Es wäre wirklich super wenn mir jemand weiterhelfen könnte, bisher konnte das niemand.
Mit freundlichen Grüßen

Code: Alles auswählen

HRESULT CALLBACK OnD3D11CreateDevice( ID3D11Device* pd3dDevice, const DXGI_SURFACE_DESC* pBackBufferSurfaceDesc,
                                      void* pUserContext )
{
	HRESULT hr;

    ID3D11DeviceContext* pd3dImmediateContext = DXUTGetD3D11DeviceContext();
    V_RETURN( g_DialogResourceManager.OnD3D11CreateDevice( pd3dDevice, pd3dImmediateContext ) );
    V_RETURN( g_D3DSettingsDlg.OnD3D11CreateDevice( pd3dDevice ) );

    ID3DBlob* pBlobVS = NULL;
    ID3DBlob* pBlobPS = NULL;

    V_RETURN( CompileShaderFromFile( L"Shader.hlsl", "DrawVS",     "vs_5_0", &pBlobVS ) );
    V_RETURN( CompileShaderFromFile( L"Shader.hlsl", "DrawPS",     "ps_5_0", &pBlobPS ) );

    V_RETURN( pd3dDevice->CreateVertexShader( pBlobVS->GetBufferPointer(), pBlobVS->GetBufferSize(), NULL, &g_pVertexShader ) );
    V_RETURN( pd3dDevice->CreatePixelShader( pBlobPS->GetBufferPointer(), pBlobPS->GetBufferSize(), NULL, &g_pPixelShader ) );

    const D3D11_INPUT_ELEMENT_DESC patchlayout[] =
    {
        { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0,  D3D11_INPUT_PER_VERTEX_DATA, 0 },
		{ "WORLDPOS", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12,  D3D11_INPUT_PER_VERTEX_DATA, 0 },
    };

    V_RETURN( pd3dDevice->CreateInputLayout( patchlayout, ARRAYSIZE( patchlayout ), pBlobVS->GetBufferPointer(),
                                             pBlobVS->GetBufferSize(), &g_pPatchLayout ) );

    SAFE_RELEASE( pBlobVS );
    SAFE_RELEASE( pBlobPS );

    D3D11_BUFFER_DESC Desc;
    Desc.Usage = D3D11_USAGE_DYNAMIC;
    Desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
    Desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
    Desc.MiscFlags = 0;

    Desc.ByteWidth = sizeof( CB_PER_FRAME_CONSTANTS );
    [u]V_RETURN( pd3dDevice->CreateBuffer( &Desc, NULL, &g_pcbPerFrame ) );[/u]

    D3D11_RASTERIZER_DESC RasterDesc;
    ZeroMemory( &RasterDesc, sizeof(D3D11_RASTERIZER_DESC) );
    RasterDesc.FillMode = D3D11_FILL_SOLID;
    RasterDesc.CullMode = D3D11_CULL_NONE;
    RasterDesc.DepthClipEnable = TRUE;
    V_RETURN( pd3dDevice->CreateRasterizerState( &RasterDesc, &g_pRasterizerStateSolid ) );

    RasterDesc.FillMode = D3D11_FILL_WIREFRAME;
    V_RETURN( pd3dDevice->CreateRasterizerState( &RasterDesc, &g_pRasterizerStateWireframe ) );

    D3D11_BUFFER_DESC vbDesc;
    ZeroMemory( &vbDesc, sizeof(D3D11_BUFFER_DESC) );
    vbDesc.ByteWidth = sizeof(MESH_CONTROL_POINT) * (ARRAYSIZE(g_Cornell));
    vbDesc.Usage = D3D11_USAGE_DEFAULT;
    vbDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;

    D3D11_SUBRESOURCE_DATA vbInitData;
    ZeroMemory( &vbInitData, sizeof(vbInitData) );
	vbInitData.pSysMem = g_Cornell;
    V_RETURN( pd3dDevice->CreateBuffer( &vbDesc, &vbInitData, &g_pControlPointVB ) );

    return S_OK;
}

Code: Alles auswählen

void CALLBACK OnD3D11FrameRender( ID3D11Device* pd3dDevice, ID3D11DeviceContext* pd3dImmediateContext,
                                  double fTime, float fElapsedTime, void* pUserContext )
{
	 if( g_D3DSettingsDlg.IsActive() )
    {
        g_D3DSettingsDlg.OnRender( fElapsedTime );
        return;
    }

    D3DXMATRIX mViewProjection;
    D3DXMATRIX mProj = *g_Camera.GetProjMatrix();
    D3DXMATRIX mView = *g_Camera.GetViewMatrix();

    mViewProjection = mView * mProj;

    D3D11_MAPPED_SUBRESOURCE MappedResource;
    pd3dImmediateContext->Map( g_pcbPerFrame, 0, D3D11_MAP_WRITE_DISCARD, 0, &MappedResource );
    CB_PER_FRAME_CONSTANTS* pData = ( CB_PER_FRAME_CONSTANTS* )MappedResource.pData;

    D3DXMatrixTranspose( &pData->mViewProjection, &mViewProjection );
    pData->vCameraPosWorld = *( g_Camera.GetEyePt() );

    pd3dImmediateContext->Unmap( g_pcbPerFrame, 0 );

    float ClearColor[4] = { 0.05f, 0.05f, 0.05f, 0.0f };
    ID3D11RenderTargetView* pRTV = DXUTGetD3D11RenderTargetView();
    pd3dImmediateContext->ClearRenderTargetView( pRTV, ClearColor );
    ID3D11DepthStencilView* pDSV = DXUTGetD3D11DepthStencilView();
    pd3dImmediateContext->ClearDepthStencilView( pDSV, D3D11_CLEAR_DEPTH, 1.0, 0 );

    pd3dImmediateContext->RSSetState( g_pRasterizerStateSolid );

    pd3dImmediateContext->VSSetConstantBuffers( g_iBindPerFrame, 1, &g_pcbPerFrame );
    pd3dImmediateContext->PSSetConstantBuffers( g_iBindPerFrame, 1, &g_pcbPerFrame );

    pd3dImmediateContext->VSSetShader( g_pVertexShader, NULL, 0 );
    pd3dImmediateContext->PSSetShader( g_pPixelShader, NULL, 0 );

    if( g_bDrawWires )
    {
        pd3dImmediateContext->RSSetState( g_pRasterizerStateWireframe ); 
    }

    pd3dImmediateContext->IASetInputLayout( g_pPatchLayout );
    UINT Stride = sizeof( MESH_CONTROL_POINT );
    UINT Offset = 0;
    pd3dImmediateContext->IASetVertexBuffers( 0, 1, &g_pControlPointVB, &Stride, &Offset );
	pd3dImmediateContext->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST );

	pd3dImmediateContext->Draw( ARRAYSIZE(g_Cornell), 0 );

    pd3dImmediateContext->RSSetState( g_pRasterizerStateSolid );
}

[anonym]

Die Debug-Output-Ausgabe sollte nähere Auskünfte aussprucken. (irgendwo im DirectX Control Panel zu finden)

Hast Du das hier in den Anmerkungen der Dokumentation von CreateBuffer gesehen?

If the bind flag is D3D11_BIND_CONSTANT_BUFFER then the ByteWidth value must be in multiples of 16, and less than or equal to D3D11_REQ_CONSTANT_BUFFER_ELEMENT_COUNT.

[Grubenlord]

Leider nein,
ich hatte den Fehler auch an anderer Stelle vermutet, da es andererort ja auch so funktionierte :/
Nungut, ein Desc.ByteWidth = UINT(D3D11_REQ_CONSTANT_BUFFER_ELEMENT_COUNT); hat den Fehler erstmal beseitigt und nun liegen erstmal weitere vor, aber da muss ich erst einmal sehen :-)
Vielen Dank

[Grubenlord]

Nochmals Hallo,
immoment schlage ich mich mit dem Problem rum, dass sich mein erzeugtes Dreieck nicht erweitern lässt, also bei weiteren vertices ändern sich nur komisch(unlogisch) die Koordinaten der bisherigen drei. Zudem bekomme ich die Warnung, dass
D3D11: WARNING: ID3D11DeviceContext::Draw: Vertex Buffer at the input vertex slot 0 is not big enough for what the Draw*() call expects to traverse. This is OK, as reading off the end of the Buffer is defined to return 0. However the developer probably did not intend to make use of this behavior. [ EXECUTION WARNING #356: DEVICE_DRAW_VERTEX_BUFFER_TOO_SMALL ]

Weiss vielleicht jemand woran das liegen könnte?
Und bei der Gelegenheit, wüsste jemand vielleicht eine schöne Addresse die das alles mit dem Erzeugen von Geometrie übersichtlich erklären könnte?

Mit freundlichen Grüssen

[Krishty]

Kannst du die Definition deiner Vertex-Klasse, deren D3D11_INPUT_ELEMENT_DESC[] (falls geändert) und die Definition von g_Cornell posten?

[Grubenlord]

Gerne, leicht abgeändert mittlerweile:

Code: Alles auswählen

struct SimpleVertex
{
    D3DXVECTOR3 Pos;  // Position
};


SimpleVertex vertices[] =
{
    D3DXVECTOR3( 0.0f, 0.5f, 0.5f ),

    D3DXVECTOR3( 0.5f, -0.5f, 0.5f ),

    D3DXVECTOR3( -0.5f, -0.5f, 0.5f ),


};

Code: Alles auswählen

    const D3D11_INPUT_ELEMENT_DESC layout[] =
    {
        { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0,  0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
        { "NORMAL",   0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
        { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT,    0, 24, D3D11_INPUT_PER_VERTEX_DATA, 0 },
    };

[Krishty]

Deine Vertices enthalten nur eine Position, du gibst aber im Input-Layout an, der Position würden noch Normalenvektor und Texturkoordinate folgen. Darum die Warnung, du würdest zuwenig Daten in den Vertex-Buffer packen und darum interpretiert D3D dein zweites und drittes Vertex als Normalenvektor und Texturkoordinate des ersten.

Wenn du Normalen und Texturkoordinaten brauchst, musst du nochmal fünf Floats zu deiner Vertex-Struktur hinzufügen und entsprechend initialisieren. Wenn nicht, musst du die beiden letzten Elemente aus dem Input-Layout entfernen.

D3D weiß nicht, welche Daten du übergibst. Das musst du explizit über das Layout mitteilen, dafür ist das da. Wenn du darin angibst, die ersten zwölf Bytes seien die Position, die nächsten zwölf die Normale und die letzten acht die Texturkoordinate, du aber im Vertex-Buffer nur zwölf Bytes pro Vertex zur Verfügung stellst ist klar, dass das nicht hinhaut.

[Grubenlord]

Als ich mir die Dokumentation angesehen habe hatte ich das auch so verstanden, nur war ich sehr überrascht als ich dann doch ein kleines Dreieck in meinem Fenster hatte. Durch die Fehler hatte ich dann aber auch mal folgendes probiert:

Code: Alles auswählen

struct SimpleVertex
{
    D3DXVECTOR3 Pos;  // Position
	D3DXVECTOR3 Nor;
	D3DXVECTOR2 Tex;
};


SimpleVertex vertices[] =
{
    D3DXVECTOR3( 0.0f, 0.5f, 0.5f ),
    D3DXVECTOR3( 0.0f, 0.0f, -0.5f ),
	D3DXVECTOR2 (0.0f, 0.0f),

    D3DXVECTOR3( 0.5f, -0.5f, 0.5f ),
    D3DXVECTOR3( 0.5f, 0.0f, -0.5f ),
	D3DXVECTOR2 (0.0f, 1.0f),

    D3DXVECTOR3( -0.5f, -0.5f, 0.5f ),
    D3DXVECTOR3( 0.0f, 0.5f, -0.5f ),
	D3DXVECTOR2 (1.0f, 0.0f),

	D3DXVECTOR3( 3.5f, 3.5f, 0.5f ),
    D3DXVECTOR3( 0.0f, 0.0f, -0.5f ),
	D3DXVECTOR2 (1.0f, 0.0f),
};

scheinbar unterliegt mir immernoch irgendwo ein kapitaler Denkfehler

[Krishty]

Du hattest als Daten gegeben:

Pos( 0.0f, 0.5f, 0.5f )

Pos( 0.5f, -0.5f, 0.5f )

Pos( -0.5f, -0.5f, 0.5f )

D3D hat das so verstanden:

Pos( 0.0f, 0.5f, 0.5f )
Nor( 0.5f, -0.5f, 0.5f )
Tex( -0.5f, -0.5f )

Pos ( 0.5f, 0, 0 )
Nor( 0, 0, 0 )
Tex( 0, 0 )

Pos ( 0, 0, 0 )
Nor( 0, 0, 0 )
Tex( 0, 0 )

Durch dein „Glück“, dass die 0.5f noch in die Position des zweiten Vertex gerutscht ist bevor nurnoch mit Nullen gefüllt wurde, hattest du drei unterschiedliche Koordinaten und damit ein Dreieck.

So, wie du Nor und Tex definiert hast, müsste es aber eigentlich funktionieren. Falls nicht, schalt im Rasterizer-State das Culling aus (vielleicht siehst du zufälligerweise nur Rückseiten).

[Grubenlord]

hm, ich habe mir noch einen definiert und leider keinerlei Veränderung, sollte ich mal meine Klasse posten?

[exploid]

...

[Grubenlord]

Hm, seit dem ersten Post hatte ich einiges wieder geändert. Am besten ich poste mal die wichtigen Funktionen und die Shader - bitte nicht lachen

Code: Alles auswählen

void CALLBACK OnD3D11FrameRender( ID3D11Device* pd3dDevice, ID3D11DeviceContext* pd3dImmediateContext, double fTime,
                                 float fElapsedTime, void* pUserContext )
{
    // If the settings dialog is being shown, then render it instead of rendering the app's scene
    if( g_SettingsDlg.IsActive() )
    {
        g_SettingsDlg.OnRender( fElapsedTime );
        return;
    }       

    float ClearColor[4] = { 0.176f, 0.196f, 0.667f, 0.0f };
    ID3D11RenderTargetView* pRTV = DXUTGetD3D11RenderTargetView();
    pd3dImmediateContext->ClearRenderTargetView( pRTV, ClearColor );

    // Clear the depth stencil
    ID3D11DepthStencilView* pDSV = DXUTGetD3D11DepthStencilView();
    pd3dImmediateContext->ClearDepthStencilView( pDSV, D3D11_CLEAR_DEPTH, 1.0, 0 );

    // Get the projection & view matrix from the camera class
    D3DXMATRIX mWorld = *g_Camera.GetWorldMatrix();
    D3DXMATRIX mView = *g_Camera.GetViewMatrix();
    D3DXMATRIX mProj = *g_Camera.GetProjMatrix();
    D3DXMATRIX mWorldViewProjection = mWorld * mView * mProj;

    // Set the constant buffers
    HRESULT hr;
    D3D11_MAPPED_SUBRESOURCE MappedResource;
    V( pd3dImmediateContext->Map( g_pcbVSPerFrame11, 0, D3D11_MAP_WRITE_DISCARD, 0, &MappedResource ) );
    CB_VS_PER_FRAME* pVSPerFrame = ( CB_VS_PER_FRAME* )MappedResource.pData;
    pVSPerFrame->m_vLightDir = D3DXVECTOR3( 0,0.707f,-0.707f );
    pVSPerFrame->m_fTime = (float)fTime;
    pVSPerFrame->m_LightDiffuse = D3DXVECTOR4( 1.f, 1.f, 1.f, 1.f );
    pd3dImmediateContext->Unmap( g_pcbVSPerFrame11, 0 );
    pd3dImmediateContext->VSSetConstantBuffers( 1, 1, &g_pcbVSPerFrame11 );

    V( pd3dImmediateContext->Map( g_pcbVSPerObject11, 0, D3D11_MAP_WRITE_DISCARD, 0, &MappedResource ) );
    CB_VS_PER_OBJECT* pVSPerObject = ( CB_VS_PER_OBJECT* )MappedResource.pData;
    D3DXMatrixTranspose( &pVSPerObject->m_mWorldViewProjection, &mWorldViewProjection );
    D3DXMatrixTranspose( &pVSPerObject->m_mWorld, &mWorld );
    pVSPerObject->m_MaterialAmbientColor = D3DXVECTOR4( 0.3f, 0.3f, 0.3f, 1.0f );
    pVSPerObject->m_MaterialDiffuseColor = D3DXVECTOR4( 0.7f, 0.7f, 0.7f, 1.0f );
    pd3dImmediateContext->Unmap( g_pcbVSPerObject11, 0 );
    pd3dImmediateContext->VSSetConstantBuffers( 0, 1, &g_pcbVSPerObject11 );

	    pd3dImmediateContext->RSSetState( g_pRasterizerStateSolid );

    // Set render resources
    pd3dImmediateContext->IASetInputLayout( g_pLayout11 );
    pd3dImmediateContext->VSSetShader( g_pVertexShader11, NULL, 0 );
    pd3dImmediateContext->PSSetShader( g_pPixelShader11, NULL, 0 );
    pd3dImmediateContext->PSSetSamplers( 0, 1, &g_pSamLinear );

    // Render objects here...	// Set primitive topology	// Set vertex buffer
	UINT stride = sizeof( SimpleVertex );		//größe für ein vertex element
	UINT offset = 0;
	pd3dImmediateContext->IASetVertexBuffers( 0, 1, &g_pVertexBuffer, &stride, &offset );
	pd3dImmediateContext->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST );
	pd3dImmediateContext->Draw(sizeof( vertices ), 0);

    DXUT_BeginPerfEvent( DXUT_PERFEVENTCOLOR, L"HUD / Stats" );
    g_HUD.OnRender( fElapsedTime );
    g_SampleUI.OnRender( fElapsedTime );
    RenderText();
    DXUT_EndPerfEvent();

    static DWORD dwTimefirst = GetTickCount();
    if ( GetTickCount() - dwTimefirst > 5000 )
    {    
        OutputDebugString( DXUTGetFrameStats( DXUTIsVsyncEnabled() ) );
        OutputDebugString( L"\n" );
        dwTimefirst = GetTickCount();
    }
}

Code: Alles auswählen

HRESULT CALLBACK OnD3D11CreateDevice( ID3D11Device* pd3dDevice, const DXGI_SURFACE_DESC* pBackBufferSurfaceDesc,
                                     void* pUserContext )
{
    HRESULT hr;

    ID3D11DeviceContext* pd3dImmediateContext = DXUTGetD3D11DeviceContext();
    V_RETURN( g_DialogResourceManager.OnD3D11CreateDevice( pd3dDevice, pd3dImmediateContext ) );
    V_RETURN( g_SettingsDlg.OnD3D11CreateDevice( pd3dDevice ) );
    g_pTxtHelper = new CDXUTTextHelper( pd3dDevice, pd3dImmediateContext, &g_DialogResourceManager, 15 );

    // Read the HLSL file
    WCHAR str[MAX_PATH];
    V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, L"SimpleSample.hlsl" ) );

    // Compile the shaders
    DWORD dwShaderFlags = D3D10_SHADER_ENABLE_STRICTNESS;
#if defined( DEBUG ) || defined( _DEBUG )
    // Set the D3D10_SHADER_DEBUG flag to embed debug information in the shaders.
    // Setting this flag improves the shader debugging experience, but still allows 
    // the shaders to be optimized and to run exactly the way they will run in 
    // the release configuration of this program.
    dwShaderFlags |= D3D10_SHADER_DEBUG;
#endif

        // NOTE: We use 10level9_1 shader profiles to support all D3D11 feature-levels
    ID3DBlob* pVertexShaderBuffer = NULL;
    V_RETURN( D3DX11CompileFromFile( str, NULL, NULL, "RenderSceneVS", "vs_5_0", dwShaderFlags, 0, NULL,
                                     &pVertexShaderBuffer, NULL, NULL ) );

    ID3DBlob* pPixelShaderBuffer = NULL;
    V_RETURN( D3DX11CompileFromFile( str, NULL, NULL, "RenderScenePS", "ps_5_0", dwShaderFlags, 0, NULL,
                                     &pPixelShaderBuffer, NULL, NULL ) );

    // Create the shaders
    V_RETURN( pd3dDevice->CreateVertexShader( pVertexShaderBuffer->GetBufferPointer(),
                                              pVertexShaderBuffer->GetBufferSize(), NULL, &g_pVertexShader11 ) );
    V_RETURN( pd3dDevice->CreatePixelShader( pPixelShaderBuffer->GetBufferPointer(),
                                             pPixelShaderBuffer->GetBufferSize(), NULL, &g_pPixelShader11 ) );

    // Create a layout for the object data
    const D3D11_INPUT_ELEMENT_DESC layout[] =
    {
        { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0,  0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
        { "NORMAL",   0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
        { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT,    0, 24, D3D11_INPUT_PER_VERTEX_DATA, 0 },
    };

    V_RETURN( pd3dDevice->CreateInputLayout( layout, ARRAYSIZE( layout ), pVertexShaderBuffer->GetBufferPointer(),
                                             pVertexShaderBuffer->GetBufferSize(), &g_pLayout11 ) );

    // No longer need the shader blobs
    SAFE_RELEASE( pVertexShaderBuffer );
    SAFE_RELEASE( pPixelShaderBuffer );

    // Create state objects
    D3D11_SAMPLER_DESC samDesc;
    ZeroMemory( &samDesc, sizeof(samDesc) );
    samDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
    samDesc.AddressU = samDesc.AddressV = samDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
    samDesc.MaxAnisotropy = 1;
    samDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
    samDesc.MaxLOD = D3D11_FLOAT32_MAX;
    V_RETURN( pd3dDevice->CreateSamplerState( &samDesc, &g_pSamLinear ) );

	    // Create solid and wireframe rasterizer state objects
    D3D11_RASTERIZER_DESC RasterDesc;
    ZeroMemory( &RasterDesc, sizeof(D3D11_RASTERIZER_DESC) );
    RasterDesc.FillMode = D3D11_FILL_SOLID;
    RasterDesc.CullMode = D3D11_CULL_NONE;
    RasterDesc.DepthClipEnable = TRUE;
    V_RETURN( pd3dDevice->CreateRasterizerState( &RasterDesc, &g_pRasterizerStateSolid ) );

    // Create constant buffers
    D3D11_BUFFER_DESC cbDesc;
    ZeroMemory( &cbDesc, sizeof(cbDesc) );
    cbDesc.Usage = D3D11_USAGE_DYNAMIC;
    cbDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
    cbDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;

    cbDesc.ByteWidth = sizeof( CB_VS_PER_OBJECT );
    V_RETURN( pd3dDevice->CreateBuffer( &cbDesc, NULL, &g_pcbVSPerObject11 ) );

    cbDesc.ByteWidth = sizeof( CB_VS_PER_FRAME );
    V_RETURN( pd3dDevice->CreateBuffer( &cbDesc, NULL, &g_pcbVSPerFrame11 ) );

		// Create other render resources here
		D3D11_BUFFER_DESC bd;
		bd.Usage = D3D11_USAGE_DEFAULT;
		bd.ByteWidth = sizeof( SimpleVertex ) * 3;
		bd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
		bd.CPUAccessFlags = 0;
		bd.MiscFlags = 0;
		
		D3D11_SUBRESOURCE_DATA InitData;
		InitData.pSysMem = vertices;
		InitData.SysMemPitch = 0;
		InitData.SysMemSlicePitch = 0;

		if( FAILED( pd3dDevice->CreateBuffer( &bd, &InitData, &g_pVertexBuffer ) ) )
			return FALSE;

    // Setup the camera's view parameters
    D3DXVECTOR3 vecEye( 0.0f, 0.0f, -2.0f );
    D3DXVECTOR3 vecAt ( 0.0f, 0.0f, -0.0f );
    g_Camera.SetViewParams( &vecEye, &vecAt );

    return S_OK;
}

Code: Alles auswählen

//--------------------------------------------------------------------------------------
// Constant Buffers
//--------------------------------------------------------------------------------------
cbuffer cbPerObject : register( b0 )
{
    matrix  g_mWorldViewProjection  : packoffset( c0 );
    matrix  g_mWorld                : packoffset( c4 );
    float4  g_MaterialAmbientColor  : packoffset( c8 );
    float4  g_MaterialDiffuseColor  : packoffset( c9 );
}

cbuffer cbPerFrame : register( b1 )
{
    float3              g_vLightDir             : packoffset( c0 );
    float               g_fTime                 : packoffset( c0.w );
    float4              g_LightDiffuse          : packoffset( c1 );
};

//-----------------------------------------------------------------------------------------
// Textures and Samplers
//-----------------------------------------------------------------------------------------
Texture2D    g_txDiffuse : register( t0 );
SamplerState g_samLinear : register( s0 );

//--------------------------------------------------------------------------------------
// shader input/output structure
//--------------------------------------------------------------------------------------
struct VS_INPUT
{
    float4 Position     : POSITION; // vertex position 
    float3 Normal       : NORMAL;   // this normal comes in per-vertex
    float2 TextureUV    : TEXCOORD0;// vertex texture coords 
};

struct VS_OUTPUT
{
    float4 Position     : SV_POSITION; // vertex position 
    float4 Diffuse      : COLOR0;      // vertex diffuse color (note that COLOR0 is clamped from 0..1)
    float2 TextureUV    : TEXCOORD0;   // vertex texture coords 
};

//--------------------------------------------------------------------------------------
// This shader computes standard transform and lighting
//--------------------------------------------------------------------------------------
VS_OUTPUT RenderSceneVS( VS_INPUT input )
{
    VS_OUTPUT Output;
    float3 vNormalWorldSpace;
    
    // Transform the position from object space to homogeneous projection space
    Output.Position = mul( input.Position, g_mWorldViewProjection );
    
    // Transform the normal from object space to world space    
    vNormalWorldSpace = normalize(mul(input.Normal, (float3x3)g_mWorld)); // normal (world space)

    // Calc diffuse color    
    Output.Diffuse.rgb = g_MaterialDiffuseColor * g_LightDiffuse * max(0,dot(vNormalWorldSpace, g_vLightDir)) + 
                         g_MaterialAmbientColor;   
    Output.Diffuse.a = 1.0f; 
    
    // Just copy the texture coordinate through
    Output.TextureUV = input.TextureUV; 
    
    return Output;    
}

//--------------------------------------------------------------------------------------
// This shader outputs the pixel's color by modulating the texture's
// color with diffuse material color
//--------------------------------------------------------------------------------------
float4 RenderScenePS( VS_OUTPUT In ) : SV_TARGET
{ 
    // Lookup mesh texture and modulate it with diffuse
    return g_txDiffuse.Sample( g_samLinear, In.TextureUV ) * In.Diffuse;
}

[exploid]

...

[Grubenlord]

Die Idee dahinter war es, der Draw Methode zu sagen dass er mir immer die Menge der Vertices rendern soll, ich also dort ergänzen kann ohne es an dieser Stelle zu ändern. Wenn ich in der Draw eine 4 übergebe bekomme ich trotzdem immernoch nur ein Dreieck. :-(

[exploid]

...

[Krishty]

pd3dImmediateContext->Draw(sizeof( vertices ), 0);

An dieser Stelle gibt es die Anweisung deinen Buffer zu Zeichnen. Du übergibst eine Anzahl von sizeof(vertices) obwohl du
im oberen Buffer nur 4 Vertices angegeben hast. Das versteh ich nicht!

Falsch daran ist, dass nicht die Anzahl der Vertices übergeben wird, sondern die Größe der Vertices (in Bytes). Um die Länge des Arrays anzugeben, sollte es sizeof(vertices) / sizeof(vertices[0]) lauten (Größe eines Arrays / Größe eines Elements = Anzahl der Elemente).

Darf ich fragen was der Unterschied zwischen den Klassen ID3D11Device und ID3D11DeviceContext ist? :)

Ein ::ID3D11Device repräsentiert die GPU, ein ::ID3D11DeviceContext repräsentiert die Befehlsschlange der GPU. Alles, was unter D3D10 im Command-Buffer gelandet ist (Mappen, Rendern, Ressourcen an die Pipeline binden) landet unter D3D11 im entsprechenden Device-Context.

Um mir mehr anzusehen habe ich atm zuwenig Zeit. Gibt der Debug-Output noch spezifische Hinweise?

[Grubenlord]

The device translator uses the DeviceContext class to use the device simulator framework built-in functionality. DeviceContext is a helper class that you can use to manage the device information, tag information, and connection, if it is supported. The use of the DeviceContext class is optional. The BizTalk RFID passes an instance of DeviceContext class as a parameter to the Init method of the device translator

[Grubenlord]

[...]
Um mir mehr anzusehen habe ich atm zuwenig Zeit. Gibt der Debug-Output noch spezifische Hinweise?

Mit Ausnahme der warning kriege ich sonst keinerlei debug Meldungen

[Krishty]

Achso, die Meldung ist noch aktuell? Okay, also hier z.B.:

Code: Alles auswählen

bd.ByteWidth = sizeof( SimpleVertex ) * 3;

Daraus sollte

Code: Alles auswählen

bd.ByteWidth = sizeof(vertices);

werden, denn das gibt ja, wie gesagt, die Größe des Vertex-Arrays in Bytes an.

[Grubenlord]

Ah, ok logisch,
vielen dank!,
jetzt besteht nur noch das Problem mit dem Dreieck zu Viereck

[Krishty]

Wie genau sieht das aus? Du willst ein Viereck, siehst aber nur ein Dreieck?

In dem Fall überprüf nochmal deine Primitive-Topology, ob du D3D auch wirklich mitteilst, dass die Vertices so vorliegen, wie du es möchtest.

[Schrompf]

Als ich mir die Dokumentation angesehen habe hatte ich das auch so verstanden, nur war ich sehr überrascht als ich dann doch ein kleines Dreieck in meinem Fenster hatte. Durch die Fehler hatte ich dann aber auch mal folgendes probiert:

Code: Alles auswählen

struct SimpleVertex
{
    D3DXVECTOR3 Pos;  // Position
	D3DXVECTOR3 Nor;
	D3DXVECTOR2 Tex;
};


SimpleVertex vertices[] =
{
    D3DXVECTOR3( 0.0f, 0.5f, 0.5f ),
    D3DXVECTOR3( 0.0f, 0.0f, -0.5f ),
	D3DXVECTOR2 (0.0f, 0.0f),

    D3DXVECTOR3( 0.5f, -0.5f, 0.5f ),
    D3DXVECTOR3( 0.5f, 0.0f, -0.5f ),
	D3DXVECTOR2 (0.0f, 1.0f),

    D3DXVECTOR3( -0.5f, -0.5f, 0.5f ),
    D3DXVECTOR3( 0.0f, 0.5f, -0.5f ),
	D3DXVECTOR2 (1.0f, 0.0f),

	D3DXVECTOR3( 3.5f, 3.5f, 0.5f ),
    D3DXVECTOR3( 0.0f, 0.0f, -0.5f ),
	D3DXVECTOR2 (1.0f, 0.0f),
};

scheinbar unterliegt mir immernoch irgendwo ein kapitaler Denkfehler

Du übersiehst hier glaube ich, dass C++ von Dir erwartet, die Struktur-Initialisierer zu klammern. So, wie es hier steht, bekämest Du 9 Vertex-Strukturen, bei denen jeweils nur das erste Element gefüllt ist. Versuche es stattdessen mal so:

Code: Alles auswählen

SimpleVertex vertices[] =
{
    {
      D3DXVECTOR3( 0.0f, 0.5f, 0.5f ),
      D3DXVECTOR3( 0.0f, 0.0f, -0.5f ),
      D3DXVECTOR2 (0.0f, 0.0f)
    },

    {
      D3DXVECTOR3( 0.5f, -0.5f, 0.5f ),
      D3DXVECTOR3( 0.5f, 0.0f, -0.5f ),
      D3DXVECTOR2 (0.0f, 1.0f)
    },

    {
      D3DXVECTOR3( -0.5f, -0.5f, 0.5f ),
      D3DXVECTOR3( 0.0f, 0.5f, -0.5f ),
      D3DXVECTOR2 (1.0f, 0.0f)
    },

    {
      D3DXVECTOR3( 3.5f, 3.5f, 0.5f ),
      D3DXVECTOR3( 0.0f, 0.0f, -0.5f ),
      D3DXVECTOR2 (1.0f, 0.0f)
    }
};

[Grubenlord]

Leider gibt das ganz gemeine Syntax Error

TRIANGLELIST sollte mir ja für 4 Vertices zwei Polygone ausgeben, aber tut es leider nicht, sehr merkwürdig

[grid]

Leider gibt das ganz gemeine Syntax Error

TRIANGLELIST sollte mir ja für 4 Vertices zwei Polygone ausgeben, aber tut es leider nicht, sehr merkwürdig

Hallo erstmal,

das stimmt so nicht ganz. Wenn du keinen IndexBuffer hast, dann brauchst du für ein Viereck mit der Topology Trianglelist 6 Vertices. Nur wenn die einen IndexBuffer hast kannst du dir die doppelten Vertices sparen. Du kannst also entweder die Topologie zu Quadlist ändern, einen IndexBuffer erstellen oder weitere Vertices erstellen.

PS: Mein erstes Post im "neuen" ZFX *Jubel*

[Krishty]

@Grubenlord: Lies nochmal den Link zur Primitive-Topology … zwei Dreiecke als Triangle-List brauchen sechs Vertices. Du suchst was, was mit „Triangle“ anfängt und mit „Strip“ endet ;)

[Grubenlord]

hehe,
genau das hatte ich vorhin ausprobiert und es hat wunderbar geklappt, ich bin begeistert. Vielen Dank für die Hilfe

Aber vielleicht doch noch eine weitere Frage, was könnte ich denn jetzt am besten tun wenn ich viele Quadrate haben möchte, alle mit eigener Textur?

[Schrompf]

Falls Du sowas wie Sprites oder GUI-Elemente suchst: Alle Texturen auf eine große Textur packen und den Quadraten die jeweils passenden Texturkoordinaten geben. Danach kannst Du entweder einen dynamischen VertexBuffer mit Vertizes pro Quadrat befüllen oder Du benutzt Geometrie-Shader, Instancing und wasweißichnoch, um den Vertizes anhand von Grafikindex-Arrays im VertexShader oder GeomShader passende Texturkoordinaten zuzuweisen.

[exploid]

...

[Grubenlord]

.... Danach kannst Du entweder einen dynamischen VertexBuffer mit Vertizes pro Quadrat befüllen oder ...

Wie würde ich das denn machen? Alles was ich bisher gesehen habe war nur statisch :?

Kann mir jemand vielleicht erklären wie das mapping auf einen dynamischen buffer funktioniert? Die Doku erklärt das leider nicht.

[Krishty]

Du erzeugst deinen Buffer mit einer ausreichenden Größe. Danach rufst du einmal pro Frame ID3D11DeviceContext::Map() auf diesen Puffer auf, schreibst deine neuen Quad-Daten in pMappedResource->pData und rufs dagnach nochmal ID3D11DeviceContext::Unmap() auf.

Dazu sollte gesagt werden, dass es gerade für Quads hunderte Möglichkeiten gibt, sie zu rendern … je nach Anwendung. Abstrahier das Ganze also am besten schön in einer Klsse, damit du es mal austuschen kannst, falls das nötig wird.