[SyncVar] and variable initialization in Unity.

In the clients and server game I am developing, I need to recognize which player the client is.

So I pass the player number I set in the server to the client using a SyncVar.

However, there is a problem.

If you set the player number in the server, it will be overwritten by the server itself to it’s default value.

Why is that?

The reason is that the initialization of SyncVar happen somewhere after your player Object was already initialized locally. So setting the player number value right after Initialize() might be overwritten once the player is spawned.

In order to overcome this you need to send a message from the server to the client with the Player Number when the server adds the player.
Once the client’s player has spawned he can call a Cmd to update the player number on the server(the number it received from the server with a message).

(Kind of complex, not sure if there is a better way to do this identity synchronization)

            bool leftPlayer = FindObjectOfType<NetManager>().GetPlayerNumber(NetworkServer.connections[k].connectionId) == 1;
            var go = (GameObject)Instantiate(
                transform.position + new Vector3(0, 10, 0),
            int netPlayer = leftPlayer ? 0 : 1 + (isServerOnly ? 1 : 0);
            go.GetComponent<NetPlayer>().player1 = netPlayer;
            go.GetComponent<NetPlayer>().playerControllerId = 0;
            PlayerMessage msg = new PlayerMessage();
            msg.player1 = netPlayer;
            NetworkServer.SendToClient(NetworkServer.connections[k].connectionId, (short)(MsgType.Highest + 5), msg);
            NetworkServer.AddPlayerForConnection(NetworkServer.connections[k], go, go.GetComponent<NetPlayer>().playerControllerId);

Here is the code that handles the message on the client:

public void OnPlayerMessage(NetworkMessage netMsg)
   PlayerMessage message = netMsg.ReadMessage();
   myPlayer1ID = message.player1;

myPlayer1ID is a static int.

And then on the client I do this:

void Update()
       if (hasAuthority && !didInitServer)
              didInitServer = true;

public void SetServerPlayerNumber(int playerNumber)
void CmdSetNumber(int number)
       playerNumber = number;


Here is a similar code for creating the player on the server, what is wrong with this code?

        bool leftPlayer = FindObjectOfType().GetPlayerNumber(NetworkServer.connections[k].connectionId) == 1;
var go = (GameObject)Instantiate(
transform.position + new Vector3(0, 10, 0),
go.GetComponent().player1 = leftPlayer?0:1 + (isServerOnly ? 1 : 0);
go.GetComponent().playerControllerId = 0;
PlayerMessage msg = new PlayerMessage();
msg.player1 = go.GetComponent().player1;
NetworkServer.SendToClient(NetworkServer.connections[k].connectionId, (short)(MsgType.Highest + 5), msg);
NetworkServer.AddPlayerForConnection(NetworkServer.connections[k], go, go.GetComponent().playerControllerId);


What’s wrong with this code is that msg.player1 might not be what we want, because go.GetComponent<NetPlayer>().player1 is SyncVar and might get it’s default value overwrite the value we have just set.

Mipmaps and GL_REPEAT Artifacts in OpenGL ES 2.

I am working on a new racing game and I encountered some odd artifacts in rendering the textures of the track.

I verified that the artifacts are not ZBuffer fighting related and I couldn’t tell what caused it.

The track has a repeating texture which means it use one texture and repeat it along the track segments.

Track Start Artifacts

Track Start Artifacts

Guard Rail Artifact

Guard Rail Artifact

In the first image notice the patch of asphalt just before the car. It has artifacts while the patch further away does not.

In the second image look at the guard rails.

This phenomena happened by using either a raw mipmapped texture or a compressed mipmapped texture(pvr on iOS).

However, it only happened on textures that used the GL_REPEAT flag and not on other mipmapped textures.

So what was it?

It turned out that there was an issue with calculating the level of the mipmap.

Notice on the rail guard image that the artifact happen at a specific band of depth range which is the transition between one mipmap level to a lower level.

Look at the UV mapping of the track on the bottom right window:

Long UV mapping

Long UV mapping

The UV mapping for this track stretch way beyond the U texture mapping coordinate .

If the UV coordinates repeat on the range of [0..1]x[0..1] then the mapping on this object reach a U coordinate of about 50.

This is done to make use of the repeating texture but it is also messing up with the OpenGL ES 2 internal calculation of the mipmap.

With large U coordinates I am guessing there is a floating point accuracy issue with the mipmap calculation. I don’t exactly know how the mipmap calculations are done but I assumed this is the cause of the artifacts.

Notice that in the first artifacts screenshots the car is at the beginning of the track, which means the first patch you see on the screenshot is actually the last patch on the track model as the track is cyclic.

The artifacts get worse the further you go on the UV mapping as the values are bigger and cause more floating point accuracy issues.

Since the texture is repeating it doesn’t matter if the UV mapping is repeating the same UV area.

I made a more compact UV mapping version of the same model:

Compact UV mapping

Compact UV mapping

Using this version of the mesh made all the artifacts disappear!

Start Fixed

Start Fixed

Guard Rail Fixed

Guard Rail Fixed

In conclusion:

If you verified that you don’t have ZBuffer issues.

If you see depth related artifacts on a specific range band of a texture with mipmaps.

And if the artifacts do not appear on small UV coordinates but become more severe the more the UV coordinates are away from [0..1]x[0..1], then there is a good chance you have a UV mapping mipmap related artifacts.

Solving this issue might be as simple as remapping the UVs to have values closer to [0..1].

There is more to say why this happens and what exactly are the floating point inaccuracies that happen in the mipmap calculation done by OpenGL but this is beyond the scope of this article.

I hope you find this article useful.


Getting wrong screen resolution on iPod touch or iPhone 5? Launch image woes… (iOS)

I was working on improving my existing game Concussion Boxing and adding a new block move.

Part of it was replacing the splash screen and icon into a better looking ones.

Newer generations of iPhones and iPods have a 4 inch display and a non retina resolution of 320×568 while older devices with a 3.5 inch screen have only 320×480.

In AppDelegate I would load the correct xib file to match the screen resolution.

I would use: [[UIScreen mainScreen] bounds].size.height to figure out which screen resolution my device has.

However, for my iPod touch 5 with iOS 7 on it I would get the wrong resolution(320×480) from the bounds property instead of the 4 inch resolution.

It turns out that not having the correct Launch images set up for the application could prevent your app from running with the correct resolution for the device.

Setting the launch images is a bit tricky, you need to set the exact correct file names in order for this to work.

This post show you the correct naming for the launch images:


Even after naming correctly your launch images you may get a black splash screen instead of the image you have set.

This is due to the fact that PNG files have several types of formats and not all of them are displayed correctly.

In my case a PNG image with transparency(32 bit pixels) was not  displayed while saving the image in 24 bit with Paint.Net worked and displayed correctly.

Location 0? location -1? glGetUniformLocation, C++ and bugs. (Android\iOS GLES 2)

In OpenGLES 2 glGetUniformLocation receives the program id and a string as parameters. It then attempts to return a location int that can be used to set uniform GLSL shader variables.

If the variable is found it will return a 0 or positive value. If it fails to find the uniform variable it will return -1.

In C++ we should initialize the location ints in the ctr. If we don’t initialize the locations we might have garbage values when in Release mode.

Using the locations with garbage values might overwrite uniform variables with values we did not intend them to have.

So what we should initialize the locations with? One might think that 0 is a good value to initialize but it is not.

Remember! 0 is a valid shader uniform variable location. If we set all the locations to 0 we might overwrite the uniform variable at location 0.

We should initialize the location ints with -1.

We should do this because -1  is the value that is returned in case the uniform variable was not found and setting a value at location -1 will be ignored.

GLSL(OpenGL Shader Language) compilation bug with for loop on Adreno 205, Android.

One of the biggest advantages of the OpenGL API specification is that OpenGL is language agnostic.

That means it can be implemented on almost any programming language which makes it a very portable library.

However, there is a serious issue with OpenGL. It’s shader language(GLSL) has no specification for compilation. You can’t rely on binary files of compiled shaders to work on different devices.

Not only that but compiling the GLSL source code while running the app on different devices might produce different results or even silent bugs(Depending on driver implementation).

My game Shotgun Practice was running perfectly on my device(Galaxy Note N7000) but didn’t work on my friend’s device(HTC Desire Z).

On my friend’s ‘HTC Desire Z‘ Android device with the ‘Adreno 205‘ GPU it had graphics artifacts.

After quite some tests I found that a specific shader was the culprit. That shader was the vertex shader of skinned objects.

It took me a lot of tests because the driver for HTC Desire Z didn’t report any error or warning upon compiling and validating the skinning shader.

Eventually it boiled down to the part of code that transforms the vertices with the relevant bones.

Doesn’t work on HTC Desire Z

for(int i = 0; i < 4; ++i)
	mat4 m = BoneTransform[Index[i]];
	posOut += (w[i]*m*vec4(position, 1.0)).xyz;
	normalOut += (w[i]*m*vec4(normal, 0.0)).xyz;

Works on HTC Desire Z

mat4 m = BoneTransform[Index[0]];
posOut += (w[0]*m*vec4(position, 1.0)).xyz;
normalOut += (w[0]*m*vec4(normal, 0.0)).xyz;
m = BoneTransform[Index[1]];
posOut += (w[1]*m*vec4(position, 1.0)).xyz;
normalOut += (w[1]*m*vec4(normal, 0.0)).xyz;
m = BoneTransform[Index[2]];
posOut += (w[2]*m*vec4(position, 1.0)).xyz;
normalOut += (w[2]*m*vec4(normal, 0.0)).xyz;
m = BoneTransform[Index[3]];
posOut += (w[3]*m*vec4(position, 1.0)).xyz;
normalOut += (w[3]*m*vec4(normal, 0.0)).xyz;

As you can see the code that doesn’t work has a ‘for loop’ and in the code that works I manually unrolled the ‘for loop’.

I also tested if the issue was that ‘mat4 m’ was inside the ‘for loop’ block or that using a hard coded number of iterations would cause a faulty loop unrolling.

Neither attempts worked. I don’t know exactly what is the driver issue with this but I was told you should use ‘for loops’ very cautiously in GLSL meant for mobile devices.


Beware of ‘for loops’ and generally branching in GLSL meant for mobile devices.

But even worse, some drivers(hopefully only old devices) might not warn you that the shader isn’t going to work on the device even though it passed all the validation.

std::vector resize bug

There is a certain bug that I keep making again and again.

In C++ there is a standard template library data structure called vector.

It is a data structure that gives you random access to it’s content, much like an array.

A vector can be of variable length and there are several ways to initialize and change it’s size. One of the methods to change it’s size is std::vector::resize.

The advantage of resize is that it can be used after the ctr. But there is a subtle point that needs to be considered.

When you resize std::vector it doesn’t necesseraly call the dtr of it’s content.

The most common issue of this for me is when I want to load new data to std::vector not realizing the old data is still there. Imagine we have std::vector<std::list<unsigned int> >.

After resizing the lists in this case might not be empty.

In order to make sure your vector is empty you should call std::vector::clear first.