The clamping could be just that; clamping. Check the texture wrapping mode to ensure that it is actually wrapping the texture coordinates and not clamping them.

That was my thought too. Assuming your PC implementation is DirectX, it's worth knowing that texture wrapping modes are set per sampler in DirectX, so they're global, while in OpenGL the setting is applied to the texture object. Perhaps it's a bug in your abstraction layer where that difference isn't correctly reflected.

As mentioned, after creating the texture you need to call:

::glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );

::glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );

It defaults to GL_REPEAT so you are likely accidentally calling ::glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE ); (etc.) somewhere while that texture is bound.

After creating a texture and setting all of its parameters and data, always unbind the created texture to avoid accidentally changing one of its parameters just because it was left bound after creation.

To be 100% sure, as a test you can set GL_REPEAT just after binding the texture for rendering. If it solves the problem then you have encountered the bind-to-edit problem of OpenGL (and OpenGL ES). That isn’t a solution, however; the solution will be one of the above (or finding the accidental setting of GL_CLAMP_TO_EDGE and eliminating it).

L. Spiro

I use OpenGL for both desktop and mobile versions of the engine, so the codepath is exactly the same.

The problem is that seems that OpenGL ES 2.0 does not support wrapping in non power of 2 textures. I resized the snow texture to 256x256 and it worked.

It is a strange limitation, but oh well, now I know how to work around it

It's not that strange a limitation; I'd be willing to bet that it doesn't support mipmaps on them either (confirmed - see the "Notes" section). This is essentially what D3D9 called "conditional non-power-of-two" and what older versions of OpenGL exposed via the GL_ARB_texture_rectangle extension, which was limited non-power-of-two support with exactly these restrictions.

Relfos, you just don’t understand the raw power…of 2.

2’s power is so great that it only takes 32 of them and you have 4,294,967,296. Clearly 2 is a powerful number.

2 is clearly the God among all numbers. The power of 2 is so great that divides and multiplies with it used to be faster (and may still be on some cards used in mobile devices) on many GPU’s. It also has enough power to improve mipmaps. Since each mipmap from the base up to the highest resolution doubles each time, it is by default a power-of-2 chain. Unless you start with highest dimensions that are powers-of-2, you can’t create a mipmap chain that evenly divides in half all the way down to 1×1.

Low-end devices such as Android, iOS, Xbox, PlayStation 2, etc., need all the extra power they can get, and there is no greater power…than the power…

…of 2.

L. Spiro