blob: 4ed11f6122a831681a51140a450d9413bc1249f1 [file] [log] [blame]
// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef sw_Renderer_hpp
#define sw_Renderer_hpp
#include "VertexProcessor.hpp"
#include "PixelProcessor.hpp"
#include "SetupProcessor.hpp"
#include "Plane.hpp"
#include "Blitter.hpp"
#include "Common/MutexLock.hpp"
#include "Common/Thread.hpp"
#include "Main/Config.hpp"
#include <list>
namespace sw
class Clipper;
struct DrawCall;
class PixelShader;
class VertexShader;
class SwiftConfig;
struct Task;
class Resource;
struct Constants;
enum TranscendentalPrecision
PARTIAL, // 2^-10
WHQL, // 2^-21
IEEE // 2^-23
extern TranscendentalPrecision logPrecision;
extern TranscendentalPrecision expPrecision;
extern TranscendentalPrecision rcpPrecision;
extern TranscendentalPrecision rsqPrecision;
extern bool perspectiveCorrection;
struct Conventions
bool halfIntegerCoordinates;
bool symmetricNormalizedDepth;
bool booleanFaceRegister;
bool fullPixelPositionRegister;
bool leadingVertexFirst;
bool secondaryColor;
bool colorsDefaultToZero;
static const Conventions OpenGL =
true, // halfIntegerCoordinates
true, // symmetricNormalizedDepth
true, // booleanFaceRegister
true, // fullPixelPositionRegister
false, // leadingVertexFirst
false, // secondaryColor
true, // colorsDefaultToZero
static const Conventions Direct3D =
false, // halfIntegerCoordinates
false, // symmetricNormalizedDepth
false, // booleanFaceRegister
false, // fullPixelPositionRegister
true, // leadingVertexFirst
true, // secondardyColor
false, // colorsDefaultToZero
struct Query
Query(Type type);
void addRef();
void release();
inline void begin()
building = true;
data = 0;
inline void end()
building = false;
inline bool isReady() const
return (reference == 1);
bool building;
AtomicInt data;
const Type type;
~Query() {} // Only delete a query within the release() function
AtomicInt reference;
struct DrawData
const Constants *constants;
const void *input[MAX_VERTEX_INPUTS];
unsigned int stride[MAX_VERTEX_INPUTS];
Texture mipmap[TOTAL_IMAGE_UNITS];
const void *indices;
struct VS
float4 c[VERTEX_UNIFORM_VECTORS + 1]; // One extra for indices out of range, c[VERTEX_UNIFORM_VECTORS] = {0, 0, 0, 0}
unsigned int reg[MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS]; // Offset used when reading from registers, in components
unsigned int row[MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS]; // Number of rows to read
unsigned int col[MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS]; // Number of columns to read
unsigned int str[MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS]; // Number of components between each varying in output buffer
int4 i[16];
bool b[16];
struct PS
word4 cW[8][4];
int4 i[16];
bool b[16];
VS vs;
VertexProcessor::FixedFunction ff;
PS ps;
int instanceID;
VertexProcessor::PointSprite point;
float lineWidth;
PixelProcessor::Stencil stencil[2]; // clockwise, counterclockwise
PixelProcessor::Fog fog;
PixelProcessor::Factor factor;
unsigned int occlusion[16]; // Number of pixels passing depth test
int64_t cycles[PERF_TIMERS][16];
TextureStage::Uniforms textureStage[8];
float4 Wx16;
float4 Hx16;
float4 X0x16;
float4 Y0x16;
float4 XXXX;
float4 YYYY;
float4 halfPixelX;
float4 halfPixelY;
float viewportHeight;
float slopeDepthBias;
float depthRange;
float depthNear;
Plane clipPlane[6];
unsigned int *colorBuffer[RENDERTARGETS];
int colorPitchB[RENDERTARGETS];
int colorSliceB[RENDERTARGETS];
float *depthBuffer;
int depthPitchB;
int depthSliceB;
unsigned char *stencilBuffer;
int stencilPitchB;
int stencilSliceB;
int scissorX0;
int scissorX1;
int scissorY0;
int scissorY1;
float4 a2c0;
float4 a2c1;
float4 a2c2;
float4 a2c3;
struct Viewport
float x0;
float y0;
float width;
float height;
float minZ;
float maxZ;
class Renderer : public VertexProcessor, public PixelProcessor, public SetupProcessor
struct Task
enum Type
AtomicInt type;
AtomicInt primitiveUnit;
AtomicInt pixelCluster;
struct PrimitiveProgress
void init()
drawCall = 0;
firstPrimitive = 0;
primitiveCount = 0;
visible = 0;
references = 0;
AtomicInt drawCall;
AtomicInt firstPrimitive;
AtomicInt primitiveCount;
AtomicInt visible;
AtomicInt references;
struct PixelProgress
void init()
drawCall = 0;
processedPrimitives = 0;
executing = false;
AtomicInt drawCall;
AtomicInt processedPrimitives;
AtomicInt executing;
Renderer(Context *context, Conventions conventions, bool exactColorRounding);
virtual ~Renderer();
void *operator new(size_t size);
void operator delete(void * mem);
void draw(DrawType drawType, unsigned int indexOffset, unsigned int count, bool update = true);
void clear(void *value, Format format, Surface *dest, const Rect &rect, unsigned int rgbaMask);
void blit(Surface *source, const SliceRectF &sRect, Surface *dest, const SliceRect &dRect, bool filter, bool isStencil = false, bool sRGBconversion = true);
void blit3D(Surface *source, Surface *dest);
void setIndexBuffer(Resource *indexBuffer);
void setMultiSampleMask(unsigned int mask);
void setTransparencyAntialiasing(TransparencyAntialiasing transparencyAntialiasing);
void setTextureResource(unsigned int sampler, Resource *resource);
void setTextureLevel(unsigned int sampler, unsigned int face, unsigned int level, Surface *surface, TextureType type);
void setTextureFilter(SamplerType type, int sampler, FilterType textureFilter);
void setMipmapFilter(SamplerType type, int sampler, MipmapType mipmapFilter);
void setGatherEnable(SamplerType type, int sampler, bool enable);
void setAddressingModeU(SamplerType type, int sampler, AddressingMode addressingMode);
void setAddressingModeV(SamplerType type, int sampler, AddressingMode addressingMode);
void setAddressingModeW(SamplerType type, int sampler, AddressingMode addressingMode);
void setReadSRGB(SamplerType type, int sampler, bool sRGB);
void setMipmapLOD(SamplerType type, int sampler, float bias);
void setBorderColor(SamplerType type, int sampler, const Color<float> &borderColor);
void setMaxAnisotropy(SamplerType type, int sampler, float maxAnisotropy);
void setHighPrecisionFiltering(SamplerType type, int sampler, bool highPrecisionFiltering);
void setSwizzleR(SamplerType type, int sampler, SwizzleType swizzleR);
void setSwizzleG(SamplerType type, int sampler, SwizzleType swizzleG);
void setSwizzleB(SamplerType type, int sampler, SwizzleType swizzleB);
void setSwizzleA(SamplerType type, int sampler, SwizzleType swizzleA);
void setCompareFunc(SamplerType type, int sampler, CompareFunc compare);
void setBaseLevel(SamplerType type, int sampler, int baseLevel);
void setMaxLevel(SamplerType type, int sampler, int maxLevel);
void setMinLod(SamplerType type, int sampler, float minLod);
void setMaxLod(SamplerType type, int sampler, float maxLod);
void setSyncRequired(SamplerType type, int sampler, bool syncRequired);
void setPointSpriteEnable(bool pointSpriteEnable);
void setPointScaleEnable(bool pointScaleEnable);
void setLineWidth(float width);
void setDepthBias(float bias);
void setSlopeDepthBias(float slopeBias);
void setRasterizerDiscard(bool rasterizerDiscard);
// Programmable pipelines
void setPixelShader(const PixelShader *shader);
void setVertexShader(const VertexShader *shader);
void setPixelShaderConstantF(unsigned int index, const float value[4], unsigned int count = 1);
void setPixelShaderConstantI(unsigned int index, const int value[4], unsigned int count = 1);
void setPixelShaderConstantB(unsigned int index, const int *boolean, unsigned int count = 1);
void setVertexShaderConstantF(unsigned int index, const float value[4], unsigned int count = 1);
void setVertexShaderConstantI(unsigned int index, const int value[4], unsigned int count = 1);
void setVertexShaderConstantB(unsigned int index, const int *boolean, unsigned int count = 1);
// Viewport & Clipper
void setViewport(const Viewport &viewport);
void setScissor(const Rect &scissor);
void setClipFlags(int flags);
void setClipPlane(unsigned int index, const float plane[4]);
// Partial transform
void setModelMatrix(const Matrix &M, int i = 0);
void setViewMatrix(const Matrix &V);
void setBaseMatrix(const Matrix &B);
void setProjectionMatrix(const Matrix &P);
void addQuery(Query *query);
void removeQuery(Query *query);
void synchronize();
// Performance timers
int getThreadCount();
int64_t getVertexTime(int thread);
int64_t getSetupTime(int thread);
int64_t getPixelTime(int thread);
void resetTimers();
static int getClusterCount() { return clusterCount; }
static void threadFunction(void *parameters);
void threadLoop(int threadIndex);
void taskLoop(int threadIndex);
void findAvailableTasks();
void scheduleTask(int threadIndex);
void executeTask(int threadIndex);
void finishRendering(Task &pixelTask);
void processPrimitiveVertices(int unit, unsigned int start, unsigned int count, unsigned int loop, int thread);
int setupSolidTriangles(int batch, int count);
int setupWireframeTriangle(int batch, int count);
int setupVertexTriangle(int batch, int count);
int setupLines(int batch, int count);
int setupPoints(int batch, int count);
bool setupLine(Primitive &primitive, Triangle &triangle, const DrawCall &draw);
bool setupPoint(Primitive &primitive, Triangle &triangle, const DrawCall &draw);
bool isReadWriteTexture(int sampler);
void updateClipper();
void updateConfiguration(bool initialUpdate = false);
void initializeThreads();
void terminateThreads();
void loadConstants(const VertexShader *vertexShader);
void loadConstants(const PixelShader *pixelShader);
Context *context;
Clipper *clipper;
Blitter *blitter;
Viewport viewport;
Rect scissor;
int clipFlags;
Triangle *triangleBatch[16];
Primitive *primitiveBatch[16];
// User-defined clipping planes
Plane userPlane[MAX_CLIP_PLANES];
Plane clipPlane[MAX_CLIP_PLANES]; // Tranformed to clip space
bool updateClipPlanes;
AtomicInt exitThreads;
AtomicInt threadsAwake;
Thread *worker[16];
Event *resume[16]; // Events for resuming threads
Event *suspend[16]; // Events for suspending threads
Event *resumeApp; // Event for resuming the application thread
PrimitiveProgress primitiveProgress[16];
PixelProgress pixelProgress[16];
Task task[16]; // Current tasks for threads
enum {
DRAW_COUNT = 16, // Number of draw calls buffered (must be power of 2)
DrawCall *drawCall[DRAW_COUNT];
DrawCall *drawList[DRAW_COUNT];
AtomicInt currentDraw;
AtomicInt nextDraw;
enum {
TASK_COUNT = 32, // Size of the task queue (must be power of 2)
Task taskQueue[TASK_COUNT];
AtomicInt qHead;
AtomicInt qSize;
static AtomicInt unitCount;
static AtomicInt clusterCount;
MutexLock schedulerMutex;
int64_t vertexTime[16];
int64_t setupTime[16];
int64_t pixelTime[16];
VertexTask *vertexTask[16];
SwiftConfig *swiftConfig;
std::list<Query*> queries;
Resource *sync;
VertexProcessor::State vertexState;
SetupProcessor::State setupState;
PixelProcessor::State pixelState;
std::shared_ptr<Routine> vertexRoutine;
std::shared_ptr<Routine> setupRoutine;
std::shared_ptr<Routine> pixelRoutine;
struct DrawCall
AtomicInt drawType;
AtomicInt batchSize;
std::shared_ptr<Routine> vertexRoutine;
std::shared_ptr<Routine> setupRoutine;
std::shared_ptr<Routine> pixelRoutine;
VertexProcessor::RoutinePointer vertexPointer;
SetupProcessor::RoutinePointer setupPointer;
PixelProcessor::RoutinePointer pixelPointer;
int (Renderer::*setupPrimitives)(int batch, int count);
SetupProcessor::State setupState;
Resource *vertexStream[MAX_VERTEX_INPUTS];
Resource *indexBuffer;
Surface *renderTarget[RENDERTARGETS];
Surface *depthBuffer;
Surface *stencilBuffer;
Resource *texture[TOTAL_IMAGE_UNITS];
Resource* pUniformBuffers[MAX_UNIFORM_BUFFER_BINDINGS];
Resource* vUniformBuffers[MAX_UNIFORM_BUFFER_BINDINGS];
unsigned int vsDirtyConstF;
unsigned int vsDirtyConstI;
unsigned int vsDirtyConstB;
unsigned int psDirtyConstF;
unsigned int psDirtyConstI;
unsigned int psDirtyConstB;
std::list<Query*> *queries;
AtomicInt clipFlags;
AtomicInt primitive; // Current primitive to enter pipeline
AtomicInt count; // Number of primitives to render
AtomicInt references; // Remaining references to this draw call, 0 when done drawing, -1 when resources unlocked and slot is free
DrawData *data;
#endif // sw_Renderer_hpp