1. Computer problem? Tech Support Guy is completely free -- paid for by advertisers and donations. Click here to join today! If you're new to Tech Support Guy, we highly recommend that you visit our Guide for New Members.

Visual Studio 2017 char conversion errors with C++ DirectX

Discussion in 'Software Development' started by edjon2000, Aug 5, 2018.

Thread Status:
Not open for further replies.
  1. edjon2000

    edjon2000 Thread Starter

    Joined:
    Jul 16, 2004
    Messages:
    279
    First Name:
    Jon
    Hello again,

    I have been working my way through a DirectX 11 tutorial from http://www.rastertek.com and have run into what I think is a char conversion error I am using Visual Studio 2017 CE and its associated compiler for my C++ programs, in the tutorial they were using Visual Studio 2015 CE and there are some fundamental differences between them, not the least of which is char conversion, as there are a lot of files in this tutorial one tutorial builds on the previous tutorials, I will only show the files that are demonstrating these issues, I am at the point in the tutorials where they introduce colour and pixel shaders (tutorial 04) and ran into this problem here is the code:-

    colorshaderclass.h
    Code:
    //////////////////////////////////////////////////////
    // Filename: colorshaderclass.h
    //////////////////////////////////////////////////////
    #pragma once
    #ifndef _COLORSHADERCLASS_H_
    #define _COLORSHADERCLASS_H_
    
    //////////////
    // INCLUDES
    //////////////
    #include <d3d11.h>
    #include <d3dcompiler.h>
    #include <DirectXMath.h>
    #include <fstream>
    using namespace DirectX;
    using namespace std;
    
    //////////////////////////////////////////////////////
    // Class name: colorshaderclass.h
    //////////////////////////////////////////////////////
    class ColorShaderClass
    {
    private:
        struct MatrixBufferType
        {
            XMMATRIX world;
            XMMATRIX view;
            XMMATRIX projection;
        };
    
    public:
        ColorShaderClass();
        ColorShaderClass(const ColorShaderClass&);
        ~ColorShaderClass();
    
        bool Initialize(ID3D11Device*, HWND);
        void Shutdown();
        bool Render(ID3D11DeviceContext*, int, XMMATRIX, XMMATRIX, XMMATRIX);
    
    private:
        bool InitializeShader(ID3D11Device*, HWND, WCHAR*, WCHAR*);
        void ShutdownShader();
        void OutputShaderErrorMessage(ID3D10Blob*, HWND, WCHAR*);
    
        bool SetShaderParameters(ID3D11DeviceContext*, XMMATRIX, XMMATRIX, XMMATRIX);
        void RenderShader(ID3D11DeviceContext*, int);
    
    private:
        ID3D11VertexShader* m_vertexShader;
        ID3D11PixelShader* m_pixelShader;
        ID3D11InputLayout* m_layout;
        ID3D11Buffer* m_matrixBuffer;
    };
    
    #endif // !_COLORSHADERCLASS_H_
    
    
    colorshaderclass.cpp
    Code:
    //////////////////////////////////////////////////////
    // Filename: colorshaderclass.cpp
    //////////////////////////////////////////////////////
    #include "colorshaderclass.h"
    
    ColorShaderClass::ColorShaderClass()
    {
        m_vertexShader = 0;
        m_pixelShader = 0;
        m_layout = 0;
        m_matrixBuffer = 0;
    }
    
    ColorShaderClass::ColorShaderClass(const ColorShaderClass& other)
    {
    }
    
    ColorShaderClass::~ColorShaderClass()
    {
    }
    
    bool ColorShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
    {
        bool result;
    
        // Initialize the vertex and pixel shaders
        result = InitializeShader(device, hwnd, L"../engine4/color.vs.hlsl", L"../engine4/color.ps.hlsl"); // ERROR APPEARS HERE
        if (!result)
        {
            return false;
        }
    
        return true;
    }
    
    void ColorShaderClass::Shutdown()
    {
        // Shutdown the vertex and pixel shaders as well as the related objects
        ShutdownShader();
    
        return;
    }
    
    bool ColorShaderClass::Render(ID3D11DeviceContext* deviceContext, int indexCount, XMMATRIX worldMatrix,
        XMMATRIX viewMatrix, XMMATRIX projectionMatrix)
    {
        bool result;
        // Set the shader parameters that it will use for rendering
        result = SetShaderParameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix);
        if (!result)
        {
            return false;
        }
    
        // Now render the prepared buffers with the shader
        RenderShader(deviceContext, indexCount);
    
        return true;
    }
    
    bool ColorShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename)
    {
        HRESULT result;
        ID3D10Blob* errorMessage;
        ID3D10Blob* vertexShaderBuffer;
        ID3D10Blob* pixelShaderBuffer;
        D3D11_INPUT_ELEMENT_DESC polygonLayout[2];
        unsigned int numElements;
        D3D11_BUFFER_DESC matrixBufferDesc;
    
        // Initialize the pointers this function will use to null
        errorMessage = 0;
        vertexShaderBuffer = 0;
        pixelShaderBuffer = 0;
    
        // Compile the vertex shader code
        result = D3DCompileFromFile(vsFilename, NULL, NULL, "ColorVertexShader", "vs_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0,
            &vertexShaderBuffer, &errorMessage);
        if (FAILED(result))
        {
            // If the shader failed to compile it should have written something to the error message
            if (errorMessage)
            {
                OutputShaderErrorMessage(errorMessage, hwnd, vsFilename);
            }
            // If there was nothing in the error message then it simply could not find the shader file itself
            else
            {
                MessageBox(hwnd, vsFilename, L"Missing Shader File", MB_OK);
            }
    
            return false;
        }
    
        // Compile the pixel shader code
        result = D3DCompileFromFile(psFilename, NULL, NULL, "ColorPixelShader", "ps_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0,
            &pixelShaderBuffer, &errorMessage);
        if (FAILED(result))
        {
            // If the shader failed to compile it should have writen something to the error message.
            if (errorMessage)
            {
                OutputShaderErrorMessage(errorMessage, hwnd, psFilename);
            }
            // If there was nothing in the error message then it simply could not find the file itself.
            else
            {
                MessageBox(hwnd, psFilename, L"Missing Shader File", MB_OK);
            }
    
            return false;
        }
    
        // Create the vertex shader from the buffer
        result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &m_vertexShader);
        if (FAILED(result))
        {
            return false;
        }
    
        // Create the pixel shader from the buffer
        result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &m_pixelShader);
        if (FAILED(result))
        {
            return false;
        }
    
        // Create the vertex input layout description
        // This setup needs to match the VertexType structure in the ModelClass and in the shader
        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_R32G32B32_FLOAT;
        polygonLayout[1].InputSlot = 0;
        polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
        polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
        polygonLayout[1].InstanceDataStepRate = 0;
    
        // Get a count of the elements in the layout
        numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);
    
        // Create the vertex input layout
        result = device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(),
            vertexShaderBuffer->GetBufferSize(), &m_layout);
        if (FAILED(result))
        {
            return false;
        }
    
        // Release the vertex shader buffer and pixel shader buffer since they are no longer needed
        vertexShaderBuffer->Release();
        vertexShaderBuffer = 0;
    
        pixelShaderBuffer->Release();
        pixelShaderBuffer = 0;
    
        // Setup the description of the dynamic matrix constant buffer that is in the vertex shader
        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;
    
        // Create the constant buffer pointer so we can access the vertex shader constant buffer from within this class
        result = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer);
        if (FAILED(result))
        {
            return false;
        }
    
        return true;
    }
    
    void ColorShaderClass::ShutdownShader()
    {
        // Release the matrix constant buffer
        if (m_matrixBuffer)
        {
            m_matrixBuffer->Release();
            m_matrixBuffer = 0;
        }
    
        // Release the layout
        if (m_layout)
        {
            m_layout->Release();
            m_layout = 0;
        }
    
        // Release the pixel shader
        if (m_pixelShader)
        {
            m_pixelShader->Release();
            m_pixelShader = 0;
        }
    
        // Release the vertex shader
        if (m_vertexShader)
        {
            m_vertexShader->Release();
            m_vertexShader = 0;
        }
    
        return;
    }
    
    void ColorShaderClass::OutputShaderErrorMessage(ID3D10Blob* errorMessage, HWND hwnd, WCHAR* shaderFilename)
    {
        char* compileErrors;
        unsigned long long bufferSize, i;
        ofstream fout;
    
        // Get a pointer to the error message text buffer
        compileErrors = (char*)(errorMessage->GetBufferPointer());
    
        // Get the length of the message
        bufferSize = errorMessage->GetBufferSize();
    
        // Open a file to write the error message to
        fout.open("shader-error.txt");
    
        // Write out the error message
        for (i = 0; i < bufferSize; i++)
        {
            fout << compileErrors[i];
        }
    
        // Close the file
        fout.close();
    
        // Release the error message
        errorMessage->Release();
        errorMessage = 0;
    
        // Pop a message up on the screen to notify the user to check the text file for compile errors
        MessageBox(hwnd, L"Error compiling shader. Check shader-error.txt for message.", shaderFilename, MB_OK);
    
        return;
    }
    
    bool ColorShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContext, XMMATRIX worldMatrix,
        XMMATRIX viewMatrix, XMMATRIX projectionMatrix)
    {
        HRESULT result;
        D3D11_MAPPED_SUBRESOURCE mappedResource;
        MatrixBufferType* dataPtr;
        unsigned int bufferNumber;
    
        // Transpose the matrices to prepare them for the shader (required for DirectX 11)
        worldMatrix = XMMatrixTranspose(worldMatrix);
        viewMatrix = XMMatrixTranspose(viewMatrix);
        projectionMatrix = XMMatrixTranspose(projectionMatrix);
    
        // Lock the constant buffer so it can be written to
        result = deviceContext->Map(m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
        if (FAILED(result))
        {
            return false;
        }
    
        // Get a pointer to the data in the constant buffer
        dataPtr = (MatrixBufferType*)mappedResource.pData;
    
        // Copy the matrices into the constant buffer
        dataPtr->world = worldMatrix;
        dataPtr->view = viewMatrix;
        dataPtr->projection = projectionMatrix;
    
        // Unlock the constant buffer
        deviceContext->Unmap(m_matrixBuffer, 0);
    
        // Set the position of the constant buffer in the vertex shader
        bufferNumber = 0;
    
        // Finally set the constant buffer in the vertex shader with the updated values
        deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_matrixBuffer);
    
        return true;
    }
    
    void ColorShaderClass::RenderShader(ID3D11DeviceContext* deviceContext, int indexCount)
    {
        // Set the vertex input layout
        deviceContext->IASetInputLayout(m_layout);
    
        // Set the vertex and pixel shaders that will be used to render this triangle
        deviceContext->VSSetShader(m_vertexShader, NULL, 0);
        deviceContext->PSSetShader(m_pixelShader, NULL, 0);
    
        // Render the triangle
        deviceContext->DrawIndexed(indexCount, 0, 0);
    
        return;
    }
    
    The error occurs in the
    Code:
    bool ColorShaderClass::Initialize(ID3D11Device* device, HWND hwnd).... 
    function at the point where the location of the shader files are specified e.g.
    Code:
    // Initialize the vertex and pixel shaders
        result = InitializeShader(device, hwnd, L"../engine4/color.vs.hlsl", L"../engine4/color.ps.hlsl"); 
    with the error message argument of type const wchar_t * is incompatible with parameter of type WCHAR *

    I understand that you can virtually change any char type to any other char type using prefixes and for the most part the L prefix tends to work except in this case.

    the intellisense highlights the L prefixes nothing else

    Any help or advice with this would be greatly appreciated
     
    Last edited: Aug 5, 2018
As Seen On
As Seen On...

Welcome to Tech Support Guy!

Are you looking for the solution to your computer problem? Join our site today to ask your question. This site is completely free -- paid for by advertisers and donations.

If you're not already familiar with forums, watch our Welcome Guide to get started.

Join over 733,556 other people just like you!

Loading...
Thread Status:
Not open for further replies.

Short URL to this thread: https://techguy.org/1214035

  1. This site uses cookies to help personalise content, tailor your experience and to keep you logged in if you register.
    By continuing to use this site, you are consenting to our use of cookies.
    Dismiss Notice