3d Power Stack For Owen

/*
    A Simple 2d Plane For Owen, with proper aspect ratios!
    Color adder, single channel
    By: Chris M. Thomasson
*_____________________________________________________________*/


#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <complex.h>
#include <tgmath.h>
#include <stdbool.h>


#define CT_WIDTH 1920
#define CT_HEIGHT 1080
#define CT_N 10000000



struct ct_rgb
{
    unsigned char r;
    unsigned char g;
    unsigned char b;
};


struct ct_canvas
{
    unsigned long width;
    unsigned long height;
    //unsigned char* buf;
    struct ct_rgb* buf;
};

bool
ct_canvas_create(
    struct ct_canvas* const self,
    unsigned long width,
    unsigned long height
){
    size_t size = width * height * sizeof(*self->buf);

    self->buf = calloc(1, size);

    if (self->buf)
    {
        self->width = width;
        self->height = height;

        return true;
    }

    return false;
}

void
ct_canvas_destroy(
    struct ct_canvas const* const self
){
    free(self->buf);
}

bool
ct_canvas_save_ppm(
    struct ct_canvas const* const self,
    char const* fname
){
    FILE* fout = fopen(fname, "wb");

    if (fout)
    {
        // P6 by Bart over on:
        // https://groups.google.com/forum/#!original/comp.lang.c/4196m3Raggs/2moZ67o5EwAJ

        char const ppm_head[] =
            "P6\n"
            "# Chris M. Thomasson Simple 2d Plane ver:0.0.0.0 (pre-alpha)";

        fprintf(fout, "%s\n%lu %lu\n%u\n",
                ppm_head,
                self->width, self->height,
                255U);

        size_t size = self->width * self->height;

        for (size_t i = 0; i < size; ++i)
        {
            //unsigned int c = self->buf[i];
            struct ct_rgb* c = self->buf + i;

            fprintf(fout, "%c%c%c", c->r, c->g, c->b);
            //fprintf(fout, "%c%c%c", c, 0U, 0U);
        }

        if (! fclose(fout))
        {
            return true;
        }
    }

    return false;
}




struct ct_axes
{
    double xmin;
    double xmax;
    double ymin;
    double ymax;
};

struct ct_axes
ct_axes_from_point(
    double complex z,
    double radius
){
    struct ct_axes axes = {
        creal(z) - radius, creal(z) + radius,
        cimag(z) - radius, cimag(z) + radius
    };

    return axes;
}


struct ct_plane
{
    struct ct_axes axes;
    double xstep;
    double ystep;
};


void
ct_plane_init(
    struct ct_plane* const self,
    struct ct_axes const* axes,
    unsigned long width,
    unsigned long height
){
    self->axes = *axes;

    double awidth = self->axes.xmax - self->axes.xmin;
    double aheight = self->axes.ymax - self->axes.ymin;

    assert(width > 0 && height > 0 && awidth > 0.0);

    double daspect = fabs((double)height / width);
    double waspect = fabs(aheight / awidth);

    if (daspect > waspect)
    {
        double excess = aheight * (daspect / waspect - 1.0);
        self->axes.ymax += excess / 2.0;
        self->axes.ymin -= excess / 2.0;
    }

    else if (daspect < waspect)
    {
        double excess = awidth * (waspect / daspect - 1.0);
        self->axes.xmax += excess / 2.0;
        self->axes.xmin -= excess / 2.0;
    }

    self->xstep = (self->axes.xmax - self->axes.xmin) / width;
    self->ystep = (self->axes.ymax - self->axes.ymin) / height;
}



struct ct_plot
{
    struct ct_plane plane;
    struct ct_canvas* canvas;
};


void
ct_plot_init(
    struct ct_plot* const self,
    struct ct_axes const* axes,
    struct ct_canvas* canvas
){
    ct_plane_init(&self->plane, axes, canvas->width - 1, canvas->height - 1);
    self->canvas = canvas;
}


bool
ct_plot_add(
    struct ct_plot* const self,
    double complex z,
    struct ct_rgb const* color
){
    long x = (creal(z) - self->plane.axes.xmin) / self->plane.xstep;
    long y = (self->plane.axes.ymax - cimag(z)) / self->plane.ystep;

    if (x > -1 && x < (long)self->canvas->width &&
        y > -1 && y < (long)self->canvas->height)
    {
        // Now, we can convert to index.
        size_t i = x + y * self->canvas->width;

        assert(i < self->canvas->height * self->canvas->width);

        struct ct_rgb exist = self->canvas->buf[i];

        exist.r += 1;

        self->canvas->buf[i] = exist;
        return true;
    }

    return true;
}


bool
ct_plot_pixel(
    struct ct_plot* const self,
    long x,
    long y,
    struct ct_rgb const* color
){
    if (x > -1 && x < (long)self->canvas->width &&
        y > -1 && y < (long)self->canvas->height)
    {
        // Now, we can convert to index.
        size_t i = x + y * self->canvas->width;

        assert(i < self->canvas->height * self->canvas->width);

        self->canvas->buf[i] = *color;
        return true;
    }

    return false;
}


double complex
ct_project_to_xy(
    struct ct_plot* const self,
    long x,
    long y
){
    double complex p =
        (self->plane.axes.xmin + x * self->plane.xstep) +
        (self->plane.axes.ymax - y * self->plane.ystep) * I;

    return p;
}


bool
ct_plot_point(
    struct ct_plot* const self,
    double complex z,
    struct ct_rgb const* color
){
    long x = (creal(z) - self->plane.axes.xmin) / self->plane.xstep;
    long y = (self->plane.axes.ymax - cimag(z)) / self->plane.ystep;

    if (x > -1 && x < (long)self->canvas->width &&
        y > -1 && y < (long)self->canvas->height)
    {
        // Now, we can convert to index.
        size_t i = x + y * self->canvas->width;

        assert(i < self->canvas->height * self->canvas->width);

        self->canvas->buf[i] = *color;
        return true;
    }

    return false;
}


// slow, so what for now... ;^)
void ct_circle(
    struct ct_plot* const plot,
    double complex c,
    double radius,
    unsigned int n
){
    double abase = 6.2831853071 / n;

    for (unsigned int i = 0; i < n; ++i)
    {
        double angle = abase * i;

        double complex z =
            (creal(c) + cos(angle) * radius) +
            (cimag(c) + sin(angle) * radius) * I;

        struct ct_rgb rgb = { 255, 255, 255 };

        ct_plot_point(plot, z, &rgb);
    }
}


// Simple 3-ary vector impl, just what I need.
struct ct_vec3
{
    double x;
    double y;
    double z;
};


double ct_vev3_length(
    struct ct_vec3 const p
){
    double sum = p.x * p.x + p.y * p.y + p.z * p.z;
    return sqrt(sum);
}


struct ct_vec3
ct_vec3_add(
    struct ct_vec3 const p,
    struct ct_vec3 const addend
){
    struct ct_vec3 sum = {
        p.x + addend.x,
        p.y + addend.y,
        p.z + addend.z
    };

    return sum;
}


// The Mandelbulb, slice hardcoded
// Animation comes next Owen.
void
ct_iterate_mbulb_pixel(
    struct ct_plot* const plot,
    struct ct_vec3 const z0,
    struct ct_vec3 const c0,
    long x,
    long y,
    unsigned int n
){
    struct ct_vec3 zs = z0;
    struct ct_vec3 cs = c0;

    double power = 3.0;

    for (unsigned long i = 0; i < n; ++i)
    {
        double r = ct_vev3_length(zs);
        double rpower = pow(r, power);

        double angle0 = atan2(zs.z, sqrt(zs.x * zs.x + zs.y * zs.y));
        double angle1 = atan2(zs.y, zs.x);

        struct ct_vec3 znew;
        znew.x = rpower * cos(power * angle1) * cos(power * angle0);
        znew.y = rpower * sin(power * angle1) * cos(power * angle0);
        znew.z = rpower * sin(power * angle0);

        zs = ct_vec3_add(znew, cs);

        if (r > 2.0)
        {
            return;
        }
    }

    struct ct_rgb rgb = { 0, 255, 0 };
    ct_plot_pixel(plot, x, y, &rgb);
}


// Gain the field...
void
ct_iterate_mbulb_plane(
    struct ct_plot* const plot,
    unsigned int n
){
    for (long y = 0; y < plot->canvas->height; ++y)
    {
        for (long x = 0; x < plot->canvas->width; ++x)
        {
            double complex cz = ct_project_to_xy(plot, x, y);

            // Well, our per slice coords...
            struct ct_vec3 z;

            z.x = creal(cz);
            z.y = cimag(cz);
            z.z = 0.1;

            // Iterate the slice
            ct_iterate_mbulb_pixel(plot, z, z, x, y, n);
        }
    }
}




void ct_test_plane(
    struct ct_plot* const plot
){
    ct_iterate_mbulb_plane(plot, 64);

    ct_circle(plot, 0+0*I, 1.0, 2048);
}


int main(void)
{
    struct ct_canvas canvas;

    if (ct_canvas_create(&canvas, CT_WIDTH, CT_HEIGHT))
    {
        double complex plane_origin = 0+0*I;
        double plane_radius = 2.0;

        struct ct_axes axes = ct_axes_from_point(plane_origin, plane_radius);

        struct ct_plot plot;
        ct_plot_init(&plot, &axes, &canvas);


        ct_test_plane(&plot);


        // Our unit circle
        ct_circle(&plot, 0+0*I, 1.0, 2048);
        ct_circle(&plot, 2+0*I, 2.0, 2048);
        ct_circle(&plot, -2+0*I, 2.0, 2048);
        ct_circle(&plot, 0+2*I, 2.0, 2048);
        ct_circle(&plot, 0-2*I, 2.0, 2048);

        ct_canvas_save_ppm(&canvas, "ct_plane.ppm");

        ct_canvas_destroy(&canvas);

        return EXIT_SUCCESS;
    }

    return EXIT_FAILURE;
}