ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/rt/source.c

Comparing ray/src/rt/source.c (file contents):
Revision 2.56 by greg, Wed Jul 25 04:12:36 2007 UTC vs.
Revision 2.76 by greg, Mon Feb 1 16:19:49 2021 UTC

#	Line 9 | Line 9 | static const char RCSid[] = "$Id$";
9
10		#include  "ray.h"
11		#include  "otypes.h"
12	+	#include  "otspecial.h"
13		#include  "rtotypes.h"
14		#include  "source.h"
15		#include  "random.h"
16	+	#include  "pmapsrc.h"
17	+	#include  "pmapmat.h"
18
16	–	extern double  ssampdist;               /* scatter sampling distance */
17	–
19		#ifndef MAXSSAMP
20		#define MAXSSAMP        16              /* maximum samples per ray */
21		#endif
#	Line 42 | Line 43 | static int  maxcntr = 0;               /* size of contribution arra
43		static int cntcmp(const void *p1, const void *p2);
44
45
46	<	extern OBJREC *                 /* find an object's actual material */
46	<	findmaterial(register OBJREC *o)
47	<	{
48	<	while (!ismaterial(o->otype)) {
49	<	if (o->otype == MOD_ALIAS && o->oargs.nsargs) {
50	<	OBJECT  aobj;
51	<	OBJREC  *ao;
52	<	aobj = lastmod(objndx(o), o->oargs.sarg[0]);
53	<	if (aobj < 0)
54	<	objerror(o, USER, "bad reference");
55	<	ao = objptr(aobj);
56	<	if (ismaterial(ao->otype))
57	<	return(ao);
58	<	if (ao->otype == MOD_ALIAS) {
59	<	o = ao;
60	<	continue;
61	<	}
62	<	}
63	<	if (o->omod == OVOID)
64	<	return(NULL);
65	<	o = objptr(o->omod);
66	<	}
67	<	return(o);              /* mixtures will return NULL */
68	<	}
69	<
70	<
71	<	extern void
46	>	void
47		marksources(void)                       /* find and mark source objects */
48		{
49		int  foundsource = 0;
50		int  i;
51	<	register OBJREC  *o, *m;
52	<	register int  ns;
51	>	OBJREC  *o, *m;
52	>	int  ns;
53		/* initialize dispatch table */
54		initstypes();
55		/* find direct sources */
#	Line 85 | Line 60 | marksources(void)                      /* find and mark source objects */
60		if (!issurface(o->otype) || o->omod == OVOID)
61		continue;
62		/* find material */
63	<	m = findmaterial(objptr(o->omod));
63	>	m = findmaterial(o);
64		if (m == NULL)
65		continue;
66		if (m->otype == MAT_CLIP) {
#	Line 99 | Line 74 | marksources(void)                      /* find and mark source objects */
74		m->otype == MAT_SPOT ? 7 : 3))
75		objerror(m, USER, "bad # arguments");
76
77	+	if (m->oargs.farg[0] <= FTINY && (m->oargs.farg[1] <= FTINY) &
78	+	(m->oargs.farg[2] <= FTINY))
79	+	continue;                       /* don't bother */
80		if (m->otype == MAT_GLOW &&
81		o->otype != OBJ_SOURCE &&
82	<	m->oargs.farg[3] <= FTINY)
83	<	continue;                       /* don't bother */
84	<	if (m->oargs.farg[0] <= FTINY && m->oargs.farg[1] <= FTINY &&
85	<	m->oargs.farg[2] <= FTINY)
108	<	continue;                       /* don't bother */
109	<
82	>	m->oargs.farg[3] <= FTINY) {
83	>	foundsource += (ambounce > 0);
84	>	continue;                       /* don't track these */
85	>	}
86		if (sfun[o->otype].of == NULL ||
87		sfun[o->otype].of->setsrc == NULL)
88		objerror(o, USER, "illegal material");
#	Line 119 | Line 95 | marksources(void)                      /* find and mark source objects */
95		if (m->otype == MAT_GLOW) {
96		source[ns].sflags |= SPROX;
97		source[ns].sl.prox = m->oargs.farg[3];
98	<	if (source[ns].sflags & SDISTANT)
98	>	if (source[ns].sflags & SDISTANT) {
99		source[ns].sflags |= SSKIP;
100	+	foundsource += (ambounce > 0);
101	+	}
102		} else if (m->otype == MAT_SPOT) {
103	+	if (source[ns].sflags & SDISTANT)
104	+	objerror(o, WARNING,
105	+	"distant source is a spotlight");
106		source[ns].sflags |= SSPOT;
107		if ((source[ns].sl.s = makespot(m)) == NULL)
108		goto memerr;
#	Line 132 | Line 113 | marksources(void)                      /* find and mark source objects */
113		source[ns].sflags |= SSKIP;
114		}
115		}
116	<	#if  SHADCACHE
136	<	initobscache(ns);
137	<	#endif
138	<	if (!(source[ns].sflags & SSKIP))
139	<	foundsource++;
116	>	foundsource += !(source[ns].sflags & SSKIP);
117		}
118		if (!foundsource) {
119		error(WARNING, "no light sources found");
120		return;
121		}
122	<	markvirtuals();                 /* find and add virtual sources */
122	>	#if  SHADCACHE
123	>	for (ns = 0; ns < nsources; ns++)       /* initialize obstructor cache */
124	>	initobscache(ns);
125	>	#endif
126	>	/* PMAP: disable virtual sources */
127	>	if (!photonMapping)
128	>	markvirtuals();                 /* find and add virtual sources */
129	>
130		/* allocate our contribution arrays */
131		maxcntr = nsources + MAXSPART;  /* start with this many */
132		srccnt = (CONTRIB *)malloc(maxcntr*sizeof(CONTRIB));
133		cntord = (CNTPTR *)malloc(maxcntr*sizeof(CNTPTR));
134	<	if ((srccnt == NULL) | (cntord == NULL))
135	<	goto memerr;
152	<	return;
134	>	if ((srccnt != NULL) & (cntord != NULL))
135	>	return;
136		memerr:
137		error(SYSTEM, "out of memory in marksources");
138		}
139
140
141	<	extern void
141	>	void
142	>	distantsources(void)                    /* only mark distant sources */
143	>	{
144	>	int  i;
145	>	OBJREC  *o, *m;
146	>	int  ns;
147	>	/* initialize dispatch table */
148	>	initstypes();
149	>	/* sources needed for sourcehit() */
150	>	for (i = 0; i < nsceneobjs; i++) {
151	>
152	>	o = objptr(i);
153	>
154	>	if ((o->otype != OBJ_SOURCE) | (o->omod == OVOID))
155	>	continue;
156	>	/* find material */
157	>	m = findmaterial(o);
158	>	if (m == NULL)
159	>	continue;
160	>	if (!islight(m->otype))
161	>	continue;       /* not source modifier */
162	>
163	>	if (m->oargs.nfargs != (m->otype == MAT_GLOW ? 4 :
164	>	m->otype == MAT_SPOT ? 7 : 3))
165	>	objerror(m, USER, "bad # arguments");
166	>
167	>	if (m->oargs.farg[0] <= FTINY && (m->oargs.farg[1] <= FTINY) &
168	>	(m->oargs.farg[2] <= FTINY))
169	>	continue;                       /* don't bother */
170	>	if (sfun[o->otype].of == NULL ||
171	>	sfun[o->otype].of->setsrc == NULL)
172	>	objerror(o, USER, "illegal material");
173	>
174	>	if ((ns = newsource()) < 0)
175	>	error(SYSTEM, "out of memory in distantsources");
176	>
177	>	setsource(&source[ns], o);
178	>
179	>	if (m->otype == MAT_GLOW) {
180	>	source[ns].sflags |= SPROX|SSKIP;
181	>	source[ns].sl.prox = m->oargs.farg[3];
182	>	} else if (m->otype == MAT_SPOT)
183	>	objerror(o, WARNING, "distant source is a spotlight");
184	>	}
185	>	}
186	>
187	>
188	>	void
189		freesources(void)                       /* free all source structures */
190		{
191		if (nsources > 0) {
#	Line 167 | Line 197 | freesources(void)                      /* free all source structures */
197		source = NULL;
198		nsources = 0;
199		}
200	+	markclip(NULL);
201		if (maxcntr <= 0)
202		return;
203		free((void *)srccnt);
#	Line 177 | Line 208 | freesources(void)                      /* free all source structures */
208		}
209
210
211	<	extern int
211	>	int
212		srcray(                         /* send a ray to a source, return domega */
213	<	register RAY  *sr,              /* returned source ray */
213	>	RAY  *sr,               /* returned source ray */
214		RAY  *r,                        /* ray which hit object */
215		SRCINDEX  *si                   /* source sample index */
216		)
217		{
218	<	double  d;                          /* distance to source */
219	<	register SRCREC  *srcp;
218	>	double  d;                              /* distance to source */
219	>	SRCREC  *srcp;
220
221	<	rayorigin(sr, SHADOW, r, NULL);             /* ignore limits */
221	>	rayorigin(sr, SHADOW, r, NULL);         /* ignore limits */
222
223	<	while ((d = nextssamp(sr, si)) != 0.0) {
224	<	sr->rsrc = si->sn;                      /* remember source */
225	<	srcp = source + si->sn;
226	<	if (srcp->sflags & SDISTANT) {
227	<	if (srcp->sflags & SSPOT && spotout(sr, srcp->sl.s))
228	<	continue;
229	<	return(1);              /* sample OK */
230	<	}
223	>	if (r == NULL)
224	>	sr->rmax = 0.0;
225	>
226	>	while ((d = nextssamp(sr, si)) != 0.0) {
227	>	sr->rsrc = si->sn;                      /* remember source */
228	>	srcp = source + si->sn;
229	>	if (srcp->sflags & SDISTANT) {
230	>	if (srcp->sflags & SSPOT && spotout(sr, srcp->sl.s))
231	>	continue;
232	>	return(1);              /* sample OK */
233	>	}
234		/* local source */
235		/* check proximity */
236	<	if (srcp->sflags & SPROX && d > srcp->sl.prox)
203	<	continue;
204	<	/* check angle */
205	<	if (srcp->sflags & SSPOT) {
206	<	if (spotout(sr, srcp->sl.s))
236	>	if (srcp->sflags & SPROX && d > srcp->sl.prox)
237		continue;
238	+	/* check angle */
239	+	if (srcp->sflags & SSPOT) {
240	+	if (spotout(sr, srcp->sl.s))
241	+	continue;
242		/* adjust solid angle */
243	<	si->dom *= d*d;
244	<	d += srcp->sl.s->flen;
245	<	si->dom /= d*d;
243	>	si->dom *= d*d;
244	>	d += srcp->sl.s->flen;
245	>	si->dom /= d*d;
246	>	}
247	>	return(1);                      /* sample OK */
248		}
249	<	return(1);                      /* sample OK */
214	<	}
215	<	return(0);                  /* no more samples */
249	>	return(0);                      /* no more samples */
250		}
251
252
253	<	extern void
253	>	void
254		srcvalue(                       /* punch ray to source and compute value */
255	<	register RAY  *r
255	>	RAY  *r
256		)
257		{
258	<	register SRCREC  *sp;
258	>	SRCREC  *sp;
259
260		sp = &source[r->rsrc];
261		if (sp->sflags & SVIRTUAL) {    /* virtual source */
#	Line 260 | Line 294 | nomat:
294
295		static int
296		transillum(                     /* check if material is transparent illum */
297	<	OBJECT  obj
297	>	OBJREC *m
298		)
299		{
300	<	OBJREC *m = findmaterial(objptr(obj));
267	<
300	>	m = findmaterial(m);
301		if (m == NULL)
302		return(1);
303		if (m->otype != MAT_ILLUM)
#	Line 273 | Line 306 | transillum(                    /* check if material is transparent illu
306		}
307
308
309	<	extern int
309	>	int
310		sourcehit(                      /* check to see if ray hit distant source */
311	<	register RAY  *r
311	>	RAY  *r
312		)
313		{
314		int  glowsrc = -1;
315		int  transrc = -1;
316		int  first, last;
317	<	register int  i;
317	>	int  i;
318
319		if (r->rsrc >= 0) {             /* check only one if aimed */
320		first = last = r->rsrc;
#	Line 306 | Line 339 | sourcehit(                     /* check to see if ray hit distant source
339		* If it's a glow or transparent illum, just remember it.
340		*/
341		if (source[i].sflags & SSKIP) {
342	<	glowsrc = i;
342	>	if (glowsrc < 0)
343	>	glowsrc = i;
344		continue;
345		}
346	<	if (transillum(source[i].so->omod)) {
347	<	transrc = i;
346	>	if (transillum(source[i].so)) {
347	>	if (transrc < 0)
348	>	transrc = i;
349		continue;
350		}
351		r->ro = source[i].so;   /* otherwise, use first hit */
#	Line 328 | Line 363 | sourcehit(                     /* check to see if ray hit distant source
363		return(0);      /* nothing usable */
364		}
365		/*
366	<	* Make assignments.
366	>	* Assign object index
367		*/
368		r->robj = objndx(r->ro);
334	–	for (i = 0; i < 3; i++)
335	–	r->ron[i] = -r->rdir[i];
336	–	r->rod = 1.0;
337	–	r->pert[0] = r->pert[1] = r->pert[2] = 0.0;
338	–	r->uv[0] = r->uv[1] = 0.0;
339	–	r->rox = NULL;
369		return(1);
370		}
371
#	Line 347 | Line 376 | cntcmp(                                /* contribution compare (descending) */
376		const void *p2
377		)
378		{
379	<	register const CNTPTR  *sc1 = (const CNTPTR *)p1;
380	<	register const CNTPTR  *sc2 = (const CNTPTR *)p2;
379	>	const CNTPTR  *sc1 = (const CNTPTR *)p1;
380	>	const CNTPTR  *sc2 = (const CNTPTR *)p2;
381
382		if (sc1->brt > sc2->brt)
383		return(-1);
#	Line 358 | Line 387 | cntcmp(                                /* contribution compare (descending) */
387		}
388
389
390	<	extern void
390	>	void
391		direct(                                 /* add direct component */
392		RAY  *r,                        /* ray that hit surface */
393		srcdirf_t *f,                   /* direct component coefficient function */
394		void  *p                        /* data for f */
395		)
396		{
397	<	register int  sn;
398	<	register CONTRIB  *scp;
397	>	int  sn;
398	>	CONTRIB  *scp;
399		SRCINDEX  si;
400		int  nshadcheck, ncnts;
401		int  nhits;
402		double  prob, ourthresh, hwt;
403		RAY  sr;
404	+
405	+	/* PMAP: Factor in direct photons (primarily for debugging/validation) */
406	+	if (directPhotonMapping) {
407	+	(*f)(r -> rcol, p, r -> ron, PI);
408	+	multDirectPmap(r);
409	+	return;
410	+	}
411	+
412		/* NOTE: srccnt and cntord global so no recursion */
413		if (nsources <= 0)
414		return;         /* no sources?! */
#	Line 390 | Line 427 | direct(                                        /* add direct component */
427		cntord[sn].sndx = sn;
428		scp = srccnt + sn;
429		scp->sno = sr.rsrc;
430	<	/* compute coefficient */
394	<	(*f)(scp->coef, p, sr.rdir, si.dom);
395	<	cntord[sn].brt = intens(scp->coef);
396	<	if (cntord[sn].brt <= 0.0)
397	<	continue;
398	<	#if SHADCACHE
399	<	/* check shadow cache */
430	>	#if SHADCACHE                                   /* check shadow cache */
431		if (si.np == 1 && srcblocked(&sr)) {
432		cntord[sn].brt = 0.0;
433		continue;
434		}
435		#endif
436	+	/* compute coefficient */
437	+	(*f)(scp->coef, p, sr.rdir, si.dom);
438	+	cntord[sn].brt = intens(scp->coef);
439	+	if (cntord[sn].brt <= 0.0)
440	+	continue;
441		VCOPY(scp->dir, sr.rdir);
442		copycolor(sr.rcoef, scp->coef);
443		/* compute potential */
#	Line 409 | Line 445 | direct(                                        /* add direct component */
445		rayvalue(&sr);
446		multcolor(sr.rcol, sr.rcoef);
447		copycolor(scp->val, sr.rcol);
448	<	cntord[sn].brt = intens(sr.rcol);
448	>	cntord[sn].brt = bright(sr.rcol);
449		}
450		/* sort contributions */
451		qsort(cntord, sn, sizeof(CNTPTR), cntcmp);
452		{                                       /* find last */
453	<	register int  l, m;
453	>	int  l, m;
454
455		ncnts = l = sn;
456		sn = 0;
#	Line 441 | Line 477 | direct(                                        /* add direct component */
477		(double)source[scp->sno].ntests,
478		sn++) {
479		/* check threshold */
480	<	if ((sn+nshadcheck>=ncnts ? cntord[sn].brt :
480	>	if (sn >= MINSHADCNT &&
481	>	(sn+nshadcheck>=ncnts ? cntord[sn].brt :
482		cntord[sn].brt-cntord[sn+nshadcheck].brt)
483	<	< ourthresh*bright(r->rcol))
483	>	< ourthresh*bright(r->rcol))
484		break;
485		scp = srccnt + cntord[sn].sndx;
486		/* test for hit */
#	Line 509 | Line 546 | direct(                                        /* add direct component */
546		}
547
548
549	<	extern void
549	>	void
550		srcscatter(                     /* compute source scattering into ray */
551	<	register RAY  *r
551	>	RAY  *r
552		)
553		{
554		int  oldsampndx;
#	Line 523 | Line 560 | srcscatter(                    /* compute source scattering into ray */
560		COLOR  cvext;
561		int  i, j;
562
563	<	if (r->slights == NULL || r->slights[0] == 0
564	<	|| r->gecc >= 1.-FTINY || r->rot >= FHUGE)
563	>	if (r->rot >= FHUGE*.99 || r->gecc >= 1.-FTINY)
564	>	return;         /* this can never work */
565	>	/* PMAP: do unconditional inscattering for volume photons */
566	>	if (!volumePhotonMapping && (r->slights == NULL || r->slights[0] == 0))
567		return;
568	+
569		if (ssampdist <= FTINY || (nsamps = r->rot/ssampdist + .5) < 1)
570		nsamps = 1;
571		#if MAXSSAMP
#	Line 534 | Line 574 | srcscatter(                    /* compute source scattering into ray */
574		#endif
575		oldsampndx = samplendx;
576		samplendx = random()&0x7fff;            /* randomize */
577	<	for (i = r->slights[0]; i > 0; i--) {   /* for each source */
577	>	for (i = volumePhotonMapping ? 1 : r->slights[0]; i > 0; i--) {
578	>	/* for each source OR once if volume photon map enabled */
579		for (j = 0; j < nsamps; j++) {  /* for each sample position */
580		samplendx++;
581		t = r->rot * (j+frandom())/nsamps;
#	Line 550 | Line 591 | srcscatter(                    /* compute source scattering into ray */
591		sr.rorg[0] = r->rorg[0] + r->rdir[0]*t;
592		sr.rorg[1] = r->rorg[1] + r->rdir[1]*t;
593		sr.rorg[2] = r->rorg[2] + r->rdir[2]*t;
594	<	sr.rmax = 0.;
595	<	initsrcindex(&si);      /* sample ray to this source */
596	<	si.sn = r->slights[i];
597	<	nopart(&si, &sr);
598	<	if (!srcray(&sr, NULL, &si) ||
599	<	sr.rsrc != r->slights[i])
600	<	continue;               /* no path */
594	>
595	>	if (!volumePhotonMapping) {
596	>	initsrcindex(&si);      /* sample ray to this source */
597	>	si.sn = r->slights[i];
598	>	nopart(&si, &sr);
599	>	if (!srcray(&sr, NULL, &si) ||
600	>	sr.rsrc != r->slights[i])
601	>	continue;       /* no path */
602		#if SHADCACHE
603	<	if (srcblocked(&sr))            /* check shadow cache */
604	<	continue;
603	>	if (srcblocked(&sr))    /* check shadow cache */
604	>	continue;
605		#endif
606	<	copycolor(sr.cext, r->cext);
607	<	copycolor(sr.albedo, r->albedo);
608	<	sr.gecc = r->gecc;
609	<	sr.slights = r->slights;
610	<	rayvalue(&sr);                  /* eval. source ray */
611	<	if (bright(sr.rcol) <= FTINY) {
606	>	copycolor(sr.cext, r->cext);
607	>	copycolor(sr.albedo, r->albedo);
608	>	sr.gecc = r->gecc;
609	>	sr.slights = r->slights;
610	>	rayvalue(&sr);          /* eval. source ray */
611	>	if (bright(sr.rcol) <= FTINY) {
612		#if SHADCACHE
613	<	srcblocker(&sr);        /* add blocker to cache */
613	>	srcblocker(&sr); /* add blocker to cache */
614		#endif
615	<	continue;
616	<	}
617	<	if (r->gecc <= FTINY)           /* compute P(theta) */
618	<	d = 1.;
619	<	else {
620	<	d = DOT(r->rdir, sr.rdir);
621	<	d = 1. + r->gecc*r->gecc - 2.*r->gecc*d;
622	<	d = (1. - r->gecc*r->gecc) / (d*sqrt(d));
623	<	}
615	>	continue;
616	>	}
617	>	if (r->gecc <= FTINY)   /* compute P(theta) */
618	>	d = 1.;
619	>	else {
620	>	d = DOT(r->rdir, sr.rdir);
621	>	d = 1. + r->gecc*r->gecc - 2.*r->gecc*d;
622	>	d = (1. - r->gecc*r->gecc) / (d*sqrt(d));
623	>	}
624		/* other factors */
625	<	d *= si.dom * r->rot / (4.*PI*nsamps);
625	>	d *= si.dom * r->rot / (4.*PI*nsamps);
626	>	scalecolor(sr.rcol, d);
627	>	} else {
628	>	/* PMAP: Add ambient inscattering from
629	>	* volume photons; note we reverse the
630	>	* incident ray direction since we're
631	>	* now in *backward* raytracing mode! */
632	>	sr.rdir [0] = -r -> rdir [0];
633	>	sr.rdir [1] = -r -> rdir [1];
634	>	sr.rdir [2] = -r -> rdir [2];
635	>	sr.gecc = r -> gecc;
636	>	inscatterVolumePmap(&sr, sr.rcol);
637	>	scalecolor(sr.rcol, r -> rot / nsamps);
638	>	}
639		multcolor(sr.rcol, r->cext);
640		multcolor(sr.rcol, r->albedo);
586	–	scalecolor(sr.rcol, d);
641		multcolor(sr.rcol, cvext);
642		addcolor(r->rcol, sr.rcol);     /* add it in */
643		}
#	Line 609 | Line 663 | srcscatter(                    /* compute source scattering into ray */
663		*/
664
665		static int
666	<	weaksrcmat(OBJECT obj)          /* identify material */
666	>	weaksrcmat(OBJREC *m)           /* identify material */
667		{
668	<	OBJREC *m = findmaterial(objptr(obj));
615	<
668	>	m = findmaterial(m);
669		if (m == NULL) return(0);
670		return((m->otype==MAT_ILLUM) | (m->otype==MAT_GLOW));
671		}
672
673		#define  illumblock(m, r)       (!(source[r->rsrc].sflags&SVIRTUAL) && \
674		r->rod > 0.0 && \
675	<	weaksrcmat(source[r->rsrc].so->omod))
675	>	weaksrcmat(source[r->rsrc].so))
676
677		/* wrongsource *
678		*
#	Line 650 | Line 703 | weaksrcmat(OBJECT obj)         /* identify material */
703		* The same is true for stray specular samples, since the specular
704		* contribution from light sources is calculated separately.
705		*/
706	<
707	<	#define  badcomponent(m, r)     (r->crtype&(AMBIENT|SPECULAR) && \
706	>	/* PMAP: Also avoid counting sources via transferred ambient rays (e.g.
707	>	* through glass) when photon mapping is enabled, as these indirect
708	>	* components are already accounted for.
709	>	*/
710	>	#define  badcomponent(m, r)   (srcRayInPmap(r) || \
711	>	(r->crtype&(AMBIENT|SPECULAR) && \
712		!(r->crtype&SHADOW || r->rod < 0.0 || \
713	<	/* not 100% correct */  distglow(m, r, r->rot)))
713	>	/* not 100% correct */  distglow(m, r, r->rot))))
714
715		/* passillum *
716		*
#	Line 675 | Line 732 | weaksrcmat(OBJECT obj)         /* identify material */
732		distglow(m, r, raydist(r,PRIMARY)))
733
734
735	<	extern int
735	>	int
736		m_light(                                /* ray hit a light source */
737	<	register OBJREC  *m,
738	<	register RAY  *r
737	>	OBJREC  *m,
738	>	RAY  *r
739		)
740		{
741		/* check for over-counting */

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)