romdev-mcp 0.1.1

package/src/platforms/genesis/lib/sgdk/src/maths3D.c

@@ -0,0 +1,480 @@
+#include "config.h"
+#include "types.h"
+
+#include "maths.h"
+#include "maths3D.h"
+
+#include "bmp.h"
+
+
+Context3D context3D;
+
+
+void M3D_reset()
+{
+    context3D.lightEnabled = FALSE;
+
+    // we assume default viewport for BMP drawing
+    M3D_setViewport(BMP_WIDTH, BMP_HEIGHT);
+    // default camera distance
+    context3D.camDist = FIX16(20);
+
+    context3D.light.x = FIX16(1);
+    context3D.light.y = FIX16(0);
+    context3D.light.z = FIX16(0);
+}
+
+
+void M3D_setLightEnabled(u16 enabled)
+{
+    context3D.lightEnabled = enabled;
+}
+
+u16 M3D_getLightEnabled()
+{
+    return context3D.lightEnabled;
+}
+
+
+void M3D_setViewport(u16 w, u16 h)
+{
+    context3D.viewport.x = w;
+    context3D.viewport.y = h;
+}
+
+void M3D_setCamDistance(fix16 value)
+{
+    context3D.camDist = value;
+}
+
+void M3D_setLightXYZ(fix16 x, fix16 y, fix16 z)
+{
+    context3D.light.x = x;
+    context3D.light.y = y;
+    context3D.light.z = z;
+}
+
+void M3D_setLight(V3f16 *value)
+{
+    context3D.light.x = value->x;
+    context3D.light.y = value->y;
+    context3D.light.z = value->z;
+}
+
+
+void M3D_resetTransform(Transformation3D* t)
+{
+    Rotation3D* rot = t->rotation;
+    Translation3D* trans = t->translation;
+
+    rot->x = 0;
+    rot->y = 0;
+    rot->z = 0;
+    trans->x = 0;
+    trans->y = 0;
+    trans->z = 0;
+
+    t->mat.a.x = FIX16(1);
+    t->mat.b.x = FIX16(0);
+    t->mat.c.x = FIX16(0);
+
+    t->mat.a.y = FIX16(0);
+    t->mat.b.y = FIX16(1);
+    t->mat.c.y = FIX16(0);
+
+    t->mat.a.z = FIX16(0);
+    t->mat.b.z = FIX16(0);
+    t->mat.c.z = FIX16(1);
+
+    t->matInv.a.x = FIX16(1);
+    t->matInv.b.x = FIX16(0);
+    t->matInv.c.x = FIX16(0);
+
+    t->matInv.a.y = FIX16(0);
+    t->matInv.b.y = FIX16(1);
+    t->matInv.c.y = FIX16(0);
+
+    t->matInv.a.z = FIX16(0);
+    t->matInv.b.z = FIX16(0);
+    t->matInv.c.z = FIX16(1);
+
+    // transform camview vector (0, 0, 1)
+    t->cameraInv.x = FIX16(0);
+    t->cameraInv.y = FIX16(0);
+    t->cameraInv.z = FIX16(1);
+
+    t->rebuildMat = 0;
+
+    // transform light vector (after rebuiltMat set to 0)
+    if (context3D.lightEnabled)
+        M3D_rotateInv(t, &(context3D.light), &(t->lightInv));
+}
+
+void M3D_setTransform(Transformation3D* tr, Translation3D* t, Rotation3D* r)
+{
+    tr->translation = t;
+
+    if (tr->rotation != r)
+    {
+        tr->rotation = r;
+        tr->rebuildMat = 1;
+    }
+}
+
+void M3D_setTranslation(Transformation3D* t, fix16 x, fix16 y, fix16 z)
+{
+    Translation3D* trans = t->translation;
+
+    trans->x = x;
+    trans->y = y;
+    trans->z = z;
+}
+
+void M3D_setRotation(Transformation3D* t, fix16 x, fix16 y, fix16 z)
+{    
+    Rotation3D* rot = t->rotation;
+
+    if ((rot->x != x) || (rot->y != y) || (rot->z != z))
+    {
+        rot->x = x;
+        rot->y = y;
+        rot->z = z;
+        t->rebuildMat = 1;
+    }
+}
+
+
+void M3D_combineTransform(Transformation3D* left, Transformation3D* right, Transformation3D* result)
+{
+    // rebuild matrice if needed
+    if (left->rebuildMat) M3D_buildMat3DOnly(left);
+    if (right->rebuildMat) M3D_buildMat3DOnly(right);
+
+//              x y z t   x y z t
+//
+//          a   a b c x   k l m u   x     ak+bn+cq al+bo+cr am+bp+cs au+bv+cw+x
+// tr.T =   b   d e f y . n o p v   y  =  dk+en+fq dl+eo+fr dm+ep+fs du+ev+fw+y  = 36 mul + 27 add
+//          c   g h i z   q r s w   z     gk+hn+iq gl+ho+ir gm+hp+is gu+hv+iw+z
+//              0 0 0 1   0 0 0 1
+
+    const M3f16* mat1 = &(left->mat);
+    const Translation3D* t1 = left->translation;
+    const M3f16* mat2 = &(right->mat);
+    const Translation3D* t2 = right->translation;
+
+    M3f16* matRes = &(result->mat);
+    Translation3D* tRes = result->translation;
+
+    // compute matrix product (36 multiplications + 27 additions... outch !!!)
+    matRes->a.x = ((mat1->a.x * mat2->a.x) + (mat1->a.y * mat2->b.x) + (mat1->a.z * mat2->c.x)) >> FIX16_FRAC_BITS;
+    matRes->a.y = ((mat1->a.x * mat2->a.y) + (mat1->a.y * mat2->b.y) + (mat1->a.z * mat2->c.y)) >> FIX16_FRAC_BITS;
+    matRes->a.z = ((mat1->a.x * mat2->a.z) + (mat1->a.y * mat2->b.z) + (mat1->a.z * mat2->c.z)) >> FIX16_FRAC_BITS;
+    tRes->x = (((mat1->a.x * t2->x) + (mat1->a.y * t2->y) + (mat1->a.z * t2->z)) >> FIX16_FRAC_BITS) + t1->x;
+
+    matRes->b.x = ((mat1->b.x * mat2->a.x) + (mat1->b.y * mat2->b.x) + (mat1->b.z * mat2->c.x)) >> FIX16_FRAC_BITS;
+    matRes->b.y = ((mat1->b.x * mat2->a.y) + (mat1->b.y * mat2->b.y) + (mat1->b.z * mat2->c.y)) >> FIX16_FRAC_BITS;
+    matRes->b.z = ((mat1->b.x * mat2->a.z) + (mat1->b.y * mat2->b.z) + (mat1->b.z * mat2->c.z)) >> FIX16_FRAC_BITS;
+    tRes->y = (((mat1->b.x * t2->x) + (mat1->b.y * t2->y) + (mat1->b.z * t2->z)) >> FIX16_FRAC_BITS) + t1->y;
+
+    matRes->c.x = ((mat1->c.x * mat2->a.x) + (mat1->c.y * mat2->b.x) + (mat1->c.z * mat2->c.x)) >> FIX16_FRAC_BITS;
+    matRes->c.y = ((mat1->c.x * mat2->a.y) + (mat1->c.y * mat2->b.y) + (mat1->c.z * mat2->c.y)) >> FIX16_FRAC_BITS;
+    matRes->c.z = ((mat1->c.x * mat2->a.z) + (mat1->c.y * mat2->b.z) + (mat1->c.z * mat2->c.z)) >> FIX16_FRAC_BITS;
+    tRes->z = (((mat1->c.x * t2->x) + (mat1->c.y * t2->y) + (mat1->c.z * t2->z)) >> FIX16_FRAC_BITS) + t1->z;
+
+    // rebuild matrix cached infos
+    M3D_buildMat3DExtras(result);
+}
+
+void M3D_combineTranslationLeft(Translation3D* left, Transformation3D* right, Transformation3D* result)
+{
+    // rebuild matrice if needed
+    if (right->rebuildMat) M3D_buildMat3D(right);
+
+    // copy unmodified value from right directly
+    if (result != right)
+    {
+        result->mat = right->mat;
+        result->matInv = right->matInv;
+        result->cameraInv = right->cameraInv;
+        result->lightInv = right->lightInv;
+    }
+
+//              x y z t   x y z t
+//
+//          a   1 0 0 x   k l m u   x     k l m u+x
+// tr.T =   b   0 1 0 y . n o p v   y  =  n o p v+y
+//          c   0 0 1 z   q r s w   z     q r s w+z
+//              0 0 0 1   0 0 0 1
+
+    const Translation3D* t1 = left;
+    const Translation3D* t2 = right->translation;
+    Translation3D* tRes = result->translation;
+
+    // only need to modify translation object (3 additions... ok :) )
+    tRes->x = t1->x + t2->x;
+    tRes->y = t1->y + t2->y;
+    tRes->z = t1->z + t2->z;
+}
+
+void M3D_combineTranslationRight(Transformation3D* left, Translation3D* right, Transformation3D* result)
+{
+    // rebuild matrice if needed
+    if (left->rebuildMat) M3D_buildMat3D(left);
+
+    // copy unmodified value from left directly
+    if (result != left)
+    {
+        result->mat = left->mat;
+        result->matInv = left->matInv;
+        result->cameraInv = left->cameraInv;
+        result->lightInv = left->lightInv;
+    }
+
+//              x y z t   x y z t
+//
+//          a   k l m u   1 0 0 x   x     k l m kx+ly+mz+u
+// tr.T =   b   n o p v . 0 1 0 y   y  =  n o p nx+oy+pz+v
+//          c   q r s w   0 0 1 z   z     q r s qx+ry+sz+w
+//              0 0 0 1   0 0 0 1
+
+    const M3f16* mat1 = &(left->mat);
+    const Translation3D* t1 = left->translation;
+    const Translation3D* t2 = right;
+    Translation3D* tRes = result->translation;
+
+    // only need to modify translation object (9 multiplications + 6 additions... ok :) )
+    tRes->x = (((mat1->a.x * t2->x) + (mat1->a.y * t2->y) + (mat1->a.z * t2->z)) >> FIX16_FRAC_BITS) + t1->x;
+    tRes->y = (((mat1->b.x * t2->x) + (mat1->b.y * t2->y) + (mat1->b.z * t2->z)) >> FIX16_FRAC_BITS) + t1->y;
+    tRes->z = (((mat1->c.x * t2->x) + (mat1->c.y * t2->y) + (mat1->c.z * t2->z)) >> FIX16_FRAC_BITS) + t1->z;
+}
+
+
+void M3D_buildMat3D(Transformation3D* t)
+{
+    M3D_buildMat3DOnly(t);
+    M3D_buildMat3DExtras(t);
+}
+
+void M3D_buildMat3DOnly(Transformation3D* t)
+{
+    Rotation3D* rot = t->rotation;
+    // get angles in degree (fix16 format)
+    fix16 rx = rot->x;
+    fix16 ry = rot->y;
+    fix16 rz = rot->z;
+
+    // normalize rotation angles
+    if (rx >= FIX16(360)) rx -= FIX16(360);
+    else if (rx < 0) rx += FIX16(360);
+    if (ry >= FIX16(360)) ry -= FIX16(360);
+    else if (ry < 0) ry += FIX16(360);
+    if (rz >= FIX16(360)) rz -= FIX16(360);
+    else if (rz < 0) rz += FIX16(360);
+    // store back after normalization
+    rot->x = rx;
+    rot->y = ry;
+    rot->z = rz;
+
+    fix16 sx = F16_sin(rx);
+    fix16 sy = F16_sin(ry);
+    fix16 sz = F16_sin(rz);
+    fix16 cx = F16_cos(rx);
+    fix16 cy = F16_cos(ry);
+    fix16 cz = F16_cos(rz);
+
+    t->mat.a.x = F16_mul(cy, cz);
+    t->mat.b.x = -F16_mul(cy, sz);
+    t->mat.c.x = sy;
+
+    fix16 sxsy = F16_mul(sx, sy);
+    t->mat.a.y = ((sxsy * cz) + (cx * sz)) >> FIX16_FRAC_BITS;
+    t->mat.b.y = ((cx * cz) - (sxsy * sz)) >> FIX16_FRAC_BITS;
+    t->mat.c.y = -F16_mul(sx, cy);
+
+    fix16 cxsy = F16_mul(cx, sy);
+    t->mat.a.z = ((sx * sz) - (cxsy * cz)) >> FIX16_FRAC_BITS;
+    t->mat.b.z = ((cxsy * sz) + (sx * cz)) >> FIX16_FRAC_BITS;
+    t->mat.c.z = F16_mul(cx, cy);
+
+    // matrix built
+    t->rebuildMat = 0;
+}
+
+void M3D_buildMat3DExtras(Transformation3D* t)
+{
+    t->matInv.a.x = t->mat.a.x;
+    t->matInv.b.x = t->mat.a.y;
+    t->matInv.c.x = t->mat.a.z;
+
+    t->matInv.a.y = t->mat.b.x;
+    t->matInv.b.y = t->mat.b.y;
+    t->matInv.c.y = t->mat.b.z;
+
+    t->matInv.a.z = t->mat.c.x;
+    t->matInv.b.z = t->mat.c.y;
+    t->matInv.c.z = t->mat.c.z;
+
+    // transform camview vector (0, 0, 1)
+    t->cameraInv.x = t->matInv.a.z;
+    t->cameraInv.y = t->matInv.b.z;
+    t->cameraInv.z = t->matInv.c.z;
+
+    // transform light vector (after rebuiltMat set to 0)
+    if (context3D.lightEnabled)
+        M3D_rotateInv(t, &(context3D.light), &(t->lightInv));
+}
+
+
+void M3D_translate(Transformation3D* t, V3f16* vertices, u16 numv)
+{
+    fix16 *d;
+    u16 i;
+    Translation3D* trans = t->translation;
+
+    const fix16 tx = trans->x;
+    const fix16 ty = trans->y;
+    const fix16 tz = trans->z;
+
+    d = (fix16*) vertices;
+    i = numv;
+
+    while (i--)
+    {
+        *d++ += tx;
+        *d++ += ty;
+        *d++ += tz;
+    }
+}
+
+void M3D_rotate(Transformation3D* t, const V3f16* src, V3f16* dest, u16 numv)
+{
+    const fix16 *s;
+    fix16 *d;
+    u16 i;
+
+    if (t->rebuildMat) M3D_buildMat3D(t);
+
+    s = (fix16*) src;
+    d = (fix16*) dest;
+    i = numv;
+
+    while (i--)
+    {
+        const fix16 sx = *s++;
+        const fix16 sy = *s++;
+        const fix16 sz = *s++;
+
+        *d++ = ((sx * t->mat.a.x) + (sy * t->mat.a.y) + (sz * t->mat.a.z)) >> FIX16_FRAC_BITS;
+        *d++ = ((sx * t->mat.b.x) + (sy * t->mat.b.y) + (sz * t->mat.b.z)) >> FIX16_FRAC_BITS;
+        *d++ = ((sx * t->mat.c.x) + (sy * t->mat.c.y) + (sz * t->mat.c.z)) >> FIX16_FRAC_BITS;
+    }
+}
+
+void M3D_rotateInv(Transformation3D* t, const V3f16* src, V3f16* dest)
+{
+    if (t->rebuildMat) M3D_buildMat3D(t);
+
+    const fix16 sx = src->x;
+    const fix16 sy = src->y;
+    const fix16 sz = src->z;
+
+    dest->x = ((sx * t->matInv.a.x) + (sy * t->matInv.a.y) + (sz * t->matInv.a.z)) >> FIX16_FRAC_BITS;
+    dest->y = ((sx * t->matInv.b.x) + (sy * t->matInv.b.y) + (sz * t->matInv.b.z)) >> FIX16_FRAC_BITS;
+    dest->z = ((sx * t->matInv.c.x) + (sy * t->matInv.c.y) + (sz * t->matInv.c.z)) >> FIX16_FRAC_BITS;
+}
+
+//void M3D_transform_old(Transformation3D* t, const V3f16* src, V3f16* dest, u16 numv)
+//{
+//    fix16 *s;
+//    fix16 *d;
+//    u16 i;
+//
+//    if (t->rebuildMat) M3D_buildMat3D(t);
+//
+//    Translation3D* trans = t->translation;
+//
+//    const fix16 tx = trans->x;
+//    const fix16 ty = trans->y;
+//    const fix16 tz = trans->z;
+//
+//    s = (fix16*) src;
+//    d = (fix16*) dest;
+//    i = numv;
+//
+//    while (i--)
+//    {
+//        const fix16 sx = *s++;
+//        const fix16 sy = *s++;
+//        const fix16 sz = *s++;
+//
+//        *d++ = F16_mul(sx, t->mat.a.x) + F16_mul(sy, t->mat.a.y) + F16_mul(sz, t->mat.a.z) + tx;
+//        *d++ = F16_mul(sx, t->mat.b.x) + F16_mul(sy, t->mat.b.y) + F16_mul(sz, t->mat.b.z) + ty;
+//        *d++ = F16_mul(sx, t->mat.c.x) + F16_mul(sy, t->mat.c.y) + F16_mul(sz, t->mat.c.z) + tz;
+//    }
+//}
+//
+//void M3D_project_f16_old(const V3f16* src, V2_f16 *dest, u16 numv)
+//{
+//    const V3f16 *s;
+//    Vect2D_f16 *d;
+//    fix16 zi;
+//    fix16 wi, hi;
+//    u16 i;
+//
+//    wi = viewport.x << 5;
+//    hi = viewport.y << 5;
+//    s = src;
+//    d = dest;
+//    i = numv;
+//
+//    while (i--)
+//    {
+//        if ((zi = (s->z + camDist)) >= 0)
+//        {
+//            zi = F16_div(camDist, zi);
+//            d->x = wi + F16_mul(s->x >> 1, zi);
+//            d->y = hi - F16_mul(s->y, zi);
+//        }
+//        else
+//        {
+//            d->x = wi;
+//            d->y = hi;
+//        }
+//
+//        s++;
+//        d++;
+//    }
+//}
+//
+//void M3D_project_s16_old(const V3f16* src, V2s16 *dest, u16 numv)
+//{
+//    const V3f16 *s;
+//    V2s16 *d;
+//    fix16 zi;
+//    u16 wi, hi;
+//    u16 i;
+//
+//    wi = viewport.x >> 1;
+//    hi = viewport.y >> 1;
+//    s = src;
+//    d = dest;
+//    i = numv;
+//
+//    while (i--)
+//    {
+//        if ((zi = (s->z + camDist)) >= 0)
+//        {
+//            zi = F16_div(camDist, zi);
+//            d->x = wi + F16_toInt(F16_mul(s->x >> 1, zi));
+//            d->y = hi - F16_toInt(F16_mul(s->y, zi));
+//        }
+//        else
+//        {
+//            d->x = wi;
+//            d->y = hi;
+//        }
+//
+//        s++;
+//        d++;
+//    }
+//}

package/src/platforms/genesis/lib/sgdk/src/maths3D_a.s

@@ -0,0 +1,205 @@
+    .extern    viewport
+
+#include "asm_mac.i"
+
+func M3D_transform
+    movm.l %d2-%d5/%a2-%a5,-(%sp)
+
+    move.l 36(%sp),%a2             	// a2 = &transform
+
+    tst.w (%a2)
+    jeq .L45
+
+    move.l %a2,-(%sp)
+    jsr M3D_buildMat3D
+    addq.l #4,%sp
+
+.L45:
+    move.l 2(%a2),%a0               // a0 = &translation
+    movem.w (%a0)+,%a3-%a5          // a3 = translation.x   a4 = translation.y   a5 = translation.z
+
+    move.l 40(%sp),%a0              // a0 = src
+    move.l 44(%sp),%a1              // a1 = dest
+    lea    10(%a2),%a2              // a2 = &(transform.mat)
+    move.w 50(%sp),%d5              // d5 = numv
+
+    subq.w #1,%d5
+    jmi    .L50
+
+.L48:
+    movem.w (%a0)+,%d2-%d4          // d2 = sx        d3 = sy        d4 = sz
+
+    move.w (%a2)+,%d0               // d0 = mat.a.x
+    muls.w %d2,%d0                  // d0 = mat.a.x * sx
+    move.w (%a2)+,%d1               // d1 = mat.a.y
+    muls.w %d3,%d1                  // d1 = mat.a.y * sy
+    add.l %d1,%d0                   // d0 = (mat.a.x * sx) + (mat.a.y * sy)
+    move.w (%a2)+,%d1               // d1 = mat.a.z
+    muls.w %d4,%d1                  // d1 = mat.a.z * sz
+    add.l %d1,%d0                   // d0 = (mat.a.x * sx) + (mat.a.y * sy) + (mat.a.z * sz)
+    asr.l #6,%d0
+    add.w %a3,%d0                   // d0 = (mat.a.x * sx) + (mat.a.y * sy) + (mat.a.z * sz) + translation.x
+    move.w %d0,(%a1)+               // dest++ = (mat.a.x * sx) + (mat.a.y * sy) + (mat.a.z * sz) + translation.x
+
+    move.w (%a2)+,%d0               // d0 = mat.b.x
+    muls.w %d2,%d0                  // d0 = mat.b.x * sx
+    move.w (%a2)+,%d1               // d1 = mat.b.y
+    muls.w %d3,%d1                  // d1 = mat.b.y * sy
+    add.l %d1,%d0                   // d0 = (mat.b.x * sx) + (mat.b.y * sy)
+    move.w (%a2)+,%d1               // d1 = mat.b.z
+    muls.w %d4,%d1                  // d1 = mat.b.z * sz
+    add.l %d1,%d0                   // d0 = (mat.b.x * sx) + (mat.b.y * sy) + (mat.b.z * sz)
+    asr.l #6,%d0
+    add.w %a4,%d0                   // d0 = (mat.b.x * sx) + (mat.b.y * sy) + (mat.b.z * sz) + translation.y
+    move.w %d0,(%a1)+               // dest++ = (mat.b.x * sx) + (mat.b.y * sy) + (mat.b.z * sz) + translation.y
+
+    muls.w (%a2)+,%d2               // d2 = mat.c.x * sx
+    muls.w (%a2)+,%d3               // d3 = mat.c.y * sy
+    add.l %d3,%d2                   // d2 = (mat.c.x * sx) + (mat.c.y * sy)
+    muls.w (%a2)+,%d4               // d4 = mat.c.z * sz
+    add.l %d4,%d2                   // d2 = (mat.c.x * sx) + (mat.c.y * sy) + (mat.c.z * sz)
+    asr.l #6,%d2
+    add.w %a5,%d2                   // d2 = (mat.c.x * sx) + (mat.c.y * sy) + (mat.c.z * sz) + translation.z
+    move.w %d2,(%a1)+               // dest++ = (mat.c.x * sx) + (mat.c.y * sy) + (mat.c.z * sz) + translation.z
+
+    lea -18(%a2),%a2                // a2 = &(transform.mat)
+    dbra %d5,.L48
+
+.L50:
+    movem.l (%sp)+,%d2-%d5/%a2-%a5
+    rts
+
+
+func M3D_project_f16
+    movem.l %d2-%d7/%a2-%a3,-(%sp)
+
+    move.l 36(%sp),%a0                      // a0 = s = src
+    move.l 40(%sp),%a1                      // a1 = d = dst
+    move.w 46(%sp),%d7                      // d7 = i = numv
+
+    subq.w #1,%d7
+    jmi .L34
+
+    lea context3D,%a2
+
+    move.w (%a2)+,%d5
+    lsl.w #5,%d5                            // d5 = centerX = FIX16(viewport.x / 2)
+    move.w (%a2)+,%d6
+    lsl.w #5,%d6                            // d6 = centerY = FIX16(viewport.y / 2)
+    moveq #0,%d4
+    move.w (%a2),%d4                        // d4 = camDist
+
+    move.w %d5,%d0
+    swap %d0
+    move.w %d6,%d0
+    move.l %d0,%a2                          // a2 = (centerX << 16) // centerY
+
+    move.w %d4,%d0
+    ext.l %d0
+    asl.l #6,%d0
+    move.l %d0,%a3                          // a3 = camDist << 6
+
+.L32:                                       // {
+    movem.w (%a0)+,%d0-%d2                  //   d0 = x = s->x, d1 = y = s->y, d2 = z = s->z
+
+    add.w %d4,%d2                           //   if ((zi = (camDist + z)) > 0)
+    jle .L30                                //   {
+
+    move.l %a3,%d3
+    divs.w %d2,%d3                          //       d3 = scale = F16_div(camDist, camDist + z)
+
+    muls.w %d3,%d0
+    asr.l #6,%d0
+    add.w %d5,%d0
+    move.w %d0,(%a1)+                       //       d->x = centerX + (scale * x)
+
+    muls.w %d3,%d1
+    asr.l #6,%d1
+    move.w %d6,%d0
+    sub.w %d1,%d0
+    move.w %d0,(%a1)+                       //       d->y = centerY - (scale * y)
+
+    dbra %d7,.L32
+
+    movem.l (%sp)+,%d2-%d7/%a2-%a3
+    rts                                     //   }
+                                            //   else
+.L30:                                       //   {
+    move.l %a2,(%a1)+                       //       d->x = centerX
+                                            //       d->y = centerY
+                                            //   }
+    dbra %d7,.L32                           // }
+
+.L34:
+    movem.l (%sp)+,%d2-%d7/%a2-%a3
+    rts
+
+
+func M3D_project_s16
+    movem.l %d2-%d7/%a2-%a3,-(%sp)
+
+    move.l 36(%sp),%a0                      // a0 = s = src
+    move.l 40(%sp),%a1                      // a1 = d = dst
+    move.w 46(%sp),%d7                      // d7 = i = numv
+
+    subq.w #1,%d7
+    jmi .L42
+
+    lea context3D,%a2
+
+    move.w (%a2)+,%d5
+    lsr.w #1,%d5                            // d5 = centerX = viewport.x / 2
+    move.w (%a2)+,%d6
+    lsr.w #1,%d6                            // d6 = centerY = viewport.y / 2
+    moveq #0,%d4
+    move.w (%a2),%d4                        // d4 = camDist
+
+    move.w %d5,%d0
+    swap %d0
+    move.w %d6,%d0
+    move.l %d0,%a2                          // a2 = (centerX << 16) // centerY
+
+    move.w %d4,%d0
+    ext.l %d0
+    swap %d0
+    asr.l #6,%d0
+    move.l %d0,%a3                          // a3 = camDist << (6 + 4)
+                                            // 6 to prepare for division
+                                            // 4 for *16 ratio
+
+.L40:                                       // while(i--) {
+    movem.w (%a0)+,%d0-%d2                  //   d0 = x = s->x, d1 = y = s->y, d2 = z = s->z
+
+    add.w %d4,%d2                           //   if ((zi = (camDist + z)) > 0)
+    jle .L38                                //   {
+
+    move.l %a3,%d3
+    divs.w %d2,%d3                          //       d3 = scale = F16_div((camDist << (4 + 2)), zi)
+
+    muls.w %d3,%d0
+    swap %d0
+    rol.l #4,%d0
+    add.w %d5,%d0
+    move.w %d0,(%a1)+                       //       d->x = centerX + (scale * x)
+
+    muls.w %d3,%d1
+    swap %d1
+    rol.l #4,%d1
+    move.w %d6,%d0
+    sub.w %d1,%d0
+    move.w %d0,(%a1)+                       //       d->y = centerY - (scale * y)
+
+    dbra %d7,.L40
+
+    movem.l (%sp)+,%d2-%d7/%a2-%a3
+    rts                                     //   }
+                                            //   else
+.L38:                                       //   {
+    move.l %a2,(%a1)+                       //       d->x = centerX
+                                            //       d->y = centerY
+                                            //   }
+    dbra %d7,.L40                           // }
+
+.L42:
+    movem.l (%sp)+,%d2-%d7/%a2-%a3
+    rts