src/gpu/glsl/GrGLSLProgramBuilder.cpp - platform/external/skia - Gitiles

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */

 #include "glsl/GrGLSLProgramBuilder.h"

 #include "GrPipeline.h"
 #include "glsl/GrGLSLFragmentProcessor.h"
 #include "glsl/GrGLSLGeometryProcessor.h"
 #include "glsl/GrGLSLXferProcessor.h"

 const int GrGLSLProgramBuilder::kVarsPerBlock = 8;

 GrGLSLProgramBuilder::GrGLSLProgramBuilder(const DrawArgs& args)
     : fVS(this)
     , fGS(this)
     , fFS(this, args.fDesc->header().fFragPosKey)
     , fStageIndex(-1)
     , fArgs(args)
     , fGeometryProcessor(nullptr)
     , fXferProcessor(nullptr) {
 }

 bool GrGLSLProgramBuilder::emitAndInstallProcs(GrGLSLExpr4* inputColor,
                                                GrGLSLExpr4* inputCoverage,
                                                int maxTextures) {
     // First we loop over all of the installed processors and collect coord transforms.  These will
     // be sent to the GrGLSLPrimitiveProcessor in its emitCode function
     const GrPrimitiveProcessor& primProc = this->primitiveProcessor();
     int totalTextures = primProc.numTextures();

     for (int i = 0; i < this->pipeline().numFragmentProcessors(); i++) {
         const GrFragmentProcessor& processor = this->pipeline().getFragmentProcessor(i);

         if (!primProc.hasTransformedLocalCoords()) {
             SkTArray<const GrCoordTransform*, true>& procCoords = fCoordTransforms.push_back();
             processor.gatherCoordTransforms(&procCoords);
         }

         totalTextures += processor.numTextures();
         if (totalTextures >= maxTextures) {
             GrCapsDebugf(this->caps(), "Program would use too many texture units\n");
             return false;
         }
     }

     this->emitAndInstallPrimProc(primProc, inputColor, inputCoverage);

     int numProcs = this->pipeline().numFragmentProcessors();
     this->emitAndInstallFragProcs(0, this->pipeline().numColorFragmentProcessors(), inputColor);
     this->emitAndInstallFragProcs(this->pipeline().numColorFragmentProcessors(), numProcs,
                                   inputCoverage);
     if (primProc.getPixelLocalStorageState() !=
         GrPixelLocalStorageState::kDraw_GrPixelLocalStorageState) {
         this->emitAndInstallXferProc(this->pipeline().getXferProcessor(), *inputColor,
                                      *inputCoverage, this->pipeline().ignoresCoverage(),
                                      primProc.getPixelLocalStorageState());
         this->emitFSOutputSwizzle(this->pipeline().getXferProcessor().hasSecondaryOutput());
     }
     return true;
 }

 void GrGLSLProgramBuilder::emitAndInstallPrimProc(const GrPrimitiveProcessor& proc,
                                                   GrGLSLExpr4* outputColor,
                                                   GrGLSLExpr4* outputCoverage) {
     // Program builders have a bit of state we need to clear with each effect
     AutoStageAdvance adv(this);
     this->nameExpression(outputColor, "outputColor");
     this->nameExpression(outputCoverage, "outputCoverage");

     // Enclose custom code in a block to avoid namespace conflicts
     SkString openBrace;
     openBrace.printf("{ // Stage %d, %s\n", fStageIndex, proc.name());
     fFS.codeAppend(openBrace.c_str());
     fVS.codeAppendf("// Primitive Processor %s\n", proc.name());

     SkASSERT(!fGeometryProcessor);
     fGeometryProcessor = proc.createGLSLInstance(*this->glslCaps());

     SkSTArray<4, GrGLSLTextureSampler> samplers(proc.numTextures());
     this->emitSamplers(proc, &samplers);

     GrGLSLGeometryProcessor::EmitArgs args(&fVS,
                                            &fFS,
                                            this->varyingHandler(),
                                            this->uniformHandler(),
                                            this->glslCaps(),
                                            proc,
                                            outputColor->c_str(),
                                            outputCoverage->c_str(),
                                            samplers,
                                            fCoordTransforms,
                                            &fOutCoords);
     fGeometryProcessor->emitCode(args);

     // We have to check that effects and the code they emit are consistent, ie if an effect
     // asks for dst color, then the emit code needs to follow suit
     verify(proc);

     fFS.codeAppend("}");
 }

 void GrGLSLProgramBuilder::emitAndInstallFragProcs(int procOffset,
                                                    int numProcs,
                                                    GrGLSLExpr4* inOut) {
     for (int i = procOffset; i < numProcs; ++i) {
         GrGLSLExpr4 output;
         const GrFragmentProcessor& fp = this->pipeline().getFragmentProcessor(i);
         this->emitAndInstallFragProc(fp, i, *inOut, &output);
         *inOut = output;
     }
 }

 // TODO Processors cannot output zeros because an empty string is all 1s
 // the fix is to allow effects to take the GrGLSLExpr4 directly
 void GrGLSLProgramBuilder::emitAndInstallFragProc(const GrFragmentProcessor& fp,
                                                   int index,
                                                   const GrGLSLExpr4& input,
                                                   GrGLSLExpr4* output) {
     // Program builders have a bit of state we need to clear with each effect
     AutoStageAdvance adv(this);
     this->nameExpression(output, "output");

     // Enclose custom code in a block to avoid namespace conflicts
     SkString openBrace;
     openBrace.printf("{ // Stage %d, %s\n", fStageIndex, fp.name());
     fFS.codeAppend(openBrace.c_str());

     GrGLSLFragmentProcessor* fragProc = fp.createGLSLInstance();

     SkSTArray<4, GrGLSLTextureSampler> samplers(fp.numTextures());
     this->emitSamplers(fp, &samplers);

     GrGLSLFragmentProcessor::EmitArgs args(&fFS,
                                            this->uniformHandler(),
                                            this->glslCaps(),
                                            fp,
                                            output->c_str(),
                                            input.isOnes() ? nullptr : input.c_str(),
                                            fOutCoords[index],
                                            samplers);
     fragProc->emitCode(args);

     // We have to check that effects and the code they emit are consistent, ie if an effect
     // asks for dst color, then the emit code needs to follow suit
     verify(fp);
     fFragmentProcessors.push_back(fragProc);

     fFS.codeAppend("}");
 }

 void GrGLSLProgramBuilder::emitAndInstallXferProc(const GrXferProcessor& xp,
                                                   const GrGLSLExpr4& colorIn,
                                                   const GrGLSLExpr4& coverageIn,
                                                   bool ignoresCoverage,
                                                   GrPixelLocalStorageState plsState) {
     // Program builders have a bit of state we need to clear with each effect
     AutoStageAdvance adv(this);

     SkASSERT(!fXferProcessor);
     fXferProcessor = xp.createGLSLInstance();

     // Enable dual source secondary output if we have one
     if (xp.hasSecondaryOutput()) {
         fFS.enableSecondaryOutput();
     }

     if (this->glslCaps()->mustDeclareFragmentShaderOutput()) {
         fFS.enableCustomOutput();
     }

     SkString openBrace;
     openBrace.printf("{ // Xfer Processor: %s\n", xp.name());
     fFS.codeAppend(openBrace.c_str());

     SkSTArray<4, GrGLSLTextureSampler> samplers(xp.numTextures());
     this->emitSamplers(xp, &samplers);

     bool usePLSDstRead = (plsState == GrPixelLocalStorageState::kFinish_GrPixelLocalStorageState);
     GrGLSLXferProcessor::EmitArgs args(&fFS,
                                        this->uniformHandler(),
                                        this->glslCaps(),
                                        xp, colorIn.c_str(),
                                        ignoresCoverage ? nullptr : coverageIn.c_str(),
                                        fFS.getPrimaryColorOutputName(),
                                        fFS.getSecondaryColorOutputName(),
                                        samplers,
                                        usePLSDstRead);
     fXferProcessor->emitCode(args);

     // We have to check that effects and the code they emit are consistent, ie if an effect
     // asks for dst color, then the emit code needs to follow suit
     verify(xp);
     fFS.codeAppend("}");
 }

 void GrGLSLProgramBuilder::emitFSOutputSwizzle(bool hasSecondaryOutput) {
     // Swizzle the fragment shader outputs if necessary.
     GrSwizzle swizzle;
     swizzle.setFromKey(this->desc().header().fOutputSwizzle);
     if (swizzle != GrSwizzle::RGBA()) {
         fFS.codeAppendf("%s = %s.%s;", fFS.getPrimaryColorOutputName(),
                         fFS.getPrimaryColorOutputName(),
                         swizzle.c_str());
         if (hasSecondaryOutput) {
             fFS.codeAppendf("%s = %s.%s;", fFS.getSecondaryColorOutputName(),
                             fFS.getSecondaryColorOutputName(),
                             swizzle.c_str());
         }
     }
 }

 void GrGLSLProgramBuilder::verify(const GrPrimitiveProcessor& gp) {
     SkASSERT(fFS.hasReadFragmentPosition() == gp.willReadFragmentPosition());
 }

 void GrGLSLProgramBuilder::verify(const GrXferProcessor& xp) {
     SkASSERT(fFS.hasReadDstColor() == xp.willReadDstColor());
 }

 void GrGLSLProgramBuilder::verify(const GrFragmentProcessor& fp) {
     SkASSERT(fFS.hasReadFragmentPosition() == fp.willReadFragmentPosition());
 }

 void GrGLSLProgramBuilder::nameVariable(SkString* out, char prefix, const char* name, bool mangle) {
     if ('\0' == prefix) {
         *out = name;
     } else {
         out->printf("%c%s", prefix, name);
     }
     if (mangle) {
         if (out->endsWith('_')) {
             // Names containing "__" are reserved.
             out->append("x");
         }
         out->appendf("_Stage%d%s", fStageIndex, fFS.getMangleString().c_str());
     }
 }

 void GrGLSLProgramBuilder::nameExpression(GrGLSLExpr4* output, const char* baseName) {
     // create var to hold stage result.  If we already have a valid output name, just use that
     // otherwise create a new mangled one.  This name is only valid if we are reordering stages
     // and have to tell stage exactly where to put its output.
     SkString outName;
     if (output->isValid()) {
         outName = output->c_str();
     } else {
         this->nameVariable(&outName, '\0', baseName);
     }
     fFS.codeAppendf("vec4 %s;", outName.c_str());
     *output = outName;
 }

 void GrGLSLProgramBuilder::appendUniformDecls(ShaderVisibility visibility,
                                               SkString* out) const {
     this->uniformHandler()->appendUniformDecls(visibility, out);
 }

 void GrGLSLProgramBuilder::addRTAdjustmentUniform(GrSLPrecision precision,
                                                   const char* name,
                                                   const char** outName) {
         SkASSERT(!fUniformHandles.fRTAdjustmentUni.isValid());
         fUniformHandles.fRTAdjustmentUni =
             this->uniformHandler()->addUniform(GrGLSLUniformHandler::kVertex_Visibility,
                                                kVec4f_GrSLType,
                                                precision,
                                                name,
                                                outName);
 }

 void GrGLSLProgramBuilder::addRTHeightUniform(const char* name, const char** outName) {
         SkASSERT(!fUniformHandles.fRTHeightUni.isValid());
         GrGLSLUniformHandler* uniformHandler = this->uniformHandler();
         fUniformHandles.fRTHeightUni =
             uniformHandler->internalAddUniformArray(GrGLSLUniformHandler::kFragment_Visibility,
                                                     kFloat_GrSLType, kDefault_GrSLPrecision,
                                                     name, false, 0, outName);
 }

 void GrGLSLProgramBuilder::cleanupFragmentProcessors() {
     for (int i = 0; i < fFragmentProcessors.count(); ++i) {
         delete fFragmentProcessors[i];
     }
 }
	/*
	* Copyright 2015 Google Inc.
	*
	* Use of this source code is governed by a BSD-style license that can be
	* found in the LICENSE file.
	*/

	#include "glsl/GrGLSLProgramBuilder.h"

	#include "GrPipeline.h"
	#include "glsl/GrGLSLFragmentProcessor.h"
	#include "glsl/GrGLSLGeometryProcessor.h"
	#include "glsl/GrGLSLXferProcessor.h"

	const int GrGLSLProgramBuilder::kVarsPerBlock = 8;

	GrGLSLProgramBuilder::GrGLSLProgramBuilder(const DrawArgs& args)
	: fVS(this)
	, fGS(this)
	, fFS(this, args.fDesc->header().fFragPosKey)
	, fStageIndex(-1)
	, fArgs(args)
	, fGeometryProcessor(nullptr)
	, fXferProcessor(nullptr) {
	}

	bool GrGLSLProgramBuilder::emitAndInstallProcs(GrGLSLExpr4* inputColor,
	GrGLSLExpr4* inputCoverage,
	int maxTextures) {
	// First we loop over all of the installed processors and collect coord transforms. These will
	// be sent to the GrGLSLPrimitiveProcessor in its emitCode function
	const GrPrimitiveProcessor& primProc = this->primitiveProcessor();
	int totalTextures = primProc.numTextures();

	for (int i = 0; i < this->pipeline().numFragmentProcessors(); i++) {
	const GrFragmentProcessor& processor = this->pipeline().getFragmentProcessor(i);

	if (!primProc.hasTransformedLocalCoords()) {
	SkTArray<const GrCoordTransform*, true>& procCoords = fCoordTransforms.push_back();
	processor.gatherCoordTransforms(&procCoords);
	}

	totalTextures += processor.numTextures();
	if (totalTextures >= maxTextures) {
	GrCapsDebugf(this->caps(), "Program would use too many texture units\n");
	return false;
	}
	}

	this->emitAndInstallPrimProc(primProc, inputColor, inputCoverage);

	int numProcs = this->pipeline().numFragmentProcessors();
	this->emitAndInstallFragProcs(0, this->pipeline().numColorFragmentProcessors(), inputColor);
	this->emitAndInstallFragProcs(this->pipeline().numColorFragmentProcessors(), numProcs,
	inputCoverage);
	if (primProc.getPixelLocalStorageState() !=
	GrPixelLocalStorageState::kDraw_GrPixelLocalStorageState) {
	this->emitAndInstallXferProc(this->pipeline().getXferProcessor(), *inputColor,
	*inputCoverage, this->pipeline().ignoresCoverage(),
	primProc.getPixelLocalStorageState());
	this->emitFSOutputSwizzle(this->pipeline().getXferProcessor().hasSecondaryOutput());
	}
	return true;
	}

	void GrGLSLProgramBuilder::emitAndInstallPrimProc(const GrPrimitiveProcessor& proc,
	GrGLSLExpr4* outputColor,
	GrGLSLExpr4* outputCoverage) {
	// Program builders have a bit of state we need to clear with each effect
	AutoStageAdvance adv(this);
	this->nameExpression(outputColor, "outputColor");
	this->nameExpression(outputCoverage, "outputCoverage");

	// Enclose custom code in a block to avoid namespace conflicts
	SkString openBrace;
	openBrace.printf("{ // Stage %d, %s\n", fStageIndex, proc.name());
	fFS.codeAppend(openBrace.c_str());
	fVS.codeAppendf("// Primitive Processor %s\n", proc.name());

	SkASSERT(!fGeometryProcessor);
	fGeometryProcessor = proc.createGLSLInstance(*this->glslCaps());

	SkSTArray<4, GrGLSLTextureSampler> samplers(proc.numTextures());
	this->emitSamplers(proc, &samplers);

	GrGLSLGeometryProcessor::EmitArgs args(&fVS,
	&fFS,
	this->varyingHandler(),
	this->uniformHandler(),
	this->glslCaps(),
	proc,
	outputColor->c_str(),
	outputCoverage->c_str(),
	samplers,
	fCoordTransforms,
	&fOutCoords);
	fGeometryProcessor->emitCode(args);

	// We have to check that effects and the code they emit are consistent, ie if an effect
	// asks for dst color, then the emit code needs to follow suit
	verify(proc);

	fFS.codeAppend("}");
	}

	void GrGLSLProgramBuilder::emitAndInstallFragProcs(int procOffset,
	int numProcs,
	GrGLSLExpr4* inOut) {
	for (int i = procOffset; i < numProcs; ++i) {
	GrGLSLExpr4 output;
	const GrFragmentProcessor& fp = this->pipeline().getFragmentProcessor(i);
	this->emitAndInstallFragProc(fp, i, *inOut, &output);
	*inOut = output;
	}
	}

	// TODO Processors cannot output zeros because an empty string is all 1s
	// the fix is to allow effects to take the GrGLSLExpr4 directly
	void GrGLSLProgramBuilder::emitAndInstallFragProc(const GrFragmentProcessor& fp,
	int index,
	const GrGLSLExpr4& input,
	GrGLSLExpr4* output) {
	// Program builders have a bit of state we need to clear with each effect
	AutoStageAdvance adv(this);
	this->nameExpression(output, "output");

	// Enclose custom code in a block to avoid namespace conflicts
	SkString openBrace;
	openBrace.printf("{ // Stage %d, %s\n", fStageIndex, fp.name());
	fFS.codeAppend(openBrace.c_str());

	GrGLSLFragmentProcessor* fragProc = fp.createGLSLInstance();

	SkSTArray<4, GrGLSLTextureSampler> samplers(fp.numTextures());
	this->emitSamplers(fp, &samplers);

	GrGLSLFragmentProcessor::EmitArgs args(&fFS,
	this->uniformHandler(),
	this->glslCaps(),
	fp,
	output->c_str(),
	input.isOnes() ? nullptr : input.c_str(),
	fOutCoords[index],
	samplers);
	fragProc->emitCode(args);

	// We have to check that effects and the code they emit are consistent, ie if an effect
	// asks for dst color, then the emit code needs to follow suit
	verify(fp);
	fFragmentProcessors.push_back(fragProc);

	fFS.codeAppend("}");
	}

	void GrGLSLProgramBuilder::emitAndInstallXferProc(const GrXferProcessor& xp,
	const GrGLSLExpr4& colorIn,
	const GrGLSLExpr4& coverageIn,
	bool ignoresCoverage,
	GrPixelLocalStorageState plsState) {
	// Program builders have a bit of state we need to clear with each effect
	AutoStageAdvance adv(this);

	SkASSERT(!fXferProcessor);
	fXferProcessor = xp.createGLSLInstance();

	// Enable dual source secondary output if we have one
	if (xp.hasSecondaryOutput()) {
	fFS.enableSecondaryOutput();
	}

	if (this->glslCaps()->mustDeclareFragmentShaderOutput()) {
	fFS.enableCustomOutput();
	}

	SkString openBrace;
	openBrace.printf("{ // Xfer Processor: %s\n", xp.name());
	fFS.codeAppend(openBrace.c_str());

	SkSTArray<4, GrGLSLTextureSampler> samplers(xp.numTextures());
	this->emitSamplers(xp, &samplers);

	bool usePLSDstRead = (plsState == GrPixelLocalStorageState::kFinish_GrPixelLocalStorageState);
	GrGLSLXferProcessor::EmitArgs args(&fFS,
	this->uniformHandler(),
	this->glslCaps(),
	xp, colorIn.c_str(),
	ignoresCoverage ? nullptr : coverageIn.c_str(),
	fFS.getPrimaryColorOutputName(),
	fFS.getSecondaryColorOutputName(),
	samplers,
	usePLSDstRead);
	fXferProcessor->emitCode(args);

	// We have to check that effects and the code they emit are consistent, ie if an effect
	// asks for dst color, then the emit code needs to follow suit
	verify(xp);
	fFS.codeAppend("}");
	}

	void GrGLSLProgramBuilder::emitFSOutputSwizzle(bool hasSecondaryOutput) {
	// Swizzle the fragment shader outputs if necessary.
	GrSwizzle swizzle;
	swizzle.setFromKey(this->desc().header().fOutputSwizzle);
	if (swizzle != GrSwizzle::RGBA()) {
	fFS.codeAppendf("%s = %s.%s;", fFS.getPrimaryColorOutputName(),
	fFS.getPrimaryColorOutputName(),
	swizzle.c_str());
	if (hasSecondaryOutput) {
	fFS.codeAppendf("%s = %s.%s;", fFS.getSecondaryColorOutputName(),
	fFS.getSecondaryColorOutputName(),
	swizzle.c_str());
	}
	}
	}

	void GrGLSLProgramBuilder::verify(const GrPrimitiveProcessor& gp) {
	SkASSERT(fFS.hasReadFragmentPosition() == gp.willReadFragmentPosition());
	}

	void GrGLSLProgramBuilder::verify(const GrXferProcessor& xp) {
	SkASSERT(fFS.hasReadDstColor() == xp.willReadDstColor());
	}

	void GrGLSLProgramBuilder::verify(const GrFragmentProcessor& fp) {
	SkASSERT(fFS.hasReadFragmentPosition() == fp.willReadFragmentPosition());
	}

	void GrGLSLProgramBuilder::nameVariable(SkString* out, char prefix, const char* name, bool mangle) {
	if ('\0' == prefix) {
	*out = name;
	} else {
	out->printf("%c%s", prefix, name);
	}
	if (mangle) {
	if (out->endsWith('_')) {
	// Names containing "__" are reserved.
	out->append("x");
	}
	out->appendf("_Stage%d%s", fStageIndex, fFS.getMangleString().c_str());
	}
	}

	void GrGLSLProgramBuilder::nameExpression(GrGLSLExpr4* output, const char* baseName) {
	// create var to hold stage result. If we already have a valid output name, just use that
	// otherwise create a new mangled one. This name is only valid if we are reordering stages
	// and have to tell stage exactly where to put its output.
	SkString outName;
	if (output->isValid()) {
	outName = output->c_str();
	} else {
	this->nameVariable(&outName, '\0', baseName);
	}
	fFS.codeAppendf("vec4 %s;", outName.c_str());
	*output = outName;
	}

	void GrGLSLProgramBuilder::appendUniformDecls(ShaderVisibility visibility,
	SkString* out) const {
	this->uniformHandler()->appendUniformDecls(visibility, out);
	}

	void GrGLSLProgramBuilder::addRTAdjustmentUniform(GrSLPrecision precision,
	const char* name,
	const char** outName) {
	SkASSERT(!fUniformHandles.fRTAdjustmentUni.isValid());
	fUniformHandles.fRTAdjustmentUni =
	this->uniformHandler()->addUniform(GrGLSLUniformHandler::kVertex_Visibility,
	kVec4f_GrSLType,
	precision,
	name,
	outName);
	}

	void GrGLSLProgramBuilder::addRTHeightUniform(const char* name, const char** outName) {
	SkASSERT(!fUniformHandles.fRTHeightUni.isValid());
	GrGLSLUniformHandler* uniformHandler = this->uniformHandler();
	fUniformHandles.fRTHeightUni =
	uniformHandler->internalAddUniformArray(GrGLSLUniformHandler::kFragment_Visibility,
	kFloat_GrSLType, kDefault_GrSLPrecision,
	name, false, 0, outName);
	}

	void GrGLSLProgramBuilder::cleanupFragmentProcessors() {
	for (int i = 0; i < fFragmentProcessors.count(); ++i) {
	delete fFragmentProcessors[i];
	}
	}