CSharpGL(9)解析OBJ文件并用CSharpGL渲染

CSharpGL(9)解析OBJ文件并用CSharpGL渲染

2016-08-13

由于CSharpGL一直在更新，现在这个教程已经不适用最新的代码了。CSharpGL源码中包含10多个独立的Demo，更适合入门参考。

为了尽可能提升渲染效率，CSharpGL是面向Shader的，因此稍有难度。

最近研究shader，需要一些典型的模型来显示效果。我自己做了几个。

但是都不如这个茶壶更典型。

我搜罗半天，找到几个用*.obj格式存储的茶壶模型，于是不得不写个OBJ格式文件的解析器来读取和渲染这个茶壶了。

下载

这个OBJ解析器是CSharpGL的一部分，CSharpGL已在GitHub开源，欢迎对OpenGL有兴趣的同学加入（https://github.com/bitzhuwei/CSharpGL）

OBJ文件格式

OBJ文件格式是非常简单的。这种文件以纯文本的形式存储了模型的顶点、法线和纹理坐标和材质使用信息。OBJ文件的每一行，都有极其相似的格式。在OBJ文件中，每行的格式如下：

前缀 参数1 参数2 参数3 ...

其中，前缀标识了这一行所存储的信息类型。参数则是具体的数据。OBJ文件常见的的前缀有

v 表示本行指定一个顶点。 前缀后跟着3个单精度浮点数，分别表示该定点的X、Y、Z坐标值

vt 表示本行指定一个纹理坐标。此前缀后跟着两个单精度浮点数。分别表示此纹理坐标的U、V值

vn 表示本行指定一个法线向量。此前缀后跟着3个单精度浮点数，分别表示该法向量的X、Y、Z坐标值

f 表示本行指定一个表面(Face)。一个表面实际上就是一个三角形图元。此前缀行的参数格式后面将详细介绍。

usemtl 此前缀后只跟着一个参数。该参数指定了从此行之后到下一个以usemtl开头的行之间的所有表面所使用的材质名称。该材质可以在此OBJ文件所附属的MTL文件中找到具体信息。

mtllib 此前缀后只跟着一个参数。该参数指定了此OBJ文件所使用的材质库文件(*.mtl)的文件路径

现在，我们再来看一下OBJ文件的结构。在一个OBJ文件中，首先有一些以v、vt或vn前缀开头的行指定了所有的顶点、纹理坐标、法线的坐标。然后再由一些以f开头的行指定每一个三角形所对应的顶点、纹理坐标和法线的索引。在顶点、纹理坐标和法线的索引之间，使用符号"/"隔开的。一个f行可以以下面几种格式出现：

f 1 2 3 这样的行表示以第1、2、3号顶点组成一个三角形。

f 1/3 2/5 3/4 这样的行表示以第1、2、3号顶点组成一个三角形，其中第一个顶点的纹理坐标的索引值为3，第二个顶点的纹理坐标的索引值为5，第三个顶点的纹理坐标的索引值为4。

f 1/3/4 2/5/6 3/4/2 这样的行表示以第1、2、3号顶点组成一个三角形，其中第一个顶点的纹理坐标的索引值为3，其法线的索引值是4；第二个顶点的纹理坐标的索引值为5，其法线的索引值是6；第三个顶点的纹理坐标的索引值为6，其法线的索引值是2。

f 1//4 2//6 3//2这样的行表示以第1、2、3号顶点组成一个三角形，且忽略纹理坐标。其中第一个顶点的法线的索引值是4；第二个顶点的法线的索引值是6；第三个顶点的法线的索引值是2。

值得注意的是文件中的索引值是以1作为起点的，这一点与C语言中以0作为起点有很大的不同。在渲染的时候应注意将从文件中读取的坐标值减去1。

另外，一个OBJ文件里可能有多个模型，每个模型都是由(若干顶点属性信息+若干面信息)这样的顺序描述的。

解析器设计思路

代码并不复杂。

    public class ObjFile
    {
        private List<ObjModel> models = new List<ObjModel>();

        public List<ObjModel> Models
        {
            get { return models; }
            //set { models = value; }
        }

        public static ObjFile Load(string filename)
        {
            ObjFile file = new ObjFile();

            LoadModels(filename, file);
            GenNormals(file);
            OrganizeModels(file);

            return file;
        }

        private static void OrganizeModels(ObjFile file)
        {
            List<ObjModel> models = new List<ObjModel>();
            foreach (var model in file.models)
            {
                var newModel = OrganizeModels(model);
                models.Add(newModel);
            }

            file.models.Clear();
            file.models.AddRange(models);
        }

        private static ObjModel OrganizeModels(ObjModel model)
        {
            ObjModel result = new ObjModel();
            result.positionList = model.positionList;

            result.normalList.AddRange(model.normalList);

            bool hasUV = model.uvList.Count > 0;
            if (hasUV)
            {
                result.uvList.AddRange(model.uvList);
            }

            for (int i = 0; i < model.innerFaceList.Count; i++)
            {
                var face = model.innerFaceList[i];
                var tuple = new Tuple<int, int, int>(face.vertex0.position, face.vertex1.position, face.vertex2.position);
                result.faceList.Add(tuple);
                if (face.vertex0.normal > 0)
                    result.normalList[face.vertex0.position - 1] = model.normalList[face.vertex0.normal - 1];
                if (face.vertex1.normal > 0)
                    result.normalList[face.vertex1.position - 1] = model.normalList[face.vertex1.normal - 1];
                if (face.vertex2.normal > 0)
                    result.normalList[face.vertex2.position - 1] = model.normalList[face.vertex2.normal - 1];

                if (hasUV)
                {
                    if (face.vertex0.uv > 0)
                        result.uvList[face.vertex0.position - 1] = model.uvList[face.vertex0.uv - 1];
                    if (face.vertex1.uv > 0)
                        result.uvList[face.vertex1.position - 1] = model.uvList[face.vertex1.uv - 1];
                    if (face.vertex2.uv > 0)
                        result.uvList[face.vertex2.position - 1] = model.uvList[face.vertex2.uv - 1];
                }

                result.faceList.Add(new Tuple<int, int, int>(face.vertex0.position, face.vertex1.position, face.vertex2.position));
                //result.faceList[i] = new Tuple<int, int, int>(face.vertex0.position, face.vertex1.position, face.vertex2.position);
            }

            //model.innerFaceList.Clear();

            return result;
        }

        private static void GenNormals(ObjFile file)
        {
            foreach (var model in file.models)
            {
                GenNormals(model);
            }
        }

        private static void GenNormals(ObjModel model)
        {
            if (model.normalList.Count > 0) { return; }

            var faceNormals = new vec3[model.innerFaceList.Count];
            model.normalList.AddRange(new vec3[model.positionList.Count]);

            for (int i = 0; i < model.innerFaceList.Count; i++)
            {
                var face = model.innerFaceList[i];
                vec3 vertex0 = model.positionList[face.vertex0.position - 1];
                vec3 vertex1 = model.positionList[face.vertex1.position - 1];
                vec3 vertex2 = model.positionList[face.vertex2.position - 1];
                vec3 v1 = vertex0 - vertex2;
                vec3 v2 = vertex2 - vertex1;
                faceNormals[i] = v1.cross(v2);
            }

            for (int i = 0; i < model.positionList.Count; i++)
            {
                vec3 sum = new vec3();
                int shared = 0;
                for (int j = 0; j < model.innerFaceList.Count; j++)
                {
                    var face = model.innerFaceList[j];
                    if (face.vertex0.position - 1 == i || face.vertex1.position - 1 == i || face.vertex2.position - 1 == i)
                    {
                        sum = sum + faceNormals[i];
                        shared++;
                    }
                }
                if (shared > 0)
                {
                    sum = sum / shared;
                    sum.Normalize();
                }
                model.normalList[i] = sum;
            }

        }

        private static void LoadModels(string filename, ObjFile file)
        {
            using (var sr = new StreamReader(filename))
            {
                var model = new ObjModel();

                while (!sr.EndOfStream)
                {
                    string line = sr.ReadLine();
                    string[] parts = line.Split(separator, StringSplitOptions.RemoveEmptyEntries);
                    if (parts[0] == ("v"))
                    {
                        if (model.innerFaceList.Count > 0)
                        {
                            file.models.Add(model);
                            model = new ObjModel();
                        }

                        vec3 position = new vec3(float.Parse(parts[1]), float.Parse(parts[2]), float.Parse(parts[3]));
                        model.positionList.Add(position);
                    }
                    else if (parts[0] == ("vt"))
                    {
                        vec2 uv = new vec2(float.Parse(parts[1]), float.Parse(parts[2]));
                        model.uvList.Add(uv);
                    }
                    else if (parts[0] == ("vn"))
                    {
                        vec3 normal = new vec3(float.Parse(parts[1]), float.Parse(parts[2]), float.Parse(parts[3]));
                        model.normalList.Add(normal);
                    }
                    else if (parts[0] == ("f"))
                    {
                        Triangle triangle = ParseFace(parts);
                        model.innerFaceList.Add(triangle);
                    }
                }

                file.models.Add(model);
            }
        }

        private static Triangle ParseFace(string[] parts)
        {
            Triangle result = new Triangle();
            if (parts[1].Contains("//"))
            {
                for (int i = 1; i < 4; i++)
                {
                    string[] indexes = parts[i].Split('/');
                    int position = int.Parse(indexes[0]); int normal = int.Parse(indexes[1]);
                    result[i - 1] = new VertexInfo() { position = position, normal = normal, uv = -1 };
                }
            }
            else if (parts[1].Contains("/"))
            {
                int components = parts[1].Split('/').Length;
                if (components == 2)
                {
                    for (int i = 1; i < 4; i++)
                    {
                        string[] indexes = parts[i].Split('/');
                        int position = int.Parse(indexes[0]); int uv = int.Parse(indexes[1]);
                        result[i - 1] = new VertexInfo() { position = position, normal = -1, uv = uv };
                    }
                }
                else if (components == 3)
                {
                    for (int i = 1; i < 4; i++)
                    {
                        string[] indexes = parts[i].Split('/');
                        int position = int.Parse(indexes[0]); int uv = int.Parse(indexes[1]); int normal = int.Parse(indexes[2]);
                        result[i - 1] = new VertexInfo() { position = position, normal = normal, uv = uv, };
                    }
                }
            }
            else
            {
                for (int i = 1; i < 4; i++)
                {
                    int position = int.Parse(parts[i]);
                    result[i - 1] = new VertexInfo() { position = position, normal = -1, uv = -1, };
                }
            }

            return result;
        }

        static readonly char[] separator = new char[] { ' ' };
        static readonly char[] separator1 = new char[] { '/' };
    }

    class VertexInfo
    {
        public int position;
        public int normal;
        public int uv;
    }
    class Triangle
    {
        public VertexInfo vertex0;
        public VertexInfo vertex1;
        public VertexInfo vertex2;

        public VertexInfo this[int index]
        {
            set
            {
                if (index == 0)
                {
                    this.vertex0 = value;
                }
                else if (index == 1)
                {
                    this.vertex1 = value;
                }
                else if (index == 2)
                {
                    this.vertex2 = value;
                }
                else
                {
                    throw new ArgumentException();
                }
            }
        }
    }

用CSharpGL渲染OBJ模型文件

IModel接口

我发现一个shader可以渲染多个模型，一个模型也可以用多种shader来渲染。为了保证这种多对多关系，CSharpGL创建了一个IModel接口，用于将模型数据转换为OpenGL需要的Vertex Buffer Object。

public interface IModel

{

    BufferRenderer GetPositionBufferRenderer(string varNameInShader);

    BufferRenderer GetColorBufferRenderer(string varNameInShader);

    BufferRenderer GetNormalBufferRenderer(string varNameInShader);

    BufferRenderer GetIndexes();

}

 

从模型到VBO

为了保证Obj解析器项目的纯净，我们不直接让ObjModel实现IModel接口，而是另建一个Adapter类（可能不是这个名字，原谅我没有细学设计模式）。

class ObjModelAdpater : IModel
    {
        private ObjModel model;
        public ObjModelAdpater(ObjModel model)
        {
            this.model = model;
        }


        CSharpGL.Objects.VertexBuffers.BufferRenderer IModel.GetPositionBufferRenderer(string varNameInShader)
        {
            using (var buffer = new ObjModelPositionBuffer(varNameInShader))
            {
                buffer.Alloc(model.positionList.Count);
                unsafe
                {
                    vec3* array = (vec3*)buffer.FirstElement();
                    for (int i = 0; i < model.positionList.Count; i++)
                    {
                        array[i] = model.positionList[i];
                    }
                }

                return buffer.GetRenderer();
            }

        }

        CSharpGL.Objects.VertexBuffers.BufferRenderer IModel.GetColorBufferRenderer(string varNameInShader)
        {
            if (model.uvList.Count == 0) { return null; }

            using (var buffer = new ObjModelColorBuffer(varNameInShader))
            {
                buffer.Alloc(model.uvList.Count);
                unsafe
                {
                    vec2* array = (vec2*)buffer.FirstElement();
                    for (int i = 0; i < model.uvList.Count; i++)
                    {
                        array[i] = model.uvList[i];
                    }
                }

                return buffer.GetRenderer();
            }

        }

        CSharpGL.Objects.VertexBuffers.BufferRenderer IModel.GetNormalBufferRenderer(string varNameInShader)
        {
            using (var buffer = new ObjModelNormalBuffer(varNameInShader))
            {
                buffer.Alloc(model.normalList.Count);
                unsafe
                {
                    vec3* array = (vec3*)buffer.FirstElement();
                    for (int i = 0; i < model.normalList.Count; i++)
                    {
                        array[i] = model.normalList[i];
                    }
                }

                return buffer.GetRenderer();
            }

        }

        CSharpGL.Objects.VertexBuffers.BufferRenderer IModel.GetIndexes()
        {
            using (var buffer = new IndexBuffer<uint>(DrawMode.Triangles, IndexElementType.UnsignedInt, BufferUsage.StaticDraw))
            {
                buffer.Alloc(model.faceList.Count * 3);
                unsafe
                {
                    uint* array = (uint*)buffer.FirstElement();
                    for (int i = 0; i < model.faceList.Count; i++)
                    {
                        array[i * 3 + 0] = (uint)(model.faceList[i].Item1 - 1);
                        array[i * 3 + 1] = (uint)(model.faceList[i].Item2 - 1);
                        array[i * 3 + 2] = (uint)(model.faceList[i].Item3 - 1);
                    }
                }

                return buffer.GetRenderer();
            }
        }
    }


    class ObjModelPositionBuffer : PropertyBuffer<vec3>
    {
        public ObjModelPositionBuffer(string varNameInShader)
            : base(varNameInShader, 3, GL.GL_FLOAT, BufferUsage.StaticDraw)
        {

        }
    }

    class ObjModelColorBuffer : PropertyBuffer<vec2>
    {
        public ObjModelColorBuffer(string varNameInShader)
            : base(varNameInShader, 3, GL.GL_FLOAT, BufferUsage.StaticDraw)
        {

        }
    }

    class ObjModelNormalBuffer : PropertyBuffer<vec3>
    {
        public ObjModelNormalBuffer(string varNameInShader)
            : base(varNameInShader, 3, GL.GL_FLOAT, BufferUsage.StaticDraw)
        {

        }
    }

渲染

剩下的就简单了，把其他Element的框架抄来就差不多了。

 

    class ObjModelElement : SceneElementBase
    {
        ShaderProgram shaderProgram;

        #region VAO/VBO renderers

        VertexArrayObject vertexArrayObject;

        const string strin_Position = "in_Position";
        BufferRenderer positionBufferRenderer;

        //const string strin_Color = "in_Color";
        //BufferRenderer colorBufferRenderer;

        const string strin_Normal = "in_Normal";
        BufferRenderer normalBufferRenderer;

        BufferRenderer indexBufferRenderer;

        #endregion

        #region uniforms


        const string strmodelMatrix = "modelMatrix";
        public mat4 modelMatrix;

        const string strviewMatrix = "viewMatrix";
        public mat4 viewMatrix;

        const string strprojectionMatrix = "projectionMatrix";
        public mat4 projectionMatrix;

        #endregion


        public PolygonModes polygonMode = PolygonModes.Filled;

        private int indexCount;

        private ObjModelAdpater objModelAdapter;

        public ObjModelElement(ObjModel objModel)
        {
            this.objModelAdapter = new ObjModelAdpater(objModel);
        }

        protected void InitializeShader(out ShaderProgram shaderProgram)
        {
            var vertexShaderSource = ManifestResourceLoader.LoadTextFile(@"ObjModelElement.vert");
            var fragmentShaderSource = ManifestResourceLoader.LoadTextFile(@"ObjModelElement.frag");

            shaderProgram = new ShaderProgram();
            shaderProgram.Create(vertexShaderSource, fragmentShaderSource, null);

        }

        protected void InitializeVAO()
        {
            IModel model = this.objModelAdapter;

            this.positionBufferRenderer = model.GetPositionBufferRenderer(strin_Position);
            //this.colorBufferRenderer = model.GetColorBufferRenderer(strin_Color);
            this.normalBufferRenderer = model.GetNormalBufferRenderer(strin_Normal);
            this.indexBufferRenderer = model.GetIndexes();

            IndexBufferRenderer renderer = this.indexBufferRenderer as IndexBufferRenderer;
            if (renderer != null)
            {
                this.indexCount = renderer.ElementCount;
            }
        }

        protected override void DoInitialize()
        {
            InitializeShader(out shaderProgram);

            InitializeVAO();
        }

        protected override void DoRender(RenderEventArgs e)
        {
            if (this.vertexArrayObject == null)
            {
                var vao = new VertexArrayObject(
                    this.positionBufferRenderer,
                    //this.colorBufferRenderer,
                    this.normalBufferRenderer,
                    this.indexBufferRenderer);
                vao.Create(e, this.shaderProgram);

                this.vertexArrayObject = vao;
            }

            ShaderProgram program = this.shaderProgram;
            // 绑定shader
            program.Bind();

            program.SetUniformMatrix4(strprojectionMatrix, projectionMatrix.to_array());
            program.SetUniformMatrix4(strviewMatrix, viewMatrix.to_array());
            program.SetUniformMatrix4(strmodelMatrix, modelMatrix.to_array());

            int[] originalPolygonMode = new int[1];
            GL.GetInteger(GetTarget.PolygonMode, originalPolygonMode);

            GL.PolygonMode(PolygonModeFaces.FrontAndBack, this.polygonMode);
            this.vertexArrayObject.Render(e, this.shaderProgram);
            GL.PolygonMode(PolygonModeFaces.FrontAndBack, (PolygonModes)(originalPolygonMode[0]));

            // 解绑shader
            program.Unbind();
        }



        protected override void CleanUnmanagedRes()
        {
            if (this.vertexArrayObject != null)
            {
                this.vertexArrayObject.Dispose();
            }

            base.CleanUnmanagedRes();
        }

        public void DecreaseVertexCount()
        {
            IndexBufferRenderer renderer = this.indexBufferRenderer as IndexBufferRenderer;
            if (renderer != null)
            {
                if (renderer.ElementCount > 0)
                    renderer.ElementCount--;
            }
        }

        public void IncreaseVertexCount()
        {
            IndexBufferRenderer renderer = this.indexBufferRenderer as IndexBufferRenderer;
            if (renderer != null)
            {
                if (renderer.ElementCount < this.indexCount)
                    renderer.ElementCount++;
            }
        }


    }

 

结果如图所示。我用normal值来表示颜色，就成了这个样子。

 

总结

本篇介绍了一个OBJ文件解析器、渲染器和IModel接口的设计思想。