![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to uiplot.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Generator SEGA Genesis emulator] / generator / main|
Return to uiplot.c CVS log | Up to [Generator SEGA Genesis emulator] / generator / main |
1.1 root 1: /* Generator is (c) James Ponder, 1997-2001 http://www.squish.net/generator/ */
2:
3: /* plotter routines for user interfaces - used by console and gtk */
4:
5: #include "generator.h"
6: #include "vdp.h"
7:
8: #include "uiplot.h"
9:
10: uint32 uiplot_palcache[192];
11:
12: static int uiplot_redshift;
13: static int uiplot_greenshift;
14: static int uiplot_blueshift;
15:
16: void uiplot_setshifts(int redshift, int greenshift, int blueshift)
17: {
18: uiplot_redshift = redshift;
19: uiplot_greenshift = greenshift;
20: uiplot_blueshift = blueshift;
21: }
22:
23: /* uiplot_checkpalcache goes through the CRAM memory in the Genesis and
24: converts it to the uiplot_palcache table. The Genesis has 64 colours,
25: but we store three versions of the colour table into uiplot_palcache - a
26: normal, hilighted and dim version. The vdp_cramf buffer has 64
27: entries and is set to 1 when the game writes to CRAM, this means this
28: code skips entries that have not changed, unless 'flag' is set to 1 in
29: which case this updates all entries regardless. */
30:
31: void uiplot_checkpalcache(int flag)
32: {
33: unsigned int col;
34: uint8 *p;
35:
36: /* this code requires that there be at least 4 bits per colour, that
37: is, three bits that come from the console's palette, and one more bit
38: when we do a dim or bright colour, i.e. this code works with 12bpp
39: upwards */
40:
41: /* the flag forces it to do the update despite the vdp_cramf buffer */
42:
43: for (col = 0; col < 64; col++) { /* the CRAM has 64 colours */
44: if (!flag && !vdp_cramf[col])
45: continue;
46: vdp_cramf[col] = 0;
47: p = (uint8 *)vdp_cram + 2 * col; /* point p to the two-byte CRAM entry */
48: uiplot_palcache[col] = /* normal */
49: (p[0] & 0xE) << (uiplot_blueshift + 1) |
50: (p[1] & 0xE) << (uiplot_redshift + 1) |
51: ((p[1] & 0xE0) >> 4) << (uiplot_greenshift + 1);
52: uiplot_palcache[col + 64] = /* hilight */
53: (p[0] & 0xE) << uiplot_blueshift |
54: (p[1] & 0xE) << uiplot_redshift |
55: ((p[1] & 0xE0) >> 4) << uiplot_greenshift |
56: (16 << uiplot_blueshift) | (16 << uiplot_redshift) |
57: (16 << uiplot_greenshift);
58: uiplot_palcache[col + 128] = /* shadow */
59: (p[0] & 0xE) << uiplot_blueshift |
60: (p[1] & 0xE) << uiplot_redshift |
61: ((p[1] & 0xE0) >> 4) << uiplot_greenshift;
62: }
63: }
64:
65: /*** uiplot_convertdata - convert genesis data to 16 bit colour */
66:
67: /* must call uiplot_checkpalcache first */
68:
69: void uiplot_convertdata16(uint8 *indata, uint16 *outdata, unsigned int pixels)
70: {
71: unsigned int ui;
72: uint32 outdata1;
73: uint32 outdata2;
74: uint32 indata_val;
75:
76: /* not scaled, 16bpp - we do 4 pixels at a time */
77: for (ui = 0; ui < (pixels >> 2); ui++) {
78: indata_val = ((uint32 *)indata)[ui]; /* 4 bytes of in data */
79: outdata1 = (uiplot_palcache[indata_val & 0xff] |
80: uiplot_palcache[(indata_val >> 8) & 0xff] << 16);
81: outdata2 = (uiplot_palcache[(indata_val >> 16) & 0xff] |
82: uiplot_palcache[(indata_val >> 24) & 0xff] << 16);
83: #ifdef WORDS_BIGENDIAN
84: ((uint32 *)outdata)[(ui << 1)] = outdata2;
85: ((uint32 *)outdata)[(ui << 1) + 1] = outdata1;
86: #else
87: ((uint32 *)outdata)[(ui << 1)] = outdata1;
88: ((uint32 *)outdata)[(ui << 1) + 1] = outdata2;
89: #endif
90: }
91: }
92:
93: /*** uiplot_convertdata - convert genesis data to 32 bit colour ***/
94:
95: /* must call uiplot_checkpalcache first */
96:
97: void uiplot_convertdata32(uint8 *indata, uint32 *outdata, unsigned int pixels)
98: {
99: unsigned int ui;
100: uint32 outdata1;
101: uint32 outdata2;
102: uint32 outdata3;
103: uint32 outdata4;
104: uint32 indata_val;
105:
106: /* not scaled, 32bpp - we do 4 pixels at a time */
107: for (ui = 0; ui < pixels >> 2; ui++) {
108: indata_val = ((uint32 *)indata)[ui]; /* 4 bytes of in data */
109: outdata1 = uiplot_palcache[indata_val & 0xff];
110: outdata2 = uiplot_palcache[(indata_val >> 8) & 0xff];
111: outdata3 = uiplot_palcache[(indata_val >> 16) & 0xff];
112: outdata4 = uiplot_palcache[(indata_val >> 24) & 0xff];
113: #ifdef WORDS_BIGENDIAN
114: ((uint32 *)outdata)[(ui << 2)] = outdata4;
115: ((uint32 *)outdata)[(ui << 2) + 1] = outdata3;
116: ((uint32 *)outdata)[(ui << 2) + 2] = outdata2;
117: ((uint32 *)outdata)[(ui << 2) + 3] = outdata1;
118: #else
119: ((uint32 *)outdata)[(ui << 2)] = outdata1;
120: ((uint32 *)outdata)[(ui << 2) + 1] = outdata2;
121: ((uint32 *)outdata)[(ui << 2) + 2] = outdata3;
122: ((uint32 *)outdata)[(ui << 2) + 3] = outdata4;
123: #endif
124: }
125: }
126:
127: /*** uiplot_render16_x1 - copy to screen with delta changes (16 bit) ***/
128:
129: void uiplot_render16_x1(uint16 *linedata, uint16 *olddata, uint8 *screen,
130: unsigned int pixels)
131: {
132: unsigned int ui;
133: uint32 inval;
134:
135: for (ui = 0; ui < pixels >> 1; ui++) {
136: /* do two words of input data at a time */
137: inval = ((uint32 *)linedata)[ui];
138: if (inval != ((uint32 *)olddata)[ui])
139: ((uint32 *)screen)[ui] = inval;
140: }
141: }
142:
143: /*** uiplot_render32_x1 - copy to screen with delta changes (32 bit) ***/
144:
145: void uiplot_render32_x1(uint32 *linedata, uint32 *olddata, uint8 *screen,
146: unsigned int pixels)
147: {
148: unsigned int ui;
149: uint32 inval;
150:
151: for (ui = 0; ui < pixels; ui++) {
152: inval = linedata[ui];
153: if (inval != olddata[ui])
154: ((uint32 *)screen)[ui] = inval;
155: }
156: }
157:
158: /*** uiplot_render16_x2 - blow up screen image by two (16 bit) ***/
159:
160: void uiplot_render16_x2(uint16 *linedata, uint16 *olddata, uint8 *screen,
161: unsigned int linewidth, unsigned int pixels)
162: {
163: unsigned int ui;
164: uint32 inval, outval, mask;
165: uint8 *screen2 = screen + linewidth;
166:
167: mask = 0xffffffff;
168: for (ui = 0; ui < pixels >> 1; ui++) {
169: /* do two words of input data at a time */
170: inval = ((uint32 *)linedata)[ui];
171: if (olddata)
172: mask = inval ^ ((uint32 *)olddata)[ui]; /* check for changed data */
173: if (mask & 0xffff) {
174: /* write first two words */
175: outval = inval & 0xffff;
176: outval |= outval << 16;
177: #ifdef WORDS_BIGENDIAN
178: ((uint32 *)screen)[(ui << 1) + 1] = outval;
179: ((uint32 *)screen2)[(ui << 1) + 1] = outval;
180: #else
181: ((uint32 *)screen)[(ui << 1)] = outval;
182: ((uint32 *)screen2)[(ui << 1)] = outval;
183: #endif
184: }
185: if (mask & 0xffff0000) {
186: /* write second two words */
187: outval = inval & 0xffff0000;
188: outval |= outval >> 16;
189: #ifdef WORDS_BIGENDIAN
190: ((uint32 *)screen)[(ui << 1)] = outval;
191: ((uint32 *)screen2)[(ui << 1)] = outval;
192: #else
193: ((uint32 *)screen)[(ui << 1) + 1] = outval;
194: ((uint32 *)screen2)[(ui << 1) + 1] = outval;
195: #endif
196: }
197: }
198: }
199:
200: /*** uiplot_render32_x2 - blow up screen image by two (32 bit) ***/
201:
202: void uiplot_render32_x2(uint32 *linedata, uint32 *olddata, uint8 *screen,
203: unsigned int linewidth, unsigned int pixels)
204: {
205: unsigned int ui;
206: uint32 val;
207: uint8 *screen2 = screen + linewidth;
208:
209: if (olddata) {
210: for (ui = 0; ui < pixels; ui++) {
211: val = linedata[ui];
212: /* check for changed data */
213: if (val != olddata[ui]) {
214: ((uint32 *)screen)[(ui << 1) + 0] = val;
215: ((uint32 *)screen)[(ui << 1) + 1] = val;
216: ((uint32 *)screen2)[(ui << 1) + 0] = val;
217: ((uint32 *)screen2)[(ui << 1) + 1] = val;
218: }
219: }
220: } else {
221: for (ui = 0; ui < pixels; ui++) {
222: val = linedata[ui];
223: ((uint32 *)screen)[(ui << 1) + 0] = val;
224: ((uint32 *)screen)[(ui << 1) + 1] = val;
225: ((uint32 *)screen2)[(ui << 1) + 0] = val;
226: ((uint32 *)screen2)[(ui << 1) + 1] = val;
227: }
228: }
229: }
230:
231: /*** uiplot_render16_x2h - blow up by two in horizontal direction
232: only (16 bit) ***/
233:
234: void uiplot_render16_x2h(uint16 *linedata, uint16 *olddata, uint8 *screen,
235: unsigned int pixels)
236: {
237: unsigned int ui;
238: uint32 inval, outval, mask;
239:
240: mask = 0xffffffff;
241: for (ui = 0; ui < pixels >> 1; ui++) {
242: /* do two words of input data at a time */
243: inval = ((uint32 *)linedata)[ui];
244: if (olddata)
245: mask = inval ^ ((uint32 *)olddata)[ui]; /* check for changed data */
246: if (mask & 0xffff) {
247: /* write first two words */
248: outval = inval & 0xffff;
249: outval |= outval << 16;
250: #ifdef WORDS_BIGENDIAN
251: ((uint32 *)screen)[(ui << 1) + 1] = outval;
252: #else
253: ((uint32 *)screen)[(ui << 1)] = outval;
254: #endif
255: }
256: if (mask & 0xffff0000) {
257: /* write second two words */
258: outval = inval & 0xffff0000;
259: outval |= outval >> 16;
260: #ifdef WORDS_BIGENDIAN
261: ((uint32 *)screen)[(ui << 1)] = outval;
262: #else
263: ((uint32 *)screen)[(ui << 1) + 1] = outval;
264: #endif
265: }
266: }
267: }
268:
269: /*** uiplot_render32_x2h - blow up by two in horizontal direction
270: only (32 bit) ***/
271:
272: void uiplot_render32_x2h(uint32 *linedata, uint32 *olddata, uint8 *screen,
273: unsigned int pixels)
274: {
275: unsigned int ui;
276: uint32 val;
277:
278: for (ui = 0; ui < pixels; ui++) {
279: val = linedata[ui];
280: /* check for changed data */
281: if (!olddata || val != olddata[ui]) {
282: ((uint32 *)screen)[(ui << 1) + 0] = val;
283: ((uint32 *)screen)[(ui << 1) + 1] = val;
284: }
285: }
286: }
287:
288: /*** uiplot_irender16_weavefilter - take even and odd fields, filter and
289: plot (16 bit) ***/
290:
291: void uiplot_irender16_weavefilter(uint16 *evendata, uint16 *odddata,
292: uint8 *screen, unsigned int pixels)
293: {
294: unsigned int ui;
295: uint32 evenval, oddval, e_r, e_g, e_b, o_r, o_g, o_b;
296: uint32 outval, w1, w2;
297:
298: for (ui = 0; ui < pixels >> 1; ui++) {
299: evenval = ((uint32 *)evendata)[ui]; /* two words of input data */
300: oddval = ((uint32 *)odddata)[ui]; /* two words of input data */
301: e_r = (evenval >> uiplot_redshift) & 0x001f001f;
302: e_g = (evenval >> uiplot_greenshift) & 0x001f001f;
303: e_b = (evenval >> uiplot_blueshift) & 0x001f001f;
304: o_r = (oddval >> uiplot_redshift) & 0x001f001f;
305: o_g = (oddval >> uiplot_greenshift) & 0x001f001f;
306: o_b = (oddval >> uiplot_blueshift) & 0x001f001f;
307: outval = (((e_r + o_r) >> 1) & 0x001f001f) << uiplot_redshift |
308: (((e_g + o_g) >> 1) & 0x001f001f) << uiplot_greenshift |
309: (((e_b + o_b) >> 1) & 0x001f001f) << uiplot_blueshift;
310: w1 = (outval & 0xffff);
311: w1 |= w1 << 16;
312: w2 = outval & 0xffff0000;
313: w2 |= w2 >> 16;
314: #ifdef WORDS_BIGENDIAN
315: ((uint32 *)screen)[(ui << 1)] = w2;
316: ((uint32 *)screen)[(ui << 1) + 1] = w1;
317: #else
318: ((uint32 *)screen)[(ui << 1)] = w1;
319: ((uint32 *)screen)[(ui << 1) + 1] = w2;
320: #endif
321: }
322: }
323:
324: /*** uiplot_irender32_weavefilter - take even and odd fields, filter and
325: plot (32 bit) ***/
326:
327: void uiplot_irender32_weavefilter(uint32 *evendata, uint32 *odddata,
328: uint8 *screen, unsigned int pixels)
329: {
330: unsigned int ui;
331: uint32 evenval, oddval;
332:
333: for (ui = 0; ui < pixels; ui++) {
334: evenval = evendata[ui];
335: oddval = odddata[ui];
336: /* with 32-bit data we know that there are no touching bits */
337: ((uint32 *)screen)[(ui << 1) + 0] = (evenval >> 1) + (oddval >> 1);
338: ((uint32 *)screen)[(ui << 1) + 1] = (evenval >> 1) + (oddval >> 1);
339: }
340: }
341:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.