Skip to content

S
swiftshader
Commit bc1c067b by Ben Clayton
Options

clang-format the src/Pipeline directory

Bug: b/144825072 Change-Id: I869aef91d6318bf6955581e5dad762800bd46296 Reviewed-on: https://swiftshader-review.googlesource.com/c/SwiftShader/+/39655Tested-by: 's avatarBen Clayton <bclayton@google.com> Reviewed-by: 's avatarNicolas Capens <nicolascapens@google.com>
parent fccfc566
Showing with 446 additions and 390 deletions
src/Pipeline/ComputeProgram.cpp
......@@ -26,16 +26,21 @@
namespace {
enum { X, Y, Z };
enum
{
X,
Y,
Z
};
} // anonymous namespace
namespace sw {
ComputeProgram::ComputeProgram(SpirvShader const *shader, vk::PipelineLayout const *pipelineLayout, const vk::DescriptorSet::Bindings &descriptorSets)
: shader(shader),
pipelineLayout(pipelineLayout),
descriptorSets(descriptorSets)
: shader(shader)
, pipelineLayout(pipelineLayout)
, descriptorSets(descriptorSets)
{
}
......@@ -53,10 +58,9 @@ void ComputeProgram::generate()
shader->emitEpilog(&routine);
}
void ComputeProgram::setWorkgroupBuiltins(Pointer<Byte> data, SpirvRoutine* routine, Int workgroupID[3])
void ComputeProgram::setWorkgroupBuiltins(Pointer<Byte> data, SpirvRoutine *routine, Int workgroupID[3])
{
routine->setInputBuiltin(shader, spv::BuiltInNumWorkgroups, [&](const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)
{
routine->setInputBuiltin(shader, spv::BuiltInNumWorkgroups, [&](const SpirvShader::BuiltinMapping &builtin, Array<SIMD::Float> &value) {
auto numWorkgroups = *Pointer<Int4>(data + OFFSET(Data, numWorkgroups));
for(uint32_t component = 0; component < builtin.SizeInComponents; component++)
{
......@@ -65,8 +69,7 @@ void ComputeProgram::setWorkgroupBuiltins(Pointer<Byte> data, SpirvRoutine* rout
}
});
routine->setInputBuiltin(shader, spv::BuiltInWorkgroupId, [&](const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)
{
routine->setInputBuiltin(shader, spv::BuiltInWorkgroupId, [&](const SpirvShader::BuiltinMapping &builtin, Array<SIMD::Float> &value) {
for(uint32_t component = 0; component < builtin.SizeInComponents; component++)
{
value[builtin.FirstComponent + component] =
......@@ -74,8 +77,7 @@ void ComputeProgram::setWorkgroupBuiltins(Pointer<Byte> data, SpirvRoutine* rout
}
});
routine->setInputBuiltin(shader, spv::BuiltInWorkgroupSize, [&](const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)
{
routine->setInputBuiltin(shader, spv::BuiltInWorkgroupSize, [&](const SpirvShader::BuiltinMapping &builtin, Array<SIMD::Float> &value) {
auto workgroupSize = *Pointer<Int4>(data + OFFSET(Data, workgroupSize));
for(uint32_t component = 0; component < builtin.SizeInComponents; component++)
{
......@@ -84,15 +86,13 @@ void ComputeProgram::setWorkgroupBuiltins(Pointer<Byte> data, SpirvRoutine* rout
}
});
routine->setInputBuiltin(shader, spv::BuiltInNumSubgroups, [&](const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)
{
routine->setInputBuiltin(shader, spv::BuiltInNumSubgroups, [&](const SpirvShader::BuiltinMapping &builtin, Array<SIMD::Float> &value) {
ASSERT(builtin.SizeInComponents == 1);
auto subgroupsPerWorkgroup = *Pointer<Int>(data + OFFSET(Data, subgroupsPerWorkgroup));
value[builtin.FirstComponent] = As<SIMD::Float>(SIMD::Int(subgroupsPerWorkgroup));
});
routine->setInputBuiltin(shader, spv::BuiltInSubgroupSize, [&](const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)
{
routine->setInputBuiltin(shader, spv::BuiltInSubgroupSize, [&](const SpirvShader::BuiltinMapping &builtin, Array<SIMD::Float> &value) {
ASSERT(builtin.SizeInComponents == 1);
auto invocationsPerSubgroup = *Pointer<Int>(data + OFFSET(Data, invocationsPerSubgroup));
value[builtin.FirstComponent] = As<SIMD::Float>(SIMD::Int(invocationsPerSubgroup));
......@@ -101,7 +101,7 @@ void ComputeProgram::setWorkgroupBuiltins(Pointer<Byte> data, SpirvRoutine* rout
routine->setImmutableInputBuiltins(shader);
}
void ComputeProgram::setSubgroupBuiltins(Pointer<Byte> data, SpirvRoutine* routine, Int workgroupID[3], SIMD::Int localInvocationIndex, Int subgroupIndex)
void ComputeProgram::setSubgroupBuiltins(Pointer<Byte> data, SpirvRoutine *routine, Int workgroupID[3], SIMD::Int localInvocationIndex, Int subgroupIndex)
{
Int4 numWorkgroups = *Pointer<Int4>(data + OFFSET(Data, numWorkgroups));
Int4 workgroupSize = *Pointer<Int4>(data + OFFSET(Data, workgroupSize));
......@@ -120,20 +120,17 @@ void ComputeProgram::setSubgroupBuiltins(Pointer<Byte> data, SpirvRoutine* routi
localInvocationID[X] = idx;
}
routine->setInputBuiltin(shader, spv::BuiltInLocalInvocationIndex, [&](const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)
{
routine->setInputBuiltin(shader, spv::BuiltInLocalInvocationIndex, [&](const SpirvShader::BuiltinMapping &builtin, Array<SIMD::Float> &value) {
ASSERT(builtin.SizeInComponents == 1);
value[builtin.FirstComponent] = As<SIMD::Float>(localInvocationIndex);
});
routine->setInputBuiltin(shader, spv::BuiltInSubgroupId, [&](const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)
{
routine->setInputBuiltin(shader, spv::BuiltInSubgroupId, [&](const SpirvShader::BuiltinMapping &builtin, Array<SIMD::Float> &value) {
ASSERT(builtin.SizeInComponents == 1);
value[builtin.FirstComponent] = As<SIMD::Float>(SIMD::Int(subgroupIndex));
});
routine->setInputBuiltin(shader, spv::BuiltInLocalInvocationId, [&](const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)
{
routine->setInputBuiltin(shader, spv::BuiltInLocalInvocationId, [&](const SpirvShader::BuiltinMapping &builtin, Array<SIMD::Float> &value) {
for(uint32_t component = 0; component < builtin.SizeInComponents; component++)
{
value[builtin.FirstComponent + component] =
......@@ -141,8 +138,7 @@ void ComputeProgram::setSubgroupBuiltins(Pointer<Byte> data, SpirvRoutine* routi
}
});
routine->setInputBuiltin(shader, spv::BuiltInGlobalInvocationId, [&](const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)
{
routine->setInputBuiltin(shader, spv::BuiltInGlobalInvocationId, [&](const SpirvShader::BuiltinMapping &builtin, Array<SIMD::Float> &value) {
SIMD::Int wgID = 0;
wgID = Insert(wgID, workgroupID[X], X);
wgID = Insert(wgID, workgroupID[Y], Y);
......@@ -156,7 +152,7 @@ void ComputeProgram::setSubgroupBuiltins(Pointer<Byte> data, SpirvRoutine* routi
});
}
void ComputeProgram::emit(SpirvRoutine* routine)
void ComputeProgram::emit(SpirvRoutine *routine)
{
Pointer<Byte> data = Arg<0>();
Int workgroupX = Arg<1>();
......@@ -174,7 +170,7 @@ void ComputeProgram::emit(SpirvRoutine* routine)
Int invocationsPerWorkgroup = *Pointer<Int>(data + OFFSET(Data, invocationsPerWorkgroup));
Int workgroupID[3] = {workgroupX, workgroupY, workgroupZ};
Int workgroupID[3] = { workgroupX, workgroupY, workgroupZ };
setWorkgroupBuiltins(data, routine, workgroupID);
For(Int i = 0, i < subgroupCount, i++)
......@@ -231,8 +227,7 @@ void ComputeProgram::run(
for(uint32_t batchID = 0; batchID < batchCount && batchID < groupCount; batchID++)
{
wg.add(1);
marl::schedule([=, &data]
{
marl::schedule([=, &data] {
defer(wg.done());
std::vector<uint8_t> workgroupMemory(shader->workgroupMemory.size());
......
src/Pipeline/ComputeProgram.hpp
......@@ -17,13 +17,15 @@
#include "SpirvShader.hpp"
#include "Reactor/Coroutine.hpp"
#include "Device/Context.hpp"
#include "Reactor/Coroutine.hpp"
#include "Vulkan/VkDescriptorSet.hpp"
#include <functional>
namespace vk { class PipelineLayout; }
namespace vk {
class PipelineLayout;
}
namespace sw {
......@@ -34,11 +36,11 @@ struct Constants;
// ComputeProgram builds a SPIR-V compute shader.
class ComputeProgram : public Coroutine<SpirvShader::YieldResult(
void* data,
void *data,
int32_t workgroupX,
int32_t workgroupY,
int32_t workgroupZ,
void* workgroupMemory,
void *workgroupMemory,
int32_t firstSubgroup,
int32_t subgroupCount)>
{
......@@ -59,9 +61,9 @@ public:
uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);
protected:
void emit(SpirvRoutine* routine);
void setWorkgroupBuiltins(Pointer<Byte> data, SpirvRoutine* routine, Int workgroupID[3]);
void setSubgroupBuiltins(Pointer<Byte> data, SpirvRoutine* routine, Int workgroupID[3], SIMD::Int localInvocationIndex, Int subgroupIndex);
void emit(SpirvRoutine *routine);
void setWorkgroupBuiltins(Pointer<Byte> data, SpirvRoutine *routine, Int workgroupID[3]);
void setSubgroupBuiltins(Pointer<Byte> data, SpirvRoutine *routine, Int workgroupID[3], SIMD::Int localInvocationIndex, Int subgroupIndex);
struct Data
{
......@@ -76,8 +78,8 @@ protected:
const Constants *constants;
};
SpirvShader const * const shader;
vk::PipelineLayout const * const pipelineLayout;
SpirvShader const *const shader;
vk::PipelineLayout const *const pipelineLayout;
const vk::DescriptorSet::Bindings &descriptorSets;
};
......
src/Pipeline/Constants.hpp
......@@ -15,8 +15,8 @@
#ifndef sw_Constants_hpp
#define sw_Constants_hpp
#include "System/Types.hpp"
#include "System/Math.hpp"
#include "System/Types.hpp"
#include "Vulkan/VkConfig.h"
namespace sw {
......@@ -91,10 +91,10 @@ struct Constants
// VK_SAMPLE_COUNT_4_BIT
// https://www.khronos.org/registry/vulkan/specs/1.1/html/vkspec.html#primsrast-multisampling
static constexpr float VkSampleLocations4[][2] = {
{0.375, 0.125},
{0.875, 0.375},
{0.125, 0.625},
{0.625, 0.875},
{ 0.375, 0.125 },
{ 0.875, 0.375 },
{ 0.125, 0.625 },
{ 0.625, 0.875 },
};
// Vulkan spec sample positions are relative to 0,0 in top left corner, with Y+ going down.
......@@ -141,6 +141,6 @@ struct Constants
extern Constants constants;
} // namepsace sw
} // namespace sw
#endif // sw_Constants_hpp
src/Pipeline/PixelProgram.cpp
......@@ -56,48 +56,43 @@ Int4 PixelProgram::maskAny(Int cMask[4], Int sMask[4], Int zMask[4]) const
return mask;
}
void PixelProgram::setBuiltins(Int &x, Int &y, Float4(&z)[4], Float4 &w, Int cMask[4])
void PixelProgram::setBuiltins(Int &x, Int &y, Float4 (&z)[4], Float4 &w, Int cMask[4])
{
routine.setImmutableInputBuiltins(spirvShader);
routine.setInputBuiltin(spirvShader, spv::BuiltInViewIndex, [&](const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)
{
routine.setInputBuiltin(spirvShader, spv::BuiltInViewIndex, [&](const SpirvShader::BuiltinMapping &builtin, Array<SIMD::Float> &value) {
assert(builtin.SizeInComponents == 1);
value[builtin.FirstComponent] = As<Float4>(Int4((*Pointer<Int>(data + OFFSET(DrawData, viewID)))));
});
routine.setInputBuiltin(spirvShader, spv::BuiltInFragCoord, [&](const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)
{
routine.setInputBuiltin(spirvShader, spv::BuiltInFragCoord, [&](const SpirvShader::BuiltinMapping &builtin, Array<SIMD::Float> &value) {
assert(builtin.SizeInComponents == 4);
value[builtin.FirstComponent+0] = SIMD::Float(Float(x)) + SIMD::Float(0.5f, 1.5f, 0.5f, 1.5f);
value[builtin.FirstComponent+1] = SIMD::Float(Float(y)) + SIMD::Float(0.5f, 0.5f, 1.5f, 1.5f);
value[builtin.FirstComponent+2] = z[0]; // sample 0
value[builtin.FirstComponent+3] = w;
value[builtin.FirstComponent + 0] = SIMD::Float(Float(x)) + SIMD::Float(0.5f, 1.5f, 0.5f, 1.5f);
value[builtin.FirstComponent + 1] = SIMD::Float(Float(y)) + SIMD::Float(0.5f, 0.5f, 1.5f, 1.5f);
value[builtin.FirstComponent + 2] = z[0]; // sample 0
value[builtin.FirstComponent + 3] = w;
});
routine.setInputBuiltin(spirvShader, spv::BuiltInPointCoord, [&](const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)
{
routine.setInputBuiltin(spirvShader, spv::BuiltInPointCoord, [&](const SpirvShader::BuiltinMapping &builtin, Array<SIMD::Float> &value) {
assert(builtin.SizeInComponents == 2);
value[builtin.FirstComponent+0] = SIMD::Float(0.5f, 1.5f, 0.5f, 1.5f) +
value[builtin.FirstComponent + 0] = SIMD::Float(0.5f, 1.5f, 0.5f, 1.5f) +
SIMD::Float(Float(x) - (*Pointer<Float>(primitive + OFFSET(Primitive, pointCoordX))));
value[builtin.FirstComponent+1] = SIMD::Float(0.5f, 0.5f, 1.5f, 1.5f) +
value[builtin.FirstComponent + 1] = SIMD::Float(0.5f, 0.5f, 1.5f, 1.5f) +
SIMD::Float(Float(y) - (*Pointer<Float>(primitive + OFFSET(Primitive, pointCoordY))));
});
routine.setInputBuiltin(spirvShader, spv::BuiltInSubgroupSize, [&](const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)
{
routine.setInputBuiltin(spirvShader, spv::BuiltInSubgroupSize, [&](const SpirvShader::BuiltinMapping &builtin, Array<SIMD::Float> &value) {
assert(builtin.SizeInComponents == 1);
value[builtin.FirstComponent] = As<SIMD::Float>(SIMD::Int(SIMD::Width));
});
routine.setInputBuiltin(spirvShader, spv::BuiltInHelperInvocation, [&](const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)
{
routine.setInputBuiltin(spirvShader, spv::BuiltInHelperInvocation, [&](const SpirvShader::BuiltinMapping &builtin, Array<SIMD::Float> &value) {
assert(builtin.SizeInComponents == 1);
value[builtin.FirstComponent] = As<SIMD::Float>(~maskAny(cMask));
});
routine.windowSpacePosition[0] = x + SIMD::Int(0,1,0,1);
routine.windowSpacePosition[1] = y + SIMD::Int(0,0,1,1);
routine.windowSpacePosition[0] = x + SIMD::Int(0, 1, 0, 1);
routine.windowSpacePosition[1] = y + SIMD::Int(0, 0, 1, 1);
routine.viewID = *Pointer<Int>(data + OFFSET(DrawData, viewID));
}
......@@ -169,7 +164,7 @@ void PixelProgram::applyShader(Int cMask[4], Int sMask[4], Int zMask[4])
for(auto i = 0u; i < state.multiSample; i++)
{
cMask[i] &= SignMask(CmpNEQ(outputSampleMask & SIMD::Int(1<<i), SIMD::Int(0)));
cMask[i] &= SignMask(CmpNEQ(outputSampleMask & SIMD::Int(1 << i), SIMD::Int(0)));
}
}
......@@ -313,10 +308,14 @@ void PixelProgram::clampColor(Vector4f oC[RENDERTARGETS])
case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
oC[index].x = Max(oC[index].x, Float4(0.0f)); oC[index].x = Min(oC[index].x, Float4(1.0f));
oC[index].y = Max(oC[index].y, Float4(0.0f)); oC[index].y = Min(oC[index].y, Float4(1.0f));
oC[index].z = Max(oC[index].z, Float4(0.0f)); oC[index].z = Min(oC[index].z, Float4(1.0f));
oC[index].w = Max(oC[index].w, Float4(0.0f)); oC[index].w = Min(oC[index].w, Float4(1.0f));
oC[index].x = Max(oC[index].x, Float4(0.0f));
oC[index].x = Min(oC[index].x, Float4(1.0f));
oC[index].y = Max(oC[index].y, Float4(0.0f));
oC[index].y = Min(oC[index].y, Float4(1.0f));
oC[index].z = Max(oC[index].z, Float4(0.0f));
oC[index].z = Min(oC[index].z, Float4(1.0f));
oC[index].w = Max(oC[index].w, Float4(0.0f));
oC[index].w = Min(oC[index].w, Float4(1.0f));
break;
case VK_FORMAT_R32_SFLOAT:
case VK_FORMAT_R32G32_SFLOAT:
......@@ -361,4 +360,4 @@ Float4 PixelProgram::linearToSRGB(const Float4 &x) // Approximates x^(1.0/2.2)
return Min(Max(sRGB, Float4(0.0f)), Float4(1.0f));
}
} // namepsace sw
} // namespace sw
src/Pipeline/PixelProgram.hpp
......@@ -26,15 +26,15 @@ public:
const PixelProcessor::State &state,
vk::PipelineLayout const *pipelineLayout,
SpirvShader const *spirvShader,
const vk::DescriptorSet::Bindings &descriptorSets) :
PixelRoutine(state, pipelineLayout, spirvShader, descriptorSets)
const vk::DescriptorSet::Bindings &descriptorSets)
: PixelRoutine(state, pipelineLayout, spirvShader, descriptorSets)
{
}
virtual ~PixelProgram() {}
protected:
virtual void setBuiltins(Int &x, Int &y, Float4(&z)[4], Float4 &w, Int cMask[4]);
virtual void setBuiltins(Int &x, Int &y, Float4 (&z)[4], Float4 &w, Int cMask[4]);
virtual void applyShader(Int cMask[4], Int sMask[4], Int zMask[4]);
virtual Bool alphaTest(Int cMask[4]);
virtual void rasterOperation(Pointer<Byte> cBuffer[4], Int &x, Int sMask[4], Int zMask[4], Int cMask[4]);
......
src/Pipeline/PixelRoutine.hpp
......@@ -43,7 +43,7 @@ protected:
// Depth output
Float4 oDepth;
virtual void setBuiltins(Int &x, Int &y, Float4(&z)[4], Float4 &w, Int cMask[4]) = 0;
virtual void setBuiltins(Int &x, Int &y, Float4 (&z)[4], Float4 &w, Int cMask[4]) = 0;
virtual void applyShader(Int cMask[4], Int sMask[4], Int zMask[4]) = 0;
virtual Bool alphaTest(Int cMask[4]) = 0;
virtual void rasterOperation(Pointer<Byte> cBuffer[4], Int &x, Int sMask[4], Int zMask[4], Int cMask[4]) = 0;
......@@ -55,7 +55,7 @@ protected:
// Raster operations
void alphaBlend(int index, const Pointer<Byte> &cBuffer, Vector4s &current, const Int &x);
void writeColor(int index, const Pointer<Byte> &cBuffer, const Int& x, Vector4f& oC, const Int& sMask, const Int& zMask, const Int& cMask);
void writeColor(int index, const Pointer<Byte> &cBuffer, const Int &x, Vector4f &oC, const Int &sMask, const Int &zMask, const Int &cMask);
void alphaBlend(int index, const Pointer<Byte> &cBuffer, Vector4f &oC, const Int &x);
void writeColor(int index, const Pointer<Byte> &cBuffer, const Int &x, Vector4s &current, const Int &sMask, const Int &zMask, const Int &cMask);
......
src/Pipeline/SamplerCore.hpp
......@@ -21,7 +21,7 @@
#include "Reactor/Reactor.hpp"
#ifdef None
#undef None // b/127920555
# undef None // b/127920555
#endif
namespace sw {
......@@ -45,7 +45,9 @@ enum SamplerMethod : uint32_t
struct SamplerFunction
{
SamplerFunction(SamplerMethod method, bool offset = false, bool sample = false)
: method(method), offset(offset), sample(sample)
: method(method)
, offset(offset)
, sample(sample)
{}
operator SamplerMethod() { return method; }
......@@ -60,20 +62,20 @@ class SamplerCore
public:
SamplerCore(Pointer<Byte> &constants, const Sampler &state);
Vector4f sampleTexture(Pointer<Byte> &texture, Pointer<Byte> &sampler, Float4 uvw[4], Float4 &q, Float &&lodOrBias, Float4 &dsx, Float4 &dsy, Vector4f &offset, Int4& sampleId, SamplerFunction function);
Vector4f sampleTexture(Pointer<Byte> &texture, Pointer<Byte> &sampler, Float4 uvw[4], Float4 &q, Float &&lodOrBias, Float4 &dsx, Float4 &dsy, Vector4f &offset, Int4 &sampleId, SamplerFunction function);
private:
Short4 offsetSample(Short4 &uvw, Pointer<Byte> &mipmap, int halfOffset, bool wrap, int count, Float &lod);
Vector4s sampleFilter(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, const Float4& cubeArrayCoord, const Int4& sampleId, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, SamplerFunction function);
Vector4s sampleAniso(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, const Float4& cubeArrayCoord, const Int4& sampleId, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, bool secondLOD, SamplerFunction function);
Vector4s sampleQuad(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, const Float4& cubeArrayCoord, const Int4& sampleId, Float &lod, bool secondLOD, SamplerFunction function);
Vector4s sampleQuad2D(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, const Float4& cubeArrayCoord, const Int4& sampleId, Float &lod, bool secondLOD, SamplerFunction function);
Vector4s sample3D(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, const Float4& cubeArrayCoord, const Int4& sampleId, Float &lod, bool secondLOD, SamplerFunction function);
Vector4f sampleFloatFilter(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &offset, const Float4& cubeArrayCoord, const Int4& sampleId, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, SamplerFunction function);
Vector4f sampleFloatAniso(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &offset, const Float4& cubeArrayCoord, const Int4& sampleId, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, bool secondLOD, SamplerFunction function);
Vector4f sampleFloat(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &offset, const Float4& cubeArrayCoord, const Int4& sampleId, Float &lod, bool secondLOD, SamplerFunction function);
Vector4f sampleFloat2D(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &offset, const Float4& cubeArrayCoord, const Int4& sampleId, Float &lod, bool secondLOD, SamplerFunction function);
Vector4f sampleFloat3D(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, const Float4& cubeArrayCoord, const Int4& sampleId, Float &lod, bool secondLOD, SamplerFunction function);
Vector4s sampleFilter(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, const Float4 &cubeArrayCoord, const Int4 &sampleId, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, SamplerFunction function);
Vector4s sampleAniso(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, const Float4 &cubeArrayCoord, const Int4 &sampleId, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, bool secondLOD, SamplerFunction function);
Vector4s sampleQuad(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, const Float4 &cubeArrayCoord, const Int4 &sampleId, Float &lod, bool secondLOD, SamplerFunction function);
Vector4s sampleQuad2D(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, const Float4 &cubeArrayCoord, const Int4 &sampleId, Float &lod, bool secondLOD, SamplerFunction function);
Vector4s sample3D(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, const Float4 &cubeArrayCoord, const Int4 &sampleId, Float &lod, bool secondLOD, SamplerFunction function);
Vector4f sampleFloatFilter(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &offset, const Float4 &cubeArrayCoord, const Int4 &sampleId, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, SamplerFunction function);
Vector4f sampleFloatAniso(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &offset, const Float4 &cubeArrayCoord, const Int4 &sampleId, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, bool secondLOD, SamplerFunction function);
Vector4f sampleFloat(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &offset, const Float4 &cubeArrayCoord, const Int4 &sampleId, Float &lod, bool secondLOD, SamplerFunction function);
Vector4f sampleFloat2D(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &offset, const Float4 &cubeArrayCoord, const Int4 &sampleId, Float &lod, bool secondLOD, SamplerFunction function);
Vector4f sampleFloat3D(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, const Float4 &cubeArrayCoord, const Int4 &sampleId, Float &lod, bool secondLOD, SamplerFunction function);
Float log2sqrt(Float lod);
Float log2(Float lod);
void computeLod(Pointer<Byte> &texture, Pointer<Byte> &sampler, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, Float4 &u, Float4 &v, Float4 &dsx, Float4 &dsy, SamplerFunction function);
......@@ -81,15 +83,15 @@ private:
void computeLod3D(Pointer<Byte> &texture, Pointer<Byte> &sampler, Float &lod, Float4 &u, Float4 &v, Float4 &w, Float4 &dsx, Float4 &dsy, SamplerFunction function);
Int4 cubeFace(Float4 &U, Float4 &V, Float4 &x, Float4 &y, Float4 &z, Float4 &M);
Short4 applyOffset(Short4 &uvw, Float4 &offset, const Int4 &whd, AddressingMode mode);
void computeIndices(UInt index[4], Short4 uuuu, Short4 vvvv, Short4 wwww, Vector4f &offset, const Pointer<Byte> &mipmap, const Short4& cubeArrayId, const Int4& sampleId, SamplerFunction function);
void computeIndices(UInt index[4], Int4 uuuu, Int4 vvvv, Int4 wwww, Int4 valid, const Pointer<Byte> &mipmap, const Int4& cubeArrayId, const Int4& sampleId, SamplerFunction function);
Vector4s sampleTexel(Short4 &u, Short4 &v, Short4 &s, Vector4f &offset, Pointer<Byte> &mipmap, const Short4& cubeArrayId, const Int4& sampleId, Pointer<Byte> buffer, SamplerFunction function);
void computeIndices(UInt index[4], Short4 uuuu, Short4 vvvv, Short4 wwww, Vector4f &offset, const Pointer<Byte> &mipmap, const Short4 &cubeArrayId, const Int4 &sampleId, SamplerFunction function);
void computeIndices(UInt index[4], Int4 uuuu, Int4 vvvv, Int4 wwww, Int4 valid, const Pointer<Byte> &mipmap, const Int4 &cubeArrayId, const Int4 &sampleId, SamplerFunction function);
Vector4s sampleTexel(Short4 &u, Short4 &v, Short4 &s, Vector4f &offset, Pointer<Byte> &mipmap, const Short4 &cubeArrayId, const Int4 &sampleId, Pointer<Byte> buffer, SamplerFunction function);
Vector4s sampleTexel(UInt index[4], Pointer<Byte> buffer);
Vector4f sampleTexel(Int4 &u, Int4 &v, Int4 &s, Float4 &z, Pointer<Byte> &mipmap, const Int4& cubeArrayId, const Int4& sampleId, Pointer<Byte> buffer, SamplerFunction function);
Vector4f sampleTexel(Int4 &u, Int4 &v, Int4 &s, Float4 &z, Pointer<Byte> &mipmap, const Int4 &cubeArrayId, const Int4 &sampleId, Pointer<Byte> buffer, SamplerFunction function);
Vector4f replaceBorderTexel(const Vector4f &c, Int4 valid);
void selectMipmap(const Pointer<Byte> &texture, Pointer<Byte> &mipmap, Pointer<Byte> &buffer, const Float &lod, bool secondLOD);
Short4 address(const Float4 &uw, AddressingMode addressingMode, Pointer<Byte>& mipmap);
void address(const Float4 &uw, Int4& xyz0, Int4& xyz1, Float4& f, Pointer<Byte>& mipmap, Float4 &texOffset, Int4 &filter, int whd, AddressingMode addressingMode, SamplerFunction function);
Short4 address(const Float4 &uw, AddressingMode addressingMode, Pointer<Byte> &mipmap);
void address(const Float4 &uw, Int4 &xyz0, Int4 &xyz1, Float4 &f, Pointer<Byte> &mipmap, Float4 &texOffset, Int4 &filter, int whd, AddressingMode addressingMode, SamplerFunction function);
Int4 computeFilterOffset(Float &lod);
void convertSigned15(Float4 &cf, Short4 &ci);
......@@ -120,9 +122,10 @@ private:
#ifdef ENABLE_RR_PRINT
namespace rr {
template <> struct PrintValue::Ty<sw::SamplerFunction>
template<>
struct PrintValue::Ty<sw::SamplerFunction>
{
static std::string fmt(const sw::SamplerFunction& v)
static std::string fmt(const sw::SamplerFunction &v)
{
return std::string("SamplerFunction[") +
"method: " + std::to_string(v.method) +
......@@ -131,7 +134,7 @@ template <> struct PrintValue::Ty<sw::SamplerFunction>
"]";
}
static std::vector<rr::Value*> val(const sw::SamplerFunction& v) { return {}; }
static std::vector<rr::Value *> val(const sw::SamplerFunction &v) { return {}; }
};
} // namespace rr
......
src/Pipeline/ShaderCore.hpp
......@@ -19,8 +19,8 @@
#include "Reactor/Reactor.hpp"
#include "Vulkan/VkDebug.hpp"
#include <atomic> // std::memory_order
#include <array>
#include <atomic> // std::memory_order
#include <utility> // std::pair
namespace sw {
......@@ -87,17 +87,17 @@ struct Pointer
Pointer(rr::Pointer<Byte> base, rr::Int limit, SIMD::Int offset);
Pointer(rr::Pointer<Byte> base, unsigned int limit, SIMD::Int offset);
Pointer& operator += (Int i);
Pointer& operator *= (Int i);
Pointer &operator+=(Int i);
Pointer &operator*=(Int i);
Pointer operator + (SIMD::Int i);
Pointer operator * (SIMD::Int i);
Pointer operator+(SIMD::Int i);
Pointer operator*(SIMD::Int i);
Pointer& operator += (int i);
Pointer& operator *= (int i);
Pointer &operator+=(int i);
Pointer &operator*=(int i);
Pointer operator + (int i);
Pointer operator * (int i);
Pointer operator+(int i);
Pointer operator*(int i);
SIMD::Int offsets() const;
......@@ -146,10 +146,24 @@ struct Pointer
bool hasDynamicOffsets; // True if any dynamicOffsets are non-zero.
};
template <typename T> struct Element {};
template <> struct Element<Float> { using type = rr::Float; };
template <> struct Element<Int> { using type = rr::Int; };
template <> struct Element<UInt> { using type = rr::UInt; };
template<typename T>
struct Element
{};
template<>
struct Element<Float>
{
using type = rr::Float;
};
template<>
struct Element<Int>
{
using type = rr::Int;
};
template<>
struct Element<UInt>
{
using type = rr::UInt;
};
} // namespace SIMD
......@@ -199,10 +213,10 @@ rr::RValue<rr::Bool> AnyTrue(rr::RValue<sw::SIMD::Int> const &ints);
rr::RValue<rr::Bool> AnyFalse(rr::RValue<sw::SIMD::Int> const &ints);
template <typename T>
template<typename T>
inline rr::RValue<T> AndAll(rr::RValue<T> const &mask);
template <typename T>
template<typename T>
inline rr::RValue<T> OrAll(rr::RValue<T> const &mask);
rr::RValue<sw::SIMD::Float> Sign(rr::RValue<sw::SIMD::Float> const &val);
......@@ -476,7 +490,7 @@ inline void SIMD::Pointer::Store(RValue<T> val, OutOfBoundsBehavior robustness,
Store(T(val), robustness, mask, atomic, order);
}
template <typename T>
template<typename T>
inline rr::RValue<T> AndAll(rr::RValue<T> const &mask)
{
T v1 = mask; // [x] [y] [z] [w]
......@@ -484,7 +498,7 @@ inline rr::RValue<T> AndAll(rr::RValue<T> const &mask)
return v2.xxxx & v2.yyyy; // [xyzw] [xyzw] [xyzw] [xyzw]
}
template <typename T>
template<typename T>
inline rr::RValue<T> OrAll(rr::RValue<T> const &mask)
{
T v1 = mask; // [x] [y] [z] [w]
......@@ -496,9 +510,10 @@ inline rr::RValue<T> OrAll(rr::RValue<T> const &mask)
#ifdef ENABLE_RR_PRINT
namespace rr {
template <> struct PrintValue::Ty<sw::Vector4f>
template<>
struct PrintValue::Ty<sw::Vector4f>
{
static std::string fmt(const sw::Vector4f& v)
static std::string fmt(const sw::Vector4f &v)
{
return "[x: " + PrintValue::fmt(v.x) +
", y: " + PrintValue::fmt(v.y) +
......@@ -506,14 +521,15 @@ template <> struct PrintValue::Ty<sw::Vector4f>
", w: " + PrintValue::fmt(v.w) + "]";
}
static std::vector<rr::Value*> val(const sw::Vector4f& v)
static std::vector<rr::Value *> val(const sw::Vector4f &v)
{
return PrintValue::vals(v.x, v.y, v.z, v.w);
}
};
template <> struct PrintValue::Ty<sw::Vector4s>
template<>
struct PrintValue::Ty<sw::Vector4s>
{
static std::string fmt(const sw::Vector4s& v)
static std::string fmt(const sw::Vector4s &v)
{
return "[x: " + PrintValue::fmt(v.x) +
", y: " + PrintValue::fmt(v.y) +
......@@ -521,13 +537,13 @@ template <> struct PrintValue::Ty<sw::Vector4s>
", w: " + PrintValue::fmt(v.w) + "]";
}
static std::vector<rr::Value*> val(const sw::Vector4s& v)
static std::vector<rr::Value *> val(const sw::Vector4s &v)
{
return PrintValue::vals(v.x, v.y, v.z, v.w);
}
};
} // namespace sw
} // namespace rr
#endif // ENABLE_RR_PRINT
#endif // sw_ShaderCore_hpp
src/Pipeline/SpirvID.hpp
......@@ -15,8 +15,8 @@
#ifndef sw_ID_hpp
#define sw_ID_hpp
#include <unordered_map>
#include <cstdint>
#include <unordered_map>
namespace sw {
......@@ -25,39 +25,43 @@ namespace sw {
// ID; instead it is used to prevent implicit casts between identifiers of
// different T types.
// IDs are typically used as a map key to value of type T.
template <typename T>
template<typename T>
class SpirvID
{
public:
SpirvID() : id(0) {}
SpirvID(uint32_t id) : id(id) {}
bool operator == (const SpirvID<T>& rhs) const { return id == rhs.id; }
bool operator != (const SpirvID<T>& rhs) const { return id != rhs.id; }
bool operator < (const SpirvID<T>& rhs) const { return id < rhs.id; }
SpirvID()
: id(0)
{}
SpirvID(uint32_t id)
: id(id)
{}
bool operator==(const SpirvID<T> &rhs) const { return id == rhs.id; }
bool operator!=(const SpirvID<T> &rhs) const { return id != rhs.id; }
bool operator<(const SpirvID<T> &rhs) const { return id < rhs.id; }
// value returns the numerical value of the identifier.
uint32_t value() const { return id; }
private:
uint32_t id;
};
// HandleMap<T> is an unordered map of SpirvID<T> to T.
template <typename T>
template<typename T>
using HandleMap = std::unordered_map<SpirvID<T>, T>;
}
} // namespace sw
namespace std
{
namespace std {
// std::hash implementation for sw::SpirvID<T>
template<typename T>
struct hash< sw::SpirvID<T> >
struct hash<sw::SpirvID<T> >
{
std::size_t operator()(const sw::SpirvID<T>& id) const noexcept
std::size_t operator()(const sw::SpirvID<T> &id) const noexcept
{
return std::hash<uint32_t>()(id.value());
}
};
} // namespace sw
} // namespace std
#endif // sw_ID_hpp
src/Pipeline/SpirvShaderArithmetic.cpp
......@@ -254,8 +254,7 @@ SpirvShader::EmitResult SpirvShader::EmitUnaryOp(InsnIterator insn, EmitState *s
break;
case spv::OpFwidth:
case spv::OpFwidthCoarse:
dst.move(i, SIMD::Float(Abs(Extract(src.Float(i), 1) - Extract(src.Float(i), 0))
+ Abs(Extract(src.Float(i), 2) - Extract(src.Float(i), 0))));
dst.move(i, SIMD::Float(Abs(Extract(src.Float(i), 1) - Extract(src.Float(i), 0)) + Abs(Extract(src.Float(i), 2) - Extract(src.Float(i), 0))));
break;
case spv::OpDPdxFine:
{
......@@ -532,7 +531,7 @@ SpirvShader::EmitResult SpirvShader::EmitDot(InsnIterator insn, EmitState *state
return EmitResult::Continue;
}
SIMD::Float SpirvShader::Dot(unsigned numComponents, GenericValue const & x, GenericValue const & y) const
SIMD::Float SpirvShader::Dot(unsigned numComponents, GenericValue const &x, GenericValue const &y) const
{
SIMD::Float d = x.Float(0) * y.Float(0);
......
src/Pipeline/SpirvShaderControlFlow.cpp
......@@ -24,7 +24,9 @@
namespace sw {
SpirvShader::Block::Block(InsnIterator begin, InsnIterator end) : begin_(begin), end_(end)
SpirvShader::Block::Block(InsnIterator begin, InsnIterator end)
: begin_(begin)
, end_(end)
{
// Default to a Simple, this may change later.
kind = Block::Simple;
......@@ -111,7 +113,7 @@ SpirvShader::Block::Block(InsnIterator begin, InsnIterator end) : begin_(begin),
}
}
void SpirvShader::Function::TraverseReachableBlocks(Block::ID id, SpirvShader::Block::Set& reachable) const
void SpirvShader::Function::TraverseReachableBlocks(Block::ID id, SpirvShader::Block::Set &reachable) const
{
if(reachable.count(id) == 0)
{
......@@ -196,7 +198,7 @@ void SpirvShader::EmitState::addOutputActiveLaneMaskEdge(Block::ID to, RValue<SI
void SpirvShader::EmitState::addActiveLaneMaskEdge(Block::ID from, Block::ID to, RValue<SIMD::Int> mask)
{
auto edge = Block::Edge{from, to};
auto edge = Block::Edge{ from, to };
auto it = edgeActiveLaneMasks.find(edge);
if(it == edgeActiveLaneMasks.end())
{
......@@ -212,7 +214,7 @@ void SpirvShader::EmitState::addActiveLaneMaskEdge(Block::ID from, Block::ID to,
RValue<SIMD::Int> SpirvShader::GetActiveLaneMaskEdge(EmitState *state, Block::ID from, Block::ID to) const
{
auto edge = Block::Edge{from, to};
auto edge = Block::Edge{ from, to };
auto it = state->edgeActiveLaneMasks.find(edge);
ASSERT_MSG(it != state->edgeActiveLaneMasks.end(), "Could not find edge %d -> %d", from.value(), to.value());
return it->second;
......@@ -239,8 +241,7 @@ void SpirvShader::EmitBlocks(Block::ID id, EmitState *state, Block::ID ignore /*
// Ensure all dependency blocks have been generated.
auto depsDone = true;
function.ForeachBlockDependency(id, [&](Block::ID dep)
{
function.ForeachBlockDependency(id, [&](Block::ID dep) {
if(state->visited.count(dep) == 0)
{
state->pending->push_front(dep);
......@@ -414,7 +415,7 @@ void SpirvShader::EmitLoop(EmitState *state) const
// Add active lanes to the merge lane mask.
for(auto in : function.getBlock(mergeBlockId).ins)
{
auto edge = Block::Edge{in, mergeBlockId};
auto edge = Block::Edge{ in, mergeBlockId };
auto it = state->edgeActiveLaneMasks.find(edge);
if(it != state->edgeActiveLaneMasks.end())
{
......@@ -563,9 +564,9 @@ SpirvShader::EmitResult SpirvShader::EmitKill(InsnIterator insn, EmitState *stat
SpirvShader::EmitResult SpirvShader::EmitFunctionCall(InsnIterator insn, EmitState *state) const
{
auto functionId = Function::ID(insn.word(3));
const auto& functionIt = functions.find(functionId);
const auto &functionIt = functions.find(functionId);
ASSERT(functionIt != functions.end());
auto& function = functionIt->second;
auto &function = functionIt->second;
// TODO(b/141246700): Add full support for spv::OpFunctionCall
// The only supported function is a single OpKill wrapped in a
......@@ -654,7 +655,7 @@ void SpirvShader::LoadPhi(InsnIterator insn, EmitState *state) const
}
}
void SpirvShader::StorePhi(Block::ID currentBlock, InsnIterator insn, EmitState *state, std::unordered_set<SpirvShader::Block::ID> const& filter) const
void SpirvShader::StorePhi(Block::ID currentBlock, InsnIterator insn, EmitState *state, std::unordered_set<SpirvShader::Block::ID> const &filter) const
{
auto typeId = Type::ID(insn.word(1));
auto type = getType(typeId);
......
src/Pipeline/SpirvShaderEnumNames.cpp
......@@ -14,15 +14,15 @@
// This file contains code used to aid debugging.
#include <spirv/unified1/spirv.h>
#include "SpirvShader.hpp"
#include <spirv/unified1/spirv.h>
// Prototypes for SPIRV-Tools functions that do not have public headers.
// This is a C++ function, so the name is mangled, and signature changes will
// result in a linker error instead of runtime signature mismatches.
// Gets the name of an instruction, without the "Op" prefix.
extern const char* spvOpcodeString(const SpvOp opcode);
extern const char *spvOpcodeString(const SpvOp opcode);
namespace sw {
......
src/Pipeline/SpirvShaderGLSLstd450.cpp
......@@ -16,12 +16,11 @@
#include "ShaderCore.hpp"
#include <spirv/unified1/spirv.hpp>
#include <spirv/unified1/GLSL.std.450.h>
#include <spirv/unified1/spirv.hpp>
namespace
{
constexpr float PI = 3.141592653589793f;
namespace {
constexpr float PI = 3.141592653589793f;
}
namespace sw {
......@@ -196,7 +195,9 @@ SpirvShader::EmitResult SpirvShader::EmitExtendedInstruction(InsnIterator insn,
for(auto i = 0u; i < type.sizeInComponents; i++)
{
auto tx = Min(Max((x.Float(i) - edge0.Float(i)) /
(edge1.Float(i) - edge0.Float(i)), SIMD::Float(0.0f)), SIMD::Float(1.0f));
(edge1.Float(i) - edge0.Float(i)),
SIMD::Float(0.0f)),
SIMD::Float(1.0f));
dst.move(i, tx * tx * (Float4(3.0f) - Float4(2.0f) * tx));
}
break;
......@@ -394,11 +395,14 @@ SpirvShader::EmitResult SpirvShader::EmitExtendedInstruction(InsnIterator insn,
dst.move(0, (SIMD::Int(Round(Min(Max(val.Float(0), SIMD::Float(-1.0f)), SIMD::Float(1.0f)) * SIMD::Float(127.0f))) &
SIMD::Int(0xFF)) |
((SIMD::Int(Round(Min(Max(val.Float(1), SIMD::Float(-1.0f)), SIMD::Float(1.0f)) * SIMD::Float(127.0f))) &
SIMD::Int(0xFF)) << 8) |
SIMD::Int(0xFF))
<< 8) |
((SIMD::Int(Round(Min(Max(val.Float(2), SIMD::Float(-1.0f)), SIMD::Float(1.0f)) * SIMD::Float(127.0f))) &
SIMD::Int(0xFF)) << 16) |
SIMD::Int(0xFF))
<< 16) |
((SIMD::Int(Round(Min(Max(val.Float(3), SIMD::Float(-1.0f)), SIMD::Float(1.0f)) * SIMD::Float(127.0f))) &
SIMD::Int(0xFF)) << 24));
SIMD::Int(0xFF))
<< 24));
break;
}
case GLSLstd450PackUnorm4x8:
......@@ -416,7 +420,8 @@ SpirvShader::EmitResult SpirvShader::EmitExtendedInstruction(InsnIterator insn,
dst.move(0, (SIMD::Int(Round(Min(Max(val.Float(0), SIMD::Float(-1.0f)), SIMD::Float(1.0f)) * SIMD::Float(32767.0f))) &
SIMD::Int(0xFFFF)) |
((SIMD::Int(Round(Min(Max(val.Float(1), SIMD::Float(-1.0f)), SIMD::Float(1.0f)) * SIMD::Float(32767.0f))) &
SIMD::Int(0xFFFF)) << 16));
SIMD::Int(0xFFFF))
<< 16));
break;
}
case GLSLstd450PackUnorm2x16:
......@@ -425,7 +430,8 @@ SpirvShader::EmitResult SpirvShader::EmitExtendedInstruction(InsnIterator insn,
dst.move(0, (SIMD::UInt(Round(Min(Max(val.Float(0), SIMD::Float(0.0f)), SIMD::Float(1.0f)) * SIMD::Float(65535.0f))) &
SIMD::UInt(0xFFFF)) |
((SIMD::UInt(Round(Min(Max(val.Float(1), SIMD::Float(0.0f)), SIMD::Float(1.0f)) * SIMD::Float(65535.0f))) &
SIMD::UInt(0xFFFF)) << 16));
SIMD::UInt(0xFFFF))
<< 16));
break;
}
case GLSLstd450PackHalf2x16:
......@@ -437,9 +443,9 @@ SpirvShader::EmitResult SpirvShader::EmitExtendedInstruction(InsnIterator insn,
case GLSLstd450UnpackSnorm4x8:
{
auto val = GenericValue(this, state, insn.word(5));
dst.move(0, Min(Max(SIMD::Float(((val.Int(0)<<24) & SIMD::Int(0xFF000000))) * SIMD::Float(1.0f / float(0x7f000000)), SIMD::Float(-1.0f)), SIMD::Float(1.0f)));
dst.move(1, Min(Max(SIMD::Float(((val.Int(0)<<16) & SIMD::Int(0xFF000000))) * SIMD::Float(1.0f / float(0x7f000000)), SIMD::Float(-1.0f)), SIMD::Float(1.0f)));
dst.move(2, Min(Max(SIMD::Float(((val.Int(0)<<8) & SIMD::Int(0xFF000000))) * SIMD::Float(1.0f / float(0x7f000000)), SIMD::Float(-1.0f)), SIMD::Float(1.0f)));
dst.move(0, Min(Max(SIMD::Float(((val.Int(0) << 24) & SIMD::Int(0xFF000000))) * SIMD::Float(1.0f / float(0x7f000000)), SIMD::Float(-1.0f)), SIMD::Float(1.0f)));
dst.move(1, Min(Max(SIMD::Float(((val.Int(0) << 16) & SIMD::Int(0xFF000000))) * SIMD::Float(1.0f / float(0x7f000000)), SIMD::Float(-1.0f)), SIMD::Float(1.0f)));
dst.move(2, Min(Max(SIMD::Float(((val.Int(0) << 8) & SIMD::Int(0xFF000000))) * SIMD::Float(1.0f / float(0x7f000000)), SIMD::Float(-1.0f)), SIMD::Float(1.0f)));
dst.move(3, Min(Max(SIMD::Float(((val.Int(0)) & SIMD::Int(0xFF000000))) * SIMD::Float(1.0f / float(0x7f000000)), SIMD::Float(-1.0f)), SIMD::Float(1.0f)));
break;
}
......@@ -447,9 +453,9 @@ SpirvShader::EmitResult SpirvShader::EmitExtendedInstruction(InsnIterator insn,
{
auto val = GenericValue(this, state, insn.word(5));
dst.move(0, SIMD::Float((val.UInt(0) & SIMD::UInt(0xFF))) * SIMD::Float(1.0f / 255.f));
dst.move(1, SIMD::Float(((val.UInt(0)>>8) & SIMD::UInt(0xFF))) * SIMD::Float(1.0f / 255.f));
dst.move(2, SIMD::Float(((val.UInt(0)>>16) & SIMD::UInt(0xFF))) * SIMD::Float(1.0f / 255.f));
dst.move(3, SIMD::Float(((val.UInt(0)>>24) & SIMD::UInt(0xFF))) * SIMD::Float(1.0f / 255.f));
dst.move(1, SIMD::Float(((val.UInt(0) >> 8) & SIMD::UInt(0xFF))) * SIMD::Float(1.0f / 255.f));
dst.move(2, SIMD::Float(((val.UInt(0) >> 16) & SIMD::UInt(0xFF))) * SIMD::Float(1.0f / 255.f));
dst.move(3, SIMD::Float(((val.UInt(0) >> 24) & SIMD::UInt(0xFF))) * SIMD::Float(1.0f / 255.f));
break;
}
case GLSLstd450UnpackSnorm2x16:
......@@ -457,9 +463,12 @@ SpirvShader::EmitResult SpirvShader::EmitExtendedInstruction(InsnIterator insn,
auto val = GenericValue(this, state, insn.word(5));
// clamp(f / 32767.0, -1.0, 1.0)
dst.move(0, Min(Max(SIMD::Float(As<SIMD::Int>((val.UInt(0) & SIMD::UInt(0x0000FFFF)) << 16)) *
SIMD::Float(1.0f / float(0x7FFF0000)), SIMD::Float(-1.0f)), SIMD::Float(1.0f)));
SIMD::Float(1.0f / float(0x7FFF0000)),
SIMD::Float(-1.0f)),
SIMD::Float(1.0f)));
dst.move(1, Min(Max(SIMD::Float(As<SIMD::Int>(val.UInt(0) & SIMD::UInt(0xFFFF0000))) * SIMD::Float(1.0f / float(0x7FFF0000)),
SIMD::Float(-1.0f)), SIMD::Float(1.0f)));
SIMD::Float(-1.0f)),
SIMD::Float(1.0f)));
break;
}
case GLSLstd450UnpackUnorm2x16:
......
src/Pipeline/SpirvShaderGroup.cpp
......@@ -18,20 +18,21 @@
namespace sw {
struct SpirvShader::GroupOps {
struct SpirvShader::GroupOps
{
// Template function to perform a binary operation.
// |TYPE| should be the type of the identity value (as an SIMD::<Type>).
// |APPLY| should be a callable object that takes two RValue<TYPE> parameters
// and returns a new RValue<TYPE> corresponding to the operation's result.
template <typename TYPE, typename APPLY>
template<typename TYPE, typename APPLY>
static void BinaryOperation(
const SpirvShader* shader,
const SpirvShader::InsnIterator& insn,
const SpirvShader::EmitState* state,
Intermediate& dst,
const TYPE& identity,
APPLY&& apply)
const SpirvShader *shader,
const SpirvShader::InsnIterator &insn,
const SpirvShader::EmitState *state,
Intermediate &dst,
const TYPE &identity,
APPLY &&apply)
{
SpirvShader::GenericValue value(shader, state, insn.word(5));
auto &type = shader->getType(SpirvShader::Type::ID(insn.word(1)));
......@@ -72,10 +73,8 @@ struct SpirvShader::GroupOps {
}
}
}
};
SpirvShader::EmitResult SpirvShader::EmitGroupNonUniform(InsnIterator insn, EmitState *state) const
{
static_assert(SIMD::Width == 4, "EmitGroupNonUniform makes many assumptions that the SIMD vector width is 4");
......@@ -322,8 +321,7 @@ SpirvShader::EmitResult SpirvShader::EmitGroupNonUniform(InsnIterator insn, Emit
SpirvShader::GroupOps::BinaryOperation(
this, insn, state, dst,
Type(0),
[](RValue<Type>a, RValue<Type>b){ return a + b; }
);
[](RValue<Type> a, RValue<Type> b) { return a + b; });
break;
}
......@@ -333,8 +331,7 @@ SpirvShader::EmitResult SpirvShader::EmitGroupNonUniform(InsnIterator insn, Emit
SpirvShader::GroupOps::BinaryOperation(
this, insn, state, dst,
Type(0.),
[](RValue<Type>a, RValue<Type>b){ return a + b; }
);
[](RValue<Type> a, RValue<Type> b) { return a + b; });
break;
}
......@@ -344,8 +341,7 @@ SpirvShader::EmitResult SpirvShader::EmitGroupNonUniform(InsnIterator insn, Emit
SpirvShader::GroupOps::BinaryOperation(
this, insn, state, dst,
Type(1),
[](RValue<Type>a, RValue<Type>b){ return a * b; }
);
[](RValue<Type> a, RValue<Type> b) { return a * b; });
break;
}
......@@ -355,8 +351,7 @@ SpirvShader::EmitResult SpirvShader::EmitGroupNonUniform(InsnIterator insn, Emit
SpirvShader::GroupOps::BinaryOperation(
this, insn, state, dst,
Type(1.),
[](RValue<Type>a, RValue<Type>b){ return a * b; }
);
[](RValue<Type> a, RValue<Type> b) { return a * b; });
break;
}
......@@ -366,8 +361,7 @@ SpirvShader::EmitResult SpirvShader::EmitGroupNonUniform(InsnIterator insn, Emit
SpirvShader::GroupOps::BinaryOperation(
this, insn, state, dst,
Type(~0u),
[](RValue<Type>a, RValue<Type>b){ return a & b; }
);
[](RValue<Type> a, RValue<Type> b) { return a & b; });
break;
}
......@@ -377,8 +371,7 @@ SpirvShader::EmitResult SpirvShader::EmitGroupNonUniform(InsnIterator insn, Emit
SpirvShader::GroupOps::BinaryOperation(
this, insn, state, dst,
Type(0),
[](RValue<Type>a, RValue<Type>b){ return a | b; }
);
[](RValue<Type> a, RValue<Type> b) { return a | b; });
break;
}
......@@ -388,8 +381,7 @@ SpirvShader::EmitResult SpirvShader::EmitGroupNonUniform(InsnIterator insn, Emit
SpirvShader::GroupOps::BinaryOperation(
this, insn, state, dst,
Type(0),
[](RValue<Type>a, RValue<Type>b){ return a ^ b; }
);
[](RValue<Type> a, RValue<Type> b) { return a ^ b; });
break;
}
......@@ -399,8 +391,7 @@ SpirvShader::EmitResult SpirvShader::EmitGroupNonUniform(InsnIterator insn, Emit
SpirvShader::GroupOps::BinaryOperation(
this, insn, state, dst,
Type(INT32_MAX),
[](RValue<Type>a, RValue<Type>b){ return Min(a, b); }
);
[](RValue<Type> a, RValue<Type> b) { return Min(a, b); });
break;
}
......@@ -410,8 +401,7 @@ SpirvShader::EmitResult SpirvShader::EmitGroupNonUniform(InsnIterator insn, Emit
SpirvShader::GroupOps::BinaryOperation(
this, insn, state, dst,
Type(~0u),
[](RValue<Type>a, RValue<Type>b){ return Min(a, b); }
);
[](RValue<Type> a, RValue<Type> b) { return Min(a, b); });
break;
}
......@@ -421,8 +411,7 @@ SpirvShader::EmitResult SpirvShader::EmitGroupNonUniform(InsnIterator insn, Emit
SpirvShader::GroupOps::BinaryOperation(
this, insn, state, dst,
Type::positive_inf(),
[](RValue<Type>a, RValue<Type>b){ return NMin(a, b); }
);
[](RValue<Type> a, RValue<Type> b) { return NMin(a, b); });
break;
}
......@@ -432,8 +421,7 @@ SpirvShader::EmitResult SpirvShader::EmitGroupNonUniform(InsnIterator insn, Emit
SpirvShader::GroupOps::BinaryOperation(
this, insn, state, dst,
Type(INT32_MIN),
[](RValue<Type>a, RValue<Type>b){ return Max(a, b); }
);
[](RValue<Type> a, RValue<Type> b) { return Max(a, b); });
break;
}
......@@ -443,8 +431,7 @@ SpirvShader::EmitResult SpirvShader::EmitGroupNonUniform(InsnIterator insn, Emit
SpirvShader::GroupOps::BinaryOperation(
this, insn, state, dst,
Type(0),
[](RValue<Type>a, RValue<Type>b){ return Max(a, b); }
);
[](RValue<Type> a, RValue<Type> b) { return Max(a, b); });
break;
}
......@@ -454,8 +441,7 @@ SpirvShader::EmitResult SpirvShader::EmitGroupNonUniform(InsnIterator insn, Emit
SpirvShader::GroupOps::BinaryOperation(
this, insn, state, dst,
Type::negative_inf(),
[](RValue<Type>a, RValue<Type>b){ return NMax(a, b); }
);
[](RValue<Type> a, RValue<Type> b) { return NMax(a, b); });
break;
}
......@@ -465,11 +451,10 @@ SpirvShader::EmitResult SpirvShader::EmitGroupNonUniform(InsnIterator insn, Emit
SpirvShader::GroupOps::BinaryOperation(
this, insn, state, dst,
Type(~0u),
[](RValue<Type>a, RValue<Type>b){
[](RValue<Type> a, RValue<Type> b) {
SIMD::UInt zero = SIMD::UInt(0);
return CmpNEQ(a, zero) & CmpNEQ(b, zero);
}
);
});
break;
}
......@@ -479,11 +464,10 @@ SpirvShader::EmitResult SpirvShader::EmitGroupNonUniform(InsnIterator insn, Emit
SpirvShader::GroupOps::BinaryOperation(
this, insn, state, dst,
Type(0),
[](RValue<Type>a, RValue<Type>b){
[](RValue<Type> a, RValue<Type> b) {
SIMD::UInt zero = SIMD::UInt(0);
return CmpNEQ(a, zero) | CmpNEQ(b, zero);
}
);
});
break;
}
......@@ -493,11 +477,10 @@ SpirvShader::EmitResult SpirvShader::EmitGroupNonUniform(InsnIterator insn, Emit
SpirvShader::GroupOps::BinaryOperation(
this, insn, state, dst,
Type(0),
[](RValue<Type>a, RValue<Type>b){
[](RValue<Type> a, RValue<Type> b) {
SIMD::UInt zero = SIMD::UInt(0);
return CmpNEQ(a, zero) ^ CmpNEQ(b, zero);
}
);
});
break;
}
......
src/Pipeline/SpirvShaderMemory.cpp
......@@ -57,8 +57,7 @@ SpirvShader::EmitResult SpirvShader::EmitLoad(InsnIterator insn, EmitState *stat
auto &dst = state->createIntermediate(resultId, resultTy.sizeInComponents);
auto robustness = state->getOutOfBoundsBehavior(pointerTy.storageClass);
VisitMemoryObject(pointerId, [&](const MemoryElement& el)
{
VisitMemoryObject(pointerId, [&](const MemoryElement &el) {
auto p = ptr + el.offset;
if(interleavedByLane) { p = InterleaveByLane(p); } // TODO: Interleave once, then add offset?
dst.move(el.index, p.Load<SIMD::Float>(robustness, state->activeLaneMask(), atomic, memoryOrder));
......@@ -101,8 +100,7 @@ SpirvShader::EmitResult SpirvShader::EmitStore(InsnIterator insn, EmitState *sta
{
// Constant source data.
const uint32_t *src = object.constantValue.get();
VisitMemoryObject(pointerId, [&](const MemoryElement& el)
{
VisitMemoryObject(pointerId, [&](const MemoryElement &el) {
auto p = ptr + el.offset;
if(interleavedByLane) { p = InterleaveByLane(p); }
p.Store(SIMD::Int(src[el.index]), robustness, mask, atomic, memoryOrder);
......@@ -112,8 +110,7 @@ SpirvShader::EmitResult SpirvShader::EmitStore(InsnIterator insn, EmitState *sta
{
// Intermediate source data.
auto &src = state->getIntermediate(objectId);
VisitMemoryObject(pointerId, [&](const MemoryElement& el)
{
VisitMemoryObject(pointerId, [&](const MemoryElement &el) {
auto p = ptr + el.offset;
if(interleavedByLane) { p = InterleaveByLane(p); }
p.Store(src.Float(el.index), robustness, mask, atomic, memoryOrder);
......@@ -239,8 +236,7 @@ SpirvShader::EmitResult SpirvShader::EmitVariable(InsnIterator insn, EmitState *
bool interleavedByLane = IsStorageInterleavedByLane(objectTy.storageClass);
auto ptr = GetPointerToData(resultId, 0, state);
GenericValue initialValue(this, state, initializerId);
VisitMemoryObject(resultId, [&](const MemoryElement& el)
{
VisitMemoryObject(resultId, [&](const MemoryElement &el) {
auto p = ptr + el.offset;
if(interleavedByLane) { p = InterleaveByLane(p); }
auto robustness = OutOfBoundsBehavior::UndefinedBehavior; // Local variables are always within bounds.
......@@ -271,10 +267,9 @@ SpirvShader::EmitResult SpirvShader::EmitCopyMemory(InsnIterator insn, EmitState
std::unordered_map<uint32_t, uint32_t> srcOffsets;
VisitMemoryObject(srcPtrId, [&](const MemoryElement& el) { srcOffsets[el.index] = el.offset; });
VisitMemoryObject(srcPtrId, [&](const MemoryElement &el) { srcOffsets[el.index] = el.offset; });
VisitMemoryObject(dstPtrId, [&](const MemoryElement& el)
{
VisitMemoryObject(dstPtrId, [&](const MemoryElement &el) {
auto it = srcOffsets.find(el.index);
ASSERT(it != srcOffsets.end());
auto srcOffset = it->second;
......@@ -303,7 +298,7 @@ SpirvShader::EmitResult SpirvShader::EmitMemoryBarrier(InsnIterator insn, EmitSt
return EmitResult::Continue;
}
void SpirvShader::VisitMemoryObjectInner(sw::SpirvShader::Type::ID id, sw::SpirvShader::Decorations d, uint32_t& index, uint32_t offset, const MemoryVisitor& f) const
void SpirvShader::VisitMemoryObjectInner(sw::SpirvShader::Type::ID id, sw::SpirvShader::Decorations d, uint32_t &index, uint32_t offset, const MemoryVisitor &f) const
{
ApplyDecorationsForId(&d, id);
auto const &type = getType(id);
......@@ -322,7 +317,7 @@ void SpirvShader::VisitMemoryObjectInner(sw::SpirvShader::Type::ID id, sw::Spirv
case spv::OpTypeInt:
case spv::OpTypeFloat:
case spv::OpTypeRuntimeArray:
f(MemoryElement{index++, offset, type});
f(MemoryElement{ index++, offset, type });
break;
case spv::OpTypeVector:
{
......@@ -366,10 +361,10 @@ void SpirvShader::VisitMemoryObjectInner(sw::SpirvShader::Type::ID id, sw::Spirv
}
}
void SpirvShader::VisitMemoryObject(sw::SpirvShader::Object::ID id, const MemoryVisitor& f) const
void SpirvShader::VisitMemoryObject(sw::SpirvShader::Object::ID id, const MemoryVisitor &f) const
{
auto typeId = getObject(id).type;
auto const & type = getType(typeId);
auto const &type = getType(typeId);
if(IsExplicitLayout(type.storageClass))
{
Decorations d{};
......@@ -384,7 +379,7 @@ void SpirvShader::VisitMemoryObject(sw::SpirvShader::Object::ID id, const Memory
for(auto index = 0u; index < elType.sizeInComponents; index++)
{
auto offset = static_cast<uint32_t>(index * sizeof(float));
f({index, offset, elType});
f({ index, offset, elType });
}
}
}
......@@ -442,8 +437,7 @@ std::memory_order SpirvShader::MemoryOrder(spv::MemorySemanticsMask memorySemant
spv::MemorySemanticsAcquireMask |
spv::MemorySemanticsReleaseMask |
spv::MemorySemanticsAcquireReleaseMask |
spv::MemorySemanticsSequentiallyConsistentMask
);
spv::MemorySemanticsSequentiallyConsistentMask);
switch(control)
{
case spv::MemorySemanticsMaskNone: return std::memory_order_relaxed;
......
src/Pipeline/SpirvShaderSampling.cpp
......@@ -15,13 +15,13 @@
#include "SpirvShader.hpp"
#include "SamplerCore.hpp" // TODO: Figure out what's needed.
#include "Device/Config.hpp"
#include "System/Math.hpp"
#include "Vulkan/VkDebug.hpp"
#include "Vulkan/VkDescriptorSetLayout.hpp"
#include "Vulkan/VkDevice.hpp"
#include "Vulkan/VkImageView.hpp"
#include "Vulkan/VkSampler.hpp"
#include "Device/Config.hpp"
#include <spirv/unified1/spirv.hpp>
......@@ -36,22 +36,22 @@ SpirvShader::ImageSampler *SpirvShader::getImageSampler(uint32_t inst, vk::Sampl
const auto samplerId = sampler ? sampler->id : 0;
ASSERT(imageDescriptor->imageViewId != 0 && (samplerId != 0 || instruction.samplerMethod == Fetch));
vk::Device::SamplingRoutineCache::Key key = {inst, imageDescriptor->imageViewId, samplerId};
vk::Device::SamplingRoutineCache::Key key = { inst, imageDescriptor->imageViewId, samplerId };
ASSERT(imageDescriptor->device);
if(auto routine = imageDescriptor->device->findInConstCache(key))
{
return (ImageSampler*)(routine->getEntry());
return (ImageSampler *)(routine->getEntry());
}
std::unique_lock<std::mutex> lock(imageDescriptor->device->getSamplingRoutineCacheMutex());
vk::Device::SamplingRoutineCache* cache = imageDescriptor->device->getSamplingRoutineCache();
vk::Device::SamplingRoutineCache *cache = imageDescriptor->device->getSamplingRoutineCache();
auto routine = cache->query(key);
if(routine)
{
return (ImageSampler*)(routine->getEntry());
return (ImageSampler *)(routine->getEntry());
}
auto type = imageDescriptor->type;
......@@ -100,7 +100,7 @@ SpirvShader::ImageSampler *SpirvShader::getImageSampler(uint32_t inst, vk::Sampl
routine = emitSamplerRoutine(instruction, samplerState);
cache->add(key, routine);
return (ImageSampler*)(routine->getEntry());
return (ImageSampler *)(routine->getEntry());
}
std::shared_ptr<rr::Routine> SpirvShader::emitSamplerRoutine(ImageInstruction instruction, const Sampler &samplerState)
......@@ -114,17 +114,17 @@ std::shared_ptr<rr::Routine> SpirvShader::emitSamplerRoutine(ImageInstruction in
Pointer<SIMD::Float> out = function.Arg<3>();
Pointer<Byte> constants = function.Arg<4>();
SIMD::Float uvw[4] = {0, 0, 0, 0};
SIMD::Float uvw[4] = { 0, 0, 0, 0 };
SIMD::Float q = 0;
SIMD::Float lodOrBias = 0; // Explicit level-of-detail, or bias added to the implicit level-of-detail (depending on samplerMethod).
Vector4f dsx = {0, 0, 0, 0};
Vector4f dsy = {0, 0, 0, 0};
Vector4f offset = {0, 0, 0, 0};
Vector4f dsx = { 0, 0, 0, 0 };
Vector4f dsy = { 0, 0, 0, 0 };
Vector4f offset = { 0, 0, 0, 0 };
SIMD::Int sampleId = 0;
SamplerFunction samplerFunction = instruction.getSamplerFunction();
uint32_t i = 0;
for( ; i < instruction.coordinates; i++)
for(; i < instruction.coordinates; i++)
{
uvw[i] = in[i];
}
......
src/Pipeline/VertexProgram.cpp
......@@ -29,26 +29,23 @@ VertexProgram::VertexProgram(
vk::PipelineLayout const *pipelineLayout,
SpirvShader const *spirvShader,
const vk::DescriptorSet::Bindings &descriptorSets)
: VertexRoutine(state, pipelineLayout, spirvShader),
descriptorSets(descriptorSets)
: VertexRoutine(state, pipelineLayout, spirvShader)
, descriptorSets(descriptorSets)
{
routine.setImmutableInputBuiltins(spirvShader);
routine.setInputBuiltin(spirvShader, spv::BuiltInViewIndex, [&](const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)
{
routine.setInputBuiltin(spirvShader, spv::BuiltInViewIndex, [&](const SpirvShader::BuiltinMapping &builtin, Array<SIMD::Float> &value) {
assert(builtin.SizeInComponents == 1);
value[builtin.FirstComponent] = As<Float4>(Int4((*Pointer<Int>(data + OFFSET(DrawData, viewID)))));
});
routine.setInputBuiltin(spirvShader, spv::BuiltInInstanceIndex, [&](const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)
{
routine.setInputBuiltin(spirvShader, spv::BuiltInInstanceIndex, [&](const SpirvShader::BuiltinMapping &builtin, Array<SIMD::Float> &value) {
// TODO: we could do better here; we know InstanceIndex is uniform across all lanes
assert(builtin.SizeInComponents == 1);
value[builtin.FirstComponent] = As<Float4>(Int4((*Pointer<Int>(data + OFFSET(DrawData, instanceID)))));
});
routine.setInputBuiltin(spirvShader, spv::BuiltInSubgroupSize, [&](const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)
{
routine.setInputBuiltin(spirvShader, spv::BuiltInSubgroupSize, [&](const SpirvShader::BuiltinMapping &builtin, Array<SIMD::Float> &value) {
ASSERT(builtin.SizeInComponents == 1);
value[builtin.FirstComponent] = As<SIMD::Float>(SIMD::Int(SIMD::Width));
});
......@@ -63,7 +60,7 @@ VertexProgram::~VertexProgram()
{
}
void VertexProgram::program(Pointer<UInt> &batch, UInt& vertexCount)
void VertexProgram::program(Pointer<UInt> &batch, UInt &vertexCount)
{
auto it = spirvShader->inputBuiltins.find(spv::BuiltInVertexIndex);
if(it != spirvShader->inputBuiltins.end())
......@@ -82,4 +79,4 @@ void VertexProgram::program(Pointer<UInt> &batch, UInt& vertexCount)
spirvShader->emitEpilog(&routine);
}
} // namepsace sw
} // namespace sw
src/Pipeline/VertexProgram.hpp
......@@ -15,8 +15,8 @@
#ifndef sw_VertexProgram_hpp
#define sw_VertexProgram_hpp
#include "VertexRoutine.hpp"
#include "ShaderCore.hpp"
#include "VertexRoutine.hpp"
namespace sw {
......@@ -34,11 +34,11 @@ public:
virtual ~VertexProgram();
private:
void program(Pointer<UInt> &batch, UInt& vertexCount) override;
void program(Pointer<UInt> &batch, UInt &vertexCount) override;
const vk::DescriptorSet::Bindings &descriptorSets;
};
} // namepsace sw
} // namespace sw
#endif // sw_VertexProgram_hpp
src/Pipeline/VertexRoutine.hpp
......@@ -20,14 +20,21 @@
#include "Device/Color.hpp"
#include "Device/VertexProcessor.hpp"
namespace vk { class PipelineLayout; }
namespace vk {
class PipelineLayout;
}
namespace sw {
class VertexRoutinePrototype : public VertexRoutineFunction
{
public:
VertexRoutinePrototype() : vertex(Arg<0>()), batch(Arg<1>()), task(Arg<2>()), data(Arg<3>()) {}
VertexRoutinePrototype()
: vertex(Arg<0>())
, batch(Arg<1>())
, task(Arg<2>())
, data(Arg<3>())
{}
virtual ~VertexRoutinePrototype() {}
protected:
......@@ -57,15 +64,15 @@ protected:
SpirvRoutine routine;
const VertexProcessor::State &state;
SpirvShader const * const spirvShader;
SpirvShader const *const spirvShader;
private:
virtual void program(Pointer<UInt> &batch, UInt& vertexCount) = 0;
virtual void program(Pointer<UInt> &batch, UInt &vertexCount) = 0;
typedef VertexProcessor::State::Input Stream;
Vector4f readStream(Pointer<Byte> &buffer, UInt &stride, const Stream &stream, Pointer<UInt> &batch,
bool robustBufferAccess, UInt& robustnessSize, Int baseVertex);
bool robustBufferAccess, UInt &robustnessSize, Int baseVertex);
void readInput(Pointer<UInt> &batch);
void computeClipFlags();
void computeCullMask();
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment