Alabb kis leirast fogok kozzetenni a Unity5.0.x verziorol. Csak a legalapvetobb dolgok, hogy el tudd kezdeni a fejlesztest. Mivel unity-ben lehet fejleszteni androidra, ios-ra, oculusra, akarmire masra is, ezert fontos lehet. Fontos tudni, hogy bizonyos PRO funkciok nelkul bizonyos dolgok nem fognak mukodni. Pl. oculushoz is ez kell ugye. Ezert, ha azt akarod, hogy minden mukodjon es esetleg commercial cuccot irsz, vagy bevetelt varsz a dologert, akkor erdemes PRO-ra elofizetned. 75$ egy honapban, ha jol emlekszem. 

Menuk:

- File / Build settings - Platform beallitas (pl android)
  Build and Run-al compile-olhatunk illetve felrakja az usb-re bedugott device-ra apk formaban

- Player settings: itt gondolom minden egyertelmu, felbontast, app ikonokat, splash screen kepet (ha PRO verzio), a renderelest, az android app package nevet, verzioszamat, stb beallitasokat, es keystore-t tudjuk beallitani.

- Edit menu-ben a gyakorlatilag majdnem minden IDE-ben talalhato cuccok erhetoek el, mint copy, paste, etc..

- Assets menu: itt tudunk mindenfele scripteket (c#, js), prefabokat, materialokat, stb-ket elkesziteni. Importalni package-eket, illetve asset-eket. Ez a menu lenn az Assets folderben jobb klikkre is elehero. Lenn a menuben altalaban mindent azonos nev ala teszunk, pl a scripteket Scripts konyvtarba, mig Shaders konyvtarba a shader-eket, Textures a texturak.., etc. 

- GameObject menu: 3D, 2D objektumokat, hangokat, fenyeket, 2D UI cuccokat, particle systemet, kamerat tudunk a Hierarchyra/Scene-re rakni. Ezeket a Hierarchyba at is nevezhetjuk sajat egyedi nevekre.

Ha a hierarchy-ban raklikkelunk egy elemre, akkor a Scene-en kijelolodik az object es az Inspectorban latni fogjuk a tulajdonsagait.

Transform - Position Rotation Scale: az object helyzetet hatarozza meg a 3d terben, helyet, forgasat, scale-jet. Itt tudunk collider-eket hozzaadni az object-hez, pl egy box collidert miutan rigid body-va valt az object-unk.

A legtobb dolgot fogd es vidd-el el tudjuk erni Unityben. Azaz ha van egy texturank a Textures mappaban es ra akarjuk rakni egy 3D object-re, akkor fogd es vidd-el egyszeruen radobjuk.

Miutan az objektumot rigid body-va tettuk az Add Component-el (Add component, Phisics, Rigid body) be tudjuk allitani, hogy hasson e ra a gravitacio. Be tudunk kulonfele tulajdonsagokat is allitani ra. Pl. hogy pattogjon e mint egy labda vagy se. (ezt pl. egy custom BouncingMaterial-al)

Sajat shader-t is tudunk krealni es rarakni az objektumokra, illetve lehetoseg van FBO-zasra is. Tehat arra, hogy az egesz megjelenitendo kepen vegezzunk shade-et. (pl. Vignette effekt)

Sajat shader-t ertelemszeruen a Shaders mappaban hozunk letre, a neve pedig Something.shader lesz. A shaderek HLSL-ek, nem glsl. De konnyen utana lehet nezni neten.

Fejleszteni MonoDevelop-ban lehet, mint editor, vagy pl. Visual Studioban is.

Kis scripteles:

Mivel en C#-et hasznalok js helyett, ezekben fogom irni a dolgokat, nyilvan a js sem nehezebb nekem 10+ ev webes fejlesztokent, de en ezt szoktam meg.

Egy alap class igy nez ki Unityben:

using UnityEngine;
using System.Collections;

public class Class1 : MonoBehaviour {

    private GameObject wall1;

    void Start () {
        wall1 = GameObject.Find ("Wall1");
    }
    
    void Update () {

    }
}

A class1 helyett nyilvan majd egy ertelmes angol nevet adunk, ami a tartalmara utal. A Start metodus az inicializalaskor fut le egyszer, mig az Update a rendereleskor.
Jatek objektumot a GameObject.Find("Nev")-el talalunk meg. Ez az a nev, amit megadtunk a hierarchy-ban.

Valtozokat stb fuggvenyeket, etc ugyanugy irunk, mint egy C#-es appban.

Par kodreszlet:

Köd keszitese kodbol:

Start-ba:
        RenderSettings.fog = true;
        RenderSettings.fogDensity = 0.051f;
        RenderSettings.fogStartDistance = 0.5f;
        RenderSettings.fogEndDistance = 2.5f;
        RenderSettings.fogMode = FogMode.ExponentialSquared;

2D-s dolgokat kiirni a kepernyore a void OnGUI() { - bol tudunk.

peldaul:

    void OnGUI() {
        GUI.Label(FPSRect1, "<b>" + (string.Format("{0:0}", fps) + "</b> fps, <b>" + totalVertex + "</b> verts" )
                                     , style1);

    }

Kamera poziciojat athelyezni igy tudjuk:

    private void updateCamPos() {

        camPos.Set(Player.transform.position.x, Player.transform.position.y + 2.7f, Player.transform.position.z - 4.5f);

        Camera.main.transform.position = camPos;
        Camera.main.transform.LookAt(ball.transform);
    }

ahol camPos egy Vector3

android back gombbal kilepes az appbol:

if (Input.GetKeyDown(KeyCode.Escape)) Application.Quit();

rigidbody object sebesseget igy tudjuk novelni:

ball.GetComponent<Rigidbody>().velocity = ball.GetComponent<Rigidbody>().velocity * 1.0003f;

objektum transzformaciojat igy erhetjuk el:

ball.transform pl. ball.transform.position.x

directionLight.transform.Rotate (0, 0.1f, 0);

Ok, ennyi lett volna a Unity5 FREE gyorstalpalo, igazan nem nehez szerintem...

OK, elozmeny: mostanaban olvasgatok a VR-rol sokat, illetve lehet, hogy rendelek egy VR-es eszkozt, mondjuk egy Oculus Rift DK2-t. Elvileg lehet ra kodolni 3D-t sima Unity5-ben (C#, js) is, es vannak mar hozza pofas kis jatekok. Lehet Unitybe ugye portolni a 3D-s jatekod/alkalmazasodat mobilokra is, errol majd egy kesobbi post-ban beszamolok hogyan. De lassuk a durovis dive-ot. Mi is ez?

http://www.durovis.com/index.html

Tehat: Ez egy oculus rift szeruseg ugye, ami a mobiltelefonodbol egy VR elmenyt tesz elerhetove. Gyakorlatilag ugyanazt tudja, mint a rift, csak itt ugye manualisan oldottak meg sok dolgot, valamint csak bizonyos keszulekekkel hasznalhato a cucc. Az ara 59.5 EUR. Unity-ben lehet erre is fejleszteni, van hozza tehat egy unity plugin. Azt azert tudni kell, hogy a free Unity verziokkal a pluginok/dll-ek nem igazan mukodnek, ezert egy PRO csomagra elo kell fizetnunk, mint pl. az oculusra valo fejleszteskor is...

Fejlesztoi szemmel jo moka, viszont ne oruljunk nagyon neki, mivel kb 50 keszuleket tamogat jelenleg, pl. nincs koztuk az en Nexus 6-om, illetve Galaxy Note 2-m sem.

Elkezdtem ezzel is foglalkozni, igazabol szegyen, hogy eddig alig foglalkoztam veluk, pedig milyen szep!

Kezdoknek youtube video:

Es ha mar kicsit PRO-t is akarsz:

http://www.angelikalanger.com/GenericsFAQ/JavaGenericsFAQ.pdf

Vigyazat, 350 oldal!:)))

Kis sajat kod:

public class Generics {

    interface IParent {
        public void printX();
        
        public void printASD();
        
        public <T> void printABC(T s);
    }
    
    @Author(first = "Gipsz", last = "Jakab")
    static abstract class BaseParentClass implements IParent {
        
        @Override
        public abstract void printX();
        
        @Override
        public void printASD() {
            System.out.println("printASD " + this.toString());
        }
        
        @Override
        public <T> void printABC(T t) {
            System.out.println("printABC " + t.getClass().getSimpleName() );
        }

    }
    
    static class ParentClass extends BaseParentClass {
        
        ParentClass() {
            
        }
        
        @Override
        public String toString()  {
            return this.getClass().getSimpleName();
        }

        @Override
        public void printX() {
            System.out.println("printX " + this.toString());
        }
        
    }    

    static class ChildClass extends ParentClass {
        
        ChildClass() {
            super();
        }

        public void printY() {
            System.out.println("printY " + this.toString());
        }

        @Override
        public String toString()  {
            return this.getClass().getSimpleName();
        }
    }
    
    static class ChildChildClass extends ChildClass {
        
        ChildChildClass() {
            super();
        }

        public void printY() {
            System.out.println("printY " + this.toString());
        }

        @Override
        public String toString()  {
            return this.getClass().getSimpleName();
        }
    }    

    private static <T> void printMe(T[] array) {
        
        for (T t: array) {
            System.out.printf("printMe is: %s %s \n", t, (t.getClass().getSimpleName()) );
        }
        
        System.out.println("----------------------");
    }

    
    private static void printTestArray1(ArrayList<? extends ParentClass> array) {
        
        for (ParentClass c: array) {
            System.out.printf("printTestArray1 is a %s\n", c.toString() );
            c.printX();
        }
        
        System.out.println("----------------------");
    }

    private static void printTestArray2(ArrayList<? super ChildClass> array) {
        
        for (Object c: array) {
            System.out.printf("printTestArray2 is a %s\n", c.toString() );
            ((ChildClass) c).printY();
        }
        
        System.out.println("----------------------");
    }

    private static void printTestArray3(ArrayList<?> array) {
        
        for (Object c: array) {
            System.out.printf("printTestArray3 is a %s\n", c.toString() );
        }
        
        System.out.println("----------------------");
    }
    
    public static void testCases() {
        
        String[] sArr = {"one", "twoo", "three"};
        Character[] cArr = {'A', 'B', 'C'};
        Integer[] iArr = {100, 200, 300};
        
        printMe(sArr);
        printMe(cArr);
        printMe(iArr);
        
        System.out.println("----------------------");
        
        ////////////////////
        ArrayList<ParentClass> test1 = new ArrayList<ParentClass>();
        test1.add(new ParentClass());
        test1.add(new ChildClass());
        
        printTestArray1(test1);
        
        ArrayList<ChildClass> test2 = new ArrayList<ChildClass>();
        test2.add(new ChildClass());
        test2.add(new ChildChildClass());
        
        printTestArray2(test2);
        
        printTestArray3(test1);
        
        Test1 t1 = MyTests.getInctance().new Test1() {
            @Override
            public void start() {
                super.start();
                System.out.println("start2");
            }
        };
        
        t1.start();
        
        System.out.println("----------------------");
        System.out.printf("maximum is: %s\n", getMaximum(1, 50, 34));
        
        System.out.println("----------------------");
        System.out.printf("maximum is: %s\n", getMaximum("asd", "rtt", "ddd"));

        System.out.println("----------------------");
        System.out.printf("comparePairs is: %s\n", comparePairs(pair1, pair2));

        System.out.println("----------------------");
        System.out.printf("wildString is: %s\n", wildString(pair3));
        
        //NumberList<?> nList = new NumberList<Integer>();
        //nList.setValues(values);
    }
    
    private static <T extends Comparable<T>> T getMaximum(T a, T b, T c) {
        
        T m = a;
        
        if (b.compareTo(m)>0) m = b;
        if (c.compareTo(m)>0) m = c;
        
        return m;
    }
    
    
    private static Pair<String, Integer> pair1 = new Pair<>("asd1", 1);
    private static Pair<String, Integer> pair2 = new Pair<>("asd2", 5);
    private static Pair<String, Object> pair3 = new Pair<>("asd3", null);
    
    private static class Pair<K, V> {
        K key;
        V value;
        
        public Pair(K key, V value) {
            this.key = key;
            this.value = value;
        }
        
        public K getKey() {
            return key;
        }
        public void setKey(K key) {
            this.key = key;
        }
        public V getValue() {
            return value;
        }
        public void setValue(V value) {
            this.value = value;
        }
    }
    
    private static <K, V> boolean comparePairs(Pair<K, V> p1, Pair<K, V> p2) {
        return p1.equals(p2);
    }
    
    private static String wildString(Pair<String, ? super Number> p) {
        return p.getKey();
    }
    
    private static Point<Float, Integer> point1 = new Point<>(2.4f, 1);
    
    private static class Point<X extends Number, Y extends Number> {
        X x;
        Y y;
        
        public Point(X x, Y y) {
            this.x = x;
            this.y = y;
        }
        
        public X getX() {
            return x;
        }
        public void setX(X x) {
            this.x = x;
        }
        public Y getY() {
            return y;
        }
        public void setY(Y y) {
            this.y = y;
        }
    }
    
    private static class NumberList<T extends Number> extends ArrayList<T> {
        private List<? extends T> values;

        public List<? extends T> getValues() {
            return values;
        }

        public void setValues(List<? extends T> values) {
            this.values = values;
        }
    }
    
}