romdev-mcp 0.1.1

package/src/platforms/gba/lib/libtonc/src/tonc_color.c

@@ -0,0 +1,368 @@
+//
+//  Some interesting color routines
+//
+//! \file tonc_color.c
+//! \author J Vijn
+//! \date 20070823 - 20070907
+//
+// === NOTES ===
+
+#include "tonc_memmap.h"
+#include "tonc_video.h"
+#include "tonc_bios.h"
+#include "tonc_math.h"
+
+
+// --------------------------------------------------------------------
+// FUNCTIONS 
+// --------------------------------------------------------------------
+
+
+//! Rotate \a nclrs colors at \a clrs to the right by \a ror.
+/*!	\note I can't help but think there's a faster way ... I just can't 
+		see it atm.
+*/
+void clr_rotate(COLOR *clrs, uint nclrs, int ror)
+{
+	if(ror == 0)		// Nothing to do
+		return;
+
+	int ii, jj, rot;
+	u32 tmp;
+
+	// NOTE: 
+	// Yes, this is O(n^2)
+	// Two optimisations are possible for |ror|>1
+	// 1) Extra buffer (simply write at an offset) O(n)
+	// 2) Double loops (ror and nclrs/ror) steps), run recursively 
+	//	  with nclrs=nclrs-nclrs%ror, ror=nclrs-nclrs%ror. O(n)*log(n) ?
+
+	if(ror > 0)			// Rotate right
+	{
+		rot= ror;
+		if(rot > nclrs)
+			rot= Mod(rot, nclrs);
+		for(ii=0; ii<rot; ii++)
+		{
+			tmp= clrs[nclrs-1];
+			for(jj=nclrs-1; jj>0; jj--)
+				clrs[jj]= clrs[jj-1];
+			clrs[0]= tmp;
+		}	
+	}
+	else				// Rotate left
+	{
+		rot= nclrs-ror;
+		if(rot > nclrs)
+			rot= Mod(rot, nclrs);
+		for(ii=0; ii<rot; ii++)
+		{
+			tmp= clrs[0];
+			for(jj=0; jj<nclrs-1; jj++)
+				clrs[jj]= clrs[jj+1];
+			clrs[nclrs-1]= tmp;
+		}
+	}	
+}
+
+
+//!	Blends color arrays \a srca and \a srcb into \a dst.
+/*!	Specific transitional blending effects can be created by making 
+	a 'target' color array with other routines, then using \a alpha 
+	to morph into it.
+	\param srca	Source array A.
+	\param srcb	Source array B
+	\param dst	Destination array.
+	\param nclrs	Number of colors.
+	\param alpha	Blend weight (range: 0-32). 0 Means full \a srca
+*/
+void clr_blend(const COLOR *srca, const COLOR *srcb, COLOR *dst, 
+		uint nclrs, u32 alpha)
+{
+	if(!nclrs)
+		return;
+
+	int ii;
+	u32 clra, clrb, clr;
+	u32 parta, partb, part;
+	const u32 rbmask= (RED_MASK|BLUE_MASK), gmask= GREEN_MASK;
+	const u32 rbhalf= 0x4010, ghalf= 0x0200;
+
+	for(ii=0; ii<nclrs; ii++)
+	{
+		clra= srca[ii];
+		clrb= srcb[ii];
+		
+		// Red and blue
+		parta= clra & rbmask;
+		partb= clrb & rbmask;
+		part = (partb-parta)*alpha + parta*32 + rbhalf;
+		clr  = (part/32 ) & rbmask;
+
+		// Green
+		parta= clra & gmask;
+		partb= clrb & gmask;
+		part = (partb-parta)*alpha + parta*32 + ghalf;
+		clr |= (part/32 ) & gmask;
+
+		dst[ii]= clr;
+	}
+}
+
+//!	Fades color arrays \a srca to \a clr into \a dst.
+/*!
+	\param src	Source array.
+	\param clr	Final color (at alpha=32).
+	\param dst	Destination array.
+	\param nclrs	Number of colors.
+	\param alpha	Blend weight (range: 0-32). 0 Means full \a srca
+*/
+void clr_fade(const COLOR *src, COLOR clr, COLOR *dst, 
+		uint nclrs, u32 alpha)
+{
+	if(!nclrs)
+		return;
+
+	int ii;
+	u32 clra, parta, part;
+	const u32 rbmask= (RED_MASK|BLUE_MASK), gmask= GREEN_MASK;
+	const u32 rbhalf= 0x4010, ghalf= 0x0200;
+
+	// precalc color B parts
+	u32 partb_rb= clr & rbmask, partb_g= clr & gmask;
+
+	for(ii=0; ii<nclrs; ii++)
+	{
+		clra= src[ii];
+
+		// Red and blue
+		parta= clra & rbmask;
+		part = (partb_rb-parta)*alpha + parta*32 + rbhalf;
+		clr  = (part/32) & rbmask;
+
+		// Green
+		parta= clra & gmask;
+		part = (partb_g-parta)*alpha + parta*32 + ghalf;
+		clr |= (part/32) & gmask;
+
+		dst[ii]= clr;
+	}
+}
+
+
+//! Transform colors to grayscale.
+/*!
+	\param dst	Destination color array
+	\param src	Source color array.
+	\param nclrs	Number of colors.
+*/
+void clr_grayscale(COLOR *dst, const COLOR *src, uint nclrs)
+{
+	u32 ii;
+	u32 clr, gray, rr, gg, bb;
+
+	for(ii=0; ii<nclrs; ii++)
+	{
+		clr= *src++;
+
+		// Do RGB conversion in .8 fixed point
+		rr= ((clr    )&31)*0x4C;	// 29.7%
+		gg= ((clr>> 5)&31)*0x96;	// 58.6%
+		bb= ((clr>>10)&31)*0x1E;	// 11.7%
+		gray= (rr+gg+bb+0x80)>>8;
+
+		*dst++= RGB15(gray, gray, gray);
+	}
+}
+
+//! Transform colors to an rgb-scale.
+/*!	\a clr indicates a color vector in RGB-space. Each source color is 
+	converted to a brightness value (i.e., grayscale) and then mapped 
+	onto that color vector. A grayscale is a special case of this, 
+	using a color with R=G=B.
+	\param dst	Destination color array
+	\param src	Source color array.
+	\param nclrs	Number of colors.
+	\param clr	Destination color vector.
+*/
+void clr_rgbscale(COLOR *dst, const COLOR *src, uint nclrs, COLOR clr)
+{
+	int ii;
+	u32 rr, gg, bb, scale, gray;
+
+	// Normalize target color
+	rr= (clr    )&31;
+	gg= (clr>> 5)&31;
+	bb= (clr>>10)&31;
+
+	scale= max(max(rr, gg), bb);
+	if(scale == 0)	// Can't scale to black : use gray instead
+	{
+		clr_grayscale(dst, src, nclrs);
+		return;
+	}
+
+	scale= lu_div(scale);
+	rr *= scale;		// rr, gg, bb -> 0.16f
+	gg *= scale;
+	bb *= scale;
+
+	for(ii=0; ii<nclrs; ii++)
+	{	
+		clr= *src++;
+
+		// Grayscaly in 5.8f
+		gray  = ((clr    )&31)*0x4C;	// 29.7%
+		gray += ((clr>> 5)&31)*0x96;	// 58.6%
+		gray += ((clr>>10)&31)*0x1E;	// 11.7%
+		
+		// Match onto color vector
+		dst[ii]= RGB15(rr*gray>>24, gg*gray>>24, bb*gray>>24);
+	}
+}
+
+
+//! Create a gradient between pal[first] and pal[last].
+/*!
+	\param pal		Palette to work on.
+	\param first	First index of gradient.
+	\param last		Last index of gradient.
+*/
+void pal_gradient(COLOR *pal, int first, int last)
+{
+	// Normalize
+	if(first > last)
+		SWAP(first, last);
+
+	// 2 entries means nothing to do
+	if(last-first < 2)
+		return;
+
+	int ii;
+	COLOR clra= pal[first], clrb= pal[last];
+
+	int r= (clra    )&31, dr= ((clrb    )&31) - r;
+	int g= (clra>> 5)&31, dg= ((clrb>> 5)&31) - g;
+	int b= (clra>>10)&31, db= ((clrb>>10)&31) - b;
+
+	// r,g,b will be .20 fixeds. Note rounding
+	const u32 SCALE= 1<<16;
+	r= r*SCALE + SCALE/2;	dr= (int)(dr*SCALE)/(last-first);
+	g= g*SCALE + SCALE/2;	dg= (int)(dg*SCALE)/(last-first);
+	b= b*SCALE + SCALE/2;	db= (int)(db*SCALE)/(last-first);
+
+	for(ii=first+1; ii<last; ii++)
+	{
+		r += dr;
+		g += dg;
+		b += db;
+
+		pal[ii]= RGB15(r/SCALE, g/SCALE, b/SCALE);
+	}
+}
+
+//! Create a gradient between pal[first] and pal[last].
+/*!
+	\param pal		Palette to work on.
+	\param first	First index of gradient.
+	\param last		Last index of gradient.
+	\param clr_first	Color of first index.
+	\param clr_last		Color of last index.
+*/
+void pal_gradient_ex(COLOR *pal, int first, int last, 
+	COLOR clr_first, COLOR clr_last)
+{
+	pal[first]= clr_first;
+	pal[last]= clr_last;
+	pal_gradient(pal, first, last);
+}
+
+
+// --------------------------------------------------------------------
+// Color adjustments
+// --------------------------------------------------------------------
+
+
+//! Adjust brightness by \a bright
+/*!	Operation: color= color+dB;
+	\param dst	Destination color array
+	\param src	Source color array.
+	\param nclrs	Number of colors.
+	\param bright	Brightness difference, dB (in .8f)
+	\note	Might be faster if preformed via lut.
+*/
+void clr_adj_brightness(COLOR *dst, const COLOR *src, uint nclrs, FIXED bright)
+{
+	u32 ii, clr;
+	int rr, gg, bb;
+
+	bright >>= 3;
+	for(ii=0; ii<nclrs; ii++)
+	{
+		clr= src[ii];
+
+		rr= ((clr    )&31) + bright;
+		gg= ((clr>>5 )&31) + bright;
+		bb= ((clr>>10)&31) + bright;
+
+		dst[ii]= RGB15(bf_clamp(rr,5), bf_clamp(gg,5), bf_clamp(bb,5));
+	}
+}
+
+
+//! Adjust contrast by \a contrast
+/*!	Operation: color = color*(1+dC) - MAX*dC/2
+	\param dst	Destination color array
+	\param src	Source color array.
+	\param nclrs	Number of colors.
+	\param contrast	Contrast differencem dC (in .8f)
+	\note	Might be faster if preformed via lut.
+*/
+void clr_adj_contrast(COLOR *dst, const COLOR *src, uint nclrs, FIXED contrast)
+{
+	u32 ii, clr;
+	int rr, gg, bb;
+	FIXED ca= contrast+FIX_ONE, cb= (-contrast>>1)*32;
+
+	for(ii=0; ii<nclrs; ii++)
+	{
+		clr= src[ii];
+
+		rr= ca*((clr    )&31) + cb;
+		gg= ca*((clr>>5 )&31) + cb;
+		bb= ca*((clr>>10)&31) + cb;
+
+		// Shift here, because it'd be unsigned-shift otherwise
+		dst[ii]= RGB15(bf_clamp(rr>>8,5), bf_clamp(gg>>8,5), bf_clamp(bb>>8,5));
+	}
+}
+
+//! Adjust intensity by \a intensity. 
+/*!	Operation: color = (1+dI)*color.
+	\param dst	Destination color array
+	\param src	Source color array.
+	\param nclrs	Number of colors.
+	\param intensity	Intensity difference, dI (in .8f)
+	\note	Might be faster if preformed via lut.
+*/
+void clr_adj_intensity(COLOR *dst, const COLOR *src, uint nclrs, FIXED intensity)
+{
+	u32 ii, clr;
+	int rr, gg, bb;
+	FIXED ia= intensity+FIX_ONE;
+
+	for(ii=0; ii<nclrs; ii++)
+	{
+		clr= *src++;
+
+		rr= ia*((clr    )&31);
+		gg= ia*((clr>>5 )&31);
+		bb= ia*((clr>>10)&31);
+
+		// Shift here, because it'd be unsigned-shift otherwise
+		*dst++= RGB15(bf_clamp(rr>>8,5), bf_clamp(gg>>8,5), bf_clamp(bb>>8,5));
+	}
+}
+
+
+// EOF

package/src/platforms/gba/lib/libtonc/src/tonc_core.c

@@ -0,0 +1,237 @@
+//
+//  Core stuff: keys, interrupts and misc
+//
+//! \file tonc_core.c
+//! \author J Vijn
+//! \date 20060508 - 20060508
+//
+// === NOTES ===
+
+#include "tonc_memmap.h"
+#include "tonc_core.h"
+
+
+// --------------------------------------------------------------------
+// CONSTANTS
+// --------------------------------------------------------------------
+
+
+const u8 oam_sizes[3][4][2]=
+{
+	{ { 8, 8}, {16,16}, {32,32}, {64,64} }, 
+	{ {16, 8}, {32, 8}, {32,16}, {64,32} },
+	{ { 8,16}, { 8,32}, {16,32}, {32,64} },
+};
+
+const BG_AFFINE bg_aff_default= { 256, 0, 0, 256, 0, 0 };
+
+const uint __snd_rates[12]=
+{
+	8013, 7566, 7144, 6742, // C , C#, D , D#
+	6362, 6005, 5666, 5346, // E , F , F#, G
+	5048, 4766, 4499, 4246  // G#, A , A#, B
+};
+
+
+// --------------------------------------------------------------------
+// GLOBALS 
+// --------------------------------------------------------------------
+
+
+int __qran_seed= 42;
+COLOR *vid_page= vid_mem_back;
+
+
+// --------------------------------------------------------------------
+// FUNCTIONS 
+// --------------------------------------------------------------------
+
+
+// --- data -----------------------------------------------------------
+
+//! VRAM-safe cpy.
+/*!	This version mimics memcpy in functionality, with 
+	the benefit of working for VRAM as well. It is also 
+	slightly faster than the original memcpy, but faster 
+	implementations can be made.
+	\param dst	Destination pointer.
+	\param src	Source pointer.
+	\param size	Fill-length in bytes.
+	\return		\a dst.
+	\note	The pointers and size need not be word-aligned.
+*/
+void *tonccpy(void *dst, const void *src, uint size)
+{
+	if(size == 0 || dst==NULL || src==NULL)
+		return dst;
+
+	uint count;
+	u16 *dst16;		// hword destination
+	u8  *src8;		// byte source
+
+	// Ideal case: copy by 4x words. Leaves tail for later.
+	if( ((u32)src|(u32)dst)%4==0 && size>=4)
+	{
+		u32 *src32= (u32*)src, *dst32= (u32*)dst;
+
+		count= size/4;
+		uint tmp= count&3;
+		count /= 4;
+
+		// Duff, bitch!
+		switch(tmp) {
+			do {	*dst32++ = *src32++;
+		case 3:		*dst32++ = *src32++;
+		case 2:		*dst32++ = *src32++;
+		case 1:		*dst32++ = *src32++;
+		case 0:		; }	while(count--);
+		}
+
+		// Check for tail
+		size &= 3;
+		if(size == 0)
+			return dst;
+
+		src8= (u8*)src32;
+		dst16= (u16*)dst32;
+	}
+	else		// Unaligned.
+	{
+		uint dstOfs= (u32)dst&1;
+		src8= (u8*)src;
+		dst16= (u16*)(dst-dstOfs);
+
+		// Head: 1 byte.
+		if(dstOfs != 0)
+		{
+			*dst16= (*dst16 & 0xFF) | *src8++<<8;
+			dst16++;
+			if(--size==0)
+				return dst;
+		}
+	}
+
+	// Unaligned main: copy by 2x byte.
+	count= size/2;
+	while(count--)
+	{
+		*dst16++ = src8[0] | src8[1]<<8;
+		src8 += 2;
+	}
+
+	// Tail: 1 byte.
+	if(size&1)
+		*dst16= (*dst16 &~ 0xFF) | *src8;
+
+	return dst;
+}
+
+//! VRAM-safe memset, internal routine.
+/*!	This version mimics memset in functionality, with 
+	the benefit of working for VRAM as well. It is also 
+	slightly faster than the original memset.
+	\param dst	Destination pointer.
+	\param fill	Word to fill with.
+	\param size	Fill-length in bytes.
+	\return		\a dst.
+	\note	The \a dst pointer and \a size need not be 
+		word-aligned. In the case of unaligned fills, \a fill 
+		will be masked off to match the situation.
+*/
+void *__toncset(void *dst, u32 fill, uint size)
+{
+	if(dst==NULL || size==0)
+		return dst;
+
+	uint left= (u32)dst&3;
+	u32 *dst32= (u32*)(dst-left);
+	u32 count, mask;
+
+	// Unaligned head.
+	if(left != 0)
+	{
+		// Adjust for very small stint.
+		if(left+size<4)
+		{
+			mask= BIT_MASK(size*8)<<(left*8);	
+			*dst32= (*dst32 &~ mask) | (fill & mask);
+			return dst;
+		}
+
+		mask= BIT_MASK(left*8);
+		*dst32= (*dst32 & mask) | (fill&~mask);
+		dst32++;
+		size -= 4-left;
+	}
+
+	// Main stint.
+	count= size/4;
+	uint tmp= count&3;
+	count /= 4;
+
+	switch(tmp) {
+		do {	*dst32++ = fill;
+	case 3:		*dst32++ = fill;
+	case 2:		*dst32++ = fill;
+	case 1:		*dst32++ = fill;
+	case 0:		; }	while(count--);
+	}
+
+	// Tail
+	size &= 3;
+	if(size)
+	{
+		mask= BIT_MASK(size*8);
+		*dst32= (*dst32 &~ mask) | (fill & mask);
+	}
+
+	return dst;
+}
+
+
+// --- random numbers -------------------------------------------------
+
+int sqran(int seed)
+{	
+	int old= __qran_seed;
+	__qran_seed= seed; 
+	return old;	
+}
+
+// --- misc -----------------------------------------------------------
+
+//! Get the octant that (\a x, \a y) is in.
+/*!	This function divides the circle in 8 parts. The angle 
+	starts at the \a y=0 line and then moves in the direction
+	of the \a x=0 line. On the screen, this would be like
+	starting at the 3 o'clock position and moving clockwise 
+*/
+u32 octant(int x, int y)
+{
+    u32 oct=0;
+    if(y<0) { oct ^= 7; y=-y; }
+    if(x<0) { oct ^= 3; x=-x; }
+    if(x<y) { oct ^= 1; }
+    return oct;
+}
+
+//! Get the rotated octant that (\a x, \a y) is in.
+/*!	Like \c octant() but with a twist. The 0-octant starts 
+	22.5� earlier so that 3 o'clock falls in the middle of 
+	octant 0, instead of at its start. This can be useful for 
+	8 directional pointing.
+*/
+u32 octant_rot(int x0, int y0)
+{
+	//rotate by pi/8: (.9: sin: 195.9; cos 473.0)
+	int x= 473*x0 - 196*y0;
+	int y= 196*x0 + 473*y0;
+
+    u32 oct=0;
+    if(y<0) { oct ^= 7; y=-y; }
+    if(x<0) { oct ^= 3; x=-x; }
+    if(x<y) { oct ^= 1; }
+    return oct;
+}
+
+//	EOF

package/src/platforms/gba/lib/libtonc/src/tonc_input.c

@@ -0,0 +1,118 @@
+//
+//  Input implementation
+//
+//! \file tonc_input.c
+//! \author J Vijn
+//! \date 20070406 - 20070406
+//
+// === NOTES ===
+
+
+#include "tonc_input.h"
+#include "tonc_bios.h"
+
+// --------------------------------------------------------------------
+// CLASSES 
+// --------------------------------------------------------------------
+
+//! Repeated keys struct
+typedef struct REPEAT_REC
+{
+	u16	keys;	//!< Repeated keys.
+	u16	mask;	//!< Only check repeats for these keys.
+	u8	count;	//!< Repeat counter.
+	u8	delay;	//!< Limit for first repeat.
+	u8	repeat;	//!< Limit for successive repeats.
+} ALIGN4 REPEAT_REC;
+
+
+// --------------------------------------------------------------------
+// GLOBALS 
+// --------------------------------------------------------------------
+
+
+u16 __key_curr= 0, __key_prev= 0;
+
+REPEAT_REC __key_rpt= { 0, KEY_MASK, 60, 60, 30 };
+
+
+// --------------------------------------------------------------------
+// FUNCTIONS 
+// --------------------------------------------------------------------
+
+
+//! Poll for keystates and repeated keys
+void key_poll(void)
+{
+	__key_prev= __key_curr;
+	__key_curr= ~REG_KEYINPUT & KEY_MASK;
+
+	REPEAT_REC *rpt= &__key_rpt;
+
+	rpt->keys= 0;	// Clear repeats again
+
+	if(rpt->delay)
+	{
+		// Change in masked keys: reset repeat
+		// NOTE: this also counts as a repeat!
+		if(key_transit(rpt->mask))
+		{
+			rpt->count= rpt->delay;
+			rpt->keys= __key_curr;
+		}
+		else
+			rpt->count--;
+
+		// Time's up: set repeats (for this frame)
+		if(rpt->count == 0)
+		{
+			rpt->count= rpt->repeat;
+			rpt->keys= __key_curr & rpt->mask;
+		}
+	}
+}
+
+//! Wait until \a key is hit.
+void key_wait_till_hit(u16 key)
+{
+	while(1)
+	{
+		VBlankIntrWait();
+		key_poll();
+		if(key_hit(key))
+			return;
+	}	
+}
+
+// === Repeated keys functions ===
+
+//! Get status of repeated keys.
+u32 key_repeat(u32 keys)
+{
+	return __key_rpt.keys & keys;
+}
+
+//! Set repeat mask. Only these keys will be considered for repeats.
+void key_repeat_mask(u32 mask)
+{
+	__key_rpt.mask= mask & KEY_MASK;
+}
+
+//! Set the delay and repeat limits for repeated keys
+/*!
+	\param delay	Set first repeat limit. If 0, repeats are off.
+	\param repeat	Sets later repeat limit.
+	\note	Both limits have a range of [0, 255]. If either argument 
+	  is <0, the old value will be kept.
+*/
+void key_repeat_limits(uint delay, uint repeat)
+{
+	REPEAT_REC *rpt= &__key_rpt;
+
+	if(delay >= 0)
+		rpt->delay= delay;
+	if(repeat >= 0)
+		rpt->repeat= repeat;
+
+	rpt->count= delay;		// Reset counter.
+}