/* Copyright (C) Manuel Matusich
* Unauthorized copying of this file, via any medium is strictly prohibited
* Written by Manuel Matusich , Juli 2017
*/

using System.Collections.Generic;
using UnityEngine;

public static class SewerSystem {

  private static List < Pipe > pipes = new List < Pipe > ();
  private static List < Shaft > shafts = new List < Shaft > ();
  private static int numberOfPipeNodes = 0;
  private static int minNumberOfNodesPerPipe = int.MaxValue;
  public static int maxSimulationTimeStep = 7200;
  public static int simulationSteps = 721;

  public static void setActive(bool active) {
    foreach(Pipe pipe in pipes) {
      pipe.setActive(active);
    }

    foreach(Shaft shaft in shafts) {
      shaft.setActive(active);
    }
  }

  public static int getNumberOfPipeNodes() {
    if (numberOfPipeNodes == 0) {
      foreach(Pipe pipe in pipes) {
        numberOfPipeNodes += pipe.getNodeCount();

        if (pipe.getNodeCount() < minNumberOfNodesPerPipe) minNumberOfNodesPerPipe = pipe.getNodeCount();
      }

    }
    return numberOfPipeNodes;
  }

  public static void addShaft(Shaft shaft) {
    shafts.Add(shaft);
  }

  public static void addPipe(Pipe pipe) {
    pipes.Add(pipe);
  }

  public static List < Pipe > getPipes() {
    return pipes;
  }

  public static List < Shaft > getShafts() {
    return shafts;
  }

  public static Shaft getShaftbyIndex(int index) {
    return shafts[index];
  }

  public static Pipe getPipebyIndex(int index) {
    return pipes[index];
  }

  public static Pipe getPipeByID(int id) {
    foreach(Pipe pipe in pipes) {
      if (pipe.id == id) {
        return pipe;
      }
    }

    return null;
  }

  //sort pipes by height, to ensure the are drawn in this order by geometryshader
  private static void sortPipesByHeight() {
    pipes.Sort(delegate(Pipe a, Pipe b) {
      return (b.position.y).CompareTo(a.position.y);
    });
  }

  public static void intializeAfterParsing() {
    foreach(Pipe pipe in pipes) {
      pipe.initializAfterParsing();
    }

    sortPipesByHeight();

    foreach(Shaft shaft in shafts) {
      shaft.createShaft();
      shaft.createWater();
    }

  }

}

/* Copyright (C) Manuel Matusich
* Unauthorized copying of this file, via any medium is strictly prohibited
* Written by Manuel Matusich , Juli 2017
*/

using UnityEngine;
using System.Collections.Generic;
using System.Collections;

public class Pipe {
  private GameObject pipeGameObject;

  private List < Vector3 > pipeNodes;
  private Vector2[] UVs = null;

  private Shaft startShaft;
  private Shaft endShaft;

  public Vector3 position = Vector3.one;
  public float radius = 0;
  public int id;

  public float[] depthTimeline;
  public Color[] depthColorTimeline;
  public Color[] dischargeColorTimeline;

  public Pipe(int id, GameObject parent) {
    this.id = id;
    pipeNodes = new List < Vector3 > ();

    depthTimeline = new float[SewerSystem.simulationSteps];
    depthColorTimeline = new Color[SewerSystem.simulationSteps];
    dischargeColorTimeline = new Color[SewerSystem.simulationSteps];

    pipeGameObject = new GameObject();
    pipeGameObject.name = "Pipe ID: " + this.id;
    pipeGameObject.transform.SetParent(parent.transform);
    pipeGameObject.tag = "pipe";

  }

  public void setDepthForTimestep(float depth, int timestep) {
    depthTimeline[timestep] = depth;
  }

  public void setDepthColorForTimestep(Color color, int timestep) {
    depthColorTimeline[timestep] = color;
  }

  public void setDischargeColorForTimestep(Color color, int timestep) {
    dischargeColorTimeline[timestep] = color;
  }

  public void broadcastRadiusToShafts() {
    startShaft.increaseWidth(radius);
    endShaft.increaseWidth(radius);
  }

  private void initiateUVs() {
    if (UVs == null) UVs = new Vector2[pipeNodes.Count];
  }

  public void setUV(Vector2 uv, int nodeID) {
    initiateUVs();
    this.UVs[nodeID] = uv;
  }

  public Vector2[] getUVs() {
    return this.UVs;
  }

  public void setActive(bool active) {
    pipeGameObject.SetActive(active);
  }

  public void initializAfterParsing() {
    swapShaftsIfNeeded();
    position.x = (pipeNodes[0].x + pipeNodes[pipeNodes.Count - 1].x) / 2;
    position.y = (pipeNodes[0].y + pipeNodes[pipeNodes.Count - 1].y) / 2;
    position.z = (pipeNodes[0].z + pipeNodes[pipeNodes.Count - 1].z) / 2;
  }

  public void setStartShaft(Shaft shaft) {
    startShaft = shaft;
  }

  public void setEndShaft(Shaft shaft) {
    endShaft = shaft;
  }

  public float getHeightOfPipeEndToConnectedShaft(Shaft shaft) {
    if (shaft.getID() == startShaft.getID()) {
      return pipeNodes[0].y;
    } else if (shaft.getID() == endShaft.getID()) {
      return pipeNodes[pipeNodes.Count - 1].y;
    } else {
      Debug.Log("shaft error: given shaft is neither endshaft or startshaft");
      return - 1000000;
    }
  }

  //Make shure that start shaft is closer to index 0 of pipeNodes
  public void swapShaftsIfNeeded() {
    float distStart = Vector3.Distance(startShaft.getPos(), pipeNodes[0]);
    float distEnd = Vector3.Distance(endShaft.getPos(), pipeNodes[0]);
    if (distStart > distEnd) {
      Shaft temp = startShaft;
      startShaft = endShaft;
      endShaft = temp;
    }
  }

  public List < Vector3 > getNodes() {
    return pipeNodes;
  }

  public void addNode(Vector3 node) {
    pipeNodes.Add(node);
  }

  public void addAllNodes(List < Vector3 > nodes) {
    pipeNodes = nodes;
  }

  public int getNodeCount() {
    return pipeNodes.Count;
  }

}

/* Copyright (C) Manuel Matusich
* Unauthorized copying of this file, via any medium is strictly prohibited
* Written by Manuel Matusich , Juli 2017
*/

using UnityEngine;
using System.Collections.Generic;

public class Shaft {

  static private float wallThickness = 0.1f;
  static private float waterOffset = 0.01f;

  private GameObject shaft;
  private GameObject water;
  private GameObject cylinder;
  private GameObject cylinderInside;
  private GameObject manhole;
  private GameObject pipeCancel;
  private Material shaftMaterial;
  private Material manholeMaterial;
  private Material waterMaterial;
  private Material shaftInsideMaterial;
  private Material pipeCancelMaterial;

  private Vector3 upperPoint;
  private Vector3 lowerPoint;

  private float[] depthTimeline;
  private Color[] depthColorTimeline;
  private Color[] dischargeColorTimeline;

  private List < Pipe > connectedPipes;
  private int id;
  private float width;

  private float waterFillPercent;

  public Shaft(int id, GameObject parent, Material shaftMaterial, Material shaftInsideMaterial, Material manholeMaterial, Material waterMaterial, Material pipeCancelMaterial) {
    this.id = id;
    depthTimeline = new float[SewerSystem.simulationSteps];
    depthColorTimeline = new Color[SewerSystem.simulationSteps];
    dischargeColorTimeline = new Color[SewerSystem.simulationSteps];

    shaft = new GameObject();
    shaft.transform.SetParent(parent.transform);
    shaft.name = "Shaft ID: " + this.id;

    this.shaftMaterial = shaftMaterial;
    this.manholeMaterial = manholeMaterial;
    this.waterMaterial = waterMaterial;
    this.shaftInsideMaterial = shaftInsideMaterial;
    this.pipeCancelMaterial = pipeCancelMaterial;

    this.width = 0.7f;

    upperPoint = new Vector3();
    lowerPoint = new Vector3();
    connectedPipes = new List < Pipe > ();

    cylinder = GameObject.CreatePrimitive(PrimitiveType.Cylinder);
    cylinder.transform.SetParent(shaft.transform);
    cylinder.name = "Shaft Cylinder";
    cylinder.tag = "shaft";

    pipeCancel = GameObject.CreatePrimitive(PrimitiveType.Cylinder);
    pipeCancel.transform.SetParent(shaft.transform);
    pipeCancel.name = "Shaft Pipe Cancel";
    pipeCancel.tag = "shaft";

    cylinderInside = GameObject.CreatePrimitive(PrimitiveType.Cylinder);
    cylinderInside.transform.SetParent(shaft.transform);
    cylinderInside.name = "Shaft Cylinder Inside";
    cylinderInside.tag = "shaft";

    water = GameObject.CreatePrimitive(PrimitiveType.Cylinder);
    water.transform.SetParent(shaft.transform);
    water.name = "Water";
    waterFillPercent = Random.Range(0.0f, 1.0f);

    manhole = GameObject.CreatePrimitive(PrimitiveType.Cylinder);
    manhole.transform.SetParent(cylinder.transform);
    manhole.name = "Manhole";
  }

  public int getID() {
    return this.id;
  }

  public void setDepthForTimestep(float depth, int timestep) {
    depthTimeline[timestep] = depth;
  }

  public void setDepthColorForTimestep(Color color, int timestep) {
    depthColorTimeline[timestep] = color;
  }

  public void setDischargeColorForTimestep(Color color, int timestep) {
    dischargeColorTimeline[timestep] = color;
  }

  public void increaseWidth(float radius) {
    if (radius * 2.5f > width) width = radius * 2.5f;
  }

  // called at the end of start when all is set up
  public void createShaft() {
    Vector3 offset = lowerPoint - upperPoint;
    Vector3 scale = new Vector3(width, offset.magnitude / 2.0f, width);
    cylinder.transform.position = upperPoint + new Vector3(offset.x / 2.0f, offset.y / 2.0f, offset.z / 2.0f);
    cylinder.GetComponent < MeshRenderer > ().sharedMaterial = shaftMaterial;
    cylinder.transform.up = offset;
    cylinder.transform.localScale = scale;
    cylinder.isStatic = true;

    pipeCancel.transform.position = upperPoint + new Vector3(offset.x / 2.0f, offset.y / 2.0f, offset.z / 2.0f);
    pipeCancel.GetComponent < MeshRenderer > ().sharedMaterial = pipeCancelMaterial;
    pipeCancel.transform.up = offset;
    pipeCancel.transform.localScale = scale;
    pipeCancel.isStatic = true;

    manhole.transform.position = upperPoint + new Vector3(0, 0.05f, 0);
    manhole.GetComponent < MeshRenderer > ().sharedMaterial = manholeMaterial;
    manhole.transform.localScale = new Vector3(0.9f, 0.02f, 0.9f);
    manhole.isStatic = true;

    float widthModifier = 1 - wallThickness;
    Vector3 upperPointInner = upperPoint + Vector3.down * waterOffset / 2;
    Vector3 lowerPointInner = lowerPoint + Vector3.up * wallThickness / 2;
    offset = lowerPointInner - upperPointInner;
    scale = new Vector3(width * widthModifier, offset.magnitude / 2.0f, width * widthModifier);
    cylinderInside.transform.position = upperPointInner + new Vector3(offset.x / 2.0f, offset.y / 2.0f, offset.z / 2.0f);
    cylinderInside.GetComponent < MeshRenderer > ().sharedMaterial = shaftInsideMaterial;
    cylinderInside.transform.up = offset;
    cylinderInside.transform.localScale = scale;
    cylinderInside.isStatic = true;
  }

  public void createWater() {
    Vector3 waterMax = upperPoint + Vector3.down * (wallThickness / 2 + waterOffset);
    Vector3 waterMin = lowerPoint + Vector3.up * (wallThickness / 2 + waterOffset);
    float widthModifier = 1 - wallThickness - waterOffset * 10;

    //float maxDist = Vector3.Distance(waterMin, waterMax);

    Vector3 offset = (waterMin - waterMax);
    Vector3 scale = new Vector3(width * widthModifier, offset.magnitude / 2.0f, width * widthModifier);
    water.transform.position = waterMax + new Vector3(offset.x / 2.0f, offset.y / 2.0f, offset.z / 2.0f);
    //GameObject cylinder = (GameObject)UnityEngine.Object.Instantiate(cylinderPrefab, position, Quaternion.identity);
    water.GetComponent < MeshRenderer > ().sharedMaterial = waterMaterial;
    water.transform.up = offset;
    water.transform.localScale = scale;
  }

  public void setTimeStep(int timestep) {
    float waterHeight = depthTimeline[timestep];
    float minHeight = 100000000.0f;

    //move this to initialzation
    foreach(Pipe pipe in connectedPipes) {
      float height = pipe.getHeightOfPipeEndToConnectedShaft(this);
      if (height < minHeight) minHeight = height;
    }
    if (minHeight < lowerPoint.y) minHeight = lowerPoint.y;
    waterFillPercent = ((minHeight - lowerPoint.y) + waterHeight) / Vector3.Distance(upperPoint, lowerPoint);
    if (waterFillPercent > 1) waterFillPercent = 1.0f;
    waterMaterial.SetColor("_Color", depthColorTimeline[timestep]);

    rescaleWater();
  }

  public void rescaleWater() {
    Vector3 waterMax = upperPoint + Vector3.down * (wallThickness / 2 + waterOffset);
    Vector3 waterMin = lowerPoint + Vector3.up * (wallThickness / 2 + waterOffset);
    float widthModifier = 1 - wallThickness - waterOffset * 10;

    float maxDist = Vector3.Distance(waterMin, waterMax);
    Vector3 waterLevel = waterMin + Vector3.up * maxDist * waterFillPercent;

    Vector3 offset = (waterMin - waterLevel);
    Vector3 scale = new Vector3(width * widthModifier, offset.magnitude / 2.0f, width * widthModifier);
    water.transform.position = waterLevel + new Vector3(offset.x / 2.0f, offset.y / 2.0f, offset.z / 2.0f);
    water.transform.up = offset;
    water.transform.localScale = scale;
  }

  public void setActive(bool active) {
    shaft.SetActive(active);
  }

  public void addConnectedPipe(Pipe pipe) {
    if (!connectedPipes.Contains(pipe)) connectedPipes.Add(pipe);
  }

  public void setLower(Vector3 lower) {
    lowerPoint = lower + Vector3.down;
  }

  //setUpper must be called after setLower for each shaft respectively
  public void setUpper(Vector3 upper) {
    if (upper.y < lowerPoint.y && lowerPoint.y != 0) {
      upperPoint = lowerPoint;
      lowerPoint = upper;
    } else {
      upperPoint = upper;
    }
  }

  public Vector3 getPos() {
    Vector3 position = new Vector3(0f, 0f, 0f);
    position.x = (lowerPoint.x + upperPoint.x) / 2;
    position.y = (lowerPoint.y + upperPoint.y) / 2;
    position.z = (lowerPoint.z + upperPoint.z) / 2;
    return position;
  }

}

/* Copyright (C) Manuel Matusich
* Unauthorized copying of this file, via any medium is strictly prohibited
* Written by Manuel Matusich , Juli 2017
*/

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using System;

public static class DistanceTransform {

  public static Texture2D copyTextureWhite(Texture2D tex_in) {
    Texture2D tex_out = new Texture2D(tex_in.width, tex_in.height);
    Color32[] setColorArray = tex_in.GetPixels32();
    Color32 white = new Color32(255, 255, 255, 255);

    for (int i = 0; i < setColorArray.Length; i++) {
      Color col = setColorArray[i];
      if (col.r > 0.5) setColorArray[i] = white;
      else setColorArray[i] = white;
    }

    tex_out.SetPixels32(setColorArray);
    tex_out.Apply();
    return tex_out;
  }

  public static void DrawPipes(this Texture2D texture) {
    int counter = 0;

    float height = texture.height;
    float width = texture.height;

    foreach(Pipe pipe in SewerSystem.getPipes()) {
      Vector2[] pipeUvNodes = pipe.getUVs();
      if (pipeUvNodes != null) {
        counter++;
        for (int j = 1; j < pipeUvNodes.Length; j++) {
          Vector2 v = new Vector2(pipeUvNodes[j - 1].x * height, pipeUvNodes[j - 1].y * width);
          Vector2 w = new Vector2(pipeUvNodes[j].x * height, pipeUvNodes[j].y * width);
          if (isValidV2(v) && isValidV2(w)) DrawLine(texture, v, w, Color.black);
        }
      }
    }
    Debug.Log("Pipes Drawn: " + counter);
    Debug.Log("Pipes Count: " + SewerSystem.getPipes().Count);
    texture.Apply();
  }

  private static bool isValidV2(Vector2 v) {
    if (v.x == 0 || v.y == 0) return false;
    else return true;
  }

  //Source: http://answers.unity3d.com/questions/244417/create-line-on-a-texture.html
  private static Texture2D DrawLine(this Texture2D tex, Vector2 p1, Vector2 p2, Color col) {

    Vector2 t = p1;
    float frac = 1 / Mathf.Sqrt(Mathf.Pow(p2.x - p1.x, 2) + Mathf.Pow(p2.y - p1.y, 2));
    float ctr = 0;

    while ((int) t.x != (int) p2.x || (int) t.y != (int) p2.y) {
      t = Vector2.Lerp(p1, p2, ctr);
      ctr += frac;
      tex.SetPixel((int) t.x, (int) t.y, col);
    }
    //tex.Apply();
    return tex;
  }

  public static Texture2D transform(Texture2D texture) {
    Texture2D tex = copyTextureWhite(texture);

    DrawPipes(tex);

    L1_2PASS(tex);

    rotate90CCW(tex);
    L1_2PASS(tex);

    rotate90CCW(tex);
    rotate90CCW(tex);
    rotate90CCW(tex);

    return tex;

  }

  public static void rotate90CCW(Texture2D texture) {
    Color32[] ret = new Color32[texture.width * texture.height];
    Color32[] matrix = texture.GetPixels32();
    int n = texture.width;

    for (int i = 0; i < n; ++i) {
      for (int j = 0; j < n; ++j) {
        ret[i * n + j] = matrix[(n - j - 1) * n + i];
      }
    }

    texture.SetPixels32(ret);
    texture.Apply();
  }

  private static Color isLastColorBrighter(Color32 thisColor, Color32 lastColor) {
    float toAdd = (10.0f / 255.0f);
    lastColor = (Color32)((Color) lastColor + new Color(toAdd, toAdd, toAdd, 0)); // add 1
    if (thisColor.r < lastColor.r) return thisColor; // r = g = b
    else return lastColor;
  }

  public static void L1_2PASS(Texture2D tex_in) {
    int height = tex_in.height;
    int width = tex_in.height;
    List < Color[] > rows = new List < Color[] > ();

    for (int y = 0; y < height; y++) {
      Color[] cols = tex_in.GetPixels(0, y, width, 1);
      rows.Add(cols);
    }

    List < Color > colorArray = new List < Color > ();
    foreach(Color[] cols in rows) {

      // 1. Pass (forward)
      for (int i = 1; i < cols.Length; i++) {
        cols[i] = isLastColorBrighter(cols[i], cols[i - 1]);
      }

      // 2. Pass (backwards)
      for (int i = cols.Length - 2; i >= 0; i--) {
        cols[i] = isLastColorBrighter(cols[i], cols[i + 1]);
      }

      //Compose
      foreach(Color col in cols) {
        colorArray.Add(col);
      }
    }

    tex_in.SetPixels(colorArray.ToArray());
    tex_in.Apply();
  }

}

/* Copyright (C) Manuel Matusich
* Unauthorized copying of this file, via any medium is strictly prohibited
* Written by Manuel Matusich , Juli 2017
*/

using UnityEngine;
using System.Collections;
using System.Collections.Generic;

public class MyPipeRenderer: MonoBehaviour {

  public Material cutSurfaceMaterial;
  public Material backFaceRepairMaterial;
  public Material proxyInsideMaterial;
  public Material pipeBillboardMaterial;
  public Material pipeShadowMaterial;
  public Material pipeWaterMaterial;

  private float someOtherRadius = 0.3f;
  private float wallThickness = 0.1f;

  private ComputeBuffer proxyTriangleBuffer;
  private ComputeBuffer proxyQuadsBuffer;
  private ComputeBuffer pipeQuadsBuffer;
  private ComputeBuffer pipeWaterLevelBuffer;
  private ComputeBuffer pipeWaterColorBuffer;

  private static bool drawProxy = true;
  private static bool drawStencilPrepare = false;
  private static bool drawBillboards = false;
  private static bool drawPipes = true;

  private int proxyTriangleBufferSize = 0;
  private int proxyQuadsBufferSize = 0;
  private int pipeQuadsBufferSize = 0;
  private int pipeWaterLevelBufferSize = 0;
  private int pipeWaterColorBufferSize = 0;

  private float[] pipeWaterLevel;
  private Color[] pipeWaterColor;

  struct proxyData {
    public Vector3 lastPos;
    public Vector3 pos;
    public Vector3 nextPos;
    public float radius;
    public int pipeID;
  };

  //40 = 4bytes times float3 times 3 plus 4bytes for int
  private int proxyDataByteSize = sizeof(float) * 10 + sizeof(int);

  struct pipeData {
    public Vector3 lastPos;
    public Vector3 pos;
    public Vector3 nextPos;
    public float radius;
    public int pipeID;
    public int id;
    public int pipeNodeCount;
    public int isCut;
  };

  //52 = 4bytes times float3 times 3 plus 4bytes per int times 4
  private int pipeDataByteSize = sizeof(float) * 10 + sizeof(int) * 4;

  // Use this for initialization
  void Start() {
    cutSurfaceMaterial.renderQueue = 2011;
    proxyInsideMaterial.renderQueue = 2011;
    pipeBillboardMaterial.renderQueue = 2011;
    pipeShadowMaterial.renderQueue = 2011;
    pipeWaterMaterial.renderQueue = 2011;
    backFaceRepairMaterial.renderQueue = 2011;

    List < Pipe > pipes = SewerSystem.getPipes();
    List < proxyData > proxyTriangleData = new List < proxyData > ();
    List < proxyData > proxyQuadsData = new List < proxyData > ();
    List < pipeData > pipeQuadsData = new List < pipeData > ();
    pipeWaterLevel = new float[pipes.Count];
    pipeWaterColor = new Color[pipes.Count];

    for (int p = 0; p < pipes.Count; p++) {
      Pipe pipe = pipes[p];
      List < Vector3 > pipeNodes = pipe.getNodes();

      pipeWaterLevel[p] = pipe.depthTimeline[0];
      pipeWaterColor[p] = pipe.depthColorTimeline[0];

      // data for view aligned billboards
      if (pipeNodes.Count >= 2) {

        //first node
        pipeQuadsData.Add(new pipeData() {
          lastPos = pipeNodes[0],
          pos = pipeNodes[0],
          nextPos = pipeNodes[1],
          radius = pipe.radius,
          pipeID = p,
          id = 0,
          pipeNodeCount = pipeNodes.Count,
          isCut = 0
        });

        //nodes in between
        for (int i = 1; i < pipeNodes.Count - 1; i++) {
          int cut = 0;
          if (pipeNodes.Count >= 4) cut = 1;
          pipeQuadsData.Add(new pipeData() {
            lastPos = pipeNodes[i - 1],
            pos = pipeNodes[i],
            nextPos = pipeNodes[i + 1],
            radius = pipe.radius,
            pipeID = p,
            id = i,
            pipeNodeCount = pipeNodes.Count,
            isCut = cut
          });
        }

        //last node
        pipeQuadsData.Add(new pipeData() {
          lastPos = pipeNodes[pipeNodes.Count - 2],
          pos = pipeNodes[pipeNodes.Count - 1],
          nextPos = pipeNodes[pipeNodes.Count - 1],
          radius = pipe.radius,
          pipeID = p,
          id = pipeNodes.Count - 1,
          pipeNodeCount = pipeNodes.Count,
          isCut = 0
        });
      }

      //ProxyGeometry
      if (pipeNodes.Count >= 4) {

        proxyTriangleData.Add(new proxyData() {
          lastPos = pipeNodes[0],
          pos = pipeNodes[1],
          nextPos = pipeNodes[2],
          radius = pipe.radius,
          pipeID = p
        });

        proxyTriangleData.Add(new proxyData() {
          lastPos = pipeNodes[pipeNodes.Count - 1],
          pos = pipeNodes[pipeNodes.Count - 2],
          nextPos = pipeNodes[pipeNodes.Count - 3],
          radius = pipe.radius,
          pipeID = p
        });

        for (int i = 1; i < pipeNodes.Count - 1; i++) {
          proxyQuadsData.Add(new proxyData() {
            lastPos = pipeNodes[i - 1],
            pos = pipeNodes[i],
            nextPos = pipeNodes[i + 1],
            radius = pipe.radius,
            pipeID = p
          });
        }

      }
    }

    proxyTriangleBufferSize = proxyTriangleData.Count;
    proxyQuadsBufferSize = proxyQuadsData.Count;
    pipeQuadsBufferSize = pipeQuadsData.Count;
    pipeWaterLevelBufferSize = pipeWaterLevel.Length;
    pipeWaterColorBufferSize = pipeWaterColor.Length;

    proxyTriangleBuffer = new ComputeBuffer(proxyTriangleBufferSize, proxyDataByteSize);
    proxyTriangleBuffer.SetData(proxyTriangleData.ToArray());

    proxyQuadsBuffer = new ComputeBuffer(proxyQuadsBufferSize, proxyDataByteSize);
    proxyQuadsBuffer.SetData(proxyQuadsData.ToArray());

    pipeQuadsBuffer = new ComputeBuffer(pipeQuadsBufferSize, pipeDataByteSize);
    pipeQuadsBuffer.SetData(pipeQuadsData.ToArray());

    pipeWaterLevelBuffer = new ComputeBuffer(pipeWaterLevelBufferSize, sizeof(float));
    pipeWaterLevelBuffer.SetData(pipeWaterLevel);

    pipeWaterColorBuffer = new ComputeBuffer(pipeWaterColorBufferSize, sizeof(float) * 4);
    pipeWaterColorBuffer.SetData(pipeWaterColor);

    Shader.SetGlobalFloat("wallThickness", wallThickness);

    cutSurfaceMaterial.SetBuffer("proxyTriangleBuffer", proxyTriangleBuffer);
    cutSurfaceMaterial.SetBuffer("proxyQuadsBuffer", proxyQuadsBuffer);

    proxyInsideMaterial.SetBuffer("proxyTriangleBuffer", proxyTriangleBuffer);
    proxyInsideMaterial.SetBuffer("proxyQuadsBuffer", proxyQuadsBuffer);

    pipeBillboardMaterial.SetBuffer("pipeQuadsBuffer", pipeQuadsBuffer);

    pipeShadowMaterial.SetBuffer("pipeQuadsBuffer", pipeQuadsBuffer);

    backFaceRepairMaterial.SetBuffer("proxyTriangleBuffer", proxyTriangleBuffer);
    backFaceRepairMaterial.SetBuffer("pipeQuadsBuffer", pipeQuadsBuffer);

    pipeWaterMaterial.SetBuffer("pipeQuadsBuffer", pipeQuadsBuffer);

  }

  void OnRenderObject() {
    //TODO: instanced mit 3 parameter 
    //BETTER: ONLY USE one of this call instead of doing it for each pipe respectively with more buffers

    //First two indices form a line, and then each new index 
    //connects a new vertex to the existing line strip.

    if (drawPipes) {
      //vertical triangles cut surfaces
      cutSurfaceMaterial.SetPass(0);
      Graphics.DrawProcedural(MeshTopology.Points, proxyTriangleBufferSize);

      //horizontal quadrilaterals cut surfaces
      cutSurfaceMaterial.SetPass(1);
      Graphics.DrawProcedural(MeshTopology.LineStrip, proxyQuadsBufferSize);

      //vertical triangles stencil prepare
      proxyInsideMaterial.SetPass(0);
      Graphics.DrawProcedural(MeshTopology.Points, proxyTriangleBufferSize);

      //horizontal quadrilaterals stencil prepare
      proxyInsideMaterial.SetPass(1);
      Graphics.DrawProcedural(MeshTopology.LineStrip, proxyQuadsBufferSize);

      //view-aligned quadrilaterals inside
      pipeBillboardMaterial.SetPass(0);
      Graphics.DrawProcedural(MeshTopology.LineStrip, pipeQuadsBufferSize);

      //view-aligned quadrilaterals outside prepare EXCLUDE
      pipeBillboardMaterial.SetPass(1);
      Graphics.DrawProcedural(MeshTopology.LineStrip, pipeQuadsBufferSize);

      //view-aligned quadrilaterals outside
      pipeBillboardMaterial.SetPass(2);
      Graphics.DrawProcedural(MeshTopology.LineStrip, pipeQuadsBufferSize);

      //vertical triangles stencil prepare backfaces
      backFaceRepairMaterial.SetPass(0);
      Graphics.DrawProcedural(MeshTopology.Points, proxyTriangleBufferSize);

      //view-aligned quadrilaterals outside at triangle backfaces
      backFaceRepairMaterial.SetPass(1);
      Graphics.DrawProcedural(MeshTopology.LineStrip, pipeQuadsBufferSize);

      //pipe shadow pass
      pipeShadowMaterial.SetPass(0);
      Graphics.DrawProcedural(MeshTopology.LineStrip, pipeQuadsBufferSize);

      //pipe water prepare
      pipeWaterMaterial.SetPass(0);
      Graphics.DrawProcedural(MeshTopology.LineStrip, pipeQuadsBufferSize);

      //pipe water surface
      pipeWaterMaterial.SetPass(1);
      Graphics.DrawProcedural(MeshTopology.LineStrip, pipeQuadsBufferSize);

      //pipe water body
      pipeWaterMaterial.SetPass(2);
      Graphics.DrawProcedural(MeshTopology.LineStrip, pipeQuadsBufferSize);
    }

  }

  void Update() {

    if (Input.GetKey(KeyCode.Q) && Input.GetKey(KeyCode.P)) {
      drawPipes = false;
    }

    if (Input.GetKey(KeyCode.Y) && Input.GetKey(KeyCode.P)) {
      drawPipes = true;
    }

    if (Input.GetKey(KeyCode.X) && Input.GetKey(KeyCode.P)) {
      drawProxy = !drawProxy;
    }

    if (Input.GetKey(KeyCode.X) && Input.GetKey(KeyCode.S)) {
      drawStencilPrepare = !drawStencilPrepare;
    }

    if (Input.GetKey(KeyCode.X) && Input.GetKey(KeyCode.B)) {
      drawBillboards = !drawBillboards;
    }

    if (Input.GetKey(KeyCode.R) && Input.GetKey(KeyCode.KeypadPlus)) {
      someOtherRadius += 0.01f;
    }

    if (Input.GetKey(KeyCode.R) && Input.GetKey(KeyCode.KeypadMinus)) {
      someOtherRadius -= 0.01f;
    }

    if (Input.GetKey(KeyCode.F) && Input.GetKey(KeyCode.KeypadPlus)) {
      wallThickness += 0.001f;
      if (wallThickness < 0) wallThickness = 0;
      if (wallThickness > 1) wallThickness = 1;

      Shader.SetGlobalFloat("wallThickness", wallThickness);
    }

    if (Input.GetKey(KeyCode.F) && Input.GetKey(KeyCode.KeypadMinus)) {
      wallThickness -= 0.001f;
      if (wallThickness < 0.001) wallThickness = 0.001f;
      if (wallThickness > 0.3f) wallThickness = 0.3f;

      Shader.SetGlobalFloat("wallThickness", wallThickness);
    }

  }

  void FixedUpdate() {
    for (int p = 0; p < SewerSystem.getPipes().Count; p++) {
      pipeWaterLevel[p] = SewerSystem.getPipebyIndex(p).depthTimeline[SewerManager.currenTimestep];
      pipeWaterColor[p] = SewerSystem.getPipebyIndex(p).depthColorTimeline[SewerManager.currenTimestep];
    }
    pipeWaterColorBuffer.SetData(pipeWaterColor);
    pipeWaterMaterial.SetBuffer("pipeWaterColorBuffer", pipeWaterColorBuffer);
    pipeWaterLevelBuffer.SetData(pipeWaterLevel);
    pipeWaterMaterial.SetBuffer("pipeWaterLevelBuffer", pipeWaterLevelBuffer);
  }

  void OnDestroy() {
    if (proxyTriangleBuffer != null) proxyTriangleBuffer.Release();
    proxyTriangleBuffer = null;

    if (proxyQuadsBuffer != null) proxyQuadsBuffer.Release();
    proxyQuadsBuffer = null;

    if (pipeQuadsBuffer != null) pipeQuadsBuffer.Release();
    pipeQuadsBuffer = null;

    if (pipeWaterLevelBuffer != null) pipeWaterLevelBuffer.Release();
    pipeWaterLevelBuffer = null;

    if (pipeWaterColorBuffer != null) pipeWaterColorBuffer.Release();
    pipeWaterColorBuffer = null;

  }

}

/* Copyright (C) Manuel Matusich
* Unauthorized copying of this file, via any medium is strictly prohibited
* Written by Manuel Matusich , Juli 2017
*/

Shader "Custom/PipeCutsurface" {

  Properties {
    _CutColor("Cut Surface Diffuse Color", Color) = (1, 1, 1, 1)
    _SpecColor("Specular Color", Color) = (1, 1, 1, 1)
    _Shininess("Shininess", Float) = 10
  }

  SubShader {

    /* vertical triangles cut surfaces
    */
    Pass {
      Tags {
        "LightMode" = "ForwardBase"
      }
      Name "PipeCut"

      Stencil {
        Ref 6
        Comp Always
        Pass replace
      }

      Cull Back
      //ZTest Always
      //ZWrite off
      //ColorMask 0

      CGPROGRAM#pragma target 5.0

      #pragma vertex vert#pragma geometry geom#pragma fragment frag

      //#pragma multi_compile_fog

      #include "UnityCG.cginc"

      float4 _CutColor;
      float wallThickness;

      // color of light source (from "Lighting.cginc")
      uniform float4 _LightColor0;

      uniform float4 _SpecColor;
      uniform float _Shininess;

      struct proxyData {
        float3 lastPos;
        float3 pos;
        float3 nextPos;
        float radius;
        uint pipeID;
      };

      //buffer containing the points of the line we want to draw.
      StructuredBuffer < proxyData > proxyTriangleBuffer;

      struct input {
        float4 pos: POSITION0;
        float4 nextPos: POSITION1;
        float4 lastPos: POSITION2;
        float radius: BLENDWEIGHT;
      };

      //PREPARE DATA FOR GEOMETRY SHADER
      input vert(uint id: SV_VertexID) {
        input o;

        o.pos = float4(proxyTriangleBuffer[id].pos, 1.0f);
        o.lastPos = float4(proxyTriangleBuffer[id].lastPos, 1.0f);
        o.nextPos = float4(proxyTriangleBuffer[id].nextPos, 1.0f);
        o.radius = proxyTriangleBuffer[id].radius;

        return o;
      }

      // SEMANTICS DONT SUGGEST THIS PARAMETERS ?
      struct vertexOutput {
        float4 pos: SV_POSITION;
        float4 posWorld: POSITION1;
        float2 uv: TEXCOORD0;
        float3 quadNormal: NORMAL;
      };

      float3 invert(float3 vec) {
        return vec * ( - 1.0f);
      }

      //GEOMETRY SHADER
      [maxvertexcount(3)]
      void geom(point input p[1], inout TriangleStream < vertexOutput > OutputStream) {
        float radius = p[0].radius;
        float halfDiagonal = sqrt(pow(radius, 2) + pow(radius, 2));

        vertexOutput vOut;

        float4 v[4];
        float3 lastTangent = normalize(p[0].pos.xyz - p[0].lastPos.xyz);
        float3 tangent = normalize(p[0].nextPos.xyz - p[0].pos.xyz);

        float3 bisectTangent = normalize(lastTangent + tangent);

        float3 toSide = normalize(cross(bisectTangent, float3(0, 1, 0)));
        float3 up = normalize(cross(toSide, bisectTangent));
        float3 left = normalize(cross(bisectTangent, up));
        float3 right = invert(left);

        v[0] = p[0].pos + float4(up.xyz, 0) * halfDiagonal;
        v[1] = p[0].pos + float4(left.xyz, 0) * halfDiagonal;
        v[2] = p[0].pos + float4(right.xyz, 0) * halfDiagonal;

        vOut.quadNormal = tangent;

        vOut.pos = mul(UNITY_MATRIX_VP, v[0]);
        vOut.posWorld = v[0];
        vOut.uv = float2(0.0f, 0.0f);
        OutputStream.Append(vOut);

        vOut.pos = mul(UNITY_MATRIX_VP, v[1]);
        vOut.posWorld = v[1];
        vOut.uv = float2(0.0f, 1.0f);
        OutputStream.Append(vOut);

        vOut.pos = mul(UNITY_MATRIX_VP, v[2]);
        vOut.posWorld = v[2];
        vOut.uv = float2(1.0f, 0.0f);
        OutputStream.Append(vOut);

      }

      struct fragOutput {
        float4 color: SV_TARGET;
      };

      fragOutput frag(vertexOutput i) {
        fragOutput o;

        // (0.5f, 0.5f) = center
        float distanceToCenter = sqrt(pow((0.5f - i.uv.x), 2) + pow((0.5f - i.uv.y), 2));

        if (distanceToCenter > 0.5f) {
          discard;
        }
        else if (distanceToCenter < (0.5f - wallThickness)) {
          o.color = float4(0, 0, 0, 1);
          discard;
        }

        else {
          //LIGHT SHADING
          float3 normalDirection = normalize(i.quadNormal);
          float3 viewDirection = normalize(
          _WorldSpaceCameraPos - i.posWorld.xyz);

          // cull is off, so invert normal if camera is on the other side
          if (dot(normalDirection, viewDirection) < 0.0) {
            normalDirection *= -1;
          }

          float3 lightDirection;
          float attenuation;

          if (0.0 == _WorldSpaceLightPos0.w) // directional light?
          {
            attenuation = 1.0; // no attenuation
            lightDirection = normalize(_WorldSpaceLightPos0.xyz);
          }
          else // point or spot light
          {
            float3 vertexToLightSource = _WorldSpaceLightPos0.xyz - i.posWorld.xyz;
            float distance = length(vertexToLightSource);
            attenuation = 1.0 / distance; // linear attenuation 
            lightDirection = normalize(vertexToLightSource);
          }

          float3 ambientLighting = UNITY_LIGHTMODEL_AMBIENT.rgb * _CutColor.rgb;

          float3 diffuseReflection = attenuation * _LightColor0.rgb * _CutColor.rgb * max(0.0f, dot(normalDirection, lightDirection));

          float3 specularReflection;
          if (dot(normalDirection, lightDirection) < 0.0)
          // light source on the wrong side?
          {
            specularReflection = float3(0.0, 0.0, 0.0);
            // no specular reflection
          }
          else // light source on the right side
          {
            specularReflection = attenuation * _LightColor0.rgb * _SpecColor.rgb * pow(max(0.0, dot(
            reflect( - lightDirection, normalDirection), viewDirection)), _Shininess);
          }

          o.color = float4(diffuseReflection + ambientLighting + specularReflection, 1.0);
        }

        //discard;
        return o;

      }

      ENDCG
    }

    /* horizontal quadrilaterals cut surfaces
    */
    Pass {

      Name "PipeBillboards"
      Tags {
        "LightMode" = "ForwardBase"
      }
      Stencil {
        Ref 6
        Comp Always
        Pass replace
      }

      //LOD 100
      //Blend SrcAlpha OneMinusSrcAlpha

      Cull Front
      //ZTest Always
      //ZWrite Off

      //ColorMask 0

      CGPROGRAM#pragma target 5.0#pragma vertex vert#pragma geometry geom#pragma fragment frag

      //#pragma multi_compile_fog

      #include "UnityCG.cginc"

      float4 _CutColor;
      float wallThickness;
      int nodeCount;

      // color of light source (from "Lighting.cginc")
      uniform float4 _LightColor0;

      uniform float4 _SpecColor;
      uniform float _Shininess;

      struct proxyData {
        float3 lastPos;
        float3 pos;
        float3 nextPos;
        float radius;
        uint pipeID;
      };

      //buffer containing the points of the line we want to draw.
      StructuredBuffer < proxyData > proxyQuadsBuffer;

      struct input {
        float4 pos: POSITION0;
        float4 nextPos: POSITION1;
        float4 lastPos: POSITION2;
        float radius: BLENDWEIGHT;
        uint pipeID: BLENDINDICES;
      };

      //PREPARE DATA FOR GEOMETRY SHADER
      input vert(uint id: SV_VertexID) {
        input o;

        o.pos = float4(proxyQuadsBuffer[id].pos, 1.0f);
        o.lastPos = float4(proxyQuadsBuffer[id].lastPos, 1.0f);
        o.nextPos = float4(proxyQuadsBuffer[id].nextPos, 1.0f);
        o.radius = proxyQuadsBuffer[id].radius;
        o.pipeID = proxyQuadsBuffer[id].pipeID;

        return o;
      }

      // SEMANTICS DONT SUGGEST THIS PARAMETERS ?
      struct vertexOutput {
        float4 pos: SV_POSITION;
        float4 posWorld: POSITION1;
        float2 uv: TEXCOORD0;
        float3 quadNormal: NORMAL;
      };

      float3 invert(float3 vec) {
        return vec * ( - 1.0f);
      }

      //GEOMETRY SHADER
      [maxvertexcount(4)]
      void geom(line input p[2], inout TriangleStream < vertexOutput > OutputStream) {

        // p[0].lastPos -> previous pos to p[0]
        // p[0] -> current pos
        // p[1] -> next pos
        // p[1].nextPos -> after next to p[0]

        // prevent to connect distinct pipes
        if (p[0].pipeID == p[1].pipeID) {

          float radius = p[0].radius;
          vertexOutput vOut;
          float4 v[4];
          float3 posToCamera = normalize(_WorldSpaceCameraPos - p[0].pos.xyz);
          float3 nextPosToCamera = normalize(_WorldSpaceCameraPos - p[1].pos.xyz);

          float3 lastTangent = normalize(p[0].pos.xyz - p[0].lastPos.xyz);
          float3 tangent = normalize(p[1].pos.xyz - p[0].pos.xyz);
          float3 nextTangent = normalize(p[1].nextPos.xyz - p[1].pos.xyz);

          float3 bisectLast = normalize(lastTangent + tangent);
          float3 bisectNext = normalize(nextTangent + tangent);

          float3 upvec = float3(0, 1, 0);
          float3 side = normalize(cross(tangent, upvec));
          float3 upWards = normalize(cross(tangent, side));

          float3 upLast = normalize(cross(upWards, bisectLast));
          float3 downLast = invert(upLast);

          v[0] = p[0].pos + float4(upLast.xyz, 0) * radius;
          v[1] = p[0].pos + float4(downLast.xyz, 0) * radius;

          float3 upNext = normalize(cross(upWards, bisectNext));
          float3 downNext = invert(upNext);

          v[2] = p[1].pos + float4(upNext.xyz, 0) * radius;
          v[3] = p[1].pos + float4(downNext.xyz, 0) * radius;

          float3 bisectUp = normalize(upLast + upNext);
          vOut.quadNormal = normalize(cross(bisectUp, tangent));

          vOut.pos = mul(UNITY_MATRIX_VP, v[0]);
          vOut.posWorld = v[0];
          vOut.uv = float2(0.0f, 0.0f);
          OutputStream.Append(vOut);

          vOut.pos = mul(UNITY_MATRIX_VP, v[1]);
          vOut.posWorld = v[1];
          vOut.uv = float2(0.0f, 1.0f);
          OutputStream.Append(vOut);

          vOut.pos = mul(UNITY_MATRIX_VP, v[2]);
          vOut.posWorld = v[2];
          vOut.uv = float2(1.0f, 0.0f);
          OutputStream.Append(vOut);

          vOut.pos = mul(UNITY_MATRIX_VP, v[3]);
          vOut.posWorld = v[3];
          vOut.uv = float2(1.0f, 1.0f);
          OutputStream.Append(vOut);
        }

      }

      struct fragOutput {
        float4 color: SV_TARGET;
      };

      fragOutput frag(vertexOutput i) {
        fragOutput o;
        //o.color = float4(0, 0, 0, 1);
        if (i.uv.y < (1 - wallThickness) && i.uv.y > wallThickness) {
          discard;
        }
        else {
          //LIGHT SHADING
          float3 normalDirection = normalize(i.quadNormal);
          float3 viewDirection = normalize(
          _WorldSpaceCameraPos - i.posWorld.xyz);

          float3 lightDirection;
          float attenuation;

          if (0.0 == _WorldSpaceLightPos0.w) // directional light?
          {
            attenuation = 1.0; // no attenuation
            lightDirection = normalize(_WorldSpaceLightPos0.xyz);
          }
          else // point or spot light
          {
            float3 vertexToLightSource = _WorldSpaceLightPos0.xyz - i.posWorld.xyz;
            float distance = length(vertexToLightSource);
            attenuation = 1.0 / distance; // linear attenuation 
            lightDirection = normalize(vertexToLightSource);
          }

          float3 ambientLighting = UNITY_LIGHTMODEL_AMBIENT.rgb * _CutColor.rgb;

          float3 diffuseReflection = attenuation * _LightColor0.rgb * _CutColor.rgb * max(0.0f, dot(normalDirection, lightDirection));

          float3 specularReflection;
          if (dot(normalDirection, lightDirection) < 0.0)
          // light source on the wrong side?
          {
            specularReflection = float3(0.0, 0.0, 0.0);
            // no specular reflection
          }
          else // light source on the right side
          {
            specularReflection = attenuation * _LightColor0.rgb * _SpecColor.rgb * pow(max(0.0, dot(
            reflect( - lightDirection, normalDirection), viewDirection)), _Shininess);
          }

          o.color = float4(diffuseReflection + ambientLighting + specularReflection, 1.0);
        }

        return o;

      }

      ENDCG
    }

  }
  Fallback Off
}

/* Copyright (C) Manuel Matusich
* Unauthorized copying of this file, via any medium is strictly prohibited
* Written by Manuel Matusich , Juli 2017
*/

Shader "Custom/PipeProxyInside" {

  Properties {
    _InsideColor("Inside Diffuse Color", Color) = (1, 1, 1, 1)
  }

  SubShader {

    /* vertical triangles stencil prepare
    */
    Pass {

      Stencil {
        Ref 5
        Comp Always
        Pass replace
      }

      Cull Back
      //ZTest Always
      //ZWrite off
      //ColorMask 0

      CGPROGRAM#pragma target 5.0

      #pragma vertex vert#pragma geometry geom#pragma fragment frag

      //#pragma multi_compile_fog

      #include "UnityCG.cginc"

      float4 _InsideColor;
      float wallThickness;

      // color of light source (from "Lighting.cginc")
      uniform float4 _LightColor0;

      struct proxyData {
        float3 lastPos;
        float3 pos;
        float3 nextPos;
        float radius;
        uint pipeID;
      };

      //buffer containing the points of the line we want to draw.
      StructuredBuffer < proxyData > proxyTriangleBuffer;

      struct input {
        float4 pos: POSITION0;
        float4 nextPos: POSITION1;
        float4 lastPos: POSITION2;
        float radius: BLENDWEIGHT;
      };

      //PREPARE DATA FOR GEOMETRY SHADER
      input vert(uint id: SV_VertexID) {
        input o;

        o.pos = float4(proxyTriangleBuffer[id].pos, 1.0f);
        o.lastPos = float4(proxyTriangleBuffer[id].lastPos, 1.0f);
        o.nextPos = float4(proxyTriangleBuffer[id].nextPos, 1.0f);
        o.radius = proxyTriangleBuffer[id].radius;

        return o;
      }

      // SEMANTICS DONT SUGGEST THIS PARAMETERS ?
      struct vertexOutput {
        float4 pos: SV_POSITION;
        float4 posWorld: POSITION1;
        float2 uv: TEXCOORD0;
      };

      float3 invert(float3 vec) {
        return vec * ( - 1.0f);
      }

      //GEOMETRY SHADER
      [maxvertexcount(3)]
      void geom(point input p[1], inout TriangleStream < vertexOutput > OutputStream) {
        float radius = p[0].radius;
        float halfDiagonal = sqrt(pow(radius, 2) + pow(radius, 2));

        vertexOutput vOut;
        float4 v[4];
        float3 lastTangent = normalize(p[0].pos.xyz - p[0].lastPos.xyz);
        float3 tangent = normalize(p[0].nextPos.xyz - p[0].pos.xyz);

        float3 bisectTangent = normalize(lastTangent + tangent);

        float3 toSide = normalize(cross(bisectTangent, float3(0, 1, 0)));
        float3 up = normalize(cross(toSide, bisectTangent));
        float3 left = normalize(cross(bisectTangent, up));
        float3 right = invert(left);

        v[0] = p[0].pos + float4(up.xyz, 0) * halfDiagonal;
        v[1] = p[0].pos + float4(left.xyz, 0) * halfDiagonal;
        v[2] = p[0].pos + float4(right.xyz, 0) * halfDiagonal;

        vOut.pos = mul(UNITY_MATRIX_VP, v[0]);
        vOut.posWorld = v[0];
        vOut.uv = float2(0.0f, 0.0f);
        OutputStream.Append(vOut);

        vOut.pos = mul(UNITY_MATRIX_VP, v[1]);
        vOut.posWorld = v[1];
        vOut.uv = float2(0.0f, 1.0f);
        OutputStream.Append(vOut);

        vOut.pos = mul(UNITY_MATRIX_VP, v[2]);
        vOut.posWorld = v[2];
        vOut.uv = float2(1.0f, 0.0f);
        OutputStream.Append(vOut);

      }

      struct fragOutput {
        float4 color: SV_TARGET;
      };

      fragOutput frag(vertexOutput i) {
        fragOutput o;

        // (0.5f, 0.5f) = center
        float distanceToCenter = sqrt(pow((0.5f - i.uv.x), 2) + pow((0.5f - i.uv.y), 2));

        if (distanceToCenter > 0.5f) {
          discard;
        }
        else if (distanceToCenter < (0.5f - wallThickness)) {
          o.color = _InsideColor;
        }
        else {
          discard;
        }

        //discard;
        return o;

      }

      ENDCG
    }

    /* horizontal quadrilaterals stencil prepare 
    */
    Pass {

      Stencil {
        Ref 5
        Comp Always
        Pass replace
      }

      //LOD 100
      //Blend SrcAlpha OneMinusSrcAlpha

      Cull Front
      //ZTest Always
      //ZWrite Off

      //ColorMask 0

      CGPROGRAM#pragma target 5.0#pragma vertex vert#pragma geometry geom#pragma fragment frag

      //#pragma multi_compile_fog

      #include "UnityCG.cginc"

      float4 _InsideColor;
      float wallThickness;
      int nodeCount;

      // color of light source (from "Lighting.cginc")
      uniform float4 _LightColor0;

      struct proxyData {
        float3 lastPos;
        float3 pos;
        float3 nextPos;
        float radius;
        uint pipeID;
      };

      //buffer containing the points of the line we want to draw.
      StructuredBuffer < proxyData > proxyQuadsBuffer;

      struct input {
        float4 pos: POSITION0;
        float4 nextPos: POSITION1;
        float4 lastPos: POSITION2;
        float radius: BLENDWEIGHT;
        uint pipeID: BLENDINDICES;
      };

      //PREPARE DATA FOR GEOMETRY SHADER
      input vert(uint id: SV_VertexID) {
        input o;

        o.pos = float4(proxyQuadsBuffer[id].pos, 1.0f);
        o.lastPos = float4(proxyQuadsBuffer[id].lastPos, 1.0f);
        o.nextPos = float4(proxyQuadsBuffer[id].nextPos, 1.0f);
        o.radius = proxyQuadsBuffer[id].radius;
        o.pipeID = proxyQuadsBuffer[id].pipeID;

        return o;
      }

      // SEMANTICS DONT SUGGEST THIS PARAMETERS ?
      struct vertexOutput {
        float4 pos: SV_POSITION;
        float4 posWorld: POSITION1;
        float2 uv: TEXCOORD0;
      };

      float3 invert(float3 vec) {
        return vec * ( - 1.0f);
      }

      //GEOMETRY SHADER
      [maxvertexcount(4)]
      void geom(line input p[2], inout TriangleStream < vertexOutput > OutputStream) {
        float radius = p[0].radius;
        // p[0].lastPos -> previous pos to p[0]
        // p[0] -> current pos
        // p[1] -> next pos
        // p[1].nextPos -> after next to p[0]

        // prevent to connect distinct pipes
        if (p[0].pipeID == p[1].pipeID) {

          vertexOutput vOut;
          float4 v[4];
          float3 posToCamera = normalize(_WorldSpaceCameraPos - p[0].pos.xyz);
          float3 nextPosToCamera = normalize(_WorldSpaceCameraPos - p[1].pos.xyz);

          float3 lastTangent = normalize(p[0].pos.xyz - p[0].lastPos.xyz);
          float3 tangent = normalize(p[1].pos.xyz - p[0].pos.xyz);
          float3 nextTangent = normalize(p[1].nextPos.xyz - p[1].pos.xyz);

          float3 bisectLast = normalize(lastTangent + tangent);
          float3 bisectNext = normalize(nextTangent + tangent);

          float3 upvec = float3(0, 1, 0);
          float3 side = normalize(cross(tangent, upvec));
          float3 upWards = normalize(cross(tangent, side));

          float3 upLast = normalize(cross(upWards, bisectLast));
          float3 downLast = invert(upLast);

          v[0] = p[0].pos + float4(upLast.xyz, 0) * radius;
          v[1] = p[0].pos + float4(downLast.xyz, 0) * radius;

          float3 upNext = normalize(cross(upWards, bisectNext));
          float3 downNext = invert(upNext);

          v[2] = p[1].pos + float4(upNext.xyz, 0) * radius;
          v[3] = p[1].pos + float4(downNext.xyz, 0) * radius;

          float3 bisectUp = normalize(upLast + upNext);

          vOut.pos = mul(UNITY_MATRIX_VP, v[0]);
          vOut.posWorld = v[0];
          vOut.uv = float2(0.0f, 0.0f);
          OutputStream.Append(vOut);

          vOut.pos = mul(UNITY_MATRIX_VP, v[1]);
          vOut.posWorld = v[1];
          vOut.uv = float2(0.0f, 1.0f);
          OutputStream.Append(vOut);

          vOut.pos = mul(UNITY_MATRIX_VP, v[2]);
          vOut.posWorld = v[2];
          vOut.uv = float2(1.0f, 0.0f);
          OutputStream.Append(vOut);

          vOut.pos = mul(UNITY_MATRIX_VP, v[3]);
          vOut.posWorld = v[3];
          vOut.uv = float2(1.0f, 1.0f);
          OutputStream.Append(vOut);
        }

      }

      struct fragOutput {
        float4 color: SV_TARGET;
      };

      fragOutput frag(vertexOutput i) {
        fragOutput o;

        if (i.uv.y < (1 - wallThickness) && i.uv.y > wallThickness) {
          o.color = _InsideColor;
        }
        else {
          discard;
        }

        return o;

      }

      ENDCG
    }

  }
  Fallback Off
}

/* Copyright (C) Manuel Matusich
* Unauthorized copying of this file, via any medium is strictly prohibited
* Written by Manuel Matusich , Juli 2017
*/

Shader "Custom/PipeBillboard" {
  Properties {
    _Color("Diffuse Color Outside", Color) = (1, 1, 1, 1)
    _InsideColor("Diffuse Color Inside", Color) = (1, 1, 1, 1)
    _SpecColor("Specular Color", Color) = (1, 1, 1, 1)
    _Shininess("Shininess", Float) = 10
  }
  SubShader {

    //PIPE BILLBOARDS VIEW ALIGNED INSIDE
    Pass {

      Stencil {
        Ref 5
        Comp Equal
        Pass IncrSat
      }

      //LOD 100
      //Blend SrcAlpha OneMinusSrcAlpha
      //Blend DstAlpha OneMinusDstAlpha

      Cull Front
      ZTest Always
      //ZTest Always
      //ColorMask 0

      CGPROGRAM#pragma target 5.0#pragma vertex vert#pragma geometry geom#pragma fragment frag
      //#pragma multi_compile_fwdbase

      //#pragma multi_compile_fog

      #include "AutoLight.cginc"#include "UnityCG.cginc"

      float4 _Color;
      float4 _InsideColor;
      float wallThickness;

      // color of light source (from "Lighting.cginc")
      uniform float4 _LightColor0;

      uniform float4 _SpecColor;
      uniform float _Shininess;

      struct pipeData {
        float3 lastPos;
        float3 pos;
        float3 nextPos;
        float radius;
        uint pipeID;
        uint id;
        uint pipeNodeCount;
        uint isCut;
      };

      //buffer containing the points of the line we want to draw.
      StructuredBuffer < pipeData > pipeQuadsBuffer;

      struct input {
        float4 pos: POSITION0;
        float4 nextPos: POSITION1;
        float4 lastPos: POSITION2;
        float radius: BLENDWEIGHT;
        uint pipeID: BLENDINDICES0;
        uint id: BLENDINDICES1;
        uint pipeNodeCount: BLENDINDICES2;
      };

      //PREPARE DATA FOR GEOMETRY SHADER
      input vert(uint id: SV_VertexID) {
        input o;

        o.pos = float4(pipeQuadsBuffer[id].pos, 1.0f);
        o.lastPos = float4(pipeQuadsBuffer[id].lastPos, 1.0f);
        o.nextPos = float4(pipeQuadsBuffer[id].nextPos, 1.0f);
        o.pipeID = pipeQuadsBuffer[id].pipeID;
        o.radius = pipeQuadsBuffer[id].radius;
        o.id = pipeQuadsBuffer[id].id;
        o.pipeNodeCount = pipeQuadsBuffer[id].pipeNodeCount;

        return o;
      }

      // SEMANTICS DONT SUGGEST THIS PARAMETERS ?
      struct vertexOutput {
        float4 pos: SV_POSITION;
        float4 posWorld: POSITION1;
        float4 screenPos: POSITION2;
        float4 depthCorrectFarScreenPos: POSITION3;
        float3 quadNormal: TEXCOORD2;
        float3 normal: NORMAL;
        float2 uv: TEXCOORD0;
        //SHADOW_COORDS(3)
      };

      float3 invert(float3 vec) {
        return vec * ( - 1.0f);
      }

      //GEOMETRY SHADER
      [maxvertexcount(4)]
      void geom(line input p[2], inout TriangleStream < vertexOutput > OutputStream) {
        int id = p[0].id;
        int nodeCount = p[0].pipeNodeCount;
        float radius = p[0].radius - (wallThickness * p[0].radius);
        // p[0].lastPos -> previous pos to p[0]
        // p[0].pos -> current pos
        // p[1].pos -> next pos
        // p[1].nextPos -> after next to p[0]

        //the quad is drawn from the previous (second last) position to the last
        if (id < nodeCount - 1 && p[0].pipeID == p[1].pipeID) {

          //CASE: EXACTLY 2 POINTS
          if (nodeCount == 2) {
            vertexOutput vOut;
            //TRANSFER_SHADOW(vOut);
            float4 v[4];
            float3 posToCamera = normalize(_WorldSpaceCameraPos - p[0].pos.xyz);
            float3 nextPosToCamera = normalize(_WorldSpaceCameraPos - p[1].pos.xyz);
            float3 tangent = normalize(p[1].pos.xyz - p[0].pos.xyz);

            float3 up = normalize(cross(tangent, posToCamera));
            float3 down = invert(up);

            v[0] = p[0].pos + float4(up, 0) * radius;
            v[1] = p[0].pos + float4(down, 0) * radius;

            float3 upNext = normalize(cross(tangent, nextPosToCamera));
            float3 downNext = invert(upNext);

            v[2] = p[1].pos + float4(upNext, 0) * radius;
            v[3] = p[1].pos + float4(downNext, 0) * radius;

            float3 bisectUp = normalize(up + upNext);
            vOut.quadNormal = normalize(cross(bisectUp, tangent));

            float3 upvec = float3(0, 1, 0);

            vOut.pos = mul(UNITY_MATRIX_VP, v[0]);
            vOut.posWorld = v[0];
            vOut.screenPos = ComputeScreenPos(vOut.pos);
            vOut.depthCorrectFarScreenPos = ComputeScreenPos(mul(UNITY_MATRIX_VP, v[0] - float4(cross(up, tangent), 0) * radius));
            vOut.normal = normalize(cross(vOut.quadNormal, (tangent * ( - 1))));
            vOut.uv = float2(0.0f, 0.0f);
            OutputStream.Append(vOut);

            vOut.pos = mul(UNITY_MATRIX_VP, v[1]);
            vOut.posWorld = v[1];
            vOut.screenPos = ComputeScreenPos(vOut.pos);
            vOut.depthCorrectFarScreenPos = ComputeScreenPos(mul(UNITY_MATRIX_VP, v[1] - float4(cross(up, tangent), 0) * radius));
            vOut.normal = normalize(cross(vOut.quadNormal, tangent));
            vOut.uv = float2(0.0f, 1.0f);
            OutputStream.Append(vOut);

            vOut.pos = mul(UNITY_MATRIX_VP, v[2]);
            vOut.posWorld = v[2];
            vOut.screenPos = ComputeScreenPos(vOut.pos);
            vOut.depthCorrectFarScreenPos = ComputeScreenPos(mul(UNITY_MATRIX_VP, v[2] - float4(cross(upNext, tangent), 0) * radius));
            vOut.normal = normalize(cross(vOut.quadNormal, (tangent * ( - 1))));
            vOut.uv = float2(1.0f, 0.0f);
            OutputStream.Append(vOut);

            vOut.pos = mul(UNITY_MATRIX_VP, v[3]);
            vOut.posWorld = v[3];
            vOut.screenPos = ComputeScreenPos(vOut.pos);
            vOut.depthCorrectFarScreenPos = ComputeScreenPos(mul(UNITY_MATRIX_VP, v[3] - float4(cross(upNext, tangent), 0) * radius));
            vOut.normal = normalize(cross(vOut.quadNormal, tangent));
            vOut.uv = float2(1.0f, 1.0f);
            OutputStream.Append(vOut);

          }

          //CASE: MORE THAN 2 POINTS
          else if (nodeCount > 2) {
            vertexOutput vOut;
            //TRANSFER_SHADOW(vOut);
            float4 v[4];
            float3 posToCamera = normalize(_WorldSpaceCameraPos - p[0].pos.xyz);
            float3 nextPosToCamera = normalize(_WorldSpaceCameraPos - p[1].pos.xyz);

            float3 lastTangent = normalize(p[0].pos.xyz - p[0].lastPos.xyz);
            float3 tangent = normalize(p[1].pos.xyz - p[0].pos.xyz);
            float3 nextTangent = normalize(p[1].nextPos.xyz - p[1].pos.xyz);

            float3 bisectLast = normalize(lastTangent + tangent);
            float3 bisectNext = normalize(nextTangent + tangent);

            float3 upvec = float3(0, 1, 0);

            // FIRST POSITION
            if (id == 0) {

              float3 up = normalize(cross(tangent, posToCamera));
              float3 down = invert(up);

              v[0] = p[0].pos + float4(up, 0) * radius;
              v[1] = p[0].pos + float4(down, 0) * radius;

              float3 upNext = normalize(cross(bisectNext, nextPosToCamera));
              float3 downNext = invert(upNext);

              v[2] = p[1].pos + float4(upNext, 0) * radius;
              v[3] = p[1].pos + float4(downNext, 0) * radius;

              float3 bisectUp = normalize(up + upNext);
              vOut.quadNormal = normalize(cross(bisectUp, tangent));

              vOut.pos = mul(UNITY_MATRIX_VP, v[0]);
              vOut.posWorld = v[0];
              vOut.screenPos = ComputeScreenPos(vOut.pos);
              vOut.depthCorrectFarScreenPos = ComputeScreenPos(mul(UNITY_MATRIX_VP, v[0] - float4(cross(up, tangent), 0) * radius));
              vOut.normal = normalize(cross(vOut.quadNormal, (tangent * ( - 1))));
              vOut.uv = float2(0.0f, 0.0f);
              OutputStream.Append(vOut);

              vOut.pos = mul(UNITY_MATRIX_VP, v[1]);
              vOut.posWorld = v[1];
              vOut.screenPos = ComputeScreenPos(vOut.pos);
              vOut.depthCorrectFarScreenPos = ComputeScreenPos(mul(UNITY_MATRIX_VP, v[1] - float4(cross(up, tangent), 0) * radius));
              vOut.normal = normalize(cross(vOut.quadNormal, tangent));
              vOut.uv = float2(0.0f, 1.0f);
              OutputStream.Append(vOut);

              vOut.pos = mul(UNITY_MATRIX_VP, v[2]);
              vOut.posWorld = v[2];
              vOut.screenPos = ComputeScreenPos(vOut.pos);
              vOut.depthCorrectFarScreenPos = ComputeScreenPos(mul(UNITY_MATRIX_VP, v[2] - float4(cross(upNext, tangent), 0) * radius));
              vOut.normal = normalize(cross(vOut.quadNormal, (tangent * ( - 1))));
              vOut.uv = float2(1.0f, 0.0f);
              OutputStream.Append(vOut);

              vOut.pos = mul(UNITY_MATRIX_VP, v[3]);
              vOut.posWorld = v[3];
              vOut.screenPos = ComputeScreenPos(vOut.pos);
              vOut.depthCorrectFarScreenPos = ComputeScreenPos(mul(UNITY_MATRIX_VP, v[3] - float4(cross(upNext, tangent), 0) * radius));
              vOut.normal = normalize(cross(vOut.quadNormal, tangent));
              vOut.uv = float2(1.0f, 1.0f);
              OutputStream.Append(vOut);
            }

            // SECOND LAST POSITION (last billboard quad)
            else if (id == nodeCount - 2) {

              float3 upLast = normalize(cross(bisectLast, posToCamera));
              float3 downLast = invert(upLast);

              float3 upNext = normalize(cross(tangent, nextPosToCamera));
              float3 downNext = invert(upNext);

              v[0] = p[0].pos + float4(upLast.xyz, 0) * radius;
              v[1] = p[0].pos + float4(downLast.xyz, 0) * radius;

              v[2] = p[1].pos + float4(upNext, 0) * radius;
              v[3] = p[1].pos + float4(downNext, 0) * radius;

              float3 bisectUp = normalize(upLast + upNext);
              vOut.quadNormal = normalize(cross(bisectUp, tangent));

              vOut.pos = mul(UNITY_MATRIX_VP, v[0]);
              vOut.posWorld = v[0];
              vOut.screenPos = ComputeScreenPos(vOut.pos);
              vOut.depthCorrectFarScreenPos = ComputeScreenPos(mul(UNITY_MATRIX_VP, v[0] - float4(cross(upLast, tangent), 0) * radius));
              vOut.normal = normalize(cross(vOut.quadNormal, (tangent * ( - 1))));
              vOut.uv = float2(0.0f, 0.0f);
              OutputStream.Append(vOut);

              vOut.pos = mul(UNITY_MATRIX_VP, v[1]);
              vOut.posWorld = v[1];
              vOut.screenPos = ComputeScreenPos(vOut.pos);
              vOut.depthCorrectFarScreenPos = ComputeScreenPos(mul(UNITY_MATRIX_VP, v[1] - float4(cross(upLast, tangent), 0) * radius));
              vOut.normal = normalize(cross(vOut.quadNormal, tangent));
              vOut.uv = float2(0.0f, 1.0f);
              OutputStream.Append(vOut);

              vOut.pos = mul(UNITY_MATRIX_VP, v[2]);
              vOut.posWorld = v[2];
              vOut.screenPos = ComputeScreenPos(vOut.pos);
              vOut.depthCorrectFarScreenPos = ComputeScreenPos(mul(UNITY_MATRIX_VP, v[2] - float4(cross(upNext, tangent), 0) * radius));
              vOut.normal = normalize(cross(vOut.quadNormal, (tangent * ( - 1))));
              vOut.uv = float2(1.0f, 0.0f);
              OutputStream.Append(vOut);

              vOut.pos = mul(UNITY_MATRIX_VP, v[3]);
              vOut.posWorld = v[3];
              vOut.screenPos = ComputeScreenPos(vOut.pos);
              vOut.depthCorrectFarScreenPos = ComputeScreenPos(mul(UNITY_MATRIX_VP, v[3] - float4(cross(upNext, tangent), 0) * radius));
              vOut.normal = normalize(cross(vOut.quadNormal, tangent));
              vOut.uv = float2(1.0f, 1.0f);
              OutputStream.Append(vOut);
            }

            // SECOND POSITION TO THIRD LAST POSITION
            else {

              float3 upLast = normalize(cross(bisectLast, posToCamera));
              float3 downLast = invert(upLast);

              float3 upNext = normalize(cross(bisectNext, nextPosToCamera));
              float3 downNext = invert(upNext);

              float3 bisectUp = normalize(upLast + upNext);
              vOut.quadNormal = normalize(cross(bisectUp, tangent));
              //vOut.quadNormal = float3(0,1,0);

              float3 upNormal = normalize(cross(vOut.quadNormal, (tangent * ( - 1))));
              float3 downNormal = normalize(cross(vOut.quadNormal, tangent));

              v[0] = p[0].pos + float4(upLast.xyz, 0) * radius;
              v[1] = p[0].pos + float4(downLast.xyz, 0) * radius;

              v[2] = p[1].pos + float4(upNext, 0) * radius;
              v[3] = p[1].pos + float4(downNext, 0) * radius;

              vOut.pos = mul(UNITY_MATRIX_VP, v[0]);
              vOut.posWorld = v[0];
              vOut.screenPos = ComputeScreenPos(vOut.pos);
              vOut.depthCorrectFarScreenPos = ComputeScreenPos(mul(UNITY_MATRIX_VP, v[0] - float4(cross(upLast, tangent), 0) * radius));
              vOut.normal = upNormal;
              vOut.uv = float2(0.0f, 0.0f);
              OutputStream.Append(vOut);

              vOut.pos = mul(UNITY_MATRIX_VP, v[1]);
              vOut.posWorld = v[1];
              vOut.screenPos = ComputeScreenPos(vOut.pos);
              vOut.depthCorrectFarScreenPos = ComputeScreenPos(mul(UNITY_MATRIX_VP, v[1] - float4(cross(upLast, tangent), 0) * radius));
              vOut.normal = downNormal;
              vOut.uv = float2(0.0f, 1.0f);
              OutputStream.Append(vOut);

              vOut.pos = mul(UNITY_MATRIX_VP, v[2]);
              vOut.posWorld = v[2];
              vOut.screenPos = ComputeScreenPos(vOut.pos);
              vOut.depthCorrectFarScreenPos = ComputeScreenPos(mul(UNITY_MATRIX_VP, v[2] - float4(cross(upNext, tangent), 0) * radius));
              vOut.normal = upNormal;
              vOut.uv = float2(1.0f, 0.0f);
              OutputStream.Append(vOut);

              vOut.pos = mul(UNITY_MATRIX_VP, v[3]);
              vOut.posWorld = v[3];
              vOut.screenPos = ComputeScreenPos(vOut.pos);
              vOut.depthCorrectFarScreenPos = ComputeScreenPos(mul(UNITY_MATRIX_VP, v[3] - float4(cross(upNext, tangent), 0) * radius));
              vOut.normal = downNormal;
              vOut.uv = float2(1.0f, 1.0f);
              OutputStream.Append(vOut);
            }
          }
        }
      }

      struct fragOutput {
        float4 color: SV_TARGET;
        float depth: SV_DEPTH;
      };

      fragOutput frag(vertexOutput i) {
        fragOutput o;

        //LIGHT SHADING

        // i.normal is set to the correct normal at the edge of the pipe
        // i.quadNormal is set to the correct normal at the center of the pipe
        // this gets interpolated automatically
        float3 normalDirection = normalize(i.normal * ( - 1.0f) + i.quadNormal);
        float3 viewDirection = normalize(
        _WorldSpaceCameraPos - i.posWorld.xyz);
        float3 lightDirection;
        float attenuation;

        //INSIDE
        float specularFactor = 0.1f;

        if (0.0 == _WorldSpaceLightPos0.w) // directional light?
        {
          attenuation = 1.0; // no attenuation
          lightDirection = normalize(_WorldSpaceLightPos0.xyz);
        }
        else // point or spot light
        {
          float3 vertexToLightSource = _WorldSpaceLightPos0.xyz - i.posWorld.xyz;
          float distance = length(vertexToLightSource);
          attenuation = 1.0 / distance; // linear attenuation 
          lightDirection = normalize(vertexToLightSource);
        }

        float3 ambientLighting = UNITY_LIGHTMODEL_AMBIENT.rgb * _Color.rgb;

        float3 diffuseReflection = attenuation * _LightColor0.rgb * _Color.rgb * max(0.0f, dot(normalDirection, lightDirection));

        float3 specularReflection;
        if (dot(normalDirection, lightDirection) < 0.0)
        // light source on the wrong side?
        {
          specularReflection = float3(0.0, 0.0, 0.0);
          // no specular reflection
        }
        else // light source on the right side
        {
          specularReflection = attenuation * _LightColor0.rgb * _SpecColor.rgb * pow(max(0.0, dot(
          reflect( - lightDirection, normalDirection), viewDirection)), _Shininess);
        }

        o.color = float4(diffuseReflection + ambientLighting + specularReflection * specularFactor, 1.0);
        o.color *= _InsideColor;

        // DEPTH CORRECTION
        float vertPixPos = i.uv.y;
        float alpha = 0.5f;
        float billboardDepth = (i.screenPos.z / i.screenPos.w);
        float nearDepth = (i.depthCorrectFarScreenPos.z / i.depthCorrectFarScreenPos.w);

        // transform   0 -> 0.5 -> 1   to   0.00001 -> 1 -> 0.00001 
        if (vertPixPos <= 0.5f) {
          alpha = vertPixPos * 2;
        }
        else {
          alpha = (1 - vertPixPos) * 2;
        }
        if (alpha <= 0) alpha = 0.00001f;

        //cicular interpolation (unit circle)
        float circularAlpha = sqrt(1 - pow((1 - alpha), 2));
        o.depth = (1 - (circularAlpha)) * billboardDepth + (circularAlpha) * nearDepth;

        return o;

      }

      ENDCG
    }

    //PIPE BILLBOARDS VIEW ALIGNED OUTSIDE PREPARE EXCLUDE
    Pass {

      Stencil {
        Ref 5
        Comp Always
        Pass replace
      }

      Cull Front
      ZWrite off
      //ZTest Always
      ColorMask 0

      CGPROGRAM#pragma target 5.0#pragma vertex vert#pragma geometry geom#pragma fragment frag

      #include "AutoLight.cginc"#include "UnityCG.cginc"

      float4 _Color;

      // color of light source (from "Lighting.cginc")
      uniform float4 _LightColor0;

      uniform float4 _SpecColor;
      uniform float _Shininess;

      struct pipeData {
        float3 lastPos;
        float3 pos;
        float3 nextPos;
        float radius;
        uint pipeID;
        uint id;
        uint pipeNodeCount;
        uint isCut;
      };

      //buffer containing the points of the line we want to draw.
      StructuredBuffer < pipeData > pipeQuadsBuffer;

      struct input {
        float4 pos: POSITION0;
        float4 nextPos: POSITION1;
        float4 lastPos: POSITION2;
        float radius: BLENDWEIGHT;
        uint pipeID: BLENDINDICES0;
        uint id: BLENDINDICES1;
        uint pipeNodeCount: BLENDINDICES2;
        uint isCut: BLENDINDICES3;
      };

      //PREPARE DATA FOR GEOMETRY SHADER
      input vert(uint id: SV_VertexID) {
        input o;

        o.pos = float4(pipeQuadsBuffer[id].pos, 1.0f);
        o.lastPos = float4(pipeQuadsBuffer[id].lastPos, 1.0f);
        o.nextPos = float4(pipeQuadsBuffer[id].nextPos, 1.0f);
        o.pipeID = pipeQuadsBuffer[id].pipeID;
        o.radius = pipeQuadsBuffer[id].radius;
        o.id = pipeQuadsBuffer[id].id;
        o.pipeNodeCount = pipeQuadsBuffer[id].pipeNodeCount;
        o.isCut = pipeQuadsBuffer[id].isCut;

        return o;
      }

      // SEMANTICS DONT SUGGEST THIS PARAMETERS ?
      struct vertexOutput {
        float4 pos: SV_POSITION;
        //SHADOW_COORDS(3)
      };

      float3 invert(float3 vec) {
        return vec * ( - 1.0f);
      }

      //GEOMETRY SHADER
      [maxvertexcount(4)]
      void geom(line input p[2], inout TriangleStream < vertexOutput > OutputStream) {
        int id = p[0].id;
        int nodeCount = p[0].pipeNodeCount;
        float radius = p[0].radius;
        // p[0].lastPos -> previous pos to p[0]
        // p[0].pos -> current pos
        // p[1].pos -> next pos
        // p[1].nextPos -> after next to p[0]

        //the quad is drawn from the previous (second last) position to the last
        if (id < nodeCount - 2 && p[0].pipeID == p[1].pipeID) {

          //CASE: MORE THAN 2 POINTS
          if (nodeCount > 2) {
            vertexOutput vOut;
            //TRANSFER_SHADOW(vOut);
            float4 v[4];
            float3 posToCamera = normalize(_WorldSpaceCameraPos - p[0].pos.xyz);
            float3 nextPosToCamera = normalize(_WorldSpaceCameraPos - p[1].pos.xyz);

            float3 lastTangent = normalize(p[0].pos.xyz - p[0].lastPos.xyz);
            float3 tangent = normalize(p[1].pos.xyz - p[0].pos.xyz);
            float3 nextTangent = normalize(p[1].nextPos.xyz - p[1].pos.xyz);

            float3 bisectLast = normalize(lastTangent + tangent);
            float3 bisectNext = normalize(nextTangent + tangent);

            float3 upvec = float3(0, 1, 0);

            // SECOND POSITION TO THIRD LAST POSITION
            {

              float3 upLast = normalize(cross(bisectLast, posToCamera));
              float3 downLast = invert(upLast);

              float3 upNext = normalize(cross(bisectNext, nextPosToCamera));
              float3 downNext = invert(upNext);

              float3 bisectUp = normalize(upLast + upNext);

              v[0] = p[0].pos + float4(upLast.xyz, 0) * radius;
              v[1] = p[0].pos + float4(downLast.xyz, 0) * radius;

              v[2] = p[1].pos + float4(upNext, 0) * radius;
              v[3] = p[1].pos + float4(downNext, 0) * radius;

              //depending on the view position 
              if (dot(upvec, upLast) >= 0.0f) {
                v[1] = p[0].pos;
                v[3] = p[1].pos;
              }
              else {
                v[0] = p[0].pos;
                v[2] = p[1].pos;
              }

              vOut.pos = mul(UNITY_MATRIX_VP, v[0]);
              OutputStream.Append(vOut);

              vOut.pos = mul(UNITY_MATRIX_VP, v[1]);
              OutputStream.Append(vOut);

              vOut.pos = mul(UNITY_MATRIX_VP, v[2]);
              OutputStream.Append(vOut);

              vOut.pos = mul(UNITY_MATRIX_VP, v[3]);
              OutputStream.Append(vOut);
            }
          }
        }
      }

      struct fragOutput {
        float4 color: SV_TARGET;
      };

      fragOutput frag(vertexOutput i) {
        fragOutput o;

        o.color = float4(1, 0, 0, 1.0);
        return o;

      }

      ENDCG
    }

    //PIPE BILLBOARDS VIEW ALIGNED OUTSIDE
    Pass {

      Stencil {
        Ref 5
        Comp Greater
        Pass DecrSat
      }

      //LOD 100
      //Blend SrcAlpha OneMinusSrcAlpha
      //Blend DstAlpha OneMinusDstAlpha

      Cull Front
      //ZWrite off
      //ZTest Always
      //ColorMask 0

      CGPROGRAM#pragma target 5.0#pragma vertex vert#pragma geometry geom#pragma fragment frag
      //#pragma multi_compile_fwdbase

      //#pragma multi_compile_fog

      #include "AutoLight.cginc"#include "UnityCG.cginc"

      float4 _Color;

      // color of light source (from "Lighting.cginc")
      uniform float4 _LightColor0;

      uniform float4 _SpecColor;
      uniform float _Shininess;

      struct pipeData {
        float3 lastPos;
        float3 pos;
        float3 nextPos;
        float radius;
        uint pipeID;
        uint id;
        uint pipeNodeCount;
        uint isCut;
      };

      //buffer containing the points of the line we want to draw.
      StructuredBuffer < pipeData > pipeQuadsBuffer;

      struct input {
        float4 pos: POSITION0;
        float4 nextPos: POSITION1;
        float4 lastPos: POSITION2;
        float radius: BLENDWEIGHT;
        uint pipeID: BLENDINDICES0;
        uint id: BLENDINDICES1;
        uint pipeNodeCount: BLENDINDICES2;
        uint isCut: BLENDINDICES3;
      };

      //PREPARE DATA FOR GEOMETRY SHADER
      input vert(uint id: SV_VertexID) {
        input o;

        o.pos = float4(pipeQuadsBuffer[id].pos, 1.0f);
        o.lastPos = float4(pipeQuadsBuffer[id].lastPos, 1.0f);
        o.nextPos = float4(pipeQuadsBuffer[id].nextPos, 1.0f);
        o.pipeID = pipeQuadsBuffer[id].pipeID;
        o.radius = pipeQuadsBuffer[id].radius;
        o.id = pipeQuadsBuffer[id].id;
        o.pipeNodeCount = pipeQuadsBuffer[id].pipeNodeCount;
        o.isCut = pipeQuadsBuffer[id].isCut;

        return o;
      }

      // SEMANTICS DONT SUGGEST THIS PARAMETERS ?
      struct vertexOutput {
        float4 pos: SV_POSITION;
        float4 posWorld: POSITION1;
        float4 screenPos: POSITION2;
        float4 depthCorrectNearScreenPos: POSITION3;
        float3 quadNormal: TEXCOORD2;
        float3 normal: NORMAL;
        float2 uv: TEXCOORD0;
        //SHADOW_COORDS(3)
      };

      float3 invert(float3 vec) {
        return vec * ( - 1.0f);
      }

      //GEOMETRY SHADER
      [maxvertexcount(4)]
      void geom(line input p[2], inout TriangleStream < vertexOutput > OutputStream) {
        int id = p[0].id;
        int nodeCount = p[0].pipeNodeCount;
        float radius = p[0].radius;
        // p[0].lastPos -> previous pos to p[0]
        // p[0].pos -> current pos
        // p[1].pos -> next pos
        // p[1].nextPos -> after next to p[0]

        //the quad is drawn from the previous (second last) position to the last
        if (id < nodeCount - 1 && p[0].pipeID == p[1].pipeID) {

          //CASE: EXACTLY 2 POINTS
          if (nodeCount == 2) {
            vertexOutput vOut;
            //TRANSFER_SHADOW(vOut);
            float4 v[4];
            float3 posToCamera = normalize(_WorldSpaceCameraPos - p[0].pos.xyz);
            float3 nextPosToCamera = normalize(_WorldSpaceCameraPos - p[1].pos.xyz);
            float3 tangent = normalize(p[1].pos.xyz - p[0].pos.xyz);

            float3 up = normalize(cross(tangent, posToCamera));
            float3 down = invert(up);

            v[0] = p[0].pos + float4(up, 0) * radius;
            v[1] = p[0].pos + float4(down, 0) * radius;

            float3 upNext = normalize(cross(tangent, nextPosToCamera));
            float3 downNext = invert(upNext);

            v[2] = p[1].pos + float4(upNext, 0) * radius;
            v[3] = p[1].pos + float4(downNext, 0) * radius;

            float3 bisectUp = normalize(up + upNext);
            vOut.quadNormal = normalize(cross(bisectUp, tangent));

            float3 upvec = float3(0, 1, 0);

            vOut.pos = mul(UNITY_MATRIX_VP, v[0]);
            vOut.posWorld = v[0];
            vOut.screenPos = ComputeScreenPos(vOut.pos);
            vOut.depthCorrectNearScreenPos = ComputeScreenPos(mul(UNITY_MATRIX_VP, v[0] + float4(cross(up, tangent), 0) * radius));
            vOut.normal = normalize(cross(vOut.quadNormal, (tangent * ( - 1))));
            vOut.uv = float2(0.0f, 0.0f);
            OutputStream.Append(vOut);

            vOut.pos = mul(UNITY_MATRIX_VP, v[1]);
            vOut.posWorld = v[1];
            vOut.screenPos = ComputeScreenPos(vOut.pos);
            vOut.depthCorrectNearScreenPos = ComputeScreenPos(mul(UNITY_MATRIX_VP, v[1] + float4(cross(up, tangent), 0) * radius));
            vOut.normal = normalize(cross(vOut.quadNormal, tangent));
            vOut.uv = float2(0.0f, 1.0f);
            OutputStream.Append(vOut);

            vOut.pos = mul(UNITY_MATRIX_VP, v[2]);
            vOut.posWorld = v[2];
            vOut.screenPos = ComputeScreenPos(vOut.pos);
            vOut.depthCorrectNearScreenPos = ComputeScreenPos(mul(UNITY_MATRIX_VP, v[2] + float4(cross(upNext, tangent), 0) * radius));
            vOut.normal = normalize(cross(vOut.quadNormal, (tangent * ( - 1))));
            vOut.uv = float2(1.0f, 0.0f);
            OutputStream.Append(vOut);

            vOut.pos = mul(UNITY_MATRIX_VP, v[3]);
            vOut.posWorld = v[3];
            vOut.screenPos = ComputeScreenPos(vOut.pos);
            vOut.depthCorrectNearScreenPos = ComputeScreenPos(mul(UNITY_MATRIX_VP, v[3] + float4(cross(upNext, tangent), 0) * radius));
            vOut.normal = normalize(cross(vOut.quadNormal, tangent));
            vOut.uv = float2(1.0f, 1.0f);
            OutputStream.Append(vOut);

          }

          //CASE: MORE THAN 2 POINTS
          else if (nodeCount > 2) {
            vertexOutput vOut;
            //TRANSFER_SHADOW(vOut);
            float4 v[4];
            float3 posToCamera = normalize(_WorldSpaceCameraPos - p[0].pos.xyz);
            float3 nextPosToCamera = normalize(_WorldSpaceCameraPos - p[1].pos.xyz);

            float3 lastTangent = normalize(p[0].pos.xyz - p[0].lastPos.xyz);
            float3 tangent = normalize(p[1].pos.xyz - p[0].pos.xyz);
            float3 nextTangent = normalize(p[1].nextPos.xyz - p[1].pos.xyz);

            float3 bisectLast = normalize(lastTangent + tangent);
            float3 bisectNext = normalize(nextTangent + tangent);

            float3 upvec = float3(0, 1, 0);
            float3 side = normalize(cross(upvec, tangent));

            // FIRST POSITION
            if (id == 0) {

              float3 up = normalize(cross(tangent, posToCamera));
              float3 down = invert(up);

              v[0] = p[0].pos + float4(up, 0) * radius;
              v[1] = p[0].pos + float4(down, 0) * radius;

              float3 upNext = normalize(cross(bisectNext, nextPosToCamera));
              float3 downNext = invert(upNext);

              v[2] = p[1].pos + float4(upNext, 0) * radius;
              v[3] = p[1].pos + float4(downNext, 0) * radius;

              float3 bisectUp = normalize(up + upNext);
              vOut.quadNormal = normalize(cross(bisectUp, tangent));

              vOut.pos = mul(UNITY_MATRIX_VP, v[0]);
              vOut.posWorld = v[0];
              vOut.screenPos = ComputeScreenPos(vOut.pos);
              vOut.depthCorrectNearScreenPos = ComputeScreenPos(mul(UNITY_MATRIX_VP, v[0] + float4(cross(up, tangent), 0) * radius));
              vOut.normal = normalize(cross(vOut.quadNormal, (tangent * ( - 1))));
              vOut.uv = float2(0.0f, 0.0f);
              OutputStream.Append(vOut);

              vOut.pos = mul(UNITY_MATRIX_VP, v[1]);
              vOut.posWorld = v[1];
              vOut.screenPos = ComputeScreenPos(vOut.pos);
              vOut.depthCorrectNearScreenPos = ComputeScreenPos(mul(UNITY_MATRIX_VP, v[1] + float4(cross(up, tangent), 0) * radius));
              vOut.normal = normalize(cross(vOut.quadNormal, tangent));
              vOut.uv = float2(0.0f, 1.0f);
              OutputStream.Append(vOut);

              vOut.pos = mul(UNITY_MATRIX_VP, v[2]);
              vOut.posWorld = v[2];
              vOut.screenPos = ComputeScreenPos(vOut.pos);
              vOut.depthCorrectNearScreenPos = ComputeScreenPos(mul(UNITY_MATRIX_VP, v[2] + float4(cross(upNext, tangent), 0) * radius));
              vOut.normal = normalize(cross(vOut.quadNormal, (tangent * ( - 1))));
              vOut.uv = float2(1.0f, 0.0f);
              OutputStream.Append(vOut);

              vOut.pos = mul(UNITY_MATRIX_VP, v[3]);
              vOut.posWorld = v[3];
              vOut.screenPos = ComputeScreenPos(vOut.pos);
              vOut.depthCorrectNearScreenPos = ComputeScreenPos(mul(UNITY_MATRIX_VP, v[3] + float4(cross(upNext, tangent), 0) * radius));
              vOut.normal = normalize(cross(vOut.quadNormal, tangent));
              vOut.uv = float2(1.0f, 1.0f);
              OutputStream.Append(vOut);
            }

            // SECOND LAST POSITION (last billboard quad)
            else if (id == nodeCount - 2) {

              float3 upLast = normalize(cross(bisectLast, posToCamera));
              float3 downLast = invert(upLast);

              float3 upNext = normalize(cross(tangent, nextPosToCamera));
              float3 downNext = invert(upNext);

              v[0] = p[0].pos + float4(upLast.xyz, 0) * radius;
              v[1] = p[0].pos + float4(downLast.xyz, 0) * radius;

              v[2] = p[1].pos + float4(upNext, 0) * radius;
              v[3] = p[1].pos + float4(downNext, 0) * radius;

              float3 bisectUp = normalize(upLast + upNext);
              vOut.quadNormal = normalize(cross(bisectUp, tangent));

              vOut.pos = mul(UNITY_MATRIX_VP, v[0]);
              vOut.posWorld = v[0];
              vOut.screenPos = ComputeScreenPos(vOut.pos);
              vOut.depthCorrectNearScreenPos = ComputeScreenPos(mul(UNITY_MATRIX_VP, v[0] + float4(cross(upLast, tangent), 0) * radius));
              vOut.normal = normalize(cross(vOut.quadNormal, (tangent * ( - 1))));
              vOut.uv = float2(0.0f, 0.0f);
              OutputStream.Append(vOut);

              vOut.pos = mul(UNITY_MATRIX_VP, v[1]);
              vOut.posWorld = v[1];
              vOut.screenPos = ComputeScreenPos(vOut.pos);
              vOut.depthCorrectNearScreenPos = ComputeScreenPos(mul(UNITY_MATRIX_VP, v[1] + float4(cross(upLast, tangent), 0) * radius));
              vOut.normal = normalize(cross(vOut.quadNormal, tangent));
              vOut.uv = float2(0.0f, 1.0f);
              OutputStream.Append(vOut);

              vOut.pos = mul(UNITY_MATRIX_VP, v[2]);
              vOut.posWorld = v[2];
              vOut.screenPos = ComputeScreenPos(vOut.pos);
              vOut.depthCorrectNearScreenPos = ComputeScreenPos(mul(UNITY_MATRIX_VP, v[2] + float4(cross(upNext, tangent), 0) * radius));
              vOut.normal = normalize(cross(vOut.quadNormal, (tangent * ( - 1))));
              vOut.uv = float2(1.0f, 0.0f);
              OutputStream.Append(vOut);

              vOut.pos = mul(UNITY_MATRIX_VP, v[3]);
              vOut.posWorld = v[3];
              vOut.screenPos = ComputeScreenPos(vOut.pos);
              vOut.depthCorrectNearScreenPos = ComputeScreenPos(mul(UNITY_MATRIX_VP, v[3] + float4(cross(upNext, tangent), 0) * radius));
              vOut.normal = normalize(cross(vOut.quadNormal, tangent));
              vOut.uv = float2(1.0f, 1.0f);
              OutputStream.Append(vOut);
            }

            // SECOND POSITION TO THIRD LAST POSITION
            else {

              float3 upLast = normalize(cross(bisectLast, posToCamera));
              float3 downLast = invert(upLast);

              float3 upNext = normalize(cross(bisectNext, nextPosToCamera));
              float3 downNext = invert(upNext);

              float3 bisectUp = normalize(upLast + upNext);
              vOut.quadNormal = normalize(cross(bisectUp, tangent));

              float3 upNormal = normalize(cross(vOut.quadNormal, (tangent * ( - 1))));
              float3 downNormal = normalize(cross(vOut.quadNormal, tangent));

              float2 uv[4];
              float4 depth[4];

              v[0] = p[0].pos + float4(upLast.xyz, 0) * radius;
              v[1] = p[0].pos + float4(downLast.xyz, 0) * radius;

              v[2] = p[1].pos + float4(upNext, 0) * radius;
              v[3] = p[1].pos + float4(downNext, 0) * radius;

              uv[0] = float2(0.0f, 0.0f);
              uv[1] = float2(0.0f, 1.0f);
              uv[2] = float2(1.0f, 0.0f);
              uv[3] = float2(1.0f, 1.0f);

              depth[0] = ComputeScreenPos(mul(UNITY_MATRIX_VP, v[0] + float4(cross(upLast, tangent), 0) * radius));
              depth[1] = ComputeScreenPos(mul(UNITY_MATRIX_VP, v[1] + float4(cross(upLast, tangent), 0) * radius));
              depth[2] = ComputeScreenPos(mul(UNITY_MATRIX_VP, v[2] + float4(cross(upNext, tangent), 0) * radius));
              depth[3] = ComputeScreenPos(mul(UNITY_MATRIX_VP, v[3] + float4(cross(upNext, tangent), 0) * radius));

              vOut.pos = mul(UNITY_MATRIX_VP, v[0]);
              vOut.posWorld = v[0];
              vOut.screenPos = ComputeScreenPos(vOut.pos);
              vOut.depthCorrectNearScreenPos = depth[0];
              vOut.normal = upNormal;
              vOut.uv = uv[0];
              OutputStream.Append(vOut);

              vOut.pos = mul(UNITY_MATRIX_VP, v[1]);
              vOut.posWorld = v[1];
              vOut.screenPos = ComputeScreenPos(vOut.pos);
              vOut.depthCorrectNearScreenPos = depth[1];
              vOut.normal = downNormal;
              vOut.uv = uv[1];
              OutputStream.Append(vOut);

              vOut.pos = mul(UNITY_MATRIX_VP, v[2]);
              vOut.posWorld = v[2];
              vOut.screenPos = ComputeScreenPos(vOut.pos);
              vOut.depthCorrectNearScreenPos = depth[2];
              vOut.normal = upNormal;
              vOut.uv = uv[2];
              OutputStream.Append(vOut);

              vOut.pos = mul(UNITY_MATRIX_VP, v[3]);
              vOut.posWorld = v[3];
              vOut.screenPos = ComputeScreenPos(vOut.pos);
              vOut.depthCorrectNearScreenPos = depth[3];
              vOut.normal = downNormal;
              vOut.uv = uv[3];
              OutputStream.Append(vOut);
            }
          }
        }
      }

      struct fragOutput {
        float4 color: SV_TARGET;
        float depth: SV_DEPTH;
      };

      fragOutput frag(vertexOutput i) {
        fragOutput o;

        //LIGHT SHADING

        // i.normal is set to the correct normal at the edge of the pipe
        // i.quadNormal is set to the correct normal at the center of the pipe
        // this gets interpolated automatically
        float3 normalDirection = normalize(i.normal + i.quadNormal);
        float3 viewDirection = normalize(
        _WorldSpaceCameraPos - i.posWorld.xyz);
        float3 lightDirection;
        float attenuation;
        float specularFactor = 0.2f;

        if (0.0 == _WorldSpaceLightPos0.w) // directional light?
        {
          attenuation = 1.0; // no attenuation
          lightDirection = normalize(_WorldSpaceLightPos0.xyz);
        }
        else // point or spot light
        {
          float3 vertexToLightSource = _WorldSpaceLightPos0.xyz - i.posWorld.xyz;
          float distance = length(vertexToLightSource);
          attenuation = 1.0 / distance; // linear attenuation 
          lightDirection = normalize(vertexToLightSource);
        }

        float3 ambientLighting = UNITY_LIGHTMODEL_AMBIENT.rgb * _Color.rgb;

        float3 diffuseReflection = attenuation * _LightColor0.rgb * _Color.rgb * max(0.0f, dot(normalDirection, lightDirection));

        float3 specularReflection;
        if (dot(normalDirection, lightDirection) < 0.0)
        // light source on the wrong side?
        {
          specularReflection = float3(0.0, 0.0, 0.0);
          // no specular reflection
        }
        else // light source on the right side
        {
          specularReflection = attenuation * _LightColor0.rgb * _SpecColor.rgb * pow(max(0.0, dot(
          reflect( - lightDirection, normalDirection), viewDirection)), _Shininess);
        }

        //float shadowAtten = SHADOW_ATTENUATION(i);
        //o.color = float4(diffuseReflection * shadowAtten + ambientLighting + specularReflection * specularFactor, 1.0);

        o.color = float4(diffuseReflection + ambientLighting + specularReflection * specularFactor, 1.0);

        // DEPTH CORRECTION
        float vertPixPos = i.uv.y;
        float alpha = 0.5f;
        float billboardDepth = (i.screenPos.z / i.screenPos.w);
        float nearDepth = (i.depthCorrectNearScreenPos.z / i.depthCorrectNearScreenPos.w);

        // transform   0 -> 0.5 -> 1   to   0.00001 -> 1 -> 0.00001 
        if (vertPixPos <= 0.5f) {
          alpha = vertPixPos * 2;
        }
        else {
          alpha = (1 - vertPixPos) * 2;
        }
        if (alpha <= 0) alpha = 0.00001f;

        //cicular interpolation (unit circle)
        float circularAlpha = sqrt(1 - pow((1 - alpha), 2));
        o.depth = (1 - (circularAlpha)) * billboardDepth + (circularAlpha) * nearDepth;

        return o;

      }

      ENDCG
    }

  }
  FallBack Off

}

/* Copyright (C) Manuel Matusich
* Unauthorized copying of this file, via any medium is strictly prohibited
* Written by Manuel Matusich , Juli 2017
*/

Shader "Custom/Terrain" {
  Properties {
    _MainTex("Texture For Diffuse Material Color", 2D) = "white" {}
    _TexHeight("TextureHeight", Float) = 2048
    _Color("Diffuse Material Color", Color) = (1, 1, 1, 1)
    _CutColor("Cut Color", Color) = (0, 1, 0, 0)
  }
  SubShader {
    Pass {
      Tags {
        "LightMode" = "ForwardBase"
      }
      // pass for ambient light and first light source
      //Blend SrcAlpha OneMinusSrcAlpha
      //ColorMask 0
      CGPROGRAM#pragma target 5.0#pragma vertex vert#pragma fragment frag#pragma multi_compile_fwdadd_fullshadows#include "UnityCG.cginc"#include "AutoLight.cginc"
      uniform float4 _LightColor0;
      // color of light source (from "Lighting.cginc")

      // User-specified properties
      uniform sampler2D _MainTex;
      uniform float4 _Color;
      uniform float4 _CutColor;
      uniform float _TexHeight;

      struct data {
        float3 pos;
        int pipeID;
        int nodeID;
      };

      struct uvData {
        float2 uvPos;
        int pipeID;
        int nodeID;
      };

      uniform sampler2D DTglobalTex;
      uniform int scanTexCoords; // 0 or 1 (bool)

      uniform int UpdateCounterPipeNodeID;
      uniform float terrainCutModifierSize;
      uniform float terrainCutModifierWidth;
      StructuredBuffer < data > pipeNodesVec3ReadBuffer;
      RWStructuredBuffer < uvData > RWpipeNodesUVBuffer: register(u[1]);

      struct vertexInput {
        float4 vertex: POSITION;
        float3 normal: NORMAL;
        float4 texcoord: TEXCOORD0;
      };
      struct vertexOutput {
        float4 pos: SV_POSITION;
        float4 tex: TEXCOORD0;
        float4 posWorld: TEXCOORD1;
        float3 normalDir: TEXCOORD2;
        SHADOW_COORDS(3)
      };

      vertexOutput vert(vertexInput v) {
        vertexOutput o;

        float4x4 modelMatrix = unity_ObjectToWorld;
        float4x4 modelMatrixInverse = unity_WorldToObject;

        o.posWorld = mul(modelMatrix, v.vertex);
        o.normalDir = normalize(
        mul(float4(v.normal, 0.0), modelMatrixInverse).xyz);
        o.pos = mul(UNITY_MATRIX_MVP, v.vertex);
        o.tex = v.texcoord;
        TRANSFER_SHADOW(o);

        return o;
      }

      struct fragOutput {
        float4 color: SV_TARGET;
      };

      fragOutput frag(vertexOutput input) {
        fragOutput o;

        float3 normalDirection = normalize(input.normalDir);

        float3 viewDirection = normalize(
        _WorldSpaceCameraPos - input.posWorld.xyz);
        float3 lightDirection;
        float attenuation;

        if (0.0 == _WorldSpaceLightPos0.w) // directional light?
        {
          attenuation = 1.0; // no attenuation
          lightDirection = normalize(_WorldSpaceLightPos0.xyz);
        }
        else // point or spot light
        {
          float3 vertexToLightSource = _WorldSpaceLightPos0.xyz - input.posWorld.xyz;
          float distance = length(vertexToLightSource);
          attenuation = 1.0 / distance; // linear attenuation 
          lightDirection = normalize(vertexToLightSource);
        }

        float3 ambientLighting = UNITY_LIGHTMODEL_AMBIENT.rgb * _Color.rgb;

        float3 diffuseReflection = attenuation * _LightColor0.rgb * _Color.rgb * max(0.0, dot(normalDirection, lightDirection));

        float shadowAtten = SHADOW_ATTENUATION(input);

        o.color = float4(ambientLighting + diffuseReflection * tex2D(_MainTex, input.tex.xy) * shadowAtten, 1.0);

        if (scanTexCoords == 1) {
          float3 node = pipeNodesVec3ReadBuffer[UpdateCounterPipeNodeID].pos;
          float dist = distance(float2(node.x, node.z), input.posWorld.xz);
          if (dist < 0.1f) {
            o.color = float4(1, 0, 0, 1);
            RWpipeNodesUVBuffer[0].uvPos = input.tex.xy;
            RWpipeNodesUVBuffer[0].pipeID = pipeNodesVec3ReadBuffer[UpdateCounterPipeNodeID].pipeID;
            RWpipeNodesUVBuffer[0].nodeID = pipeNodesVec3ReadBuffer[UpdateCounterPipeNodeID].nodeID;
          }
        }

        if (scanTexCoords != 1) {

          float dist2pipe = tex2Dlod(DTglobalTex, float4(input.tex.xy, 0, 0)).y;
          float dist2cam = distance(_WorldSpaceCameraPos, input.posWorld.xyz);
          //float threshold = terrainCutModifierWidth * 25.0f * terrainCutModifierSize - terrainCutModifierWidth * dist2cam / terrainCutModifierSize;

          float threshold = (terrainCutModifierWidth) * ((pow(terrainCutModifierSize, 2) - dist2cam)) / (terrainCutModifierSize);
          int iterations = 12;
          float epsilon = sqrt(2) / _TexHeight / iterations;
          float2 viewDirection2D = viewDirection.xz * epsilon;

          if (dist2pipe < threshold) {
            float2 coords = float2(input.tex.x, input.tex.y);
            bool solid = false;
            for (int i = 0; i < iterations; i++) {
              float2 lookUpUV = coords + viewDirection2D * i;
              if (tex2Dlod(DTglobalTex, float4(lookUpUV.xy, 0, 0)).y > threshold) {
                solid = true;
                o.color = float4((ambientLighting * 2 + diffuseReflection / 2) * _CutColor.rgb, 1.0);
              }
            }
            if (!solid) discard;
          }
        }

        return o;
      }

      ENDCG
    }

  }
  Fallback "Diffuse"
}