/*
 * povray.c - Generate POV-Ray output
 *
 * Written 2010 by Werner Almesberger
 * Copyright 2010 by Werner Almesberger
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 */


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

#include "face.h"
#include "solid.h"


static void height_field(const char *name, const struct face *f,
    const struct matrix *m)
{
	FILE *file;
	int x, y;
	int z;
	uint16_t g;
	uint8_t v[2];

	file = fopen(name, "w");
	if (!file) {
		perror(name);
		exit(1);
	}
	fprintf(file, "P5\n%d %d\n65535\n", f->sx, f->sy);
	for (y = 0; y != f->sy; y++)
		for (x = 0; x != f->sx; x++) {
			z = get(f->a, x+f->a->min_x, y+f->a->min_y);
			g = z == UNDEF ? 0 :
			    65535*(z-f->a->min_z)/(f->a->max_z-f->a->min_z);
			v[0] = g >> 8;
			v[1] = g;
			fwrite(v, 2, 1, file);
		}
	fclose(file);
}


static void sanitize(const char *s, char *res)
{
	while (*s) {
		if ((*s >= 'A' && *s <= 'Z') ||
		    (*s >= 'a' && *s <= 'z') ||
		    (*s >= '0' && *s <= '9') || *s == '_')
			*res = *s;
		else
			*res = '_';
		res++;
		s++;
	}
	*res = 0;
}


/*
 * For now, we put the part such that its x/y/z center is at the origin.
 * Later, we will also have to consider the changes the user made and the
 * relation with the opposing face.
 */

static void povray_face(const struct face *f, const char *side,
    const char *prefix, int flip, double dist)
{
	double a;

	/*
	 * 1/65535 = 0.000015..., so we set the water level a bit lower, e.g.,
	 * to 0.0001
	 */
	a = asin(-f->m.a[0][1])/M_PI*180;
        if (f->m.a[0][0] < 0)
                a = 180-a;
	printf(
"\theight_field {\n"
"\t    pgm \"%s-%s.pgm\"\n"
"\t    water_level 0.00001\n"
"\t    smooth\n"
"\t    scale <%g, %g, %g>	/* scale from unit cube to real size */\n"
"\t    rotate <90, 0, 0>	/* swap Y/Z axis */\n"
"\t    translate <%g, %g, 0>	/* move to X/Y center */\n"
"\t    rotate <%g, %g, 0>	/* z0 plane tilt */\n"
"\t    translate <0, 0, %g>	/* min_z offset */\n"
"\t    translate <0, 0, %g>	/* z0 plane offset */\n"
"\t    rotate <0, 0, %g>	/* overlay - rotation */\n"
"\t    translate <%g, %g, 0>	/* overlay - shift */\n"
"%s"	/* flip bottom face */
"\t    translate <0, 0, %g>	/* half the distance between faces */\n"
"\t}\n", prefix, side,
    f->sx*f->x_step, (f->sz-1)*f->z_step, f->sy*f->y_step,
    -f->sx*f->x_step/2, f->sy*f->y_step/2,
    -atan(f->fy)/M_PI*180, atan(f->fx)/M_PI*180,
    f->a->min_z*f->z_step,
    -f->z_ref*f->z_step,
    a,
    f->m.b[0]*f->x_step, f->m.b[1]*f->y_step,
    flip ? "\t    rotate <0, 180, 0>\t/* flip bottom face */\n" : "",
    dist*f->z_step);
}


void povray(const char *name, const struct solid *s)
{
	struct matrix m;
	char tmp[1000]; /* @@@ enough */

	m.a[0][0] = m.a[1][1] = 1;
	m.a[0][1] = m.a[1][0] = 0;
	m.b[0] = m.b[1] = 0;

	sprintf(tmp, "%s-top.pgm", name);
	height_field(tmp, s->a, &m);
	sprintf(tmp, "%s-bot.pgm", name);
	height_field(tmp, s->b, &m);

	sanitize(name, tmp);
	printf("#declare Part_%s =\n    intersection {\n", tmp);
	povray_face(s->a, "top", name, 0, s->dist/2);
	povray_face(s->b, "bot", name, 1, -s->dist/2);
	printf("    }\n");
}