add Terrain support but not with textures at present

Author: Rui Wang

osgExport/BundleMeshCollider.cs

@@ -27,25 +27,28 @@ public override SceneComponent GetObjectData()
         if ( unityMeshCollider!=null )
         {
             Mesh unityMesh = unityMeshCollider.sharedMesh;
-            sceneData.mesh = new SceneMesh();
-            sceneData.mesh.name = unityMesh.name;
-
-            // submeshes
-            sceneData.mesh.subMeshCount = unityMesh.subMeshCount;
-            sceneData.mesh.triangles = new int[unityMesh.subMeshCount][];
-            for ( int i=0; i<unityMesh.subMeshCount;i++ )
+            if ( unityMesh!=null )
             {
-                sceneData.mesh.triangles[i] = unityMesh.GetTriangles(i);
+                sceneData.mesh = new SceneMesh();
+                sceneData.mesh.name = unityMesh.name;
+
+                // submeshes
+                sceneData.mesh.subMeshCount = unityMesh.subMeshCount;
+                sceneData.mesh.triangles = new int[unityMesh.subMeshCount][];
+                for ( int i=0; i<unityMesh.subMeshCount;i++ )
+                {
+                    sceneData.mesh.triangles[i] = unityMesh.GetTriangles(i);
+                }
+
+                // Vertices
+                sceneData.mesh.vertexCount = unityMesh.vertexCount;
+                sceneData.mesh.vertexPositions = unityMesh.vertices;
+                sceneData.mesh.vertexUV = unityMesh.uv;
+                sceneData.mesh.vertexUV2 = unityMesh.uv2;
+                sceneData.mesh.vertexColors = unityMesh.colors;
+                sceneData.mesh.vertexNormals = unityMesh.normals;
+                sceneData.mesh.vertexTangents = unityMesh.tangents;
             }
-
-            // Vertices
-            sceneData.mesh.vertexCount = unityMesh.vertexCount;
-            sceneData.mesh.vertexPositions = unityMesh.vertices;
-            sceneData.mesh.vertexUV = unityMesh.uv;
-            sceneData.mesh.vertexUV2 = unityMesh.uv2;
-            sceneData.mesh.vertexColors = unityMesh.colors;
-            sceneData.mesh.vertexNormals = unityMesh.normals;
-            sceneData.mesh.vertexTangents = unityMesh.tangents;
         }
         return sceneData;
     }

osgExport/BundleTerrain.cs

@@ -12,16 +12,24 @@ override public void Preprocess()
     {
         terrain = unityComponent as Terrain;
         terrainData = terrain.terrainData;
+        if ( terrainData==null ) return;
+        
+        SplatPrototype[] splats = terrainData.splatPrototypes;
+        for ( int i=0; i<splats.Length; ++i )
+        {
+            textures.Add( BundleTexture.RegisterTexture(splats[i].texture, "SplatTex") );
+            textureSizes.Add( splats[i].tileSize );
+            textureOffsets.Add( splats[i].tileOffset );
+        }
     }
 
     override public void Process()
     {
+        if ( terrainData==null ) return;
         heightmapHeight = terrainData.heightmapHeight;
         heightmapWidth = terrainData.heightmapWidth;
-        heightmapResolution = terrainData.heightmapResolution;
-        heightmapScale = terrainData.heightmapScale;
         size = terrainData.size;
-
+        
         float[,] heights = terrainData.GetHeights(0, 0, heightmapWidth, heightmapHeight);
         float[] arrayHeight = new float[heightmapWidth * heightmapHeight];
         for ( int y=0; y<heightmapHeight; y++ )
@@ -70,8 +78,6 @@ public override SceneComponent GetObjectData()
         sceneData.type = "Terrain";
         sceneData.heightmapHeight = heightmapHeight;
         sceneData.heightmapWidth = heightmapWidth;
-        sceneData.heightmapResolution = heightmapResolution;
-        sceneData.heightmapScale = heightmapScale;
         sceneData.size = size;
         sceneData.alphamapWidth = alphamapWidth;
         sceneData.alphamapHeight = alphamapHeight;
@@ -84,27 +90,45 @@ public override SceneComponent GetObjectData()
         sceneData.alphamapTexture = new SceneTexture();
         sceneData.alphamapTexture.base64PNG = base64Alpha;
         sceneData.alphamapTexture.base64PNGLength = base64AlphaLength;
+        
+        if ( textures.Count>0 )
+        {
+            sceneData.textureIDs = new int[textures.Count];
+            for ( int i=0; i<textures.Count; i++ )
+                sceneData.textureIDs[i] = textures[i].uniqueID;
+            
+            sceneData.textureTilingOffsets = new Vector4[textures.Count];
+            for ( int i=0; i<textures.Count; i++ )
+            {
+                Vector2 sc = textureSizes[i], of = textureOffsets[i];
+                sceneData.textureTilingOffsets[i] = new Vector4(sc.x, sc.y, of.x, of.y);
+            }
+        }
+        
+        if ( terrain!=null )
+        {
+            sceneData.lightmapIndex = terrain.lightmapIndex;
+            sceneData.lightmapTilingOffset = terrain.lightmapScaleOffset;
+        }
         return sceneData;
     }
 
     public Terrain terrain;
     private TerrainData terrainData;
 
-    int heightmapHeight;
-    int heightmapWidth;
-    int heightmapResolution;
-    Vector3 heightmapScale;
     Vector3 size;
-
-    int alphamapWidth;
-    int alphamapHeight;
-    int alphamapLayers;
+    int heightmapHeight, heightmapWidth;
+    int alphamapWidth, alphamapHeight, alphamapLayers;
 
     public string base64Height;
     public int base64HeightLength;
 
     public string base64Alpha;
     public int base64AlphaLength;
+    
+    public List<BundleTexture> textures = new List<BundleTexture>();
+    public List<Vector2> textureSizes = new List<Vector2>();
+    public List<Vector2> textureOffsets = new List<Vector2>();
 }
 
 }

osgExport/ExportTerrain.cs

@@ -0,0 +1,90 @@
+using System;
+using System.IO;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+
+namespace nwTools
+{
+
+public class TerrainExporter
+{
+    public static string ExportTerrain( ref SceneData sceneData, ref SceneTerrain st, string spaces )
+    {
+        string osgData = spaces + "Size " + st.size.x + " " + st.size.y + " " + st.size.z + "\n";
+        
+        // Handle heightmap data
+        osgData += spaces + "HeightMap " + st.heightmapWidth + " " + st.heightmapHeight + " {\n";
+        byte[] heightData = System.Convert.FromBase64String(st.heightmapTexture.base64PNG);
+        System.Text.StringBuilder sb = new System.Text.StringBuilder();
+        for ( int y=0; y<st.heightmapHeight; y++ )
+        {
+            sb.Append( spaces + "  " );
+            for ( int x=0; x<st.heightmapWidth; x++ )
+            {
+                int index = (y * st.heightmapWidth) + x;
+                sb.Append( System.BitConverter.ToSingle(heightData, index * 4) + " " );
+            }
+            sb.Append( "\n" );
+        }
+        osgData += sb.ToString() + spaces + "}\n";
+        
+        // Handle alphamap layers
+        osgData += spaces + "AlphaMap " + st.alphamapWidth + " " + st.alphamapHeight
+                                        + " " + st.alphamapLayers + " {\n";
+        byte[] alphaData = System.Convert.FromBase64String(st.alphamapTexture.base64PNG);
+        System.Text.StringBuilder sb2 = new System.Text.StringBuilder();
+        for ( int i=0; i<st.alphamapLayers; i++ )
+        {
+            sb2.Append( spaces + "  Layer " + i + " {\n" );
+            for ( int y=0; y<st.alphamapHeight; y++ )
+            {
+                sb2.Append( spaces + "    " );
+                for ( int x=0; x<st.alphamapWidth; x++ )
+                {
+                    int index = i * (st.alphamapHeight * st.alphamapWidth) + (y * st.alphamapWidth) + x;
+                    sb2.Append( System.BitConverter.ToSingle(alphaData, index * 4) + " " );
+                }
+                sb2.Append( "\n" );
+            }
+            sb2.Append( spaces + "  }\n" );
+        }
+        osgData += sb2.ToString() + spaces + "}\n";
+        
+        // Handle all splat textures
+        for ( int i=0; i<st.textureIDs.Length; i++ )
+        {
+            int texID = st.textureIDs[i];
+            SceneTexture texture = sceneData.resources.GetTexture(texID, false);
+            if ( texture==null ) continue;
+            
+            Vector4 off = st.textureTilingOffsets[i];
+            osgData += spaces + "Splat" + i + " \"" + texture.name + "\""
+                        + " \"" + texture.path + "\"\n";
+            osgData += spaces + "SplatTilingOffset" + i + " "
+                     + off.x + " " + off.y + " " + off.z + " " + off.w + "\n";
+        }
+        
+        // Handle lightmaps
+        if ( st.lightmapIndex>=0 )
+        {
+            SceneTexture texture = sceneData.resources.lightmaps[st.lightmapIndex];
+            if ( texture!=null )
+            {
+                osgData += spaces + "Lightmap \"" + texture.name + "\""
+                        + " \"" + texture.path + "\"\n";
+                osgData += spaces + "LightmapTilingOffset " + st.lightmapTilingOffset.x + " "
+                         + st.lightmapTilingOffset.y + " " + st.lightmapTilingOffset.z + " "
+                         + st.lightmapTilingOffset.w + "\n";
+            }
+        }
+        return osgData;
+    }
+    
+    public static void Reset()
+    {
+    }
+}
+
+}

osgExport/SceneDataClasses.cs

@@ -176,9 +176,6 @@ public class SceneTerrain : SceneComponent
 {
     public int heightmapHeight;
     public int heightmapWidth;
-    public int heightmapResolution;
-
-    public Vector3 heightmapScale;
     public Vector3 size;
 
     public int alphamapWidth;
@@ -187,6 +184,11 @@ public class SceneTerrain : SceneComponent
 
     public SceneTexture heightmapTexture;
     public SceneTexture alphamapTexture;
+    
+    public int[] textureIDs;
+    public Vector4[] textureTilingOffsets;
+    public int lightmapIndex;
+    public Vector4 lightmapTilingOffset;
 }
 
 public class SceneResources

osgExport/SceneExporter.cs

@@ -158,6 +158,18 @@ private static string ExportHierarchy( ref SceneData sceneData, SceneGameObject
                 //SceneMeshCollider smc = (SceneMeshCollider)component;
                 // TODO
             }
+            else if ( component.type=="Terrain" )
+            {
+                SceneTerrain st = (SceneTerrain)component;
+                osgSubData += spaces + "  Geode {\n"
+                            + ExportCommonAttr(st.type, spaces + "  ")
+                            + subSpaces + "num_drawables 1\n";
+                osgSubData += subSpaces + "nwTools::Terrain {\n"
+                            + TerrainExporter.ExportTerrain(ref sceneData, ref st, subSpaces + "  ")
+                            + subSpaces + "}\n";
+                osgSubData += spaces + "  }\n";
+                numChildren++;
+            }
             else if ( component.type=="MeshRenderer" )
             {
                 SceneMeshRenderer smr = (SceneMeshRenderer)component;

viewer/CMakeLists.txt

@@ -47,6 +47,7 @@ LINK_DIRECTORIES(${OPENSCENEGRAPH_LIB_DIR})
 SET(SOURCE_FILES
     viewer.cpp
     shader_data.cpp
+    terrain_data.cpp
     utilities.cpp
     user_data_classes.h
 )

viewer/Default.frag

@@ -6,9 +6,19 @@ uniform sampler2D specularTexture;
 uniform sampler2D emissionTexture;
 uniform samplerCube reflectTexture;
 
+uniform vec3 lightColor, lightDirection;
+uniform mat4 osg_ViewMatrix;
+
+varying vec4 eyeVec;
+varying vec3 normalVec, tangentVec, binormalVec;
+
 void main()
 {
     vec4 color = texture2D(mainTexture, gl_TexCoord[0].st);
     vec4 light = texture2D(lightTexture, gl_TexCoord[1].st);
-    gl_FragColor = color * light;
+    
+    vec3 lightDir = normalize(mat3(osg_ViewMatrix) * lightDirection);
+    float diff = max(0.0, dot(normalVec.xyz, lightDir));
+    gl_FragColor.rgb = color.rgb * light.rgb;
+    gl_FragColor.a = color.a;
 }

viewer/Default.vert

@@ -1,9 +1,17 @@
 varying vec4 gl_TexCoord[gl_MaxTextureCoords];
 uniform mat4 gl_TextureMatrix[gl_MaxTextureCoords];
+attribute vec3 tangent;
+
+varying vec4 eyeVec;
+varying vec3 normalVec, tangentVec, binormalVec;
 
 void main()
 {
     gl_Position = ftransform();
     gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0;
     gl_TexCoord[1] = gl_TextureMatrix[1] * gl_MultiTexCoord1;
+    normalVec = normalize(vec3(gl_NormalMatrix * gl_Normal));
+    tangentVec = normalize(vec3(gl_NormalMatrix * tangent));
+    binormalVec = cross(normalVec, tangentVec);
+    eyeVec = gl_ModelViewMatrix * gl_Vertex;
 }

viewer/Legacy_Shaders/Bumped_Diffuse.frag

@@ -1,14 +1,28 @@
 varying vec4 gl_TexCoord[gl_MaxTextureCoords];
 uniform sampler2D mainTexture;
-uniform sampler2D lightTexture;
 uniform sampler2D normalTexture;
-uniform sampler2D specularTexture;
-uniform sampler2D emissionTexture;
-uniform samplerCube reflectTexture;
+uniform vec3 lightColor, lightDirection;
+uniform mat4 osg_ViewMatrix;
+
+varying vec4 eyeVec;
+varying vec3 normalVec, tangentVec, binormalVec;
 
 void main()
 {
-    vec4 color = texture2D(mainTexture, gl_TexCoord[0].st);
-    vec4 light = texture2D(lightTexture, gl_TexCoord[1].st);
-    gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0) * color;  // just test
+    vec2 uv = gl_TexCoord[0].st;
+    vec4 color = texture2D(mainTexture, uv);
+    vec4 normal = texture2D(normalTexture, uv);
+    
+    vec3 lightDir = normalize(mat3(osg_ViewMatrix) * lightDirection);
+    float diff = max(0.0, dot(normalVec.xyz, lightDir));
+    gl_FragColor.rgb = color.rgb * lightColor * diff;
+    gl_FragColor.a = color.a;
 }
+
+// Legacy Shaders/Bumped Specular
+// Legacy Shaders/Reflective/Bumped Specular
+// Legacy Shaders/Transparent/Diffuse
+// Legacy Shaders/Transparent/Cutout/Diffuse
+// Legacy Shaders/Transparent/Bumped Diffuse
+// Legacy Shaders/Transparent/Cutout/Bumped Specular
+// Legacy Shaders/Reflective/Bumped Diffuse

viewer/shader_data.cpp

@@ -27,6 +27,7 @@ void applyUserShaders( ShaderDataProxyMap& sdMap, const std::string& dbPath )
             osg::ref_ptr<osg::Program> program = new osg::Program;
             program->addShader( osgDB::readShaderFile(osg::Shader::VERTEX, vertFile) );
             program->addShader( osgDB::readShaderFile(osg::Shader::FRAGMENT, fragFile) );
+            program->addBindAttribLocation( "tangent", 6 );
             s_sharedShaderPrograms[name] = program;
         }
         itr->second->removeAttribute( itr->first );