flatland: add a GPU hardware benchmark (9c183f24) · Commits · e / os / android_frameworks_native

cmds/flatland/Android.mk

0 → 100644

+22 −0

Original line number	Diff line number	Diff line
		LOCAL_PATH:= $(call my-dir)
		include $(CLEAR_VARS)

		LOCAL_SRC_FILES:= \
		Composers.cpp \
		GLHelper.cpp \
		Renderers.cpp \
		Main.cpp \

		LOCAL_MODULE:= flatland

		LOCAL_MODULE_TAGS := tests

		LOCAL_SHARED_LIBRARIES := \
		libEGL \
		libGLESv2 \
		libcutils \
		libgui \
		libui \
		libutils \

		include $(BUILD_EXECUTABLE)

cmds/flatland/Composers.cpp

0 → 100644

+282 −0

Original line number	Diff line number	Diff line
		/*
		* 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.
		*/

		#include "Flatland.h"
		#include "GLHelper.h"

		namespace android {

		class Blitter {
		public:

		bool setUp(GLHelper* helper) {
		bool result;

		result = helper->getShaderProgram("Blit", &mBlitPgm);
		if (!result) {
		return false;
		}

		mPosAttribLoc = glGetAttribLocation(mBlitPgm, "position");
		mUVAttribLoc = glGetAttribLocation(mBlitPgm, "uv");
		mUVToTexUniformLoc = glGetUniformLocation(mBlitPgm, "uvToTex");
		mObjToNdcUniformLoc = glGetUniformLocation(mBlitPgm, "objToNdc");
		mBlitSrcSamplerLoc = glGetUniformLocation(mBlitPgm, "blitSrc");
		mModColorUniformLoc = glGetUniformLocation(mBlitPgm, "modColor");

		return true;
		}

		bool blit(GLuint texName, const float* texMatrix,
		int32_t x, int32_t y, uint32_t w, uint32_t h) {
		float modColor[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
		return modBlit(texName, texMatrix, modColor, x, y, w, h);
		}

		bool modBlit(GLuint texName, const float* texMatrix, float* modColor,
		int32_t x, int32_t y, uint32_t w, uint32_t h) {
		glUseProgram(mBlitPgm);

		GLint vp[4];
		glGetIntegerv(GL_VIEWPORT, vp);
		float screenToNdc[16] = {
		2.0f/float(vp[2]), 0.0f, 0.0f, 0.0f,
		0.0f, -2.0f/float(vp[3]), 0.0f, 0.0f,
		0.0f, 0.0f, 1.0f, 0.0f,
		-1.0f, 1.0f, 0.0f, 1.0f,
		};
		const float pos[] = {
		float(x), float(y),
		float(x+w), float(y),
		float(x), float(y+h),
		float(x+w), float(y+h),
		};
		const float uv[] = {
		0.0f, 0.0f,
		1.0f, 0.0f,
		0.0f, 1.0f,
		1.0f, 1.0f,
		};

		glVertexAttribPointer(mPosAttribLoc, 2, GL_FLOAT, GL_FALSE, 0, pos);
		glVertexAttribPointer(mUVAttribLoc, 2, GL_FLOAT, GL_FALSE, 0, uv);
		glEnableVertexAttribArray(mPosAttribLoc);
		glEnableVertexAttribArray(mUVAttribLoc);

		glUniformMatrix4fv(mObjToNdcUniformLoc, 1, GL_FALSE, screenToNdc);
		glUniformMatrix4fv(mUVToTexUniformLoc, 1, GL_FALSE, texMatrix);
		glUniform4fv(mModColorUniformLoc, 1, modColor);

		glActiveTexture(GL_TEXTURE0);
		glBindTexture(GL_TEXTURE_EXTERNAL_OES, texName);
		glUniform1i(mBlitSrcSamplerLoc, 0);

		glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

		glDisableVertexAttribArray(mPosAttribLoc);
		glDisableVertexAttribArray(mUVAttribLoc);

		if (glGetError() != GL_NO_ERROR) {
		fprintf(stderr, "GL error!\n");
		}

		return true;
		}

		private:
		GLuint mBlitPgm;
		GLint mPosAttribLoc;
		GLint mUVAttribLoc;
		GLint mUVToTexUniformLoc;
		GLint mObjToNdcUniformLoc;
		GLint mBlitSrcSamplerLoc;
		GLint mModColorUniformLoc;
		};

		class ComposerBase : public Composer {
		public:
		virtual ~ComposerBase() {}

		virtual bool setUp(const LayerDesc& desc,
		GLHelper* helper) {
		mLayerDesc = desc;
		return setUp(helper);
		}

		virtual void tearDown() {
		}

		virtual bool compose(GLuint texName, const sp<GLConsumer>& glc) {
		return true;
		}

		protected:
		virtual bool setUp(GLHelper* helper) {
		return true;
		}

		LayerDesc mLayerDesc;
		};

		Composer* nocomp() {
		class NoComp : public ComposerBase {
		};
		return new NoComp();
		}

		Composer* opaque() {
		class OpaqueComp : public ComposerBase {
		virtual bool setUp(GLHelper* helper) {
		return mBlitter.setUp(helper);
		}

		virtual bool compose(GLuint texName, const sp<GLConsumer>& glc) {
		float texMatrix[16];
		glc->getTransformMatrix(texMatrix);

		int32_t x = mLayerDesc.x;
		int32_t y = mLayerDesc.y;
		int32_t w = mLayerDesc.width;
		int32_t h = mLayerDesc.height;

		return mBlitter.blit(texName, texMatrix, x, y, w, h);
		}

		Blitter mBlitter;
		};
		return new OpaqueComp();
		}

		Composer* opaqueShrink() {
		class OpaqueComp : public ComposerBase {
		virtual bool setUp(GLHelper* helper) {
		mParity = false;
		return mBlitter.setUp(helper);
		}

		virtual bool compose(GLuint texName, const sp<GLConsumer>& glc) {
		float texMatrix[16];
		glc->getTransformMatrix(texMatrix);

		int32_t x = mLayerDesc.x;
		int32_t y = mLayerDesc.y;
		int32_t w = mLayerDesc.width;
		int32_t h = mLayerDesc.height;

		mParity = !mParity;
		if (mParity) {
		x += w / 128;
		y += h / 128;
		w -= w / 64;
		h -= h / 64;
		}

		return mBlitter.blit(texName, texMatrix, x, y, w, h);
		}

		Blitter mBlitter;
		bool mParity;
		};
		return new OpaqueComp();
		}

		Composer* blend() {
		class BlendComp : public ComposerBase {
		virtual bool setUp(GLHelper* helper) {
		return mBlitter.setUp(helper);
		}

		virtual bool compose(GLuint texName, const sp<GLConsumer>& glc) {
		bool result;

		float texMatrix[16];
		glc->getTransformMatrix(texMatrix);

		float modColor[4] = { .75f, .75f, .75f, .75f };

		int32_t x = mLayerDesc.x;
		int32_t y = mLayerDesc.y;
		int32_t w = mLayerDesc.width;
		int32_t h = mLayerDesc.height;

		glEnable(GL_BLEND);
		glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);

		result = mBlitter.modBlit(texName, texMatrix, modColor,
		x, y, w, h);
		if (!result) {
		return false;
		}

		glDisable(GL_BLEND);

		return true;
		}

		Blitter mBlitter;
		};
		return new BlendComp();
		}

		Composer* blendShrink() {
		class BlendShrinkComp : public ComposerBase {
		virtual bool setUp(GLHelper* helper) {
		mParity = false;
		return mBlitter.setUp(helper);
		}

		virtual bool compose(GLuint texName, const sp<GLConsumer>& glc) {
		bool result;

		float texMatrix[16];
		glc->getTransformMatrix(texMatrix);

		float modColor[4] = { .75f, .75f, .75f, .75f };

		int32_t x = mLayerDesc.x;
		int32_t y = mLayerDesc.y;
		int32_t w = mLayerDesc.width;
		int32_t h = mLayerDesc.height;

		mParity = !mParity;
		if (mParity) {
		x += w / 128;
		y += h / 128;
		w -= w / 64;
		h -= h / 64;
		}

		glEnable(GL_BLEND);
		glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);

		result = mBlitter.modBlit(texName, texMatrix, modColor,
		x, y, w, h);
		if (!result) {
		return false;
		}

		glDisable(GL_BLEND);

		return true;
		}

		Blitter mBlitter;
		bool mParity;
		};
		return new BlendShrinkComp();
		}

		} // namespace android

cmds/flatland/Flatland.h

0 → 100644

+71 −0

Original line number	Diff line number	Diff line
		/*
		* 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.
		*/

		#include <stdint.h>

		#include <EGL/egl.h>
		#include <GLES2/gl2.h>

		#include <gui/GLConsumer.h>

		namespace android {

		#define NELEMS(x) ((int) (sizeof(x) / sizeof((x)[0])))

		enum { MAX_NUM_LAYERS = 16 };
		enum { MAX_TEST_RUNS = 16 };

		class Composer;
		class Renderer;
		class GLHelper;

		struct LayerDesc {
		uint32_t flags;
		Renderer* (*rendererFactory)();
		Composer* (*composerFactory)();
		int32_t x;
		int32_t y;
		uint32_t width;
		uint32_t height;
		};

		void resetColorGenerator();

		class Composer {
		public:
		virtual ~Composer() {}
		virtual bool setUp(const LayerDesc& desc, GLHelper* helper) = 0;
		virtual void tearDown() = 0;
		virtual bool compose(GLuint texName, const sp<GLConsumer>& glc) = 0;
		};

		Composer* nocomp();
		Composer* opaque();
		Composer* opaqueShrink();
		Composer* blend();
		Composer* blendShrink();

		class Renderer {
		public:
		virtual ~Renderer() {}
		virtual bool setUp(GLHelper* helper) = 0;
		virtual void tearDown() = 0;
		virtual bool render(EGLSurface surface) = 0;
		};

		Renderer* staticGradient();

		} // namespace android

cmds/flatland/GLHelper.cpp

0 → 100644

+461 −0

Original line number	Diff line number	Diff line
		/*
		* 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.
		*/

		#include <ui/Fence.h>

		#include <ui/DisplayInfo.h>
		#include <gui/SurfaceComposerClient.h>

		#include "GLHelper.h"

		namespace android {

		GLHelper::GLHelper() :
		mGraphicBufferAlloc(new GraphicBufferAlloc()),
		mDisplay(EGL_NO_DISPLAY),
		mContext(EGL_NO_CONTEXT),
		mDummySurface(EGL_NO_SURFACE),
		mConfig(0),
		mShaderPrograms(NULL),
		mDitherTexture(0) {
		}

		GLHelper::~GLHelper() {
		}

		bool GLHelper::setUp(const ShaderDesc* shaderDescs, size_t numShaders) {
		bool result;

		mDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
		if (mDisplay == EGL_NO_DISPLAY) {
		fprintf(stderr, "eglGetDisplay error: %#x\n", eglGetError());
		return false;
		}

		EGLint majorVersion;
		EGLint minorVersion;
		result = eglInitialize(mDisplay, &majorVersion, &minorVersion);
		if (result != EGL_TRUE) {
		fprintf(stderr, "eglInitialize error: %#x\n", eglGetError());
		return false;
		}

		EGLint numConfigs = 0;
		EGLint configAttribs[] = {
		EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
		EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
		EGL_RED_SIZE, 8,
		EGL_GREEN_SIZE, 8,
		EGL_BLUE_SIZE, 8,
		EGL_ALPHA_SIZE, 8,
		EGL_NONE
		};
		result = eglChooseConfig(mDisplay, configAttribs, &mConfig, 1,
		&numConfigs);
		if (result != EGL_TRUE) {
		fprintf(stderr, "eglChooseConfig error: %#x\n", eglGetError());
		return false;
		}

		EGLint contextAttribs[] = {
		EGL_CONTEXT_CLIENT_VERSION, 2,
		EGL_NONE
		};
		mContext = eglCreateContext(mDisplay, mConfig, EGL_NO_CONTEXT,
		contextAttribs);
		if (mContext == EGL_NO_CONTEXT) {
		fprintf(stderr, "eglCreateContext error: %#x\n", eglGetError());
		return false;
		}

		bool resultb = createNamedSurfaceTexture(0, 1, 1, &mDummyGLConsumer,
		&mDummySurface);
		if (!resultb) {
		return false;
		}

		resultb = makeCurrent(mDummySurface);
		if (!resultb) {
		return false;
		}

		resultb = setUpShaders(shaderDescs, numShaders);
		if (!resultb) {
		return false;
		}

		return true;
		}

		void GLHelper::tearDown() {
		if (mShaderPrograms != NULL) {
		delete[] mShaderPrograms;
		mShaderPrograms = NULL;
		}

		if (mSurfaceComposerClient != NULL) {
		mSurfaceComposerClient->dispose();
		mSurfaceComposerClient.clear();
		}

		if (mDisplay != EGL_NO_DISPLAY) {
		eglMakeCurrent(mDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE,
		EGL_NO_CONTEXT);
		}

		if (mContext != EGL_NO_CONTEXT) {
		eglDestroyContext(mDisplay, mContext);
		}

		if (mDummySurface != EGL_NO_SURFACE) {
		eglDestroySurface(mDisplay, mDummySurface);
		}

		mDisplay = EGL_NO_DISPLAY;
		mContext = EGL_NO_CONTEXT;
		mDummySurface = EGL_NO_SURFACE;
		mDummyGLConsumer.clear();
		mConfig = 0;
		}

		bool GLHelper::makeCurrent(EGLSurface surface) {
		EGLint result;

		result = eglMakeCurrent(mDisplay, surface, surface, mContext);
		if (result != EGL_TRUE) {
		fprintf(stderr, "eglMakeCurrent error: %#x\n", eglGetError());
		return false;
		}

		EGLint w, h;
		eglQuerySurface(mDisplay, surface, EGL_WIDTH, &w);
		eglQuerySurface(mDisplay, surface, EGL_HEIGHT, &h);
		glViewport(0, 0, w, h);

		return true;
		}

		bool GLHelper::createSurfaceTexture(uint32_t w, uint32_t h,
		sp<GLConsumer>* glConsumer, EGLSurface* surface,
		GLuint* name) {
		if (!makeCurrent(mDummySurface)) {
		return false;
		}

		*name = 0;
		glGenTextures(1, name);
		if (*name == 0) {
		fprintf(stderr, "glGenTextures error: %#x\n", glGetError());
		return false;
		}

		return createNamedSurfaceTexture(*name, w, h, glConsumer, surface);
		}

		void GLHelper::destroySurface(EGLSurface* surface) {
		if (eglGetCurrentSurface(EGL_READ) == *surface \|\|
		eglGetCurrentSurface(EGL_DRAW) == *surface) {
		eglMakeCurrent(mDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE,
		EGL_NO_CONTEXT);
		}
		eglDestroySurface(mDisplay, *surface);
		*surface = EGL_NO_SURFACE;
		}

		bool GLHelper::swapBuffers(EGLSurface surface) {
		EGLint result;
		result = eglSwapBuffers(mDisplay, surface);
		if (result != EGL_TRUE) {
		fprintf(stderr, "eglSwapBuffers error: %#x\n", eglGetError());
		return false;
		}
		return true;
		}

		bool GLHelper::getShaderProgram(const char* name, GLuint* outPgm) {
		for (size_t i = 0; i < mNumShaders; i++) {
		if (strcmp(mShaderDescs[i].name, name) == 0) {
		*outPgm = mShaderPrograms[i];
		return true;
		}
		}

		fprintf(stderr, "unknown shader name: \"%s\"\n", name);

		return false;
		}

		bool GLHelper::createNamedSurfaceTexture(GLuint name, uint32_t w, uint32_t h,
		sp<GLConsumer>* glConsumer, EGLSurface* surface) {
		sp<BufferQueue> bq = new BufferQueue(true, mGraphicBufferAlloc);
		sp<GLConsumer> glc = new GLConsumer(name, true,
		GL_TEXTURE_EXTERNAL_OES, false, bq);
		glc->setDefaultBufferSize(w, h);
		glc->setDefaultMaxBufferCount(3);
		glc->setConsumerUsageBits(GRALLOC_USAGE_HW_COMPOSER);

		sp<ANativeWindow> anw = new SurfaceTextureClient(bq);
		EGLSurface s = eglCreateWindowSurface(mDisplay, mConfig, anw.get(), NULL);
		if (s == EGL_NO_SURFACE) {
		fprintf(stderr, "eglCreateWindowSurface error: %#x\n", eglGetError());
		return false;
		}

		*glConsumer = glc;
		*surface = s;
		return true;
		}

		bool GLHelper::computeWindowScale(uint32_t w, uint32_t h, float* scale) {
		sp<IBinder> dpy = mSurfaceComposerClient->getBuiltInDisplay(0);
		if (dpy == NULL) {
		fprintf(stderr, "SurfaceComposer::getBuiltInDisplay failed.\n");
		return false;
		}

		DisplayInfo info;
		status_t err = mSurfaceComposerClient->getDisplayInfo(dpy, &info);
		if (err != NO_ERROR) {
		fprintf(stderr, "SurfaceComposer::getDisplayInfo failed: %#x\n", err);
		return false;
		}

		float scaleX = float(info.w) / float(w);
		float scaleY = float(info.h) / float(h);
		*scale = scaleX < scaleY ? scaleX : scaleY;

		return true;
		}

		bool GLHelper::createWindowSurface(uint32_t w, uint32_t h,
		sp<SurfaceControl>* surfaceControl, EGLSurface* surface) {
		bool result;
		status_t err;

		if (mSurfaceComposerClient == NULL) {
		mSurfaceComposerClient = new SurfaceComposerClient;
		}
		err = mSurfaceComposerClient->initCheck();
		if (err != NO_ERROR) {
		fprintf(stderr, "SurfaceComposerClient::initCheck error: %#x\n", err);
		return false;
		}

		sp<SurfaceControl> sc = mSurfaceComposerClient->createSurface(
		String8("Benchmark"), w, h, PIXEL_FORMAT_RGBA_8888, 0);
		if (sc == NULL \|\| !sc->isValid()) {
		fprintf(stderr, "Failed to create SurfaceControl.\n");
		return false;
		}

		float scale;
		result = computeWindowScale(w, h, &scale);
		if (!result) {
		return false;
		}

		SurfaceComposerClient::openGlobalTransaction();
		err = sc->setLayer(0x7FFFFFFF);
		if (err != NO_ERROR) {
		fprintf(stderr, "SurfaceComposer::setLayer error: %#x\n", err);
		return false;
		}
		err = sc->setMatrix(scale, 0.0f, 0.0f, scale);
		if (err != NO_ERROR) {
		fprintf(stderr, "SurfaceComposer::setMatrix error: %#x\n", err);
		return false;
		}

		err = sc->show();
		if (err != NO_ERROR) {
		fprintf(stderr, "SurfaceComposer::show error: %#x\n", err);
		return false;
		}
		SurfaceComposerClient::closeGlobalTransaction();

		sp<ANativeWindow> anw = sc->getSurface();
		EGLSurface s = eglCreateWindowSurface(mDisplay, mConfig, anw.get(), NULL);
		if (s == EGL_NO_SURFACE) {
		fprintf(stderr, "eglCreateWindowSurface error: %#x\n", eglGetError());
		return false;
		}

		*surfaceControl = sc;
		*surface = s;
		return true;
		}

		static bool compileShader(GLenum shaderType, const char* src,
		GLuint* outShader) {
		GLuint shader = glCreateShader(shaderType);
		if (shader == 0) {
		fprintf(stderr, "glCreateShader error: %#x\n", glGetError());
		return false;
		}

		glShaderSource(shader, 1, &src, NULL);
		glCompileShader(shader);

		GLint compiled = 0;
		glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
		if (!compiled) {
		GLint infoLen = 0;
		glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen);
		if (infoLen) {
		char* buf = new char[infoLen];
		if (buf) {
		glGetShaderInfoLog(shader, infoLen, NULL, buf);
		fprintf(stderr, "Shader compile log:\n%s\n", buf);
		delete[] buf;
		}
		}
		glDeleteShader(shader);
		return false;
		}
		*outShader = shader;
		return true;
		}

		static void printShaderSource(const char* const* src) {
		for (size_t i = 0; i < MAX_SHADER_LINES && src[i] != NULL; i++) {
		fprintf(stderr, "%3d: %s\n", i+1, src[i]);
		}
		}

		static const char* makeShaderString(const char* const* src) {
		size_t len = 0;
		for (size_t i = 0; i < MAX_SHADER_LINES && src[i] != NULL; i++) {
		// The +1 is for the '\n' that will be added.
		len += strlen(src[i]) + 1;
		}

		char* result = new char[len+1];
		char* end = result;
		for (size_t i = 0; i < MAX_SHADER_LINES && src[i] != NULL; i++) {
		strcpy(end, src[i]);
		end += strlen(src[i]);
		*end = '\n';
		end++;
		}
		*end = '\0';

		return result;
		}

		static bool compileShaderLines(GLenum shaderType, const char* const* lines,
		GLuint* outShader) {
		const char* src = makeShaderString(lines);
		bool result = compileShader(shaderType, src, outShader);
		if (!result) {
		fprintf(stderr, "Shader source:\n");
		printShaderSource(lines);
		return false;
		}
		delete[] src;

		return true;
		}

		static bool linkShaderProgram(GLuint vs, GLuint fs, GLuint* outPgm) {
		GLuint program = glCreateProgram();
		if (program == 0) {
		fprintf(stderr, "glCreateProgram error: %#x\n", glGetError());
		return false;
		}

		glAttachShader(program, vs);
		glAttachShader(program, fs);
		glLinkProgram(program);
		GLint linkStatus = GL_FALSE;
		glGetProgramiv(program, GL_LINK_STATUS, &linkStatus);
		if (linkStatus != GL_TRUE) {
		GLint bufLength = 0;
		glGetProgramiv(program, GL_INFO_LOG_LENGTH, &bufLength);
		if (bufLength) {
		char* buf = new char[bufLength];
		if (buf) {
		glGetProgramInfoLog(program, bufLength, NULL, buf);
		fprintf(stderr, "Program link log:\n%s\n", buf);
		delete[] buf;
		}
		}
		glDeleteProgram(program);
		program = 0;
		}

		*outPgm = program;
		return program != 0;
		}

		bool GLHelper::setUpShaders(const ShaderDesc* shaderDescs, size_t numShaders) {
		mShaderPrograms = new GLuint[numShaders];
		bool result = true;

		for (size_t i = 0; i < numShaders && result; i++) {
		GLuint vs, fs;

		result = compileShaderLines(GL_VERTEX_SHADER,
		shaderDescs[i].vertexShader, &vs);
		if (!result) {
		return false;
		}

		result = compileShaderLines(GL_FRAGMENT_SHADER,
		shaderDescs[i].fragmentShader, &fs);
		if (!result) {
		glDeleteShader(vs);
		return false;
		}

		result = linkShaderProgram(vs, fs, &mShaderPrograms[i]);
		glDeleteShader(vs);
		glDeleteShader(fs);
		}

		mNumShaders = numShaders;
		mShaderDescs = shaderDescs;

		return result;
		}

		bool GLHelper::getDitherTexture(GLuint* outTexName) {
		if (mDitherTexture == 0) {
		const uint8_t pattern[] = {
		0, 8, 2, 10,
		12, 4, 14, 6,
		3, 11, 1, 9,
		15, 7, 13, 5
		};

		glGenTextures(1, &mDitherTexture);
		glBindTexture(GL_TEXTURE_2D, mDitherTexture);

		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

		glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, DITHER_KERNEL_SIZE,
		DITHER_KERNEL_SIZE, 0, GL_ALPHA, GL_UNSIGNED_BYTE, &pattern);
		}

		*outTexName = mDitherTexture;

		return true;
		}

		}

cmds/flatland/GLHelper.h

0 → 100644

+94 −0

File added.

Preview size limit exceeded, changes collapsed.