void Init( int width, int height )
{
// Init the shaders
gProgramHandle = createProgram( gVertexShader, gPixelShader );
if( !gProgramHandle )
{
LogError( "Could not create program." );
assert(0);
}
// Read attribute locations from the program
gaPositionHandle = glGetAttribLocation( gProgramHandle, "aPosition" );
CheckGlError( "glGetAttribLocation" );
gaTexCoordHandle = glGetAttribLocation( gProgramHandle, "aTexCoord" );
CheckGlError( "glGetAttribLocation" );
gaTexSamplerHandle = glGetUniformLocation( gProgramHandle, "sTexture" );
CheckGlError( "glGetUnitformLocation" );
// Set up viewport
glViewport( 0, 0, width, height ) ;
CheckGlError( "glViewport" );
// Load textures
gTextureHandlePNG = LoadTexturePNG("tex_png.png");
gTextureHandleUnsupported = LoadTexturePNG("tex_bw.png");
gTextureHandleETC = ( IsETCSupported() ) ? LoadTextureETC_KTX("tex_etc1.ktx") : gTextureHandleUnsupported;
gTextureHandleETC2 = ( IsETC2Supported() ) ? LoadTextureETC_KTX("tex_etc2.ktx") : gTextureHandleUnsupported;
gTextureHandlePVRTC = ( IsPVRTCSupported() ) ? LoadTexturePVRTC("tex_pvr.pvr") : gTextureHandleUnsupported;
gTextureHandleS3TC = ( IsS3TCSupported() ) ? LoadTextureS3TC("tex_s3tc.dds") : gTextureHandleUnsupported;
}
GLuint GlUtil::CreateProgram(const char* vertex_source, const char* fragment_source)
{
LOGI("%s\n", vertex_source);
GLuint vertexShader = 0;
GLuint fragment_shader = 0;
if (vertex_source)
{
vertexShader = LoadShader(GL_VERTEX_SHADER, vertex_source);
if (!vertexShader) {
return 0;
}
}
if (fragment_source)
{
fragment_shader = LoadShader(GL_FRAGMENT_SHADER, fragment_source);
if (!fragment_shader) {
return 0;
}
}
GLuint program = glCreateProgram();
if (program) {
glAttachShader(program, vertexShader);
CheckGlError("glAttachShader");
if (fragment_shader)
{
glAttachShader(program, fragment_shader);
CheckGlError("glAttachShader");
}
LinkProgram(program);
}
return program;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
// createProgram - Creates a new program with the given vertex and pixel shader
GLuint createProgram( const char* pVertexSource, const char* pPixelSource )
{
// Compile the vertex shader
GLuint vertexShaderHandle = CompileShader( GL_VERTEX_SHADER, pVertexSource );
GLuint pixelShaderHandle = CompileShader( GL_FRAGMENT_SHADER, pPixelSource );
if( !vertexShaderHandle || !pixelShaderHandle )
{
return 0;
}
// Create a new handle for this program
GLuint programHandle = glCreateProgram();
// Link and finish the program
if( programHandle )
{
// Set the vertex shader for this program
glAttachShader( programHandle, vertexShaderHandle );
CheckGlError( "glAttachShader" );
// Set the pixel shader for this program
glAttachShader( programHandle, pixelShaderHandle );
CheckGlError( "glAttachShader" );
// Link the program
glLinkProgram( programHandle );
// Check the link status
GLint linkStatus = 0;
glGetProgramiv( programHandle, GL_LINK_STATUS, &linkStatus );
if( !linkStatus )
{
// There was an error, print it out
GLint infoLogLength = 0;
glGetProgramiv( programHandle, GL_INFO_LOG_LENGTH, &infoLogLength );
if( infoLogLength )
{
char* pInfoLog = (char*)malloc( infoLogLength );
if( pInfoLog )
{
glGetProgramInfoLog( programHandle, infoLogLength, NULL, pInfoLog );
LogError( "Error linking the program: \n%s", pInfoLog );
free( pInfoLog );
}
}
// Free the handle
glDeleteProgram( programHandle );
programHandle = 0;
}
}
return programHandle;
}
GLuint GlUtil::LoadShader(GLenum shader_type, const char* shader_source) {
GLuint shader = glCreateShader(shader_type);
CheckGlError("glCreateShader");
if (shader) {
glShaderSource(shader, 1, &shader_source, NULL);
glCompileShader(shader);
GLint compiled = 0;
glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
if (!compiled) {
GLint info_len = 0;
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &info_len);
if (info_len) {
char* buf = (char*)malloc(info_len);
if (buf) {
glGetShaderInfoLog(shader, info_len, NULL, buf);
LOGE("Could not compile shader %d:\n%s\n", shader_type, buf);
free(buf);
}
glDeleteShader(shader);
shader = 0;
exit(1);
}
}
}
return shader;
}
void Scene::draw(GLuint textureHandler) {
glClearColor( 0.8f, 0.7f, 0.6f, 1.0f);
CheckGlError( "glClearColor" );
// Clear the color and depth buffer
glClear( GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
CheckGlError( "glClear" );
// Select vertex/pixel shader
glUseProgram( programHandle );
CheckGlError( "glUseProgram" );
CheckGlError( "glUniformMatrix4fv" );
// Enable vertex
glEnableVertexAttribArray( aPositionHandle );
CheckGlError( "glEnableVertexAttribArray" );
// Enable tex coords
glEnableVertexAttribArray( aTexCoordHandle );
CheckGlError( "glEnableVertexAttribArray" );
// Set texture sampler
glActiveTexture( GL_TEXTURE0 );
// Enable texture sampler
glUniform1i( aTexSamplerHandle, 0 );
// PNG //////////////////////////////////////////////////////////////////////////////////////////////////////
// Set vertex position
glVertexAttribPointer( aPositionHandle, 2, GL_FLOAT, GL_FALSE, sizeof(TriangleVertex), triangleVerticesPNG );
CheckGlError( "glVertexAttribPointer" );
// Set vertex texture coordinates
glVertexAttribPointer( aTexCoordHandle, 2, GL_FLOAT, GL_FALSE, sizeof(TriangleVertex), textureCoordsPNG );
CheckGlError( "glVertexAttribPointer" );
// glBindTexture( GL_TEXTURE_2D, fb.renderableTexture );
if(textureHandler) {
glBindTexture( GL_TEXTURE_2D, textureHandler );
}
else {
fb->bindTexture();
}
glDrawArrays( GL_TRIANGLES, 0, 6 );
fb->unbindTexture();
glFlush();
}
Scene::Scene(int w,int h):width(w),height(h),scale(1.0),fb(0),textureHandle(0),checkboard_width(256),checkboard_height(256) {
// Initialize GL state.
// glHint(GL_PEr, GL_FASTEST);
glEnable(GL_CULL_FACE);
// glShadeModel(GL_SH);
glDisable(GL_DEPTH_TEST);
// Init the shaders
// gProgramHandle = createProgram( gVertexShader, gPixelShader );
programHandle = createProgram( "shaders/vertexShader", "shaders/fragmentShader" );
Log("Program handle %d",programHandle);
if( !programHandle )
{
LogError( "Could not create program." );
assert(0);
}
//
// Read attribute locations from the program
aPositionHandle = glGetAttribLocation( programHandle, "aPosition" );
Log("gaPositionHandle %d",aPositionHandle);
CheckGlError( "glGetAttribLocation" );
//
aTexCoordHandle = glGetAttribLocation( programHandle, "aTexCoord" );
Log("gaTexCoordHandle %d",aTexCoordHandle);
CheckGlError( "glGetAttribLocation" );
aTexSamplerHandle = glGetUniformLocation( programHandle, "sTexture" );
Log("gaTexSamplerHandle %d",aTexSamplerHandle);
CheckGlError( "glGetUnitformLocation" );
GLubyte* pixels = generateCheckBoardTextureData(checkboard_width,checkboard_height,3);
GLubyte* resizedPointer = (GLubyte*)scaleTexture(1.0,pixels,checkboard_width,checkboard_height,GL_RGB,GL_UNSIGNED_BYTE);
/*
* Do whatever you want with resized texture data pointer
*/
delete resizedPointer;
delete pixels;
glViewport(0,0,width,height);
}
void DumpGlLog(GLuint handle)
{
return;
int nLogLen = 0;
MP_ASSERT(0 == glGetError());
glGetObjectParameterivARB(handle, GL_OBJECT_INFO_LOG_LENGTH_ARB, &nLogLen);
if(nLogLen > 1)
{
char* pChars = (char*)malloc(nLogLen);
int nLen = 0;
glGetInfoLogARB(handle, nLogLen, &nLen, pChars);
printf("COMPILE MESSAGE\n%s\n\n", pChars);
free(pChars);
__BREAK();
}
CheckGlError();
}
///////////////////////////////////////////////////////////////////////////////////////////////////
// Render - Called from Java-side to render a frame
void Render()
{
// Set the clear color
glClearColor( 0.8f, 0.7f, 0.6f, 1.0f);
CheckGlError( "glClearColor" );
// Clear the color and depth buffer
glClear( GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
CheckGlError( "glClear" );
// Select vertex/pixel shader
glUseProgram( gProgramHandle );
CheckGlError( "glUseProgram" );
// Enable vertex
glEnableVertexAttribArray( gaPositionHandle );
CheckGlError( "glEnableVertexAttribArray" );
// Enable tex coords
glEnableVertexAttribArray( gaTexCoordHandle );
CheckGlError( "glEnableVertexAttribArray" );
// Set texture sampler
glActiveTexture( GL_TEXTURE0 );
// Enable texture sampler
glUniform1i( gaTexSamplerHandle, 0 );
// PNG //////////////////////////////////////////////////////////////////////////////////////////////////////
// Set vertex position
glVertexAttribPointer( gaPositionHandle, 2, GL_FLOAT, GL_FALSE, sizeof(TriangleVertex), gTriangleVerticesPNG );
CheckGlError( "glVertexAttribPointer" );
// Set vertex texture coordinates
glVertexAttribPointer( gaTexCoordHandle, 2, GL_FLOAT, GL_FALSE, sizeof(TriangleVertex), (char*)gTriangleVerticesPNG + sizeof(float)*2 );
CheckGlError( "glVertexAttribPointer" );
// Set active texture
glBindTexture( GL_TEXTURE_2D, gTextureHandlePNG );
glDrawArrays( GL_TRIANGLES, 0, 6 );
// ETC //////////////////////////////////////////////////////////////////////////////////////////////////////
// Set vertex position
glVertexAttribPointer( gaPositionHandle, 2, GL_FLOAT, GL_FALSE, sizeof(TriangleVertex), gTriangleVerticesETC );
CheckGlError( "glVertexAttribPointer");
// Set vertex texture coordinates
glVertexAttribPointer( gaTexCoordHandle, 2, GL_FLOAT, GL_FALSE, sizeof(TriangleVertex), (char*)gTriangleVerticesETC + sizeof(float)*2 );
CheckGlError( "glVertexAttribPointer");
// Set active texture
glBindTexture( GL_TEXTURE_2D, gTextureHandleETC );
glDrawArrays( GL_TRIANGLES, 0, 6 );
// ETC2 //////////////////////////////////////////////////////////////////////////////////////////////////////
// Set vertex position
glVertexAttribPointer( gaPositionHandle, 2, GL_FLOAT, GL_FALSE, sizeof(TriangleVertex), gTriangleVerticesETC2 );
CheckGlError( "glVertexAttribPointer");
// Set vertex texture coordinates
glVertexAttribPointer( gaTexCoordHandle, 2, GL_FLOAT, GL_FALSE, sizeof(TriangleVertex), (char*)gTriangleVerticesETC2 + sizeof(float)*2 );
CheckGlError( "glVertexAttribPointer");
// Set active texture
glBindTexture( GL_TEXTURE_2D, gTextureHandleETC2 );
glDrawArrays( GL_TRIANGLES, 0, 6 );
// PVRTC //////////////////////////////////////////////////////////////////////////////////////////////////////
// Set vertex position
glVertexAttribPointer( gaPositionHandle, 2, GL_FLOAT, GL_FALSE, sizeof(TriangleVertex), gTriangleVerticesPVRTC );
CheckGlError( "glVertexAttribPointer" );
// Set vertex texture coordinates
glVertexAttribPointer( gaTexCoordHandle, 2, GL_FLOAT, GL_FALSE, sizeof(TriangleVertex), (char*)gTriangleVerticesPVRTC + sizeof(float)*2 );
CheckGlError( "glVertexAttribPointer" );
// Set active texture
glBindTexture( GL_TEXTURE_2D, gTextureHandlePVRTC );
glDrawArrays( GL_TRIANGLES, 0, 6) ;
// S3TC //////////////////////////////////////////////////////////////////////////////////////////////////////
// Set vertex position
glVertexAttribPointer( gaPositionHandle, 2, GL_FLOAT, GL_FALSE, sizeof(TriangleVertex), gTriangleVerticesS3TC );
CheckGlError( "glVertexAttribPointer" );
// Set vertex texture coordinates
glVertexAttribPointer( gaTexCoordHandle, 2, GL_FLOAT, GL_FALSE, sizeof(TriangleVertex), (char*)gTriangleVerticesS3TC + sizeof(float)*2 );
CheckGlError( "glVertexAttribPointer" );
// Set active texture
glBindTexture( GL_TEXTURE_2D, gTextureHandleS3TC );
glDrawArrays( GL_TRIANGLES, 0, 6 );
}
