Affine Sprite Rotation

[michaelsarr]

I was looking at
https://github.com/raspberrypi/pico-playground/blob/master/scanvideo/sprite/affine_transform.h
for some ideas about rotating sprites

I'm stumped at the moment about getting it rotate around its center and not the upper left pixel
any ideas?

IMG_6448.MOV

I think the sin and cos are correct.. this is how I made them

/// Fixed-point Format: 8.8 (16-bit)
typedef uint16_t fixed_point_t;
#define FIXED_POINT_FRACTIONAL_BITS 8
inline double fixed_to_double(fixed_point_t input)
{
        return ((double)input / (double)(1 << FIXED_POINT_FRACTIONAL_BITS));
}

inline fixed_point_t double_to_fixed(double input)
{
        return (fixed_point_t)(round(input * (1 << FIXED_POINT_FRACTIONAL_BITS)));
}


int main()
{
        printf("const sin_lookup_fp8_8[256] = { \n\t");
        double t = 0;

        for (int loop =0 ; loop < 256; loop ++)
        {
                printf("0x%04x", double_to_fixed(sin(t))) ;
                if (loop != 255)
                        printf(", ");
                if ( loop && loop % 16 ==15)
                        printf("\n\t");

                t += ((2*M_PI) / 256);
        }

        printf("\n\t};\n");




        printf("const cos_lookup_fp8_8[256] = { \n\t");
        t = 0;

        for (int loop =0 ; loop < 256; loop ++)
        {
                printf("0x%04x", double_to_fixed(cos(t))) ;
                if (loop != 255)
                        printf(", ");
                if ( loop && loop % 16 ==15)
                        printf("\n\t");

                t += ((2*M_PI) / 256);
        }

        printf("\n\t};\n");



        return 0;
}

the picocomputer code is at

https://github.com/michaelsarr/pico6502_sprite_rotation

[rumbledethumps]

Circle the origin around your new center. Here's some general math info: https://docs.godotengine.org/en/stable/tutorials/math/index.html

[michaelsarr]

i set the position of the sprite to the points along the perimeter of a circle around my desired center as I rotated it but
its not working.
.. more reading i guess..

Img.6452-1.mp4

[rumbledethumps]

Right idea, but use transform[2] and transform[5].

[vruumllc]

I'm not sure if you've figured this out yet, but I needed to know this too.
Here's what I've got so far.
(NOTE: It doesn't seem to work for sprite of size 128x128, although smaller sizes work fine)

static const int16_t sin_fix8[] = {
        0,  66, 128, 181, 222, 247, 256, 247, 222, 181, 128,  66,
        0, -66,-128,-181,-222,-247,-256,-247,-222,-181,-128, -66,
        0
};

static const int16_t cos_fix8[] = {
    256, 247, 222, 181, 128,  66,   0, -66,-128,-181,-222,-247,
   -256,-247,-222,-181,-120, -66,   0,  66, 128, 181, 222, 247,
    256
};

// fix_8((1+(sin(theta_deg)-cos(theta_deg)))/2)
static const int16_t t2_fix8[] = {
        0,  37,  81, 128, 175, 219, 256, 285, 303, 309, 303, 285,
    256, 219, 175, 128,  81,  37,   0, -29, -47, -53, -47, -29,
        0
};

// fix_8((1+(sin(360-theta_deg)-cos(360-theta_deg)))/2)
// (just the reverse of table above, so unnecessary!!
/*
int16_t t5_fix8[] = {
        0, -29, -47, -53, -47, -29,   0,  37,  81, 128, 175, 219,
    256, 285, 303, 309, 303, 285, 256, 219, 175, 128,  81,  37,
        0
};
*/

// ----------------------------------------------------------------------------
// Rotate an affine sprite around its center point, rather than top left.
//
// The asprite_dim is W (and H) in pixels of the affine sprite.
//
// All fix_8 tables assume 15 degrees incr. for each index, 0 to 360 degrees.
// Positive theta_deg for CW rotation, negative theta_deg for CCW.
//
// NOTE: This routine assumes sprite is NOT scaled!
//       I haven't figured out how to rotate a scaled sprite yet.
// ----------------------------------------------------------------------------
bool rotate_asprite(uint16_t asprite_config, uint8_t asprite_dim, int16_t theta_deg)
{
    // the number of elements in each array
    static const uint8_t n = sizeof(sin_fix8) / sizeof(int16_t);

    // check theta_deg for validity
    if ((theta_deg >= -360) && (theta_deg <= 360) && ((theta_deg%(360/(n-1))) == 0)) {

        // compute desired index into arrays
        uint8_t i;
        if (theta_deg > 0) { // want clockwise rotation
            i = (360-theta_deg)/(360/(n-1));
        } else {             // want counter-clockwise
            i = -theta_deg/(360/(n-1));
        }

        printf("theta_deg = %d, i = %d, t2_fix8[i] = %d, t5_fix8[i] = %d\n",
               theta_deg, i, t2_fix8[i], t2_fix8[n-i-1]);

        xram0_struct_set(asprite_config, vga_mode4_asprite_t, transform[0], cos_fix8[i]);
        xram0_struct_set(asprite_config, vga_mode4_asprite_t, transform[1], -sin_fix8[i]);
        xram0_struct_set(asprite_config, vga_mode4_asprite_t, transform[2], asprite_dim*t2_fix8[i]);
        xram0_struct_set(asprite_config, vga_mode4_asprite_t, transform[3], sin_fix8[i]);
        xram0_struct_set(asprite_config, vga_mode4_asprite_t, transform[4], cos_fix8[i]);
        xram0_struct_set(asprite_config, vga_mode4_asprite_t, transform[5], asprite_dim*t2_fix8[n-i-1]);
        return true;
    }
    printf("Invalid theta_deg = %d!/n", theta_deg);
    return false;
}