commit 44151a97f9915252ddf8815112a3b3d4f54caf54
author Brandon Jones <bajones@chromium.org> Wed Sep 10 11:32:25 2014 -0700
committer Brandon Jones <bajones@chromium.org> Tue Sep 23 23:00:36 2014 +0000
tree 062c827514a1304f92daf6c4fd490d9420fa2470
parent abce762061418a6590a9a9332118e8f03b8e8d0a

Removed the last references to DynamicHLSL from ProgramBinary.

Migrated several more non-generic values from ProgramBinary the D3D impl.

BUG=angle:731
Change-Id: Ic043dd75328cffbc6bef6556da801c382b4138bc
Reviewed-on: https://chromium-review.googlesource.com/219390
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Shannon Woods <shannonwoods@chromium.org>
Tested-by: Brandon Jones <bajones@chromium.org>

src/libGLESv2/renderer/d3d/ProgramD3D.cpp

diff --git a/src/libGLESv2/renderer/d3d/ProgramD3D.cpp b/src/libGLESv2/renderer/d3d/ProgramD3D.cpp
index d7d97cc..15c6e13 100644
--- a/src/libGLESv2/renderer/d3d/ProgramD3D.cpp
+++ b/src/libGLESv2/renderer/d3d/ProgramD3D.cpp
@@ -25,8 +25,10 @@
       mDynamicHLSL(NULL),
       mVertexWorkarounds(rx::ANGLE_D3D_WORKAROUND_NONE),
       mPixelWorkarounds(rx::ANGLE_D3D_WORKAROUND_NONE),
+      mUsesPointSize(false),
       mVertexUniformStorage(NULL),
-      mFragmentUniformStorage(NULL)
+      mFragmentUniformStorage(NULL),
+      mShaderVersion(100)
 {
     mDynamicHLSL = new rx::DynamicHLSL(renderer);
 }
@@ -49,13 +51,31 @@
     return static_cast<const ProgramD3D*>(impl);
 }
 
+bool ProgramD3D::usesPointSize() const
+{
+    return mUsesPointSize;
+}
+
+bool ProgramD3D::usesPointSpriteEmulation() const
+{
+    return mUsesPointSize && mRenderer->getMajorShaderModel() >= 4;
+}
+
+bool ProgramD3D::usesGeometryShader() const
+{
+    return usesPointSpriteEmulation();
+}
+
 bool ProgramD3D::load(gl::InfoLog &infoLog, gl::BinaryInputStream *stream)
 {
+    stream->readInt(&mShaderVersion);
+
     stream->readString(&mVertexHLSL);
     stream->readInt(&mVertexWorkarounds);
     stream->readString(&mPixelHLSL);
     stream->readInt(&mPixelWorkarounds);
     stream->readBool(&mUsesFragDepth);
+    stream->readBool(&mUsesPointSize);
 
     const size_t pixelShaderKeySize = stream->readInt<unsigned int>();
     mPixelShaderKey.resize(pixelShaderKeySize);
@@ -72,11 +92,14 @@
 
 bool ProgramD3D::save(gl::BinaryOutputStream *stream)
 {
+    stream->writeInt(mShaderVersion);
+
     stream->writeString(mVertexHLSL);
     stream->writeInt(mVertexWorkarounds);
     stream->writeString(mPixelHLSL);
     stream->writeInt(mPixelWorkarounds);
     stream->writeInt(mUsesFragDepth);
+    stream->writeInt(mUsesPointSize);
 
     const std::vector<rx::PixelShaderOutputVariable> &pixelShaderKey = mPixelShaderKey;
     stream->writeInt(pixelShaderKey.size());
@@ -125,6 +148,22 @@
     return vertexExecutable;
 }
 
+rx::ShaderExecutable *ProgramD3D::getGeometryExecutable(gl::InfoLog &infoLog, gl::Shader *fragmentShader, gl::Shader *vertexShader,
+                                                        const std::vector<gl::LinkedVarying> &transformFeedbackLinkedVaryings,
+                                                        bool separatedOutputBuffers, int registers)
+{
+    rx::ShaderD3D *vertexShaderD3D = rx::ShaderD3D::makeShaderD3D(vertexShader->getImplementation());
+    rx::ShaderD3D *fragmentShaderD3D = rx::ShaderD3D::makeShaderD3D(fragmentShader->getImplementation());
+
+    std::string geometryHLSL = mDynamicHLSL->generateGeometryShaderHLSL(registers, fragmentShaderD3D, vertexShaderD3D);
+
+    rx::ShaderExecutable *geometryExecutable = mRenderer->compileToExecutable(infoLog, geometryHLSL.c_str(),
+                                                                              rx::SHADER_GEOMETRY, transformFeedbackLinkedVaryings,
+                                                                              separatedOutputBuffers, rx::ANGLE_D3D_WORKAROUND_NONE);
+
+    return geometryExecutable;
+}
+
 bool ProgramD3D::link(gl::InfoLog &infoLog, gl::Shader *fragmentShader, gl::Shader *vertexShader,
                       const std::vector<std::string> &transformFeedbackVaryings, int *registers,
                       std::vector<gl::LinkedVarying> *linkedVaryings, std::map<int, gl::VariableLocation> *outputVariables)
@@ -137,6 +176,7 @@
 
     mVertexHLSL = vertexShaderD3D->getTranslatedSource();
     mVertexWorkarounds = vertexShaderD3D->getD3DWorkarounds();
+    mShaderVersion = vertexShaderD3D->getShaderVersion();
 
     // Map the varyings to the register file
     rx::VaryingPacking packing = { NULL };
@@ -159,9 +199,16 @@
         return false;
     }
 
+    mUsesPointSize = vertexShaderD3D->usesPointSize();
+
     return true;
 }
 
+void ProgramD3D::getInputLayoutSignature(const gl::VertexFormat inputLayout[], GLenum signature[]) const
+{
+    mDynamicHLSL->getInputLayoutSignature(inputLayout, signature);
+}
+
 void ProgramD3D::initializeUniformStorage(const std::vector<gl::LinkedUniform*> &uniforms)
 {
     // Compute total default block size
@@ -192,11 +239,13 @@
 {
     mVertexHLSL.clear();
     mVertexWorkarounds = rx::ANGLE_D3D_WORKAROUND_NONE;
+    mShaderVersion = 100;
 
     mPixelHLSL.clear();
     mPixelWorkarounds = rx::ANGLE_D3D_WORKAROUND_NONE;
     mUsesFragDepth = false;
     mPixelShaderKey.clear();
+    mUsesPointSize = false;
 
     SafeDelete(mVertexUniformStorage);
     SafeDelete(mFragmentUniformStorage);