TEST () { GeglBuffer *buffer; GeglRectangle rect = {0, 0, 50, 50}; GeglRectangle getrect = {0, 0, 12, 8}; guchar *buf; test_start (); buffer = gegl_buffer_new (&rect, babl_format ("Y u8")); checkerboard (buffer, 2, 0.0, 1.0); buf = g_malloc (getrect.width*getrect.height*sizeof(gfloat)); { gint i; for (i=0; i<10; i++) { getrect.x=i; /*getrect.y=i;*/ gegl_buffer_get (buffer, 1.2, &getrect, babl_format ("Y u8"), buf, 0); print_linear_buffer_u8 (getrect.width, getrect.height, buf); } } gegl_buffer_destroy (buffer); g_free (buf); test_end (); }
/* Loads an image into the Drawable. When grabbing desktop images, the Window will be unmapped first. Used only when running "real" X11, not jwxyz. */ static void load_random_image_x11 (Screen *screen, Window window, Drawable drawable, void (*callback) (Screen *, Window, Drawable, const char *name, XRectangle *geom, void *closure), void *closure) { Display *dpy = DisplayOfScreen (screen); char *grabber = get_string_resource(dpy, "desktopGrabber", "DesktopGrabber"); char *cmd; char id[200]; if (!grabber || !*grabber) { fprintf (stderr, "%s: resources installed incorrectly: \"desktopGrabber\" is unset!\n", progname); exit (1); } sprintf (id, "0x%lx 0x%lx", (unsigned long) window, (unsigned long) drawable); cmd = (char *) malloc (strlen(grabber) + strlen(id) + 1); /* Needn't worry about buffer overflows here, because the buffer is longer than the length of the format string, and the length of what we're putting into it. So the only way to crash would be if the format string itself was corrupted, but that comes from the resource database, and if hostile forces have access to that, then the game is already over. */ sprintf (cmd, grabber, id); free (grabber); grabber = 0; /* In case "cmd" fails, leave some random image on the screen, not just black or white, so that it's more obvious what went wrong. */ checkerboard (screen, drawable); if (window == drawable) print_loading_msg (screen, window); XSync (dpy, True); hack_subproc_environment (dpy); /* Start the image loading in another fork and return immediately. Invoke the callback function when done. */ fork_exec_cb (cmd, screen, window, drawable, callback, closure); free (cmd); XSync (dpy, True); }
TEST () { GeglBuffer *buffer; GeglRectangle rect = {0, 0, 20, 20}; test_start (); buffer = gegl_buffer_new (&rect, babl_format ("Y float")); checkerboard (buffer, 3, 0.0, 1.0); print_buffer (buffer); gegl_buffer_destroy (buffer); test_end (); }
TEST () { GeglBuffer *buffer, *buffer2; GeglRectangle bound = {0, 0, 20, 20}; test_start (); buffer = gegl_buffer_new (&bound, babl_format ("Y float")); vgrad (buffer); buffer2 = gegl_buffer_dup (buffer); checkerboard (buffer, 3, 0.0, 1.0); print_buffer (buffer); g_object_unref (buffer); g_object_unref (buffer2); test_end (); }
void onDraw(SkCanvas* canvas) override { SkAutoTUnref<SkImageFilter> gradient(SkImageSource::Create(fGradientCircle)); SkAutoTUnref<SkImageFilter> checkerboard(SkImageSource::Create(fCheckerboard)); SkImageFilter* filters[] = { SkBlurImageFilter::Create(12, 0), SkDropShadowImageFilter::Create(0, 15, 8, 0, SK_ColorGREEN, SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode), SkDisplacementMapEffect::Create(SkDisplacementMapEffect::kR_ChannelSelectorType, SkDisplacementMapEffect::kR_ChannelSelectorType, 12, gradient.get(), checkerboard.get()), SkDilateImageFilter::Create(2, 2, checkerboard.get()), SkErodeImageFilter::Create(2, 2, checkerboard.get()), }; const SkScalar margin = SkIntToScalar(20); const SkScalar size = SkIntToScalar(60); for (size_t j = 0; j < 3; j++) { canvas->save(); canvas->translate(margin, 0); for (size_t i = 0; i < SK_ARRAY_COUNT(filters); ++i) { SkPaint paint; paint.setColor(SK_ColorWHITE); paint.setImageFilter(filters[i]); paint.setAntiAlias(true); canvas->save(); canvas->translate(size * SK_ScalarHalf, size * SK_ScalarHalf); canvas->scale(SkDoubleToScalar(0.8), SkDoubleToScalar(0.8)); if (j == 1) { canvas->rotate(SkIntToScalar(45)); } else if (j == 2) { canvas->skew(SkDoubleToScalar(0.5), SkDoubleToScalar(0.2)); } canvas->translate(-size * SK_ScalarHalf, -size * SK_ScalarHalf); canvas->drawOval(SkRect::MakeXYWH(0, size * SkDoubleToScalar(0.1), size, size * SkDoubleToScalar(0.6)), paint); canvas->restore(); canvas->translate(size + margin, 0); } canvas->restore(); canvas->translate(0, size + margin); } for (size_t i = 0; i < SK_ARRAY_COUNT(filters); ++i) { SkSafeUnref(filters[i]); } }
static void draw_slice_error(AVPicture *frame) { int slice, mb, y, x; for (slice = 0; slice < proc.frame->slice_count; slice++) { for (mb = proc.frame->slice[slice].start_index; mb < proc.frame->slice[slice].end_index; mb++) { const int mb_x = mb % proc.mb_width; const int mb_y = mb / proc.mb_width; const byte_block_t error = byte_spread * ((5 * proc.frame->slice_count * proc.frame->slice[slice].direct_quality_loss < 1.0) ? (uint8_t)(0xFF * 5 * proc.frame->slice_count * proc.frame->slice[slice].direct_quality_loss) : 0xFF); int start_x = mb_x << mb_size_log; int start_y = mb_y << mb_size_log; int end_x = (mb_x + 1) << mb_size_log; int end_y = (mb_y + 1) << mb_size_log; /* Y */ if (proc.frame->replacement) for (y = start_y; y < end_y; y++) for (x = start_x; x < end_x; x += sizeof(byte_block_t)) BLOCK(frame->data[0], x + y * frame->linesize[0]) = error; else for (y = start_y; y < end_y; y++) for (x = start_x; x < end_x; x += sizeof(byte_block_t)) BLOCK(frame->data[0], x + y * frame->linesize[0]) = checkerboard(mb_x, mb_y); start_x = mb_x << (mb_size_log - 1); start_y = mb_y << (mb_size_log - 1); end_x = (mb_x + 1) << (mb_size_log - 1); end_y = (mb_y + 1) << (mb_size_log - 1); /* Cb */ for (y = start_y; y < end_y; y++) for (x = start_x; x < end_x; x += sizeof(byte_block_t)) BLOCK(frame->data[1], x + y * frame->linesize[1]) = byte_spread * 0x80; /* Cr */ for (y = start_y; y < end_y; y++) for (x = start_x; x < end_x; x += sizeof(byte_block_t)) BLOCK(frame->data[2], x + y * frame->linesize[2]) = byte_spread * 0x80; } /* write slice number onto the image */ print_number(frame, proc.frame->slice[slice].start_index, proc.frame->slice[slice].end_index); } }
virtual void onDraw(SkCanvas* canvas) { if (!fInitialized) { this->make_checkerboard(); this->make_gradient_circle(64, 64); fInitialized = true; } canvas->clear(0x00000000); SkAutoTUnref<SkImageFilter> gradient(SkBitmapSource::Create(fGradientCircle)); SkAutoTUnref<SkImageFilter> checkerboard(SkBitmapSource::Create(fCheckerboard)); SkAutoTUnref<SkShader> noise(SkPerlinNoiseShader::CreateFractalNoise( SkDoubleToScalar(0.1), SkDoubleToScalar(0.05), 1, 0)); SkMatrix resizeMatrix; resizeMatrix.setScale(RESIZE_FACTOR_X, RESIZE_FACTOR_Y); SkImageFilter* filters[] = { SkBlurImageFilter::Create(SkIntToScalar(12), SkIntToScalar(12)), SkDropShadowImageFilter::Create(SkIntToScalar(10), SkIntToScalar(10), SkIntToScalar(3), SK_ColorGREEN), SkDisplacementMapEffect::Create(SkDisplacementMapEffect::kR_ChannelSelectorType, SkDisplacementMapEffect::kR_ChannelSelectorType, SkIntToScalar(12), gradient.get(), checkerboard.get()), SkDilateImageFilter::Create(2, 2, checkerboard.get()), SkErodeImageFilter::Create(2, 2, checkerboard.get()), SkOffsetImageFilter::Create(SkIntToScalar(-16), SkIntToScalar(32)), SkMatrixImageFilter::Create(resizeMatrix, SkPaint::kNone_FilterLevel), SkRectShaderImageFilter::Create(noise), }; SkRect r = SkRect::MakeWH(SkIntToScalar(64), SkIntToScalar(64)); SkScalar margin = SkIntToScalar(16); SkRect bounds = r; bounds.outset(margin, margin); for (int xOffset = 0; xOffset < 80; xOffset += 16) { canvas->save(); bounds.fLeft = SkIntToScalar(xOffset); for (size_t i = 0; i < SK_ARRAY_COUNT(filters); ++i) { SkPaint paint; paint.setColor(SK_ColorWHITE); paint.setImageFilter(filters[i]); paint.setAntiAlias(true); canvas->save(); canvas->clipRect(bounds); if (5 == i) { canvas->translate(SkIntToScalar(16), SkIntToScalar(-32)); } else if (6 == i) { canvas->scale(SkScalarInvert(RESIZE_FACTOR_X), SkScalarInvert(RESIZE_FACTOR_Y)); } canvas->drawCircle(r.centerX(), r.centerY(), SkScalarDiv(r.width()*2, SkIntToScalar(5)), paint); canvas->restore(); canvas->translate(r.width() + margin, 0); } canvas->restore(); canvas->translate(0, r.height() + margin); } for (size_t i = 0; i < SK_ARRAY_COUNT(filters); ++i) { SkSafeUnref(filters[i]); } }
void VolumeRender::generate() { double start_time, end_time, dt; start_time = glfwGetTime(); // Load tree int32_t tree_size = 0; tree_data = 0; // Load from file if (_scene == 0) { tree_size = rendering::read_full_file_binary(_treeFilename, &tree_data); if (tree_size == 0) { fprintf(stderr, "Invalid tree file: %s\n", _treeFilename); exit(1); } } else { char filename_buffer[1024]; sprintf(filename_buffer, "scene%d.tree.%d", _scene, _depth); FILE* file = fopen(filename_buffer, "rb"); if (file != nullptr) { // Load tree printf("Loading file %s\n", filename_buffer); fclose(file); tree_size = rendering::read_full_file_binary(filename_buffer, &tree_data); if (tree_size == 0) { fprintf(stderr, "Invalid tree file: %s\n", filename_buffer); exit(1); } } else { // Generate printf("Generating scene for the first time, please wait..\n"); // Generate from sphere if (_scene == 1) { tree_size = rendering::genOctreeSphere((int32_t**)&tree_data, _depth, glm::vec3(0.5f, 0.5f, 0.5f), 0.4f); } // Generate from miku mesh if (_scene == 2) { if (_mesh.load("miku.md2")) { // Rotate mesh to right rotation (md2s are messed up like that..) glm::mat4 rotation = glm::rotate(180.0f, glm::vec3(0, 0, 1.0f)); rotation = glm::rotate(rotation, 90.0f, glm::vec3(0, 1.0f, 0)); _mesh.transform(rotation); tree_size = genOctreeMesh((int32_t**)&tree_data, _depth, &_mesh); } } // r = 1.5 sphere with embedded r = 1 sphere if (_scene == 3) { if (_mesh.load("miku.md2")) { // Rotate mesh to right rotation (md2s are messed up like that..) glm::mat4 rotation = glm::rotate(180.0f, glm::vec3(0, 0, 1.0f)); rotation = glm::rotate(rotation, 90.0f, glm::vec3(0, 1.0f, 0)); _mesh.transform(rotation); // Get min, max and func for octree generation glm::vec3 overall_min = *_mesh.getMin(); glm::vec3 overall_max = *_mesh.getMax(); overall_max += (overall_max - overall_min); // Make cube around bounds glm::vec3 extents = (overall_max - overall_min) * 0.5f; glm::vec3 centre = overall_min + extents; float greatest_extent = std::max(std::max(extents.x, extents.y), extents.z); extents.x = greatest_extent; extents.y = greatest_extent; extents.z = greatest_extent; overall_min = centre - extents; overall_max = centre + extents; // Sphere position glm::vec3 sphere_pos = centre; sphere_pos.x += extents.x * 0.5f; float sphere_radius = 10.0f; // Test function auto test_func = [&] (glm::vec3 min, glm::vec3 max, raw_attachment_uncompressed& shading_attributes) { glm::vec3 half_size = 0.5f * (max - min); glm::vec3 centre = min + half_size; float half_size_one_axis = half_size.x; //bool sphere_intersect = cubeSphereSurfaceIntersection(centre, half_size_one_axis, sphere_pos, sphere_radius); bool sphere_intersect = boxSphereIntersection(min, max, sphere_pos, sphere_radius); if (sphere_intersect) { // This is not normalised to save generation time // it is normalised later in the GPU anyway after being unpacked shading_attributes.normal = sphere_pos - centre; shading_attributes.colour = glm::vec4(1.0f, 1.0f, 1.0f, 0.5f); shading_attributes.reflectivity = 1.0f; shading_attributes.refractive_index = 1.5f; float distFromCentre = glm::length(shading_attributes.normal); if (distFromCentre < 0.5f * sphere_radius) shading_attributes.refractive_index = 1.0f; return true; } else { bool mesh_intersect = meshAABBIntersect(&_mesh, min, max, shading_attributes); if (mesh_intersect) { shading_attributes.colour.a = 1.0f; shading_attributes.reflectivity = 0.0f; return true; } } return false; }; point_test_func func(test_func); // Generate octree tree_size = genOctree((int32_t**)&tree_data, _depth, func, overall_min, overall_max); } } // r = 1.5 sphere with hollow sphere (should be the same as above) if (_scene == 4) { if (_mesh.load("miku.md2")) { // Rotate mesh to right rotation (md2s are messed up like that..) glm::mat4 rotation = glm::rotate(180.0f, glm::vec3(0, 0, 1.0f)); rotation = glm::rotate(rotation, 90.0f, glm::vec3(0, 1.0f, 0)); _mesh.transform(rotation); // Get min, max and func for octree generation glm::vec3 overall_min = *_mesh.getMin(); glm::vec3 overall_max = *_mesh.getMax(); overall_max += (overall_max - overall_min); // Make cube around bounds glm::vec3 extents = (overall_max - overall_min) * 0.5f; glm::vec3 centre = overall_min + extents; float greatest_extent = std::max(std::max(extents.x, extents.y), extents.z); extents.x = greatest_extent; extents.y = greatest_extent; extents.z = greatest_extent; overall_min = centre - extents; overall_max = centre + extents; // Sphere position glm::vec3 sphere_pos = centre; sphere_pos.x += extents.x * 0.5f; float sphere_radius = 10.0f; // Test function auto test_func = [&] (glm::vec3 min, glm::vec3 max, raw_attachment_uncompressed& shading_attributes) { glm::vec3 half_size = 0.5f * (max - min); glm::vec3 centre = min + half_size; float half_size_one_axis = half_size.x; //bool sphere_intersect = cubeSphereSurfaceIntersection(centre, half_size_one_axis, sphere_pos, sphere_radius); bool sphere_intersect = boxSphereIntersection(min, max, sphere_pos, sphere_radius); if (sphere_intersect) { // This is not normalised to save generation time // it is normalised later in the GPU anyway after being unpacked shading_attributes.normal = sphere_pos - centre; shading_attributes.colour = glm::vec4(1.0f, 1.0f, 1.0f, 0.5f); shading_attributes.reflectivity = 1.0f; shading_attributes.refractive_index = 1.5f; float distFromCentre = glm::length(shading_attributes.normal); if (distFromCentre < 0.5f * sphere_radius) return false; return true; } else { bool mesh_intersect = meshAABBIntersect(&_mesh, min, max, shading_attributes); if (mesh_intersect) { shading_attributes.colour.a = 1.0f; shading_attributes.reflectivity = 0.0f; return true; } } return false; }; point_test_func func(test_func); // Generate octree tree_size = genOctree((int32_t**)&tree_data, _depth, func, overall_min, overall_max); } } // Generate from mesh if (_scene == 5) { Mesh teapot("teapot.obj", true); Mesh checkerboard("checkerboard.obj", true); // Lift teapot off checkerboard a bit so they don't intersect glm::mat4 translation = glm::translate(glm::vec3(0.0f, 0.1f, 0.0f)); glm::mat4 rotation = glm::rotate(180.0f, glm::vec3(0, 0, 1.0f)); checkerboard.transform(translation * rotation); teapot.transform(rotation); // Get min, max and func for octree generation glm::vec3 overall_min = *teapot.getMin(); glm::vec3 overall_max = *teapot.getMax(); overall_max += (overall_max - overall_min); // Make cube around bounds glm::vec3 extents = (overall_max - overall_min) * 0.5f; glm::vec3 centre = overall_min + extents; float greatest_extent = std::max(std::max(extents.x, extents.y), extents.z); extents.x = greatest_extent; extents.y = greatest_extent; extents.z = greatest_extent; overall_min = centre - extents; overall_max = centre + extents; // Test function auto test_func = [&] (glm::vec3 min, glm::vec3 max, raw_attachment_uncompressed& shading_attributes) { if (meshAABBIntersect(&checkerboard, min, max, shading_attributes)) { shading_attributes.colour.a = 1.0f; shading_attributes.reflectivity = 0.0f; return true; } if (meshAABBIntersect(&teapot, min, max, shading_attributes)) { shading_attributes.colour.a = 0.3f; shading_attributes.reflectivity = 0.5f; return true; } return false; }; point_test_func func(test_func); // Generate octree tree_size = genOctree((int32_t**)&tree_data, _depth, func, overall_min, overall_max); } // transparent and reflective boxes on checkerboard if (_scene == 6) { Mesh checkerboard("checkerboard.obj", true); // The cube should have flat normals instead of smooth Mesh box1("cube.obj", true, aiProcess_GenNormals); Mesh box2("cube.obj", true, aiProcess_GenNormals); // Rotate checkerboard glm::mat4 rotation = glm::rotate(180.0f, glm::vec3(0, 0, 1.0f)); checkerboard.transform(rotation); // Scale and position box glm::mat4 translation = glm::translate(glm::vec3(0, 1.0f, 0)); glm::mat4 scale = glm::scale(glm::vec3(0.25f)); glm::mat4 box_transform = scale * translation; box1.transform(scale); box2.transform(scale); // Get min, max and func for octree generation glm::vec3 overall_min = *checkerboard.getMin(); glm::vec3 overall_max = *checkerboard.getMax(); overall_max += (overall_max - overall_min); // Make cube around bounds glm::vec3 extents = (overall_max - overall_min) * 0.5f; glm::vec3 centre = overall_min + extents; float greatest_extent = std::max(std::max(extents.x, extents.y), extents.z); extents.x = greatest_extent; extents.y = greatest_extent; extents.z = greatest_extent; overall_min = centre - extents; overall_max = centre + extents; // Test function auto test_func = [&] (glm::vec3 min, glm::vec3 max, raw_attachment_uncompressed& shading_attributes) { if (meshAABBIntersect(&checkerboard, min, max, shading_attributes)) { shading_attributes.colour.a = 1.0f; shading_attributes.reflectivity = 0.0f; return true; } if (meshAABBIntersect(&box1, min, max, shading_attributes)) { shading_attributes.colour.a = 1.0f; shading_attributes.reflectivity = 1.0f; return true; } return false; }; point_test_func func(test_func); // Generate octree tree_size = genOctree((int32_t**)&tree_data, _depth, func, overall_min, overall_max); } // Reflective inverted box with teapot inside if (_scene == 7) { // The cube should have flat normals instead of smooth Mesh teapot("teapot.obj", true); Mesh box1("inverted_cube.obj", true, aiProcess_GenNormals); teapot.transform(glm::scale(glm::vec3(0.2f)) * glm::rotate(180.0f, glm::vec3(0.0f, 0.0f, 1.0f))); // Get min, max and func for octree generation glm::vec3 overall_min = *box1.getMin(); glm::vec3 overall_max = *box1.getMax(); overall_max += (overall_max - overall_min); // Make cube around bounds glm::vec3 extents = (overall_max - overall_min) * 0.5f; glm::vec3 centre = overall_min + extents; float greatest_extent = std::max(std::max(extents.x, extents.y), extents.z); extents.x = greatest_extent; extents.y = greatest_extent; extents.z = greatest_extent; overall_min = centre - extents; overall_max = centre + extents; // Test function auto test_func = [&] (glm::vec3 min, glm::vec3 max, raw_attachment_uncompressed& shading_attributes) { glm::vec3 aabb_extents = (max - min) * 0.5f; glm::vec3 aabb_centre = aabb_centre + min; if (meshAABBIntersect(&box1, min, max, shading_attributes)) { shading_attributes.colour.a = 1.0f; shading_attributes.reflectivity = 1.0f; return true; } if (meshAABBIntersect(&teapot, min, max, shading_attributes)) { shading_attributes.colour = glm::vec4(1.0f, 0.0f, 0.0f, 1.0f); shading_attributes.reflectivity = 0.0f; return true; } return false; }; point_test_func func(test_func); // Generate octree tree_size = genOctree((int32_t**)&tree_data, _depth, func, overall_min, overall_max); } // Write custom generation to file if (_saveTrees) { printf("Writing %s...\n", filename_buffer); file = fopen(filename_buffer, "wb"); if (file == nullptr) { fprintf(stderr, "Failed to open file for writing: %s\n", filename_buffer); } else { fwrite(tree_data, tree_size, sizeof(char), file); fclose(file); } } } } // Calculate time to load/generate end_time = glfwGetTime(); dt = end_time - start_time; printf("Time to load/generate tree: %f\n", dt); printf("%.2fMB\n", tree_size / (1024.0f * 1024.0f)); // Reset timer start_time = glfwGetTime(); // Upload sphere to GPU gpuErrchk(cudaMalloc((void**)&_gpuTree, tree_size)); gpuErrchk(cudaMemcpy(_gpuTree, tree_data, tree_size, cudaMemcpyHostToDevice)); // Calculate time to upload end_time = glfwGetTime(); dt = end_time - start_time; printf("Time to upload tree: %f\n", dt); printf("%.2fMB\n", tree_size / (1024.0f * 1024.0f)); // Free CPU memory //free(tree_data); }
void display(void) { glClear(GL_COLOR_BUFFER_BIT); checkerboard(10); glutSwapBuffers(); }
virtual void onDraw(SkCanvas* canvas) { if (!fInitialized) { fCheckerboard.allocN32Pixels(64, 64); SkCanvas checkerboardCanvas(fCheckerboard); sk_tool_utils::draw_checkerboard(&checkerboardCanvas, 0xFFA0A0A0, 0xFF404040, 8); this->make_gradient_circle(64, 64); fInitialized = true; } canvas->clear(SK_ColorBLACK); SkAutoTUnref<SkImageFilter> gradient(SkBitmapSource::Create(fGradientCircle)); SkAutoTUnref<SkImageFilter> checkerboard(SkBitmapSource::Create(fCheckerboard)); SkAutoTUnref<SkShader> noise(SkPerlinNoiseShader::CreateFractalNoise( SkDoubleToScalar(0.1), SkDoubleToScalar(0.05), 1, 0)); SkPoint3 pointLocation(0, 0, SkIntToScalar(10)); SkPoint3 spotLocation(SkIntToScalar(-10), SkIntToScalar(-10), SkIntToScalar(20)); SkPoint3 spotTarget(SkIntToScalar(40), SkIntToScalar(40), 0); SkScalar spotExponent = SK_Scalar1; SkScalar cutoffAngle = SkIntToScalar(15); SkScalar kd = SkIntToScalar(2); SkScalar surfaceScale = SkIntToScalar(1); SkColor white(0xFFFFFFFF); SkMatrix resizeMatrix; resizeMatrix.setScale(RESIZE_FACTOR, RESIZE_FACTOR); SkImageFilter* filters[] = { SkBlurImageFilter::Create(SkIntToScalar(4), SkIntToScalar(4)), SkDropShadowImageFilter::Create(SkIntToScalar(5), SkIntToScalar(10), SkIntToScalar(3), SkIntToScalar(3), SK_ColorYELLOW, SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode), SkDisplacementMapEffect::Create(SkDisplacementMapEffect::kR_ChannelSelectorType, SkDisplacementMapEffect::kR_ChannelSelectorType, SkIntToScalar(12), gradient.get(), checkerboard.get()), SkDilateImageFilter::Create(1, 1, checkerboard.get()), SkErodeImageFilter::Create(1, 1, checkerboard.get()), SkOffsetImageFilter::Create(SkIntToScalar(32), 0), SkImageFilter::CreateMatrixFilter(resizeMatrix, kNone_SkFilterQuality), SkRectShaderImageFilter::Create(noise), SkLightingImageFilter::CreatePointLitDiffuse(pointLocation, white, surfaceScale, kd), SkLightingImageFilter::CreateSpotLitDiffuse(spotLocation, spotTarget, spotExponent, cutoffAngle, white, surfaceScale, kd), }; SkVector scales[] = { SkVector::Make(SkScalarInvert(2), SkScalarInvert(2)), SkVector::Make(SkIntToScalar(1), SkIntToScalar(1)), SkVector::Make(SkIntToScalar(1), SkIntToScalar(2)), SkVector::Make(SkIntToScalar(2), SkIntToScalar(1)), SkVector::Make(SkIntToScalar(2), SkIntToScalar(2)), }; SkRect r = SkRect::MakeWH(SkIntToScalar(64), SkIntToScalar(64)); SkScalar margin = SkIntToScalar(16); SkRect bounds = r; bounds.outset(margin, margin); for (size_t j = 0; j < SK_ARRAY_COUNT(scales); ++j) { canvas->save(); for (size_t i = 0; i < SK_ARRAY_COUNT(filters); ++i) { SkPaint paint; paint.setColor(SK_ColorBLUE); paint.setImageFilter(filters[i]); paint.setAntiAlias(true); canvas->save(); canvas->scale(scales[j].fX, scales[j].fY); if (5 == i) { canvas->translate(SkIntToScalar(-32), 0); } else if (6 == i) { canvas->scale(SkScalarInvert(RESIZE_FACTOR), SkScalarInvert(RESIZE_FACTOR)); } canvas->drawCircle(r.centerX(), r.centerY(), SkScalarDiv(r.width()*2, SkIntToScalar(5)), paint); canvas->restore(); canvas->translate(r.width() * scales[j].fX + margin, 0); } canvas->restore(); canvas->translate(0, r.height() * scales[j].fY + margin); } for (size_t i = 0; i < SK_ARRAY_COUNT(filters); ++i) { filters[i]->unref(); } }
void display_loop(){ // mcuf_serial_mode(); mode = setjmp(newmode_jmpbuf); #ifdef JOYSTICK_SUPPORT // in case we get here via mode jump, we (re)enable joystick queries waitForFire = 1; #endif oldOldmode = oldMode; #ifdef JOYSTICK_SUPPORT waitForFire = 1; #endif for(;;){ #ifndef MENU_SUPPORT clear_screen(0); #endif oldMode = mode; switch(mode++) { #ifdef ANIMATION_SCROLLTEXT case 1: scrolltext(scrolltext_text); #ifdef RANDOM_SUPPORT { char a[28]; sprintf(a,"</# counter == %lu ", (unsigned long)percnt_get(&g_reset_counter, &g_reset_counter_idx)); scrolltext(a); } #endif #endif #ifdef ANIMATION_TIME #ifndef ANIMATION_SCROLLTEXT case 1: #endif time_anim(); break; #else #ifdef ANIMATION_SCROLLTEXT break; #endif #endif #ifdef ANIMATION_SPIRAL # ifndef SPIRAL_DELAY # define SPIRAL_DELAY 5 # endif case 2: spiral(SPIRAL_DELAY); break; #endif #ifdef ANIMATION_JOERN1 case 3: joern1(); break; #endif #ifdef ANIMATION_SNAKE case 4: snake_animation(); break; #endif #ifdef ANIMATION_CHECKERBOARD case 5: checkerboard(20); break; #endif #ifdef ANIMATION_FIRE case 6: fire(); break; #endif #ifdef ANIMATION_TIME case 7: time_anim(); break; #endif #ifdef ANIMATION_MATRIX case 8: matrix(); break; #endif #ifdef ANIMATION_RANDOM_BRIGHT case 9: random_bright(30); break; #endif #ifdef ANIMATION_STONEFLY case 10: stonefly(); break; #endif #ifdef ANIMATION_GAMEOFLIFE case 11: gameoflife(); break; #endif #ifdef ANIMATION_FLYINGDOTS case 12: flyingdots(); break; #endif #ifdef ANIMATION_BREAKOUT case 13: breakout_demo(); break; #endif #ifdef ANIMATION_MHERWEG case 14: mherweg(); break; #endif #ifdef ANIMATION_MOIRE case 15: moire(); break; #endif #ifdef ANIMATION_TIME case 16: time_anim(); break; #endif #ifdef ANIMATION_LTN_ANT case 17: ltn_ant(); break; #endif #ifdef ANIMATION_LABORLOGO case 18: laborlogo(); break; #endif #ifdef ANIMATION_AMPHIBIAN case 19: amphibian(); break; #endif #ifdef ANIMATION_LOGO_OOS case 20: logo_OutOfSpec(); break; #endif #ifdef ANIMATION_FAIRYDUST case 21: fairydust(); break; #endif #ifdef ANIMATION_PLASMA case 22: plasma(); break; #endif #ifdef ANIMATION_PSYCHEDELIC case 23: psychedelic(); break; #endif #ifdef ANIMATION_BLACKHOLE case 24: blackhole(); break; #endif #ifdef ANIMATION_SQUARES case 25: squares(); break; #endif #ifdef ANIMATION_DNA case 26: dna(); break; #endif #ifdef ANIMATION_TESTS case 31: test_level(1, false); break; case 32: test_level(2, false); break; case 33: test_level(3, false); break; case 35: test_palette(false); test_palette2(false); break; #endif #ifdef SMALLANIMATION_ROWWALK case 36: rowwalk(SMALLANIMATION_ROWWALK_COUNT,SMALLANIMATION_ROWWALK_SPEED); break; #endif #ifdef SMALLANIMATION_COLWALK case 37: colwalk(SMALLANIMATION_COLWALK_COUNT,SMALLANIMATION_COLWALK_SPEED); break; #endif #ifdef SMALLANIMATION_COLBOUNCE case 38: colbounce(SMALLANIMATION_COLBOUNCE_COUNT,SMALLANIMATION_COLBOUNCE_SPEED); break; #endif #ifdef SMALLANIMATION_ROWBOUNCE case 39: rowbounce(SMALLANIMATION_ROWBOUNCE_COUNT,SMALLANIMATION_ROWBOUNCE_SPEED); break; #endif #ifdef MENU_SUPPORT case 0xFDu: mode = 1; break; case 0xFEu: menu(); mode = oldOldmode; break; #else case 0xFDu: #ifdef JOYSTICK_SUPPORT if (JOYISFIRE) mode = 0xFEu; else #endif mode = 1; break; case 0xFEu: #ifdef JOYSTICK_SUPPORT waitForFire = 0; // avoid circular jumps while (JOYISFIRE); // wait until user released the fire button #endif wait(25); // wait for button to settle # ifdef GAME_TETRIS tetris(); # endif # ifdef GAME_BASTET tetris_bastet(); # endif # ifdef GAME_TETRIS_FP tetris_fp(); # endif # ifdef GAME_SPACE_INVADERS borg_invaders(); # endif # ifdef GAME_SNAKE snake_game(); # endif # ifdef GAME_BREAKOUT borg_breakout(0); # endif #ifdef JOYSTICK_SUPPORT while (JOYISFIRE); // avoid an unwanted restart of the game loop #endif wait(25); // wait for button to settle mode = oldOldmode; // restore old animation mode #ifdef JOYSTICK_SUPPORT waitForFire = 1; // reenable joystick query of the wait() function #endif break; #endif #ifdef ANIMATION_OFF case 0xFFu: off(); break; #endif default: if (reverseMode) { if (reverseMode-- == (mode - 1)) { mode -= 2; } else { reverseMode = 0; } } break; } } }