Formatted EVERYTHING

2024-06-09 12:20:53 +02:00
parent f18bf8acbe
commit d95dab850c
265 changed files with 8002 additions and 12310 deletions
@@ -11,49 +11,44 @@ using namespace Seele;
 using namespace Seele::Metal;

 BufferAllocation::BufferAllocation(PGraphics graphics)
-  : CommandBoundResource(graphics)
-{}
+    : CommandBoundResource(graphics) {}

-BufferAllocation::~BufferAllocation()
-{
-  if(buffer != nullptr)
-  {
+BufferAllocation::~BufferAllocation() {
+  if (buffer != nullptr) {
    buffer->release();
  }
 }

-Buffer::Buffer(PGraphics graphics, uint64 size, void* data, bool dynamic, const std::string& name)
- : graphics(graphics) 
- , dynamic(dynamic)
- , name(name) {
+Buffer::Buffer(PGraphics graphics, uint64 size, void *data, bool dynamic,
+               const std::string &name)
+    : graphics(graphics), dynamic(dynamic), name(name) {
  createBuffer(size, data);
 }

 Buffer::~Buffer() {
  for (size_t i = 0; i < buffers.size(); ++i) {
-    //TODO
+    // TODO
  }
 }

-void* Buffer::map(bool) { return getHandle()->contents(); }
+void *Buffer::map(bool) { return getHandle()->contents(); }

-void* Buffer::mapRegion(uint64 regionOffset, uint64, bool) { return (char*)getHandle()->contents() + regionOffset; }
+void *Buffer::mapRegion(uint64 regionOffset, uint64, bool) {
+  return (char *)getHandle()->contents() + regionOffset;
+}

 void Buffer::unmap() {}

-void Buffer::rotateBuffer(uint64 size)
-{
+void Buffer::rotateBuffer(uint64 size) {
  size = std::max(getSize(), size);
-  for(size_t i = 0; i < buffers.size(); ++i)
-  {
-    if(buffers[i]->isCurrentlyBound())
-    {
+  for (size_t i = 0; i < buffers.size(); ++i) {
+    if (buffers[i]->isCurrentlyBound()) {
      continue;
    }
-    if(buffers[i]->size < size)
-    {
+    if (buffers[i]->size < size) {
      buffers[i]->buffer->release();
-      buffers[i]->buffer = graphics->getDevice()->newBuffer(size, MTL::StorageModeShared);
+      buffers[i]->buffer =
+          graphics->getDevice()->newBuffer(size, MTL::StorageModeShared);
      buffers[i]->size = size;
    }
    currentBuffer = i;
@@ -63,79 +58,106 @@ void Buffer::rotateBuffer(uint64 size)
  currentBuffer = buffers.size() - 1;
 }

-void Buffer::createBuffer(uint64 size, void* data)
-{
+void Buffer::createBuffer(uint64 size, void *data) {
  buffers.add(new BufferAllocation(graphics));
  if (data != nullptr) {
-    buffers.back()->buffer = graphics->getDevice()->newBuffer(data, size, MTL::StorageModeShared);
+    buffers.back()->buffer =
+        graphics->getDevice()->newBuffer(data, size, MTL::StorageModeShared);
  } else {
-    buffers.back()->buffer = graphics->getDevice()->newBuffer(size, MTL::StorageModeShared);
+    buffers.back()->buffer =
+        graphics->getDevice()->newBuffer(size, MTL::StorageModeShared);
  }
-  buffers.back()->buffer->setLabel(NS::String::string(name.c_str(), NS::ASCIIStringEncoding));
+  buffers.back()->buffer->setLabel(
+      NS::String::string(name.c_str(), NS::ASCIIStringEncoding));
 }

-VertexBuffer::VertexBuffer(PGraphics graphics, const VertexBufferCreateInfo& createInfo)
-    : Gfx::VertexBuffer(graphics->getFamilyMapping(), createInfo.numVertices, createInfo.vertexSize,
-                        createInfo.sourceData.owner),
-      Seele::Metal::Buffer(graphics, createInfo.sourceData.size, createInfo.sourceData.data, false, createInfo.name) {}
+VertexBuffer::VertexBuffer(PGraphics graphics,
+                           const VertexBufferCreateInfo &createInfo)
+    : Gfx::VertexBuffer(graphics->getFamilyMapping(), createInfo.numVertices,
+                        createInfo.vertexSize, createInfo.sourceData.owner),
+      Seele::Metal::Buffer(graphics, createInfo.sourceData.size,
+                           createInfo.sourceData.data, false, createInfo.name) {
+}

 VertexBuffer::~VertexBuffer() {}

 void VertexBuffer::updateRegion(DataSource update) {
-  void* data = getHandle()->contents();
-  std::memcpy((char*)data + update.offset, update.data, update.size);
+  void *data = getHandle()->contents();
+  std::memcpy((char *)data + update.offset, update.data, update.size);
 }

-void VertexBuffer::download(Array<uint8>& buffer) {
-  void* data = getHandle()->contents();
+void VertexBuffer::download(Array<uint8> &buffer) {
+  void *data = getHandle()->contents();
  buffer.resize(getSize());
  std::memcpy(buffer.data(), data, getSize());
 }

-void VertexBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner) { currentOwner = newOwner; }
-
-void VertexBuffer::executePipelineBarrier(Gfx::SeAccessFlags srcAccess, Gfx::SePipelineStageFlags srcStage,
-                                          Gfx::SeAccessFlags dstAccess, Gfx::SePipelineStageFlags dstStage) {
-  
+void VertexBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner) {
+  currentOwner = newOwner;
 }

-IndexBuffer::IndexBuffer(PGraphics graphics, const IndexBufferCreateInfo& createInfo)
-    : Gfx::IndexBuffer(graphics->getFamilyMapping(), createInfo.sourceData.size, createInfo.indexType,
-                       createInfo.sourceData.owner),
-      Seele::Metal::Buffer(graphics, createInfo.sourceData.size, createInfo.sourceData.data, false, createInfo.name) {}
+void VertexBuffer::executePipelineBarrier(Gfx::SeAccessFlags srcAccess,
+                                          Gfx::SePipelineStageFlags srcStage,
+                                          Gfx::SeAccessFlags dstAccess,
+                                          Gfx::SePipelineStageFlags dstStage) {}
+
+IndexBuffer::IndexBuffer(PGraphics graphics,
+                         const IndexBufferCreateInfo &createInfo)
+    : Gfx::IndexBuffer(graphics->getFamilyMapping(), createInfo.sourceData.size,
+                       createInfo.indexType, createInfo.sourceData.owner),
+      Seele::Metal::Buffer(graphics, createInfo.sourceData.size,
+                           createInfo.sourceData.data, false, createInfo.name) {
+}

 IndexBuffer::~IndexBuffer() {}

-void IndexBuffer::download(Array<uint8>& buffer) {
-  void* data = getHandle()->contents();
+void IndexBuffer::download(Array<uint8> &buffer) {
+  void *data = getHandle()->contents();
  buffer.resize(getSize());
  std::memcpy(buffer.data(), data, getSize());
 }
-void IndexBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner) { currentOwner = newOwner; }
+void IndexBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner) {
+  currentOwner = newOwner;
+}

-void IndexBuffer::executePipelineBarrier(Gfx::SeAccessFlags srcAccess, Gfx::SePipelineStageFlags srcStage,
-                                          Gfx::SeAccessFlags dstAccess, Gfx::SePipelineStageFlags dstStage) {}
+void IndexBuffer::executePipelineBarrier(Gfx::SeAccessFlags srcAccess,
+                                         Gfx::SePipelineStageFlags srcStage,
+                                         Gfx::SeAccessFlags dstAccess,
+                                         Gfx::SePipelineStageFlags dstStage) {}

-UniformBuffer::UniformBuffer(PGraphics graphics, const UniformBufferCreateInfo& createInfo)
+UniformBuffer::UniformBuffer(PGraphics graphics,
+                             const UniformBufferCreateInfo &createInfo)
    : Gfx::UniformBuffer(graphics->getFamilyMapping(), createInfo.sourceData),
-      Seele::Metal::Buffer(graphics, createInfo.sourceData.size, createInfo.sourceData.data, createInfo.dynamic, createInfo.name) {}
+      Seele::Metal::Buffer(graphics, createInfo.sourceData.size,
+                           createInfo.sourceData.data, createInfo.dynamic,
+                           createInfo.name) {}

 UniformBuffer::~UniformBuffer() {}

-bool UniformBuffer::updateContents(const DataSource& sourceData) {
-  void* data = getHandle()->contents();
-  std::memcpy((char*)data + sourceData.offset, sourceData.data, sourceData.size);
+bool UniformBuffer::updateContents(const DataSource &sourceData) {
+  void *data = getHandle()->contents();
+  std::memcpy((char *)data + sourceData.offset, sourceData.data,
+              sourceData.size);
  return true;
 }

-void UniformBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner) { currentOwner = newOwner; }
+void UniformBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner) {
+  currentOwner = newOwner;
+}

-void UniformBuffer::executePipelineBarrier(Gfx::SeAccessFlags srcAccess, Gfx::SePipelineStageFlags srcStage,
-                                          Gfx::SeAccessFlags dstAccess, Gfx::SePipelineStageFlags dstStage) {}
+void UniformBuffer::executePipelineBarrier(Gfx::SeAccessFlags srcAccess,
+                                           Gfx::SePipelineStageFlags srcStage,
+                                           Gfx::SeAccessFlags dstAccess,
+                                           Gfx::SePipelineStageFlags dstStage) {
+}

-ShaderBuffer::ShaderBuffer(PGraphics graphics, const ShaderBufferCreateInfo& createInfo)
-    : Gfx::ShaderBuffer(graphics->getFamilyMapping(), createInfo.numElements, createInfo.sourceData),
-      Seele::Metal::Buffer(graphics, createInfo.sourceData.size, createInfo.sourceData.data, createInfo.dynamic, createInfo.name) {}
+ShaderBuffer::ShaderBuffer(PGraphics graphics,
+                           const ShaderBufferCreateInfo &createInfo)
+    : Gfx::ShaderBuffer(graphics->getFamilyMapping(), createInfo.numElements,
+                        createInfo.sourceData),
+      Seele::Metal::Buffer(graphics, createInfo.sourceData.size,
+                           createInfo.sourceData.data, createInfo.dynamic,
+                           createInfo.name) {}

 ShaderBuffer::~ShaderBuffer() {}

@@ -143,29 +165,28 @@ void ShaderBuffer::rotateBuffer(uint64 size) {
  Metal::Buffer::rotateBuffer(size);
 }

-void ShaderBuffer::updateContents(const ShaderBufferCreateInfo& createInfo) {
+void ShaderBuffer::updateContents(const ShaderBufferCreateInfo &createInfo) {
  Gfx::ShaderBuffer::updateContents(createInfo);
-  if(createInfo.sourceData.data == nullptr)
-  {
+  if (createInfo.sourceData.data == nullptr) {
    return;
  }
-  void* data = map();
-  std::memcpy((char*)data + createInfo.sourceData.offset, createInfo.sourceData.data, createInfo.sourceData.size);
+  void *data = map();
+  std::memcpy((char *)data + createInfo.sourceData.offset,
+              createInfo.sourceData.data, createInfo.sourceData.size);
  unmap();
 }

-void* ShaderBuffer::mapRegion(uint64 offset, uint64 size, bool writeOnly)
-{
+void *ShaderBuffer::mapRegion(uint64 offset, uint64 size, bool writeOnly) {
  return Metal::Buffer::mapRegion(offset, size, writeOnly);
 }

-void ShaderBuffer::unmap()
-{
-  Metal::Buffer::unmap();
+void ShaderBuffer::unmap() { Metal::Buffer::unmap(); }
+
+void ShaderBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner) {
+  currentOwner = newOwner;
 }

-void ShaderBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner) { currentOwner = newOwner; }
-
-
-void ShaderBuffer::executePipelineBarrier(Gfx::SeAccessFlags srcAccess, Gfx::SePipelineStageFlags srcStage,
-                                          Gfx::SeAccessFlags dstAccess, Gfx::SePipelineStageFlags dstStage) {}
+void ShaderBuffer::executePipelineBarrier(Gfx::SeAccessFlags srcAccess,
+                                          Gfx::SePipelineStageFlags srcStage,
+                                          Gfx::SeAccessFlags dstAccess,
+                                          Gfx::SePipelineStageFlags dstStage) {}