Terrains with splat textures are fully supported

Rui Wang · Rui Wang · commit fcaface53b6d · 2016-09-09T14:57:53.000+08:00
diff --git a/README.md b/README.md
@@ -8,14 +8,16 @@ Note that the texture paths are always relative to Unity project folder, so you
 
 ## TODO List
 1. Support multiple texture maps (done)
-2. Support lightmaps (done)
-3. Use specified viewer (with a default shader) to show scene
+2. Support lightmaps and lightprobes (partly)
+3. Use specified viewer (with a default shader) to show scene (done)
 4. Support light and camera data outputs (partly)
-5. Change to different camera views in viewer
+5. Make use of dynamic lights from Forward+ pass
 6. Support game object and camera animations
 7. Support character data and animation outputs
 8. Play kinds of animations in viewer
 9. Support mesh collider data outputs (partly)
 10. Load and use colliders in physics engine integrations
 11. Support particle animations
-12. Support Unity legacy shaders and reimplement them in OSG
+12. Support Unity legacy shaders and reimplement them in OSG (partly)
+13. Support terrains and plants (partly)
+14. Support Unity 5.x standard PBR shader
diff --git a/viewer/CMakeLists.txt b/viewer/CMakeLists.txt
@@ -55,6 +55,8 @@ SET(SOURCE_FILES
 SET(COMMON_SHADER_FILES
     Default.vert
     Default.frag
+    Terrain.vert
+    Terrain.frag
 )
 
 SET(LEGACY_SHADER_FILES
diff --git a/viewer/Default.frag b/viewer/Default.frag
@@ -1,3 +1,4 @@
+#version 130
 varying vec4 gl_TexCoord[gl_MaxTextureCoords];
 uniform sampler2D mainTexture;
 uniform sampler2D lightTexture;
@@ -14,11 +15,11 @@ varying vec3 normalVec, tangentVec, binormalVec;
 
 void main()
 {
-    vec4 color = texture2D(mainTexture, gl_TexCoord[0].st);
-    vec4 light = texture2D(lightTexture, gl_TexCoord[1].st);
+    vec4 color = texture(mainTexture, gl_TexCoord[0].st);
+    vec4 light = texture(lightTexture, gl_TexCoord[1].st);
     
     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.rgb = color.rgb * light.rgb * lightColor * diff;
     gl_FragColor.a = color.a;
 }
diff --git a/viewer/Legacy_Shaders/Bumped_Diffuse.frag b/viewer/Legacy_Shaders/Bumped_Diffuse.frag
@@ -1,3 +1,4 @@
+#version 130
 varying vec4 gl_TexCoord[gl_MaxTextureCoords];
 uniform sampler2D mainTexture;
 uniform sampler2D normalTexture;
@@ -10,8 +11,8 @@ varying vec3 normalVec, tangentVec, binormalVec;
 void main()
 {
     vec2 uv = gl_TexCoord[0].st;
-    vec4 color = texture2D(mainTexture, uv);
-    vec4 normal = texture2D(normalTexture, uv);
+    vec4 color = texture(mainTexture, uv);
+    vec4 normal = texture(normalTexture, uv);
     
     vec3 lightDir = normalize(mat3(osg_ViewMatrix) * lightDirection);
     float diff = max(0.0, dot(normalVec.xyz, lightDir));
diff --git a/viewer/Terrain.frag b/viewer/Terrain.frag
@@ -0,0 +1,31 @@
+#version 130
+varying vec4 gl_TexCoord[gl_MaxTextureCoords];
+uniform sampler2DArray splatTexture;
+uniform sampler2D lightTexture;
+uniform sampler2D alphaTexture;
+uniform vec4 splatTilingOffsets[4];
+
+uniform vec3 lightColor, lightDirection;
+uniform mat4 osg_ViewMatrix;
+
+varying vec4 eyeVec;
+varying vec3 normalVec;
+
+void main()
+{
+    ivec3 size = textureSize(splatTexture, 0);
+    vec4 alpha = texture(alphaTexture, gl_TexCoord[0].st);
+    vec4 color = vec4(0.0, 0.0, 0.0, 1.0);
+    vec4 light = texture(lightTexture, gl_TexCoord[1].st);
+    for ( int i=0; i<size.z; ++i )
+    {
+        vec4 offset = splatTilingOffsets[i];
+        vec3 uv = vec3(gl_TexCoord[0].st * offset.xy + offset.zw, float(i));
+        color += texture(splatTexture, uv) * alpha[3 - i];
+    }
+    
+    vec3 lightDir = normalize(mat3(osg_ViewMatrix) * lightDirection);
+    float diff = max(0.0, dot(normalVec.xyz, lightDir));
+    gl_FragColor.rgb = color.rgb * light.rgb * lightColor * diff;
+    gl_FragColor.a = color.a;
+}
diff --git a/viewer/Terrain.vert b/viewer/Terrain.vert
@@ -0,0 +1,12 @@
+varying vec4 gl_TexCoord[gl_MaxTextureCoords];
+uniform mat4 gl_TextureMatrix[gl_MaxTextureCoords];
+varying vec4 eyeVec;
+varying vec3 normalVec;
+
+void main()
+{
+    gl_Position = ftransform();
+    gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0;
+    normalVec = normalize(vec3(gl_NormalMatrix * gl_Normal));
+    eyeVec = gl_ModelViewMatrix * gl_Vertex;
+}
diff --git a/viewer/terrain_data.cpp b/viewer/terrain_data.cpp
@@ -1,3 +1,5 @@
+#include <osg/Texture2D>
+#include <osg/Texture2DArray>
 #include <osgDB/FileUtils>
 #include <osgDB/Registry>
 #include <osgDB/Input>
@@ -19,9 +21,11 @@ void applyUserTerrains( TerrainDataProxyMap& tdMap, const std::string& dbPath )
             for ( short x=0; x<proxy->heightMapSize[0]; ++x )
             {
                 int index = int(x) + int(y) * int(proxy->heightMapSize[0]);
-                va->push_back( osg::Vec3(float(y) * proxy->size[2] / float(proxy->heightMapSize[1] - 1),
-                                         proxy->heightMap[index] * proxy->size[1],
-                                         float(x) * proxy->size[0] / float(proxy->heightMapSize[0] - 1)) );
+                float tx = float(y) / float(proxy->heightMapSize[1] - 1);
+                float ty = float(x) / float(proxy->heightMapSize[0] - 1);
+                va->push_back( osg::Vec3(
+                    tx * proxy->size[2], proxy->heightMap[index] * proxy->size[1], ty * proxy->size[0]) );
+                ta->push_back( osg::Vec2(ty, tx) );
             }
         }
         
@@ -37,11 +41,63 @@ void applyUserTerrains( TerrainDataProxyMap& tdMap, const std::string& dbPath )
             }
         }
         
+        // Create splat texture array
+        osg::ref_ptr<osg::Texture2DArray> splatTexture = new osg::Texture2DArray;
+        splatTexture->setTextureDepth( proxy->layers );
+        splatTexture->setWrap( osg::Texture2D::WRAP_S, osg::Texture2D::REPEAT );
+        splatTexture->setWrap( osg::Texture2D::WRAP_T, osg::Texture2D::REPEAT );
+        splatTexture->setFilter( osg::Texture2D::MIN_FILTER, osg::Texture2D::LINEAR_MIPMAP_LINEAR );
+        splatTexture->setFilter( osg::Texture2D::MAG_FILTER, osg::Texture2D::LINEAR );
+        
+        int splatW = 0, splatH = 0;
+        for ( int i=0; i<proxy->layers; ++i )
+        {
+            osg::Image* image = osgDB::readImageFile(proxy->splatTextures[i]);
+            splatTexture->setImage( i, image );
+            
+            if ( !image ) { OSG_NOTICE << "Bad splat file " << proxy->splatTextures[i] << std::endl; }
+            else if ( !splatW || !splatH ) { splatW = image->s(); splatH = image->t(); }
+            else if ( splatW!=image->s() || splatH!=image->t() ) image->scaleImage(splatW, splatH, 1);
+        }
+        
+        // Create alpha texture
+        unsigned int dataSize = proxy->alphaMaps.size() * sizeof(osg::Vec4ub);
+        unsigned char* data = new unsigned char[dataSize];
+        memcpy( data, (unsigned char*)&(proxy->alphaMaps[0]), dataSize );
+        
+        osg::ref_ptr<osg::Image> alphaImage = new osg::Image;
+        alphaImage->setImage( proxy->alphaMapSize[0], proxy->alphaMapSize[1], 1, GL_RGBA, GL_RGBA,
+                              GL_UNSIGNED_BYTE, data, osg::Image::USE_NEW_DELETE );
+        
+        osg::ref_ptr<osg::Texture2D> alphaTexture = new osg::Texture2D( alphaImage.get() );
+        alphaTexture->setWrap( osg::Texture2D::WRAP_S, osg::Texture2D::REPEAT );
+        alphaTexture->setWrap( osg::Texture2D::WRAP_T, osg::Texture2D::REPEAT );
+        alphaTexture->setFilter( osg::Texture2D::MIN_FILTER, osg::Texture2D::LINEAR_MIPMAP_LINEAR );
+        alphaTexture->setFilter( osg::Texture2D::MAG_FILTER, osg::Texture2D::LINEAR );
+        
+        // Create the terrain geometry
         osg::ref_ptr<osg::Geometry> geom = new osg::Geometry;
         geom->setVertexArray( va.get() );
-        //geom->setTexCoordArray( 0, ta.get() );
+        geom->setTexCoordArray( 0, ta.get() );
         geom->addPrimitiveSet( de.get() );
         
+        osg::StateSet* ss = geom->getOrCreateStateSet();
+        ss->setTextureAttribute( 0, splatTexture.get() );  // TODO: lightmap at unit 1?
+        ss->setTextureAttributeAndModes( 2, alphaTexture.get() );
+        
+        osg::ref_ptr<osg::Program> program = new osg::Program;
+        program->addShader( osgDB::readShaderFile(osg::Shader::VERTEX, dbPath + "/shaders/Terrain.vert") );
+        program->addShader( osgDB::readShaderFile(osg::Shader::FRAGMENT, dbPath + "/shaders/Terrain.frag") );
+        ss->setAttributeAndModes( program.get() );
+        ss->addUniform( new osg::Uniform("splatTexture", (int)0) );
+        ss->addUniform( new osg::Uniform("lightTexture", (int)1) );
+        ss->addUniform( new osg::Uniform("alphaTexture", (int)2) );
+        
+        osg::Uniform* splatTilingOffsetsUniform = ss->getOrCreateUniform(
+            "splatTilingOffsets", osg::Uniform::FLOAT_VEC4, 4);
+        for ( int i=0; i<proxy->layers; ++i )
+            splatTilingOffsetsUniform->setElement( i, proxy->splatTilingOffsets[i] );
+        
         // Add normal and tangent array for the geometry
         osgUtil::SmoothingVisitor smv;
         smv.smooth( *geom );
@@ -85,7 +141,67 @@ bool TerrainData_readLocalData( osg::Object& obj, osgDB::Input& fr )
         iteratorAdvanced = true; ++fr;
     }
     
-    // TODO
+    proxy.layers = 0;
+    if ( fr.matchSequence("AlphaMap %i %i %i {") )
+    {
+        int w = 0, h = 0;
+        fr[1].getInt(w); fr[2].getInt(h); fr[3].getInt(proxy.layers);
+        proxy.alphaMapSize.set( w, h );
+        proxy.alphaMaps.resize( w * h );
+        proxy.splatTextures.resize( proxy.layers );
+        proxy.splatTilingOffsets.resize( proxy.layers );
+        
+        int entry0 = fr[0].getNoNestedBrackets();
+        fr += 5;
+        while ( !fr.eof() && fr[0].getNoNestedBrackets()>entry0 )
+        {
+            if ( fr.matchSequence("Layer %i {") )
+            {
+                int id = 0, index = 0;
+                fr[1].getInt( id );
+                
+                int entry = fr[0].getNoNestedBrackets();
+                fr += 3;
+                if ( id<4 )
+                {
+                    while ( !fr.eof() && fr[0].getNoNestedBrackets()>entry )
+                    {
+                        float v = 0.0f; fr[0].getFloat(v);
+                        proxy.alphaMaps[index][3 - id] = unsigned char(v * 255.0f);  // start from v.w
+                        ++fr; ++index;
+                    }
+                }
+                else
+                {
+                    OSG_WARN << "We only handle terrain with equal or less than 4 layers" << std::endl;
+                    while ( !fr.eof() && fr[0].getNoNestedBrackets()>entry ) ++fr;
+                }
+                ++fr;
+            }
+        }
+        iteratorAdvanced = true; ++fr;
+    }
+    
+    for ( int i=0; i<proxy.layers; ++i )
+    {
+        std::stringstream ss; ss << "Splat" << i << " %s %s";
+        if ( fr.matchSequence(ss.str().c_str()) )
+        {
+            std::string texName = fr[1].getStr(), texPath = fr[2].getStr();
+            proxy.splatTextures[i] = texPath;
+            iteratorAdvanced = true; fr += 3;
+        }
+        
+        ss.str(""); ss << "SplatTilingOffset" << i << " %f %f %f %f";
+        if ( fr.matchSequence(ss.str().c_str()) )
+        {
+            osg::Vec4 tilingOffset;
+            for ( int n=0; n<4; ++n ) fr[1 + n].getFloat( tilingOffset[n] );
+            proxy.splatTilingOffsets[i].set( tilingOffset[0], tilingOffset[1],
+                                             tilingOffset[2], tilingOffset[3] );
+            iteratorAdvanced = true; fr += 5;
+        }
+    }
     return iteratorAdvanced;
 }
 
diff --git a/viewer/user_data_classes.h b/viewer/user_data_classes.h
@@ -1,6 +1,7 @@
 #ifndef H_UNITY2OSG_USERDATACLASSES
 #define H_UNITY2OSG_USERDATACLASSES
 
+#include <osg/io_utils>
 #include <osg/Program>
 #include <osg/StateSet>
 #include <osgDB/ReadFile>
@@ -28,9 +29,12 @@ struct TerrainDataProxy : public osg::Geometry
     virtual const char* className() const { return "Terrain"; }
     
     std::vector<float> heightMap;
-    std::vector< std::vector<float> > alphaMaps;
+    std::vector<osg::Vec4ub> alphaMaps;
+    std::vector<std::string> splatTextures;
+    std::vector<osg::Vec4> splatTilingOffsets;
     osg::Vec2s heightMapSize, alphaMapSize;
     osg::Vec3 size;
+    int layers;
 };
 
 typedef std::map<ShaderDataProxy*, osg::StateSet*> ShaderDataProxyMap;
diff --git a/viewer/viewer.cpp b/viewer/viewer.cpp
@@ -79,8 +79,8 @@ int main( int argc, char** argv )
     if ( databasePath.empty() ) databasePath = ".";
     
     LightUniforms sceneLight;
-    sceneLight.color = new osg::Uniform("lightColor", osg::Vec3(1.0f, 1.0f, 0.9f));
-    sceneLight.direction = new osg::Uniform("lightDirection", osg::Vec3(0.5f, 0.5f, -0.5f));
+    sceneLight.color = new osg::Uniform("lightColor", osg::Vec3(1.0f, 1.0f, 1.0f));
+    sceneLight.direction = new osg::Uniform("lightDirection", osg::Vec3(-0.5f, 0.0f, 0.5f));
     
     // Build the scene graph
     osg::ref_ptr<osg::MatrixTransform> root = new osg::MatrixTransform;

Original file line number	Diff line number	Diff line change
`@@ -55,6 +55,8 @@ SET(SOURCE_FILES`
`55`	`55`	`SET(COMMON_SHADER_FILES`
`56`	`56`	`Default.vert`
`57`	`57`	`Default.frag`
	`58`	`+ Terrain.vert`
	`59`	`+ Terrain.frag`
`58`	`60`	`)`
`59`	`61`
`60`	`62`	`SET(LEGACY_SHADER_FILES`