Unity MeshRenderer与SkinnedMeshRenderer数据自定义序列化保存

于 2024-04-28 09:21:02 发布
阅读量232 收藏 1
点赞数 3
文章标签： unity 游戏引擎
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40426854/article/details/138267594
版权

模型数据自定义的保存与加载

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class SerializationGameObj_Manager : MonoBehaviour
{
    public Material matTemp;
    public GameObject obj;
    public GameObjData gameObjData;

    [ContextMenu("Save")]
    public void Save()//测试保存
    {
        gameObjData= GetGameObjData(obj);
    }
    [ContextMenu("Load")]
    public void Load()//测试加载
    {
        obj= CreateGameObject(gameObjData);
    }

    /// <summary>
    /// 生成GameObject
    /// </summary>
    /// <param name="gameObjData">GameObject信息</param>
    /// <returns></returns>
    public GameObject CreateGameObject(GameObjData gameObjData)
    {
        GameObject gameObject = new GameObject();
        List<Transform> roots = new List<Transform>();

        gameObject.name = gameObjData.name;
        foreach(nodeData nodeData in gameObjData.nodeDatas)
        {
            GameObject child = new GameObject();
            roots.Add(child.transform);
            child.name = nodeData.nodeName;
           Transform parent=  gameObject.transform.Find(nodeData.nodePath);
            if (parent == null)
            {
                parent = gameObject.transform;
            }
            child.transform.SetParent(parent);
            child.transform.localPosition = nodeData.localPosition;
            child.transform.localEulerAngles = nodeData.localEuler;
        }
       // var combineInstances = new List<CombineInstance>();
        int index = 0;
        foreach(MeshObjData meshObjData in gameObjData.meshObjDatas)
        {
            var bones = new List<Transform>();
            Transform nood = gameObject.transform.Find(meshObjData.nodePath);

            Mesh mesh = new Mesh();
            mesh.vertices = meshObjData.meshVertices;
            mesh.triangles = meshObjData.meshTriangles;
            mesh.boneWeights = meshObjData.meshBoneWeight;
            mesh.uv = meshObjData.meshUV;
            mesh.bindposes = meshObjData.meshBindPoses;
            mesh.bounds = meshObjData.meshBounds;
            mesh.normals = meshObjData.meshNormals;
            mesh.tangents = meshObjData.meshTangents;

            var newMaterial = Instantiate(matTemp);
            switch (meshObjData.rendererType)
            {
                case "UnityEngine.MeshRenderer":
                    MeshRenderer meshRenderer = nood.gameObject.AddComponent<MeshRenderer>();
                    MeshFilter meshFilter= nood.gameObject.AddComponent<MeshFilter>();
                    meshFilter.sharedMesh = mesh;
                    meshRenderer.sharedMaterial = newMaterial;
                    break;
                case "UnityEngine.SkinnedMeshRenderer":
                    SkinnedMeshRenderer skinnedMeshRenderer= nood.gameObject.AddComponent<SkinnedMeshRenderer>();
                    
                    foreach (var boneRoot in meshObjData.meshBonesRoot)
                    {
                        var target = gameObject.transform.Find(boneRoot);
                        if (target != null)
                        {
                            bones.Add(target);
                        }
                    }
                    skinnedMeshRenderer.sharedMesh = mesh;
                    skinnedMeshRenderer.bones = bones.ToArray();
                    skinnedMeshRenderer.sharedMaterial = newMaterial;
                    skinnedMeshRenderer.rootBone = gameObject.transform.Find(meshObjData.rootBonePath);

                    break;
            }
            foreach (TextureData textureData in meshObjData.textureDatas)
            {
                Texture2D texture2D = TextureDataConvertToTexture2D(textureData);
                newMaterial.SetTexture(textureData.propertyName, texture2D);
            }
            index++;
        }

        return gameObject;
    }
    /// <summary>
    /// 获得GameObject信息
    /// </summary>
    /// <param name="target">目标GameObject</param>
    /// <returns></returns>
    public GameObjData GetGameObjData(GameObject target)
    {
        GameObjData gameObjData = new GameObjData(target.name);
        gameObjData.nodeDatas = new List<nodeData>();
        foreach (Transform child in target.GetComponentsInChildren<Transform>(true))
        {
            if (child != target.transform)
            {
                gameObjData.nodeDatas.Add(new nodeData(child.name, GetChildPath(target.transform, child, false), child.localPosition, child.localEulerAngles));
            }
        }


        foreach (Renderer renderer in target.GetComponentsInChildren<Renderer>(true))
        {
            MeshObjData meshObjData = new MeshObjData();
            if (renderer != null)
            {
                switch (renderer.GetType().ToString())
                {
                    case "UnityEngine.MeshRenderer":
                        meshObjData = GetMeshObjDataByMeshRenderer((MeshRenderer)renderer);
                        break;
                    case "UnityEngine.SkinnedMeshRenderer":
                        meshObjData = GetMeshObjDataBySkinMeshRenderer((SkinnedMeshRenderer)renderer);
                        foreach (var item in ((SkinnedMeshRenderer)renderer).bones)
                        {
                            meshObjData.meshBonesRoot.Add(GetChildPath(target.transform, item.transform));
                        }
                        meshObjData.rootBonePath = GetChildPath(target.transform, ((SkinnedMeshRenderer)renderer).rootBone);
                        break;
                }
                meshObjData.rendererType = renderer.GetType().ToString();
                foreach (string propertyName in renderer.sharedMaterial.GetTexturePropertyNames())
                {
                    Texture texture = renderer.sharedMaterial.GetTexture(propertyName);
                    if (texture != null)
                    {
                        if (texture.GetType() == typeof(Texture2D))
                        {
                            Texture2D currentTexture2D = (Texture2D)texture;
                            Texture2D newTexture2D = new Texture2D(currentTexture2D.width, currentTexture2D.height, currentTexture2D.format, currentTexture2D.mipmapCount > 1);
                            Graphics.ConvertTexture(currentTexture2D, newTexture2D);
                            string texture2DBase64 = Texture2DToBase64(currentTexture2D);
                            meshObjData.textureDatas.Add(new TextureData(texture.name, propertyName, texture2DBase64, newTexture2D.width, newTexture2D.height, newTexture2D.format, newTexture2D.mipmapCount>1));
                        }
                    }
                }
            }
            meshObjData.nodePath = GetChildPath(target.transform, renderer.transform, true);
            gameObjData.meshObjDatas.Add(meshObjData);
        }


        return gameObjData;
    }
    private MeshObjData GetMeshObjDataBySkinMeshRenderer(SkinnedMeshRenderer meshRenderer)
    {
        MeshObjData meshObjData = new MeshObjData();
        meshObjData.meshVertices = meshRenderer.sharedMesh.vertices;
        meshObjData.meshTriangles = meshRenderer.sharedMesh.triangles;
        meshObjData.meshUV = meshRenderer.sharedMesh.uv;
        meshObjData.meshBoneWeight = meshRenderer.sharedMesh.boneWeights;
        meshObjData.subMeshCount = meshRenderer.sharedMesh.subMeshCount;
        meshObjData.meshMaterialCount = meshRenderer.sharedMaterials.Length;
        meshObjData.meshBindPoses = meshRenderer.sharedMesh.bindposes;
        meshObjData.meshBounds = meshRenderer.sharedMesh.bounds;
        meshObjData.meshNormals = meshRenderer.sharedMesh.normals;
        meshObjData.meshTangents = meshRenderer.sharedMesh.tangents;

        return meshObjData;
    }

    private MeshObjData GetMeshObjDataByMeshRenderer(MeshRenderer meshRenderer)
    {
        MeshFilter meshFilter = meshRenderer.GetComponent<MeshFilter>();
        MeshObjData meshObjData = new MeshObjData();
        meshObjData.meshVertices = meshFilter.sharedMesh.vertices;
        meshObjData.meshTriangles = meshFilter.sharedMesh.triangles;
        meshObjData.meshUV = meshFilter.sharedMesh.uv;
        meshObjData.meshBoneWeight = meshFilter.sharedMesh.boneWeights;
        meshObjData.subMeshCount = meshFilter.sharedMesh.subMeshCount;
        meshObjData.meshMaterialCount = meshRenderer.sharedMaterials.Length;
        meshObjData.meshBindPoses = meshFilter.sharedMesh.bindposes;
        meshObjData.meshBounds = meshFilter.sharedMesh.bounds;
        meshObjData.meshNormals = meshFilter.sharedMesh.normals;
        meshObjData.meshTangents = meshFilter.sharedMesh.tangents;

        return meshObjData;
    }
    private Texture2D TextureDataConvertToTexture2D(TextureData textureData)
    {
        byte[] data = Convert.FromBase64String(textureData.base64);
        Texture2D texture = new Texture2D(textureData.width, textureData.height, textureData.textureFormat, textureData.isMipMap);
        texture.LoadImage(data);
        return texture;
    }
    private string Texture2DToBase64(Texture2D texture2D)
    {
        Texture2D screenshot = new Texture2D(texture2D.width, texture2D.height, texture2D.format, false);
        RenderTexture renderTexture = new RenderTexture(texture2D.width, texture2D.height, 0);
        Graphics.Blit(texture2D, renderTexture);
        // 备份当前的RenderTexture
        RenderTexture previous = RenderTexture.active;

        // 设置为我们想要截图的RenderTexture
        RenderTexture.active = renderTexture;

        // 读取像素数据
        screenshot.ReadPixels(new Rect(0, 0, renderTexture.width, renderTexture.height), 0, 0);
        screenshot.Apply();

        // 重置RenderTexture
        RenderTexture.active = previous;
        return System.Convert.ToBase64String(screenshot.EncodeToPNG());
    }

    public string GetChildPath(Transform parent, Transform child, bool includeSelf=true)
    {
        string path = "";
        Transform[] parents = child.GetComponentsInParent<Transform>(true);
        for (int i = includeSelf ? 0 : 1; i < parents.Length - 1; i++)
        {
            if (parent == parents[i])
            {
                break;
            }
            path = parents[i].name + (path == "" ? "" : "/") + path;
        }
        return path;
    }

    [System.Serializable]
    public class GameObjData
    {
        public string name;
        public List<nodeData> nodeDatas;//所有子物体节点信息
        public List<MeshObjData> meshObjDatas;//带有模型的物体信息
        public GameObjData(string name)
        {
            this.name = name;
            nodeDatas = new List<nodeData>();
            meshObjDatas = new List<MeshObjData>();
        }
    }
    [System.Serializable]
    public class MeshObjData//Renderer信息
    {
        public string rootBonePath;//根骨骼路径
        public string nodePath;//节点路径(基于根物体)
        public string rendererType;//renderer类型

        public string shaderName;

        public List<TextureData> textureDatas;

        public Vector3[] meshVertices;
        public Vector2[] meshUV;
        public int[] meshTriangles;
        public BoneWeight[] meshBoneWeight;
        public int subMeshCount;
        public List<string> meshBonesRoot;
        public int meshMaterialCount;
        public Matrix4x4[] meshBindPoses;
        public Bounds meshBounds;
        public Vector3[] meshNormals;
        public Vector4[] meshTangents;
        public MeshObjData()
        {
            textureDatas = new List<TextureData>();
            meshBonesRoot = new List<string>();
        }
    }
    [System.Serializable]
    public struct nodeData
    {
        public string nodeName;
        public string nodePath;//节点路径(基于根物体)
        public Vector3 localPosition;
        public Vector3 localEuler;
        public nodeData(string nodeName,string nodePath, Vector3 localPosition, Vector3 localEuler)
        {
            this.nodeName = nodeName;
            this.nodePath = nodePath;
            this.localPosition = localPosition;
            this.localEuler = localEuler;
        }
    }
    [System.Serializable]
    public struct TextureData//图片信息
    {
        public string name;//图片名称
        public string propertyName;//在材质球里使用的特性名称
        public string base64;
        public int width;
        public int height;
        public TextureFormat textureFormat;
        public bool isMipMap;

        public TextureData(string name, string propertyName, string base64, int width, int height, TextureFormat textureFormat, bool isMipMap)
        {
            this.name = name;
            this.propertyName = propertyName;
            this.base64 = base64;
            this.width = width;
            this.height = height;
            this.textureFormat = textureFormat;
            this.isMipMap = isMipMap;

        }
    }
}
时间会走呢
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
Unity网格数据（mesh）存储
07-10
把脚本放在Editor文件夹，右键mesh组件会多了个选项，可以把网格数据保存下来。把脚本放在Editor文件夹，右键mesh组件会多了个选项，可以把网格数据保存下来。
Unity保存Mesh为OBJ文件
06-12
由于无法直接保存自定义创建的Mesh，所以通过转成OBJ保存，再加载OBJ文件。（保存的OBJ没有贴图，重新加载需设置贴图）
保存网格(mesh)到磁盘上
化石
04-18 7620
Unity提供了很方便的工具来保存mesh之类的，下面的代码挂在GameObject上后，按下F键能把mesh（该GameObject必须有mesh组件）保存到磁盘的Assets目录下。在磁盘上是.asset的文件，在project中看到的是一个mesh符号的文件。代码完全是示意作用，没有做严格测试。
【Unity】关于unity Mesh 文件转存及解析
TaoDuanYi的博客
12-01 695
关于unity Mesh 文件转存及解析问题
Unity合并Mesh并保存在本地
weixin_43780907的博客
05-17 569
【代码】Unity合并Mesh并保存在本地。
Unity使用LineRenderer实现多组数据可视化
03-02
本教程将详细介绍如何使用Unity的LineRenderer结合C#脚本来实现多组数据的可视化。 首先，LineRenderer组件是Unity内置的一个图形渲染组件，它可以绘制出由一系列点连接而成的线。在使用LineRenderer之前，你需要在...
uinty3d SkinnedMeshRenderer batches 优化，模型合并网格贴图
05-29
SkinnedMeshRenderer 模型贴图网格分块过多，导致 batches过大，影响程序运行，通过将单个模型的网格贴图合并达到优化效果 详解：https://blog.csdn.net/weixin_41843959/article/details/80500930
Unity PDF Renderer v5.15
02-23
Unity PDF Renderer v5.15 是一款专为Unity游戏引擎设计的插件，它使得开发者能够在Unity环境中方便地集成和渲染PDF文档。这个插件的出现解决了Unity原生不支持直接处理PDF格式的问题，为教育、培训、信息展示等领域...
关于Unity中单独提取mesh组件并保存
热门推荐
Superirion的博客
05-29 1万+
关于Unity中单独提取mesh组件并保存 作为一个新入职的程序猿，老大给我分配了个任务，让我从一个Fbx模型中提取他的mesh。=。=这可如何是好，从未遇到过这个，最后只能求助谷歌了（别问为啥是谷歌），果然网络上还是有大佬的，终于找到了解决方法。 在这感谢TinyHum博主的文章，使用以下代码，就能把mesh保存在Assets目录下（当然目录你可以自己选）。在磁盘上是.asset的文件，在pro...
【UnityEditor】创建并保存 Texture图片、Mesh网格
萧然
08-30 5996
创建保存Texture： private void CreateSampleSprite() { int minRadius = 64; int maxRadius = 128; //图片尺寸 int spriteSize = maxRadius * 2; //创建Texture2D Texture2D texture2D = new Texture2D(spriteSize,sprite.
unity3d保存代码生成的Mesh到Assets目录下
zouxin_88的专栏
12-01 4000
Unity-MeshSaver/MeshSaverEditor.cs at master · pharan/Unity-MeshSaver · GitHub 使用时在meshFilter上点右键，选择Save Mesh即可。 using UnityEditor; using UnityEngine; public class MeshSaverEditor : MonoBehaviour { [MenuItem("CONTEXT/MeshFilter/Save Mesh...")].
Unity合并网格并保存
qq_45498613的博客
05-30 378
合并网格并保存
Unity 保存自定义模型数据
最新发布
weixin_40426854的博客
04-22 183
【代码】Unity 保存自定义模型数据。
Unity——脚本与序列化
m0_63024355的博客
09-02 1312
自定义二进制序列化是一种在代码级别定义对象如何转换为二进制数据的过程，以及如何将二进制数据转换回对象。在Unity中，通过自定义二进制序列化，我们可以完全控制对象的序列化和反序列化过程，以适应特定的需求。// ...// 将字段写入二进制流中// ...// 从二进制流中读取字段// ...// 设置对象的值...// 将二进制数据存储到磁盘或发送给其他系统...// 使用反序列化后的对象...
unity中保存mesh资源和点集txt文档并实现物体镜像
weixin_44345862的博客
10-11 1113
给一个fbx或obj格式的导入物体，另外保存其mesh资源，或者保存其内部的点的STL坐标以供研究。代码挂载到fbx或obj物体上即可，另外此代码可以随机不停地更改物体的顶点坐标形成动画效果（见代码中的update中屏蔽的部分）。物体的镜像需要进行两个操作：顶点Vertices取反和三角面片Triangles的渲染顺序颠倒。
Unity最佳实践-资产，对象和序列化
greedylin的博客
06-21 1887
Best Practices(2) - Assets, Objects and serialization 适用版本：2017.3 原文地址：https://unity3d.com/cn/learn/tutorials/topics/best-practices/assets-objects-and-serialization?playlist=30089 目录 用 [TOC]来生成...
Unity Asset 序列化
LCHUIHUI的博客
02-25 733
首先需要创建一个类 using System.Collections; using System.Collections.Generic; using UnityEngine; [CreateAssetMenu(fileName = &quot;testAsset&quot;,menuName = &quot;createAsset&quot;,order = 100)]//菜单按钮 第二个参数是菜单的名字 第三个是菜单上的顺序 pu...
unity skinned mesh renderer 碰撞
09-01
Unity中的Skinned Mesh Renderer（蒙皮网格渲染器）是一种用于渲染动画角色模型的组件，它可以将骨骼动画应用到静态的网格上。但是Skinned Mesh Renderer并不直接处理碰撞检测，它主要用于绘制和渲染模型。 如果...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值