//Version()

// empty definition for tree for mesh generation

#include "stdinc.inc"
#include "arrays.inc"

#declare STRUCT_SUBTREES=0;
#declare STRUCT_VERTICES=1;
#declare STRUCT_NORMALS=2;
#declare STRUCT_FACES=3;
#declare STRUCT_SMOOTH_FACES_V=4;
#declare STRUCT_SMOOTH_FACES_N=5;
#declare STRUCT_TEXTURES=6;
#declare STRUCT_COUNTER=7;
#declare STRUCT_ENTRIES=8;

#declare CONE_ACCURACY=10;
#declare SPHERE_ACCURACY=3;

#macro Empty_Struct()
  #local Struct=array[STRUCT_ENTRIES];
  #local Struct[STRUCT_COUNTER]=array[STRUCT_ENTRIES-1];
  Struct
#end

#macro Struct_Texture(Tex)
  array[1]{Tex}
#end

#macro Empty_Struct_Texture()
  array[1]
#end

#macro Count_ID_Struct(ID)
  #ifdef(Struct[ID])
    #declare Struct[STRUCT_COUNTER][ID]=dimension_size(Struct[ID],1);
  #end
#end

#macro Count_Struct(Struct)
  #local Counter=0;
  #while(Counter<dimension_size(Struct[STRUCT_COUNTER],1))
    Count_ID_Struct(Counter)
    #local Counter=Counter+1;
  #end
#end

#macro Cone_Struct(P1,R1,P2,R2,Tex,Accuracy)

  #local Struct=Empty_Struct();
  #local Axis=vnormalize(P2-P1);
  #local Radius=vnormalize(vcross(Axis,<Axis.y,Axis.z,-Axis.x>));

  // FILL VERTICES AND NORMALS
  #local Struct[STRUCT_VERTICES]=array[2*(Accuracy+1)];
  #local Struct[STRUCT_NORMALS]=array[2*(Accuracy+1)];

  #local Struct[STRUCT_VERTICES][0]=P1;
  #local Struct[STRUCT_NORMALS][0]=-Axis;
  #local Struct[STRUCT_VERTICES][Accuracy+1]=P2;
  #local Struct[STRUCT_NORMALS][Accuracy+1]=Axis;

  #local Counter=0;
  #while (Counter<Accuracy)
    #local Struct[STRUCT_VERTICES][1+Counter]=P1+vaxis_rotate(Radius*R1,Axis,360*Counter/Accuracy);
    #local Struct[STRUCT_NORMALS][1+Counter]=vnormalize(Struct[STRUCT_VERTICES][1+Counter]-P1);
    #local Struct[STRUCT_VERTICES][Accuracy+2+Counter]=P2+vaxis_rotate(Radius*R2,Axis,360*(Counter+.5)/Accuracy);
    #local Struct[STRUCT_NORMALS][Accuracy+2+Counter]=vnormalize(Struct[STRUCT_VERTICES][Accuracy+2+Counter]-P2);
    #local Counter=Counter+1;
  #end

  // FILL FACES
  #local Struct[STRUCT_FACES]=array[2*Accuracy];
  #local Struct[STRUCT_SMOOTH_FACES_V]=array[2*Accuracy];
  #local Struct[STRUCT_SMOOTH_FACES_N]=array[2*Accuracy];
  #local Counter=0;
  #local Last=Accuracy-1;
  #while (Counter<Accuracy)
    #local Struct[STRUCT_FACES][Counter]=<0,1+Last,1+Counter>;
    #local Struct[STRUCT_FACES][Accuracy+Counter]=<Accuracy+1,Accuracy+2+Last,Accuracy+2+Counter>;
    #local Struct[STRUCT_SMOOTH_FACES_V][Counter]=<Accuracy+2+Last,1+Last,1+Counter>;
    #local Struct[STRUCT_SMOOTH_FACES_N][Counter]=<Accuracy+2+Last,1+Last,1+Counter>;
    #local Struct[STRUCT_SMOOTH_FACES_V][Accuracy+Counter]=<Accuracy+2+Last,Accuracy+2+Counter,1+Counter>;
    #local Struct[STRUCT_SMOOTH_FACES_N][Accuracy+Counter]=<Accuracy+2+Last,Accuracy+2+Counter,1+Counter>;
    #local Last=Counter;
    #local Counter=Counter+1;
  #end

  // FILL TEXTURE
  #local Struct[STRUCT_TEXTURES]=Tex;
  
  // FILL COUNTERS
  Count_Struct(Struct)
  
  Struct
#end

#macro Sphere_Struct(P0,R,Tex,Accuracy)

  #local Struct=Empty_Struct();

  // FILL VERTICES AND FACES
  #local Struct[STRUCT_VERTICES]=array[6];

  #local Struct[STRUCT_VERTICES][0]=x;
  #local Struct[STRUCT_VERTICES][1]=-x;
  #local Struct[STRUCT_VERTICES][2]=y;
  #local Struct[STRUCT_VERTICES][3]=-y;
  #local Struct[STRUCT_VERTICES][4]=z;
  #local Struct[STRUCT_VERTICES][5]=-z;

  #local Struct[STRUCT_SMOOTH_FACES_V]=array[8];
  #local Struct[STRUCT_SMOOTH_FACES_V][0]=<0,2,4>;
  #local Struct[STRUCT_SMOOTH_FACES_V][1]=<4,2,1>;
  #local Struct[STRUCT_SMOOTH_FACES_V][2]=<1,2,5>;
  #local Struct[STRUCT_SMOOTH_FACES_V][3]=<5,2,0>;
  #local Struct[STRUCT_SMOOTH_FACES_V][4]=<0,3,4>;
  #local Struct[STRUCT_SMOOTH_FACES_V][5]=<4,3,1>;
  #local Struct[STRUCT_SMOOTH_FACES_V][6]=<1,3,5>;
  #local Struct[STRUCT_SMOOTH_FACES_V][7]=<5,3,0>;

  // SUBDIVIDE FACES AND ADD NEW VERTICES
  #while(Accuracy>0)
    #local Current=0;
    #local Last=dimension_size(Struct[STRUCT_SMOOTH_FACES_V],1);
    #local First_New_Vertex=dimension_size(Struct[STRUCT_VERTICES],1);
    #while(Current<Last)
      #local _P1=Struct[STRUCT_SMOOTH_FACES_V][Current].x;
      #local _P2=Struct[STRUCT_SMOOTH_FACES_V][Current].y;
      #local _P3=Struct[STRUCT_SMOOTH_FACES_V][Current].z;
      #local P1=Struct[STRUCT_VERTICES][_P1];
      #local P2=Struct[STRUCT_VERTICES][_P2];
      #local P3=Struct[STRUCT_VERTICES][_P3];
      #local PA=vnormalize(P1+P2);
      #local PB=vnormalize(P2+P3);
      #local PC=vnormalize(P3+P1);
      #ifdef(_PA)#undef _PA#end
      #ifdef(_PB)#undef _PB#end
      #ifdef(_PC)#undef _PC#end
      #local Counter=First_New_Vertex;
      #while(Counter<dimension_size(Struct[STRUCT_VERTICES],1))
        #local CP=Struct[STRUCT_VERTICES][Counter];
        #ifndef(_PA)#if(vlength(CP-PA)=0)#local _PA=Counter;#end#end
        #ifndef(_PB)#if(vlength(CP-PB)=0)#local _PB=Counter;#end#end
        #ifndef(_PC)#if(vlength(CP-PC)=0)#local _PC=Counter;#end#end
        #local Counter=Counter+1;
      #end
      #ifndef(_PA)
        #local _PA=dimension_size(Struct[STRUCT_VERTICES],1);
        Resize_Array(Struct[STRUCT_VERTICES],_PA+1)
        #local Struct[STRUCT_VERTICES][_PA]=PA;
      #end
      #ifndef(_PB)
        #local _PB=dimension_size(Struct[STRUCT_VERTICES],1);
        Resize_Array(Struct[STRUCT_VERTICES],_PB+1)
        #local Struct[STRUCT_VERTICES][_PB]=PB;
      #end
      #ifndef(_PC)
        #local _PC=dimension_size(Struct[STRUCT_VERTICES],1);
        Resize_Array(Struct[STRUCT_VERTICES],_PC+1)
        #local Struct[STRUCT_VERTICES][_PC]=PC;
      #end
      #local Struct[STRUCT_SMOOTH_FACES_V][Current]=<_PA,_PB,_PC>;
      #local S=dimension_size(Struct[STRUCT_SMOOTH_FACES_V],1);
      Resize_Array(Struct[STRUCT_SMOOTH_FACES_V],S+3)
      #local Struct[STRUCT_SMOOTH_FACES_V][S]=<_P1,_PA,_PC>;
      #local Struct[STRUCT_SMOOTH_FACES_V][S+1]=<_P2,_PB,_PA>;
      #local Struct[STRUCT_SMOOTH_FACES_V][S+2]=<_P3,_PB,_PC>;
      #local Current=Current+1;
    #end
    #local Accuracy=Accuracy-1;
  #end
  
  // FILL NORMALS AND ADJUST VERTICES
  #local Struct[STRUCT_NORMALS]=Struct[STRUCT_VERTICES];
  #local Counter=0;
  #while(Counter<dimension_size(Struct[STRUCT_VERTICES],1))
    #local Struct[STRUCT_VERTICES][Counter]=P0+R*Struct[STRUCT_VERTICES][Counter];
    #local Counter=Counter+1;
  #end
  #local Struct[STRUCT_SMOOTH_FACES_N]=Struct[STRUCT_SMOOTH_FACES_V];
  
  // FILL TEXTURE
  #local Struct[STRUCT_TEXTURES]=Tex;

  // FILL COUNTERS
  Count_Struct(Struct)

  Struct
#end

#macro Add_Sub_Struct(Root,Struct)
  #ifndef(Root[STRUCT_SUBTREES])
    #declare Root[STRUCT_SUBTREES]=array[1]{Struct}
  #else
    Resize_Array(Root[STRUCT_SUBTREES],dimension_size(Root[STRUCT_SUBTREES],1)+1)
    #declare Root[STRUCT_SUBTREES][dimension_size(Root[STRUCT_SUBTREES],1)-1]=Struct;
  #end
#end

#macro Transform_Struct(Struct,Trans)
  
#end

#macro Create_Mesh_Struct(Struct)
  #ifdef(Struct[STRUCT_FACES])
    #local Faces=Struct[STRUCT_FACES];
    #local Counter=0;
    #while(Counter<dimension_size(Faces,1))
      #ifdef(Faces[Counter])
        triangle{
          Struct[STRUCT_VERTICES][Faces[Counter].x]
          Struct[STRUCT_VERTICES][Faces[Counter].y]
          Struct[STRUCT_VERTICES][Faces[Counter].z]
          #ifdef(Struct[STRUCT_TEXTURES])
            #local Textures=Struct[STRUCT_TEXTURES];
            #ifdef(Textures[0])
              texture{Textures[0]}
            #end
          #end
        }
      #end
      #local Counter=Counter+1;
    #end
  #end
  #ifdef(Struct[STRUCT_SMOOTH_FACES_V])
    #local Faces=Struct[STRUCT_SMOOTH_FACES_V];
    #ifdef(Struct[STRUCT_SMOOTH_FACES_N])
      #local Normals=Struct[STRUCT_SMOOTH_FACES_N];
      #local Counter=0;
      #while(Counter<dimension_size(Faces,1))
        #ifdef(Faces[Counter])
          smooth_triangle{
            Struct[STRUCT_VERTICES][Faces[Counter].x] Struct[STRUCT_NORMALS][Normals[Counter].x]
            Struct[STRUCT_VERTICES][Faces[Counter].y] Struct[STRUCT_NORMALS][Normals[Counter].y]
            Struct[STRUCT_VERTICES][Faces[Counter].z] Struct[STRUCT_NORMALS][Normals[Counter].z]
            #ifdef(Struct[STRUCT_TEXTURES])
              #local Textures=Struct[STRUCT_TEXTURES];
              #ifdef(Textures[0])
                texture{Textures[0]}
              #end
            #end
          }
        #end
        #local Counter=Counter+1;
      #end
    #end
  #end
  #ifdef(Struct[STRUCT_SUBTREES])
    #local Faces=Struct[STRUCT_SUBTREES];
    #local Counter=0;
    #while(Counter<dimension_size(Faces,1))
      #ifdef(Faces[Counter])
        Create_Mesh_Struct(Faces[Counter])
      #end
      #local Counter=Counter+1;
    #end
  #end
#end

#macro Mesh_Struct(Root)
  mesh{
    Create_Mesh_Struct(Root)
    #ifdef(Root[STRUCT_TEXTURES])
      #local Textures=Root[STRUCT_TEXTURES];
      #ifdef(Textures[0])
        texture{Textures[0]}
      #end
    #end
  }
#end

#macro Count_Mesh2_Struct(Struct,ID)
  #local Tree=0;
  #ifdef(Struct[STRUCT_SUBTREES])
    #local Faces=Struct[STRUCT_SUBTREES];
    #local Counter=0;
    #while(Counter<dimension_size(Faces,1))
      #ifdef(Faces[Counter])
        #local Tree=Tree+Count_Mesh2_Struct(Faces[Counter],ID)
      #end
      #local Counter=Counter+1;
    #end
  #end
  (Struct[STRUCT_COUNTER][ID]+Tree)
#end

#macro List_Mesh_Struct(Struct,ID,Signs)
  #local Tree=0;
  #ifdef(Struct[STRUCT_SUBTREES])
    #local Faces=Struct[STRUCT_SUBTREES];
    #local Counter=0;
    #while(Counter<dimension_size(Faces,1))
      #ifdef(Faces[Counter])
        List_Mesh2_Struct(Faces[Counter],ID,Signs)
      #end
      #local Counter=Counter+1;
    #end
  #end
  (Struct[STRUCT_COUNTER][ID]+Tree)
#end

#macro Mesh2_Struct(Root)
  mesh2{
    #local Vertex=0;
    #local Normal=0;
    vertex_vectors{
      Count_Mesh2_Struct(Root,STRUCT_VERTICES)
      List_Mesh2_Struct(Root,STRUCT_VERTICES,-1)
    }
    pigment{color rgb 1}
  }
#end

#declare Root=Empty_Struct();
union{
#declare Cone1=Cone_Struct(x,.5,y+z,.1,Struct_Texture(texture{pigment{color red 1}}),CONE_ACCURACY)
#declare Cone2=Cone_Struct(-x,.5,-(y+z),.1,Struct_Texture(texture{pigment{color green 1}}),CONE_ACCURACY)
#declare Cone3=Cone_Struct(-x,.1,x,.1,Struct_Texture(texture{pigment{color blue 1}}),CONE_ACCURACY)
Add_Sub_Struct(Cone1,Cone2)
Add_Sub_Struct(Cone1,Cone3)
Add_Sub_Struct(Cone1,Sphere_Struct(0,1,Struct_Texture(texture{pigment{color blue 1}}),SPHERE_ACCURACY))
//Mesh_Struct(Cone1)
Mesh2_Struct(Cone1)
pigment{color rgb 1}
rotate <20,30,40>
rotate y*90
}

//Add_Struct_To_Root(Root,Cone)

camera{
#local Size=4;
orthographic
location -z*10
right Size*x*image_width/image_height
up Size*y
direction z 
}

light_source{-100*z color rgb 1}