Skip to content

A
angle
Commit 83f349ea by Jamie Madill
Options

Remove CompilerImpl and merge code to gl::Compiler.

This class uses no Impl-specific code. We can also do a similar code relocation for the gl::Shader class, but in several steps because it is a bit more complex. BUG=angleproject:1159 Change-Id: I4d3ce3253df0a2bdee1d98e46cfd4b999d86be6e Reviewed-on: https://chromium-review.googlesource.com/299874Reviewed-by: 's avatarGeoff Lang <geofflang@chromium.org> Tested-by: 's avatarJamie Madill <jmadill@chromium.org>
parent 6cbf4385
Showing with 182 additions and 289 deletions
src/libANGLE/Compiler.cpp
......@@ -7,32 +7,128 @@
// Compiler.cpp: implements the gl::Compiler class.
#include "libANGLE/Compiler.h"
#include "libANGLE/renderer/CompilerImpl.h"
#include "common/debug.h"
#include "libANGLE/Data.h"
#include "libANGLE/renderer/CompilerImpl.h"
#include "libANGLE/renderer/ImplFactory.h"
namespace gl
{
Compiler::Compiler(rx::CompilerImpl *impl)
: mCompiler(impl)
namespace
{
// Global count of active shader compiler handles. Needed to know when to call ShInitialize and
// ShFinalize.
size_t activeCompilerHandles = 0;
} // anonymous namespace
Compiler::Compiler(rx::ImplFactory *implFactory, const gl::Data &data)
: mImplementation(implFactory->createCompiler()),
mSpec(data.clientVersion > 2 ? SH_GLES3_SPEC : SH_GLES2_SPEC),
mOutputType(mImplementation->getTranslatorOutputType()),
mResources(),
mFragmentCompiler(nullptr),
mVertexCompiler(nullptr)
{
ASSERT(mCompiler);
ASSERT(data.clientVersion == 2 || data.clientVersion == 3);
const gl::Caps &caps = *data.caps;
const gl::Extensions &extensions = *data.extensions;
ShInitBuiltInResources(&mResources);
mResources.MaxVertexAttribs = caps.maxVertexAttributes;
mResources.MaxVertexUniformVectors = caps.maxVertexUniformVectors;
mResources.MaxVaryingVectors = caps.maxVaryingVectors;
mResources.MaxVertexTextureImageUnits = caps.maxVertexTextureImageUnits;
mResources.MaxCombinedTextureImageUnits = caps.maxCombinedTextureImageUnits;
mResources.MaxTextureImageUnits = caps.maxTextureImageUnits;
mResources.MaxFragmentUniformVectors = caps.maxFragmentUniformVectors;
mResources.MaxDrawBuffers = caps.maxDrawBuffers;
mResources.OES_standard_derivatives = extensions.standardDerivatives;
mResources.EXT_draw_buffers = extensions.drawBuffers;
mResources.EXT_shader_texture_lod = extensions.shaderTextureLOD;
// TODO: disabled until the extension is actually supported.
mResources.OES_EGL_image_external = 0;
// TODO: use shader precision caps to determine if high precision is supported?
mResources.FragmentPrecisionHigh = 1;
mResources.EXT_frag_depth = extensions.fragDepth;
// GLSL ES 3.0 constants
mResources.MaxVertexOutputVectors = caps.maxVertexOutputComponents / 4;
mResources.MaxFragmentInputVectors = caps.maxFragmentInputComponents / 4;
mResources.MinProgramTexelOffset = caps.minProgramTexelOffset;
mResources.MaxProgramTexelOffset = caps.maxProgramTexelOffset;
}
Compiler::~Compiler()
{
SafeDelete(mCompiler);
release();
SafeDelete(mImplementation);
}
Error Compiler::release()
{
return mCompiler->release();
if (mFragmentCompiler)
{
ShDestruct(mFragmentCompiler);
mFragmentCompiler = nullptr;
ASSERT(activeCompilerHandles > 0);
activeCompilerHandles--;
}
if (mVertexCompiler)
{
ShDestruct(mVertexCompiler);
mVertexCompiler = nullptr;
ASSERT(activeCompilerHandles > 0);
activeCompilerHandles--;
}
if (activeCompilerHandles == 0)
{
ShFinalize();
}
mImplementation->release();
return gl::Error(GL_NO_ERROR);
}
rx::CompilerImpl *Compiler::getImplementation()
ShHandle Compiler::getCompilerHandle(GLenum type)
{
return mCompiler;
}
ShHandle *compiler = nullptr;
switch (type)
{
case GL_VERTEX_SHADER:
compiler = &mVertexCompiler;
break;
case GL_FRAGMENT_SHADER:
compiler = &mFragmentCompiler;
break;
default:
UNREACHABLE();
return nullptr;
}
if (!(*compiler))
{
if (activeCompilerHandles == 0)
{
ShInitialize();
}
*compiler = ShConstructCompiler(type, mSpec, mOutputType, &mResources);
activeCompilerHandles++;
}
return *compiler;
}
} // namespace gl
src/libANGLE/Compiler.h
......@@ -11,29 +11,39 @@
#define LIBANGLE_COMPILER_H_
#include "libANGLE/Error.h"
#include "GLSLANG/ShaderLang.h"
namespace rx
{
class CompilerImpl;
class ImplFactory;
}
namespace gl
{
struct Data;
class Compiler final
class Compiler final : angle::NonCopyable
{
public:
explicit Compiler(rx::CompilerImpl *impl);
Compiler(rx::ImplFactory *implFactory, const Data &data);
~Compiler();
Error release();
rx::CompilerImpl *getImplementation();
ShHandle getCompilerHandle(GLenum type);
ShShaderOutput getShaderOutputType() const { return mOutputType; }
private:
rx::CompilerImpl *mCompiler;
rx::CompilerImpl *mImplementation;
ShShaderSpec mSpec;
ShShaderOutput mOutputType;
ShBuiltInResources mResources;
ShHandle mFragmentCompiler;
ShHandle mVertexCompiler;
};
}
} // namespace gl
#endif // LIBANGLE_COMPILER_H_
src/libANGLE/Context.cpp
......@@ -145,7 +145,7 @@ Context::Context(const egl::Config *config,
mResetStrategy = (notifyResets ? GL_LOSE_CONTEXT_ON_RESET_EXT : GL_NO_RESET_NOTIFICATION_EXT);
mRobustAccess = robustAccess;
mCompiler = new Compiler(mRenderer->createCompiler(getData()));
mCompiler = new Compiler(mRenderer, getData());
}
Context::~Context()
......
src/libANGLE/renderer/CompilerImpl.h
......@@ -8,6 +8,7 @@
// for the gl::Compiler object.
#include "common/angleutils.h"
#include "GLSLANG/ShaderLang.h"
#include "libANGLE/Error.h"
#ifndef LIBANGLE_RENDERER_COMPILERIMPL_H_
......@@ -23,6 +24,9 @@ class CompilerImpl : angle::NonCopyable
virtual ~CompilerImpl() {}
virtual gl::Error release() = 0;
// TODO(jmadill): Expose translator built-in resources init method.
virtual ShShaderOutput getTranslatorOutputType() const = 0;
};
}
......
src/libANGLE/renderer/ImplFactory.h
......@@ -36,7 +36,7 @@ class ImplFactory : angle::NonCopyable
virtual ~ImplFactory() {}
// Shader creation
virtual CompilerImpl *createCompiler(const gl::Data &data) = 0;
virtual CompilerImpl *createCompiler() = 0;
virtual ShaderImpl *createShader(GLenum type) = 0;
virtual ProgramImpl *createProgram(const gl::Program::Data &data) = 0;
......
src/libANGLE/renderer/d3d/CompilerD3D.cpp
//
// Copyright (c) 2014 The ANGLE Project Authors. All rights reserved.
// Copyright 2015 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// CompilerD3D.cpp: Implementation of the rx::CompilerD3D class.
// CompilerGL:
// Implementation of the D3D compiler methods.
//
#include "libANGLE/renderer/d3d/CompilerD3D.h"
#include "libANGLE/Caps.h"
#include "libANGLE/Data.h"
#include "common/debug.h"
namespace rx
{
// Global count of active shader compiler handles. Needed to know when to call ShInitialize and ShFinalize.
static size_t activeCompilerHandles = 0;
CompilerD3D::CompilerD3D(const gl::Data &data, ShShaderOutput outputType)
: mSpec(data.clientVersion > 2 ? SH_GLES3_SPEC : SH_GLES2_SPEC),
mOutputType(outputType),
mResources(),
mFragmentCompiler(NULL),
mVertexCompiler(NULL)
namespace
{
ASSERT(data.clientVersion == 2 || data.clientVersion == 3);
const gl::Caps &caps = *data.caps;
const gl::Extensions &extensions = *data.extensions;
ShInitBuiltInResources(&mResources);
mResources.MaxVertexAttribs = caps.maxVertexAttributes;
mResources.MaxVertexUniformVectors = caps.maxVertexUniformVectors;
mResources.MaxVaryingVectors = caps.maxVaryingVectors;
mResources.MaxVertexTextureImageUnits = caps.maxVertexTextureImageUnits;
mResources.MaxCombinedTextureImageUnits = caps.maxCombinedTextureImageUnits;
mResources.MaxTextureImageUnits = caps.maxTextureImageUnits;
mResources.MaxFragmentUniformVectors = caps.maxFragmentUniformVectors;
mResources.MaxDrawBuffers = caps.maxDrawBuffers;
mResources.OES_standard_derivatives = extensions.standardDerivatives;
mResources.EXT_draw_buffers = extensions.drawBuffers;
mResources.EXT_shader_texture_lod = 1;
// resources.OES_EGL_image_external = mRenderer->getShareHandleSupport() ? 1 : 0; // TODO: commented out until the extension is actually supported.
mResources.FragmentPrecisionHigh = 1; // Shader Model 2+ always supports FP24 (s16e7) which corresponds to highp
mResources.EXT_frag_depth = 1; // Shader Model 2+ always supports explicit depth output
// GLSL ES 3.0 constants
mResources.MaxVertexOutputVectors = caps.maxVertexOutputComponents / 4;
mResources.MaxFragmentInputVectors = caps.maxFragmentInputComponents / 4;
mResources.MinProgramTexelOffset = caps.minProgramTexelOffset;
mResources.MaxProgramTexelOffset = caps.maxProgramTexelOffset;
}
CompilerD3D::~CompilerD3D()
{
release();
}
gl::Error CompilerD3D::release()
ShShaderOutput GetShaderOutputType(RendererClass rendererClass)
{
if (mFragmentCompiler)
{
ShDestruct(mFragmentCompiler);
mFragmentCompiler = NULL;
ASSERT(activeCompilerHandles > 0);
activeCompilerHandles--;
}
if (mVertexCompiler)
if (rendererClass == RENDERER_D3D11)
{
ShDestruct(mVertexCompiler);
mVertexCompiler = NULL;
ASSERT(activeCompilerHandles > 0);
activeCompilerHandles--;
return SH_HLSL11_OUTPUT;
}
if (activeCompilerHandles == 0)
else
{
ShFinalize();
ASSERT(rendererClass == RENDERER_D3D9);
return SH_HLSL9_OUTPUT;
}
return gl::Error(GL_NO_ERROR);
}
ShHandle CompilerD3D::getCompilerHandle(GLenum type)
{
ShHandle *compiler = NULL;
switch (type)
{
case GL_VERTEX_SHADER:
compiler = &mVertexCompiler;
break;
} // anonymous namespace
case GL_FRAGMENT_SHADER:
compiler = &mFragmentCompiler;
break;
default:
UNREACHABLE();
return NULL;
}
if (!(*compiler))
{
if (activeCompilerHandles == 0)
{
ShInitialize();
}
*compiler = ShConstructCompiler(type, mSpec, mOutputType, &mResources);
activeCompilerHandles++;
}
return *compiler;
CompilerD3D::CompilerD3D(RendererClass rendererClass)
: mTranslatorOutputType(GetShaderOutputType(rendererClass))
{
}
}
} // namespace rx
src/libANGLE/renderer/d3d/CompilerD3D.h
......@@ -10,14 +10,7 @@
#define LIBANGLE_RENDERER_COMPILERD3D_H_
#include "libANGLE/renderer/CompilerImpl.h"
#include "libANGLE/Caps.h"
#include "GLSLANG/ShaderLang.h"
namespace gl
{
struct Data;
}
#include "libANGLE/renderer/d3d/RendererD3D.h"
namespace rx
{
......@@ -25,20 +18,14 @@ namespace rx
class CompilerD3D : public CompilerImpl
{
public:
CompilerD3D(const gl::Data &data, ShShaderOutput outputType);
virtual ~CompilerD3D();
gl::Error release() override;
CompilerD3D(RendererClass rendererClass);
~CompilerD3D() override {}
ShHandle getCompilerHandle(GLenum type);
gl::Error release() override { return gl::Error(GL_NO_ERROR); }
ShShaderOutput getTranslatorOutputType() const override { return mTranslatorOutputType; }
private:
ShShaderSpec mSpec;
ShShaderOutput mOutputType;
ShBuiltInResources mResources;
ShHandle mFragmentCompiler;
ShHandle mVertexCompiler;
ShShaderOutput mTranslatorOutputType;
};
}
......
src/libANGLE/renderer/d3d/RendererD3D.cpp
......@@ -19,6 +19,7 @@
#include "libANGLE/VertexArray.h"
#include "libANGLE/formatutils.h"
#include "libANGLE/renderer/d3d/BufferD3D.h"
#include "libANGLE/renderer/d3d/CompilerD3D.h"
#include "libANGLE/renderer/d3d/DisplayD3D.h"
#include "libANGLE/renderer/d3d/IndexDataManager.h"
#include "libANGLE/renderer/d3d/ProgramD3D.h"
......@@ -33,7 +34,7 @@ namespace
// degenerate case where we are stuck hogging memory.
const int ScratchMemoryBufferLifetime = 1000;
}
} // anonymous namespace
const uintptr_t RendererD3D::DirtyPointer = std::numeric_limits<uintptr_t>::max();
......@@ -67,6 +68,11 @@ void RendererD3D::cleanup()
}
}
CompilerImpl *RendererD3D::createCompiler()
{
return new CompilerD3D(getRendererClass());
}
gl::Error RendererD3D::drawArrays(const gl::Data &data, GLenum mode, GLint first, GLsizei count)
{
return genericDrawArrays(data, mode, first, count, 0);
......
src/libANGLE/renderer/d3d/RendererD3D.h
......@@ -129,6 +129,8 @@ class RendererD3D : public Renderer, public BufferFactoryD3D
bool isDeviceLost() const override;
std::string getVendorString() const override;
CompilerImpl *createCompiler() override;
virtual int getMinorShaderModel() const = 0;
virtual std::string getShaderModelSuffix() const = 0;
......
src/libANGLE/renderer/d3d/ShaderD3D.cpp
......@@ -6,14 +6,13 @@
// ShaderD3D.cpp: Defines the rx::ShaderD3D class which implements rx::ShaderImpl.
#include "libANGLE/Shader.h"
#include "libANGLE/Compiler.h"
#include "libANGLE/renderer/d3d/RendererD3D.h"
#include "libANGLE/renderer/d3d/ShaderD3D.h"
#include "libANGLE/renderer/d3d/CompilerD3D.h"
#include "libANGLE/features.h"
#include "common/utilities.h"
#include "libANGLE/Compiler.h"
#include "libANGLE/Shader.h"
#include "libANGLE/features.h"
#include "libANGLE/renderer/d3d/RendererD3D.h"
// Definitions local to the translation unit
namespace
......@@ -321,8 +320,7 @@ bool ShaderD3D::compile(gl::Compiler *compiler, const std::string &source)
{
uncompile();
CompilerD3D *compilerD3D = GetImplAs<CompilerD3D>(compiler);
ShHandle compilerHandle = compilerD3D->getCompilerHandle(mShaderType);
ShHandle compilerHandle = compiler->getCompilerHandle(mShaderType);
mCompilerOutputType = ShGetShaderOutputType(compilerHandle);
......
src/libANGLE/renderer/d3d/d3d11/Renderer11.cpp
......@@ -22,7 +22,6 @@
#include "libANGLE/Surface.h"
#include "libANGLE/formatutils.h"
#include "libANGLE/histogram_macros.h"
#include "libANGLE/renderer/d3d/CompilerD3D.h"
#include "libANGLE/renderer/d3d/FramebufferD3D.h"
#include "libANGLE/renderer/d3d/IndexDataManager.h"
#include "libANGLE/renderer/d3d/ProgramD3D.h"
......@@ -3004,11 +3003,6 @@ FramebufferImpl *Renderer11::createFramebuffer(const gl::Framebuffer::Data &data
return new Framebuffer11(data, this);
}
CompilerImpl *Renderer11::createCompiler(const gl::Data &data)
{
return new CompilerD3D(data, SH_HLSL11_OUTPUT);
}
ShaderImpl *Renderer11::createShader(GLenum type)
{
return new ShaderD3D(type, this);
......
src/libANGLE/renderer/d3d/d3d11/Renderer11.h
......@@ -182,7 +182,6 @@ class Renderer11 : public RendererD3D
FramebufferImpl *createFramebuffer(const gl::Framebuffer::Data &data) override;
// Shader creation
virtual CompilerImpl *createCompiler(const gl::Data &data);
virtual ShaderImpl *createShader(GLenum type);
virtual ProgramImpl *createProgram(const gl::Program::Data &data);
......
src/libANGLE/renderer/d3d/d3d9/Renderer9.cpp
......@@ -21,7 +21,6 @@
#include "libANGLE/angletypes.h"
#include "libANGLE/features.h"
#include "libANGLE/formatutils.h"
#include "libANGLE/renderer/d3d/CompilerD3D.h"
#include "libANGLE/renderer/d3d/FramebufferD3D.h"
#include "libANGLE/renderer/d3d/IndexDataManager.h"
#include "libANGLE/renderer/d3d/ProgramD3D.h"
......@@ -2714,11 +2713,6 @@ FramebufferImpl *Renderer9::createFramebuffer(const gl::Framebuffer::Data &data)
return new Framebuffer9(data, this);
}
CompilerImpl *Renderer9::createCompiler(const gl::Data &data)
{
return new CompilerD3D(data, SH_HLSL9_OUTPUT);
}
ShaderImpl *Renderer9::createShader(GLenum type)
{
return new ShaderD3D(type, this);
......
src/libANGLE/renderer/d3d/d3d9/Renderer9.h
......@@ -169,7 +169,6 @@ class Renderer9 : public RendererD3D
FramebufferImpl *createFramebuffer(const gl::Framebuffer::Data &data) override;
// Shader creation
virtual CompilerImpl *createCompiler(const gl::Data &data);
virtual ShaderImpl *createShader(GLenum type);
virtual ProgramImpl *createProgram(const gl::Program::Data &data);
......
src/libANGLE/renderer/gl/CompilerGL.cpp
......@@ -3,23 +3,21 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// CompilerGL.cpp: Implements the class methods for CompilerGL.
// CompilerGL:
// Implementation of the GL compiler methods.
//
#include "libANGLE/renderer/gl/CompilerGL.h"
#include "common/debug.h"
#include "libANGLE/Caps.h"
#include "libANGLE/Data.h"
#include "libANGLE/renderer/gl/FunctionsGL.h"
namespace rx
{
// Global count of active shader compiler handles. Needed to know when to call ShInitialize and ShFinalize.
static size_t activeCompilerHandles = 0;
namespace
{
static ShShaderOutput GetShaderOutputType(const FunctionsGL *functions)
ShShaderOutput GetShaderOutputType(const FunctionsGL *functions)
{
ASSERT(functions);
......@@ -83,105 +81,11 @@ static ShShaderOutput GetShaderOutputType(const FunctionsGL *functions)
}
}
CompilerGL::CompilerGL(const gl::Data &data, const FunctionsGL *functions)
: CompilerImpl(),
mSpec(data.clientVersion > 2 ? SH_GLES3_SPEC : SH_GLES2_SPEC),
mOutputType(GetShaderOutputType(functions)),
mResources(),
mFragmentCompiler(nullptr),
mVertexCompiler(nullptr)
{
ASSERT(data.clientVersion == 2 || data.clientVersion == 3);
const gl::Caps &caps = *data.caps;
const gl::Extensions &extensions = *data.extensions;
ShInitBuiltInResources(&mResources);
mResources.MaxVertexAttribs = caps.maxVertexAttributes;
mResources.MaxVertexUniformVectors = caps.maxVertexUniformVectors;
mResources.MaxVaryingVectors = caps.maxVaryingVectors;
mResources.MaxVertexTextureImageUnits = caps.maxVertexTextureImageUnits;
mResources.MaxCombinedTextureImageUnits = caps.maxCombinedTextureImageUnits;
mResources.MaxTextureImageUnits = caps.maxTextureImageUnits;
mResources.MaxFragmentUniformVectors = caps.maxFragmentUniformVectors;
mResources.MaxDrawBuffers = caps.maxDrawBuffers;
mResources.OES_standard_derivatives = extensions.standardDerivatives;
mResources.EXT_draw_buffers = extensions.drawBuffers;
mResources.EXT_shader_texture_lod = extensions.shaderTextureLOD;
mResources.OES_EGL_image_external = 0; // TODO: disabled until the extension is actually supported.
mResources.FragmentPrecisionHigh = 1; // TODO: use shader precision caps to determine if high precision is supported?
mResources.EXT_frag_depth = extensions.fragDepth;
// GLSL ES 3.0 constants
mResources.MaxVertexOutputVectors = caps.maxVertexOutputComponents / 4;
mResources.MaxFragmentInputVectors = caps.maxFragmentInputComponents / 4;
mResources.MinProgramTexelOffset = caps.minProgramTexelOffset;
mResources.MaxProgramTexelOffset = caps.maxProgramTexelOffset;
}
CompilerGL::~CompilerGL()
{
release();
}
gl::Error CompilerGL::release()
{
if (mFragmentCompiler)
{
ShDestruct(mFragmentCompiler);
mFragmentCompiler = NULL;
ASSERT(activeCompilerHandles > 0);
activeCompilerHandles--;
}
if (mVertexCompiler)
{
ShDestruct(mVertexCompiler);
mVertexCompiler = NULL;
ASSERT(activeCompilerHandles > 0);
activeCompilerHandles--;
}
if (activeCompilerHandles == 0)
{
ShFinalize();
}
return gl::Error(GL_NO_ERROR);
}
} // anonymous namespace
ShHandle CompilerGL::getCompilerHandle(GLenum type)
CompilerGL::CompilerGL(const FunctionsGL *functions)
: mTranslatorOutputType(GetShaderOutputType(functions))
{
ShHandle *compiler = NULL;
switch (type)
{
case GL_VERTEX_SHADER:
compiler = &mVertexCompiler;
break;
case GL_FRAGMENT_SHADER:
compiler = &mFragmentCompiler;
break;
default:
UNREACHABLE();
return NULL;
}
if ((*compiler) == nullptr)
{
if (activeCompilerHandles == 0)
{
ShInitialize();
}
*compiler = ShConstructCompiler(type, mSpec, mOutputType, &mResources);
activeCompilerHandles++;
}
return *compiler;
}
}
} // namespace rx
src/libANGLE/renderer/gl/CompilerGL.h
......@@ -11,35 +11,21 @@
#include "libANGLE/renderer/CompilerImpl.h"
#include "GLSLANG/ShaderLang.h"
namespace gl
{
struct Data;
}
namespace rx
{
class FunctionsGL;
class CompilerGL : public CompilerImpl
{
public:
CompilerGL(const gl::Data &data, const FunctionsGL *functions);
~CompilerGL() override;
gl::Error release() override;
CompilerGL(const FunctionsGL *functions);
~CompilerGL() override {}
ShHandle getCompilerHandle(GLenum type);
gl::Error release() override { return gl::Error(GL_NO_ERROR); }
ShShaderOutput getTranslatorOutputType() const { return mTranslatorOutputType; }
private:
ShShaderSpec mSpec;
ShShaderOutput mOutputType;
ShBuiltInResources mResources;
ShHandle mFragmentCompiler;
ShHandle mVertexCompiler;
ShShaderOutput mTranslatorOutputType;
};
}
......
src/libANGLE/renderer/gl/RendererGL.cpp
......@@ -237,9 +237,9 @@ gl::Error RendererGL::drawRangeElements(const gl::Data &data,
return gl::Error(GL_NO_ERROR);
}
CompilerImpl *RendererGL::createCompiler(const gl::Data &data)
CompilerImpl *RendererGL::createCompiler()
{
return new CompilerGL(data, mFunctions);
return new CompilerGL(mFunctions);
}
ShaderImpl *RendererGL::createShader(GLenum type)
......
src/libANGLE/renderer/gl/RendererGL.h
......@@ -58,7 +58,7 @@ class RendererGL : public Renderer
const gl::IndexRange &indexRange) override;
// Shader creation
CompilerImpl *createCompiler(const gl::Data &data) override;
CompilerImpl *createCompiler() override;
ShaderImpl *createShader(GLenum type) override;
ProgramImpl *createProgram(const gl::Program::Data &data) override;
......
src/libANGLE/renderer/gl/ShaderGL.cpp
......@@ -10,7 +10,6 @@
#include "common/debug.h"
#include "libANGLE/Compiler.h"
#include "libANGLE/renderer/gl/CompilerGL.h"
#include "libANGLE/renderer/gl/FunctionsGL.h"
template <typename VarT>
......@@ -72,8 +71,7 @@ bool ShaderGL::compile(gl::Compiler *compiler, const std::string &source)
}
// Translate the ESSL into GLSL
CompilerGL *compilerGL = GetImplAs<CompilerGL>(compiler);
ShHandle compilerHandle = compilerGL->getCompilerHandle(mType);
ShHandle compilerHandle = compiler->getCompilerHandle(mType);
int compileOptions = (SH_OBJECT_CODE | SH_VARIABLES | SH_INIT_GL_POSITION);
const char* sourceCString = source.c_str();
......
src/tests/angle_unittests_utils.h
......@@ -21,7 +21,7 @@ class NullFactory : public ImplFactory
NullFactory() {}
// Shader creation
CompilerImpl *createCompiler(const gl::Data &data) override { return nullptr; }
CompilerImpl *createCompiler() override { return nullptr; }
ShaderImpl *createShader(GLenum type) override { return nullptr; }
ProgramImpl *createProgram(const gl::Program::Data &data) override { return nullptr; }
......
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