text: /*-------------------------------------------------------------------------
   * drawElements Quality Program OpenGL ES Utilities
   * ------------------------------------------------
   *
   * Copyright 2014 The Android Open Source Project
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   *
   */
  
  'use strict';
  goog.provide('framework.opengl.simplereference.sglrShaderProgram');
  goog.require('framework.common.tcuTexture');
  goog.require('framework.common.tcuTextureUtil');
  goog.require('framework.delibs.debase.deMath');
  goog.require('framework.opengl.gluShaderUtil');
  goog.require('framework.opengl.gluTextureUtil');
  goog.require('framework.referencerenderer.rrDefs');
  goog.require('framework.referencerenderer.rrFragmentOperations');
  goog.require('framework.referencerenderer.rrGenericVector');
  goog.require('framework.referencerenderer.rrShaders');
  goog.require('framework.referencerenderer.rrShadingContext');
  goog.require('framework.referencerenderer.rrVertexAttrib');
  goog.require('framework.referencerenderer.rrVertexPacket');
  
  goog.scope(function() {
  
      var sglrShaderProgram = framework.opengl.simplereference.sglrShaderProgram;
      var rrShaders = framework.referencerenderer.rrShaders;
      var rrGenericVector = framework.referencerenderer.rrGenericVector;
      var tcuTexture = framework.common.tcuTexture;
      var deMath = framework.delibs.debase.deMath;
      var gluTextureUtil = framework.opengl.gluTextureUtil;
      var gluShaderUtil = framework.opengl.gluShaderUtil;
      var tcuTextureUtil = framework.common.tcuTextureUtil;
      var rrDefs = framework.referencerenderer.rrDefs;
      var rrFragmentOperations = framework.referencerenderer.rrFragmentOperations;
      var rrVertexAttrib = framework.referencerenderer.rrVertexAttrib;
      var rrVertexPacket = framework.referencerenderer.rrVertexPacket;
      var rrShadingContext = framework.referencerenderer.rrShadingContext;
  
      var DE_ASSERT = function(x) {
          if (!x)
              throw new Error('Assert failed');
      };
  
      /**
       * sglrShaderProgram.VaryingFlags
       * @constructor
       * @struct
       */
      sglrShaderProgram.VaryingFlags = function() {
          this.NONE = true; //TODO: is NONE necessary?
          this.FLATSHADE = false;
      };
  
      /**
       * sglrShaderProgram.VertexAttribute
       * @constructor
       * @param {string} name_
       * @param {rrGenericVector.GenericVecType} type_
       */
      sglrShaderProgram.VertexAttribute = function(name_, type_) {
          this.name = name_;
          this.type = type_;
      };
  
      /**
       * sglrShaderProgram.VertexToFragmentVarying
       * @constructor
       * @param {rrGenericVector.GenericVecType} type_
       * @param {sglrShaderProgram.VaryingFlags=} flags
       */
      sglrShaderProgram.VertexToFragmentVarying = function(type_, flags) {
          this.type = type_;
          this.flatshade = flags === undefined ? new sglrShaderProgram.VaryingFlags().FLATSHADE : flags.FLATSHADE;
      };
  
      /**
       * sglrShaderProgram.FragmentOutput
       * @constructor
       * @param {rrGenericVector.GenericVecType} type_
       */
      sglrShaderProgram.FragmentOutput = function(type_) {
          /** @type {rrGenericVector.GenericVecType} */ this.type = type_;
      };
  
      /**
       * sglrShaderProgram.Uniform
       * @constructor
       * @param {string} name_
       * @param {gluShaderUtil.DataType} type_
       */
      sglrShaderProgram.Uniform = function(name_, type_) {
          /** @type {string} */ this.name = name_;
          /** @type {gluShaderUtil.DataType} */ this.type = type_;
          /** @type {Array<number>} */ this.value;
          /** @type {?rrDefs.Sampler} */ this.sampler = null;
      };
  
      /**
       * sglrShaderProgram.VertexSource
       * @constructor
       * @param {string} str
       */
      sglrShaderProgram.VertexSource = function(str) {
          /** @type {string} */ this.source = str;
      };
  
      /**
       * sglrShaderProgram.FragmentSource
       * @constructor
       * @param {string} str
       */
      sglrShaderProgram.FragmentSource = function(str) {
          /** @type {string} */ this.source = str;
      };
  
      /**
       * sglrShaderProgram.ShaderProgramDeclaration
       * @constructor
       */
      sglrShaderProgram.ShaderProgramDeclaration = function() {
          /** @type {Array<sglrShaderProgram.VertexAttribute>} */ this.m_vertexAttributes = [];
          /** @type {Array<sglrShaderProgram.VertexToFragmentVarying>} */ this.m_vertexToFragmentVaryings = [];
          /** @type {Array<sglrShaderProgram.FragmentOutput>} */ this.m_fragmentOutputs = [];
          /** @type {Array<sglrShaderProgram.Uniform>} */ this.m_uniforms = [];
          /** @type {string} */ this.m_vertexSource;
          /** @type {string} */ this.m_fragmentSource;
  
          /** @type {boolean} */ this.m_vertexShaderSet = false;
          /** @type {boolean} */ this.m_fragmentShaderSet = false;
      };
  
      /**
       * Add a vertex attribute to the shader program declaration.
       * @param {sglrShaderProgram.VertexAttribute} v
       * @return {sglrShaderProgram.ShaderProgramDeclaration}
       */
      sglrShaderProgram.ShaderProgramDeclaration.prototype.pushVertexAttribute = function(v) {
          this.m_vertexAttributes.push(v);
          return this;
      };
  
      /**
       * Add a vertex to fragment varying to the shader program declaration.
       * @param {sglrShaderProgram.VertexToFragmentVarying} v
       * @return {sglrShaderProgram.ShaderProgramDeclaration}
       */
      sglrShaderProgram.ShaderProgramDeclaration.prototype.pushVertexToFragmentVarying = function(v) {
          this.m_vertexToFragmentVaryings.push(v);
          return this;
      };
  
      /**
       * Add a fragment output to the shader program declaration.
       * @param {sglrShaderProgram.FragmentOutput} v
       * @return {sglrShaderProgram.ShaderProgramDeclaration}
       */
      sglrShaderProgram.ShaderProgramDeclaration.prototype.pushFragmentOutput = function(v) {
          this.m_fragmentOutputs.push(v);
          return this;
      };
  
      /**
       * Add a uniform to the shader program declaration.
       * @param {sglrShaderProgram.Uniform} v
       * @return {sglrShaderProgram.ShaderProgramDeclaration}
       */
      sglrShaderProgram.ShaderProgramDeclaration.prototype.pushUniform = function(v) {
          this.m_uniforms.push(v);
          return this;
      };
  
      /**
       * @param {sglrShaderProgram.VertexSource} c
       * @return {sglrShaderProgram.ShaderProgramDeclaration}
       */
      sglrShaderProgram.ShaderProgramDeclaration.prototype.pushVertexSource = function(c) {
          DE_ASSERT(!this.m_vertexShaderSet);
          this.m_vertexSource = c.source;
          this.m_vertexShaderSet = true;
          return this;
      };
  
      /**
       * @param {sglrShaderProgram.FragmentSource} c
       * @return {sglrShaderProgram.ShaderProgramDeclaration}
       */
      sglrShaderProgram.ShaderProgramDeclaration.prototype.pushFragmentSource = function(c) {
          DE_ASSERT(!this.m_fragmentSource);
          /** @type {sglrShaderProgram.FragmentSource} */ this.m_fragmentSource = c.source;
          /** @type {boolean} */ this.m_fragmentShaderSet = true;
          return this;
      };
  
      /**
       * @return {boolean}
       */
      sglrShaderProgram.ShaderProgramDeclaration.prototype.valid = function() {
          if (!this.m_vertexShaderSet || !this.m_fragmentShaderSet)
              return false;
  
          if (this.m_fragmentOutputs.length == 0)
              return false;
  
          return true;
      };
  
      /**
       * @return {number}
       */
      sglrShaderProgram.ShaderProgramDeclaration.prototype.getVertexInputCount = function() {
          return this.m_vertexAttributes.length;
      };
  
      /**
       * @return {number}
       */
      sglrShaderProgram.ShaderProgramDeclaration.prototype.getVertexOutputCount = function() {
          return this.m_vertexToFragmentVaryings.length;
      };
  
      /**
       * @return {number}
       */
      sglrShaderProgram.ShaderProgramDeclaration.prototype.getFragmentInputCount = function() {
          return this.m_vertexToFragmentVaryings.length;
      };
  
      /**
       * @return {number}
       */
      sglrShaderProgram.ShaderProgramDeclaration.prototype.getFragmentOutputCount = function() {
          return this.m_fragmentOutputs.length;
      };
  
      /**
       * @constructor
       * @param {sglrShaderProgram.ShaderProgramDeclaration} decl
       */
      sglrShaderProgram.ShaderProgram = function(decl) {
          /** @type {rrShaders.VertexShader} */ this.vertexShader = new rrShaders.VertexShader(decl.getVertexInputCount(), decl.getVertexOutputCount());
          /** @type {rrShaders.FragmentShader} */ this.fragmentShader = new rrShaders.FragmentShader(decl.getFragmentInputCount(), decl.getFragmentOutputCount());
  
          /** @type {Array<string>} */ this.m_attributeNames = [];
          /** @type {Array<sglrShaderProgram.Uniform>} */ this.m_uniforms = [];
          /** @type {string} */ this.m_vertSrc = decl.m_vertexSource;
          /** @type {string} */ this.m_fragSrc = decl.m_fragmentSource;
  
          DE_ASSERT(decl.valid());
  
          // Set up shader IO
  
          for (var ndx = 0; ndx < decl.m_vertexAttributes.length; ++ndx) {
              this.vertexShader.m_inputs[ndx].type = decl.m_vertexAttributes[ndx].type;
              this.m_attributeNames[ndx] = decl.m_vertexAttributes[ndx].name;
          }
  
          for (var ndx = 0; ndx < decl.m_vertexToFragmentVaryings.length; ++ndx) {
              this.vertexShader.m_outputs[ndx].type = decl.m_vertexToFragmentVaryings[ndx].type;
              this.vertexShader.m_outputs[ndx].flatshade = decl.m_vertexToFragmentVaryings[ndx].flatshade;
  
              this.fragmentShader.m_inputs[ndx] = this.vertexShader.m_outputs[ndx];
          }
  
          for (var ndx = 0; ndx < decl.m_fragmentOutputs.length; ++ndx)
              this.fragmentShader.m_outputs[ndx].type = decl.m_fragmentOutputs[ndx].type;
  
          // Set up uniforms
  
          for (var ndx = 0; ndx < decl.m_uniforms.length; ++ndx)
              this.m_uniforms[ndx] = new sglrShaderProgram.Uniform(decl.m_uniforms[ndx].name, decl.m_uniforms[ndx].type);
      };
  
      /**
       * @return {rrShaders.VertexShader}
       */
      sglrShaderProgram.ShaderProgram.prototype.getVertexShader = function() {
          return this.vertexShader;
      };
  
      /**
       * @return {rrShaders.FragmentShader}
       */
      sglrShaderProgram.ShaderProgram.prototype.getFragmentShader = function() {
          return this.fragmentShader;
      };
  
      /**
       * @param {string} name
       * @return {sglrShaderProgram.Uniform}
       * @throws {Error}
       */
      sglrShaderProgram.ShaderProgram.prototype.getUniformByName = function(name) {
          DE_ASSERT(name);
  
          for (var ndx = 0; ndx < this.m_uniforms.length; ++ndx)
              if (this.m_uniforms[ndx].name == name)
                  return this.m_uniforms[ndx];
  
          throw new Error('Invalid uniform name, uniform not found.');
      };
  
      /**
       * shadeFragments - abstract function, to be implemented by children classes
       * @param {Array<rrFragmentOperations.Fragment>} packets
       * @param {rrShadingContext.FragmentShadingContext} context
       * @throws {Error}
       */
      sglrShaderProgram.ShaderProgram.prototype.shadeFragments = function(packets, context) {
          throw new Error('This function needs to be overwritten in a child class.');
      };
  
      /**
       * shadeVertices - abstract function, to be implemented by children classes
       * @param {Array<rrVertexAttrib.VertexAttrib>} inputs
       * @param {Array<rrVertexPacket.VertexPacket>} packets
       * @param {number} numPackets
       * @throws {Error}
       */
       sglrShaderProgram.ShaderProgram.prototype.shadeVertices = function(inputs, packets, numPackets) {
          throw new Error('This function needs to be overwritten in a child class.');
       };
  
  });
  