| Previous | 199869 Revisions | Next |
| r32031 Tuesday 9th September, 2014 at 19:04:23 UTC by Oliver Stöneberg |
|---|
| fixed most of the -Wunreachable-code-break and -Wunreachable-code-return warnings of clang 3.5 when compiling MAME (nw) |
| [src/emu/sound] | k053260.c zsg2.c |
| [src/emu/video] | h63484.c voodoo.c |
| [src/mame/drivers] | airbustr.c bmcbowl.c cbasebal.c chihiro.c cops.c cps3.c firebeat.c gottlieb.c hitpoker.c igs017.c jpmsys5.c lethal.c magictg.c mitchell.c model1.c model2.c mpu5hw.c namcos21.c nbmj9195.c segas24.c seibuspi.c vega.c viper.c |
| [src/mame/machine] | balsente.c harddriv.c igs025.c kaneko_hit.c model1.c model3.c namcos2.c nb1413m3.c stvprot.c williams.c |
| [src/mame/video] | k001604.c k051960.c leland.c metro.c model2.c model3.c namcos22.c nycaptor.c scn2674.c thief.c ygv608.c |
| r32030 | r32031 | |
|---|---|---|
| 711 | 711 | case 0x03: |
| 712 | 712 | fatalerror("HD63484 color modes (Pattern RAM indirect)\n"); |
| 713 | 713 | // TODO |
| 714 | break; | |
| 715 | 714 | } |
| 716 | 715 | |
| 717 | 716 | return false; |
| r32030 | r32031 | |
| 1766 | 1765 | default: |
| 1767 | 1766 | printf("%04x\n",m_cr); |
| 1768 | 1767 | fatalerror("stop!\n"); |
| 1769 | break; | |
| 1770 | 1768 | } |
| 1771 | 1769 | } |
| 1772 | 1770 |
| r32030 | r32031 | |
|---|---|---|
| 1654 | 1654 | case 2: /* RET */ |
| 1655 | 1655 | if (LOG_CMDFIFO) logerror(" RET $%06X\n", target); |
| 1656 | 1656 | fatalerror("RET in CMDFIFO!\n"); |
| 1657 | break; | |
| 1658 | 1657 | |
| 1659 | 1658 | case 3: /* JMP LOCAL FRAME BUFFER */ |
| 1660 | 1659 | if (LOG_CMDFIFO) logerror(" JMP LOCAL FRAMEBUF $%06X\n", target); |
| r32030 | r32031 | |
| 1670 | 1669 | default: |
| 1671 | 1670 | osd_printf_debug("INVALID JUMP COMMAND!\n"); |
| 1672 | 1671 | fatalerror(" INVALID JUMP COMMAND\n"); |
| 1673 | break; | |
| 1674 | 1672 | } |
| 1675 | 1673 | break; |
| 1676 | 1674 | |
| r32030 | r32031 | |
| 2889 | 2887 | /* send tmu config data to the frame buffer */ |
| 2890 | 2888 | v->send_config = (TREXINIT_SEND_TMU_CONFIG(data) > 0); |
| 2891 | 2889 | goto default_case; |
| 2892 | break; | |
| 2893 | 2890 | |
| 2894 | 2891 | /* these registers are referenced in the renderer; we must wait for pending work before changing */ |
| 2895 | 2892 | case chromaRange: |
| r32030 | r32031 | |
| 4571 | 4568 | |
| 4572 | 4569 | case cmdBump0: |
| 4573 | 4570 | fatalerror("cmdBump0\n"); |
| 4574 | break; | |
| 4575 | 4571 | |
| 4576 | 4572 | case cmdRdPtrL0: |
| 4577 | 4573 | v->fbi.cmdfifo[0].rdptr = data; |
| r32030 | r32031 | |
| 4608 | 4604 | |
| 4609 | 4605 | case cmdBump1: |
| 4610 | 4606 | fatalerror("cmdBump1\n"); |
| 4611 | break; | |
| 4612 | 4607 | |
| 4613 | 4608 | case cmdRdPtrL1: |
| 4614 | 4609 | v->fbi.cmdfifo[1].rdptr = data; |
| r32030 | r32031 | |
| 4956 | 4951 | |
| 4957 | 4952 | default: |
| 4958 | 4953 | fatalerror("Unsupported voodoo card in voodoo_start!\n"); |
| 4959 | break; | |
| 4960 | 4954 | } |
| 4961 | 4955 | |
| 4962 | 4956 | /* set the type, and initialize the chip mask */ |
| r32030 | r32031 | |
|---|---|---|
| 397 | 397 | |
| 398 | 398 | return status; |
| 399 | 399 | } |
| 400 | break; | |
| 401 | 400 | |
| 402 | 401 | case 0x2e: /* read ROM */ |
| 403 | 402 | if ( m_mode & 1 ) |
| r32030 | r32031 | |
|---|---|---|
| 448 | 448 | { |
| 449 | 449 | return control_r(offset - 0x300); |
| 450 | 450 | } |
| 451 | ||
| 452 | return 0; | |
| 453 | 451 | } |
| r32030 | r32031 | |
|---|---|---|
| 215 | 215 | return ret; |
| 216 | 216 | /*** ***/ |
| 217 | 217 | |
| 218 | return m_eeprom_data[m_eeprom_index & 0xfff]; | |
| 218 | // FIXME: never executed | |
| 219 | //return m_eeprom_data[m_eeprom_index & 0xfff]; | |
| 219 | 220 | } |
| 220 | 221 | |
| 221 | 222 | READ8_MEMBER(hitpoker_state::hitpoker_pic_r) |
| r32030 | r32031 | |
|---|---|---|
| 691 | 691 | else |
| 692 | 692 | { |
| 693 | 693 | fatalerror("????\n"); |
| 694 | return 0; | |
| 695 | 694 | } |
| 696 | 695 | } |
| 697 | 696 |
| r32030 | r32031 | |
|---|---|---|
| 215 | 215 | case 0x1013: return 0; |
| 216 | 216 | default: return 0x46<<8; |
| 217 | 217 | } |
| 218 | break; | |
| 219 | 218 | } |
| 220 | 219 | logerror("Protection read @ %X\n",space.device().safe_pcbase()); |
| 221 | 220 | return machine().rand(); |
| r32030 | r32031 | |
|---|---|---|
| 391 | 391 | m_laserdisc_audio_address %= AUDIORAM_SIZE; |
| 392 | 392 | return result; |
| 393 | 393 | } |
| 394 | return 0; | |
| 394 | // never executed | |
| 395 | //return 0; | |
| 395 | 396 | } |
| 396 | 397 | |
| 397 | 398 |
| r32030 | r32031 | |
|---|---|---|
| 303 | 303 | { |
| 304 | 304 | return m_i8255->read( space, m_p2_data>>6); /* A6,A7 -> A0,A1 */ |
| 305 | 305 | } |
| 306 | break; | |
| 307 | 306 | |
| 308 | 307 | case 1: /* 04-07 */ |
| 309 | 308 | { |
| 310 | 309 | /* AY 3-8910 */ |
| 311 | 310 | m_ay8910->data_w(space, 0, offset); |
| 312 | 311 | return 0xff;//mame_rand(space.machine); |
| 313 | ||
| 314 | 312 | } |
| 315 | break; | |
| 316 | 313 | |
| 317 | 314 | case 2: /* 08-0b */ |
| 318 | 315 | { |
| r32030 | r32031 | |
| 327 | 324 | //register r ? |
| 328 | 325 | return m_ins8154->ins8154_r(space,offset&0x7f); |
| 329 | 326 | } |
| 330 | ||
| 331 | 327 | } |
| 332 | break; | |
| 333 | 328 | #if 0 |
| 334 | 329 | case 3: /* 0c-0f */ |
| 335 | 330 | { |
| r32030 | r32031 | |
|---|---|---|
| 957 | 957 | default: |
| 958 | 958 | return ioport("SYSTEM")->read(); |
| 959 | 959 | } |
| 960 | return 0xffffffff; | |
| 960 | // never executed | |
| 961 | //return 0xffffffff; | |
| 961 | 962 | } |
| 962 | 963 | |
| 963 | 964 | WRITE32_MEMBER(seibuspi_state::ejsakura_input_select_w) |
| r32030 | r32031 | |
|---|---|---|
| 152 | 152 | case 0xf0: |
| 153 | 153 | { |
| 154 | 154 | return asic_r32(space, offset&3,mem_mask); |
| 155 | break; | |
| 156 | 155 | } |
| 157 | 156 | |
| 158 | 157 | default: |
| r32030 | r32031 | |
|---|---|---|
| 781 | 781 | WRITE16_MEMBER(model1_state::md1_w) |
| 782 | 782 | { |
| 783 | 783 | COMBINE_DATA(m_display_list1+offset); |
| 784 | if(0 && offset) | |
| 785 | return; | |
| 784 | // never executed | |
| 785 | //if(0 && offset) | |
| 786 | // return; | |
| 786 | 787 | if(1 && m_dump) |
| 787 | 788 | logerror("TGP: md1_w %x, %04x @ %04x (%x)\n", offset, data, mem_mask, space.device().safe_pc()); |
| 788 | 789 | } |
| r32030 | r32031 | |
| 790 | 791 | WRITE16_MEMBER(model1_state::md0_w) |
| 791 | 792 | { |
| 792 | 793 | COMBINE_DATA(m_display_list0+offset); |
| 793 | if(0 && offset) | |
| 794 | return; | |
| 794 | // never executed | |
| 795 | //if(0 && offset) | |
| 796 | // return; | |
| 795 | 797 | if(1 && m_dump) |
| 796 | 798 | logerror("TGP: md0_w %x, %04x @ %04x (%x)\n", offset, data, mem_mask, space.device().safe_pc()); |
| 797 | 799 | } |
| r32030 | r32031 | |
|---|---|---|
| 852 | 852 | } |
| 853 | 853 | case 2: |
| 854 | 854 | fatalerror("egas24_state::irq_timer_start - case 2\n"); |
| 855 | break; | |
| 856 | 855 | case 3: { |
| 857 | 856 | int count = 0x1000 - irq_tval; |
| 858 | 857 | irq_timer->adjust(attotime::from_hz(TIMER_CLOCK)*count); |
| r32030 | r32031 | |
|---|---|---|
| 687 | 687 | { |
| 688 | 688 | return ioport("COINS")->read() << 8; |
| 689 | 689 | } |
| 690 | break; | |
| 691 | 690 | default: |
| 692 | 691 | { |
| 693 | 692 | logerror("coins read offset: %x",offset); |
| r32030 | r32031 | |
|---|---|---|
| 1905 | 1905 | default: |
| 1906 | 1906 | { |
| 1907 | 1907 | fatalerror("ibutton: unknown normal mode cmd %02X\n", data); |
| 1908 | break; | |
| 1909 | 1908 | } |
| 1910 | 1909 | } |
| 1911 | 1910 | break; |
| r32030 | r32031 | |
|---|---|---|
| 1768 | 1768 | // if(DEBUG_PRINTF) printf("unk read eeprom addr %04x, mask %08x\n", addr, mem_mask); |
| 1769 | 1769 | return 0x00000000; |
| 1770 | 1770 | } |
| 1771 | return 0x00000000; | |
| 1772 | 1771 | } |
| 1773 | 1772 | |
| 1774 | 1773 | WRITE32_MEMBER(cps3_state::cps3_eeprom_w) |
| r32030 | r32031 | |
|---|---|---|
| 319 | 319 | return 0; |
| 320 | 320 | else |
| 321 | 321 | return (232 - GUNY(1)); |
| 322 | break; | |
| 323 | 322 | case 2: |
| 324 | 323 | return GUNX(2) >> 1; |
| 325 | 324 | case 3: |
| r32030 | r32031 | |
| 327 | 326 | return 0; |
| 328 | 327 | else |
| 329 | 328 | return (232 - GUNY(2)); |
| 330 | break; | |
| 331 | 329 | } |
| 332 | 330 | |
| 333 | 331 | return 0; |
| r32030 | r32031 | |
|---|---|---|
| 1521 | 1521 | default: |
| 1522 | 1522 | fatalerror("voodoo3_pci_r: %08X at %08X\n", reg, device->machine().device("maincpu")->safe_pc()); |
| 1523 | 1523 | } |
| 1524 | return 0; | |
| 1524 | // never executed | |
| 1525 | //return 0; | |
| 1525 | 1526 | } |
| 1526 | 1527 | |
| 1527 | 1528 | static void voodoo3_pci_w(device_t *busdevice, device_t *device, int function, int reg, UINT32 data, UINT32 mem_mask) |
| r32030 | r32031 | |
| 1744 | 1745 | { |
| 1745 | 1746 | case 0x33: ds2430_state = DS2430_STATE_READ_ROM; break; |
| 1746 | 1747 | case 0xcc: ds2430_state = DS2430_STATE_MEM_FUNCTION; break; |
| 1747 | default: fatalerror("DS2430_w: unimplemented rom command %02X\n", ds2430_cmd); | |
| 1748 | default: fatalerror("DS2430_w: unimplemented rom command %02X\n", ds2430_cmd); | |
| 1748 | 1749 | } |
| 1749 | 1750 | } |
| 1750 | 1751 | break; |
| r32030 | r32031 | |
| 1758 | 1759 | switch (ds2430_cmd) |
| 1759 | 1760 | { |
| 1760 | 1761 | case 0xf0: ds2430_state = DS2430_STATE_READ_MEM_ADDRESS; break; |
| 1761 | default: fatalerror("DS2430_w: unimplemented mem function %02X\n", ds2430_cmd); | |
| 1762 | default: fatalerror("DS2430_w: unimplemented mem function %02X\n", ds2430_cmd); | |
| 1762 | 1763 | } |
| 1763 | 1764 | } |
| 1764 | 1765 | break; |
| r32030 | r32031 | |
|---|---|---|
| 245 | 245 | return (x & 0x00ff) >> 0; |
| 246 | 246 | else |
| 247 | 247 | return (x & 0xff00) >> 8; |
| 248 | } | |
| 248 | } | |
| 249 | 249 | |
| 250 | 250 | /* Reading eff4, F0 times must yield at most 80-1 consecutive |
| 251 | 251 | equal values */ |
| r32030 | r32031 | |
|---|---|---|
| 224 | 224 | return mahjong_input_r(space, offset - 1); |
| 225 | 225 | else |
| 226 | 226 | return ioport("IN0")->read(); |
| 227 | break; | |
| 228 | 227 | case 2: /* Block Block - dial control */ |
| 229 | 228 | if (offset) |
| 230 | 229 | return block_input_r(space, offset - 1); |
| 231 | 230 | else |
| 232 | 231 | return ioport("IN0")->read(); |
| 233 | break; | |
| 234 | 232 | case 3: /* Super Pang - simulate START 1 press to initialize EEPROM */ |
| 235 | 233 | return ioport(portnames[offset])->read(); |
| 236 | 234 | } |
| r32030 | r32031 | |
|---|---|---|
| 1989 | 1989 | switch (c) { |
| 1990 | 1990 | case 0: |
| 1991 | 1991 | return 0xff000000 + convert_r5g6b5_r8g8b8(color0); |
| 1992 | break; | |
| 1993 | 1992 | case 1: |
| 1994 | 1993 | return 0xff000000 + convert_r5g6b5_r8g8b8(color1); |
| 1995 | break; | |
| 1996 | 1994 | case 2: |
| 1997 | 1995 | cb = pal5bit(((color0m2 & 0x003e) + (color1 & 0x001f)) / 3); |
| 1998 | 1996 | cg = pal6bit(((color0m2 & 0x0fc0) + (color1 & 0x07e0)) / 3 >> 5); |
| 1999 | 1997 | cr = pal5bit(((color0m2 & 0x1f000) + color1) / 3 >> 11); |
| 2000 | 1998 | return 0xff000000 | (cr << 16) | (cg << 8) | (cb); |
| 2001 | break; | |
| 2002 | 1999 | case 3: |
| 2003 | 2000 | cb = pal5bit(((color1m2 & 0x003e) + (color0 & 0x001f)) / 3); |
| 2004 | 2001 | cg = pal6bit(((color1m2 & 0x0fc0) + (color0 & 0x07e0)) / 3 >> 5); |
| 2005 | 2002 | cr = pal5bit(((color1m2 & 0x1f000) + color0) / 3 >> 11); |
| 2006 | 2003 | return 0xff000000 | (cr << 16) | (cg << 8) | (cb); |
| 2007 | break; | |
| 2008 | 2004 | case 4: |
| 2009 | 2005 | return 0xff000000 + convert_r5g6b5_r8g8b8(color0); |
| 2010 | break; | |
| 2011 | 2006 | case 5: |
| 2012 | 2007 | return 0xff000000 + convert_r5g6b5_r8g8b8(color1); |
| 2013 | break; | |
| 2014 | 2008 | case 6: |
| 2015 | 2009 | cb = pal5bit(((color0 & 0x001f) + (color1 & 0x001f)) / 2); |
| 2016 | 2010 | cg = pal6bit(((color0 & 0x07e0) + (color1 & 0x07e0)) / 2 >> 5); |
| 2017 | 2011 | cr = pal5bit(((color0 & 0xf800) + (color1 & 0xf800)) / 2 >> 11); |
| 2018 | 2012 | return 0xff000000 | (cr << 16) | (cg << 8) | (cb); |
| 2019 | break; | |
| 2020 | 2013 | default: |
| 2021 | 2014 | return 0xff000000; |
| 2022 | break; | |
| 2023 | 2015 | } |
| 2024 | 2016 | case DXT3: |
| 2025 | 2017 | bx = x >> 2; |
| r32030 | r32031 | |
| 2038 | 2030 | switch (c) { |
| 2039 | 2031 | case 0: |
| 2040 | 2032 | return ((ca + (ca << 4)) << 24) + convert_r5g6b5_r8g8b8(color0); |
| 2041 | break; | |
| 2042 | 2033 | case 1: |
| 2043 | 2034 | return ((ca + (ca << 4)) << 24) + convert_r5g6b5_r8g8b8(color1); |
| 2044 | break; | |
| 2045 | 2035 | case 2: |
| 2046 | 2036 | cb = pal5bit((2 * (color0 & 0x001f) + (color1 & 0x001f)) / 3); |
| 2047 | 2037 | cg = pal6bit((2 * (color0 & 0x07e0) + (color1 & 0x07e0)) / 3 >> 5); |
| 2048 | 2038 | cr = pal5bit((2 * (color0 & 0xf800) + (color1 & 0xf800)) / 3 >> 11); |
| 2049 | 2039 | return ((ca + (ca << 4)) << 24) | (cr << 16) | (cg << 8) | (cb); |
| 2050 | break; | |
| 2051 | 2040 | default: |
| 2052 | 2041 | cb = pal5bit(((color0 & 0x001f) + 2 * (color1 & 0x001f)) / 3); |
| 2053 | 2042 | cg = pal6bit(((color0 & 0x07e0) + 2 * (color1 & 0x07e0)) / 3 >> 5); |
| 2054 | 2043 | cr = pal5bit(((color0 & 0xf800) + 2 * (color1 & 0xf800)) / 3 >> 11); |
| 2055 | 2044 | return ((ca + (ca << 4)) << 24) | (cr << 16) | (cg << 8) | (cb); |
| 2056 | break; | |
| 2057 | 2045 | } |
| 2058 | break; | |
| 2059 | 2046 | case A4R4G4B4: |
| 2060 | 2047 | to = dilated0[texture[number].dilate][x] + dilated1[texture[number].dilate][y]; // offset of texel in texture memory |
| 2061 | 2048 | a4r4g4b4 = *(((UINT16 *)texture[number].buffer) + to); // get texel color |
| r32030 | r32031 | |
| 2144 | 2131 | switch (c) { |
| 2145 | 2132 | case 0: |
| 2146 | 2133 | return (ca << 24) + convert_r5g6b5_r8g8b8(color0); |
| 2147 | break; | |
| 2148 | 2134 | case 1: |
| 2149 | 2135 | return (ca << 24) + convert_r5g6b5_r8g8b8(color1); |
| 2150 | break; | |
| 2151 | 2136 | case 2: |
| 2152 | 2137 | cb = pal5bit((2 * (color0 & 0x001f) + (color1 & 0x001f)) / 3); |
| 2153 | 2138 | cg = pal6bit((2 * (color0 & 0x07e0) + (color1 & 0x07e0)) / 3 >> 5); |
| 2154 | 2139 | cr = pal5bit((2 * (color0 & 0xf800) + (color1 & 0xf800)) / 3 >> 11); |
| 2155 | 2140 | return (ca << 24) | (cr << 16) | (cg << 8) | (cb); |
| 2156 | break; | |
| 2157 | 2141 | default: |
| 2158 | 2142 | cb = pal5bit(((color0 & 0x001f) + 2 * (color1 & 0x001f)) / 3); |
| 2159 | 2143 | cg = pal6bit(((color0 & 0x07e0) + 2 * (color1 & 0x07e0)) / 3 >> 5); |
| 2160 | 2144 | cr = pal5bit(((color0 & 0xf800) + 2 * (color1 & 0xf800)) / 3 >> 11); |
| 2161 | 2145 | return (ca << 24) | (cr << 16) | (cg << 8) | (cb); |
| 2162 | break; | |
| 2163 | 2146 | } |
| 2164 | 2147 | default: |
| 2165 | 2148 | return 0xff00ff00; |
| r32030 | r32031 | |
| 2192 | 2175 | switch (alpha_func) { |
| 2193 | 2176 | case nv2a_renderer::NEVER: |
| 2194 | 2177 | return; |
| 2195 | break; | |
| 2196 | 2178 | case nv2a_renderer::ALWAYS: |
| 2197 | 2179 | default: |
| 2198 | 2180 | break; |
| r32030 | r32031 | |
| 3563 | 3545 | case 0: |
| 3564 | 3546 | default: |
| 3565 | 3547 | return combiner.register_zero[index]; |
| 3566 | break; | |
| 3567 | 3548 | case 1: |
| 3568 | 3549 | return combiner.register_color0[index]; |
| 3569 | break; | |
| 3570 | 3550 | case 2: |
| 3571 | 3551 | return combiner.register_color1[index]; |
| 3572 | break; | |
| 3573 | 3552 | case 3: |
| 3574 | 3553 | return combiner.register_fogcolor[index]; |
| 3575 | break; | |
| 3576 | 3554 | case 4: |
| 3577 | 3555 | return combiner.register_primarycolor[index]; |
| 3578 | break; | |
| 3579 | 3556 | case 5: |
| 3580 | 3557 | return combiner.register_secondarycolor[index]; |
| 3581 | break; | |
| 3582 | 3558 | case 8: |
| 3583 | 3559 | return combiner.register_texture0color[index]; |
| 3584 | break; | |
| 3585 | 3560 | case 9: |
| 3586 | 3561 | return combiner.register_texture1color[index]; |
| 3587 | break; | |
| 3588 | 3562 | case 10: |
| 3589 | 3563 | return combiner.register_texture2color[index]; |
| 3590 | break; | |
| 3591 | 3564 | case 11: |
| 3592 | 3565 | return combiner.register_texture3color[index]; |
| 3593 | break; | |
| 3594 | 3566 | case 12: |
| 3595 | 3567 | return combiner.register_spare0[index]; |
| 3596 | break; | |
| 3597 | 3568 | case 13: |
| 3598 | 3569 | return combiner.register_spare1[index]; |
| 3599 | break; | |
| 3600 | 3570 | case 14: |
| 3601 | 3571 | return combiner.variable_sumclamp[index]; |
| 3602 | break; | |
| 3603 | 3572 | case 15: |
| 3604 | 3573 | return combiner.variable_EF[index]; |
| 3605 | break; | |
| 3606 | 3574 | } |
| 3607 | 3575 | |
| 3608 | return 0; | |
| 3576 | // never executed | |
| 3577 | //return 0; | |
| 3609 | 3578 | } |
| 3610 | 3579 | |
| 3611 | 3580 | float *nv2a_renderer::combiner_map_input_select3(int code) |
| r32030 | r32031 | |
| 3614 | 3583 | case 0: |
| 3615 | 3584 | default: |
| 3616 | 3585 | return combiner.register_zero; |
| 3617 | break; | |
| 3618 | 3586 | case 1: |
| 3619 | 3587 | return combiner.register_color0; |
| 3620 | break; | |
| 3621 | 3588 | case 2: |
| 3622 | 3589 | return combiner.register_color1; |
| 3623 | break; | |
| 3624 | 3590 | case 3: |
| 3625 | 3591 | return combiner.register_fogcolor; |
| 3626 | break; | |
| 3627 | 3592 | case 4: |
| 3628 | 3593 | return combiner.register_primarycolor; |
| 3629 | break; | |
| 3630 | 3594 | case 5: |
| 3631 | 3595 | return combiner.register_secondarycolor; |
| 3632 | break; | |
| 3633 | 3596 | case 8: |
| 3634 | 3597 | return combiner.register_texture0color; |
| 3635 | break; | |
| 3636 | 3598 | case 9: |
| 3637 | 3599 | return combiner.register_texture1color; |
| 3638 | break; | |
| 3639 | 3600 | case 10: |
| 3640 | 3601 | return combiner.register_texture2color; |
| 3641 | break; | |
| 3642 | 3602 | case 11: |
| 3643 | 3603 | return combiner.register_texture3color; |
| 3644 | break; | |
| 3645 | 3604 | case 12: |
| 3646 | 3605 | return combiner.register_spare0; |
| 3647 | break; | |
| 3648 | 3606 | case 13: |
| 3649 | 3607 | return combiner.register_spare1; |
| 3650 | break; | |
| 3651 | 3608 | case 14: |
| 3652 | 3609 | return combiner.variable_sumclamp; |
| 3653 | break; | |
| 3654 | 3610 | case 15: |
| 3655 | 3611 | return combiner.variable_EF; |
| 3656 | break; | |
| 3657 | 3612 | } |
| 3658 | 3613 | |
| 3659 | return 0; | |
| 3614 | // never executed | |
| 3615 | //return 0; | |
| 3660 | 3616 | } |
| 3661 | 3617 | |
| 3662 | 3618 | float *nv2a_renderer::combiner_map_output_select3(int code) |
| r32030 | r32031 | |
| 3664 | 3620 | switch (code) { |
| 3665 | 3621 | case 0: |
| 3666 | 3622 | return 0; |
| 3667 | break; | |
| 3668 | 3623 | case 1: |
| 3669 | 3624 | return 0; |
| 3670 | break; | |
| 3671 | 3625 | case 2: |
| 3672 | 3626 | return 0; |
| 3673 | break; | |
| 3674 | 3627 | case 3: |
| 3675 | 3628 | return 0; |
| 3676 | break; | |
| 3677 | 3629 | case 4: |
| 3678 | 3630 | return combiner.register_primarycolor; |
| 3679 | break; | |
| 3680 | 3631 | case 5: |
| 3681 | 3632 | return combiner.register_secondarycolor; |
| 3682 | break; | |
| 3683 | 3633 | case 8: |
| 3684 | 3634 | return combiner.register_texture0color; |
| 3685 | break; | |
| 3686 | 3635 | case 9: |
| 3687 | 3636 | return combiner.register_texture1color; |
| 3688 | break; | |
| 3689 | 3637 | case 10: |
| 3690 | 3638 | return combiner.register_texture2color; |
| 3691 | break; | |
| 3692 | 3639 | case 11: |
| 3693 | 3640 | return combiner.register_texture3color; |
| 3694 | break; | |
| 3695 | 3641 | case 12: |
| 3696 | 3642 | return combiner.register_spare0; |
| 3697 | break; | |
| 3698 | 3643 | case 13: |
| 3699 | 3644 | return combiner.register_spare1; |
| 3700 | break; | |
| 3701 | 3645 | case 14: |
| 3702 | 3646 | return 0; |
| 3703 | break; | |
| 3704 | 3647 | case 15: |
| 3705 | 3648 | default: |
| 3706 | 3649 | return 0; |
| 3707 | break; | |
| 3708 | 3650 | } |
| 3709 | ||
| 3710 | return 0; | |
| 3711 | 3651 | } |
| 3712 | 3652 | |
| 3713 | 3653 | float nv2a_renderer::combiner_map_input_function(int code,float value) |
| r32030 | r32031 | |
| 3717 | 3657 | switch (code) { |
| 3718 | 3658 | case 0: |
| 3719 | 3659 | return MAX(0.0,value); |
| 3720 | break; | |
| 3721 | 3660 | case 1: |
| 3722 | 3661 | t=MAX(value, 0.0); |
| 3723 | 3662 | return 1.0 - MIN(t, 1.0); |
| 3724 | break; | |
| 3725 | 3663 | case 2: |
| 3726 | 3664 | return 2.0 * MAX(0.0, value) - 1.0; |
| 3727 | break; | |
| 3728 | 3665 | case 3: |
| 3729 | 3666 | return -2.0 * MAX(0.0, value) + 1.0; |
| 3730 | break; | |
| 3731 | 3667 | case 4: |
| 3732 | 3668 | return MAX(0.0, value) - 0.5; |
| 3733 | break; | |
| 3734 | 3669 | case 5: |
| 3735 | 3670 | return -MAX(0.0, value) + 0.5; |
| 3736 | break; | |
| 3737 | 3671 | case 6: |
| 3738 | 3672 | return value; |
| 3739 | break; | |
| 3740 | 3673 | case 7: |
| 3741 | 3674 | default: |
| 3742 | 3675 | return -value; |
| 3743 | break; | |
| 3744 | 3676 | } |
| 3745 | 3677 | |
| 3746 | return 0; | |
| 3678 | // never executed | |
| 3679 | //return 0; | |
| 3747 | 3680 | } |
| 3748 | 3681 | |
| 3749 | 3682 | void nv2a_renderer::combiner_map_input_function3(int code,float *data) |
| r32030 | r32031 | |
| 3786 | 3719 | break; |
| 3787 | 3720 | case 6: |
| 3788 | 3721 | return; |
| 3789 | break; | |
| 3790 | 3722 | case 7: |
| 3791 | 3723 | default: |
| 3792 | 3724 | data[0]=-data[0]; |
| r32030 | r32031 | |
|---|---|---|
| 130 | 130 | { |
| 131 | 131 | case 0x01: |
| 132 | 132 | return ioport("KEY0")->read(); |
| 133 | break; | |
| 134 | 133 | case 0x02: |
| 135 | 134 | return ioport("KEY1")->read(); |
| 136 | break; | |
| 137 | 135 | case 0x04: |
| 138 | 136 | return ioport("KEY2")->read(); |
| 139 | break; | |
| 140 | 137 | case 0x08: |
| 141 | 138 | return ioport("KEY3")->read(); |
| 142 | break; | |
| 143 | 139 | case 0x10: |
| 144 | 140 | return ioport("KEY4")->read(); |
| 145 | break; | |
| 146 | 141 | default: |
| 147 | 142 | return (ioport("KEY0")->read() & ioport("KEY1")->read() & ioport("KEY2")->read() |
| 148 | 143 | & ioport("KEY3")->read() & ioport("KEY4")->read()); |
| 149 | break; | |
| 150 | 144 | } |
| 151 | ||
| 152 | return 0xff; | |
| 145 | // never executed | |
| 146 | //return 0xff; | |
| 153 | 147 | } |
| 154 | 148 | |
| 155 | 149 | READ8_MEMBER(nbmj9195_state::mscoutm_cpu_portc_r) |
| r32030 | r32031 | |
| 159 | 153 | { |
| 160 | 154 | case 0x01: |
| 161 | 155 | return ioport("KEY5")->read(); |
| 162 | break; | |
| 163 | 156 | case 0x02: |
| 164 | 157 | return ioport("KEY6")->read(); |
| 165 | break; | |
| 166 | 158 | case 0x04: |
| 167 | 159 | return ioport("KEY7")->read(); |
| 168 | break; | |
| 169 | 160 | case 0x08: |
| 170 | 161 | return ioport("KEY8")->read(); |
| 171 | break; | |
| 172 | 162 | case 0x10: |
| 173 | 163 | return ioport("KEY9")->read(); |
| 174 | break; | |
| 175 | 164 | default: |
| 176 | 165 | return (ioport("KEY5")->read() & ioport("KEY6")->read() & ioport("KEY7")->read() |
| 177 | 166 | & ioport("KEY8")->read() & ioport("KEY9")->read()); |
| 178 | break; | |
| 179 | 167 | } |
| 180 | return 0xff; | |
| 168 | // never executed | |
| 169 | //return 0xff; | |
| 181 | 170 | } |
| 182 | 171 | |
| 183 | 172 | |
| r32030 | r32031 | |
| 213 | 202 | { |
| 214 | 203 | case 0x01: |
| 215 | 204 | return ioport("KEY0")->read(); |
| 216 | break; | |
| 217 | 205 | case 0x02: |
| 218 | 206 | return ioport("KEY1")->read(); |
| 219 | break; | |
| 220 | 207 | case 0x04: |
| 221 | 208 | return ioport("KEY2")->read(); |
| 222 | break; | |
| 223 | 209 | case 0x08: |
| 224 | 210 | return ioport("KEY3")->read(); |
| 225 | break; | |
| 226 | 211 | case 0x10: |
| 227 | 212 | return ((ioport("KEY4")->read() & 0x7f) | (nbmj9195_dipsw_r() << 7)); |
| 228 | break; | |
| 229 | 213 | default: |
| 230 | 214 | return (ioport("KEY0")->read() & ioport("KEY1")->read() & ioport("KEY2")->read() & ioport("KEY3")->read() & (ioport("KEY4")->read() & 0x7f)); |
| 231 | break; | |
| 232 | 215 | } |
| 233 | return 0xff; | |
| 216 | // ever executed | |
| 217 | //return 0xff; | |
| 234 | 218 | } |
| 235 | 219 | |
| 236 | 220 | READ8_MEMBER(nbmj9195_state::others_cpu_portc_r) |
| r32030 | r32031 | |
| 240 | 224 | { |
| 241 | 225 | case 0x01: |
| 242 | 226 | return ioport("KEY5")->read(); |
| 243 | break; | |
| 244 | 227 | case 0x02: |
| 245 | 228 | return ioport("KEY6")->read(); |
| 246 | break; | |
| 247 | 229 | case 0x04: |
| 248 | 230 | return ioport("KEY7")->read(); |
| 249 | break; | |
| 250 | 231 | case 0x08: |
| 251 | 232 | return ioport("KEY8")->read(); |
| 252 | break; | |
| 253 | 233 | case 0x10: |
| 254 | 234 | return ioport("KEY9")->read() & 0x7f; |
| 255 | break; | |
| 256 | 235 | default: |
| 257 | 236 | return (ioport("KEY5")->read() & ioport("KEY6")->read() & ioport("KEY7")->read() & ioport("KEY8")->read() & (ioport("KEY9")->read() & 0x7f)); |
| 258 | break; | |
| 259 | 237 | } |
| 260 | return 0xff;; | |
| 238 | // never executed | |
| 239 | //return 0xff; | |
| 261 | 240 | } |
| 262 | 241 | |
| 263 | 242 |
| r32030 | r32031 | |
|---|---|---|
| 366 | 366 | logerror("Unknown io1_r, offset = %03x\n", offset); |
| 367 | 367 | return 0; |
| 368 | 368 | } |
| 369 | return 0; | |
| 370 | 369 | } |
| 371 | 370 | |
| 372 | 371 | WRITE8_MEMBER(cops_state::io1_w) |
| r32030 | r32031 | |
|---|---|---|
| 143 | 143 | return false; |
| 144 | 144 | |
| 145 | 145 | fatalerror("Copro FIFOIN underflow (at %08X)\n", device->safe_pc()); |
| 146 | return false; | |
| 147 | 146 | } |
| 148 | 147 | |
| 149 | 148 | r = m_copro_fifoin_data[m_copro_fifoin_rpos++]; |
| r32030 | r32031 | |
| 203 | 202 | if (m_copro_fifoin_num == COPRO_FIFOIN_SIZE) |
| 204 | 203 | { |
| 205 | 204 | fatalerror("Copro FIFOIN overflow (at %08X)\n", device->safe_pc()); |
| 206 | return; | |
| 207 | 205 | } |
| 208 | 206 | |
| 209 | 207 | //printf("COPRO FIFOIN at %08X, %08X, %f\n", device->safe_pc(), data, *(float*)&data); |
| r32030 | r32031 | |
| 272 | 270 | if (m_copro_fifoout_num == COPRO_FIFOOUT_SIZE) |
| 273 | 271 | { |
| 274 | 272 | fatalerror("Copro FIFOOUT overflow (at %08X)\n", device->safe_pc()); |
| 275 | return; | |
| 276 | 273 | } |
| 277 | 274 | |
| 278 | 275 | // logerror("COPRO FIFOOUT PUSH %08X, %f, %d\n", data, *(float*)&data,state->m_copro_fifoout_num); |
| r32030 | r32031 | |
| 308 | 305 | if (m_copro_fifoout_num == COPRO_FIFOOUT_SIZE) |
| 309 | 306 | { |
| 310 | 307 | fatalerror("Copro FIFOOUT overflow (at %08X)\n", m_tgp->pc()); |
| 311 | return; | |
| 312 | 308 | } |
| 313 | 309 | |
| 314 | 310 | // logerror("COPRO FIFOOUT PUSH %08X, %f, %d\n", data, *(float*)&data,m_copro_fifoout_num); |
| r32030 | r32031 | |
|---|---|---|
| 793 | 793 | namcos21_state *state = machine.driver_data<namcos21_state>(); |
| 794 | 794 | if( state->m_mpDspState->slaveOutputSize >= 4096 ) |
| 795 | 795 | { |
| 796 | logerror( "FATAL ERROR: SLAVE OVERFLOW (0x%x)\n",state->m_mpDspState->slaveOutputBuffer[0] ); | |
| 797 | exit(1); | |
| 798 | return; | |
| 796 | fatalerror( "FATAL ERROR: SLAVE OVERFLOW (0x%x)\n",state->m_mpDspState->slaveOutputBuffer[0] ); | |
| 799 | 797 | } |
| 800 | 798 | |
| 801 | 799 | /* append word to slave output buffer */ |
| r32030 | r32031 | |
|---|---|---|
| 51 | 51 | return m_palette->basemem().read8(offset); |
| 52 | 52 | else |
| 53 | 53 | return 0; |
| 54 | break; | |
| 55 | 54 | default: |
| 56 | 55 | return cbasebal_scrollram_r(space, offset); /* SCROLL */ |
| 57 | 56 | } |
| r32030 | r32031 | |
|---|---|---|
| 2372 | 2372 | |
| 2373 | 2373 | logerror("%s: read bitswap - val %04x -> %02x\n", machine().describe_context(), m_prot_val, res); |
| 2374 | 2374 | return res; |
| 2375 | ||
| 2376 | break; | |
| 2377 | 2375 | } |
| 2378 | 2376 | |
| 2379 | 2377 | default: |
| r32030 | r32031 | |
|---|---|---|
| 346 | 346 | // case 3: popmessage("blah %08x",space.device().safe_pc()); |
| 347 | 347 | default: return space.machine().rand(); |
| 348 | 348 | } |
| 349 | break; | |
| 350 | 349 | |
| 351 | 350 | case NAMCOS2_SUPER_WSTADIUM_92: |
| 352 | 351 | switch(offset) |
| r32030 | r32031 | |
|---|---|---|
| 1144 | 1144 | return m_ds3sdsp_regs[offset]; |
| 1145 | 1145 | } |
| 1146 | 1146 | |
| 1147 | return 0xff; | |
| 1147 | // never executed | |
| 1148 | //return 0xff; | |
| 1148 | 1149 | } |
| 1149 | 1150 | |
| 1150 | 1151 | |
| r32030 | r32031 | |
| 1209 | 1210 | return m_ds3xdsp_regs[offset]; |
| 1210 | 1211 | } |
| 1211 | 1212 | |
| 1212 | return 0xff; | |
| 1213 | // never executed | |
| 1214 | //return 0xff; | |
| 1213 | 1215 | } |
| 1214 | 1216 | |
| 1215 | 1217 |
| r32030 | r32031 | |
|---|---|---|
| 2078 | 2078 | if (state->m_copro_fifoin_num == FIFO_SIZE) |
| 2079 | 2079 | { |
| 2080 | 2080 | fatalerror("Copro FIFOIN overflow (at %08X)\n", space.device().safe_pc()); |
| 2081 | return; | |
| 2082 | 2081 | } |
| 2083 | 2082 | |
| 2084 | 2083 | state->m_copro_fifoin_data[state->m_copro_fifoin_wpos++] = data; |
| r32030 | r32031 | |
| 2123 | 2122 | if (m_copro_fifoout_num == FIFO_SIZE) |
| 2124 | 2123 | { |
| 2125 | 2124 | fatalerror("Copro FIFOOUT overflow (at %08X)\n", m_tgp->pc()); |
| 2126 | return; | |
| 2127 | 2125 | } |
| 2128 | 2126 | |
| 2129 | 2127 | m_copro_fifoout_data[m_copro_fifoout_wpos++] = data; |
| r32030 | r32031 | |
|---|---|---|
| 290 | 290 | default: // >= 5 |
| 291 | 291 | return 0x3f00 | BITSWAP8(m_kb_prot_hold, 5, 2, 9, 7, 10, 13, 12, 15); |
| 292 | 292 | } |
| 293 | ||
| 294 | return 0x3f00; | |
| 295 | //return 0; | |
| 296 | 293 | } |
| 297 | 294 | |
| 298 | 295 | case 0x40: |
| r32030 | r32031 | |
|---|---|---|
| 315 | 315 | |
| 316 | 316 | default: |
| 317 | 317 | fatalerror("RTC-72421: Unknown reg %02X\n", reg); |
| 318 | return 0; | |
| 319 | 318 | } |
| 320 | 319 | } |
| 321 | 320 |
| r32030 | r32031 | |
|---|---|---|
| 645 | 645 | return (data & 0xc0) | gun; |
| 646 | 646 | |
| 647 | 647 | // FIXME: this code is never reached |
| 648 | return 0; | |
| 648 | //return 0; | |
| 649 | 649 | } |
| 650 | 650 | |
| 651 | 651 |
| r32030 | r32031 | |
|---|---|---|
| 350 | 350 | case 0x04: return 0xff; |
| 351 | 351 | default: return 0xff; |
| 352 | 352 | } |
| 353 | break; | |
| 354 | 353 | case NB1413M3_MSJIKEN: |
| 355 | 354 | case NB1413M3_TELMAHJN: |
| 356 | 355 | if (root.ioport("DSWA")->read() & 0x80) |
| r32030 | r32031 | |
| 367 | 366 | } |
| 368 | 367 | } |
| 369 | 368 | else return root.ioport("JAMMA2")->read(); |
| 370 | break; | |
| 371 | 369 | case NB1413M3_PAIRSNB: |
| 372 | 370 | case NB1413M3_PAIRSTEN: |
| 373 | 371 | case NB1413M3_OHPAIPEE: |
| r32030 | r32031 | |
| 384 | 382 | default: return (root.ioport("KEY0")->read() & root.ioport("KEY1")->read() & root.ioport("KEY2")->read() |
| 385 | 383 | & root.ioport("KEY3")->read() & root.ioport("KEY4")->read()); |
| 386 | 384 | } |
| 387 | break; | |
| 388 | 385 | } |
| 389 | 386 | } |
| 390 | 387 | |
| r32030 | r32031 | |
| 402 | 399 | case 0x04: return root.ioport("IN2")->read(); |
| 403 | 400 | default: return 0xff; |
| 404 | 401 | } |
| 405 | break; | |
| 406 | 402 | case NB1413M3_MSJIKEN: |
| 407 | 403 | case NB1413M3_TELMAHJN: |
| 408 | 404 | if (root.ioport("DSWA")->read() & 0x80) |
| r32030 | r32031 | |
| 419 | 415 | } |
| 420 | 416 | } |
| 421 | 417 | else return root.ioport("JAMMA1")->read(); |
| 422 | break; | |
| 423 | 418 | case NB1413M3_PAIRSNB: |
| 424 | 419 | case NB1413M3_PAIRSTEN: |
| 425 | 420 | case NB1413M3_OHPAIPEE: |
| r32030 | r32031 | |
| 436 | 431 | default: return (root.ioport("KEY5")->read() & root.ioport("KEY6")->read() & root.ioport("KEY7")->read() |
| 437 | 432 | & root.ioport("KEY8")->read() & root.ioport("KEY9")->read()); |
| 438 | 433 | } |
| 439 | break; | |
| 440 | 434 | } |
| 441 | 435 | } |
| 442 | 436 |
| r32030 | r32031 | |
|---|---|---|
| 120 | 120 | |
| 121 | 121 | default: |
| 122 | 122 | fatalerror("kaneko_hit_r called, but m_hittype not set\n"); |
| 123 | return 0; | |
| 124 | 123 | } |
| 125 | 124 | } |
| 126 | 125 | |
| r32030 | r32031 | |
| 134 | 133 | |
| 135 | 134 | default: |
| 136 | 135 | fatalerror("kaneko_hit_r called, but m_hittype not set\n"); |
| 137 | break; | |
| 138 | 136 | } |
| 139 | 137 | } |
| 140 | 138 |
| r32030 | r32031 | |
|---|---|---|
| 493 | 493 | return res; |
| 494 | 494 | } |
| 495 | 495 | |
| 496 | return 0; | |
| 496 | // never executed | |
| 497 | //return 0; | |
| 497 | 498 | } |
| 498 | 499 | |
| 499 | 500 | UINT32 astrass_prot_read_callback( address_space &space, int protaddr, UINT32 key ) |
| r32030 | r32031 | |
| 537 | 538 | return res; |
| 538 | 539 | } |
| 539 | 540 | |
| 540 | return 0; | |
| 541 | // never executed | |
| 542 | //return 0; | |
| 541 | 543 | } |
| 542 | 544 | |
| 543 | 545 | UINT32 ffreveng_prot_read_callback( address_space &space, int protaddr, UINT32 key ) |
| r32030 | r32031 | |
|---|---|---|
| 754 | 754 | m_counter[which].readbyte = 0; |
| 755 | 755 | return (m_counter[which].count >> 8) & 0xff; |
| 756 | 756 | } |
| 757 | break; | |
| 758 | 757 | } |
| 759 | 758 | return 0; |
| 760 | 759 | } |
| r32030 | r32031 | |
|---|---|---|
| 21 | 21 | return m_sharedram[0x299] ? m_sharedram[0x298] : 0; |
| 22 | 22 | else |
| 23 | 23 | return 0; |
| 24 | ||
| 25 | return 0; | |
| 26 | 24 | } |
| 27 | 25 | |
| 28 | 26 | TILE_GET_INFO_MEMBER(nycaptor_state::get_tile_info) |
| r32030 | r32031 | |
|---|---|---|
| 279 | 279 | //logerror("%04x: read unknown 051937 address %x\n", device->cpu->safe_pc(), offset); |
| 280 | 280 | return 0; |
| 281 | 281 | } |
| 282 | ||
| 283 | return 0; | |
| 284 | 282 | } |
| 285 | 283 | |
| 286 | 284 | WRITE8_MEMBER( k051960_device::k051937_w ) |
| r32030 | r32031 | |
|---|---|---|
| 1050 | 1050 | } |
| 1051 | 1051 | return (data << 8); |
| 1052 | 1052 | } |
| 1053 | break; | |
| 1054 | 1053 | |
| 1055 | 1054 | case 0x01: /* P#1 - sprite data port */ |
| 1056 | 1055 | data = m_sprite_attribute_table.b[m_regs.s.saa]; |
| r32030 | r32031 | |
| 1096 | 1095 | } |
| 1097 | 1096 | return (data << 8); |
| 1098 | 1097 | } |
| 1099 | break; | |
| 1100 | 1098 | |
| 1101 | 1099 | case 0x05: |
| 1102 | 1100 | break; |
| r32030 | r32031 | |
|---|---|---|
| 228 | 228 | int result = 0xc000 | (addr>>3); |
| 229 | 229 | return (offset==0x03)?(result>>8):(result&0xff); |
| 230 | 230 | } |
| 231 | break; | |
| 232 | 231 | |
| 233 | 232 | case GFX_PORT: |
| 234 | 233 | { |
| r32030 | r32031 | |
| 255 | 254 | return 0x80>>dx; // no flip |
| 256 | 255 | } |
| 257 | 256 | } |
| 258 | break; | |
| 259 | 257 | } |
| 260 | 258 | |
| 261 | 259 | return thief_coprocessor.param[offset]; |
| r32030 | r32031 | |
|---|---|---|
| 588 | 588 | m_scn2674_spl1 = (data & 0x40); |
| 589 | 589 | m_scn2674_spl2 = (data & 0x80); |
| 590 | 590 | break; |
| 591 | ||
| 592 | break; | |
| 593 | 591 | } |
| 594 | 592 | } |
| 595 | 593 |
| r32030 | r32031 | |
|---|---|---|
| 1248 | 1248 | { |
| 1249 | 1249 | fatalerror( "SEGA 3D: Unknown rasterizer command %08x\n", raster->cur_command ); |
| 1250 | 1250 | } |
| 1251 | break; | |
| 1252 | 1251 | } |
| 1253 | 1252 | } |
| 1254 | 1253 | else |
| r32030 | r32031 | |
|---|---|---|
| 109 | 109 | |
| 110 | 110 | default: |
| 111 | 111 | fatalerror("Unexpected leland_gfx_port_w\n"); |
| 112 | break; | |
| 113 | 112 | } |
| 114 | 113 | } |
| 115 | 114 |
| r32030 | r32031 | |
|---|---|---|
| 689 | 689 | break; |
| 690 | 690 | default: |
| 691 | 691 | fatalerror("Unknown texture type: %02X\n", header >> 24); |
| 692 | break; | |
| 693 | 692 | } |
| 694 | 693 | } |
| 695 | 694 |
| r32030 | r32031 | |
|---|---|---|
| 252 | 252 | case 0: window_xmask = (128 * tile_size) - 1; break; |
| 253 | 253 | case 2: window_xmask = (64 * tile_size) - 1; break; |
| 254 | 254 | case 3: window_xmask = (32 * tile_size) - 1; break; |
| 255 | default: fatalerror("k001604_draw_back_layer(): layer_size %d\n", layer_size); | |
| 255 | default: fatalerror("k001604_draw_back_layer(): layer_size %d\n", layer_size); | |
| 256 | 256 | } |
| 257 | 257 | |
| 258 | 258 | window_ymask = pixmap.height() - 1; |
| r32030 | r32031 | |
|---|---|---|
| 703 | 703 | |
| 704 | 704 | default: |
| 705 | 705 | fatalerror("invalid node->type\n"); |
| 706 | break; | |
| 707 | 706 | } |
| 708 | 707 | free_scenenode(node); |
| 709 | 708 | node = next; |
| r32030 | r32031 | |
|---|---|---|
| 218 | 218 | else |
| 219 | 219 | return 0; |
| 220 | 220 | } |
| 221 | ||
| 222 | // shouldn't get here.. | |
| 223 | return 0; | |
| 224 | 221 | } |
| 225 | 222 | |
| 226 | 223 |
| Previous | 199869 Revisions | Next |