trunk/src/mame/drivers/namcos23.c
| r29178 | r29179 | |
| 1605 | 1605 | return m_matrices[id]; |
| 1606 | 1606 | } |
| 1607 | 1607 | |
| 1608 | | void namcos23_state::c435_matrix_matrix_mul() // 000. |
| 1608 | void namcos23_state::c435_matrix_matrix_mul() // 0.0 |
| 1609 | 1609 | { |
| 1610 | | if(m_c435_buffer[0] != 0x0004) |
| 1610 | if((m_c435_buffer[0] & 0xf) != 4) |
| 1611 | 1611 | { |
| 1612 | 1612 | logerror("WARNING: c435_matrix_matrix_mul with size %d\n", m_c435_buffer[0] & 0xf); |
| 1613 | 1613 | return; |
| r29178 | r29179 | |
| 1630 | 1630 | t[8] = INT16((m1[6]*m2[6] + m1[7]*m2[7] + m1[8]*m2[8]) >> 14); |
| 1631 | 1631 | } |
| 1632 | 1632 | |
| 1633 | | void namcos23_state::c435_matrix_set() // 004. |
| 1633 | void namcos23_state::c435_matrix_vector_mul() // 0.1 |
| 1634 | 1634 | { |
| 1635 | | if(m_c435_buffer[0] != 0x004a) |
| 1635 | if((m_c435_buffer[0] & 0xf) != 4) |
| 1636 | 1636 | { |
| 1637 | | logerror("WARNING: c435_matrix_set with size %d\n", m_c435_buffer[0] & 0xf); |
| 1638 | | return; |
| 1639 | | } |
| 1640 | | INT16 *t = c435_getm(m_c435_buffer[1]); |
| 1641 | | for(int i=0; i<9; i++) |
| 1642 | | t[i] = m_c435_buffer[i+2]; |
| 1643 | | } |
| 1644 | | |
| 1645 | | void namcos23_state::c435_vector_set() // 005. |
| 1646 | | { |
| 1647 | | if(m_c435_buffer[0] != 0x0057) |
| 1648 | | { |
| 1649 | | logerror("WARNING: c435_vector_set with size %d\n", m_c435_buffer[0] & 0xf); |
| 1650 | | return; |
| 1651 | | } |
| 1652 | | INT32 *t = c435_getv(m_c435_buffer[1]); |
| 1653 | | for(int i=0; i<3; i++) |
| 1654 | | t[i] = u32_to_s24((m_c435_buffer[2*i+2] << 16) | m_c435_buffer[2*i+3]); |
| 1655 | | } |
| 1656 | | |
| 1657 | | void namcos23_state::c435_matrix_vector_mul() // 081. |
| 1658 | | { |
| 1659 | | if(m_c435_buffer[0] != 0x0814) |
| 1660 | | { |
| 1661 | 1637 | logerror("WARNING: c435_matrix_vector_mul with size %d\n", m_c435_buffer[0] & 0xf); |
| 1662 | 1638 | return; |
| 1663 | 1639 | } |
| r29178 | r29179 | |
| 1673 | 1649 | t[2] = INT32((m[6]*INT64(v[0]) + m[7]*INT64(v[1]) + m[8]*INT64(v[2])) >> 14); |
| 1674 | 1650 | } |
| 1675 | 1651 | |
| 1676 | | void namcos23_state::c435_vector_matrix_mul() // 101. |
| 1652 | void namcos23_state::c435_matrix_set() // 0.4 |
| 1677 | 1653 | { |
| 1678 | | if(m_c435_buffer[0] != 0x1014) |
| 1654 | if((m_c435_buffer[0] & 0xf) != 10) |
| 1679 | 1655 | { |
| 1680 | | logerror("WARNING: c435_vector_matrix_mul with size %d\n", m_c435_buffer[0] & 0xf); |
| 1656 | logerror("WARNING: c435_matrix_set with size %d\n", m_c435_buffer[0] & 0xf); |
| 1681 | 1657 | return; |
| 1682 | 1658 | } |
| 1683 | | if(m_c435_buffer[3] != 0xffff) |
| 1684 | | logerror("WARNING: c435_vector_matrix_mul with [3]=%04x\n", m_c435_buffer[3]); |
| 1659 | INT16 *t = c435_getm(m_c435_buffer[1]); |
| 1660 | for(int i=0; i<9; i++) |
| 1661 | t[i] = m_c435_buffer[i+2]; |
| 1662 | } |
| 1685 | 1663 | |
| 1686 | | INT32 *t = c435_getv(m_c435_buffer[1]); |
| 1687 | | const INT16 *m = c435_getm(m_c435_buffer[2]); |
| 1688 | | const INT32 *v = c435_getv(m_c435_buffer[4]); |
| 1689 | | |
| 1690 | | t[0] = INT32((m[0]*INT64(v[0]) + m[1]*INT64(v[1]) + m[2]*INT64(v[2])) >> 14); |
| 1691 | | t[1] = INT32((m[3]*INT64(v[0]) + m[4]*INT64(v[1]) + m[5]*INT64(v[2])) >> 14); |
| 1692 | | t[2] = INT32((m[6]*INT64(v[0]) + m[7]*INT64(v[1]) + m[8]*INT64(v[2])) >> 14); |
| 1664 | void namcos23_state::c435_vector_set() // 0.5 |
| 1665 | { |
| 1666 | if((m_c435_buffer[0] & 0xf) != 7) |
| 1667 | { |
| 1668 | logerror("WARNING: c435_vector_set with size %d\n", m_c435_buffer[0] & 0xf); |
| 1669 | return; |
| 1670 | } |
| 1671 | INT32 *t = c435_getv(m_c435_buffer[1]); |
| 1672 | for(int i=0; i<3; i++) |
| 1673 | t[i] = u32_to_s24((m_c435_buffer[2*i+2] << 16) | m_c435_buffer[2*i+3]); |
| 1693 | 1674 | } |
| 1694 | 1675 | |
| 1695 | | void namcos23_state::c435_scaling_set() // 44.. |
| 1676 | void namcos23_state::c435_scaling_set() // 4.4 |
| 1696 | 1677 | { |
| 1697 | | if(m_c435_buffer[0] != 0x4401) |
| 1678 | if((m_c435_buffer[0] & 0xff) != 1) |
| 1698 | 1679 | { |
| 1699 | 1680 | logerror("WARNING: c435_scaling_set with size %d\n", m_c435_buffer[0] & 0xff); |
| 1700 | 1681 | return; |
| r29178 | r29179 | |
| 1702 | 1683 | m_scaling = m_c435_buffer[1]; |
| 1703 | 1684 | } |
| 1704 | 1685 | |
| 1705 | | void namcos23_state::c435_state_set_interrupt() // 4f.. 0001 |
| 1686 | void namcos23_state::c435_state_set_interrupt() // 4.f.0001 |
| 1706 | 1687 | { |
| 1707 | 1688 | if(m_c435_buffer[0] != 0x4f02) |
| 1708 | 1689 | { |
| r29178 | r29179 | |
| 1715 | 1696 | update_main_interrupts(m_main_irqcause & ~MAIN_C435_IRQ); |
| 1716 | 1697 | } |
| 1717 | 1698 | |
| 1718 | | void namcos23_state::c435_state_set() // 4f.. |
| 1699 | void namcos23_state::c435_state_set() // 4.f |
| 1719 | 1700 | { |
| 1720 | | if(m_c435_buffer[0] == 0x4f00) |
| 1701 | if((m_c435_buffer[0] & 0xff) == 0) |
| 1721 | 1702 | { |
| 1722 | 1703 | logerror("WARNING: c435_state_set with size %d\n", m_c435_buffer[0] & 0xff); |
| 1723 | 1704 | return; |
| r29178 | r29179 | |
| 1730 | 1711 | } |
| 1731 | 1712 | } |
| 1732 | 1713 | |
| 1733 | | void namcos23_state::c435_render() // 800. 808. |
| 1714 | void namcos23_state::c435_render() // 8 |
| 1734 | 1715 | { |
| 1735 | | if(m_c435_buffer[0] != 0x8003 && m_c435_buffer[0] != 0x8043 && m_c435_buffer[0] != 0x8083) |
| 1716 | if((m_c435_buffer[0] & 0xf) != 3) |
| 1736 | 1717 | { |
| 1737 | | logerror("WARNING: c435_render with header %04x\n", m_c435_buffer[0]); |
| 1718 | logerror("WARNING: c435_render with size %d, header %04x", m_c435_buffer[0] & 0xf, m_c435_buffer[0]); |
| 1738 | 1719 | return; |
| 1739 | 1720 | } |
| 1740 | 1721 | |
| r29178 | r29179 | |
| 1770 | 1751 | render.count[render.cur]++; |
| 1771 | 1752 | } |
| 1772 | 1753 | |
| 1773 | | void namcos23_state::c435_flush() // c00. |
| 1754 | void namcos23_state::c435_flush() // c |
| 1774 | 1755 | { |
| 1775 | | if(m_c435_buffer[0] != 0xc000) |
| 1756 | if((m_c435_buffer[0] & 0xf) != 0) |
| 1776 | 1757 | { |
| 1777 | 1758 | logerror("WARNING: c435_flush with size %d\n", m_c435_buffer[0] & 0xf); |
| 1778 | 1759 | return; |
| r29178 | r29179 | |
| 1789 | 1770 | { |
| 1790 | 1771 | m_c435_buffer[m_c435_buffer_pos++] = data; |
| 1791 | 1772 | UINT16 h = m_c435_buffer[0]; |
| 1792 | | UINT16 h1; |
| 1793 | 1773 | int psize; |
| 1794 | | if(h & 0x4000) |
| 1795 | | { |
| 1796 | | h1 = h & 0xff00; |
| 1774 | if((h & 0x4000) == 0x4000) |
| 1797 | 1775 | psize = h & 0xff; |
| 1798 | | } |
| 1799 | 1776 | else |
| 1800 | | { |
| 1801 | | h1 = h & 0xfff0; |
| 1802 | 1777 | psize = h & 0xf; |
| 1803 | | } |
| 1804 | 1778 | if(m_c435_buffer_pos < psize+1) |
| 1805 | 1779 | return; |
| 1806 | 1780 | |
| 1807 | | switch(h1) |
| 1808 | | { |
| 1809 | | case 0x0000: c435_matrix_matrix_mul(); break; |
| 1810 | | case 0x0040: c435_matrix_set(); break; |
| 1811 | | case 0x0050: c435_vector_set(); break; |
| 1812 | | case 0x0810: c435_matrix_vector_mul(); break; |
| 1813 | | case 0x1010: c435_vector_matrix_mul(); break; |
| 1814 | | case 0x4400: c435_scaling_set(); break; |
| 1815 | | case 0x4f00: c435_state_set(); break; |
| 1816 | | case 0x8000: c435_render(); break; |
| 1817 | | case 0x8040: c435_render(); break; |
| 1818 | | case 0x8080: c435_render(); break; |
| 1819 | | case 0xc000: c435_flush(); break; |
| 1820 | | default: |
| 1821 | | if(1) |
| 1822 | | { |
| 1823 | | logerror("c435 - [%04x]", h1); |
| 1824 | | for(int i=0; i<m_c435_buffer_pos; i++) |
| 1825 | | logerror(" %04x", m_c435_buffer[i]); |
| 1826 | | logerror("\n"); |
| 1781 | bool known = true; |
| 1782 | switch(h & 0xc000) { |
| 1783 | case 0x0000: |
| 1784 | switch(h & 0xf0) { |
| 1785 | case 0x00: c435_matrix_matrix_mul(); break; |
| 1786 | case 0x10: c435_matrix_vector_mul(); break; |
| 1787 | case 0x40: c435_matrix_set(); break; |
| 1788 | case 0x50: c435_vector_set(); break; |
| 1789 | default: known = false; break; |
| 1827 | 1790 | } |
| 1828 | 1791 | break; |
| 1792 | |
| 1793 | case 0x4000: |
| 1794 | switch(h & 0xf00) { |
| 1795 | case 0x400: c435_scaling_set(); break; |
| 1796 | case 0xf00: c435_state_set(); break; |
| 1797 | default: known = false; break; |
| 1798 | } |
| 1799 | break; |
| 1800 | |
| 1801 | case 0x8000: c435_render(); break; |
| 1802 | case 0xc000: c435_flush(); break; |
| 1829 | 1803 | } |
| 1804 | |
| 1805 | if(!known) { |
| 1806 | logerror("c435 -"); |
| 1807 | for(int i=0; i<m_c435_buffer_pos; i++) |
| 1808 | logerror(" %04x", m_c435_buffer[i]); |
| 1809 | logerror("\n"); |
| 1810 | } |
| 1811 | |
| 1830 | 1812 | m_c435_buffer_pos = 0; |
| 1831 | 1813 | } |
| 1832 | 1814 | |