How can I get Unity to stop resampling my sprites?

How do you render into that texture? Do you use RenderTextures or regular textures? Do you create textures by script or are you exclusively using project assets? When you hit play and zoom in, hit pause, then select the object you suspect to have 32x32 in the scene view and find the texture in the inspector. What resolution does it give in the preview? Are any other settings off?

We need more information.

It is just a plain project asset, a PNG. The image in the preview is the original resolution on disk (24x24), but in Scene and Game view it's 32x32 with the resampling artifacts.

So you counted the pixels? Are you certain it's not just interpolation artefacts from bilinear sampling? While zoomed in in Play mode, does the texture change if you modify the texture asset, for example limiting it to 16x16, setting Filter mode to "Point", etc.?

Yes, I counted the pixels. I posted the image so you can too. :) There is no bilinear sampling; it's set to Point mode. If I use a 32x32 asset it renders perfectly.

Hm, this shouldn't happen ^^

Try a reimport of the texture. Also, try my 16x16 suggestion. Does the scene view react to the change?

Another idea: any platform dependent texture settings? What are you building for (i.e., what's your project set to), Win/$$anonymous$$ac, iOS, Android?

Limiting to 16x16 doesn't appear to be an option; the $$anonymous$$ax Size option in the Inspector doesn't go lower than 32 for me. Changing to bilinear blurs the image, as expected. No platform specific settings, build mode set to PC/$$anonymous$$ac Standalone.

What shader are you using for that object?

In advanced and check there is no mipmaps activated, nearestPowerOfTwo to none and point mode ?

Hm, come to think of it, I seem to remember there has been some bug for ages where small(?) textures are resampled despite being set to non-power-of-two. Unfortunately I don't have my Unity here, so I can only confirm that tomorrow.

@liszto: It makes no difference. $$anonymous$$y screenshot was with the texture in GUI mode but if I switch to Advanced with those settings it looks identical. @Wolfram: currently using the Unlit/Transparent shader. The same effect appears with any shaders I try though.

Sorry I didn't get back to you earlier. The answer is "yes, Unity resamples your textures, and no, you can't prevent it". See my answer for a more detailed explanation.

Additional note: if you look along the rim of your resampled texture you'll notice several pixels interpolated towards white, although the original texture has no white pixels there. This is a problem of how you generate/prepare your alpha textures, and can later bite you in the, umh, bum, even if you use true POT textures. See @Eric5h5's answer in this question, where Ben $$anonymous$$t explains the approach to prevent these errors.

That should only apply if you bilinearly sample them. With point sampling it should always be exactly on a texel with no blending. Ideally, if I was going to be bilinearly sampling textures with alpha, I'd use premultiplied alpha with additive blending which doesn't have these problems.

As Eric explains, it is independent of the filtering method and mipmapping, so you will get this problem even with point sampling (see his snapshot).

However, it is not a problem if you always display your textures "pixel perfect" (=1 texel displayed exactly in 1 pixel). Which I suppose you do?

Once you start to zoom in or zoom out, the problem will become visible.

I am not sure how anti-aliasing influence/intensify this behaviour.

UPDATE: O$$anonymous$$, I did some analysis of that.

If you exclusively use either 0% or 100% alpha pixels, you are correct that setting the (POT!-)texture to "Point" is enough to prevent the white rims, independent of mipmapping - if the textures are displayed pixel-perfect or enlarged. Artifacts will appear even for "Point" if a) mipmapping is enabled, and b) the texture is displayed at 70% (=1/sqrt(2)) or smaller. Or if you have any half-transparent pixels in your textures (or use NPOT textures).

I'll update Eric's answer with additional snapshots and more info.

$$anonymous$$ipmapping causes problems because the extra mip levels are essentially filtered downsamples. Without that, point sampling should always be fine by definition, because it never blends texels. If Unity is doing something different then that is likely to be a bug.

Unity generates the mip levels always via bilinear texel interpolation, independent of the point/bilinear/trilinear filter mode setting. The filter mode is merely an output setting, which does nto modify the texture data. This is also the default behaviour for both OpenGL and DirectX. AFAI$$anonymous$$ DirectX in theory allows point sampling for mipmap generation, while OpenGL does not, but I could be wrong.

Summary of the white-alpha-pixel-problem: http://forum.unity3d.com/threads/168532-White-rims-around-transparent-textures-an-analysis

I know, there's no safe way to use mipmaps if you want to avoid texture bleeding unless you manually generate the mip levels yourself. I was trying to say that if you have no mip mapping then point sampling should always work. The only exception would be anti-aliased diagonals, but I don't understand why it would be sampling the white pixels. I guess that's a multisampling issue.

For reference: the whole internal-rescaling-to-POT-for-NPOT-textures issue is fixed in Unity 4 (tested 4.2.0)!