Attachment #452670 for bug #236903

View Details Raw Unified Return to Bug 236903

| Differences between



2022-02-19  Myles C. Maxfield  <mmaxfield@apple.com>

        [WebGPU] Tracer bullet part 9: Basic implementation of bindings
        https://bugs.webkit.org/show_bug.cgi?id=236903

        Reviewed by NOBODY (OOPS!).

        This is a basic implementation of the BindGroup, BindGroupLayout, and PipelineLayout methods.
        Eventually we'll want to suballocate multiple BindGroups so they coexist within the same Buffer,
        but this is an initial simple implementation that doesn't do that.

        * WebGPU/BindGroup.h:
        (WebGPU::BindGroup::vertexArgumentBuffer const):
        (WebGPU::BindGroup::fragmentArgumentBuffer const):
        (WebGPU::BindGroup::computeArgumentBuffer const):
        * WebGPU/BindGroup.mm:
        (WebGPU::bufferIsPresent):
        (WebGPU::samplerIsPresent):
        (WebGPU::textureViewIsPresent):
        (WebGPU::Device::createBindGroup):
        (WebGPU::BindGroup::BindGroup):
        (WebGPU::BindGroup::setLabel):
        * WebGPU/BindGroupLayout.h:
        (WebGPU::BindGroupLayout::vertexArgumentEncoder const):
        (WebGPU::BindGroupLayout::fragmentArgumentEncoder const):
        (WebGPU::BindGroupLayout::computeArgumentEncoder const):
        * WebGPU/BindGroupLayout.mm:
        (WebGPU::isPresent):
        (WebGPU::createArgumentDescriptor):
        (WebGPU::Device::createBindGroupLayout):
        (WebGPU::BindGroupLayout::BindGroupLayout):
        (WebGPU::BindGroupLayout::setLabel):
        (WebGPU::BindGroupLayout::encodedLength const):
        * WebGPU/Buffer.h:
        (WebGPU::Buffer::buffer const):
        * WebGPU/Buffer.mm:
        (WebGPU::Buffer::Buffer):
        * WebGPU/PipelineLayout.h:
        (WebGPU::PipelineLayout::create):
        (WebGPU::PipelineLayout::numberOfBindGroupLayouts const):
        (WebGPU::PipelineLayout::bindGroupLayout const):
        * WebGPU/PipelineLayout.mm:
        (WebGPU::Device::createPipelineLayout):
        (WebGPU::PipelineLayout::PipelineLayout):
        (WebGPU::PipelineLayout::setLabel):
        * WebGPU/Sampler.h:
        (WebGPU::Sampler::samplerState const):
        * WebGPU/Sampler.mm:
        (WebGPU::Sampler::Sampler):
        * WebGPU/TextureView.h:
        (WebGPU::TextureView::texture const):
        * WebGPU/TextureView.mm:
        (WebGPU::TextureView::TextureView):

2022-02-19  Myles C. Maxfield  <mmaxfield@apple.com>

        [WebGPU] Tracer bullet part 8: Basic implementation of device creation routines

Lines 43-48 public: a/Source/WebGPU/WebGPU/BindGroup.h_sec1
- a/Source/WebGPU/WebGPU/BindGroup.h +4 lines
43		43
44	void setLabel(const char*);	44	void setLabel(const char*);
45		45
		46	id <MTLBuffer> vertexArgumentBuffer() const { return m_vertexArgumentBuffer; }
		47	id <MTLBuffer> fragmentArgumentBuffer() const { return m_fragmentArgumentBuffer; }
		48	id <MTLBuffer> computeArgumentBuffer() const { return m_computeArgumentBuffer; }
		49
46	private:	50	private:
47	BindGroup(id <MTLBuffer> vertexArgumentBuffer, id <MTLBuffer> fragmentArgumentBuffer, id <MTLBuffer> computeArgumentBuffer);	51	BindGroup(id <MTLBuffer> vertexArgumentBuffer, id <MTLBuffer> fragmentArgumentBuffer, id <MTLBuffer> computeArgumentBuffer);
48		52

Lines 26-39 a/Source/WebGPU/WebGPU/BindGroup.mm_sec1
- a/Source/WebGPU/WebGPU/BindGroup.mm -6 / +82 lines
26	#import "config.h"	26	#import "config.h"
27	#import "BindGroup.h"	27	#import "BindGroup.h"
28		28
		29	#import "BindGroupLayout.h"
		30	#import "Buffer.h"
29	#import "Device.h"	31	#import "Device.h"
		32	#import "Sampler.h"
		33	#import "TextureView.h"
30		34
31	namespace WebGPU {	35	namespace WebGPU {
32		36
		37	static bool bufferIsPresent(const WGPUBindGroupEntry& entry)
		38	{
		39	return entry.buffer;
		40	}
		41
		42	static bool samplerIsPresent(const WGPUBindGroupEntry& entry)
		43	{
		44	return entry.sampler;
		45	}
		46
		47	static bool textureViewIsPresent(const WGPUBindGroupEntry& entry)
		48	{
		49	return entry.textureView;
		50	}
		51
33	RefPtr<BindGroup> Device::createBindGroup(const WGPUBindGroupDescriptor* descriptor)	52	RefPtr<BindGroup> Device::createBindGroup(const WGPUBindGroupDescriptor* descriptor)
34	{	53	{
35	UNUSED_PARAM(descriptor);	54	if (descriptor->nextInChain)
36	return BindGroup::create(nil, nil, nil);	55	return nullptr;
		56
		57	const BindGroupLayout& bindGroupLayout = descriptor->layout->bindGroupLayout;
		58
		59	// FIXME: Don't allocate 3 new buffers for every bind group.
		60	// In fact, don't even allocate a single new buffer for every bind group.
		61	id <MTLBuffer> vertexArgumentBuffer = [m_device newBufferWithLength:bindGroupLayout.encodedLength() options:MTLResourceStorageModeShared];
		62	id <MTLBuffer> fragmentArgumentBuffer = [m_device newBufferWithLength:bindGroupLayout.encodedLength() options:MTLResourceStorageModeShared];
		63	id <MTLBuffer> computeArgumentBuffer = [m_device newBufferWithLength:bindGroupLayout.encodedLength() options:MTLResourceStorageModeShared];
		64	if (!vertexArgumentBuffer \|\| !fragmentArgumentBuffer \|\| !computeArgumentBuffer)
		65	return nullptr;
		66
		67	auto label = [NSString stringWithCString:descriptor->label encoding:NSUTF8StringEncoding];
		68	vertexArgumentBuffer.label = label;
		69	fragmentArgumentBuffer.label = label;
		70	computeArgumentBuffer.label = label;
		71
		72	id <MTLArgumentEncoder> vertexArgumentEncoder = bindGroupLayout.vertexArgumentEncoder();
		73	id <MTLArgumentEncoder> fragmentArgumentEncoder = bindGroupLayout.fragmentArgumentEncoder();
		74	id <MTLArgumentEncoder> computeArgumentEncoder = bindGroupLayout.computeArgumentEncoder();
		75	[vertexArgumentEncoder setArgumentBuffer:vertexArgumentBuffer offset:0];
		76	[fragmentArgumentEncoder setArgumentBuffer:fragmentArgumentBuffer offset:0];
		77	[computeArgumentEncoder setArgumentBuffer:computeArgumentBuffer offset:0];
		78
		79	for (uint32_t i = 0; i < descriptor->entryCount; ++i) {
		80	const WGPUBindGroupEntry& entry = descriptor->entries[i];
		81
		82	if (entry.nextInChain)
		83	return nullptr;
		84
		85	bool bufferIsPresent = WebGPU::bufferIsPresent(entry);
		86	bool samplerIsPresent = WebGPU::samplerIsPresent(entry);
		87	bool textureViewIsPresent = WebGPU::textureViewIsPresent(entry);
		88	if (static_cast<int>(bufferIsPresent) + static_cast<int>(samplerIsPresent) + static_cast<int>(textureViewIsPresent) != 1)
		89	return nullptr;
		90
		91	if (bufferIsPresent) {
		92	id <MTLBuffer> buffer = entry.buffer->buffer->buffer();
		93	[vertexArgumentEncoder setBuffer:buffer offset:entry.offset atIndex:entry.binding];
		94	[fragmentArgumentEncoder setBuffer:buffer offset:entry.offset atIndex:entry.binding];
		95	[computeArgumentEncoder setBuffer:buffer offset:entry.offset atIndex:entry.binding];
		96	} else if (samplerIsPresent) {
		97	id <MTLSamplerState> sampler = entry.sampler->sampler->samplerState();
		98	[vertexArgumentEncoder setSamplerState:sampler atIndex:entry.binding];
		99	[fragmentArgumentEncoder setSamplerState:sampler atIndex:entry.binding];
		100	[computeArgumentEncoder setSamplerState:sampler atIndex:entry.binding];
		101	} else if (textureViewIsPresent) {
		102	id <MTLTexture> texture = entry.textureView->textureView->texture();
		103	[vertexArgumentEncoder setTexture:texture atIndex:entry.binding];
		104	[fragmentArgumentEncoder setTexture:texture atIndex:entry.binding];
		105	[computeArgumentEncoder setTexture:texture atIndex:entry.binding];
		106	} else {
		107	ASSERT_NOT_REACHED();
		108	return nullptr;
		109	}
		110	}
		111
		112	return BindGroup::create(vertexArgumentBuffer, fragmentArgumentBuffer, computeArgumentBuffer);
37	}	113	}
38		114
39	BindGroup::BindGroup(id <MTLBuffer> vertexArgumentBuffer, id <MTLBuffer> fragmentArgumentBuffer, id <MTLBuffer> computeArgumentBuffer)	115	BindGroup::BindGroup(id <MTLBuffer> vertexArgumentBuffer, id <MTLBuffer> fragmentArgumentBuffer, id <MTLBuffer> computeArgumentBuffer)
Lines 41-56 BindGroup::BindGroup(id <MTLBuffer> vertexArgumentBuffer, id <MTLBuffer> fragmen a/Source/WebGPU/WebGPU/BindGroup.mm_sec2
41	, m_fragmentArgumentBuffer(fragmentArgumentBuffer)	117	, m_fragmentArgumentBuffer(fragmentArgumentBuffer)
42	, m_computeArgumentBuffer(computeArgumentBuffer)	118	, m_computeArgumentBuffer(computeArgumentBuffer)
43	{	119	{
44	UNUSED_VARIABLE(m_vertexArgumentBuffer);
45	UNUSED_VARIABLE(m_fragmentArgumentBuffer);
46	UNUSED_VARIABLE(m_computeArgumentBuffer);
47	}	120	}
48		121
49	BindGroup::~BindGroup() = default;	122	BindGroup::~BindGroup() = default;
50		123
51	void BindGroup::setLabel(const char* label)	124	void BindGroup::setLabel(const char* label)
52	{	125	{
53	UNUSED_PARAM(label);	126	auto labelString = [NSString stringWithCString:label encoding:NSUTF8StringEncoding];
		127	m_vertexArgumentBuffer.label = labelString;
		128	m_fragmentArgumentBuffer.label = labelString;
		129	m_computeArgumentBuffer.label = labelString;
54	}	130	}
55		131
56	}	132	}

Lines 43-48 public: a/Source/WebGPU/WebGPU/BindGroupLayout.h_sec1
- a/Source/WebGPU/WebGPU/BindGroupLayout.h +6 lines
43		43
44	void setLabel(const char*);	44	void setLabel(const char*);
45		45
		46	NSUInteger encodedLength() const;
		47
		48	id <MTLArgumentEncoder> vertexArgumentEncoder() const { return m_vertexArgumentEncoder; }
		49	id <MTLArgumentEncoder> fragmentArgumentEncoder() const { return m_fragmentArgumentEncoder; }
		50	id <MTLArgumentEncoder> computeArgumentEncoder() const { return m_computeArgumentEncoder; }
		51
46	private:	52	private:
47	BindGroupLayout(id <MTLArgumentEncoder> vertexArgumentEncoder, id <MTLArgumentEncoder> fragmentArgumentEncoder, id <MTLArgumentEncoder> computeArgumentEncoder);	53	BindGroupLayout(id <MTLArgumentEncoder> vertexArgumentEncoder, id <MTLArgumentEncoder> fragmentArgumentEncoder, id <MTLArgumentEncoder> computeArgumentEncoder);
48		54




namespace WebGPU {

static bool isPresent(const WGPUBufferBindingLayout& buffer)
{
    return buffer.type != WGPUBufferBindingType_Undefined;
}

static MTLArgumentDescriptor *createArgumentDescriptor(const WGPUBufferBindingLayout& buffer)
{
    if (buffer.nextInChain)
        return nil;

    auto descriptor = [MTLArgumentDescriptor new];
    descriptor.dataType = MTLDataTypePointer;
    // FIXME: Handle hasDynamicOffset.
    // FIXME: Handle minBindingSize.
    switch (buffer.type) {
    case WGPUBufferBindingType_Uniform:
    case WGPUBufferBindingType_ReadOnlyStorage:
        descriptor.access = MTLArgumentAccessReadOnly;
        break;
    case WGPUBufferBindingType_Storage:
        descriptor.access = MTLArgumentAccessReadWrite;
        break;
    default:
        return nil;
    }
    return descriptor;
}

static bool isPresent(const WGPUSamplerBindingLayout& sampler)
{
    return sampler.type != WGPUSamplerBindingType_Undefined;
}

static MTLArgumentDescriptor *createArgumentDescriptor(const WGPUSamplerBindingLayout& sampler)
{
    if (sampler.nextInChain)
        return nil;

    UNUSED_PARAM(sampler);
    auto descriptor = [MTLArgumentDescriptor new];
    descriptor.dataType = MTLDataTypeSampler;
    // FIXME: Implement this.
    return descriptor;
}

static bool isPresent(const WGPUTextureBindingLayout& texture)
{
    return texture.sampleType != WGPUTextureSampleType_Undefined
        && texture.viewDimension != WGPUTextureViewDimension_Undefined;
}

static MTLArgumentDescriptor *createArgumentDescriptor(const WGPUTextureBindingLayout& texture)
{
    if (texture.nextInChain)
        return nil;

    UNUSED_PARAM(texture);
    auto descriptor = [MTLArgumentDescriptor new];
    descriptor.dataType = MTLDataTypeTexture;
    // FIXME: Implement this.
    return descriptor;
}

static bool isPresent(const WGPUStorageTextureBindingLayout& storageTexture)
{
    return storageTexture.access != WGPUStorageTextureAccess_Undefined
        && storageTexture.format != WGPUTextureFormat_Undefined
        && storageTexture.viewDimension != WGPUTextureViewDimension_Undefined;
}

static MTLArgumentDescriptor *createArgumentDescriptor(const WGPUStorageTextureBindingLayout& storageTexture)
{
    if (storageTexture.nextInChain)
        return nil;

    UNUSED_PARAM(storageTexture);
    auto descriptor = [MTLArgumentDescriptor new];
    descriptor.dataType = MTLDataTypeTexture;
    // FIXME: Implement this.
    return descriptor;
}

RefPtr<BindGroupLayout> Device::createBindGroupLayout(const WGPUBindGroupLayoutDescriptor* descriptor)
{
if (descriptor->nextInChain)
        return nullptr;

    NSMutableArray<MTLArgumentDescriptor *> *vertexArguments = [NSMutableArray arrayWithCapacity:descriptor->entryCount];
    NSMutableArray<MTLArgumentDescriptor *> *fragmentArguments = [NSMutableArray arrayWithCapacity:descriptor->entryCount];
    NSMutableArray<MTLArgumentDescriptor *> *computeArguments = [NSMutableArray arrayWithCapacity:descriptor->entryCount];
    if (!vertexArguments || !fragmentArguments || !computeArguments)
        return nullptr;

    for (uint32_t i = 0; i < descriptor->entryCount; ++i) {
        const WGPUBindGroupLayoutEntry& entry = descriptor->entries[i];
        if (entry.nextInChain)
            return nullptr;

        // https://gpuweb.github.io/gpuweb/#dictdef-gpubindgrouplayoutentry
        // "Only one [of buffer, sampler, texture, storageTexture, or externalTexture] may be defined for any given GPUBindGroupLayoutEntry."

        ASSERT(i == vertexArguments.count);
        ASSERT(vertexArguments.count == fragmentArguments.count);
        ASSERT(fragmentArguments.count == computeArguments.count);

        const WGPUBufferBindingLayout& buffer = entry.buffer;
        const WGPUSamplerBindingLayout& sampler = entry.sampler;
        const WGPUTextureBindingLayout& texture = entry.texture;
        const WGPUStorageTextureBindingLayout& storageTexture = entry.storageTexture;

        MTLArgumentDescriptor *descriptor = nil;

        if (isPresent(buffer)) {
            if (i != vertexArguments.count)
                return nullptr;

            descriptor = createArgumentDescriptor(buffer);
            if (!descriptor)
                return nullptr;
        }

        if (isPresent(sampler)) {
            if (i != vertexArguments.count)
                return nullptr;

            descriptor = createArgumentDescriptor(sampler);
            if (!descriptor)
                return nullptr;
        }

        if (isPresent(texture)) {
            if (i != vertexArguments.count)
                return nullptr;

            descriptor = createArgumentDescriptor(texture);
            if (!descriptor)
                return nullptr;
        }

        if (isPresent(storageTexture)) {
            if (i != vertexArguments.count)
                return nullptr;

            descriptor = createArgumentDescriptor(storageTexture);
            if (!descriptor)
                return nullptr;
        }

        // FIXME: This needs coordination with the shader compiler.
        descriptor.index = i;

        MTLArgumentDescriptor *vertexDescriptor = descriptor;
        MTLArgumentDescriptor *fragmentDescriptor = [descriptor copy];
        MTLArgumentDescriptor *computeDescriptor = [descriptor copy];
        if (!fragmentDescriptor || !computeDescriptor)
            return nullptr;

        if (!(entry.visibility & WGPUShaderStage_Vertex))
            vertexDescriptor.access = MTLArgumentAccessReadOnly;
        if (!(entry.visibility & WGPUShaderStage_Fragment))
            fragmentDescriptor.access = MTLArgumentAccessReadOnly;
        if (!(entry.visibility & WGPUShaderStage_Compute))
            computeDescriptor.access = MTLArgumentAccessReadOnly;

        [vertexArguments addObject:vertexDescriptor];
        [fragmentArguments addObject:fragmentDescriptor];
        [computeArguments addObject:computeDescriptor];
    }

    id <MTLArgumentEncoder> vertexArgumentEncoder = [m_device newArgumentEncoderWithArguments:vertexArguments];
    id <MTLArgumentEncoder> fragmentArgumentEncoder = [m_device newArgumentEncoderWithArguments:fragmentArguments];
    id <MTLArgumentEncoder> computeArgumentEncoder = [m_device newArgumentEncoderWithArguments:computeArguments];
    if (!vertexArgumentEncoder || !fragmentArgumentEncoder || !computeArgumentEncoder)
        return nullptr;

    auto label = [NSString stringWithCString:descriptor->label encoding:NSUTF8StringEncoding];
    vertexArgumentEncoder.label = label;
    fragmentArgumentEncoder.label = label;
    computeArgumentEncoder.label = label;

    return BindGroupLayout::create(vertexArgumentEncoder, fragmentArgumentEncoder, computeArgumentEncoder);
}

BindGroupLayout::BindGroupLayout(id <MTLArgumentEncoder> vertexArgumentEncoder, id <MTLArgumentEncoder> fragmentArgumentEncoder, id <MTLArgumentEncoder> computeArgumentEncoder)

    , m_fragmentArgumentEncoder(fragmentArgumentEncoder)
    , m_computeArgumentEncoder(computeArgumentEncoder)
{
    UNUSED_VARIABLE(m_vertexArgumentEncoder);
    UNUSED_VARIABLE(m_fragmentArgumentEncoder);
    UNUSED_VARIABLE(m_computeArgumentEncoder);
}

BindGroupLayout::~BindGroupLayout() = default;

void BindGroupLayout::setLabel(const char* label)
{
    auto labelString = [NSString stringWithCString:label encoding:NSUTF8StringEncoding];
    m_vertexArgumentEncoder.label = labelString;
    m_fragmentArgumentEncoder.label = labelString;
    m_computeArgumentEncoder.label = labelString;
}

NSUInteger BindGroupLayout::encodedLength() const
{
    auto result = m_vertexArgumentEncoder.encodedLength;
    ASSERT(result == m_fragmentArgumentEncoder.encodedLength);
    ASSERT(result == m_computeArgumentEncoder.encodedLength);
    return result;
}

}

Lines 49-54 public: a/Source/WebGPU/WebGPU/Buffer.h_sec1
- a/Source/WebGPU/WebGPU/Buffer.h +2 lines
49	void unmap();	49	void unmap();
50	void setLabel(const char*);	50	void setLabel(const char*);
51		51
		52	id <MTLBuffer> buffer() const { return m_buffer; }
		53
52	private:	54	private:
53	Buffer(id <MTLBuffer>);	55	Buffer(id <MTLBuffer>);
54		56

Lines 39-45 RefPtr<Buffer> Device::createBuffer(const WGPUBufferDescriptor* descriptor) a/Source/WebGPU/WebGPU/Buffer.mm_sec1
- a/Source/WebGPU/WebGPU/Buffer.mm -1 lines
39	Buffer::Buffer(id <MTLBuffer> buffer)	39	Buffer::Buffer(id <MTLBuffer> buffer)
40	: m_buffer(buffer)	40	: m_buffer(buffer)
41	{	41	{
42	UNUSED_VARIABLE(m_buffer);
43	}	42	}
44		43
45	Buffer::~Buffer() = default;	44	Buffer::~Buffer() = default;

Lines 28-50 a/Source/WebGPU/WebGPU/PipelineLayout.h_sec1
- a/Source/WebGPU/WebGPU/PipelineLayout.h -3 / +11 lines
28	#import <wtf/FastMalloc.h>	28	#import <wtf/FastMalloc.h>
29	#import <wtf/Ref.h>	29	#import <wtf/Ref.h>
30	#import <wtf/RefCounted.h>	30	#import <wtf/RefCounted.h>
		31	#import <wtf/Vector.h>
31		32
32	namespace WebGPU {	33	namespace WebGPU {
33		34
		35	class BindGroupLayout;
		36
34	class PipelineLayout : public RefCounted<PipelineLayout> {	37	class PipelineLayout : public RefCounted<PipelineLayout> {
35	WTF_MAKE_FAST_ALLOCATED;	38	WTF_MAKE_FAST_ALLOCATED;
36	public:	39	public:
37	static Ref<PipelineLayout> create()	40	static Ref<PipelineLayout> create(Vector<Ref<BindGroupLayout>>&& bindGroupLayouts)
38	{	41	{
39	return adoptRef(*new PipelineLayout());	42	return adoptRef(*new PipelineLayout(WTFMove(bindGroupLayouts)));
40	}	43	}
41		44
42	~PipelineLayout();	45	~PipelineLayout();
43		46
44	void setLabel(const char*);	47	void setLabel(const char*);
45		48
		49	size_t numberOfBindGroupLayouts() const { return m_bindGroupLayouts.size(); }
		50	const BindGroupLayout& bindGroupLayout(size_t i) const { return m_bindGroupLayouts[i]; }
		51
46	private:	52	private:
47	PipelineLayout();	53	PipelineLayout(Vector<Ref<BindGroupLayout>>&&);
		54
		55	const Vector<Ref<BindGroupLayout>> m_bindGroupLayouts;
48	};	56	};
49		57
50	} // namespace WebGPU	58	} // namespace WebGPU



#import "config.h"
#import "PipelineLayout.h"

#import "BindGroupLayout.h"
#import "Device.h"

namespace WebGPU {

RefPtr<PipelineLayout> Device::createPipelineLayout(const WGPUPipelineLayoutDescriptor* descriptor)
{
    if (descriptor->nextInChain)
        return nullptr;

    Vector<Ref<BindGroupLayout>> bindGroupLayouts;
    bindGroupLayouts.reserveInitialCapacity(descriptor->bindGroupLayoutCount);
    for (uint32_t i = 0; i < descriptor->bindGroupLayoutCount; ++i) {
        const auto* bindGroupLayout = descriptor->bindGroupLayouts[i];
        bindGroupLayouts.uncheckedAppend(bindGroupLayout->bindGroupLayout);
    }
    return PipelineLayout::create(WTFMove(bindGroupLayouts));
}

PipelineLayout::PipelineLayout(Vector<Ref<BindGroupLayout>>&& bindGroupLayouts)
    : m_bindGroupLayouts(WTFMove(bindGroupLayouts))
{
}

PipelineLayout::~PipelineLayout() = default;

void PipelineLayout::setLabel(const char*)
{
    // There is no Metal object that represents a pipeline layout.
}

}

Lines 43-48 public: a/Source/WebGPU/WebGPU/Sampler.h_sec1
- a/Source/WebGPU/WebGPU/Sampler.h +2 lines
43		43
44	void setLabel(const char*);	44	void setLabel(const char*);
45		45
		46	id <MTLSamplerState> samplerState() const { return m_samplerState; }
		47
46	private:	48	private:
47	Sampler(id <MTLSamplerState>);	49	Sampler(id <MTLSamplerState>);
48		50

Lines 39-45 RefPtr<Sampler> Device::createSampler(const WGPUSamplerDescriptor* descriptor) a/Source/WebGPU/WebGPU/Sampler.mm_sec1
- a/Source/WebGPU/WebGPU/Sampler.mm -1 lines
39	Sampler::Sampler(id <MTLSamplerState> samplerState)	39	Sampler::Sampler(id <MTLSamplerState> samplerState)
40	: m_samplerState(samplerState)	40	: m_samplerState(samplerState)
41	{	41	{
42	UNUSED_VARIABLE(m_samplerState);
43	}	42	}
44		43
45	Sampler::~Sampler() = default;	44	Sampler::~Sampler() = default;

Lines 43-48 public: a/Source/WebGPU/WebGPU/TextureView.h_sec1
- a/Source/WebGPU/WebGPU/TextureView.h +2 lines
43		43
44	void setLabel(const char*);	44	void setLabel(const char*);
45		45
		46	id <MTLTexture> texture() const { return m_texture; }
		47
46	private:	48	private:
47	TextureView(id <MTLTexture>);	49	TextureView(id <MTLTexture>);
48		50

Lines 32-38 namespace WebGPU { a/Source/WebGPU/WebGPU/TextureView.mm_sec1
- a/Source/WebGPU/WebGPU/TextureView.mm -1 lines
32	TextureView::TextureView(id <MTLTexture> texture)	32	TextureView::TextureView(id <MTLTexture> texture)
33	: m_texture(texture)	33	: m_texture(texture)
34	{	34	{
35	UNUSED_VARIABLE(m_texture);
36	}	35	}
37		36
38	TextureView::~TextureView() = default;	37	TextureView::~TextureView() = default;

Return to Bug 236903

Lines 1-3 a/Source/WebGPU/ChangeLog_sec1
- a/Source/WebGPU/ChangeLog +54 lines
		1	2022-02-19 Myles C. Maxfield <mmaxfield@apple.com>
		2
		3	[WebGPU] Tracer bullet part 9: Basic implementation of bindings
		4	https://bugs.webkit.org/show_bug.cgi?id=236903
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	This is a basic implementation of the BindGroup, BindGroupLayout, and PipelineLayout methods.
		9	Eventually we'll want to suballocate multiple BindGroups so they coexist within the same Buffer,
		10	but this is an initial simple implementation that doesn't do that.
		11
		12	* WebGPU/BindGroup.h:
		13	(WebGPU::BindGroup::vertexArgumentBuffer const):
		14	(WebGPU::BindGroup::fragmentArgumentBuffer const):
		15	(WebGPU::BindGroup::computeArgumentBuffer const):
		16	* WebGPU/BindGroup.mm:
		17	(WebGPU::bufferIsPresent):
		18	(WebGPU::samplerIsPresent):
		19	(WebGPU::textureViewIsPresent):
		20	(WebGPU::Device::createBindGroup):
		21	(WebGPU::BindGroup::BindGroup):
		22	(WebGPU::BindGroup::setLabel):
		23	* WebGPU/BindGroupLayout.h:
		24	(WebGPU::BindGroupLayout::vertexArgumentEncoder const):
		25	(WebGPU::BindGroupLayout::fragmentArgumentEncoder const):
		26	(WebGPU::BindGroupLayout::computeArgumentEncoder const):
		27	* WebGPU/BindGroupLayout.mm:
		28	(WebGPU::isPresent):
		29	(WebGPU::createArgumentDescriptor):
		30	(WebGPU::Device::createBindGroupLayout):
		31	(WebGPU::BindGroupLayout::BindGroupLayout):
		32	(WebGPU::BindGroupLayout::setLabel):
		33	(WebGPU::BindGroupLayout::encodedLength const):
		34	* WebGPU/Buffer.h:
		35	(WebGPU::Buffer::buffer const):
		36	* WebGPU/Buffer.mm:
		37	(WebGPU::Buffer::Buffer):
		38	* WebGPU/PipelineLayout.h:
		39	(WebGPU::PipelineLayout::create):
		40	(WebGPU::PipelineLayout::numberOfBindGroupLayouts const):
		41	(WebGPU::PipelineLayout::bindGroupLayout const):
		42	* WebGPU/PipelineLayout.mm:
		43	(WebGPU::Device::createPipelineLayout):
		44	(WebGPU::PipelineLayout::PipelineLayout):
		45	(WebGPU::PipelineLayout::setLabel):
		46	* WebGPU/Sampler.h:
		47	(WebGPU::Sampler::samplerState const):
		48	* WebGPU/Sampler.mm:
		49	(WebGPU::Sampler::Sampler):
		50	* WebGPU/TextureView.h:
		51	(WebGPU::TextureView::texture const):
		52	* WebGPU/TextureView.mm:
		53	(WebGPU::TextureView::TextureView):
		54
1	2022-02-19 Myles C. Maxfield <mmaxfield@apple.com>	55	2022-02-19 Myles C. Maxfield <mmaxfield@apple.com>
2		56
3	[WebGPU] Tracer bullet part 8: Basic implementation of device creation routines	57	[WebGPU] Tracer bullet part 8: Basic implementation of device creation routines