XNA texture stretching at extreme coordinates

Question

I was toying around with infinitely scrolling 2D textures using the XNA framework and came across a rather strange observation.

Using the basic draw code:

spriteBatch.Begin(SpriteSortMode.Deferred, null, SamplerState.PointWrap, null, null);
spriteBatch.Draw(texture, Vector2.Zero, sourceRect, Color.White, 0.0f, Vector2.Zero, 2.0f, SpriteEffects.None, 1.0f);
spriteBatch.End();

with a small 32x32 texture and a sourceRect defined as:

sourceRect = new Rectangle(0, 0, Window.ClientBounds.Width, Window.ClientBounds.Height);

I was able to scroll the texture across the window infinitely by changing the X and Y coordinates of the sourceRect.

Playing with different coordinate locations, I noticed that if I made either of the coordinates too large, the texture no longer drew and was instead replaced by either a flat color or alternating bands of color. Tracing the coordinates back down, I found the following at around (0, -16,777,000):

As you can see, the texture in the top half of the image is stretched vertically.

My question is why is this occurring? Certainly I can do things like bind the x/y position to some low multiple of 32 to give the same effect without this occurring, so fixing it isn't an issue, but I'm curious about why this happens. My initial thought was perhaps it was overflowing the coordinate value or some such thing, but looking at a data type size chart, the next closest below is an unsigned short with a range of about 32,000, and above is an unsigned int with a range of around 2,000,000,000 so that isn't likely the cause.

Update 1: The image above shows the texture stretching vertically near (0, -16,777,000), and the texture stretches horizontally at around (-16,777,000, 0). If I go beyond this point on both axes, the texture is stretched in both directions. This occurs in both the positive and negative directions.

The above positions were noted with a 32x32 texture. With a 16x16 texture, the distortion occurs at the same location. Interestingly, with a 64x64 texture, the distortion occurs in the same location on the x-axis, but is actually farther on the y-axis, more near (0, -17,301,000). It occurs at the same location with a 64x64 texture too, I mistakenly used a 64x66 texture before.

Update 2: I have repeated the test with a 1024x1024 texture and have found the same results. I looked farther and noticed that it stretches again at double the distance, somewhere near (-33,554,000, -33,554,00), but then doesn't happen again until around 4 times the initial stretching point, near (-67,109,000, -67,109,000).

It seems to occur only at powers of two times that initial value, 16,777,216 * 2^n. The answer below by mh01 suggested to check the MaxTextureRepeat cap of my graphics card (a GeForce GTX 560). According to KluDX this cap has a value of 8192, and it's description indicates that texture coordinates are stored in 32-bit signed integers.

Correction: The stretch points occur at 2^n intervals because my texture sizes are 2^n. Testing with a texture size of 25x33 resulted in the first stretch point appearing near (-13,107,000, -17,301,000). So while it's related to the texture's aspect ratio, it doesn't seem to be directly related to the texture's size.

Answer 1

I think you've found some weird corner case bug, but you should never be in the scenario that your source rect has a coordinate like -16.777,000. It looks like you're not 100% sure what source rect is for.

The source rectangle should 'never' (I'll get back to that) be larger than the size of the texture. What the source rectangle does is select the part of the texture that will be drawn to the sprite you've selected. Say you have a texture that is 200x200, now if you only want the top left quadrant to be drawn you would use a source rectangle like (0,0, 100, 100).

Now for infinitely scrolling textures. As you've noticed you can keep updating the x and y coordinates of the source rectangle to have it keep scrolling. This happens because in certain texture modes (like Linear Wrap) a coordinate that would be outside the texture is placed inside the texture again by using the modulo of the texture size. So to counter the bug you've encountered we need to add this code ourselves so that the linear wrap algorithm never encounters such large numbers.

So some code:

int x; //x-coordinate of source rectangle
int y; //y-coordinate of source rectangle
int width; //texture width
int height; //texture height

x = x % width; //x will always be smaller than 2x the texture width
y =y % height; //y will always be smaller than 2x the texture height

Rectangle sourceRect = new Rectangle(x,y, width, height);

This should fix your problem :)

Answer 2

Check the value for MaxTextureRepeat in your DirectX Caps Viewer (you'll need the DX SDK installed for this of course).

Answer 3

Having been unable to come up with a better solution, I'm going to settle on this being due to floating point precision errors at such extreme coordinates. As Roy T. pointed out, you should never come across such coordinates in a properly set up environment, so it is effectively a non-issue, but hopefully this question will provide answers for those experiencing this issue.