libs/rs/rsProgramFragment.cpp - platform/frameworks/base - Gitiles

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

 #include "rsContext.h"
 #ifndef ANDROID_RS_SERIALIZE
 #include <GLES/gl.h>
 #include <GLES/glext.h>
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #endif //ANDROID_RS_SERIALIZE

 #include "rsProgramFragment.h"

 using namespace android;
 using namespace android::renderscript;

 ProgramFragment::ProgramFragment(Context *rsc, const char * shaderText,
                                  uint32_t shaderLength, const uint32_t * params,
                                  uint32_t paramLength)
     : Program(rsc, shaderText, shaderLength, params, paramLength) {

     mConstantColor[0] = 1.f;
     mConstantColor[1] = 1.f;
     mConstantColor[2] = 1.f;
     mConstantColor[3] = 1.f;

     init(rsc);
 }

 ProgramFragment::~ProgramFragment() {
     if (mShaderID) {
         mRSC->mShaderCache.cleanupFragment(mShaderID);
     }
 }

 void ProgramFragment::setConstantColor(Context *rsc, float r, float g, float b, float a) {
     if (isUserProgram()) {
         LOGE("Attempting to set fixed function emulation color on user program");
         rsc->setError(RS_ERROR_BAD_SHADER, "Cannot  set fixed function emulation color on user program");
         return;
     }
     if (mConstants[0].get() == NULL) {
         LOGE("Unable to set fixed function emulation color because allocation is missing");
         rsc->setError(RS_ERROR_BAD_SHADER, "Unable to set fixed function emulation color because allocation is missing");
         return;
     }
     mConstantColor[0] = r;
     mConstantColor[1] = g;
     mConstantColor[2] = b;
     mConstantColor[3] = a;
     memcpy(mConstants[0]->getPtr(), mConstantColor, 4*sizeof(float));
     mDirty = true;
 }

 void ProgramFragment::setupGL2(Context *rsc, ProgramFragmentState *state, ShaderCache *sc) {
     //LOGE("sgl2 frag1 %x", glGetError());
     if ((state->mLast.get() == this) && !mDirty) {
         return;
     }
     state->mLast.set(this);

     rsc->checkError("ProgramFragment::setupGL2 start");

     rsc->checkError("ProgramFragment::setupGL2 begin uniforms");
     setupUserConstants(rsc, sc, true);

     uint32_t numTexturesToBind = mTextureCount;
     uint32_t numTexturesAvailable = rsc->getMaxFragmentTextures();
     if (numTexturesToBind >= numTexturesAvailable) {
         LOGE("Attempting to bind %u textures on shader id %u, but only %u are available",
              mTextureCount, (uint32_t)this, numTexturesAvailable);
         rsc->setError(RS_ERROR_BAD_SHADER, "Cannot bind more textuers than available");
         numTexturesToBind = numTexturesAvailable;
     }

     for (uint32_t ct=0; ct < numTexturesToBind; ct++) {
         glActiveTexture(GL_TEXTURE0 + ct);
         if (!mTextures[ct].get()) {
             LOGE("No texture bound for shader id %u, texture unit %u", (uint)this, ct);
             rsc->setError(RS_ERROR_BAD_SHADER, "No texture bound");
             continue;
         }

         mTextures[ct]->uploadCheck(rsc);
         GLenum target = (GLenum)mTextures[ct]->getGLTarget();
         if (target != GL_TEXTURE_2D && target != GL_TEXTURE_CUBE_MAP) {
             LOGE("Attempting to bind unknown texture to shader id %u, texture unit %u", (uint)this, ct);
             rsc->setError(RS_ERROR_BAD_SHADER, "Non-texture allocation bound to a shader");
         }
         glBindTexture(target, mTextures[ct]->getTextureID());
         rsc->checkError("ProgramFragment::setupGL2 tex bind");
         if (mSamplers[ct].get()) {
             mSamplers[ct]->setupGL(rsc, mTextures[ct].get());
         } else {
             glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
             glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
             glTexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
             glTexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
             rsc->checkError("ProgramFragment::setupGL2 tex env");
         }

         glUniform1i(sc->fragUniformSlot(mTextureUniformIndexStart + ct), ct);
         rsc->checkError("ProgramFragment::setupGL2 uniforms");
     }

     glActiveTexture(GL_TEXTURE0);
     mDirty = false;
     rsc->checkError("ProgramFragment::setupGL2");
 }

 void ProgramFragment::loadShader(Context *rsc) {
     Program::loadShader(rsc, GL_FRAGMENT_SHADER);
 }

 void ProgramFragment::createShader() {
     if (mUserShader.length() > 1) {
         mShader.append("precision mediump float;\n");
         appendUserConstants();
         char buf[256];
         for (uint32_t ct=0; ct < mTextureCount; ct++) {
             if (mTextureTargets[ct] == RS_TEXTURE_2D) {
                 snprintf(buf, sizeof(buf), "uniform sampler2D UNI_Tex%i;\n", ct);
             } else {
                 snprintf(buf, sizeof(buf), "uniform samplerCube UNI_Tex%i;\n", ct);
             }
             mShader.append(buf);
         }
         mShader.append(mUserShader);
     } else {
         LOGE("ProgramFragment::createShader cannot create program, shader code not defined");
         rsAssert(0);
     }
 }

 void ProgramFragment::init(Context *rsc) {
     uint32_t uniformIndex = 0;
     if (mUserShader.size() > 0) {
         for (uint32_t ct=0; ct < mConstantCount; ct++) {
             initAddUserElement(mConstantTypes[ct]->getElement(), mUniformNames, mUniformArraySizes, &uniformIndex, RS_SHADER_UNI);
         }
     }
     mTextureUniformIndexStart = uniformIndex;
     char buf[256];
     for (uint32_t ct=0; ct < mTextureCount; ct++) {
         snprintf(buf, sizeof(buf), "UNI_Tex%i", ct);
         mUniformNames[uniformIndex].setTo(buf);
         mUniformArraySizes[uniformIndex] = 1;
         uniformIndex++;
     }

     createShader();
 }

 void ProgramFragment::serialize(OStream *stream) const {
 }

 ProgramFragment *ProgramFragment::createFromStream(Context *rsc, IStream *stream) {
     return NULL;
 }

 ProgramFragmentState::ProgramFragmentState() {
     mPF = NULL;
 }

 ProgramFragmentState::~ProgramFragmentState() {
     ObjectBase::checkDelete(mPF);
     mPF = NULL;
 }

 void ProgramFragmentState::init(Context *rsc) {
     String8 shaderString(RS_SHADER_INTERNAL);
     shaderString.append("varying lowp vec4 varColor;\n");
     shaderString.append("varying vec2 varTex0;\n");
     shaderString.append("void main() {\n");
     shaderString.append("  lowp vec4 col = UNI_Color;\n");
     shaderString.append("  gl_FragColor = col;\n");
     shaderString.append("}\n");

     const Element *colorElem = Element::create(rsc, RS_TYPE_FLOAT_32, RS_KIND_USER, false, 4);
     rsc->mStateElement.elementBuilderBegin();
     rsc->mStateElement.elementBuilderAdd(colorElem, "Color", 1);
     const Element *constInput = rsc->mStateElement.elementBuilderCreate(rsc);

     Type *inputType = Type::getType(rsc, constInput, 1, 0, 0, false, false);

     uint32_t tmp[2];
     tmp[0] = RS_PROGRAM_PARAM_CONSTANT;
     tmp[1] = (uint32_t)inputType;

     Allocation *constAlloc = new Allocation(rsc, inputType, RS_ALLOCATION_USAGE_SCRIPT | RS_ALLOCATION_USAGE_GRAPHICS_CONSTANTS);
     ProgramFragment *pf = new ProgramFragment(rsc, shaderString.string(),
                                               shaderString.length(), tmp, 2);
     pf->bindAllocation(rsc, constAlloc, 0);
     pf->setConstantColor(rsc, 1.0f, 1.0f, 1.0f, 1.0f);

     mDefault.set(pf);
 }

 void ProgramFragmentState::deinit(Context *rsc) {
     mDefault.clear();
     mLast.clear();
 }

 namespace android {
 namespace renderscript {

 RsProgramFragment rsi_ProgramFragmentCreate(Context *rsc, const char * shaderText,
                              uint32_t shaderLength, const uint32_t * params,
                              uint32_t paramLength) {
     ProgramFragment *pf = new ProgramFragment(rsc, shaderText, shaderLength, params, paramLength);
     pf->incUserRef();
     //LOGE("rsi_ProgramFragmentCreate %p", pf);
     return pf;
 }

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

	#include "rsContext.h"
	#ifndef ANDROID_RS_SERIALIZE
	#include <GLES/gl.h>
	#include <GLES/glext.h>
	#include <GLES2/gl2.h>
	#include <GLES2/gl2ext.h>
	#endif //ANDROID_RS_SERIALIZE

	#include "rsProgramFragment.h"

	using namespace android;
	using namespace android::renderscript;

	ProgramFragment::ProgramFragment(Context rsc, const char shaderText,
	uint32_t shaderLength, const uint32_t * params,
	uint32_t paramLength)
	: Program(rsc, shaderText, shaderLength, params, paramLength) {

	mConstantColor[0] = 1.f;
	mConstantColor[1] = 1.f;
	mConstantColor[2] = 1.f;
	mConstantColor[3] = 1.f;

	init(rsc);
	}

	ProgramFragment::~ProgramFragment() {
	if (mShaderID) {
	mRSC->mShaderCache.cleanupFragment(mShaderID);
	}
	}

	void ProgramFragment::setConstantColor(Context *rsc, float r, float g, float b, float a) {
	if (isUserProgram()) {
	LOGE("Attempting to set fixed function emulation color on user program");
	rsc->setError(RS_ERROR_BAD_SHADER, "Cannot set fixed function emulation color on user program");
	return;
	}
	if (mConstants[0].get() == NULL) {
	LOGE("Unable to set fixed function emulation color because allocation is missing");
	rsc->setError(RS_ERROR_BAD_SHADER, "Unable to set fixed function emulation color because allocation is missing");
	return;
	}
	mConstantColor[0] = r;
	mConstantColor[1] = g;
	mConstantColor[2] = b;
	mConstantColor[3] = a;
	memcpy(mConstants[0]->getPtr(), mConstantColor, 4*sizeof(float));
	mDirty = true;
	}

	void ProgramFragment::setupGL2(Context rsc, ProgramFragmentState state, ShaderCache *sc) {
	//LOGE("sgl2 frag1 %x", glGetError());
	if ((state->mLast.get() == this) && !mDirty) {
	return;
	}
	state->mLast.set(this);

	rsc->checkError("ProgramFragment::setupGL2 start");

	rsc->checkError("ProgramFragment::setupGL2 begin uniforms");
	setupUserConstants(rsc, sc, true);

	uint32_t numTexturesToBind = mTextureCount;
	uint32_t numTexturesAvailable = rsc->getMaxFragmentTextures();
	if (numTexturesToBind >= numTexturesAvailable) {
	LOGE("Attempting to bind %u textures on shader id %u, but only %u are available",
	mTextureCount, (uint32_t)this, numTexturesAvailable);
	rsc->setError(RS_ERROR_BAD_SHADER, "Cannot bind more textuers than available");
	numTexturesToBind = numTexturesAvailable;
	}

	for (uint32_t ct=0; ct < numTexturesToBind; ct++) {
	glActiveTexture(GL_TEXTURE0 + ct);
	if (!mTextures[ct].get()) {
	LOGE("No texture bound for shader id %u, texture unit %u", (uint)this, ct);
	rsc->setError(RS_ERROR_BAD_SHADER, "No texture bound");
	continue;
	}

	mTextures[ct]->uploadCheck(rsc);
	GLenum target = (GLenum)mTextures[ct]->getGLTarget();
	if (target != GL_TEXTURE_2D && target != GL_TEXTURE_CUBE_MAP) {
	LOGE("Attempting to bind unknown texture to shader id %u, texture unit %u", (uint)this, ct);
	rsc->setError(RS_ERROR_BAD_SHADER, "Non-texture allocation bound to a shader");
	}
	glBindTexture(target, mTextures[ct]->getTextureID());
	rsc->checkError("ProgramFragment::setupGL2 tex bind");
	if (mSamplers[ct].get()) {
	mSamplers[ct]->setupGL(rsc, mTextures[ct].get());
	} else {
	glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	rsc->checkError("ProgramFragment::setupGL2 tex env");
	}

	glUniform1i(sc->fragUniformSlot(mTextureUniformIndexStart + ct), ct);
	rsc->checkError("ProgramFragment::setupGL2 uniforms");
	}

	glActiveTexture(GL_TEXTURE0);
	mDirty = false;
	rsc->checkError("ProgramFragment::setupGL2");
	}

	void ProgramFragment::loadShader(Context *rsc) {
	Program::loadShader(rsc, GL_FRAGMENT_SHADER);
	}

	void ProgramFragment::createShader() {
	if (mUserShader.length() > 1) {
	mShader.append("precision mediump float;\n");
	appendUserConstants();
	char buf[256];
	for (uint32_t ct=0; ct < mTextureCount; ct++) {
	if (mTextureTargets[ct] == RS_TEXTURE_2D) {
	snprintf(buf, sizeof(buf), "uniform sampler2D UNI_Tex%i;\n", ct);
	} else {
	snprintf(buf, sizeof(buf), "uniform samplerCube UNI_Tex%i;\n", ct);
	}
	mShader.append(buf);
	}
	mShader.append(mUserShader);
	} else {
	LOGE("ProgramFragment::createShader cannot create program, shader code not defined");
	rsAssert(0);
	}
	}

	void ProgramFragment::init(Context *rsc) {
	uint32_t uniformIndex = 0;
	if (mUserShader.size() > 0) {
	for (uint32_t ct=0; ct < mConstantCount; ct++) {
	initAddUserElement(mConstantTypes[ct]->getElement(), mUniformNames, mUniformArraySizes, &uniformIndex, RS_SHADER_UNI);
	}
	}
	mTextureUniformIndexStart = uniformIndex;
	char buf[256];
	for (uint32_t ct=0; ct < mTextureCount; ct++) {
	snprintf(buf, sizeof(buf), "UNI_Tex%i", ct);
	mUniformNames[uniformIndex].setTo(buf);
	mUniformArraySizes[uniformIndex] = 1;
	uniformIndex++;
	}

	createShader();
	}

	void ProgramFragment::serialize(OStream *stream) const {
	}

	ProgramFragment ProgramFragment::createFromStream(Context rsc, IStream *stream) {
	return NULL;
	}

	ProgramFragmentState::ProgramFragmentState() {
	mPF = NULL;
	}

	ProgramFragmentState::~ProgramFragmentState() {
	ObjectBase::checkDelete(mPF);
	mPF = NULL;
	}

	void ProgramFragmentState::init(Context *rsc) {
	String8 shaderString(RS_SHADER_INTERNAL);
	shaderString.append("varying lowp vec4 varColor;\n");
	shaderString.append("varying vec2 varTex0;\n");
	shaderString.append("void main() {\n");
	shaderString.append(" lowp vec4 col = UNI_Color;\n");
	shaderString.append(" gl_FragColor = col;\n");
	shaderString.append("}\n");

	const Element *colorElem = Element::create(rsc, RS_TYPE_FLOAT_32, RS_KIND_USER, false, 4);
	rsc->mStateElement.elementBuilderBegin();
	rsc->mStateElement.elementBuilderAdd(colorElem, "Color", 1);
	const Element *constInput = rsc->mStateElement.elementBuilderCreate(rsc);

	Type *inputType = Type::getType(rsc, constInput, 1, 0, 0, false, false);

	uint32_t tmp[2];
	tmp[0] = RS_PROGRAM_PARAM_CONSTANT;
	tmp[1] = (uint32_t)inputType;

	Allocation *constAlloc = new Allocation(rsc, inputType, RS_ALLOCATION_USAGE_SCRIPT \| RS_ALLOCATION_USAGE_GRAPHICS_CONSTANTS);
	ProgramFragment *pf = new ProgramFragment(rsc, shaderString.string(),
	shaderString.length(), tmp, 2);
	pf->bindAllocation(rsc, constAlloc, 0);
	pf->setConstantColor(rsc, 1.0f, 1.0f, 1.0f, 1.0f);

	mDefault.set(pf);
	}

	void ProgramFragmentState::deinit(Context *rsc) {
	mDefault.clear();
	mLast.clear();
	}

	namespace android {
	namespace renderscript {

	RsProgramFragment rsi_ProgramFragmentCreate(Context rsc, const char shaderText,
	uint32_t shaderLength, const uint32_t * params,
	uint32_t paramLength) {
	ProgramFragment *pf = new ProgramFragment(rsc, shaderText, shaderLength, params, paramLength);
	pf->incUserRef();
	//LOGE("rsi_ProgramFragmentCreate %p", pf);
	return pf;
	}

	}
	}