/* qbism.c
 *
 * Andy Goth <unununium@openverse.com>
 *
 * Derived from, and hopefully compatible with, GIMP's gqbist.c, originally by
 * Jens Ch. Restemeier <jrestemeier@currantbun.com>.  gqbist.c is available
 * under the GPL (GNU General Public License), version 2 or later.  Therefore,
 * the file is also available under the GPL.  And there was much rejoicing. */

#include <math.h>
#include <stdio.h>
#include <stdlib.h>

#include "qbism.h"

/* You're not going to believe this. */
void qbism_render(algo_t* algo, int width, int height, FILE* out)
{
    int y, x;                   /* Coordinates.                             */
    int step;                   /* Current transformation step.             */
    int i;                      /* General-purpose iterator.                */
    reg_t* reg;                 /* Registers.                               */
    int sr, cr, dr;             /* Source, control, dest register indices.  */
    float sum;                  /* Temporary variable: sum.                 */
    float dot_product;          /* Temporary variable: dot product.         */

    /* Allocate the registers. */
    reg = xmalloc(sizeof(*reg) * algo->num_regs);

    /* Output MIFF header. */
    fprintf(out, "id=ImageMagick\n");
    fprintf(out, "columns=%d\n", width);
    fprintf(out, "rows=%d\n", height);
    fprintf(out, "depth=16\n");
    fprintf(out, "\f\n:\x01a");

    /* Render image. */
    for (y = 0; y < height; ++y) {
        for (x = 0; x < width; ++x) {
            /* Initialize registers for this pixel. */
            for (i = 0; i < algo->num_regs; ++i) {
                reg[i][0] = x / (float)width;
                reg[i][1] = y / (float)height;
                reg[i][2] = i / (float)algo->num_regs;
            }

            /* Apply transformations. */
            for (step = 0; step < algo->num_steps; ++step) {
                sr = algo->seq[step].source;
                cr = algo->seq[step].control;
                dr = algo->seq[step].dest;

                /* Update the registers for this pixel. */
                switch (algo->seq[step].opcode) {
                case XOP_PROJECTION:
                    dot_product = 0;
                    for (i = 0; i < 3; ++i) {
                        dot_product += reg[sr][i] * reg[cr][i];
                    }
                    for (i = 0; i < 3; ++i) {
                        reg[dr][i] = dot_product * reg[sr][i];
                    }
                    break;
                case XOP_SHIFT:
                    for (i = 0; i < 3; ++i) {
                        reg[dr][i] = reg[sr][i] + reg[cr][i];
                        if (reg[dr][i] >= 1.0) {
                            reg[dr][i] -= 1.0;
                        }
                    }
                    break;
                case XOP_SHIFTBACK:
                    for (i = 0; i < 3; ++i) {
                        reg[dr][i] = reg[sr][i] - reg[cr][i];
                        if (reg[dr][i] <= 0.0) {
                            reg[dr][i] += 1.0;
                        }
                    }
                    break;
                case XOP_ROTATE:
                    for (i = 0; i < 3; ++i) {
                        reg[dr][i] = reg[sr][(i + 1) % 3];
                    }
                    break;
                case XOP_ROTATE2:
                    for (i = 0; i < 3; ++i) {
                        reg[dr][i] = reg[sr][(i + 2) % 3];
                    }
                    break;
                case XOP_MULTIPLY:
                    for (i = 0; i < 3; ++i) {
                        reg[dr][i] = reg[sr][i] * reg[cr][i];
                    }
                    break;
                case XOP_SINE:
                    for (i = 0; i < 3; ++i) {
                        reg[dr][i] = (sin(20 * reg[sr][i] * reg[cr][i]) + 1) /2;
                    }
                    break;
                case XOP_CONDITIONAL:
                    sum = 0.0;
                    for (i = 0; i < 3; ++i) {
                        sum += reg[cr][i];
                    }
                    if (sum > 0.5) {
                        for (i = 0; i < 3; ++i) {
                            reg[dr][i] = reg[sr][i];
                        }
                    } else {
                        for (i = 0; i < 3; ++i) {
                            reg[dr][i] = reg[cr][i];
                        }
                    }
                    break;
                case XOP_COMPLEMENT:
                    for (i = 0; i < 3; ++i) {
                        reg[dr][i] = 1.0 - reg[sr][i];
                    }
                    break;
                }
            }

            /* Calculate and output pixel. */
            for (i = 0; i < 3; ++i) {
                fputc((int)(reg[0][i] * 65535 + 0.5) >> 8, out);
                fputc((int)(reg[0][i] * 65535 + 0.5) >> 0, out);
            }
        }
    }

    /* Done with reg; free it. */
    free(reg);
}

/* vim: set ts=4 sts=4 sw=4 tw=80 et: */