enum piglit_result piglit_display(void) { GLuint tex; GLboolean pass = GL_TRUE; glClearColor(0, 0, 0, 0); glClear(GL_COLOR_BUFFER_BIT); tex = create_texture(GL_COMPRESSED_RGB_S3TC_DXT1_EXT); display_mipmaps(10, 10 + (10 + SIZE) * 0); glDeleteTextures(1, &tex); tex = create_texture(GL_COMPRESSED_RGBA_S3TC_DXT1_EXT); display_mipmaps(10, 10 + (10 + SIZE) * 1); glDeleteTextures(1, &tex); tex = create_texture(GL_COMPRESSED_RGBA_S3TC_DXT3_EXT); display_mipmaps(10, 10 + (10 + SIZE) * 2); glDeleteTextures(1, &tex); tex = create_texture(GL_COMPRESSED_RGBA_S3TC_DXT5_EXT); display_mipmaps(10, 10 + (10 + SIZE) * 3); glDeleteTextures(1, &tex); pass = pass && check_resulting_mipmaps(10, 10 + (10 + SIZE) * 0); pass = pass && check_resulting_mipmaps(10, 10 + (10 + SIZE) * 1); pass = pass && check_resulting_mipmaps(10, 10 + (10 + SIZE) * 2); pass = pass && check_resulting_mipmaps(10, 10 + (10 + SIZE) * 3); glutSwapBuffers(); return pass ? PIGLIT_PASS : PIGLIT_FAIL; }
void opengl_init(int w, int h) { /* init statue *********************************************************************************/ LOGI("begin load shader"); shader_loader vs, ps; quad_mesh.program = new shader_program; if(!quad_mesh.program->build(vs.load_shader_source("media/flame.vs"),ps.load_shader_source("media/flame.ps"))) { LOGI("build shader failed"); return; } quad_mesh.texs_idxs[0] = create_texture("media/FireBase.tga", GL_CLAMP_TO_EDGE); quad_mesh.texs_idxs[1] = create_texture("media/FireDistortion.tga",GL_REPEAT); quad_mesh.texs_idxs[2] = create_texture("media/FireOpacity.tga",GL_CLAMP_TO_EDGE); quad_mesh.attribute_locations[static_mesh::POSITION] = glGetAttribLocation(quad_mesh.program->get_program(),"rm_Vertex"); quad_mesh.attribute_locations[static_mesh::TEXCOORD] = glGetAttribLocation(quad_mesh.program->get_program(),"rm_TexCoord0"); quad_mesh.loc_time = glGetUniformLocation(quad_mesh.program->get_program(),"time_0_X"); quad_mesh.texs_locs[0] = glGetUniformLocation(quad_mesh.program->get_program(),"fire_base"); quad_mesh.texs_locs[1] = glGetUniformLocation(quad_mesh.program->get_program(),"fire_distortion"); quad_mesh.texs_locs[2] = glGetUniformLocation(quad_mesh.program->get_program(),"fire_opacity"); float*pos, *texcoord; unsigned short *indx; GLuint num_vertexs; GLuint num_index; num_index = shape::create_plane(1, &pos, NULL, &texcoord, &indx, num_vertexs); glGenBuffers(4, quad_mesh.attribute_vbos); glBindBuffer(GL_ARRAY_BUFFER, quad_mesh.attribute_vbos[static_mesh::POSITION]); glBufferData(GL_ARRAY_BUFFER, 4*3*num_vertexs, pos, GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER, quad_mesh.attribute_vbos[static_mesh::TEXCOORD]); glBufferData(GL_ARRAY_BUFFER, 4*2*num_vertexs, texcoord, GL_STATIC_DRAW); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, quad_mesh.attribute_vbos[static_mesh::INDEX]); glBufferData(GL_ELEMENT_ARRAY_BUFFER, 2*num_index, indx, GL_STATIC_DRAW); quad_mesh.num_faces = num_index/3; delete []pos; delete []texcoord; delete []indx; glViewport(0,0,w,h); }
enum piglit_result piglit_display(void) { bool pass = true; GLuint tex; int i; tex = create_texture(); clear_texture(tex); glBindTexture(GL_TEXTURE_CUBE_MAP, tex); draw_faces(); glBindTexture(GL_TEXTURE_CUBE_MAP, 0); glDeleteTextures(1, &tex); for (i = 0; i < 6; i++) pass &= piglit_probe_pixel_rgb(i, 0, faces[i].color); piglit_present_results(); return pass ? PIGLIT_PASS : PIGLIT_FAIL; }
bgfx_texture* texture_manager::create_png_texture(std::string path, std::string file_name, std::string texture_name, uint32_t flags, uint32_t screen) { bitmap_argb32 bitmap; emu_file file(path.c_str(), OPEN_FLAG_READ); render_load_png(bitmap, file, nullptr, file_name.c_str()); if (bitmap.width() == 0 || bitmap.height() == 0) { printf("Unable to load PNG '%s' from path '%s'\n", path.c_str(), file_name.c_str()); return nullptr; } uint8_t *data = new uint8_t[bitmap.width() * bitmap.height() * 4]; uint32_t *data32 = reinterpret_cast<uint32_t *>(data); const uint32_t width = bitmap.width(); const uint32_t height = bitmap.height(); const uint32_t rowpixels = bitmap.rowpixels(); uint32_t* base = reinterpret_cast<uint32_t *>(bitmap.raw_pixptr(0)); for (int y = 0; y < height; y++) { copy_util::copyline_argb32(data32 + y * width, base + y * rowpixels, width, nullptr); } if (screen >= 0) { texture_name += std::to_string(screen); } bgfx_texture* texture = create_texture(texture_name, bgfx::TextureFormat::RGBA8, width, height, data, flags); delete [] data; return texture; }
NE_API void draw_text(font_text* text) { if (current_font_asset && text->text[0] != '\0') { font_asset* font = get_font(current_font_asset); SDL_Color color = { 255, 255, 255, 255 }; SDL_Surface* surface = nullptr; TTF_Font* ttf = (TTF_Font*) font->resource_handle; if (text->wrap_length == 0) { surface = TTF_RenderUTF8_Blended(ttf, text->text.c_str(), color); } else { surface = TTF_RenderUTF8_Blended_Wrapped(ttf, text->text.c_str(), color, text->wrap_length); } if (text->texture.resource_handle == 0) { text->texture.resource_handle = create_texture(); } load_texture_from_pixels(&text->texture, (uint32*) surface->pixels, surface->w, surface->h); text->old_text = text->text; text->text[0] = '\0'; text->transform.scale = { (float) surface->w, (float) surface->h, 0.0f }; SDL_FreeSurface(surface); } if (text->texture.resource_handle != 0 && text->old_text[0] != '\0' && text->text[0] == '\0') { set_model_matrix(&text->transform); bind_texture(&text->texture); draw_vertex_array(&shapes[current_shape].vertex_array); } }
void init_load(t_wolf *wolf) { void *img; int w; int h; int bpp; int size_line; int endian; wolf->screen = 1; w = 1000; h = 800; if (wolf->texture == NULL) { wolf->texture = my_malloc(sizeof(t_texture)); wolf->texture->load = NULL; wolf->texture->wall_one = NULL; } if (wolf->texture->load == NULL) wolf->texture->load = create_texture("texture/load.xpm", wolf); if (wolf->texture->wall_one == NULL) init_texture(wolf); mlx_put_image_to_window(wolf->mlx, wolf->win, wolf->texture->load->image, 0, 0); }
void TextureCollectionItem::slot_import_textures() { const QStringList filepaths = get_open_filenames( treeWidget(), "Import Textures...", g_bitmap_files_filter, m_editor_context.m_settings, SETTINGS_FILE_DIALOG_PROJECTS); if (filepaths.empty()) return; const filesystem::path path( QDir::toNativeSeparators(filepaths.first()).toStdString()); // todo: schedule creation of texture and texture instances when rendering. for (int i = 0; i < filepaths.size(); ++i) { const string filepath = QDir::toNativeSeparators(filepaths[i]).toStdString(); auto_release_ptr<Texture> texture = create_texture(filepath); auto_release_ptr<TextureInstance> texture_instance = create_texture_instance(texture->get_name()); m_parent_item->add_item(texture.get()); m_parent_item->add_item(texture_instance.get()); m_parent.textures().insert(texture); m_parent.texture_instances().insert(texture_instance); } m_editor_context.m_project_builder.notify_project_modification(); }
t_env *init_env(void) { t_env *e; if (!(e = (t_env *)malloc(sizeof(t_env)))) return (NULL); new_window(e); e->music = 0; e->posx = 3; e->posy = 5; e->dirx = -1; e->diry = 0; e->xmax = 0; e->ymax = 0; e->planex = 0; e->planey = 0.66; e->time = 0; e->oldtime = e->time; e->time = clock(); e->fps = (e->time - e->oldtime) / 1000.0; e->movespeed = e->fps * 0.001; e->rotspeed = e->fps * 0.0005; e->tab = (int *)mlx_get_data_addr(e->img->img, &e->img->bpp, \ &e->img->size_line, &e->img->endian); e->buffer = init_tab(e); e->texture = create_texture(e); return (e); }
void PointCloudApplication::setup_video_texture() { assert(context.video_format == POINTCLOUD_BGRA_8888); video_texture = create_texture(NULL, context.video_width, context.video_height, true, GL_BGRA); // Setup geometry for the video overlay video_vertices[0] = 0; video_vertices[1] = context.viewport_height; video_vertices[2] = context.viewport_width; video_vertices[3] = context.viewport_height; video_vertices[4] = context.viewport_width; video_vertices[5] = 0; video_vertices[6] = 0; video_vertices[7] = 0; video_texcoords[0] = context.video_width - context.video_crop_x; video_texcoords[1] = context.video_height - context.video_crop_y; video_texcoords[2] = context.video_width - context.video_crop_x; video_texcoords[3] = context.video_crop_y; video_texcoords[4] = context.video_crop_x; video_texcoords[5] = context.video_crop_y; video_texcoords[6] = context.video_crop_x; video_texcoords[7] = context.video_height - context.video_crop_y; for (int i = 0; i < 8; i += 2) { video_texcoords[i] /= context.video_width; video_texcoords[i+1] /= context.video_height; } }
texture* gen_bush_fruiting_branches_texture(bush_appearance *appearance) { texture *result = create_texture(BLOCK_TEXTURE_SIZE, BLOCK_TEXTURE_SIZE); fltr_branches(result, &(appearance->thick_branches)); fltr_leaves(result, &(appearance->leaves)); fltr_leaves(result, &(appearance->fruit)); return result; }
static bool is_resource_supported(const test_data *data, const GLenum pname, const GLenum target, const GLenum internalformat) { GLuint tex; GLuint buffer; if (!check_query2_dependencies(pname, target)) return false; if (!test_data_check_supported(data, target, internalformat)) return false; if (target == GL_RENDERBUFFER) return is_supported_renderbuffer(target, internalformat); if (!create_texture(target, internalformat, &tex, &buffer)) return false; glDeleteTextures(1, &tex); glDeleteBuffers(1, &buffer); return true; }
enum piglit_result piglit_display(void) { GLboolean pass = GL_TRUE; int dim; GLuint tex; int x; glClearColor(0.5, 0.5, 0.5, 0.5); glClear(GL_COLOR_BUFFER_BIT); tex = create_texture(); x = 1; for (dim = TEX_WIDTH; dim > 1; dim /= 2) { draw_mipmap(x, 1, dim); x += dim + 1; } x = 1; for (dim = TEX_WIDTH; dim > 1; dim /= 2) { pass &= test_mipmap_drawing(x, 1, dim); x += dim + 1; } glDeleteTextures(1, &tex); piglit_present_results(); return pass ? PIGLIT_PASS : PIGLIT_FAIL; }
void run_grammar(tx_grammar_literal *lit) { size_t i; int row, col; pixel px; tx_grammar_literal *chosen = NULL; tx_grammar_expansion_site *ges = NULL; // Create a list of expansion sites: list *expansion_sites = create_list(); // Start by loading our source file into our result texture and calling our // pre-processing filter if we have one: if (lit->filename == NULL) { if (lit->anchor_x == 0 || lit->anchor_y == 0) { fprintf( stderr, "Error: grammar with NULL filename must have nonzero anchor values.\n" ); fprintf(stderr, "(found: %zu, %zu)\n", lit->anchor_x, lit->anchor_y); exit(EXIT_FAILURE); } lit->result = create_texture(lit->anchor_x, lit->anchor_y); } else { lit->result = load_texture_from_png(lit->filename); } if (lit->preprocess != NULL) { (*(lit->preprocess))(lit->result, lit->preargs); } // Now expand each child reference at random. Note that due to the low // resolution of the pseudo-random process, any item with a weight of less // than 1/65536th of the total weight of all items in a disjunction will // never be picked. for (col = 0; col < lit->result->width; ++col) { for (row = 0; row < lit->result->height; ++row) { px = tx_get_px(lit->result, col, row); for (i = 0; i < N_GRAMMAR_KEYS; ++i) { if (px == GRAMMAR_KEYS[i] && lit->children[i] != NULL) { chosen = choose_child( lit->children[i], hash_3d(hash_2d(hash_1d((ptrdiff_t) lit), i), col, row) ); if (chosen->result == NULL) { run_grammar(chosen); } ges = create_expansion_site(); ges->col = col; ges->row = row; ges->literal = chosen; l_append_element(expansion_sites, ges); ges = NULL; // destroy_list later on takes care of the memory used. } } } } l_witheach(expansion_sites, (void *) lit, expand_literal_into); // Clean up our list of expansion sites: destroy_list(expansion_sites); // Before wrapping up call our post-processing function if it exists: if (lit->postprocess != NULL) { (*(lit->postprocess))(lit->result, lit->postargs); } }
ParticleController::ParticleController(ParticleEmitter* emitter, ParticleType c_type) : ParticleRenderer(), ParticleEmitter(*emitter) { set_emitter_parent(this); set_renderer_parent(this); type = c_type; create_texture(); }
int main(int argc, char **argv) { int q; int start, end; printf("Initializing EGL...\n"); if(!init_gl_surface()) { printf("GL initialisation failed - exiting\n"); return 0; } init_scene(); create_texture(); printf("Start test...\n"); render(argc==2 ? atoi(argv[1]) : ITERATIONS); free_gl_surface(); return 0; }
void st_resize_framebuffer(struct st_framebuffer *stfb, uint width, uint height) { struct vg_context *ctx = vg_current_context(); struct st_renderbuffer *strb = stfb->strb; struct pipe_framebuffer_state *state; if (!ctx) return; state = &ctx->state.g3d.fb; /* If this is a noop, exit early and don't do the clear, etc below. */ if (strb->width == width && strb->height == height && state->zsbuf) return; if (strb->width != width || strb->height != height) st_renderbuffer_alloc_storage(ctx, strb, width, height); if (stfb->dsrb->width != width || stfb->dsrb->height != height) st_renderbuffer_alloc_storage(ctx, stfb->dsrb, width, height); { VGuint i; memset(state, 0, sizeof(struct pipe_framebuffer_state)); state->width = width; state->height = height; state->nr_cbufs = 1; state->cbufs[0] = strb->surface; for (i = 1; i < PIPE_MAX_COLOR_BUFS; ++i) state->cbufs[i] = 0; state->zsbuf = stfb->dsrb->surface; cso_set_framebuffer(ctx->cso_context, state); } ctx->state.dirty |= VIEWPORT_DIRTY; ctx->state.dirty |= DEPTH_STENCIL_DIRTY;/*to reset the scissors*/ ctx->pipe->clear(ctx->pipe, PIPE_CLEAR_DEPTHSTENCIL, NULL, 0.0, 0); /* we need all the other state already set */ setup_new_alpha_mask(ctx, stfb, width, height); pipe_texture_reference( &stfb->blend_texture, NULL ); stfb->blend_texture = create_texture(ctx->pipe, PIPE_FORMAT_A8R8G8B8_UNORM, width, height); }
int main(int argc, char** argv) { int x, y, width; GLuint texture; glfwSetErrorCallback(error_callback, NULL); if (!glfwInit()) exit(EXIT_FAILURE); windows[0] = open_window("First", NULL, OFFSET, OFFSET); if (!windows[0]) { glfwTerminate(); exit(EXIT_FAILURE); } // This is the one and only time we create a texture // It is created inside the first context, created above // It will then be shared with the second context, created below texture = create_texture(); glfwGetWindowPos(windows[0], &x, &y); glfwGetWindowSize(windows[0], &width, NULL); // Put the second window to the right of the first one windows[1] = open_window("Second", windows[0], x + width + OFFSET, y); if (!windows[1]) { glfwTerminate(); exit(EXIT_FAILURE); } // Set drawing color for both contexts glfwMakeContextCurrent(windows[0]); glColor3f(0.6f, 0.f, 0.6f); glfwMakeContextCurrent(windows[1]); glColor3f(0.6f, 0.6f, 0.f); glfwMakeContextCurrent(windows[0]); while (!glfwWindowShouldClose(windows[0]) && !glfwWindowShouldClose(windows[1])) { glfwMakeContextCurrent(windows[0]); draw_quad(texture); glfwMakeContextCurrent(windows[1]); draw_quad(texture); glfwSwapBuffers(windows[0]); glfwSwapBuffers(windows[1]); glfwWaitEvents(); } glfwTerminate(); exit(EXIT_SUCCESS); }
void initGl () { int zero = 0; glutInit (&zero, NULL); glewInit (); glClearColor (0.0f, 0.0f, 0.0f, 0.0f); glClearDepth (1.0); glDepthFunc (GL_LESS); glEnable (GL_DEPTH_TEST); glShadeModel (GL_SMOOTH); GLfloat light_ambient[] = {0.5f, 0.5f, 0.5f, 1.0f}; GLfloat light_diffuse[] = {0.4f, 0.4f, 0.3f, 1.0f}; GLfloat light_position[] = {0.0f, 1.0f, 2.0f, 1.0f}; glLightfv (GL_LIGHT1, GL_AMBIENT, light_ambient); glLightfv (GL_LIGHT1, GL_DIFFUSE, light_diffuse); glLightfv (GL_LIGHT1, GL_POSITION, light_position); glEnable (GL_LIGHT1); glEnable (GL_LIGHTING); glColorMaterial (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE); glEnable (GL_COLOR_MATERIAL); map_image_texture_id = create_texture (); glGenBuffers (1, &laser_buffer_id); glBindBuffer (GL_ARRAY_BUFFER, laser_buffer_id); laser_pos_buffer = NULL; glMatrixMode (GL_PROJECTION); glLoadIdentity (); gluPerspective (45.0f, WINDOW_WIDTH / WINDOW_HEIGHT, 0.1f, 4000.0f); // Calculate The Aspect Ratio Of The Window carmen_pose_3D_t zero_pose; zero_pose.position.x = 0.0; zero_pose.position.y = 0.0; zero_pose.position.z = 0.0; zero_pose.orientation.roll = 0.0; zero_pose.orientation.pitch = 0.0; zero_pose.orientation.yaw = 0.0; camera_pose = zero_pose; camera_offset = zero_pose; camera_pose.position.z = 30.0; camera_pose.orientation.pitch = carmen_degrees_to_radians (90.0); background_r = 0.0; background_g = 0.0; background_b = 0.0; glMatrixMode (GL_MODELVIEW); }
NE_API void load_texture_asset(texture_asset* texture) { texture->resource_handle = create_texture(); if (texture->pixels) { load_texture_from_pixels(texture, texture->pixels, texture->size.x, texture->size.y); } else { load_texture_from_file(texture); } }
bool PXL_Texture::create_texture(std::string file_path) { //creates a bitmap from the specified file path and checks if it is valid PXL_Bitmap bitmap; if (bitmap.create_bitmap(file_path)) { //if valid, create the texture from the bitmap and delete it afterwards bool success = create_texture(&bitmap); delete &bitmap; return success; } return false; }
bool PXL_Texture::create_texture(PXL_Bitmap* bitmap) { texture_created = false; if (bitmap != NULL) { has_transparency = bitmap->has_transparency; create_texture(bitmap->get_width(), bitmap->get_height(), bitmap->get_pixels(), bitmap->get_channel()); texture_created = true; }else { PXL_show_exception("Could not create texture, specified bitmap is NULL", PXL_ERROR_TEXTURE_CREATION_FAILED); } return texture_created; }
void rows_init(void) { create_texture(&row_texes[0], width, height, create_row0); create_texture(&row_texes[1], width, height, create_row1); create_texture(&row_texes[2], width, height, create_row2); create_texture(&row_texes[3], width, height, create_row3); create_texture(&row_texes[4], width, height, create_row4); create_texture(&row_texes[5], width, height, create_row5); create_texture(&row_texes[6], width, height, create_row6); register_event("draw opaque", draw_rows); }
BC_Texture::BC_Texture(int w, int h, int colormodel) { this->w = w; this->h = h; this->colormodel = colormodel; texture_id = -1; texture_id = -1; texture_w = 0; texture_h = 0; texture_components = 0; window_id = -1; create_texture(w, h, colormodel); }
void init(const char *sphereFile) { static GLfloat lightpos[] = {.5, .75, 1.5, 1}; glEnable(GL_DEPTH_TEST); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glLightfv(GL_LIGHT0, GL_POSITION, lightpos); create_texture(sphereFile, &sphereTexW, &sphereTexH, &padSphereTexW, &padSphereTexH, &sphereTexComp); }
enum piglit_result piglit_display(void) { bool pass = true; GLuint tex; tex = create_texture(); clear_texture(tex); draw_tex(tex); glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, 0); glDeleteTextures(1, &tex); pass &= piglit_probe_rect_rgb(VALUE_CLEAR_X * 2, VALUE_CLEAR_Y * 2, VALUE_CLEAR_WIDTH * 2, VALUE_CLEAR_HEIGHT * 2, green); pass &= piglit_probe_rect_rgb(ZERO_CLEAR_X * 2, ZERO_CLEAR_Y * 2, ZERO_CLEAR_WIDTH * 2, ZERO_CLEAR_HEIGHT * 2, black); /* Everything else should be red */ pass &= probe_tex(0, 0, TEX_WIDTH, ZERO_CLEAR_Y); pass &= probe_tex(0, ZERO_CLEAR_Y, ZERO_CLEAR_X, ZERO_CLEAR_HEIGHT); pass &= probe_tex(ZERO_CLEAR_X + ZERO_CLEAR_WIDTH, ZERO_CLEAR_Y, TEX_WIDTH - ZERO_CLEAR_X - ZERO_CLEAR_WIDTH, ZERO_CLEAR_HEIGHT); pass &= probe_tex(0, VALUE_CLEAR_Y, VALUE_CLEAR_X, VALUE_CLEAR_HEIGHT); pass &= probe_tex(VALUE_CLEAR_X + VALUE_CLEAR_WIDTH, VALUE_CLEAR_Y, TEX_WIDTH - VALUE_CLEAR_X - VALUE_CLEAR_WIDTH, VALUE_CLEAR_HEIGHT); pass &= probe_tex(0, VALUE_CLEAR_Y + VALUE_CLEAR_HEIGHT, TEX_WIDTH, TEX_HEIGHT - VALUE_CLEAR_Y - VALUE_CLEAR_HEIGHT); piglit_present_results(); return pass ? PIGLIT_PASS : PIGLIT_FAIL; }
static GLuint create_fbo(const struct fmt_test *test, GLuint *tex) { GLuint fbo; GLuint fbo_tex = create_texture(test); *tex = fbo_tex; glGenFramebuffers(1, &fbo); glBindFramebuffer(GL_FRAMEBUFFER, fbo); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, fbo_tex, 0); return fbo; }
void test_alpha_test (void) { CoglTexture *tex = COGL_TEXTURE (create_texture (test_ctx)); CoglPipeline *pipeline = cogl_pipeline_new (test_ctx); int fb_width = cogl_framebuffer_get_width (test_fb); int fb_height = cogl_framebuffer_get_height (test_fb); CoglColor clear_color; cogl_pipeline_set_layer_texture (pipeline, 0, tex); cogl_pipeline_set_layer_filters (pipeline, 0, COGL_PIPELINE_FILTER_NEAREST, COGL_PIPELINE_FILTER_NEAREST); cogl_pipeline_set_alpha_test_function (pipeline, COGL_PIPELINE_ALPHA_FUNC_GEQUAL, 254 / 255.0f /* alpha reference */); cogl_color_init_from_4ub (&clear_color, 0x00, 0x00, 0xff, 0xff); cogl_framebuffer_clear (test_fb, COGL_BUFFER_BIT_COLOR, &clear_color); cogl_framebuffer_draw_rectangle (test_fb, pipeline, -1, -1, 1, 1); cogl_object_unref (pipeline); cogl_object_unref (tex); /* The left side of the framebuffer should use the first pixel from * the texture which is red */ test_utils_check_region (test_fb, 2, 2, fb_width / 2 - 4, fb_height - 4, 0xff0000ff); /* The right side of the framebuffer should use the clear color * because the second pixel from the texture is clipped from the * alpha test */ test_utils_check_region (test_fb, fb_width / 2 + 2, 2, fb_width / 2 - 4, fb_height - 4, 0x0000ffff); if (cogl_test_verbose ()) g_print ("OK\n"); }
/* * Creates and returns a texture based on a bundled image filename */ GLuint read_png_texture(const char *name, bool pixel_texture) { char *data = NULL; int width = 0; int height= 0; bool success = read_png_image(name,&data,&width,&height); if (!success) return 0; GLuint texture_object = create_texture(data, width, height, pixel_texture); delete data; return texture_object; }
enum piglit_result piglit_display(void) { GLuint tex; GLboolean pass = GL_TRUE; const GLfloat *expected; int i, j; glClear(GL_COLOR_BUFFER_BIT); glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_TEXTURE_COORD_ARRAY); /* Do glCopyPixels and draw a textured rectangle for each format * and each texture target */ for (j = 0; j < ARRAY_SIZE(target); j++) { if (test_target != -1 && test_target != j) continue; if (!supported_target(j)) continue; printf("Testing %s\n", piglit_get_gl_enum_name(target[j].target)); if (target[j].target == GL_TEXTURE_1D_ARRAY) { printf("NOTE: We use glCopyTexSubImage2D to set 4 texture layers at once.\n"); } tex = create_texture(target[j].target); for (i = 0; i < ARRAY_SIZE(test_vectors); i++) { GLint x = IMAGE_SIZE * (i + 1); GLint y = 0; expected = (const float*)test_vectors[i].expected; if (!test_target_and_format(x, y, target[j].target, test_vectors[i].format, expected)) { pass = GL_FALSE; } } glDeleteTextures(1, &tex); } if (!piglit_automatic) piglit_present_results(); return (pass ? PIGLIT_PASS : PIGLIT_FAIL); }
bool renderer::create() { m_vformat_ID = m_video.spawn(m_vformat); m_memreader_ID = m_video.spawn(m_memreader); m_vbuffer_ID = m_video.spawn(m_vbuffer); m_video.get_<vo::vbuffer>(m_vbuffer_ID).set_source(m_memreader_ID); m_vshader_ID = m_video.spawn(m_vshader); m_pshader_ID = m_video.spawn(m_pshader); m_vbufset_ID = m_video.spawn(m_vbufset); m_video.get_<vo::vbufset>(m_vbufset_ID).set_vformat(m_vformat_ID); m_video.get_<vo::vbufset>(m_vbufset_ID).set_vbuffer(0, m_vbuffer_ID, 0, 4); m_states_ID = m_video.spawn(m_states); m_texset_ID = m_deftexset_ID = create_texture(video::tf::a8r8g8b8, &bad_ID, 1, 1, 4); return true; }