/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
 *
 * SPDX-License-Identifier: Apache-2.0 */

#include "stdcycles.h"

/* Magic */
color magic(point p, float scale, int n, float distortion)
{
  float dist = distortion;

  float a = mod(p.x * scale, M_2PI);
  float b = mod(p.y * scale, M_2PI);
  float c = mod(p.z * scale, M_2PI);

  float x = sin((a + b + c) * 5.0);
  float y = cos((-a + b - c) * 5.0);
  float z = -cos((-a - b + c) * 5.0);

  if (n > 0) {
    x *= dist;
    y *= dist;
    z *= dist;
    y = -cos(x - y + z);
    y *= dist;

    if (n > 1) {
      x = cos(x - y - z);
      x *= dist;

      if (n > 2) {
        z = sin(-x - y - z);
        z *= dist;

        if (n > 3) {
          x = -cos(-x + y - z);
          x *= dist;

          if (n > 4) {
            y = -sin(-x + y + z);
            y *= dist;

            if (n > 5) {
              y = -cos(-x + y + z);
              y *= dist;

              if (n > 6) {
                x = cos(x + y + z);
                x *= dist;

                if (n > 7) {
                  z = sin(x + y - z);
                  z *= dist;

                  if (n > 8) {
                    x = -cos(-x - y + z);
                    x *= dist;

                    if (n > 9) {
                      y = -sin(x - y + z);
                      y *= dist;
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }

  if (dist != 0.0) {
    dist *= 2.0;
    x /= dist;
    y /= dist;
    z /= dist;
  }

  return color(0.5 - x, 0.5 - y, 0.5 - z);
}

shader node_magic_texture(int use_mapping = 0,
                          matrix mapping = matrix(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
                          int depth = 2,
                          float Distortion = 5.0,
                          float Scale = 5.0,
                          point Vector = P,
                          output float Fac = 0.0,
                          output color Color = 0.0)
{
  point p = Vector;

  if (use_mapping)
    p = transform(mapping, p);

  Color = magic(p, Scale, depth, Distortion);
  Fac = (Color[0] + Color[1] + Color[2]) * (1.0 / 3.0);
}
