dx11ShaderProgram::dx11ShaderProgram(const char *vshader, const char *pshader,int flags, const ConstantDesc *uniforms, const DataDesc *attributes) { bool fromCode=(flags&ShaderProgram::Flag_FromCode); long VSLen, PSLen; void *VSFile = fromCode?NULL:LoadShaderFile(vshader, "cso", &VSLen); if (!VSFile) { void *src = fromCode?(void *)vshader:LoadShaderFile(vshader, "hlsl", &VSLen); ID3DBlob *pCode; ID3DBlob *pError; if (fromCode&&vshader) VSLen = strlen(vshader); D3DCompile(src, VSLen, vshader, NULL, NULL, "VShader", "vs_4_0_level_9_3", D3DCOMPILE_PREFER_FLOW_CONTROL, 0, &pCode, &pError); if (src&&(!fromCode)) free(src); if (pError) { errorLog.append("VertexShader:\n"); errorLog.append((char *) pError->GetBufferPointer(), pError->GetBufferSize()); errorLog.append("\n"); pError->Release(); } if (pCode) { VSLen = pCode->GetBufferSize(); VSFile = malloc(VSLen); memcpy(VSFile, pCode->GetBufferPointer(), VSLen); pCode->Release(); } } void *PSFile = fromCode?NULL:LoadShaderFile(pshader, "cso", &PSLen); if (!PSFile) { void *src = fromCode?(void *)pshader:LoadShaderFile(pshader, "hlsl", &PSLen); ID3DBlob *pCode; ID3DBlob *pError; if (fromCode&&pshader) PSLen = strlen(pshader); D3DCompile(src, PSLen, pshader, NULL, NULL, "PShader", "ps_4_0_level_9_3", D3DCOMPILE_PREFER_FLOW_CONTROL, 0, &pCode, &pError); if (src&&(!fromCode)) free(src); if (pError) { errorLog.append("PixelShader:\n"); errorLog.append((char *) pError->GetBufferPointer(), pError->GetBufferSize()); errorLog.append("\n"); pError->Release(); } if (pCode) { PSLen = pCode->GetBufferSize(); PSFile = malloc(PSLen); memcpy(PSFile, pCode->GetBufferPointer(), PSLen); pCode->Release(); } } buildShaderProgram(VSFile, VSLen, PSFile, PSLen, flags, uniforms, attributes); if (VSFile) free(VSFile); if (PSFile) free(PSFile); }
void overlay::init_shaders() { auto device = d3d_device::instance()->raw(); com_ptr<ID3DBlob> vs_blob, ps_blob; const string & vs_code = vertex_shader_code(); const string & ps_code = pixel_shader_code(); HRESULT result = D3DCompile(vs_code.c_str(), vs_code.size(), nullptr, nullptr, nullptr, "vs", "vs_5_0", 0, 0, &vs_blob, nullptr); if (FAILED(result)) throw std::runtime_error("Error compiling vertex shader"); result = D3DCompile(ps_code.c_str(), ps_code.size(), nullptr, nullptr, nullptr, "ps", "ps_5_0", 0, 0, &ps_blob, nullptr); if (FAILED(result)) throw std::runtime_error("Error compiling pixel shader"); D3D11_INPUT_ELEMENT_DESC input_desc[] = { { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 }, { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 } }; device->CreateInputLayout(input_desc, 2, vs_blob->GetBufferPointer(), vs_blob->GetBufferSize(), &input_layout); device->CreateVertexShader(vs_blob->GetBufferPointer(), vs_blob->GetBufferSize(), nullptr, &vertex_shader); device->CreatePixelShader(ps_blob->GetBufferPointer(), ps_blob->GetBufferSize(), nullptr, &pixel_shader); }
bool Ivy::Graphics::DXShader::Compile(std::string filename, ShaderType type) { unsigned int flags = D3DCOMPILE_ENABLE_STRICTNESS | D3DCOMPILE_PACK_MATRIX_COLUMN_MAJOR; #if defined(DEBUG) || defined(_DEBUG) // MakeActive the D3DCOMPILE_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. flags |= D3DCOMPILE_DEBUG; // Disable optimizations to further improve shader debugging flags |= D3DCOMPILE_SKIP_OPTIMIZATION; #endif D3D_FEATURE_LEVEL featureLevel = device->GetID3D11Device()->GetFeatureLevel(); ComPtr<ID3DBlob> l_pErrorBlob = nullptr; HRESULT hr = D3DCompileFromFile(Core::Utility::StringToWString(filename).c_str(), nullptr, D3D_COMPILE_STANDARD_FILE_INCLUDE, "main", GetCompilerTarget(featureLevel, type).c_str(), flags, 0, const_cast<ID3DBlob**>(GetShaderBlob(type).GetAddressOf()), l_pErrorBlob.GetAddressOf()); if (FAILED(hr)) { // Notify of shader error if one exists. if(l_pErrorBlob.Get() != nullptr) std::cout << reinterpret_cast<const char*>(l_pErrorBlob->GetBufferPointer()) << std::endl; // Use error shader in the event of failure. if (type == ShaderType::Pixel) { std::cout << "Trying prefab Pixel Shader..." << std::endl; std::cout << Ivy::ShaderPrefab::HLSLErrorPixelShader << std::endl; hr = D3DCompile(Ivy::ShaderPrefab::HLSLErrorPixelShader.c_str(), Ivy::ShaderPrefab::HLSLErrorPixelShader.size(), nullptr, nullptr, D3D_COMPILE_STANDARD_FILE_INCLUDE, "main", GetCompilerTarget(featureLevel, type).c_str(), flags, 0, const_cast<ID3DBlob**>(GetShaderBlob(type).GetAddressOf()), l_pErrorBlob.GetAddressOf()); if (FAILED(hr)) return false; } else { std::cout << "Trying prefab Vertex Shader..." << std::endl; std::cout << Ivy::ShaderPrefab::HLSLErrorVertexShader << std::endl; hr = D3DCompile(Ivy::ShaderPrefab::HLSLErrorVertexShader.c_str(), Ivy::ShaderPrefab::HLSLErrorVertexShader.size(), nullptr, nullptr, D3D_COMPILE_STANDARD_FILE_INCLUDE, "main", GetCompilerTarget(featureLevel, type).c_str(), flags, 0, const_cast<ID3DBlob**>(GetShaderBlob(type).GetAddressOf()), l_pErrorBlob.GetAddressOf()); if (FAILED(hr)) return false; } std::cout << "Prefab shader was compiled successfully..." << std::endl; return true; } std::cout << "Shader " << filename << " was compiled successfully..." << std::endl; return true; }
bool ReloadShader( char * szShaderCode, int nShaderCodeSize, char * szErrorBuffer, int nErrorBufferSize ) { ID3DBlob * pCode = NULL; ID3DBlob * pErrors = NULL; if (D3DCompile( szShaderCode, nShaderCodeSize, NULL, NULL, NULL, "main", "ps_4_0", NULL, NULL, &pCode, &pErrors ) != S_OK) { memset( szErrorBuffer, 0, nErrorBufferSize ); strncpy( szErrorBuffer, (char*)pErrors->GetBufferPointer(), nErrorBufferSize - 1 ); return false; } if (theShader) { theShader->Release(); theShader = NULL; } if (pDevice->CreatePixelShader( pCode->GetBufferPointer(), pCode->GetBufferSize(), NULL, &theShader ) != S_OK) { return false; } D3DReflect( pCode->GetBufferPointer(), pCode->GetBufferSize(), IID_ID3D11ShaderReflection, (void**)&pShaderReflection ); pCBuf = pShaderReflection->GetConstantBufferByIndex(0); return true; }
ID3DBlob* D3DApp::GenerateShader(const std::string& filename, const std::string& function, const std::string& model, const D3D_SHADER_MACRO* pDefines) { HRESULT hr = S_OK; ID3DBlob* pCompiledShader = nullptr; ID3DBlob* pErrorMessages = nullptr; UINT flags = D3DCOMPILE_PACK_MATRIX_ROW_MAJOR; #ifdef _DEBUG flags |= D3DCOMPILE_DEBUG | D3DCOMPILE_SKIP_OPTIMIZATION; // | D3DCOMPILE_WARNINGS_ARE_ERRORS; #endif std::ifstream shaderFile(filename); std::string hlslCode((std::istreambuf_iterator<char>(shaderFile)), std::istreambuf_iterator<char>()); HR(D3DCompile( hlslCode.c_str(), hlslCode.size(), nullptr, pDefines, nullptr, function.c_str(), model.c_str(), flags, 0, &pCompiledShader, &pErrorMessages)); ReleaseCOM(pErrorMessages); return(pCompiledShader); }
bool CompileShader(void *p_pData, uint32 p_nSize, const char *p_sFuncName, const char *p_sProfile, ID3DBlob **p_ppBlob) { ID3DBlob *pErrorBlob = NULL; DWORD dwShaderFlags = D3DCOMPILE_ENABLE_STRICTNESS; #ifdef SAM_DEBUG dwShaderFlags |= D3DCOMPILE_DEBUG; #endif HRESULT hResult = D3DCompile(p_pData, p_nSize, NULL, NULL, NULL, p_sFuncName, p_sProfile, dwShaderFlags, 0, p_ppBlob, &pErrorBlob); if(hResult != S_OK) { if(pErrorBlob != NULL) { g_Env->pRenderWindow->LogError(hResult, (char*)pErrorBlob->GetBufferPointer()); pErrorBlob->Release(); } else { g_Env->pRenderWindow->LogError(hResult, "Unable to compile shader"); } return false; } return true; }
inline HRESULT D3DCompileFromFile( LPCWSTR pFileName, const D3D_SHADER_MACRO *pDefines, ID3DInclude *pInclude, LPCSTR pEntrypoint, LPCSTR pTarget, UINT Flags1, UINT Flags2, ID3DBlob **ppCode, ID3DBlob **ppErrorMsgs ) { std::ifstream ifs(pFileName, std::ios::binary); if(!ifs){ return E_FAIL; } ifs.seekg (0, std::ios::end); std::vector<unsigned char> buffer(static_cast<unsigned int>(ifs.tellg ())); ifs.seekg (0, std::ios::beg); if(buffer.empty()){ return E_FAIL; } ifs.read ((char*)&buffer[0], buffer.size()); return D3DCompile(&buffer[0], buffer.size(), to_MultiByte(932, pFileName).c_str() , pDefines , pInclude , pEntrypoint , pTarget , Flags1 , Flags2 , ppCode , ppErrorMsgs); }
bool ShaderCompiler::compile(const String& fileName, const String& entryPoint, const String& target, DataBlob& byteCode) { DataBlob buffer; if (!readRawBlob(fileName, buffer)) return false; UINT flags = D3DCOMPILE_WARNINGS_ARE_ERRORS | D3DCOMPILE_PACK_MATRIX_ROW_MAJOR; #if defined (_DEBUG) flags |= (D3DCOMPILE_DEBUG | D3DCOMPILE_SKIP_OPTIMIZATION); #else flags |= D3DCOMPILE_OPTIMIZATION_LEVEL3; #endif // _DEBUG IncludeHandler includeHandler; ID3DBlob* shaderByteCode = 0; ID3DBlob* errorMsgs = 0; if (FAILED(D3DCompile(buffer.getPtr(), buffer.getSize(), NULL, NULL, &includeHandler, entryPoint.c_str(), target.c_str(), flags, 0, &shaderByteCode, &errorMsgs))) { // parse error message const char* msg = (const char*)errorMsgs->GetBufferPointer(); MessageBox(NULL, msg, "Error", MB_OK); if (errorMsgs) errorMsgs->Release(); } else { byteCode.allocate(shaderByteCode->GetBufferSize()); memcpy(byteCode.getPtr(), shaderByteCode->GetBufferPointer(), shaderByteCode->GetBufferSize()); shaderByteCode->Release(); } return true; }
CPixelBufferView::PixelShaderPtr CPixelBufferView::CreatePixelShaderFromResource(const TCHAR* resourceName) { HRESULT result = S_OK; auto shaderResourceInfo = FindResource(GetModuleHandle(nullptr), resourceName, _T("TEXTFILE")); assert(shaderResourceInfo != nullptr); auto shaderResourceHandle = LoadResource(GetModuleHandle(nullptr), shaderResourceInfo); auto shaderResourceSize = SizeofResource(GetModuleHandle(nullptr), shaderResourceInfo); auto shaderResource = reinterpret_cast<const char*>(LockResource(shaderResourceHandle)); UINT compileFlags = 0; #ifdef _DEBUG compileFlags |= D3DCOMPILE_DEBUG; #endif Framework::Win32::CComPtr<ID3DBlob> shaderBinary; Framework::Win32::CComPtr<ID3DBlob> compileErrors; result = D3DCompile(shaderResource, shaderResourceSize, "ps", nullptr, nullptr, "main", "ps_3_0", compileFlags, 0, &shaderBinary, &compileErrors); assert(SUCCEEDED(result)); PixelShaderPtr shader; result = m_device->CreatePixelShader(reinterpret_cast<DWORD*>(shaderBinary->GetBufferPointer()), &shader); assert(SUCCEEDED(result)); return shader; }
static ID3DBlob* CompileShader(const char* src, const char* entryPoint, const char* target) { HRESULT hr; ID3DBlob* pCode = NULL; ID3DBlob* pErrorMsgs = NULL; UINT flags = D3DCOMPILE_ENABLE_STRICTNESS; #if _DEBUG flags |= D3DCOMPILE_DEBUG; #endif hr = D3DCompile(src, strlen(src), NULL, NULL, NULL, entryPoint, target, flags, 0, &pCode, &pErrorMsgs); if (pErrorMsgs != NULL) { OutputDebugStringA((LPCSTR)pErrorMsgs->GetBufferPointer()); pErrorMsgs->Release(); pErrorMsgs = NULL; } if (FAILED(hr)) { SafeRelease(pCode); throw std::exception("Failed to compile HLSL shader"); } return pCode; }
HRESULT ShaderBase::loadFromSource( const std::string &source, const std::string &entryPoint ) { //load shader source unsigned int flags = D3DCOMPILE_PACK_MATRIX_COLUMN_MAJOR | D3DCOMPILE_WARNINGS_ARE_ERRORS; #ifdef _DEBUG flags |= D3DCOMPILE_DEBUG | D3DCOMPILE_OPTIMIZATION_LEVEL0; #else flags |= D3DCOMPILE_OPTIMIZATION_LEVEL3; #endif ID3DBlob *shaderSource; ID3DBlob *compileErrors; HRESULT res = D3DCompile( source.c_str(), sizeof( source ), NULL, NULL, NULL, entryPoint.c_str(), m_target.c_str(), flags, 0u, &shaderSource, &compileErrors ); if ( FAILED(res) ) { //TODO: parse compile errors std::cout << "Error (ShaderBase::loadFromSource): Error loading shader source " << std::endl; return res; } if ( FAILED( processLoadedShaderBlob( shaderSource ) ) ) { std::cout << "Error (ShaderBase::loadFromSource): Error processing shader source " << std::endl; shaderSource->Release(); return res; } shaderSource->Release(); return S_OK; }
ID3DBlob* ShaderCompile(char * shaderName, const char * shaderSrcString, const char * profile) { ID3DBlob* pShaderCode = NULL; ID3DBlob* pErrorMsg = NULL; if (FAILED(D3DCompile(shaderSrcString, strlen(shaderSrcString),NULL,NULL,NULL, "main",profile,D3DCOMPILE_OPTIMIZATION_LEVEL3,0, &pShaderCode,&pErrorMsg))) MessageBoxA(NULL,(char *) pErrorMsg->GetBufferPointer(),"", MB_OK); if (pErrorMsg) pErrorMsg->Release(); //Now write out blob char tempString[1000]; int numDWORDs = ((int)pShaderCode->GetBufferSize())/4; DWORD * ptr = (DWORD *)pShaderCode->GetBufferPointer(); sprintf_s(tempString,"DWORD %s[%d] = {",shaderName,numDWORDs); OutputDebugStringA(tempString); for (int i = 0; i < numDWORDs; i++) { sprintf_s(tempString,"%lu,",ptr[i]); OutputDebugStringA(tempString); } OutputDebugStringA("};\n"); return(pShaderCode); }
com_ptr<ID3DBlob> compile_shader(const std::string& source_code, const std::string& source_filename, uint32_t compile_flags, const char* p_entry_point_name, const char* p_shader_model) { com_ptr<ID3DBlob> p_bytecode; com_ptr<ID3DBlob> p_error_blob; const char* p_filename = (source_filename.empty()) ? nullptr : source_filename.c_str(); HRESULT hr = D3DCompile( source_code.c_str(), source_code.size(), p_filename, nullptr, // defines D3D_COMPILE_STANDARD_FILE_INCLUDE, // includes p_entry_point_name, p_shader_model, compile_flags, 0, // effect compilation flags &p_bytecode.ptr, &p_error_blob.ptr ); if (hr != S_OK) { std::string error(static_cast<char*>(p_error_blob->GetBufferPointer()), p_error_blob->GetBufferSize()); throw std::runtime_error(error); } return p_bytecode; }
static ID3DBlob * _CompileShader(std::string const &target, std::string const &entry, std::string const &shaderSource) { DWORD dwShaderFlags = D3DCOMPILE_ENABLE_STRICTNESS; #ifdef _DEBUG dwShaderFlags |= D3DCOMPILE_DEBUG; #endif ID3DBlob* pBlob = NULL; ID3DBlob* pBlobError = NULL; HRESULT hr = D3DCompile(shaderSource.c_str(), shaderSource.size(), NULL, NULL, NULL, entry.c_str(), target.c_str(), dwShaderFlags, 0, &pBlob, &pBlobError); if (FAILED(hr)) { if ( pBlobError != NULL ) { OpenSubdiv::Far::Error(OpenSubdiv::Far::FAR_RUNTIME_ERROR, "Error compiling HLSL shader: %s\n", (CHAR*)pBlobError->GetBufferPointer()); pBlobError->Release(); return NULL; } } return pBlob; }
HRESULT WINAPI D3D10CompileShader(const char *data, SIZE_T data_size, const char *filename, const D3D10_SHADER_MACRO *defines, ID3D10Include *include, const char *entrypoint, const char *profile, UINT flags, ID3D10Blob **shader, ID3D10Blob **error_messages) { /* Forward to d3dcompiler */ return D3DCompile(data, data_size, filename, defines, include, entrypoint, profile, flags, 0, shader, error_messages); }
void Shader::Compile(const std::string &code, SHADER_TYPE st) { HRESULT hr; ComPtr<ID3DBlob> errorBlob; switch (st) { case SHADER_TYPE::SHADER_TYPE_VERTEX: hr = D3DCompile(code.c_str(), code.size(), "VertexProgram.hlsl", nullptr, nullptr, "main", "vs_5_0", 0, 0, &bytecode, errorBlob.GetAddressOf()); if (hr != S_OK) LOG_ERROR(RSX, "VS build failed:%s", errorBlob->GetBufferPointer()); break; case SHADER_TYPE::SHADER_TYPE_FRAGMENT: hr = D3DCompile(code.c_str(), code.size(), "FragmentProgram.hlsl", nullptr, nullptr, "main", "ps_5_0", 0, 0, &bytecode, errorBlob.GetAddressOf()); if (hr != S_OK) LOG_ERROR(RSX, "FS build failed:%s", errorBlob->GetBufferPointer()); break; } }
void DxBuilder::buildPixelShader(const ASTEffect& effect, ASTTechnique& technique) { const ASTFunction* pfunction = effect.findFunction(technique.mPixel.mEntry); String code = UTEXT("// generated pixel shader\n\n"); String num; NumberConverter& conv = NumberConverter::getInstance(); for ( std::size_t index = 0; index < effect.mTextures.size(); ++index ) { ASTTexture* ptexture = effect.mTextures[index]; code += UTEXT("Texture2D ") + ptexture->mName + UTEXT(" : register(t"); int reg = ptexture->mRegister; if ( reg == -1 ) { reg = (int) index; } code += conv.format(num, reg) + UTEXT(");\n"); num = UTEXT(""); } for ( std::size_t index = 0; index < effect.mSamplers.size(); ++index ) { ASTSampler* psampler = effect.mSamplers[index]; code += UTEXT("SamplerState ") + psampler->mName + UTEXT(" : register(s"); int reg = psampler->mRegister; if ( reg == -1 ) { reg = index; } code += conv.format(num, (int)reg) + UTEXT(");\n"); num = UTEXT(""); } code += buildStructs(effect, *pfunction); code += buildFunction(*pfunction); std::string data = code.toUtf8(); std::string entry = technique.mPixel.mEntry.toUtf8(); std::string target = technique.mPixel.mTarget.toUtf8(); uint32_t flags = D3DCOMPILE_ENABLE_STRICTNESS; ID3DBlob *presult, *perror; HRESULT hr = D3DCompile(data.c_str(), data.length(), NULL, NULL, D3D_COMPILE_STANDARD_FILE_INCLUDE, entry.c_str(), target.c_str(), flags, 0, &presult, &perror); if ( FAILED(hr) ) { std::string d3derror = "Shader compile error: " + std::string((const char*)perror->GetBufferPointer()); throw std::exception(d3derror.c_str()); } technique.mPixel.mCompiledCode.writeBlob(presult->GetBufferPointer(), presult->GetBufferSize()); }
bool Cef3DDirect3D12Renderer::CompileShader(ShaderType type, unsigned flags, const char* entryPoint, const std::string& source, ID3D10Blob** outBlob) { ID3DBlob* errorMsgs = 0; HRESULT hr = D3DCompile(source.c_str(), source.length(), "", 0, 0, entryPoint, type == Vertex ? "vs_5_0" : "ps_5_0", flags, 0, outBlob, &errorMsgs); if (FAILED(hr)) return false; return true; }
void compile(const std::string &entry, const std::string &target) { if (_src.empty()) return; if (entry != _entry || target != _target) _dirty = true; if (!_dirty) return; _bin = nullptr; _msg = nullptr; _hr = D3DCompile(&_src[0], _src.size(), nullptr, _defs, _inc, entry.c_str(), target.c_str(), _flags1, _flags2, &_bin, &_msg); _dirty = false; }
HRESULT WINAPI D3D10CompileEffectFromMemory(void *data, SIZE_T data_size, const char *filename, const D3D10_SHADER_MACRO *defines, ID3D10Include *include, UINT hlsl_flags, UINT fx_flags, ID3D10Blob **effect, ID3D10Blob **errors) { TRACE("data %p, data_size %lu, filename %s, defines %p, include %p, " "hlsl_flags %#x, fx_flags %#x, effect %p, errors %p.\n", data, data_size, wine_dbgstr_a(filename), defines, include, hlsl_flags, fx_flags, effect, errors); return D3DCompile(data, data_size, filename, defines, include, NULL, "fx_4_0", hlsl_flags, fx_flags, effect, errors); }
//-------------------------------------------------------------------------------------- // Helper function to compile an hlsl shader from file, // its binary compiled code is returned //-------------------------------------------------------------------------------------- HRESULT D3D11Object::CompileShaderFromFile( WCHAR* szFileName, LPCSTR szEntryPoint, LPCSTR szShaderModel, ID3DBlob** ppBlobOut ) { HRESULT hr = S_OK; // find the file //WCHAR str[MAX_PATH]; //V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, szFileName ) ); WCHAR *str = szFileName; // open the file //"createFile" creates or opens the file HANDLE hFile = CreateFile( szFileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, NULL ); if( INVALID_HANDLE_VALUE == hFile ) return E_FAIL; // Get the file size LARGE_INTEGER FileSize; GetFileSizeEx( hFile, &FileSize ); // create enough space for the file data BYTE* pFileData = new BYTE[ FileSize.LowPart ]; if( !pFileData ) return E_OUTOFMEMORY; // read the data in DWORD BytesRead; if( !ReadFile( hFile, pFileData, FileSize.LowPart, &BytesRead, NULL ) ) return E_FAIL; CloseHandle( hFile ); // Compile the shader char pFilePathName[MAX_PATH]; WideCharToMultiByte(CP_ACP, 0, str, -1, pFilePathName, MAX_PATH, NULL, NULL); ID3DBlob* pErrorBlob; hr = D3DCompile( pFileData, FileSize.LowPart, pFilePathName, NULL, NULL, szEntryPoint, szShaderModel, D3D10_SHADER_ENABLE_STRICTNESS, 0, ppBlobOut, &pErrorBlob ); delete []pFileData; if( FAILED(hr) ) { printf( (char*)pErrorBlob->GetBufferPointer() ); SAFE_RELEASE( pErrorBlob ); return hr; } SAFE_RELEASE( pErrorBlob ); return S_OK; }
HRESULT CompileShader( const char* Source, LPCSTR strFunctionName, const D3D_SHADER_MACRO* pDefines, IShaderSourceInputStreamFactory *pIncludeStreamFactory, LPCSTR profile, ID3DBlob **ppBlobOut ) { DWORD dwShaderFlags = D3DCOMPILE_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 |= D3DCOMPILE_DEBUG; #else // Warning: do not use this flag as it causes shader compiler to fail the compilation and // report strange errors: // dwShaderFlags |= D3D10_SHADER_OPTIMIZATION_LEVEL3; #endif HRESULT hr; do { CComPtr<ID3DBlob> errors; auto SourceLen = strlen(Source); D3DIncludeImpl IncludeImpl(pIncludeStreamFactory); hr = D3DCompile( Source, SourceLen, NULL, pDefines, &IncludeImpl, strFunctionName, profile, dwShaderFlags, 0, ppBlobOut, &errors ); if( FAILED(hr) || errors ) { std::wstringstream errorss; ComErrorDesc ErrDesc(hr); if( FAILED(hr) ) Diligent::FormatMsg( errorss, "Failed to compile shader\n" ); else Diligent::FormatMsg( errorss, "Shader compiler output:\n" ); Diligent::FormatMsg( errorss, ErrDesc.Get(), "\n" ); if( errors ) Diligent::FormatMsg( errorss, (char*)errors->GetBufferPointer() ); auto ErrorDesc = errorss.str(); OutputDebugStringW( ErrorDesc.c_str() ); if( FAILED(hr) #ifdef PLATFORM_WIN32 && IDRETRY != MessageBoxW( NULL, ErrorDesc.c_str() , L"FX Error", MB_ICONERROR | (Source == nullptr ? MB_ABORTRETRYIGNORE : 0) ) #endif ) { break; } } } while( FAILED(hr) ); return hr; }
Impl<Shader, RendererType::DX>::Impl(DXRenderer* renderer, Shader* shader) { auto& source = shader->bunch->getSourceText(ShaderBunch::BlobType::Hlsl); auto entryPoint = shader->entryPoint.c_str(); auto target = shader->type == ShaderType::Vertex ? "vs_5_0" : "ps_5_0"; UINT compileFlags = 0; auto result = D3DCompile(source.data(), source.size(), entryPoint, nullptr, nullptr, entryPoint, target, compileFlags, 0, &blob, nullptr); if (FAILED(result)) throw; }
void setupShaders(ID3D11Device* device, ID3D11DeviceContext* context) { // load and compile the two shaders const char* shaders = "#define ATTRIBUTES 5\n" "struct Foo { float4 v[ATTRIBUTES]; };" "float4 VS(uint index: SV_VertexId, out Foo foo: FOO): SV_Position { uint i = index % 3; [unroll] for (int j = 0; j < ATTRIBUTES; j++) foo.v[j] = j; return float4(i != 0, i != 2, 0, 1); }" "float4 PS(Foo foo: FOO): SV_Target { float4 result = 0; [unroll] for (int j = 0; j < ATTRIBUTES; j++) result += foo.v[j]; return result; }"; ID3DBlob* vsblob = 0; ID3DBlob* psblob = 0; D3DCompile(shaders, strlen(shaders), 0, 0, 0, "VS", "vs_5_0", 0, 0, &vsblob, 0); D3DCompile(shaders, strlen(shaders), 0, 0, 0, "PS", "ps_5_0", 0, 0, &psblob, 0); ID3D11VertexShader* vs = 0; ID3D11PixelShader* ps = 0; device->CreateVertexShader(vsblob->GetBufferPointer(), vsblob->GetBufferSize(), 0, &vs); device->CreatePixelShader(psblob->GetBufferPointer(), psblob->GetBufferSize(), 0, &ps); context->VSSetShader(vs, 0, 0); context->PSSetShader(ps, 0, 0); }
void Shader::Compile(const std::string &code, SHADER_TYPE st) { HRESULT hr; ComPtr<ID3DBlob> errorBlob; UINT compileFlags; if (rpcs3::config.rsx.d3d12.debug_output.value()) compileFlags = D3DCOMPILE_DEBUG | D3DCOMPILE_SKIP_OPTIMIZATION; else compileFlags = 0; switch (st) { case SHADER_TYPE::SHADER_TYPE_VERTEX: hr = D3DCompile(code.c_str(), code.size(), "VertexProgram.hlsl", nullptr, nullptr, "main", "vs_5_0", compileFlags, 0, &bytecode, errorBlob.GetAddressOf()); if (hr != S_OK) LOG_ERROR(RSX, "VS build failed:%s", errorBlob->GetBufferPointer()); break; case SHADER_TYPE::SHADER_TYPE_FRAGMENT: hr = D3DCompile(code.c_str(), code.size(), "FragmentProgram.hlsl", nullptr, nullptr, "main", "ps_5_0", compileFlags, 0, &bytecode, errorBlob.GetAddressOf()); if (hr != S_OK) LOG_ERROR(RSX, "FS build failed:%s", errorBlob->GetBufferPointer()); break; } }
void ShaderCompiler::compileProgram(IO* io, const ProgramDesc& programDesc, std::weak_ptr<DX12DeviceContext> context) { auto fmt = boost::format("Compiling program \"%1%\"") % programDesc.name; LOGS_INDENT_START << boost::str(fmt); Program prog; for (auto shaderDesc : programDesc.shaders) { auto fmt = boost::format("Path: %1%, Type: %2%, Entry: %3%") % shaderDesc.path % shaderDesc.type % shaderDesc.main; LOGS << boost::str(fmt); auto buffer = io->loadFile(shaderDesc.path); ID3DBlob* shaderBlob = nullptr; ID3DBlob* errorBlob = nullptr; auto hr = D3DCompile(buffer.c_str(), buffer.size(), shaderDesc.path.c_str(), nullptr, D3D_COMPILE_STANDARD_FILE_INCLUDE, shaderDesc.main.c_str(), getDXShaderType(shaderDesc.type).c_str(), shaderDesc.flags, 0, &shaderBlob, &errorBlob); if (FAILED(hr)) { if (errorBlob != nullptr) { LOGE << "Compilation failed" << std::endl << static_cast<char*>(errorBlob->GetBufferPointer()); errorBlob->Release(); } if (shaderBlob != nullptr) shaderBlob->Release(); fmt = boost::format("Shader compilation failed: %1%") % shaderDesc.path; throw new std::runtime_error(boost::str(fmt)); } D3D12_SHADER_BYTECODE bc; bc.BytecodeLength = shaderBlob->GetBufferSize(); bc.pShaderBytecode = shaderBlob->GetBufferPointer(); if (shaderDesc.type == "vs") prog.vs = bc; else if (shaderDesc.type == "ps") prog.ps = bc; getShaderResources(shaderBlob, context); } LOGS_INDENT_END << "Program done."; }
// see https://msdn.microsoft.com/en-us/library/windows/desktop/dd607324(v=vs.85).aspx bool D3D12Shader::CompileSource(const ShaderDescriptor& shaderDesc) { /* Get source code */ std::string fileContent; const char* sourceCode = nullptr; SIZE_T sourceLength = 0; if (shaderDesc.sourceType == ShaderSourceType::CodeFile) { fileContent = ReadFileString(shaderDesc.source); sourceCode = fileContent.c_str(); sourceLength = fileContent.size(); } else { sourceCode = shaderDesc.source; sourceLength = shaderDesc.sourceSize; } /* Get parameter from union */ const char* entry = shaderDesc.entryPoint; const char* target = (shaderDesc.profile != nullptr ? shaderDesc.profile : ""); auto flags = shaderDesc.flags; /* Compile shader code */ ComPtr<ID3DBlob> code; auto hr = D3DCompile( sourceCode, sourceLength, nullptr, // LPCSTR pSourceName nullptr, // D3D_SHADER_MACRO* pDefines nullptr, // ID3DInclude* pInclude entry, // LPCSTR pEntrypoint target, // LPCSTR pTarget DXGetCompilerFlags(flags), // UINT Flags1 0, // UINT Flags2 (recommended to always be 0) code.ReleaseAndGetAddressOf(), // ID3DBlob** ppCode errors_.ReleaseAndGetAddressOf() // ID3DBlob** ppErrorMsgs ); /* Get byte code from blob */ if (code) byteCode_ = DXGetBlobData(code.Get()); /* Store if compilation was successful */ return !FAILED(hr); }
HRESULT WINAPI D3DX11CompileFromMemory(const char *data, SIZE_T data_size, const char *filename, const D3D10_SHADER_MACRO *defines, ID3D10Include *include, const char *entry_point, const char *target, UINT sflags, UINT eflags, ID3DX11ThreadPump *pump, ID3D10Blob **shader, ID3D10Blob **error_messages, HRESULT *hresult) { TRACE("data %s, data_size %lu, filename %s, defines %p, include %p, entry_point %s, target %s, " "sflags %#x, eflags %#x, pump %p, shader %p, error_messages %p, hresult %p.\n", debugstr_a(data), data_size, debugstr_a(filename), defines, include, debugstr_a(entry_point), debugstr_a(target), sflags, eflags, pump, shader, error_messages, hresult); if (pump) FIXME("Unimplemented ID3DX11ThreadPump handling.\n"); return D3DCompile(data, data_size, filename, defines, include, entry_point, target, sflags, eflags, shader, error_messages); }
static ID3DBlobPtr CompileShader(const char* shaderCode, size_t shaderLength, const char* shaderProfile) { ID3DBlobPtr blob = nullptr; ID3DBlobPtr errors = nullptr; HRESULT hr = D3DCompile(shaderCode, shaderLength, nullptr, nullptr, nullptr, "Main", shaderProfile, 0, 0, &blob, &errors); if (FAILED(hr)) { if (errors) { OutputDebugStringA((char*)errors->GetBufferPointer()); errors->Release(); } return nullptr; } return blob; }
HRESULT ShaderCompilerClass::compileString(MutableString&& str , const char* entryPoint, const char* shaderTarget, ID3DBlob** output) { HRESULT hr; DWORD dwShaderFlags = D3DCOMPILE_ENABLE_STRICTNESS | D3DCOMPILE_OPTIMIZATION_LEVEL3; #if defined( DEBUG ) || defined( _DEBUG ) // Set the D3DCOMPILE_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 |= D3DCOMPILE_DEBUG; #endif ID3DBlob* errorMsg = nullptr; ID3DBlob* compiled = nullptr; std::string shaderstr = str.getMultiByteString(); std::cout << shaderstr << std::endl; hr = D3DCompile(shaderstr.c_str(), shaderstr.length(), nullptr, nullptr, D3D_COMPILE_STANDARD_FILE_INCLUDE, entryPoint, shaderTarget, dwShaderFlags, 0, output, &errorMsg); if (errorMsg != nullptr) { char* errorText = new char[errorMsg->GetBufferSize()]; memcpy(errorText, errorMsg->GetBufferPointer(), errorMsg->GetBufferSize()); MessageBoxA(NULL,errorText,"Shader Error",MB_OK); errorMsg->Release(); return E_FAIL; } if (FAILED(hr)) { return hr; } return S_OK; }