7890a708 |
1 | /*************************************************************************** |
2 | begin : Sun Mar 08 2009 |
3 | copyright : (C) 1999-2009 by Pete Bernert |
4 | email : BlackDove@addcom.de |
5 | |
6 | PCSX rearmed rework (C) notaz, 2012 |
7 | ***************************************************************************/ |
8 | |
9 | /*************************************************************************** |
10 | * * |
11 | * This program is free software; you can redistribute it and/or modify * |
12 | * it under the terms of the GNU General Public License as published by * |
13 | * the Free Software Foundation; either version 2 of the License, or * |
14 | * (at your option) any later version. See also the license.txt file for * |
15 | * additional informations. * |
16 | * * |
17 | ***************************************************************************/ |
18 | |
19 | #include "gpuDraw.c" |
20 | #include "gpuTexture.c" |
21 | #include "gpuPrim.c" |
22 | |
23 | static const short dispWidths[8] = {256,320,512,640,368,384,512,640}; |
24 | short g_m1,g_m2,g_m3; |
25 | short DrawSemiTrans; |
26 | |
27 | short ly0,lx0,ly1,lx1,ly2,lx2,ly3,lx3; // global psx vertex coords |
28 | long GlobalTextAddrX,GlobalTextAddrY,GlobalTextTP; |
29 | long GlobalTextREST,GlobalTextABR,GlobalTextPAGE; |
30 | |
31 | unsigned long dwGPUVersion; |
32 | int iGPUHeight=512; |
33 | int iGPUHeightMask=511; |
34 | int GlobalTextIL; |
35 | |
36 | unsigned char *psxVub; |
37 | unsigned short *psxVuw; |
38 | |
39 | GLfloat gl_z=0.0f; |
40 | BOOL bNeedInterlaceUpdate; |
41 | BOOL bNeedRGB24Update; |
42 | BOOL bChangeWinMode; |
43 | long lGPUstatusRet; |
44 | unsigned long ulGPUInfoVals[16]; |
45 | VRAMLoad_t VRAMWrite; |
46 | VRAMLoad_t VRAMRead; |
47 | int iDataWriteMode; |
48 | int iDataReadMode; |
49 | |
50 | long lClearOnSwap; |
51 | long lClearOnSwapColor; |
52 | BOOL bSkipNextFrame; |
53 | |
54 | PSXDisplay_t PSXDisplay; |
55 | PSXDisplay_t PreviousPSXDisplay; |
56 | TWin_t TWin; |
57 | BOOL bDisplayNotSet; |
58 | BOOL bNeedWriteUpload; |
59 | int iLastRGB24; |
60 | |
61 | // don't do GL vram read |
62 | void CheckVRamRead(int x, int y, int dx, int dy, bool bFront) |
63 | { |
64 | } |
65 | |
66 | void CheckVRamReadEx(int x, int y, int dx, int dy) |
67 | { |
68 | } |
69 | |
70 | void SetFixes(void) |
71 | { |
72 | } |
73 | |
74 | static void PaintBlackBorders(void) |
75 | { |
76 | short s; |
77 | glDisable(GL_SCISSOR_TEST); glError(); |
78 | if(bTexEnabled) {glDisable(GL_TEXTURE_2D);bTexEnabled=FALSE;} glError(); |
79 | if(bOldSmoothShaded) {glShadeModel(GL_FLAT);bOldSmoothShaded=FALSE;} glError(); |
80 | if(bBlendEnable) {glDisable(GL_BLEND);bBlendEnable=FALSE;} glError(); |
81 | glDisable(GL_ALPHA_TEST); glError(); |
82 | |
83 | glEnable(GL_ALPHA_TEST); glError(); |
84 | glEnable(GL_SCISSOR_TEST); glError(); |
85 | } |
86 | |
87 | void updateDisplay(void) |
88 | { |
89 | bFakeFrontBuffer=FALSE; |
90 | bRenderFrontBuffer=FALSE; |
91 | |
92 | if(PSXDisplay.RGB24)// && !bNeedUploadAfter) // (mdec) upload wanted? |
93 | { |
94 | PrepareFullScreenUpload(-1); |
95 | UploadScreen(PSXDisplay.Interlaced); // -> upload whole screen from psx vram |
96 | bNeedUploadTest=FALSE; |
97 | bNeedInterlaceUpdate=FALSE; |
98 | bNeedUploadAfter=FALSE; |
99 | bNeedRGB24Update=FALSE; |
100 | } |
101 | else |
102 | if(bNeedInterlaceUpdate) // smaller upload? |
103 | { |
104 | bNeedInterlaceUpdate=FALSE; |
105 | xrUploadArea=xrUploadAreaIL; // -> upload this rect |
106 | UploadScreen(TRUE); |
107 | } |
108 | |
109 | if(dwActFixes&512) bCheckFF9G4(NULL); // special game fix for FF9 |
110 | |
111 | if(PSXDisplay.Disabled) // display disabled? |
112 | { |
113 | // moved here |
114 | glDisable(GL_SCISSOR_TEST); glError(); |
115 | glClearColor(0,0,0,128); glError(); // -> clear whole backbuffer |
116 | glClear(uiBufferBits); glError(); |
117 | glEnable(GL_SCISSOR_TEST); glError(); |
118 | gl_z=0.0f; |
119 | bDisplayNotSet = TRUE; |
120 | } |
121 | |
122 | if(iDrawnSomething) |
123 | eglSwapBuffers(display, surface); |
124 | iDrawnSomething=0; |
125 | |
126 | if(lClearOnSwap) // clear buffer after swap? |
127 | { |
128 | GLclampf g,b,r; |
129 | |
130 | if(bDisplayNotSet) // -> set new vals |
131 | SetOGLDisplaySettings(1); |
132 | |
133 | g=((GLclampf)GREEN(lClearOnSwapColor))/255.0f; // -> get col |
134 | b=((GLclampf)BLUE(lClearOnSwapColor))/255.0f; |
135 | r=((GLclampf)RED(lClearOnSwapColor))/255.0f; |
136 | glDisable(GL_SCISSOR_TEST); glError(); |
137 | glClearColor(r,g,b,128); glError(); // -> clear |
138 | glClear(uiBufferBits); glError(); |
139 | glEnable(GL_SCISSOR_TEST); glError(); |
140 | lClearOnSwap=0; // -> done |
141 | } |
142 | else |
143 | { |
144 | if(iZBufferDepth) // clear zbuffer as well (if activated) |
145 | { |
146 | glDisable(GL_SCISSOR_TEST); glError(); |
147 | glClear(GL_DEPTH_BUFFER_BIT); glError(); |
148 | glEnable(GL_SCISSOR_TEST); glError(); |
149 | } |
150 | } |
151 | gl_z=0.0f; |
152 | |
153 | // additional uploads immediatly after swapping |
154 | if(bNeedUploadAfter) // upload wanted? |
155 | { |
156 | bNeedUploadAfter=FALSE; |
157 | bNeedUploadTest=FALSE; |
158 | UploadScreen(-1); // -> upload |
159 | } |
160 | |
161 | if(bNeedUploadTest) |
162 | { |
163 | bNeedUploadTest=FALSE; |
164 | if(PSXDisplay.InterlacedTest && |
165 | //iOffscreenDrawing>2 && |
166 | PreviousPSXDisplay.DisplayPosition.x==PSXDisplay.DisplayPosition.x && |
167 | PreviousPSXDisplay.DisplayEnd.x==PSXDisplay.DisplayEnd.x && |
168 | PreviousPSXDisplay.DisplayPosition.y==PSXDisplay.DisplayPosition.y && |
169 | PreviousPSXDisplay.DisplayEnd.y==PSXDisplay.DisplayEnd.y) |
170 | { |
171 | PrepareFullScreenUpload(TRUE); |
172 | UploadScreen(TRUE); |
173 | } |
174 | } |
175 | } |
176 | |
177 | void updateFrontDisplay(void) |
178 | { |
179 | if(PreviousPSXDisplay.Range.x0|| |
180 | PreviousPSXDisplay.Range.y0) |
181 | PaintBlackBorders(); |
182 | |
183 | bFakeFrontBuffer=FALSE; |
184 | bRenderFrontBuffer=FALSE; |
185 | |
186 | if(iDrawnSomething) // linux: |
187 | eglSwapBuffers(display, surface); |
188 | } |
189 | |
190 | static void ChangeDispOffsetsX(void) // CENTER X |
191 | { |
192 | long lx,l;short sO; |
193 | |
194 | if(!PSXDisplay.Range.x1) return; // some range given? |
195 | |
196 | l=PSXDisplay.DisplayMode.x; |
197 | |
198 | l*=(long)PSXDisplay.Range.x1; // some funky calculation |
199 | l/=2560;lx=l;l&=0xfffffff8; |
200 | |
201 | if(l==PreviousPSXDisplay.Range.x1) return; // some change? |
202 | |
203 | sO=PreviousPSXDisplay.Range.x0; // store old |
204 | |
205 | if(lx>=PSXDisplay.DisplayMode.x) // range bigger? |
206 | { |
207 | PreviousPSXDisplay.Range.x1= // -> take display width |
208 | PSXDisplay.DisplayMode.x; |
209 | PreviousPSXDisplay.Range.x0=0; // -> start pos is 0 |
210 | } |
211 | else // range smaller? center it |
212 | { |
213 | PreviousPSXDisplay.Range.x1=l; // -> store width (8 pixel aligned) |
214 | PreviousPSXDisplay.Range.x0= // -> calc start pos |
215 | (PSXDisplay.Range.x0-500)/8; |
216 | if(PreviousPSXDisplay.Range.x0<0) // -> we don't support neg. values yet |
217 | PreviousPSXDisplay.Range.x0=0; |
218 | |
219 | if((PreviousPSXDisplay.Range.x0+lx)> // -> uhuu... that's too much |
220 | PSXDisplay.DisplayMode.x) |
221 | { |
222 | PreviousPSXDisplay.Range.x0= // -> adjust start |
223 | PSXDisplay.DisplayMode.x-lx; |
224 | PreviousPSXDisplay.Range.x1+=lx-l; // -> adjust width |
225 | } |
226 | } |
227 | |
228 | if(sO!=PreviousPSXDisplay.Range.x0) // something changed? |
229 | { |
230 | bDisplayNotSet=TRUE; // -> recalc display stuff |
231 | } |
232 | } |
233 | |
234 | //////////////////////////////////////////////////////////////////////// |
235 | |
236 | static void ChangeDispOffsetsY(void) // CENTER Y |
237 | { |
238 | int iT;short sO; // store previous y size |
239 | |
240 | if(PSXDisplay.PAL) iT=48; else iT=28; // different offsets on PAL/NTSC |
241 | |
242 | if(PSXDisplay.Range.y0>=iT) // crossed the security line? :) |
243 | { |
244 | PreviousPSXDisplay.Range.y1= // -> store width |
245 | PSXDisplay.DisplayModeNew.y; |
246 | |
247 | sO=(PSXDisplay.Range.y0-iT-4)*PSXDisplay.Double; // -> calc offset |
248 | if(sO<0) sO=0; |
249 | |
250 | PSXDisplay.DisplayModeNew.y+=sO; // -> add offset to y size, too |
251 | } |
252 | else sO=0; // else no offset |
253 | |
254 | if(sO!=PreviousPSXDisplay.Range.y0) // something changed? |
255 | { |
256 | PreviousPSXDisplay.Range.y0=sO; |
257 | bDisplayNotSet=TRUE; // -> recalc display stuff |
258 | } |
259 | } |
260 | |
261 | static void updateDisplayIfChanged(void) |
262 | { |
263 | BOOL bUp; |
264 | |
265 | if ((PSXDisplay.DisplayMode.y == PSXDisplay.DisplayModeNew.y) && |
266 | (PSXDisplay.DisplayMode.x == PSXDisplay.DisplayModeNew.x)) |
267 | { |
268 | if((PSXDisplay.RGB24 == PSXDisplay.RGB24New) && |
269 | (PSXDisplay.Interlaced == PSXDisplay.InterlacedNew)) |
270 | return; // nothing has changed? fine, no swap buffer needed |
271 | } |
272 | else // some res change? |
273 | { |
274 | glLoadIdentity(); glError(); |
275 | glOrtho(0,PSXDisplay.DisplayModeNew.x, // -> new psx resolution |
276 | PSXDisplay.DisplayModeNew.y, 0, -1, 1); glError(); |
277 | if(bKeepRatio) SetAspectRatio(); |
278 | } |
279 | |
280 | bDisplayNotSet = TRUE; // re-calc offsets/display area |
281 | |
282 | bUp=FALSE; |
283 | if(PSXDisplay.RGB24!=PSXDisplay.RGB24New) // clean up textures, if rgb mode change (usually mdec on/off) |
284 | { |
285 | PreviousPSXDisplay.RGB24=0; // no full 24 frame uploaded yet |
286 | ResetTextureArea(FALSE); |
287 | bUp=TRUE; |
288 | } |
289 | |
290 | PSXDisplay.RGB24 = PSXDisplay.RGB24New; // get new infos |
291 | PSXDisplay.DisplayMode.y = PSXDisplay.DisplayModeNew.y; |
292 | PSXDisplay.DisplayMode.x = PSXDisplay.DisplayModeNew.x; |
293 | PSXDisplay.Interlaced = PSXDisplay.InterlacedNew; |
294 | |
295 | PSXDisplay.DisplayEnd.x= // calc new ends |
296 | PSXDisplay.DisplayPosition.x+ PSXDisplay.DisplayMode.x; |
297 | PSXDisplay.DisplayEnd.y= |
298 | PSXDisplay.DisplayPosition.y+ PSXDisplay.DisplayMode.y+PreviousPSXDisplay.DisplayModeNew.y; |
299 | PreviousPSXDisplay.DisplayEnd.x= |
300 | PreviousPSXDisplay.DisplayPosition.x+ PSXDisplay.DisplayMode.x; |
301 | PreviousPSXDisplay.DisplayEnd.y= |
302 | PreviousPSXDisplay.DisplayPosition.y+ PSXDisplay.DisplayMode.y+PreviousPSXDisplay.DisplayModeNew.y; |
303 | |
304 | ChangeDispOffsetsX(); |
305 | if(bUp) updateDisplay(); // yeah, real update (swap buffer) |
306 | } |
307 | |
308 | #define GPUwriteStatus_ext GPUwriteStatus_ext // for gpulib to see this |
309 | void GPUwriteStatus_ext(unsigned long gdata) |
310 | { |
311 | switch((gdata>>24)&0xff) |
312 | { |
313 | case 0x00: |
314 | PSXDisplay.Disabled=1; |
315 | PSXDisplay.DrawOffset.x=PSXDisplay.DrawOffset.y=0; |
316 | drawX=drawY=0;drawW=drawH=0; |
317 | sSetMask=0;lSetMask=0;bCheckMask=FALSE;iSetMask=0; |
318 | usMirror=0; |
319 | GlobalTextAddrX=0;GlobalTextAddrY=0; |
320 | GlobalTextTP=0;GlobalTextABR=0; |
321 | PSXDisplay.RGB24=FALSE; |
322 | PSXDisplay.Interlaced=FALSE; |
323 | bUsingTWin = FALSE; |
324 | return; |
325 | |
326 | case 0x03: |
327 | PreviousPSXDisplay.Disabled = PSXDisplay.Disabled; |
328 | PSXDisplay.Disabled = (gdata & 1); |
329 | |
330 | if (iOffscreenDrawing==4 && |
331 | PreviousPSXDisplay.Disabled && |
332 | !(PSXDisplay.Disabled)) |
333 | { |
334 | |
335 | if(!PSXDisplay.RGB24) |
336 | { |
337 | PrepareFullScreenUpload(TRUE); |
338 | UploadScreen(TRUE); |
339 | updateDisplay(); |
340 | } |
341 | } |
342 | return; |
343 | |
344 | case 0x05: |
345 | { |
346 | short sx=(short)(gdata & 0x3ff); |
347 | short sy; |
348 | |
349 | sy = (short)((gdata>>10)&0x3ff); // really: 0x1ff, but we adjust it later |
350 | if (sy & 0x200) |
351 | { |
352 | sy|=0xfc00; |
353 | PreviousPSXDisplay.DisplayModeNew.y=sy/PSXDisplay.Double; |
354 | sy=0; |
355 | } |
356 | else PreviousPSXDisplay.DisplayModeNew.y=0; |
357 | |
358 | if(sx>1000) sx=0; |
359 | |
360 | if(dwActFixes&8) |
361 | { |
362 | if((!PSXDisplay.Interlaced) && |
363 | PreviousPSXDisplay.DisplayPosition.x == sx && |
364 | PreviousPSXDisplay.DisplayPosition.y == sy) |
365 | return; |
366 | |
367 | PSXDisplay.DisplayPosition.x = PreviousPSXDisplay.DisplayPosition.x; |
368 | PSXDisplay.DisplayPosition.y = PreviousPSXDisplay.DisplayPosition.y; |
369 | PreviousPSXDisplay.DisplayPosition.x = sx; |
370 | PreviousPSXDisplay.DisplayPosition.y = sy; |
371 | } |
372 | else |
373 | { |
374 | if((!PSXDisplay.Interlaced) && |
375 | PSXDisplay.DisplayPosition.x == sx && |
376 | PSXDisplay.DisplayPosition.y == sy) |
377 | return; |
378 | PreviousPSXDisplay.DisplayPosition.x = PSXDisplay.DisplayPosition.x; |
379 | PreviousPSXDisplay.DisplayPosition.y = PSXDisplay.DisplayPosition.y; |
380 | PSXDisplay.DisplayPosition.x = sx; |
381 | PSXDisplay.DisplayPosition.y = sy; |
382 | } |
383 | |
384 | PSXDisplay.DisplayEnd.x= |
385 | PSXDisplay.DisplayPosition.x+ PSXDisplay.DisplayMode.x; |
386 | PSXDisplay.DisplayEnd.y= |
387 | PSXDisplay.DisplayPosition.y+ PSXDisplay.DisplayMode.y+PreviousPSXDisplay.DisplayModeNew.y; |
388 | |
389 | PreviousPSXDisplay.DisplayEnd.x= |
390 | PreviousPSXDisplay.DisplayPosition.x+ PSXDisplay.DisplayMode.x; |
391 | PreviousPSXDisplay.DisplayEnd.y= |
392 | PreviousPSXDisplay.DisplayPosition.y+ PSXDisplay.DisplayMode.y+PreviousPSXDisplay.DisplayModeNew.y; |
393 | |
394 | bDisplayNotSet = TRUE; |
395 | |
396 | if (!(PSXDisplay.Interlaced)) |
397 | { |
398 | updateDisplay(); |
399 | } |
400 | else |
401 | if(PSXDisplay.InterlacedTest && |
402 | ((PreviousPSXDisplay.DisplayPosition.x != PSXDisplay.DisplayPosition.x)|| |
403 | (PreviousPSXDisplay.DisplayPosition.y != PSXDisplay.DisplayPosition.y))) |
404 | PSXDisplay.InterlacedTest--; |
405 | return; |
406 | } |
407 | |
408 | case 0x06: |
409 | PSXDisplay.Range.x0=gdata & 0x7ff; //0x3ff; |
410 | PSXDisplay.Range.x1=(gdata>>12) & 0xfff;//0x7ff; |
411 | |
412 | PSXDisplay.Range.x1-=PSXDisplay.Range.x0; |
413 | |
414 | ChangeDispOffsetsX(); |
415 | return; |
416 | |
417 | case 0x07: |
418 | PreviousPSXDisplay.Height = PSXDisplay.Height; |
419 | |
420 | PSXDisplay.Range.y0=gdata & 0x3ff; |
421 | PSXDisplay.Range.y1=(gdata>>10) & 0x3ff; |
422 | |
423 | PSXDisplay.Height = PSXDisplay.Range.y1 - |
424 | PSXDisplay.Range.y0 + |
425 | PreviousPSXDisplay.DisplayModeNew.y; |
426 | |
427 | if (PreviousPSXDisplay.Height != PSXDisplay.Height) |
428 | { |
429 | PSXDisplay.DisplayModeNew.y=PSXDisplay.Height*PSXDisplay.Double; |
430 | ChangeDispOffsetsY(); |
431 | updateDisplayIfChanged(); |
432 | } |
433 | return; |
434 | |
435 | case 0x08: |
436 | PSXDisplay.DisplayModeNew.x = dispWidths[(gdata & 0x03) | ((gdata & 0x40) >> 4)]; |
437 | |
438 | if (gdata&0x04) PSXDisplay.Double=2; |
439 | else PSXDisplay.Double=1; |
440 | PSXDisplay.DisplayModeNew.y = PSXDisplay.Height*PSXDisplay.Double; |
441 | |
442 | ChangeDispOffsetsY(); |
443 | |
444 | PSXDisplay.PAL = (gdata & 0x08)?TRUE:FALSE; // if 1 - PAL mode, else NTSC |
445 | PSXDisplay.RGB24New = (gdata & 0x10)?TRUE:FALSE; // if 1 - TrueColor |
446 | PSXDisplay.InterlacedNew = (gdata & 0x20)?TRUE:FALSE; // if 1 - Interlace |
447 | |
448 | PreviousPSXDisplay.InterlacedNew=FALSE; |
449 | if (PSXDisplay.InterlacedNew) |
450 | { |
451 | if(!PSXDisplay.Interlaced) |
452 | { |
453 | PSXDisplay.InterlacedTest=2; |
454 | PreviousPSXDisplay.DisplayPosition.x = PSXDisplay.DisplayPosition.x; |
455 | PreviousPSXDisplay.DisplayPosition.y = PSXDisplay.DisplayPosition.y; |
456 | PreviousPSXDisplay.InterlacedNew=TRUE; |
457 | } |
458 | } |
459 | else |
460 | { |
461 | PSXDisplay.InterlacedTest=0; |
462 | } |
463 | updateDisplayIfChanged(); |
464 | return; |
465 | } |
466 | } |
467 | |
468 | ///////////////////////////////////////////////////////////////////////////// |
469 | |
470 | #include <stdint.h> |
471 | |
472 | #include "../gpulib/gpu.c" |
473 | |
474 | static int is_opened; |
475 | |
476 | int renderer_init(void) |
477 | { |
478 | psxVub=(void *)gpu.vram; |
479 | psxVuw=(unsigned short *)psxVub; |
480 | |
481 | PSXDisplay.RGB24 = FALSE; // init some stuff |
482 | PSXDisplay.Interlaced = FALSE; |
483 | PSXDisplay.DrawOffset.x = 0; |
484 | PSXDisplay.DrawOffset.y = 0; |
485 | PSXDisplay.DisplayMode.x= 320; |
486 | PSXDisplay.DisplayMode.y= 240; |
487 | PSXDisplay.Disabled = FALSE; |
488 | PSXDisplay.Range.x0=0; |
489 | PSXDisplay.Range.x1=0; |
490 | PSXDisplay.Double = 1; |
491 | |
492 | lGPUstatusRet = 0x14802000; |
493 | |
494 | return 0; |
495 | } |
496 | |
497 | extern const unsigned char cmd_lengths[256]; |
498 | |
499 | void do_cmd_list(unsigned int *list, int list_len) |
500 | { |
501 | unsigned int cmd, len; |
502 | |
503 | unsigned int *list_end = list + list_len; |
504 | |
505 | for (; list < list_end; list += 1 + len) |
506 | { |
507 | cmd = *list >> 24; |
508 | len = cmd_lengths[cmd]; |
509 | |
510 | primTableJ[cmd]((void *)list); |
511 | |
512 | switch(cmd) |
513 | { |
514 | case 0x48 ... 0x4F: |
515 | { |
516 | uint32_t num_vertexes = 1; |
517 | uint32_t *list_position = &(list[2]); |
518 | |
519 | while(1) |
520 | { |
521 | if((*list_position & 0xf000f000) == 0x50005000 || list_position >= list_end) |
522 | break; |
523 | |
524 | list_position++; |
525 | num_vertexes++; |
526 | } |
527 | |
528 | if(num_vertexes > 2) |
529 | len += (num_vertexes - 2); |
530 | |
531 | break; |
532 | } |
533 | |
534 | case 0x58 ... 0x5F: |
535 | { |
536 | uint32_t num_vertexes = 1; |
537 | uint32_t *list_position = &(list[2]); |
538 | |
539 | while(1) |
540 | { |
541 | if((*list_position & 0xf000f000) == 0x50005000 || list_position >= list_end) |
542 | break; |
543 | |
544 | list_position += 2; |
545 | num_vertexes++; |
546 | } |
547 | |
548 | if(num_vertexes > 2) |
549 | len += (num_vertexes - 2) * 2; |
550 | |
551 | break; |
552 | } |
553 | |
554 | #ifdef TEST |
555 | case 0xA0: // sys -> vid |
556 | { |
557 | short *slist = (void *)list; |
558 | uint32_t load_width = slist[4]; |
559 | uint32_t load_height = slist[5]; |
560 | uint32_t load_size = load_width * load_height; |
561 | |
562 | len += load_size / 2; |
563 | break; |
564 | } |
565 | #endif |
566 | } |
567 | } |
568 | } |
569 | |
570 | void renderer_sync_ecmds(uint32_t *ecmds) |
571 | { |
572 | cmdTexturePage((unsigned char *)&ecmds[1]); |
573 | cmdTextureWindow((unsigned char *)&ecmds[2]); |
574 | cmdDrawAreaStart((unsigned char *)&ecmds[3]); |
575 | cmdDrawAreaEnd((unsigned char *)&ecmds[4]); |
576 | cmdDrawOffset((unsigned char *)&ecmds[5]); |
577 | cmdSTP((unsigned char *)&ecmds[6]); |
578 | } |
579 | |
580 | void renderer_update_caches(int x, int y, int w, int h) |
581 | { |
582 | VRAMWrite.x = x; |
583 | VRAMWrite.y = y; |
584 | VRAMWrite.Width = w; |
585 | VRAMWrite.Height = h; |
586 | if(is_opened) |
587 | CheckWriteUpdate(); |
588 | } |
589 | |
590 | void renderer_flush_queues(void) |
591 | { |
592 | } |
593 | |
594 | void renderer_set_interlace(int enable, int is_odd) |
595 | { |
596 | } |
597 | |
598 | int vout_init(void) |
599 | { |
600 | return 0; |
601 | } |
602 | |
603 | int vout_finish(void) |
604 | { |
605 | return 0; |
606 | } |
607 | |
608 | void vout_update(void) |
609 | { |
610 | if(PSXDisplay.Interlaced) // interlaced mode? |
611 | { |
612 | if(PSXDisplay.DisplayMode.x>0 && PSXDisplay.DisplayMode.y>0) |
613 | { |
614 | updateDisplay(); // -> swap buffers (new frame) |
615 | } |
616 | } |
617 | else if(bRenderFrontBuffer) // no interlace mode? and some stuff in front has changed? |
618 | { |
619 | updateFrontDisplay(); // -> update front buffer |
620 | } |
621 | } |
622 | |
623 | long GPUopen(void **dpy) |
624 | { |
625 | iResX = 800; iResY = 480; |
626 | rRatioRect.left = rRatioRect.top=0; |
627 | rRatioRect.right = iResX; |
628 | rRatioRect.bottom = iResY; |
629 | |
630 | bDisplayNotSet = TRUE; |
631 | bSetClip = TRUE; |
632 | CSTEXTURE = CSVERTEX = CSCOLOR = 0; |
633 | |
634 | InitializeTextureStore(); // init texture mem |
635 | is_opened = 1; |
636 | |
637 | return GLinitialize(); |
638 | } |
639 | |
640 | long GPUclose(void) |
641 | { |
642 | is_opened = 0; |
643 | |
644 | GLcleanup(); // close OGL |
645 | return 0; |
646 | } |
647 | |
648 | //#include "../../frontend/plugin_lib.h" |
649 | |
650 | static const struct rearmed_cbs *cbs; |
651 | |
652 | /* acting as both renderer and vout handler here .. */ |
653 | void renderer_set_config(const struct rearmed_cbs *cbs_) |
654 | { |
655 | cbs = cbs_; |
656 | |
657 | iOffscreenDrawing = 0; |
658 | iZBufferDepth = 0; |
659 | iFrameReadType = 0; |
660 | bKeepRatio = TRUE; |
661 | |
662 | dwActFixes = cbs->gpu_peopsgl.dwActFixes; |
663 | bDrawDither = cbs->gpu_peopsgl.bDrawDither; |
664 | iFilterType = cbs->gpu_peopsgl.iFilterType; |
665 | iFrameTexType = cbs->gpu_peopsgl.iFrameTexType; |
666 | iUseMask = cbs->gpu_peopsgl.iUseMask; |
667 | bOpaquePass = cbs->gpu_peopsgl.bOpaquePass; |
668 | bAdvancedBlend = cbs->gpu_peopsgl.bAdvancedBlend; |
669 | bUseFastMdec = cbs->gpu_peopsgl.bUseFastMdec; |
670 | iTexGarbageCollection = cbs->gpu_peopsgl.iTexGarbageCollection; |
671 | iVRamSize = cbs->gpu_peopsgl.iVRamSize; |
672 | } |
673 | |
674 | void vout_set_config(const struct rearmed_cbs *cbs) |
675 | { |
676 | } |
677 | |
678 | void SetAspectRatio(void) |
679 | { |
680 | cbs->pl_get_layer_pos(&rRatioRect.left, &rRatioRect.top, &rRatioRect.right, &rRatioRect.bottom); |
681 | |
682 | glScissor(rRatioRect.left, |
683 | iResY-(rRatioRect.top+rRatioRect.bottom), |
684 | rRatioRect.right,rRatioRect.bottom); |
685 | glViewport(rRatioRect.left, |
686 | iResY-(rRatioRect.top+rRatioRect.bottom), |
687 | rRatioRect.right,rRatioRect.bottom); |
688 | glError(); |
689 | } |