int test_compiler(int i) { static char vert_shader[64 * 1024], frag_shader[64 * 1024]; GLuint program; int vert_fd, frag_fd; int ret; vert_fd = openfile("shaders/%04d.vs", i); frag_fd = openfile("shaders/%04d.fs", i); if ((vert_fd < 0) || (frag_fd < 0)) return -1; ret = read(vert_fd, vert_shader, sizeof(vert_shader)); if (ret < 0) return ret; vert_shader[ret] = '\0'; ret = read(frag_fd, frag_shader, sizeof(frag_shader)); if (ret < 0) return ret; frag_shader[ret] = '\0'; RD_START("compiler", "%d", i); program = get_program(vert_shader, frag_shader); link_program(program); GCHK(glFlush()); RD_END(); return 0; }
void test_fill(uint32_t w, uint32_t h, uint32_t format) { PixmapPtr dest; C2D_RECT rect; c2d_ts_handle curTimestamp; DEBUG_MSG("fill: %04dx%04d-%08x", w, h, format); RD_START("fill", "%dx%d-%08x", w, h, format); dest = create_pixmap(w, h, format); rect.x = 1 + (w / 64); rect.y = 2 + (w / 32); rect.width = w - 2 * rect.x; rect.height = h - 2 * rect.y; // note: look for pattern 0xff556677 in memory to find cmdstream: CHK(c2dFillSurface(dest->id, 0xff556677, &rect)); CHK(c2dFlush(dest->id, &curTimestamp)); CHK(c2dWaitTimestamp(curTimestamp)); // second blit.. fill a sub-rect in center of surface: rect.x = (w - 10) / 2; rect.y = (h - 16) / 2; rect.width = 10; rect.height = 16; CHK(c2dFillSurface(dest->id, 0xff223344, &rect)); CHK(c2dFlush(dest->id, &curTimestamp)); CHK(c2dWaitTimestamp(curTimestamp)); RD_END(); dump_pixmap(dest, "fill-%04dx%04d-%08x.bmp", w, h, format); }
void test_fill(uint32_t w, uint32_t h, uint32_t format, uint32_t x1, uint32_t y1, uint32_t x2, uint32_t y2) { PixmapPtr dest; C2D_RECT rect; c2d_ts_handle curTimestamp; DEBUG_MSG("----------------------------------------------------------------"); DEBUG_MSG("fill2: %04dx%04d-%08x-%d,%d,%d,%d", w, h, format, x1, y1, x2, y2); RD_START("fill2", "%dx%d-%08x-%d-%d-%d-%d", w, h, format, x1, y1, x2, y2); dest = create_pixmap(w, h, format); rect.x = x1; rect.y = y1; rect.width = x2 - x1; rect.height = y2 - y1; CHK(c2dFillSurface(dest->id, 0x00585a5d, &rect)); CHK(c2dFlush(dest->id, &curTimestamp)); CHK(c2dWaitTimestamp(curTimestamp)); RD_END(); dump_pixmap(dest, "fill-%04dx%04d-%08x.bmp", w, h, format); }
static void test_mipmap(int maxlevels, int w, int h, unsigned filt) { RD_START("mipmap", "maxlevels=%d, texsize=%dx%d", maxlevels, w, h); display = get_display(); /* get an appropriate EGL frame buffer configuration */ ECHK(eglChooseConfig(display, config_attribute_list, &config, 1, &num_config)); DEBUG_MSG("num_config: %d", num_config); /* create an EGL rendering context */ ECHK(context = eglCreateContext(display, config, EGL_NO_CONTEXT, context_attribute_list)); surface = make_window(display, config, 400, 240); ECHK(eglQuerySurface(display, surface, EGL_WIDTH, &width)); ECHK(eglQuerySurface(display, surface, EGL_HEIGHT, &height)); DEBUG_MSG("Buffer: %dx%d", width, height); /* connect the context to the surface */ ECHK(eglMakeCurrent(display, surface, surface, context)); programObject = get_program(vShaderStr, fShaderStr); link_program(programObject); // Get the attribute locations GCHK(positionLoc = glGetAttribLocation(programObject, "a_position")); GCHK(texCoordLoc = glGetAttribLocation(programObject, "a_texCoord")); // Get the sampler location GCHK(samplerLoc = glGetUniformLocation(programObject, "s_texture")); // Get the offset location GCHK(offsetLoc = glGetUniformLocation(programObject, "u_offset")); // Load the texture GCHK(textureId = CreateMipMappedTexture2D(maxlevels, w, h, filt)); GCHK(glClearColor(0.0f, 0.0f, 0.0f, 0.0f)); GCHK(Draw()); ECHK(eglSwapBuffers(display, surface)); GCHK(glFlush()); #ifndef BIONIC sleep(5); #endif ECHK(eglDestroySurface(display, surface)); #ifdef BIONIC ECHK(eglTerminate(display)); #endif RD_END(); }
void test_piglit(void) { RD_START("piglit-good", ""); display = get_display(); /* get an appropriate EGL frame buffer configuration */ ECHK(eglChooseConfig(display, config_attribute_list, &config, 1, &num_config)); DEBUG_MSG("num_config: %d", num_config); /* create an EGL rendering context */ ECHK(context = eglCreateContext(display, config, EGL_NO_CONTEXT, context_attribute_list)); surface = make_window(display, config, 250, 250); ECHK(eglQuerySurface(display, surface, EGL_WIDTH, &width)); ECHK(eglQuerySurface(display, surface, EGL_HEIGHT, &height)); DEBUG_MSG("Buffer: %dx%d", width, height); /* connect the context to the surface */ ECHK(eglMakeCurrent(display, surface, surface, context)); program = get_program(vertex_shader_source, fragment_shader_source); GCHK(glBindAttribLocation(program, 0, "vertex")); link_program(program); GCHK(glViewport(0, 0, width, height)); /* clear the color buffer */ GCHK(glClearColor(0.5, 0.5, 0.5, 0.5)); GCHK(glClear(GL_COLOR_BUFFER_BIT)); GCHK(glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, (GLfloat[]){ 20.0, 5.0, 0.0, 1.0, 30.0, 5.0, 0.0, 1.0, 20.0, 15.0, 0.0, 1.0, 30.0, 15.0, 0.0, 1.0 })); GCHK(glEnableVertexAttribArray(0)); /* now set up our uniforms. */ GCHK(uniform_location = glGetUniformLocation(program, "row")); GCHK(glUniform1i(uniform_location, 1)); GCHK(uniform_location = glGetUniformLocation(program, "expect")); GCHK(glUniform1fv(uniform_location, 1, (GLfloat[]){ 4 })); GCHK(glDrawArrays(GL_TRIANGLE_STRIP, 0, 4)); ECHK(eglSwapBuffers(display, surface)); GCHK(glFlush()); usleep(1000000); eglTerminate(display); RD_END(); }
void test_copy(uint32_t w, uint32_t h, uint32_t format) { PixmapPtr src, dest; C2D_OBJECT blit = {}; C2D_RECT rect; c2d_ts_handle curTimestamp; DEBUG_MSG("----------------------------------------------------------------"); DEBUG_MSG("copy: %04dx%04d-%08x", w, h, format); RD_START("copy", "%dx%d format:%08x", w, h, format); dest = create_pixmap(w, h, format); src = create_pixmap(13, 17, format); rect.x = 1; rect.y = 2; rect.width = w - 2; rect.height = h - 3; CHK(c2dFillSurface(dest->id, 0xff556677, &rect)); CHK(c2dFlush(dest->id, &curTimestamp)); CHK(c2dWaitTimestamp(curTimestamp)); rect.x = 0; rect.y = 0; rect.width = 13; rect.height = 17; CHK(c2dFillSurface(src->id, 0xff223344, &rect)); CHK(c2dFlush(src->id, &curTimestamp)); CHK(c2dWaitTimestamp(curTimestamp)); blit.surface_id = src->id; blit.config_mask = DEFAULT_BLIT_MASK; blit.next = NULL; blit.source_rect.x = FIXED(1); blit.source_rect.y = FIXED(2); blit.source_rect.width = FIXED(13-1); blit.source_rect.height = FIXED(17-2); blit.target_rect.x = FIXED((w - 13) / 2); blit.target_rect.y = FIXED((h - 17) / 2); blit.target_rect.width = FIXED(13); blit.target_rect.height = FIXED(17); CHK(c2dDraw(dest->id, 0, NULL, 0, 0, &blit, 1)); CHK(c2dFlush(dest->id, &curTimestamp)); CHK(c2dWaitTimestamp(curTimestamp)); RD_END(); dump_pixmap(dest, "copy-%04dx%04d-%08x.bmp", w, h, format); }
void test_caps(void) { GLint width, height; EGLint pbuffer_attribute_list[] = { EGL_WIDTH, 256, EGL_HEIGHT, 256, EGL_LARGEST_PBUFFER, EGL_TRUE, EGL_NONE }; EGLSurface surface; int i; RD_START("caps", ""); ECHK(surface = eglCreatePbufferSurface(display, config, pbuffer_attribute_list)); ECHK(eglQuerySurface(display, surface, EGL_WIDTH, &width)); ECHK(eglQuerySurface(display, surface, EGL_HEIGHT, &height)); DEBUG_MSG("PBuffer: %dx%d", width, height); /* connect the context to the surface */ ECHK(eglMakeCurrent(display, surface, surface, context)); GCHK(glFlush()); printf("EGL Version %s\n", eglQueryString(display, EGL_VERSION)); printf("EGL Vendor %s\n", eglQueryString(display, EGL_VENDOR)); printf("EGL Extensions %s\n", eglQueryString(display, EGL_EXTENSIONS)); printf("GL Version %s\n", glGetString(GL_VERSION)); printf("GL extensions: %s\n", glGetString(GL_EXTENSIONS)); for (i = 0; i < ARRAY_SIZE(int_params); i++) { GLint val[4] = {}; GLenum err; glGetIntegerv(int_params[i].pname, val); err = glGetError(); if (err != GL_NO_ERROR) { printf("no %s: %s\n", int_params[i].name, glStrError(err)); } else { printf("%s: %d %d %d %d\n", int_params[i].name, val[0], val[1], val[2], val[3]); } } RD_END(); }
void test_triangle_quad(void) { EGLDisplay display; EGLConfig config; EGLint num_config; EGLContext context; EGLSurface surface; GLuint program; GLint width, height; int uniform_location; const char *vertex_shader_source = "precision mediump float; \n" "attribute vec4 aPosition; \n" " \n" "void main() \n" "{ \n" " gl_Position = aPosition; \n" "} \n"; const char *fragment_shader_source = "precision mediump float; \n" "uniform vec4 uColor; \n" " \n" "void main() \n" "{ \n" " gl_FragColor = uColor; \n" "} \n"; GLfloat vertices[] = { /* triangle */ -0.8, 0.50, 0.0, -0.2, 0.50, 0.0, -0.5, -0.50, 0.0, /* quad */ 0.2, -0.50, 0.0, 0.8, -0.50, 0.0, 0.2, 0.50, 0.0, 0.8, 0.50, 0.0 }; GLfloat triangle_color[] = {0.0, 1.0, 0.0, 1.0 }; GLfloat quad_color[] = {1.0, 0.0, 0.0, 1.0 }; DEBUG_MSG("----------------------------------------------------------------"); RD_START("triangle-quad", ""); display = get_display(); /* get an appropriate EGL frame buffer configuration */ ECHK(eglChooseConfig(display, config_attribute_list, &config, 1, &num_config)); DEBUG_MSG("num_config: %d", num_config); /* create an EGL rendering context */ ECHK(context = eglCreateContext(display, config, EGL_NO_CONTEXT, context_attribute_list)); ECHK(surface = eglCreatePbufferSurface(display, config, pbuffer_attribute_list)); ECHK(eglQuerySurface(display, surface, EGL_WIDTH, &width)); ECHK(eglQuerySurface(display, surface, EGL_HEIGHT, &height)); DEBUG_MSG("PBuffer: %dx%d", width, height); /* connect the context to the surface */ ECHK(eglMakeCurrent(display, surface, surface, context)); GCHK(glFlush()); program = get_program(vertex_shader_source, fragment_shader_source); GCHK(glBindAttribLocation(program, 0, "aPosition")); link_program(program); GCHK(glViewport(0, 0, width, height)); GCHK(glFlush()); /* clear the color buffer */ GCHK(glClearColor(0.3125, 0.3125, 0.3125, 1.0)); GCHK(glFlush()); GCHK(glClear(GL_COLOR_BUFFER_BIT)); GCHK(glFlush()); GCHK(glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, vertices)); GCHK(glFlush()); GCHK(glEnableVertexAttribArray(0)); GCHK(glFlush()); /* now set up our uniform. */ GCHK(uniform_location = glGetUniformLocation(program, "uColor")); GCHK(glUniform4fv(uniform_location, 1, triangle_color)); GCHK(glFlush()); GCHK(glDrawArrays(GL_TRIANGLES, 0, 3)); GCHK(glFlush()); GCHK(glUniform4fv(uniform_location, 1, quad_color)); GCHK(glFlush()); GCHK(glDrawArrays(GL_TRIANGLE_STRIP, 3, 4)); GCHK(glFlush()); ECHK(eglSwapBuffers(display, surface)); GCHK(glFlush()); usleep(1000000); RD_END(); }
void test_stencil(void) { GLint numStencilBits; GLuint stencilValues[NumTests] = { 0x7, // Result of test 0 0x0, // Result of test 1 0x2, // Result of test 2 0xff // Result of test 3. We need to fill this value in a run-time }; int i; DEBUG_MSG("----------------------------------------------------------------"); RD_START("stencil", ""); ECHK(surface = eglCreatePbufferSurface(display, config, pbuffer_attribute_list)); ECHK(eglQuerySurface(display, surface, EGL_WIDTH, &width)); ECHK(eglQuerySurface(display, surface, EGL_HEIGHT, &height)); DEBUG_MSG("PBuffer: %dx%d", width, height); /* connect the context to the surface */ ECHK(eglMakeCurrent(display, surface, surface, context)); GCHK(glFlush()); if (!program) { program = get_program(vertex_shader_source, fragment_shader_source); GCHK(glBindAttribLocation(program, 0, "aPosition")); link_program(program); /* now set up our uniform. */ GCHK(uniform_location = glGetUniformLocation(program, "uColor")); } GCHK(glClearColor(0.0, 0.0, 0.0, 0.0)); GCHK(glClearStencil(0x1)); GCHK(glClearDepthf(0.75)); GCHK(glEnable(GL_DEPTH_TEST)); GCHK(glEnable(GL_STENCIL_TEST)); // Set the viewport GCHK(glViewport(0, 0, width, height)); // Clear the color, depth, and stencil buffers. At this // point, the stencil buffer will be 0x1 for all pixels GCHK(glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT)); // Use the program object GCHK(glUseProgram(program)); // Load the vertex position GCHK(glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, vVertices)); GCHK(glEnableVertexAttribArray(0)); // Test 0: // // Initialize upper-left region. In this case, the // stencil-buffer values will be replaced because the // stencil test for the rendered pixels will fail the // stencil test, which is // // ref mask stencil mask // ( 0x7 & 0x3 ) < ( 0x1 & 0x7 ) // // The value in the stencil buffer for these pixels will // be 0x7. // GCHK(glStencilFunc(GL_LESS, 0x7, 0x3)); GCHK(glStencilOp(GL_REPLACE, GL_DECR, GL_DECR)); GCHK(glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, indices[0])); // Test 1: // // Initialize the upper-right region. Here, we'll decrement // the stencil-buffer values where the stencil test passes // but the depth test fails. The stencil test is // // ref mask stencil mask // ( 0x3 & 0x3 ) > ( 0x1 & 0x3 ) // // but where the geometry fails the depth test. The // stencil values for these pixels will be 0x0. // GCHK(glStencilFunc(GL_GREATER, 0x3, 0x3)); GCHK(glStencilOp(GL_KEEP, GL_DECR, GL_KEEP)); GCHK(glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, indices[1])); // Test 2: // // Initialize the lower-left region. Here we'll increment // (with saturation) the stencil value where both the // stencil and depth tests pass. The stencil test for // these pixels will be // // ref mask stencil mask // ( 0x1 & 0x3 ) == ( 0x1 & 0x3 ) // // The stencil values for these pixels will be 0x2. // GCHK(glStencilFunc(GL_EQUAL, 0x1, 0x3)); GCHK(glStencilOp(GL_KEEP, GL_INCR, GL_INCR)); GCHK(glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, indices[2])); // Test 3: // // Finally, initialize the lower-right region. We'll invert // the stencil value where the stencil tests fails. The // stencil test for these pixels will be // // ref mask stencil mask // ( 0x2 & 0x1 ) == ( 0x1 & 0x1 ) // // The stencil value here will be set to ~((2^s-1) & 0x1), // (with the 0x1 being from the stencil clear value), // where 's' is the number of bits in the stencil buffer // GCHK(glStencilFunc(GL_EQUAL, 0x2, 0x1)); GCHK(glStencilOp(GL_INVERT, GL_KEEP, GL_KEEP)); GCHK(glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, indices[3])); // Since we don't know at compile time how many stencil bits are present, // we'll query, and update the value correct value in the // stencilValues arrays for the fourth tests. We'll use this value // later in rendering. GCHK(glGetIntegerv(GL_STENCIL_BITS, &numStencilBits)); stencilValues[3] = ~(((1 << numStencilBits) - 1) & 0x1) & 0xff; // Use the stencil buffer for controlling where rendering will // occur. We disable writing to the stencil buffer so we // can test against them without modifying the values we // generated. GCHK(glStencilMask(0x0)); for (i = 0; i < NumTests; i++) { GCHK(glStencilFunc(GL_EQUAL, stencilValues[i], 0xff)); GCHK(glUniform4fv(uniform_location, 1, colors[i])); GCHK(glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, indices[4])); } ECHK(eglSwapBuffers(display, surface)); GCHK(glFlush()); ECHK(eglDestroySurface(display, surface)); GCHK(glFlush()); usleep(1000000); dump_bmp(display, surface, "stencil.bmp"); RD_END(); }
int main(int argc, char **argv) { struct fd_state *state; struct fd_surface *surface, *lolstex1, *lolstex2; struct fd_program *cat_program, *tex_program; struct fd_bo *position_vbo, *normal_vbo; const char *cat_vertex_shader_asm = "@varying(R0) vertex_normal \n" "@varying(R1) vertex_position \n" "@attribute(R1) normal \n" "@attribute(R2) position \n" "@uniform(C0-C3) ModelViewMatrix \n" "@uniform(C4-C7) ModelViewProjectionMatrix \n" "@uniform(C8-C10) NormalMatrix \n" "@const(C11) 1.000000, 0.000000, 0.000000, 0.000000 \n" "EXEC \n" " FETCH: VERTEX R1.xyz_ = R0.x FMT_32_32_32_FLOAT SIGNED STRIDE(12) CONST(20, 0)\n" " FETCH: VERTEX R2.xyz_ = R0.x FMT_32_32_32_FLOAT SIGNED STRIDE(12) CONST(20, 1)\n" " (S)ALU: MULADDv R0 = C7, R2.zzzz, C6 \n" " ALU: MULADDv R0 = R0, R2.yyyy, C5 \n" "ALLOC POSITION SIZE(0x0) \n" "EXEC \n" " ALU: MULADDv export62 = R0, R2.xxxx, C4 ; gl_Position \n" " ALU: MULv R0.xyz_ = R1.zzzw, C10 \n" " ALU: MULADDv R0.xyz_ = R0, R1.yyyw, C9 \n" " ALU: MULADDv R0.xyz_ = R0, R1.xxxw, C8 \n" " ALU: DOT3v R1.x___ = R0, R0 \n" " ALU: MULADDv R3 = C3, R2.zzzz, C2 \n" "EXEC \n" " ALU: MULADDv R3 = R3, R2.yyyy, C1 \n" " ALU: MAXv R0.____ = R0, R0 \n" " RECIPSQ_IEEE R0.___w = R1.xyzx \n" "ALLOC PARAM/PIXEL SIZE(0x1) \n" "EXEC_END \n" " ALU: MULADDv export1 = R3, R2.xxxx, C0 \n" " ALU: MULv export0.xyz_ = R0, R0.wwww \n"; const char *cat_fragment_shader_asm = /* precision mediump float; const vec4 MaterialDiffuse = vec4(0.000000, 0.000000, 1.000000, 1.000000); const vec4 LightColor0 = vec4(0.800000, 0.800000, 0.800000, 1.000000); const vec4 light_position = vec4(0.000000, 1.000000, 0.000000, 1.000000); varying vec3 vertex_normal; varying vec4 vertex_position; void main(void) { const vec4 diffuse_light_color = LightColor0; const vec4 lightAmbient = vec4(0.1, 0.1, 0.1, 1.0); const vec4 lightSpecular = vec4(0.8, 0.8, 0.8, 1.0); const vec4 matAmbient = vec4(0.2, 0.2, 0.2, 1.0); const vec4 matSpecular = vec4(1.0, 1.0, 1.0, 1.0); const float matShininess = 100.0; // C4.x vec3 eye_direction = normalize(-vertex_position.xyz); vec3 light_direction = normalize(light_position.xyz/light_position.w - vertex_position.xyz/vertex_position.w); vec3 normalized_normal = normalize(vertex_normal); // reflect(i,n) -> i - 2 * dot(n,i) * n vec3 reflection = reflect(-light_direction, normalized_normal); float specularTerm = pow(max(0.0, dot(reflection, eye_direction)), matShininess); float diffuseTerm = max(0.0, dot(normalized_normal, light_direction)); vec4 specular = (lightSpecular * matSpecular); vec4 ambient = (lightAmbient * matAmbient); vec4 diffuse = (diffuse_light_color * MaterialDiffuse); vec4 result = (specular * specularTerm) + ambient + (diffuse * diffuseTerm); gl_FragColor = result; } */ "@varying(R0) vertex_normal \n" "@varying(R1) vertex_position \n" "@const(C0) 0.000000, 1.000000, 0.000000, 0.000000 \n" "@const(C1) 0.800000, 0.800000, 0.800000, 1.000000 \n" "@const(C2) 0.020000, 0.020000, 0.020000, 1.000000 \n" "@const(C3) 0.000000, 0.000000, 0.800000, 1.000000 \n" "@const(C4) 100.000000, 0.000000, 0.000000, 0.000000 \n" "EXEC \n" " (S)ALU: DOT3v R2.x___ = R0, R0 ; normalize(vertex_normal) \n" " RECIP_IEEE R3.x___ = R1 ; 1/vertex_position.x ? R1.wyzw? \n" " ALU: MULADDv R3.xyz_ = C0.xyxw, -R1, R3.xxxw ; light_position.xyz/1.0 - \n" " ; vertex_position.xyz/vertex_position.w \n" " ALU: DOT3v R2.x___ = R3, R3 ; normalize(light_position...) \n" " RECIPSQ_IEEE R0.___w = R2.xyzx ; normalize(vertex_normal) \n" "; here the RSQ sees the R2 value written in first instruction, rather than \n" "; the R2 dst being calculated as part of the same VLIW instruction \n" " ALU: MULv R0.xyz_ = R0, R0.wwww ; normalized_normal = normalize(vertex_normal) \n" " RECIPSQ_IEEE R0.___w = R2.xyzx ; normalize(light_position...) \n" " ALU: MULv R2.xyz_ = R3, R0.wwww ; light_direction = normalize(light_position...) \n" " ALU: DOT3v R3.x___ = -R1, -R1 ; normalize(-vertex_position.xyz) \n" "EXEC \n" "; reflect(i,n) -> i - 2 * dot(n,i) * n \n" " ALU: DOT3v R3.x___ = -R2, R0 ; reflect(-light_direction, normalized_normal) \n" " RECIPSQ_IEEE R0.___w = R3.xyzx ; normalize(-vertex_position.xyz); \n" " ALU: MULv R1.xyz_ = -R1, R0.wwww ; eye_direction = normalize(-vertex_position.xyz) \n" " ADDs R3.x___ = R3.xyzx ; 2 * dot(n, i) \n" " ALU: MULADDv R3.xyz_ = -R2, R0, -R3.xxxw ; reflect(..) -> i + (n * (2 * dot(n, i)) \n" " ALU: DOT3v R1.x___ = R1, R3 ; dot(reflection, eye_direction) \n" " ALU: MAXv R1.x___ = R1, C0 ; max(0.0, dot(reflection, eye_direction) \n" " ALU: DOT3v R0.x___ = R2, R0 ; dot(normalized_normal, light_direction) \n" " LOG_CLAMP R0.___w = R1.xyzx ; pow(max(0.0, dot(...)), matShininess) \n" "EXEC \n" " ALU: MAXv R0.x___ = R0, C0 ; diffuseTerm = max(0.0, dot(...)) \n" " MUL_CONST_0 R0.___w = C4.wyzx ; specularTerm = pow(..., matShininess) \n" " ALU: MAXv R0.____ = R0, R0 \n" " EXP_IEEE R1.x___ = R0 ; specularTerm = pow(..) \n" "; C2 is ambient = (lightAmbient * matAmbient) = vec4(0.1,0.1,0.1,1.0) * vec4(0.2,0.2,0.2,1.0) \n" "; C1 is specular = (lightSpecular * matSpecular) = vec4(0.8,0.8,0.8,1.0) * vec4(1.0,1.0,1.0,1.0) \n" " ALU: MULADDv R1.x__w = C2, R1.xyzx, C1 ; ambient + (specularTerm * specular) \n" "ALLOC PARAM/PIXEL SIZE(0x0) \n" "EXEC_END ADDR(0x12) CNT(0x1) \n" " ALU: MULADDv export0 = R1.xxxw, R0.xxxx, C3.xxzw ; gl_FragColor \n" "NOP \n"; static const GLfloat texcoords[] = { 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, }; static const GLfloat tex1_vertices[] = { -0.95, +0.45, -1.0, +0.45, +0.45, -1.0, -0.95, +0.95, -1.0, +0.45, +0.95, -1.0 }; static const GLfloat tex2_vertices[] = { -0.45, -0.95, -1.0, +0.95, -0.95, -1.0, -0.45, -0.45, -1.0, +0.95, -0.45, -1.0 }; const char *tex_vertex_shader_asm = "@attribute(R1) aPosition \n" "@attribute(R2) aTexCoord \n" "@varying(R0) vTexCoord \n" "EXEC \n" " FETCH: VERTEX R2.xy11 = R0.x FMT_32_32_FLOAT SIGNED \n" " STRIDE(8) CONST(20, 1) \n" " (S)FETCH: VERTEX R1.xyz1 = R0.x FMT_32_32_32_FLOAT SIGNED \n" " STRIDE(12) CONST(20, 0) \n" "ALLOC POSITION SIZE(0x0) \n" "EXEC \n" " ALU: MAXv export62 = R1, R1 ; gl_Position \n" "ALLOC PARAM/PIXEL SIZE(0x0) \n" "EXEC_END \n" " ALU: MAXv export0 = R2, R2 ; vTexCoord \n" "NOP \n"; const char *tex_fragment_shader_asm = "@varying(R0) vTexCoord \n" "@sampler(0) uTexture \n" "EXEC \n" " (S)FETCH: SAMPLE R0.xyzw = R0.xyx CONST(0) \n" "ALLOC PARAM/PIXEL SIZE(0x0) \n" "EXEC_END \n" " ALU: MAXv export0 = R0, R0 ; gl_FragColor \n" "NOP \n"; uint32_t width = 0, height = 0; int i, n = 1; if (argc == 2) n = atoi(argv[1]); DEBUG_MSG("----------------------------------------------------------------"); RD_START("fd-cat", ""); state = fd_init(); if (!state) return -1; surface = fd_surface_screen(state, &width, &height); if (!surface) return -1; /* load textures: */ lolstex1 = fd_surface_new_fmt(state, lolstex1_image.width, lolstex1_image.height, COLORX_8_8_8_8); fd_surface_upload(lolstex1, lolstex1_image.pixel_data); lolstex2 = fd_surface_new_fmt(state, lolstex2_image.width, lolstex2_image.height, COLORX_8_8_8_8); fd_surface_upload(lolstex2, lolstex2_image.pixel_data); fd_enable(state, GL_CULL_FACE); fd_depth_func(state, GL_LEQUAL); fd_enable(state, GL_DEPTH_TEST); fd_tex_param(state, GL_TEXTURE_MAG_FILTER, GL_LINEAR); fd_tex_param(state, GL_TEXTURE_MIN_FILTER, GL_LINEAR); fd_blend_func(state, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); /* this needs to come after enabling depth test as enabling depth test * effects bin sizes: */ fd_make_current(state, surface); /* construct the two shader programs: */ cat_program = fd_program_new(); fd_program_attach_asm(cat_program, FD_SHADER_VERTEX, cat_vertex_shader_asm); fd_program_attach_asm(cat_program, FD_SHADER_FRAGMENT, cat_fragment_shader_asm); tex_program = fd_program_new(); fd_program_attach_asm(tex_program, FD_SHADER_VERTEX, tex_vertex_shader_asm); fd_program_attach_asm(tex_program, FD_SHADER_FRAGMENT, tex_fragment_shader_asm); fd_link(state); position_vbo = fd_attribute_bo_new(state, cat_position_sz, cat_position); normal_vbo = fd_attribute_bo_new(state, cat_normal_sz, cat_normal); for (i = 0; i < n; i++) { GLfloat aspect = (GLfloat)height / (GLfloat)width; ESMatrix modelview; ESMatrix projection; ESMatrix modelviewprojection; float normal[9]; float scale = 1.8; esMatrixLoadIdentity(&modelview); esTranslate(&modelview, 0.0f, 0.0f, -8.0f); esRotate(&modelview, 45.0f - (0.5f * i), 0.0f, 1.0f, 0.0f); esMatrixLoadIdentity(&projection); esFrustum(&projection, -scale, +scale, -scale * aspect, +scale * aspect, 5.5f, 10.0f); esMatrixLoadIdentity(&modelviewprojection); esMatrixMultiply(&modelviewprojection, &modelview, &projection); normal[0] = modelview.m[0][0]; normal[1] = modelview.m[0][1]; normal[2] = modelview.m[0][2]; normal[3] = modelview.m[1][0]; normal[4] = modelview.m[1][1]; normal[5] = modelview.m[1][2]; normal[6] = modelview.m[2][0]; normal[7] = modelview.m[2][1]; normal[8] = modelview.m[2][2]; fd_clear_color(state, 0xff000000); fd_clear(state, GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); fd_attribute_bo(state, "normal", normal_vbo); fd_attribute_bo(state, "position", position_vbo); fd_uniform_attach(state, "ModelViewMatrix", 4, 4, &modelview.m[0][0]); fd_uniform_attach(state, "ModelViewProjectionMatrix", 4, 4, &modelviewprojection.m[0][0]); fd_uniform_attach(state, "NormalMatrix", 3, 3, normal); /* draw cat: */ fd_disable(state, GL_BLEND); fd_set_program(state, cat_program); fd_draw_arrays(state, GL_TRIANGLES, 0, cat_vertices); /* setup to draw text (common to tex1 and tex2): */ fd_enable(state, GL_BLEND); fd_set_program(state, tex_program); fd_attribute_pointer(state, "aTexCoord", 2, 4, texcoords); /* draw tex1: */ fd_set_texture(state, "uTexture", lolstex1); fd_attribute_pointer(state, "aPosition", 3, 4, tex1_vertices); fd_draw_arrays(state, GL_TRIANGLE_STRIP, 0, 4); /* draw tex2: */ fd_set_texture(state, "uTexture", lolstex2); fd_attribute_pointer(state, "aPosition", 3, 4, tex2_vertices); fd_draw_arrays(state, GL_TRIANGLE_STRIP, 0, 4); fd_swap_buffers(state); } fd_flush(state); fd_dump_bmp(surface, "lolscat.bmp"); fd_fini(state); RD_END(); return 0; }
int main(int argc, char **argv) { struct fd_state *state; struct fd_surface *surface; int width, height; static const GLfloat vertices[] = { -0.75f, +0.25f, +0.50f, // Quad #0 -0.25f, +0.25f, +0.50f, -0.25f, +0.75f, +0.50f, -0.75f, +0.75f, +0.50f, +0.25f, +0.25f, +0.90f, // Quad #1 +0.75f, +0.25f, +0.90f, +0.75f, +0.75f, +0.90f, +0.25f, +0.75f, +0.90f, -0.75f, -0.75f, +0.50f, // Quad #2 -0.25f, -0.75f, +0.50f, -0.25f, -0.25f, +0.50f, -0.75f, -0.25f, +0.50f, +0.25f, -0.75f, +0.50f, // Quad #3 +0.75f, -0.75f, +0.50f, +0.75f, -0.25f, +0.50f, +0.25f, -0.25f, +0.50f, -1.00f, -1.00f, +0.00f, // Big Quad +1.00f, -1.00f, +0.00f, +1.00f, +1.00f, +0.00f, -1.00f, +1.00f, +0.00f, }; static const GLubyte indices[][6] = { { 0, 1, 2, 0, 2, 3 }, // Quad #0 { 4, 5, 6, 4, 6, 7 }, // Quad #1 { 8, 9, 10, 8, 10, 11 }, // Quad #2 { 12, 13, 14, 12, 14, 15 }, // Quad #3 { 16, 17, 18, 16, 18, 19 }, // Big Quad }; #define NumTests 4 static const GLfloat colors[NumTests][4] = { { 1.0f, 0.0f, 0.0f, 1.0f }, { 0.0f, 1.0f, 0.0f, 1.0f }, { 0.0f, 0.0f, 1.0f, 1.0f }, { 1.0f, 1.0f, 0.0f, 0.0f }, }; #if 0 const char *vertex_shader_source = "attribute vec4 aPosition; \n" " \n" "void main() \n" "{ \n" " gl_Position = aPosition; \n" "} \n"; const char *fragment_shader_source = "precision highp float; \n" "uniform vec4 uColor; \n" " \n" "void main() \n" "{ \n" " gl_FragColor = uColor; \n" "} \n"; #else const char *vertex_shader_asm = "@attribute(R1) aPosition \n" "EXEC \n" " (S)FETCH: VERTEX R1.xyz1 = R0.x FMT_32_32_32_FLOAT SIGNED \n" " STRIDE(12) CONST(20, 0) \n" "ALLOC POSITION SIZE(0x0) \n" "EXEC \n" " ALU: MAXv export62 = R1, R1 ; gl_Position \n" "ALLOC PARAM/PIXEL SIZE(0x0) \n" "EXEC_END \n" "NOP \n"; const char *fragment_shader_asm = "@uniform(C0) uColor \n" "ALLOC PARAM/PIXEL SIZE(0x0) \n" "EXEC_END \n" " ALU: MAXv export0 = C0, C0 ; gl_FragColor \n"; #endif GLint numStencilBits; GLuint stencilValues[NumTests] = { 0x7, // Result of test 0 0x0, // Result of test 1 0x2, // Result of test 2 0xff // Result of test 3. We need to fill this value in a run-time }; int i; DEBUG_MSG("----------------------------------------------------------------"); RD_START("fd-stencil", ""); state = fd_init(); if (!state) return -1; surface = fd_surface_screen(state, &width, &height); if (!surface) return -1; fd_enable(state, GL_DEPTH_TEST); fd_enable(state, GL_STENCIL_TEST); /* this needs to come after enabling depth/stencil test as these * effect bin sizes: */ fd_make_current(state, surface); fd_vertex_shader_attach_asm(state, vertex_shader_asm); fd_fragment_shader_attach_asm(state, fragment_shader_asm); fd_link(state); fd_clear_color(state, 0x00000000); fd_clear_stencil(state, 0x1); fd_clear_depth(state, 0.75); // Clear the color, depth, and stencil buffers. At this // point, the stencil buffer will be 0x1 for all pixels fd_clear(state, GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); fd_attribute_pointer(state, "aPosition", 3, 20, vertices); fd_uniform_attach(state, "uColor", 4, 1, (GLfloat[]){ 0.0, 0.0, 0.0, 0.0, }); // Test 0: // // Initialize upper-left region. In this case, the // stencil-buffer values will be replaced because the // stencil test for the rendered pixels will fail the // stencil test, which is // // ref mask stencil mask // ( 0x7 & 0x3 ) < ( 0x1 & 0x7 ) // // The value in the stencil buffer for these pixels will // be 0x7. // fd_stencil_func(state, GL_LESS, 0x7, 0x3); fd_stencil_op(state, GL_REPLACE, GL_DECR, GL_DECR); fd_draw_elements(state, GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, indices[0]); // Test 1: // // Initialize the upper-right region. Here, we'll decrement // the stencil-buffer values where the stencil test passes // but the depth test fails. The stencil test is // // ref mask stencil mask // ( 0x3 & 0x3 ) > ( 0x1 & 0x3 ) // // but where the geometry fails the depth test. The // stencil values for these pixels will be 0x0. // fd_stencil_func(state, GL_GREATER, 0x3, 0x3); fd_stencil_op(state, GL_KEEP, GL_DECR, GL_KEEP); fd_draw_elements(state, GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, indices[1]); // Test 2: // // Initialize the lower-left region. Here we'll increment // (with saturation) the stencil value where both the // stencil and depth tests pass. The stencil test for // these pixels will be // // ref mask stencil mask // ( 0x1 & 0x3 ) == ( 0x1 & 0x3 ) // // The stencil values for these pixels will be 0x2. // fd_stencil_func(state, GL_EQUAL, 0x1, 0x3); fd_stencil_op(state, GL_KEEP, GL_INCR, GL_INCR); fd_draw_elements(state, GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, indices[2]); // Test 3: // // Finally, initialize the lower-right region. We'll invert // the stencil value where the stencil tests fails. The // stencil test for these pixels will be // // ref mask stencil mask // ( 0x2 & 0x1 ) == ( 0x1 & 0x1 ) // // The stencil value here will be set to ~((2^s-1) & 0x1), // (with the 0x1 being from the stencil clear value), // where 's' is the number of bits in the stencil buffer // fd_stencil_func(state, GL_EQUAL, 0x2, 0x1); fd_stencil_op(state, GL_INVERT, GL_KEEP, GL_KEEP); fd_draw_elements(state, GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, indices[3]); // Since we don't know at compile time how many stencil bits are present, // we'll query, and update the value correct value in the // stencilValues arrays for the fourth tests. We'll use this value // later in rendering. numStencilBits = 8; stencilValues[3] = ~(((1 << numStencilBits) - 1) & 0x1) & 0xff; // Use the stencil buffer for controlling where rendering will // occur. We disable writing to the stencil buffer so we // can test against them without modifying the values we // generated. fd_stencil_mask(state, 0x0); for (i = 0; i < NumTests; i++) { fd_stencil_func(state, GL_EQUAL, stencilValues[i], 0xff); fd_uniform_attach(state, "uColor", 4, 1, colors[i]); fd_draw_elements(state, GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, indices[4]); } fd_swap_buffers(state); fd_flush(state); fd_dump_bmp(surface, "stencil.bmp"); fd_fini(state); RD_END(); return 0; }
void test_triangle_quad(int samples, int depth, int stencil) { EGLDisplay display; EGLConfig config; EGLint num_config; EGLContext context; EGLSurface surface; GLuint program; GLint width, height; int uniform_location; const char *vertex_shader_source = "precision mediump float; \n" "attribute vec4 aPosition; \n" " \n" "void main() \n" "{ \n" " gl_Position = aPosition; \n" "} \n"; const char *fragment_shader_source = "precision mediump float; \n" "uniform vec4 uColor; \n" " \n" "void main() \n" "{ \n" " gl_FragColor = uColor; \n" "} \n"; EGLint const config_attribute_list[] = { EGL_RED_SIZE, 8, EGL_GREEN_SIZE, 8, EGL_BLUE_SIZE, 8, EGL_SURFACE_TYPE, EGL_PBUFFER_BIT, EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, EGL_STENCIL_SIZE, stencil, EGL_DEPTH_SIZE, depth, EGL_SAMPLES, samples, EGL_NONE }; GLfloat vertices[] = { /* triangle */ -0.8, 0.50, 0.0, -0.2, 0.50, 0.0, -0.5, -0.50, 0.0, /* quad */ 0.2, -0.50, 0.0, 0.8, -0.50, 0.0, 0.2, 0.50, 0.0, 0.8, 0.50, 0.0 }; GLfloat triangle_color[] = {0.0, 1.0, 0.0, 1.0 }; GLfloat quad_color[] = {1.0, 0.0, 0.0, 1.0 }; RD_START("triangle-quad", "samples=%d, depth=%d, stencil=%d", samples, depth, stencil); display = get_display(); /* get an appropriate EGL frame buffer configuration */ ECHK(eglChooseConfig(display, config_attribute_list, &config, 1, &num_config)); DEBUG_MSG("num_config: %d", num_config); /* create an EGL rendering context */ ECHK(context = eglCreateContext(display, config, EGL_NO_CONTEXT, context_attribute_list)); surface = make_window(display, config, 400, 240); ECHK(eglQuerySurface(display, surface, EGL_WIDTH, &width)); ECHK(eglQuerySurface(display, surface, EGL_HEIGHT, &height)); ECHK(eglGetConfigAttrib(display, config, EGL_SAMPLES, &samples)); ECHK(eglGetConfigAttrib(display, config, EGL_DEPTH_SIZE, &depth)); ECHK(eglGetConfigAttrib(display, config, EGL_STENCIL_SIZE, &stencil)); DEBUG_MSG("Buffer: %dx%d (samples=%d, depth=%d, stencil=%d)", width, height, samples, depth, stencil); /* connect the context to the surface */ ECHK(eglMakeCurrent(display, surface, surface, context)); program = get_program(vertex_shader_source, fragment_shader_source); GCHK(glBindAttribLocation(program, 0, "aPosition")); link_program(program); GCHK(glViewport(0, 0, width, height)); /* clear the color buffer */ GCHK(glClearColor(0.3125, 0.3125, 0.3125, 1.0)); GCHK(glClear(GL_COLOR_BUFFER_BIT)); GCHK(glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, vertices)); GCHK(glEnableVertexAttribArray(0)); /* now set up our uniform. */ GCHK(uniform_location = glGetUniformLocation(program, "uColor")); GCHK(glUniform4fv(uniform_location, 1, triangle_color)); GCHK(glDrawArrays(GL_TRIANGLES, 0, 3)); GCHK(glUniform4fv(uniform_location, 1, quad_color)); GCHK(glDrawArrays(GL_TRIANGLE_STRIP, 3, 4)); ECHK(eglSwapBuffers(display, surface)); GCHK(glFlush()); usleep(1000000); RD_END(); }
static void run_test(int image_width, int image_height, int image_pitch, int chan_order, int chan_type) { unsigned int num_platforms; int err, i; #define NAME(x) [x & 0xf] = #x static const char *channel_orders[] = { NAME(CL_R), NAME(CL_A), NAME(CL_RG), NAME(CL_RA), NAME(CL_RGB), NAME(CL_RGBA), NAME(CL_BGRA), NAME(CL_ARGB), NAME(CL_INTENSITY), NAME(CL_LUMINANCE), NAME(CL_Rx), NAME(CL_RGx), NAME(CL_RGBx), }; static const char *channel_types[] = { NAME(CL_SNORM_INT8), NAME(CL_SNORM_INT16), NAME(CL_UNORM_INT8), NAME(CL_UNORM_INT16), NAME(CL_UNORM_SHORT_565), NAME(CL_UNORM_SHORT_555), NAME(CL_UNORM_INT_101010), NAME(CL_SIGNED_INT8), NAME(CL_SIGNED_INT16), NAME(CL_SIGNED_INT32), NAME(CL_UNSIGNED_INT8), NAME(CL_UNSIGNED_INT16), NAME(CL_UNSIGNED_INT32), NAME(CL_HALF_FLOAT), NAME(CL_FLOAT), }; size_t global; // global domain size for our calculation size_t local; // local domain size for our calculation size_t bin_size; size_t len; unsigned char *bin; cl_platform_id platform; cl_device_id device_id; // compute device id cl_context context; // compute context cl_command_queue commands; // compute command queue cl_program program; // compute program cl_kernel kernel; // compute kernel cl_mem input1, input2; // device memory used for the input array cl_mem output; // device memory used for the output array RD_START("image", "width=%d, height=%d, pitch=%d, order=%s, type=%s", image_width, image_height, image_pitch, channel_orders[chan_order & 0xf], channel_types[chan_type & 0xf]); CCHK(clGetPlatformIDs(1, &platform, &num_platforms)); CCHK(clGetPlatformInfo(platform, CL_PLATFORM_EXTENSIONS, sizeof(buffer), buffer, &len)); DEBUG_MSG("extensions=%s\n", buffer); CCHK(clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 1, &device_id, NULL)); CCHK(clGetDeviceInfo(device_id, CL_DEVICE_VERSION, sizeof(buffer), buffer, &len)); DEBUG_MSG("version=%s\n", buffer); CCHK(clGetDeviceInfo(device_id, CL_DEVICE_EXTENSIONS, sizeof(buffer), buffer, &len)); DEBUG_MSG("device extensions=%s\n", buffer); context = clCreateContext(0, 1, &device_id, NULL, NULL, NULL); commands = clCreateCommandQueue(context, device_id, 0, NULL); program = clCreateProgramWithSource(context, 1, (const char **) &KernelSource, NULL, NULL); CCHK(clBuildProgram(program, 0, NULL, "-cl-mad-enable -DFILTER_SIZE=1 " "-DSAMP_MODE=CLK_NORMALIZED_COORDS_FALSE|CLK_ADDRESS_CLAMP_TO_EDGE|CLK_FILTER_NEAREST", NULL, NULL)); kernel = clCreateKernel(program, "test_kernel", NULL); /* fill buffer with dummy pattern: */ for (i = 0; i < 256; i++) buffer[i] = i; const cl_image_format format = { chan_order, chan_type }; input1 = clCreateImage2D(context, CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR, &format, image_width, image_height, image_pitch, buffer, &err); CCHK(err); input2 = clCreateImage2D(context, CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR, &format, image_width+1, image_height+1, image_pitch, buffer + 4, &err); CCHK(err); output = clCreateImage2D(context, CL_MEM_WRITE_ONLY, &format, image_width+2, image_height+2, 0, NULL, &err); CCHK(err); CCHK(clSetKernelArg(kernel, 0, sizeof(cl_mem), &input1)); CCHK(clSetKernelArg(kernel, 1, sizeof(cl_mem), &input2)); CCHK(clSetKernelArg(kernel, 2, sizeof(cl_mem), &output)); CCHK(clGetKernelWorkGroupInfo(kernel, device_id, CL_KERNEL_WORK_GROUP_SIZE, sizeof(local), &local, NULL)); global = 1024; CCHK(clEnqueueNDRangeKernel(commands, kernel, 1, NULL, &global, &local, 0, NULL, NULL)); CCHK(clFinish(commands)); // CCHK(clEnqueueReadBuffer( commands, output, CL_TRUE, 0, sizeof(float) * count, results, 0, NULL, NULL)); clReleaseMemObject(input1); clReleaseMemObject(input2); clReleaseMemObject(output); clReleaseProgram(program); clReleaseKernel(kernel); clReleaseCommandQueue(commands); clReleaseContext(context); RD_END(); }
/* Run through multiple variants to detect clear color, quad color (frag * shader param), and vertices */ void test_tex(int nvtex, int nftex, int bcolor) { GLint width, height; EGLint pbuffer_attribute_list[] = { EGL_WIDTH, 256, EGL_HEIGHT, 256, EGL_LARGEST_PBUFFER, EGL_TRUE, EGL_NONE }; GLfloat quad_color[] = {1.0, 0.0, 0.0, 1.0}; GLfloat vertices[] = { -0.45, -0.75, 0.0, 0.45, -0.75, 0.0, -0.45, 0.75, 0.0, 0.45, 0.75, 0.0 }; GLfloat bcolors[][4] = { { 0.25, 0.50, 0.75, 1.0 }, { 1.00, 0.00, 0.00, 1.0 }, { 0.00, 1.00, 0.00, 1.0 }, { 0.00, 0.00, 1.00, 1.0 }, }; EGLSurface surface; int n; RD_START("tex", "%d vtex, %d ftex, bcolor=%d", nvtex, nftex, bcolor); ECHK(surface = eglCreatePbufferSurface(display, config, pbuffer_attribute_list)); ECHK(eglQuerySurface(display, surface, EGL_WIDTH, &width)); ECHK(eglQuerySurface(display, surface, EGL_HEIGHT, &height)); DEBUG_MSG("PBuffer: %dx%d", width, height); /* connect the context to the surface */ ECHK(eglMakeCurrent(display, surface, surface, context)); program = get_program(vertex_shader_source[nvtex], fragment_shader_source[nftex]); GCHK(glBindAttribLocation(program, 0, "aPosition")); link_program(program); GCHK(glViewport(0, 0, width, height)); GCHK(glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, vertices)); GCHK(glEnableVertexAttribArray(0)); /* now set up our uniforms/textures. */ GCHK(uniform_location = glGetUniformLocation(program, "uColor")); GCHK(glUniform4fv(uniform_location, 1, quad_color)); for (n = 0; n < max(nvtex, nftex); n++) { GLuint texturename = 0, texture_handle; static char name[8]; GCHK(glActiveTexture(tex_enums[n])); GCHK(glGenTextures(1, &texturename)); GCHK(glBindTexture(GL_TEXTURE_2D, texturename)); GCHK(glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, cube_texture.width, cube_texture.height, 0, GL_RGB, GL_UNSIGNED_BYTE, cube_texture.pixel_data)); GCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)); GCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)); if (bcolor) { GCHK(glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR_EXT, bcolors[n])); GCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER_EXT)); GCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER_EXT)); GCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R_OES, GL_CLAMP_TO_BORDER_EXT)); } else { GCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT)); GCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT)); GCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R_OES, GL_REPEAT)); } sprintf(name, "uTex%d", n+1); GCHK(texture_handle = glGetUniformLocation(program, name)); GCHK(glUniform1i(texture_handle, n)); } GCHK(glDrawArrays(GL_TRIANGLE_STRIP, 0, 4)); GCHK(glFlush()); ECHK(eglSwapBuffers(display, surface)); ECHK(eglDestroySurface(display, surface)); GCHK(glFlush()); RD_END(); }
void test_quad_textured(int shadow, int cfunc) { GLint width, height; GLuint textures[2], texture_handle; GLfloat vVertices[] = { // front -0.45, -0.75, 0.0, 0.45, -0.75, 0.0, -0.45, 0.75, 0.0, 0.45, 0.75, 0.0 }; GLfloat vTexCoords[] = { 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, }; EGLSurface surface; RD_START("quad-textured", "shadow=%d, cfunc=%x", shadow, cfunc); display = get_display(); /* get an appropriate EGL frame buffer configuration */ ECHK(eglChooseConfig(display, config_attribute_list, &config, 1, &num_config)); DEBUG_MSG("num_config: %d", num_config); /* create an EGL rendering context */ ECHK(context = eglCreateContext(display, config, EGL_NO_CONTEXT, context_attribute_list)); surface = make_window(display, config, 255, 255); ECHK(eglQuerySurface(display, surface, EGL_WIDTH, &width)); ECHK(eglQuerySurface(display, surface, EGL_HEIGHT, &height)); DEBUG_MSG("Buffer: %dx%d", width, height); /* connect the context to the surface */ ECHK(eglMakeCurrent(display, surface, surface, context)); printf("EGL Version %s\n", eglQueryString(display, EGL_VERSION)); printf("EGL Vendor %s\n", eglQueryString(display, EGL_VENDOR)); printf("EGL Extensions %s\n", eglQueryString(display, EGL_EXTENSIONS)); printf("GL Version %s\n", glGetString(GL_VERSION)); printf("GL extensions: %s\n", glGetString(GL_EXTENSIONS)); program = get_program(vertex_shader_source, shadow ? fragment_shader_source_shadow : fragment_shader_source); GCHK(glBindAttribLocation(program, 0, "in_position")); GCHK(glBindAttribLocation(program, 1, "in_TexCoord")); link_program(program); GCHK(glViewport(0, 0, width, height)); /* clear the color buffer */ GCHK(glClearColor(0.5, 0.5, 0.5, 1.0)); GCHK(glClear(GL_COLOR_BUFFER_BIT)); GCHK(glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, vVertices)); GCHK(glEnableVertexAttribArray(0)); GCHK(glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, vTexCoords)); GCHK(glEnableVertexAttribArray(1)); GCHK(glGenTextures(2, &textures)); GCHK(glActiveTexture(GL_TEXTURE0)); GCHK(glBindTexture(GL_TEXTURE_2D, textures[0])); if (shadow) { GCHK(glTexImage2D( GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, cube_texture.width/2, cube_texture.height/2, 0, GL_DEPTH_COMPONENT, GL_FLOAT, cube_texture.pixel_data)); } else { GCHK(glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, cube_texture.width, cube_texture.height, 0, GL_RGB, GL_UNSIGNED_BYTE, cube_texture.pixel_data)); } GCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)); GCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)); GCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)); GCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)); GCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE)); if (shadow) { #define GL_TEXTURE_COMPARE_MODE 0x884C #define GL_TEXTURE_COMPARE_FUNC 0x884D #define GL_COMPARE_REF_TO_TEXTURE 0x884E GCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE)); GCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, cfunc)); } else { float minlod = cfunc, maxlod = cfunc; GCHK(glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_LOD, minlod)); GCHK(glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_LOD, maxlod)); switch (cfunc) { case 0: GCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)); break; case 1: GCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST)); break; case 2: GCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST)); break; case 3: GCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR)); break; case 4: GCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR)); break; #ifndef GL_TEXTURE_MAX_ANISOTROPY_EXT #define GL_TEXTURE_MAX_ANISOTROPY_EXT 0x84FE #endif case 5: GCHK(glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 4)); break; case 6: GCHK(glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 8)); break; case 7: GCHK(glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 16)); break; case 8: GCHK(glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 32)); break; case 9: GCHK(glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 320)); break; } } GCHK(texture_handle = glGetUniformLocation(program, "uTexture")); GCHK(glUniform1i(texture_handle, 0)); /* '0' refers to texture unit 0. */ GCHK(glActiveTexture(GL_TEXTURE1)); GCHK(glBindTexture(GL_TEXTURE_2D, textures[1])); GCHK(glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, cube_texture.width/3, cube_texture.height-1, 0, GL_RGBA, GL_UNSIGNED_BYTE, cube_texture.pixel_data+1)); /* Note: cube turned black until these were defined. */ GCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)); GCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)); GCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)); GCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)); GCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE)); GCHK(texture_handle = glGetUniformLocation(program, "uTexture")); GCHK(glUniform1i(texture_handle, 1)); /* '1' refers to texture unit 1. */ GCHK(glEnable(GL_CULL_FACE)); GCHK(glDrawArrays(GL_TRIANGLE_STRIP, 0, 4)); ECHK(eglSwapBuffers(display, surface)); GCHK(glFlush()); sleep(1); ECHK(eglDestroySurface(display, surface)); ECHK(eglTerminate(display)); RD_END(); }
int test_compiler(int n) { static char vert_shader[64 * 1024], frag_shader[64 * 1024]; static GLfloat v[ARRAY_SIZE(attrnames)][NVERT * 4]; static int nattr = 0; GLuint program; int vert_fd, frag_fd, gs_fd, tcs_fd, tes_fd; int i, ret; vert_fd = openfile("shaders/%04d.vs", n); tcs_fd = openfile("shaders/%04d.tcs", n); tes_fd = openfile("shaders/%04d.tes", n); gs_fd = openfile("shaders/%04d.gs", n); frag_fd = openfile("shaders/%04d.fs", n); if ((vert_fd < 0) || (frag_fd < 0)) return -1; ret = read(vert_fd, vert_shader, sizeof(vert_shader)); if (ret < 0) return ret; vert_shader[ret] = '\0'; ret = read(frag_fd, frag_shader, sizeof(frag_shader)); if (ret < 0) return ret; frag_shader[ret] = '\0'; RD_START("compiler", "%d", n); program = get_program(vert_shader, frag_shader); if (tcs_fd >= 0) compile_shader(program, tcs_fd, 0x8E88/*GL_TESS_CONTROL_SHADER*/); if (tes_fd >= 0) compile_shader(program, tes_fd, 0x8E87/*GL_TESS_EVALUATION_SHADER*/); if (gs_fd >= 0) compile_shader(program, gs_fd, 0x8DD9/*GL_GEOMETRY_SHADER*/); for (i = 0; i < ARRAY_SIZE(attrnames); i++) { glBindAttribLocation(program, i, attrnames[i]); if (glGetError() == GL_NO_ERROR) { printf("use attribute: %s\n", attrnames[i]); nattr++; } /* clear any errors, just in case: */ while (glGetError() != GL_NO_ERROR) {} } link_program(program); GCHK(glFlush()); for (i = 0; i < nattr; i++) { GCHK(glVertexAttribPointer(i, 4, GL_FLOAT, GL_FALSE, 0, v[i])); GCHK(glEnableVertexAttribArray(i)); } if (tes_fd >= 0) GCHK(glDrawArrays(0x000E/*GL_PATCHES*/, 0, NVERT)); else GCHK(glDrawArrays(GL_TRIANGLES, 0, NVERT)); ECHK(eglSwapBuffers(display, surface)); GCHK(glFlush()); RD_END(); return 0; }
int main(int argc, char **argv) { uint32_t timestamp; PixmapPtr dest = NULL; int fd, ret; fd = open("replay.txt", 0); if (fd < 0) { ERROR_MSG("could not open"); return -1; } RD_START("replay", "replay"); init(); while(1) { char *line = readline(fd); DEBUG_MSG("line: %s", line); if (strstr(line, "EXA: SOLID:") == line) { int x1, y1, x2, y2; uint32_t fill; sscanf(line, "EXA: SOLID: x1=%d\ty1=%d\tx2=%d\ty2=%d\tfill=%08x", &x1, &y1, &x2, &y2, &fill); DEBUG_MSG("GOT: SOLID: x1=%d\ty1=%d\tx2=%d\ty2=%d\tfill=%08x", x1, y1, x2, y2, fill); dest = get_pixmap(fd); solid(dest, x1, y1, x2, y2, fill); } else if (strstr(line, "EXA: COPY:") == line) { int srcX, srcY, dstX, dstY, width, height; PixmapPtr src; sscanf(line, "EXA: COPY: srcX=%d\tsrcY=%d\tdstX=%d\tdstY=%d\twidth=%d\theight=%d", &srcX, &srcY, &dstX, &dstY, &width, &height); DEBUG_MSG("GOT: COPY: srcX=%d\tsrcY=%d\tdstX=%d\tdstY=%d\twidth=%d\theight=%d", srcX, srcY, dstX, dstY, width, height); dest = get_pixmap(fd); src = get_pixmap(fd); copy(dest, src, srcX, srcY, dstX, dstY, width, height); } else if (strstr(line, "EXA: COMPOSITE:") == line) { ERROR_MSG("TODO"); end(); } else if (strstr(line, "EXA: WAIT:") == line) { DEBUG_MSG("wait, timestamp=%u", timestamp); wait(timestamp); } else if (strstr(line, "FLUSH:") == line) { flush(dest, ×tamp); DEBUG_MSG("flush, timestamp=%u", timestamp); } else { ERROR_MSG("unexpected line: %s", line); end(); } } return 0; }
void test_strip_smoothed(int fbo) { GLint width, height; GLfloat vVertices[] = { -0.7, 0.7, -0.7, -0.7, 0.2, -0.4, 0.0, 0.3, -0.5, -0.2, -0.3, 0.3, 0.5, -0.2, 0.4, 0.7, -0.7, 0.7 }; GLfloat vColors[] = { 0.1, 0.1, 0.1, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 1.0, 0.0, 1.0, 1.0, 1.0, 0.9, 0.9, 0.9, 1.0}; EGLSurface surface; RD_START("strip-smoothed", "fbo=%d", fbo); display = get_display(); /* get an appropriate EGL frame buffer configuration */ ECHK(eglChooseConfig(display, config_attribute_list, &config, 1, &num_config)); DEBUG_MSG("num_config: %d", num_config); /* create an EGL rendering context */ ECHK(context = eglCreateContext(display, config, EGL_NO_CONTEXT, context_attribute_list)); surface = make_window(display, config, 256, 256); ECHK(eglQuerySurface(display, surface, EGL_WIDTH, &width)); ECHK(eglQuerySurface(display, surface, EGL_HEIGHT, &height)); DEBUG_MSG("Buffer: %dx%d", width, height); /* connect the context to the surface */ ECHK(eglMakeCurrent(display, surface, surface, context)); program = get_program(vertex_shader_source, fragment_shader_source); GCHK(glBindAttribLocation(program, 0, "aPosition")); GCHK(glBindAttribLocation(program, 1, "aColor")); link_program(program); GCHK(glViewport(0, 0, width, height)); if (fbo) GCHK(setup_fbo(width, height)); /* clear the color buffer */ GCHK(glClearColor(0.3125, 0.3125, 0.3125, 1.0)); GCHK(glClear(GL_COLOR_BUFFER_BIT)); GCHK(glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, vVertices)); GCHK(glEnableVertexAttribArray(0)); GCHK(glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 0, vColors)); GCHK(glEnableVertexAttribArray(1)); GCHK(glDrawArrays(GL_TRIANGLE_STRIP, 0, 6)); ECHK(eglSwapBuffers(display, surface)); GCHK(glFlush()); if (fbo) GCHK(cleanup_fbo()); ECHK(eglDestroySurface(display, surface)); ECHK(eglTerminate(display)); RD_END(); }
void test_cube_textured(GLint mag_filter, GLint min_filter, GLint wrap_s, GLint wrap_t) { GLint width, height; GLint modelviewmatrix_handle, modelviewprojectionmatrix_handle, normalmatrix_handle; GLuint texturename = 0, texture_handle; EGLint pbuffer_attribute_list[] = { EGL_WIDTH, 256, EGL_HEIGHT, 256, EGL_LARGEST_PBUFFER, EGL_TRUE, EGL_NONE }; GLfloat vVertices[] = { // front -1.0f, -1.0f, +1.0f, // point blue +1.0f, -1.0f, +1.0f, // point magenta -1.0f, +1.0f, +1.0f, // point cyan +1.0f, +1.0f, +1.0f, // point white // back +1.0f, -1.0f, -1.0f, // point red -1.0f, -1.0f, -1.0f, // point black +1.0f, +1.0f, -1.0f, // point yellow -1.0f, +1.0f, -1.0f, // point green // right +1.0f, -1.0f, +1.0f, // point magenta +1.0f, -1.0f, -1.0f, // point red +1.0f, +1.0f, +1.0f, // point white +1.0f, +1.0f, -1.0f, // point yellow // left -1.0f, -1.0f, -1.0f, // point black -1.0f, -1.0f, +1.0f, // point blue -1.0f, +1.0f, -1.0f, // point green -1.0f, +1.0f, +1.0f, // point cyan // top -1.0f, +1.0f, +1.0f, // point cyan +1.0f, +1.0f, +1.0f, // point white -1.0f, +1.0f, -1.0f, // point green +1.0f, +1.0f, -1.0f, // point yellow // bottom -1.0f, -1.0f, -1.0f, // point black +1.0f, -1.0f, -1.0f, // point red -1.0f, -1.0f, +1.0f, // point blue +1.0f, -1.0f, +1.0f // point magenta }; GLfloat vTexCoords[] = { //front 1.0f, 1.0f, //point blue 0.0f, 1.0f, //point magenta 1.0f, 0.0f, //point cyan 0.0f, 0.0f, //point white //back 1.0f, 1.0f, //point red 0.0f, 1.0f, //point black 1.0f, 0.0f, //point yellow 0.0f, 0.0f, //point green //right 1.0f, 1.0f, //point magenta 0.0f, 1.0f, //point red 1.0f, 0.0f, //point white 0.0f, 0.0f, //point yellow //left 1.0f, 1.0f, //point black 0.0f, 1.0f, //point blue 1.0f, 0.0f, //point green 0.0f, 0.0f, //point cyan //top 1.0f, 1.0f, //point cyan 0.0f, 1.0f, //point white 1.0f, 0.0f, //point green 0.0f, 0.0f, //point yellow //bottom 1.0f, 0.0f, //point black 0.0f, 0.0f, //point red 1.0f, 1.0f, //point blue 0.0f, 1.0f, //point magenta }; GLfloat vNormals[] = { // front +0.0f, +0.0f, +1.0f, // forward +0.0f, +0.0f, +1.0f, // forward +0.0f, +0.0f, +1.0f, // forward +0.0f, +0.0f, +1.0f, // forward // back +0.0f, +0.0f, -1.0f, // backbard +0.0f, +0.0f, -1.0f, // backbard +0.0f, +0.0f, -1.0f, // backbard +0.0f, +0.0f, -1.0f, // backbard // right +1.0f, +0.0f, +0.0f, // right +1.0f, +0.0f, +0.0f, // right +1.0f, +0.0f, +0.0f, // right +1.0f, +0.0f, +0.0f, // right // left -1.0f, +0.0f, +0.0f, // left -1.0f, +0.0f, +0.0f, // left -1.0f, +0.0f, +0.0f, // left -1.0f, +0.0f, +0.0f, // left // top +0.0f, +1.0f, +0.0f, // up +0.0f, +1.0f, +0.0f, // up +0.0f, +1.0f, +0.0f, // up +0.0f, +1.0f, +0.0f, // up // bottom +0.0f, -1.0f, +0.0f, // down +0.0f, -1.0f, +0.0f, // down +0.0f, -1.0f, +0.0f, // down +0.0f, -1.0f, +0.0f // down }; EGLSurface surface; DEBUG_MSG("----------------------------------------------------------------"); RD_START("cube-textured", "mag_filter=%04x, min_filter=%04x, wrap_s=%04x, wrap_t=%04x", mag_filter, min_filter, wrap_s, wrap_t); ECHK(surface = eglCreatePbufferSurface(display, config, pbuffer_attribute_list)); ECHK(eglQuerySurface(display, surface, EGL_WIDTH, &width)); ECHK(eglQuerySurface(display, surface, EGL_HEIGHT, &height)); DEBUG_MSG("PBuffer: %dx%d", width, height); /* connect the context to the surface */ ECHK(eglMakeCurrent(display, surface, surface, context)); GCHK(glFlush()); if (!program) { program = get_program(vertex_shader_source, fragment_shader_source); GCHK(glBindAttribLocation(program, 0, "in_position")); GCHK(glBindAttribLocation(program, 1, "in_normal")); GCHK(glBindAttribLocation(program, 2, "in_TexCoord")); link_program(program); GCHK(glFlush()); } GCHK(glViewport(0, 0, width, height)); GCHK(glFlush()); /* clear the color buffer */ GCHK(glClearColor(0.5, 0.5, 0.5, 1.0)); GCHK(glFlush()); GCHK(glClear(GL_COLOR_BUFFER_BIT)); GCHK(glFlush()); GCHK(glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, vVertices)); GCHK(glFlush()); GCHK(glEnableVertexAttribArray(0)); GCHK(glFlush()); GCHK(glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, vNormals)); GCHK(glFlush()); GCHK(glEnableVertexAttribArray(1)); GCHK(glFlush()); GCHK(glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, vTexCoords)); GCHK(glEnableVertexAttribArray(2)); ESMatrix modelview; esMatrixLoadIdentity(&modelview); esTranslate(&modelview, 0.0f, 0.0f, -8.0f); esRotate(&modelview, 45.0f, 1.0f, 0.0f, 0.0f); esRotate(&modelview, 45.0f, 0.0f, 1.0f, 0.0f); esRotate(&modelview, 10.0f, 0.0f, 0.0f, 1.0f); GLfloat aspect = (GLfloat)(height) / (GLfloat)(width); ESMatrix projection; esMatrixLoadIdentity(&projection); esFrustum(&projection, -2.8f, +2.8f, -2.8f * aspect, +2.8f * aspect, 6.0f, 10.0f); ESMatrix modelviewprojection; esMatrixLoadIdentity(&modelviewprojection); esMatrixMultiply(&modelviewprojection, &modelview, &projection); float normal[9]; normal[0] = modelview.m[0][0]; normal[1] = modelview.m[0][1]; normal[2] = modelview.m[0][2]; normal[3] = modelview.m[1][0]; normal[4] = modelview.m[1][1]; normal[5] = modelview.m[1][2]; normal[6] = modelview.m[2][0]; normal[7] = modelview.m[2][1]; normal[8] = modelview.m[2][2]; GCHK(glActiveTexture(GL_TEXTURE0)); GCHK(glFlush()); GCHK(glGenTextures(1, &texturename)); GCHK(glFlush()); GCHK(glBindTexture(GL_TEXTURE_2D, texturename)); GCHK(glFlush()); GCHK(glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, cube_texture.width, cube_texture.height, 0, GL_RGB, GL_UNSIGNED_BYTE, cube_texture.pixel_data)); GCHK(glFlush()); /* Note: cube turned black until these were defined. */ GCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, mag_filter)); GCHK(glFlush()); GCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, min_filter)); GCHK(glFlush()); GCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrap_s)); GCHK(glFlush()); GCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrap_t)); GCHK(glFlush()); GCHK(modelviewmatrix_handle = glGetUniformLocation(program, "modelviewMatrix")); GCHK(modelviewprojectionmatrix_handle = glGetUniformLocation(program, "modelviewprojectionMatrix")); GCHK(normalmatrix_handle = glGetUniformLocation(program, "normalMatrix")); GCHK(texture_handle = glGetUniformLocation(program, "uTexture")); GCHK(glFlush()); GCHK(glUniformMatrix4fv(modelviewmatrix_handle, 1, GL_FALSE, &modelview.m[0][0])); GCHK(glFlush()); GCHK(glUniformMatrix4fv(modelviewprojectionmatrix_handle, 1, GL_FALSE, &modelviewprojection.m[0][0])); GCHK(glFlush()); GCHK(glUniformMatrix3fv(normalmatrix_handle, 1, GL_FALSE, normal)); GCHK(glFlush()); GCHK(glUniform1i(texture_handle, 0)); /* '0' refers to texture unit 0. */ GCHK(glFlush()); GCHK(glEnable(GL_CULL_FACE)); GCHK(glFlush()); GCHK(glDrawArrays(GL_TRIANGLE_STRIP, 0, 4)); GCHK(glFlush()); GCHK(glDrawArrays(GL_TRIANGLE_STRIP, 4, 4)); GCHK(glFlush()); GCHK(glDrawArrays(GL_TRIANGLE_STRIP, 8, 4)); GCHK(glFlush()); GCHK(glDrawArrays(GL_TRIANGLE_STRIP, 12, 4)); GCHK(glFlush()); GCHK(glDrawArrays(GL_TRIANGLE_STRIP, 16, 4)); GCHK(glFlush()); GCHK(glDrawArrays(GL_TRIANGLE_STRIP, 20, 4)); GCHK(glFlush()); ECHK(eglSwapBuffers(display, surface)); GCHK(glFlush()); ECHK(eglDestroySurface(display, surface)); GCHK(glFlush()); RD_END(); }
void test_composite(const char *name, const struct blend_mode *blend, const struct format_mode *dst_format, uint32_t bw, uint32_t bh, const struct format_mode *src_format, uint32_t src_repeat, uint32_t sw, uint32_t sh, const struct format_mode *mask_format, uint32_t mask_repeat, uint32_t mw, uint32_t mh) { PixmapPtr src, dest, mask = NULL; C2D_OBJECT blit = {}; c2d_ts_handle curTimestamp; DEBUG_MSG("%s: op:%s src:%s (repeat:%d) mask=%s (repeat:%d) dst:%s", name, blend->name, src_format->name, src_repeat, mask_format ? mask_format->name : "none", mask_repeat, dst_format->name); RD_START(name, "op:%s src:%s (repeat:%d) mask=%s (repeat:%d) dst:%s", blend->name, src_format->name, src_repeat, mask_format ? mask_format->name : "none", mask_repeat, dst_format->name); blit.config_mask = DEFAULT_BLEND_MASK | blend->mode; dest = create_pixmap(1033, 1077, dst_format->format); if (src_repeat) { src = create_pixmap(1, 1, src_format->format); blit.config_mask |= C2D_SOURCE_TILE_BIT; } else { src = create_pixmap(sw, sh, src_format->format); } blit.config_mask |= C2D_SOURCE_RECT_BIT; blit.surface_id = src->id; if (mask_format) { /* TODO not clear if mask repeat is really supported.. msm-exa-c2d2.c * seems to reject it but C2D_MASK_TILE_BIT?? * * Also, for src format, msm-exa-c2d2.c seems to encode fgcolor (like * a solid fill) for repeats.. not really clear if TILE_BIT does what * we expect or not?? * * Seems like libC2D2 doesn't actually give any way to specify the * maskX/maskY!!! The previous c2d API does, so I'd have to assume * this is actually supported by the hardware and this is just C2D2 * retardation */ if (mask_repeat) { mask = create_pixmap(1, 1, mask_format->format); blit.config_mask |= C2D_MASK_TILE_BIT; } else { mask = create_pixmap(mw, mh, mask_format->format); } blit.config_mask |= C2D_MASK_SURFACE_BIT; blit.mask_surface_id = mask->id; } else { // TODO make redump not confused when one column has extra rows mask = create_pixmap(1, 1, ARGB); } blit.next = NULL; blit.source_rect.x = FIXED(1); blit.source_rect.y = FIXED(2); blit.source_rect.width = FIXED(bw - blit.source_rect.x - 1); blit.source_rect.height = FIXED(bh - blit.source_rect.y - 2); blit.target_rect.x = FIXED((dest->width - sw) / 2); blit.target_rect.y = FIXED((dest->height - sh) / 2); blit.target_rect.width = blit.source_rect.width; blit.target_rect.height = blit.source_rect.height; CHK(c2dDraw(dest->id, 0, NULL, 0, 0, &blit, 1)); CHK(c2dFlush(dest->id, &curTimestamp)); CHK(c2dWaitTimestamp(curTimestamp)); free_pixmap(src); free_pixmap(dest); if (mask) free_pixmap(mask); RD_END(); // dump_pixmap(dest, "copy-%04dx%04d-%08x.bmp", w, h, format); }
void test_cat(void) { GLint width, height; GLint modelviewmatrix_handle, modelviewprojectionmatrix_handle, normalmatrix_handle; GLuint position_vbo, normal_vbo; EGLSurface surface; float scale = 1.3; DEBUG_MSG("----------------------------------------------------------------"); RD_START("cat", ""); display = get_display(); /* get an appropriate EGL frame buffer configuration */ ECHK(eglChooseConfig(display, config_attribute_list, &config, 1, &num_config)); DEBUG_MSG("num_config: %d", num_config); /* create an EGL rendering context */ ECHK(context = eglCreateContext(display, config, EGL_NO_CONTEXT, context_attribute_list)); surface = make_window(display, config, 400, 240); ECHK(eglQuerySurface(display, surface, EGL_WIDTH, &width)); ECHK(eglQuerySurface(display, surface, EGL_HEIGHT, &height)); DEBUG_MSG("Buffer: %dx%d", width, height); /* connect the context to the surface */ ECHK(eglMakeCurrent(display, surface, surface, context)); program = get_program(vertex_shader_source, fragment_shader_source); GCHK(glBindAttribLocation(program, 0, "normal")); GCHK(glBindAttribLocation(program, 1, "position")); /* upload the attribute vbo's, only done once: */ GCHK(glGenBuffers(1, &normal_vbo)); GCHK(glBindBuffer(GL_ARRAY_BUFFER, normal_vbo)); GCHK(glBufferData(GL_ARRAY_BUFFER, sizeof(cat_normal), cat_normal, GL_STATIC_DRAW)); GCHK(glGenBuffers(1, &position_vbo)); GCHK(glBindBuffer(GL_ARRAY_BUFFER, position_vbo)); GCHK(glBufferData(GL_ARRAY_BUFFER, sizeof(cat_position), cat_position, GL_STATIC_DRAW)); link_program(program); GCHK(glViewport(0, 0, width, height)); /* clear the color buffer */ GCHK(glClearColor(0.5, 0.5, 0.5, 1.0)); GCHK(glEnable(GL_DEPTH_TEST)); GCHK(glDepthFunc(GL_LEQUAL)); GCHK(glEnable(GL_CULL_FACE)); GCHK(glCullFace(GL_BACK)); GCHK(glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT)); GCHK(glEnableVertexAttribArray(0)); GCHK(glBindBuffer(GL_ARRAY_BUFFER, normal_vbo)); GCHK(glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, NULL)); GCHK(glEnableVertexAttribArray(1)); GCHK(glBindBuffer(GL_ARRAY_BUFFER, position_vbo)); GCHK(glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, NULL)); ESMatrix modelview; esMatrixLoadIdentity(&modelview); esTranslate(&modelview, 0.0f, 0.0f, -8.0f); esRotate(&modelview, 45.0f, 0.0f, 1.0f, 0.0f); GLfloat aspect = (GLfloat)(height) / (GLfloat)(width); ESMatrix projection; esMatrixLoadIdentity(&projection); esFrustum(&projection, -scale, +scale, -scale * aspect, +scale * aspect, 5.5f, 10.0f); ESMatrix modelviewprojection; esMatrixLoadIdentity(&modelviewprojection); esMatrixMultiply(&modelviewprojection, &modelview, &projection); float normal[9]; normal[0] = modelview.m[0][0]; normal[1] = modelview.m[0][1]; normal[2] = modelview.m[0][2]; normal[3] = modelview.m[1][0]; normal[4] = modelview.m[1][1]; normal[5] = modelview.m[1][2]; normal[6] = modelview.m[2][0]; normal[7] = modelview.m[2][1]; normal[8] = modelview.m[2][2]; GCHK(modelviewmatrix_handle = glGetUniformLocation(program, "ModelViewMatrix")); GCHK(modelviewprojectionmatrix_handle = glGetUniformLocation(program, "ModelViewProjectionMatrix")); GCHK(normalmatrix_handle = glGetUniformLocation(program, "NormalMatrix")); GCHK(glUniformMatrix4fv(modelviewmatrix_handle, 1, GL_FALSE, &modelview.m[0][0])); GCHK(glUniformMatrix4fv(modelviewprojectionmatrix_handle, 1, GL_FALSE, &modelviewprojection.m[0][0])); GCHK(glUniformMatrix3fv(normalmatrix_handle, 1, GL_FALSE, normal)); GCHK(glDrawArrays(GL_TRIANGLES, 0, cat_vertices)); ECHK(eglSwapBuffers(display, surface)); GCHK(glFlush()); ECHK(eglDestroySurface(display, surface)); ECHK(eglTerminate(display)); RD_END(); }
static void test_transform_feedback(int n, int separate) { GLint width, height, ret, i; GLuint texturename = 0, texture_handle, tf; GLfloat vVertices[] = { // front -0.45, -0.75, 0.0, 0.45, -0.75, 0.0, -0.45, 0.75, 0.0, 0.45, 0.75, 0.0 }; const char *varyings[] = { "pos", "pos2", "pos3", "pos4", "pos5", "pos6", "pos7", //"posen[0]", //"posen[1]", //"posen[2]", //"posen[8]", //"posen[5]", }; GLuint tf_bufs[ARRAY_SIZE(varyings)] = { 0 }; EGLSurface surface; RD_START("transform-feedback", "n=%d, separate=%d", n, separate); display = get_display(); /* get an appropriate EGL frame buffer configuration */ ECHK(eglChooseConfig(display, config_attribute_list, &config, 1, &num_config)); DEBUG_MSG("num_config: %d", num_config); /* create an EGL rendering context */ ECHK(context = eglCreateContext(display, config, EGL_NO_CONTEXT, context_attribute_list)); surface = make_window(display, config, 255, 255); ECHK(eglQuerySurface(display, surface, EGL_WIDTH, &width)); ECHK(eglQuerySurface(display, surface, EGL_HEIGHT, &height)); DEBUG_MSG("Buffer: %dx%d", width, height); /* connect the context to the surface */ ECHK(eglMakeCurrent(display, surface, surface, context)); printf("EGL Version %s\n", eglQueryString(display, EGL_VERSION)); printf("EGL Vendor %s\n", eglQueryString(display, EGL_VENDOR)); printf("EGL Extensions %s\n", eglQueryString(display, EGL_EXTENSIONS)); printf("GL Version %s\n", glGetString(GL_VERSION)); printf("GL extensions: %s\n", glGetString(GL_EXTENSIONS)); program = get_program(vertex_shader_source, fragment_shader_source); if (n > 0) GCHK(glEnable(GL_RASTERIZER_DISCARD)); GCHK(glBindAttribLocation(program, 0, "in_position")); if (n > 0) { GCHK(glTransformFeedbackVaryings(program, n, varyings, separate ? GL_SEPARATE_ATTRIBS : GL_INTERLEAVED_ATTRIBS)); } link_program(program); GCHK(glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, vVertices)); GCHK(glEnableVertexAttribArray(0)); if (n > 0) { GCHK(glGenBuffers(n, tf_bufs)); for (i = 0; i < (separate ? n : 1); i++) { GCHK(glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, tf_bufs[i])); GCHK(glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 1024, NULL, GL_STREAM_DRAW)); GCHK(glBindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, i, tf_bufs[i], 32 * i, 1024)); } } //GCHK(glGenTransformFeedbacks(1, &tf)); //GCHK(glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tf)); if (n > 0) GCHK(glBeginTransformFeedback(GL_POINTS)); GCHK(glDrawArrays(GL_POINTS, 0, 4)); if (n > 0) GCHK(glEndTransformFeedback()); //ECHK(eglSwapBuffers(display, surface)); GCHK(glFlush()); sleep(1); ECHK(eglDestroySurface(display, surface)); ECHK(eglTerminate(display)); RD_END(); }
void test_composite(uint32_t blend_mode, uint32_t dst_format, uint32_t dst_width, uint32_t dst_height, uint32_t src_format, uint32_t src_width, uint32_t src_height, uint32_t mask_format, uint32_t mask_width, uint32_t mask_height, uint32_t src_x, uint32_t src_y, uint32_t mask_x, uint32_t mask_y, uint32_t dst_x, uint32_t dst_y, uint32_t w, uint32_t h) { PixmapPtr src, dest, mask = NULL; C2D_OBJECT blit = {}; c2d_ts_handle curTimestamp; DEBUG_MSG("composite2: blend_mode:%08x, dst_format:%08x, dst_width:%x, dst_height=%x, " "src_format:%08x, src_width:%x, src_height:%x, " "mask_format:%08x, mask_width:%x, mask_height:%x, " "src_x:%x, src_y:%x, mask_x:%x, mask_y:%x, dst_x:%x, dst_y:%x, w:%x, h:%x", blend_mode, dst_format, dst_width, dst_height, src_format, src_width, src_height, mask_format, mask_width, mask_height, src_x, src_y, mask_x, mask_y, dst_x, dst_y, w, h); RD_START("composite2","blend_mode:%08x, dst_format:%08x, dst_width:%x, dst_height=%x, " "src_format:%08x, src_width:%x, src_height:%x, " "mask_format:%08x, mask_width:%x, mask_height:%x, " "src_x:%x, src_y:%x, mask_x:%x, mask_y:%x, dst_x:%x, dst_y:%x, w:%x, h:%x", blend_mode, dst_format, dst_width, dst_height, src_format, src_width, src_height, mask_format, mask_width, mask_height, src_x, src_y, mask_x, mask_y, dst_x, dst_y, w, h); blit.config_mask = DEFAULT_BLEND_MASK | blend_mode; dest = create_pixmap(dst_width, dst_height, dst_format); src = create_pixmap(src_width, src_height, src_format); blit.config_mask |= C2D_SOURCE_RECT_BIT; blit.surface_id = src->id; if (mask_format) { /* TODO not clear if mask repeat is really supported.. msm-exa-c2d2.c * seems to reject it but C2D_MASK_TILE_BIT?? * * Also, for src format, msm-exa-c2d2.c seems to encode fgcolor (like * a solid fill) for repeats.. not really clear if TILE_BIT does what * we expect or not?? * * Seems like libC2D2 doesn't actually give any way to specify the * maskX/maskY!!! The previous c2d API does, so I'd have to assume * this is actually supported by the hardware and this is just C2D2 * retardation */ mask = create_pixmap(mask_width, mask_height, mask_format); blit.config_mask |= C2D_MASK_SURFACE_BIT; blit.mask_surface_id = mask->id; } blit.next = NULL; blit.source_rect.x = FIXED(src_x); blit.source_rect.y = FIXED(src_y); blit.source_rect.width = FIXED(w); blit.source_rect.height = FIXED(h); blit.target_rect.x = FIXED(dst_x); blit.target_rect.y = FIXED(dst_y); blit.target_rect.width = FIXED(w); blit.target_rect.height = FIXED(h); CHK(c2dDraw(dest->id, 0, NULL, 0, 0, &blit, 1)); CHK(c2dFlush(dest->id, &curTimestamp)); CHK(c2dWaitTimestamp(curTimestamp)); free_pixmap(src); free_pixmap(dest); if (mask) free_pixmap(mask); RD_END(); // dump_pixmap(dest, "copy-%04dx%04d-%08x.bmp", w, h, format); }
/* Run through multiple variants to detect clear color, quad color (frag * shader param), and vertices */ void test_query(int querytype, int w, int h) { static const GLfloat clear_color[] = {0.0, 0.0, 0.0, 0.0}; static const GLfloat quad_color[] = {1.0, 0.0, 0.0, 1.0}; static const GLfloat quad2_color[] = {0.0, 1.0, 0.0, 1.0}; static const GLfloat vertices[] = { -0.45, -0.75, 0.0, 0.45, -0.75, 0.0, -0.45, 0.75, 0.0, 0.45, 0.75, 0.0, }; static const GLfloat vertices2[] = { -0.15, -0.23, 1.0, 0.25, -0.33, 1.0, -0.35, 0.43, 1.0, 0.45, 0.53, 1.0, }; static const char *queryname[] = { "none", "samples-passed", "time-elapsed", }; RD_START("query", "query=%s", queryname[querytype]); display = get_display(); /* get an appropriate EGL frame buffer configuration */ ECHK(eglChooseConfig(display, config_attribute_list, &config, 1, &num_config)); DEBUG_MSG("num_config: %d", num_config); /* create an EGL rendering context */ ECHK(context = eglCreateContext(display, config, EGL_NO_CONTEXT, context_attribute_list)); surface = make_window(display, config, w, h); ECHK(eglQuerySurface(display, surface, EGL_WIDTH, &width)); ECHK(eglQuerySurface(display, surface, EGL_HEIGHT, &height)); DEBUG_MSG("Buffer: %dx%d", width, height); /* connect the context to the surface */ ECHK(eglMakeCurrent(display, surface, surface, context)); program = get_program(vertex_shader_source, fragment_shader_source); GCHK(glBindAttribLocation(program, 0, "aPosition")); link_program(program); GCHK(glGenQueries(1, &query)); GCHK(glDepthMask(GL_TRUE)); GCHK(glEnable(GL_DEPTH_TEST)); GCHK(glViewport(0, 0, width, height)); if (clear_color) { /* clear the color buffer */ GCHK(glClearColor(clear_color[0], clear_color[1], clear_color[2], clear_color[3])); GCHK(glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)); } GCHK(glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, vertices)); GCHK(glEnableVertexAttribArray(0)); /* now set up our uniform. */ GCHK(uniform_location = glGetUniformLocation(program, "uColor")); GCHK(glUniform4fv(uniform_location, 1, quad_color)); GCHK(glDrawArrays(GL_TRIANGLE_STRIP, 0, 4)); switch (querytype) { case 1: GCHK(glBeginQuery(GL_ANY_SAMPLES_PASSED, query)); break; case 2: GCHK(glBeginQuery(GL_TIME_ELAPSED_EXT, query)); break; } /* Quad 2 render */ GCHK(glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, vertices2)); /* now set up our uniform. */ GCHK(uniform_location = glGetUniformLocation(program, "uColor")); GCHK(glUniform4fv(uniform_location, 1, quad2_color)); GCHK(glDrawArrays(GL_TRIANGLE_STRIP, 0, 4)); switch (querytype) { case 1: GCHK(glEndQuery(GL_ANY_SAMPLES_PASSED)); break; case 2: GCHK(glEndQuery(GL_TIME_ELAPSED_EXT)); break; } if (querytype > 0) { GLuint result; do { GCHK(glGetQueryObjectuiv(query, GL_QUERY_RESULT_AVAILABLE, &result)); } while (!result); GCHK(glGetQueryObjectuiv(query, GL_QUERY_RESULT, &result)); DEBUG_MSG("Query ended with %d", result); } ECHK(eglSwapBuffers(display, surface)); GCHK(glFlush()); usleep(1000000); GCHK(glDeleteQueries(1, &query)); eglTerminate(display); RD_END(); }
int main(int argc, char **argv) { struct fd_state *state; struct fd_surface *surface, *lolstex1, *lolstex2; struct fd_program *cat_program, *tex_program; struct fd_bo *position_vbo, *normal_vbo; const char *cat_vertex_shader_asm = "@out(r2.y) gl_Position \n" "@varying(r0.x-r0.z) vertex_normal \n" "@varying(r1.y-r2.x) vertex_position \n" "@attribute(r0.x-r0.z) normal \n" "@attribute(r0.w-r1.y) position \n" "@uniform(c0.x-c3.w) ModelViewMatrix \n" "@uniform(c4.x-c7.w) ModelViewProjectionMatrix \n" "@uniform(c8.x-c10.w) NormalMatrix \n" "(sy)(ss)(rpt2)mul.f r1.z, r0.z, (r)c10.x \n" "(rpt3)mad.f32 r2.y, (r)c2.x, r1.y, (r)c3.x \n" "(rpt2)mad.f32 r1.z, (r)c9.x, r0.y, (r)r1.z \n" "(rpt3)mad.f32 r3.y, (r)c6.x, r1.y, (r)c7.x \n" "(rpt2)mad.f32 r0.x, (r)c8.x, r0.x, (r)r1.z \n" "(rpt3)mad.f32 r1.y, (r)c1.x, r1.x, (r)r2.y \n" "mul.f r2.y, r0.x, r0.x \n" "(rpt3)mad.f32 r2.z, (r)c5.x, r1.x, (r)r3.y \n" "mad.f32 r1.x, r0.y, r0.y, r2.y \n" "(rpt3)mad.f32 r1.y, (r)c0.x, r0.w, (r)r1.y \n" "mad.f32 r1.x, r0.z, r0.z, r1.x \n" "(rpt3)mad.f32 r2.y, (r)c4.x, r0.w, (r)r2.z \n" "(rpt1)nop \n" "rsq r0.w, r1.x \n" "(ss)(rpt2)mul.f r0.x, (r)r0.x, r0.w \n" "end \n"; const char *cat_fragment_shader_asm = /* precision mediump float; const vec4 MaterialDiffuse = vec4(0.000000, 0.000000, 1.000000, 1.000000); const vec4 LightColor0 = vec4(0.800000, 0.800000, 0.800000, 1.000000); const vec4 light_position = vec4(0.000000, 1.000000, 0.000000, 1.000000); varying vec3 vertex_normal; varying vec4 vertex_position; void main(void) { const vec4 diffuse_light_color = LightColor0; const vec4 lightAmbient = vec4(0.1, 0.1, 0.1, 1.0); const vec4 lightSpecular = vec4(0.8, 0.8, 0.8, 1.0); const vec4 matAmbient = vec4(0.2, 0.2, 0.2, 1.0); const vec4 matSpecular = vec4(1.0, 1.0, 1.0, 1.0); const float matShininess = 100.0; // C4.x vec3 eye_direction = normalize(-vertex_position.xyz); vec3 light_direction = normalize(light_position.xyz/light_position.w - vertex_position.xyz/vertex_position.w); vec3 normalized_normal = normalize(vertex_normal); // reflect(i,n) -> i - 2 * dot(n,i) * n vec3 reflection = reflect(-light_direction, normalized_normal); float specularTerm = pow(max(0.0, dot(reflection, eye_direction)), matShininess); float diffuseTerm = max(0.0, dot(normalized_normal, light_direction)); vec4 specular = (lightSpecular * matSpecular); vec4 ambient = (lightAmbient * matAmbient); vec4 diffuse = (diffuse_light_color * MaterialDiffuse); vec4 result = (specular * specularTerm) + ambient + (diffuse * diffuseTerm); gl_FragColor = result; } */ "@out(hr0.y) gl_FragColor \n" "@varying(r0.x-r0.z) vertex_normal \n" "@varying(r1.y-r2.x) vertex_position \n" "@const(c0.x) 0.000000, 1.000000, 0.000000, 0.000000 \n" "@const(c1.x) 0.800000, 0.800000, 0.800000, 1.000000 \n" "@const(c2.x) 0.020000, 0.020000, 0.020000, 1.000000 \n" "@const(c3.x) 0.000000, 0.000000, 0.800000, 1.000000 \n" "@const(c4.x) 100.000000, 0.000000, 0.000000, 0.000000 \n" "@const(c5.x) 2.000000, 0.000000, 0.000000, 0.000000 \n" "(sy)(ss)(rpt3)bary.f hr0.x, (r)3, r0.x \n" "(rpt2)bary.f (ei)hr1.x, (r)0, r0.x \n" "(rpt2)nop \n" "rcp hr0.w, hr0.w \n" "mul.f hr1.w, hr1.x, hr1.x \n" "mul.f hr2.x, (neg)hr0.x, (neg)hr0.x \n" "mad.f16 hr1.w, hr1.y, hr1.y, hr1.w \n" "mad.f16 hr2.x, (neg)hr0.y, (neg)hr0.y, hr2.x \n" "mad.f16 hr1.w, hr1.z, hr1.z, hr1.w \n" "mad.f16 hr2.x, (neg)hr0.z, (neg)hr0.z, hr2.x \n" "(ss)(rpt1)mul.f hr2.y, (r)hr0.x, hr0.w \n" "mul.f hr0.w, hr0.z, hr0.w \n" "(rpt1)nop \n" "rsq hr1.w, hr1.w \n" "add.f hr2.z, (neg)hr2.z, hc0.y \n" "mul.f hr2.w, (neg)hr2.y, (neg)hr2.y \n" "rsq hr2.x, hr2.x \n" "(rpt1)nop \n" "mad.f16 hr2.w, hr2.z, hr2.z, hr2.w \n" "nop \n" "mad.f16 hr2.w, (neg)hr0.w, (neg)hr0.w, hr2.w \n" "(ss)(rpt2)mul.f hr1.x, (r)hr1.x, hr1.w \n" "(rpt2)mul.f hr0.x, (neg)(r)hr0.x, hr2.x \n" "rsq hr1.w, hr2.w \n" "(ss)mul.f hr2.w, (neg)hr2.y, hr1.w \n" "mul.f hr3.x, hr2.z, hr1.w \n" "mul.f hr3.y, (neg)hr0.w, hr1.w \n" "nop \n" "mul.f hr0.w, (neg)hr2.w, hr1.x \n" "mul.f hr1.w, hr2.w, hr1.x \n" "mad.f16 hr0.w, (neg)hr3.x, hr1.y, hr0.w \n" "mad.f16 hr1.w, hr3.x, hr1.y, hr1.w \n" "mad.f16 hr0.w, (neg)hr3.y, hr1.z, hr0.w \n" "mad.f16 hr1.w, hr3.y, hr1.z, hr1.w \n" "(rpt1)nop \n" "mul.f hr0.w, hr0.w, hc5.x \n" "max.f hr1.w, hr1.w, hc0.x \n" "(rpt1)nop \n" "(rpt2)mad.f16 hr0.w, (r)hr1.x, (neg)hr0.w, (neg)(r)hr2.w \n" "mul.f hr1.z, hr1.w, hc3.z \n" "mul.f hr0.x, hr0.x, hr0.w \n" "nop \n" "mad.f16 hr0.x, hr0.y, hr1.x, hr0.x \n" "nop \n" "mad.f16 hr0.x, hr0.z, hr1.y, hr0.x \n" "(rpt2)nop \n" "max.f hr0.x, hr0.x, hc0.x \n" "(rpt5)nop \n" "log2 hr0.x, hr0.x \n" "(ss)mul.f hr0.x, hr0.x, hc4.x \n" "(rpt5)nop \n" "exp2 hr0.x, hr0.x \n" "(ss)mul.f hr0.y, hr0.x, hc1.x \n" "add.f hr0.x, hr0.x, hc2.w \n" "(rpt1)nop \n" "add.f hr0.y, hr0.y, hc2.x \n" "add.f hr1.x, hr0.x, hr1.w \n" "(rpt1)nop \n" "add.f hr0.w, hr0.y, hr1.z \n" "mov.f16f16 hr0.z, hr0.y \n" "end \n"; static const GLfloat texcoords[] = { 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, }; static const GLfloat tex1_vertices[] = { -0.95, +0.45, -1.0, +0.45, +0.45, -1.0, -0.95, +0.95, -1.0, +0.45, +0.95, -1.0 }; static const GLfloat tex2_vertices[] = { -0.45, -0.95, -1.0, +0.95, -0.95, -1.0, -0.45, -0.45, -1.0, +0.95, -0.45, -1.0 }; const char *tex_vertex_shader_asm = "@out(r0.x) gl_Position \n" "@attribute(r0.x-r0.w) aPosition \n" "@attribute(r1.x-r1.y) aTexCoord \n" "@varying(r1.x-r1.y) vTexCoord \n" "(sy)(ss)end \n"; const char *tex_fragment_shader_asm = "@out(hr0.x) gl_FragColor \n" "@varying(r1.x-r1.y) vTexCoord \n" "@sampler(0) uTexture \n" "(sy)(ss)(rpt1)bary.f (ei)r0.z, (r)0, r0.x \n" "(rpt5)nop \n" "sam (f16)(xyzw)hr0.x, r0.z, s#0, t#0 \n" "end \n"; uint32_t width = 0, height = 0; int i, n = 1; if (argc == 2) n = atoi(argv[1]); DEBUG_MSG("----------------------------------------------------------------"); RD_START("fd-cat", ""); state = fd_init(); if (!state) return -1; surface = fd_surface_screen(state, &width, &height); if (!surface) return -1; /* load textures: */ lolstex1 = fd_surface_new_fmt(state, lolstex1_image.width, lolstex1_image.height, RB_R8G8B8A8_UNORM); fd_surface_upload(lolstex1, lolstex1_image.pixel_data); lolstex2 = fd_surface_new_fmt(state, lolstex2_image.width, lolstex2_image.height, RB_R8G8B8A8_UNORM); fd_surface_upload(lolstex2, lolstex2_image.pixel_data); fd_enable(state, GL_CULL_FACE); fd_depth_func(state, GL_LEQUAL); fd_enable(state, GL_DEPTH_TEST); fd_tex_param(state, GL_TEXTURE_MAG_FILTER, GL_LINEAR); fd_tex_param(state, GL_TEXTURE_MIN_FILTER, GL_LINEAR); fd_blend_func(state, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); /* this needs to come after enabling depth test as enabling depth test * effects bin sizes: */ fd_make_current(state, surface); /* construct the two shader programs: */ cat_program = fd_program_new(); fd_program_attach_asm(cat_program, FD_SHADER_VERTEX, cat_vertex_shader_asm); fd_program_attach_asm(cat_program, FD_SHADER_FRAGMENT, cat_fragment_shader_asm); tex_program = fd_program_new(); fd_program_attach_asm(tex_program, FD_SHADER_VERTEX, tex_vertex_shader_asm); fd_program_attach_asm(tex_program, FD_SHADER_FRAGMENT, tex_fragment_shader_asm); fd_link(state); position_vbo = fd_attribute_bo_new(state, cat_position_sz, cat_position); normal_vbo = fd_attribute_bo_new(state, cat_normal_sz, cat_normal); for (i = 0; i < n; i++) { GLfloat aspect = (GLfloat)height / (GLfloat)width; ESMatrix modelview; ESMatrix projection; ESMatrix modelviewprojection; float normal[9]; float scale = 1.3; esMatrixLoadIdentity(&modelview); esTranslate(&modelview, 0.0f, 0.0f, -8.0f); esRotate(&modelview, 45.0f - (0.5f * i), 0.0f, 1.0f, 0.0f); esMatrixLoadIdentity(&projection); esFrustum(&projection, -scale, +scale, -scale * aspect, +scale * aspect, 5.5f, 10.0f); esMatrixLoadIdentity(&modelviewprojection); esMatrixMultiply(&modelviewprojection, &modelview, &projection); normal[0] = modelview.m[0][0]; normal[1] = modelview.m[0][1]; normal[2] = modelview.m[0][2]; normal[3] = modelview.m[1][0]; normal[4] = modelview.m[1][1]; normal[5] = modelview.m[1][2]; normal[6] = modelview.m[2][0]; normal[7] = modelview.m[2][1]; normal[8] = modelview.m[2][2]; fd_clear_color(state, (float[]){ 0.0, 0.0, 0.0, 1.0 }); fd_clear(state, GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); fd_attribute_bo(state, "normal", VFMT_FLOAT_32_32_32, normal_vbo); fd_attribute_bo(state, "position", VFMT_FLOAT_32_32_32, position_vbo); fd_uniform_attach(state, "ModelViewMatrix", 4, 4, &modelview.m[0][0]); fd_uniform_attach(state, "ModelViewProjectionMatrix", 4, 4, &modelviewprojection.m[0][0]); fd_uniform_attach(state, "NormalMatrix", 3, 3, normal); /* draw cat: */ fd_disable(state, GL_BLEND); fd_set_program(state, cat_program); fd_draw_arrays(state, GL_TRIANGLES, 0, cat_vertices); /* setup to draw text (common to tex1 and tex2): */ fd_enable(state, GL_BLEND); fd_set_program(state, tex_program); fd_attribute_pointer(state, "aTexCoord", VFMT_FLOAT_32_32, 4, texcoords); /* draw tex1: */ fd_set_texture(state, "uTexture", lolstex1); fd_attribute_pointer(state, "aPosition", VFMT_FLOAT_32_32_32, 4, tex1_vertices); fd_draw_arrays(state, GL_TRIANGLE_STRIP, 0, 4); /* draw tex2: */ fd_set_texture(state, "uTexture", lolstex2); fd_attribute_pointer(state, "aPosition", VFMT_FLOAT_32_32_32, 4, tex2_vertices); fd_draw_arrays(state, GL_TRIANGLE_STRIP, 0, 4); fd_swap_buffers(state); }
void test_quad_instanced(int instances, int div0, int div1) { GLint width, height; GLuint texturename = 0, texture_handle; GLfloat vVertices[] = { // front -0.45, -0.75, 0.0, 0.45, -0.75, 0.0, -0.45, 0.75, 0.0, 0.45, 0.75, 0.0 }; GLfloat vTexCoords[] = { 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, }; EGLSurface surface; RD_START("instanced", "instances=%d, div0=%d, div1=%d", instances, div0, div1); display = get_display(); /* get an appropriate EGL frame buffer configuration */ ECHK(eglChooseConfig(display, config_attribute_list, &config, 1, &num_config)); DEBUG_MSG("num_config: %d", num_config); /* create an EGL rendering context */ ECHK(context = eglCreateContext(display, config, EGL_NO_CONTEXT, context_attribute_list)); surface = make_window(display, config, 255, 255); ECHK(eglQuerySurface(display, surface, EGL_WIDTH, &width)); ECHK(eglQuerySurface(display, surface, EGL_HEIGHT, &height)); DEBUG_MSG("Buffer: %dx%d", width, height); /* connect the context to the surface */ ECHK(eglMakeCurrent(display, surface, surface, context)); printf("EGL Version %s\n", eglQueryString(display, EGL_VERSION)); printf("EGL Vendor %s\n", eglQueryString(display, EGL_VENDOR)); printf("EGL Extensions %s\n", eglQueryString(display, EGL_EXTENSIONS)); printf("GL Version %s\n", glGetString(GL_VERSION)); printf("GL extensions: %s\n", glGetString(GL_EXTENSIONS)); program = get_program(vertex_shader_source, fragment_shader_source); GCHK(glBindAttribLocation(program, 0, "in_position")); GCHK(glBindAttribLocation(program, 1, "in_TexCoord")); link_program(program); GCHK(glViewport(0, 0, width, height)); /* clear the color buffer */ GCHK(glClearColor(0.5, 0.5, 0.5, 1.0)); GCHK(glClear(GL_COLOR_BUFFER_BIT)); GCHK(glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, vVertices)); GCHK(glEnableVertexAttribArray(0)); GCHK(glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, vTexCoords)); GCHK(glEnableVertexAttribArray(1)); GCHK(glActiveTexture(GL_TEXTURE0)); GCHK(glGenTextures(1, &texturename)); GCHK(glBindTexture(GL_TEXTURE_2D, texturename)); GCHK(glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, cube_texture.width, cube_texture.height, 0, GL_RGB, GL_UNSIGNED_BYTE, cube_texture.pixel_data)); /* Note: cube turned black until these were defined. */ GCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)); GCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)); GCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)); GCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)); GCHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE)); GCHK(texture_handle = glGetUniformLocation(program, "uTexture")); GCHK(glUniform1i(texture_handle, 0)); /* '0' refers to texture unit 0. */ GCHK(glEnable(GL_CULL_FACE)); if (instances > 0) { GCHK(glVertexAttribDivisor(0, div0)); GCHK(glVertexAttribDivisor(1, div1)); GCHK(glDrawArraysInstanced(GL_TRIANGLE_STRIP, 0, 4, instances)); } else { GCHK(glDrawArrays(GL_TRIANGLE_STRIP, 0, 4)); } ECHK(eglSwapBuffers(display, surface)); GCHK(glFlush()); sleep(1); ECHK(eglDestroySurface(display, surface)); ECHK(eglTerminate(display)); RD_END(); }
void test_multi(void) { PixmapPtr src, dest; C2D_OBJECT blit = {}; C2D_RECT rect; c2d_ts_handle curTimestamp; uint32_t w = 1920, h = 1080, format = xRGB; int i; DEBUG_MSG("multi: %04dx%04d-%08x", w, h, format); RD_START("multi", "%dx%d format:%08x", w, h, format); dest = create_pixmap(w, h, format); src = create_pixmap(w, h, format); for (i = 0; i < 200; i++ ) { rect.x = 1; rect.y = 2; rect.width = w - 2; rect.height = h - 3; CHK(c2dFillSurface(dest->id, 0xff556677, &rect)); CHK(c2dFillSurface(dest->id, 0xff556677, &rect)); CHK(c2dFillSurface(dest->id, 0xff556677, &rect)); CHK(c2dFillSurface(dest->id, 0xff556677, &rect)); CHK(c2dFillSurface(dest->id, 0xff556677, &rect)); CHK(c2dFillSurface(dest->id, 0xff556677, &rect)); CHK(c2dFillSurface(dest->id, 0xff556677, &rect)); CHK(c2dFillSurface(dest->id, 0xff556677, &rect)); rect.x = 0; rect.y = 0; rect.width = 13; rect.height = 17; CHK(c2dFillSurface(src->id, 0xff223344, &rect)); CHK(c2dFillSurface(src->id, 0xff223344, &rect)); CHK(c2dFillSurface(src->id, 0xff223344, &rect)); CHK(c2dFillSurface(src->id, 0xff223344, &rect)); CHK(c2dFillSurface(src->id, 0xff223344, &rect)); CHK(c2dFillSurface(src->id, 0xff223344, &rect)); CHK(c2dFillSurface(src->id, 0xff223344, &rect)); CHK(c2dFillSurface(src->id, 0xff223344, &rect)); blit.surface_id = src->id; blit.config_mask = DEFAULT_BLIT_MASK; blit.next = NULL; blit.source_rect.x = FIXED(1); blit.source_rect.y = FIXED(2); blit.source_rect.width = FIXED(13-2); blit.source_rect.height = FIXED(17-4); blit.target_rect.x = FIXED((w - 13) / 2); blit.target_rect.y = FIXED((h - 17) / 2); blit.target_rect.width = blit.source_rect.width; blit.target_rect.height = blit.source_rect.height; CHK(c2dDraw(dest->id, 0, NULL, 0, 0, &blit, 1)); // well, identical copy twice is fine, and I'm lazy: CHK(c2dDraw(dest->id, 0, NULL, 0, 0, &blit, 1)); CHK(c2dDraw(dest->id, 0, NULL, 0, 0, &blit, 1)); CHK(c2dDraw(dest->id, 0, NULL, 0, 0, &blit, 1)); CHK(c2dDraw(dest->id, 0, NULL, 0, 0, &blit, 1)); CHK(c2dDraw(dest->id, 0, NULL, 0, 0, &blit, 1)); CHK(c2dDraw(dest->id, 0, NULL, 0, 0, &blit, 1)); CHK(c2dDraw(dest->id, 0, NULL, 0, 0, &blit, 1)); CHK(c2dDraw(dest->id, 0, NULL, 0, 0, &blit, 1)); CHK(c2dFlush(dest->id, &curTimestamp)); if (!(i % 16)) CHK(c2dWaitTimestamp(curTimestamp)); } free_pixmap(src); free_pixmap(dest); RD_END(); }