#ifndef D3D9_Capabilities_hpp
#define D3D9_Capabilities_hpp
+#include "Config.hpp"
+#include "MetaMacro.hpp"
+
#include <d3d9.h>
namespace D3D9
extern unsigned int textureMemory;
extern unsigned int maxAnisotropy;
+
+ enum
+ {
+ MAX_VERTEX_SHADER_CONST = 256,
+ MAX_PIXEL_SHADER_CONST = 224,
+ MAX_VERTEX_OUTPUTS = 12,
+ };
+
+ // Shader Model 3.0 requirements
+ META_ASSERT(MAX_VERTEX_SHADER_CONST >= 256);
+ META_ASSERT(MAX_PIXEL_SHADER_CONST == 224);
+ META_ASSERT(MAX_VERTEX_OUTPUTS == 12);
+
+ // Back-end minimum requirements
+ META_ASSERT(sw::VERTEX_UNIFORM_VECTORS >= MAX_VERTEX_SHADER_CONST);
+ META_ASSERT(sw::FRAGMENT_UNIFORM_VECTORS >= MAX_PIXEL_SHADER_CONST);
+ META_ASSERT(sw::MAX_VERTEX_OUTPUTS >= MAX_VERTEX_OUTPUTS);
}
#endif // D3D9_Capabilities_hpp
}
else // Bind directly to the output
{
- for(int i = 0; i < 12; i++)
+ for(int i = 0; i < MAX_VERTEX_OUTPUTS; i++)
{
if((usage == shader->output[i][0].usage || (usage == D3DDECLUSAGE_POSITIONT && shader->output[i][0].usage == D3DDECLUSAGE_POSITION)) &&
index == shader->output[i][0].index)
#include "Direct3D9.hpp"
#include "Direct3DSwapChain9.hpp"
+#include "Capabilities.hpp"
#include "Stream.hpp"
class Direct3DIndexBuffer9;
class CriticalSection;
- enum
- {
- MAX_VERTEX_SHADER_CONST = MIN(256, sw::VERTEX_UNIFORM_VECTORS),
- MAX_PIXEL_SHADER_CONST = MIN(224, sw::FRAGMENT_UNIFORM_VECTORS),
- };
-
class Direct3DDevice9 : public IDirect3DDevice9, public Unknown
{
friend CriticalSection;
TOTAL_IMAGE_UNITS = TEXTURE_IMAGE_UNITS + VERTEX_TEXTURE_IMAGE_UNITS,
FRAGMENT_UNIFORM_VECTORS = 224,
VERTEX_UNIFORM_VECTORS = 256,
+ MAX_VERTEX_OUTPUTS = 12,
MAX_FRAGMENT_UNIFORM_BLOCKS = 12,
MAX_VERTEX_UNIFORM_BLOCKS = 12,
MAX_UNIFORM_BUFFER_BINDINGS = MAX_FRAGMENT_UNIFORM_BLOCKS + MAX_VERTEX_UNIFORM_BLOCKS, // Limited to 127 by SourceParameter.bufferIndex in Shader.hpp
}
else if(vertexShader)
{
- if((var + registerCount) > sw::VertexShader::MAX_OUTPUT_VARYINGS)
+ if((var + registerCount) > sw::MAX_VERTEX_OUTPUTS)
{
mContext.error(varying->getLine(), "Varyings packing failed: Too many varyings", "vertex shader");
return 0;
draw->pUniformBuffers[i] = nullptr;
}
}
-
+
if(context->pixelShaderVersion() <= 0x0104)
{
for(int stage = 0; stage < 8; stage++)
}
}
}
-
+
// Find primitive tasks
if(currentDraw == nextDraw)
{
case Task::PRIMITIVES:
{
int unit = task[threadIndex].primitiveUnit;
-
+
int input = primitiveProgress[unit].firstPrimitive;
int count = primitiveProgress[unit].primitiveCount;
DrawCall *draw = drawList[primitiveProgress[unit].drawCall % DRAW_COUNT];
return visible;
}
-
+
int Renderer::setupVertexTriangle(Renderer *renderer, int unit, int count)
{
Triangle *triangle = renderer->triangleBatch[unit];
int pts = state.pointSizeRegister;
- if(state.pointSizeRegister != 0xF)
+ if(state.pointSizeRegister != Unused)
{
pSize = v.v[pts].y;
}
return false;
}
}
-
+
return setupRoutine(&primitive, &triangle, &polygon, &data);
}
exitThreads = true;
resume[thread]->signal();
worker[thread]->join();
-
+
delete worker[thread];
worker[thread] = 0;
delete resume[thread];
delete suspend[thread];
suspend[thread] = 0;
}
-
+
deallocate(vertexTask[thread]);
vertexTask[thread] = 0;
}
return true;
}
}
-
+
if(context->depthBuffer && context->texture[sampler] == context->depthBuffer->getResource())
{
return true;
return false;
}
-
+
void Renderer::updateClipper()
{
if(updateClipPlanes)
void Renderer::setTextureLevel(unsigned int sampler, unsigned int face, unsigned int level, Surface *surface, TextureType type)
{
ASSERT(sampler < TOTAL_IMAGE_UNITS && face < 6 && level < MIPMAP_LEVELS);
-
+
context->sampler[sampler].setTextureLevel(face, level, surface, type);
}
{
queries.push_back(query);
}
-
+
void Renderer::removeQuery(Query *query)
{
queries.remove(query);
{
return threadCount;
}
-
+
int64_t Renderer::getVertexTime(int thread)
{
return vertexTime[thread];
{
return setupTime[thread];
}
-
+
int64_t Renderer::getPixelTime(int thread)
{
return pixelTime[thread];
state.vFace = context->pixelShader && context->pixelShader->vFaceDeclared;
state.positionRegister = Pos;
- state.pointSizeRegister = 0xF; // No vertex point size
+ state.pointSizeRegister = Unused;
state.multiSample = context->getMultiSampleCount();
state.rasterizerDiscard = context->rasterizerDiscard;
if(context->pixelShader->semantic[interpolant][component - project].active())
{
int input = interpolant;
- for(int i = 0; i < 12; i++)
+ for(int i = 0; i < MAX_VERTEX_OUTPUTS; i++)
{
if(context->pixelShader->semantic[interpolant][component - project] == context->vertexShader->output[i][component - project])
{
bool interpolateW : 1;
bool perspective : 1;
bool pointSprite : 1;
- unsigned int positionRegister : 4;
- unsigned int pointSizeRegister : 4;
+ unsigned int positionRegister : BITS(VERTEX_OUTPUT_LAST);
+ unsigned int pointSizeRegister : BITS(VERTEX_OUTPUT_LAST);
CullMode cullMode : BITS(CULL_LAST);
bool twoSidedStencil : 1;
bool slopeDepthBias : 1;
struct Gradient
{
- unsigned char attribute : BITS(Unused);
+ unsigned char attribute : BITS(VERTEX_OUTPUT_LAST);
bool flat : 1;
bool wrap : 1;
};
#include "Color.hpp"
#include "Common/MetaMacro.hpp"
#include "Common/Types.hpp"
+#include "Main/Config.hpp"
namespace sw
{
- enum Out // Default vertex output semantic
+ enum Out
{
+ // Default vertex output semantics
Pos = 0,
C0 = 1, // Diffuse
C1 = 2, // Specular
T7 = 10,
Fog = 11, // x component
Pts = Fog, // y component
- Unused
+
+ // Variable semantics
+ V0 = 0,
+ Vn_1 = MAX_VERTEX_OUTPUTS - 1,
+
+ Unused,
+ VERTEX_OUTPUT_LAST = Unused,
};
struct UVWQ
float pSize; // Point size
};
- float4 v[12]; // Generic components using semantic declaration
+ float4 v[MAX_VERTEX_OUTPUTS]; // Generic components using semantic declaration
};
// Projected coordinates
if(context->vertexShader) // FIXME: Also when pre-transformed?
{
- for(int i = 0; i < 12; i++)
+ for(int i = 0; i < MAX_VERTEX_OUTPUTS; i++)
{
state.output[i].xWrite = context->vertexShader->output[i][0].active();
state.output[i].yWrite = context->vertexShader->output[i][1].active();
bool fixedFunction : 1;
bool textureSampling : 1;
- unsigned int positionRegister : 4;
- unsigned int pointSizeRegister : 4; // 0xF signifies no vertex point size
+ unsigned int positionRegister : BITS(MAX_VERTEX_OUTPUTS);
+ unsigned int pointSizeRegister : BITS(MAX_VERTEX_OUTPUTS);
unsigned int vertexBlendMatrixCount : 3;
bool indexedVertexBlendEnable : 1;
};
Input input[VERTEX_ATTRIBUTES];
- Output output[12];
+ Output output[MAX_VERTEX_OUTPUTS];
};
struct State : States
If(m != 0 || Bool(!solidTriangle)) // Clipped triangle; reproject
{
Pointer<Byte> V = polygon + OFFSET(Polygon,P) + m * sizeof(void*) * 16;
-
+
Int i = 0;
Do
// Vertical range
Int yMin = Y[0];
Int yMax = Y[0];
-
+
Int i = 1;
-
+
Do
{
yMin = Min(Y[i], yMin);
yMin = Max(yMin, *Pointer<Int>(data + OFFSET(DrawData,scissorY0)));
yMax = Min(yMax, *Pointer<Int>(data + OFFSET(DrawData,scissorY1)));
-
+
For(Int q = 0, q < state.multiSample, q++)
{
Array<Int> Xq(16);
if(component == 1) i.z = 1.0f;
if(component == 2) i.z = 0.0f;
if(component == 3) i.z = 1.0f;
-
+
i.w = 0;
}
Int ceil = -d >> 31; // Ceiling division: remainder <= 0
x -= ceil;
d -= ceil & FDY12;
-
+
Int Q = FDX12 / FDY12; // Edge-step
Int R = FDX12 % FDY12; // Error-step
Int floor = R >> 31; // Flooring division: remainder >= 0
d += R;
Int overflow = -d >> 31;
-
+
d -= D & overflow;
x -= overflow;
If(condition)
{
Pointer<Byte> vX;
-
+
vX = v0;
v0 = v1;
v1 = v2;
If(condition)
{
Pointer<Byte> vX;
-
+
vX = v2;
v2 = v1;
v1 = v0;
predicate = false;
predicateNot = false;
predicateSwizzle = 0xE4;
-
+
coissue = false;
samplerType = SAMPLER_UNKNOWN;
usage = USAGE_POSITION;
token++;
size--;
}
-
+
token++;
size--;
}
predicateNot = (Modifier)((*token & 0x0F000000) >> 24) == MODIFIER_NOT;
predicateSwizzle = (unsigned char)((*token & 0x00FF0000) >> 16);
-
+
token++;
size--;
}
std::string Shader::Instruction::string(ShaderType shaderType, unsigned short version) const
{
std::string instructionString;
-
+
if(opcode != OPCODE_DCL)
{
instructionString += coissue ? "+ " : "";
-
+
if(predicate)
{
instructionString += predicateNot ? "(!p0" : "(p0";
{
instructionString += " " + dst.string(shaderType, version) +
dst.relativeString() +
- dst.maskString();
+ dst.maskString();
}
for(int i = 0; i < 4; i++)
instructionString += (dst.type != PARAMETER_VOID || i > 0) ? ", " : " ";
instructionString += src[i].preModifierString() +
src[i].string(shaderType, version) +
- src[i].relativeString() +
- src[i].postModifierString() +
+ src[i].relativeString() +
+ src[i].postModifierString() +
src[i].swizzleString();
}
}
{
case 0: return "";
case 1: return "_x2";
- case 2: return "_x4";
+ case 2: return "_x4";
case 3: return "_x8";
case -1: return "_d2";
- case -2: return "_d4";
+ case -2: return "_d4";
case -3: return "_d8";
default:
return "";
src[i].rel.type = PARAMETER_VOID;
src[i].rel.swizzle = 0x00;
src[i].rel.scale = 1;
-
+
switch(opcode)
{
case OPCODE_DEF:
else if(type != PARAMETER_RASTOUT && !(type == PARAMETER_ADDR && shaderType == SHADER_VERTEX) && type != PARAMETER_LOOP && type != PARAMETER_PREDICATE && type != PARAMETER_MISCTYPE)
{
buffer << index;
-
+
return typeString(shaderType, version) + buffer.str();
}
else
{
return opcode == OPCODE_IF || opcode == OPCODE_IFC;
}
-
+
bool Shader::Instruction::isCall() const
{
return opcode == OPCODE_CALL || opcode == OPCODE_CALLNZ;
token += 1 + tokenCount;
}
}
-
+
int Shader::size(unsigned long opcode) const
{
return size(opcode, version);
{
containsLeave = true;
}
-
+
if(instruction[i]->isBreak())
{
containsBreak = true;
{
if(shader)
{
- for(int i = 0; i < 12; i++)
+ for(int i = 0; i < MAX_VERTEX_OUTPUTS; i++)
{
unsigned char usage = shader->output[i][0].usage;
loopRepDepth--;
llvm::BasicBlock *endBlock = loopRepEndBlock[loopRepDepth];
-
+
Nucleus::createBr(loopRepEndBlock[loopRepDepth]);
Nucleus::setInsertBlock(endBlock);
{
Vector4f v;
- for(int i = 0; i < 12; i++)
+ for(int i = 0; i < MAX_VERTEX_OUTPUTS; i++)
{
if(state.output[i].write)
{
void VertexRoutine::writeVertex(const Pointer<Byte> &vertex, Pointer<Byte> &cache)
{
- for(int i = 0; i < 12; i++)
+ for(int i = 0; i < MAX_VERTEX_OUTPUTS; i++)
{
if(state.output[i].write)
{
Int clipFlags;
RegisterArray<16> v; // Varying registers
- RegisterArray<12> o; // Output registers
+ RegisterArray<MAX_VERTEX_OUTPUTS> o; // Output registers
const VertexProcessor::State &state;
{
version = 0x0300;
positionRegister = Pos;
- pointSizeRegister = -1; // No vertex point size
+ pointSizeRegister = Unused;
instanceIdDeclared = false;
for(int i = 0; i < MAX_INPUT_ATTRIBUTES; i++)
parse(token);
positionRegister = Pos;
- pointSizeRegister = -1; // No vertex point size
+ pointSizeRegister = Unused;
instanceIdDeclared = false;
for(int i = 0; i < MAX_INPUT_ATTRIBUTES; i++)
#define sw_VertexShader_hpp
#include "Shader.hpp"
+#include "Main/Config.hpp"
namespace sw
{
enum {MAX_INPUT_ATTRIBUTES = 16};
Semantic input[MAX_INPUT_ATTRIBUTES]; // FIXME: Private
- enum {MAX_OUTPUT_VARYINGS = 12};
- Semantic output[MAX_OUTPUT_VARYINGS][4]; // FIXME: Private
+ Semantic output[MAX_VERTEX_OUTPUTS][4]; // FIXME: Private
private:
void analyzeInput();
OSDN Git Service
