public static byte[] CompileHLSL(
ShaderResult shaderResult, string shaderFunction, string shaderProfile,
ref string errorsAndWarnings)
{
try
{
SharpDX.D3DCompiler.ShaderFlags shaderFlags = 0;
// While we never allow preshaders, this flag is invalid for
// the DX11 shader compiler which doesn't allow preshaders
// in the first place.
//shaderFlags |= SharpDX.D3DCompiler.ShaderFlags.NoPreshader;
if (shaderResult.Profile == ShaderProfile.DirectX_11)
{
shaderFlags |= SharpDX.D3DCompiler.ShaderFlags.EnableBackwardsCompatibility;
}
if (shaderResult.Debug)
{
shaderFlags |= SharpDX.D3DCompiler.ShaderFlags.SkipOptimization;
shaderFlags |= SharpDX.D3DCompiler.ShaderFlags.Debug;
}
else
{
shaderFlags |= SharpDX.D3DCompiler.ShaderFlags.OptimizationLevel3;
}
// Compile the shader into bytecode.
var result = SharpDX.D3DCompiler.ShaderBytecode.Compile(
shaderResult.FileContent,
shaderFunction,
shaderProfile,
shaderFlags,
0,
null,
null,
shaderResult.FilePath);
// Store all the errors and warnings to log out later.
errorsAndWarnings += result.Message;
if (result.Bytecode == null)
{
throw new ShaderCompilerException();
}
var shaderByteCode = result.Bytecode;
//var source = shaderByteCode.Disassemble();
// Return a copy of the shader bytecode.
return(shaderByteCode.Data);
}
catch (SharpDX.CompilationException ex)
{
errorsAndWarnings += ex.Message;
throw new ShaderCompilerException();
}
}
/// <summary>
/// Compiles the effect10 from memory.
/// </summary>
/// <param name="dataRef">The data ref.</param>
/// <param name="dataLength">Length of the data.</param>
/// <param name="srcFileNameRef">The SRC file name ref.</param>
/// <param name="definesRef">The defines ref.</param>
/// <param name="includeRef">The include ref.</param>
/// <param name="hlslFlags">The h LSL flags.</param>
/// <param name="fxFlags">The f X flags.</param>
/// <param name="compiledEffectOut">The compiled effect out.</param>
/// <param name="errorsOut">The errors out.</param>
/// <returns>Result code.</returns>
/// <unmanaged>HRESULT D3D10CompileEffectFromMemory([In] void* pData,[In] SIZE_T DataLength,[In] const char* pSrcFileName,[In, Buffer, Optional] const D3D_SHADER_MACRO* pDefines,[In] ID3DInclude* pInclude,[In] D3DCOMPILE_SHADER_FLAGS HLSLFlags,[In] D3DCOMPILE_EFFECT_FLAGS FXFlags,[In] ID3D10Blob** ppCompiledEffect,[In] ID3D10Blob** ppErrors)</unmanaged>
public static SharpDX.Result CompileEffect10FromMemory(
System.IntPtr dataRef,
SharpDX.PointerSize dataLength,
string srcFileNameRef,
SharpDX.Direct3D.ShaderMacro[] definesRef,
System.IntPtr includeRef,
SharpDX.D3DCompiler.ShaderFlags hlslFlags,
SharpDX.D3DCompiler.EffectFlags fxFlags,
out SharpDX.Direct3D.Blob compiledEffectOut,
out SharpDX.Direct3D.Blob errorsOut)
{
unsafe
{
IntPtr srcFileNameRef_ = Marshal.StringToHGlobalAnsi(srcFileNameRef);
SharpDX.Direct3D.ShaderMacro.__Native[] definesRef__ = (definesRef == null)
? null
: new SharpDX.Direct3D.ShaderMacro.__Native[definesRef.Length];
if (definesRef != null)
{
for (int i = 0; i < definesRef.Length; i++)
{
definesRef[i].__MarshalTo(ref definesRef__[i]);
}
}
IntPtr compiledEffectOut_ = IntPtr.Zero;
IntPtr errorsOut_ = IntPtr.Zero;
SharpDX.Result __result__;
fixed(void *definesRef_ = definesRef__)
{
__result__ = SharpDX.D3DCompiler.LocalInterop.CalliFuncint(
(void *)dataRef,
(void *)dataLength,
(void *)srcFileNameRef_,
definesRef_,
(void *)includeRef,
unchecked ((int)hlslFlags),
unchecked ((int)fxFlags),
&compiledEffectOut_,
&errorsOut_,
(void *)D3D10CompileEffectFromMemory_);
}
Marshal.FreeHGlobal(srcFileNameRef_);
if (definesRef != null)
{
for (int i = 0; i < definesRef.Length; i++)
{
definesRef[i].__MarshalFree(ref definesRef__[i]);
}
}
compiledEffectOut = (compiledEffectOut_ == IntPtr.Zero) ? null : new SharpDX.Direct3D.Blob(compiledEffectOut_);
errorsOut = (errorsOut_ == IntPtr.Zero) ? null : new SharpDX.Direct3D.Blob(errorsOut_);
__result__.CheckError();
return(__result__);
}
}
private static byte[] CompileHLSL(ShaderInfo shaderInfo, string shaderFunction, string shaderProfile)
{
SharpDX.D3DCompiler.ShaderBytecode shaderByteCode;
try
{
SharpDX.D3DCompiler.ShaderFlags shaderFlags = 0;
// While we never allow preshaders, this flag is invalid for
// the DX11 shader compiler which doesn't allow preshaders
// in the first place.
//shaderFlags |= SharpDX.D3DCompiler.ShaderFlags.NoPreshader;
if (shaderInfo.Profile == ShaderProfile.DirectX_11)
{
shaderFlags |= SharpDX.D3DCompiler.ShaderFlags.EnableBackwardsCompatibility;
}
if (shaderInfo.Debug)
{
shaderFlags |= SharpDX.D3DCompiler.ShaderFlags.SkipOptimization;
shaderFlags |= SharpDX.D3DCompiler.ShaderFlags.Debug;
}
else
{
shaderFlags |= SharpDX.D3DCompiler.ShaderFlags.OptimizationLevel3;
}
// Compile the shader into bytecode.
var result = SharpDX.D3DCompiler.ShaderBytecode.Compile(
shaderInfo.fileContent,
shaderFunction,
shaderProfile,
shaderFlags,
0,
null,
null,
shaderInfo.fileName);
if (result.HasErrors)
{
throw new Exception(result.Message);
}
shaderByteCode = result.Bytecode;
//var source = shaderByteCode.Disassemble();
}
catch (Exception ex)
{
throw ex;
}
// Return a copy of the shader bytecode.
return(shaderByteCode.Data.ToArray());
}
private static DX11Effect CompileSharpDX(string content, bool isfile, Include include, ShaderMacro[] defines, bool library = false)
{
DX11Effect shader = new DX11Effect();
var profile = library ? "lib_5_0" : "fx_5_0";
SharpDX.D3DCompiler.Include sdxInclude = include != null ? new SharpDXIncludeWrapper(include) : null;
var sdxDefines = defines != null?defines.AsSharpDXMacro() : null;
string errors;
try
{
SharpDX.D3DCompiler.ShaderFlags flags = SharpDX.D3DCompiler.ShaderFlags.OptimizationLevel1;
if (isfile)
{
SharpDX.D3DCompiler.CompilationResult result = SharpDX.D3DCompiler.ShaderBytecode.CompileFromFile(content, profile, flags, SharpDX.D3DCompiler.EffectFlags.None, sdxDefines, sdxInclude);
if (result.Bytecode != null)
{
SlimDX.DataStream ds = new SlimDX.DataStream(result.Bytecode, true, true);
shader.ByteCode = new ShaderBytecode(ds);
shader.Preprocess();
}
errors = result.Message;
}
else
{
//shader.ByteCode = ShaderBytecode.Compile(content, "fx_5_0", flags, EffectFlags.None, defines, include, out errors);
SharpDX.D3DCompiler.CompilationResult result = SharpDX.D3DCompiler.ShaderBytecode.Compile(content, profile, flags, SharpDX.D3DCompiler.EffectFlags.None, sdxDefines, sdxInclude);
if (result.Bytecode != null)
{
SlimDX.DataStream ds = new SlimDX.DataStream(result.Bytecode, true, true);
shader.ByteCode = new ShaderBytecode(ds);
shader.Preprocess();
}
errors = result.Message;
}
//Compilation worked, but we can still have warning
shader.IsCompiled = shader.ByteCode != null;
shader.ErrorMessage = errors;
}
catch (Exception ex)
{
shader.IsCompiled = false;
shader.ErrorMessage = ex.Message;
shader.DefaultEffect = null;
}
return(shader);
}
public static ComputeShader GetComputeShader(SharpDX.Direct3D11.Device _dx11Device, string sourse, SharpDX.Direct3D.ShaderMacro[] defines)
{
SharpDX.D3DCompiler.ShaderFlags shaderFlags = SharpDX.D3DCompiler.ShaderFlags.None;
#if DEBUG
shaderFlags = SharpDX.D3DCompiler.ShaderFlags.Debug;
#endif
using (var horizBC = SharpDX.D3DCompiler.ShaderBytecode.CompileFromFile(sourse,
"CS",
"cs_5_0",
shaderFlags,
SharpDX.D3DCompiler.EffectFlags.None,
defines, null))
return(new ComputeShader(_dx11Device, horizBC));
}
private d3dx_state CreateShader(TwoMGFX.ShaderInfo shaderInfo, string shaderFunction, string shaderProfile, bool isVertexShader)
{
// Compile the shader.
SharpDX.D3DCompiler.ShaderBytecode shaderByteCode;
try
{
SharpDX.D3DCompiler.ShaderFlags shaderFlags = 0;
// While we never allow preshaders, this flag is invalid for
// the DX11 shader compiler which doesn't allow preshaders
// in the first place.
//shaderFlags |= SharpDX.D3DCompiler.ShaderFlags.NoPreshader;
if (shaderInfo.DX11Profile)
{
shaderFlags |= SharpDX.D3DCompiler.ShaderFlags.EnableBackwardsCompatibility;
}
if (shaderInfo.Debug)
{
shaderFlags |= SharpDX.D3DCompiler.ShaderFlags.SkipOptimization;
shaderFlags |= SharpDX.D3DCompiler.ShaderFlags.Debug;
}
else
{
shaderFlags |= SharpDX.D3DCompiler.ShaderFlags.OptimizationLevel3;
}
// Compile the shader into bytecode.
var result = SharpDX.D3DCompiler.ShaderBytecode.Compile(
shaderInfo.fileContent,
shaderFunction,
shaderProfile,
shaderFlags,
0,
null,
null,
shaderInfo.fileName);
if (result.HasErrors)
{
throw new Exception(result.Message);
}
shaderByteCode = result.Bytecode;
//var source = shaderByteCode.Disassemble();
}
catch (Exception ex)
{
throw ex;
}
// Get a copy of the shader bytecode.
var bytecode = shaderByteCode.Data.ToArray();
// First look to see if we already created this same shader.
DXShaderData dxShader = null;
foreach (var shader in Shaders)
{
if (bytecode.SequenceEqual(shader.Bytecode))
{
dxShader = shader;
break;
}
}
// Create a new shader.
if (dxShader == null)
{
if (shaderInfo.DX11Profile)
{
dxShader = DXShaderData.CreateHLSL(bytecode, isVertexShader, ConstantBuffers, Shaders.Count, shaderInfo.Debug);
}
else
{
dxShader = DXShaderData.CreateGLSL(bytecode, ConstantBuffers, Shaders.Count);
}
Shaders.Add(dxShader);
}
//var assmbly = desc.Bytecode.Disassemble();
//var buffer = reflection.GetConstantBuffer(0);
var state = new d3dx_state();
state.index = 0;
state.type = STATE_TYPE.CONSTANT;
state.operation = isVertexShader ? (uint)146 : (uint)147;
state.parameter = new d3dx_parameter();
state.parameter.name = string.Empty;
state.parameter.semantic = string.Empty;
state.parameter.class_ = D3DXPARAMETER_CLASS.OBJECT;
state.parameter.type = isVertexShader ? D3DXPARAMETER_TYPE.VERTEXSHADER : D3DXPARAMETER_TYPE.PIXELSHADER;
state.parameter.rows = 0;
state.parameter.columns = 0;
state.parameter.data = dxShader.SharedIndex;
return(state);
}
