AxioDL
/
boo
mirror of https://github.com/AxioDL/boo.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
boo/lib/graphicsdev/nx/NX.cpp

2174 lines
73 KiB
C++
Raw Normal View History

Huge shader infrastructure refactor
2018-10-07 02:49:22 +00:00
#include "logvisor/logvisor.hpp"
#include "boo/graphicsdev/NX.hpp"
#include "boo/IGraphicsContext.hpp"
#include "boo/graphicsdev/GLSLMacros.hpp"
#include "../Common.hpp"
#include "xxhash/xxhash.h"
#include "main/shaderobj.h"
#include "st_program.h"
#include "pipe/p_state.h"
#include "util/u_format.h"
#include "state_tracker/winsys_handle.h"
extern "C" {
#include "main/viewport.h"
#include "nouveau_winsys.h"
#include "nouveau_screen.h"
#include "nvc0/nvc0_program.h"
#include "gallium/winsys/nouveau/switch/nouveau_switch_public.h"
}
#include <switch.h>
namespace boo
{
static logvisor::Module Log("boo::NX");
struct NXCommandQueue;
class NXDataFactoryImpl : public NXDataFactory, public GraphicsDataFactoryHead
{
public:
float m_gamma = 1.f;
ObjToken<IShaderDataBinding> m_gammaBinding;
IGraphicsContext* m_parent;
NXContext* m_ctx;
NXDataFactoryImpl(IGraphicsContext* parent, NXContext* ctx) : m_parent(parent), m_ctx(ctx) {}
Platform platform() const {return Platform::NX;}
const SystemChar* platformName() const {return _SYS_STR("NX");}
void SetupGammaResources()
{
}
void DestroyGammaResources()
{
}
void commitTransaction(const FactoryCommitFunc& __BooTraceArgs);
boo::ObjToken<IGraphicsBufferD> newPoolBuffer(BufferUse use, size_t stride, size_t count __BooTraceArgs);
void setDisplayGamma(float gamma)
{
m_gamma = gamma;
//if (gamma != 1.f)
// UpdateGammaLUT(m_gammaLUT.get(), gamma);
}
bool isTessellationSupported(uint32_t& maxPatchSizeOut)
{
maxPatchSizeOut = 0;
if (!m_ctx->m_st->ctx->Extensions.ARB_tessellation_shader)
return false;
maxPatchSizeOut = m_ctx->m_st->ctx->Const.MaxPatchVertices;
return true;
}
};
struct NXData : BaseGraphicsData
{
NXContext* m_ctx;
/* Vertex, Index, Uniform */
struct pipe_resource* m_constantBuffers[3] = {};
explicit NXData(NXDataFactoryImpl& head __BooTraceArgs)
: BaseGraphicsData(head __BooTraceArgsUse), m_ctx(head.m_ctx) {}
~NXData()
{
for (int i=0 ; i<3 ; ++i)
pipe_resource_reference(&m_constantBuffers[i], nullptr);
}
};
struct NXPool : BaseGraphicsPool
{
NXContext* m_ctx;
struct pipe_resource* m_constantBuffer;
explicit NXPool(NXDataFactoryImpl& head __BooTraceArgs)
: BaseGraphicsPool(head __BooTraceArgsUse), m_ctx(head.m_ctx) {}
~NXPool()
{
pipe_resource_reference(&m_constantBuffer, nullptr);
}
};
static const unsigned USE_TABLE[] =
{
0,
PIPE_BIND_VERTEX_BUFFER,
PIPE_BIND_INDEX_BUFFER,
PIPE_BIND_CONSTANT_BUFFER
};
union nx_buffer_info
{
pipe_vertex_buffer v;
pipe_constant_buffer c;
};
class NXGraphicsBufferS : public GraphicsDataNode<IGraphicsBufferS>
{
friend class NXDataFactory;
friend struct NXCommandQueue;
NXContext* m_ctx;
size_t m_sz;
std::unique_ptr<uint8_t[]> m_stagingBuf;
NXGraphicsBufferS(const boo::ObjToken<BaseGraphicsData>& parent, BufferUse use,
NXContext* ctx, const void* data, size_t stride, size_t count)
: GraphicsDataNode<IGraphicsBufferS>(parent),
m_ctx(ctx), m_sz(stride * count),
m_stagingBuf(new uint8_t[m_sz]), m_use(use)
{
memmove(m_stagingBuf.get(), data, m_sz);
if (m_use == BufferUse::Vertex)
m_bufferInfo.v.stride = uint16_t(stride);
}
public:
size_t size() const {return m_sz;}
nx_buffer_info m_bufferInfo;
BufferUse m_use;
unsigned sizeForGPU(NXContext* ctx, unsigned offset)
{
if (m_use == BufferUse::Uniform)
{
unsigned minOffset = std::max(256u,
ctx->m_st->ctx->Const.UniformBufferOffsetAlignment);
offset = (offset + minOffset - 1) & ~(minOffset - 1);
m_bufferInfo.c.buffer_offset = offset;
m_bufferInfo.c.buffer_size = m_sz;
}
else
{
m_bufferInfo.v.buffer_offset = offset;
}
offset += m_sz;
return offset;
}
void placeForGPU(struct pipe_resource* bufObj, uint8_t* buf)
{
if (m_use == BufferUse::Uniform)
m_bufferInfo.c.buffer = bufObj;
else
m_bufferInfo.v.buffer.resource = bufObj;
memmove(buf + m_bufferInfo.v.buffer_offset, m_stagingBuf.get(), m_sz);
m_stagingBuf.reset();
}
};
template <class DataCls>
class NXGraphicsBufferD : public GraphicsDataNode<IGraphicsBufferD, DataCls>
{
friend class NXDataFactory;
friend class NXDataFactoryImpl;
friend struct NXCommandQueue;
NXContext* m_ctx;
size_t m_cpuSz;
std::unique_ptr<uint8_t[]> m_cpuBuf;
int m_validSlots = 0;
NXGraphicsBufferD(const boo::ObjToken<DataCls>& parent, BufferUse use,
NXContext* ctx, size_t stride, size_t count)
: GraphicsDataNode<IGraphicsBufferD, DataCls>(parent),
m_ctx(ctx), m_cpuSz(stride * count), m_cpuBuf(new uint8_t[m_cpuSz]), m_use(use)
{
if (m_use == BufferUse::Vertex)
{
m_bufferInfo[0].v.stride = stride;
m_bufferInfo[1].v.stride = stride;
}
}
void update(int b)
{
int slot = 1 << b;
if ((slot & m_validSlots) == 0)
{
memcpy(m_bufferPtrs[b], m_cpuBuf.get(), m_cpuSz);
m_validSlots |= slot;
}
}
public:
nx_buffer_info m_bufferInfo[2];
uint8_t* m_bufferPtrs[2] = {};
BufferUse m_use;
void load(const void* data, size_t sz)
{
size_t bufSz = std::min(sz, m_cpuSz);
memmove(m_cpuBuf.get(), data, bufSz);
m_validSlots = 0;
}
void* map(size_t sz)
{
if (sz > m_cpuSz)
return nullptr;
return m_cpuBuf.get();
}
void unmap()
{
m_validSlots = 0;
}
unsigned sizeForGPU(NXContext* ctx, unsigned offset)
{
for (int i=0 ; i<2 ; ++i)
{
if (m_use == BufferUse::Uniform)
{
size_t minOffset = std::max(256u,
ctx->m_st->ctx->Const.UniformBufferOffsetAlignment);
offset = (offset + minOffset - 1) & ~(minOffset - 1);
m_bufferInfo[i].c.buffer_offset = offset;
m_bufferInfo[i].c.buffer_size = m_cpuSz;
}
else
{
m_bufferInfo[i].v.buffer_offset = offset;
}
offset += m_cpuSz;
}
return offset;
}
void placeForGPU(struct pipe_resource* bufObj, uint8_t* buf)
{
if (m_use == BufferUse::Uniform)
{
m_bufferInfo[0].c.buffer = bufObj;
m_bufferInfo[1].c.buffer = bufObj;
m_bufferPtrs[0] = buf + m_bufferInfo[0].c.buffer_offset;
m_bufferPtrs[1] = buf + m_bufferInfo[1].c.buffer_offset;
}
else
{
m_bufferInfo[0].v.buffer.resource = bufObj;
m_bufferInfo[1].v.buffer.resource = bufObj;
m_bufferPtrs[0] = buf + m_bufferInfo[0].v.buffer_offset;
m_bufferPtrs[1] = buf + m_bufferInfo[1].v.buffer_offset;
}
}
};
static void MakeSampler(NXContext* ctx, void*& sampOut, TextureClampMode mode, int mips)
{
uint32_t key = (uint32_t(mode) << 16) | mips;
auto search = ctx->m_samplers.find(key);
if (search != ctx->m_samplers.end())
{
sampOut = search->second;
return;
}
/* Create linear sampler */
pipe_sampler_state samplerInfo = {};
samplerInfo.min_img_filter = PIPE_TEX_FILTER_LINEAR;
samplerInfo.min_mip_filter = PIPE_TEX_MIPFILTER_LINEAR;
samplerInfo.mag_img_filter = PIPE_TEX_FILTER_LINEAR;
samplerInfo.compare_mode = PIPE_TEX_COMPARE_NONE;
samplerInfo.compare_func = PIPE_FUNC_ALWAYS;
samplerInfo.normalized_coords = 1;
samplerInfo.max_anisotropy = 16;
samplerInfo.seamless_cube_map = 0;
samplerInfo.lod_bias = 0;
samplerInfo.min_lod = 0;
samplerInfo.max_lod = mips - 1;
switch (mode)
{
case TextureClampMode::Repeat:
default:
samplerInfo.wrap_s = PIPE_TEX_WRAP_REPEAT;
samplerInfo.wrap_t = PIPE_TEX_WRAP_REPEAT;
samplerInfo.wrap_r = PIPE_TEX_WRAP_REPEAT;
break;
case TextureClampMode::ClampToWhite:
samplerInfo.wrap_s = PIPE_TEX_WRAP_MIRROR_CLAMP_TO_BORDER;
samplerInfo.wrap_t = PIPE_TEX_WRAP_MIRROR_CLAMP_TO_BORDER;
samplerInfo.wrap_r = PIPE_TEX_WRAP_MIRROR_CLAMP_TO_BORDER;
for (int i = 0; i < 4; ++i)
samplerInfo.border_color.f[i] = 1.f;
break;
case TextureClampMode::ClampToBlack:
samplerInfo.wrap_s = PIPE_TEX_WRAP_MIRROR_CLAMP_TO_BORDER;
samplerInfo.wrap_t = PIPE_TEX_WRAP_MIRROR_CLAMP_TO_BORDER;
samplerInfo.wrap_r = PIPE_TEX_WRAP_MIRROR_CLAMP_TO_BORDER;
samplerInfo.border_color.f[3] = 1.f;
break;
case TextureClampMode::ClampToEdge:
samplerInfo.wrap_s = PIPE_TEX_WRAP_MIRROR_CLAMP_TO_EDGE;
samplerInfo.wrap_t = PIPE_TEX_WRAP_MIRROR_CLAMP_TO_EDGE;
samplerInfo.wrap_r = PIPE_TEX_WRAP_MIRROR_CLAMP_TO_EDGE;
break;
case TextureClampMode::ClampToEdgeNearest:
samplerInfo.mag_img_filter = PIPE_TEX_FILTER_NEAREST;
samplerInfo.min_mip_filter = PIPE_TEX_MIPFILTER_NEAREST;
samplerInfo.min_img_filter = PIPE_TEX_FILTER_NEAREST;
samplerInfo.max_anisotropy = 0;
samplerInfo.wrap_s = PIPE_TEX_WRAP_MIRROR_CLAMP_TO_EDGE;
samplerInfo.wrap_t = PIPE_TEX_WRAP_MIRROR_CLAMP_TO_EDGE;
samplerInfo.wrap_r = PIPE_TEX_WRAP_MIRROR_CLAMP_TO_EDGE;
break;
}
sampOut = ctx->m_pctx->create_sampler_state(ctx->m_pctx, &samplerInfo);
ctx->m_samplers[key] = sampOut;
}
class NXTextureS : public GraphicsDataNode<ITextureS>
{
friend class NXDataFactory;
NXContext* m_ctx;
TextureFormat m_fmt;
size_t m_sz;
size_t m_width, m_height, m_mips;
TextureClampMode m_clampMode;
pipe_format m_nxFmt;
int m_pixelPitchNum = 1;
int m_pixelPitchDenom = 1;
NXTextureS(const boo::ObjToken<BaseGraphicsData>& parent, NXContext* ctx,
size_t width, size_t height, size_t mips,
TextureFormat fmt, TextureClampMode clampMode,
const void* data, size_t sz)
: GraphicsDataNode<ITextureS>(parent), m_ctx(ctx), m_fmt(fmt), m_sz(sz),
m_width(width), m_height(height), m_mips(mips), m_clampMode(clampMode)
{
pipe_format pfmt;
switch (fmt)
{
case TextureFormat::RGBA8:
pfmt = PIPE_FORMAT_R8G8B8A8_UNORM;
m_pixelPitchNum = 4;
break;
case TextureFormat::I8:
pfmt = PIPE_FORMAT_R8_UNORM;
break;
case TextureFormat::I16:
pfmt = PIPE_FORMAT_R16_UNORM;
m_pixelPitchNum = 2;
break;
case TextureFormat::DXT1:
pfmt = PIPE_FORMAT_DXT1_RGBA;
m_pixelPitchNum = 1;
m_pixelPitchDenom = 2;
break;
default:
Log.report(logvisor::Fatal, "unsupported tex format");
}
m_nxFmt = pfmt;
struct pipe_resource texTempl = {};
texTempl.target = PIPE_TEXTURE_2D;
texTempl.format = m_nxFmt;
texTempl.width0 = width;
texTempl.height0 = height;
texTempl.depth0 = 1;
texTempl.last_level = mips - 1;
texTempl.array_size = 1;
texTempl.bind = PIPE_BIND_SAMPLER_VIEW;
m_gpuTex = ctx->m_screen->resource_create(ctx->m_screen, &texTempl);
if (!m_gpuTex) {
Log.report(logvisor::Fatal, "Failed to create texture");
return;
}
uint blockSize = util_format_get_blocksize(m_nxFmt);
uint8_t* ptr = (uint8_t*)data;
for (int i=0 ; i<mips ; ++i)
{
size_t regionPitch = width * height * m_pixelPitchNum / m_pixelPitchDenom;
size_t rowStride = width * blockSize;
size_t imageBytes = rowStride * height;
struct pipe_box box;
u_box_2d(0, 0, width, height, &box);
ctx->m_pctx->texture_subdata(ctx->m_pctx, m_gpuTex, i, PIPE_TRANSFER_WRITE,
&box, ptr, rowStride, imageBytes);
if (width > 1)
width /= 2;
if (height > 1)
height /= 2;
ptr += regionPitch;
}
struct pipe_sampler_view svTempl = {};
svTempl.format = m_nxFmt;
svTempl.texture = m_gpuTex;
svTempl.u.tex.last_level = mips - 1;
svTempl.swizzle_r = PIPE_SWIZZLE_X;
svTempl.swizzle_g = PIPE_SWIZZLE_Y;
svTempl.swizzle_b = PIPE_SWIZZLE_Z;
svTempl.swizzle_a = PIPE_SWIZZLE_W;
m_gpuView = ctx->m_pctx->create_sampler_view(ctx->m_pctx, m_gpuTex, &svTempl);
}
public:
struct pipe_resource* m_gpuTex;
struct pipe_sampler_view* m_gpuView = nullptr;
void* m_sampler = nullptr;
~NXTextureS()
{
pipe_resource_reference(&m_gpuTex, nullptr);
pipe_sampler_view_reference(&m_gpuView, nullptr);
}
void setClampMode(TextureClampMode mode)
{
m_clampMode = mode;
MakeSampler(m_ctx, m_sampler, mode, m_mips);
}
TextureFormat format() const {return m_fmt;}
};
class NXTextureSA : public GraphicsDataNode<ITextureSA>
{
friend class NXDataFactory;
NXContext* m_ctx;
TextureFormat m_fmt;
size_t m_sz;
size_t m_width, m_height, m_layers, m_mips;
TextureClampMode m_clampMode;
pipe_format m_nxFmt;
int m_pixelPitchNum = 1;
int m_pixelPitchDenom = 1;
NXTextureSA(const boo::ObjToken<BaseGraphicsData>& parent, NXContext* ctx,
size_t width, size_t height, size_t layers,
size_t mips, TextureFormat fmt, TextureClampMode clampMode,
const void* data, size_t sz)
: GraphicsDataNode<ITextureSA>(parent),
m_ctx(ctx), m_fmt(fmt), m_sz(sz), m_width(width), m_height(height),
m_layers(layers), m_mips(mips), m_clampMode(clampMode)
{
pipe_format pfmt;
switch (fmt)
{
case TextureFormat::RGBA8:
pfmt = PIPE_FORMAT_R8G8B8A8_UNORM;
m_pixelPitchNum = 4;
break;
case TextureFormat::I8:
pfmt = PIPE_FORMAT_R8_UNORM;
break;
case TextureFormat::I16:
pfmt = PIPE_FORMAT_R16_UNORM;
m_pixelPitchNum = 2;
break;
default:
Log.report(logvisor::Fatal, "unsupported tex format");
}
m_nxFmt = pfmt;
struct pipe_resource texTempl = {};
texTempl.target = PIPE_TEXTURE_2D;
texTempl.format = m_nxFmt;
texTempl.width0 = width;
texTempl.height0 = height;
texTempl.depth0 = 1;
texTempl.last_level = mips - 1;
texTempl.array_size = layers;
texTempl.bind = PIPE_BIND_SAMPLER_VIEW;
m_gpuTex = ctx->m_screen->resource_create(ctx->m_screen, &texTempl);
if (!m_gpuTex) {
Log.report(logvisor::Fatal, "Failed to create texture");
return;
}
uint blockSize = util_format_get_blocksize(m_nxFmt);
uint8_t* ptr = (uint8_t*)data;
for (int i=0 ; i<mips ; ++i)
{
size_t regionPitch = width * height * m_layers * m_pixelPitchNum / m_pixelPitchDenom;
size_t rowStride = width * blockSize;
size_t imageBytes = rowStride * height;
struct pipe_box box;
u_box_2d(0, 0, width, height, &box);
ctx->m_pctx->texture_subdata(ctx->m_pctx, m_gpuTex, i, PIPE_TRANSFER_WRITE,
&box, ptr, rowStride, imageBytes);
if (width > 1)
width /= 2;
if (height > 1)
height /= 2;
ptr += regionPitch;
}
struct pipe_sampler_view svTempl = {};
svTempl.format = m_nxFmt;
svTempl.texture = m_gpuTex;
svTempl.u.tex.last_layer = layers - 1;
svTempl.u.tex.last_level = mips - 1;
svTempl.swizzle_r = PIPE_SWIZZLE_X;
svTempl.swizzle_g = PIPE_SWIZZLE_Y;
svTempl.swizzle_b = PIPE_SWIZZLE_Z;
svTempl.swizzle_a = PIPE_SWIZZLE_W;
m_gpuView = ctx->m_pctx->create_sampler_view(ctx->m_pctx, m_gpuTex, &svTempl);
}
public:
struct pipe_resource* m_gpuTex;
struct pipe_sampler_view* m_gpuView = nullptr;
void* m_sampler = nullptr;
~NXTextureSA()
{
pipe_resource_reference(&m_gpuTex, nullptr);
pipe_sampler_view_reference(&m_gpuView, nullptr);
}
void setClampMode(TextureClampMode mode)
{
m_clampMode = mode;
MakeSampler(m_ctx, m_sampler, mode, m_mips);
}
TextureFormat format() const {return m_fmt;}
size_t layers() const {return m_layers;}
};
class NXTextureD : public GraphicsDataNode<ITextureD>
{
friend class NXDataFactory;
friend class NXCommandQueue;
NXCommandQueue* m_q;
size_t m_width;
size_t m_height;
TextureFormat m_fmt;
TextureClampMode m_clampMode;
std::unique_ptr<uint8_t[]> m_stagingBuf;
size_t m_cpuSz;
pipe_format m_nxFmt;
int m_validSlots = 0;
NXTextureD(const boo::ObjToken<BaseGraphicsData>& parent, NXCommandQueue* q,
size_t width, size_t height, TextureFormat fmt, TextureClampMode clampMode);
void update(int b);
public:
struct pipe_resource* m_gpuTex[2];
struct pipe_sampler_view* m_gpuView[2];
void* m_sampler = nullptr;
~NXTextureD()
{
for (int i = 0; i < 2; ++i)
{
pipe_resource_reference(&m_gpuTex[i], nullptr);
pipe_sampler_view_reference(&m_gpuView[i], nullptr);
}
}
void setClampMode(TextureClampMode mode);
void load(const void* data, size_t sz);
void* map(size_t sz);
void unmap();
TextureFormat format() const {return m_fmt;}
};
#define MAX_BIND_TEXS 4
static constexpr pipe_format ColorFormat = PIPE_FORMAT_R8G8B8A8_UNORM;
static constexpr pipe_format DepthFormat = PIPE_FORMAT_Z32_FLOAT;
class NXTextureR : public GraphicsDataNode<ITextureR>
{
NXContext* m_ctx;
friend class NXDataFactory;
friend struct NXCommandQueue;
size_t m_width = 0;
size_t m_height = 0;
unsigned m_samplesColor, m_samplesDepth;
size_t m_colorBindCount;
size_t m_depthBindCount;
void Setup(NXContext* ctx)
{
/* no-ops on first call */
doDestroy();
/* color target */
struct pipe_resource texTempl = {};
texTempl.target = PIPE_TEXTURE_2D;
texTempl.format = ColorFormat;
texTempl.width0 = m_width;
texTempl.height0 = m_height;
texTempl.depth0 = 1;
texTempl.array_size = 1;
texTempl.nr_samples = texTempl.nr_storage_samples = m_samplesColor;
texTempl.bind = PIPE_BIND_RENDER_TARGET;
m_colorTex = ctx->m_screen->resource_create(ctx->m_screen, &texTempl);
if (!m_colorTex) {
Log.report(logvisor::Fatal, "Failed to create color target texture");
return;
}
/* depth target */
texTempl.format = DepthFormat;
texTempl.nr_samples = texTempl.nr_storage_samples = m_samplesDepth;
texTempl.bind = PIPE_BIND_DEPTH_STENCIL;
m_depthTex = ctx->m_screen->resource_create(ctx->m_screen, &texTempl);
if (!m_depthTex) {
Log.report(logvisor::Fatal, "Failed to create depth target texture");
return;
}
texTempl.nr_samples = texTempl.nr_storage_samples = 1;
for (size_t i=0 ; i<m_colorBindCount ; ++i)
{
texTempl.format = ColorFormat;
texTempl.bind = PIPE_BIND_SAMPLER_VIEW;
m_colorBindTex[i] = ctx->m_screen->resource_create(ctx->m_screen, &texTempl);
if (!m_colorBindTex[i]) {
Log.report(logvisor::Fatal, "Failed to create color bind texture");
return;
}
}
for (size_t i=0 ; i<m_depthBindCount ; ++i)
{
texTempl.format = DepthFormat;
texTempl.bind = PIPE_BIND_SAMPLER_VIEW;
m_depthBindTex[i] = ctx->m_screen->resource_create(ctx->m_screen, &texTempl);
if (!m_depthBindTex[i]) {
Log.report(logvisor::Fatal, "Failed to create depth bind texture");
return;
}
}
/* Create resource views */
struct pipe_sampler_view svTempl = {};
svTempl.format = ColorFormat;
svTempl.swizzle_r = PIPE_SWIZZLE_X;
svTempl.swizzle_g = PIPE_SWIZZLE_Y;
svTempl.swizzle_b = PIPE_SWIZZLE_Z;
svTempl.swizzle_a = PIPE_SWIZZLE_W;
svTempl.texture = m_colorTex;
m_colorView = ctx->m_pctx->create_sampler_view(ctx->m_pctx, m_colorTex, &svTempl);
if (!m_colorView) {
Log.report(logvisor::Fatal, "Failed to create color sampler view");
return;
}
svTempl.format = DepthFormat;
svTempl.texture = m_depthTex;
m_depthView = ctx->m_pctx->create_sampler_view(ctx->m_pctx, m_depthTex, &svTempl);
if (!m_depthView) {
Log.report(logvisor::Fatal, "Failed to create depth sampler view");
return;
}
svTempl.format = ColorFormat;
for (size_t i=0 ; i<m_colorBindCount ; ++i)
{
svTempl.texture = m_colorBindTex[i];
m_colorBindView[i] = ctx->m_pctx->create_sampler_view(ctx->m_pctx, m_colorBindTex[i], &svTempl);
if (!m_colorBindView[i]) {
Log.report(logvisor::Fatal, "Failed to create color bind sampler view");
return;
}
}
svTempl.format = DepthFormat;
for (size_t i=0 ; i<m_depthBindCount ; ++i)
{
svTempl.texture = m_depthBindTex[i];
m_depthBindView[i] = ctx->m_pctx->create_sampler_view(ctx->m_pctx, m_depthBindTex[i], &svTempl);
if (!m_depthBindView[i]) {
Log.report(logvisor::Fatal, "Failed to create depth bind sampler view");
return;
}
}
/* surfaces */
struct pipe_surface surfTempl = {};
surfTempl.format = ColorFormat;
m_colorSurface = ctx->m_pctx->create_surface(ctx->m_pctx, m_colorTex, &surfTempl);
if (!m_colorSurface) {
Log.report(logvisor::Fatal, "Failed to create color surface");
return;
}
surfTempl.format = DepthFormat;
m_depthSurface = ctx->m_pctx->create_surface(ctx->m_pctx, m_depthTex, &surfTempl);
if (!m_depthSurface) {
Log.report(logvisor::Fatal, "Failed to create depth surface");
return;
}
/* framebuffer */
m_framebuffer.width = uint16_t(m_width);
m_framebuffer.height = uint16_t(m_height);
m_framebuffer.nr_cbufs = 1;
m_framebuffer.cbufs[0] = m_colorSurface;
m_framebuffer.zsbuf = m_depthSurface;
}
NXTextureR(const boo::ObjToken<BaseGraphicsData>& parent, NXContext* ctx,
size_t width, size_t height, TextureClampMode clampMode,
size_t colorBindCount, size_t depthBindCount)
: GraphicsDataNode<ITextureR>(parent), m_ctx(ctx)
{
if (colorBindCount > MAX_BIND_TEXS)
Log.report(logvisor::Fatal, "too many color bindings for render texture");
if (depthBindCount > MAX_BIND_TEXS)
Log.report(logvisor::Fatal, "too many depth bindings for render texture");
if (m_samplesColor == 0) m_samplesColor = 1;
if (m_samplesDepth == 0) m_samplesDepth = 1;
setClampMode(clampMode);
Setup(ctx);
}
public:
struct pipe_resource* m_colorTex;
struct pipe_sampler_view* m_colorView = nullptr;
struct pipe_resource* m_depthTex;
struct pipe_sampler_view* m_depthView = nullptr;
struct pipe_resource* m_colorBindTex[MAX_BIND_TEXS] = {};
struct pipe_sampler_view* m_colorBindView[MAX_BIND_TEXS] = {};
struct pipe_resource* m_depthBindTex[MAX_BIND_TEXS] = {};
struct pipe_sampler_view* m_depthBindView[MAX_BIND_TEXS] = {};
struct pipe_surface* m_colorSurface = nullptr;
struct pipe_surface* m_depthSurface = nullptr;
void* m_sampler = nullptr;
struct pipe_framebuffer_state m_framebuffer = {};
void setClampMode(TextureClampMode mode)
{
MakeSampler(m_ctx, m_sampler, mode, 1);
}
void doDestroy()
{
pipe_resource_reference(&m_colorTex, nullptr);
pipe_sampler_view_reference(&m_colorView, nullptr);
pipe_resource_reference(&m_depthTex, nullptr);
pipe_sampler_view_reference(&m_depthView, nullptr);
for (size_t i = 0; i < MAX_BIND_TEXS; ++i)
{
pipe_resource_reference(&m_colorBindTex[i], nullptr);
pipe_sampler_view_reference(&m_colorBindView[i], nullptr);
pipe_resource_reference(&m_depthBindTex[i], nullptr);
pipe_sampler_view_reference(&m_depthBindView[i], nullptr);
}
pipe_surface_reference(&m_colorSurface, nullptr);
pipe_surface_reference(&m_depthSurface, nullptr);
}
~NXTextureR()
{
doDestroy();
}
void resize(NXContext* ctx, size_t width, size_t height)
{
if (width < 1)
width = 1;
if (height < 1)
height = 1;
m_width = width;
m_height = height;
Setup(ctx);
}
};
static const size_t SEMANTIC_SIZE_TABLE[] =
{
0,
12,
16,
12,
16,
16,
4,
8,
16,
16,
16
};
static const pipe_format SEMANTIC_TYPE_TABLE[] =
{
PIPE_FORMAT_NONE,
PIPE_FORMAT_R32G32B32_FLOAT,
PIPE_FORMAT_R32G32B32A32_FLOAT,
PIPE_FORMAT_R32G32B32_FLOAT,
PIPE_FORMAT_R32G32B32A32_FLOAT,
PIPE_FORMAT_R32G32B32A32_FLOAT,
PIPE_FORMAT_R8G8B8A8_UNORM,
PIPE_FORMAT_R32G32_FLOAT,
PIPE_FORMAT_R32G32B32A32_FLOAT,
PIPE_FORMAT_R32G32B32A32_FLOAT,
PIPE_FORMAT_R32G32B32A32_FLOAT
};
struct NXVertexFormat
{
void* m_vtxElem;
size_t m_stride = 0;
size_t m_instStride = 0;
NXVertexFormat(NXContext* ctx, const VertexFormatInfo& info)
{
std::unique_ptr<pipe_vertex_element[]> attributes(new pipe_vertex_element[info.elementCount]);
for (size_t i = 0; i < info.elementCount; ++i)
{
const VertexElementDescriptor* elemin = &info.elements[i];
pipe_vertex_element& attribute = attributes[i];
int semantic = int(elemin->semantic & boo::VertexSemantic::SemanticMask);
attribute.src_format = SEMANTIC_TYPE_TABLE[semantic];
if ((elemin->semantic & boo::VertexSemantic::Instanced) != boo::VertexSemantic::None)
{
attribute.vertex_buffer_index = 1;
attribute.instance_divisor = 1;
attribute.src_offset = m_instStride;
m_instStride += SEMANTIC_SIZE_TABLE[semantic];
}
else
{
attribute.vertex_buffer_index = 0;
attribute.instance_divisor = 0;
attribute.src_offset = m_stride;
m_stride += SEMANTIC_SIZE_TABLE[semantic];
}
}
uint64_t key = XXH64(attributes.get(), sizeof(pipe_vertex_element) * info.elementCount, 0);
auto search = ctx->m_vtxElemStates.find(key);
if (search != ctx->m_vtxElemStates.end())
{
m_vtxElem = search->second;
return;
}
m_vtxElem = ctx->m_pctx->create_vertex_elements_state(ctx->m_pctx, info.elementCount, attributes.get());
ctx->m_vtxElemStates[key] = m_vtxElem;
}
};
static const pipe_prim_type PRIMITIVE_TABLE[] =
{
PIPE_PRIM_TRIANGLES,
PIPE_PRIM_TRIANGLE_STRIP,
PIPE_PRIM_PATCHES
};
static const nx_shader_stage SHADER_TYPE_TABLE[] =
{
nx_shader_stage::NONE,
nx_shader_stage::VERTEX,
nx_shader_stage::FRAGMENT,
nx_shader_stage::GEOMETRY,
nx_shader_stage::TESS_CTRL,
nx_shader_stage::TESS_EVAL,
};
class NXShaderStage : public GraphicsDataNode<IShaderStage>
{
friend class NXDataFactory;
nx_shader_stage_object m_obj;
NXShaderStage(const boo::ObjToken<BaseGraphicsData>& parent, NXContext* ctx,
const uint8_t* data, size_t size, PipelineStage stage)
: GraphicsDataNode<IShaderStage>(parent),
m_obj(ctx->m_compiler.compile(SHADER_TYPE_TABLE[int(stage)], (char*)data))
{
if (!m_obj)
Log.report(logvisor::Fatal, "Shader compile fail:\n%s\n", m_obj.info_log());
}
public:
const nx_shader_stage_object* shader() const { return &m_obj; }
};
static const unsigned BLEND_FACTOR_TABLE[] =
{
PIPE_BLENDFACTOR_ZERO,
PIPE_BLENDFACTOR_ONE,
PIPE_BLENDFACTOR_SRC_COLOR,
PIPE_BLENDFACTOR_INV_SRC_COLOR,
PIPE_BLENDFACTOR_DST_COLOR,
PIPE_BLENDFACTOR_INV_DST_COLOR,
PIPE_BLENDFACTOR_SRC_ALPHA,
PIPE_BLENDFACTOR_INV_SRC_ALPHA,
PIPE_BLENDFACTOR_DST_ALPHA,
PIPE_BLENDFACTOR_INV_DST_ALPHA,
PIPE_BLENDFACTOR_SRC1_COLOR,
PIPE_BLENDFACTOR_INV_SRC1_COLOR
};
static void MakeBlendState(NXContext* ctx, void*& bsOut, const AdditionalPipelineInfo& info)
{
uint32_t key = (uint32_t(info.srcFac) << 16) | (uint32_t(info.dstFac) << 3) |
info.colorWrite << 2 | info.alphaWrite << 1 | info.overwriteAlpha;
auto search = ctx->m_blendStates.find(key);
if (search != ctx->m_blendStates.end())
{
bsOut = search->second;
return;
}
pipe_blend_state bs = {};
bs.rt->blend_enable = info.srcFac != BlendFactor::One || info.dstFac != BlendFactor::Zero;
if (info.srcFac == BlendFactor::Subtract || info.dstFac == BlendFactor::Subtract)
{
bs.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_SRC_ALPHA;
bs.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_ONE;
bs.rt[0].rgb_func = PIPE_BLEND_REVERSE_SUBTRACT;
if (info.overwriteAlpha)
{
bs.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE;
bs.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO;
bs.rt[0].alpha_func = PIPE_BLEND_ADD;
}
else
{
bs.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_SRC_ALPHA;
bs.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ONE;
bs.rt[0].alpha_func = PIPE_BLEND_REVERSE_SUBTRACT;
}
}
else
{
bs.rt[0].rgb_src_factor = BLEND_FACTOR_TABLE[int(info.srcFac)];
bs.rt[0].rgb_dst_factor = BLEND_FACTOR_TABLE[int(info.dstFac)];
bs.rt[0].rgb_func = PIPE_BLEND_ADD;
if (info.overwriteAlpha)
{
bs.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE;
bs.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO;
}
else
{
bs.rt[0].alpha_src_factor = BLEND_FACTOR_TABLE[int(info.srcFac)];
bs.rt[0].alpha_dst_factor = BLEND_FACTOR_TABLE[int(info.dstFac)];
}
bs.rt[0].alpha_func = PIPE_BLEND_ADD;
}
bs.rt[0].colormask =
(info.colorWrite ? (PIPE_MASK_R |
PIPE_MASK_G |
PIPE_MASK_B) : 0) |
(info.alphaWrite ? PIPE_MASK_A : 0);
bsOut = ctx->m_pctx->create_blend_state(ctx->m_pctx, &bs);
ctx->m_blendStates[key] = bsOut;
}
static void MakeRasterizerState(NXContext* ctx, void*& rasOut, const AdditionalPipelineInfo& info)
{
uint32_t key = uint32_t(info.culling);
auto search = ctx->m_rasStates.find(key);
if (search != ctx->m_rasStates.end())
{
rasOut = search->second;
return;
}
pipe_rasterizer_state ras = {};
ras.clamp_fragment_color = 1;
ras.front_ccw = 1;
switch (info.culling)
{
case CullMode::None:
default:
ras.cull_face = PIPE_FACE_NONE;
break;
case CullMode::Backface:
ras.cull_face = PIPE_FACE_BACK;
break;
case CullMode::Frontface:
ras.cull_face = PIPE_FACE_FRONT;
break;
}
ras.scissor = 1;
ras.multisample = unsigned(ctx->m_sampleCount > 1);
ras.half_pixel_center = 1;
ras.bottom_edge_rule = 1;
ras.depth_clip_near = 1;
ras.depth_clip_far = 1;
rasOut = ctx->m_pctx->create_rasterizer_state(ctx->m_pctx, &ras);
ctx->m_rasStates[key] = rasOut;
}
static void MakeDepthStencilState(NXContext* ctx, void*& dsOut, const AdditionalPipelineInfo& info)
{
uint32_t key = (uint32_t(info.depthTest) << 16) | info.depthWrite;
auto search = ctx->m_dsStates.find(key);
if (search != ctx->m_dsStates.end())
{
dsOut = search->second;
return;
}
pipe_depth_stencil_alpha_state ds = {};
ds.depth.enabled = info.depthTest != ZTest::None;
ds.depth.writemask = info.depthWrite;
switch (info.depthTest)
{
case ZTest::None:
default:
ds.depth.func = PIPE_FUNC_ALWAYS;
break;
case ZTest::LEqual:
ds.depth.func = PIPE_FUNC_LEQUAL;
break;
case ZTest::Greater:
ds.depth.func = PIPE_FUNC_GREATER;
break;
case ZTest::Equal:
ds.depth.func = PIPE_FUNC_EQUAL;
break;
case ZTest::GEqual:
ds.depth.func = PIPE_FUNC_GEQUAL;
break;
}
dsOut = ctx->m_pctx->create_depth_stencil_alpha_state(ctx->m_pctx, &ds);
ctx->m_dsStates[key] = dsOut;
}
class NXShaderPipeline : public GraphicsDataNode<IShaderPipeline>
{
protected:
friend class NXDataFactory;
friend struct NXShaderDataBinding;
NXVertexFormat m_vtxFmt;
nx_linked_shader m_shader;
Primitive m_prim;
pipe_prim_type m_nxPrim;
uint32_t m_patchSize;
void* m_blendState;
void* m_rasState;
void* m_dsState;
NXShaderPipeline(const boo::ObjToken<BaseGraphicsData>& parent,
NXContext* ctx,
ObjToken<IShaderStage> vertex,
ObjToken<IShaderStage> fragment,
ObjToken<IShaderStage> geometry,
ObjToken<IShaderStage> control,
ObjToken<IShaderStage> evaluation,
const VertexFormatInfo& vtxFmt,
const AdditionalPipelineInfo& info)
: GraphicsDataNode<IShaderPipeline>(parent),
m_vtxFmt(ctx, vtxFmt), m_prim(info.prim), m_patchSize(info.patchSize)
{
m_nxPrim = PRIMITIVE_TABLE[int(m_prim)];
MakeBlendState(ctx, m_blendState, info);
MakeRasterizerState(ctx, m_rasState, info);
MakeDepthStencilState(ctx, m_dsState, info);
const nx_shader_stage_object* stages[5];
unsigned numStages = 0;
if (vertex)
stages[numStages++] = vertex.cast<NXShaderStage>()->shader();
if (control)
stages[numStages++] = control.cast<NXShaderStage>()->shader();
if (evaluation)
stages[numStages++] = evaluation.cast<NXShaderStage>()->shader();
if (geometry)
stages[numStages++] = geometry.cast<NXShaderStage>()->shader();
if (fragment)
stages[numStages++] = fragment.cast<NXShaderStage>()->shader();
std::string infoLog;
m_shader = ctx->m_compiler.link(numStages, stages, &infoLog);
if (!m_shader)
Log.report(logvisor::Fatal, "Unable to link shader:\n%s\n", infoLog.c_str());
}
public:
NXShaderPipeline& operator=(const NXShaderPipeline&) = delete;
NXShaderPipeline(const NXShaderPipeline&) = delete;
void bind(struct pipe_context* pctx) const
{
const struct gl_shader_program* prog = m_shader.program();
if (gl_linked_shader* fs = prog->_LinkedShaders[MESA_SHADER_FRAGMENT])
{
struct st_fragment_program* p = (struct st_fragment_program*)fs->Program;
pctx->bind_fs_state(pctx, p->variants->driver_shader);
}
if (gl_linked_shader* gs = prog->_LinkedShaders[MESA_SHADER_GEOMETRY])
{
struct st_common_program* p = (struct st_common_program*)gs->Program;
pctx->bind_gs_state(pctx, p->variants->driver_shader);
}
if (gl_linked_shader* tes = prog->_LinkedShaders[MESA_SHADER_TESS_EVAL])
{
struct st_common_program* p = (struct st_common_program*)tes->Program;
pctx->bind_tes_state(pctx, p->variants->driver_shader);
}
if (gl_linked_shader* tcs = prog->_LinkedShaders[MESA_SHADER_TESS_CTRL])
{
struct st_common_program* p = (struct st_common_program*)tcs->Program;
pctx->bind_tcs_state(pctx, p->variants->driver_shader);
}
if (gl_linked_shader* vs = prog->_LinkedShaders[MESA_SHADER_VERTEX])
{
struct st_vertex_program* p = (struct st_vertex_program*)vs->Program;
pctx->bind_vs_state(pctx, p->variants->driver_shader);
}
pctx->bind_blend_state(pctx, m_blendState);
pctx->bind_rasterizer_state(pctx, m_rasState);
pctx->bind_depth_stencil_alpha_state(pctx, m_dsState);
}
};
static const nx_buffer_info* GetBufferGPUResource(const IGraphicsBuffer* buf, int idx)
{
if (buf->dynamic())
{
const NXGraphicsBufferD<BaseGraphicsData>* cbuf =
static_cast<const NXGraphicsBufferD<BaseGraphicsData>*>(buf);
return &cbuf->m_bufferInfo[idx];
}
else
{
const NXGraphicsBufferS* cbuf = static_cast<const NXGraphicsBufferS*>(buf);
return &cbuf->m_bufferInfo;
}
}
static const struct pipe_sampler_view* GetTextureGPUResource(
const ITexture* tex, int idx, int bindIdx, bool depth, void*& samplerOut)
{
switch (tex->type())
{
case TextureType::Dynamic:
{
const NXTextureD* ctex = static_cast<const NXTextureD*>(tex);
samplerOut = ctex->m_sampler;
return ctex->m_gpuView[idx];
}
case TextureType::Static:
{
const NXTextureS* ctex = static_cast<const NXTextureS*>(tex);
samplerOut = ctex->m_sampler;
return ctex->m_gpuView;
}
case TextureType::StaticArray:
{
const NXTextureSA* ctex = static_cast<const NXTextureSA*>(tex);
samplerOut = ctex->m_sampler;
return ctex->m_gpuView;
}
case TextureType::Render:
{
const NXTextureR* ctex = static_cast<const NXTextureR*>(tex);
samplerOut = ctex->m_sampler;
return depth ? ctex->m_depthBindView[bindIdx] : ctex->m_colorBindView[bindIdx];
}
default: break;
}
return nullptr;
}
struct NXShaderDataBinding : GraphicsDataNode<IShaderDataBinding>
{
NXContext* m_ctx;
boo::ObjToken<IShaderPipeline> m_pipeline;
boo::ObjToken<IGraphicsBuffer> m_vbuf;
boo::ObjToken<IGraphicsBuffer> m_instVbuf;
boo::ObjToken<IGraphicsBuffer> m_ibuf;
std::vector<boo::ObjToken<IGraphicsBuffer>> m_ubufs;
std::vector<std::array<size_t, 2>> m_ubufOffs;
struct BindTex
{
boo::ObjToken<ITexture> tex;
int idx;
bool depth;
};
std::vector<BindTex> m_texs;
struct pipe_vertex_buffer m_vboBufs[2][2] = {{},{}};
std::vector<std::array<struct pipe_constant_buffer, 2>> m_ubufBinds[MESA_SHADER_STAGES];
size_t m_vertOffset;
size_t m_instOffset;
#ifndef NDEBUG
/* Debugging aids */
bool m_committed = false;
#endif
NXShaderDataBinding(const boo::ObjToken<BaseGraphicsData>& d,
NXDataFactoryImpl& factory,
const boo::ObjToken<IShaderPipeline>& pipeline,
const boo::ObjToken<IGraphicsBuffer>& vbuf,
const boo::ObjToken<IGraphicsBuffer>& instVbuf,
const boo::ObjToken<IGraphicsBuffer>& ibuf,
size_t ubufCount, const boo::ObjToken<IGraphicsBuffer>* ubufs,
const size_t* ubufOffs, const size_t* ubufSizes,
size_t texCount, const boo::ObjToken<ITexture>* texs,
const int* bindIdxs, const bool* depthBinds,
size_t baseVert, size_t baseInst)
: GraphicsDataNode<IShaderDataBinding>(d),
m_ctx(factory.m_ctx),
m_pipeline(pipeline),
m_vbuf(vbuf),
m_instVbuf(instVbuf),
m_ibuf(ibuf)
{
NXShaderPipeline* cpipeline = m_pipeline.cast<NXShaderPipeline>();
NXVertexFormat& vtxFmt = cpipeline->m_vtxFmt;
m_vertOffset = baseVert * vtxFmt.m_stride;
m_instOffset = baseInst * vtxFmt.m_instStride;
m_ubufs.reserve(ubufCount);
if (ubufOffs && ubufSizes)
m_ubufOffs.reserve(ubufCount);
for (size_t i=0 ; i<ubufCount ; ++i)
{
#ifndef NDEBUG
if (!ubufs[i])
Log.report(logvisor::Fatal, "null uniform-buffer %d provided to newShaderDataBinding", int(i));
#endif
m_ubufs.push_back(ubufs[i]);
if (ubufOffs && ubufSizes)
m_ubufOffs.push_back({ubufOffs[i], ubufSizes[i]});
}
m_texs.reserve(texCount);
for (size_t i=0 ; i<texCount ; ++i)
{
m_texs.push_back({texs[i], bindIdxs ? bindIdxs[i] : 0, depthBinds ? depthBinds[i] : false});
}
}
void commit()
{
struct pipe_context* pctx = m_ctx->m_pctx;
for (int i = 0; i < 2; ++i)
{
if (m_vbuf)
{
m_vboBufs[i][0] = GetBufferGPUResource(m_vbuf.get(), i)->v;
m_vboBufs[i][0].buffer_offset += m_vertOffset;
}
if (m_instVbuf)
{
m_vboBufs[i][1] = GetBufferGPUResource(m_instVbuf.get(), i)->v;
m_vboBufs[i][1].buffer_offset += m_instOffset;
}
}
NXShaderPipeline* cpipeline = m_pipeline.cast<NXShaderPipeline>();
const struct gl_shader_program* program = cpipeline->m_shader.program();
for (uint i = 0; i < MESA_SHADER_STAGES; ++i)
{
if (const struct gl_linked_shader* lsh = program->_LinkedShaders[i])
{
std::vector<std::array<struct pipe_constant_buffer, 2>>& bindings = m_ubufBinds[i];
const struct gl_shader_program_data* data = lsh->Program->sh.data;
bindings.reserve(data->NumUniformBlocks);
for (uint j = 0; j < data->NumUniformBlocks; ++j)
{
const struct gl_uniform_block* block = &data->UniformBlocks[j];
assert(block->Binding < m_ubufs.size() && "Uniform binding oob");
bindings.emplace_back();
for (int k = 0; k < 2; ++k)
{
struct pipe_constant_buffer& bufBind = bindings.back()[k];
const nx_buffer_info* buf = GetBufferGPUResource(m_ubufs[block->Binding].get(), k);
bufBind = buf->c;
if (!m_ubufOffs.empty())
{
bufBind.buffer_offset += m_ubufOffs[block->Binding][0];
bufBind.buffer_size = unsigned(m_ubufOffs[block->Binding][1]);
}
}
}
}
}
#ifndef NDEBUG
m_committed = true;
#endif
}
void bind(int b)
{
#ifndef NDEBUG
if (!m_committed)
Log.report(logvisor::Fatal,
"attempted to use uncommitted NXShaderDataBinding");
#endif
struct pipe_context* pctx = m_ctx->m_pctx;
NXShaderPipeline* pipeline = m_pipeline.cast<NXShaderPipeline>();
pipeline->bind(pctx);
const struct gl_shader_program* program = pipeline->m_shader.program();
for (uint i = 0; i < MESA_SHADER_STAGES; ++i)
{
uint j = 0;
for (const auto& bind : m_ubufBinds[i])
pctx->set_constant_buffer(pctx, pipe_shader_type(i), j++, &bind[b]);
if (const struct gl_linked_shader* lsh = program->_LinkedShaders[i])
{
void* samplers[BOO_GLSL_MAX_TEXTURE_COUNT] = {};
struct pipe_sampler_view* samplerViews[BOO_GLSL_MAX_TEXTURE_COUNT] = {};
unsigned numSamplers = 0;
const struct gl_program* stprogram = lsh->Program;
for (int t = 0; t < BOO_GLSL_MAX_TEXTURE_COUNT; ++t)
{
if (stprogram->SamplersUsed & (1 << t))
{
GLubyte unit = GLubyte(stprogram->SamplerUnits[t] - BOO_GLSL_MAX_UNIFORM_COUNT);
assert(unit < m_texs.size() && "Texture binding oob");
const BindTex& tex = m_texs[unit];
samplerViews[numSamplers] = (pipe_sampler_view*)
GetTextureGPUResource(tex.tex.get(), t, tex.idx, tex.depth, samplers[numSamplers]);
++numSamplers;
}
}
pctx->bind_sampler_states(pctx, pipe_shader_type(i), 0, numSamplers, samplers);
pctx->set_sampler_views(pctx, pipe_shader_type(i), 0, numSamplers, samplerViews);
}
}
if (m_vbuf && m_instVbuf)
pctx->set_vertex_buffers(pctx, 0, 2, m_vboBufs[b]);
else if (m_vbuf)
pctx->set_vertex_buffers(pctx, 0, 1, m_vboBufs[b]);
else if (m_instVbuf)
pctx->set_vertex_buffers(pctx, 1, 1, &m_vboBufs[b][1]);
}
pipe_prim_type getPrimitive() const { return m_pipeline.cast<NXShaderPipeline>()->m_nxPrim; }
uint32_t getPatchVerts() const { return m_pipeline.cast<NXShaderPipeline>()->m_patchSize; }
struct pipe_resource* getIndexBuf(int b) const { return GetBufferGPUResource(m_ibuf.get(), b)->v.buffer.resource; }
};
struct NXCommandQueue : IGraphicsCommandQueue
{
Platform platform() const {return IGraphicsDataFactory::Platform::Vulkan;}
const SystemChar* platformName() const {return _SYS_STR("NX");}
NXContext* m_ctx;
IGraphicsContext* m_parent;
bool m_running = true;
int m_fillBuf = 0;
int m_drawBuf = 0;
std::vector<boo::ObjToken<boo::IObj>> m_drawResTokens[2];
NXCommandQueue(NXContext* ctx, IGraphicsContext* parent)
: m_ctx(ctx), m_parent(parent)
{
}
void startRenderer()
{
static_cast<NXDataFactoryImpl*>(m_parent->getDataFactory())->SetupGammaResources();
}
void stopRenderer()
{
m_running = false;
static_cast<NXDataFactoryImpl*>(m_parent->getDataFactory())->DestroyGammaResources();
m_drawResTokens[0].clear();
m_drawResTokens[1].clear();
m_boundTarget.reset();
m_resolveDispSource.reset();
}
~NXCommandQueue()
{
if (m_running)
stopRenderer();
}
boo::ObjToken<IShaderDataBinding> m_curSDBinding;
void setShaderDataBinding(const boo::ObjToken<IShaderDataBinding>& binding)
{
m_curSDBinding = binding;
NXShaderDataBinding* cbind = binding.cast<NXShaderDataBinding>();
cbind->bind(m_fillBuf);
m_drawResTokens[m_fillBuf].push_back(binding.get());
}
boo::ObjToken<ITextureR> m_boundTarget;
void setRenderTarget(const boo::ObjToken<ITextureR>& target)
{
NXTextureR* ctarget = target.cast<NXTextureR>();
if (m_boundTarget.get() != ctarget)
{
m_boundTarget = target;
m_drawResTokens[m_fillBuf].push_back(target.get());
}
m_ctx->m_pctx->set_framebuffer_state(m_ctx->m_pctx, &ctarget->m_framebuffer);
}
void setViewport(const SWindowRect& rect, float znear, float zfar)
{
if (m_boundTarget)
{
NXTextureR* ctarget = m_boundTarget.cast<NXTextureR>();
struct gl_context* ctx = m_ctx->m_st->ctx;
ctx->ViewportArray[0].X = float(rect.location[0]);
ctx->ViewportArray[0].Y = float(std::max(0, int(ctarget->m_height) - rect.location[1] - rect.size[1]));
ctx->ViewportArray[0].Width = float(rect.size[0]);
ctx->ViewportArray[0].Height = float(rect.size[1]);
ctx->ViewportArray[0].Near = znear;
ctx->ViewportArray[0].Far = zfar;
pipe_viewport_state vp = {};
_mesa_get_viewport_xform(ctx, 0, vp.scale, vp.translate);
m_ctx->m_pctx->set_viewport_states(m_ctx->m_pctx, 0, 1, &vp);
}
}
void setScissor(const SWindowRect& rect)
{
if (m_boundTarget)
{
NXTextureR* ctarget = m_boundTarget.cast<NXTextureR>();
pipe_scissor_state scissor = {};
scissor.minx = unsigned(rect.location[0]);
scissor.miny = unsigned(std::max(0, int(ctarget->m_height) - rect.location[1] - rect.size[1]));
scissor.maxx = scissor.minx + unsigned(rect.size[0]);
scissor.maxy = scissor.miny + unsigned(rect.size[1]);
m_ctx->m_pctx->set_scissor_states(m_ctx->m_pctx, 0, 1, &scissor);
}
}
std::unordered_map<NXTextureR*, std::pair<size_t, size_t>> m_texResizes;
void resizeRenderTexture(const boo::ObjToken<ITextureR>& tex, size_t width, size_t height)
{
NXTextureR* ctex = tex.cast<NXTextureR>();
m_texResizes[ctex] = std::make_pair(width, height);
m_drawResTokens[m_fillBuf].push_back(tex.get());
}
void schedulePostFrameHandler(std::function<void(void)>&& func)
{
func();
}
float m_clearColor[4] = {0.0,0.0,0.0,0.0};
void setClearColor(const float rgba[4])
{
m_clearColor[0] = rgba[0];
m_clearColor[1] = rgba[1];
m_clearColor[2] = rgba[2];
m_clearColor[3] = rgba[3];
}
void clearTarget(bool render=true, bool depth=true)
{
if (!m_boundTarget)
return;
unsigned buffers = 0;
if (render)
buffers |= PIPE_CLEAR_COLOR0;
if (depth)
buffers |= PIPE_CLEAR_DEPTH;
pipe_color_union cunion;
for (int i = 0; i < 4; ++i)
cunion.f[i] = m_clearColor[i];
m_ctx->m_pctx->clear(m_ctx->m_pctx, buffers, &cunion, 1.f, 0);
}
void draw(size_t start, size_t count)
{
pipe_draw_info info = {};
NXShaderDataBinding* sdBinding = m_curSDBinding.cast<NXShaderDataBinding>();
info.mode = sdBinding->getPrimitive();
info.vertices_per_patch = sdBinding->getPatchVerts();
info.start = start;
info.count = count;
m_ctx->m_pctx->draw_vbo(m_ctx->m_pctx, &info);
}
void drawIndexed(size_t start, size_t count)
{
pipe_draw_info info = {};
NXShaderDataBinding* sdBinding = m_curSDBinding.cast<NXShaderDataBinding>();
info.index_size = 4;
info.mode = sdBinding->getPrimitive();
info.primitive_restart = 1;
info.vertices_per_patch = sdBinding->getPatchVerts();
info.start = start;
info.count = count;
info.restart_index = 0xffffffff;
info.index.resource = sdBinding->getIndexBuf(m_fillBuf);
m_ctx->m_pctx->draw_vbo(m_ctx->m_pctx, &info);
}
void drawInstances(size_t start, size_t count, size_t instCount)
{
pipe_draw_info info = {};
NXShaderDataBinding* sdBinding = m_curSDBinding.cast<NXShaderDataBinding>();
info.mode = sdBinding->getPrimitive();
info.vertices_per_patch = sdBinding->getPatchVerts();
info.start = start;
info.count = count;
info.instance_count = instCount;
m_ctx->m_pctx->draw_vbo(m_ctx->m_pctx, &info);
}
void drawInstancesIndexed(size_t start, size_t count, size_t instCount)
{
pipe_draw_info info = {};
NXShaderDataBinding* sdBinding = m_curSDBinding.cast<NXShaderDataBinding>();
info.index_size = 4;
info.mode = sdBinding->getPrimitive();
info.primitive_restart = 1;
info.vertices_per_patch = sdBinding->getPatchVerts();
info.start = start;
info.count = count;
info.instance_count = instCount;
info.restart_index = 0xffffffff;
info.index.resource = sdBinding->getIndexBuf(m_fillBuf);
m_ctx->m_pctx->draw_vbo(m_ctx->m_pctx, &info);
}
boo::ObjToken<ITextureR> m_resolveDispSource;
void resolveDisplay(const boo::ObjToken<ITextureR>& source)
{
m_resolveDispSource = source;
}
bool _resolveDisplay()
{
if (!m_resolveDispSource)
return false;
NXTextureR* csource = m_resolveDispSource.cast<NXTextureR>();
#ifndef NDEBUG
if (!csource->m_colorBindCount)
Log.report(logvisor::Fatal,
"texture provided to resolveDisplay() must have at least 1 color binding");
#endif
struct pipe_surface* backBuf = m_ctx->m_windowSurfaces[ST_ATTACHMENT_BACK_LEFT];
NXDataFactoryImpl* dataFactory = static_cast<NXDataFactoryImpl*>(m_parent->getDataFactory());
if (dataFactory->m_gamma != 1.f)
{
SWindowRect rect(0, 0, csource->m_width, csource->m_height);
_resolveBindTexture(csource, rect, true, 0, true, false);
NXShaderDataBinding* gammaBinding = dataFactory->m_gammaBinding.cast<NXShaderDataBinding>();
pipe_framebuffer_state fstate = {};
fstate.width = backBuf->texture->width0;
fstate.height = backBuf->texture->height0;
fstate.nr_cbufs = 1;
fstate.cbufs[0] = backBuf;
m_ctx->m_pctx->set_framebuffer_state(m_ctx->m_pctx, &fstate);
gammaBinding->m_texs[0].tex = m_resolveDispSource.get();
gammaBinding->bind(m_drawBuf);
pipe_draw_info info = {};
info.mode = PIPE_PRIM_TRIANGLE_STRIP;
info.start = 0;
info.count = 4;
info.instance_count = 1;
m_ctx->m_pctx->draw_vbo(m_ctx->m_pctx, &info);
gammaBinding->m_texs[0].tex.reset();
}
else
{
pipe_blit_info binfo = {};
binfo.src.resource = csource->m_colorTex;
binfo.dst.resource = backBuf->texture;
u_box_2d(0, 0, csource->m_width, csource->m_height, &binfo.src.box);
binfo.dst.box = binfo.src.box;
binfo.src.format = binfo.dst.format = PIPE_FORMAT_R8G8B8A8_UNORM;
binfo.mask = PIPE_MASK_RGBA;
binfo.filter = PIPE_TEX_FILTER_NEAREST;
m_ctx->m_pctx->blit(m_ctx->m_pctx, &binfo);
}
m_resolveDispSource.reset();
return true;
}
void _resolveBindTexture(NXTextureR* ctexture,
const SWindowRect& rect, bool tlOrigin,
int bindIdx, bool color, bool depth)
{
SWindowRect intersectRect = rect.intersect(SWindowRect(0, 0, ctexture->m_width, ctexture->m_height));
if (color && ctexture->m_colorBindCount)
{
pipe_blit_info binfo = {};
binfo.src.resource = ctexture->m_colorTex;
binfo.dst.resource = ctexture->m_colorBindTex[bindIdx];
u_box_2d(intersectRect.location[0],
tlOrigin ? intersectRect.location[1] :
(ctexture->m_height - intersectRect.size[1] - intersectRect.location[1]),
intersectRect.size[0], intersectRect.size[1], &binfo.src.box);
binfo.dst.box = binfo.src.box;
binfo.src.format = binfo.dst.format = PIPE_FORMAT_R8G8B8A8_UNORM;
binfo.mask = PIPE_MASK_RGBA;
binfo.filter = PIPE_TEX_FILTER_NEAREST;
m_ctx->m_pctx->blit(m_ctx->m_pctx, &binfo);
}
if (depth && ctexture->m_depthBindCount)
{
pipe_blit_info binfo = {};
binfo.src.resource = ctexture->m_depthTex;
binfo.dst.resource = ctexture->m_depthBindTex[bindIdx];
u_box_2d(intersectRect.location[0],
tlOrigin ? intersectRect.location[1] :
(ctexture->m_height - intersectRect.size[1] - intersectRect.location[1]),
intersectRect.size[0], intersectRect.size[1], &binfo.src.box);
binfo.dst.box = binfo.src.box;
binfo.src.format = binfo.dst.format = PIPE_FORMAT_Z32_FLOAT;
binfo.mask = PIPE_MASK_Z;
binfo.filter = PIPE_TEX_FILTER_NEAREST;
m_ctx->m_pctx->blit(m_ctx->m_pctx, &binfo);
}
}
void resolveBindTexture(const boo::ObjToken<ITextureR>& texture,
const SWindowRect& rect, bool tlOrigin,
int bindIdx, bool color, bool depth, bool clearDepth)
{
NXTextureR* ctexture = texture.cast<NXTextureR>();
_resolveBindTexture(ctexture, rect, tlOrigin, bindIdx, color, depth);
if (clearDepth)
m_ctx->m_pctx->clear(m_ctx->m_pctx, PIPE_CLEAR_DEPTH, nullptr, 1.f, 0);
}
void execute();
};
NXDataFactory::Context::Context(NXDataFactory& parent __BooTraceArgs)
: m_parent(parent), m_data(new NXData(static_cast<NXDataFactoryImpl&>(parent) __BooTraceArgsUse)) {}
NXDataFactory::Context::~Context() {}
boo::ObjToken<IGraphicsBufferS>
NXDataFactory::Context::newStaticBuffer(BufferUse use, const void* data, size_t stride, size_t count)
{
NXDataFactoryImpl& factory = static_cast<NXDataFactoryImpl&>(m_parent);
return {new NXGraphicsBufferS(m_data, use, factory.m_ctx, data, stride, count)};
}
boo::ObjToken<IGraphicsBufferD>
NXDataFactory::Context::newDynamicBuffer(BufferUse use, size_t stride, size_t count)
{
NXDataFactoryImpl& factory = static_cast<NXDataFactoryImpl&>(m_parent);
return {new NXGraphicsBufferD<BaseGraphicsData>(m_data, use, factory.m_ctx, stride, count)};
}
boo::ObjToken<ITextureS>
NXDataFactory::Context::newStaticTexture(size_t width, size_t height, size_t mips, TextureFormat fmt,
TextureClampMode clampMode, const void* data, size_t sz)
{
NXDataFactoryImpl& factory = static_cast<NXDataFactoryImpl&>(m_parent);
return {new NXTextureS(m_data, factory.m_ctx, width, height, mips, fmt, clampMode, data, sz)};
}
boo::ObjToken<ITextureSA>
NXDataFactory::Context::newStaticArrayTexture(size_t width, size_t height, size_t layers, size_t mips,
TextureFormat fmt, TextureClampMode clampMode,
const void* data, size_t sz)
{
NXDataFactoryImpl& factory = static_cast<NXDataFactoryImpl&>(m_parent);
return {new NXTextureSA(m_data, factory.m_ctx, width, height, layers, mips, fmt, clampMode, data, sz)};
}
boo::ObjToken<ITextureD>
NXDataFactory::Context::newDynamicTexture(size_t width, size_t height, TextureFormat fmt, TextureClampMode clampMode)
{
NXDataFactoryImpl& factory = static_cast<NXDataFactoryImpl&>(m_parent);
NXCommandQueue* q = static_cast<NXCommandQueue*>(factory.m_parent->getCommandQueue());
return {new NXTextureD(m_data, q, width, height, fmt, clampMode)};
}
boo::ObjToken<ITextureR>
NXDataFactory::Context::newRenderTexture(size_t width, size_t height, TextureClampMode clampMode,
size_t colorBindCount, size_t depthBindCount)
{
NXDataFactoryImpl& factory = static_cast<NXDataFactoryImpl&>(m_parent);
return {new NXTextureR(m_data, factory.m_ctx, width, height, clampMode, colorBindCount, depthBindCount)};
}
ObjToken<IShaderStage>
NXDataFactory::Context::newShaderStage(const uint8_t* data, size_t size, PipelineStage stage)
{
NXDataFactoryImpl& factory = static_cast<NXDataFactoryImpl&>(m_parent);
return {new NXShaderStage(m_data, factory.m_ctx, data, size, stage)};
}
ObjToken<IShaderPipeline>
NXDataFactory::Context::newShaderPipeline(ObjToken<IShaderStage> vertex, ObjToken<IShaderStage> fragment,
ObjToken<IShaderStage> geometry, ObjToken<IShaderStage> control,
ObjToken<IShaderStage> evaluation, const VertexFormatInfo& vtxFmt,
const AdditionalPipelineInfo& info)
{
NXDataFactoryImpl& factory = static_cast<NXDataFactoryImpl&>(m_parent);
return {new NXShaderPipeline(m_data, factory.m_ctx, vertex, fragment, geometry, control, evaluation, vtxFmt, info)};
}
boo::ObjToken<IShaderDataBinding>
NXDataFactory::Context::newShaderDataBinding(const boo::ObjToken<IShaderPipeline>& pipeline,
const boo::ObjToken<IGraphicsBuffer>& vbo,
const boo::ObjToken<IGraphicsBuffer>& instVbo,
const boo::ObjToken<IGraphicsBuffer>& ibo,
size_t ubufCount, const boo::ObjToken<IGraphicsBuffer>* ubufs, const PipelineStage* ubufStages,
const size_t* ubufOffs, const size_t* ubufSizes,
size_t texCount, const boo::ObjToken<ITexture>* texs,
const int* bindIdxs, const bool* bindDepth,
size_t baseVert, size_t baseInst)
{
NXDataFactoryImpl& factory = static_cast<NXDataFactoryImpl&>(m_parent);
return {new NXShaderDataBinding(m_data, factory, pipeline, vbo, instVbo, ibo, ubufCount, ubufs, ubufOffs,
ubufSizes, texCount, texs, bindIdxs, bindDepth, baseVert, baseInst)};
}
NXTextureD::NXTextureD(const boo::ObjToken<BaseGraphicsData>& parent, NXCommandQueue* q,
size_t width, size_t height, TextureFormat fmt, TextureClampMode clampMode)
: GraphicsDataNode<ITextureD>(parent), m_q(q), m_width(width), m_height(height),
m_fmt(fmt), m_clampMode(clampMode)
{
NXContext* ctx = m_q->m_ctx;
pipe_format pfmt;
switch (fmt)
{
case TextureFormat::RGBA8:
pfmt = PIPE_FORMAT_R8G8B8A8_UNORM;
m_cpuSz = width * height * 4;
break;
case TextureFormat::I8:
pfmt = PIPE_FORMAT_R8_UNORM;
m_cpuSz = width * height;
break;
case TextureFormat::I16:
pfmt = PIPE_FORMAT_R16_UNORM;
m_cpuSz = width * height * 2;
break;
default:
Log.report(logvisor::Fatal, "unsupported tex format");
}
m_nxFmt = pfmt;
m_stagingBuf.reset(new uint8_t[m_cpuSz]);
struct pipe_resource texTempl = {};
texTempl.target = PIPE_TEXTURE_2D;
texTempl.format = m_nxFmt;
texTempl.width0 = width;
texTempl.height0 = height;
texTempl.depth0 = 1;
texTempl.array_size = 1;
texTempl.bind = PIPE_BIND_SAMPLER_VIEW;
for (int i = 0; i < 2; ++i)
{
m_gpuTex[i] = ctx->m_screen->resource_create(ctx->m_screen, &texTempl);
if (!m_gpuTex[i]) {
Log.report(logvisor::Fatal, "Failed to create texture");
return;
}
}
struct pipe_sampler_view svTempl = {};
svTempl.format = m_nxFmt;
svTempl.swizzle_r = PIPE_SWIZZLE_X;
svTempl.swizzle_g = PIPE_SWIZZLE_Y;
svTempl.swizzle_b = PIPE_SWIZZLE_Z;
svTempl.swizzle_a = PIPE_SWIZZLE_W;
for (int i = 0; i < 2; ++i)
{
svTempl.texture = m_gpuTex[i];
m_gpuView[i] = ctx->m_pctx->create_sampler_view(ctx->m_pctx, m_gpuTex[i], &svTempl);
}
}
void NXTextureD::update(int b)
{
int slot = 1 << b;
if ((slot & m_validSlots) == 0)
{
NXContext* ctx = m_q->m_ctx;
uint blockSize = util_format_get_blocksize(m_nxFmt);
uint8_t* ptr = m_stagingBuf.get();
size_t rowStride = m_width * blockSize;
size_t imageBytes = rowStride * m_height;
struct pipe_box box;
u_box_2d(0, 0, m_width, m_height, &box);
ctx->m_pctx->texture_subdata(ctx->m_pctx, m_gpuTex[m_q->m_fillBuf], 0, PIPE_TRANSFER_WRITE,
&box, ptr, rowStride, imageBytes);
m_validSlots |= slot;
}
}
void NXTextureD::setClampMode(TextureClampMode mode)
{
m_clampMode = mode;
MakeSampler(m_q->m_ctx, m_sampler, mode, 1);
}
void NXTextureD::load(const void* data, size_t sz)
{
size_t bufSz = std::min(sz, m_cpuSz);
memmove(m_stagingBuf.get(), data, bufSz);
m_validSlots = 0;
}
void* NXTextureD::map(size_t sz)
{
if (sz > m_cpuSz)
return nullptr;
return m_stagingBuf.get();
}
void NXTextureD::unmap()
{
m_validSlots = 0;
}
static inline struct pipe_resource *
pipe_buffer_create_flags(struct pipe_screen *screen,
unsigned bind,
enum pipe_resource_usage usage,
unsigned flags,
unsigned size)
{
struct pipe_resource buffer;
memset(&buffer, 0, sizeof buffer);
buffer.target = PIPE_BUFFER;
buffer.format = PIPE_FORMAT_R8_UNORM; /* want TYPELESS or similar */
buffer.bind = bind;
buffer.usage = usage;
buffer.flags = flags;
buffer.width0 = size;
buffer.height0 = 1;
buffer.depth0 = 1;
buffer.array_size = 1;
return screen->resource_create(screen, &buffer);
}
void NXDataFactoryImpl::commitTransaction
(const std::function<bool(IGraphicsDataFactory::Context&)>& trans __BooTraceArgs)
{
Context ctx(*this __BooTraceArgsUse);
if (!trans(ctx))
return;
NXData* data = ctx.m_data.cast<NXData>();
/* size up resources */
unsigned constantMemSizes[3] = {};
if (data->m_SBufs)
for (IGraphicsBufferS& buf : *data->m_SBufs)
{
auto& cbuf = static_cast<NXGraphicsBufferS&>(buf);
if (cbuf.m_use == BufferUse::Null)
continue;
unsigned& sz = constantMemSizes[int(cbuf.m_use) - 1];
sz = cbuf.sizeForGPU(m_ctx, sz);
}
if (data->m_DBufs)
for (IGraphicsBufferD& buf : *data->m_DBufs)
{
auto& cbuf = static_cast<NXGraphicsBufferD<BaseGraphicsData>&>(buf);
if (cbuf.m_use == BufferUse::Null)
continue;
unsigned& sz = constantMemSizes[int(cbuf.m_use) - 1];
sz = cbuf.sizeForGPU(m_ctx, sz);
}
/* allocate memory and place buffers */
for (int i=0 ; i<3 ; ++i)
{
if (constantMemSizes[i])
{
struct pipe_resource* poolBuf =
pipe_buffer_create_flags(m_ctx->m_screen, USE_TABLE[i+1], PIPE_USAGE_DEFAULT,
PIPE_RESOURCE_FLAG_MAP_PERSISTENT | PIPE_RESOURCE_FLAG_MAP_COHERENT,
constantMemSizes[i]);
data->m_constantBuffers[i] = poolBuf;
pipe_transfer* xfer;
uint8_t* mappedData = (uint8_t*)pipe_buffer_map(m_ctx->m_pctx, poolBuf,
PIPE_TRANSFER_WRITE | PIPE_TRANSFER_MAP_DIRECTLY |
PIPE_TRANSFER_PERSISTENT | PIPE_TRANSFER_COHERENT, &xfer);
if (data->m_SBufs)
for (IGraphicsBufferS& buf : *data->m_SBufs)
{
auto& cbuf = static_cast<NXGraphicsBufferS&>(buf);
if (int(cbuf.m_use) - 1 != i)
continue;
cbuf.placeForGPU(poolBuf, mappedData);
}
if (data->m_DBufs)
for (IGraphicsBufferD& buf : *data->m_DBufs)
{
auto& cbuf = static_cast<NXGraphicsBufferD<BaseGraphicsData>&>(buf);
if (int(cbuf.m_use) - 1 != i)
continue;
cbuf.placeForGPU(poolBuf, mappedData);
}
}
}
/* Commit data bindings (create descriptor sets) */
if (data->m_SBinds)
for (IShaderDataBinding& bind : *data->m_SBinds)
static_cast<NXShaderDataBinding&>(bind).commit();
}
boo::ObjToken<IGraphicsBufferD>
NXDataFactoryImpl::newPoolBuffer(BufferUse use, size_t stride, size_t count __BooTraceArgs)
{
boo::ObjToken<BaseGraphicsPool> pool(new NXPool(*this __BooTraceArgsUse));
NXPool* cpool = pool.cast<NXPool>();
NXGraphicsBufferD<BaseGraphicsPool>* retval =
new NXGraphicsBufferD<BaseGraphicsPool>(pool, use, m_ctx, stride, count);
unsigned size = retval->sizeForGPU(m_ctx, 0);
/* allocate memory */
if (size)
{
struct pipe_resource* poolBuf =
pipe_buffer_create_flags(m_ctx->m_screen, USE_TABLE[int(use)], PIPE_USAGE_DEFAULT,
PIPE_RESOURCE_FLAG_MAP_PERSISTENT | PIPE_RESOURCE_FLAG_MAP_COHERENT, size);
cpool->m_constantBuffer = poolBuf;
pipe_transfer* xfer;
uint8_t* mappedData = (uint8_t*)pipe_buffer_map(m_ctx->m_pctx, poolBuf,
PIPE_TRANSFER_WRITE | PIPE_TRANSFER_MAP_DIRECTLY |
PIPE_TRANSFER_PERSISTENT | PIPE_TRANSFER_COHERENT, &xfer);
retval->placeForGPU(poolBuf, mappedData);
}
return {retval};
}
void NXCommandQueue::execute()
{
if (!m_running)
return;
/* Stage dynamic uploads */
NXDataFactoryImpl* gfxF = static_cast<NXDataFactoryImpl*>(m_parent->getDataFactory());
std::unique_lock<std::recursive_mutex> datalk(gfxF->m_dataMutex);
if (gfxF->m_dataHead)
{
for (BaseGraphicsData& d : *gfxF->m_dataHead)
{
if (d.m_DBufs)
for (IGraphicsBufferD& b : *d.m_DBufs)
static_cast<NXGraphicsBufferD<BaseGraphicsData>&>(b).update(m_fillBuf);
if (d.m_DTexs)
for (ITextureD& t : *d.m_DTexs)
static_cast<NXTextureD&>(t).update(m_fillBuf);
}
}
if (gfxF->m_poolHead)
{
for (BaseGraphicsPool& p : *gfxF->m_poolHead)
{
if (p.m_DBufs)
for (IGraphicsBufferD& b : *p.m_DBufs)
static_cast<NXGraphicsBufferD<BaseGraphicsData>&>(b).update(m_fillBuf);
}
}
datalk.unlock();
/* Perform texture and swap-chain resizes */
if (m_ctx->_resizeWindowSurfaces() || m_texResizes.size())
{
for (const auto& resize : m_texResizes)
{
if (m_boundTarget.get() == resize.first)
m_boundTarget.reset();
resize.first->resize(m_ctx, resize.second.first, resize.second.second);
}
m_texResizes.clear();
m_resolveDispSource = nullptr;
return;
}
/* Clear dead data */
m_drawResTokens[m_drawBuf].clear();
/* Swap internal buffers */
m_drawBuf = m_fillBuf;
m_fillBuf ^= 1;
/* Flush the pipe */
m_ctx->m_pctx->flush(m_ctx->m_pctx, nullptr, PIPE_FLUSH_END_OF_FRAME);
/* Set framebuffer fence */
NvFence fence;
struct pipe_surface* old_back = m_ctx->m_windowSurfaces[ST_ATTACHMENT_BACK_LEFT];
fence.id = nouveau_switch_resource_get_syncpoint(old_back->texture, &fence.value);
if ((int)fence.id >= 0) {
NvFence* surf_fence = &m_ctx->m_fences[m_ctx->m_fence_swap];
if (surf_fence->id != fence.id || surf_fence->value != fence.value) {
*surf_fence = fence;
NvMultiFence mf;
nvMultiFenceCreate(&mf, &fence);
gfxAppendFence(&mf);
}
}
gfxSwapBuffers();
/* Swap buffer attachments and invalidate framebuffer */
m_ctx->m_fence_swap = !m_ctx->m_fence_swap;
m_ctx->m_windowSurfaces[ST_ATTACHMENT_BACK_LEFT] = m_ctx->m_windowSurfaces[ST_ATTACHMENT_FRONT_LEFT];
m_ctx->m_windowSurfaces[ST_ATTACHMENT_FRONT_LEFT] = old_back;
}
static void setMesaConfig()
{
// Uncomment below to disable error checking and save CPU time (useful for production):
//setenv("MESA_NO_ERROR", "1", 1);
// Uncomment below to enable Mesa logging:
setenv("EGL_LOG_LEVEL", "debug", 1);
setenv("MESA_VERBOSE", "all", 1);
setenv("NOUVEAU_MESA_DEBUG", "1", 1);
// Uncomment below to enable shader debugging in Nouveau:
setenv("NV50_PROG_OPTIMIZE", "0", 1);
setenv("NV50_PROG_DEBUG", "1", 1);
setenv("NV50_PROG_CHIPSET", "0x120", 1);
}
bool NXContext::initialize()
{
/* Set mesa configuration (useful for debugging) */
setMesaConfig();
gfxInitDefault();
gfxSetMode(GfxMode_TiledDouble);
consoleInit(NULL);
printf("Activated console\n\n");
m_screen = nouveau_switch_screen_create();
if (!m_screen)
{
Log.report(logvisor::Fatal, "Failed to create nouveau screen");
return false;
}
printf("nouveau_switch_screen_create done\n");
fflush(stdout);
m_pctx = m_screen->context_create(m_screen, nullptr, 0);
if (!m_pctx)
{
Log.report(logvisor::Fatal, "Failed to create pipe context");
m_screen->destroy(m_screen);
return false;
}
printf("m_screen->context_create done\n");
st_config_options opts = {};
m_st = st_create_context(API_OPENGL_CORE, m_pctx, nullptr, nullptr, &opts, false);
if (!m_st)
{
Log.report(logvisor::Fatal, "Failed to create st context");
m_screen->destroy(m_screen);
return false;
}
u32 width, height;
gfxGetFramebufferResolution(&width, &height);
for (int i = 0; i < 2; ++i)
{
/* color target */
struct pipe_resource texTempl = {};
texTempl.target = PIPE_TEXTURE_RECT;
texTempl.format = ColorFormat;
texTempl.width0 = width;
texTempl.height0 = height;
texTempl.depth0 = 1;
texTempl.array_size = 1;
texTempl.usage = PIPE_USAGE_DEFAULT;
texTempl.nr_samples = texTempl.nr_storage_samples = 1;
texTempl.bind = PIPE_BIND_RENDER_TARGET;
u32 index = i == ST_ATTACHMENT_FRONT_LEFT ? 1 : 0;
struct winsys_handle whandle;
whandle.type = WINSYS_HANDLE_TYPE_SHARED;
whandle.handle = gfxGetFramebufferHandle(index, &whandle.offset);
whandle.stride = gfxGetFramebufferPitch();
struct pipe_resource* tex = m_screen->resource_from_handle(m_screen, &texTempl, &whandle, 0);
if (!tex) {
Log.report(logvisor::Fatal, "Failed to create color target texture");
return false;
}
/* surface */
struct pipe_surface surfTempl = {};
surfTempl.format = ColorFormat;
m_windowSurfaces[i] = m_pctx->create_surface(m_pctx, tex, &surfTempl);
if (!m_windowSurfaces[i]) {
Log.report(logvisor::Fatal, "Failed to create color surface");
return false;
}
m_fences[i].id = UINT32_MAX;
}
return m_compiler.initialize(m_screen, m_st);
}
bool NXContext::terminate()
{
if (m_st)
st_destroy_context(m_st);
if (m_screen)
m_screen->destroy(m_screen);
gfxExit();
return true;
}
bool NXContext::_resizeWindowSurfaces()
{
return false;
}
std::unique_ptr<IGraphicsCommandQueue> _NewNXCommandQueue(NXContext* ctx, IGraphicsContext* parent)
{
return std::make_unique<NXCommandQueue>(ctx, parent);
}
std::unique_ptr<IGraphicsDataFactory> _NewNXDataFactory(IGraphicsContext* parent, NXContext* ctx)
{
return std::make_unique<NXDataFactoryImpl>(parent, ctx);
}
}