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);