/*
 * Copyright (C) 2012 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.
 */

package androidx.media.filterfw;

import android.graphics.RectF;
import android.opengl.GLES20;
import android.util.Log;

import androidx.media.filterfw.geometry.Quad;

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;
import java.util.Arrays;
import java.util.HashMap;

/**
 * Convenience class to perform GL shader operations on image data.
 * <p>
 * The ImageShader class greatly simplifies the task of running GL shader language kernels over
 * Frame data buffers that contain RGBA image data.
 * </p><p>
 * TODO: More documentation
 * </p>
 */
public class ImageShader {

    private int mProgram = 0;
    private boolean mClearsOutput = false;
    private float[] mClearColor = { 0f, 0f, 0f, 0f };
    private boolean mBlendEnabled = false;
    private int mSFactor = GLES20.GL_SRC_ALPHA;
    private int mDFactor = GLES20.GL_ONE_MINUS_SRC_ALPHA;
    private int mDrawMode = GLES20.GL_TRIANGLE_STRIP;
    private int mVertexCount = 4;
    private int mBaseTexUnit = GLES20.GL_TEXTURE0;
    private int mClearBuffers = GLES20.GL_COLOR_BUFFER_BIT;
    private float[] mSourceCoords = new float[] { 0f, 0f, 1f, 0f, 0f, 1f, 1f, 1f };
    private float[] mTargetCoords = new float[] { -1f, -1f, 1f, -1f, -1f, 1f, 1f, 1f };

    private HashMap<String, ProgramUniform> mUniforms;
    private HashMap<String, VertexAttribute> mAttributes = new HashMap<String, VertexAttribute>();

    private final static int FLOAT_SIZE = 4;

    private final static String mDefaultVertexShader =
        "attribute vec4 a_position;\n" +
        "attribute vec2 a_texcoord;\n" +
        "varying vec2 v_texcoord;\n" +
        "void main() {\n" +
        "  gl_Position = a_position;\n" +
        "  v_texcoord = a_texcoord;\n" +
        "}\n";

    private final static String mIdentityShader =
        "precision mediump float;\n" +
        "uniform sampler2D tex_sampler_0;\n" +
        "varying vec2 v_texcoord;\n" +
        "void main() {\n" +
        "  gl_FragColor = texture2D(tex_sampler_0, v_texcoord);\n" +
        "}\n";

    private static class VertexAttribute {
        private String mName;
        private boolean mIsConst;
        private int mIndex;
        private boolean mShouldNormalize;
        private int mOffset;
        private int mStride;
        private int mComponents;
        private int mType;
        private int mVbo;
        private int mLength;
        private FloatBuffer mValues;

        public VertexAttribute(String name, int index) {
            mName = name;
            mIndex = index;
            mLength = -1;
        }

        public void set(boolean normalize, int stride, int components, int type, float[] values) {
            mIsConst = false;
            mShouldNormalize = normalize;
            mStride = stride;
            mComponents = components;
            mType = type;
            mVbo = 0;
            if (mLength != values.length){
                initBuffer(values);
                mLength = values.length;
            }
            copyValues(values);
        }

        public void set(boolean normalize, int offset, int stride, int components, int type,
                int vbo){
            mIsConst = false;
            mShouldNormalize = normalize;
            mOffset = offset;
            mStride = stride;
            mComponents = components;
            mType = type;
            mVbo = vbo;
            mValues = null;
        }

        public boolean push() {
            if (mIsConst) {
                switch (mComponents) {
                    case 1:
                        GLES20.glVertexAttrib1fv(mIndex, mValues);
                        break;
                    case 2:
                        GLES20.glVertexAttrib2fv(mIndex, mValues);
                        break;
                    case 3:
                        GLES20.glVertexAttrib3fv(mIndex, mValues);
                        break;
                    case 4:
                        GLES20.glVertexAttrib4fv(mIndex, mValues);
                        break;
                    default:
                        return false;
                }
                GLES20.glDisableVertexAttribArray(mIndex);
            } else {
                if (mValues != null) {
                    // Note that we cannot do any size checking here, as the correct component
                    // count depends on the drawing step. GL should catch such errors then, and
                    // we will report them to the user.
                    GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, 0);
                    GLES20.glVertexAttribPointer(mIndex,
                                                 mComponents,
                                                 mType,
                                                 mShouldNormalize,
                                                 mStride,
                                                 mValues);
                } else {
                    GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, mVbo);
                    GLES20.glVertexAttribPointer(mIndex,
                                                 mComponents,
                                                 mType,
                                                 mShouldNormalize,
                                                 mStride,
                                                 mOffset);
                }
                GLES20.glEnableVertexAttribArray(mIndex);
            }
            GLToolbox.checkGlError("Set vertex-attribute values");
            return true;
        }

        @Override
        public String toString() {
            return mName;
        }

        private void initBuffer(float[] values) {
            mValues = ByteBuffer.allocateDirect(values.length * FLOAT_SIZE)
                .order(ByteOrder.nativeOrder()).asFloatBuffer();
        }

        private void copyValues(float[] values) {
            mValues.put(values).position(0);
        }

    }

    private static final class ProgramUniform {
        private String mName;
        private int mLocation;
        private int mType;
        private int mSize;

        public ProgramUniform(int program, int index) {
            int[] len = new int[1];
            GLES20.glGetProgramiv(program, GLES20.GL_ACTIVE_UNIFORM_MAX_LENGTH, len, 0);

            int[] type = new int[1];
            int[] size = new int[1];
            byte[] name = new byte[len[0]];
            int[] ignore = new int[1];

            GLES20.glGetActiveUniform(program, index, len[0], ignore, 0, size, 0, type, 0, name, 0);
            mName = new String(name, 0, strlen(name));
            mLocation = GLES20.glGetUniformLocation(program, mName);
            mType = type[0];
            mSize = size[0];
            GLToolbox.checkGlError("Initializing uniform");
        }

        public String getName() {
            return mName;
        }

        public int getType() {
            return mType;
        }

        public int getLocation() {
            return mLocation;
        }

        public int getSize() {
            return mSize;
        }
    }

    public ImageShader(String fragmentShader) {
        mProgram = createProgram(mDefaultVertexShader, fragmentShader);
        scanUniforms();
    }

    public ImageShader(String vertexShader, String fragmentShader) {
        mProgram = createProgram(vertexShader, fragmentShader);
        scanUniforms();
    }

    public static ImageShader createIdentity() {
        return new ImageShader(mIdentityShader);
    }

    public static ImageShader createIdentity(String vertexShader) {
        return new ImageShader(vertexShader, mIdentityShader);
    }

    public static void renderTextureToTarget(TextureSource texture,
                                             RenderTarget target,
                                             int width,
                                             int height) {
        ImageShader shader = RenderTarget.currentTarget().getIdentityShader();
        shader.process(texture, target, width, height);
    }

    public void process(FrameImage2D input, FrameImage2D output) {
        TextureSource texSource = input.lockTextureSource();
        RenderTarget renderTarget = output.lockRenderTarget();
        processMulti(new TextureSource[] { texSource },
                     renderTarget,
                     output.getWidth(),
                     output.getHeight());
        input.unlock();
        output.unlock();
    }

    public void processMulti(FrameImage2D[] inputs, FrameImage2D output) {
        TextureSource[] texSources = new TextureSource[inputs.length];
        for (int i = 0; i < inputs.length; ++i) {
            texSources[i] = inputs[i].lockTextureSource();
        }
        RenderTarget renderTarget = output.lockRenderTarget();
        processMulti(texSources,
                     renderTarget,
                     output.getWidth(),
                     output.getHeight());
        for (FrameImage2D input : inputs) {
            input.unlock();
        }
        output.unlock();
    }

    public void process(TextureSource texture, RenderTarget target, int width, int height) {
        processMulti(new TextureSource[] { texture }, target, width, height);
    }

    public void processMulti(TextureSource[] sources, RenderTarget target, int width, int height) {
        GLToolbox.checkGlError("Unknown Operation");
        checkExecutable();
        checkTexCount(sources.length);
        focusTarget(target, width, height);
        pushShaderState();
        bindInputTextures(sources);
        render();
    }

    public void processNoInput(FrameImage2D output) {
        RenderTarget renderTarget = output.lockRenderTarget();
        processNoInput(renderTarget, output.getWidth(), output.getHeight());
        output.unlock();
    }

    public void processNoInput(RenderTarget target, int width, int height) {
        processMulti(new TextureSource[] {}, target, width, height);
    }

    public int getUniformLocation(String name) {
        return getProgramUniform(name, true).getLocation();
    }

    public int getAttributeLocation(String name) {
        if (name.equals(positionAttributeName()) || name.equals(texCoordAttributeName())) {
            Log.w("ImageShader", "Attempting to access internal attribute '" + name
                + "' directly!");
        }
        int loc = GLES20.glGetAttribLocation(mProgram, name);
        if (loc < 0) {
            throw new RuntimeException("Unknown attribute '" + name + "' in shader program!");
        }
        return loc;
    }

    public void setUniformValue(String uniformName, int value) {
        useProgram();
        int uniformHandle = getUniformLocation(uniformName);
        GLES20.glUniform1i(uniformHandle, value);
        GLToolbox.checkGlError("Set uniform value (" + uniformName + ")");
    }

    public void setUniformValue(String uniformName, float value) {
        useProgram();
        int uniformHandle = getUniformLocation(uniformName);
        GLES20.glUniform1f(uniformHandle, value);
        GLToolbox.checkGlError("Set uniform value (" + uniformName + ")");
    }

    public void setUniformValue(String uniformName, int[] values) {
        ProgramUniform uniform = getProgramUniform(uniformName, true);
        useProgram();
        int len = values.length;
        switch (uniform.getType()) {
            case GLES20.GL_INT:
                checkUniformAssignment(uniform, len, 1);
                GLES20.glUniform1iv(uniform.getLocation(), len, values, 0);
                break;
            case GLES20.GL_INT_VEC2:
                checkUniformAssignment(uniform, len, 2);
                GLES20.glUniform2iv(uniform.getLocation(), len / 2, values, 0);
                break;
            case GLES20.GL_INT_VEC3:
                checkUniformAssignment(uniform, len, 3);
                GLES20.glUniform2iv(uniform.getLocation(), len / 3, values, 0);
                break;
            case GLES20.GL_INT_VEC4:
                checkUniformAssignment(uniform, len, 4);
                GLES20.glUniform2iv(uniform.getLocation(), len / 4, values, 0);
                break;
            default:
                throw new RuntimeException("Cannot assign int-array to incompatible uniform type "
                    + "for uniform '" + uniformName + "'!");
        }
        GLToolbox.checkGlError("Set uniform value (" + uniformName + ")");
    }


    public void setUniformValue(String uniformName, float[] values) {
        ProgramUniform uniform = getProgramUniform(uniformName, true);
        useProgram();
        int len = values.length;
        switch (uniform.getType()) {
            case GLES20.GL_FLOAT:
                checkUniformAssignment(uniform, len, 1);
                GLES20.glUniform1fv(uniform.getLocation(), len, values, 0);
                break;
            case GLES20.GL_FLOAT_VEC2:
                checkUniformAssignment(uniform, len, 2);
                GLES20.glUniform2fv(uniform.getLocation(), len / 2, values, 0);
                break;
            case GLES20.GL_FLOAT_VEC3:
                checkUniformAssignment(uniform, len, 3);
                GLES20.glUniform3fv(uniform.getLocation(), len / 3, values, 0);
                break;
            case GLES20.GL_FLOAT_VEC4:
                checkUniformAssignment(uniform, len, 4);
                GLES20.glUniform4fv(uniform.getLocation(), len / 4, values, 0);
                break;
            case GLES20.GL_FLOAT_MAT2:
                checkUniformAssignment(uniform, len, 4);
                GLES20.glUniformMatrix2fv(uniform.getLocation(), len / 4, false, values, 0);
                break;
            case GLES20.GL_FLOAT_MAT3:
                checkUniformAssignment(uniform, len, 9);
                GLES20.glUniformMatrix3fv(uniform.getLocation(), len / 9, false, values, 0);
                break;
            case GLES20.GL_FLOAT_MAT4:
                checkUniformAssignment(uniform, len, 16);
                GLES20.glUniformMatrix4fv(uniform.getLocation(), len / 16, false, values, 0);
                break;
            default:
                throw new RuntimeException("Cannot assign float-array to incompatible uniform type "
                    + "for uniform '" + uniformName + "'!");
        }
        GLToolbox.checkGlError("Set uniform value (" + uniformName + ")");
    }

    public void setAttributeValues(String attributeName, float[] data, int components) {
        VertexAttribute attr = getProgramAttribute(attributeName, true);
        attr.set(false, FLOAT_SIZE * components, components, GLES20.GL_FLOAT, data);
    }

    public void setAttributeValues(String attributeName, int vbo, int type, int components,
                                   int stride, int offset, boolean normalize) {
        VertexAttribute attr = getProgramAttribute(attributeName, true);
        attr.set(normalize, offset, stride, components, type, vbo);
    }

    public void setSourceRect(float x, float y, float width, float height) {
        setSourceCoords(new float[] { x, y, x + width, y, x, y + height, x + width, y + height });
    }

    public void setSourceRect(RectF rect) {
        setSourceRect(rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top);
    }

    public void setSourceQuad(Quad quad) {
        setSourceCoords(new float[] { quad.topLeft().x,     quad.topLeft().y,
                                      quad.topRight().x,    quad.topRight().y,
                                      quad.bottomLeft().x,  quad.bottomLeft().y,
                                      quad.bottomRight().x, quad.bottomRight().y });
    }

    public void setSourceCoords(float[] coords) {
        if (coords.length != 8) {
            throw new IllegalArgumentException("Expected 8 coordinates as source coordinates but "
                + "got " + coords.length + " coordinates!");
        }
        mSourceCoords = Arrays.copyOf(coords, 8);
    }

    public void setSourceTransform(float[] matrix) {
        if (matrix.length != 16) {
            throw new IllegalArgumentException("Expected 4x4 matrix for source transform!");
        }
        setSourceCoords(new float[] {
            matrix[12],
            matrix[13],

            matrix[0] + matrix[12],
            matrix[1] + matrix[13],

            matrix[4] + matrix[12],
            matrix[5] + matrix[13],

            matrix[0] + matrix[4] + matrix[12],
            matrix[1] + matrix[5] + matrix[13],
        });
    }

    public void setTargetRect(float x, float y, float width, float height) {
        setTargetCoords(new float[] { x, y,
                                      x + width, y,
                                      x, y + height,
                                      x + width, y + height });
    }

    public void setTargetRect(RectF rect) {
        setTargetCoords(new float[] { rect.left,    rect.top,
                                      rect.right,   rect.top,
                                      rect.left,    rect.bottom,
                                      rect.right,   rect.bottom });
    }

    public void setTargetQuad(Quad quad) {
        setTargetCoords(new float[] { quad.topLeft().x,     quad.topLeft().y,
                                      quad.topRight().x,    quad.topRight().y,
                                      quad.bottomLeft().x,  quad.bottomLeft().y,
                                      quad.bottomRight().x, quad.bottomRight().y });
    }

    public void setTargetCoords(float[] coords) {
        if (coords.length != 8) {
            throw new IllegalArgumentException("Expected 8 coordinates as target coordinates but "
                + "got " + coords.length + " coordinates!");
        }
        mTargetCoords = new float[8];
        for (int i = 0; i < 8; ++i) {
            mTargetCoords[i] = coords[i] * 2f - 1f;
        }
    }

    public void setTargetTransform(float[] matrix) {
        if (matrix.length != 16) {
            throw new IllegalArgumentException("Expected 4x4 matrix for target transform!");
        }
        setTargetCoords(new float[] {
            matrix[12],
            matrix[13],

            matrix[0] + matrix[12],
            matrix[1] + matrix[13],

            matrix[4] + matrix[12],
            matrix[5] + matrix[13],

            matrix[0] + matrix[4] + matrix[12],
            matrix[1] + matrix[5] + matrix[13],
        });
    }

    public void setClearsOutput(boolean clears) {
        mClearsOutput = clears;
    }

    public boolean getClearsOutput() {
        return mClearsOutput;
    }

    public void setClearColor(float[] rgba) {
        mClearColor = rgba;
    }

    public float[] getClearColor() {
        return mClearColor;
    }

    public void setClearBufferMask(int bufferMask) {
        mClearBuffers = bufferMask;
    }

    public int getClearBufferMask() {
        return mClearBuffers;
    }

    public void setBlendEnabled(boolean enable) {
        mBlendEnabled = enable;
    }

    public boolean getBlendEnabled() {
        return mBlendEnabled;
    }

    public void setBlendFunc(int sFactor, int dFactor) {
        mSFactor = sFactor;
        mDFactor = dFactor;
    }

    public void setDrawMode(int drawMode) {
        mDrawMode = drawMode;
    }

    public int getDrawMode() {
        return mDrawMode;
    }

    public void setVertexCount(int count) {
        mVertexCount = count;
    }

    public int getVertexCount() {
        return mVertexCount;
    }

    public void setBaseTextureUnit(int baseTexUnit) {
        mBaseTexUnit = baseTexUnit;
    }

    public int baseTextureUnit() {
        return mBaseTexUnit;
    }

    public String texCoordAttributeName() {
        return "a_texcoord";
    }

    public String positionAttributeName() {
        return "a_position";
    }

    public String inputTextureUniformName(int index) {
        return "tex_sampler_" + index;
    }

    public static int maxTextureUnits() {
        return GLES20.GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS;
    }

    @Override
    protected void finalize() throws Throwable {
        GLES20.glDeleteProgram(mProgram);
    }

    protected void pushShaderState() {
        useProgram();
        updateSourceCoordAttribute();
        updateTargetCoordAttribute();
        pushAttributes();
        if (mClearsOutput) {
            GLES20.glClearColor(mClearColor[0], mClearColor[1], mClearColor[2], mClearColor[3]);
            GLES20.glClear(mClearBuffers);
        }
        if (mBlendEnabled) {
            GLES20.glEnable(GLES20.GL_BLEND);
            GLES20.glBlendFunc(mSFactor, mDFactor);
        } else {
            GLES20.glDisable(GLES20.GL_BLEND);
        }
        GLToolbox.checkGlError("Set render variables");
    }

    private void focusTarget(RenderTarget target, int width, int height) {
        target.focus();
        GLES20.glViewport(0, 0, width, height);
        GLToolbox.checkGlError("glViewport");
    }

    private void bindInputTextures(TextureSource[] sources) {
        for (int i = 0; i < sources.length; ++i) {
            // Activate texture unit i
            GLES20.glActiveTexture(baseTextureUnit() + i);

            // Bind texture
            sources[i].bind();

            // Assign the texture uniform in the shader to unit i
            int texUniform = GLES20.glGetUniformLocation(mProgram, inputTextureUniformName(i));
            if (texUniform >= 0) {
                GLES20.glUniform1i(texUniform, i);
            } else {
                throw new RuntimeException("Shader does not seem to support " + sources.length
                    + " number of input textures! Missing uniform " + inputTextureUniformName(i)
                    + "!");
            }
            GLToolbox.checkGlError("Binding input texture " + i);
        }
    }

    private void pushAttributes() {
        for (VertexAttribute attr : mAttributes.values()) {
            if (!attr.push()) {
                throw new RuntimeException("Unable to assign attribute value '" + attr + "'!");
            }
        }
        GLToolbox.checkGlError("Push Attributes");
    }

    private void updateSourceCoordAttribute() {
        // If attribute does not exist, simply do nothing (may be custom shader).
        VertexAttribute attr = getProgramAttribute(texCoordAttributeName(), false);
        // A non-null value of mSourceCoords indicates new values to be set.
        if (mSourceCoords != null && attr != null) {
            // Upload new source coordinates to GPU
            attr.set(false, FLOAT_SIZE * 2, 2, GLES20.GL_FLOAT, mSourceCoords);
        }
        // Do not set again (even if failed, to not cause endless attempts)
        mSourceCoords = null;
    }

    private void updateTargetCoordAttribute() {
        // If attribute does not exist, simply do nothing (may be custom shader).
        VertexAttribute attr = getProgramAttribute(positionAttributeName(), false);
        // A non-null value of mTargetCoords indicates new values to be set.
        if (mTargetCoords != null && attr != null) {
            // Upload new target coordinates to GPU
            attr.set(false, FLOAT_SIZE * 2, 2, GLES20.GL_FLOAT, mTargetCoords);
        }
        // Do not set again (even if failed, to not cause endless attempts)
        mTargetCoords = null;
    }

    private void render() {
        GLES20.glDrawArrays(mDrawMode, 0, mVertexCount);
        GLToolbox.checkGlError("glDrawArrays");
    }

    private void checkExecutable() {
        if (mProgram == 0) {
            throw new RuntimeException("Attempting to execute invalid shader-program!");
        }
    }

    private void useProgram() {
        GLES20.glUseProgram(mProgram);
        GLToolbox.checkGlError("glUseProgram");
    }

    private static void checkTexCount(int count) {
        if (count > maxTextureUnits()) {
            throw new RuntimeException("Number of textures passed (" + count + ") exceeds the "
                + "maximum number of allowed texture units (" + maxTextureUnits() + ")!");
        }
    }

    private static int loadShader(int shaderType, String source) {
        int shader = GLES20.glCreateShader(shaderType);
        if (shader != 0) {
            GLES20.glShaderSource(shader, source);
            GLES20.glCompileShader(shader);
            int[] compiled = new int[1];
            GLES20.glGetShaderiv(shader, GLES20.GL_COMPILE_STATUS, compiled, 0);
            if (compiled[0] == 0) {
                String info = GLES20.glGetShaderInfoLog(shader);
                GLES20.glDeleteShader(shader);
                shader = 0;
                throw new RuntimeException("Could not compile shader " + shaderType + ":" + info);
            }
        }
        return shader;
    }

    private static int createProgram(String vertexSource, String fragmentSource) {
        int vertexShader = loadShader(GLES20.GL_VERTEX_SHADER, vertexSource);
        if (vertexShader == 0) {
            throw new RuntimeException("Could not create shader-program as vertex shader "
                + "could not be compiled!");
        }
        int pixelShader = loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentSource);
        if (pixelShader == 0) {
            throw new RuntimeException("Could not create shader-program as fragment shader "
                + "could not be compiled!");
        }

        int program = GLES20.glCreateProgram();
        if (program != 0) {
            GLES20.glAttachShader(program, vertexShader);
            GLToolbox.checkGlError("glAttachShader");
            GLES20.glAttachShader(program, pixelShader);
            GLToolbox.checkGlError("glAttachShader");
            GLES20.glLinkProgram(program);
            int[] linkStatus = new int[1];
            GLES20.glGetProgramiv(program, GLES20.GL_LINK_STATUS, linkStatus, 0);
            if (linkStatus[0] != GLES20.GL_TRUE) {
                String info = GLES20.glGetProgramInfoLog(program);
                GLES20.glDeleteProgram(program);
                program = 0;
                throw new RuntimeException("Could not link program: " + info);
            }
        }

        GLES20.glDeleteShader(vertexShader);
        GLES20.glDeleteShader(pixelShader);

        return program;
    }

    private void scanUniforms() {
        int uniformCount[] = new int [1];
        GLES20.glGetProgramiv(mProgram, GLES20.GL_ACTIVE_UNIFORMS, uniformCount, 0);
        if (uniformCount[0] > 0) {
            mUniforms = new HashMap<String, ProgramUniform>(uniformCount[0]);
            for (int i = 0; i < uniformCount[0]; ++i) {
                ProgramUniform uniform = new ProgramUniform(mProgram, i);
                mUniforms.put(uniform.getName(), uniform);
            }
        }
    }

    private ProgramUniform getProgramUniform(String name, boolean required) {
        ProgramUniform result = mUniforms.get(name);
        if (result == null && required) {
            throw new IllegalArgumentException("Unknown uniform '" + name + "'!");
        }
        return result;
    }

    private VertexAttribute getProgramAttribute(String name, boolean required) {
        VertexAttribute result = mAttributes.get(name);
        if (result == null) {
            int handle = GLES20.glGetAttribLocation(mProgram, name);
            if (handle >= 0) {
                result = new VertexAttribute(name, handle);
                mAttributes.put(name, result);
            } else if (required) {
                throw new IllegalArgumentException("Unknown attribute '" + name + "'!");
            }
        }
        return result;
    }

    private void checkUniformAssignment(ProgramUniform uniform, int values, int components) {
        if (values % components != 0) {
            throw new RuntimeException("Size mismatch: Attempting to assign values of size "
                + values + " to uniform '" + uniform.getName() + "' (must be multiple of "
                + components + ")!");
        } else if (uniform.getSize() != values / components) {
            throw new RuntimeException("Size mismatch: Cannot assign " + values + " values to "
                + "uniform '" + uniform.getName() + "'!");
        }
    }

    private static int strlen(byte[] strVal) {
        for (int i = 0; i < strVal.length; ++i) {
            if (strVal[i] == '\0') {
                return i;
            }
        }
        return strVal.length;
    }
}