新規サンプルの追加

Author: Hasenpfote

BitonicSort/CMakeLists.txt

@@ -0,0 +1,6 @@
+cmake_minimum_required(VERSION 3.5)
+
+project(BitonicSort)
+
+include(template)
+make_simple_example_project(${PROJECT_NAME})

BitonicSort/README.md

@@ -0,0 +1,25 @@
+Bitonic Sort
+=============================
+
+
+
+![Preview](preview.gif)
+
+
+
+This sample is a WORK IN PROGRESS and actually not meant as a sample.
+
+On the TODO list:
+*
+
+Run the sample for more information.
+
+
+
+See also:
+
+- [Bitonic sort](http://www.iti.fh-flensburg.de/lang/algorithmen/sortieren/bitonic/bitonicen.htm)
+- [Bitonic sorting network for n not a power of 2](http://www.iti.fh-flensburg.de/lang/algorithmen/sortieren/bitonic/oddn.htm)
+- [[GPU Gems 2](https://developer.nvidia.com/gpugems/GPUGems2/gpugems2_chapter46.html)]
+- [t-pot『Bitonic sort』](https://t-pot.com/program/90_BitonicSort/index.html)
+

BitonicSort/assets/shaders/apply.fs

@@ -0,0 +1,13 @@
+#version 430
+
+out vec4 o_color;
+
+uniform sampler2D u_tex0;
+uniform vec2 u_pixel_size;
+
+void main(void)
+{
+    vec2 tex_coord = gl_FragCoord.xy * u_pixel_size;
+    o_color.rgb = texture(u_tex0, tex_coord).rgb;
+    o_color.a = 1.0;
+}

BitonicSort/assets/shaders/apply.vs

@@ -0,0 +1,13 @@
+#version 430
+
+layout(location = 0) in vec3 vs_position;
+
+out gl_PerVertex
+{
+    vec4 gl_Position;
+};
+
+void main(void)
+{
+    gl_Position = vec4(vs_position.x, vs_position.y, 0.0, 1.0);
+}

BitonicSort/assets/shaders/decode.fs

@@ -0,0 +1,31 @@
+#version 430
+
+out vec4 o_color;
+
+uniform sampler2D u_tex0;
+uniform vec2 u_src_resolution;
+uniform vec2 u_dst_resolution;
+
+float address(vec2 address2d, vec2 resolution)
+{
+    vec2 temp = floor(address2d);
+    return temp.y * resolution.x + temp.x;
+}
+
+vec2 address(float address1d, vec2 resolution)
+{
+    vec2 temp;
+    temp.x = mod(address1d, resolution.x);
+    temp.y = address1d / resolution.x;
+    return floor(temp) + 0.5;
+}
+
+void main(void)
+{
+    float adr1d = address(gl_FragCoord.xy, u_dst_resolution);
+    vec2 adr2d = address(adr1d, u_src_resolution);
+
+    vec3 color = texture(u_tex0, adr2d / u_src_resolution).rgb;
+
+    o_color = vec4(color, 1.0);
+}

BitonicSort/assets/shaders/decode.vs

@@ -0,0 +1,13 @@
+#version 430
+
+layout(location = 0) in vec3 vs_position;
+
+out gl_PerVertex
+{
+    vec4 gl_Position;
+};
+
+void main(void)
+{
+    gl_Position = vec4(vs_position.x, vs_position.y, 0.0, 1.0);
+}

BitonicSort/assets/shaders/noise.fs

@@ -0,0 +1,52 @@
+#version 430
+
+out vec4 o_color;
+
+uniform vec2 u_pixel_size;
+
+float hash(in vec2 p)
+{
+    return fract(sin(dot(p.xy, vec2(12.9898, 78.233))) * 43758.5453123);
+}
+
+float noise(in vec2 x)
+{
+    vec2 i = floor(x);
+    vec2 f = fract(x);
+
+    // Four corners.
+    float a = hash(i);
+    float b = hash(i + vec2(1.0, 0.0));
+    float c = hash(i + vec2(0.0, 1.0));
+    float d = hash(i + vec2(1.0, 1.0));
+
+    // Cubic Hermite Curve.
+    vec2 u = smoothstep(0.0, 1.0, f);
+
+    return mix(mix(a, b, u.x), mix(c, d, u.x), u.y);
+}
+
+#define OCTAVES 6
+float fbm(in vec2 st)
+{
+    float value = 0.0;
+    float amplitude = .5;
+    float frequency = 0.;
+
+    for(int i = 0; i < OCTAVES; i++)
+    {
+        value += amplitude * noise(st);
+        st *= 2.;
+        amplitude *= .5;
+    }
+    return value;
+}
+
+void main(void)
+{
+    vec2 p = gl_FragCoord.xy * u_pixel_size;
+
+    vec3 color = vec3(fbm(p*3.0));
+
+    o_color = vec4(color, 1.0);
+}

BitonicSort/assets/shaders/noise.vs

@@ -0,0 +1,13 @@
+#version 430
+
+layout(location = 0) in vec3 vs_position;
+
+out gl_PerVertex
+{
+    vec4 gl_Position;
+};
+
+void main(void)
+{
+    gl_Position = vec4(vs_position.x, vs_position.y, 0.0, 1.0);
+}

BitonicSort/assets/shaders/sort.fs

@@ -0,0 +1,44 @@
+#version 430
+
+out vec4 o_color;
+
+uniform sampler2D u_tex0;
+uniform vec2 u_resolution;
+uniform float u_seq_size;
+uniform float u_offset;
+uniform float u_range;
+
+float address(vec2 address2d, vec2 resolution)
+{
+    vec2 temp = floor(address2d);
+    return temp.y * resolution.x + temp.x;
+}
+
+vec2 address(float address1d, vec2 resolution)
+{
+    vec2 temp;
+    temp.x = mod(address1d, resolution.x);
+    temp.y = address1d / resolution.x;
+    return floor(temp) + 0.5;
+}
+
+void main(void)
+{
+    float own_adr1d = address(gl_FragCoord.xy, u_resolution);
+
+    float fetch_dir = (mod(own_adr1d, u_range) < u_offset)? 1 : -1;
+    float sort_dir = (mod(floor(own_adr1d / u_seq_size), 2.0) <= 0.5)? 1 : -1;
+
+    float partner_adr1d = own_adr1d + fetch_dir * u_offset;
+    vec2 partner_adr2d = address(partner_adr1d, u_resolution);
+
+    vec3 own_color = texture(u_tex0, gl_FragCoord.xy / u_resolution).rgb;
+    vec3 partner_color = texture(u_tex0, partner_adr2d / u_resolution).rgb;
+
+    vec3 min_color = (own_color.x < partner_color.x)? own_color : partner_color;
+    vec3 max_color = (own_color.x < partner_color.x)? partner_color : own_color;
+
+    vec3 color = (fetch_dir == sort_dir)? min_color : max_color;
+
+    o_color = vec4(color, 1.0);
+}

BitonicSort/assets/shaders/sort.vs

@@ -0,0 +1,13 @@
+#version 430
+
+layout(location = 0) in vec3 vs_position;
+
+out gl_PerVertex
+{
+    vec4 gl_Position;
+};
+
+void main(void)
+{
+    gl_Position = vec4(vs_position.x, vs_position.y, 0.0, 1.0);
+}

BitonicSort/preview.gif

@@ -0,0 +1,99 @@
+#include <iterator>
+#include <cstdlib>
+#include <cassert>
+#include <array>
+#include <cmath>
+#include <vector>
+#include <numeric>
+#include <random>
+#include <algorithm>
+#include "bitonic_sort.h"
+
+namespace bitonic_sort
+{
+
+static int solve_quadratic_equation(double a, double b, double c, std::array<double, 2> & roots)
+{
+    double d = b * b - 4.0 * a * c;
+    if(d < 0.0)
+        return 0;   // equation has imaginary roots.
+
+    double x = (std::abs(b) + std::sqrt(d)) / (2.0 * a);
+    if(d > 0.0)
+    {
+        // equation has 2 roots.
+        if(b < 0.0) // negative sign
+        {
+            // x1 = (- b - sqrt(D)) / 2a = (- (-|b|) - sqrt(D)) / 2a = (|b| - sqrt(D)) / 2a ... When b is larger, There is a possibility to underflow.
+            // x2 = (- b + sqrt(D)) / 2a = (- (-|b|) + sqrt(D)) / 2a = (|b| + sqrt(D)) / 2a
+            roots[0] = c / (a * x);	// rationalize the numerator
+            roots[1] = x;
+        }
+        else        // positive sign
+        {
+            // x1 = (- b - sqrt(D)) / 2a = (- (+|b|) - sqrt(D)) / 2a = (-|b| - sqrt(D)) / 2a = -(|b| + sqrt(D)) / 2a
+            // x2 = (- b + sqrt(D)) / 2a = (- (+|b|) + sqrt(D)) / 2a = (-|b| + sqrt(D)) / 2a = -(|b| - sqrt(D)) / 2a ... When b is larger, There is a possibility to underflow.
+            roots[0] = -x;
+            roots[1] = -(c / (a * x));	// rationalize the numerator
+        }
+        return 2;
+    }
+
+    // equation has 1 root
+    roots[0] = roots[1] = (b < 0.0) ? x : -x;
+    return 1;
+}
+
+static int pass_to_step(int pass)
+{
+    // ax^2 + bx + c = 0
+    double a = 1.0;
+    double b = 1.0;
+    double c = -2.0 * static_cast<double>(pass);
+    std::array<double, 2> roots;
+    auto ret = solve_quadratic_equation(a, b, c, roots);
+    assert(ret > 0);
+    auto root = std::max(roots[0], roots[1]);
+
+    return static_cast<int>(std::ceil(root));
+}
+
+static int pass_to_stage(int pass, int step)
+{
+    auto sum = step * (step + 1) / 2;
+    return sum - pass + 1;
+}
+
+static int stage_to_offset(int stage)
+{
+    return std::pow(2.0, stage - 1);
+}
+
+double next_lower_power_of_two(double x)
+{
+    return std::pow(2.0, std::floor(std::log2(x)));
+}
+
+double next_higher_power_of_two(double x)
+{
+    return std::pow(2.0, std::ceil(std::log2(x)));
+}
+
+int get_num_passes(int N)
+{
+    auto n = static_cast<int>(std::log2(N));
+    return n * (n + 1) / 2;
+}
+
+params get_params(int pass)
+{
+    auto step = pass_to_step(pass);
+    auto stage = pass_to_stage(pass, step);
+    auto seq_size = static_cast<int>(std::pow(2.0, step));
+    auto offset = stage_to_offset(stage);
+    auto range = offset * 2;
+
+    return std::make_tuple(step, stage, seq_size, offset, range);
+}
+
+}

BitonicSort/src/bitonic_sort.cpp

@@ -0,0 +1,13 @@
+#pragma once
+
+namespace bitonic_sort
+{
+
+using params = std::tuple<int, int, int, int, int>;
+
+double next_lower_power_of_two(double x);
+double next_higher_power_of_two(double x);
+int get_num_passes(int N);
+params get_params(int pass);
+
+}