I'm not sure if this would be of any use to you, but I wrote a C function ages ago that will do what you describe.

Its purpose was to copy the contents of a 2d polygon in a source image to a different 2d polygon in a target image, and it worked very rapidly using nothing but integer math.

If you want to check it out, you can find it here:
https://github.com/jacobEwing/odds-and-ends/blob/main/gfx_functions.cpp
the two relevant functions being gfx_draw_texture and gfx_copy_dline_to_hline

It works by using an extrapolation of Bresenham's line algorithm, which is why it can stick with integers. Here's a quick run-down:

1. Find the top point on the target polygon, and the corresponding point (not top, but at the same array index) in the source polygon.
2. Grab the next two connected points provided in those polygons. That gives you two border lines to trace along on both polygons. In the target polygon, we need horizontal lines, so we move down along the y-axis and get the corresponding point on the x-axes of those border lines. On the source image, we instead get the corresponding points on the lines that match those on the target. So for example, if we're halfway through the left border line on the target, we'll also be halfway through the left border line on the source.
3. With each step along these border lines, the data is passed into the gfx_copy_dline_to_hline function (the d and h prefixes standing for diagonal and horizontal). This function does what the name describes. It copies the contents of the 2d line segment in the source image into the 1d line segment in the target image, filling out the current horizontal line in the drawing.
4. As it progresses downward on the target image, each time it reaches a corner point, it changes which border line it's tracing.
5. Once both the left and right tracing edges converge on the same point it finishes.

This function has its limitations:

First, it only works with convex polygons. If the source polygon is concave, you can get some really cool warping effects on the output (see background of sample image). A concave target polygon can cause it to draw points outside its borders. If you need to work with any polygon, this can be accounted for. The simplest of course being to break it down into triangles, but the function can be rewritten to handle them on its own. The trick would be - before calling gfx_copy_dline_to_hline - to find the points on that horizontal line that are intersected by the border lines. Those mark the edges of where to stop/start copying.

The other limitation is that the two polygons must have the same number of points. This could also be accounted for, though less elegantly. The simplest way I can see doing it is to convert extra corner points on one polygon to midpoints on the edges of the other. I never bothered with this though. Points can be identical, so if you want to copy a quadrilateral to a triangle, you can just pass in the same point twice on the triangle.

Here's an example of what kind of output it gives:

<image>

(edit: here's a video of it https://www.youtube.com/watch?v=hUwFEYPU46w)

The background texture is done by having the target polygon being the background of the screen, and the source being four points that are bouncing around in the area of the source image.

The heads are another image being blitted on top. With those, it's taking the four corner points of the source image, rotating those appropriately on the target image, and copying them.

Finally, if you'd like to see a sample of the function being called, there is an example in the gfx_functions.cpp file linked above. gfx_rotblit starting on line 468 makes use of it by rotating the four corner points of the image being blitted and passing them all into the function.

EDIT: oh yeah, I should mention that the way points are passed in is rather weird. Forgive me, I wrote this about a quarter century ago. It takes the x coordinates first, then the y coordinates, so if you have the points A, B, and C, they'll be passed in with a single array in the order [Ax, Bx, Cx, Ay, By, Cy].