Added Daybreak, a system updater homebrew (#1073)
* Implemented a system updater homebrew (titled Daybreak) * git subrepo pull ./troposphere/daybreak/nanovg subrepo: subdir: "troposphere/daybreak/nanovg" merged: "c197ba2f" upstream: origin: "https://github.com/Adubbz/nanovg-deko.git" branch: "master" commit: "c197ba2f" git-subrepo: version: "0.4.1" origin: "???" commit: "???" (+1 squashed commits) Squashed commits: [232dc943] git subrepo clone https://github.com/Adubbz/nanovg-deko.git troposphere/daybreak/nanovg subrepo: subdir: "troposphere/daybreak/nanovg" merged: "52bb784b" upstream: origin: "https://github.com/Adubbz/nanovg-deko.git" branch: "master" commit: "52bb784b" git-subrepo: version: "0.4.1" origin: "???" commit: "???" * daybreak: switch to using hiddbg for home blocking (+1 squashed commits) Squashed commits: [4bfc7b0d] daybreak: block the home button during installation
This commit is contained in:
Adubbz
@@ -0,0 +1,38 @@
|
||||
/*
|
||||
** Sample Framework for deko3d Applications
|
||||
** CApplication.h: Wrapper class containing common application boilerplate
|
||||
*/
|
||||
#pragma once
|
||||
#include "common.h"
|
||||
|
||||
class CApplication
|
||||
{
|
||||
protected:
|
||||
virtual void onFocusState(AppletFocusState) { }
|
||||
virtual void onOperationMode(AppletOperationMode) { }
|
||||
virtual bool onFrame(u64) { return true; }
|
||||
|
||||
public:
|
||||
CApplication();
|
||||
~CApplication();
|
||||
|
||||
void run();
|
||||
|
||||
static constexpr void chooseFramebufferSize(uint32_t& width, uint32_t& height, AppletOperationMode mode);
|
||||
};
|
||||
|
||||
constexpr void CApplication::chooseFramebufferSize(uint32_t& width, uint32_t& height, AppletOperationMode mode)
|
||||
{
|
||||
switch (mode)
|
||||
{
|
||||
default:
|
||||
case AppletOperationMode_Handheld:
|
||||
width = 1280;
|
||||
height = 720;
|
||||
break;
|
||||
case AppletOperationMode_Docked:
|
||||
width = 1920;
|
||||
height = 1080;
|
||||
break;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,57 @@
|
||||
/*
|
||||
** Sample Framework for deko3d Applications
|
||||
** CCmdMemRing.h: Memory provider class for dynamic command buffers
|
||||
*/
|
||||
#pragma once
|
||||
#include "common.h"
|
||||
#include "CMemPool.h"
|
||||
|
||||
template <unsigned NumSlices>
|
||||
class CCmdMemRing
|
||||
{
|
||||
static_assert(NumSlices > 0, "Need a non-zero number of slices...");
|
||||
CMemPool::Handle m_mem;
|
||||
unsigned m_curSlice;
|
||||
dk::Fence m_fences[NumSlices];
|
||||
public:
|
||||
CCmdMemRing() : m_mem{}, m_curSlice{}, m_fences{} { }
|
||||
~CCmdMemRing()
|
||||
{
|
||||
m_mem.destroy();
|
||||
}
|
||||
|
||||
bool allocate(CMemPool& pool, uint32_t sliceSize)
|
||||
{
|
||||
sliceSize = (sliceSize + DK_CMDMEM_ALIGNMENT - 1) &~ (DK_CMDMEM_ALIGNMENT - 1);
|
||||
m_mem = pool.allocate(NumSlices*sliceSize);
|
||||
return m_mem;
|
||||
}
|
||||
|
||||
void begin(dk::CmdBuf cmdbuf)
|
||||
{
|
||||
// Clear/reset the command buffer, which also destroys all command list handles
|
||||
// (but remember: it does *not* in fact destroy the command data)
|
||||
cmdbuf.clear();
|
||||
|
||||
// Wait for the current slice of memory to be available, and feed it to the command buffer
|
||||
uint32_t sliceSize = m_mem.getSize() / NumSlices;
|
||||
m_fences[m_curSlice].wait();
|
||||
|
||||
// Feed the memory to the command buffer
|
||||
cmdbuf.addMemory(m_mem.getMemBlock(), m_mem.getOffset() + m_curSlice * sliceSize, sliceSize);
|
||||
}
|
||||
|
||||
DkCmdList end(dk::CmdBuf cmdbuf)
|
||||
{
|
||||
// Signal the fence corresponding to the current slice; so that in the future when we want
|
||||
// to use it again, we can wait for the completion of the commands we've just submitted
|
||||
// (and as such we don't overwrite in-flight command data with new one)
|
||||
cmdbuf.signalFence(m_fences[m_curSlice]);
|
||||
|
||||
// Advance the current slice counter; wrapping around when we reach the end
|
||||
m_curSlice = (m_curSlice + 1) % NumSlices;
|
||||
|
||||
// Finish off the command list, returning it to the caller
|
||||
return cmdbuf.finishList();
|
||||
}
|
||||
};
|
||||
@@ -0,0 +1,71 @@
|
||||
/*
|
||||
** Sample Framework for deko3d Applications
|
||||
** CDescriptorSet.h: Image/Sampler descriptor set class
|
||||
*/
|
||||
#pragma once
|
||||
#include "common.h"
|
||||
#include "CMemPool.h"
|
||||
|
||||
template <unsigned NumDescriptors>
|
||||
class CDescriptorSet
|
||||
{
|
||||
static_assert(NumDescriptors > 0, "Need a non-zero number of descriptors...");
|
||||
static_assert(sizeof(DkImageDescriptor) == sizeof(DkSamplerDescriptor), "shouldn't happen");
|
||||
static_assert(DK_IMAGE_DESCRIPTOR_ALIGNMENT == DK_SAMPLER_DESCRIPTOR_ALIGNMENT, "shouldn't happen");
|
||||
static constexpr size_t DescriptorSize = sizeof(DkImageDescriptor);
|
||||
static constexpr size_t DescriptorAlign = DK_IMAGE_DESCRIPTOR_ALIGNMENT;
|
||||
|
||||
CMemPool::Handle m_mem;
|
||||
public:
|
||||
CDescriptorSet() : m_mem{} { }
|
||||
~CDescriptorSet()
|
||||
{
|
||||
m_mem.destroy();
|
||||
}
|
||||
|
||||
bool allocate(CMemPool& pool)
|
||||
{
|
||||
m_mem = pool.allocate(NumDescriptors*DescriptorSize, DescriptorAlign);
|
||||
return m_mem;
|
||||
}
|
||||
|
||||
void bindForImages(dk::CmdBuf cmdbuf)
|
||||
{
|
||||
cmdbuf.bindImageDescriptorSet(m_mem.getGpuAddr(), NumDescriptors);
|
||||
}
|
||||
|
||||
void bindForSamplers(dk::CmdBuf cmdbuf)
|
||||
{
|
||||
cmdbuf.bindSamplerDescriptorSet(m_mem.getGpuAddr(), NumDescriptors);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
void update(dk::CmdBuf cmdbuf, uint32_t id, T const& descriptor)
|
||||
{
|
||||
static_assert(sizeof(T) == DescriptorSize);
|
||||
cmdbuf.pushData(m_mem.getGpuAddr() + id*DescriptorSize, &descriptor, DescriptorSize);
|
||||
}
|
||||
|
||||
template <typename T, size_t N>
|
||||
void update(dk::CmdBuf cmdbuf, uint32_t id, std::array<T, N> const& descriptors)
|
||||
{
|
||||
static_assert(sizeof(T) == DescriptorSize);
|
||||
cmdbuf.pushData(m_mem.getGpuAddr() + id*DescriptorSize, descriptors.data(), descriptors.size()*DescriptorSize);
|
||||
}
|
||||
|
||||
#ifdef DK_HPP_SUPPORT_VECTOR
|
||||
template <typename T, typename Allocator = std::allocator<T>>
|
||||
void update(dk::CmdBuf cmdbuf, uint32_t id, std::vector<T,Allocator> const& descriptors)
|
||||
{
|
||||
static_assert(sizeof(T) == DescriptorSize);
|
||||
cmdbuf.pushData(m_mem.getGpuAddr() + id*DescriptorSize, descriptors.data(), descriptors.size()*DescriptorSize);
|
||||
}
|
||||
#endif
|
||||
|
||||
template <typename T>
|
||||
void update(dk::CmdBuf cmdbuf, uint32_t id, std::initializer_list<T const> const& descriptors)
|
||||
{
|
||||
static_assert(sizeof(T) == DescriptorSize);
|
||||
cmdbuf.pushData(m_mem.getGpuAddr() + id*DescriptorSize, descriptors.data(), descriptors.size()*DescriptorSize);
|
||||
}
|
||||
};
|
||||
@@ -0,0 +1,37 @@
|
||||
/*
|
||||
** Sample Framework for deko3d Applications
|
||||
** CExternalImage.h: Utility class for loading images from the filesystem
|
||||
*/
|
||||
#pragma once
|
||||
#include "common.h"
|
||||
#include "CMemPool.h"
|
||||
|
||||
class CExternalImage
|
||||
{
|
||||
dk::Image m_image;
|
||||
dk::ImageDescriptor m_descriptor;
|
||||
CMemPool::Handle m_mem;
|
||||
public:
|
||||
CExternalImage() : m_image{}, m_descriptor{}, m_mem{} { }
|
||||
~CExternalImage()
|
||||
{
|
||||
m_mem.destroy();
|
||||
}
|
||||
|
||||
constexpr operator bool() const
|
||||
{
|
||||
return m_mem;
|
||||
}
|
||||
|
||||
constexpr dk::Image& get()
|
||||
{
|
||||
return m_image;
|
||||
}
|
||||
|
||||
constexpr dk::ImageDescriptor const& getDescriptor() const
|
||||
{
|
||||
return m_descriptor;
|
||||
}
|
||||
|
||||
bool load(CMemPool& imagePool, CMemPool& scratchPool, dk::Device device, dk::Queue transferQueue, const char* path, uint32_t width, uint32_t height, DkImageFormat format, uint32_t flags = 0);
|
||||
};
|
||||
@@ -0,0 +1,119 @@
|
||||
/*
|
||||
** Sample Framework for deko3d Applications
|
||||
** CIntrusiveList.h: Intrusive doubly-linked list helper class
|
||||
*/
|
||||
#pragma once
|
||||
#include "common.h"
|
||||
|
||||
template <typename T>
|
||||
struct CIntrusiveListNode
|
||||
{
|
||||
T *m_next, *m_prev;
|
||||
|
||||
constexpr CIntrusiveListNode() : m_next{}, m_prev{} { }
|
||||
constexpr operator bool() const { return m_next || m_prev; }
|
||||
};
|
||||
|
||||
template <typename T, CIntrusiveListNode<T> T::* node_ptr>
|
||||
class CIntrusiveList
|
||||
{
|
||||
T *m_first, *m_last;
|
||||
|
||||
public:
|
||||
constexpr CIntrusiveList() : m_first{}, m_last{} { }
|
||||
|
||||
constexpr T* first() const { return m_first; }
|
||||
constexpr T* last() const { return m_last; }
|
||||
constexpr bool empty() const { return !m_first; }
|
||||
constexpr void clear() { m_first = m_last = nullptr; }
|
||||
|
||||
constexpr bool isLinked(T* obj) const { return obj->*node_ptr || m_first == obj; }
|
||||
constexpr T* prev(T* obj) const { return (obj->*node_ptr).m_prev; }
|
||||
constexpr T* next(T* obj) const { return (obj->*node_ptr).m_next; }
|
||||
|
||||
void add(T* obj)
|
||||
{
|
||||
return addBefore(nullptr, obj);
|
||||
}
|
||||
|
||||
void addBefore(T* pos, T* obj)
|
||||
{
|
||||
auto& node = obj->*node_ptr;
|
||||
node.m_next = pos;
|
||||
node.m_prev = pos ? (pos->*node_ptr).m_prev : m_last;
|
||||
|
||||
if (pos)
|
||||
(pos->*node_ptr).m_prev = obj;
|
||||
else
|
||||
m_last = obj;
|
||||
|
||||
if (node.m_prev)
|
||||
(node.m_prev->*node_ptr).m_next = obj;
|
||||
else
|
||||
m_first = obj;
|
||||
}
|
||||
|
||||
void addAfter(T* pos, T* obj)
|
||||
{
|
||||
auto& node = obj->*node_ptr;
|
||||
node.m_next = pos ? (pos->*node_ptr).m_next : m_first;
|
||||
node.m_prev = pos;
|
||||
|
||||
if (pos)
|
||||
(pos->*node_ptr).m_next = obj;
|
||||
else
|
||||
m_first = obj;
|
||||
|
||||
if (node.m_next)
|
||||
(node.m_next->*node_ptr).m_prev = obj;
|
||||
else
|
||||
m_last = obj;
|
||||
}
|
||||
|
||||
T* pop()
|
||||
{
|
||||
T* ret = m_first;
|
||||
if (ret)
|
||||
{
|
||||
m_first = (ret->*node_ptr).m_next;
|
||||
if (m_first)
|
||||
(m_first->*node_ptr).m_prev = nullptr;
|
||||
else
|
||||
m_last = nullptr;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
void remove(T* obj)
|
||||
{
|
||||
auto& node = obj->*node_ptr;
|
||||
if (node.m_prev)
|
||||
{
|
||||
(node.m_prev->*node_ptr).m_next = node.m_next;
|
||||
if (node.m_next)
|
||||
(node.m_next->*node_ptr).m_prev = node.m_prev;
|
||||
else
|
||||
m_last = node.m_prev;
|
||||
} else
|
||||
{
|
||||
m_first = node.m_next;
|
||||
if (m_first)
|
||||
(m_first->*node_ptr).m_prev = nullptr;
|
||||
else
|
||||
m_last = nullptr;
|
||||
}
|
||||
|
||||
node.m_next = node.m_prev = 0;
|
||||
}
|
||||
|
||||
template <typename L>
|
||||
void iterate(L lambda) const
|
||||
{
|
||||
T* next = nullptr;
|
||||
for (T* cur = m_first; cur; cur = next)
|
||||
{
|
||||
next = (cur->*node_ptr).m_next;
|
||||
lambda(cur);
|
||||
}
|
||||
}
|
||||
};
|
||||
@@ -0,0 +1,250 @@
|
||||
/*
|
||||
** Sample Framework for deko3d Applications
|
||||
** CIntrusiveTree.h: Intrusive red-black tree helper class
|
||||
*/
|
||||
#pragma once
|
||||
#include "common.h"
|
||||
|
||||
#include <functional>
|
||||
|
||||
struct CIntrusiveTreeNode
|
||||
{
|
||||
enum Color
|
||||
{
|
||||
Red,
|
||||
Black,
|
||||
};
|
||||
|
||||
enum Leaf
|
||||
{
|
||||
Left,
|
||||
Right,
|
||||
};
|
||||
|
||||
private:
|
||||
uintptr_t m_parent_color;
|
||||
CIntrusiveTreeNode* m_children[2];
|
||||
|
||||
public:
|
||||
constexpr CIntrusiveTreeNode() : m_parent_color{}, m_children{} { }
|
||||
|
||||
constexpr CIntrusiveTreeNode* getParent() const
|
||||
{
|
||||
return reinterpret_cast<CIntrusiveTreeNode*>(m_parent_color &~ 1);
|
||||
}
|
||||
|
||||
void setParent(CIntrusiveTreeNode* parent)
|
||||
{
|
||||
m_parent_color = (m_parent_color & 1) | reinterpret_cast<uintptr_t>(parent);
|
||||
}
|
||||
|
||||
constexpr Color getColor() const
|
||||
{
|
||||
return static_cast<Color>(m_parent_color & 1);
|
||||
}
|
||||
|
||||
void setColor(Color color)
|
||||
{
|
||||
m_parent_color = (m_parent_color &~ 1) | static_cast<uintptr_t>(color);
|
||||
}
|
||||
|
||||
constexpr CIntrusiveTreeNode*& child(Leaf leaf)
|
||||
{
|
||||
return m_children[leaf];
|
||||
}
|
||||
|
||||
constexpr CIntrusiveTreeNode* const& child(Leaf leaf) const
|
||||
{
|
||||
return m_children[leaf];
|
||||
}
|
||||
|
||||
//--------------------------------------
|
||||
|
||||
constexpr bool isRed() const { return getColor() == Red; }
|
||||
constexpr bool isBlack() const { return getColor() == Black; }
|
||||
void setRed() { setColor(Red); }
|
||||
void setBlack() { setColor(Black); }
|
||||
|
||||
constexpr CIntrusiveTreeNode*& left() { return child(Left); }
|
||||
constexpr CIntrusiveTreeNode*& right() { return child(Right); }
|
||||
constexpr CIntrusiveTreeNode* const& left() const { return child(Left); }
|
||||
constexpr CIntrusiveTreeNode* const& right() const { return child(Right); }
|
||||
};
|
||||
|
||||
NX_CONSTEXPR CIntrusiveTreeNode::Leaf operator!(CIntrusiveTreeNode::Leaf val) noexcept
|
||||
{
|
||||
return static_cast<CIntrusiveTreeNode::Leaf>(!static_cast<unsigned>(val));
|
||||
}
|
||||
|
||||
class CIntrusiveTreeBase
|
||||
{
|
||||
using N = CIntrusiveTreeNode;
|
||||
|
||||
void rotate(N* node, N::Leaf leaf);
|
||||
void recolor(N* parent, N* node);
|
||||
protected:
|
||||
N* m_root;
|
||||
|
||||
constexpr CIntrusiveTreeBase() : m_root{} { }
|
||||
|
||||
N* walk(N* node, N::Leaf leaf) const;
|
||||
void insert(N* node, N* parent);
|
||||
void remove(N* node);
|
||||
|
||||
N* minmax(N::Leaf leaf) const
|
||||
{
|
||||
N* p = m_root;
|
||||
if (!p)
|
||||
return nullptr;
|
||||
while (p->child(leaf))
|
||||
p = p->child(leaf);
|
||||
return p;
|
||||
}
|
||||
|
||||
template <typename H>
|
||||
N*& navigate(N*& node, N*& parent, N::Leaf leafOnEqual, H helm) const
|
||||
{
|
||||
node = nullptr;
|
||||
parent = nullptr;
|
||||
|
||||
N** point = const_cast<N**>(&m_root);
|
||||
while (*point)
|
||||
{
|
||||
int direction = helm(*point);
|
||||
parent = *point;
|
||||
if (direction < 0)
|
||||
point = &(*point)->left();
|
||||
else if (direction > 0)
|
||||
point = &(*point)->right();
|
||||
else
|
||||
{
|
||||
node = *point;
|
||||
point = &(*point)->child(leafOnEqual);
|
||||
}
|
||||
}
|
||||
return *point;
|
||||
}
|
||||
};
|
||||
|
||||
template <typename ClassT, typename MemberT>
|
||||
constexpr ClassT* parent_obj(MemberT* member, MemberT ClassT::* ptr)
|
||||
{
|
||||
union whatever
|
||||
{
|
||||
MemberT ClassT::* ptr;
|
||||
intptr_t offset;
|
||||
};
|
||||
// This is technically UB, but basically every compiler worth using admits it as an extension
|
||||
return (ClassT*)((intptr_t)member - whatever{ptr}.offset);
|
||||
}
|
||||
|
||||
template <
|
||||
typename T,
|
||||
CIntrusiveTreeNode T::* node_ptr,
|
||||
typename Comparator = std::less<>
|
||||
>
|
||||
class CIntrusiveTree final : protected CIntrusiveTreeBase
|
||||
{
|
||||
using N = CIntrusiveTreeNode;
|
||||
|
||||
static constexpr T* toType(N* m)
|
||||
{
|
||||
return m ? parent_obj(m, node_ptr) : nullptr;
|
||||
}
|
||||
|
||||
static constexpr N* toNode(T* m)
|
||||
{
|
||||
return m ? &(m->*node_ptr) : nullptr;
|
||||
}
|
||||
|
||||
template <typename A, typename B>
|
||||
static int compare(A const& a, B const& b)
|
||||
{
|
||||
Comparator comp;
|
||||
if (comp(a, b))
|
||||
return -1;
|
||||
if (comp(b, a))
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
public:
|
||||
constexpr CIntrusiveTree() : CIntrusiveTreeBase{} { }
|
||||
|
||||
T* first() const { return toType(minmax(N::Left)); }
|
||||
T* last() const { return toType(minmax(N::Right)); }
|
||||
bool empty() const { return m_root != nullptr; }
|
||||
void clear() { m_root = nullptr; }
|
||||
|
||||
T* prev(T* node) const { return toType(walk(toNode(node), N::Left)); }
|
||||
T* next(T* node) const { return toType(walk(toNode(node), N::Right)); }
|
||||
|
||||
enum SearchMode
|
||||
{
|
||||
Exact = 0,
|
||||
LowerBound = 1,
|
||||
UpperBound = 2,
|
||||
};
|
||||
|
||||
template <typename Lambda>
|
||||
T* search(SearchMode mode, Lambda lambda) const
|
||||
{
|
||||
N *node, *parent;
|
||||
N*& point = navigate(node, parent,
|
||||
mode != UpperBound ? N::Left : N::Right,
|
||||
[&lambda](N* curnode) { return lambda(toType(curnode)); });
|
||||
|
||||
switch (mode)
|
||||
{
|
||||
default:
|
||||
case Exact:
|
||||
break;
|
||||
case LowerBound:
|
||||
if (!node && parent)
|
||||
{
|
||||
if (&parent->left() == &point)
|
||||
node = parent;
|
||||
else
|
||||
node = walk(parent, N::Right);
|
||||
}
|
||||
break;
|
||||
case UpperBound:
|
||||
if (node)
|
||||
node = walk(node, N::Right);
|
||||
else if (parent)
|
||||
{
|
||||
if (&parent->right() == &point)
|
||||
node = walk(parent, N::Right);
|
||||
else
|
||||
node = parent;
|
||||
}
|
||||
break;
|
||||
}
|
||||
return toType(node);
|
||||
}
|
||||
|
||||
template <typename K>
|
||||
T* find(K const& key, SearchMode mode = Exact) const
|
||||
{
|
||||
return search(mode, [&key](T* obj) { return compare(key, *obj); });
|
||||
}
|
||||
|
||||
T* insert(T* obj, bool allow_dupes = false)
|
||||
{
|
||||
N *node, *parent;
|
||||
N*& point = navigate(node, parent, N::Right,
|
||||
[obj](N* curnode) { return compare(*obj, *toType(curnode)); });
|
||||
|
||||
if (node && !allow_dupes)
|
||||
return toType(node);
|
||||
|
||||
point = toNode(obj);
|
||||
CIntrusiveTreeBase::insert(point, parent);
|
||||
return obj;
|
||||
}
|
||||
|
||||
void remove(T* obj)
|
||||
{
|
||||
CIntrusiveTreeBase::remove(toNode(obj));
|
||||
}
|
||||
};
|
||||
120
troposphere/daybreak/nanovg/include/nanovg/framework/CMemPool.h
Normal file
120
troposphere/daybreak/nanovg/include/nanovg/framework/CMemPool.h
Normal file
@@ -0,0 +1,120 @@
|
||||
/*
|
||||
** Sample Framework for deko3d Applications
|
||||
** CMemPool.h: Pooled dynamic memory allocation manager class
|
||||
*/
|
||||
#pragma once
|
||||
#include "common.h"
|
||||
#include "CIntrusiveList.h"
|
||||
#include "CIntrusiveTree.h"
|
||||
|
||||
class CMemPool
|
||||
{
|
||||
dk::Device m_dev;
|
||||
uint32_t m_flags;
|
||||
uint32_t m_blockSize;
|
||||
|
||||
struct Block
|
||||
{
|
||||
CIntrusiveListNode<Block> m_node;
|
||||
dk::MemBlock m_obj;
|
||||
void* m_cpuAddr;
|
||||
DkGpuAddr m_gpuAddr;
|
||||
|
||||
constexpr void* cpuOffset(uint32_t offset) const
|
||||
{
|
||||
return m_cpuAddr ? ((u8*)m_cpuAddr + offset) : nullptr;
|
||||
}
|
||||
|
||||
constexpr DkGpuAddr gpuOffset(uint32_t offset) const
|
||||
{
|
||||
return m_gpuAddr != DK_GPU_ADDR_INVALID ? (m_gpuAddr + offset) : DK_GPU_ADDR_INVALID;
|
||||
}
|
||||
};
|
||||
|
||||
CIntrusiveList<Block, &Block::m_node> m_blocks;
|
||||
|
||||
struct Slice
|
||||
{
|
||||
CIntrusiveListNode<Slice> m_node;
|
||||
CIntrusiveTreeNode m_treenode;
|
||||
CMemPool* m_pool;
|
||||
Block* m_block;
|
||||
uint32_t m_start;
|
||||
uint32_t m_end;
|
||||
|
||||
constexpr uint32_t getSize() const { return m_end - m_start; }
|
||||
constexpr bool canCoalesce(Slice const& rhs) const { return m_pool == rhs.m_pool && m_block == rhs.m_block && m_end == rhs.m_start; }
|
||||
|
||||
constexpr bool operator<(Slice const& rhs) const { return getSize() < rhs.getSize(); }
|
||||
constexpr bool operator<(uint32_t rhs) const { return getSize() < rhs; }
|
||||
};
|
||||
|
||||
friend constexpr bool operator<(uint32_t lhs, Slice const& rhs);
|
||||
|
||||
CIntrusiveList<Slice, &Slice::m_node> m_memMap, m_sliceHeap;
|
||||
CIntrusiveTree<Slice, &Slice::m_treenode> m_freeList;
|
||||
|
||||
Slice* _newSlice();
|
||||
void _deleteSlice(Slice*);
|
||||
|
||||
void _destroy(Slice* slice);
|
||||
|
||||
public:
|
||||
static constexpr uint32_t DefaultBlockSize = 0x800000;
|
||||
class Handle
|
||||
{
|
||||
Slice* m_slice;
|
||||
public:
|
||||
constexpr Handle(Slice* slice = nullptr) : m_slice{slice} { }
|
||||
constexpr operator bool() const { return m_slice != nullptr; }
|
||||
constexpr operator Slice*() const { return m_slice; }
|
||||
constexpr bool operator!() const { return !m_slice; }
|
||||
constexpr bool operator==(Handle const& rhs) const { return m_slice == rhs.m_slice; }
|
||||
constexpr bool operator!=(Handle const& rhs) const { return m_slice != rhs.m_slice; }
|
||||
|
||||
void destroy()
|
||||
{
|
||||
if (m_slice)
|
||||
{
|
||||
m_slice->m_pool->_destroy(m_slice);
|
||||
m_slice = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
constexpr dk::MemBlock getMemBlock() const
|
||||
{
|
||||
return m_slice->m_block->m_obj;
|
||||
}
|
||||
|
||||
constexpr uint32_t getOffset() const
|
||||
{
|
||||
return m_slice->m_start;
|
||||
}
|
||||
|
||||
constexpr uint32_t getSize() const
|
||||
{
|
||||
return m_slice->getSize();
|
||||
}
|
||||
|
||||
constexpr void* getCpuAddr() const
|
||||
{
|
||||
return m_slice->m_block->cpuOffset(m_slice->m_start);
|
||||
}
|
||||
|
||||
constexpr DkGpuAddr getGpuAddr() const
|
||||
{
|
||||
return m_slice->m_block->gpuOffset(m_slice->m_start);
|
||||
}
|
||||
};
|
||||
|
||||
CMemPool(dk::Device dev, uint32_t flags = DkMemBlockFlags_CpuUncached | DkMemBlockFlags_GpuCached, uint32_t blockSize = DefaultBlockSize) :
|
||||
m_dev{dev}, m_flags{flags}, m_blockSize{blockSize}, m_blocks{}, m_memMap{}, m_sliceHeap{}, m_freeList{} { }
|
||||
~CMemPool();
|
||||
|
||||
Handle allocate(uint32_t size, uint32_t alignment = DK_CMDMEM_ALIGNMENT);
|
||||
};
|
||||
|
||||
constexpr bool operator<(uint32_t lhs, CMemPool::Slice const& rhs)
|
||||
{
|
||||
return lhs < rhs.getSize();
|
||||
}
|
||||
@@ -0,0 +1,31 @@
|
||||
/*
|
||||
** Sample Framework for deko3d Applications
|
||||
** CShader.h: Utility class for loading shaders from the filesystem
|
||||
*/
|
||||
#pragma once
|
||||
#include "common.h"
|
||||
#include "CMemPool.h"
|
||||
|
||||
class CShader
|
||||
{
|
||||
dk::Shader m_shader;
|
||||
CMemPool::Handle m_codemem;
|
||||
public:
|
||||
CShader() : m_shader{}, m_codemem{} { }
|
||||
~CShader()
|
||||
{
|
||||
m_codemem.destroy();
|
||||
}
|
||||
|
||||
constexpr operator bool() const
|
||||
{
|
||||
return m_codemem;
|
||||
}
|
||||
|
||||
constexpr operator dk::Shader const*() const
|
||||
{
|
||||
return &m_shader;
|
||||
}
|
||||
|
||||
bool load(CMemPool& pool, const char* path);
|
||||
};
|
||||
@@ -0,0 +1,9 @@
|
||||
/*
|
||||
** Sample Framework for deko3d Applications
|
||||
** FileLoader.h: Helpers for loading data from the filesystem directly into GPU memory
|
||||
*/
|
||||
#pragma once
|
||||
#include "common.h"
|
||||
#include "CMemPool.h"
|
||||
|
||||
CMemPool::Handle LoadFile(CMemPool& pool, const char* path, uint32_t alignment = DK_CMDMEM_ALIGNMENT);
|
||||
@@ -0,0 +1,12 @@
|
||||
/*
|
||||
** Sample Framework for deko3d Applications
|
||||
** common.h: Common includes
|
||||
*/
|
||||
#pragma once
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include <switch.h>
|
||||
|
||||
#include <deko3d.hpp>
|
||||
Reference in New Issue
Block a user