Implemented basic game dll interaction

src/Engine/Graphics/Graphics.cpp

@@ -25,4 +25,4 @@ PVertexBuffer Graphics::getNullVertexBuffer()
         nullVertexBuffer = createVertexBuffer(createInfo);
     }
     return nullVertexBuffer;
-}
+}

src/Engine/Graphics/Graphics.h

@@ -37,6 +37,8 @@ public:
     virtual void executeCommands(const Array<PComputeCommand>& commands) = 0;
 
     virtual PTexture2D createTexture2D(const TextureCreateInfo &createInfo) = 0;
+    virtual PTexture3D createTexture3D(const TextureCreateInfo &createInfo) = 0;
+    virtual PTextureCube createTextureCube(const TextureCreateInfo &createInfo) = 0;
     virtual PUniformBuffer createUniformBuffer(const UniformBufferCreateInfo &bulkData) = 0;
     virtual PStructuredBuffer createStructuredBuffer(const StructuredBufferCreateInfo &bulkData) = 0;
     virtual PVertexBuffer createVertexBuffer(const VertexBufferCreateInfo &bulkData) = 0;

src/Engine/Graphics/GraphicsResources.cpp

@@ -434,6 +434,24 @@ Texture2D::~Texture2D()
 {
 }
 
+Texture3D::Texture3D(QueueFamilyMapping mapping, Gfx::QueueType startQueueType)
+	: Texture(mapping, startQueueType)
+{	
+}
+
+Texture3D::~Texture3D()
+{
+}
+
+TextureCube::TextureCube(QueueFamilyMapping mapping, Gfx::QueueType startQueueType)
+	: Texture(mapping, startQueueType)
+{	
+}
+
+TextureCube::~TextureCube()
+{
+}
+
 RenderCommand::RenderCommand()
 {
 }

src/Engine/Graphics/GraphicsResources.h

@@ -45,7 +45,7 @@ DEFINE_REF(VertexShader)
 class ControlShader
 {
 public:
-    ControlShader() {}
+    ControlShader() : numPatchPoints(0) {}
     virtual ~ControlShader() {}
     uint32 getNumPatches() const { return numPatchPoints; }
 
@@ -555,6 +555,7 @@ protected:
         SeAccessFlags dstAccess, SePipelineStageFlags dstStage) = 0;
 };
 DEFINE_REF(Texture)
+
 class Texture2D : public Texture
 {
 public:
@@ -577,6 +578,50 @@ protected:
 };
 DEFINE_REF(Texture2D)
 
+class Texture3D : public Texture
+{
+public:
+    Texture3D(QueueFamilyMapping mapping, QueueType startQueueType);
+    virtual ~Texture3D();
+
+    virtual SeFormat getFormat() const = 0;
+    virtual uint32 getSizeX() const = 0;
+    virtual uint32 getSizeY() const = 0;
+    virtual uint32 getSizeZ() const = 0;
+    virtual SeSampleCountFlags getNumSamples() const = 0;
+    virtual uint32 getMipLevels() const = 0;
+    virtual void changeLayout(SeImageLayout newLayout) = 0;
+    virtual class Texture3D* getTexture3D() { return this; }
+protected:
+    //Inherited via QueueOwnedResource
+    virtual void executeOwnershipBarrier(QueueType newOwner) = 0;
+    virtual void executePipelineBarrier(SeAccessFlags srcAccess, SePipelineStageFlags srcStage, 
+        SeAccessFlags dstAccess, SePipelineStageFlags dstStage) = 0;
+};
+DEFINE_REF(Texture3D)
+
+class TextureCube : public Texture
+{
+public:
+    TextureCube(QueueFamilyMapping mapping, QueueType startQueueType);
+    virtual ~TextureCube();
+
+    virtual SeFormat getFormat() const = 0;
+    virtual uint32 getSizeX() const = 0;
+    virtual uint32 getSizeY() const = 0;
+    virtual uint32 getSizeZ() const = 0;
+    virtual SeSampleCountFlags getNumSamples() const = 0;
+    virtual uint32 getMipLevels() const = 0;
+    virtual void changeLayout(SeImageLayout newLayout) = 0;
+    virtual class TextureCube* getTextureCube() { return this; }
+protected:
+    //Inherited via QueueOwnedResource
+    virtual void executeOwnershipBarrier(QueueType newOwner) = 0;
+    virtual void executePipelineBarrier(SeAccessFlags srcAccess, SePipelineStageFlags srcStage, 
+        SeAccessFlags dstAccess, SePipelineStageFlags dstStage) = 0;
+};
+DEFINE_REF(TextureCube)
+
 DECLARE_REF(Viewport)
 class RenderCommand
 {
@@ -684,6 +729,8 @@ public:
         , stencilLoadOp(stencilLoadOp)
         , stencilStoreOp(stencilStoreOp)
         , texture(texture)
+        , clear()
+        , componentFlags(0)
     {
     }
     virtual ~RenderTargetAttachment()

src/Engine/Graphics/RenderPass/CMakeLists.txt

@@ -14,6 +14,8 @@ target_sources(Engine
         RenderGraphResources.h
         RenderGraphResources.cpp
         RenderPass.h
+        SkyboxRenderPass.h
+        SkyboxRenderPass.cpp
         TextPass.h
         TextPass.cpp
         UIPass.h
@@ -30,5 +32,6 @@ target_sources(Engine
             RenderGraph.h
             RenderGraphResources.h
             RenderPass.h
+            SkyboxRenderPass.h
             TextPass.h
             UIPass.h)

src/Engine/Graphics/RenderPass/SkyboxRenderPass.cpp

@@ -0,0 +1,194 @@
+#include "SkyboxRenderPass.h"
+#include "Graphics/Graphics.h"
+
+using namespace Seele;
+
+SkyboxRenderPass::SkyboxRenderPass(Gfx::PGraphics graphics)
+    : RenderPass(graphics)
+{
+    Array<Vector> vertices = {
+        // Back
+        Vector(-1, -1, -1),
+        Vector(1, -1, -1),
+        Vector(-1,  1, -1),
+
+        Vector(1, -1, -1),
+        Vector(-1,  1, -1),
+        Vector(1,  1, -1),
+
+        // Front
+        Vector(1, -1,  1),
+        Vector(-1,  1,  1),
+        Vector(-1, -1,  1),
+
+        Vector(-1,  1,  1),
+        Vector(1,  1,  1),
+        Vector(1, -1,  1),
+
+        // Top
+        Vector(-1, -1, -1),
+        Vector(1, -1, -1),
+        Vector(1, -1,  1),
+
+        Vector(1, -1, -1),
+        Vector(1, -1,  1),
+        Vector(1, -1,  1),
+
+        // Bottom
+        Vector(-1,  1, -1),
+        Vector(-1,  1,  1),
+        Vector(1,  1, -1),
+
+        Vector(1,  1, -1),
+        Vector(-1,  1,  1),
+        Vector(1,  1,  1),
+
+        // Left
+        Vector(-1, -1, -1),
+        Vector(-1, -1,  1),
+        Vector(-1,  1, -1),
+
+        Vector(-1,  1, -1),
+        Vector(-1, -1,  1),
+        Vector(-1,  1,  1),
+
+        // Right
+        Vector(1, -1,  1),
+        Vector(1,  1, -1),
+        Vector(1, -1, -1),
+
+        Vector(1, -1,  1),
+        Vector(1,  1,  1),
+        Vector(1,  1, -1),
+    };
+
+    VertexBufferCreateInfo vertexBufferInfo = {
+        .resourceData = {
+            .size = sizeof(Vector) * vertices.size(),
+            .data = (uint8*)vertices.data(),
+        },
+        .vertexSize = sizeof(Vector),
+        .numVertices = (uint32)vertices.size(),
+    };
+    cubeBuffer = graphics->createVertexBuffer(vertexBufferInfo);
+}
+SkyboxRenderPass::~SkyboxRenderPass()
+{
+
+}
+
+void SkyboxRenderPass::beginFrame(const Component::Camera& cam)
+{
+    BulkResourceData uniformUpdate;
+
+    viewParams.viewMatrix = cam.getViewMatrix();
+    viewParams.projectionMatrix = viewport->getProjectionMatrix();
+    viewParams.cameraPosition = Vector4(cam.getCameraPosition(), 0);
+    viewParams.screenDimensions = Vector2(static_cast<float>(viewport->getSizeX()), static_cast<float>(viewport->getSizeY()));
+    uniformUpdate.size = sizeof(ViewParameter);
+    uniformUpdate.data = (uint8*)&viewParams;
+    viewParamsBuffer->updateContents(uniformUpdate);
+    descriptorLayout->reset();
+    descriptorSet = descriptorLayout->allocateDescriptorSet();
+    descriptorSet->updateBuffer(0, viewParamsBuffer);
+    descriptorSet->updateTexture(1, passData.skybox.day);
+    descriptorSet->updateTexture(2, passData.skybox.night);
+    descriptorSet->updateSampler(3, passData.skybox.sampler);
+    descriptorSet->writeChanges();
+}
+
+void SkyboxRenderPass::render()
+{
+    graphics->beginRenderPass(renderPass);
+    Gfx::PRenderCommand renderCommand = graphics->createRenderCommand("SkyboxRender");
+    renderCommand->setViewport(viewport);
+    renderCommand->bindPipeline(pipeline);
+    renderCommand->bindDescriptor(descriptorSet);
+    renderCommand->bindVertexBuffer({ VertexInputStream(0, 0, cubeBuffer) });
+    renderCommand->pushConstants(pipelineLayout, Gfx::SE_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, sizeof(Vector), &passData.skybox.fogColor);
+    renderCommand->pushConstants(pipelineLayout, Gfx::SE_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, sizeof(Vector), sizeof(float), &passData.skybox.blendFactor);
+    renderCommand->draw(36, 1, 0, 0);
+    graphics->executeCommands(Array{ renderCommand });
+    graphics->endRenderPass();
+}
+
+void SkyboxRenderPass::endFrame()
+{
+
+}
+
+void SkyboxRenderPass::publishOutputs()
+{
+    UniformBufferCreateInfo viewCreateInfo = {
+        .resourceData = BulkResourceData {
+            .size = sizeof(ViewParameter),
+            .data = nullptr,
+        },
+        .bDynamic = true
+    };
+    viewParamsBuffer = graphics->createUniformBuffer(viewCreateInfo);
+
+    descriptorLayout = graphics->createDescriptorLayout("SkyboxDescLayout");
+    descriptorLayout->addDescriptorBinding(0, Gfx::SE_DESCRIPTOR_TYPE_UNIFORM_BUFFER);
+    descriptorLayout->addDescriptorBinding(1, Gfx::SE_DESCRIPTOR_TYPE_SAMPLED_IMAGE);
+    descriptorLayout->addDescriptorBinding(2, Gfx::SE_DESCRIPTOR_TYPE_SAMPLED_IMAGE);
+    descriptorLayout->addDescriptorBinding(3, Gfx::SE_DESCRIPTOR_TYPE_SAMPLER);
+    descriptorLayout->create();
+
+    pipelineLayout = graphics->createPipelineLayout();
+    pipelineLayout->addDescriptorLayout(0, descriptorLayout);
+    pipelineLayout->addPushConstants(Gfx::SePushConstantRange{
+        .stageFlags = Gfx::SE_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
+        .offset = 0,
+        .size = sizeof(Vector),
+        });
+    pipelineLayout->addPushConstants(Gfx::SePushConstantRange{
+        .stageFlags = Gfx::SE_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
+        .offset = sizeof(Vector),
+        .size = sizeof(float),
+        });
+
+    pipelineLayout->create();
+}
+
+void SkyboxRenderPass::createRenderPass()
+{
+    Gfx::PRenderTargetAttachment baseColorAttachment = resources->requestRenderTarget("BASEPASS_COLOR");
+    baseColorAttachment->loadOp = Gfx::SE_ATTACHMENT_LOAD_OP_LOAD;
+    Gfx::PRenderTargetAttachment depthAttachment = resources->requestRenderTarget("DEPTHPREPASS_DEPTH");
+    depthAttachment->loadOp = Gfx::SE_ATTACHMENT_LOAD_OP_LOAD;
+    Gfx::PRenderTargetLayout layout = new Gfx::RenderTargetLayout(baseColorAttachment, depthAttachment);
+    renderPass = graphics->createRenderPass(layout, viewport);
+
+    ShaderCreateInfo createInfo;
+    createInfo.name = "SkyboxVertex";
+    createInfo.mainModule = "Skybox";
+    createInfo.entryPoint = "vertexMain";
+    createInfo.defines["INDEX_VIEW_PARAMS"] = "0";
+    Gfx::PVertexShader vertexShader = graphics->createVertexShader(createInfo);
+
+    createInfo.name = "SkyboxFragment";
+    createInfo.entryPoint = "fragmentMain";
+    Gfx::PFragmentShader fragmentShader = graphics->createFragmentShader(createInfo);
+
+    Gfx::PVertexDeclaration vertexDecl = graphics->createVertexDeclaration({
+        Gfx::VertexElement {
+            .streamIndex = 0,
+            .offset = 0,
+            .vertexFormat = Gfx::SE_FORMAT_R32G32B32_SFLOAT,
+            .attributeIndex = 0,
+            .stride = sizeof(Vector),
+        }
+        });
+
+    GraphicsPipelineCreateInfo gfxInfo;
+    gfxInfo.vertexDeclaration = vertexDecl;
+    gfxInfo.vertexShader = vertexShader;
+    gfxInfo.fragmentShader = fragmentShader;
+    gfxInfo.rasterizationState.polygonMode = Gfx::SE_POLYGON_MODE_FILL;
+    gfxInfo.rasterizationState.lineWidth = 5.f;
+    gfxInfo.topology = Gfx::SE_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
+    gfxInfo.pipelineLayout = pipelineLayout;
+    gfxInfo.renderPass = renderPass;
+    pipeline = graphics->createGraphicsPipeline(gfxInfo);
+}

src/Engine/Graphics/RenderPass/SkyboxRenderPass.h

@@ -0,0 +1,34 @@
+#pragma once
+#include "RenderPass.h"
+#include "Graphics/GraphicsResources.h"
+#include "Component/Skybox.h"
+
+namespace Seele
+{
+DECLARE_REF(CameraActor)
+DECLARE_REF(Scene)
+DECLARE_REF(Viewport)
+struct SkyboxPassData
+{
+    Component::Skybox skybox;
+};
+class SkyboxRenderPass : public RenderPass<SkyboxPassData>
+{
+public:
+    SkyboxRenderPass(Gfx::PGraphics graphics);
+    virtual ~SkyboxRenderPass();
+    virtual void beginFrame(const Component::Camera& cam) override;
+    virtual void render() override;
+    virtual void endFrame() override;
+    virtual void publishOutputs() override;
+    virtual void createRenderPass() override;
+private:
+    Gfx::PVertexBuffer cubeBuffer;
+    Gfx::PUniformBuffer viewParamsBuffer;
+    Gfx::PDescriptorLayout descriptorLayout;
+    Gfx::PDescriptorSet descriptorSet;
+    Gfx::PPipelineLayout pipelineLayout;
+    Gfx::PGraphicsPipeline pipeline;
+};
+DEFINE_REF(SkyboxRenderPass)
+} // namespace Seele

src/Engine/Graphics/Vulkan/VulkanGraphics.cpp

@@ -116,6 +116,18 @@ Gfx::PTexture2D Graphics::createTexture2D(const TextureCreateInfo &createInfo)
     return result;
 }
 
+Gfx::PTexture3D Graphics::createTexture3D(const TextureCreateInfo &createInfo)
+{
+    PTexture3D result = new Texture3D(this, createInfo);
+    return result;
+}
+
+Gfx::PTextureCube Graphics::createTextureCube(const TextureCreateInfo &createInfo)
+{
+    PTextureCube result = new TextureCube(this, createInfo);
+    return result;
+}
+
 Gfx::PUniformBuffer Graphics::createUniformBuffer(const UniformBufferCreateInfo &bulkData)
 {
     PUniformBuffer uniformBuffer = new UniformBuffer(this, bulkData);

src/Engine/Graphics/Vulkan/VulkanGraphics.h

@@ -45,6 +45,8 @@ public:
     virtual void executeCommands(const Array<Gfx::PComputeCommand>& commands) override;
 
     virtual Gfx::PTexture2D createTexture2D(const TextureCreateInfo &createInfo) override;
+    virtual Gfx::PTexture3D createTexture3D(const TextureCreateInfo &createInfo) override;
+    virtual Gfx::PTextureCube createTextureCube(const TextureCreateInfo &createInfo) override;
     virtual Gfx::PUniformBuffer createUniformBuffer(const UniformBufferCreateInfo &bulkData) override;
     virtual Gfx::PStructuredBuffer createStructuredBuffer(const StructuredBufferCreateInfo &bulkData) override;
     virtual Gfx::PVertexBuffer createVertexBuffer(const VertexBufferCreateInfo &bulkData) override;

src/Engine/Graphics/Vulkan/VulkanGraphicsResources.h

@@ -268,6 +268,8 @@ private:
     Gfx::SeImageLayout layout;
     friend class TextureBase;
     friend class Texture2D;
+    friend class Texture3D;
+    friend class TextureCube;
     friend class Graphics;
 };
 
@@ -336,6 +338,116 @@ protected:
 };
 DEFINE_REF(Texture2D)
 
+class Texture3D : public Gfx::Texture3D, public TextureBase
+{
+public:
+    Texture3D(PGraphics graphics, const TextureCreateInfo& createInfo, VkImage existingImage = VK_NULL_HANDLE);
+    virtual ~Texture3D();
+    virtual uint32 getSizeX() const override
+    {
+        return textureHandle->sizeX;
+    }
+    virtual uint32 getSizeY() const override
+    {
+        return textureHandle->sizeY;
+    }
+    virtual uint32 getSizeZ() const override
+    {
+        return textureHandle->sizeZ;
+    }
+    virtual Gfx::SeFormat getFormat() const override
+    {
+        return textureHandle->format;
+    }
+    virtual Gfx::SeSampleCountFlags getNumSamples() const override
+    {
+        return textureHandle->getNumSamples();
+    }
+    virtual uint32 getMipLevels() const override
+    {
+        return textureHandle->getMipLevels();
+    }
+    virtual void changeLayout(Gfx::SeImageLayout newLayout) override;
+    virtual void* getNativeHandle() override
+    {
+        return textureHandle;
+    }
+    inline VkImage getHandle() const
+    {
+        return textureHandle->image;
+    }
+    inline VkImageView getView() const
+    {
+        return textureHandle->defaultView;
+    }
+    inline bool isDepthStencil() const
+    {
+        return textureHandle->isDepthStencil();
+    }
+protected:
+    // Inherited via QueueOwnedResource
+    virtual void executeOwnershipBarrier(Gfx::QueueType newOwner);
+    virtual void executePipelineBarrier(VkAccessFlags srcAccess, VkPipelineStageFlags srcStage, 
+        VkAccessFlags dstAccess, VkPipelineStageFlags dstStage);
+
+};
+DEFINE_REF(Texture3D)
+
+class TextureCube : public Gfx::TextureCube, public TextureBase
+{
+public:
+    TextureCube(PGraphics graphics, const TextureCreateInfo& createInfo, VkImage existingImage = VK_NULL_HANDLE);
+    virtual ~TextureCube();
+    virtual uint32 getSizeX() const override
+    {
+        return textureHandle->sizeX;
+    }
+    virtual uint32 getSizeY() const override
+    {
+        return textureHandle->sizeY;
+    }
+    virtual uint32 getSizeZ() const override
+    {
+        return textureHandle->sizeZ;
+    }
+    virtual Gfx::SeFormat getFormat() const override
+    {
+        return textureHandle->format;
+    }
+    virtual Gfx::SeSampleCountFlags getNumSamples() const override
+    {
+        return textureHandle->getNumSamples();
+    }
+    virtual uint32 getMipLevels() const override
+    {
+        return textureHandle->getMipLevels();
+    }
+    virtual void changeLayout(Gfx::SeImageLayout newLayout) override;
+    virtual void* getNativeHandle() override
+    {
+        return textureHandle;
+    }
+    inline VkImage getHandle() const
+    {
+        return textureHandle->image;
+    }
+    inline VkImageView getView() const
+    {
+        return textureHandle->defaultView;
+    }
+    inline bool isDepthStencil() const
+    {
+        return textureHandle->isDepthStencil();
+    }
+protected:
+    // Inherited via QueueOwnedResource
+    virtual void executeOwnershipBarrier(Gfx::QueueType newOwner);
+    virtual void executePipelineBarrier(VkAccessFlags srcAccess, VkPipelineStageFlags srcStage, 
+        VkAccessFlags dstAccess, VkPipelineStageFlags dstStage);
+
+};
+DEFINE_REF(TextureCube)
+
 class SamplerState : public Gfx::SamplerState
 {
 public:

src/Engine/Graphics/Vulkan/VulkanTexture.cpp

@@ -305,4 +305,58 @@ void Texture2D::executePipelineBarrier(VkAccessFlags srcAccess, VkPipelineStageF
         VkAccessFlags dstAccess, VkPipelineStageFlags dstStage) 
 {
     textureHandle->executePipelineBarrier(srcAccess, srcStage, dstAccess, dstStage);
-}
+}
+
+Texture3D::Texture3D(PGraphics graphics, const TextureCreateInfo& createInfo, VkImage existingImage)
+    : Gfx::Texture3D(graphics->getFamilyMapping(), createInfo.resourceData.owner)
+{
+    textureHandle = new TextureHandle(graphics, VK_IMAGE_VIEW_TYPE_3D, 
+        createInfo, currentOwner, existingImage);
+}
+
+Texture3D::~Texture3D()
+{
+}
+
+void Texture3D::changeLayout(Gfx::SeImageLayout newLayout) 
+{
+    textureHandle->changeLayout(newLayout);
+}
+
+void Texture3D::executeOwnershipBarrier(Gfx::QueueType newOwner)
+{
+    textureHandle->executeOwnershipBarrier(newOwner);
+}
+
+void Texture3D::executePipelineBarrier(VkAccessFlags srcAccess, VkPipelineStageFlags srcStage, 
+        VkAccessFlags dstAccess, VkPipelineStageFlags dstStage) 
+{
+    textureHandle->executePipelineBarrier(srcAccess, srcStage, dstAccess, dstStage);
+}
+
+TextureCube::TextureCube(PGraphics graphics, const TextureCreateInfo& createInfo, VkImage existingImage)
+    : Gfx::TextureCube(graphics->getFamilyMapping(), createInfo.resourceData.owner)
+{
+    textureHandle = new TextureHandle(graphics, createInfo.bArray ? VK_IMAGE_VIEW_TYPE_CUBE_ARRAY : VK_IMAGE_VIEW_TYPE_CUBE, 
+        createInfo, currentOwner, existingImage);
+}
+
+TextureCube::~TextureCube()
+{
+}
+
+void TextureCube::changeLayout(Gfx::SeImageLayout newLayout) 
+{
+    textureHandle->changeLayout(newLayout);
+}
+
+void TextureCube::executeOwnershipBarrier(Gfx::QueueType newOwner)
+{
+    textureHandle->executeOwnershipBarrier(newOwner);
+}
+
+void TextureCube::executePipelineBarrier(VkAccessFlags srcAccess, VkPipelineStageFlags srcStage, 
+        VkAccessFlags dstAccess, VkPipelineStageFlags dstStage) 
+{
+    textureHandle->executePipelineBarrier(srcAccess, srcStage, dstAccess, dstStage);
+}