0

I'm fairly new to Directx, so I have next to no idea what's going on here.

I have confirmed that the initial setup and activation of the window and DirectX API has been successful. However, although the drawing and update functions seem to be fully operational, they still aren't successful at displaying output. I've checked over the linker, my object classes, my effects file, and basically the entire project a dozen times over. Please help!

Cube.h

#pragma once
#pragma comment(lib,"d3d11.lib")

#include <d3d11.h>
#include <d3dcompiler.h>
#include <DirectXMath.h>
#include <string>
#include <WICTextureLoader.h>
#include <d3d11_2.h>
#include <vector>
using namespace DirectX;

struct Vertex {
    XMFLOAT3 pos;
    XMFLOAT2 texCoord;
    XMFLOAT3 normal;
};

using namespace DirectX;
class Cube
{
private:
    Vertex vertices[24];
    XMMATRIX RotX, RotZ, RotY,trans;
    double scale;
    XMFLOAT3 loc;
    DWORD indices[36];
    ID3D11DeviceContext* d3dDevCon;
    ID3D11Device*d3dDev;
    ID3D11ShaderResourceView*CubeTexture;
    XMMATRIX cubeWorld;

public:
    Cube();
    Cube(double,double,double, double, XMFLOAT3,ID3D11DeviceContext*,ID3D11Device*,std::string );
    ~Cube();
    Vertex* getVertices();
    void Rotate(double,double,double);
    void Move(double,double,double); 
    void Draw();
    void Update();
    XMMATRIX getWorld();
    DWORD* getIndices();
    ID3D11ShaderResourceView*getCubeTexture();

};

Cube.cpp

#include "stdafx.h"
#include "Cube.h"

using namespace DirectX;

Cube::Cube()
{
    RotX = XMMatrixRotationAxis(XMVectorSet(1.0, 0.0, 0.0, 0.0), 0);
    RotY = XMMatrixRotationAxis(XMVectorSet(0.0, 1.0, 0.0, 0.0), 0);
    RotZ = XMMatrixRotationAxis(XMVectorSet(0.0, 0.0, 1.0, 0.0), 0);
    scale = 1;
    loc = XMFLOAT3(0.0, 0.0, 0.0);

    Vertex v[] = 
    { //remember that structs do not have constructors unless defined!
            // Front Face
            { { -1.0f, -1.0f, -1.0f },{ 0.0f, 1.0f },{ -1.0f, -1.0f, -1.0f } },
            { { -1.0f,  1.0f, -1.0f },{ 0.0f, 0.0f },{ -1.0f,  1.0f, -1.0f } },
            { { 1.0f,  1.0f, -1.0f },{ 1.0f, 0.0f } ,{ 1.0f,  1.0f, -1.0f } },
            { { 1.0f, -1.0f, -1.0f },{ 1.0f, 1.0f } ,{ 1.0f, -1.0f, -1.0f } },

            // Back Face
            { { -1.0f, -1.0f, 1.0f },{ 1.0f, 1.0f } ,{ -1.0f, -1.0f, 1.0f } },
            { { 1.0f, -1.0f, 1.0f },{ 0.0f, 1.0f } ,{ 1.0f, -1.0f, 1.0f } },
            { { 1.0f,  1.0f, 1.0f },{ 0.0f, 0.0f } ,{ 1.0f,  1.0f, 1.0f } },
            { { -1.0f,  1.0f, 1.0f },{ 1.0f, 0.0f },{ -1.0f,  1.0f, 1.0f } },

            // Top Face
            { { -1.0f, 1.0f, -1.0f },{ 1.0f, 1.0f },{ -1.0f, 1.0f, -1.0f } },
            { { -1.0f, 1.0f,  1.0f },{ 0.0f, 1.0f },{ -1.0f, 1.0f,  1.0f } },
            { { 1.0f, 1.0f,  1.0f },{ 0.0f, 0.0f },{ 1.0f, 1.0f,  1.0f } },
            { { 1.0f, 1.0f, -1.0f },{ 1.0f, 0.0f },{ 1.0f, 1.0f, -1.0f } },

            // Bottom Face
            { { -1.0f, -1.0f, -1.0f },{ 1.0f, 1.0f },{ -1.0f, -1.0f, -1.0f } },
            { { 1.0f, -1.0f, -1.0f },{ 0.0f, 1.0f },{ 1.0f, -1.0f, -1.0f } },
            { { 1.0f, -1.0f,  1.0f },{ 0.0f, 0.0f },{ 1.0f, -1.0f,  1.0f } },
            { { -1.0f, -1.0f,  1.0f },{ 1.0f, 0.0f },{ -1.0f, -1.0f,  1.0f } },

            // Left Face
            { { -1.0f, -1.0f,  1.0f },{ 0.0f, 1.0f },{ -1.0f, -1.0f,  1.0f } },
            { { -1.0f,  1.0f,  1.0f },{ 0.0f, 0.0f },{ -1.0f,  1.0f,  1.0f } },
            { { -1.0f,  1.0f, -1.0f },{ 1.0f, 0.0f },{ -1.0f,  1.0f, -1.0f } },
            { { -1.0f, -1.0f, -1.0f },{ 1.0f, 1.0f },{ -1.0f, -1.0f, -1.0f } },

            // Right Face
            { { 1.0f, -1.0f, -1.0f },{ 0.0f, 1.0f },{ 1.0f, -1.0f, -1.0f } },
            { { 1.0f,  1.0f, -1.0f },{ 0.0f, 0.0f },{ 1.0f,  1.0f, -1.0f } },
            { { 1.0f,  1.0f,  1.0f },{ 1.0f, 0.0f },{ 1.0f,  1.0f,  1.0f } },
            { { 1.0f, -1.0f,  1.0f },{ 1.0f, 1.0f },{ 1.0f, -1.0f,  1.0f } }

    };
    for (int i = 0; i < 24; i++) {
        vertices[i] = v[i];
    }
    DWORD ind[] = {
        // 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
    };
    for (int s = 0; s < 36; s++) {
        indices[s] = ind[s];
    }
}

Cube::Cube(double rotx,double roty,double rotz, double scale, XMFLOAT3 loc,ID3D11DeviceContext*devcon, ID3D11Device*dev,std::string name ) {
    RotX = XMMatrixRotationAxis(XMVectorSet(1.0, 0.0, 0.0, 0.0), rotx);
    RotY = XMMatrixRotationAxis(XMVectorSet(0.0, 1.0, 0.0, 0.0), roty);
    RotZ = XMMatrixRotationAxis(XMVectorSet(0.0, 0.0, 1.0, 0.0), rotz); 
    this->scale = scale;
    this->loc = loc;

    d3dDevCon = devcon;
    d3dDev = dev;

    CreateWICTextureFromFile(d3dDev, L"gray.jpg", NULL, &CubeTexture, 0);
    Vertex v[] =
    { //remember that structs do not have constructors unless defined!
      // Front Face
        { { -1.0f, -1.0f, -1.0f },{ 0.0f, 1.0f },{ -1.0f, -1.0f, -1.0f } },
        { { -1.0f,  1.0f, -1.0f },{ 0.0f, 0.0f },{ -1.0f,  1.0f, -1.0f } },
        { { 1.0f,  1.0f, -1.0f },{ 1.0f, 0.0f } ,{ 1.0f,  1.0f, -1.0f } },
        { { 1.0f, -1.0f, -1.0f },{ 1.0f, 1.0f } ,{ 1.0f, -1.0f, -1.0f } },

        // Back Face
        { { -1.0f, -1.0f, 1.0f },{ 1.0f, 1.0f } ,{ -1.0f, -1.0f, 1.0f } },
        { { 1.0f, -1.0f, 1.0f },{ 0.0f, 1.0f } ,{ 1.0f, -1.0f, 1.0f } },
        { { 1.0f,  1.0f, 1.0f },{ 0.0f, 0.0f } ,{ 1.0f,  1.0f, 1.0f } },
        { { -1.0f,  1.0f, 1.0f },{ 1.0f, 0.0f },{ -1.0f,  1.0f, 1.0f } },

        // Top Face
        { { -1.0f, 1.0f, -1.0f },{ 1.0f, 1.0f },{ -1.0f, 1.0f, -1.0f } },
        { { -1.0f, 1.0f,  1.0f },{ 0.0f, 1.0f },{ -1.0f, 1.0f,  1.0f } },
        { { 1.0f, 1.0f,  1.0f },{ 0.0f, 0.0f },{ 1.0f, 1.0f,  1.0f } },
        { { 1.0f, 1.0f, -1.0f },{ 1.0f, 0.0f },{ 1.0f, 1.0f, -1.0f } },

        // Bottom Face
        { { -1.0f, -1.0f, -1.0f },{ 1.0f, 1.0f },{ -1.0f, -1.0f, -1.0f } },
        { { 1.0f, -1.0f, -1.0f },{ 0.0f, 1.0f },{ 1.0f, -1.0f, -1.0f } },
        { { 1.0f, -1.0f,  1.0f },{ 0.0f, 0.0f },{ 1.0f, -1.0f,  1.0f } },
        { { -1.0f, -1.0f,  1.0f },{ 1.0f, 0.0f },{ -1.0f, -1.0f,  1.0f } },

        // Left Face
        { { -1.0f, -1.0f,  1.0f },{ 0.0f, 1.0f },{ -1.0f, -1.0f,  1.0f } },
        { { -1.0f,  1.0f,  1.0f },{ 0.0f, 0.0f },{ -1.0f,  1.0f,  1.0f } },
        { { -1.0f,  1.0f, -1.0f },{ 1.0f, 0.0f },{ -1.0f,  1.0f, -1.0f } },
        { { -1.0f, -1.0f, -1.0f },{ 1.0f, 1.0f },{ -1.0f, -1.0f, -1.0f } },

        // Right Face
        { { 1.0f, -1.0f, -1.0f },{ 0.0f, 1.0f },{ 1.0f, -1.0f, -1.0f } },
        { { 1.0f,  1.0f, -1.0f },{ 0.0f, 0.0f },{ 1.0f,  1.0f, -1.0f } },
        { { 1.0f,  1.0f,  1.0f },{ 1.0f, 0.0f },{ 1.0f,  1.0f,  1.0f } },
        { { 1.0f, -1.0f,  1.0f },{ 1.0f, 1.0f },{ 1.0f, -1.0f,  1.0f } }

    };
    for (int i = 0; i < 24; i++) {
        vertices[i] = v[i];
    }
    DWORD ind[] = {
        // 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
    };
    for (int s = 0; s < 36; s++) {
        indices[s] = ind[s];
    }
}   
Cube::~Cube()
{
}

void Cube::Rotate(double rotx, double roty, double rotz) {
    RotX = XMMatrixRotationAxis(XMVectorSet(1.0, 0.0, 0.0, 0.0), rotx);
    RotY = XMMatrixRotationAxis(XMVectorSet(0.0, 1.0, 0.0, 0.0), roty);
    RotZ = XMMatrixRotationAxis(XMVectorSet(0.0, 0.0, 1.0, 0.0), rotz);
}

void Cube::Move(double x,double y, double z) {
    trans = XMMatrixTranslation(x, y, z);
}

void Cube::Update() {
    cubeWorld = XMMatrixIdentity();
    cubeWorld = trans*RotX*RotY*RotZ;
}

void Cube::Draw() {
    return;
}

XMMATRIX Cube::getWorld() {
    return cubeWorld;
}

Vertex* Cube::getVertices() {
    return vertices;
}

DWORD* Cube::getIndices() {
    return indices;
}

ID3D11ShaderResourceView* Cube::getCubeTexture() {
    return CubeTexture;
}

headers

#pragma comment(lib,"D3D11.lib")
#pragma comment(lib,"d3dcompiler.lib")
#pragma comment(lib,"DXGI.lib")
#pragma comment(lib,"dwrite.lib")
#pragma comment(lib,"dinput8.lib")
#pragma comment(lib,"dxguid.lib")

#include "stdafx.h"
#include "Cube.h"
#include "D3DIndependentExperimentation.h"
#include <d3d11.h>
#include <d3dcompiler.h>
#include <DirectXMath.h>
#include <dinput.h>
#include <vector>
#include <iostream>
#include <d3dcompiler.h>

DrawScene()

void DrawScene(std::vector<Cube> cubelist) { // performs actual rendering
                   //clear backbuffer
    float bgColor[4] = { 0.0, 0.0, 0.0, 0.0f };

    d3d11DevCon->ClearRenderTargetView(renderTargetView, bgColor);
    //clear depth stencil
    d3d11DevCon->ClearDepthStencilView(depthStencilView, D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 1.0, 0.0);
    //set default blend state(no blending)
    d3d11DevCon->OMSetBlendState(0, 0, 0xffffff);
    World = XMMatrixIdentity();
    d3d11DevCon->PSSetConstantBuffers(0, 1, &cbPerFrameBuffer);
    d3d11DevCon->VSSetShader(VS, 0, 0);
    d3d11DevCon->PSSetShader(PS, 0, 0);
    constBufferPerFrame.light = light;
    d3d11DevCon->UpdateSubresource(cbPerFrameBuffer, 0, NULL, &constBufferPerFrame, 0, 0);



    d3d11DevCon->OMSetRenderTargets(1, &renderTargetView, depthStencilView);

    d3d11DevCon->IASetIndexBuffer(IndexBuffer, DXGI_FORMAT_R32_UINT, 0);
    //set buffer data
    UINT stride = sizeof(Vertex);//size of each Vertex
    UINT offset = 0;// how far from the buffer beginning we start
    d3d11DevCon->IASetVertexBuffers(0, 1, &VertexBuffer, &stride, &offset);
    //TODO: everything
    XMMATRIX cubeWorld = XMMatrixIdentity();
    for (int i = 0; i < cubelist.size(); i++) {
        Cube active = cubelist.at(i);
        cubeWorld = active.getWorld();
        WVP = cubeWorld*camView*camProjection;
        cbPerObj.WVP = XMMatrixTranspose(WVP);
        cbPerObj.World = XMMatrixTranspose(cubeWorld);
        d3d11DevCon->UpdateSubresource(cbPerObjectBuffer, 0, NULL, &cbPerObj, 0, 0);

        d3d11DevCon->VSSetConstantBuffers(0, 1, &cbPerObjectBuffer);
        ID3D11ShaderResourceView* temp = active.getCubeTexture();
        d3d11DevCon->PSSetShaderResources(0, 1, &temp);

        d3d11DevCon->PSSetSamplers(0, 1, &CubesTexSamplerState);
        d3d11DevCon->RSSetState(NOcullMode);
        d3d11DevCon->DrawIndexed(36, 36 * i, 24 * i);
    }

    SwapChain->Present(0, 0);
}

InitScene()

bool InitScene(std::vector<Cube> cubelist) {
    HRESULT hr;
    //Compiling Shaders
    hr = D3DCompileFromFile(L"effects.fx", 0, 0, "VS", "vs_5_0", 0, 0, &VS_Buffer, 0);
    hr = D3DCompileFromFile(L"effects.fx", 0, 0, "PS", "ps_5_0", 0, 0, &PS_Buffer, 0);
    //Creating Shaders
    hr = d3d11Device->CreateVertexShader(VS_Buffer->GetBufferPointer(), VS_Buffer->GetBufferSize(), NULL, &VS);
    hr = d3d11Device->CreatePixelShader(PS_Buffer->GetBufferPointer(), PS_Buffer->GetBufferSize(), NULL, &PS);
    //Setting Shaders
    d3d11DevCon->VSSetShader(VS, NULL, NULL);
    d3d11DevCon->PSSetShader(PS, NULL, NULL);

    //Creating and populating Vertex Buffers
    //Buffer description
    D3D11_BUFFER_DESC vertexBufferDesc;
    ZeroMemory(&vertexBufferDesc, sizeof(vertexBufferDesc));

    vertexBufferDesc.Usage = D3D11_USAGE_DEFAULT; //describes how buffer is used
    vertexBufferDesc.ByteWidth = sizeof(Vertex)*cubelist.size() *24; // specifies the size of buffer; dependent on amount of vertices passed and size of vertices
    vertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;//Specifies that this is a vertex buffer
    vertexBufferDesc.CPUAccessFlags = 0;
    vertexBufferDesc.MiscFlags = 0;

    //Specifies what kind of data is placed in buffer
    D3D11_SUBRESOURCE_DATA vertexBufferData;
    ZeroMemory(&vertexBufferData, sizeof(vertexBufferData));
    std::vector<Vertex> cubeVertices;
    for (int i = 0; i < cubelist.size(); i++) {
        Vertex *point = cubelist.at(i).getVertices();
        cubeVertices.insert(cubeVertices.end(), point, point + 24);
    }

    vertexBufferData.pSysMem = &cubeVertices;
    hr = d3d11Device->CreateBuffer(&vertexBufferDesc, &vertexBufferData, &VertexBuffer);

    //Buffer description is mostly the same as vertex buffer
    D3D11_BUFFER_DESC indexBufferDesc;
    ZeroMemory(&indexBufferDesc, sizeof(indexBufferDesc));

    indexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
    indexBufferDesc.ByteWidth = sizeof(DWORD) * 36*cubelist.size();
    indexBufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER;
    vertexBufferDesc.CPUAccessFlags = 0;
    indexBufferDesc.MiscFlags = 0;
    std::vector<short> cubeIndices;
    D3D11_SUBRESOURCE_DATA indexBufferData;
    ZeroMemory(&indexBufferData, sizeof(indexBufferData));

    for (int i = 0; i < cubelist.size(); i++) {
        DWORD*point = cubelist.at(i).getIndices();
        cubeIndices.insert(cubeIndices.end(), point, point + 36);
    }
    indexBufferData.pSysMem = &cubeIndices;
    d3d11Device->CreateBuffer(&indexBufferDesc, &indexBufferData, &IndexBuffer);

    //set input layout
    hr = d3d11Device->CreateInputLayout(layout, NUMELEMENTS, VS_Buffer->GetBufferPointer(), VS_Buffer->GetBufferSize(), &vertLayout);
    d3d11DevCon->IASetInputLayout(vertLayout);

    d3d11DevCon->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
    //Create and set viewport
    D3D11_VIEWPORT viewport;
    ZeroMemory(&viewport, sizeof(D3D11_VIEWPORT));
    viewport.TopLeftX = 0;
    viewport.TopLeftY = 0;
    viewport.Width = SCREENWIDTH;
    viewport.Height = SCREENHEIGHT;
    viewport.MinDepth = 0.0;
    viewport.MaxDepth = 1.0;

    d3d11DevCon->RSSetViewports(1, &viewport);


    D3D11_BUFFER_DESC constantBufferDesc;
    ZeroMemory(&constantBufferDesc, sizeof(D3D11_BUFFER_DESC));

    constantBufferDesc.Usage = D3D11_USAGE_DEFAULT;
    constantBufferDesc.ByteWidth = sizeof(cbPerObject);
    constantBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
    constantBufferDesc.CPUAccessFlags = 0;
    constantBufferDesc.MiscFlags = 0;

    hr = d3d11Device->CreateBuffer(&constantBufferDesc, NULL, &cbPerObjectBuffer);

    ZeroMemory(&constantBufferDesc, sizeof(D3D11_BUFFER_DESC));

    constantBufferDesc.Usage = D3D11_USAGE_DEFAULT;
    constantBufferDesc.ByteWidth = sizeof(cbPerFrame);
    constantBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
    constantBufferDesc.CPUAccessFlags = 0;
    constantBufferDesc.MiscFlags = 0;

    hr = d3d11Device->CreateBuffer(&constantBufferDesc, NULL, &cbPerFrameBuffer);

    camPosition = XMVectorSet(0.0f, 5.0f, -10.0f, 0.0f);
    camTarget = XMVectorSet(0.0f, 0.0f, 0.0f, 0.0f);
    camUp = XMVectorSet(0.0f, 1.0f, 0.0f, 0.0f);

    camView = XMMatrixLookAtLH(camPosition, camTarget, camUp);

    camProjection = XMMatrixPerspectiveFovLH(0.4f*3.14f, (float)SCREENWIDTH / SCREENHEIGHT, 1.0f, 1000.0f);

    //Describe and create rasterizer state
    D3D11_RASTERIZER_DESC wfdesc;
    ZeroMemory(&wfdesc, sizeof(D3D11_RASTERIZER_DESC));
    wfdesc.FillMode = D3D11_FILL_SOLID; 
    wfdesc.CullMode = D3D11_CULL_NONE;
    hr = d3d11Device->CreateRasterizerState(&wfdesc, &FULL);

    //hr = CreateWICTextureFromFile(d3d11Device, L"gray.jpg", NULL, &CubeTexture, 0);
    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;

    hr = d3d11Device->CreateSamplerState(&sampDesc, &CubesTexSamplerState);

    //describe and create blend state
    /*D3D11_BLEND_DESC blendDesc;
    ZeroMemory(&blendDesc, sizeof(blendDesc));

    D3D11_RENDER_TARGET_BLEND_DESC rtbd;
    ZeroMemory(&rtbd, sizeof(rtbd));

    rtbd.BlendEnable = true;
    rtbd.SrcBlend = D3D11_BLEND_SRC_COLOR;
    rtbd.DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
    rtbd.BlendOp = D3D11_BLEND_OP_ADD;
    rtbd.SrcBlendAlpha = D3D11_BLEND_ONE;
    rtbd.DestBlendAlpha = D3D11_BLEND_ZERO;
    rtbd.BlendOpAlpha = D3D11_BLEND_OP_ADD;
    rtbd.RenderTargetWriteMask = D3D10_COLOR_WRITE_ENABLE_ALL;

    blendDesc.AlphaToCoverageEnable = false;
    blendDesc.RenderTarget[0] = rtbd;

    //d3d11Device->CreateBlendState(&blendDesc, &Transparency);*/

    //define rasterizer states for blending
    D3D11_RASTERIZER_DESC cmdesc;
    ZeroMemory(&cmdesc, sizeof(D3D11_RASTERIZER_DESC));

    cmdesc.CullMode = D3D11_CULL_BACK;
    cmdesc.FillMode = D3D11_FILL_SOLID;

    cmdesc.FrontCounterClockwise = true;
    hr = d3d11Device->CreateRasterizerState(&cmdesc, &CCWcullMode);

    cmdesc.FrontCounterClockwise = false;
    hr = d3d11Device->CreateRasterizerState(&cmdesc, &CWcullMode);

    cmdesc.CullMode = D3D11_CULL_NONE;

    hr = d3d11Device->CreateRasterizerState(&cmdesc, &NOcullMode);

    //light setting
    //light.dir = XMFLOAT3(1.0f, 0.0f, 0.0f);
    light.ambient = XMFLOAT4(0.3f, 0.3f, 0.3f, 1.0f);
    light.diffuse = XMFLOAT4(1.0f, 1.0f, 1.0f, 1.0f);
    light.pos = XMFLOAT3(2.0f, 4.0f, 0.0f);
    light.range = 250.0f;
    light.att = XMFLOAT3(0.0f, 0.2f, 0.0f);

    return true;
}

effects.fx

cbuffer cbPerObject {
    float4x4 WVP;
    float4x4 World;
};
//note: keep structure of structs in fx files same as those in c++ code.
struct Light {
    float3 dir;
    float3 att;
    float3 pos;
    float range;
    float4 ambient;
    float4 diffuse;
};

cbuffer cbPerFrame {
    Light light;
};

struct VS_OUTPUT
{
    float4 Pos : SV_POSITION;
    float2 texCoord : TEXCOORD;
    float3 normal: NORMAL;
    float4 worldPos: POSITION;
};
Texture2D ObjTexture;
SamplerState ObjSamplerState;

VS_OUTPUT VS(float4 inPos: POSITION, float2 texCoord : TEXCOORD, float3 normal : NORMAL) {
    VS_OUTPUT output;
    output.texCoord = texCoord;
    output.Pos = mul(inPos, WVP);
    output.worldPos = mul(inPos, World);
    output.normal = mul(normal, World);
    return output;
}


float4 PS(VS_OUTPUT input) : SV_TARGET{
    input.normal = normalize(input.normal);

float4 diffuse = ObjTexture.Sample(ObjSamplerState, input.texCoord);
float3 finalColor = float3(0.0, 0.0, 0.0);
float3 lightToPixelVec = light.pos - input.worldPos;
float d = length(lightToPixelVec);


float3 finalAmbient = diffuse*light.ambient;
if (d > light.range) {
    return float4(finalAmbient, diffuse.a);
}
lightToPixelVec /= d;
float Intensity = dot(lightToPixelVec, input.normal)*20;
if (Intensity > 0.0f) {
    finalColor += Intensity*diffuse*light.diffuse;
    finalColor /= light.att[0] + (light.att[1] * d) + (light.att[2] * (d*d));
}
finalColor = saturate(finalColor + finalAmbient);

return float4(1.0, 1.0, 1.0, 1.0);//float4(finalColor,diffuse.a);

}

float4 D2D_PS(VS_OUTPUT input) : SV_TARGET
{ input.normal = normalize(input.normal);
float4 diffuse = ObjTexture.Sample(ObjSamplerState, input.texCoord);

return diffuse;
}

If any more information is needed, I'm ready to oblige.

Edward Wang
  • 1
  • Debugging graphics applications is a challenging and complex task. Any number of steps can result in 'blank screen'. Enable Direct3D device bugging. Get a minimal device and swap chain running. Then add stuff one step at a time and test each time. – Chuck Walbourn Apr 13 '18 at 22:59
  • 1
    Some resources to start with: [this blog post](https://blogs.msdn.microsoft.com/chuckw/2014/02/05/anatomy-of-direct3d-11-create-device/), [Direct3D Game templates](https://github.com/walbourn/directx-vs-templates/wiki), [DeviceResources](https://github.com/Microsoft/DirectXTK/wiki/DeviceResources) implementation, and the [DirectX Tool Kit for DirectX 11 tutorials](https://github.com/Microsoft/DirectXTK/wiki/Getting-Started). – Chuck Walbourn Apr 13 '18 at 23:01

1 Answers1

1

Reviewing your code and comparing it to the code I've written in the past for DirectX 11 rendering, you are missing at least one thing - a Depth/Stencil State. I'm not certain what the GPU will do if you decide to use a depth/stencil buffer without it, but it looks to be the only difference between the calls your system makes (which doesn't work) and the calls my system makes (which does).

You can create a depth/stencil state with ID3D11Device::CreateDepthStencilState, and set it to the pipeline with ID3D11DeviceContext::OMSetDepthStencilState. This function works the same as ID3D11DeviceContext::OMSetBlendState, in that passing nullptr, NULL or 0 as the state object will bind a default state.

Alex
  • 1,794
  • 9
  • 20