devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

unity仓库管理简易模型(一)_仓库建模 unity3d

作者：我家自动化 | 2024-02-16 08:21:11

赞

踩

仓库建模 unity3d
1. 环境

unity2018

2. 运行截图

在这里插入图片描述

3. 功能
1. 场景漫游

提供第一视角模式和自由模式。第一视角使用unity自带的角色控制器包实现角色移动视角移动，自由模式实现鼠标拖拽，场景缩放。

2. 商品定位

通过输入商品信息，在三维场景中定位到商品模型并标识，在模型上方生成2D图形标记。

3. 存取档

通过xml、json、二进制、数据库等方式存储场景内容，本项目连接sqlserver数据库存储读取。

4. 网页（或窗体）交互

提供网页（或窗体）与unity数据传输，将unity页面嵌入浏览器网页或windows客户端（参考前面博客功能）。

4.项目搭建
1. 结构：

在这里插入图片描述
设主相机、灯光、plane平面、gameobject（游戏 控制器）、newCube(cube预设体生成位置)、shelves_2xs(场景货架放置位置)、canvas(ui界面)。

2. 实现代码

1）cube预设体
在这里插入图片描述
预设体半透明(通过Material材质球设置fade模式，如下图)，添加统一标签test（方便后续统一调用）,
在这里插入图片描述
cube预设体添加脚本moveController控制球体移动旋转,初始关闭moveController组件（后面需要时会在代码中开启）

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

public class moveController : MonoBehaviour
{
    public float speed = 3;              //人物移动速度
    public float rotatinDamping = 4;    //人物旋转的速度
    public float mouse1RotateDamping = 4;

    public bool cameraIsRotate = true;      //判断相机是否跟随人物旋转（点击鼠标左键可观看角色）

    private float h1;                //点击鼠标右键，存储鼠标X方向位移
    private float h2;                //点击鼠标左键，存储鼠标X方向位移

    private float currentOnClickMouse1AngleY = 0;     //鼠标右击时人物当前的Y轴度数
    private float currentCameraAngleY = 0;           //鼠标左击时相机当前的Y轴度数

    public GameObject cam;                  //人物后面的相机
    private CharacterController characterContro;   //角色控制器组件

    // Use this for initialization
    private void Start()
    {
        characterContro = this.GetComponent<CharacterController>();
        cam = GameObject.FindGameObjectWithTag("MainCamera");
    }

    // Update is called once per frame
    private void Update()
    {
        forwardOrBack();
        rotate();
        mouseControllerRotation();
    }

    /// <summary>
    /// 向前向后移动
    /// </summary>
    private void forwardOrBack()
    {
        if (Input.GetKey(KeyCode.W) || Input.GetKey(KeyCode.UpArrow))
        {
            characterContro.Move(transform.forward * speed * Time.deltaTime);
        }
        else
            if (Input.GetKey(KeyCode.S) || Input.GetKey(KeyCode.DownArrow))
        {
            characterContro.Move(-transform.forward * speed * Time.deltaTime);
        }
        else if (Input.GetKey(KeyCode.Q))
        {
            characterContro.Move(transform.up * speed * Time.deltaTime);
        }
        else if (Input.GetKey(KeyCode.E))
        {
            characterContro.Move(-transform.up * speed * Time.deltaTime);
        }
    }

    /// <summary>
    /// 按左右旋转
    /// </summary>
    private void rotate()
    {
        if (Input.GetKey(KeyCode.D))
        {
            transform.Rotate(Vector3.up * rotatinDamping);
        }
        if (Input.GetKey(KeyCode.A))
        {
            transform.Rotate(-Vector3.up * rotatinDamping);
        }
    }

    /// <summary>
    /// 鼠标控制旋转
    /// </summary>
    private void mouseControllerRotation()
    {
        if (Input.GetMouseButtonDown(1))
        {
            currentOnClickMouse1AngleY = transform.eulerAngles.y;
            h1 = 0;
        }
        if (Input.GetMouseButton(1))
        {
            h1 += Input.GetAxis("Mouse X") * mouse1RotateDamping;
            transform.eulerAngles = new Vector3(transform.eulerAngles.x, h1 + currentOnClickMouse1AngleY, transform.eulerAngles.z);
        }

        if (Input.GetMouseButtonDown(0))
        {
            currentCameraAngleY = cam.transform.eulerAngles.y;
            h2 = 0;
        }
        if (Input.GetMouseButton(0))
        {
            // float currentOnClickMouse1Angle = transform.eulerAngles.y;
            cameraIsRotate = false;
            h2 += Input.GetAxis("Mouse X") * mouse1RotateDamping;
            cam.transform.eulerAngles = new Vector3(cam.transform.eulerAngles.x, h2 + currentCameraAngleY, cam.transform.eulerAngles.z);
        }
        else
        {
            cameraIsRotate = true;
        }
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109

2）货架模型shelves_2xs，2D定位预设体
可自行搭建相关货架模型机及定位标记模型在这里插入图片描述
在这里插入图片描述
3）主相机main camerra 脚本挂置
cameraController（控制第一人称移动旋转）
CameraMover （控制漫游视角）
ModelDrage（控制物体鼠标点击拖拽）

初始关闭cameraController组件

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

public class cameraController : MonoBehaviour
{
    private moveController mc;      //获取人物控制组件
    private Transform target;         //相机跟随的目标位置

    public float rotationDamping = 6;         //相机跟随人物的旋转速度
    public float zoomSpeed = 4;                //鼠标滚轮滑动速度

    private float h1;                      //点击鼠标右键，存储鼠标Y方向位移
    private float distance = 0;     //相机和目标的距离

    //private float height = 1f;       //相机和目标的高度
    //private float heightDamping = 1;
    // Vector3 offsetPosition;

    // Use this for initialization


//  OnEnable是在Awake之后Start之前执行的，这个函数二次调用时仍会执行，而Start和Awake不会。
//  当然这里有个缺点：第一次执行时，Start函数会执行两遍。之后每次激活这个脚本。便会执行一次Start函数.
//  运行顺序为awake > onenable > start

//此处控制第一视角可以转换目标（如 新建一个cube后直接转到新的cube第一视角）
    private void OnEnable()
    {
        Start();
    }

    private void Start()
    {
        // distance = Vector3.Distance(new Vector3(0, 0, target.position.z), new Vector3(0, 0, target.position.z));
        //offsetPosition = target.position - transform.position;
        int tagLength = GameObject.FindGameObjectsWithTag("test").Length;
        target = GameObject.FindGameObjectsWithTag("test")[tagLength - 1].transform;

        Debug.Log("start方法" + target.name);

        mc = target.gameObject.GetComponent<moveController>();
        distance = Vector3.Distance(new Vector3(0, 0, target.position.z), new Vector3(0, 0, transform.position.z));
    }

    // Update is called once per frame
    private void Update()
    {
        //transform.position = target.position - offsetPosition;

        flowTarget();
        zoomView();
        UpAndDownView();
    }

    /// <summary>
    /// 相机跟随人物移动旋转
    /// </summary>
    private void flowTarget()
    {
        float wantedRotationAngle = target.eulerAngles.y;    //要达到的旋转角度
        //float wantedHeight = target.position.y + height;     //要达到的高度
        float currentRotationAngle = transform.eulerAngles.y; //当前的旋转角度
        float currentHeight = transform.position.y;           //当前的高度
        if (mc.cameraIsRotate)
        {
            currentRotationAngle = Mathf.LerpAngle(currentRotationAngle, wantedRotationAngle, rotationDamping * Time.deltaTime);
        }
        // currentHeight = Mathf.Lerp(currentHeight, wantedHeight, heightDamping * Time.deltaTime);    //由当前高度达到要达到的高度
        Quaternion currentRotation = Quaternion.Euler(transform.eulerAngles.x, currentRotationAngle, 0);
        // float currentRotation=1;   //防止主角回头摄像机发生旋转，  这里不用

        Vector3 ca = target.position - currentRotation * Vector3.forward * distance;     //tt是相机的位置
                                                                                         // transform.position = target.position-currentRotation * Vector3.forward * distance;

        //    transform.position = new Vector3(ca.x, transform.position.y, ca.z);       //最后得到的相机位置
        transform.position = new Vector3(ca.x, target.position.y + 2, ca.z);
        transform.rotation = currentRotation;                                   //最后得到相机的旋转角度
                                                                                // transform.LookAt(target.position);
    }

    /// <summary>
    /// 滚轮控制缩放
    /// </summary>
    private void zoomView()
    {
        float scrollWheel = Input.GetAxis("Mouse ScrollWheel") * zoomSpeed;
        distance -= scrollWheel;
        if (distance > 5.6f)
        {
            distance = 5.6f;
        }
        if (distance < 0.9f)
        {
            distance = 0.9f;
        }
    }

    /// <summary>
    /// 摄像头上下视角
    /// </summary>
    private void UpAndDownView()
    {
        if (Input.GetMouseButton(1))
        {
            h1 = Input.GetAxis("Mouse Y") * rotationDamping;
            Vector3 originalPosition = transform.position;
            Quaternion originalRotation = transform.rotation;
            transform.RotateAround(target.position, -target.right, h1);     //决定因素position和rotation
            float x = transform.eulerAngles.x;
            if (x < -10 || x > 80)
            {
                transform.position = originalPosition;
                transform.rotation = originalRotation;
            }
        }
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
using UnityEngine;
using System.Collections;

public class CameraMover : MonoBehaviour
{
    public float cameraMoveSpeed = 30f;
    public float cameraRotSpeed = 30f;
    private bool isRotateCamera = false;

    private float trans_y = 0;
    private float trans_x = 0;
    private float trans_z = 0;

    private float eulerAngles_x;
    private float eulerAngles_y;

    // Use this for initialization
    private void Start()
    {
        Vector3 eulerAngles = this.transform.eulerAngles;//当前物体的欧拉角
                                                         //Vector3 eulerAngles = new Vector3(20, 0, 0); //当前物体的欧拉角
                                                         // Debug.Log(eulerAngles);
        this.eulerAngles_x = eulerAngles.y;

        this.eulerAngles_y = eulerAngles.x;
    }

    private void FixedUpdate()
    {
        if (Input.GetMouseButton(1))
        {
            this.eulerAngles_x += (Input.GetAxis("Mouse X") * this.cameraRotSpeed) * Time.deltaTime;

            this.eulerAngles_y -= (Input.GetAxis("Mouse Y") * this.cameraRotSpeed) * Time.deltaTime;

            Quaternion quaternion = Quaternion.Euler(this.eulerAngles_y, this.eulerAngles_x, (float)0);

            this.transform.rotation = quaternion;

            moveCameraByKey(cameraMoveSpeed);
        }
        this.trans_z = (Input.GetAxis("Mouse ScrollWheel") * this.cameraMoveSpeed * 30) * Time.deltaTime;
        this.transform.Translate(Vector3.forward * this.trans_z);
        //if (Input.GetMouseButton(2))
        //{
        //    this.trans_y = (Input.GetAxis("Mouse Y") * this.ySpeed / 2) * 0.02f;
        //    this.trans_x = (Input.GetAxis("Mouse X") * this.xSpeed / 2) * 0.02f;

        //    this.transform.Translate(-1 *Vector3.right * this.trans_x);
        //    this.transform.Translate(-1 *Vector3.up * this.trans_y);
        //}
    }

    private void moveCameraByKey(float speed)
    {
        if (Input.GetKey(KeyCode.Q))
        {
            this.transform.Translate(Vector3.down * speed * Time.deltaTime);
        }

        if (Input.GetKey(KeyCode.E))
        {
            this.transform.Translate(Vector3.up * speed * Time.deltaTime);
        }

        float moveV = Input.GetAxis("Vertical");
        float moveH = Input.GetAxis("Horizontal");

        this.transform.Translate(Vector3.forward * speed * moveV * Time.deltaTime + Vector3.right * speed * moveH * Time.deltaTime);
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class ModelDrage : MonoBehaviour
{
    private Camera cam;//发射射线的摄像机
    private GameObject go;//射线碰撞的物体
    public static string btnName;//射线碰撞物体的名字
    private Vector3 screenSpace;
    private Vector3 offset;
    private bool isDrage = false;

    private void Start()
    {
        cam = cam = Camera.main;
        // cam = Camera.current;
    }

    private void Update()
    {
        //整体初始位置
        Ray ray = cam.ScreenPointToRay(Input.mousePosition);
        //从摄像机发出到点击坐标的射线
        RaycastHit hitInfo;
        if (isDrage == false)
        {
            if (Physics.Raycast(ray, out hitInfo))
            {
                //划出射线，只有在scene视图中才能看到
                Debug.DrawLine(ray.origin, hitInfo.point);
                go = hitInfo.collider.gameObject;
                //print(btnName);
                screenSpace = cam.WorldToScreenPoint(go.transform.position);
                offset = go.transform.position - cam.ScreenToWorldPoint(new Vector3(Input.mousePosition.x, Input.mousePosition.y, screenSpace.z));
                //物体的名字
                btnName = go.name;

                //发送给winform
                //   Application.ExternalEval(btnName);

                //组件的名字
            }
            else
            {
                btnName = null;
            }
        }
        if (Input.GetMouseButton(0))
        {
            Vector3 currentScreenSpace = new Vector3(Input.mousePosition.x, Input.mousePosition.y, screenSpace.z);
            Vector3 currentPosition = cam.ScreenToWorldPoint(currentScreenSpace) + offset;
            if (btnName != null)
            {
                go.transform.position = currentPosition;
            }

            isDrage = true;
        }
        else
        {
            isDrage = false;
        }
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65

4）GameObject脚本挂置

包括新建cube预设体，存读挡，第一人称自由视角变更等操作。
sqlserver,二进制存读挡可以实现,json,xml暂存错误。
（内容较多，暂时把功能代码都放在里面了，后续会分离出来）

using LitJson;
using System.Collections;
using System.Collections.Generic;
using System.Data.SqlClient;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using System.Xml;
using UnityEditor;
using UnityEngine;
using UnityEngine.UI;

[System.Serializable]
public class newCube : MonoBehaviour
{
   public Text cubeNo;

   private GameObject[] targetGOs;

   public GameObject boxBody; //障碍物

   public GameObject mark;

   private static int i = 1;
   private static int a = 0;

   private string path;

   private bool isActive = true;

   private void Awake()
   {
   }

   // Use this for initialization
   private void Start()
   {
   }

   // Update is called once per frame
   private void Update()
   {
       int tagLength = GameObject.FindGameObjectsWithTag("test").Length;

       if (Input.GetKeyDown(KeyCode.R))
       {
           GameObject.FindGameObjectWithTag("MainCamera").GetComponent<cameraController>().enabled = false;
           AppearPosition();
       }

       if (Input.GetKeyDown(KeyCode.T))
       {
           //ExportSceneInfoToXML e = new ExportSceneInfoToXML();
           //e.ExportXML();
           //SaveByBin();
           SaveBySql();
       }

       if (Input.GetKeyDown(KeyCode.Y))
       {
           GameObject.FindGameObjectWithTag("MainCamera").GetComponent<cameraController>().enabled = false;
           LoadBySql();
       }

       if (Input.GetKeyDown(KeyCode.U))
       {
           for (int i = 0; i < tagLength; i++)
           {
               GameObject.FindGameObjectsWithTag("test")[i].GetComponent<moveController>().enabled = false;
           }
           GameObject.FindGameObjectWithTag("MainCamera").GetComponent<cameraController>().enabled = false;
           GameObject.FindGameObjectWithTag("MainCamera").GetComponent<CameraMover>().enabled = true;
           GameObject.FindGameObjectWithTag("MainCamera").GetComponent<ModelDrage>().enabled = true;
       }

       if (Input.GetKeyDown(KeyCode.I))
       {
           GameObject.FindGameObjectsWithTag("test")[tagLength - 1].GetComponent<moveController>().enabled = true;
           GameObject.FindGameObjectWithTag("MainCamera").GetComponent<cameraController>().enabled = true;
           GameObject.FindGameObjectWithTag("MainCamera").GetComponent<CameraMover>().enabled = false;
           GameObject.FindGameObjectWithTag("MainCamera").GetComponent<ModelDrage>().enabled = false;
       }
   }

   private void AppearPosition()
   {
       GameObject newCube = GameObject.Find("newCube");

       Vector3 bodyAppearPosition = new Vector3(0, 2, 0);
       Quaternion bodyAppearRotation = Quaternion.identity;

       // boxBody.transform.parent = newCube.transform;
       // Application.ExternalCall(boxBody.name);
       //   Application.ExternalEval(boxBody.name);

       boxBody = Instantiate(boxBody, bodyAppearPosition, bodyAppearRotation);
       boxBody.transform.parent = newCube.transform;
       boxBody.name = "swj" + i;
       i++;
       a += 2;
       // boxBody.GetComponent<move>().enabled = false;

       int tagLength = GameObject.FindGameObjectsWithTag("test").Length;

       for (int i = 0; i < tagLength; i++)
       {
           GameObject.FindGameObjectsWithTag("test")[i].GetComponent<moveController>().enabled = false;
       }

       GameObject.FindGameObjectsWithTag("test")[tagLength - 1].GetComponent<moveController>().enabled = true;
       GameObject.FindGameObjectWithTag("MainCamera").GetComponent<cameraController>().enabled = true;

       GameObject.FindGameObjectWithTag("MainCamera").GetComponent<CameraMover>().enabled = false;
       GameObject.FindGameObjectWithTag("MainCamera").GetComponent<ModelDrage>().enabled = false;
   }

   //创建Save对象并存储当前游戏状态信息
   private Save CreateSaveGO()
   {
       targetGOs = GameObject.FindGameObjectsWithTag("test");

       Save save = new Save();
       foreach (GameObject targetGO in targetGOs)
       {
           Transform tra = targetGO.transform;

           VectorToSave vtf = new VectorToSave();
           // vtf.VectorToFloat01(tra);

           save.listDouble.Add(vtf.VectorToDouble(tra));
           save.cubeNames.Add(tra.name);
           //     save.list.Add(targetGO);
       }

       return save;
   }

   private void SaveByJson()
   {
       Save save = CreateSaveGO();
       path = Application.dataPath + "/test" + "/byJson.json";
       //利用JsonMapper将save对象转换为Json格式的字符串
       string saveJsonStr = JsonMapper.ToJson(save);
       //将这个字符串写入到文件中
       //创建一个StreamWriter，并将字符串写入
       StreamWriter sw = new StreamWriter(path);
       sw.Write(saveJsonStr);
       //关闭写入流
       sw.Close();
       AssetDatabase.Refresh();
       //   UIManager._instance.ShowMessage("保存成功");
   }

   private void LoadByJson()
   {
       //   JsonData j;
       path = Application.dataPath + "/test" + "/byJson.json";

       //创建一个StreamReader，用来读取流
       StreamReader sr = new StreamReader(path);
       //将读取到的流赋值给saveJsonStr
       string saveJsonStr = sr.ReadToEnd();
       sr.Close();
       //将字符串转换为Save对象
       //       j = JsonMapper.ToObject<JsonData>(saveJsonStr);

       Save save = JsonMapper.ToObject<Save>(saveJsonStr);

       SetGame(save);
       //   UIManager._instance.ShowMessage("加载成功");
   }

   /// <summary>
   /// 二进制存档
   /// </summary>
   //存档
   private void SaveByBin()
   {
       //序列化过程（将save对象转换为字节流）
       //创建save对象并保存当前游戏状态
       Save save = CreateSaveGO();
       //创建一个二进制格式化程序
       BinaryFormatter bf = new BinaryFormatter();
       //创建一个文件流
       path = Application.dataPath + "/test" + "/byBin.txt";
       FileStream fileStream = File.Create(path);
       //用二进制格式化程序的序列化方法来序列化Save对象，参数：创建的文件流和需要序列化的对象
       bf.Serialize(fileStream, save);
       //关闭流
       fileStream.Close();
       //即时刷新Project工程文件
       AssetDatabase.Refresh();
   }

   // 读档
   private void LoadByBin()
   {
       path = Application.dataPath + "/test" + "/byBin.txt";
       //反序列化过程
       //创建一个二进制格式化程序
       BinaryFormatter bf = new BinaryFormatter();
       //打开一个文件流
       FileStream fileStream = File.Open(path, FileMode.Open);
       //调用格式化程序的反序列化方法，将文件流转换为一个save对象
       Save save = bf.Deserialize(fileStream) as Save;

       SetGame(save);
       //关闭文件流
       fileStream.Close();
   }

   //保存到数据库
   private void SaveBySql()
   {
       //SqlConnection conn = new SqlConnection();
       sqlAceess sql = new sqlAceess();
       sql.Conn();

       //删除数据库旧存档
       sql.delete();

       //  sql.Insert(conn);
       Save save = new Save();

       targetGOs = GameObject.FindGameObjectsWithTag("test");

       foreach (GameObject targetGO in targetGOs)
       {
           Transform tra = targetGO.transform;

           save.x = tra.position.x;
           save.y = tra.position.y;
           save.z = tra.position.z;

           save.l = tra.rotation.x;
           save.m = tra.rotation.y;
           save.n = tra.rotation.z;
           save.w = tra.rotation.w;
           save.cubeName = tra.name;

           //插入到数据库
           sql.Insert(save);
       }
       sql.ConnClose();
   }

   //从数据库读取
   private void LoadBySql()
   {
       //读取存档前 删除目前正在运行的cube
       targetGOs = GameObject.FindGameObjectsWithTag("test");

       foreach (GameObject targetGO in targetGOs)
       {
           Destroy(targetGO);
       }

       sqlAceess sql = new sqlAceess();
       sql.Conn();

       List<Save> listSave = sql.select();

       for (int i = 0; i < listSave.Count; i++)
       {
           Save sa = listSave[i];

           string name = sa.cubeName;
           float a = (float)sa.x;
           float b = (float)sa.y;
           float c = (float)sa.z;
           float d = (float)sa.l;
           float e = (float)sa.m;
           float f = (float)sa.n;
           float w = (float)sa.w;
           Vector3 v = new Vector3(a, b, c);
           Quaternion bodyAppearRotation = new Quaternion(d, e, f, w);
           boxBody = Instantiate(boxBody, v, bodyAppearRotation);
           GameObject newCube = GameObject.Find("newCube");
           boxBody.transform.parent = newCube.transform;
           boxBody.name = name;
       }

       sql.ConnClose();
       GameObject.FindGameObjectWithTag("MainCamera").GetComponent<cameraController>().enabled = true;
   }

   private void SetGame(Save save)
   {
       int length = save.listDouble.Count;

       for (int i = 0; i < length; i++)
       {
           //  boxBody = Instantiate(save.list[i]);

           double[] dou = save.listDouble[i];
           float a = (float)dou[0];
           float b = (float)dou[1];
           float c = (float)dou[2];

           float d = (float)dou[3];
           float e = (float)dou[4];
           float f = (float)dou[5];
           float w = (float)dou[6];
           Vector3 v = new Vector3(a, b, c);

           Quaternion bodyAppearRotation = new Quaternion(d, e, f, w);
           //  Quaternion bodyAppearRotation = Quaternion.identity;
           boxBody = Instantiate(boxBody, v, bodyAppearRotation);

           GameObject newCube = GameObject.Find("newCube");
           boxBody.transform.parent = newCube.transform;
           boxBody.name = save.cubeNames[i];
       }

       // Vector3 v = new Vector3(a, b, c);

       // Vector3 bodyAppearPosition = new Vector3(0, 2, 0);
       // Quaternion bodyAppearRotation = Quaternion.identity;

       // boxBody.transform.parent = newCube.transform;
       // Application.ExternalCall(boxBody.name);
       //   Application.ExternalEval(boxBody.name);

       // GameObject.FindGameObjectWithTag("test").GetComponent<moveController>().enabled = true;
       //   GameObject.FindGameObjectWithTag("MainCamera").GetComponent<cameraController>().enabled = true;
   }
   
//根据输入内容定位cube并在上方生成标签
   public void selectCube(string cubeNo)
   {
       GameObject[] ga = GameObject.FindGameObjectsWithTag("mark");
       for (int i = 0; i < ga.Length; i++)
       {
           Destroy(ga[i]);
       }

       cubeNo = this.cubeNo.text;

       Save save = CreateSaveGO();
       int length = save.cubeNames.Count;

       if (save.cubeNames.Contains(cubeNo))
       {
           Debug.Log("找到了" + cubeNo);
           GameObject gam = GameObject.Find(cubeNo);
           Vector3 v = gam.transform.position;
           Vector3 v2 = v + new Vector3(0, 1, 0);
           Instantiate(mark, v2, Quaternion.identity);
       }
       else
       {
           Debug.Log("不存在" + cubeNo);
       }

       // boxBody.name = CreateSaveGO().cubeNames[0];
   }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212
  • 213
  • 214
  • 215
  • 216
  • 217
  • 218
  • 219
  • 220
  • 221
  • 222
  • 223
  • 224
  • 225
  • 226
  • 227
  • 228
  • 229
  • 230
  • 231
  • 232
  • 233
  • 234
  • 235
  • 236
  • 237
  • 238
  • 239
  • 240
  • 241
  • 242
  • 243
  • 244
  • 245
  • 246
  • 247
  • 248
  • 249
  • 250
  • 251
  • 252
  • 253
  • 254
  • 255
  • 256
  • 257
  • 258
  • 259
  • 260
  • 261
  • 262
  • 263
  • 264
  • 265
  • 266
  • 267
  • 268
  • 269
  • 270
  • 271
  • 272
  • 273
  • 274
  • 275
  • 276
  • 277
  • 278
  • 279
  • 280
  • 281
  • 282
  • 283
  • 284
  • 285
  • 286
  • 287
  • 288
  • 289
  • 290
  • 291
  • 292
  • 293
  • 294
  • 295
  • 296
  • 297
  • 298
  • 299
  • 300
  • 301
  • 302
  • 303
  • 304
  • 305
  • 306
  • 307
  • 308
  • 309
  • 310
  • 311
  • 312
  • 313
  • 314
  • 315
  • 316
  • 317
  • 318
  • 319
  • 320
  • 321
  • 322
  • 323
  • 324
  • 325
  • 326
  • 327
  • 328
  • 329
  • 330
  • 331
  • 332
  • 333
  • 334
  • 335
  • 336
  • 337
  • 338
  • 339
  • 340
  • 341
  • 342
  • 343
  • 344
  • 345
  • 346
  • 347
  • 348
  • 349
  • 350
  • 351
  • 352
  • 353
  • 354
  • 355
  • 356

5）其余script脚本

Save 持久类（存储类型）
sqlAceess数据库连接 (暂实现查询，插入，删除三个功能代码，有需要可补充)
VectorToSave（二进制时需要，将位置信息转储为小数行式）
run（2D定位标签自转脚本，放在2D应为标签 mark预设体下）

使用sqlserver数据库需导包到项目
到unity安装目录下D:\Program Files\Unity\Editor\Data\Mono\lib\mono\unity 将以下dll文件放置到assets/Plugins文件夹下
在这里插入图片描述

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

[System.Serializable]
public class Save
{
    // public List<GameObject> list = new List<GameObject>();

    public List<double[]> listDouble = new List<double[]>();

    public List<float[]> listFloat = new List<float[]>();

    public List<string> cubeNames = new List<string>();

    public double x;
    public double y;
    public double z;

    public double l;
    public double m;
    public double n;
    public double w;
    public string cubeName;
    //public Vector3 v = new Vector3();
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using UnityEditor.MemoryProfiler;
using UnityEngine;

public class sqlAceess
{
    private string connsql = "Data Source=127.0.0.1;DataBase=test;uid=sa;pwd=Oraps123";
    private SqlConnection conn = new SqlConnection();
    // Use this for initialization
    //private void Start()
    //{
    //    SqlConnection conn = new SqlConnection();

    //    //链接数据库
    //    Conn(conn);

    //    Insert(conn);

    //    //关闭连接   Conn这个对象本身还存在内存中，需要在使用的时候，可以直接使用
    //    conn.Close();
    //    //释放对象   Conn对象已经不存在了，下次再需要使用的时候，对象就不存在了，需要重新创建（New）
    //    conn.Dispose();

    //    Console.ReadLine();
    //    SqlConnection connstr = new SqlConnection("Data Source=127.0.0.1;DataBase=test;uid=sa;pwd=Oraps123");

    //    connstr.Close();

    //    connstr.Open();
    //    SqlCommand cmd = new SqlCommand();
    //    cmd.Connection = connstr;
    //    cmd.CommandType = System.Data.CommandType.Text;
    //    //设置sql连接语句
    //    cmd.CommandText = "delete  from TEST01 where id =1";
    //    SqlDataAdapter sda = new SqlDataAdapter(cmd);
    //    sda.SelectCommand.Connection.Close();
    //    sda.SelectCommand.Connection.Open();
    //    string strtemp = sda.SelectCommand.ExecuteScalar().ToString();
    //    sda.SelectCommand.Connection.Close();
    //    //  print("连接数据库成功!" + strtemp);
    //    connstr.Close();
    //    sda.SelectCommand.Connection.Close();
    //}

    // Update is called once per frame

    //连接数据库
    public void Conn()
    {
        //获取或设置用于打开 SQL Server 数据库的字符串
        conn.ConnectionString = connsql;

        try
        {
            //打开数据库
            conn.Open();
            //打印数据库连接状态
            Console.WriteLine(conn.State);
        }
        catch (SqlException ex)
        {
            Console.WriteLine("数据库打开失败！");
            Console.WriteLine(ex.Message);
        }
    }

    public void ConnClose()
    {
        conn.Close();
        conn.Dispose();
    }

    //insert
    public void Insert(Save save)
    {
        String sql_insert = "insert into cubeInfo(cubeName,position_x,position_y,position_z,rotation_x,rotation_y,rotation_z,rotation_w) values(@NAME,@px,@py,@pz,@rx,@ry,@rz,@rw)";

        SqlCommand cmd_insert = new SqlCommand(sql_insert, conn);
        SqlParameter para1 = new SqlParameter("@NAME", save.cubeName);
        cmd_insert.Parameters.Add(para1);
        SqlParameter para2 = new SqlParameter("@px", save.x);
        cmd_insert.Parameters.Add(para2);
        SqlParameter para3 = new SqlParameter("@py", save.y);
        cmd_insert.Parameters.Add(para3);
        SqlParameter para4 = new SqlParameter("@pz", save.z);
        cmd_insert.Parameters.Add(para4);
        SqlParameter para5 = new SqlParameter("@rx", save.l);
        cmd_insert.Parameters.Add(para5);
        SqlParameter para6 = new SqlParameter("@ry", save.m);
        cmd_insert.Parameters.Add(para6);
        SqlParameter para7 = new SqlParameter("@rz", save.n);
        cmd_insert.Parameters.Add(para7);
        SqlParameter para8 = new SqlParameter("@rw", save.w);
        cmd_insert.Parameters.Add(para8);
        //对连接执行 Transact-SQL 语句并返回受影响的行数
        int res_1 = cmd_insert.ExecuteNonQuery();
        Console.WriteLine(res_1);
    }

    //update
    public void update()
    {
        string sql_update = "update Table_1 set name=@NAME where id=@ID;";
        SqlCommand cmd_update = new SqlCommand(sql_update, conn);
        cmd_update.Parameters.AddWithValue("@ID", "3");
        cmd_update.Parameters.AddWithValue("@NAME", "Bit100");
        int res_2 = cmd_update.ExecuteNonQuery();
        Console.WriteLine(res_2);
    }

    //delete
    public void delete()
    {
        string sql_delete = "DELETE FROM cubeInfo ";
        SqlCommand cmd_delete = new SqlCommand(sql_delete, conn);
        int res_3 = cmd_delete.ExecuteNonQuery();
        //string sql_delete = "DELETE FROM Table_1 WHERE name=@NAME;";
        //SqlCommand cmd_delete = new SqlCommand(sql_delete, conn);
        //cmd_delete.Parameters.AddWithValue("@NAME", "Bit106");
        //int res_3 = cmd_delete.ExecuteNonQuery();
        //Console.WriteLine(res_3);
    }

    //select
    public List<Save> select()
    {
        List<Save> listSave = new List<Save>();

        //定义查询语句
        String sql = "select * from cubeInfo";
        SqlCommand sqlComm = new SqlCommand(sql, conn);
        //接收查询到的sql数据
        SqlDataReader reader = sqlComm.ExecuteReader();
        //读取数据
        while (reader.Read())
        {
            //  save.cubeName = reader["cubeName"].ToString();
            Save save = new Save();
            save.cubeName = reader.GetString(2);
            save.x = reader.GetDouble(3);
            save.y = reader.GetDouble(4);
            save.z = reader.GetDouble(5);
            save.l = reader.GetDouble(6);
            save.m = reader.GetDouble(7);
            save.n = reader.GetDouble(8);
            save.w = reader.GetDouble(9);
            listSave.Add(save);

            /**
             * vector 中xyz等坐标都是float类型  坐标存为float时  SqlDataReader读取却只能为double 不然报错 double丢失精度
             * 目前将save里float改为了double类型 目测可以改为存为string 取出来后再转float
            */

            //float ss = (float)reader.GetDouble(3);
            //save.x = float.Parse(reader.GetValue(3).ToString());
                float sss = reader.GetFloat(4);
            //save.x = reader.GetFloat(3);
            //save.y = (float)reader.GetValue(4);
            //save.x = reader["position_x"].;
            //save.y = reader["position_y"].ToString();
            //reader["position_z"].ToString();
            //reader["rotation_x"].ToString();
            //reader["rotation_y"].ToString();
            //reader["rotation_z"].ToString();
            //reader["rotation_w"].ToString();

            //打印
            //   Console.WriteLine(reader["uid"].ToString());
            //   Console.WriteLine(reader["name"].ToString());
        }
        reader.Close();
        return listSave;
    }

    //调用存储过程
    public void procedure()
    {
        SqlCommand cmd = new SqlCommand("testInsert", conn);
        cmd.CommandType = CommandType.StoredProcedure;//告知执行存储过程
                                                      //传参数
        cmd.Parameters.AddWithValue("@Uid", "106");
        cmd.Parameters.AddWithValue("@Name", "Bit106");
        int res = cmd.ExecuteNonQuery();
        Console.WriteLine(res);
    }

    //批量写入
    public void insertBulk()
    {
        DataTable dt = GetTableSchema();

        SqlBulkCopy bulkCopy = new SqlBulkCopy(conn);
        //获取服务器上目标表的名称
        bulkCopy.DestinationTableName = "Table_1";
        bulkCopy.BatchSize = dt.Rows.Count;

        for (int i = 0, j = 107; i < 100; i++, j++)
        {
            //创建与该表结构相同的行
            DataRow dr = dt.NewRow();
            dr[1] = j;
            dr[2] = "Bit" + j;
            dt.Rows.Add(dr);
        }
        if (dt != null && dt.Rows.Count != 0)
        {
            try
            {
                //将内存中数据表的记录写到服务器上的目标表中
                bulkCopy.WriteToServer(dt);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
        //Console.WriteLine(string.Format("插入{0}条记录", 100));
    }

    private static DataTable GetTableSchema()
    {
        //内存中建一个数据表
        DataTable dt = new DataTable();
        //获取该数据表的列
        dt.Columns.AddRange(new DataColumn[] {
        new DataColumn("id",typeof(int)),
        new DataColumn("uid",typeof(int)),
        new DataColumn("name",typeof(string))});
        return dt;
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212
  • 213
  • 214
  • 215
  • 216
  • 217
  • 218
  • 219
  • 220
  • 221
  • 222
  • 223
  • 224
  • 225
  • 226
  • 227
  • 228
  • 229
  • 230
  • 231
  • 232
  • 233
  • 234
  • 235
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class run : MonoBehaviour
{
    public GameObject Axis;//轴,用于选择围绕中心
    public float RotateSpeed;//旋转速度// Use this for initialization

    // Use this for initialization
    private void Start()
    {
    }

    // Update is called once per frame
    private void Update()
    {
        this.transform.RotateAround(Axis.transform.position, Vector3.up, RotateSpeed);
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

后续再看情况更新…
相关文档

基于unity3D的可视化仓储.pdf

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/91959
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号