Skip to content

A
angle
Commit 28afae5d by Jamie Madill
Options

Rename LinkedVarying to D3DVarying.

Also move this type to D3D-only world. It was only used in the D3D renderer and has specific stuff like register/semantic indexes. Refactoring patch to clean up further work with Varyings. BUG=angleproject:1202 Change-Id: I4b1d6899e9eef356efc7d11e9cd6cf88b234aa76 Reviewed-on: https://chromium-review.googlesource.com/311240Reviewed-by: 's avatarGeoff Lang <geofflang@chromium.org> Tested-by: 's avatarJamie Madill <jmadill@chromium.org>
parent 076ca26f
Showing with 166 additions and 119 deletions
src/libANGLE/Program.cpp
......@@ -222,16 +222,6 @@ VariableLocation::VariableLocation(const std::string &name, unsigned int element
{
}
LinkedVarying::LinkedVarying()
{
}
LinkedVarying::LinkedVarying(const std::string &name, GLenum type, GLsizei size, const std::string &semanticName,
unsigned int semanticIndex, unsigned int semanticIndexCount)
: name(name), type(type), size(size), semanticName(semanticName), semanticIndex(semanticIndex), semanticIndexCount(semanticIndexCount)
{
}
Program::Data::Data()
: mAttachedFragmentShader(nullptr),
mAttachedVertexShader(nullptr),
......
src/libANGLE/Program.h
......@@ -143,24 +143,6 @@ struct VariableLocation
unsigned int index;
};
struct LinkedVarying
{
LinkedVarying();
LinkedVarying(const std::string &name, GLenum type, GLsizei size, const std::string &semanticName,
unsigned int semanticIndex, unsigned int semanticIndexCount);
// Original GL name
std::string name;
GLenum type;
GLsizei size;
// DirectX semantic information
std::string semanticName;
unsigned int semanticIndex;
unsigned int semanticIndexCount;
};
class Program : angle::NonCopyable
{
public:
......
src/libANGLE/renderer/d3d/DynamicHLSL.cpp
......@@ -13,6 +13,7 @@
#include "libANGLE/Program.h"
#include "libANGLE/Shader.h"
#include "libANGLE/formatutils.h"
#include "libANGLE/renderer/d3d/ProgramD3D.h"
#include "libANGLE/renderer/d3d/RendererD3D.h"
#include "libANGLE/renderer/d3d/ShaderD3D.h"
......@@ -863,31 +864,30 @@ void DynamicHLSL::generateVaryingLinkHLSL(const gl::Caps &caps,
linkStream << "};\n";
}
void DynamicHLSL::storeBuiltinLinkedVaryings(const SemanticInfo &info,
std::vector<LinkedVarying> *linkedVaryings) const
void DynamicHLSL::storeBuiltinVaryings(const SemanticInfo &info,
std::vector<D3DVarying> *d3dVaryingsOut) const
{
if (info.glPosition.enabled)
{
linkedVaryings->push_back(LinkedVarying(
"gl_Position", GL_FLOAT_VEC4, 1, info.glPosition.semantic, info.glPosition.index, 1));
d3dVaryingsOut->push_back(D3DVarying("gl_Position", GL_FLOAT_VEC4, 1,
info.glPosition.semantic, info.glPosition.index, 1));
}
if (info.glFragCoord.enabled)
{
linkedVaryings->push_back(LinkedVarying("gl_FragCoord", GL_FLOAT_VEC4, 1,
info.glFragCoord.semantic, info.glFragCoord.index,
1));
d3dVaryingsOut->push_back(D3DVarying("gl_FragCoord", GL_FLOAT_VEC4, 1,
info.glFragCoord.semantic, info.glFragCoord.index, 1));
}
if (info.glPointSize.enabled)
{
linkedVaryings->push_back(LinkedVarying("gl_PointSize", GL_FLOAT, 1, "PSIZE", 0, 1));
d3dVaryingsOut->push_back(D3DVarying("gl_PointSize", GL_FLOAT, 1, "PSIZE", 0, 1));
}
}
void DynamicHLSL::storeUserLinkedVaryings(const std::vector<PackedVarying> &packedVaryings,
bool programUsesPointSize,
std::vector<LinkedVarying> *linkedVaryings) const
void DynamicHLSL::storeUserVaryings(const std::vector<PackedVarying> &packedVaryings,
bool programUsesPointSize,
std::vector<D3DVarying> *d3dVaryingsOut) const
{
const std::string &varyingSemantic = getVaryingSemantic(programUsesPointSize);
......@@ -901,9 +901,9 @@ void DynamicHLSL::storeUserLinkedVaryings(const std::vector<PackedVarying> &pack
GLenum transposedType = TransposeMatrixType(varying.type);
int variableRows = (varying.isStruct() ? 1 : VariableRowCount(transposedType));
linkedVaryings->push_back(
LinkedVarying(varying.name, varying.type, varying.elementCount(), varyingSemantic,
packedVarying.registerIndex, variableRows * varying.elementCount()));
d3dVaryingsOut->push_back(D3DVarying(varying.name, varying.type, varying.elementCount(),
varyingSemantic, packedVarying.registerIndex,
variableRows * varying.elementCount()));
}
}
}
......@@ -915,7 +915,7 @@ bool DynamicHLSL::generateShaderLinkHLSL(const gl::Data &data,
std::string *pixelHLSL,
std::string *vertexHLSL,
const std::vector<PackedVarying> &packedVaryings,
std::vector<LinkedVarying> *linkedVaryings,
std::vector<D3DVarying> *d3dVaryingsOut,
std::vector<PixelShaderOutputVariable> *outPixelShaderKey,
bool *outUsesFragDepth) const
{
......@@ -974,8 +974,8 @@ bool DynamicHLSL::generateShaderLinkHLSL(const gl::Data &data,
getSemanticInfo(SHADER_VERTEX, registerCount, outputPositionFromVS, usesFragCoord,
addPointCoord, (!useInstancedPointSpriteEmulation && usesPointSize));
storeUserLinkedVaryings(packedVaryings, usesPointSize, linkedVaryings);
storeBuiltinLinkedVaryings(vertexSemantics, linkedVaryings);
storeUserVaryings(packedVaryings, usesPointSize, d3dVaryingsOut);
storeBuiltinVaryings(vertexSemantics, d3dVaryingsOut);
std::stringstream vertexStream;
vertexStream << vertexShaderGL->getTranslatedSource();
......
src/libANGLE/renderer/d3d/DynamicHLSL.h
......@@ -29,7 +29,6 @@ namespace gl
{
class InfoLog;
struct VariableLocation;
struct LinkedVarying;
struct VertexAttribute;
struct Data;
}
......@@ -95,7 +94,7 @@ class DynamicHLSL : angle::NonCopyable
std::string *pixelHLSL,
std::string *vertexHLSL,
const std::vector<PackedVarying> &packedVaryings,
std::vector<gl::LinkedVarying> *linkedVaryings,
std::vector<D3DVarying> *d3dVaryingsOut,
std::vector<PixelShaderOutputVariable> *outPixelShaderKey,
bool *outUsesFragDepth) const;
......@@ -131,11 +130,11 @@ class DynamicHLSL : angle::NonCopyable
const std::vector<PackedVarying> &varyings,
bool programUsesPointSize,
std::stringstream &hlslStream) const;
void storeUserLinkedVaryings(const std::vector<PackedVarying> &packedVaryings,
bool programUsesPointSize,
std::vector<gl::LinkedVarying> *linkedVaryings) const;
void storeBuiltinLinkedVaryings(const SemanticInfo &info,
std::vector<gl::LinkedVarying> *linkedVaryings) const;
void storeUserVaryings(const std::vector<PackedVarying> &packedVaryings,
bool programUsesPointSize,
std::vector<D3DVarying> *d3dVaryingsOut) const;
void storeBuiltinVaryings(const SemanticInfo &info,
std::vector<D3DVarying> *d3dVaryingsOut) const;
// Prepend an underscore
static std::string decorateVariable(const std::string &name);
......
src/libANGLE/renderer/d3d/ProgramD3D.cpp
......@@ -291,6 +291,8 @@ gl::PrimitiveType GetGeometryShaderTypeFromDrawMode(GLenum drawMode)
} // anonymous namespace
// D3DUniform Implementation
D3DUniform::D3DUniform(GLenum typeIn,
const std::string &nameIn,
unsigned int arraySizeIn,
......@@ -339,6 +341,29 @@ bool D3DUniform::isReferencedByFragmentShader() const
return psRegisterIndex != GL_INVALID_INDEX;
}
// D3DVarying Implementation
D3DVarying::D3DVarying()
{
}
D3DVarying::D3DVarying(const std::string &name,
GLenum type,
GLsizei size,
const std::string &semanticName,
unsigned int semanticIndex,
unsigned int semanticIndexCount)
: name(name),
type(type),
size(size),
semanticName(semanticName),
semanticIndex(semanticIndex),
semanticIndexCount(semanticIndexCount)
{
}
// ProgramD3D Implementation
ProgramD3D::VertexExecutable::VertexExecutable(const gl::InputLayout &inputLayout,
const Signature &signature,
ShaderExecutableD3D *shaderExecutable)
......@@ -664,18 +689,18 @@ LinkResult ProgramD3D::load(gl::InfoLog &infoLog, gl::BinaryInputStream *stream)
}
const unsigned int transformFeedbackVaryingCount = stream->readInt<unsigned int>();
mTransformFeedbackLinkedVaryings.resize(transformFeedbackVaryingCount);
mTransformFeedbackD3DVaryings.resize(transformFeedbackVaryingCount);
for (unsigned int varyingIndex = 0; varyingIndex < transformFeedbackVaryingCount;
varyingIndex++)
{
gl::LinkedVarying &varying = mTransformFeedbackLinkedVaryings[varyingIndex];
D3DVarying *varying = &mTransformFeedbackD3DVaryings[varyingIndex];
stream->readString(&varying.name);
stream->readInt(&varying.type);
stream->readInt(&varying.size);
stream->readString(&varying.semanticName);
stream->readInt(&varying.semanticIndex);
stream->readInt(&varying.semanticIndexCount);
stream->readString(&varying->name);
stream->readInt(&varying->type);
stream->readInt(&varying->size);
stream->readString(&varying->semanticName);
stream->readInt(&varying->semanticIndex);
stream->readInt(&varying->semanticIndexCount);
}
stream->readString(&mVertexHLSL);
......@@ -721,7 +746,7 @@ LinkResult ProgramD3D::load(gl::InfoLog &infoLog, gl::BinaryInputStream *stream)
ShaderExecutableD3D *shaderExecutable = nullptr;
gl::Error error = mRenderer->loadExecutable(
vertexShaderFunction, vertexShaderSize, SHADER_VERTEX, mTransformFeedbackLinkedVaryings,
vertexShaderFunction, vertexShaderSize, SHADER_VERTEX, mTransformFeedbackD3DVaryings,
(mData.getTransformFeedbackBufferMode() == GL_SEPARATE_ATTRIBS), &shaderExecutable);
if (error.isError())
{
......@@ -760,7 +785,7 @@ LinkResult ProgramD3D::load(gl::InfoLog &infoLog, gl::BinaryInputStream *stream)
ShaderExecutableD3D *shaderExecutable = nullptr;
gl::Error error = mRenderer->loadExecutable(
pixelShaderFunction, pixelShaderSize, SHADER_PIXEL, mTransformFeedbackLinkedVaryings,
pixelShaderFunction, pixelShaderSize, SHADER_PIXEL, mTransformFeedbackD3DVaryings,
(mData.getTransformFeedbackBufferMode() == GL_SEPARATE_ATTRIBS), &shaderExecutable);
if (error.isError())
{
......@@ -792,10 +817,9 @@ LinkResult ProgramD3D::load(gl::InfoLog &infoLog, gl::BinaryInputStream *stream)
const unsigned char *geometryShaderFunction = binary + stream->offset();
bool splitAttribs = (mData.getTransformFeedbackBufferMode() == GL_SEPARATE_ATTRIBS);
gl::Error error =
mRenderer->loadExecutable(geometryShaderFunction, geometryShaderSize, SHADER_GEOMETRY,
mTransformFeedbackLinkedVaryings, splitAttribs,
&mGeometryExecutables[geometryExeIndex]);
gl::Error error = mRenderer->loadExecutable(
geometryShaderFunction, geometryShaderSize, SHADER_GEOMETRY,
mTransformFeedbackD3DVaryings, splitAttribs, &mGeometryExecutables[geometryExeIndex]);
if (error.isError())
{
return LinkResult(false, error);
......@@ -868,10 +892,10 @@ gl::Error ProgramD3D::save(gl::BinaryOutputStream *stream)
stream->writeInt(uniformBlock.vsRegisterIndex);
}
stream->writeInt(mTransformFeedbackLinkedVaryings.size());
for (size_t i = 0; i < mTransformFeedbackLinkedVaryings.size(); i++)
stream->writeInt(mTransformFeedbackD3DVaryings.size());
for (size_t i = 0; i < mTransformFeedbackD3DVaryings.size(); i++)
{
const gl::LinkedVarying &varying = mTransformFeedbackLinkedVaryings[i];
const D3DVarying &varying = mTransformFeedbackD3DVaryings[i];
stream->writeString(varying.name);
stream->writeInt(varying.type);
......@@ -1013,7 +1037,7 @@ gl::Error ProgramD3D::getPixelExecutableForOutputLayout(const std::vector<GLenum
gl::InfoLog *currentInfoLog = infoLog ? infoLog : &tempInfoLog;
gl::Error error = mRenderer->compileToExecutable(
*currentInfoLog, finalPixelHLSL, SHADER_PIXEL, mTransformFeedbackLinkedVaryings,
*currentInfoLog, finalPixelHLSL, SHADER_PIXEL, mTransformFeedbackD3DVaryings,
(mData.getTransformFeedbackBufferMode() == GL_SEPARATE_ATTRIBS), mPixelWorkarounds,
&pixelExecutable);
if (error.isError())
......@@ -1062,7 +1086,7 @@ gl::Error ProgramD3D::getVertexExecutableForInputLayout(const gl::InputLayout &i
gl::InfoLog *currentInfoLog = infoLog ? infoLog : &tempInfoLog;
gl::Error error = mRenderer->compileToExecutable(
*currentInfoLog, finalVertexHLSL, SHADER_VERTEX, mTransformFeedbackLinkedVaryings,
*currentInfoLog, finalVertexHLSL, SHADER_VERTEX, mTransformFeedbackD3DVaryings,
(mData.getTransformFeedbackBufferMode() == GL_SEPARATE_ATTRIBS), mVertexWorkarounds,
&vertexExecutable);
if (error.isError())
......@@ -1121,7 +1145,7 @@ gl::Error ProgramD3D::getGeometryExecutableForPrimitiveType(const gl::Data &data
gl::InfoLog *currentInfoLog = infoLog ? infoLog : &tempInfoLog;
gl::Error error = mRenderer->compileToExecutable(
*currentInfoLog, geometryHLSL, SHADER_GEOMETRY, mTransformFeedbackLinkedVaryings,
*currentInfoLog, geometryHLSL, SHADER_GEOMETRY, mTransformFeedbackD3DVaryings,
(mData.getTransformFeedbackBufferMode() == GL_SEPARATE_ATTRIBS), D3DCompilerWorkarounds(),
&mGeometryExecutables[geometryShaderType]);
......@@ -1243,9 +1267,9 @@ LinkResult ProgramD3D::link(const gl::Data &data, gl::InfoLog &infoLog)
return LinkResult(false, gl::Error(GL_NO_ERROR));
}
std::vector<gl::LinkedVarying> linkedVaryings;
std::vector<D3DVarying> d3dVaryings;
if (!mDynamicHLSL->generateShaderLinkHLSL(data, mData, infoLog, registerCount, &mPixelHLSL,
&mVertexHLSL, packedVaryings, &linkedVaryings,
&mVertexHLSL, packedVaryings, &d3dVaryings,
&mPixelShaderKey, &mUsesFragDepth))
{
return LinkResult(false, gl::Error(GL_NO_ERROR));
......@@ -1273,7 +1297,7 @@ LinkResult ProgramD3D::link(const gl::Data &data, gl::InfoLog &infoLog)
defineUniformsAndAssignRegisters();
gatherTransformFeedbackVaryings(linkedVaryings);
gatherTransformFeedbackVaryings(d3dVaryings);
LinkResult result = compileProgramExecutables(data, infoLog);
if (result.error.isError() || !result.linkSuccess)
......@@ -1990,7 +2014,7 @@ void ProgramD3D::reset()
std::fill(mSemanticIndexes, mSemanticIndexes + ArraySize(mSemanticIndexes), -1);
std::fill(mAttributesByLayout, mAttributesByLayout + ArraySize(mAttributesByLayout), -1);
mTransformFeedbackLinkedVaryings.clear();
mTransformFeedbackD3DVaryings.clear();
mGeometryShaderPreamble.clear();
}
......@@ -2072,18 +2096,17 @@ void ProgramD3D::updateCachedInputLayout(const gl::State &state)
}
}
void ProgramD3D::gatherTransformFeedbackVaryings(
const std::vector<gl::LinkedVarying> &linkedVaryings)
void ProgramD3D::gatherTransformFeedbackVaryings(const std::vector<D3DVarying> &d3dVaryings)
{
// Gather the linked varyings that are used for transform feedback, they should all exist.
mTransformFeedbackLinkedVaryings.clear();
mTransformFeedbackD3DVaryings.clear();
for (const std::string &tfVaryingName : mData.getTransformFeedbackVaryingNames())
{
for (const gl::LinkedVarying &linkedVarying : linkedVaryings)
for (const D3DVarying &d3dVarying : d3dVaryings)
{
if (tfVaryingName == linkedVarying.name)
if (tfVaryingName == d3dVarying.name)
{
mTransformFeedbackLinkedVaryings.push_back(linkedVarying);
mTransformFeedbackD3DVaryings.push_back(d3dVarying);
break;
}
}
......
src/libANGLE/renderer/d3d/ProgramD3D.h
......@@ -80,6 +80,28 @@ struct D3DUniformBlock
unsigned int psRegisterIndex;
};
struct D3DVarying
{
D3DVarying();
D3DVarying(const std::string &name,
GLenum type,
GLsizei size,
const std::string &semanticName,
unsigned int semanticIndex,
unsigned int semanticIndexCount);
// Original GL name
std::string name;
GLenum type;
GLsizei size;
// DirectX semantic information
std::string semanticName;
unsigned int semanticIndex;
unsigned int semanticIndexCount;
};
class ProgramD3D : public ProgramImpl
{
public:
......@@ -283,7 +305,7 @@ class ProgramD3D : public ProgramImpl
LinkResult compileProgramExecutables(const gl::Data &data, gl::InfoLog &infoLog);
void gatherTransformFeedbackVaryings(const std::vector<gl::LinkedVarying> &varyings);
void gatherTransformFeedbackVaryings(const std::vector<D3DVarying> &varyings);
D3DUniform *getD3DUniformByName(const std::string &name);
D3DUniform *getD3DUniformFromLocation(GLint location);
......@@ -341,7 +363,7 @@ class ProgramD3D : public ProgramImpl
VertexExecutable::Signature mCachedVertexSignature;
gl::InputLayout mCachedInputLayout;
std::vector<gl::LinkedVarying> mTransformFeedbackLinkedVaryings;
std::vector<D3DVarying> mTransformFeedbackD3DVaryings;
std::vector<D3DUniform *> mD3DUniforms;
std::vector<D3DUniformBlock> mD3DUniformBlocks;
......
src/libANGLE/renderer/d3d/RendererD3D.h
......@@ -39,6 +39,7 @@ struct LinkedVarying;
namespace rx
{
struct D3DUniform;
struct D3DVarying;
class DeviceD3D;
class EGLImageD3D;
class ImageD3D;
......@@ -202,12 +203,18 @@ class RendererD3D : public Renderer, public BufferFactoryD3D
virtual gl::Error createRenderTargetCopy(RenderTargetD3D *source, RenderTargetD3D **outRT) = 0;
// Shader operations
virtual gl::Error loadExecutable(const void *function, size_t length, ShaderType type,
const std::vector<gl::LinkedVarying> &transformFeedbackVaryings,
bool separatedOutputBuffers, ShaderExecutableD3D **outExecutable) = 0;
virtual gl::Error compileToExecutable(gl::InfoLog &infoLog, const std::string &shaderHLSL, ShaderType type,
const std::vector<gl::LinkedVarying> &transformFeedbackVaryings,
bool separatedOutputBuffers, const D3DCompilerWorkarounds &workarounds,
virtual gl::Error loadExecutable(const void *function,
size_t length,
ShaderType type,
const std::vector<D3DVarying> &transformFeedbackVaryings,
bool separatedOutputBuffers,
ShaderExecutableD3D **outExecutable) = 0;
virtual gl::Error compileToExecutable(gl::InfoLog &infoLog,
const std::string &shaderHLSL,
ShaderType type,
const std::vector<D3DVarying> &transformFeedbackVaryings,
bool separatedOutputBuffers,
const D3DCompilerWorkarounds &workarounds,
ShaderExecutableD3D **outExectuable) = 0;
virtual UniformStorageD3D *createUniformStorage(size_t storageSize) = 0;
......
src/libANGLE/renderer/d3d/d3d11/Renderer11.cpp
......@@ -3254,9 +3254,12 @@ ProgramImpl *Renderer11::createProgram(const gl::Program::Data &data)
return new ProgramD3D(data, this);
}
gl::Error Renderer11::loadExecutable(const void *function, size_t length, ShaderType type,
const std::vector<gl::LinkedVarying> &transformFeedbackVaryings,
bool separatedOutputBuffers, ShaderExecutableD3D **outExecutable)
gl::Error Renderer11::loadExecutable(const void *function,
size_t length,
ShaderType type,
const std::vector<D3DVarying> &transformFeedbackVaryings,
bool separatedOutputBuffers,
ShaderExecutableD3D **outExecutable)
{
switch (type)
{
......@@ -3277,7 +3280,7 @@ gl::Error Renderer11::loadExecutable(const void *function, size_t length, Shader
std::vector<D3D11_SO_DECLARATION_ENTRY> soDeclaration;
for (size_t i = 0; i < transformFeedbackVaryings.size(); i++)
{
const gl::LinkedVarying &varying = transformFeedbackVaryings[i];
const D3DVarying &varying = transformFeedbackVaryings[i];
GLenum transposedType = gl::TransposeMatrixType(varying.type);
for (unsigned int j = 0; j < varying.semanticIndexCount; j++)
......@@ -3343,9 +3346,12 @@ gl::Error Renderer11::loadExecutable(const void *function, size_t length, Shader
return gl::Error(GL_NO_ERROR);
}
gl::Error Renderer11::compileToExecutable(gl::InfoLog &infoLog, const std::string &shaderHLSL, ShaderType type,
const std::vector<gl::LinkedVarying> &transformFeedbackVaryings,
bool separatedOutputBuffers, const D3DCompilerWorkarounds &workarounds,
gl::Error Renderer11::compileToExecutable(gl::InfoLog &infoLog,
const std::string &shaderHLSL,
ShaderType type,
const std::vector<D3DVarying> &transformFeedbackVaryings,
bool separatedOutputBuffers,
const D3DCompilerWorkarounds &workarounds,
ShaderExecutableD3D **outExectuable)
{
const char *profileType = NULL;
......
src/libANGLE/renderer/d3d/d3d11/Renderer11.h
......@@ -188,14 +188,20 @@ class Renderer11 : public RendererD3D
ProgramImpl *createProgram(const gl::Program::Data &data) override;
// Shader operations
virtual gl::Error loadExecutable(const void *function, size_t length, ShaderType type,
const std::vector<gl::LinkedVarying> &transformFeedbackVaryings,
bool separatedOutputBuffers, ShaderExecutableD3D **outExecutable);
virtual gl::Error compileToExecutable(gl::InfoLog &infoLog, const std::string &shaderHLSL, ShaderType type,
const std::vector<gl::LinkedVarying> &transformFeedbackVaryings,
bool separatedOutputBuffers, const D3DCompilerWorkarounds &workarounds,
ShaderExecutableD3D **outExectuable);
virtual UniformStorageD3D *createUniformStorage(size_t storageSize);
gl::Error loadExecutable(const void *function,
size_t length,
ShaderType type,
const std::vector<D3DVarying> &transformFeedbackVaryings,
bool separatedOutputBuffers,
ShaderExecutableD3D **outExecutable) override;
gl::Error compileToExecutable(gl::InfoLog &infoLog,
const std::string &shaderHLSL,
ShaderType type,
const std::vector<D3DVarying> &transformFeedbackVaryings,
bool separatedOutputBuffers,
const D3DCompilerWorkarounds &workarounds,
ShaderExecutableD3D **outExectuable) override;
UniformStorageD3D *createUniformStorage(size_t storageSize) override;
// Image operations
virtual ImageD3D *createImage();
......
src/libANGLE/renderer/d3d/d3d9/Renderer9.cpp
......@@ -2732,9 +2732,12 @@ ProgramImpl *Renderer9::createProgram(const gl::Program::Data &data)
return new ProgramD3D(data, this);
}
gl::Error Renderer9::loadExecutable(const void *function, size_t length, ShaderType type,
const std::vector<gl::LinkedVarying> &transformFeedbackVaryings,
bool separatedOutputBuffers, ShaderExecutableD3D **outExecutable)
gl::Error Renderer9::loadExecutable(const void *function,
size_t length,
ShaderType type,
const std::vector<D3DVarying> &transformFeedbackVaryings,
bool separatedOutputBuffers,
ShaderExecutableD3D **outExecutable)
{
// Transform feedback is not supported in ES2 or D3D9
ASSERT(transformFeedbackVaryings.size() == 0);
......@@ -2771,9 +2774,12 @@ gl::Error Renderer9::loadExecutable(const void *function, size_t length, ShaderT
return gl::Error(GL_NO_ERROR);
}
gl::Error Renderer9::compileToExecutable(gl::InfoLog &infoLog, const std::string &shaderHLSL, ShaderType type,
const std::vector<gl::LinkedVarying> &transformFeedbackVaryings,
bool separatedOutputBuffers, const D3DCompilerWorkarounds &workarounds,
gl::Error Renderer9::compileToExecutable(gl::InfoLog &infoLog,
const std::string &shaderHLSL,
ShaderType type,
const std::vector<D3DVarying> &transformFeedbackVaryings,
bool separatedOutputBuffers,
const D3DCompilerWorkarounds &workarounds,
ShaderExecutableD3D **outExectuable)
{
// Transform feedback is not supported in ES2 or D3D9
......
src/libANGLE/renderer/d3d/d3d9/Renderer9.h
......@@ -176,14 +176,20 @@ class Renderer9 : public RendererD3D
ProgramImpl *createProgram(const gl::Program::Data &data) override;
// Shader operations
virtual gl::Error loadExecutable(const void *function, size_t length, ShaderType type,
const std::vector<gl::LinkedVarying> &transformFeedbackVaryings,
bool separatedOutputBuffers, ShaderExecutableD3D **outExecutable);
virtual gl::Error compileToExecutable(gl::InfoLog &infoLog, const std::string &shaderHLSL, ShaderType type,
const std::vector<gl::LinkedVarying> &transformFeedbackVaryings,
bool separatedOutputBuffers, const D3DCompilerWorkarounds &workarounds,
ShaderExecutableD3D **outExectuable);
virtual UniformStorageD3D *createUniformStorage(size_t storageSize);
gl::Error loadExecutable(const void *function,
size_t length,
ShaderType type,
const std::vector<D3DVarying> &transformFeedbackVaryings,
bool separatedOutputBuffers,
ShaderExecutableD3D **outExecutable) override;
gl::Error compileToExecutable(gl::InfoLog &infoLog,
const std::string &shaderHLSL,
ShaderType type,
const std::vector<D3DVarying> &transformFeedbackVaryings,
bool separatedOutputBuffers,
const D3DCompilerWorkarounds &workarounds,
ShaderExecutableD3D **outExectuable) override;
UniformStorageD3D *createUniformStorage(size_t storageSize) override;
// Image operations
virtual ImageD3D *createImage();
......
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