//This is a library app, mostly for the draw command, which allows to import these shape-drawing functions into your own app.
//Arguments for each are to be given as a singleton list, for ease of use. This is with the exception of the fill_flat functions, with
//the assumption that they're unlikely to be used outside of internal calls, but it is still available to be called if necessary.
//Make sure you read the arguments and input them in the correct order, or it will mess up.
//these functions return a set of all the positions in the shape, given the parameters, without repeating a position.
//This way, you can efficiently iterate over the positions once having generated them. See draw_beta.sc for an example. todo change to draw once renamed


draw_sphere(args)->(
    [centre, radius, hollow] = args;
    positions = {};
    [cx,cy,cz]=centre;
    for(range(-90, 90, 45/radius),
        cpitch = cos(_);
        spitch = sin(_);
        for(range(0, 180, 45/radius),
            cyaw = cos(_)*cpitch*radius;
            syaw = sin(_)*cpitch*radius;
            if(hollow,
                positions += [cx+cyaw,cy+spitch*radius,cz+syaw];
                positions += [cx+cos(_+180)*cpitch*radius,cy+spitch*radius,cz+sin(_+180)*cpitch*radius],
                for(range(-syaw,syaw+1),
                    positions += [cx+cyaw*cpitch,cy+spitch*radius,cz+_]
                )
            )
        )
    );
    positions
);

draw_diamond(args)->(
    [pos, radius] = args;
    positions = {};
    c_for(r=0, r<radius, r+=1,
        y = r-radius+1;
        c_for(x=-r,x<=r,x+=1,
            z=r-abs(x);
            positions += [pos:0+x, pos:1 +y, pos:2+z];
            positions += [pos:0+x, pos:1 +y, pos:2-z];
            positions += [pos:0+x, pos:1 -y, pos:2+z];
            positions += [pos:0+x, pos:1 -y, pos:2-z];
        )
    );
    positions
);

draw_filled_diamond(args)->(
    [pos, radius] = args;
    positions = {};
    for(diamond(pos,radius,radius),
        positions += pos(_)
    );
    positions
);

draw_pyramid(args)->(
    [pos, radius, height, pointing, orientation, fill_type, is_square] = args;//todo change to hollow boolean arg
    positions = {};
    hollow = fill_type=='hollow';
    pointup = pointing=='up';
    for(range(height),
        r = if(pointup, radius * ( 1- _ / height) -1, radius * _ / height);
        positions += fill_flat(pos, _, r, is_square, orientation, !((pointup&&_==0)||(!pointup && _==height-1)) && hollow)//Always close bottom off
    );
    positions
);

draw_prism(args)->(
    [pos, rad, height, orientation, fill_type, is_square]=args;//todo change to hollow boolean arg
    positions = {};
    hollow = fill_type =='hollow';
    radius = rad+0.5;
    filled_circle_points = fill_flat(pos, 0, radius, is_square, orientation, false); //I dont actually need to generate all the points lol
    offset_vector = if(orientation=='x', [1,0,0], orientation=='y', [0,1,0],[0,0,1]);
    if(hollow,
        hollow_circle_points = fill_flat(pos, 0, radius, is_square, orientation, true);

        for(filled_circle_points,//Always close ends off
            positions+=_;
            positions+=_+offset_vector*(height-1)
        );

        for(range(1, height-1),//cos Im adding ends as filled anyways
            offset=_;
            for(hollow_circle_points,
                positions+= _ + offset_vector * offset
            )
        ),
        
        for(range(height),
            offset = _;
            for(filled_circle_points,
                positions += _ + offset_vector * offset
            )
        );
    )
    positions
);

fill_flat(pos, offset, dr, rectangle, orientation, hollow)->
    if(rectangle,
        fill_flat_rectangle(pos, offset, dr, orientation, hollow),
        fill_flat_circle(pos, offset, dr, orientation, hollow)
    );

fill_flat_circle(pos, offset, dr, orientation, hollow) ->( //Bresenham circle algorithm to be super efficient
    r = floor(dr);
    a=0;
    b=r;
    d=3-(2*r);

    positions = {};

    positions += fill_flat_circle_points(pos, orientation, offset, hollow, a, b);

    while(a<=b, 10^10,
        if(d<=0,
            d += (4*a)+6,
            d += (4*a)-(4*b)+10;
            b=b-1
        );
        a+=1;
        positions += fill_flat_circle_points(pos, orientation, offset, hollow, a, b)
    );
    positions
);

fill_flat_circle_points(pos, orientation, offset, hollow, a, b) ->(
    [x, y, z] = pos;
    positions = {};
    if(orientation == 'x',
        if(hollow,
            positions += [x + offset, a+y, b+z];
            positions += [x + offset, a+y,-b+z];
            positions += [x + offset,-a+y,-b+z];
            positions += [x + offset,-a+y, b+z];
            positions += [x + offset, b+y, a+z];
            positions += [x + offset, b+y,-a+z];
            positions += [x + offset,-b+y,-a+z];
            positions += [x + offset,-b+y, a+z],
            c_for(c = -a, c<=a, c+=1,
                positions += [x + offset,c+y, b + z];
                positions += [x + offset,c+y,-b + z]
            );
            c_for(c = -b, c<=b, c+=1,
                positions += [x + offset, a+y,c + z];
                positions += [x + offset,-a+y,c + z]
            )
        ),
        orientation=='y',
        if(hollow,
            positions += [ a+x, y + offset, b+z];
            positions += [ a+x, y + offset,-b+z];
            positions += [-a+x, y + offset,-b+z];
            positions += [-a+x, y + offset, b+z];
            positions += [ b+x, y + offset, a+z];
            positions += [ b+x, y + offset,-a+z];
            positions += [-b+x, y + offset,-a+z];
            positions += [-b+x, y + offset, a+z],
            c_for(c = -a, c<=a, c+=1,
                positions += [c+x,y + offset, b + z];
                positions += [c+x,y + offset,-b + z]
            );
            c_for(c = -b, c<=b, c+=1,
                positions += [ a+x,y + offset,c + z];
                positions += [-a+x,y + offset,c + z]
            )
        ),
        orientation=='z',
        if(hollow,
            positions += [ a+x, b+y, z + offset];
            positions += [ a+x,-b+y, z + offset];
            positions += [-a+x,-b+y, z + offset];
            positions += [-a+x, b+y, z + offset];
            positions += [ b+x, a+y, z + offset];
            positions += [ b+x,-a+y, z + offset];
            positions += [-b+x,-a+y, z + offset];
            positions += [-b+x, a+y, z + offset],
            c_for(c = -a, c<=a, c+=1,
                positions += [c+x, b + y,z + offset];
                positions += [c+x,-b + y,z + offset]
            );
            c_for(c = -b, c<=b, c+=1,
                positions += [ a+x,c + y,z + offset];
                positions += [-a+x,c + y,z + offset]
            )
        )
    )
);

fill_flat_rectangle(pos, offset, dr, orientation, hollow) -> (
    r = floor(dr);
    drsq = dr^2;
    positions = {};
    if(orientation == 'x',
        c_for(a = -r, a <=r, a +=1,
            if(hollow,
                positions += [r + offset, a, r];
                positions += [r + offset, a,-r];
                positions += [r + offset, r, a];
                positions += [r + offset,-r, a],
                c_for(b = -r, b <=r, b +=1,
                    positions += [r + offset, a, b]
                )
            )
        ),
        orientation == 'y',
        c_for(a = -r, a <=r, a +=1,
            if(hollow,
                positions += [ r, r + offset,a];
                positions += [-r, r + offset,a];
                positions += [a, r + offset, r];
                positions += [a, r + offset,-r],
                c_for(b = -r, b <=r, b +=1,
                    positions += [a, r + offset, b]
                )
            )
        ),
        orientation == 'z',
        c_for(a = -r, a <=r, a +=1,
             if(hollow,
                positions += [ r, a,r + offset];
                positions += [-r, a,r + offset];
                positions += [a, r, r + offset];
                positions += [a,-r, r + offset],
                c_for(b = -r, b <=r, b +=1,
                    positions += [b, a, r + offset]
                )
            )
        ),
    );
    positions
);