*

Assets/Editor.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: dafb6bfb42294ab44bbc4d05d0e02cd6
+folderAsset: yes
+timeCreated: 1478632487
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/TreeGeneratorEditor.cs

@@ -0,0 +1,15 @@
+using UnityEngine;
+using UnityEditor;
+using System.Collections;
+
+[CustomEditor(typeof(TreeGenerator))]
+public class TreeGeneratorEditor : Editor {
+    public override void OnInspectorGUI()
+    {
+        base.OnInspectorGUI();
+        if (GUILayout.Button("Generate"))
+        {
+            (target as TreeGenerator).Generate();
+        }
+    }
+}

Assets/Editor/TreeGeneratorEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: bcb1fb04195ea784b93737ec16a96431
+timeCreated: 1478632499
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/New Material.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: ad4245db34302df4c8fc848466196a43
+timeCreated: 1478632299
+licenseType: Free
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Procedural.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 710ea136b31bb8d4a8c0a7760351ae45
+folderAsset: yes
+timeCreated: 1481457885
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Procedural/BoxGenerator.cs

@@ -0,0 +1,100 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+
+public class BoxGenerator : MeshProcessor
+{
+    public Vector3 Size = Vector3.one;
+    public int SliceX;
+    public int SliceY;
+    public int SliceZ;
+
+    public override void Execute(ProceduralMeshData m)
+    {
+        ProceduralMeshData[] sides = new ProceduralMeshData[6];
+
+        PlaneGenerator p = new PlaneGenerator();
+        p.Width = 1;
+        p.Height = 1;
+
+        //x+
+        sides[0] = new ProceduralMeshData();
+        p.WidthSlices = SliceZ;
+        p.HeightSlices = SliceY;
+        p.Execute(sides[0]);
+
+        //x-
+        sides[1] = new ProceduralMeshData();
+        p.Execute(sides[1]);
+
+        //y+
+        sides[2] = new ProceduralMeshData();
+        p.WidthSlices = SliceX;
+        p.HeightSlices = SliceZ;
+        p.Execute(sides[2]);
+
+        //y-
+        sides[3] = new ProceduralMeshData();
+        p.Execute(sides[3]);
+
+        //z+
+        sides[4] = new ProceduralMeshData();
+        p.WidthSlices = SliceX;
+        p.HeightSlices = SliceY;
+        p.Execute(sides[4]);
+
+        //z-
+        sides[5] = new ProceduralMeshData();
+        p.Execute(sides[5]);
+
+        //x+
+        TransformVertexNode transform = new TransformVertexNode();
+        transform.Offset = Vector3.right*0.5f;
+        transform.Rotation = Quaternion.AngleAxis(-90, Vector3.up) * Quaternion.AngleAxis(-90, Vector3.right);
+        transform.Execute(sides[0]);
+
+        //x-
+        transform.Offset = Vector3.right * -0.5f;
+        transform.Rotation = Quaternion.AngleAxis(90, Vector3.up) * Quaternion.AngleAxis(-90, Vector3.right);
+        transform.Execute(sides[1]);
+
+
+        //y+
+        transform.Offset = Vector3.up * 0.5f;
+        transform.Rotation = Quaternion.identity;
+        transform.Execute(sides[2]);
+
+        //y-
+        transform.Offset = Vector3.up * -0.5f;
+        transform.Rotation = Quaternion.AngleAxis(180, Vector3.forward);
+        transform.Execute(sides[3]);
+
+        //z+
+        transform.Offset = Vector3.forward * 0.5f;
+        transform.Rotation = Quaternion.AngleAxis(180, Vector3.up) * Quaternion.AngleAxis(-90, Vector3.right);
+        transform.Execute(sides[4]);
+
+        //z-
+        transform.Offset = Vector3.forward * -0.5f;
+        transform.Rotation = Quaternion.AngleAxis(-90, Vector3.right);
+        transform.Execute(sides[5]);
+
+        CombineMeshNode combiner = new CombineMeshNode();
+        combiner.Source.Add(sides[0]);
+        combiner.Source.Add(sides[1]);
+        combiner.Source.Add(sides[2]);
+        combiner.Source.Add(sides[3]);
+        combiner.Source.Add(sides[4]);
+        combiner.Source.Add(sides[5]);
+        combiner.Execute(m);
+
+        CombineSubmeshesNode submeshCombiner = new CombineSubmeshesNode();
+        submeshCombiner.Execute(m);
+
+        transform.Offset = Vector3.zero;
+        transform.Rotation = Quaternion.identity;
+        transform.Scale = Size;
+        transform.Execute(m);
+    }
+}

Assets/Procedural/BoxGenerator.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 20da85e4530510045b3327cf8857fde1
+timeCreated: 1481452209
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Procedural/CombineMeshNode.cs

@@ -0,0 +1,63 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class CombineMeshNode : MeshProcessor {
+    public List<ProceduralMeshData> Source = new List<ProceduralMeshData>();
+
+    public override void Execute(ProceduralMeshData m)
+    {
+        List<Vector3> vertices = new List<Vector3>();
+        List<int[]> indices = new List<int[]>();
+        List<Vector3> normals = new List<Vector3>();
+        List<Vector4> tangents = new List<Vector4>();
+        List<List<Vector4>> uvs = new List<List<Vector4>>();
+
+        //combine 
+        foreach (var meshData in Source)
+        {
+            if (meshData != null)
+            {
+                //append all indices
+                foreach (var submeshIndices in meshData.Indices)
+                {
+                    var newIndices = new int[submeshIndices.Length];
+                    //offset indices
+                    for (int i = 0; i < newIndices.Length; ++i)
+                    {
+                        newIndices[i] = submeshIndices[i] + vertices.Count;
+                    }
+                    indices.Add(newIndices);
+                }
+
+
+                vertices.AddRange(meshData.Vertices);
+
+                normals.AddRange(meshData.Normals);
+
+                if (meshData.Tangents != null)
+                {
+                    tangents.AddRange(meshData.Tangents);
+                }
+               
+
+                while (uvs.Count < meshData.Uvs.Count){
+                    uvs.Add(new List<Vector4>());
+                }
+
+                for (int i = 0; i < meshData.Uvs.Count; ++i)
+                {
+                    uvs[i].AddRange(meshData.Uvs[i]);
+                }
+
+            }
+        }
+
+        m.Vertices = vertices.ToArray();
+        m.Indices = indices;
+        m.Normals = normals.ToArray();
+        m.Tangents = tangents.Count == 0 ? null : tangents.ToArray();
+        m.Uvs = uvs;
+    }
+}

Assets/Procedural/CombineMeshNode.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: c69a57e361120bf4db873f79fdc136de
+timeCreated: 1481458480
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Procedural/CombineSubmeshesNode.cs

@@ -0,0 +1,18 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class CombineSubmeshesNode : MeshProcessor {
+
+    public override void Execute(ProceduralMeshData m)
+    {
+        List<int> indices = new List<int>();
+
+        foreach (var i in m.Indices)
+        {
+            indices.AddRange(i);
+        }
+        m.Indices = new List<int[]>();
+        m.Indices.Add(indices.ToArray());
+    }
+}

Assets/Procedural/CombineSubmeshesNode.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: ff34137884a6c4f47a6c6bb289cfc1d9
+timeCreated: 1481577533
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Procedural/MeshProcessor.cs

@@ -0,0 +1,8 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public abstract class MeshProcessor
+{
+    public abstract void Execute(ProceduralMeshData m);
+}

Assets/Procedural/MeshProcessor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 8e6532d55438865429adf68ffdc9b141
+timeCreated: 1481457685
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Procedural/PlaneGenerator.cs

@@ -0,0 +1,68 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+/// <summary>
+/// Generate XZ plane
+/// </summary>
+public class PlaneGenerator : MeshProcessor
+{
+    public float Width = 1;
+    public float Height = 1;
+
+    public int WidthSlices = 0;
+    public int HeightSlices = 0;
+
+
+    public override void Execute(ProceduralMeshData m)
+    {
+        int widthVertexCount = 2 + WidthSlices;
+        int heightVertexCount = 2 + HeightSlices;
+        int vertexCount = widthVertexCount*heightVertexCount;
+
+        //generate vertices && normals
+        Vector3 offset = new Vector3(-Width / 2, 0, Height / 2);
+        m.Vertices = new Vector3[vertexCount];
+        m.Normals = new Vector3[vertexCount];
+
+        for (int x = 0; x < widthVertexCount; ++x)
+        {
+            for (int z = 0; z < heightVertexCount; ++z)
+            {
+                int id = z*widthVertexCount + x;
+                m.Vertices[id]= new Vector3((Width / (widthVertexCount - 1)) * x, 0, (-Height / (heightVertexCount - 1)) * z) + offset;
+                m.Normals[id] = Vector3.up;
+            }
+        }
+
+
+        //generate indices
+        int[] indices = new int[(widthVertexCount - 1) * (heightVertexCount - 1) * 6];
+        int indexOffset = 0;
+        for (int x = 0; x < widthVertexCount - 1; ++x){
+            for (int z = 0; z < heightVertexCount - 1; ++z) {
+                indices[indexOffset + 0] = z * widthVertexCount + x;
+                indices[indexOffset + 1] = z * widthVertexCount + x + 1;
+                indices[indexOffset + 2] = (z + 1) * widthVertexCount + x;
+                indices[indexOffset + 3] = indices[indexOffset + 2];
+                indices[indexOffset + 4] = indices[indexOffset + 1];
+                indices[indexOffset + 5] = (z + 1) * widthVertexCount + x + 1;
+                indexOffset += 6;
+            }
+        }
+
+        m.Indices.Add(indices);
+
+        //generate uvs
+        List<Vector4> uvs = new List<Vector4>(vertexCount);
+        for (int z = 0; z < heightVertexCount; ++z)
+        {
+            for (int x = 0; x < widthVertexCount; ++x)
+            {
+           
+                uvs.Add(new Vector4((float)x / (widthVertexCount - 1), (float)z / (heightVertexCount - 1), 0, 0));
+            }
+        }
+        m.Uvs.Add(uvs);
+    }
+}

Assets/Procedural/PlaneGenerator.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: cc5da59754a9bd84c81c707581bd1a6b
+timeCreated: 1481452239
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Procedural/ProceduralMeshData.cs

@@ -0,0 +1,32 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class ProceduralMeshData {
+    public Vector3[] Vertices;
+    public Vector3[] Normals;
+    public Vector4[] Tangents;
+    public List<int[]> Indices = new List<int[]>();
+    public List<List<Vector4>> Uvs = new List<List<Vector4>>();
+
+    public void ApplyToMesh(Mesh m)
+    {
+        m.Clear();
+        m.subMeshCount = Indices.Count;
+
+        m.vertices = Vertices;
+
+        for (int i = 0; i < Indices.Count; ++i)
+        {
+            m.SetIndices(Indices[i], MeshTopology.Triangles, i);
+        }
+
+        m.normals = Normals;
+        m.tangents = Tangents;
+
+        for (int i = 0; i < Uvs.Count; ++i){
+            m.SetUVs(i, Uvs[i]);
+        }
+        m.UploadMeshData(false);
+    }
+}

Assets/Procedural/ProceduralMeshData.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: d40bf391bd891254fa896c0c953cdc60
+timeCreated: 1481453030
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Procedural/TransformVertexNode.cs

@@ -0,0 +1,34 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class TransformVertexNode : MeshProcessor
+{
+    public Vector3 Offset = Vector3.zero;
+    public Quaternion Rotation = Quaternion.identity;
+    public Vector3 Scale = Vector3.one;
+
+    public override void Execute(ProceduralMeshData m){
+        var transform = Matrix4x4.TRS(Offset, Rotation, Scale);
+        int count = m.Vertices.Length;
+        for (int i = 0; i < count; ++i){
+            m.Vertices[i] = transform.MultiplyPoint3x4(m.Vertices[i]);
+        }
+
+        var normalTransform = Matrix4x4.TRS(Vector3.zero, Rotation, Scale).inverse.transpose;
+
+        for (int i = 0; i < count; ++i) {
+            m.Normals[i] = normalTransform.MultiplyPoint3x4(m.Normals[i]);
+        }
+
+        if (m.Tangents != null)
+        {
+            for (int i = 0; i < count; ++i)
+            {
+                var t = normalTransform.MultiplyPoint3x4((Vector3)m.Tangents[i]);
+                m.Tangents[i] = new Vector4(t.x, t.y, t.z, m.Tangents[i].w);
+            }
+        }
+        
+    }
+}

Assets/Procedural/TransformVertexNode.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 8d5f93e1c179aab4b8ed81b816616c32
+timeCreated: 1481457925
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Tree.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: cd4baea18a7d61a4ea0fb743d6d4d54d
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Tree.unity.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 1b1c25eaa058d364fb039e2a27f08979
+timeCreated: 1478632719
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Tree/LightingData.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 83c55413cc7e7ed4e9e7c6773c8730b7
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 112000000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Tree/ReflectionProbe-0.exr.meta

@@ -0,0 +1,130 @@
+fileFormatVersion: 2
+guid: 3c8a436ff4d920649907586e58f9310e
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 13
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 1
+  seamlessCubemap: 1
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 2
+    aniso: 0
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 2
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 4
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 100
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    customData: 
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    spriteCustomMetadata:
+      entries: []
+    nameFileIdTable: {}
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TreeGenerator.cs

@@ -0,0 +1,90 @@
+using UnityEngine;
+using System.Collections;
+using System.Collections.Generic;
+
+public class TreeGenerator : MonoBehaviour
+{
+    public int SliceX;
+    public int SliceY;
+    public int SliceZ;
+
+    public int RootBranches = 3;
+
+    public Vector3 TrunkSize = Vector3.one;
+    private float branchStep;
+    public float BranchAngle = 60;
+
+    public ProceduralMeshData GenerateTrunk(Vector3 size){
+        ProceduralMeshData m = new ProceduralMeshData();
+        BoxGenerator box = new BoxGenerator();
+        box.SliceX = SliceX;
+        box.SliceY = SliceY;
+        box.SliceZ = SliceZ;
+        box.Size = size;
+        box.Execute(m);
+
+        TransformVertexNode offsetPivot = new TransformVertexNode();
+        offsetPivot.Offset = Vector3.forward * size.z * 0.5f;
+        offsetPivot.Execute(m);
+        return m;
+    }
+
+
+
+    public void Generate() {
+        var mf = GetComponent<MeshFilter>();
+        if (mf == null) {
+            mf = gameObject.AddComponent<MeshFilter>();
+        }
+
+        var mesh = mf.sharedMesh;
+        if (mesh == null)
+        {
+            mesh = new Mesh();
+            mf.sharedMesh = mesh;
+        }
+        branchStep = TrunkSize.z/(RootBranches + 1);
+
+        var mTrunk = GenerateTrunk(TrunkSize);
+
+        List<ProceduralMeshData> branches = new List<ProceduralMeshData>();
+        for (int i = 0; i < RootBranches; ++i)
+        {
+            float zOffset = branchStep*(i + 1);
+           
+
+            var branchSize = TrunkSize;
+            branchSize.x *= 0.7f;
+            branchSize.y *= 0.7f;
+            branchSize.z *= Mathf.Pow(0.65f, i + 1) * 0.5f;
+
+            var l = GenerateTrunk(branchSize);
+            var r = GenerateTrunk(branchSize);
+
+            TransformVertexNode branchTransform = new TransformVertexNode();
+            branchTransform.Rotation = Quaternion.AngleAxis(BranchAngle, Vector3.up);
+            branchTransform.Offset = new Vector3(0,0, zOffset);
+            branchTransform.Execute(r);
+
+            branchTransform.Rotation = Quaternion.AngleAxis(-BranchAngle, Vector3.up);
+            branchTransform.Execute(l);
+
+            branches.Add(l);
+            branches.Add(r);
+        }
+
+
+        CombineMeshNode combiner = new CombineMeshNode();
+        combiner.Source.Add(mTrunk);
+        combiner.Source.AddRange(branches);
+
+        ProceduralMeshData result = new ProceduralMeshData();
+        combiner.Execute(result);
+
+
+        CombineSubmeshesNode submeshCombiner = new CombineSubmeshesNode();
+        submeshCombiner.Execute(result);
+
+        result.ApplyToMesh(mesh);
+    }
+}

Assets/TreeGenerator.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 16e47fd9404a13b4aa027a7f4f43330b
+timeCreated: 1478632373
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TreeSettings.lighting.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: b2105f5c9d12623469923145f38cb7c0
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 4890085278179872738
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: