Method CreateFromBytecode

GTE/Graphics/DX11/HLSLProgramFactory.cpp:30–87

}

std::shared_ptr<VisualProgram> HLSLProgramFactory::CreateFromBytecode(
    std::vector<uint8_t> const& vsBytecode,
    std::vector<uint8_t> const& psBytecode,
    std::vector<uint8_t> const& gsBytecode)
{
    LogAssert(vsBytecode.size() > 0 && psBytecode.size() > 0,
        "A program must have a vertex shader and a pixel shader.");

    std::shared_ptr<HLSLShader> vshader;
    std::shared_ptr<HLSLShader> pshader;
    std::shared_ptr<HLSLShader> gshader;

    HLSLReflection hlslVShader = HLSLShaderFactory::CreateFromBytecode("vs",
        vsEntry, std::string("vs_") + version, vsBytecode.size(),
        vsBytecode.data());
    if (hlslVShader.IsValid())
    {
        vshader = std::make_shared<HLSLShader>(hlslVShader, GT_VERTEX_SHADER);
    }
    else
    {
        return nullptr;
    }

    HLSLReflection hlslPShader = HLSLShaderFactory::CreateFromBytecode("ps",
        psEntry, std::string("ps_") + version, psBytecode.size(),
        psBytecode.data());
    if (hlslPShader.IsValid())
    {
        pshader = std::make_shared<HLSLShader>(hlslPShader, GT_PIXEL_SHADER);
    }
    else
    {
        return nullptr;
    }

    HLSLReflection hlslGShader;
    if (gsBytecode.size() > 0)
    {
        hlslGShader = HLSLShaderFactory::CreateFromBytecode("gs",
            gsEntry, std::string("gs_") + version, gsBytecode.size(),
            gsBytecode.data());
        if (hlslGShader.IsValid())
        {
            gshader = std::make_shared<HLSLShader>(hlslGShader, GT_GEOMETRY_SHADER);
        }
        else
        {
            return nullptr;
        }
    }

    auto program = std::make_shared<HLSLVisualProgram>();
    program->SetVertexShader(vshader);
    program->SetPixelShader(pshader);
    program->SetGeometryShader(gshader);
    return program;
}