public void SetUsedTexture( Instruction inst, SamplerType type, TextureFormat format, TextureFlags flags, int cbufSlot, int handle) { inst &= Instruction.Mask; bool isImage = inst == Instruction.ImageLoad || inst == Instruction.ImageStore || inst == Instruction.ImageAtomic; bool isWrite = inst == Instruction.ImageStore || inst == Instruction.ImageAtomic; bool accurateType = inst != Instruction.Lod && inst != Instruction.TextureSize; bool coherent = flags.HasFlag(TextureFlags.Coherent); if (isImage) { SetUsedTextureOrImage(_usedImages, cbufSlot, handle, type, format, true, isWrite, false, coherent); } else { bool intCoords = flags.HasFlag(TextureFlags.IntCoords) || inst == Instruction.TextureSize; SetUsedTextureOrImage(_usedTextures, cbufSlot, handle, type, TextureFormat.Unknown, intCoords, false, accurateType, coherent); } GpuAccessor.RegisterTexture(handle, cbufSlot); }
public uint ConstantBuffer1Read(int offset) { if (Cb1DataSize < offset + 4) { Cb1DataSize = offset + 4; } return(GpuAccessor.ConstantBuffer1Read(offset)); }
public TextureFormat GetTextureFormatAtomic(int handle, int cbufSlot = -1) { // Atomic image instructions do not support GL_EXT_shader_image_load_formatted, // and must have a type specified. Default to R32Sint if not available. var format = GpuAccessor.QueryTextureFormat(handle, cbufSlot); if (!FormatSupportsAtomic(format)) { GpuAccessor.Log($"Unsupported format for texture {handle}: {format}."); format = TextureFormat.R32Sint; } return(format); }
public BufferDescriptor[] GetConstantBufferDescriptors() { if (_cachedConstantBufferDescriptors != null) { return(_cachedConstantBufferDescriptors); } int usedMask = _usedConstantBuffers; if (UsedFeatures.HasFlag(FeatureFlags.CbIndexing)) { usedMask |= (int)GpuAccessor.QueryConstantBufferUse(); } FirstConstantBufferBinding = GetConstantBufferBinding(0); return(_cachedConstantBufferDescriptors = GetBufferDescriptors(usedMask, 0, GetConstantBufferBinding)); }
public TextureFormat GetTextureFormat(int handle, int cbufSlot = -1) { // When the formatted load extension is supported, we don't need to // specify a format, we can just declare it without a format and the GPU will handle it. if (GpuAccessor.QuerySupportsImageLoadFormatted()) { return(TextureFormat.Unknown); } var format = GpuAccessor.QueryTextureFormat(handle, cbufSlot); if (format == TextureFormat.Unknown) { GpuAccessor.Log($"Unknown format for texture {handle}."); format = TextureFormat.R8G8B8A8Unorm; } return(format); }
public BufferDescriptor[] GetConstantBufferDescriptors() { if (_cachedConstantBufferDescriptors != null) { return(_cachedConstantBufferDescriptors); } int usedMask = _usedConstantBuffers; if (UsedFeatures.HasFlag(FeatureFlags.CbIndexing)) { usedMask |= (int)GpuAccessor.QueryConstantBufferUse(); } FirstConstantBufferBinding = _counts.UniformBuffersCount; return(_cachedConstantBufferDescriptors = GetBufferDescriptors( usedMask, 0, UsedFeatures.HasFlag(FeatureFlags.CbIndexing), _counts.IncrementUniformBuffersCount)); }
/// <summary> /// Create guest shader cache entries from the runtime contexts. /// </summary> /// <param name="channel">The GPU channel in use</param> /// <param name="shaderContexts">The runtime contexts</param> /// <returns>Guest shader cahe entries from the runtime contexts</returns> public static GuestShaderCacheEntry[] CreateShaderCacheEntries(GpuChannel channel, ReadOnlySpan <TranslatorContext> shaderContexts) { MemoryManager memoryManager = channel.MemoryManager; int startIndex = shaderContexts.Length > 1 ? 1 : 0; GuestShaderCacheEntry[] entries = new GuestShaderCacheEntry[shaderContexts.Length - startIndex]; for (int i = startIndex; i < shaderContexts.Length; i++) { TranslatorContext context = shaderContexts[i]; if (context == null) { continue; } GpuAccessor gpuAccessor = context.GpuAccessor as GpuAccessor; ulong cb1DataAddress; int cb1DataSize = gpuAccessor?.Cb1DataSize ?? 0; if (context.Stage == ShaderStage.Compute) { cb1DataAddress = channel.BufferManager.GetComputeUniformBufferAddress(1); } else { int stageIndex = context.Stage switch { ShaderStage.TessellationControl => 1, ShaderStage.TessellationEvaluation => 2, ShaderStage.Geometry => 3, ShaderStage.Fragment => 4, _ => 0 }; cb1DataAddress = channel.BufferManager.GetGraphicsUniformBufferAddress(stageIndex, 1); } int size = context.Size; TranslatorContext translatorContext2 = i == 1 ? shaderContexts[0] : null; int sizeA = translatorContext2 != null ? translatorContext2.Size : 0; byte[] code = new byte[size + cb1DataSize + sizeA]; memoryManager.GetSpan(context.Address, size).CopyTo(code); if (cb1DataAddress != 0 && cb1DataSize != 0) { memoryManager.Physical.GetSpan(cb1DataAddress, cb1DataSize).CopyTo(code.AsSpan(size, cb1DataSize)); } if (translatorContext2 != null) { memoryManager.GetSpan(translatorContext2.Address, sizeA).CopyTo(code.AsSpan(size + cb1DataSize, sizeA)); } GuestGpuAccessorHeader gpuAccessorHeader = CreateGuestGpuAccessorCache(context.GpuAccessor); if (gpuAccessor != null) { gpuAccessorHeader.TextureDescriptorCount = context.TextureHandlesForCache.Count; } GuestShaderCacheEntryHeader header = new GuestShaderCacheEntryHeader( context.Stage, size + cb1DataSize, sizeA, cb1DataSize, gpuAccessorHeader); GuestShaderCacheEntry entry = new GuestShaderCacheEntry(header, code); if (gpuAccessor != null) { foreach (int textureHandle in context.TextureHandlesForCache) { GuestTextureDescriptor textureDescriptor = ((Image.TextureDescriptor)gpuAccessor.GetTextureDescriptor(textureHandle, -1)).ToCache(); textureDescriptor.Handle = (uint)textureHandle; entry.TextureDescriptors.Add(textureHandle, textureDescriptor); } } entries[i - startIndex] = entry; } return(entries); }