Oh boy, blurry aids question
You can use a x2 picture and keep pixel without blur if it don't move. But on moving picture it remain some very light blur pixels on the edges. It can work if you want a pixel perfect background or HUD and keep a blur tolerance on characters and bullets.
Its not anti-aliasing, or even close to what AA even does. The problem is that your texture's width and height are not a power of 2. This is a feature that DirectX9 has that will resize images that are not a power of 2 (n^2), which causes the image to be blurred and distorted.
This actually isn't entirely true. Yes, you do have to use images of dimensions 2
n due to the aforementioned reason. Additionally though, the reason why moving pictures are blurred is largely due to rendering at non-integer positions. Even if you're drawing a sprite at a fixed location, but non-integer, it will also get blurry aids from interpolation gimmicks (not AA).
a) Drawn at (0, 0)
b) Drawn at (0.5, 0)
c) Moving with speed 2 and angle 45

One problem is that if you're using any sort of vector-based movement (SetSpeed() and SetAngle(), SetDestAtFrame(), etc) the position change is applied at the end of the frame by the engine (so you can no longer change it), but right before it's rendered, so you can't simply force the position and have it work like that.
However, when pixel perfect precision is wanted, there is, as far as I know, no way to turn this off and keep the original pixels of the source image. Is there a way to turn off anti-aliasing in Danmakufu? If there is a solution involving shaders, I will consider it.
There's a solution for Primitive objects. Unfortunately I haven't found a way to perfectly render things like Shot objects without introducing fairly significant overhead.
Basically though, you calculate the object's position in advance, get the decimal portion of the next position, and subtract it not from the object's position, but its rendering destination.
For example, if an object were moving at speed 2 and angle 40 from (100, 100), its next position will be (100 + 2*cos(40), 100 + 2*sin(40)) = (101.532089, 101.285575), so you want to offset the rendering location by (-0.532089, -0.285575) in order to get a clean (101, 101). The downside to this is that since you're actively trying to remove any interpolation, some movement (especially slow movement) might look not as smooth since it is moving a pixel at a time.
function ObjSprite2D_Clean(obj, l, t, r, b){
let hw = (r - l) / 2;
let hh = (b - t) / 2;
let a = ObjMove_GetAngle(obj);
let s = ObjMove_GetSpeed(obj);
let off_x = (ObjRender_GetX(obj)+cos(a)*s)%1;
let off_y = (ObjRender_GetY(obj)+sin(a)*s)%1;
ObjSprite2D_SetDestRect(obj, -hw - off_x, -hh - off_y, hw - off_x, hh - off_y);
}
For Primitive objects in general you'd have to change the position of each vertex accordingly. You should also be able to see why it won't work with Shot objects: they have no way to set their rendering location.