cloudmap 0.1.1

pub use crate::cpu_shader::cm::cm3;
pub use crate::cpu_shader::cm::cm3_blue;
pub use crate::cpu_shader::cm::cm3_arrow;
mod cpu_shader {
    pub mod cm {
        extern crate nalgebra as na;
        extern crate nalgebra_glm as glm;
        use na::{Point3, Vector1, Vector3};

        pub fn cm3(u: f64, v: f64, ca: f64, cb: f64, cc: f64, cut: f64, n: i32) -> [u32; 4] {
            // let n = 12;

            let w1 = 1.0 - u;
            let w2 = u - v;
            let w3 = v;

            let mut vv = w1 * ca + w2 * cb + w3 * cc;

            let stair = 0.25;
            let per_step = n / 4;
            let mut i = 0;
            let j = per_step as u32;
            let mut perPC: [u32; 4] = [0, 0, 0, 0];
            // if  vv<0. {
            //     vv=0.;
            // }
            if vv <= cut {
                // perPC = [255, 255, 255, 255];
            } else {
                if vv <= 0.25 && vv >= 0.0 {
                    i = 0;
                    while i < j {
                        if vv >= i as f64 * stair / per_step as f64
                            && vv <= ((i as f64) + 1.0) * stair / per_step as f64
                        {
                            perPC = [0, (i as f64 / per_step as f64 * 255.0) as u32, 255, 255];
                            break;
                        }
                        i += 1;
                    }
                } else if vv > 0.25 && vv <= 0.5 {
                    i = 0;
                    while i < j {
                        if vv >= 0.25 + i as f64 * stair / per_step as f64
                            && vv <= 0.25 + ((i as f64) + 1.0) * stair / per_step as f64
                        {
                            perPC = [
                                0,
                                255,
                                (1.0 - (i + 1) as f64 / per_step as f64 * 255.0) as u32,
                                255,
                            ];
                            break;
                        }
                        i += 1;
                    }
                } else if vv > 0.5 && vv <= 0.75 {
                    i = 0;
                    while i < j {
                        if vv >= 0.5 + i as f64 * stair / per_step as f64
                            && vv <= 0.5 + ((i as f64) + 1.0) * stair / per_step as f64
                        {
                            perPC = [
                                ((i + 1) as f64 / per_step as f64 * 255.0) as u32,
                                255,
                                0,
                                255,
                            ];
                            break;
                        }
                        i += 1;
                    }
                } else if vv > 0.75 && vv <= 1.0 {
                    i = 0;
                    while i < j {
                        if vv >= 0.75 + i as f64 * stair / per_step as f64
                            && vv <= 0.75 + ((i as f64) + 1.0) * stair / per_step as f64
                        {
                            perPC = [
                                255,
                                ((1.0 - ((i + 1) as f64) / per_step as f64) * 255.0) as u32,
                                0,
                                255,
                            ];
                            break;
                        }
                        i += 1;
                    }
                } else {
                    perPC = [255, 255, 255, 255];
                }
            }
            return perPC;
        }
        pub fn cm3_blue(u: f64, v: f64, ca: f64, cb: f64, cc: f64, cut: f64, n: i32) -> [u32; 4] {
            // let n = 12;

            let w1 = 1.0 - u;
            let w2 = u - v;
            let w3 = v;

            let mut vv = w1 * ca + w2 * cb + w3 * cc;

            let stair = 0.25;
            let per_step = n / 4;
            let mut i = 0;
            let j = per_step as u32;
            let mut perPC: [u32; 4] = [0, 0, 0, 0];
            // if  vv<0. {
            //     vv=0.;
            // }
            if vv <= cut {
                // perPC = [255, 255, 255, 255];
            } else {
                if vv <= 0.25 && vv >= 0.0 {
                    i = 0;
                    while i < j {
                        if vv >= i as f64 * stair / per_step as f64
                            && vv <= ((i as f64) + 1.0) * stair / per_step as f64
                        {
                            perPC = [
                                0,
                                ((1.0 - i as f64 / per_step as f64 * stair as f64) * 255.0)
                                    as u32,
                                255,
                                255,
                            ];
                            break;
                        }
                        i += 1;
                    }
                } else if vv > 0.25 && vv <= 0.5 {
                    i = 0;
                    while i < j {
                        if vv >= 0.25 + i as f64 * stair / per_step as f64
                            && vv <= 0.25 + ((i as f64) + 1.0) * stair / per_step as f64
                        {
                            perPC = [
                                0,
                                ((0.75 - i as f64 / per_step as f64 * stair as f64) * 255.0)
                                    as u32,
                                255,
                                255,
                            ];
                            break;
                        }
                        i += 1;
                    }
                } else if vv > 0.5 && vv <= 0.75 {
                    i = 0;
                    while i < j {
                        if vv >= 0.5 + i as f64 * stair / per_step as f64
                            && vv <= 0.5 + ((i as f64) + 1.0) * stair / per_step as f64
                        {
                            perPC = [
                                0,
                                ((0.5 - i as f64 / per_step as f64 * stair as f64) * 255.0)
                                    as u32,
                                255,
                                255,
                            ];
                            break;
                        }
                        i += 1;
                    }
                } else if vv > 0.75 && vv <= 1.0 {
                    i = 0;
                    while i < j {
                        if vv >= 0.75 + i as f64 * stair / per_step as f64
                            && vv <= 0.75 + ((i as f64) + 1.0) * stair / per_step as f64
                        {
                            perPC = [
                                0,
                                ((0.25 - i as f64 / per_step as f64 * stair as f64  )
                                    * 255.0) as u32,
                                255,
                                255,
                            ];
                            break;
                        }
                        i += 1;
                    }
                } else {
                    perPC = [255, 255, 255, 255];
                }
            }
            return perPC;
        }

        pub fn cm3_f64(u: f64, v: f64, ca: f64, cb: f64, cc: f64, cut: f64, n: i32) -> [f64; 3] {
            // let n = 12;

            let w1 = 1.0 - u;
            let w2 = u - v;
            let w3 = v;

            let mut vv = w1 * ca + w2 * cb + w3 * cc;

            let stair = 0.25;
            let per_step = n / 4;
            let mut i = 0;
            let j = n as u32;
            let mut perPC: [f64; 3] = [0.0, 0.0, 0.0];
            // if  vv<0. {
            //     vv=0.;
            // }
            if vv <= cut {
                // perPC = [255, 255, 255, 255];
            } else {
                if vv <= 0.25 && vv >= 0.0 {
                    i = 0;
                    while i < j {
                        if vv >= i as f64 * stair / per_step as f64
                            && vv <= ((i as f64) + 1.0) * stair / per_step as f64
                        {
                            perPC = [0.0, (i as f64 / per_step as f64 * 1.0) as f64, 1.0];
                            break;
                        }
                        i += 1;
                    }
                } else if vv > 0.25 && vv <= 0.5 {
                    i = 0;
                    while i < j {
                        if vv >= 0.25 + i as f64 * stair / per_step as f64
                            && vv <= 0.25 + ((i as f64) + 1.0) * stair / per_step as f64
                        {
                            perPC = [
                                0.0,
                                1.,
                                (1.0 - (i + 1) as f64 / per_step as f64 * 1.0) as f64,
                            ];
                            break;
                        }
                        i += 1;
                    }
                } else if vv > 0.5 && vv <= 0.75 {
                    i = 0;
                    while i < j {
                        if vv >= 0.5 + i as f64 * stair / per_step as f64
                            && vv <= 0.5 + ((i as f64) + 1.0) * stair / per_step as f64
                        {
                            perPC = [((i + 1) as f64 / per_step as f64 * 1.0) as f64, 1.0, 0.0];
                            break;
                        }
                        i += 1;
                    }
                } else if vv > 0.75 && vv <= 1.0 {
                    i = 0;
                    while i < j {
                        if vv >= 0.75 + i as f64 * stair / per_step as f64
                            && vv <= 0.75 + ((i as f64) + 1.0) * stair / per_step as f64
                        {
                            perPC = [1.0, ((1.0 - ((i + 1) as f64) / per_step as f64) * 1.0), 0.0];
                            break;
                        }
                        i += 1;
                    }
                } else {
                    perPC = [1.0, 1.0, 1.0];
                }
            }
            return perPC;
        }
        pub fn cm3_f64_mm(vv: f64, cut: f64, n: i32) -> [f64; 3] {
            let stair = 0.25;
            let per_step = (n / 4) as f64;
            let mut i = 0;
            let j = n as u32;
            let mut perPC: [f64; 3] = [0.0, 0.0, 0.0];
            // if  vv<0. {
            //     vv=0.;
            // }
            if vv <= cut {
                // perPC = [255, 255, 255, 255];
            } else {
                if vv <= 0.25 && vv >= 0.0 {
                    i = 0;
                    while i < j {
                        if vv >= i as f64 * stair / per_step
                            && vv <= ((i as f64) + 1.0) * stair / per_step
                        {
                            perPC = [0.0, (i as f64 / per_step * 1.0) as f64, 1.0];
                            break;
                        }
                        i += 1;
                    }
                } else if vv > 0.25 && vv <= 0.5 {
                    i = 0;
                    while i < j {
                        if vv >= 0.25 + i as f64 * stair / per_step
                            && vv <= 0.25 + ((i as f64) + 1.0) * stair / per_step
                        {
                            perPC = [0.0, 1., (1.0 - (i + 1) as f64 / per_step * 1.0) as f64];
                            break;
                        }
                        i += 1;
                    }
                } else if vv > 0.5 && vv <= 0.75 {
                    i = 0;
                    while i < j {
                        if vv >= 0.5 + i as f64 * stair / per_step
                            && vv <= 0.5 + ((i as f64) + 1.0) * stair / per_step
                        {
                            perPC = [((i + 1) as f64 / per_step * 1.0) as f64, 1.0, 0.0];
                            break;
                        }
                        i += 1;
                    }
                } else if vv > 0.75 && vv <= 1.0 {
                    i = 0;
                    while i < j {
                        if vv >= 0.75 + i as f64 * stair / per_step
                            && vv <= 0.75 + ((i as f64) + 1.0) * stair / per_step
                        {
                            perPC = [1.0, ((1.0 - ((i + 1) as f64) / per_step) * 1.0), 0.0];
                            break;
                        }
                        i += 1;
                    }
                } else {
                    perPC = [1.0, 1.0, 1.0];
                }
            }
            return perPC;
        }

        //glsl to cpu math has some problem ,手工适配，调整参数，无道理
        pub fn cm3_arrow(ux: f64, vy: f64, u: f64, v: f64, vv: f64, cut: f64, n: i32) -> [u32; 4] {
            let vector1: f64 = sdVectorArrow([u, v], [ux, vy]);
            // let vector1: f64 = arrow([u, v], [ux, vy]);

            let mut mixcolor = [0., 0., 0.];
            let x = glm::vec3(0.0, 0.0, 0.0);
            let pre_y = cm3_f64_mm(vv, cut, n);
            let y = glm::vec3(pre_y[0], pre_y[1], pre_y[2]);
            let a = glm::vec1(vector1);
            let mix_color = glm::mix(&x, &y, vector1);

            let r = *mix_color.get(0).unwrap();
            let g = *mix_color.get(1).unwrap();
            let b = *mix_color.get(2).unwrap();
            if r == 0.0 && g == 0.0 && b == 0.0 {
                [0, 0, 0, 0]
            } else {
                [
                    (r * 255.0) as u32,
                    (g * 255.0) as u32,
                    (b * 255.0) as u32,
                    255,
                ]
            }

            // let d = sdEquilateralTriangle([u, v], 0.1);

            // if d > 0.0 {
            //     [0, 0, 0, 0]
            // } else {
            //     [255, 0, 0, 255]
            // }
        }

        fn thc(a: f64, b: f64) -> f64 {
            return (a * b.cos()).tanh() / a.tanh();
        }

        fn sdEquilateralTriangle(p: [f64; 2], distance: f64, size: f64) -> f64 {
            //size 0.6--0.2 比较适合，大小
            // distance ，控制位移，1:中心附近，0：前移
            let k = 3.0_f64.sqrt();
            let p_x = p[0].abs() - size;
            let p_y = p[1] + distance / k;

            let mut p1: [f64; 2] = [p_x, p_y];
            if (p_x + k * p_y > 0.0) {
                p1 = [(p_x - k * p_y) / 2.0, (-k * p_x - p_y) / 2.0];
            }

            p1[0] = p1[0].clamp(-2.0 * distance, 0.0);

            let len_p1 = glm::length(&glm::vec2(p1[0], p1[1]));
            let sign_py: f64 = if p1[1] > 0.0 {
                1.0
            } else {
                if p1[1] < 0.0 {
                    -1.0
                } else {
                    0.0
                }
            };
            return -len_p1 * sign_py;
        }

        fn sdBox(p: [f64; 2], b: [f64; 2]) -> f64 {
            let g_p = glm::vec2(p[0], p[1]);
            let g_b = glm::vec2(b[0], b[1]);
            let d = glm::abs(&g_p) - g_b;
            let one = glm::length(&glm::max(&d, 0.));
            return one + (d.x.max(d.y)).min(0.0);
        }

        fn arrow(uv: [f64; 2], v: [f64; 2], v_old: [f64; 2]) -> f64 {
            let mut max_u = v_old[0].clone();
            let mut max_v = v_old[0].clone();
            max_u = max_u.abs();
            max_v = max_v.abs();

            let mut max_of_box = max_u.max(max_v);
            max_of_box *= 0.6;
            let h = 0.3 + 0.4 * thc(4., 2.);
            let d1 = sdEquilateralTriangle(
                [uv[0] - 0., uv[1] - (0.5)],
                1.0 - max_of_box,
                max_of_box.clone() * 0.68,
            ); // 第二个参数 常量0.65 位移
            let d1_x = glm::length(&glm::vec2(v[0], v[1]));
            let d1_x_len = -0.1 + 0.1 * d1_x; //-0.1 ，后端位移，带调试，出现弧度？

            let s1: f64 = if d1_x_len < d1 { 0.0 } else { 1.0 }; // glm::step(d1, tt1); //箭头大小

            let t1_for_d2 = [uv[0] - 0.0, uv[1] - h * 0.163];
            let t2_for_d2 = glm::length(&glm::vec2(v[0], v[1]));

            let d2 = sdBox(
                t1_for_d2,
                [
                    0.085 * t2_for_d2 * max_of_box + 0.085 * t2_for_d2 * max_of_box,
                    0.52 * max_of_box + 0.52 * t2_for_d2 * max_of_box, //0.42，0.2双值控制远端位移
                ],
            );
            // let s2 = step(d2, 0.);
            let s2 = if d2 > 0.0 { 0.0 } else { 1.0 };

            return s1.max(s2);
            // return s1;
        }

        fn sdVectorArrow(p: [f64; 2], v: [f64; 2]) -> f64 {
            // return arrow(p, v); //shape
            let g_p = glm::vec2(p[0], p[1]);
            let m = glm::length(&glm::vec2(v[0], v[1])); //长度
            let n = glm::vec2(v[0] / m, v[1] / m); //sdf
            let dot_for_pp = glm::vec2(n.y * 1.0, n.x * -1.0);
            let pp = [
                glm::dot(&g_p, &dot_for_pp),
                // glm::dot(&g_p, &n),
                glm::dot(&g_p, &n),
            ]; //方向判断，n控制长度
            return arrow(pp, [v[0] / m, v[1] / m], v); //shape
        }
    }
}