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;
}
}
}
