/* http://wvware.sourceforge.net/caolan/Polyline.html */
static GpStatus
Polyline (MetafilePlayContext *context, BYTE *data)
{
GpStatus status;
int p;
/* variable number of parameters */
SHORT num = GETS(WP1);
#ifdef DEBUG_WMF
printf ("Polyline %d points", num);
#endif
SHORT x1 = GETS(WP2);
SHORT y1 = GETS(WP3);
int n = 4;
for (p = 1; p < num; p++) {
SHORT x2 = GETS(WP(n));
n++;
SHORT y2 = GETS(WP(n));
n++;
#ifdef DEBUG_WMF_2
printf ("\n\tdraw from %d,%d to %d,%d", x1, y1, x2, y2);
#endif
GpPen *pen = gdip_metafile_GetSelectedPen (context);
status = GdipDrawLine (context->graphics, pen, x1, y1, x2, y2);
if (status != Ok)
return status;
x1 = x2;
y1 = y2;
}
return Ok;
}
t_qtrn qtrn_external_prod(const t_qtrn *const a, const t_real s)
{
t_qtrn ans;
ans.type = a->type;
if (a->type == CARTHESIAN)
{
X(ans) = XP(a) * s;
Y(ans) = YP(a) * s;
Z(ans) = ZP(a) * s;
W(ans) = WP(a) * s;
}
else if (a->type == CYLINDRICAL)
{
QR(ans) = QRP(a) * s;
QTHETA(ans) = QTHETAP(a);
Z(ans) = ZP(a) * s;
W(ans) = WP(a) * s;
}
else
{
QRHO(ans) = QRHOP(a) * s;
QTHETA(ans) = QTHETAP(a);
QPHI(ans) = QPHIP(a);
W(ans) = WP(a) * s;
}
return (ans);
}
t_real qtrn_get_norm(const t_qtrn *const q)
{
if (q->type == CARTHESIAN)
return (XP(q) * XP(q) + YP(q) * YP(q)
+ ZP(q) * ZP(q) + WP(q) * WP(q));
else if (q->type == CYLINDRICAL)
return (ZP(q) * ZP(q) + QRP(q) * QRP(q));
else
return (QRHOP(q));
}
t_qtrn qtrn_get_conj(const t_qtrn *const q)
{
if (q->type == CARTHESIAN)
return (NEW_QTRN(-XP(q), -YP(q), -ZP(q), WP(q)));
else if (q->type == CYLINDRICAL)
return ((t_qtrn){CYLINDRICAL, {{
QRP(q), QTHETAP(q) + M_PI, -ZP(q), WP(q)}}});
else
return ((t_qtrn){SPHERICAL, {{
QRHOP(q), QTHETAP(q) + M_PI, QPHIP(q) + M_PI, WP(q)}}});
}
whp new_walker(pp_pp* pp, mpz_t limit, int invsum) {
whp wh;
walker* w;
walk_result* wr;
int numsize = pp->valnumsize;
wh = arena_size;
w = WP(wh);
arena_size += walker_charsize(numsize);
grow_arena(w, arena_size);
w->heap = mbh_new(I2P(wh), &mbh_compare_wr);
w->pp = pp;
w->numsize = numsize;
w->adder = pp->adder;
w->cmper = pp->cmper;
w->invsum = invsum;
w->vecsize = (pp->valsize + 31) >> 5;
w->arenanext = (wrhp)0;
w->have_previous = 0;
mpx_set_z(w_limit(w), numsize, limit);
w_pick_arena(w, wr);
wr->invsum = 0;
wr->nextbit = pp->valsize;
mpx_set_ui(wr_next_discard(w, wr), numsize, 0);
mpx_set_ui(wr_discard_direct(w, wr), numsize, 0);
memset(wr_vec_direct(w, wr), 0, w->vecsize * sizeof(int));
push_heap(w, wr);
return wh;
}
A ga(I t, I r, I n, I *s) { I k=WP(t,r,n); A z=a_malloc(k);
AT(z)=t; AC(z)=1; AR(z)=r; AN(z)=n;
if (r==1) { *AS(z)=n; }
else if (r&&s) { ICPY(AS(z),s,r); }
gcpush(z);
R z;
}
A gcinit(VO) { I k=WP(BOX,1,NOBJS); A memory;
nmem=mtop=bytes=totbytes=0;
memory=a_malloc(k);
AT(memory)=BOX; AR(memory)=1;
AN(memory)=*AS(memory)=NOBJS;
objs=AAV(memory);
R memory;
}
void qtrn_external_mult(t_qtrn *const a, const t_real s)
{
if (a->type == CARTHESIAN)
{
XP(a) *= s;
YP(a) *= s;
ZP(a) *= s;
WP(a) *= s;
}
else if (a->type == CYLINDRICAL)
{
QRP(a) *= s;
ZP(a) *= s;
WP(a) *= s;
}
else
{
QRHOP(a) *= s;
WP(a) *= s;
}
}
wrhp wr_clone(whp wh, wrhp wrh) {
walker* w = WP(wh);
walk_result *wr, *wr2;
w_pick_arena(w, wr2);
/* we may attempt to clone something already released to arena, in which
* case pick_arena may return the same address. If so, there's nothing
* to do */
wr = WRP(wh, wrh);
if (wr2 != wr)
memcpy(wr2, wr, wr_charsize(w));
return WRHP(w, wr2);
}
/* http://wvware.sourceforge.net/caolan/Polygon.html */
static GpStatus
Polygon (MetafilePlayContext *context, BYTE *data, int len)
{
GpPointF *points, *pt;
GpStatus status;
int p;
/* variable number of parameters */
SHORT num = GETS(WP1);
/* len (in WORDs) = num (WORD) + num * (x WORD + y WORD) */
if (num > len + 1)
return InvalidParameter;
#ifdef DEBUG_WMF
printf ("Polygon %d points", num);
#endif
points = (GpPointF*) GdipAlloc (num * sizeof (GpPointF));
if (!points)
return OutOfMemory;
int n = 2;
for (p = 0, pt = points; p < num; p++, pt++) {
pt->X = GETS(WP(n));
n++;
pt->Y = GETS(WP(n));
n++;
#ifdef DEBUG_WMF
printf ("\n\tpoly to %g,%g", pt->X, pt->Y);
#endif
}
status = gdip_metafile_Polygon (context, points, num);
GdipFree (points);
return status;
}
void tms340x0_device::write_pixel_8(offs_t offset, UINT32 data) { WP(0x08, 0xff); }
void tms340x0_device::write_pixel_4(offs_t offset, UINT32 data) { WP(0x0c, 0x0f); }
void tms340x0_device::write_pixel_2(offs_t offset, UINT32 data) { WP(0x0e, 0x03); }
/* No Raster Op + No Transparency */
void tms340x0_device::write_pixel_1(offs_t offset, UINT32 data) { WP(0x0f, 0x01); }
/* storage isn't very efficient, # of polygons, size of each polygon, data for each polygon */
static GpStatus
PolyPolygon (MetafilePlayContext *context, BYTE *data)
{
GpStatus status = Ok;
/* variable number of parameters */
int poly_num = GETW(WP1);
int i, j;
PointFList *list = GdipAlloc (poly_num * sizeof (PointFList));
if (!list) {
return OutOfMemory;
}
PointFList *current = list;
#ifdef DEBUG_WMF
printf ("PolyPolygon has %d polygons", poly_num);
#endif
int n = 2;
/* read size of each polygon and allocate the required memory */
for (i = 0; i < poly_num; i++) {
current->num = GETW(WP(n));
n++;
current->points = (GpPointF*) GdipAlloc (current->num * sizeof (GpPointF));
if (!current->points) {
for (j = 0; j < i; j++) {
GdipFree (list[j].points);
}
GdipFree (list);
return OutOfMemory;
}
#ifdef DEBUG_WMF_2
printf ("\n\tSub Polygon #%d has %d points", i, current->num);
#endif
current++;
}
/* read the points for each polygons */
current = list;
for (i = 0; i < poly_num; i++) {
GpPointF *pt = current->points;
int p;
for (p = 0; p < current->num; p++) {
pt->X = GETW(WP(n));
n++;
pt->Y = GETW(WP(n));
n++;
#ifdef DEBUG_WMF_3
printf ("\n\t\tpoly to %g,%g", pt->X, pt->Y);
#endif
pt++;
}
GpStatus s = gdip_metafile_Polygon (context, current->points, current->num);
if (s != Ok)
status = s;
/* free points */
GdipFree (current->points);
current++;
}
/* all points were freed, after being drawn, so we just have to free the polygon list*/
GdipFree (list);
return status;
}
void delete_walker(whp wh) {
walker* w = WP(wh);
mbh_delete(w->heap);
arena_size = wh;
}
void CMineView::InterpModelData(UINT8 *p)
{
assert(p);
assert(gModel.polys);
while (W(p) != OP_EOF) {
switch (W(p)) {
// Point Definitions with Start Offset:
// 2 UINT16 n_points number of points
// 4 UINT16 start_point starting point
// 6 UINT16 unknown
// 8 VMS_VECTOR pts[n_points] x,y,z data
case OP_DEFP_START: {
pt0 = W(p+4);
n_points = W(p+2);
gModel.n_points += n_points;
assert(W(p+6)==0);
assert(gModel.n_points < MAX_POLY_MODEL_POINTS);
assert(pt0+n_points < MAX_POLY_MODEL_POINTS);
for (pt=0;pt< n_points;pt++) {
gModel.points[pt+pt0].x = VP(p+8)[pt].x + gOffset.x;
gModel.points[pt+pt0].y = VP(p+8)[pt].y + gOffset.y;
gModel.points[pt+pt0].z = VP(p+8)[pt].z + gOffset.z;
}
SetModelPoints(pt0,pt0+n_points);
p += W(p+2)*sizeof(VMS_VECTOR) + 8;
break;
}
// Flat Shaded Polygon:
// 2 UINT16 n_verts
// 4 VMS_VECTOR vector1
// 16 VMS_VECTOR vector2
// 28 UINT16 color
// 30 UINT16 verts[n_verts]
case OP_FLATPOLY: {
panel = &gModel.polys[gModel.n_polys];
panel->n_verts = W(p+2);
panel->offset = *VP(p+4);
panel->normal = *VP(p+16);
for (pt=0;pt<panel->n_verts;pt++) {
panel->verts[pt] = WP(p+30)[pt];
}
assert(panel->n_verts>=MIN_POLY_POINTS);
assert(panel->n_verts<=MAX_POLY_POINTS);
assert(gModel.n_polys < MAX_POLYS);
DrawPoly(panel);
p += 30 + ((panel->n_verts&~1)+1)*2;
break;
}
// Texture Mapped Polygon:
// 2 UINT16 n_verts
// 4 VMS_VECTOR vector1
// 16 VMS_VECTOR vector2
// 28 UINT16 nBaseTex
// 30 UINT16 verts[n_verts]
// -- UVL uvls[n_verts]
case OP_TMAPPOLY: {
panel = &gModel.polys[gModel.n_polys];
panel->n_verts = W(p+2);
assert(panel->n_verts>=MIN_POLY_POINTS);
assert(panel->n_verts<=MAX_POLY_POINTS);
assert(gModel.n_polys < MAX_POLYS);
panel->offset = *VP(p+4);
panel->normal = *VP(p+16);
panel->color = -1;
panel->nBaseTex = W(p+28);
panel->glow_num = glow_num;
for (pt=0;pt<panel->n_verts;pt++) {
panel->verts[pt] = WP(p+30)[pt];
}
p += 30 + ((panel->n_verts&~1)+1)*2;
DrawPoly(panel);
p += panel->n_verts * 12;
break;
}
// Sort by Normal
// 2 UINT16 unknown
// 4 VMS_VECTOR Front Model normal
// 16 VMS_VECTOR Back Model normal
// 28 UINT16 Front Model Offset
// 30 UINT16 Back Model Offset
case OP_SORTNORM: {
/* = W(p+2); */
/* = W(p+4); */
/* = W(p+16); */
assert(W(p+2)==0);
assert(W(p+28)>0);
assert(W(p+30)>0);
if ( m_matrix.CheckNormal(gpObject, VP(p+4),VP(p+16)) ) {
InterpModelData(p + W(p+28));
InterpModelData(p + W(p+30));
} else {
InterpModelData(p + W(p+30));
InterpModelData(p + W(p+28));
}
p += 32;
break;
}
// Call a Sub Object
// 2 UINT16 n_anims
// 4 VMS_VECTOR offset
// 16 UINT16 model offset
case OP_SUBCALL: {
assert(W(p+16)>0);
/* = VP(p+4) */
gOffset.x += VP(p+4)->x;
gOffset.y += VP(p+4)->y;
gOffset.z += VP(p+4)->z;
InterpModelData(p + W(p+16));
gOffset.x -= VP(p+4)->x;
gOffset.y -= VP(p+4)->y;
gOffset.z -= VP(p+4)->z;
p += 20;
break;
}
// Glow Number for Next Poly
// 2 UINTW Glow_Value
case OP_GLOW: {
glow_num = W(p+2);
p += 4;
break;
}
default: {
assert(0);
}
}
}
return;
}
inline int* wr_vec(whp wh, wrhp wrh) {
return (int*)&WRP(wh, wrh)->tail[WP(wh)->numsize * 2];
}
inline mpx_t wr_discard(whp wh, wrhp wrh) {
return (mpx_t)&WRP(wh, wrh)->tail[WP(wh)->numsize];
}
void wr_clone_free(whp wh, wrhp wrh) {
w_free_arena(WP(wh), WRP(wh, wrh));
}
