compatible with existing v4 CHD readers, so I don't want
these out in the wild. We will need a version bump to add
this support properly.
I'll tackle this next (after fixing recent regressions).
and paths consistently for devices, I/O ports, memory
regions, memory banks, and memory shares. [Aaron Giles]
NOTE: there are likely regressions lurking here, mostly
due to devices not being properly found. I have temporarily
added more logging to -verbose to help understand what's
going on. Please let me know ASAP if anything that is being
actively worked on got broken.
As before, the driver device is the root device and all
other devices are owned by it. Previously all devices
were kept in a single master list, and the hierarchy was
purely logical. With this change, each device owns its
own list of subdevices, and the hierarchy is explicitly
manifest. This means when a device is removed, all of its
subdevices are automatically removed as well.
A side effect of this is that walking the device list is
no longer simple. To address this, a new set of iterator
classes is provided, which walks the device tree in a depth
first manner. There is a general device_iterator class for
walking all devices, plus templates for a device_type_iterator
and a device_interface_iterator which are used to build
iterators for identifying only devices of a given type or
with a given interface. Typedefs for commonly-used cases
(e.g., screen_device_iterator, memory_interface_iterator)
are provided. Iterators can also provide counts, and can
perform indexed lookups.
All device name lookups are now done relative to another
device. The maching_config and running_machine classes now
have a root_device() method to get the root of the hierarchy.
The existing machine->device("name") is now equivalent to
machine->root_device().subdevice("name").
A proper and normalized device path structure is now
supported. Device names that start with a colon are
treated as absolute paths from the root device. Device
names can also use a caret (^) to refer to the owning
device. Querying the device's tag() returns the device's
full path from the root. A new method basetag() returns
just the final tag.
The new pathing system is built on top of the
device_t::subtag() method, so anyone using that will
automatically support the new pathing rules. Each device
has its own internal map to cache successful lookups so
that subsequent lookups should be very fast.
Updated every place I could find that referenced devices,
memory regions, I/O ports, memory banks and memory shares
to leverage subtag/subdevice (or siblingtag/siblingdevice
which are built on top).
Removed the device_list class, as it doesn't apply any
more. Moved some of its methods into running_machine
instead.
Simplified the device callback system since the new
pathing can describe all of the special-case devices that
were previously handled manually.
Changed the core output function callbacks to be delegates.
Completely rewrote the validity checking mechanism. The
validity checker is now a proper C++ class, and temporarily
takes over the error and warning outputs. All errors and
warnings are collected during a session, and then output in
a consistent manner, with an explicit driver and source file
listed for each one, as well as additional device and/or
I/O port contexts where appropriate. Validity checkers
should no longer explicitly output this information, just
the error, assuming that the context is provided.
Rewrote the software_list_device as a modern device, getting
rid of the software_list_config abstraction and simplifying
things.
Changed the way FLAC compiles so that it works like other
external libraries, and also compiles successfully for MSVC
builds.
--------------------
Steal See (& Get Land) [N. A. Jimenez, M. Krug, ShiggsUnderground, C. Stefano, Ted Bailey, R. Mucciarelli, Smitdogg, The Dumping Union]
for drivers that used GFX_RAW support for 4bpp systems, and yet
we had a bunch of extra code to support it. Updated these drivers
to do without it and removed all the extra code for supporting
it.
functions and just inline mapped them to the class. Will do
a pass soon to actually update drivers to use the C++
methods directly. Also, the tilemap callbacks are now
delegates which should make for cleaner integrating into
modern devices and drivers going forward.
- Converted AI / VI / MI / RI / SI / PI into a modernized device
- PI DMA now takes place after an appropriate delay to simulate transfer time
- SP DMA no longer rejects transfers of 0 bytes (should transfer one 8-byte word)
allocates a given bitmap to match the screen size and resizes
it as appropriate when the screen size changes. Updated all
the obvious spots in the code where this could be leveraged.
Move allocate/resize methods in the bitmap classes down into
bitmap_t because they no longer have any dependency on the
bitmap format or type.
Ensured that the bitmap's palette remains set across a resize
call (it is lost doing an allocate).
strictly by the type. Also added code to more aggressively align
the bitmap base and rowbytes, and create a resize method which
attempts to re-use existing memory rather than always
reallocating.
test driver that (ab)uses the core to single step a CPU executing
arbitrary instructions and capturing before/after state and
tracking memory. Currently this driver is always compiled, but is
not referenced in mame.lst.
Also updated and modernized the dummy empty driver.
at the start or end of VBLANK depending on the video flag
VIDEO_UPDATE_AFTER_VBLANK. Replaced with SCREEN_VBLANK
callbacks which are called both at the start and end of
VBLANK, so you can operate either way, and be explicit
about it. Updated all callers.
Also updated screen_device to use device timers and some
other minor cleanups.
device_delegate which wraps a regular delegate and includes
a string pointer to a device tag, which can be simply
resolved later. Converted the screen_update delegates to
to be based on this. Changed the mechanism by which screen
formats are auto-deduced. Converted SCREEN_EOF to use these
delegates as well, so now there is MCFG_SCREEN_EOF_STATIC/
DRIVER/DEVICE just like MCFG_SCREEN_UPDATE.
almost certainly some regressions lurking. Let me know if
something seems busted.
Bitmaps are now strongly typed based on format. bitmap_t still
exists as an abstract base class, but it is almost never used.
Instead, format-specific bitmap classes are provided:
bitmap_ind8 == 8bpp indexed
bitmap_ind16 == 16bpp indexed
bitmap_ind32 == 32bpp indexed
bitmap_ind64 == 64bpp indexed
bitmap_rgb32 == 32bpp RGB
bitmap_argb32 == 32bpp ARGB
bitmap_yuy16 == 16bpp YUY
For each format, a generic pix() method is provided which
references pixels of the correct type. The old pix8/pix16/pix32/
pix64 methods still exist in the short term, but the only one
available is the one that matches the bitmap's pixel size. Note
also that the old RGB15 format bitmaps are no longer supported
at all.
Converted model1, megadriv, and stv drivers away from the RGB15
format bitmaps.
New auto_bitmap_<type>_alloc() macros are provided for allocating
the appropriate type of bitmap.
Screen update functions now must specify the correct bitmap type
as their input parameters. For static update functions the
SCREEN_UPDATE macro is now replaced with SCREEN_UPDATE_RGB32 and
SCREEN_UPDATE_IND16 macros. All existing drivers have been
updated to use the correct macros.
Screen update functions are now required for all screens; there
is no longer any default behavior of copying a "default" bitmap
to the screen (in fact the default bitmap has been deprecated).
Use one of the following to specify your screen_update callback:
MCFG_SCREEN_UPDATE_STATIC(name) - static functions
MCFG_SCREEN_UPDATE_DRIVER(class, func) - driver members
MCFG_SCREEN_UPDATE_DEVICE(tag, class, func) - device members
Because the target bitmap format can now be deduced from the
screen update function itself, the MCFG_SCREEN_FORMAT macro is
no longer necessary, and has been removed. If you specify a
screen update callback that takes a bitmap_ind16, then the screen
will be configured to use a 16bpp indexed bitmap, and if you
specify a callback that takes a bitmap_rgb32, then a 32bpp RGB
bitmap will be provided.
Extended the bitmap classes to support wrapping a subregion of
another bitmap, and cleaner allocation/resetting. The preferred
use of bitmaps now is to define them directly in drivers/devices
and use allocate() or wrap() to set them up, rather than
allocating them via auto_bitmap_*_alloc().
Several common devices needed overhauls or changes as a result
of the above changes:
* Reorganized the laserdisc base driver and all the laserdisc
drivers as modern C++ devices, cleaning the code up
considerably. Merged ldsound device into the laserdsc
device since modern devices are flexible enough to handle
it.
* Reorganized the v9938 device as a modern C++ device. Removed
v9938mod.c in favor of template functions in v9938.c directly.
* Added independent ind16 and rgb32 callbacks for TMS340x0 devices.
* All video devices are now hard-coded to either ind16 or rgb32
bitmaps. The most notable is the mc6845 which is rgb32, and
required changes to a number of consumers.
* Added screen_update methods to most video devices so they can be
directly called via MCFG_SCREEN_UPDATE_DEVICE instead of creating
tons of stub functions.
Not working due to recent addition of msm6242 device. Many games stall with "Timer Error" and this is one of them. Possible clash with Y2K bug in the MSM6242 "chip" or what the PCB expects.
New Clone Added
------------------------------------
Gals Panic S - Extra Edition (Europe) [Hartenberger, arcadiabay.de]
VM and IF flags from changing depending on privilege level.
Fixed exception error codes in protected mode.
Further work on virtual 8086 mode. EMM386 will now load, but will
still die a few seconds later.
Doesn't work due to missing graphics roms not dumped.
Note - The speed up isn't correct.
New Game Added
--------------------------------
Toy Land Adventure [f205v, The Dumping Union]
* Dumped and added Street Fighter III 3rd Strike
Euro BIOS, unlocked 2 new sets
* Reordered all sets per release date
* Minor fixes
New clones added
------------------------------------------------------------------------------------------------------
Street Fighter III 3rd Strike: Fight for the Future (Euro 990608) [Layne, Smitdogg, The Dumping Union]
Street Fighter III 3rd Strike: Fight for the Future (Euro 990512) [Layne, Smitdogg, The Dumping Union]
Uploading the quizrd34 CHD right now.
Next time something like this comes up, someone should contact me by /msg-ing MooglyGuy on IRC (EFNet). I get tons, tons of non-MAME-related e-mail to my mooglyguy@gmail address, so I make an explicit point of never checking it unless I want to catch up on the MAME mailing list, since I filter all MAME-related e-mails into a separate folder for asynchronous reading. Therefore, any synchronous communications should occur through other means.
and SCREEN_UPDATE(generic_bitmapped). In their place, each screen_device
now maintains a default bitmap which is automatically copied to the
screen on each update if no SCREEN_UPDATE function is provided and if
no driver_device::video_update override is present. This bitmap can be
found by querying the screen's new default_bitmap() method. [Aaron Giles]
parameters for the global SCREEN_UPDATE callback match the parameters
for the driver_device version. Added allocate() and deallocate()
methods to bitmap_t to permit cleaner handling of bitmaps in drivers
and modern devices. [Aaron Giles]
-----------------------------------
Quizard 1.8 [Klaus Sommer, Team Europe, The Dumping Union]
Quizard 2.3 [Klaus Sommer, Team Europe, The Dumping Union]
New games added as NOT_WORKING
----------------------------------
Quizard 3.4 [Klaus Sommer, Team Europe, The Dumping Union]
(nw) Games will be on the FTP in roms/CHD/quizrd18 et al, soon... (nw)
cliprects mandatory everywhere. In general, cliprects were being
correctly passed through the video side of most drivers already, so
it is mostly a semantic change. Note that with my previous change,
bitmaps have cliprects, so if you just want to clip to the bitmap's
boundaries, pass bitmap->cliprect() instead of NULL (which is no
longer permitted). [Aaron Giles]
macros with bitmap->pix* functions, and moved bitmap_fill() to bitmap->fill()
among other similar changes. Bitmap fields now only available via accessors.
Replaced sect_rect with &= and union_rect with |= operators for rectangle
classes. Some general cleanup as a result of these changes. [Aaron Giles]
