Previous 199869 Revisions Next

r35290 Thursday 26th February, 2015 at 15:11:29 UTC by Olivier Galibert
namcos23: Better state management [O. Galibert]
[src/mame/drivers]namcos23.c

trunk/src/mame/drivers/namcos23.c
r243801r243802
8484        return
8585
8686
87c8000000:
88  8011e384:
89   if((a2000000.w & 0xfff0 != 0x0080) (c417_r, 808e or 008e)
90     +10.w = 2
91     +16.w = 42
92     +16.w = 23c0
93     +10.w = 3
94     801deaf0.w *0x28 -> +12.w (fixed)
95
96
97
98
99':maincpu' (801142FC): unmapped program memory write to 0C800010 = 00020000 & FFFF0000
100':maincpu' (801143A8): unmapped program memory write to 0C800010 = 00020000 & FFFF0000
101':maincpu' (801143B4): unmapped program memory write to 0C800014 = 00000042 & 0000FFFF
102':maincpu' (801143C0): unmapped program memory write to 0C800014 = 000023C0 & 0000FFFF
103':maincpu' (801143CC): unmapped program memory write to 0C800010 = 00030000 & FFFF0000
104':maincpu' (801143E0): unmapped program memory write to 0C800010 = 00000000 & 0000FFFF
105':maincpu' (801143E0): unmapped program memory write to 0C800010 = 00000000 & 0000FFFF
106':maincpu' (801143E0): unmapped program memory write to 0C800010 = 00000000 & 0000FFFF
107':maincpu' (801143E0): unmapped program memory write to 0C800010 = 00000000 & 0000FFFF
108
87109****************************************************************************
88110
89111Namco System 23 and Super System 23 Hardware Overview (last updated 7th April 2013 at 12.49am)
r243801r243802
15201542   UINT16 nthword(const UINT32 *pSource, int offs);
15211543   inline INT32 u32_to_s24(UINT32 v);
15221544   inline INT32 u32_to_s10(UINT32 v);
1545   float f24_to_f32(UINT32 v);
1546
15231547   INT32 *c435_getv(UINT16 id);
15241548   INT16 *c435_getm(UINT16 id);
15251549
1550   void c435_state_set_interrupt(const UINT16 *param);
1551   void c435_state_set_projection_matrix_line(const UINT16 *param);
1552   void c435_state_set(UINT16 type, const UINT16 *param);
1553   int c435_get_state_entry_size(UINT16 type);
1554
15261555   void c435_matrix_matrix_mul();
15271556   void c435_matrix_set();
15281557   void c435_vector_set();
15291558   void c435_matrix_vector_mul();
15301559   void c435_vector_matrix_mul();
1560   void c435_state_set();
15311561   void c435_scaling_set();
1532   void c435_state_set_interrupt();
1533   void c435_state_set();
15341562   void c435_render();
15351563   void c435_flush();
15361564
r243801r243802
15801608   return v & 0x200 ? v | 0xfffffe00 : v & 0x1ff;
15811609}
15821610
1611float namcos23_state::f24_to_f32(UINT32 v)
1612{
1613   // 8 bits exponent, 16 mantissa
1614   // mantissa is 16-bits signed, 2-complement
1615   // value is m * 2**(e-46)
1616   // 1 is e=32, m=0x4000, -1 is e=31, m=0x8000
15831617
1618   // This code turns it into a standard float
1619   if(!v)
1620      return 0;
1621
1622   UINT32 r = v & 0x8000 ? 0x80000000 : 0;
1623   UINT16 m = r ? -v : v;
1624   UINT8 e = (v >> 16) + 0x60;
1625   while(!(m & 0x8000)) {
1626      m <<= 1;
1627      e--;
1628   }
1629
1630   r = r | (e << 23) | ((m & 0x7fff) << 8);
1631   return *(float *)&r;
1632}
1633
15841634INLINE UINT8 light(UINT8 c, float l)
15851635{
15861636   if(l < 1)
r243801r243802
16121662   return m_matrices[id];
16131663}
16141664
1665void namcos23_state::c435_state_set_interrupt(const UINT16 *param)
1666{
1667   if(param[0] & 1)
1668      update_main_interrupts(m_main_irqcause | MAIN_C435_IRQ);
1669   else
1670      update_main_interrupts(m_main_irqcause & ~MAIN_C435_IRQ);
1671}
1672
1673void namcos23_state::c435_state_set_projection_matrix_line(const UINT16 *param)
1674{
1675   // timecrs2:
1676   //   sx = 640/2, sy = 480/2, t = tan(fov/2) (fov=45 degrees)
1677   //   line 1: 1 0 -(sx-a)/(sx/t) 0 -1  0 -(sx+a)/(sx/t) 0
1678   //   line 2: 0 1 -(sy-b)/(sx/t) 0  0 -1 -(sy+b)/(sx/t) 0
1679   //   line 3: 0 0 -1             c  0  0              0 sx/t
1680
1681   logerror("projection matrix line:");
1682   for(int i=0; i<8; i++)
1683      logerror(" %f", f24_to_f32((param[2*i+1] << 16) | param[2*i+2]));
1684   logerror("\n");
1685}
1686
1687void namcos23_state::c435_state_set(UINT16 type, const UINT16 *param)
1688{
1689   switch(type) {
1690   case 0x0001: c435_state_set_interrupt(param); break;
1691   case 0x00c8: c435_state_set_projection_matrix_line(param); break;
1692   default:
1693      //      logerror("WARNING: Unhandled state type %04x\n", type);
1694      break;
1695   }
1696}
1697
1698int namcos23_state::c435_get_state_entry_size(UINT16 type)
1699{
1700   switch(type) {
1701   case 0x0001: return 1;
1702   case 0x0009: return 19;
1703   case 0x0042: return 41;
1704   case 0x0046: return 13;
1705   case 0x00c0: return 33;
1706   case 0x00c6: return 13;
1707   case 0x00c8: return 17;
1708   default:
1709      logerror("WARNING: Unknown size for state type %04x\n", type);
1710      return -1;
1711   }
1712}
1713
16151714void namcos23_state::c435_matrix_matrix_mul() // 0.0
16161715{
16171716   if((m_c435_buffer[0] & 0xf) != 4)
r243801r243802
16221721   if(m_c435_buffer[3] != 0xffff)
16231722      logerror("WARNING: c435_matrix_matrix_mul with +2=%04x\n", m_c435_buffer[3]);
16241723
1724
1725   if(0 && m_c435_buffer[0] != 0x0004)
1726      fprintf(stderr, "c435_matrix_matrix_mul header %04x\n", m_c435_buffer[0]);
1727   if(m_c435_buffer[3] != 0xffff)
1728      fprintf(stderr, "c435_matrix_matrix_mul with +2=%04x\n", m_c435_buffer[3]);
1729
1730
16251731   INT16 *t        = c435_getm(m_c435_buffer[1]);
16261732   const INT16 *m2 = c435_getm(m_c435_buffer[2]);
16271733   const INT16 *m1 = c435_getm(m_c435_buffer[4]);
r243801r243802
16451751      return;
16461752   }
16471753
1754   if(1 && m_c435_buffer[0] != 0x0814 && m_c435_buffer[0] != 0x1014)
1755      fprintf(stderr, "c435_matrix_vector_mul header %04x\n", m_c435_buffer[0]);
1756
1757
16481758   if(m_c435_buffer[3] != 0xffff) {
16491759      INT32 *t        = c435_getv(m_c435_buffer[1]);
16501760      const INT16 *m  = c435_getm(m_c435_buffer[2]);
r243801r243802
16731783      logerror("WARNING: c435_matrix_set with size %d\n", m_c435_buffer[0] & 0xf);
16741784      return;
16751785   }
1786
1787   if(m_c435_buffer[0] != 0x004a)
1788      fprintf(stderr, "c435_matrix_set header %04x\n", m_c435_buffer[0]);
1789
16761790   INT16 *t = c435_getm(m_c435_buffer[1]);
16771791   for(int i=0; i<9; i++)
16781792      t[i] = m_c435_buffer[i+2];
r243801r243802
16851799      logerror("WARNING: c435_vector_set with size %d\n", m_c435_buffer[0] & 0xf);
16861800      return;
16871801   }
1802   if(m_c435_buffer[0] != 0x057)
1803      fprintf(stderr, "c435_vector_set header %04x\n", m_c435_buffer[0]);
1804
16881805   INT32 *t = c435_getv(m_c435_buffer[1]);
16891806   for(int i=0; i<3; i++)
16901807      t[i] = u32_to_s24((m_c435_buffer[2*i+2] << 16) | m_c435_buffer[2*i+3]);
r243801r243802
17001817   m_scaling = m_c435_buffer[1];
17011818}
17021819
1703void namcos23_state::c435_state_set_interrupt() // 4.f.0001
1820void namcos23_state::c435_state_set() // 4.f
17041821{
1705   if(m_c435_buffer[0] != 0x4f02)
1822   if((m_c435_buffer[0] & 0xff) == 0)
17061823   {
1707      logerror("WARNING: c435_state_set_interrupt with size %d\n", m_c435_buffer[0] & 0xff);
1824      logerror("WARNING: c435_state_set with zero size\n");
17081825      return;
17091826   }
1710   if(m_c435_buffer[2] & 1)
1711      update_main_interrupts(m_main_irqcause | MAIN_C435_IRQ);
1712   else
1713      update_main_interrupts(m_main_irqcause & ~MAIN_C435_IRQ);
1714}
1715
1716void namcos23_state::c435_state_set() // 4.f
1717{
1718   if((m_c435_buffer[0] & 0xff) == 0)
1827   int size = c435_get_state_entry_size(m_c435_buffer[1]);
1828   if(size != (m_c435_buffer[0] & 0xff)-1)
17191829   {
1720      logerror("WARNING: c435_state_set with size %d\n", m_c435_buffer[0] & 0xff);
1830      logerror("WARNING: c435_state_set size disagreement (type=%04x, got %d, expected %d)\n", m_c435_buffer[1], (m_c435_buffer[0] & 0xff)-1, size);
17211831      return;
17221832   }
1723   switch(m_c435_buffer[1]) {
1724   case 0x0001: c435_state_set_interrupt(); break;
1725   default:
1726      logerror("WARNING: c435_state_set(%04x, ...)\n", m_c435_buffer[1]);
1727      break;
1728   }
1833
1834   c435_state_set(m_c435_buffer[1], m_c435_buffer+2);
17291835}
17301836
17311837void namcos23_state::c435_render() // 8
17321838{
17331839   if((m_c435_buffer[0] & 0xf) != 3)
17341840   {
1735      logerror("WARNING: c435_render with size %d, header %04x", m_c435_buffer[0] & 0xf, m_c435_buffer[0]);
1841      logerror("WARNING: c435_render with size %d, header %04x\n", m_c435_buffer[0] & 0xf, m_c435_buffer[0]);
17361842      return;
17371843   }
17381844
r243801r243802
17571863   re->model.scaling = use_scaling ? m_scaling / 16384.0 : 1.0;
17581864   memcpy(re->model.m, m, sizeof(re->model.m));
17591865   memcpy(re->model.v, v, sizeof(re->model.v));
1866   //   re->model.v[2] *= 768/420.0;
1867
17601868   if(0)
1761      fprintf(stderr, "Render %04x (%f %f %f %f %f %f %f %f %f) (%f %f %f)\n",
1869      fprintf(stderr, "Render %04x (%f %f %f %f %f %f %f %f %f) (%f %f %f) %f\n",
17621870            re->model.model,
17631871            re->model.m[0]/16384.0, re->model.m[1]/16384.0, re->model.m[2]/16384.0,
17641872            re->model.m[3]/16384.0, re->model.m[4]/16384.0, re->model.m[5]/16384.0,
17651873            re->model.m[6]/16384.0, re->model.m[7]/16384.0, re->model.m[8]/16384.0,
1766            re->model.v[0]/16384.0, re->model.v[1]/16384.0, re->model.v[2]/16384.0);
1874            re->model.v[0]/16384.0, re->model.v[1]/16384.0, re->model.v[2]/16384.0,
1875            re->model.scaling);
17671876
17681877   render.count[render.cur]++;
17691878}
r243801r243802
18391948
18401949void namcos23_state::c435_dma(address_space &space, UINT32 adr, UINT32 size)
18411950{
1951   UINT32 oadr = adr;
18421952   adr &= 0x1fffffff;
18431953
1954
1955   for(int pos=0; pos < size; pos += 2) {
1956      UINT16 v0, v1;
1957      v0 = space.read_word(adr+pos);
1958      v1 = space.read_word(adr+pos+2);
1959
1960      if(v0 == 0x8083 && v1 == 0x0d9e)
1961         fprintf(stderr, "adr=%x %04x %04x\n", oadr+pos, v0, v1);
1962   }
1963
18441964   for(int pos=0; pos < size; pos += 2)
18451965      c435_pio_w(space.read_word(adr+pos));
18461966}
r243801r243802
19322052   // 480/(2.34375/3.75) = 768
19332053
19342054   float w = pv.p[0] ? 1/pv.p[0] : 0;
2055#if 1
19352056   pv.x = 320 + 768*w*pv.x;
19362057   pv.y = 240 - 768*w*pv.y;
2058#else
2059   pv.x = 320 + 410*w*pv.x;
2060   pv.y = 240 - 410*w*pv.y;
2061#endif
19372062   pv.p[0] = w;
19382063}
19392064
r243801r243802
19592084void namcos23_state::render_one_model(const namcos23_render_entry *re)
19602085{
19612086   render_t &render = m_render;
2087   if(re->model.model < 0x80) {
2088      logerror("WARNING: model %02x requested\n", re->model.model);
2089      return;
2090   }
2091
2092   if(re->model.model == 3486)
2093      return;
2094
19622095   UINT32 adr = m_ptrom[re->model.model];
19632096   if(adr >= m_ptrom_limit)
19642097   {

https://github.com/mamedev/mame/commit/f36019032107d6845a5657a52aecc02970ac6efc

Previous 199869 Revisions Next

© 1997-2024 The MAME Team