public VkShaderModule CreateShaderModule(byte[] code)
{
var info = new VkShaderModuleCreateInfo();
info.data = code;
return(new VkShaderModule(device, info));
}
public bool Build()
{
if (Code == null)
{
return(false);
}
unsafe
{
ulong shaderSize = (ulong)Code.Length;
fixed(byte *scPtr = Code)
{
var sm = new VkShaderModuleCreateInfo
{
sType = VkStructureType.ShaderModuleCreateInfo,
pCode = (uint *)scPtr,
codeSize = new UIntPtr(shaderSize)
};
handle = Device.CreateShaderModule(ref sm);
}
}
return(handle != null);
}
internal VkShaderModule LoadSPIR_V_Shader(string path, Zeckoxe.ShaderCompiler.ShaderCompiler.Stage stage)
{
byte[] shaderCode = File.ReadAllBytes(path);
Zeckoxe.ShaderCompiler.ShaderCompiler c = new Zeckoxe.ShaderCompiler.ShaderCompiler();
var o = new CompileOptions();
o.Language = CompileOptions.InputLanguage.HLSL;
string testShader = File.ReadAllText(path);
var r = c.Compile(testShader, stage, o, "testShader", "main");
var bc = r.GetBytes();
fixed(byte *scPtr = bc)
{
// Create a new shader module that will be used for Pipeline creation
VkShaderModuleCreateInfo moduleCreateInfo = VkShaderModuleCreateInfo.New();
moduleCreateInfo.codeSize = new UIntPtr((ulong)bc.Length);
moduleCreateInfo.pCode = (uint *)scPtr;
vkCreateShaderModule(Device, ref moduleCreateInfo, null, out VkShaderModule shaderModule);
return(shaderModule);
}
}
public unsafe void Init(ShaderType type, byte[] compiledShaderCode)
{
_type = type;
fixed(byte *byteCodePtr = compiledShaderCode)
{
var shaderInfo = new VkShaderModuleCreateInfo
{
sType = VkStructureType.ShaderModuleCreateInfo,
codeSize = new UIntPtr((uint)compiledShaderCode.Length),
pCode = (uint *)byteCodePtr
};
VkShaderModule shaderModule;
if (VulkanNative.vkCreateShaderModule(
_device.Handle,
&shaderInfo,
null,
&shaderModule
) != VkResult.Success)
{
throw new Exception("failed to create shader module");
}
_handle = shaderModule;
}
}
private static VkShaderModule loadShader(AssetReference <ShaderAsset> asset, VkDevice device, VkShaderStageFlags stage)
{
if (!asset.IsLoaded)
{
asset.LoadNow();
}
var shader = asset.Get();
if ((stage & VkShaderStageFlags.Fragment) != 0)
{
DebugHelper.AssertThrow <InvalidOperationException>(shader.Type == ShaderAsset.ShaderType.Frag);
}
else if ((stage & VkShaderStageFlags.Vertex) != 0)
{
DebugHelper.AssertThrow <InvalidOperationException>(shader.Type == ShaderAsset.ShaderType.Vertex);
}
byte[] shaderCode = shader.GetBytes();
ulong shaderSize = (ulong)shaderCode.Length;
fixed(byte *scPtr = shaderCode)
{
// Create a new shader module that will be used for Pipeline creation
VkShaderModuleCreateInfo moduleCreateInfo = VkShaderModuleCreateInfo.New();
moduleCreateInfo.codeSize = new UIntPtr(shaderSize);
moduleCreateInfo.pCode = (uint *)scPtr;
Util.CheckResult(vkCreateShaderModule(device, ref moduleCreateInfo, null, out VkShaderModule shaderModule));
return(shaderModule);
}
}
}/// <summary>
/// Load spirv code from unmanaged native pointer.
/// </summary>
/// <returns>the vulkan shader module.</returns>
/// <param name="code">unmanaged pointer holding the spirv code. Pointer must stay valid only during
/// the call to this method.</param>
/// <param name="codeSize">spirv code byte size.</param>
public VkShaderModule CreateShaderModule(IntPtr code, UIntPtr codeSize)
{
VkShaderModuleCreateInfo moduleCreateInfo = VkShaderModuleCreateInfo.New();
moduleCreateInfo.codeSize = codeSize;
moduleCreateInfo.pCode = code;
Utils.CheckResult(vkCreateShaderModule(VkDev, ref moduleCreateInfo, IntPtr.Zero, out VkShaderModule shaderModule));
return(shaderModule);
}
private VkShaderModule CreateShader(byte[] bytecode)
{
VkShaderModuleCreateInfo smci = VkShaderModuleCreateInfo.New();
fixed(byte *byteCodePtr = bytecode)
{
smci.pCode = (uint *)byteCodePtr;
smci.codeSize = new UIntPtr((uint)bytecode.Length);
vkCreateShaderModule(NativeDevice.Device, ref smci, null, out VkShaderModule module);
return(module);
}
}
private unsafe IVkShaderModule CreateShaderModule(byte[] code)
{
fixed(byte *pCode = code)
{
var createinfo = new VkShaderModuleCreateInfo
{
Code = (IntPtr)pCode,
CodeSize = (IntPtr)code.Length
};
return(device.CreateShaderModule(createinfo, null).Object);
}
}
public static VkResult vkCreateShaderModule(VkDevice device, byte[] bytecode, VkAllocationCallbacks *allocator, out VkShaderModule shaderModule)
{
fixed(byte *bytecodePtr = bytecode)
{
var createInfo = new VkShaderModuleCreateInfo
{
sType = VkStructureType.ShaderModuleCreateInfo,
codeSize = new VkPointerSize((uint)bytecode.Length),
pCode = (uint *)bytecodePtr
};
return(vkCreateShaderModule(device, &createInfo, allocator, out shaderModule));
}
}
public VkShader(VkGraphicsDevice gd, ref ShaderDescription description)
{
_gd = gd;
VkShaderModuleCreateInfo shaderModuleCI = VkShaderModuleCreateInfo.New();
fixed(byte *codePtr = description.ShaderBytes)
{
shaderModuleCI.codeSize = (UIntPtr)description.ShaderBytes.Length;
shaderModuleCI.pCode = (uint *)codePtr;
VkResult result = vkCreateShaderModule(gd.Device, ref shaderModuleCI, null, out _shaderModule);
CheckResult(result);
}
}
public ShaderModule(VkShaderStageFlags stage, IntPtr CodePointer, uint CodeLength)
{
Stage = stage;
unsafe
{
var sm = new VkShaderModuleCreateInfo
{
sType = VkStructureType.ShaderModuleCreateInfo,
pCode = (uint *)CodePointer,
codeSize = new UIntPtr(CodeLength),
};
handle = Device.CreateShaderModule(ref sm);
}
}
public unsafe VkShader(VkDevice device, ShaderStages type, VkShaderBytecode bytecode)
{
_device = device;
Type = type;
VkShaderModuleCreateInfo shaderModuleCI = VkShaderModuleCreateInfo.New();
fixed(byte *codePtr = bytecode.ShaderBytes)
{
shaderModuleCI.codeSize = (UIntPtr)bytecode.ShaderBytes.Length;
shaderModuleCI.pCode = (uint *)codePtr;
VkResult result = vkCreateShaderModule(_device, ref shaderModuleCI, null, out _shaderModule);
CheckResult(result);
}
}
public static VkShaderModule loadShader(string fileName, VkDevice device, VkShaderStageFlagBits stage)
{
using (var fs = File.OpenRead(fileName)) {
var length = fs.Length;
}
byte[] shaderCode = File.ReadAllBytes(fileName);
// Create a new shader module that will be used for Pipeline creation
VkShaderModuleCreateInfo moduleCreateInfo = new VkShaderModuleCreateInfo();
moduleCreateInfo.sType = ShaderModuleCreateInfo;
moduleCreateInfo.code = shaderCode;
VkShaderModule module;
vkCreateShaderModule(device, &moduleCreateInfo, null, &module);
return(module);
}
VkShaderModule CreateShaderModule(byte[] code)
{
VkShaderModuleCreateInfo createInfo = new VkShaderModuleCreateInfo();
createInfo.sType = VkStructureType.VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
createInfo.codeSize = (UIntPtr)code.Length;
fixed(byte *sourcePointer = code)
{
createInfo.pCode = (uint *)sourcePointer;
}
VkShaderModule shaderModule;
Helpers.CheckErrors(VulkanNative.vkCreateShaderModule(device, &createInfo, null, &shaderModule));
return(shaderModule);
}
public VkShaderModule CreateShaderModule(byte[] code)
{
GCHandle handle = GCHandle.Alloc(code, GCHandleType.Pinned);
var info = new VkShaderModuleCreateInfo();
info.sType = CSGL.Vulkan.VkStructureType.ShaderModuleCreateInfo;
info.codeSize = (IntPtr)code.LongLength;
info.pCode = handle.AddrOfPinnedObject();
VkShaderModule temp;
var result = VK.CreateShaderModule(device, ref info, alloc, out temp);
handle.Free();
return(temp);
}
private VkShaderModule createShaderModule(Type shaderCode)
{
VkShaderModuleCreateInfo createInfo = new VkShaderModuleCreateInfo();
createInfo.sType = VkStructureType.VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
createInfo.pCode = shaderCode;
VkShaderModule shaderModule = null;
VkResult result;
result = Vulkan.vkCreateShaderModule(device, createInfo, default(VkAllocationCallbacks), out shaderModule);
if (result != VkResult.VK_SUCCESS)
{
throw Program.Throw("failed to create shader module!", result);
}
return(shaderModule);
}
public VkShaderModule LoadSPIRVShader(string filename)
{
byte[] shaderCode = File.ReadAllBytes(filename);
ulong shaderSize = (ulong)shaderCode.Length;
unsafe {
// Create a new shader module that will be used for Pipeline creation
VkShaderModuleCreateInfo moduleCreateInfo = VkShaderModuleCreateInfo.New();
moduleCreateInfo.codeSize = new UIntPtr(shaderSize);
moduleCreateInfo.pCode = shaderCode.Pin();
Utils.CheckResult(vkCreateShaderModule(VkDev, ref moduleCreateInfo, IntPtr.Zero, out VkShaderModule shaderModule));
shaderCode.Unpin();
return(shaderModule);
}
}
void CreateShader(ShaderModuleCreateInfo mInfo)
{
VkShaderModuleCreateInfo info = new VkShaderModuleCreateInfo();
info.sType = VkStructureType.ShaderModuleCreateInfo;
info.codeSize = (ulong)mInfo.Data.LongLength;
var dataPinned = new PinnedArray <byte>(mInfo.Data);
info.pCode = dataPinned.Address;
using (dataPinned) {
var result = createShaderModule(device.Native, ref info, device.Instance.AllocationCallbacks, out shaderModule);
if (result != VkResult.Success)
{
throw new ShaderModuleException(string.Format("Error creating shader module: {0}"));
}
}
}
static VkShaderModule LoadShader(VkDevice device, string path)
{
byte[] bytes = File.ReadAllBytes(path);
uint length = (uint)bytes.Length;
VkShaderModuleCreateInfo pCreateInfo = VkShaderModuleCreateInfo.New();
pCreateInfo.codeSize = (UIntPtr)length;
fixed(byte *ptr = bytes)
pCreateInfo.pCode = (uint *)ptr;
VkShaderModule shaderModule = new VkShaderModule();
Assert(vkCreateShaderModule(device, &pCreateInfo, null, &shaderModule));
return(shaderModule);
}
public ShaderModule(Device dev, ReadOnlySpan <byte> code)
{
Device = dev;
unsafe
{
fixed(byte *pCode = &code.DangerousGetPinnableReference())
{
var info = new VkShaderModuleCreateInfo()
{
SType = VkStructureType.ShaderModuleCreateInfo,
Flags = 0,
CodeSize = new IntPtr(code.Length),
PCode = (uint *)pCode,
PNext = IntPtr.Zero
};
Handle = Device.Handle.CreateShaderModule(&info, Instance.AllocationCallbacks);
}
}
}
private VkShaderModule CreateShaderModule(byte[] shaderCode)
{
VkShaderModuleCreateInfo createInfo = new VkShaderModuleCreateInfo()
{
sType = VkStructureType.VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
codeSize = (UIntPtr)shaderCode.Length,
};
fixed(byte *sourcePointer = shaderCode)
{
createInfo.pCode = (uint *)sourcePointer;
}
VkShaderModule newShaderModule;
var result = VulkanNative.vkCreateShaderModule(vkDevice, &createInfo, null, &newShaderModule);
Helpers.CheckErrors(result);
return(newShaderModule);
}
public static VkShaderModule loadShader(string fileName, VkDevice device, VkShaderStageFlags stage)
{
using (var fs = File.OpenRead(fileName))
{
var length = fs.Length;
}
byte[] shaderCode = File.ReadAllBytes(fileName);
ulong shaderSize = (ulong)shaderCode.Length;
fixed(byte *scPtr = shaderCode)
{
// Create a new shader module that will be used for Pipeline creation
VkShaderModuleCreateInfo moduleCreateInfo = VkShaderModuleCreateInfo.New();
moduleCreateInfo.codeSize = new UIntPtr(shaderSize);
moduleCreateInfo.pCode = (uint *)scPtr;
Util.CheckResult(vkCreateShaderModule(device, ref moduleCreateInfo, null, out VkShaderModule shaderModule));
return(shaderModule);
}
}
/// <summary>
/// SPVシェーダーファイルを読み込んで VkPipelineShaderStageCreateInfo を作成します.
/// </summary>
/// <param name="device"></param>
/// <param name="shaderFile"></param>
/// <param name="stageFlag"></param>
/// <returns></returns>
public static VkPipelineShaderStageCreateInfo CreateShader(VkDevice device, string shaderFile, VkShaderStageFlagBits stageFlag)
{
var stageCreateInfo = new VkPipelineShaderStageCreateInfo();
using (var fs = new FileStream(shaderFile, FileMode.Open, FileAccess.Read))
{
var code = new byte[fs.Length];
fs.Read(code, 0, (int)fs.Length);
var shaderModuleCreateInfo = new VkShaderModuleCreateInfo()
{
shaderCodeBinary = code,
};
VkShaderModule shaderModule;
VulkanAPI.vkCreateShaderModule(device, ref shaderModuleCreateInfo, out shaderModule);
stageCreateInfo.flags = 0;
stageCreateInfo.stage = stageFlag;
stageCreateInfo.pName = "main";
stageCreateInfo.module = shaderModule;
}
return(stageCreateInfo);
}
public static extern VkResult CreateShaderModule(
VkDevice device,
ref VkShaderModuleCreateInfo pCreateInfo,
IntPtr pAllocator,
out VkShaderModule pShaderModule
);
public override VkResult CreateShaderModule(VkShaderModuleCreateInfo createInfo, out VkShaderModule shaderModule)
{
throw new NotImplementedException();
}
public SoftwareShaderModule(SoftwareDevice device, VkShaderModuleCreateInfo createInfo)
{
this.m_createInfo = createInfo;
this.m_codeClassType = createInfo.pCode;
}
public static VkShaderModule CreateShaderModule(ref VkShaderModuleCreateInfo shaderModuleCreateInfo)
{
VulkanUtil.CheckResult(vkCreateShaderModule(device, Utilities.AsPtr(ref shaderModuleCreateInfo), null, out VkShaderModule shaderModule));
return(shaderModule);
}
public override VkResult CreateShaderModule(VkShaderModuleCreateInfo createInfo, out VkShaderModule shaderModule)
{
shaderModule = new SoftwareShaderModule(this, createInfo);
return(VkResult.VK_SUCCESS);
}
VkPipeline CreatePipeline(VkDevice device, VkSurfaceCapabilitiesKHR surfaceCapabilities,
VkRenderPass renderPass, VkPipelineLayout pipelineLayout)
{
//VkShaderModule vertexShaderModule = device.CreateShaderModule(LoadResource(@"Shaders\shader.vert.spv"));
VkShaderModule vsModule;
{
var info = new VkShaderModuleCreateInfo {
sType = VkStructureType.ShaderModuleCreateInfo
};
byte[] bytes = LoadResource(@"Shaders\shader.vert.spv");
info.code = bytes;
//vkAPI.vkCreateShaderModule(device, bytes);
vkAPI.vkCreateShaderModule(device, &info, null, &vsModule).Check();
info.Free();
}
//VkShaderModule fragmentShaderModule = device.CreateShaderModule(LoadResource(@"Shaders\shader.frag.spv"));
VkShaderModule fsModule;
{
var info = new VkShaderModuleCreateInfo {
sType = VkStructureType.ShaderModuleCreateInfo
};
byte[] bytes = LoadResource(@"Shaders\shader.frag.spv");
info.code = bytes;
//vkAPI.vkCreateShaderModule(device, bytes);
vkAPI.vkCreateShaderModule(device, &info, null, &fsModule).Check();
info.Free();
}
var shaderStages = new VkPipelineShaderStageCreateInfo[2];
{
shaderStages[0].sType = VkStructureType.PipelineShaderStageCreateInfo;
shaderStages[0].stage = VkShaderStageFlagBits.Vertex;
shaderStages[0].module = vsModule;
//"main".Set(ref shaderStages[0].pName);
shaderStages[0].pName = "main";
shaderStages[1].sType = VkStructureType.PipelineShaderStageCreateInfo;
shaderStages[1].stage = VkShaderStageFlagBits.Fragment;
shaderStages[1].module = fsModule;
//"main".Set(ref shaderStages[1].pName);
shaderStages[1].pName = "main";
}
var viewport = new VkPipelineViewportStateCreateInfo {
sType = VkStructureType.PipelineViewportStateCreateInfo
};
viewport.viewports = new VkViewport(surfaceCapabilities.currentExtent, 0.0f, 1.0f);
viewport.scissors = new VkRect2D(surfaceCapabilities.currentExtent);
var multisample = new VkPipelineMultisampleStateCreateInfo {
sType = VkStructureType.PipelineMultisampleStateCreateInfo
};
multisample.rasterizationSamples = VkSampleCountFlagBits._1;
var colorBlend = new VkPipelineColorBlendStateCreateInfo {
sType = VkStructureType.PipelineColorBlendStateCreateInfo
};
colorBlend.logicOp = VkLogicOp.Copy;
var blend = new VkPipelineColorBlendAttachmentState(
colorWriteMask: VkColorComponentFlagBits.R | VkColorComponentFlagBits.G
| VkColorComponentFlagBits.B | VkColorComponentFlagBits.A,
blendEnable: false);
colorBlend.attachments = blend;
var rasterization = new VkPipelineRasterizationStateCreateInfo {
sType = VkStructureType.PipelineRasterizationStateCreateInfo
};
rasterization.polygonMode = VkPolygonMode.Fill;
rasterization.cullMode = VkCullModeFlagBits.None;
rasterization.frontFace = VkFrontFace.Clockwise;
rasterization.lineWidth = 1.0f;
var inputAssem = new VkPipelineInputAssemblyStateCreateInfo {
sType = VkStructureType.PipelineInputAssemblyStateCreateInfo
};
inputAssem.topology = VkPrimitiveTopology.TriangleList;
var input = new VkPipelineVertexInputStateCreateInfo {
sType = VkStructureType.PipelineVertexInputStateCreateInfo
};
// static readonly float[] Vertices = { .. }
input.vertexBindingDescriptions = new VkVertexInputBindingDescription(
binding: 0,
stride: 2 * sizeof(float),
inputRate: VkVertexInputRate.Vertex);
// layout(location = 0) in vec2 inPos;
input.vertexAttributeDescriptions = new VkVertexInputAttributeDescription(
location: 0,
binding: 0,
format: VkFormat.R32g32Sfloat,
offset: 0);
//VkPipelineCache cache = device.CreatePipelineCache(ref cacheInfo);
VkPipelineCache cache;
{
var info = VkPipelineCacheCreateInfo.Alloc();
vkAPI.vkCreatePipelineCache(device, info, null, &cache).Check();
Marshal.FreeHGlobal((IntPtr)info);
}
//var infos = new VkGraphicsPipelineCreateInfo[] { pipelineCreateInfo };
//return device.CreateGraphicsPipelines(ref cache, infos);
VkPipeline pipeline;
{
var info = new VkGraphicsPipelineCreateInfo {
sType = VkStructureType.GraphicsPipelineCreateInfo
};
info.layout = pipelineLayout;
info.pViewportState = &viewport;
info.stages = shaderStages;
info.pMultisampleState = &multisample;
info.pColorBlendState = &colorBlend;
info.pRasterizationState = &rasterization;
info.pInputAssemblyState = &inputAssem;
info.pVertexInputState = &input;
info.renderPass = renderPass;
vkAPI.vkCreateGraphicsPipelines(device, cache, 1, &info, null, &pipeline).Check();
info.Free();
}
shaderStages[0].Free();
shaderStages[1].Free();
viewport.Free();
colorBlend.Free();
input.Free();
return(pipeline);
}
public abstract VkResult CreateShaderModule(VkShaderModuleCreateInfo createInfo, out VkShaderModule shaderModule);
