shithub: libgraphics

Info  •  Files  •  Log

import the new renderer and clean things up.

i integrated the renderer i've been developing
on the tinyrend repo and got rid of a bunch of
stuff that's no longer necessary. also began
structuring things to fit the new interface i
have in mind.

there are still some artifacts with the
projection xforms that cause issues with
clipping and division by zero.

--- /dev/null

+++ b/alloc.c

@@ -1,0 +1,51 @@

+#include <u.h>

+#include <libc.h>

+#include <thread.h>

+#include <draw.h>

+#include <memdraw.h>

+#include <geometry.h>

+#include "libobj/obj.h"

+#include "graphics.h"

+#include "internal.h"

+

+void *

+emalloc(ulong n)

+{

+	void *p;

+

+	p = malloc(n);

+	if(p == nil)

+		sysfatal("malloc: %r");

+	setmalloctag(p, getcallerpc(&n));

+	return p;

+}

+

+void *

+erealloc(void *p, ulong n)

+{

+	void *np;

+

+	np = realloc(p, n);

+	if(np == nil){

+		if(n == 0)

+			return nil;

+		sysfatal("realloc: %r");

+	}

+	if(p == nil)

+		setmalloctag(np, getcallerpc(&p));

+	else

+		setrealloctag(np, getcallerpc(&p));

+	return np;

+}

+

+Memimage *

+eallocmemimage(Rectangle r, ulong chan)

+{

+	Memimage *i;

+

+	i = allocmemimage(r, chan);

+	if(i == nil)

+		sysfatal("allocmemimage: %r");

+	memfillcolor(i, DTransparent);

+	return i;

+}

--- a/camera.c

+++ b/camera.c

@@ -1,32 +1,41 @@

 #include <u.h>

 #include <libc.h>

+#include <thread.h>

 #include <draw.h>

+#include <memdraw.h>

 #include <geometry.h>

-#include <graphics.h>

+#include "libobj/obj.h"

+#include "graphics.h"

+#include "internal.h"

-static int

-max(int a, int b)

+static void

+updatestats(Camera *c, uvlong v)

 {

-	return a > b ? a : b;

+	c->stats.v = v;

+	c->stats.n++;

+	c->stats.acc += v;

+	c->stats.avg = c->stats.acc/c->stats.n;

+	c->stats.min = v < c->stats.min || c->stats.n == 1? v: c->stats.min;

+	c->stats.max = v > c->stats.max || c->stats.n == 1? v: c->stats.max;

 }

 static void

 verifycfg(Camera *c)

 {

-	assert(c->viewport != nil);

-	if(c->ptype == Ppersp)

+	assert(c->vp != nil);

+	if(c->projtype == PERSPECTIVE)

 		assert(c->fov > 0 && c->fov < 360*DEG);

 	assert(c->clip.n > 0 && c->clip.n < c->clip.f);

 }

 void

-configcamera(Camera *c, Image *v, double fov, double n, double f, Projection p)

+configcamera(Camera *c, Viewport *v, double fov, double n, double f, Projection p)

 {

-	c->viewport = v;

+	c->vp = v;

 	c->fov = fov;

 	c->clip.n = n;

 	c->clip.f = f;

-	c->ptype = p;

+	c->projtype = p;

 	reloadcamera(c);

 }

@@ -55,23 +64,37 @@

 	double l, r, b, t;

 	verifycfg(c);

-	switch(c->ptype){

-	case Portho:

+	switch(c->projtype){

+	case ORTHOGRAPHIC:

 		/*

-		r = Dx(c->viewport->r)/2;

-		t = Dy(c->viewport->r)/2;

+		r = Dx(c->vp->fbctl->fb[0]->r)/2;

+		t = Dy(c->vp->fbctl->fb[0]->r)/2;

 		l = -r;

 		b = -t;

 		*/

 		l = t = 0;

-		r = Dx(c->viewport->r);

-		b = Dy(c->viewport->r);

+		r = Dx(c->vp->fbctl->fb[0]->r);

+		b = Dy(c->vp->fbctl->fb[0]->r);

 		orthographic(c->proj, l, r, b, t, c->clip.n, c->clip.f);

 		break;

-	case Ppersp:

-		a = (double)Dx(c->viewport->r)/Dy(c->viewport->r);

+	case PERSPECTIVE:

+		a = (double)Dx(c->vp->fbctl->fb[0]->r)/Dy(c->vp->fbctl->fb[0]->r);

 		perspective(c->proj, c->fov, a, c->clip.n, c->clip.f);

 		break;

 	default: sysfatal("unknown projection type");

 	}

+}

+

+void

+shootcamera(Camera *c, OBJ *m, Memimage *tex, Shader *s)

+{

+	uvlong t0, t1;

+

+	c->vp->fbctl->reset(c->vp->fbctl);

+	t0 = nanosec();

+	shade(c->vp->fbctl->fb[c->vp->fbctl->idx^1], m, tex, s, 1);	/* address the back buffer */

+	t1 = nanosec();

+	c->vp->fbctl->swap(c->vp->fbctl);

+

+	updatestats(c, t1-t0);

 }

--- /dev/null

+++ b/fb.c

@@ -1,0 +1,81 @@

+#include <u.h>

+#include <libc.h>

+#include <thread.h>

+#include <draw.h>

+#include <memdraw.h>

+#include <geometry.h>

+#include "libobj/obj.h"

+#include "graphics.h"

+#include "internal.h"

+

+static void

+framebufctl_draw(Framebufctl *ctl, Memimage *dst)

+{

+	lock(&ctl->swplk);

+	memimagedraw(dst, dst->r, ctl->fb[ctl->idx]->cb, ZP, nil, ZP, SoverD);

+	unlock(&ctl->swplk);

+}

+

+static void

+framebufctl_swap(Framebufctl *ctl)

+{

+	lock(&ctl->swplk);

+	ctl->idx ^= 1;

+	unlock(&ctl->swplk);

+}

+

+static void

+framebufctl_reset(Framebufctl *ctl)

+{

+	Framebuf *fb;

+

+	/* address the back buffer—resetting the front buffer is VERBOTEN */

+	fb = ctl->fb[ctl->idx^1];

+	memsetd(fb->zbuf, Inf(-1), Dx(fb->r)*Dy(fb->r));

+	memfillcolor(fb->cb, DTransparent);

+}

+

+Framebuf *

+mkfb(Rectangle r)

+{

+	Framebuf *fb;

+

+	fb = emalloc(sizeof *fb);

+	memset(fb, 0, sizeof *fb);

+	fb->cb = eallocmemimage(r, RGBA32);

+	fb->zbuf = emalloc(Dx(r)*Dy(r)*sizeof(*fb->zbuf));

+	memsetd(fb->zbuf, Inf(-1), Dx(r)*Dy(r));

+	fb->r = r;

+	return fb;

+}

+

+void

+rmfb(Framebuf *fb)

+{

+	free(fb->zbuf);

+	freememimage(fb->cb);

+	free(fb);

+}

+

+Framebufctl *

+mkfbctl(Rectangle r)

+{

+	Framebufctl *fc;

+

+	fc = emalloc(sizeof *fc);

+	memset(fc, 0, sizeof *fc);

+	fc->fb[0] = mkfb(r);

+	fc->fb[1] = mkfb(r);

+	fc->draw = framebufctl_draw;

+	fc->swap = framebufctl_swap;

+	fc->reset = framebufctl_reset;

+	return fc;

+}

+

+void

+rmfbctl(Framebufctl *fc)

+{

+	rmfb(fc->fb[1]);

+	rmfb(fc->fb[0]);

+	free(fc);

+}

--- a/graphics.h

+++ b/graphics.h

@@ -1,18 +1,24 @@

+#define HZ2MS(hz)	(1000/(hz))

+

 typedef enum {

-	Portho,		/* orthographic */

-	Ppersp		/* perspective */

+	ORTHOGRAPHIC,

+	PERSPECTIVE

 } Projection;

 typedef struct Color Color;

 typedef struct Vertex Vertex;

-typedef struct Framebuffer Framebuffer;

+typedef struct VSparams VSparams;

+typedef struct FSparams FSparams;

+typedef struct SUparams SUparams;

+typedef struct Shader Shader;

+typedef struct Framebuf Framebuf;

+typedef struct Framebufctl Framebufctl;

 typedef struct Viewport Viewport;

 typedef struct Camera Camera;

-typedef struct Triangle Triangle;

 struct Color

 {

-	double r, g, b;

+	double r, g, b, a;

 };

 struct Vertex

@@ -23,61 +29,122 @@

 	Point2 uv;	/* texture coordinate */

 };

-struct Framebuffer

+typedef Vertex Triangle[3];

+

+/* shader params */

+struct VSparams

 {

-	Rectangle r;	/* frame geometry */

-	int bpp;	/* bytes per pixel */

-	uchar *color;	/* pixel color buffer */

-	float *depth;	/* pixel depth buffer */

+	SUparams *su;

+	Point3 *p;

+	Point3 *n;

+	uint idx;

 };

+struct FSparams

+{

+	SUparams *su;

+	Memimage *frag;

+	Point p;

+	Point3 bc;

+	uchar *cbuf;

+};

+

+/* shader unit params */

+struct SUparams

+{

+	Framebuf *fb;

+	OBJElem **b, **e;

+	int id;

+	Channel *donec;

+

+	/* TODO replace with a Scene */

+	OBJ *model;

+	Memimage *modeltex;

+

+	double var_intensity[3];

+

+	uvlong uni_time;

+

+	Point3 (*vshader)(VSparams*);

+	Memimage *(*fshader)(FSparams*);

+};

+

+struct Shader

+{

+	char *name;

+	Point3 (*vshader)(VSparams*);		/* vertex shader */

+	Memimage *(*fshader)(FSparams*);	/* fragment shader */

+};

+

+struct Framebuf

+{

+	Memimage *cb;	/* color buffer */

+	double *zbuf;	/* z/depth buffer */

+	Lock zbuflk;

+	Rectangle r;

+};

+

+struct Framebufctl

+{

+	Framebuf *fb[2];	/* double buffering */

+	uint idx;		/* front buffer index */

+	Lock swplk;

+

+	void (*draw)(Framebufctl*, Memimage*);

+	void (*swap)(Framebufctl*);

+	void (*reset)(Framebufctl*);

+};

+

 struct Viewport

 {

 	RFrame;

-	Framebuffer;

+	Framebufctl *fbctl;

 };

 struct Camera

 {

 	RFrame3;		/* VCS */

-	Image *viewport;

+	Viewport *vp;

 	double fov;		/* vertical FOV */

 	struct {

 		double n, f;	/* near and far clipping planes */

 	} clip;

 	Matrix3 proj;		/* VCS to NDC xform */

-	Projection ptype;

-};

+	Projection projtype;

-struct Triangle

-{

-	Point p0, p1, p2;

+	struct {

+		uvlong min, avg, max, acc, n, v;

+	} stats;

 };

-/* Camera */

-void configcamera(Camera*, Image*, double, double, double, Projection);

+/* camera */

+void configcamera(Camera*, Viewport*, double, double, double, Projection);

 void placecamera(Camera*, Point3, Point3, Point3);

 void aimcamera(Camera*, Point3);

 void reloadcamera(Camera*);

+void shootcamera(Camera*, OBJ*, Memimage*, Shader*);

-/* rendering */

-#define FPS	(60)		/* frame rate */

-#define MS2FR	(1e3/FPS)	/* ms per frame */

+/* viewport */

+Viewport *mkviewport(Rectangle);

+void rmviewport(Viewport*);

+

+/* render */

 Point3 world2vcs(Camera*, Point3);

 Point3 vcs2ndc(Camera*, Point3);

 Point3 world2ndc(Camera*, Point3);

-int isclipping(Point3);

-int clipline3(Point3*, Point3*);

-Point toviewport(Camera*, Point3);

-Point2 fromviewport(Camera*, Point);

+Point3 ndc2viewport(Camera*, Point3);

 void perspective(Matrix3, double, double, double, double);

 void orthographic(Matrix3, double, double, double, double, double, double);

-/* temporary debug helpers */

-void line3(Camera*, Point3, Point3, int, int, Image*);

-Point string3(Camera*, Point3, Image*, Font*, char*);

-/* triangle */

-Triangle Trian(int, int, int, int, int, int);

-Triangle Trianpt(Point, Point, Point);

-void triangle(Image*, Triangle, int, Image*, Point);

-void filltriangle(Image*, Triangle, Image*, Point);

+/* util */

+double fmin(double, double);

+double fmax(double, double);

+Memimage *rgb(ulong);

+Memimage *readtga(char*);

+Memimage *readpng(char*);

+

+/* shadeop */

+double step(double, double);

+double smoothstep(double, double, double);

+

+extern Rectangle UR;	/* unit rectangle */

--- /dev/null

+++ b/internal.h

@@ -1,0 +1,29 @@

+typedef struct Deco Deco;

+struct Deco

+{

+	int pfd[2];

+	int infd;

+	char *prog;

+};

+

+/* alloc */

+void *emalloc(ulong);

+void *erealloc(void*, ulong);

+Memimage *eallocmemimage(Rectangle, ulong);

+

+/* fb */

+Framebuf *mkfb(Rectangle);

+void rmfb(Framebuf*);

+Framebufctl *mkfbctl(Rectangle);

+void rmfbctl(Framebufctl*);

+

+/* render */

+void shade(Framebuf *fb, OBJ *model, Memimage *modeltex, Shader *s, ulong nprocs);

+

+/* util */

+int min(int, int);

+int max(int, int);

+void memsetd(double*, double, usize);

+

+/* nanosec */

+uvlong nanosec(void);

--- a/mkfile

+++ b/mkfile

@@ -3,9 +3,35 @@

 LIB=libgraphics.a$O

 OFILES=\

 	camera.$O\

+	viewport.$O\

 	render.$O\

-	triangle.$O\

+	alloc.$O\

+	fb.$O\

+	shadeop.$O\

+	util.$O\

+	nanosec.$O\

-HFILES=graphics.h

+HFILES=\

+	graphics.h\

+	internal.h\

+	libobj/obj.h

+UPDATE=\

+	mkfile\

+	$HFILES\

+	${OFILES:%.$O=%.c}\

+

 </sys/src/cmd/mklib

+

+libobj/libobj.a$O:

+	cd libobj

+	mk install

+

+pulldeps:VQ:

+	git/clone git://antares-labs.eu/libobj || \

+	git/clone git://shithub.us/rodri/libobj || \

+	git/clone https://github.com/sametsisartenep/libobj

+

+clean nuke:V:

+	rm -f *.[$OS] $LIB

+	@{cd libobj; mk $target}

--- /dev/null

+++ b/nanosec.c

@@ -1,0 +1,109 @@

+#include <u.h>

+#include <libc.h>

+#include <tos.h>

+

+/*

+ * This code is a mixture of cpuid(1) and the nanosec() found in vmx,

+ * in order to force the use of nsec(2) in case we are running in a

+ * virtualized environment where the clock is mis-bhyve-ing.

+ */

+

+typedef struct Res {

+	ulong ax, bx, cx, dx;

+} Res;

+

+static uchar _cpuid[] = {

+	0x5E,			/* POP SI (PC) */

+	0x5D,			/* POP BP (Res&) */

+	0x58,			/* POP AX */

+	0x59,			/* POP CX */

+

+	0x51,			/* PUSH CX */

+	0x50,			/* PUSH AX */

+	0x55,			/* PUSH BP */

+	0x56,			/* PUSH SI */

+

+	0x31, 0xDB,		/* XOR BX, BX */

+	0x31, 0xD2,		/* XOR DX, DX */

+

+	0x0F, 0xA2,		/* CPUID */

+

+	0x89, 0x45, 0x00,	/* MOV AX, 0(BP) */

+	0x89, 0x5d, 0x04,	/* MOV BX, 4(BP) */

+	0x89, 0x4d, 0x08,	/* MOV CX, 8(BP) */

+	0x89, 0x55, 0x0C,	/* MOV DX, 12(BP) */

+	0xC3,			/* RET */

+};

+

+static Res (*cpuid)(ulong ax, ulong cx) = (Res(*)(ulong, ulong)) _cpuid;

+

+/*

+ * nsec() is wallclock and can be adjusted by timesync

+ * so need to use cycles() instead, but fall back to

+ * nsec() in case we can't

+ */

+uvlong

+nanosec(void)

+{

+	static uvlong fasthz, xstart;

+	char buf[13], path[128];

+	ulong w;

+	uvlong x, div;

+	int fd;

+	Res r;

+

+	if(fasthz == ~0ULL)

+		return nsec() - xstart;

+

+	if(fasthz == 0){

+		/* first long in a.out header */

+		snprint(path, sizeof path, "/proc/%d/text", getpid());

+		fd = open(path, OREAD);

+		if(fd < 0)

+			goto Wallclock;

+		if(read(fd, buf, 4) != 4){

+			close(fd);

+			goto Wallclock;

+		}

+		close(fd);

+

+		w = ((ulong *) buf)[0];

+

+		switch(w){

+		default:

+			goto Wallclock;

+		case 0x978a0000:	/* amd64 */

+			/* patch out POP BP -> POP AX */

+			_cpuid[1] = 0x58;

+		case 0xeb010000:	/* 386 */

+			break;

+		}

+		segflush(_cpuid, sizeof(_cpuid));

+

+		r = cpuid(0x40000000, 0);

+		((ulong *) buf)[0] = r.bx;

+		((ulong *) buf)[1] = r.cx;

+		((ulong *) buf)[2] = r.dx;

+		buf[12] = 0;

+

+		if(strstr(buf, "bhyve") != nil)

+			goto Wallclock;

+

+		if(_tos->cyclefreq){

+			fasthz = _tos->cyclefreq;

+			cycles(&xstart);

+		} else {

+Wallclock:

+			fasthz = ~0ULL;

+			xstart = nsec();

+		}

+		return 0;

+	}

+	cycles(&x);

+	x -= xstart;

+

+	/* this is ugly */

+	for(div = 1000000000ULL; x < 0x1999999999999999ULL && div > 1 ; div /= 10ULL, x *= 10ULL);

+

+	return x / (fasthz / div);

+}

--- a/readme

+++ b/readme

@@ -1,6 +1,6 @@

 libgraphics

-Libgraphics provides 3D computer graphics through draw(3).

+Libgraphics provides 3D computer graphics through memdraw(2).

 Still in early stages of research, subject to change, drastically, at

 any given time.

--- a/render.c

+++ b/render.c

@@ -1,31 +1,85 @@

 #include <u.h>

 #include <libc.h>

+#include <thread.h>

 #include <draw.h>

+#include <memdraw.h>

 #include <geometry.h>

-#include <graphics.h>

+#include "libobj/obj.h"

+#include "graphics.h"

+#include "internal.h"

-static Point2

-flatten(Camera *c, Point3 p)

+Rectangle UR = {0,0,1,1};

+

+

+static void

+pixel(Memimage *dst, Point p, Memimage *src)

 {

-	Point2 p2;

-	Matrix S = {

-		Dx(c->viewport->r)/2, 0, 0,

-		0, Dy(c->viewport->r)/2, 0,

-		0, 0, 1,

-	}, T = {

-		1, 0, 1,

-		0, 1, 1,

-		0, 0, 1,

-	};

+	if(dst == nil || src == nil)

+		return;

-	p2 = Pt2(p.x, p.y, p.w);

-	if(p2.w != 0)

-		p2 = divpt2(p2, p2.w);

-	mulm(S, T);

-	p2 = xform(p2, S);

-	return p2;

+	memimagedraw(dst, rectaddpt(UR, p), src, ZP, nil, ZP, SoverD);

 }

+/*

+ * it only processes quads for now.

+ */

+static int

+triangulate(OBJElem **newe, OBJElem *e)

+{

+	OBJIndexArray *newidxtab;

+	OBJIndexArray *idxtab;

+

+	idxtab = &e->indextab[OBJVGeometric];

+	newe[0] = emalloc(sizeof *newe[0]);

+	newe[0]->type = OBJEFace;

+	newidxtab = &newe[0]->indextab[OBJVGeometric];

+	newidxtab->nindex = 3;

+	newidxtab->indices = emalloc(newidxtab->nindex*sizeof(*newidxtab->indices));

+	newidxtab->indices[0] = idxtab->indices[0];

+	newidxtab->indices[1] = idxtab->indices[1];

+	newidxtab->indices[2] = idxtab->indices[2];

+	idxtab = &e->indextab[OBJVTexture];

+	newidxtab = &newe[0]->indextab[OBJVTexture];

+	newidxtab->nindex = 3;

+	newidxtab->indices = emalloc(newidxtab->nindex*sizeof(*newidxtab->indices));

+	newidxtab->indices[0] = idxtab->indices[0];

+	newidxtab->indices[1] = idxtab->indices[1];

+	newidxtab->indices[2] = idxtab->indices[2];

+	idxtab = &e->indextab[OBJVNormal];

+	newidxtab = &newe[0]->indextab[OBJVNormal];

+	newidxtab->nindex = 3;

+	newidxtab->indices = emalloc(newidxtab->nindex*sizeof(*newidxtab->indices));

+	newidxtab->indices[0] = idxtab->indices[0];

+	newidxtab->indices[1] = idxtab->indices[1];

+	newidxtab->indices[2] = idxtab->indices[2];

+

+	idxtab = &e->indextab[OBJVGeometric];

+	newe[1] = emalloc(sizeof *newe[1]);

+	newe[1]->type = OBJEFace;

+	newidxtab = &newe[1]->indextab[OBJVGeometric];

+	newidxtab->nindex = 3;

+	newidxtab->indices = emalloc(newidxtab->nindex*sizeof(*newidxtab->indices));

+	newidxtab->indices[0] = idxtab->indices[0];

+	newidxtab->indices[1] = idxtab->indices[2];

+	newidxtab->indices[2] = idxtab->indices[3];

+	idxtab = &e->indextab[OBJVTexture];

+	newidxtab = &newe[1]->indextab[OBJVTexture];

+	newidxtab->nindex = 3;

+	newidxtab->indices = emalloc(newidxtab->nindex*sizeof(*newidxtab->indices));

+	newidxtab->indices[0] = idxtab->indices[0];

+	newidxtab->indices[1] = idxtab->indices[2];

+	newidxtab->indices[2] = idxtab->indices[3];

+	idxtab = &e->indextab[OBJVNormal];

+	newidxtab = &newe[1]->indextab[OBJVNormal];

+	newidxtab->nindex = 3;

+	newidxtab->indices = emalloc(newidxtab->nindex*sizeof(*newidxtab->indices));

+	newidxtab->indices[0] = idxtab->indices[0];

+	newidxtab->indices[1] = idxtab->indices[2];

+	newidxtab->indices[2] = idxtab->indices[3];

+

+	return 2;

+}

+

 Point3

 world2vcs(Camera *c, Point3 p)

 {

@@ -44,105 +98,22 @@

 	return vcs2ndc(c, world2vcs(c, p));

 }

-/* requires p to be in NDC */

-int

-isclipping(Point3 p)

+Point3

+ndc2viewport(Camera *c, Point3 p)

 {

-	if(p.x > p.w || p.x < -p.w ||

-	   p.y > p.w || p.y < -p.w ||

-	   p.z > p.w || p.z < 0)

-		return 1;

-	return 0;

-}

+	Matrix3 view;

-/* Liang-Barsky algorithm, requires p0, p1 to be in NDC */

-int

-clipline3(Point3 *p0, Point3 *p1)

-{

-	Point3 q0, q1, v;

-	int m0, m1, i;

-	double ti, to, th;

-	double c0[3*2] = {

-		p0->w + p0->x, p0->w - p0->x, p0->w + p0->y,

-		p0->w - p0->y,         p0->z, p0->w - p0->z,

-	}, c1[3*2] = {

-		p1->w + p1->x, p1->w - p1->x, p1->w + p1->y,

-		p1->w - p1->y,         p1->z, p1->w - p1->z,

-	};

+	identity3(view);

+	view[0][3] = c->vp->fbctl->fb[0]->r.max.x/2.0;

+	view[1][3] = c->vp->fbctl->fb[0]->r.max.y/2.0;

+	view[2][3] = 1.0/2.0;

+	view[0][0] = Dx(c->vp->fbctl->fb[0]->r)/2.0;

+	view[1][1] = -Dy(c->vp->fbctl->fb[0]->r)/2.0;

+	view[2][2] = 1.0/2.0;

-	/* bit-encoded regions */

-	m0 = (c0[0] < 0) << 0 |

-	     (c0[1] < 0) << 1 |

-	     (c0[2] < 0) << 2 |

-	     (c0[3] < 0) << 3 |

-	     (c0[4] < 0) << 4 |

-	     (c0[5] < 0) << 5;

-	m1 = (c1[0] < 0) << 0 |

-	     (c1[1] < 0) << 1 |

-	     (c1[2] < 0) << 2 |

-	     (c1[3] < 0) << 3 |

-	     (c1[4] < 0) << 4 |

-	     (c1[5] < 0) << 5;

-

-	if((m0 & m1) != 0)

-		return 1;	/* trivially rejected */

-	if((m0 | m1) == 0)

-		return 0;	/* trivially accepted */

-

-	ti = 0;

-	to = 1;

-	for(i = 0; i < 3*2; i++){

-		if(c1[i] < 0){

-			th = c0[i] / (c0[i]-c1[i]);

-			if(th < to)

-				to = th;

-		}else if(c0[i] < 0){

-			th = c0[i] / (c0[i]-c1[i]);

-			if(th < ti)

-				ti = th;

-		}

-		if(ti > to)

-			return 1;

-	}

-

-	/* chop line to fit inside NDC */

-	q0 = *p0;

-	q1 = *p1;

-	v = subpt3(q1, q0);

-	if(m0 != 0)

-		*p0 = addpt3(q0, mulpt3(v, ti));

-	if(m1 != 0)

-		*p1 = addpt3(q0, mulpt3(v, to));

-

-	return 0;

+	return xform3(p, view);

 }

-Point

-toviewport(Camera *c, Point3 p)

-{

-	Point2 p2;

-	RFrame rf = {

-		c->viewport->r.min.x, c->viewport->r.max.y, 1,

-		1, 0, 0,

-		0, -1, 0

-	};

-

-	p2 = invrframexform(flatten(c, p), rf);

-	return Pt(p2.x, p2.y);

-}

-

-Point2

-fromviewport(Camera *c, Point p)

-{

-	RFrame rf = {

-		c->viewport->r.min.x, c->viewport->r.max.y, 1,

-		1, 0, 0,

-		0, -1, 0

-	};

-

-	return rframexform(Pt2(p.x,p.y,1), rf);

-}

-

 void

 perspective(Matrix3 m, double fov, double a, double n, double f)

 {

@@ -152,7 +123,7 @@

 	identity3(m);

 	m[0][0] =  cotan/a;

 	m[1][1] =  cotan;

-	m[2][2] = -(f+n)/(f-n);

+	m[2][2] = (f+n)/(f-n);

 	m[2][3] = -2*f*n/(f-n);

 	m[3][2] = -1;

 }

@@ -169,21 +140,213 @@

 	m[2][3] = -(f + n)/(f - n);

 }

-void

-line3(Camera *c, Point3 p0, Point3 p1, int end0, int end1, Image *src)

+static void

+rasterize(SUparams *params, Triangle t, Memimage *frag)

 {

-	p0 = world2ndc(c, p0);

-	p1 = world2ndc(c, p1);

-	if(clipline3(&p0, &p1))

-		return;

-	line(c->viewport, toviewport(c, p0), toviewport(c, p1), end0, end1, 0, src, ZP);

+	FSparams fsp;

+	Triangle2 t₂, tt₂;

+	Rectangle bbox;

+	Point p, tp;

+	Point3 bc;

+	double z, w, depth;

+	uchar cbuf[4];

+

+	t₂.p0 = Pt2(t[0].p.x/t[0].p.w, t[0].p.y/t[0].p.w, 1);

+	t₂.p1 = Pt2(t[1].p.x/t[1].p.w, t[1].p.y/t[1].p.w, 1);

+	t₂.p2 = Pt2(t[2].p.x/t[2].p.w, t[2].p.y/t[2].p.w, 1);

+	/* find the triangle's bbox and clip it against the fb */

+	bbox = Rect(

+		min(min(t₂.p0.x, t₂.p1.x), t₂.p2.x), min(min(t₂.p0.y, t₂.p1.y), t₂.p2.y),

+		max(max(t₂.p0.x, t₂.p1.x), t₂.p2.x)+1, max(max(t₂.p0.y, t₂.p1.y), t₂.p2.y)+1

+	);

+	bbox.min.x = max(bbox.min.x, params->fb->r.min.x);

+	bbox.min.y = max(bbox.min.y, params->fb->r.min.y);

+	bbox.max.x = min(bbox.max.x, params->fb->r.max.x);

+	bbox.max.y = min(bbox.max.y, params->fb->r.max.y);

+	cbuf[0] = 0xFF;

+	fsp.su = params;

+	fsp.frag = frag;

+	fsp.cbuf = cbuf;

+

+	for(p.y = bbox.min.y; p.y < bbox.max.y; p.y++)

+		for(p.x = bbox.min.x; p.x < bbox.max.x; p.x++){

+			bc = barycoords(t₂, Pt2(p.x,p.y,1));

+			if(bc.x < 0 || bc.y < 0 || bc.z < 0)

+				continue;

+

+			z = t[0].p.z*bc.x + t[1].p.z*bc.y + t[2].p.z*bc.z;

+			w = t[0].p.w*bc.x + t[1].p.w*bc.y + t[2].p.w*bc.z;

+			depth = fclamp(z/w, 0, 1);

+			lock(&params->fb->zbuflk);

+			if(depth <= params->fb->zbuf[p.x + p.y*Dx(params->fb->r)]){

+				unlock(&params->fb->zbuflk);

+				continue;

+			}

+			params->fb->zbuf[p.x + p.y*Dx(params->fb->r)] = depth;

+			unlock(&params->fb->zbuflk);

+

+			cbuf[0] = 0xFF;

+			if((t[0].uv.w + t[1].uv.w + t[2].uv.w) != 0){

+				tt₂.p0 = mulpt2(t[0].uv, bc.x);

+				tt₂.p1 = mulpt2(t[1].uv, bc.y);

+				tt₂.p2 = mulpt2(t[2].uv, bc.z);

+

+				tp.x = (tt₂.p0.x + tt₂.p1.x + tt₂.p2.x)*Dx(params->modeltex->r);

+				tp.y = (1 - (tt₂.p0.y + tt₂.p1.y + tt₂.p2.y))*Dy(params->modeltex->r);

+

+				switch(params->modeltex->chan){

+				case RGB24:

+					unloadmemimage(params->modeltex, rectaddpt(UR, tp), cbuf+1, sizeof cbuf - 1);

+					break;

+				case RGBA32:

+					unloadmemimage(params->modeltex, rectaddpt(UR, tp), cbuf, sizeof cbuf);

+					break;

+				}

+			}else

+				memset(cbuf+1, 0xFF, sizeof cbuf - 1);

+

+			fsp.p = p;

+			fsp.bc = bc;

+			pixel(params->fb->cb, p, params->fshader(&fsp));

+		}

 }

-Point

-string3(Camera *c, Point3 p, Image *src, Font *f, char *s)

+static void

+shaderunit(void *arg)

 {

-	p = world2ndc(c, p);

-	if(isclipping(p))

-		return Pt(-1,-1);

-	return string(c->viewport, toviewport(c, p), src, ZP, f, s);

+	SUparams *params;

+	VSparams vsp;

+	Memimage *frag;

+	OBJVertex *verts, *tverts, *nverts;	/* geometric, texture and normals vertices */

+	OBJIndexArray *idxtab;

+	OBJElem **ep;

+	Triangle t;

+	Point3 n;				/* surface normal */

+

+	params = arg;

+	vsp.su = params;

+	frag = rgb(DBlack);

+

+	threadsetname("shader unit #%d", params->id);

+

+	verts = params->model->vertdata[OBJVGeometric].verts;

+	tverts = params->model->vertdata[OBJVTexture].verts;

+	nverts = params->model->vertdata[OBJVNormal].verts;

+

+	for(ep = params->b; ep != params->e; ep++){

+		idxtab = &(*ep)->indextab[OBJVGeometric];

+

+		t[0].p = Pt3(verts[idxtab->indices[0]].x,verts[idxtab->indices[0]].y,verts[idxtab->indices[0]].z,verts[idxtab->indices[0]].w);

+		t[1].p = Pt3(verts[idxtab->indices[1]].x,verts[idxtab->indices[1]].y,verts[idxtab->indices[1]].z,verts[idxtab->indices[1]].w);

+		t[2].p = Pt3(verts[idxtab->indices[2]].x,verts[idxtab->indices[2]].y,verts[idxtab->indices[2]].z,verts[idxtab->indices[2]].w);

+

+		idxtab = &(*ep)->indextab[OBJVNormal];

+		if(idxtab->nindex == 3){

+			t[0].n = Vec3(nverts[idxtab->indices[0]].i, nverts[idxtab->indices[0]].j, nverts[idxtab->indices[0]].k);

+			t[0].n = normvec3(t[0].n);

+			t[1].n = Vec3(nverts[idxtab->indices[1]].i, nverts[idxtab->indices[1]].j, nverts[idxtab->indices[1]].k);

+			t[1].n = normvec3(t[1].n);

+			t[2].n = Vec3(nverts[idxtab->indices[2]].i, nverts[idxtab->indices[2]].j, nverts[idxtab->indices[2]].k);

+			t[2].n = normvec3(t[2].n);

+		}else{

+			n = normvec3(crossvec3(subpt3(t[2].p, t[0].p), subpt3(t[1].p, t[0].p)));

+			t[0].n = t[1].n = t[2].n = mulpt3(n, -1);

+		}

+

+		vsp.p = &t[0].p;

+		vsp.n = &t[0].n;

+		vsp.idx = 0;

+		t[0].p = params->vshader(&vsp);

+		vsp.p = &t[1].p;

+		vsp.n = &t[1].n;

+		vsp.idx = 1;

+		t[1].p = params->vshader(&vsp);

+		vsp.p = &t[2].p;

+		vsp.n = &t[2].n;

+		vsp.idx = 2;

+		t[2].p = params->vshader(&vsp);

+

+		idxtab = &(*ep)->indextab[OBJVTexture];

+		if(params->modeltex != nil && idxtab->nindex == 3){

+			t[0].uv = Pt2(tverts[idxtab->indices[0]].u, tverts[idxtab->indices[0]].v, 1);

+			t[1].uv = Pt2(tverts[idxtab->indices[1]].u, tverts[idxtab->indices[1]].v, 1);

+			t[2].uv = Pt2(tverts[idxtab->indices[2]].u, tverts[idxtab->indices[2]].v, 1);

+		}else{

+			t[0].uv = t[1].uv = t[2].uv = Vec2(0,0);

+		}

+

+		rasterize(params, t, frag);

+	}

+

+	freememimage(frag);

+	sendp(params->donec, nil);

+	free(params);

+	threadexits(nil);

+}

+

+void

+shade(Framebuf *fb, OBJ *model, Memimage *modeltex, Shader *s, ulong nprocs)

+{

+	static int nparts, nworkers;

+	static OBJElem **elems = nil;

+	OBJElem *trielems[2];

+	int i, nelems;

+	uvlong time;

+	OBJObject *o;

+	OBJElem *e;

+	OBJIndexArray *idxtab;

+	SUparams *params;

+	Channel *donec;

+

+	if(elems == nil){

+		nelems = 0;

+		for(i = 0; i < nelem(model->objtab); i++)

+			for(o = model->objtab[i]; o != nil; o = o->next)

+				for(e = o->child; e != nil; e = e->next){

+					idxtab = &e->indextab[OBJVGeometric];

+					/* discard non-triangles */

+					if(e->type != OBJEFace || (idxtab->nindex != 3 && idxtab->nindex != 4))

+						continue;

+					if(idxtab->nindex == 4){

+						triangulate(trielems, e);

+						nelems += 2;

+						elems = erealloc(elems, nelems*sizeof(*elems));

+						elems[nelems-2] = trielems[0];

+						elems[nelems-1] = trielems[1];

+					}else{

+						elems = erealloc(elems, ++nelems*sizeof(*elems));

+						elems[nelems-1] = e;

+					}

+				}

+		if(nelems < nprocs){

+			nworkers = nelems;

+			nparts = 1;

+		}else{

+			nworkers = nprocs;

+			nparts = nelems/nprocs;

+		}

+	}

+	time = nanosec();

+

+	donec = chancreate(sizeof(void*), 0);

+

+	for(i = 0; i < nworkers; i++){

+		params = emalloc(sizeof *params);

+		params->fb = fb;

+		params->b = &elems[i*nparts];

+		params->e = params->b + nparts;

+		params->id = i;

+		params->donec = donec;

+		params->model = model;

+		params->modeltex = modeltex;

+		params->uni_time = time;

+		params->vshader = s->vshader;

+		params->fshader = s->fshader;

+		proccreate(shaderunit, params, mainstacksize);

+//		fprint(2, "spawned su %d for elems [%d, %d)\n", params->id, i*nparts, i*nparts+nparts);

+	}

+

+	while(i--)

+		recvp(donec);

+	chanfree(donec);

 }

--- /dev/null

+++ b/shadeop.c

@@ -1,0 +1,26 @@

+#include <u.h>

+#include <libc.h>

+#include <thread.h>

+#include <draw.h>

+#include <memdraw.h>

+#include <geometry.h>

+#include "libobj/obj.h"

+#include "graphics.h"

+#include "internal.h"

+

+double

+step(double edge, double n)

+{

+	if(n < edge)

+		return 0;

+	return 1;

+}

+

+double

+smoothstep(double edge0, double edge1, double n)

+{

+	double t;

+

+	t = fclamp((n-edge0)/(edge1-edge0), 0, 1);

+	return t*t * (3 - 2*t);

+}

--- a/triangle.c

+++ /dev/null

@@ -1,42 +1,0 @@

-#include <u.h>

-#include <libc.h>

-#include <draw.h>

-#include <geometry.h>

-#include <graphics.h>

-

-Triangle

-Trian(int x0, int y0, int x1, int y1, int x2, int y2)

-{

-	return (Triangle){Pt(x0, y0), Pt(x1, y1), Pt(x2, y2)};

-}

-

-Triangle

-Trianpt(Point p0, Point p1, Point p2)

-{

-	return (Triangle){p0, p1, p2};

-};

-

-void

-triangle(Image *dst, Triangle t, int thick, Image *src, Point sp)

-{

-	Point pl[4];

-

-	pl[0] = t.p0;

-	pl[1] = t.p1;

-	pl[2] = t.p2;

-	pl[3] = pl[0];

-

-	poly(dst, pl, nelem(pl), 0, 0, thick, src, sp);

-}

-

-void

-filltriangle(Image *dst, Triangle t, Image *src, Point sp)

-{

-	Point pl[3];

-

-	pl[0] = t.p0;

-	pl[1] = t.p1;

-	pl[2] = t.p2;

-

-	fillpoly(dst, pl, nelem(pl), 0, src, sp);

-}

--- /dev/null

+++ b/util.c

@@ -1,0 +1,108 @@

+#include <u.h>

+#include <libc.h>

+#include <thread.h>

+#include <draw.h>

+#include <memdraw.h>

+#include <geometry.h>

+#include "libobj/obj.h"

+#include "graphics.h"

+#include "internal.h"

+

+int

+min(int a, int b)

+{

+	return a < b? a: b;

+}

+

+int

+max(int a, int b)

+{

+	return a > b? a: b;

+}

+

+double

+fmin(double a, double b)

+{

+	return a < b? a: b;

+}

+

+double

+fmax(double a, double b)

+{

+	return a > b? a: b;

+}

+

+void

+memsetd(double *p, double v, usize len)

+{

+	double *dp;

+

+	for(dp = p; dp < p+len; dp++)

+		*dp = v;

+}

+

+Memimage *

+rgb(ulong c)

+{

+	Memimage *i;

+

+	i = eallocmemimage(UR, screen->chan);

+	i->flags |= Frepl;

+	i->clipr = Rect(-1e6, -1e6, 1e6, 1e6);

+	memfillcolor(i, c);

+	return i;

+}

+

+static void

+decproc(void *arg)

+{

+	char buf[32];

+	Deco *d;

+

+	d = arg;

+

+	close(d->pfd[0]);

+	dup(d->infd, 0);

+	close(d->infd);

+	dup(d->pfd[1], 1);

+	close(d->pfd[1]);

+

+	snprint(buf, sizeof buf, "/bin/%s", d->prog);

+

+	execl(buf, d->prog, "-9t", nil);

+	threadexitsall("execl: %r");

+}

+

+static Memimage *

+genreadimage(char *prog, char *path)

+{

+	Memimage *i;

+	Deco d;

+

+	d.prog = prog;

+

+	if(pipe(d.pfd) < 0)

+		sysfatal("pipe: %r");

+	d.infd = open(path, OREAD);

+	if(d.infd < 0)

+		sysfatal("open: %r");

+	procrfork(decproc, &d, mainstacksize, RFFDG|RFNAMEG|RFNOTEG);

+	close(d.pfd[1]);

+	i = readmemimage(d.pfd[0]);

+	close(d.pfd[0]);

+	close(d.infd);

+

+	return i;

+}

+

+Memimage *

+readtga(char *path)

+{

+	return genreadimage("tga", path);

+}

+

+Memimage *

+readpng(char *path)

+{

+	return genreadimage("png", path);

+}

--- /dev/null

+++ b/viewport.c

@@ -1,0 +1,29 @@

+#include <u.h>

+#include <libc.h>

+#include <thread.h>

+#include <draw.h>

+#include <memdraw.h>

+#include <geometry.h>

+#include "libobj/obj.h"

+#include "graphics.h"

+#include "internal.h"

+

+Viewport *

+mkviewport(Rectangle r)

+{

+	Viewport *v;

+

+	v = emalloc(sizeof *v);

+	v->p = Pt2(0,0,1);

+	v->bx = Vec2(1,0);

+	v->by = Vec2(0,1);

+	v->fbctl = mkfbctl(r);

+	return v;

+}

+

+void

+rmviewport(Viewport *v)

+{

+	rmfbctl(v->fbctl);

+	free(v);

+}