protected override void Initialize(DeviceChild view)
{
// The initialize method will override the view.Tag, so we are setting it back
base.Initialize(view);
IsRenderView = view is RenderTargetView;
var shaderResourceView = view as ShaderResourceView;
int mipLevel = 0;
if (shaderResourceView != null)
{
var description = shaderResourceView.Description;
mipLevel = description.Texture1D.MostDetailedMip;
}
else
{
var renderTargetView = view as RenderTargetView;
if (renderTargetView == null)
{
throw new ArgumentException("Expecting argument to be a ShaderResourceView or RenderTargetView", "view");
}
mipLevel = renderTargetView.Description.Texture1D.MipSlice;
}
Size = new Size2(Math.Max(1, Texture.Width >> mipLevel), Math.Max(1, Texture.Height >> mipLevel));
TexelSize = new Size2F
{
Width = 1.0f / Size.Width,
Height = 1.0f / Size.Height
};
}
public static unsafe void SetDebugName(this DeviceChild child, string debugName)
{
byte[] debugNameBytes = Encoding.ASCII.GetBytes(debugName);
fixed(byte *debugNameBytesPtr = debugNameBytes)
child.SetPrivateData(CommonGuid.DebugObjectName, debugNameBytes.Length, new IntPtr(debugNameBytesPtr));
}
protected override void CompileInternal(ShaderStage shaderStage, string filePath, VertexType vertexType)
{
var macros = Macros.Select(macro => new ShaderMacro(macro.Key, macro.Value)).ToArray();
using var includeHandler = new IncludeHandler(null);
_shaderBytecode = LoadBytecode(shaderStage, filePath, includeHandler, macros);
if (shaderStage == ShaderStage.Vertex && vertexType != VertexType.Unknown)
{
InputLayout = _graphicsFactory.CreateInputLayout(vertexType, _shaderBytecode);
}
switch (shaderStage)
{
case ShaderStage.Vertex:
_shaderObject = new VertexShader(_graphicsDevice, _shaderBytecode);
break;
case ShaderStage.Pixel:
_shaderObject = new PixelShader(_graphicsDevice, _shaderBytecode);
break;
case ShaderStage.Compute:
_shaderObject = new ComputeShader(_graphicsDevice, _shaderBytecode);
break;
default:
throw new ArgumentOutOfRangeException(nameof(shaderStage), shaderStage, null);
}
}
/// <summary>
/// Initializes the specified device local.
/// </summary>
/// <param name="resource">The resource.</param>
protected virtual void Initialize(DeviceChild resource)
{
Resource = ToDispose(resource);
if (resource != null)
{
resource.Tag = this;
}
}
protected override void Dispose(bool disposeManagedResources)
{
base.Dispose(disposeManagedResources);
if (disposeManagedResources)
{
Resource = null;
}
}
public static int GetID(DeviceChild deviceChild)
{
if (deviceChild == null)
{
return(-1);
}
return(deviceChild.ID);
}
protected override void CompileStringInternal(ShaderStage shaderStage, string shaderText, VertexType vertexType)
{
var macros = Macros.Select(macro => new ShaderMacro(macro.Key, macro.Value)).ToArray();
using var includeHandler = new IncludeHandler(null);
_shaderBytecode = CreateBytecode(shaderStage, shaderText, includeHandler, macros);
_shaderObject = CreateShader(shaderStage, vertexType);
}
internal TextureView(Texture texture, DeviceChild view) : base(texture.GraphicsDevice)
{
if (view == null)
{
throw new ArgumentNullException("view");
}
Texture = texture;
Description = texture.Description;
Initialize(view);
}
protected override void Initialize(DeviceChild view)
{
// The initialize method will override the view.Tag, so we are setting it back
base.Initialize(view);
var shaderResourceView = view as ShaderResourceView;
int mipLevel = 0;
bool isMultisampled = Texture.Description.SampleDescription.Count > 1;
if (shaderResourceView != null)
{
mipLevel = isMultisampled ? 0 : shaderResourceView.Description.Texture1D.MostDetailedMip;
}
else
{
var renderTargetView = view as RenderTargetView;
if (renderTargetView != null)
{
IsRenderView = true;
mipLevel = isMultisampled ? 0 : renderTargetView.Description.Texture1D.MipSlice;
}
else
{
var depthStencilView = view as DepthStencilView;
if (depthStencilView != null)
{
IsDepthStencilView = true;
mipLevel = isMultisampled ? 0 : depthStencilView.Description.Texture1D.MipSlice;
}
else
{
throw new ArgumentException("Expecting argument to be a ShaderResourceView, RenderTargetView or DepthStencilView", "view");
}
}
}
Size = new Size2(Math.Max(1, Texture.Width >> mipLevel), Math.Max(1, Texture.Height >> mipLevel));
TexelSize = new Size2F
{
Width = 1.0f / Size.Width,
Height = 1.0f / Size.Height
};
}
protected override void Initialize(DeviceChild resource)
{
base.Initialize(resource);
this.InitializeViews();
}
internal DeviceChild GetOrCompileShader(EffectShaderType shaderType, int index, int soRasterizedStream, StreamOutputElement[] soElements, out string profileError)
{
DeviceChild shader = null;
profileError = null;
lock (sync)
{
shader = compiledShadersGroup[(int)shaderType][index];
if (shader == null)
{
if (RegisteredShaders[index].Level > graphicsDevice.Features.Level)
{
profileError = string.Format("{0}", RegisteredShaders[index].Level);
return(null);
}
var bytecodeRaw = RegisteredShaders[index].Bytecode;
switch (shaderType)
{
case EffectShaderType.Vertex:
shader = new VertexShader(graphicsDevice, bytecodeRaw);
break;
case EffectShaderType.Domain:
shader = new DomainShader(graphicsDevice, bytecodeRaw);
break;
case EffectShaderType.Hull:
shader = new HullShader(graphicsDevice, bytecodeRaw);
break;
case EffectShaderType.Geometry:
if (soElements != null)
{
// Calculate the strides
var soStrides = new List <int>();
foreach (var streamOutputElement in soElements)
{
for (int i = soStrides.Count; i < (streamOutputElement.Stream + 1); i++)
{
soStrides.Add(0);
}
soStrides[streamOutputElement.Stream] += streamOutputElement.ComponentCount * sizeof(float);
}
shader = new GeometryShader(graphicsDevice, bytecodeRaw, soElements, soStrides.ToArray(), soRasterizedStream);
}
else
{
shader = new GeometryShader(graphicsDevice, bytecodeRaw);
}
break;
case EffectShaderType.Pixel:
shader = new PixelShader(graphicsDevice, bytecodeRaw);
break;
case EffectShaderType.Compute:
shader = new ComputeShader(graphicsDevice, bytecodeRaw);
break;
}
compiledShadersGroup[(int)shaderType][index] = ToDispose(shader);
}
}
return(shader);
}
public static int GetID(DeviceChild deviceChild)
{
if (deviceChild == null)
return -1;
return deviceChild.ID;
}
public GraphicsObjectViewModel(DeviceChild deviceChild)
{
_deviceChild = deviceChild;
}
private void PlatformConstruct(
GraphicsDevice graphicsDevice,
string functionName,
byte[] deviceBytecode,
out ShaderType shaderType,
out ShaderResourceBinding[] resourceBindings)
{
DeviceBytecode = deviceBytecode;
using (var shaderBytecode = new ShaderBytecode(DeviceBytecode))
{
switch (shaderBytecode.GetVersion().Version)
{
case ShaderVersion.VertexShader:
DeviceShader = AddDisposable(new VertexShader(graphicsDevice.Device, DeviceBytecode));
shaderType = ShaderType.VertexShader;
break;
case ShaderVersion.PixelShader:
DeviceShader = AddDisposable(new PixelShader(graphicsDevice.Device, DeviceBytecode));
shaderType = ShaderType.PixelShader;
break;
default:
throw new NotSupportedException();
}
}
using (var reflection = new ShaderReflection(DeviceBytecode))
{
resourceBindings = new ShaderResourceBinding[reflection.Description.BoundResources];
for (var i = 0; i < resourceBindings.Length; i++)
{
var resourceDescription = reflection.GetResourceBindingDescription(i);
int constantBufferSizeInBytes;
ConstantBufferField[] constantBufferFields;
if (resourceDescription.Type == ShaderInputType.ConstantBuffer)
{
using (var constantBufferDesc = reflection.GetConstantBuffer(resourceDescription.Name))
{
constantBufferSizeInBytes = constantBufferDesc.Description.Size;
constantBufferFields = new ConstantBufferField[constantBufferDesc.Description.VariableCount];
for (var j = 0; j < constantBufferFields.Length; j++)
{
var variable = constantBufferDesc.GetVariable(j);
constantBufferFields[j] = new ConstantBufferField(
variable.Description.Name,
variable.Description.StartOffset,
variable.Description.Size);
}
}
}
else
{
constantBufferSizeInBytes = 0;
constantBufferFields = null;
}
resourceBindings[i] = new ShaderResourceBinding(
resourceDescription.Name,
GetResourceType(resourceDescription.Type),
shaderType,
resourceDescription.BindPoint,
constantBufferSizeInBytes,
constantBufferFields);
}
}
}
public GraphicsObjectViewModel(DeviceChild deviceChild)
{
_deviceChild = deviceChild;
}