c#和unity引擎的全部笔记

时间 2019-11-19

标签 c# unity 引擎全部笔记栏目 C# 繁體版

原文原文链接

Shader摄像机死亡效果

做者： 1056923207@qq.com

1：Shader脚本

Shader "Custom/CameraShader"

{

Properties

{

_MainTex( "MainTexture",2D )= "white" {}

}

SubShader

{

Tags{"RenderType"= "Opaque"}

LOD 200

Pass

{

CGPROGRAM

#pragma vertex vert

#pragma fragment frag

#include "UnityCG.cginc"

sampler2D _MainTex;

void vert ( inout appdata_base v)

{

v.vertex= mul ( UNITY_MATRIX_MVP ,v.vertex);

}

float4 frag( appdata_base v):COLOR

{

fixed4 c= tex2D(_MainTex,v.texcoord);

fixed d = 0.3*c.r+0.59*c.g+0.11*c.b;

return fixed4 (d,d,d,1);

}

ENDCG

}

2：摄像机上挂载的脚本：

using UnityEngine;

using System.Collections;

public class CameraTest : MonoBehaviour {

public Material material;

//相机的回调函数

void OnRenderImage( RenderTexture rest/*相机渲染的图像*/ , RenderTexture dest /*通过Shader渲染后的图像*/ )

{

Graphics.Blit(rest, dest, material);//摄像机渲染好的图像通过处理再显示出来

}

快速排序

做者： 1056923207@qq.com

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace QuickSort

{

class Program

{

static void Main(string[] args)

{

int[] arr = new int[8000000];

for (int i = 0; i < arr.Length; i++)

{

arr[i] = 8000000 - i;

}

kuaisu(arr, 0, arr.Length - 1);

//BuddleSort(arr);

foreach (var item in arr)

{

Console.WriteLine(item);

}

//普通冒泡排序

public static void BuddleSort( int[] arr)

{

for (int i = 0; i < arr.Length-1; i++)

{

for (int j = 0; j < arr.Length-1-i; j++)

{

if (arr[j]>arr[j+1])

{

int temp = arr[j];

arr[j] = arr[j + 1];

arr[j + 1] = temp;

}

//快速排序

public static void kuaisu( int [] arr,int left,int right)

{

if (left>=right)

{

return;

}

if (left<right)

{

int middle = arr[(left + right) / 2];

int i = left-1;

int j = right+1;

while (true )

{

while (arr[++i] < middle) { }

while (arr[--j] > middle) { }

if (i>=j)

{

break;

}

int temp = arr[i];

arr[i] = arr[j];

arr[j] = temp;

}

kuaisu(arr, left, i - 1);

kuaisu(arr, j + 1, right);

}

Shader

来源网址： http://www.jianshu.com/p/7b9498e58659
做者： 1056923207@qq.com

http://www.jianshu.com/p/7b9498e58659

最他妈好的解释没有之一

struct SurfaceOutput {

  half3 Albedo; // 纹理颜色值（r, g, b)
  half3 Normal; // 法向量(x, y, z)
  half3 Emission; // 自发光颜色值(r, g, b)
  half Specular; // 镜面反射度
  half Gloss; // 光泽度
  half Alpha; // 不透明度

};

ambient 环境光

Shader

做者： 1056923207@qq.com

shader数据类型

fixed 取值范围[-2,2]

half

double

网络

做者： 1056923207@qq.com

同步动画在人物身上绑定来性格组件：networkidentity，

Out和Ref的区别

来源网址： http://www.cnblogs.com/sjrhero/articles/1922902.html
做者： 1056923207@qq.com

ref和out的使用与区别

out的使用php

————————————————————————————————————————————————— html

   class Program
    {
        static void Main(string[] args)
        {node

　　　　　string tmp; //先声明，但不初始化算法

　　　　　User _user=new User(); sql

　　　　　_user.Name(out tmp); //调用Name方法数据库

Console.WriteLine("{0}",tmp);　//这时tmp的值为“在这里面赋值了”编程

Console.ReadKey(true);json

　　　}canvas

}小程序

　　class User

{

　　　　public void Name(out string tmps)

{

　　　　　 tmps="在这里面赋值了";

}

结果：

在这里面赋值了

—————————————————————————————————————————————————

ref的使用

—————————————————————————————————————————————————

   class Program
    {
        static void Main(string[] args)
        {

　　　　　string tmp="传值以前"; //声明并初始化这时若是输出tmp值为"传值以前"

　　 User _user=new User();

_user.Name(ref tmp);

Console.WriteLine("{0}",tmp);

Console.ReadKey(true);

}

class User

{

public void Name(ref string tmps)

{

tmps="传值以后";

}

结果：

传值以后

—————————————————————————————————————————————————

区别：

ref和out的区别在C# 中，既能够经过值也能够经过引用传递参数。经过引用传递参数容许函数成员更改参数的值，并保持该更改。若要经过引用传递参数，可以使用ref或out关键字。ref和out这两个关键字都可以提供类似的功效，其做用也很像C中的指针变量。它们的区别是：

一、使用ref型参数时，传入的参数必须先被初始化。对out而言，必须在方法中对其完成初始化。

二、使用ref和out时，在方法的参数和执行方法时，都要加Ref或Out关键字。以知足匹配。

三、out适合用在须要retrun多个返回值的地方，而ref则用在须要被调用的方法修改调用者的引用的时候。

out

方法参数上的 out 方法参数关键字使方法引用传递到方法的同一个变量。当控制传递回调用方法时，在方法中对参数所作的任何更改都将反映在该变量中。

当但愿方法返回多个值时，声明 out 方法很是有用。使用 out 参数的方法仍然能够返回一个值。一个方法能够有一个以上的 out 参数。

若要使用 out 参数，必须将参数做为 out 参数显式传递到方法。out 参数的值不会传递到 out 参数。

没必要初始化做为 out 参数传递的变量。然而，必须在方法返回以前为 out 参数赋值。

属性不是变量，不能做为 out 参数传递。

ref是有进有出，而out是只出不进。

根据Txt文件数据生成地图

做者： 1056923207@qq.com

往文件写东西用：FileStream;

从文件读东西用：StreamReader；

字符串转化为字节的区别：

一个一个转换： this .data[i, j] = byte .Parse(data[i][j].ToString());

多个转换 byte [] map = Encoding .UTF8.GetBytes(sb.ToString());//想获得什么类型的数据就Get什么

using UnityEngine;

using System.Collections;

using UnityEditor;

using System.IO;

using System.Text;

public class MapBuilder : Editor{

public const int RowCount = 6;

public const int ColCount = 6;

[ MenuItem ( "Map/Build")]

static void BuildMap()

{

//建立地图10*10

//规则：蓝色是海洋，红色是障碍物，黄色是终止点

byte[,] map = GetMapData();

GameObject Roads = new GameObject( "Roads");

GameObject BlueCube = Resources .Load("Blue") as GameObject ;

GameObject RedCude = Resources .Load("Red") as GameObject ;

for (int i = 0; i <RowCount; i++)

{

for (int j = 0; j < ColCount; j++)

{

switch (map[i,j])

{

case 1:

GameObject RCube= Instantiate(RedCude) as GameObject;

RCube.transform.SetParent(Roads.transform);

RCube.transform.position = new Vector3 (-17.5f + i, 0, j + 17.5f );

RCube.transform.localScale = Vector3.one * 0.8f;

RCube.name = i.ToString() + "_" + j.ToString();

break;

case 2:

GameObject Bcube= Instantiate(BlueCube) as GameObject;

Bcube.transform.SetParent(Roads.transform);

Bcube.transform.position = new Vector3 (-17.5f + i, 0, j + 17.5f );

Bcube.transform.localScale = Vector3.one * 0.8f;

Bcube.name = i.ToString() + "_" + j.ToString();

break;

default:

GameObject cube= GameObject .CreatePrimitive(PrimitiveType.Cube);

cube.transform.SetParent(Roads.transform);

cube.transform.position = new Vector3 (-17.5f + i, 0, j + 17.5f);

cube.transform.localScale = Vector3.one * 0.8f;

cube.name = i.ToString() + "_" + j.ToString();

break;

}

//从地图取数据

[ MenuItem ( "Map/Test")]

static byte[,] GetMapData()

{

string path = Application .dataPath + "/Map/Map1.txt";

//文件读写流

StreamReader sr = new StreamReader(path); //读取文件而且将文件中的内容放到sr中

string result = sr.ReadToEnd(); //读取内容(从当前位置到末尾读取)

string[] data = result.Split(new char[] { '\n'});//逐行截取,生成的数据就是一行一行的

byte[,] mapdata = new byte[RowCount, ColCount]; //定义一个二维数组

Debug.Log(data.Length);

for (int i = 0; i < RowCount; i++)

{

for (int j = 0; j < ColCount; j++)

{

mapdata[i, j] = byte.Parse(data[i][j].ToString());//将字符串存入到二维数组

}

return mapdata;

}

//往地图写数据

[ MenuItem ( "Map/CreateMap")]

static void CreateMap()

{

//第一步访问txt文件

string path = Application .dataPath + "/Map/Map1.txt";

FileStream fs= File .OpenWrite(path);//能够对文件进行操做

//第二步填充内容

StringBuilder sb = new StringBuilder(); //容量可变的字符串数组

for (int i = 0; i < RowCount; i++)

{

for (int j = 0; j < ColCount; j++)

{

sb.Append( Random.Range(0, 3));//给字符串添加值

}

sb.AppendLine(); //换行

}

byte[] map = Encoding .UTF8.GetBytes(sb.ToString());//想获得什么类型的数据就Get什么

fs.Write(map, 0, map.Length); //将Map写到文件中，从map的第0个空间开始，长度为length

fs.Close(); //关闭流

fs.Dispose(); //释放资源

AssetDatabase.Refresh();//刷新资源显示

}

A*算法

做者： 1056923207@qq.com

using UnityEngine;

using System.Collections.Generic;

using System.IO;

using System.Text;

public class AStar : MonoBehaviour {

#region 字段

byte[,] mapData; //存储地图数据的数组

int rowCount; //地图行数

int colCount; //地图列数

string mappath;

Transform Player; //小球

Vector2 start; //起始点

Vector2 end; //终止点

Vector3 MoveDir; //移动的方向

Vector3 Target; //移动的下一个目标

//存放待访问节点

List< Node> list = new List< Node> ();

//存放已经访问过的节点

List< Node> visited = new List< Node>();

//存放小球的路径点

Stack< Vector2> path = new Stack< Vector2>();

//方向

Vector2[] dirs = new Vector2 [] { Vector2.left, Vector2.right, Vector2 .up, Vector2.down ,

new Vector2(1, 1), new Vector2 (1, -1), new Vector2(-1, -1), new Vector2 (-1, 1) };

#endregion

#region 方法

void Start()

{

string datapath = Application .dataPath + "/Map/Map2.txt";

LoadMapData(datapath); //加载地图数据

CreateMap(); //根据地图数据建立地图

BFS(); //查找一条最优路径

Player = GameObject.CreatePrimitive(PrimitiveType .Sphere).transform;

Player.transform.position = GetPosition(start);

Target = GetPosition(path.Peek()); //取出最上面的值

}

void Update()

{

MoveDir = (Target - Player.position).normalized;

Player.Translate(MoveDir * Time.deltaTime);

if (Vector3 .Distance(Player.position,Target)<0.1f)

{

path.Pop(); //出栈操做（取出来栈里面就没有该元素了）若是用Peek还会存在

if (path.Count == 0)

{

this.enabled = false ;//脚本失效

}

else

{

Target = GetPosition(path.Peek());

}

void LoadMapData( string Path)

{

StreamReader sr = new StreamReader(Path);

string content = sr.ReadToEnd();

string[] Mapdata = content.Split(new string[] {"\r\n"},System.StringSplitOptions .RemoveEmptyEntries);//清除空格

rowCount = Mapdata.Length;

colCount = Mapdata[0].Trim().Length;

mapData = new byte [rowCount, colCount];

//Debug.Log(rowCount +" "+ colCount);

for (int i = 0; i < rowCount; i++)

{

for (int j = 0; j < colCount; j++)

{

mapData[i,j] = byte.Parse(Mapdata[i][j].ToString());

// Debug.Log(mapData[i,j]);

}

sr.Close();

sr.Dispose();

}

Vector3 GetPosition( int x,int y)

{

float pos_x = -rowCount * 0.5f + y;

float pos_y = -colCount * 0.5f - x;

return new Vector3(pos_x, 0, pos_y);

}

Vector3 GetPosition( Vector2 point)

{

float pos_x = -rowCount * 0.5f + point.y;

float pos_y = -colCount * 0.5f - point.x;

return new Vector3(pos_x, 1, pos_y);

}

/// <summary>

/// 获取起始点和终止点

/// </summary>

void GetStartEnd()

{

for (int i = 0; i < mapData.GetLength(0); i++)

{

for (int j = 0; j < mapData.GetLength(1); j++)

{

if (mapData[i,j]==0)

{

start.x = i;

start.y = j;

}

else if (mapData[i,j]==9)

{

end.x = i;

end.y = j;

}

int NodeSort( Node x, Node y)

{

if (x.F == y.F)

{

return 0;//表示不交换位置

}

else if (x.F > y.F)

{

return 1;//表示交换位置

}

else

{

return -1;//表示不交换位置

}

bool IsOk( Vector2 point)

{

//越界

if (point.x<0||point.y<0||point.x>=mapData.GetLength(0)||point.y>= mapData.GetLength(1))

{

return false ;

}

//障碍物

if (mapData[(int )point.x, (int)point.y]==2)

{

return false ;

}

//已访问

for (int i = 0; i < visited.Count; i++)

{

if (visited[i].x==(int )point.x&&visited[i].y==(int)point.y)

{

return false ;

}

for (int i = 0; i < list.Count; i++)

{

if (list[i].x == (int )point.x && list[i].y==(int)point.y)

{

return false ;

}

return true ;

}

//搜索最短路径

void BFS()

{

//给起始点和终止点赋值

GetStartEnd();

//建立起始节点看，进入队列

Node root = new Node(start);

list.Add(root);

//开始检索

while (list.Count > 0)

{

//先按照F值排序，后去F值最小的节点

list.Sort(NodeSort);

Node node =list[0];

list.Remove(node); //移除，以跳出循环

visited.Add(node); //添加节点到已经访问过的集合

for (int i = 0; i < dirs.Length; i++)

{

Vector2 point;

point.x = node.x + dirs[i].x;

point.y = node.y + dirs[i].y;

//判断是否合法（是否越界是不是障碍物）

if (IsOk(point))

{

Node n = new Node(point,node);

if (i > 3)

{

n.G = node.G + 14;

}

else

{

n.G = node.G + 10;

}

n.CalculateH(end);

n.CalculateF();

list.Add(n);

if (point==end)

{

Debug.Log("Find!" );

Node p = n;//取出目标点

while (p != null )

{

//原路返回将路径点放到List数组中

path.Push( new Vector2 (p.x, p.y));

p = p.Parent;

}

return;

}

void CreateMap()

{

GameObject Black = Resources .Load("Black") as GameObject ;

GameObject Red = Resources .Load("Red") as GameObject ;

GameObject Blue = Resources .Load("Blue") as GameObject ;

for (int i = 0; i < mapData.GetLength(0); i++)

{

for (int j = 0; j < mapData.GetLength(1); j++)

{

GameObject cube = null ;

switch (mapData[i, j])

{

case 1:

cube = GameObject.CreatePrimitive(PrimitiveType .Cube);

break;

case 2:

cube = GameObject.Instantiate(Black);

break;

case 9:

cube = GameObject.Instantiate(Blue);

break;

case 0:

cube = GameObject.Instantiate(Red);

break;

default:

break;

}

cube.transform.SetParent(transform);

cube.transform.position = GetPosition(i, j);

//cube.transform.position = new Vector3(i, 0, j);

cube.transform.localScale = Vector3.one* 0.95f;

}

#endregion

}

另外一个脚本：Node类

using UnityEngine;

using System.Collections;

/// <summary>

/// 节点模型类

/// </summary>

public class Node {

//坐标

public int x, y;

//记录消耗值

public int F, G, H;

//父节点

public Node Parent;

//自动估算出H值，估计值

public void CalculateH(Vector2 end)

{

this.H = (int )(10 * (Mathf.Abs(end.x - x) + Mathf.Abs(end.y - y)));

}

//自动估算F值

public void CalculateF()

{

this.F = G + H;

}

public Node( int x,int y,Node parent= null)

{

this.x = x;

this.y = y;

this.Parent = parent;

}

public Node( Vector2 point, Node parent = null)

{

this.x = (int )point.x;

this.y =(int )point.y;

this.Parent = parent;

}

二叉树

做者： 1056923207@qq.com

class Node

{

public object Data;

public Node Left;

public Node Right;

}

class Program

{

static void Main(string[] args)

{

Node node = BuildTree(7);

TraverseTree(node);

}

/// <summary>

/// 递归先序遍历二叉树

/// </summary>

public static void TraverseTree( Node node)

{

if (node==null )

{

return;

}

Console.WriteLine(node.Data);

TraverseTree(node.Left);

TraverseTree(node.Right);

}

public static Node BuildTree( int rank)

{

Node root = new Node();

root.Data = 1;

Queue<Node > queue = new Queue< Node>();

queue.Enqueue(root);

int count = 1;

while (count<rank)

{

count++;

Node child = new Node();

child.Data = count;

queue.Enqueue(child);

Node point = queue.Peek();

if (point.Left == null )

{

point.Left = child;

}

else

{

point.Right = child;

queue.Dequeue(); //出队列

}

return root;

}

遍历二叉树递归非递归

来源网址： http://blog.csdn.net/a497785609/article/details/4593224
做者： 1056923207@qq.com

递归实现先序中序后序遍历二叉树：

//先序遍历
static void PreOrder<T>(nodes<T> rootNode)
{
if(rootNode !=null )
{
Console.WriteLine(rootNode.Data);
PreOrder <T>(rootNode.LNode );
PreOrder <T>(rootNode.RNode);
}
}
//中序遍历二叉树
static void MidOrder<T>(nodes<T> rootNode)
{
if (rootNode != null)
{
MidOrder<T>(rootNode.LNode);
Console.WriteLine(rootNode.Data);
MidOrder<T>(rootNode.RNode);
}
}
//后序遍历二叉树
static void AfterOrder<T>(nodes<T> rootNode)
{
if (rootNode != null)
{
AfterOrder<T>(rootNode.LNode);
AfterOrder<T>(rootNode.RNode);
Console.WriteLine(rootNode.Data);
}
}

时间复杂度和空间复杂度

做者： 1056923207@qq.com

快速排序用来处理大量数据；

时间复杂度用o表示

一层循环：O(n)；

二层循环：O(n2);冒泡排序

快排时间复杂度：O(n*Logn)

宽度优选寻路算法（BFS）

做者： 1056923207@qq.com

using UnityEngine;

using System.Collections.Generic;

using System.Text;

using System.IO;

public class Map : MonoBehaviour

{

byte[,] data = new byte [5,5];

void Start()

{

LoadMapData();

BFSTest();

}

Queue< Vector2> queue = new Queue< Vector2>();

//存放已经访过的点

List< Vector2> visited = new List< Vector2>();

Vector2[] dirs = new Vector2 [] { Vector2.up, Vector2.right, Vector2 .down, Vector2.left };

void BFSTest()

{

//起始点

Vector2 start = Vector2 .zero;

//起始点进入未访问队列

queue.Enqueue(start);

//终止点

Vector2 end = Vector2 .one * 4;

//只要有点能够访问，就继续

while (queue.Count>0)

{

//访问一个点

Vector2 currentPoint = queue.Dequeue();

//标记该点已经访问过

visited.Add(currentPoint);

//访问先后左右

for (int i = 0; i < dirs.Length; i++)

{

Vector2 point;

point.x = currentPoint.x + dirs[i].x;

point.y = currentPoint.y + dirs[i].y;

if (IsOk(point))

{

queue.Enqueue(point);

if (point.x==end.x&&point.y==end.y)

{

Debug.Log("Find!" );

return;

}

Debug.Log("Can't Find!" );

}

//标记是否已经访问过

bool IsOk( Vector2 point)

{

if (point.x<0||point.y<0||point.x>4||point.y>4)

{

return false ;

}

if (data[(int )point.x,(int)point.y]==2) //=2表明是障碍物，不能访问返回false

{

return false ;

}

//已经访问过

foreach (Vector2 item in visited)

{

if (item.x==point.x&&item.y==point.y)//已经访问过的元素存入visited文件中

{

return false ;

}

return true ;

}

void LoadMapData()

{

string path = Application .dataPath + "/Map/Map1.txt";

//文件读写流

StreamReader sr = new StreamReader(path); //用来读写文件

//读取内容

string result = sr.ReadToEnd();

//逐行截取

string[] data = result.Split(new char[] { '\n' });

for (int i = 0; i < 5; i++)

{

for (int j = 0; j < 5; j++)

{

this.data[i, j] = byte .Parse(data[i][j].ToString());

}

编辑器扩展

做者： 1056923207@qq.com

[MenuItem("GameObject/Transform/Position")]

Static void Created()

{

}

点击Position会触发

实例：

using UnityEngine;

using System.Collections;

using UnityEditor;

using System.IO;

using System.Text;

public class MapBuilder : Editor{

public const int RowCount = 20;

public const int ColCount = 20;

[ MenuItem ( "Map/Build")]

static void BuildMap()

{

//建立地图10*10

//规则：蓝色是海洋，红色是障碍物，黄色是终止点

byte[,] map = GetMapData();

GameObject Roads = new GameObject( "Roads");

GameObject BlueCube = Resources .Load("Blue") as GameObject ;

GameObject RedCude = Resources .Load("Red") as GameObject ;

for (int i = 0; i <RowCount; i++)

{

for (int j = 0; j < ColCount; j++)

{

switch (map[i,j])

{

case 1:

GameObject RCube= Instantiate(RedCude) as GameObject;

RCube.transform.SetParent(Roads.transform);

RCube.transform.position = new Vector3 (-17.5f + i, 0, j + 17.5f );

RCube.transform.localScale = Vector3.one * 0.8f;

RCube.name = i.ToString() + "_" + j.ToString();

break;

case 2:

GameObject Bcube= Instantiate(BlueCube) as GameObject;

Bcube.transform.SetParent(Roads.transform);

Bcube.transform.position = new Vector3 (-17.5f + i, 0, j + 17.5f );

Bcube.transform.localScale = Vector3.one * 0.8f;

Bcube.name = i.ToString() + "_" + j.ToString();

break;

default:

GameObject cube= GameObject .CreatePrimitive(PrimitiveType.Cube);

cube.transform.SetParent(Roads.transform);

cube.transform.position = new Vector3 (-17.5f + i, 0, j + 17.5f);

cube.transform.localScale = Vector3.one * 0.8f;

cube.name = i.ToString() + "_" + j.ToString();

break;

}

[ MenuItem ( "Map/Test")]

static byte[,] GetMapData()

{

string path = Application .dataPath + "/Map/Map1.txt";

//文件读写流

StreamReader sr = new StreamReader(path); //读取文件而且将文件中的内容放到sr中

string result = sr.ReadToEnd(); //读取内容(从当前位置到末尾读取)

string[] data = result.Split(new char[] { '\n'});//逐行截取,生成的数据就是一行一行的

byte[,] mapdata = new byte[RowCount, ColCount]; //定义一个二维数组

Debug.Log(data.Length);

for (int i = 0; i < RowCount; i++)

{

for (int j = 0; j < ColCount; j++)

{

mapdata[i, j] = byte.Parse(data[i][j].ToString());//将字符串存入到二维数组

}

return mapdata;

}

[ MenuItem ( "Map/CreateMap")]

static void CreateMap()

{

//第一步访问txt文件

string path = Application .dataPath + "/Map/Map1.txt";

FileStream fs= File .OpenWrite(path);//能够对文件进行操做

//第二步填充内容

StringBuilder sb = new StringBuilder(); //容量可变的字符串数组

for (int i = 0; i < RowCount; i++)

{

for (int j = 0; j < ColCount; j++)

{

sb.Append( Random.Range(0, 3));//给字符串添加值

}

sb.AppendLine(); //换行

}

byte[] map = Encoding .UTF8.GetBytes(sb.ToString());//想获得什么类型的数据就Get什么

fs.Write(map, 0, map.Length); //将字符写到map中，从map的第0个空间开始，长度为length

fs.Close(); //关闭流

fs.Dispose(); //释放资源

}

FileStream类

来源网址： http://www.jb51.net/article/45696.htm
做者： 1056923207@qq.com

对流进行操做时要引用 using System.IO; 命名空间

FileStream经常使用的属性和方法：

属性：

CanRead 判断当前流是否支持读取，返回bool值，True表示能够读取

CanWrite 判断当前流是否支持写入，返回bool值，True表示能够写入

方法：

Read() 从流中读取数据，返回字节数组

Write() 将字节块（字节数组）写入该流

Seek() 设置文件读取或写入的起始位置

Flush() 清除该流缓冲区，使得全部缓冲的数据都被写入到文件中

Close() 关闭当前流并释放与之相关联的全部系统资源

文件的访问方式：（FileAccess）

包括三个枚举：

FileAccess.Read（对文件读访问）

FileAccess.Write（对文件进行写操做）

FileAccess.ReadWrite（对文件读或写操做）

文件打开模式：（FileMode）包括6个枚举

FileMode.Append 打开现有文件准备向文件追加数据，只能同FileAccess.Write一块儿使用

FileMode.Create 指示操做系统应建立新文件，若是文件已经存在，它将被覆盖

FileMode.CreateNew 指示操做系统应建立新文件，若是文件已经存在，将引起异常

FileMode.Open 指示操做系统应打开现有文件，打开的能力取决于FileAccess所指定的值

FileMode.OpenOrCreate 指示操做系统应打开文件，若是文件不存在则建立新文件

FileMode.Truncate 指示操做系统应打开现有文件，而且清空文件内容

文件共享方式：（FileShare）

FileShare方式是为了不几个程序同时访问同一个文件会形成异常的状况。

文件共享方式包括四个：

FileShare.None 谢绝共享当前文件

FileShare.Read 充许别的程序读取当前文件

FileShare.Write 充许别的程序写当前文件

FileShare.ReadWrite 充许别的程序读写当前文件

使用FileStream类建立文件流对象：

FileStream（String 文件路径，FileMode 文件打开模式）

FileStream（String 文件路径，FileMode 文件打开模式，FileAccess 文件访问方式）

FileStream（String 文件路径，FileMode 文件打开模式，FileAccess 文件访问方式，FileShare 文件共享方式）

例：

//在C盘建立a.txt文件，使用fs流对象对文件进行操做，fs的工做模式是新建（FileMode.Create）

FileStream fs=new FileStream(@"c:\a.txt",FileMode.Create);

//在C盘建立a.txt文件，使用fs流对象对文件进行操做，fs工做模式是新建（FileMode.Create）文件的访问模式是写入（Fileaccess.Write）

FileStream fs=new FileStream(@"c:\a.txt",FileMode.Create,FileAccess.Write);

//在C盘建立a.txt文件，使用fs流对象对文件进行操做，fs工做模式是新建（FileMode.Create）文件的访问模式是写入（FileAccess.Write）文件的共享模式是谢绝共享（FileShare.None）

FileStream fs=new FileStream(@"c:\a.txt",FileMode.Create,FileAccess.Write,FileShare.None);

使用File类来建立对象：(经常使用)

自定义打开文件的方式：File.Open(String，FileMode);

打开文件进行读取： File.OpenRead(String);

打开文件进行写入： File.OpenWrite(String);

示例以下：

//在C盘新建123.txt文件，使用流对象fs对文件进行操做，fs能够行文件内容追加操做FileMode.Append

FileStream fs=File.Open(@"c:\123.txt",FileMode.Append);

//在C盘新建123.txt文件，使用流对象fs对文件进行操做，fs能够进行读文件File.OpenRead()

FileStream fs=File.OpenRead(@"c:\123.txt");

//在C盘新建123.txt文件，使用流对象fs对文件进行操做，fs能够进行写操做File.OpenWrite()

FileStream fs=File.OpenWrite(@"c:\123.txt");

使用File例：

对文件进行读操做：

//新建fs流对象对象产生的路径是textbox1.text的值，文件的模式是FileMode.OpenOrCreate(可读可写)

using (FileStream fs = File.Open(textBox1.Text, FileMode.OpenOrCreate))
{

//新建字节型数组，数组的长度是fs文件对象的长度（后面用于存放文件）
byte[] bt=new byte[fs.Length];

//经过fs对象的Read方法bt获得了fs对象流中的内容
fs.Read(bt,0,bt.Length);

//关闭fs流对象
fs.Close();

//将bt字节型数组中的数据由Encoding.Default.GetString(bt)方法取出，交给textbox2.text
textBox2.Text = System.Text.Encoding.Default.GetString(bt);
}

对文件进行写入操做：

//新建fs流对象，对象操做的文件路径在textbox1.text中，fs的操做模式是FileMode.Create

using (FileStream fs = File.Open(textBox1.Text, FileMode.Create))
{

//新建字节型数组bt对象，bt对象获得了textbox2.text的Encoding的值
byte[] bt = System.Text.Encoding.Default.GetBytes(textBox2.Text);

//将bt字节型数组对象的值写入到fs流对象中（文件）
fs.Write(bt,0,bt.Length);

//关闭流对象
fs.Close();
}

注：

对文件的读写操多无论代码有多少，无非就是下面的三步：

1.建立文件读写流对象

2.对文件进行读写

3.关闭文件流

摄像头相关知识

来源网址： http://forum.china.unity3d.com/thread-622-1-1.html
做者： 1056923207@qq.com

using UnityEngine;

using System.Collections;

using UnityEngine.UI;

public class ExternalCamera : MonoBehaviour

{

public static ExternalCamera _instance;

public WebCamTexture cameraTexture;//摄像头照到的图片

private Image img;

void Awake()

{

_instance = this;

img = GetComponentInChildren< Image>();//获取子物体的组件

}

void Start()

{

StartCoroutine(CallCamera()); //开启携程

}

IEnumerator CallCamera()

{

yield return Application.RequestUserAuthorization( UserAuthorization.WebCam);//获取yoghurt摄像头权限

if (Application .HasUserAuthorization(UserAuthorization.WebCam)) //若是拥有摄像头权限

{

if (cameraTexture != null )//纹理存在

cameraTexture.Stop(); //

WebCamDevice[] device = WebCamTexture .devices;//将手机的两个摄像头存到数组

//找出后置摄像头而且记录下它的名字

int index = 0;

for (int i = 0; i < device.Length; i++)

{

if (!device[i].isFrontFacing)//若是是后置摄像头

{

index = i;

break;

}

string deviceName = device[index].name;//获取后置摄像头的名字

cameraTexture = new WebCamTexture (deviceName);//纹理使用后置摄像头的额纹理

img.canvasRenderer.SetTexture(cameraTexture); //图片的纹理

cameraTexture.Play(); //启用该纹理

}

WebCamTexture（摄像机开发须要用到的类）

[复制连接]

Unity_枫叶

114 主题	504 帖子	5545 贡献

版主

积分: 5545

发消息

电梯直达

楼主

发表于 2014-9-26 07:08:49 | 只看该做者

WebCamTexture类

命名空间: UnityEngine
继承于: Texture

Description 说明
WebCam Textures are textures onto which the live video input is rendered.
摄像头纹理是纹理到其上的实时视频输入呈现。

Static Variables
静态变量
devices    返回可用的设备列表。

Variables
变量
deviceName       将其设置为指定要使用的设备的名称。
didUpdateThisFrame 检查是否为视频缓冲后的最后一帧变化
isPlaying          判断相机是否在播放
isReadable          判断WebCamTexture是否可读。（仅适用于iOS的）
requestedFPS       设置相机装置的请求的帧速率（每秒的帧数）
requestedHeight    设置相机装置的要求高度
requestedWidth       设置相机装置的要求宽度
videoRotationAngle    返回一个顺时针方向的角度，它可用于旋转的多边形，以便相机内容显示在正确的方位
videoVerticallyMirrored  纹理图像是否垂直翻转

Constructors
构造函数
WebCamTexture  建立WebCamTexture

Functions
功能
GetPixel    获取位于坐标（x，y）的像素颜色
GetPixels       获得的像素颜色块
GetPixels32    获取原始格式的像素数据
MarkNonReadable 使WebCamTexture为不可读（无GetPixel*功能将可用（仅IOS））。
Pause    暂停相机功能
play          启用
stop          中止

Inherited members
继承的成员

Variables
变量

hideFlags    若是对象被隐藏，保存在场景或修改用户
name       对象的名称。
anisoLevel    纹理的各向异性过滤级别
filterMode    纹理过滤模式
height       像素纹理的高度（只读）
mipMapBias    MIP映射纹理偏见
width       像素纹理的宽度（只读）
wrapMode    换行模式的纹理（重复或钳.

Functions
功能

GetInstanceID       返回该对象的实例ID
ToString       返回游戏对象的名称
GetNativeTextureID    检索本地（'硬件'）处理到纹理
GetNativeTexturePtr    检索本机（'硬件'）处理到纹理.

Static Functions
静态函数
Destroy       删除一个游戏物体，组件
DestroyImmediate    当即销毁对象
DontDestroyOnLoad    在加载装载一个新的场景时，使该对象的目标不会被自动销毁FindObjectOfType    返回第一个加载的对象的类型。
FindObjectsOfType    返回全部加载对象的类型列表。
Instantiate       实例化一个对象
SetGlobalAnisotropicFilteringLimits    设置各向异性的限制

Operators
操做运算符
bool       真假
operator !=    不等于
operator ==    等于

扫雷游戏

做者： 1056923207@qq.com

using UnityEngine;

using System.Collections;

using UnityEngine.EventSystems;

using UnityEngine.UI;

/// <summary>

/// 格子类

/// </summary>

public class Grid

{

public bool IsLei;//是不是雷

public bool IsClicked;//是否点击了

public byte Count;//周围有几个雷

}

public class Map : MonoBehaviour, IPointerClickHandler//继承点击事件的接口函数

{

#region 常量

public const int RowCount = 10;//行数

public const int ColCount = 10;//列数

#endregion

#region 字段

private Grid[,] grids = new Grid[RowCount, ColCount]; //存储格子的数组

private GameObject[,] tiles = new GameObject[RowCount, ColCount]; //存储预设体实例化对象的的数组

private Vector2[] dirs = new Vector2[] { Vector2.up, Vector2 .down, Vector2.left, Vector2.right, new Vector2(-1, 1), new Vector2(-1, -1), new Vector2 (1, 1), new Vector2(1, -1) }; //格子周围八个方块

[ SerializeField ]

private Transform gridContainer;

[ SerializeField ]

private GameObject gridPrefab;

#endregion

#region 方法

//初始化游戏

public void StartGame()

{

for (int i = 0; i < RowCount; i++)

{

for (int j = 0; j < ColCount; j++)

{

//注意两个数组的坐标是一致的

//下面两句主要是给格子初始化，那些有雷，那些没有雷

grids[i, j] = new Grid ();//初始化格子

grids[i, j].IsLei = Random.Range(1, 11) > 2 ? false : true;//是不是雷

GameObject grid = (GameObject )Instantiate(gridPrefab);//建立格子

grid.transform.SetParent(gridContainer); //放到格子中

grid.name = i.ToString() + "_" + j.ToString();//格子的名字就是xy坐标中间加"_";便于后面运算

tiles[i, j] = grid; //将实例化出来的button放到数组中

}

/// <summary>

/// 格子点击

/// </summary>

/// <param name="x"> The x coordinate.</param>

/// <param name="y"> The y coordinate.</param>

public void GridClick(int x, int y)

{

if (!grids[x, y].IsClicked)

{ //若是格子没有点击过

grids[x, y].IsClicked = true;

if (grids[x, y].IsLei)

{

print( "输了");

return;

}

for (int i = 0; i < dirs.Length; i++)

{

int temp_x = x + (int )dirs[i].x;

int temp_y = y + (int )dirs[i].y;

//判断是否越界

if (temp_x >= 0 && temp_x < RowCount && temp_y >= 0 && temp_y < ColCount)

{

if (grids[temp_x, temp_y].IsLei)

{

grids[x, y].Count++; //当前格子周围的雷数+1

}

tiles[x, y].transform.GetChild(0).gameObject.SetActive( true);//把Text脚本激活用来显示雷数

tiles[x, y].GetComponent< Image>().color = Color .gray;//改变颜色

if (grids[x, y].Count > 0)

{

// Debug.Log("Click");

tiles[x, y].GetComponentInChildren< Text>().text = grids[x, y].Count.ToString();

}

else

{

DiGui(x, y);

}

/// <summary>

/// 递归

/// </summary>

/// <param name="x"> The x coordinate.</param>

/// <param name="y"> The y coordinate.</param>

public void DiGui(int x, int y)

{

for (int i = 0; i < dirs.Length; i++)

{

int temp_x = x + (int )dirs[i].x;

int temp_y = y + (int )dirs[i].y;

//判断是否越界

if (temp_x > 0 && temp_x < RowCount && temp_y > 0 && temp_y < ColCount)

{

GridClick(temp_x, temp_y);

}

#endregion

void Start()

{

StartGame();

}

//鼠标点击格子触发函数

public void OnPointerClick(PointerEventData eventData)

{

// Debug.Log("LLL");

GameObject enter = eventData.pointerEnter;

//若是是格子

Debug.Log(enter.name);

if (enter.name.Contains("_" ))

{

int x = int .Parse(enter.name.Split('_')[0]);

int y = int .Parse(enter.name.Split('_')[1]);

GridClick(x, y);

Debug.Log("LLL" );

}

递归

做者： 1056923207@qq.com

先调用和先打印书序反告终果也会反；

屏幕坐标转世界坐标（好用）

来源网址： http://www.tuicool.com/articles/Rjiqeq
做者： 1056923207@qq.com

using UnityEngine;

using System.Collections;

public class CubeTest : MonoBehaviour {

void Update () {

Vector3 Screen_point = Input .mousePosition;

Screen_point += new Vector3 (0, 0, transform.position.z - Camera.main.transform.position.z);

transform.position = Camera.main.ScreenToWorldPoint(Screen_point);

// Debug.Log(transform.position);

}

摄像机坐标系：0到1

屏幕坐标是：

unity3d 屏幕坐标、鼠标位置、视口坐标和绘制GUI时使用的坐标

时间 2012-12-30 19:58:00 博客园-原创精华区

原文 http://www.cnblogs.com/ruiying/archive/2012/12/30/unity3d_coordinate.html

主题 Unity3D

unity3d中的屏幕坐标系是以屏幕左下角为（0,0）点右上角为（Screen.Width,Screen.Height)

鼠标位置坐标与屏幕坐标系一致

视口坐标是以摄像机为准以屏幕的左下角为（0,0）点右上角为（1,1）点

绘制GUI界面时使用的坐标是以屏幕的左上角为（0，0）点右下角为（Screen.width,Screen,Height)

常常会用到某个物体的世界坐标到屏幕坐标的转化而后再屏幕上绘制出这个物体的表明性图片

是这样作的

一、Vector3 ScreenPos=Camera.WorldToScreenPoint(trans.Position);

二、GUIPos=new Vector3(ScreenPos.x,Screen.height-ScreenPos.y,0);

而后按照这个坐标绘制图片就能够了

网络相关知识

做者： 1056923207@qq.com

1：引入命名空间 Using system.Net和using System.Net.Sockets;

2:服务器代码；

Socket mConn = new Socket(AddressFamily.InterNetWork, SocketType.Stream, ProtocoType.Tcp);

int Port = 7777;

IPEndPoint endpoint = new IPEndPoint(IPAddress.Any, Port);

mConn.Bind(endpoint);

mConn.Listen(10);

a:同步接收客户端的代码（在当前客户端没有链接以前，不能进行其余操做只能等着）

while (true)

{

Socket client = mConn.Accept();

Console.WriteLine("有客户端链接");

}

b:异步接收客户端代码

mConn.BeginAccept(AcceptClient,mConn)

Console.ReadLine();//（这个方法也是至关于同步方法）保持服务器一直开着，

private static void AcceptClient(IAsyncResult ar)

{

Console.WriteLine("有客户端链接");

Socket server= ar。AsyncState as Socket;

Socket client = server.EndAccept(ar);

Console.WriteLine(client.RemoteEndPoint);//打印链接的客户端的IP地址

//再次开启异步接收

server.BeginAccept（AcceptCllient,server）;

}

客户端代码：

using UnityEngine;

using System.Collections;

using UnityEngine.Networking;

using System.Net;

using System.Net.Sockets;

public static class MyNetWork

{

private static Socket mConn;

/// <summary>

/// 开启服务器

/// </summary>

// public static void StartServer(int port = 7777)

// {

// mConn = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);//Tcp可靠，Udp不可靠

//Http Https Http不加密传输速度快不安全 HTTPS加密

// IPEndPoint endpoinnt = new IPEndPoint(IPAddress.Any, port);

// mConn.Bind(endpoinnt);//看似器服务器以前必须绑定IP和端口

// mConn.Listen(11);

// }

/// <summary>

/// 开启客户端

/// </summary>

/// <param name="endPoint"></param>

public static void StartClient(IPEndPoint endPoint)

{

mConn = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType .Tcp);

mConn.Connect(endPoint);

Debug.Log(mConn.Connected);

}

3：客户端调用方法

using UnityEngine;

using System.Collections;

using System.Net.Sockets;

using System.Net;

public class Testtt : MonoBehaviour {

void Start () {

// MyNetWork.StartServer();

//IPAddress ipaddress = IPAddress.Parse("172.18.21.139");

IPAddress ipaddress = IPAddress .Parse("127.0.0.1");

int port = 7777;

IPEndPoint endpoint = new IPEndPoint(ipaddress,port);

MyNetWork.StartClient(endpoint);

Debug.Log("连接服务器成功" );

}

异步加载场景

做者： 1056923207@qq.com

1：第一个场景Button上挂载的脚本要加载滴二哥场景

using UnityEngine;

using System.Collections;

using UnityEngine.UI;

public class Test : MonoBehaviour {

void Start()

{

GetComponent< Button>().onClick.AddListener(LoadScene);

}

public void LoadScene()

{

LoadingManager.Instance.LoadScene("2" );

}

2：单例类加载管理器

using UnityEngine;

using System.Collections;

using UnityEngine.SceneManagement;

public class LoadingManager {

#region 属性

public static LoadingManager instace;

private AsyncOperation mAsync;

private string scenename;

public string Name

{

get

{

return scenename;

}

public static LoadingManager Instance

{

get {

if (instace==null )

{

instace = new LoadingManager ();

}

return instace;

}

#endregion

#region 方法

public void LoadScene(string SceneName)

{

SceneManager.LoadScene("Login" );

//（同步方法）场景名字加载场景

//mAsync = SceneManager.LoadSceneAsync(SceneName);

// mAsync.allowSceneActivation =false;

this.scenename = SceneName;

}

3：Login场景中的脚本

using UnityEngine;

using System.Collections;

using UnityEngine.SceneManagement;

using UnityEngine.UI;

public class Loading : MonoBehaviour {

private AsyncOperation mAsync=null ;//异步加载场景的返回值

private string targetScene;

private int mProgress = 0;//表示当前进度

private int mCurrent = 0;//表示实际进度

private Slider mSlider;//进度条

void Awake()

{

mSlider = GetComponent< Slider>();

}

void Start ()

{

targetScene = LoadingManager.Instance.Name;

mAsync = SceneManager.LoadSceneAsync(targetScene);

mAsync.allowSceneActivation = false;

//print(LoadingManager.Instance.Name);

}

void Update()

{

mCurrent = System. Convert.ToInt32(mAsync.progress * 100);

if (mCurrent==90)

{

mProgress = 100;

}

if (mProgress == 100)//表示进度完成

{

mAsync.allowSceneActivation = true;

}

else

{

if (mProgress<mCurrent)

{

mProgress++;

mSlider.value = mProgress / 10000f;

}

print(mAsync.progress);

}

#endregion

}

SDK/Json

做者： 1056923207@qq.com

1：分享功能：

第一个脚本：取到Json字符串；

using UnityEngine;

using System.Collections;

using System.Net;

using System.IO;

using LitJson;

public class HttpUtility

{

/// <summary>

/// Get请求，获取内容

/// </summary>

/// <param name="url"> 网址</param>

public static string GetHttpText(string url)

{

//建立一个Http请求对象

HttpWebRequest request = HttpWebRequest .Create(url) as HttpWebRequest;

//获取相应对象

WebResponse response = request.GetResponse();

//获取相应的内容

Stream steam = response.GetResponseStream();

StreamReader sr = new StreamReader(steam);

string result = sr.ReadToEnd();

sr.Close();

sr.Dispose();

return result;

//WWW www = new WWW(url);

//while (!www.isDone)

//{

//}

//string result = www.text;

//return result;

}

//public static T GetHttpText<T>(string url) where T:class

//{

// //建立一个Http请求对象

// HttpWebRequest request = HttpWebRequest.Create(url) as HttpWebRequest;

// //获取相应对象

// WebResponse response = request.GetResponse();

// //获取相应的内容

// Stream steam = response.GetResponseStream();

// StreamReader sr = new StreamReader(steam);

// T result = sr.ReadToEnd() as T;

// sr.Close();

// sr.Dispose();

// return result;

// //WWW www = new WWW(url);

// //while (!www.isDone)

// //{

// //}

// //string result = www.text;

// //return result;

//}

//public static Weatherdata SetWeatherData(string jsonData)

//{

// try

// {

// return JsonMapper.ToObject<Weatherdata>(jsonData);

// }

// catch (System.Exception ex)

// {

// UnityEngine.Debug.Log(ex.ToString());

// return null;

// }

//}

}

第二个脚本：根据Json字符串的格式定义一个接收Json转换成Object对象的数据结构

using UnityEngine;

using System.Collections;

[System. Serializable ]

public class Weather

{

public string retCode; // 返回码

public string msg; // 返回说明

public WeatherData [] result;

}

[System. Serializable ]

public class WeatherData

{

public string airCondition; // 空气质量

public string city; // 城市

public string coldIndex; // 感冒指数

public string updateTime; // 更新时间

public string date; // 日期

public string distrct; // 区县

public string dressingIndex; // 穿衣指数

public string exerciseIndex; // 运动指数

public Future [] future;

public string humidity; // 湿度

public string pollutionIndex; // 空气质量指数

public string province; // 省份

public string sunset; // 日落时间

public string sunrise; // 日出时间

public string temperature; // 温度

public string time; // 时间

public string washIndex; // 洗车指数

public string weather; // 天气

public string week; // 星期

public string wind; // 风向

}

[System. Serializable ]

public class Future

{

public string date; // 日期

public string dayTime; // 白每天气

public string night; // 晚上天气

public string temperature; // 温度

public string week; // 星期

public string wind; // 风向

}

第三个脚本：测试脚本，将前两个脚本连接起来

using UnityEngine;

using System.Collections;

using LitJson;

public class Testt : MonoBehaviour {

// Use this for initialization

void Start () {

string result = HttpUtility .GetHttpText(Const.WeatherApiURL);

JsonData nn = JsonMapper .ToObject(result);

Weather kk = JsonMapper .ToObject<Weather>(result);

Debug.Log(kk.result[0].wind);

// Debug.Log(mm.result[0].future[0].date);

// Debug.Log(nn[0]);

//Debug.Log();

}

// Update is called once per frame

void Update ()

{

}

马帅的摄像机

做者： 1056923207@qq.com

DataBaseTool

做者： 1056923207@qq.com

/*******************

********************/

using UnityEngine;

using System.Collections;

using System.Collections.Generic;

using Mono.Data.Sqlite;

/// <summary>

/// 数据库操做的单例类

/// </summary>

public class DataBaseTool

{

private static DataBaseTool _instance;//单例的静态引用

public static DataBaseTool Instance

{

get

{

if (_instance == null )

{

_instance = new DataBaseTool ();

}

return _instance;

}

private string databaseName = "IslandDatabase.sqlite" ;//数据库名称

//数据库连接对象

private SqliteConnection sqlConnection = null ;

//数据结果

private SqliteDataReader sqlDataReader = null ;

/// <summary>

/// 初始化数据库相关对象

/// </summary>

private DataBaseTool()

{

//数据库连接地址

string path = "Data Source=" + Application.streamingAssetsPath + "/" + databaseName;

if (sqlConnection == null )

{

try

{

sqlConnection = new SqliteConnection (path);

}

catch (SqliteException e)

{

Debug.Log("建立数据库连接失败..." );

Debug.Log(e.ToString());

}

/// <summary>

/// 打开数据库连接

/// </summary>

private void OpenConnection()

{

if (sqlConnection != null )

{

try

{

sqlConnection.Open();

}

catch (SqliteException e)

{

Debug.Log("打开数据库连接失败..." );

Debug.Log(e.ToString());

}

else {

Debug.Log("打开数据库连接失败..." );

}

/// <summary>

/// 关闭数据库连接

/// </summary>

private void CloseConnection()

{

if (sqlConnection != null )

{

try

{

sqlConnection.Close();

}

catch (SqliteException e)

{

Debug.Log("关闭数据库连接失败..." );

Debug.Log(e.ToString());

}

else {

Debug.Log("关闭数据库连接失败..." );

}

/// <summary>

/// 执行增、删、改数据库操做

/// </summary>

public void ExcuteSql(string sqlStr)

{

OpenConnection();

SqliteCommand sqlCommand = sqlConnection.CreateCommand();

if (sqlCommand != null )

{

sqlCommand.CommandText = sqlStr;

int result = sqlCommand.ExecuteNonQuery();

}

else {

Debug.Log("执行数据库命令失败..." );

}

CloseConnection();

}

/// <summary>

/// 得到一行数据的方法

/// </summary>

public Dictionary<string , object> ExcuteOneClumeResult( string sql)

{

OpenConnection();

Dictionary<string , object> result = new Dictionary <string, object>();

SqliteCommand sqlCommand = sqlConnection.CreateCommand();

if (sqlCommand != null )

{

sqlCommand.CommandText = sql;

sqlDataReader = sqlCommand.ExecuteReader();

while (sqlDataReader.Read())

{

for (int i = 0; i < sqlDataReader.FieldCount; i++)

{

result.Add(sqlDataReader.GetName(i), sqlDataReader.GetValue(i));

}

break;

}

else {

result = null;

}

CloseConnection();

return result;

}

/// <summary>

/// 返回查询的全部数据（多列）

/// </summary>

/// <returns>The all rresult.</returns>

public List<Dictionary <string, object>> ExcuteAllRresult(string sql)

{

OpenConnection();

//存放查询的全部结果集

List<Dictionary <string, object>> results

= new List <Dictionary< string, object >>();

SqliteCommand sqlCommand = sqlConnection.CreateCommand();

if (sqlCommand != null )

{

//打包sql语句

sqlCommand.CommandText = sql;

//执行sql语句并得到查询结果

sqlDataReader = sqlCommand.ExecuteReader();

//逐行解析数据

while (sqlDataReader.Read())

{

//单行数据的全部内容

Dictionary<string , object> oneclum = new Dictionary <string, object>();

for (int i = 0; i < sqlDataReader.FieldCount; i++)

{

oneclum.Add(sqlDataReader.GetName(i), sqlDataReader.GetValue(i));

}

results.Add(oneclum);

}

CloseConnection();

return results;

}

泛型单例父类

做者： 1056923207@qq.com

using UnityEngine;

using System.Collections;

public abstract class MonoSingle< T> : MonoBehaviour where T :MonoBehaviour

{

private static T instance;

public static T Instance

{

get

{

return instance;

}

public virtual void Awake()

{

instance = this as T;

}

这个单例父类的做用就是当有多个类须要写成单例是，不用重复写单例；

@其余的类继承这个类就能够当作单例使用，例以下例：（注意继承的方式）

using UnityEngine;

using System.Collections;

/// <summary>

/// 声音控制器,单例类

/// </summary>

public class SoundController : MonoSingle<SoundController >

{

AudioSource m_bgMusic;

public override void Awake()

{

base.Awake();//继承基类的方法

m_bgMusic = gameObject.AddComponent< AudioSource>();//获取AudioSource组件

m_bgMusic.loop = true;//循环播放

m_bgMusic.playOnAwake = false;

}

//播放背景音乐

public void PlayBG(string bgName)

{

string currentBgName = string .Empty;//定义一个空的string类型变量

if (m_bgMusic !=null )//若是存在AudioSoruce组件

{

currentBgName = m_bgMusic.name; //获取组件的名字

}

if (bgName == currentBgName)

{

return;//若是传进来的生意与原来的声音同样就不用从新开始播放啦

Debug.Log("------" );

}

AudioClip clip = Resources .Load<AudioClip>(bgName); //加载声音资源

if (clip!=null )//若是存在声音资源

{

m_bgMusic.clip = clip; //给声音组件赋值

m_bgMusic.Play(); //播放声音组件

}

/// <summary>

/// 播放特效音乐

/// </summary>

/// <param name="Effectname"></param>

public void PlayEffect(string Effectname,float volume = 1f)

{

AudioClip clip = Resources .Load<AudioClip>(Effectname); //加载声音资源

if (clip!=null )//若是声音资源不为空

{

AudioSource.PlayClipAtPoint(clip, transform.position);

}

关于AudioSource和AudioClip的使用

做者： 1056923207@qq.com

1：实例一个AudioSource的对象： AudioSource m_bgMusic;

2：实例化一个AudioClip的对象，而且赋一个值： AudioClip clip = Resources .Load<AudioClip>(bgName);

3： m_bgMusic.clip = clip; //给声音组件赋值

4： m_bgMusic.Play(); //播放声音组件

using UnityEngine;

using System.Collections;

/// <summary>

/// 声音控制器,单例类

/// </summary>

public class SoundController : MonoSingle<SoundController >

{

AudioSource m_bgMusic;

public override void Awake()

{

base.Awake();//继承基类的方法

m_bgMusic = gameObject.AddComponent< AudioSource>();//获取AudioSource组件

m_bgMusic.loop = true;//循环播放

m_bgMusic.playOnAwake = false;

}

//播放背景音乐

public void PlayBG(string bgName)

{

string currentBgName = string .Empty;//定义一个空的string类型变量

if (m_bgMusic !=null )//若是存在AudioSoruce组件

{

currentBgName = m_bgMusic.name; //获取组件的名字

}

if (bgName == currentBgName)

{

return;//若是传进来的生意与原来的声音同样就不用从新开始播放啦

Debug.Log("------" );

}

AudioClip clip = Resources .Load<AudioClip>(bgName); //加载声音资源

if (clip!=null )//若是存在声音资源

{

m_bgMusic.clip = clip; //给声音组件赋值

m_bgMusic.Play(); //播放声音组件

}

/// <summary>

/// 播放特效音乐

/// </summary>

/// <param name="Effectname"></param>

public void PlayEffect(string Effectname,float volume = 1f)

{

AudioClip clip = Resources .Load<AudioClip>(Effectname); //加载声音资源

if (clip!=null )//若是声音资源不为空

{

AudioSource.PlayClipAtPoint(clip, transform.position);

}

类能够继承结构体不能继承；

做者： 1056923207@qq.com

类能够继承结构体不能继承；

接口和抽象类的区别：接口不能被实现，只能声明

动画插件Itween和dotween

做者： 1056923207@qq.com

本身定义的MyTween脚本：

using UnityEngine;

using System.Collections;

public class MyTween : MonoBehaviour

{

#region 字段

public Vector3 position;

public float time, delay;

public LoopType looptype;

public EaseType easetype;

#endregion

#region 枚举

public enum LoopType

{

Once,

Loop,

Pingppang

}

public enum EaseType

{

Liner,

Spring

}

#endregion

#region 注册方法

public static void MoveTo(GameObject go, Hashtable args)

{

MyTween tween = go.AddComponent<MyTween >();

if (args.Contains("position" ))

{

tween.position =( Vector3)args["position" ];

}

if (args.Contains("time" ))

{

tween.time = ( float)args["time" ];

}

if (args.Contains("delay" ))

{

tween.delay = ( float)args["delay" ];

}

if (args.ContainsKey("loopType" ))

{

tween.looptype = ( LoopType)System.Enum .Parse(typeof( LoopType), args["loopType" ].ToString());//字符串强转成枚举得方法

}

#endregion

#region 方法

private float timer;

void MoveTo()

{

timer += Time.deltaTime;//计时

if (timer>delay)

{

//若是是平滑移动，保持起始点和终点不变只有时间边

//若是是先快后慢，保证时间和终点不变，起始点变化

//Lerp公式：from +(to -from)*time,time= [0,1]

transform.position = Vector3.Lerp(transform.position, position, (timer - delay)/time);

}

if (timer>delay+time)//一段时间后销毁本脚本

{

if (looptype==LoopType .Once)//若是循环的类型为单次

{

Destroy( this);

}

#endregion

void Update()

{

Invoke( "MoveTo",0f);

}

调用MyItween的Test脚本：

using UnityEngine;

using System.Collections;

public class Test : MonoBehaviour {

Hashtable har;

// Use this for initialization

void Start () {

//是一个集合(哈希表)，能够存储任意类型

har = new Hashtable();

har.Add( "amount", Vector3 .one*180);

har.Add( "position", Vector3 .one * 3);

har.Add( "time", 5f);

// har.Add("Time", 3f);

har.Add( "delay", 1f);

har.Add( "loopType", MyTween .LoopType.Once);

har.Add( "easeType", MyTween .EaseType.Liner);

har.Add( "rotation", Vector3 .up * 180);

// iTween.RotateTo(gameObject, har);

//iTween.ShakePosition(gameObject, har);

//iTween.ShakeRotation(gameObject,har);

MyTween.MoveTo(gameObject, har);

}

// Update is called once per frame

void Update () {

// iTween.MoveUpdate(gameObject, har);

}

调用的Test脚本

using UnityEngine;

using System.Collections;

public class Test : MonoBehaviour {

Hashtable har;

// Use this for initialization

void Start ()

{

//是一个集合(哈希表)，能够存储任意类型

har = new Hashtable ();

har.Add( "amount", Vector3 .one*180);

har.Add( "position", Vector3 .one * 3);

har.Add( "time", 5f);

// har.Add("Time", 3f);

har.Add( "delay", 1f);

har.Add( "loopType", MyTween .LoopType.Once);

har.Add( "easeType", MyTween .EaseType.Liner);

har.Add( "rotation", Vector3 .up * 180);

// iTween.RotateTo(gameObject, har);

//iTween.ShakePosition(gameObject, har);

//iTween.ShakeRotation(gameObject,har);

MyTween.MoveTo(gameObject, har);//静态方法经过类名点调用；非静态方法经过对象调用

}

// Update is called once per frame

void Update () {

// iTween.MoveUpdate(gameObject, har);

}

关于技能的释放

做者： 1056923207@qq.com

1;从数据库英雄表取出数据用逗号分割，存入string数组；

this .skillsname = heroData[ "Skills"].ToString().Split(',' );

2：将这些string类型的转成int类型，存入整形数组（容量大小与string类型的数组相同）；

3：根据这些id在数据结构里面初始化技能；mskills存储的是技能数据结构，由于这个脚本是在aunit里面 aunit在人物身上，因此有aunit脚本的就能够调用技能数据。在UIController里面添加对应英雄的aunit脚本就能够调用技能数据；

this .skillsname = heroData[ "Skills" ].ToString().Split(',');

mSkillsId = new int [skillsname.Length];

this.mSkills = new SkillData[skillsname.Length];

//初始化技能数据

for (int i = 0; i < skillsname.Length; i++)

{

mSkillsId[i] = int.Parse(skillsname[i]);

this.mSkills[i].InitSkillData(this .mSkillsId[i]);

}

跨脚本调用方法

做者： 1056923207@qq.com

若是方法是静态的就经过类名（脚本名字）调用；

若是方不是静态的：就经过实例化对象而后点的方法调用（方法必须是公有的才能点出来）

改变鼠标指针单例脚本，在其余脚本中能够调用

做者： 1056923207@qq.com

using UnityEngine;

using System.Collections;

using UnityEngine.UI;

public class NYBTest : MonoBehaviour

{

public static NYBTest _instance;

public Texture2D normal;

public Texture2D npc;

public Texture2D attack;

public Texture2D locktarget;

public Texture2D pick;

private Vector2 hotspot = Vector2 .zero;

private CursorMode mode = CursorMode .Auto;

void Start()

{

_instance = this;

}

public void SetNormal()

{

Cursor.SetCursor(normal, hotspot, mode);

}

public void NPC()

{

Cursor.SetCursor(npc, hotspot, mode);

}

xml写的Transform和Json

做者： 1056923207@qq.com

Json：

Json写的transform：

委托

做者： 1056923207@qq.com

委托是讲方法做为参数进行传递方法既能够是静态方法，又能够是实例方法

委托的声明圆形以下：

delegate <函数返回类型><委托名>(<函数参数>)

委托主要用来实现回调：

委托是的使用步骤

属性，数据类型，方法参数

做者： 574096324@qq.com

属性

class Car

{

private string brand;

public double price;

//get,set也称为属性

public string GetBrand()

{

return brand;

}

public void SetBrand(string c)

{

brand = c;

}

public double GetPrice()

{

return price;

}

public void SetPrice(double p)

{

price = p;

}

属性简写

public double Price

{

get;

set;

}

数据类型

数据在内存中的空间分配

*栈区：值类型定义的变量压栈，出栈

*堆区：数组，对象

常量区：常量

静态区：Main前面static，字段用static修饰在静态区

代码区：方法

方法参数

新版网络

做者： 1056923207@qq.com

1;端口：每一个端口对应一个服务

2：新版网络的API：

Unity 网络服务器：NetWorkServer

3dmax

做者： 1056923207@qq.com

3dmax

Leapmotion虚拟现实

做者： 1056923207@qq.com

1.下载Leapmotion SDK（ https://developer.leapmotion.com/v2）

2.拖入到场景中

3.找到预设体的HandController拖到场景中缩放调为10

4.运行游戏笔记本有摄像头能够实现手部识别

5.核心的脚本就是HandController

Socket

做者： 1056923207@qq.com

步骤：服务器建立一个套接字。2：绑定一个端口。3：监听 lister4：accept

两种协议：1.TCP(可靠的协议，例如qq)2.UDP（看视频）

Unity网络基本知识

做者： 1056923207@qq.com

1：网络通讯协议

2：IP地址

、

NetWork类建立爱你服务器和客户端：

Unity高通AR解析步骤

来源网址： http://www.jianshu.com/p/bb9aa8bf2225
做者： 1056923207@qq.com

简

注册登陆

简首页专题下载手机应用

简书

交流故事，沟通想法

iOS· Android

显示模式登陆

下载简书移动应用

注册登陆

添加关注

做者欣羽馨予2015.11.02 17:05*

写了16388字，被87人关注，得到了69个喜欢

Unity高通AR解析（一）

字数852阅读2874评论7喜欢12

收藏文章分享

前言

在这个生活方式都突飞猛进的年代，任何的新技术产生都不足为奇，固然本篇所讲的AR（加强现实技术）也并非最新的技术了，目前市面上已经不少AR方面的硬件设备，固然AR技术也日渐成熟。目前，Unity对AR的支持，只有一家——高通，原来还有一家Metaio被Apple收购要如今杳无音讯，暂且不提。高通(Qualcomm)是提供Unity插件开发AR产品的AR公司。本篇咱们就来用高通的插件，来开发一个UnityAR小程序。想学Unity就来蓝鸥找我吧

注册高通帐号，获取许可证，注册识别图

因为高通的AR技术是不开源的，因此使用的时候还须要注册许可证号。首先，咱们登陆高通官方网站。

高通AR官网
注册帐号

注册

注册界面1（密码中字母要有大写有小写）

注册界面2

注册界面3

注册成功

邮箱验证
登陆到高通

登陆

登陆成功
下载插件

下载插件
注册许可证

注册许可证

填写项目名称

完成许可证注册

查看注册好了的许可证
获取许可证号

获取许可证号，暂时保存起来，一下子会用到
注册识别图数据库

注册识别图数据库

建立数据库

打开数据库建立识别图

添加识别图

添加识别图成功

下载数据

选择Unity Editor，下载

下载好了的Package

准备就绪，开始Unity开发

建立工程，导入资源（本例使用Unity5.0.2）

建立工程

导入高通插件和刚刚生成的Logo包

导入成功

找到ARCamera预设体和TargetImage预设体，导入场景

删除MainCamera

ARCamera属性介绍

VuforiaBehaviour

1.AppLicenseKey//App许可证号码
 2.CameraDeviceMode//摄像机设备模式
     MODE_DEFAULT = -1,//默认（默认）
     MODE_OPTIMIZE_SPEED = -2,//速度优化
     MODE_OPTIMIZE_QUALITY = -3//质量优化
 3.Max Simultaneous Tracked Images//最大跟踪图片数量
 4.Max Simultaneous Tracked Objects//最大跟踪对象数量
 5.Delayed Loading Object Data Sets//延迟加载对象数据集
 6.Camera Direction//摄像机方向
     CAMERA_DEFAULT,//默认（默认）
     CAMERA_BACK,//后面
     CAMERA_FRONT//前面
 7.Mirror Video Background//镜像视频背景
     DEFAULT,//默认（默认）
     ON,//开启
     OFF//关闭
 8.World Center Mode//全球中心模式
     SPECIFIC_TARGET,//特定的目标
     FIRST_TARGET,//第一个目标
     CAMERA//摄像机（默认）
 9.Bind Alternate Camera//绑定替代相机

咱们须要的设置

复制许可证号

写入许可证号

激活对象

ImageTarget属性介绍

1.Type类型
     PREDEFINED,//预约义的（默认）
     USER_DEFINED,//用户定义的
     CLOUD_RECO//云侦察的
 2.Data Set//数据集
 3.Image Target//目标识别图
 4.Width//宽度
 5.Height//高度
 6.preserve child size//保存子对象大小
 7.Extended Tracking//跟踪拓展
 8.Smart Terrain//智能地形

咱们须要的设置

选择数据库和识别图
找一个识别后显示的模型，放置为ImageTarget的子物体

放置模型
设置摄像机位置，调整模型缩放

微调

运行测试

个人iOS9.1，还没来得及下Xcode7.1，暂时这样测试

结束语

本篇主要实现基本的AR显示，后续还会写后面的高级实现，敬请期待。想学Unity就来蓝鸥找我吧

推荐拓展阅读

著做权归做者全部

若是以为个人文章对您有用，请随意打赏。您的支持将鼓励我继续创做！

¥ 打赏支持

喜欢

分享到微博分享到微信

更多分享

下载长微博图片
分享到腾讯微博
分享到QQ空间
分享到Twitter
分享到Facebook
分享到Google+
分享到豆瓣

打开微信“扫一扫”，打开网页后点击屏幕右上角分享按钮

www

做者： 1056923207@qq.com

www的属性：texture（下载的图片） audioclip（下载的声音） movie（下载的视频） bytes（下载的二进制，把文件以二进制的形式存储下来） text isdone （是否下载完成）progress（下载的进度） URL（下载的地址）

整个代码全部名字为www的变量名字的改变：点击程序中任意一个变量名，而后右键重命名这样改一个就能够，程序中全部其余的都会改变；

协程

做者： 1056923207@qq.com

携程的使用方法：

注意：携程的方法须要把void换成IEnumerator 而后在Start里面用startCoroutine()开启携程（该方法里面是携程的"方法名字”或者以下所示）

void Start()

{

StartCoroutine(DownLoadMovia());

}

public IEnumerator DownLoadMovia()

{

string url = "http://172.18.21.77/aaa.mp4";

WWW www = new WWW(url);

yield return www;

}

携程的方法：StartCoroutine(方法)；

StopCoroutine（方法）；

Yield return WaitForSeconds（float f）；//过f秒再执行后面的代码；

yield return StarCoroutine（otherIEnumerator（））；//等到括号里面的携程执行完毕后在执行本句后面的代码；

携程的执行顺序在Update和LateUpdate之间；

打包

做者： 1056923207@qq.com

数据库发布到安卓：

两个路径1.当前工程数据库文件的位置

2安卓手机上程序的安装位置（由于；安卓里没有数据库文件。解决方案：放一个数据库文件进来）；

将数据库文件放置到安卓手机程序的安装位置；1

1：解析安装包apk 拿到数据库文件而后放置到安卓手机程序的安装位置

两个语法：

1：安装包apk路径语法 jar

2：安卓数据库连接字符串语法 url

发布到安卓的具体方法：

数据库登陆界面

做者： 1056923207@qq.com

using UnityEngine;

using System.Collections;

using Mono.Data.Sqlite;

using UnityEngine.UI;

public class InputCheck : MonoBehaviour {

public InputField passwordtext;

// Use this for initialization

void Start () {

}

// Update is called once per frame

void Update () {

}

public void CheckUserName()

{

string datapath = "Data Source=" + Application .streamingAssetsPath + "/UserDatabase.sqlite" ;

SqliteConnection userconnect = new SqliteConnection (datapath);

userconnect.Open();

SqliteCommand usercommand = userconnect.CreateCommand();

string userstring = transform.GetComponent< InputField>().text;

usercommand.CommandText = "select * from UserTable";

SqliteDataReader username = usercommand.ExecuteReader();

while (username.Read())

{

for ( int i = 0; i < username.FieldCount; i++)

{

//返回值为object

//若是帐号正确

if (username.GetValue(i).ToString() == userstring)

{

//判断密码是否正确

if (username.GetValue(1).ToString() == passwordtext.text)

{

Debug.Log( "登陆成功" );

return;

}

//密码不正确

Debug.Log( "密码错误" );

return;

}

else

{

Debug.Log( "帐号不存在" );

}

SQLite

做者： 1056923207@qq.com

sql语法：

数据库字符串类型的要用单引号引发来例如:'sadfas'

username.GetValue(i)；返回值为object类型：

示例

数据存储

做者： 1056923207@qq.com

xml的生成与解析：

1：xml的生成：（引入命名空间using System.Xml:xml的生成与解析都用这一个就行）

//生成xml文件

public void creatXML()

{

//生成xml文件的名称以及路径

string filepath = Application.dataPath + "/Resources/XMLFile1.xml" ;

//建立一个xml文档操做对象

XmlDocument doc = new XmlDocument ();

//建立一个xml文档头

XmlDeclaration declaration = doc.CreateXmlDeclaration( "1.0", "UTF-8" , null);

//将xml文档头添加到文档操做对象doc中

doc.AppendChild(declaration);

//doc.Save(filepath);

//建立子节点

//1.建立一个根节点

XmlElement root = doc.CreateElement("Scene" );

//2.将根节点添加到文档中

doc.AppendChild(root);

//在根节点下添加一个子节点

XmlElement child1 = doc.CreateElement("GameObject" );

//添加给root

root.AppendChild(child1);

//添加属性

XmlAttribute attr1 = doc.CreateAttribute("Name" );

attr1.Value = "Cube";

child1.SetAttributeNode(attr1);

child1.SetAttribute( "sex", "man" );

child1.SetAttribute( "Layer", "Water" );

child1.SetAttribute( "Tag", "宁" );

//为GameObject添加子节点

XmlElement child1_transform = doc.CreateElement("Transform" );

child1.AppendChild(child1_transform);

//位Transform添加三个子节点x，y，z

XmlElement child2_position = doc.CreateElement("Position" );

child1_transform.AppendChild(child2_position);

child2_position.SetAttribute( "x", "1" );

child2_position.SetAttribute( "y", "2" );

child2_position.SetAttribute( "z", "3" );

doc.Save(filepath);

}

生成的结果：

<? xml version="1.0" encoding =" UTF-8" ?>

< Scene >

< GameObject Name="Cube" sex =" man" Layer= "Water " Tag="宁" >

< Transform>

< Position x =" 1" y= "2 " z="3" />

</ Transform>

</ GameObject >

</ Scene >

2：xml的解析：

//解析xml文档（其实就是SelectSingleNode函数）

//public void readxml()

//{

// //实例化一个xml文档操做类

// XmlDocument doc = new XmlDocument();

// string xmlfilepath = Application.dataPath + "/Resources/XMLFile1.xml";

// //doc.Load(xmlfilepath);

// //获取元素的根节点

// XmlElement root = doc.DocumentElement;

// //Debug.Log(root.Name);

// //筛选节点

// XmlNode node1 = root.SelectSingleNode("GameObject");

// //sDebug.Log(node1.Name);

// XmlAttributeCollection attributes = node1.Attributes;

// foreach (var item in attributes)

// {

// XmlAttribute att = (XmlAttribute)item;

// Debug.Log(att.Name +":"+ att.Value);

// }

// XmlNode node1_transform = node1.SelectSingleNode("Transform");

// Debug.Log(node1_transform.Name);

// //解析剩下的节点

// XmlNode xnode = node1_transform.SelectSingleNode("x");

// XmlNode ynode = node1_transform.SelectSingleNode("y");

// //获取x节点下的文本内容

// Debug.Log(xnode.OuterXml);

// Debug.Log(ynode.InnerText);

//}

要想显示汉字必须把文件（例如text）格式改成UTF-8的形式；

Json数据生产：

using UnityEngine;

using System.Collections;

using System.Json;//引入命名空间

public class jeson : MonoBehaviour {

第一种：

public void CreatJsonstr()

{

//生成一个Json对象

JsonObject root = new JsonObject ();

root.Add( "HeroName", "诺克萨斯之手" );

root.Add( "HP", "58.6f" );

JsonObject skill1 = new JsonObject ();

skill1.Add( "skillname", "chuxue" );

skill1.Add( "skilltype", "Passive" );

skill1.Add( "xiaohao", "9/8/7/6" );

JsonObject skill2 = new JsonObject ();

skill2.Add( "adf", "afdf" );

skill2.Add( "sdafa", "iui" );

skill2.Add( "aufhuds", "asdfy" );

JsonArray cd = new JsonArray();

cd.Add(skill1);

cd.Add(skill2);

root.Add( "技能",cd);

string str = root.ToString();

Debug.Log(root);

}

第二种：（不理解）

JsonObject jo;

// Use this for initialization

void Start () {

//建立一个json对象

jo = new JsonObject();//至关于写好了一个大括号

//设置一个json值

JsonValue jv = "10";//int float string

//json对象添加键值对

jo.Add( "name", jv);

Debug.Log(jo.ToString());

//建立一个json数组

JsonValue[] sons = new JsonValue[] { "masterwang", "oldwang" };

//实例化一个json数组

JsonArray arr = new JsonArray(sons);

//json对象添加对象数组

jo.Add( "sons", arr);

//debug.log(jo.tostring());

HandOfLittleStudent();

}

void HandOfLittleStudent()

{

//建立技能q的Json对象

JsonObject skillq = new JsonObject ();

//添加一个技能名称

skillq.Add( "Q", "大厦四方" );

//建立一个数组对象

JsonArray cd = new JsonArray( new JsonValue[] { 9, 8, 7, 6, 5 });

skillq.Add( "冷却时间" ,cd);

skillq.Add( "消耗法力" , 30);

skillq.Add( "jo", jo);

Debug.Log(skillq);

}

Json数据解析：

using UnityEngine;

using System.Collections;

using LitJson;//引入解析明明空间

public class litjjjson : MonoBehaviour {

void Start ()

{

ParJson();

}

public void ParJson()

{

//解析第一个文本

TextAsset jsonfile1 = Resources .Load("transformtext" ) as TextAsset ;

string jsonstr1 = jsonfile1.text;

JsonData date1 = JsonMapper.ToObject(jsonstr1);

Debug.Log(date1[2][ "y"]);

//解析第二个文本；

//加载文件到text

TextAsset jsonfile = Resources.Load( "Json") as TextAsset ;

string jsonstr = jsonfile.text;

//将text转换成对象的格式

JsonData date = JsonMapper.ToObject(jsonstr);

//输出skills对象第2个的技能名字

Debug.Log(date[ "skills"][1]["skillName" ]);

}

//如何保存成为一个Json文件

粒子特效

做者： 1056923207@qq.com

1：粒子系统

2：拖尾渲染

3：线性渲染

4：贴图融合

1.粒子系统：粒子系统其实就是一个组件：Particle System。

Particle System组件面板以下：

、

using UnityEngine;

using System.Collections;

using UnityEngine.UI;

public class PlayerprefabsTest : MonoBehaviour {

/// <summary>

/// 本地数据的存储测试

/// </summary>

// Use this for initialization

public InputField Leval;

public InputField Score;

public InputField Name;

void Start ()

{

//Debug.Log(PlayerPrefs.GetInt("Leval"));

//Leval.text = PlayerPrefs.GetInt("Leval").ToString();

//Score.text = PlayerPrefs.GetFloat("Score").ToString();

//Name.text = PlayerPrefs.GetString("姓名");

}

// Update is called once per frame

void Update () {

}

public void savedate()

{

PlayerPrefs.SetInt("Leval" , 30);

PlayerPrefs.SetFloat("Score" , 153.6f);

PlayerPrefs.SetString("姓名" ,"张大鸡复活节第三zhang" );

}

public void ReadDate()

{

string rank = PlayerPrefs.GetInt("Leval" ).ToString();

float score = PlayerPrefs.GetFloat("Score" );

string name = PlayerPrefs.GetString("姓名" );

Leval.text = rank;

Score.text = score.ToString();

Name.text = name;

}

public void clearall()

{

PlayerPrefs.DeleteAll();

}

PlayerPrefaebs 小型游戏能够用：

做者： 1056923207@qq.com

PlayerPrefaebs 小型游戏能够用：

粒子特效

做者： 1056923207@qq.com

1：粒子系统

2：拖尾渲染：Trail Render

3：线性渲染：Line Render

4：贴图融合

1.粒子系统：粒子系统其实就是一个组件：Particle System。

Particle System组件面板以下：

、

线性渲染：

贴图融合：例如制做弹痕效果：

关于射线的笔记

做者： 1056923207@qq.com

RaycastHit rrr;

Ray hit = Camera.main.ScreenPointToRay( Input.mousePosition);

Physics .Raycast(hit, out rrr);

上述代码能够获得鼠标点击点的信息,rrr.point是一种position类型；

动画系统2

做者： 1056923207@qq.com

动画层：

Mask：遮罩在JumpLayer加avator Mask （设置一下），权重weight 要设置为1；

IK Pass 勾上表明可使用IK；

Avatar Mask组件；

IK动画的使用：

1：只有人型动画才能设置IK；

1：里面的权重（1f）表示任务抬手动做的大小，0表明不抬手，1表明彻底指向目标：

2：将手指向，转向rightHandObj对象；（与lookat很类似）；

3：若是没有rightHandobj这个对象，则手不进行任何操做；

动画曲线：若是动画曲线叫Curve(以下图)，那么在parameter面板加一个一样名字的Float变量（这个变量的值随着图Curve的变化而变，大小同样），在脚本里利用GetFloat方法获取曲线的y值进行利用；

动画事件：Event；

下图是在Idle Walk 等动画里设置的不是人物里面设置的；

注意：下图Object参数必须是一个预设体：

脚本必须放在人物身上，不是动画身上；

动画系统一

做者： 1056923207@qq.com

一：mecanim动画系统：]

1:任性动画设置和重用；

2：动画剪辑设置

3；可视化动画控制界面

4：动画播放的精准控制

动画类型：无任何动画 legacy 旧版动画 Generic 通常动画（非人性动画） Humanoid 人形动画

人性动画设置：

测试骨骼：肌肉测试

点击Done 回到正常界面

点击Import 若是现实下面的内容说明该模型没有动画；

模型没有动画的时候：Animations面板

模型有动画时的Animations面板：

把模型所包含的动画剪辑成的片断：点击+号能够添加剪辑片断-好能够删除选中的片断

动画剪辑面板：

动画编辑：

loop Time 让动画循环执行：

Loop Pose 让动画起始帧和末尾帧衔接更加天然，动画更加流畅；

Cycle Offset 设置动画开始执行的帧位置：

Loop Match 红色表明动画不能播放；黄色不能顺畅的播放；绿色能够；

Bake Into pose；烘焙进姿式：只有动做（例如动画有旋转的动做，可是坐标不改变，线面两个位移也是同样）没有位移：

注意上面的Cycle Offset 和下面的Offset是不同的下面表明的是位置的便宜上面表明的是动画整形循环的开始的帧位置：

mirror：当前动画是按照原动画执行动做，仍是镜像里的动画执行动做：

Animator组件：

Controller：动画控制器

Avator：人物骨骼（阿凡达）；

Apply Root motion :只有勾选上,在动画设置里的改动才能应用，不然用的是原版动画，全部更改都没用啦;

Culling Mode :时间缩放；

Update：动画显示更新模式；

二State Machine状态机：

三：Blend Tree：融合树：

动画系统一

做者： 1056923207@qq.com

一：mecanim动画系统：]

1:任性动画设置和重用；

2：动画剪辑设置

3；可视化动画控制界面

4：动画播放的精准控制

动画类型：无任何动画 legacy 旧版动画 Generic 通常动画（非人性动画） Humanoid 人形动画

人性动画设置：

测试骨骼：肌肉测试

点击Done 回到正常界面

点击Import 若是现实下面的内容说明该模型没有动画；

模型没有动画的时候：Animations面板

模型有动画时的Animations面板：

把模型所包含的动画剪辑成的片断：点击+号能够添加剪辑片断-好能够删除选中的片断

动画剪辑面板：

动画编辑：

loop Time 让动画循环执行：

Loop Pose 让动画起始帧和末尾帧衔接更加天然，动画更加流畅；

Cycle Offset 设置动画开始执行的帧位置：

Loop Match 红色表明动画不能播放；黄色不能顺畅的播放；绿色能够；

Bake Into pose；烘焙进姿式：只有动做（例如动画有旋转的动做，可是坐标不改变，线面两个位移也是同样）没有位移：

注意上面的Cycle Offset 和下面的Offset是不同的下面表明的是位置的便宜上面表明的是动画整形循环的开始的帧位置：

mirror：当前动画是按照原动画执行动做，仍是镜像里的动画执行动做：

Animator组件：

Controller：动画控制器

Avator：人物骨骼（阿凡达）；

Apply Root motion :只有勾选上,在动画设置里的改动才能应用，不然用的是原版动画，全部更改都没用啦；

二State Machine状态机：

三：Blend Tree：融合树：

动画的遮罩

做者： 1056923207@qq.com

状态机作两个层在第二个层里加上AAnimatorMask 而且把他的Weight设置为1，两个层的页面以下：

基层：

另外一层：正常状态不是Idle 而是New State（空状态）

单例类

做者： 1056923207@qq.com

单例的缺点：没有继承各类类和MoNo；unity的封装方法没办法用，部分可使用（gameobject，tansform）若是用到了MONO的方法会异常处理（一些重要的代码用到，尤为是用户交互）；

单利类不放在任何组件对象身上，可是单利脚本（继承mono）必须放在对象身上；

单利类：

public class SImpple

{

private SImpple()

{

}

private static SImpple _instanse;

public static SImpple getinstanse()

{

if (_instanse == null)

{

_instanse = new SImpple();

}

return _instanse;

}

单例脚本

单利脚本的缺点，在切换场景的时候容易被销毁（解决办法：使用DontDestroyThis（）方法防止单例脚本被销毁）；

using UnityEngine;

using System.Collections;

public class SingleScript : MonoBehaviour

{

public static SingleScript _instance;

void Awake()

{

_instance = this;

}

单例类

做者： 1056923207@qq.com

单利类不放在任何组件对象身上，可是单利脚本（继承mono）必须放在对象身上；

单利类：

public class SImpple

{

private SImpple()

{

}

private static SImpple _instanse;

public static SImpple getinstanse()

{

if (_instanse == null)

{

_instanse = new SImpple();

}

return _instanse;

}

单例脚本

using UnityEngine;

using System.Collections;

public class SingleScript : MonoBehaviour

{

public static SingleScript _instance;

void Awake()

{

_instance = this;

}

EventSystem

做者： 1056923207@qq.com

一：添加 Event Trriger组件不用写代码；

二：写代码以下:注意引入事件系统；实现接口继承

三：实现UI明明空间;(看start里面的方法，不能写在Update里面，只注册一次就行)，须要给脚本托一个脚本组件；

using UnityEngine;

using System.Collections;

using UnityEngine.EventSystems;

using System;

using UnityEngine.UI;

public class EventSystomText : MonoBehaviour,IPointerEnterHandler ,IPointerExitHandler ,IPointerDownHandler ,IPointerUpHandler ,IPointerClickHandler ,IBeginDragHandler ,IDragHandler ,IEndDragHandler ,

{

//第三种方法的代码

public Button btn;

public void OnBeginDrag( PointerEventData eventData)

{

Debug.Log( "开始拖拽" );

//throw new NotImplementedException();

}

public void OnDrag(PointerEventData eventData)

{

Debug.Log( "正在拖拽" );

//throw new NotImplementedException();

}

public void OnEndDrag( PointerEventData eventData)

{

Debug.Log( "结束拖拽" );

//throw new NotImplementedException();

}

public void OnPointerClick( PointerEventData eventData)

{

Debug.Log( "鼠标点击" );

// throw new NotImplementedException();

}

public void OnPointerDown( PointerEventData eventData)

{

Debug.Log( "鼠标按下" );

//throw new NotImplementedException();

}

public void OnPointerEnter( PointerEventData eventData)

{

Debug.Log( "shubiaojinre");

// throw new NotImplementedException();

}

public void OnPointerExit( PointerEventData eventData)

{

Debug.Log( "鼠标离开" );

//throw new NotImplementedException();

}

public void OnPointerUp( PointerEventData eventData)

{

Debug.Log( "鼠标抬起" );

// throw new NotImplementedException();

}

//第三种方法的代码

public void Res()

{

}

// Use this for initialization

void Start () {

//只执行一次就行

btn.onClick.AddListener(Res);

}

// Update is called once per frame

void Update () {

}

场景的加载

做者： 1056923207@qq.com

//1.读取新的关卡后当即切换，其参数为所读取的新关卡的名称或索引；

Application.LoadLevel("your scene" );

//2.加载一个新的场景，当前场景不会被销毁。

Application.LoadLevelAdditive("Your scene" );

//异步加载场景

//1.加载完进入新场景销毁以前场景

Application.LoadLevelAsync("Your Scene" );

//2.加载完毕进入新场景可是不销毁以前场景的游戏对象

Application.LoadLevelAdditiveAsync("Your Scene" );

Application(应用程序)

做者： 1056923207@qq.com

做用：1.加载游戏关卡场景

2.获取资源文件路径

3.退出当前游戏场景

4.获取当前游戏平台

5.获取数据文件夹路径

Application.Plateform 返回值为当前程序运行所在的平台；

Debug .Log( Application .runInBackground);可读可写，返回程序是否在后台运行的布尔值：

Application类的测试：

void Start()

{

//打印在哪一个平台运行

Debug.Log( Application.platform);

//返回是否在后台运行（bool值）

Debug.Log( Application.runInBackground);

//当前工程的Assets文件夹位置（仅编辑器有）；

Debug.Log( Application.dataPath);

//持久路径

Debug.Log( Application.persistentDataPath);

//数据流路径

Debug.Log( Application.streamingAssetsPath);

//返回当前场景的索引号

Debug.Log( Application.loadedLevel);

}

输出结果：

坦克转向鼠标的位置

做者： 1056923207@qq.com

鼠标的位置转换成世界坐标： Vector3 WorldPoint =Camera.main.screenToWorldPoint(mousePoint)；

Vector3 direction =worldPoint -mGunTransform.position;

mGunTransform.rotation=Quternion.LookRotation(Vector3.forword,direction)

实现小地图的方法

做者： 1056923207@qq.com

在已经建立好的ui界面：首先议案家一个摄像机,而后将主摄像机的层级设置为1（大于新添加的摄像机），在建立一个Render Texture组件，建立一个RawImage组件，将该组件的北京图片换为刚才建立的Render Texture便可；

若是小地图里面物体的移动方向与主场景中的不一致，能够在sence里面调整新添加的相机的视角；

怎样实现小地图摄像机跟随某个物体移动：把小地图摄像机设置为想要跟随的目标的子物体就行：

实现小地图不显示实际的任务，只显示人物头像（相似lol小地图）：添加一个Canvas（Render Mode设置成世界模式（World Space），Event Camera设置成小地图的相机（渲染的时候将人物层剔除掉，主相机则是将人物头像（新建一个层，不能是原来的ui层）层剔除掉），将人物头像与任务xz坐标调成一致，）

添加遮罩

做者： 1056923207@qq.com

1.添加一个RawImage组件，背景图片选一张你想要显示的形状的无色的图片，在该组件上再添加一个Mask组件，将要显示的通篇放到该RawImage组件上；

血条，头像

做者： 1056923207@qq.com

遮罩：在父物体上添加Mask，在给其添加一个形状，在添加一个子物体图片，子物体的图片就会随着形状的改变而改变；

UGUI

做者： 1056923207@qq.com

Image组件：Image Type 能够作不一样的功能；

Sprite

做者： 1056923207@qq.com

1，2D游戏相机设置为正交相机 size：5

2.资源切图

3.游戏背景设置成：在game视图中设置为Free Aspect;(自适应屏幕大小)

4.预制体的建立：炮口，炮弹，鱼；

2D动画的建立

做者： 1056923207@qq.com

选中切割好的图片，所有选中拖到Hierirychy面板中，给个动画名字，而后直接播放便可，也能够拖成预制体，

世界坐标与本地坐标的转换

做者： 1056923207@qq.com

将屏幕左边转换成世界坐标；transform.postion = Camera.main.ViewportToWorldpoint(Input.mouseposition);

transform.position = Camera.main.ViewportToWorldPoint( new Vector3(Input .mousePosition.x / Screen.width, Input.mousePosition.y / Screen.height, 4));

2D图片处理

做者： 1056923207@qq.com

若是不在工程设置里Edtor更改设置（DisAble，Enable forbuildings,Always Enable），那么系统会自动打包图片（即讲多张图片放到一张图片中）。

从一张打包好的图片里切割出小图片的好处：下降 CPU 的 DrawCall 切割出来的图片都算做一次Drawcall；

处理修改图片的组件：Sprite Renderer；

快速进入API：点击组件右侧的小问号。

触发器

做者： 1056923207@qq.com

碰撞器

做者： 1056923207@qq.com

1.碰撞器的大小能够人为地改变，来适应需求；

2.碰撞器的类型：胶囊体碰撞器，圆形碰撞器(2D)

3.OnCollisionEnter等回调方法须要有刚体；

4.GetComponent<MeshRenderer>().material.color=Color.red=new Color(255,0,0);两种方式是等价的；能够改变物体的颜色；

对游戏对象的测速

做者： 1056923207@qq.com

1.两个触发器：一个触发器检测到车的触发器后继而拿到其刚体组件继而拿到其速度：

Transform类

做者： 1056923207@qq.com

静态类：Time.time 游戏从开始到如今运行的时间；

Vector3是一个结构体，经常使用属性：vector3.normalied：标准化向量方向不变，长度为1；

vector3.magnitude 向量的长度（只读）；

vector3.sqrMagnitude：向量长度平方（只读）；

经常使用方法：vector3.Normalied（）：标准化向量，长度为1

static float Angle（Vector3 from，vector3 to）；两向量之间的角度

static float Distance（Vector a，Vector3 b）；两点之间的距离

transform.rotation = Quaternion.look(vector3.left,vector.up);

子弹飞行：子弹上的脚本Update里：

transform.Translate( Vector3 .forward* Time.deltaTime*speed);

设置父对象：bullet.transform.parent=parent.transform;===bullet.transform.setparent(parent.transform);

经过设置Transform父子关系能够在敌人指定的部位产生爆炸流血特效；

float v =Input.Getaxis("Horizontal"); v是一个0到1之间的值

物体自转的公式;

transform.Rotate(transform.up * Time.deltaTime * Rspeed*hor);

7.13笔记 unity组件

做者： 1056923207@qq.com

一个游戏物体身上有不少的组件：

销毁游戏对象的两种方式：1,Destroy();继承MonoBehavior类

transform.Translate(vector3.up);改变的是本地坐标。

transform.position+=vector3.up;改变的是世界坐标。

transform.Rotate(vector3.up);

translate.RotateArround(new Vector3(0,0,0),Vector3.up,10(旋转角度，并非速度。可是放到Update每秒执行多少次，其值的大小就能够表明速度啦))；

transform.LookAt(Target.Transform);让当前脚本挂载的物体朝向目标可是不移动；

Target.transform.localscale=new vector(2,2,2); 改变Target的缩放。

关于射线的知识点

做者： 1056923207@qq.com

Debug.Draw()方法是持续执行的必须放在update()里面才能看到划线，并且只能在Scene里面才能看到在Game视图看不到；

代码以下：

public class CameraRay : MonoBehaviour

{

RaycastHit Hit;

void Start()

{

bool isRaycast = Physics.Raycast( new Vector3(0, 1, 0), Vector3.down, out Hit);

if (isRaycast)

{

Debug.Log(Hit.point);

}

void Update()

{

Debug.DrawLine( new Vector3(0, 10, 0), Hit.point, Color.red);

}

关于物体的移动

做者： 1056923207@qq.com

若是想让物体的速度由快到慢：就用lerp函数：transform.position=vector3.Lerp(transform.position,Target,Time.delTime);

第二种移动方法： float hor= Input.GetAxis("Horizontal");

float ver = Input.GetAxis("Vertical");

transform.position +=new Vector3(hor,ver,0)*Time.delTime;

第二种方法的第二种写法： float hor = Input .GetAxis("Horizontal" );

transform.position += transform.right * hor * Time.deltaTime * speed;

寻找当前脚本挂在物体的子物体

做者： 1056923207@qq.com

point= transform.Find("Gun/Point");

纹理和材质球通常是配合使用的；想要变得更逼真，就把贴图变成map的

做者： 1056923207@qq.com

纹理和材质球通常是配合使用的；想要变得更逼真，就把贴图变成map的

射线的建立

做者： 1056923207@qq.com

鼠标拖拽物体

做者： 1056923207@qq.com

using UnityEngine;

using System.Collections;

public class Script1 : MonoBehaviour

{

public float movespeed;

private Vector3 PresentPosition;

private Vector3 CurrentPosition;

void OnMouseDown()

{

PresentPosition= Input.mousePosition;

}

void OnMouseDrag()

{

CurrentPosition = Input.mousePosition;

Vector3 dir = CurrentPosition - PresentPosition;

transform.position += dir*movespeed;

PresentPosition = CurrentPosition;

}

void Update()

{

OnMouseDown();

OnMouseDrag();

}

10抽象类，静态类

做者： 574096324@qq.com

//若是一个方法前面用abstruct来修饰，改方法为抽象方法，同时须要把该抽象方法所在的类改成抽象类

//全部的子类都要把父类的抽象方法重写,若是父类里面有多个抽象方法，则必须实现

//抽象类不能实例化，他能够用普通的子类进行实例化

//抽象类里面能够不包含抽象方法，此时除了不能实例化之外，和普通的类没有任何区别

//若是子类仪式抽象类，能够不用实现父类里面的抽象方法

public abstract void Train();

public string Name { get; set; }

public void Run()

{

}

abstract class Person

{

public string Name { get; set; }

public void Talk()

{

}

class FootballPlayer : Athlete

{

public override void Train()

{

Console.WriteLine("足球运动员训练" );

}

abstract class ManFootball :FootballPlayer

{

public override void Train()

{

}

class Swimmer: Athlete

{

public override void Train()

{

Console.WriteLine("游泳运动员训练" );

}

class Runner: Athlete

{

public override void Train()

{

Console.WriteLine("短跑运动员训练" );

}

abstract class Ball

{

public abstract void Play();

}

class Basketball : Ball

{

public override void Play()

{

Console.WriteLine("打篮球" );

}

class Football : Ball

{

public override void Play()

{

Console.WriteLine("踢足球" );

}

class Volleyball : Ball

{

public override void Play()

{

Console.WriteLine("打排球" );

}

单例

class Hero

{

//1.要保证该类只能建立出一个对象，则构造方法就不能为公有的，这样就能够在类的内部建立出一个对象

//而后经过属性在类的外部获得该对象

private Hero()

{

}

//2.在类的内部声明一个Hero的对象，但不赋值，即没有new运算符在内存中开辟空间，此时其值为空

private static Hero instance;

//3.因为构造方法为私有的，类的外部不能建立对象来调用普通的属性，故把属性写成静态的，经过类名来调用该属性

//而静态属性只能调用静态成员，故要把instance写成静态的

public static Hero Instance

{

get

{

//判断instance是否为空，当第一次调用时其值为空，则执行if语句，就会建立一个对象出来，当第二次调用时，

//instance已经不为空，if语句就不会执行了，会把第一个建立的对象返回出去，这样就保证了该类的对象时惟一的一个

if (instance==null )

{

instance = new Hero ();

}

return instance;

}

枚举，结构体

做者： 574096324@qq.com

结构体数组结合

找最大最小值，先定义一个max，与max比较，一次循环

排序，冒泡，两次循环，i<length-1,j<length-1-i,

按年龄排序，要交换整个Student 类型的temp;

int c = char.Parse(Console.ReadLine());

PlayerStatus player = (PlayerStatus)c;

PlayerStatus player = (PlayerStatus )char.Parse( Console .ReadLine());

Console .WriteLine(player);

//StuInfos[] stu = new StuInfos[5];

//double maxScore = stu[0].score;

//int maxIndex = 0;

//for (int i = 0; i < stu.Length; i++)

//{

// StuInfos s;

// Console.WriteLine("请输入第{0}个学生的姓名:", i + 1);

// string inputName = Console.ReadLine();

// s.name = inputName;

// Console.WriteLine("请输入第{0}个学生的年龄:", i + 1);

// int inputAge = int.Parse(Console.ReadLine());

// s.age = inputAge;

// Console.WriteLine("请输入第{0}个学生的学号:", i + 1);

// int inputNumber = int.Parse(Console.ReadLine());

// s.number = inputNumber;

// Console.WriteLine("请输入第{0}个学生的分数:", i + 1);

// double inputScore = double.Parse(Console.ReadLine());

// s.score = inputScore;

// //把变量s存到stu的数组里面

c#和unity引擎的全部笔记

Shader摄像机死亡效果

快速排序

Shader

Shader

网络

Out和Ref的区别

ref和out的使用与区别

根据Txt文件数据生成地图

A*算法

二叉树

遍历二叉树递归非递归

时间复杂度和空间复杂度

宽度优选寻路算法（BFS）

编辑器扩展

FileStream类

摄像头相关知识

WebCamTexture（摄像机开发须要用到的类）

扫雷游戏

递归

屏幕坐标转世界坐标（好用）

unity3d 屏幕坐标、鼠标位置、视口坐标和绘制GUI时使用的坐标

网络相关知识

异步加载场景

SDK/Json

马帅的摄像机

DataBaseTool

泛型单例父类

关于AudioSource和AudioClip的使用

类能够继承 结构体不能继承；

动画插件Itween和dotween

关于技能的释放

跨脚本调用方法

改变鼠标指针单例脚本，在其余脚本中能够调用

xml写的Transform和Json

委托

属性，数据类型，方法参数

新版网络

3dmax

Leapmotion虚拟现实

Socket

Unity网络基本知识

Unity高通AR解析步骤

下载简书移动应用

Unity高通AR解析（一）

前言

结束语

打开微信“扫一扫”，打开网页后点击屏幕右上角分享按钮

www

协程

打包

数据库登陆界面

SQLite

数据存储

粒子特效

PlayerPrefaebs 小型游戏能够用：

粒子特效

导航

关于射线的笔记

动画系统2

动画系统一

动画系统一

动画的遮罩

单例类

单例类

EventSystem

场景的加载

Application(应用程序)

坦克转向鼠标的位置

实现小地图的方法

添加遮罩

血条，头像

UGUI

Sprite

2D动画的建立

世界坐标与本地坐标的转换

2D图片处理

触发器

碰撞器

对游戏对象的测速

类能够继承结构体不能继承；