Image

Adopt these following guidelines for creating all 2D assets (icons, textures) for Unity The textures made should follow the basic game textures standard rules. Other specific guidelines will be provided based on the project. The basic guidelines are as below:

• Textures should be 72 dpi / RGB / 8 bit

• The resolution of textures should be in the power of 2.

• Sample power of 2 images 32x32, 64x64, 128x128, 256x256, 512x512 and so on.

• If the texture has to be rectangular, use resolutions such as 32x64, 64x512, etc.

• Textures should have a relevant photoshop file along with the final texture/icon.

• Textures, icons, and images should always be in higher resolution. For example, if the desired resolution is 64x64, then the texture should be made in 512x512 or 256x256.

• The final texture should be in PNG / TGA format. (Format will be decided or changed according to the project needs)

 

3D

Asset Creation (Maya/Max) The creation of assets should follow the standard rules, as mentioned below:

• Suitable references should be with accurate dimensions before creating 3d models.

• The camera near clip and far clip values should be checked.

• The dimension settings in the application should be checked.

• Every model should be created in both High Poly and Low Poly configurations.

• Assets should be free of open vertices, edges, and polygons by merging them.

•  Assets should not have double polygon faces to avoid mesh artefacts.

• Assets can have an extra edge only when it is necessary

• The vertices / Polygon count of the asset should be maintained based on project requirements. 

• Assets Should have a proper naming convention. E.g. Category_Subcategory_01_ mesh.

•  Before proceeding to texture processing, the model should be unwrapped post-completion.

• UV should not overlap.

• Pack UV appropriately.

• Assets should use Maya/Max materials only (if there are any other renderers such as V-ray, do not use those materials for Unity objects).

• The material count should be minimum by utilizing textures to obtain the required effect. Material names should have a prefix like Category_Subcategory_01_, thereby making them relevant to the object.

• Use Lambert, Phong, Blin appropriately.

•  The proper texture should be assigned to relevant materials (refer to 2d asset guidelines on creating textures)

• Name Emissive materials/glow mat with the suffix - glow. For example, glow5_mat / Glow3_Mat, etc. Asset Export (Maya/Max)

• The Center pivot position should be maintained for all objects.

• The developer will decide on Pivot positions based on the project requirements.

• The object should be snapped exactly above the grid. (i.e. the object value should be (0,0,0)).

• The texture file should be in the same directory location where we export the FBX

• Texture files should be named accordingly.

• History deletion.

• Freeze Transformation. 

• Maintain a separate folder structure for the models, icons, and texture. e.g., As- sets\3d models\fbx\table.fbx, Assets \3dmodels \fbx \ wooden_table.png,  Assets\3dmodels\fbx\table_icon.png

•  Export Objects to (.fbx) format. (Object name in the outliner and the FBX name should be the same).

 

Asset Import (Unity3D)

• Create a Unity Project file.

• Add the assets folder and paste the exported 3d models into the project.

• Extract all the material to the respective folders.

• Drag all the FBX and drop it into the Hierarchy panel.

• Verify all the objects are in (0,0,0) position and scale in (1,1,1).

• Add mesh collider to every object in the Hierarchy panel.

• Create a prefab individually for all the objects.

• Install the asset bundle browser from the unity package.

• Select all the prefab and drop it into the asset bundle browser to create names for the asset bundle (Using the “Asset bundle browser” package).

 

Select all the prefab and create asset bundles for Android, IOS, and Windows. These are all the standard guidelines for making a 3D static asset for Unity. We can update the Project-specific guidelines according to game/app requirements. Note: I have not mentioned Animation guidelines with this document. We can develop these guidelines separately based on project requirements. 

 

#Code

Document for developers

 

_namespace

• Maintain all namespace under Inspirit. For example, Inspirit.UI, Inspirit.Network, etc.

• All scripts should be under Inspirit namespace.

 

_functionality  

• Maintain each functionality under relevant scripts. For example, enabling and disabling UI should be under UIManager or UI related scripts. Scripts should not have randomly written functionalities. .

• For example, An authentication call should be under Eduiz. Network.

 

_cleancode 

• Use events and delegates to maintain clean code.

• Check the below links for more

https://learn.unity.com/tutorial/events-uh#5c894782edbc2a1410355442 http://www.theappguruz.com/blog/using-delegates-and-events-in-unity

​

Snippet

• Public delegate void ButtonPressed ();

• Public event ButtonPressed OnButtonPressed;

​

Do not use Invoke and SendMessage or anything that uses string to call a method. Use coroutine or action. 

​

Snippet

     public static Coroutine Invoke(this MonoBehaviour monoBehaviour, Action action, float time)

     {

            return monoBehaviour.StartCoroutine(InvokeImpl(action, time));

     }

​

     private static IEnumerator InvokeImpl(Action action, float time)

     {

            yield return new WaitForSeconds(time); action();

     }

 

_comments

• Write a summary of each function 

• Each class should have a brief

 

_usage

• Use enum instead of Boolean 

• Save game state in enum 

• Save game OnApplicationPause () // OnApplicationQuit () 

• Save player status on regular intervals (depends on the game) 

• Use prefabs. Do not use models directly in scene. Make use of the “New Prefab System” (keep the prefabs as hierarchy prefab if necessary)

• Do not use strings other than displayed text. If necessary, use const string and as- sign the value

•  Code repetition is not allowed

• Do not use public variables for the sake of making it visible in the Inspector window.

• Use private variables and [serializeField] 

• Use properties to make get/set values private/public

 

_sourcecontrol//versioncontrol 

• Only commit, when the code is complete and bug-free

• Get a commit notification à Or enable it from version control software

• Never commit test assets (3D assets and other binary files). Commit only finalized binary files

 

_designpatterns  

• Use singletons for all manager classes

• Use the command pattern to save data as a list

• To avoid data loss, save as scriptable object and then in DB

 

_SaveData

•  Save all game data as a scriptable object in unity before saving it to DB

•  Check whether local data or server data is new before updating it to DB

 

 Note: These are only development guidelines. Once the game concept is final other guidelines will be developed.