Miroirs/mame
1
0
Fork 0
mirror of https://github.com/mamedev/mame.git synced 2024-09-29 17:38:18 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

Minor cosmetic changes for netlist

Browse source
This commit is contained in:
Couriersud 2014-02-26 00:21:06 +00:00
parent 13b36398f9
commit c32fba0da7
19 changed files with 1693 additions and 339 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
nl_examples/bjt_eb.c
View file

@ -36,7 +36,7 @@ NETLIST_START(bjt)
NET_C(RCE.1, Q.C)
NET_C(RCE.2, GND)
LOG(logB, Q.B)
LOG(logC, Q.C)
//LOG(logB, Q.B)
//LOG(logC, Q.C)
NETLIST_END()

2
nl_examples/vccs.c
View file

@ -13,7 +13,7 @@ NETLIST_START(vccs)
PARAM(Solver.ACCURACY, 1e-12)
PARAM(Solver.RESCHED_LOOPS, 10000)
NETDEV_VCCS(VV)
VCCS(VV)
PARAM(VV.G, 100) // typical OP-AMP amplification
RES(R2, 1)

2
nl_examples/vccs1.c
View file

@ -13,7 +13,7 @@ NETLIST_START(vccs)
PARAM(Solver.ACCURACY, 1e-6)
NETDEV_VCCS(VV)
VCCS(VV)
PARAM(VV.G, 100000) // typical OP-AMP amplification
RES(R1, 10000)
RES(R2, 1)

9
src/emu/drawgfxm.h
View file

@ -147,6 +147,15 @@ do
} \
while (0)
#define PIXEL_OP_REMAP_TRANSPEN_IND16(DEST, PRIORITY, SOURCE) \
do \
{ \
UINT32 srcdata = (SOURCE); \
if (srcdata != transpen) \
(DEST) = srcdata + palbase; \
} \
while (0) \
/*-------------------------------------------------
PIXEL_OP_REBASE_TRANSPEN - render all pixels
except those matching 'transpen', adding

10
src/emu/emualloc.c
View file

@ -574,6 +574,16 @@ void memory_entry::report_unfreed()
fprintf(stderr, "--- memory leak warning ---\n");
total += entry->m_size;
fprintf(stderr, "#%06d, nofree %d bytes (%s:%d)\n", (UINT32)entry->m_id, static_cast<UINT32>(entry->m_size), entry->m_file, (int)entry->m_line);
char * p = static_cast<char *>(entry->m_base);
for (int i = 0; i< entry->m_size; i++)
{
char c = p[i];
if (c>=32 && c<127)
fprintf(stderr, "%c", c);
else
fprintf(stderr, ".");
}
fprintf(stderr,"\n");
}
release_lock();

2
src/emu/machine/netlist.h
View file

@ -98,7 +98,7 @@
// ----------------------------------------------------------------------------------------
#define NETLIST_MEMREGION(_name) \
netlist.parse((char *)downcast<netlist_mame_t &>(netlist.netlist()).machine().root_device().memregion(_name)->base());
setup.parse((char *)downcast<netlist_mame_t &>(setup.netlist()).machine().root_device().memregion(_name)->base());
#define NETDEV_ANALOG_CALLBACK_MEMBER(_name) \
void _name(const double data, const attotime &time)

6
src/emu/netlist/analog/nld_fourterm.h
View file

@ -14,13 +14,11 @@
// Macros
// ----------------------------------------------------------------------------------------
#define NETDEV_VCCS(_name) \
#define VCCS(_name) \
NET_REGISTER_DEV(VCCS, _name)
//NETDEV_PARAMI(_name, model, _model)
#define NETDEV_VCVS(_name) \
#define VCVS(_name) \
NET_REGISTER_DEV(VCVS, _name)
//NETDEV_PARAMI(_name, model, _model)
// ----------------------------------------------------------------------------------------
// nld_CCCS

286
src/emu/netlist/analog/nld_solver.c
View file

@ -5,6 +5,7 @@
#include "nld_solver.h"
#include "nld_twoterm.h"
#include "../nl_lists.h"
#if HAS_OPENMP
#include "omp.h"
@ -19,73 +20,73 @@
ATTR_COLD void netlist_matrix_solver_t::setup(netlist_net_t::list_t &nets, NETLIB_NAME(solver) &aowner)
{
m_owner = &aowner;
m_owner = &aowner;
NL_VERBOSE_OUT(("New solver setup\n"));
NL_VERBOSE_OUT(("New solver setup\n"));
for (netlist_net_t * const * pn = nets.first(); pn != NULL; pn = nets.next(pn))
{
NL_VERBOSE_OUT(("setting up net\n"));
for (netlist_net_t * const * pn = nets.first(); pn != NULL; pn = nets.next(pn))
{
NL_VERBOSE_OUT(("setting up net\n"));
m_nets.add(*pn);
m_nets.add(*pn);
(*pn)->m_solver = this;
(*pn)->m_solver = this;
for (netlist_core_terminal_t *p = (*pn)->m_head; p != NULL; p = p->m_update_list_next)
{
NL_VERBOSE_OUT(("%s %s %d\n", p->name().cstr(), (*pn)->name().cstr(), (int) (*pn)->isRailNet()));
switch (p->type())
{
case netlist_terminal_t::TERMINAL:
switch (p->netdev().family())
{
case netlist_device_t::CAPACITOR:
if (!m_steps.contains(&p->netdev()))
m_steps.add(&p->netdev());
break;
case netlist_device_t::BJT_EB:
for (netlist_core_terminal_t *p = (*pn)->m_head; p != NULL; p = p->m_update_list_next)
{
NL_VERBOSE_OUT(("%s %s %d\n", p->name().cstr(), (*pn)->name().cstr(), (int) (*pn)->isRailNet()));
switch (p->type())
{
case netlist_terminal_t::TERMINAL:
switch (p->netdev().family())
{
case netlist_device_t::CAPACITOR:
if (!m_steps.contains(&p->netdev()))
m_steps.add(&p->netdev());
break;
case netlist_device_t::BJT_EB:
case netlist_device_t::DIODE:
//case netlist_device_t::VCVS:
case netlist_device_t::BJT_SWITCH:
//case netlist_device_t::VCVS:
case netlist_device_t::BJT_SWITCH:
NL_VERBOSE_OUT(("found BJT/Diode\n"));
if (!m_dynamic.contains(&p->netdev()))
m_dynamic.add(&p->netdev());
break;
default:
break;
}
{
netlist_terminal_t *pterm = static_cast<netlist_terminal_t *>(p);
if (pterm->m_otherterm->net().isRailNet())
(*pn)->m_rails.add(pterm);
else
(*pn)->m_terms.add(pterm);
}
NL_VERBOSE_OUT(("Added terminal\n"));
break;
case netlist_terminal_t::INPUT:
if (!m_inps.contains(p))
m_inps.add(p);
NL_VERBOSE_OUT(("Added input\n"));
break;
default:
owner().netlist().error("unhandled element found\n");
break;
}
}
if (!m_dynamic.contains(&p->netdev()))
m_dynamic.add(&p->netdev());
break;
default:
break;
}
{
netlist_terminal_t *pterm = static_cast<netlist_terminal_t *>(p);
if (pterm->m_otherterm->net().isRailNet())
(*pn)->m_rails.add(pterm);
else
(*pn)->m_terms.add(pterm);
}
NL_VERBOSE_OUT(("Added terminal\n"));
break;
case netlist_terminal_t::INPUT:
if (!m_inps.contains(p))
m_inps.add(p);
NL_VERBOSE_OUT(("Added input\n"));
break;
default:
owner().netlist().error("unhandled element found\n");
break;
}
}
NL_VERBOSE_OUT(("added net with %d populated connections (%d railnets)\n", (*pn)->m_terms.count(), (*pn)->m_rails.count()));
}
}
}
ATTR_HOT ATTR_HOT inline void netlist_matrix_solver_t::update_inputs()
ATTR_HOT void netlist_matrix_solver_t::update_inputs()
{
for (netlist_core_terminal_t * const *p = m_inps.first(); p != NULL; p = m_inps.next(p))
{
if ((*p)->net().m_last.Analog != (*p)->net().m_cur.Analog)
{
(*p)->netdev().update_dev();
}
}
for (netlist_core_terminal_t * const *p = m_inps.first(); p != NULL; p = m_inps.next(p))
{
if ((*p)->net().m_last.Analog != (*p)->net().m_cur.Analog)
{
(*p)->netdev().update_dev();
}
}
for (netlist_core_terminal_t * const *p = m_inps.first(); p != NULL; p = m_inps.next(p))
{
(*p)->net().m_last.Analog = (*p)->net().m_cur.Analog;
@ -94,7 +95,7 @@ ATTR_HOT ATTR_HOT inline void netlist_matrix_solver_t::update_inputs()
}
ATTR_HOT ATTR_HOT inline void netlist_matrix_solver_t::update_dynamic()
ATTR_HOT void netlist_matrix_solver_t::update_dynamic()
{
/* update all non-linear devices */
for (netlist_core_device_t * const *p = m_dynamic.first(); p != NULL; p = m_dynamic.next(p))
@ -109,7 +110,7 @@ ATTR_HOT ATTR_HOT inline void netlist_matrix_solver_t::update_dynamic()
}
}
void netlist_matrix_solver_t::schedule()
ATTR_HOT void netlist_matrix_solver_t::schedule()
{
if (!solve())
{
@ -131,14 +132,14 @@ ATTR_COLD void netlist_matrix_solver_t::reset()
m_last_step = netlist_time::zero;
}
ATTR_HOT inline void netlist_matrix_solver_t::step(const netlist_time delta)
ATTR_HOT void netlist_matrix_solver_t::step(const netlist_time delta)
{
const double dd = delta.as_double();
for (int k=0; k < m_steps.count(); k++)
m_steps[k]->step_time(dd);
}
ATTR_HOT inline bool netlist_matrix_solver_t::solve()
ATTR_HOT bool netlist_matrix_solver_t::solve()
{
int resched_cnt = 0;
@ -162,14 +163,14 @@ ATTR_HOT inline bool netlist_matrix_solver_t::solve()
update_dynamic();
this_resched = solve_non_dynamic();
resched_cnt += this_resched;
} while (this_resched > 1 && resched_cnt < m_resched_loops);
} while (this_resched > 1 && resched_cnt < m_params.m_resched_loops);
}
else
{
resched_cnt = solve_non_dynamic();
//printf("resched_cnt %d %d\n", resched_cnt, m_resched_loops);
}
return (resched_cnt >= m_resched_loops);
return (resched_cnt >= m_params.m_resched_loops);
}
// ----------------------------------------------------------------------------------------
@ -240,7 +241,7 @@ ATTR_COLD void netlist_matrix_solver_direct_t<m_N, _storage_N>::setup(netlist_ne
}
template <int m_N, int _storage_N>
ATTR_HOT inline void netlist_matrix_solver_direct_t<m_N, _storage_N>::build_LE(
ATTR_HOT void netlist_matrix_solver_direct_t<m_N, _storage_N>::build_LE(
double (* RESTRICT A)[_storage_N],
double (* RESTRICT RHS))
{
@ -282,7 +283,7 @@ ATTR_HOT inline void netlist_matrix_solver_direct_t<m_N, _storage_N>::build_LE(
}
template <int m_N, int _storage_N>
ATTR_HOT inline void netlist_matrix_solver_direct_t<m_N, _storage_N>::gauss_LE(
ATTR_HOT void netlist_matrix_solver_direct_t<m_N, _storage_N>::gauss_LE(
double (* RESTRICT A)[_storage_N],
double (* RESTRICT RHS),
double (* RESTRICT x))
@ -324,11 +325,14 @@ ATTR_HOT inline void netlist_matrix_solver_direct_t<m_N, _storage_N>::gauss_LE(
{
double f1 = A[j][i] * f;
for (int k = i; k < N(); k++)
if (f1 != 0.0)
{
A[j][k] -= A[i][k] * f1;
for (int k = i; k < N(); k++)
{
A[j][k] -= A[i][k] * f1;
}
RHS[j] -= RHS[i] * f1;
}
RHS[j] -= RHS[i] * f1;
}
}
/* back substitution */
@ -353,7 +357,7 @@ ATTR_HOT inline void netlist_matrix_solver_direct_t<m_N, _storage_N>::gauss_LE(
}
template <int m_N, int _storage_N>
ATTR_HOT inline double netlist_matrix_solver_direct_t<m_N, _storage_N>::delta(
ATTR_HOT double netlist_matrix_solver_direct_t<m_N, _storage_N>::delta(
const double (* RESTRICT RHS),
const double (* RESTRICT V))
{
@ -370,7 +374,7 @@ ATTR_HOT inline double netlist_matrix_solver_direct_t<m_N, _storage_N>::delta(
}
template <int m_N, int _storage_N>
ATTR_HOT inline void netlist_matrix_solver_direct_t<m_N, _storage_N>::store(
ATTR_HOT void netlist_matrix_solver_direct_t<m_N, _storage_N>::store(
const double (* RESTRICT RHS),
const double (* RESTRICT V))
{
@ -404,7 +408,7 @@ ATTR_HOT int netlist_matrix_solver_direct_t<m_N, _storage_N>::solve_non_dynamic(
store(RHS, new_v);
if (err > this->m_accuracy * this->m_accuracy)
if (err > this->m_params.m_accuracy * this->m_params.m_accuracy)
{
return 2;
}
@ -419,7 +423,7 @@ ATTR_HOT int netlist_matrix_solver_direct_t<m_N, _storage_N>::solve_non_dynamic(
// netlist_matrix_solver - Direct1
// ----------------------------------------------------------------------------------------
ATTR_HOT inline int netlist_matrix_solver_direct1_t::solve_non_dynamic()
ATTR_HOT int netlist_matrix_solver_direct1_t::solve_non_dynamic()
{
#if 1
@ -454,7 +458,7 @@ ATTR_HOT inline int netlist_matrix_solver_direct1_t::solve_non_dynamic()
net->m_cur.Analog = net->m_new.Analog = new_val;
if (is_dynamic() && (cerr > m_accuracy * m_accuracy))
if (is_dynamic() && (cerr > m_params.m_accuracy * m_params.m_accuracy))
{
return 2;
}
@ -491,7 +495,7 @@ ATTR_HOT int netlist_matrix_solver_direct2_t::solve_non_dynamic()
{
double err = delta(RHS, new_val);
store(RHS, new_val);
if (err > m_accuracy * m_accuracy)
if (err > m_params.m_accuracy * m_params.m_accuracy)
return 2;
else
return 1;
@ -505,7 +509,7 @@ ATTR_HOT int netlist_matrix_solver_direct2_t::solve_non_dynamic()
// ----------------------------------------------------------------------------------------
template <int m_N, int _storage_N>
ATTR_HOT inline int netlist_matrix_solver_gauss_seidel_t<m_N, _storage_N>::solve_non_dynamic()
ATTR_HOT int netlist_matrix_solver_gauss_seidel_t<m_N, _storage_N>::solve_non_dynamic()
{
bool resched = false;
@ -547,7 +551,7 @@ ATTR_HOT inline int netlist_matrix_solver_gauss_seidel_t<m_N, _storage_N>::solve
RHS_t += terms[i]->m_Idr;
}
gabs_t *= m_convergence_factor;
gabs_t *= m_params.m_convergence_factor;
if (gabs_t > gtot_t)
{
// Actually 1.0 / g_tot * g_tot / (gtot_t + gabs_t)
@ -589,13 +593,13 @@ ATTR_HOT inline int netlist_matrix_solver_gauss_seidel_t<m_N, _storage_N>::solve
net->m_cur.Analog = net->m_new.Analog = new_val;
}
if (resched || cerr / m_nets.count() > m_accuracy * m_accuracy)
if (resched || cerr / m_nets.count() > m_params.m_accuracy * m_params.m_accuracy)
{
resched = true;
//last_resched_net = net;
}
resched_cnt++;
} while (resched && (resched_cnt < m_resched_loops / 3 ));
} while (resched && (resched_cnt < m_params.m_resched_loops / 3 ));
if (resched)
return m_fallback.solve_non_dynamic();
@ -611,64 +615,64 @@ typedef netlist_net_t::list_t *net_groups_t;
ATTR_COLD static bool already_processed(net_groups_t groups, int &cur_group, netlist_net_t *net)
{
if (net->isRailNet())
return true;
for (int i = 0; i <= cur_group; i++)
{
if (groups[i].contains(net))
return true;
}
return false;
if (net->isRailNet())
return true;
for (int i = 0; i <= cur_group; i++)
{
if (groups[i].contains(net))
return true;
}
return false;
}
ATTR_COLD static void process_net(net_groups_t groups, int &cur_group, netlist_net_t *net)
{
if (net->m_head == NULL)
return;
if (net->m_head == NULL)
return;
/* add the net */
SOLVER_VERBOSE_OUT(("add %d - %s\n", cur_group, net->name().cstr()));
groups[cur_group].add(net);
for (netlist_core_terminal_t *p = net->m_head; p != NULL; p = p->m_update_list_next)
{
SOLVER_VERBOSE_OUT(("terminal %s\n", p->name().cstr()));
if (p->isType(netlist_terminal_t::TERMINAL))
{
SOLVER_VERBOSE_OUT(("isterminal\n"));
netlist_terminal_t *pt = static_cast<netlist_terminal_t *>(p);
netlist_net_t *other_net = &pt->m_otherterm->net();
if (!already_processed(groups, cur_group, other_net))
process_net(groups, cur_group, other_net);
}
}
SOLVER_VERBOSE_OUT(("add %d - %s\n", cur_group, net->name().cstr()));
groups[cur_group].add(net);
for (netlist_core_terminal_t *p = net->m_head; p != NULL; p = p->m_update_list_next)
{
SOLVER_VERBOSE_OUT(("terminal %s\n", p->name().cstr()));
if (p->isType(netlist_terminal_t::TERMINAL))
{
SOLVER_VERBOSE_OUT(("isterminal\n"));
netlist_terminal_t *pt = static_cast<netlist_terminal_t *>(p);
netlist_net_t *other_net = &pt->m_otherterm->net();
if (!already_processed(groups, cur_group, other_net))
process_net(groups, cur_group, other_net);
}
}
}
NETLIB_START(solver)
{
register_output("Q_sync", m_Q_sync);
register_output("Q_step", m_Q_step);
//register_input("FB", m_feedback);
register_output("Q_sync", m_Q_sync);
register_output("Q_step", m_Q_step);
//register_input("FB", m_feedback);
register_param("SYNC_DELAY", m_sync_delay, NLTIME_FROM_NS(5).as_double());
m_nt_sync_delay = m_sync_delay.Value();
register_param("SYNC_DELAY", m_sync_delay, NLTIME_FROM_NS(5).as_double());
m_nt_sync_delay = m_sync_delay.Value();
register_param("FREQ", m_freq, 48000.0);
m_inc = netlist_time::from_hz(m_freq.Value());
register_param("FREQ", m_freq, 48000.0);
m_inc = netlist_time::from_hz(m_freq.Value());
register_param("ACCURACY", m_accuracy, 1e-7);
register_param("CONVERG", m_convergence, 0.3);
register_param("ACCURACY", m_accuracy, 1e-7);
register_param("CONVERG", m_convergence, 0.3);
register_param("RESCHED_LOOPS", m_resched_loops, 35);
register_param("PARALLEL", m_parallel, 0);
// internal staff
// internal staff
register_input("FB_sync", m_fb_sync);
register_input("FB_step", m_fb_step);
register_input("FB_sync", m_fb_sync);
register_input("FB_step", m_fb_step);
connect(m_fb_sync, m_Q_sync);
connect(m_fb_step, m_Q_step);
connect(m_fb_sync, m_Q_sync);
connect(m_fb_step, m_Q_step);
save(NAME(m_last_step));
save(NAME(m_last_step));
}
@ -682,26 +686,26 @@ NETLIB_RESET(solver)
NETLIB_UPDATE_PARAM(solver)
{
m_inc = netlist_time::from_hz(m_freq.Value());
m_inc = netlist_time::from_hz(m_freq.Value());
}
NETLIB_NAME(solver)::~NETLIB_NAME(solver)()
{
netlist_matrix_solver_t * const *e = m_mat_solvers.first();
while (e != NULL)
{
netlist_matrix_solver_t * const *en = m_mat_solvers.next(e);
delete *e;
e = en;
}
netlist_matrix_solver_t * const *e = m_mat_solvers.first();
while (e != NULL)
{
netlist_matrix_solver_t * const *en = m_mat_solvers.next(e);
delete *e;
e = en;
}
}
NETLIB_UPDATE(solver)
{
netlist_time now = netlist().time();
netlist_time delta = now - m_last_step;
bool do_full = false;
netlist_time now = netlist().time();
netlist_time delta = now - m_last_step;
bool do_full = false;
bool global_resched = false;
bool this_resched[100];
int t_cnt = m_mat_solvers.count();
@ -749,17 +753,17 @@ NETLIB_UPDATE(solver)
}
}
if (global_resched)
{
netlist().warning("Gobal reschedule .. Consider increasing RESCHED_LOOPS");
schedule();
}
else
{
/* step circuit */
if (!m_Q_step.net().is_queued())
m_Q_step.net().push_to_queue(m_inc);
}
if (global_resched)
{
netlist().warning("Gobal reschedule .. Consider increasing RESCHED_LOOPS");
schedule();
}
else
{
/* step circuit */
if (!m_Q_step.net().is_queued())
m_Q_step.net().push_to_queue(m_inc);
}
}
@ -838,9 +842,9 @@ ATTR_COLD void NETLIB_NAME(solver)::post_start()
break;
}
ms->m_accuracy = m_accuracy.Value();
ms->m_convergence_factor = m_convergence.Value();
ms->m_resched_loops = m_resched_loops.Value();
ms->m_params.m_accuracy = m_accuracy.Value();
ms->m_params.m_convergence_factor = m_convergence.Value();
ms->m_params.m_resched_loops = m_resched_loops.Value();
ms->setup(groups[i], *this);
m_mat_solvers.add(ms);
SOLVER_VERBOSE_OUT(("%d ==> %d nets %s\n", i, groups[i].count(), (*groups[i].first())->m_head->name().cstr()));

15
src/emu/netlist/analog/nld_solver.h
View file

@ -25,6 +25,13 @@ class NETLIB_NAME(solver);
/* FIXME: these should become proper devices */
struct netlist_solver_parameters_t
{
double m_accuracy;
double m_convergence_factor;
int m_resched_loops;
};
class netlist_matrix_solver_t
{
public:
@ -53,9 +60,7 @@ public:
ATTR_HOT inline const NETLIB_NAME(solver) &owner() const;
ATTR_COLD virtual void reset();
double m_accuracy;
double m_convergence_factor;
int m_resched_loops;
netlist_solver_parameters_t m_params;
protected:
netlist_net_t::list_t m_nets;
@ -120,9 +125,7 @@ public:
ATTR_COLD virtual void setup(netlist_net_t::list_t &nets, NETLIB_NAME(solver) &owner)
{
netlist_matrix_solver_t::setup(nets, owner);
m_fallback.m_accuracy = m_accuracy;
m_fallback.m_convergence_factor = m_convergence_factor;
m_fallback.m_resched_loops = m_resched_loops;
m_fallback.m_params = m_params;
m_fallback.setup(nets, owner);
}

6
src/emu/netlist/devices/net_lib.c
View file

@ -78,8 +78,8 @@ void netlist_factory_t::initialize()
ENTRY(POT, POT, "R")
ENTRY(C, CAP, "C")
ENTRY(D, DIODE, "model")
ENTRY(VCVS, NETDEV_VCVS, "-")
ENTRY(VCCS, NETDEV_VCCS, "-")
ENTRY(VCVS, VCVS, "-") // FIXME: STD parameters ?
ENTRY(VCCS, VCCS, "-")
ENTRY(QBJT_EB, QBJT_EB, "model")
ENTRY(QBJT_switch, QBJT_SW, "model")
ENTRY(ttl_input, TTL_INPUT, "IN")
@ -89,7 +89,7 @@ void netlist_factory_t::initialize()
ENTRY(clock, CLOCK, "FREQ")
ENTRY(mainclock, MAINCLOCK, "FREQ")
ENTRY(solver, SOLVER, "FREQ")
ENTRY(gnd, NETDEV_GND, "-")
ENTRY(gnd, GND, "-")
ENTRY(switch2, SWITCH2, "+i1,i2")
ENTRY(nicRSFF, NETDEV_RSFF, "+S,R")
ENTRY(7400, TTL_7400_NAND, "+A,B")

2
src/emu/netlist/devices/nld_system.h
View file

@ -33,7 +33,7 @@
NET_REGISTER_DEV(clock, _name) \
PARAM(_name.FREQ, _freq)
#define NETDEV_GND() \
#define GND() \
NET_REGISTER_DEV(gnd, GND)
// ----------------------------------------------------------------------------------------

31
src/emu/netlist/nl_base.c
View file

@ -240,17 +240,17 @@ ATTR_HOT ATTR_ALIGN void netlist_base_t::process_queue(const netlist_time delta)
} else {
#if 0
netlist_net_t &mcQ = m_mainclock->m_Q.net();
netlist_net_t &mc_net = m_mainclock->m_Q.net();
const netlist_time inc = m_mainclock->m_inc;
while (m_time < m_stop)
{
if (m_queue.is_not_empty())
{
while (m_queue.peek().time() > mcQ.time())
while (m_queue.peek().time() > mc_net.time())
{
m_time = mcQ.time();
NETLIB_NAME(mainclock)::mc_update(mcQ, m_time + inc);
m_time = mc_net.time();
NETLIB_NAME(mainclock)::mc_update(mc_net, m_time + inc);
}
const netlist_queue_t::entry_t &e = m_queue.pop();
@ -258,8 +258,8 @@ ATTR_HOT ATTR_ALIGN void netlist_base_t::process_queue(const netlist_time delta)
e.object()->update_devs();
} else {
m_time = mcQ.time();
NETLIB_NAME(mainclock)::mc_update(mcQ, m_time + inc);
m_time = mc_net.time();
NETLIB_NAME(mainclock)::mc_update(mc_net, m_time + inc);
}
if (FATAL_ERROR_AFTER_NS)
if (time() > NLTIME_FROM_NS(FATAL_ERROR_AFTER_NS))
@ -268,9 +268,9 @@ ATTR_HOT ATTR_ALIGN void netlist_base_t::process_queue(const netlist_time delta)
add_to_stat(m_perf_out_processed, 1);
}
#else
netlist_net_t &mcQ = m_mainclock->m_Q.net();
netlist_net_t &mc_net = m_mainclock->m_Q.net();
const netlist_time inc = m_mainclock->m_inc;
netlist_time mc_time = mcQ.time();
netlist_time mc_time = mc_net.time();
netlist_time cur_time = m_time;
while (cur_time < m_stop)
@ -282,7 +282,7 @@ ATTR_HOT ATTR_ALIGN void netlist_base_t::process_queue(const netlist_time delta)
cur_time = mc_time;
mc_time += inc;
m_time = cur_time;
NETLIB_NAME(mainclock)::mc_update(mcQ);
NETLIB_NAME(mainclock)::mc_update(mc_net);
}
const netlist_queue_t::entry_t &e = m_queue.pop();
@ -293,7 +293,7 @@ ATTR_HOT ATTR_ALIGN void netlist_base_t::process_queue(const netlist_time delta)
cur_time = mc_time;
mc_time += inc;
m_time = cur_time;
NETLIB_NAME(mainclock)::mc_update(mcQ);
NETLIB_NAME(mainclock)::mc_update(mc_net);
}
if (FATAL_ERROR_AFTER_NS)
if (time() > NLTIME_FROM_NS(FATAL_ERROR_AFTER_NS))
@ -301,7 +301,7 @@ ATTR_HOT ATTR_ALIGN void netlist_base_t::process_queue(const netlist_time delta)
add_to_stat(m_perf_out_processed, 1);
}
mcQ.set_time(mc_time);
mc_net.set_time(mc_time);
m_time = cur_time;
#endif
}
@ -825,20 +825,11 @@ ATTR_COLD double netlist_param_model_t::model_value(const pstring &entity, const
// mainclock
// ----------------------------------------------------------------------------------------
#if 0
ATTR_HOT inline void NETLIB_NAME(mainclock)::mc_update(netlist_net_t &net, const netlist_time curtime)
{
net.m_new.Q ^= 1;
net.set_time(curtime);
net.update_devs();
}
#else
ATTR_HOT inline void NETLIB_NAME(mainclock)::mc_update(netlist_net_t &net)
{
net.m_new.Q ^= 1;
net.update_devs();
}
#endif
NETLIB_START(mainclock)
{

280
src/emu/netlist/nl_lists.h
View file

@ -5,6 +5,8 @@
*
*/
#pragma once
#ifndef NLLISTS_H_
#define NLLISTS_H_
@ -20,78 +22,78 @@ class netlist_list_t
{
public:
ATTR_COLD netlist_list_t(int numElements = _NumElem)
{
m_num_elements = numElements;
m_list = new _ListClass[m_num_elements];
ATTR_COLD netlist_list_t(int numElements = _NumElem)
{
m_num_elements = numElements;
m_list = new _ListClass[m_num_elements];
m_count = 0;
}
}
ATTR_COLD netlist_list_t(const netlist_list_t &rhs)
{
m_num_elements = rhs.capacity();
m_list = new _ListClass[m_num_elements];
m_count = 0;
for (int i=0; i<rhs.count(); i++)
{
this->add(rhs[i]);
}
}
ATTR_COLD netlist_list_t(const netlist_list_t &rhs)
{
m_num_elements = rhs.capacity();
m_list = new _ListClass[m_num_elements];
m_count = 0;
for (int i=0; i<rhs.count(); i++)
{
this->add(rhs[i]);
}
}
ATTR_COLD netlist_list_t &operator=(const netlist_list_t &rhs)
{
this->reset();
for (int i=0; i<rhs.count(); i++)
{
this->add(rhs[i]);
}
return *this;
}
ATTR_COLD netlist_list_t &operator=(const netlist_list_t &rhs)
{
this->reset();
for (int i=0; i<rhs.count(); i++)
{
this->add(rhs[i]);
}
return *this;
}
ATTR_COLD ~netlist_list_t()
{
delete[] m_list;
}
ATTR_COLD ~netlist_list_t()
{
delete[] m_list;
}
ATTR_HOT inline void add(const _ListClass &elem)
{
if (m_count >= m_num_elements)
resize(m_num_elements * 2);
ATTR_HOT inline void add(const _ListClass &elem)
{
if (m_count >= m_num_elements)
resize(m_num_elements * 2);
m_list[m_count++] = elem;
}
m_list[m_count++] = elem;
}
ATTR_HOT inline void resize(const int new_size)
{
int cnt = count();
_ListClass *m_new = new _ListClass[new_size];
_ListClass *pd = m_new;
ATTR_HOT inline void resize(const int new_size)
{
int cnt = count();
_ListClass *m_new = new _ListClass[new_size];
_ListClass *pd = m_new;
for (_ListClass *ps = m_list; ps < m_list + cnt; ps++, pd++)
*pd = *ps;
delete[] m_list;
m_list = m_new;
m_count = cnt;
m_num_elements = new_size;
}
for (_ListClass *ps = m_list; ps < m_list + cnt; ps++, pd++)
*pd = *ps;
delete[] m_list;
m_list = m_new;
m_count = cnt;
m_num_elements = new_size;
}
ATTR_HOT inline void remove(const _ListClass &elem)
{
for (int i = 0; i < m_count; i++)
{
if (m_list[i] == elem)
{
m_count --;
while (i < m_count)
{
m_list[i] = m_list[i+1];
i++;
}
return;
}
}
}
ATTR_HOT inline void remove(const _ListClass &elem)
{
for (int i = 0; i < m_count; i++)
{
if (m_list[i] == elem)
{
m_count --;
while (i < m_count)
{
m_list[i] = m_list[i+1];
i++;
}
return;
}
}
}
ATTR_HOT inline void remove_at(const int pos)
{
@ -103,15 +105,15 @@ public:
}
}
ATTR_HOT inline bool contains(const _ListClass &elem) const
{
for (_ListClass *i = m_list; i < m_list + m_count; i++)
{
if (*i == elem)
return true;
}
return false;
}
ATTR_HOT inline bool contains(const _ListClass &elem) const
{
for (_ListClass *i = m_list; i < m_list + m_count; i++)
{
if (*i == elem)
return true;
}
return false;
}
ATTR_HOT inline int indexof(const _ListClass &elem) const
{
@ -123,30 +125,30 @@ public:
return -1;
}
ATTR_HOT inline const _ListClass *first() const { return ((m_count > 0) ? &m_list[0] : NULL ); }
ATTR_HOT inline const _ListClass *next(const _ListClass *lc) const { return ((lc < last()) ? lc + 1 : NULL ); }
ATTR_HOT inline const _ListClass *last() const { return &m_list[m_count -1]; }
ATTR_HOT inline int count() const { return m_count; }
ATTR_HOT inline bool empty() const { return (m_count == 0); }
ATTR_HOT inline void reset() { m_count = 0; }
ATTR_HOT inline const _ListClass *first() const { return ((m_count > 0) ? &m_list[0] : NULL ); }
ATTR_HOT inline const _ListClass *next(const _ListClass *lc) const { return ((lc < last()) ? lc + 1 : NULL ); }
ATTR_HOT inline const _ListClass *last() const { return &m_list[m_count -1]; }
ATTR_HOT inline int count() const { return m_count; }
ATTR_HOT inline bool empty() const { return (m_count == 0); }
ATTR_HOT inline void reset() { m_count = 0; }
ATTR_HOT inline int capacity() const { return m_num_elements; }
ATTR_COLD void reset_and_free()
{
for (_ListClass *i = m_list; i < m_list + m_count; i++)
{
delete *i;
}
reset();
}
ATTR_COLD void reset_and_free()
{
for (_ListClass *i = m_list; i < m_list + m_count; i++)
{
delete *i;
}
reset();
}
ATTR_HOT inline _ListClass& operator[](const int & index) { return m_list[index]; }
ATTR_HOT inline const _ListClass& operator[](const int & index) const { return m_list[index]; }
ATTR_HOT inline _ListClass& operator[](const int & index) { return m_list[index]; }
ATTR_HOT inline const _ListClass& operator[](const int & index) const { return m_list[index]; }
private:
int m_count;
_ListClass * m_list;
int m_num_elements;
int m_count;
_ListClass * m_list;
int m_num_elements;
};
// ----------------------------------------------------------------------------------------
@ -156,35 +158,35 @@ private:
template <class _Element, class _Time, int _Size>
class netlist_timed_queue
{
NETLIST_PREVENT_COPYING(netlist_timed_queue)
NETLIST_PREVENT_COPYING(netlist_timed_queue)
public:
struct entry_t
{
public:
ATTR_HOT inline entry_t()
: m_time(), m_object() {}
ATTR_HOT inline entry_t(const _Time atime, const _Element elem) : m_time(atime), m_object(elem) {}
ATTR_HOT inline const _Time time() const { return m_time; }
ATTR_HOT inline const _Element object() const { return m_object; }
struct entry_t
{
public:
ATTR_HOT inline entry_t()
: m_time(), m_object() {}
ATTR_HOT inline entry_t(const _Time atime, const _Element elem) : m_time(atime), m_object(elem) {}
ATTR_HOT inline const _Time time() const { return m_time; }
ATTR_HOT inline const _Element object() const { return m_object; }
private:
_Time m_time;
_Element m_object;
};
private:
_Time m_time;
_Element m_object;
};
netlist_timed_queue()
{
//m_list = global_alloc_array(entry_t, SIZE);
clear();
}
netlist_timed_queue()
{
//m_list = global_alloc_array(entry_t, SIZE);
clear();
}
ATTR_HOT inline int capacity() const { return _Size; }
ATTR_HOT inline bool is_empty() const { return (m_end == &m_list[0]); }
ATTR_HOT inline bool is_not_empty() const { return (m_end > &m_list[0]); }
ATTR_HOT inline int capacity() const { return _Size; }
ATTR_HOT inline bool is_empty() const { return (m_end == &m_list[0]); }
ATTR_HOT inline bool is_not_empty() const { return (m_end > &m_list[0]); }
ATTR_HOT ATTR_ALIGN inline void push(const entry_t &e)
{
ATTR_HOT ATTR_ALIGN inline void push(const entry_t &e)
{
entry_t * RESTRICT i = m_end++;
while ((i > &m_list[0]) && (e.time() > (i - 1)->time()) )
{
@ -194,43 +196,43 @@ public:
}
*i = e;
inc_stat(m_prof_sort);
assert(m_end - m_list < _Size);
}
assert(m_end - m_list < _Size);
}
ATTR_HOT inline const entry_t &pop()
{
return *--m_end;
}
ATTR_HOT inline const entry_t &pop()
{
return *--m_end;
}
ATTR_HOT inline const entry_t &peek() const
{
return *(m_end-1);
}
ATTR_HOT inline const entry_t &peek() const
{
return *(m_end-1);
}
ATTR_COLD void clear()
{
m_end = &m_list[0];
}
ATTR_COLD void clear()
{
m_end = &m_list[0];
}
// save state support & mame disasm
// save state support & mame disasm
ATTR_COLD inline const entry_t *listptr() const { return &m_list[0]; }
ATTR_HOT inline int count() const { return m_end - m_list; }
ATTR_HOT inline const entry_t & operator[](const int & index) const { return m_list[index]; }
ATTR_COLD inline const entry_t *listptr() const { return &m_list[0]; }
ATTR_HOT inline int count() const { return m_end - m_list; }
ATTR_HOT inline const entry_t & operator[](const int & index) const { return m_list[index]; }
#if (NL_KEEP_STATISTICS)
// profiling
INT32 m_prof_start;
INT32 m_prof_end;
INT32 m_prof_sortmove;
INT32 m_prof_sort;
// profiling
INT32 m_prof_start;
INT32 m_prof_end;
INT32 m_prof_sortmove;
INT32 m_prof_sort;
#endif
private:
entry_t * RESTRICT m_end;
//entry_t *m_list;
entry_t m_list[_Size];
entry_t * RESTRICT m_end;
//entry_t *m_list;
entry_t m_list[_Size];
};

2
src/emu/netlist/nl_setup.c
View file

@ -16,7 +16,7 @@
static NETLIST_START(base)
TTL_INPUT(ttlhigh, 1)
TTL_INPUT(ttllow, 0)
NETDEV_GND()
GND()
NET_MODEL(".model 1N914 D(Is=2.52n Rs=.568 N=1.752 Cjo=4p M=.4 tt=20n Iave=200m Vpk=75 mfg=OnSemi type=silicon)")
NET_MODEL(".model 1N4148 D(Is=2.52n Rs=.568 N=1.752 Cjo=4p M=.4 tt=20n Iave=200m Vpk=75 mfg=OnSemi type=silicon)")

28
src/emu/netlist/nl_setup.h
View file

@ -19,49 +19,49 @@
#define NET_STR(_x) # _x
#define NET_MODEL(_model) \
netlist.register_model(_model);
setup.register_model(_model);
#define ALIAS(_alias, _name) \
netlist.register_alias(# _alias, # _name);
setup.register_alias(# _alias, # _name);
#define NET_NEW(_type) netlist.factory().new_device_by_classname(NETLIB_NAME_STR(_type), netlist)
#define NET_NEW(_type) setup.factory().new_device_by_classname(NETLIB_NAME_STR(_type), setup)
#define NET_REGISTER_DEV(_type, _name) \
netlist.register_dev(NET_NEW(_type), # _name);
setup.register_dev(NET_NEW(_type), # _name);
#define NET_REMOVE_DEV(_name) \
netlist.remove_dev(# _name);
setup.remove_dev(# _name);
#define NET_REGISTER_SIGNAL(_type, _name) \
NET_REGISTER_DEV(_type ## _ ## sig, _name)
#define NET_CONNECT(_name, _input, _output) \
netlist.register_link(# _name "." # _input, # _output);
setup.register_link(# _name "." # _input, # _output);
#define NET_C(_input, _output) \
netlist.register_link(NET_STR(_input) , NET_STR(_output));
setup.register_link(NET_STR(_input) , NET_STR(_output));
#define PARAM(_name, _val) \
netlist.register_param(# _name, _val);
setup.register_param(# _name, _val);
#define NETDEV_PARAMI(_name, _param, _val) \
netlist.register_param(# _name "." # _param, _val);
setup.register_param(# _name "." # _param, _val);
#define NETLIST_NAME(_name) netlist ## _ ## _name
#define NETLIST_START(_name) \
ATTR_COLD void NETLIST_NAME(_name)(netlist_setup_t &netlist) \
ATTR_COLD void NETLIST_NAME(_name)(netlist_setup_t &setup) \
{
#define NETLIST_END() }
#define INCLUDE(_name) \
NETLIST_NAME(_name)(netlist);
NETLIST_NAME(_name)(setup);
#define SUBMODEL(_name, _model) \
netlist.namespace_push(# _name); \
NETLIST_NAME(_model)(netlist); \
netlist.namespace_pop();
setup.namespace_push(# _name); \
NETLIST_NAME(_model)(setup); \
setup.namespace_pop();
// ----------------------------------------------------------------------------------------
// FIXME: Clean this up

6
src/emu/render.c
View file

@ -401,7 +401,7 @@ void render_texture::release()
void render_texture::set_bitmap(bitmap_t &bitmap, const rectangle &sbounds, texture_format format)
{
assert(bitmap.cliprect().contains(sbounds));
//assert(bitmap.cliprect().contains(sbounds));
// ensure we have a valid palette for palettized modes
if (format == TEXFORMAT_PALETTE16 || format == TEXFORMAT_PALETTEA16)
@ -1338,7 +1338,10 @@ render_primitive_list &render_target::get_primitives()
// if there is no associated element, it must be a screen element
if (curitem->screen() != NULL)
{
add_container_primitives(list, item_xform, curitem->screen()->container(), blendmode);
curitem->screen()->set_render_size((int) item_xform.xscale, (int) item_xform.yscale);
}
else
add_element_primitives(list, item_xform, *curitem->element(), curitem->state(), blendmode);
}
@ -1701,7 +1704,6 @@ void render_target::add_container_primitives(render_primitive_list &list, const
prim->bounds.x1 = render_round_nearest(container_xform.xoffs + bounds.x1 * container_xform.xscale);
prim->bounds.y1 = render_round_nearest(container_xform.yoffs + bounds.y1 * container_xform.yscale);
}
// compute the color of the primitive
prim->color.r = container_xform.color.r * curitem->color().r;
prim->color.g = container_xform.color.g * curitem->color().g;

985
src/emu/screen.c
View file

File diff suppressed because it is too large Load diff

114
src/emu/screen.h
View file

@ -127,6 +127,104 @@ typedef device_delegate<UINT32 (screen_device &, bitmap_rgb32 &, const rectangle
typedef device_delegate<void (screen_device &, bool)> screen_vblank_delegate;
// ======================> monitor_device
class crt_monitor
{
public:
typedef enum
{
PASSTHROUGHX = 0, // PASSTHROUGH somewhere defined in win32 environment
SHADOW_MASK = 1,
CROMA_CLEAR = 2,
// APERTURE_GRILLE,
} crt_monitor_type;
typedef struct
{
crt_monitor_type m_type;
INT16 r_off;
INT16 g_off;
INT16 b_off;
UINT16 r_gain;
UINT16 b_gain;
UINT16 g_gain;
UINT16 focus;
UINT16 decay;
UINT16 bandwidth;
UINT8 source_cie;
} crt_monitor_param;
crt_monitor(void);
~crt_monitor(void);
void resize(int new_width, int new_height);
bitmap_t &final_bitmap(int cur_bm) { return m_phos_bm[cur_bm]; }
void get_param(crt_monitor_param &param) { param = m_param; }
void set_param(crt_monitor_param &param);
crt_monitor_type type(void) const { return m_param.m_type; }
//void set_type(crt_monitor_type new_type) { m_type = new_type; }
//void set_horz_pixel(int num) { m_horz_pixel = num; }
void process(running_machine &machine, screen_bitmap &src_bm, int cur_bm, rectangle &clip);
const rectangle &get_visible() const { return m_visible; }
int get_cie_count(void);
const char * get_cie_name(void);
int get_type_count(void) { return 3; }
const char * get_type_name(void)
{
switch (m_param.m_type)
{
case PASSTHROUGHX:
return "Passthrough";
case CROMA_CLEAR:
return "Croma Clear";
case SHADOW_MASK:
return "Shadow Mask";
}
return "";
}
private:
INT16 * m_amplifier_r;
INT16 * m_amplifier_g;
INT16 * m_amplifier_b;
bitmap_rgb32 m_mask_bm;
bitmap_rgb32 m_phos_bm[2];
crt_monitor_param m_param;
rectangle m_visible;
//rectangle m_src_visible;
int m_vert_pixel;
int m_horz_pixel;
int m_width;
int m_height;
void free_bitmaps(void);
void scale_and_bandwith(running_machine &machine, bitmap_t &bm_src, const rectangle &cliprect);
void copyonly(bitmap_rgb32 &bm_dst, rectangle &clip);
void copy_shadow_mask(bitmap_rgb32 &bm_dst, const rectangle &clip);
void copy_chroma(bitmap_rgb32 &bm_dst, const rectangle &clip);
void phosphor(bitmap_rgb32 &bm_dst, bitmap_rgb32 &bm_phos, bitmap_rgb32 &bm_src, const rectangle &cliprect);
rgb_t base_red[768];
rgb_t base_green[768];
rgb_t base_blue[768];
int m_exp[256];
};
// ======================> screen_device
class screen_device : public device_t
@ -142,7 +240,7 @@ public:
screen_type_enum screen_type() const { return m_type; }
int width() const { return m_width; }
int height() const { return m_height; }
const rectangle &visible_area() const { return m_visarea; }
const rectangle &visible_area() const;// { return m_visarea; }
const rectangle &cliprect() const { return m_bitmap[0].cliprect(); }
bool oldstyle_vblank_supplied() const { return m_oldstyle_vblank_supplied; }
attoseconds_t refresh_attoseconds() const { return m_refresh; }
@ -197,6 +295,8 @@ public:
void update_now();
void reset_partial_updates();
void set_render_size(int width, int height);
// additional helpers
void register_vblank_callback(vblank_state_delegate vblank_callback);
void register_screen_bitmap(bitmap_t &bitmap);
@ -206,6 +306,10 @@ public:
bool update_quads();
void update_burnin();
// access to crt
crt_monitor &crt(void) { return m_crt; }
// globally accessible constants
static const int DEFAULT_FRAME_RATE = 60;
static const attotime DEFAULT_FRAME_PERIOD;
@ -281,6 +385,10 @@ private:
UINT64 m_frame_number; // the current frame number
UINT32 m_partial_updates_this_frame;// partial update counter this frame
// render size
INT32 m_render_width;
INT32 m_render_height;
// VBLANK callbacks
class callback_item
{
@ -312,6 +420,10 @@ private:
// static data
static UINT32 m_id_counter; // incremented for each constructed screen_device,
// used as a unique identifier during runtime
// monitor emulation
crt_monitor m_crt;
};
// device type definition

242
src/emu/ui/ui.c
View file

@ -123,6 +123,20 @@ static INT32 slider_overyoffset(running_machine &machine, void *arg, astring *st
static INT32 slider_flicker(running_machine &machine, void *arg, astring *string, INT32 newval);
static INT32 slider_beam(running_machine &machine, void *arg, astring *string, INT32 newval);
static char *slider_get_screen_desc(screen_device &screen);
static INT32 slider_crt_red_off(running_machine &machine, void *arg, astring *string, INT32 newval);
static INT32 slider_crt_green_off(running_machine &machine, void *arg, astring *string, INT32 newval);
static INT32 slider_crt_blue_off(running_machine &machine, void *arg, astring *string, INT32 newval);
static INT32 slider_crt_red_gain(running_machine &machine, void *arg, astring *string, INT32 newval);
static INT32 slider_crt_green_gain(running_machine &machine, void *arg, astring *string, INT32 newval);
static INT32 slider_crt_blue_gain(running_machine &machine, void *arg, astring *string, INT32 newval);
static INT32 slider_crt_decay(running_machine &machine, void *arg, astring *string, INT32 newval);
static INT32 slider_crt_bandwidth(running_machine &machine, void *arg, astring *string, INT32 newval);
static INT32 slider_crt_focus(running_machine &machine, void *arg, astring *string, INT32 newval);
static INT32 slider_crt_cie(running_machine &machine, void *arg, astring *string, INT32 newval);
static INT32 slider_crt_type(running_machine &machine, void *arg, astring *string, INT32 newval);
#ifdef MAME_DEBUG
static INT32 slider_crossscale(running_machine &machine, void *arg, astring *string, INT32 newval);
static INT32 slider_crossoffset(running_machine &machine, void *arg, astring *string, INT32 newval);
@ -1905,6 +1919,54 @@ static slider_state *slider_init(running_machine &machine)
break;
}
screen_device_iterator iter(machine.root_device());
for (screen_device *screen = iter.first(); screen != NULL; screen = iter.next())
if (screen->screen_type() != SCREEN_TYPE_VECTOR)
{
void *param = (void *)screen;
string.printf("%s Red Offset", slider_get_screen_desc(*screen));
*tailptr = slider_alloc(machine, string, -256, 0, 256, 5, slider_crt_red_off, param);
tailptr = &(*tailptr)->next;
string.printf("%s Green Offset", slider_get_screen_desc(*screen));
*tailptr = slider_alloc(machine, string, -256, 0, 256, 5, slider_crt_green_off, param);
tailptr = &(*tailptr)->next;
string.printf("%s Blue Offset", slider_get_screen_desc(*screen));
*tailptr = slider_alloc(machine, string, -256, 0, 256, 5, slider_crt_blue_off, param);
tailptr = &(*tailptr)->next;
string.printf("%s Red Gain", slider_get_screen_desc(*screen));
*tailptr = slider_alloc(machine, string, 0, 256, 767, 5, slider_crt_red_gain, param);
tailptr = &(*tailptr)->next;
string.printf("%s Green Gain", slider_get_screen_desc(*screen));
*tailptr = slider_alloc(machine, string, 0, 256, 767, 5, slider_crt_green_gain, param);
tailptr = &(*tailptr)->next;
string.printf("%s Blue Gain", slider_get_screen_desc(*screen));
*tailptr = slider_alloc(machine, string, 0, 256, 767, 5, slider_crt_blue_gain, param);
tailptr = &(*tailptr)->next;
string.printf("%s Phosphor decay", slider_get_screen_desc(*screen));
*tailptr = slider_alloc(machine, string, 0, 0, 256, 5, slider_crt_decay, param);
tailptr = &(*tailptr)->next;
string.printf("%s Bandwidth", slider_get_screen_desc(*screen));
*tailptr = slider_alloc(machine, string, 0, 0, 256, 5, slider_crt_bandwidth, param);
tailptr = &(*tailptr)->next;
string.printf("%s Focus", slider_get_screen_desc(*screen));
*tailptr = slider_alloc(machine, string, 0, 256, 256, 5, slider_crt_focus, param);
tailptr = &(*tailptr)->next;
string.printf("%s CIE", slider_get_screen_desc(*screen));
*tailptr = slider_alloc(machine, string, 0, 0, screen->crt().get_cie_count()-1, 1, slider_crt_cie, param);
tailptr = &(*tailptr)->next;
string.printf("%s Monitor type", slider_get_screen_desc(*screen));
*tailptr = slider_alloc(machine, string, 0, 0, screen->crt().get_type_count()-1, 1, slider_crt_type, param);
tailptr = &(*tailptr)->next;
}
#ifdef MAME_DEBUG
// add crosshair adjusters
for (port = machine.ioport().first_port(); port != NULL; port = port->next())
@ -1924,6 +1986,186 @@ static slider_state *slider_init(running_machine &machine)
return listhead;
}
/*-------------------------------------------------
slider_crt_* - CRT Monitor sliders
-------------------------------------------------*/
static INT32 slider_crt_red_off(running_machine &machine, void *arg, astring *string, INT32 newval)
{
screen_device *screen = reinterpret_cast<screen_device *>(arg);
crt_monitor::crt_monitor_param param;
screen->crt().get_param(param);
if (newval != SLIDER_NOCHANGE)
{
param.r_off = newval;
screen->crt().set_param(param);
}
if (string != NULL)
string->printf("%.2f", (double) param.r_off / 256.0f);
return param.r_off;
}
static INT32 slider_crt_green_off(running_machine &machine, void *arg, astring *string, INT32 newval)
{
screen_device *screen = reinterpret_cast<screen_device *>(arg);
crt_monitor::crt_monitor_param param;
screen->crt().get_param(param);
if (newval != SLIDER_NOCHANGE)
{
param.g_off = newval;
screen->crt().set_param(param);
}
if (string != NULL)
string->printf("%.2f", (double) param.g_off / 256.0f);
return param.g_off;
}
static INT32 slider_crt_blue_off(running_machine &machine, void *arg, astring *string, INT32 newval)
{
screen_device *screen = reinterpret_cast<screen_device *>(arg);
crt_monitor::crt_monitor_param param;
screen->crt().get_param(param);
if (newval != SLIDER_NOCHANGE)
{
param.b_off = newval;
screen->crt().set_param(param);
}
if (string != NULL)
string->printf("%.2f", (double) param.b_off / 256.0f);
return param.b_off;
}
static INT32 slider_crt_red_gain(running_machine &machine, void *arg, astring *string, INT32 newval)
{
screen_device *screen = reinterpret_cast<screen_device *>(arg);
crt_monitor::crt_monitor_param param;
screen->crt().get_param(param);
if (newval != SLIDER_NOCHANGE)
{
param.r_gain = newval;
screen->crt().set_param(param);
}
if (string != NULL)
string->printf("%.2f", (double) param.r_gain / 256.0f);
return param.r_gain;
}
static INT32 slider_crt_green_gain(running_machine &machine, void *arg, astring *string, INT32 newval)
{
screen_device *screen = reinterpret_cast<screen_device *>(arg);
crt_monitor::crt_monitor_param param;
screen->crt().get_param(param);
if (newval != SLIDER_NOCHANGE)
{
param.g_gain = newval;
screen->crt().set_param(param);
}
if (string != NULL)
string->printf("%.2f", (double) param.g_gain / 256.0f);
return param.g_gain;
}
static INT32 slider_crt_blue_gain(running_machine &machine, void *arg, astring *string, INT32 newval)
{
screen_device *screen = reinterpret_cast<screen_device *>(arg);
crt_monitor::crt_monitor_param param;
screen->crt().get_param(param);
if (newval != SLIDER_NOCHANGE)
{
param.b_gain = newval;
screen->crt().set_param(param);
}
if (string != NULL)
string->printf("%.2f", (double) param.b_gain / 256.0f);
return param.b_gain;
}
static INT32 slider_crt_decay(running_machine &machine, void *arg, astring *string, INT32 newval)
{
screen_device *screen = reinterpret_cast<screen_device *>(arg);
crt_monitor::crt_monitor_param param;
screen->crt().get_param(param);
if (newval != SLIDER_NOCHANGE)
{
param.decay = newval;
screen->crt().set_param(param);
}
if (string != NULL)
string->printf("%.2f", (double) param.decay / 256.0f);
return param.decay;
}
static INT32 slider_crt_bandwidth(running_machine &machine, void *arg, astring *string, INT32 newval)
{
screen_device *screen = reinterpret_cast<screen_device *>(arg);
crt_monitor::crt_monitor_param param;
screen->crt().get_param(param);
if (newval != SLIDER_NOCHANGE)
{
param.bandwidth = newval;
screen->crt().set_param(param);
}
if (string != NULL)
string->printf("%.2f", (double) param.bandwidth / 256.0f);
return param.bandwidth;
}
static INT32 slider_crt_focus(running_machine &machine, void *arg, astring *string, INT32 newval)
{
screen_device *screen = reinterpret_cast<screen_device *>(arg);
crt_monitor::crt_monitor_param param;
screen->crt().get_param(param);
if (newval != SLIDER_NOCHANGE)
{
param.focus = newval;
screen->crt().set_param(param);
}
if (string != NULL)
string->printf("%.2f", (double) param.focus / 256.0f);
return param.focus;
}
static INT32 slider_crt_cie(running_machine &machine, void *arg, astring *string, INT32 newval)
{
screen_device *screen = reinterpret_cast<screen_device *>(arg);
crt_monitor::crt_monitor_param param;
screen->crt().get_param(param);
if (newval != SLIDER_NOCHANGE)
{
param.source_cie = newval;
screen->crt().set_param(param);
}
if (string != NULL)
string->printf("%s", screen->crt().get_cie_name());
return param.source_cie;
}
static INT32 slider_crt_type(running_machine &machine, void *arg, astring *string, INT32 newval)
{
screen_device *screen = reinterpret_cast<screen_device *>(arg);
crt_monitor::crt_monitor_param param;
screen->crt().get_param(param);
if (newval != SLIDER_NOCHANGE)
{
param.m_type = (crt_monitor::crt_monitor_type) newval;
screen->crt().set_param(param);
}
if (string != NULL)
string->printf("%s", screen->crt().get_type_name());
return param.m_type;
}
//-------------------------------------------------
// slider_volume - global volume slider callback