using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace _11
{
class Program
{
    static void Main(string[] args)
    {
        Person p1 = new Person();
        p1.Hello();
        p1.Age = 21;
        p1.Name ="Kungge";
        //p1.Nickname = "Dogegg";// 注意这个外部不能使用
        Console.WriteLine(p1.Name );
        //p1.Hello2();//这个外部也不可使用
        p1.GiveNn("Gumzhep");
        Console.ReadKey();
    }
    class Person
    {
        public int Age;
        public string Name;
        private string Nickname;
        public void GiveNn(string nickname)
        {
            if (nickname == "Dogegg")
            {
                return;
            }
            this.Nickname = nickname;
        }
        private void Hello2()
        {
        }
        public void Hello()
        {
            Console.WriteLine("HelloWorld");
            Console.WriteLine("{0} {1} {2}",this.Age,this.Name,this.Nickname);//this.是我自己的
        }
    }
}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace _11
{
class Program
{
    static void Main(string[] args)
    {
        Person p = new Person();
        p.Age = 20;
        Console.WriteLine(p.Age);
        p.Age = -1;//非法值 无用
        Console.WriteLine(p.Age);
        p.Nage = 20;
        Console.WriteLine(p.Nage);
        /*p.Dage = 20;
        Console.WriteLine(p.Dage );*/
        //这将出现死循环
       /* Person2 p2 = new Person2();
        p2.Age = 20;//其是只读的
        Console.WriteLine(p2 .Age);*/
        Person3 p3 = new Person3();
        p3.Age = 21;
        Console.WriteLine(p3.Age);
        Console.ReadKey();
    }
    class Person
    {
        private int age;
        public int Age
        {
            set//set用来赋值
            {
                if (value < 0)//public字段和属性的区别 ：属性可以进行非法设置值的判断
                {
                    return;
                }
                this.age = value;//value是用户赋过来的值
            }
            get//get用来取值
            {
                return this.age;
            }
        }
        private int nage;
        public int Nage
        {
            set
            {
                this.nage = value;
            }
            get
            {
                return 18;//返回值是多少就是多少
            }
        }
        private int dage;
        public int Dage
        {
            set
            {
                this.Dage = value;//将出现死循环
            }
            get
            {
                return this.Dage;
            }
        }
    }
   /* class Person2
    {
        public int Age
        {
            get//这是只读的
            {
            }
        }
    }*/
    class Person3
    {
        public int Age//编译器自动生成私有字段和set get代码块
        {
            get;
            set;
        }
    }
}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace _11
{
class Program
{
    static void Main(string[] args)
    {
        Robot r1 = new Robot();
        r1.Name = "K1";
        Robot r2 = new Robot();
        r2.Name = "K2";
        Robot r;
        Console.WriteLine("请选择1：r1,2:r2");
        string s = Console.ReadLine();
        if (s == "1")
        {
            r = r1;
        }
        else
        {
            r = r2;
        }
        Console.WriteLine("Hello,I'm robot.");
        r.Eat(5);
        while (true)
        {
            string str = Console.ReadLine();
            r.Speak(str);
        }
        Console.ReadKey();
    }
}
class Robot
{
    public string Name { set; get; }
    private int full { set; get; }
    public void SayHello()
    {
        Console.WriteLine("Hello,my name is {0}", Name);
    }
    public void Speak(string str)
    {
        if (str.Contains("你") && (str.Contains("名字") || str.Contains("姓名")))
        {
            this.SayHello();
        }
        else if (str.Contains("你") && str.Contains("女朋友"))
        {
            Console.WriteLine("我还没有了，要不你给我介绍一个");
        }
        else if (str.Contains("今天") && str.Contains("天气"))
        {
            Console.WriteLine("天气很好");
        }
        else if (str.Contains("你") && str.Contains("吃饭"))
        {
            Console.WriteLine("我已经吃过了");
        }
        else if (str.Contains("再见") || str.Contains("拜") || str.Contains("8"))
        {
            Console.WriteLine("拜，下次聊");
            return;
        }
        else if (full <= 0)
        {
            Console.WriteLine("I'm hungry! Give some food.Please input the number.");
            string str1 = Console.ReadLine();
            this.Eat(Convert.ToInt32(str1));
        }
        else
        {
            Console.WriteLine("听不懂");
        }
        full--;
    }
    public void Eat(int food)
    {
        full = full + food;
    }
}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace _11
{
class Program
{
    static void Main(string[] args)
    {
        int i = 10;//int,char,bool,datetime等类型都是值类型（value type），赋值的时候是传递拷贝
        int j = i;
        i++;
        Console.WriteLine(j);
        Person p1 = new Person(10);//普通的对象则是引用类型，赋值的时候是传递引用
        Person p2 = p1;
        p1.Age++;
        Console.WriteLine(p2.Age);
        IncAge(p2);
        Console.WriteLine(p2.Age);//传递给函数也是引用传递
        static void IncAge(Person p)
        {
             p.Age++;
         }
        Console.ReadKey();
    }
}
class Person
{
    public int Age
    {
        get;
        set;
    }
    public Person(int age)
    {
        this.Age = age;
    }
}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace _11
{
class Program
{
    static void Main(string[] args)
    {
        Person p1 = new Person();
        Person p2 = new Person("K1");
        Person p3 = new Person("K2",20);
        Console.WriteLine("{0} {1}",p1 .Name,p1 .Age);
        Console.WriteLine("{0} {1}", p2.Name, p2.Age);
        Console.WriteLine("{0} {1}", p3.Name, p3.Age);
        Console.ReadKey();
    }
}
class Person
{
    public int Age { set; get; }
    public string Name { set; get; }
    public Person()//构造函数和类名相同 可以重载
    {
        Name = "unknown";
        Age = 1;
    }
    public Person(string name)
    {
        this.Name = name;
    }
    public Person(string name, int age)
    {
        this.Name = name;
        this.Age = age;
    }
}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace 继承
{
class Program
{
    static void Main(string[] args)
    {
        Chinese c1 = new Chinese();
        c1.Name = "张三";
        c1 .Age =21;
        c1.Say();
        c1.HaveTea();
        American a1 = new American();
        a1.Name = "Gump";
        Japaniese j1=new Japaniese ();
        //American a4=new Person ();//错误
        Person p1 = c1;//这是正确的
        //American a2=p1;//错误的
        //American a3 =(American) p1;//强制转换错误
        Person p2 = j1;
        Person p3 = new Person();
        Chinese c2 = (Chinese)p3;//想想为什么强制转换没有成功
        Console.ReadKey();
    }
}
class Person//所有的类都直接或间接继承Object类 其是所有类的基类
{
    public int Age { set; get; }
    public string Name { set; get; }
    public void Say()
    {
        Console.WriteLine("{0}",Name);
    }
}
class Chinese : Person
{
    public string Tea { set; get; }
    public void HaveTea()
    {
        Console.WriteLine("Chinese Tea is good!");
    }
}
class American : Person
{
    public void Westmeal()
    {
        Console.WriteLine("Make a difference.");
    }
}
class Japaniese : Person
{
}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace 异常
{
class Program
{
    static void Main(string[] args)
    {
        try
        {
            int i = Convert.ToInt32("asd");
            Console.WriteLine("Convert 之后");
        }
        catch(Exception ex)
        {
            Console.WriteLine("数据错误："+ex.Message +ex.StackTrace);
            Console.WriteLine("数据错误之后");
        }
        try
        {
            string str = DescAge(200);
        }
        catch(Exception ex)
        {
            Console.WriteLine("数据错误："+ex.Message);
        }
        Console.ReadKey();
    }
    static string DescAge(int age)
    {
        if (age >= 0 && age <= 150)
        {
         return "正常";
        }
        else if (age > 150)
        {
            throw new Exception("神人啊");
        }
        else
        {
            throw new Exception("不正常");
        }
    }
}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace 常量,变量及static成员
{
class Program
{
    public const int Week = 7;//const常量 常量名要大写
    static void Main(string[] args)
    {
        const int Pi = 3;//不可变的量 注意这种用法
       // Pi = 4;//
        Console.WriteLine(3*Pi);
        Person.height = 172;//注意
        Person.Say();//不用new就能使用的方法static方法
        Horse.Run();
        //Person.Sing();//
        Person p = new Person();
        p.Sing();
        p.Age =20;
        //Rabbit r = new Rabbit();//
        Rabbit .Weigth =8;
        //Rabbit.Walk();
        Rabbit.Eat();
        Console.ReadKey();
    }
}
public class Person
{
    public static int height;
    public int Age;
    public static void Say()
    {
        Console.WriteLine(height);
        //Console.WriteLine(Age);//在static成员中不能直接调用非static成员
        //Person.Sing();
    }
    public void Sing()
    {
        Console.WriteLine(height);
        Console.WriteLine(Age);
        Person.Say();//在非static方法中可以调用static方法中的字段 方法
    }
}
public class Horse
{
    public static int Size;
    public int Ability;
    public static void Run()
    {
        Console.WriteLine(Person.height);
       // Console.WriteLine(Person.Age);//
        Person.Say();//在static方法中可以调用其它static方法的字段，属性，但不能调用非static的
        //Person.Sing();
    }
    public void Leap()
    {
        Console.WriteLine(Person.height);
       // Console.WriteLine(Person.Age);
        Person.Say();
        //Person.Sing();
    }
}
static class Rabbit//这是一个静态类
{
    public static int Weigth;
    public string Name;
    public static void Eat()
    {
        Console.WriteLine(Horse.Size);
       // Console.WriteLine(Horse.Ability);
    }
    public void Walk()
    {
        Console.WriteLine(Horse.Size);
    }
}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using 命名空间.hr;
namespace 命名空间
{
class Program
{
    static void Main(string[] args)
    {
        Person p = new Person();//这是本命名空间的类
        命名空间.wk.Person p2 = new 命名空间.wk.Person();
        p2.Say();
        Dog d = new Dog();//using 命名空间.hr
        Convert.ToInt32("12");//using System
        Console.ReadKey();
    }
}
class Person
{
}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace 命名空间.wk
{
class Person
{
    public void Say()
    {
        Console.WriteLine("Hello");
    }
}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace 命名空间.hr
{
class Dog
{
}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace 索引
{
class Program
{
    static void Main(string[] args)
    {
        Person p = new Person();
        p[1]=172;
        Console.WriteLine("{0} {1}",p[1],p[2]);
        Console.WriteLine(p["Tom",1,2]);
        Console.ReadKey();
    }
}
class Person
{
    public int Num1=168;
    public int Num2=173;
    public int this[int index]
    {
        set
        {
            if (index == 1)
            {
                Num1 = value;
            }
            else if (index == 2)
            {
                Num2 = value;
            }
            else
            {
                throw new Exception ("数据错误");
            }
        }
        get
        {
            if (index == 1)
            {
                return Num1;
            }
            else if (index == 2)
            {
                return Num2;
            }
            else
            {
                throw new Exception("数据错误");
            }
        }
    }
    public string this[string name,int i1,int i2]
    {
        get
        {
            return name + i1 + i2;
        }
    }
}
}

void OnTriggerEnter(Collider collider)
    {
        print(collider.gameObject.name + ":" + Time.time);
    }

using UnityEngine;
using System.Collections;
public class mover : MonoBehaviour {
	// Use this for initialization
	void Start () {
		//x轴坐标
		//float xPostion = -5f;
		//z轴坐标
		//float zPostion = 10f;
		//直接将当前物体移动到x轴为xPostion，y轴为0，z轴为zPostion的三维空间位置。
		transform.position = new Vector3(0.1f,0.1f,0.1f);//初始化坐标
	}
	// Update is called once per frame
	/*
void Update () {
		/*
		//移动速度
		float TranslateSpeed = 0.1f;
		//Vector3.forward 表示“向前”
		transform.Translate(Vector3.forward *TranslateSpeed);
         //单方向移动*/
		/*
		//轴移动速度移动速度
		float xSpeed = 0.01f;
		//z轴移动速度移动速度
		float  zSpeed = 0.01f;
		float ySpeed = 0.01f;
		//向x轴移动xSpeed，同时想z轴移动zSpeed，y轴不动
		transform.Translate(xSpeed,ySpeed,zSpeed);
		*/
	/*
		//按下键盘“上方向键”控制cube的位置
		if(Input.GetKey(KeyCode.UpArrow))
		{
			Debug.Log ("up");
			transform.Translate(0.1f,0f,0f);}
		if(Input.GetKey(KeyCode.LeftArrow))
		{
			Debug.Log("left");
			transform.Translate(0f,0.1f,0f);}
		if(Input.GetKey(KeyCode.DownArrow))
		{   
			Debug.Log("down");
			transform.Translate(-0.1f,0f,0f);}
		if(Input.GetKey(KeyCode.RightArrow))
		{   
			Debug.Log("right");
			transform.Translate(0f,-0.1f,0f);}
		//按下鼠标左键（0对应左键 ， 1对应右键 ， 2对应中键）
		/*
		if(Input.GetMouseButton(0))
			Debug.Log ("mouse down");
		Input.GetAxis("Mouse X");//鼠标横向增量（横向移动）
		Input.GetAxis("Mouse Y");//鼠标纵向增量（纵向移动）
        */
	/*
		//旋转
		this.transform.Rotate (Vector3.up, 0.3f);
		this.transform.Rotate (Vector3.right, 0.3f);
		this.transform.Rotate (Vector3.forward, 0.3F);
*/
	/*
		//缩放
		float speed = 0.1f;
		float x;
		float z;
		x = Input.GetAxis("Horizontal") * Time.deltaTime * speed;    //水平           
		z = Input.GetAxis("Vertical") * Time.deltaTime * speed;      //垂直//"Fire1"，"Fine2"，"Fine3"映射到Ctrl，Alt，Cmd键和鼠标的三键或腰杆按钮。新的输入轴可以在Input Manager中添加。
		transform.localScale += new Vector3(x, 0, z);
	*/
		//鼠标按着左键移动
/*
	void Update()
	{
		move ();
	}
	void move()//move函数可复用
	{   float speed = 0.1f;
		float y;
		float x;
		if (Input.GetMouseButton (0)){
			y = Input.GetAxis ("Mouse X") * Time.deltaTime * speed;
			x = Input.GetAxis ("Mouse Y") * Time.deltaTime * speed;
			transform.Translate(x*5,y*5,0);
			Debug.Log("x="+x);
			Debug.Log("y="+y);
		}
	}
*/
/*
	float speed = 100.0f;
	float x;
	float z;
	float y;
  //鼠标控制旋转
	void Update () {
		if(Input.GetMouseButton(0)){//鼠标按着左键移动
			y = Input.GetAxis("Mouse X") * Time.deltaTime * speed;
			x = Input.GetAxis("Mouse Y") * Time.deltaTime * speed;
			Debug.Log("X="+x);
			Debug.Log("y="+y);
		}
		else{x = y = 0 ;}//检测鼠标如果没有在按压状态下移动的话，返回坐标归零
		transform.Rotate(new Vector3(x,y,0));
		/**---------------其它旋转方式----------------**///transform.Rotate(Vector3.up *Time.deltaTime * speed);//绕Y轴 旋转//用于平滑旋转至自定义目标
	/*	pinghuaxuanzhuan();}
			//平滑旋转至自定义角度
	void OnGUI(){if(GUI.Button(new Rect(Screen.width - 110,10,100,50),"set Rotation")){//自定义角度
			targetRotation = Quaternion.Euler(45.0f,45.0f,45.0f);// 直接设置旋转角度
        iszhuan = true;}
		}
		bool iszhuan= false;
		Quaternion targetRotation;
		void pinghuaxuanzhuan(){if(iszhuan){
				transform.rotation = Quaternion.Slerp(transform.rotation, targetRotation, Time.deltaTime * 3);//平缓旋转函数可复用
			}
		}
       */
		/*
		 * 脚本bug处理总结：
		 * 1，情况一：官方样板如果出现bug，则为编译框架问题改正方法：project->assembly csoption->build/general->target framework由3.5改为4.5
		 * 2，情况二：如果提示符号问题，很可能是空格所带来的问题，mono对编辑区空格宽容度较低，提示脚本中某行的问题，如果确定语法没错，很可能是因为空格的问题
		 * 3，情况三：单精度后必须加f  1.0 错  1.0f对
		 * 4，情况四：复制粘贴的代码需要大量精力来重新对格式进行debug，因此如果不是两三百行以上，尽量自己重写
		 * 5，情况五：如果编译错误很可能是因为空白区域留有字符
		 * /
*/
}

using UnityEngine;
using System.Collections;
public class camral : MonoBehaviour {
	public Vector3 v1, v2;
	public GameObject cube;
	// Use this for initialization
	void Start () {
		cube =  GameObject.Find("House N251015");//house xxxx为物体的名字
	}
	// Update is called once per frame
	void Update () {
		if (Input.GetKey (KeyCode.UpArrow))
			this.transform.RotateAround (cube.transform.position, Vector3.right, Time.deltaTime*10f);
		if (Input.GetKey (KeyCode.DownArrow))
			this.transform.RotateAround (cube.transform.position, Vector3.left, Time.deltaTime * 10f);
		if (Input.GetKey (KeyCode.LeftArrow))
			this.transform.RotateAround (cube.transform.position, Vector3.down, Time.deltaTime * 10f);
		if (Input.GetKey (KeyCode.RightArrow))
			this.transform.RotateAround (cube.transform.position, Vector3.up, Time.deltaTime * 10f);
	}
}

using UnityEngine;
using System.Collections;
public class world_v : MonoBehaviour {
	public GameObject cube;
	// Use this for initialization
	void Start () {
		this.cube.transform.position = new Vector3 (0f, 0f, 0f);
	}
	// Update is called once per frame
	void Update () {
		if(Input.GetKey(KeyCode.UpArrow))
		{
			Debug.Log ("up");
			this.cube.transform.Translate(Vector3.up * Time.deltaTime, Space.World);
		//	this.cube.transform.Translate(0f,0.1f,0f);
		}
		if(Input.GetKey(KeyCode.LeftArrow))
		{
			Debug.Log("left");
			this.cube.transform.Translate(Vector3.left * Time.deltaTime, Space.World);
		}
			//this.cube.transform.Translate(-0.1f,0f,0f);}
		if(Input.GetKey(KeyCode.DownArrow))
		{   
			Debug.Log("down");
			this.cube.transform.Translate(Vector3.down * Time.deltaTime, Space.World);
		//this.cube.transform.Translate(0f,-0.1f,0f);
		}
		if(Input.GetKey(KeyCode.RightArrow))
		{   
			Debug.Log("right");
			this.cube.transform.Translate(Vector3.right * Time.deltaTime, Space.World);
			//this.cube.transform.Translate(0.1f,0f,0f);
		}
		if (Input.GetKey (KeyCode.W)) {
			Debug.Log ("z+");
			this.cube.transform.Translate(Vector3.forward * Time.deltaTime, Space.World);
		//	this.cube.transform.Translate (0f, 0f, 0.1f);
		}
		if (Input.GetKey (KeyCode.S)) {
			Debug.Log("z-");
			this.cube.transform.Translate(Vector3.back* Time.deltaTime, Space.World);
			//this.cube.transform.Translate(0f,0f,-0.1f);
//________________________________________________________________
		}
		if (Input.GetKey (KeyCode.Y)) {
			//this.cube.transform.Rotate(new Vector3(1,0,0));
			this.cube.transform.Rotate(Vector3.up *1f, Space.World);
		}
		if(Input.GetKey(KeyCode.U))
		{
			//this.cube.transform.Rotate(new Vector3(0,1,0));
			this.cube.transform.Rotate(Vector3.left *1f, Space.World);
		}
		if(Input.GetKey(KeyCode.I))
		{
			//this.cube.transform.Rotate(new Vector3(0,0,1));
			this.cube.transform.Rotate(Vector3.forward *1f, Space.World);
		}
		if (Input.GetKey (KeyCode.H)) {
			//this.cube.transform.Rotate(new Vector3(-1,0,0));
			this.cube.transform.Rotate(Vector3.down *1f, Space.World);
		}
		if (Input.GetKey (KeyCode.J)) {
			//this.cube.transform.Rotate(new Vector3(0,-1,0));
			this.cube.transform.Rotate(Vector3.right *1f, Space.World);
		}
		if (Input.GetKey (KeyCode.K)) {
			//this.cube.transform.Rotate(new Vector3(0,0,-1));
			this.cube.transform.Rotate(Vector3.back *1f, Space.World);
		 }
	}
}

using UnityEngine;
using UnityEngine.UI;
using System.Collections;
using System;
using Leap;
using System.Collections.Generic;

   public HandController  hc;      //控制器    
private HandModel  hm;          //手部模型
public GameObject cubePrefab;   //可不定义
public Vector squizehand;      //紧握得手vector
private GameObject cube = null;
Frame currentFrame = null;//定义当前帧
Frame lastFrame = null;//上一帧

bool squize(float radius)//判断手势是否为握持  阀值为35
	{
		if (radius < 37)
			return true;
		else
			return false;
	}

double distance(Vector a,Vector b)//双手距离判断  退出机制触发阀值为35
	{
		double c=Math.Sqrt (Math.Pow ((a.x-b.x), 2) + Math.Pow ((a.y-b.y), 2) + Math.Pow ((a.z-b.z), 2));
		Debug.Log ("TWO hand distance="+c);
		return c;
	}

hc.GetLeapController().EnableGesture(Gesture.GestureType.TYPECIRCLE);  //环绕
hc.GetLeapController().EnableGesture(Gesture.GestureType.TYPESWIPE); //挥动
hc.GetLeapController().EnableGesture(Gesture.GestureType.TYPE_SCREEN_TAP); // ？
hc.GetLeapController ().EnableGesture (Gesture.GestureType.TYPEKEYTAP);   //点击
hc.GetLeapController ().EnableGesture (Gesture.GestureType.TYPEINVALID);  //无效

foreach (Gesture g in gestures) {
			Debug.Log (g.Type);
			//----code----//
			//此中循环为调取手势列表中预制的手势
			//leap在API中预置了手势即：
			//Gesture.GestureType.TYPESWIPE
			//Gesture.GestureType.TYPE_SCREEN_TAP
			//Gesture.GestureType.TYPEKEYTAP
			//Gesture.GestureType.TYPECIRCLE
			//等
			//以此预制手势来实现操作则在此编码
		}

foreach (Hand hand in frame.Hands) {
		foreach (Gesture g in gestures) {
			Debug.Log (g.Type);
			if (g.Type == Gesture.GestureType.TYPEKEYTAP) {
				Debug.Log("tip position"+hand.PalmPosition);
				}
		}
	}

public  void OnFrame (HandController controller)
	{
		//获取基本信息
		Frame frame = controller.GetFrame();    //当前帧
		Frame lastframe = controller.getlastframe ();//之前帧 星标1后续会重点讲这里记住
		Debug.Log ("Frame id: " + frame.Id                              //帧ID
		           + ", timestamp: " + frame.Timestamp                  //帧时间戳：从捕捉开始经过了多少毫秒
		           + ", hands: " + frame.Hands.Count                    //有几只手
		           + ", fingers: " + frame.Fingers.Count                //有几只手指
		           + ", tools: " + frame.Tools.Count                    //有几个工具
		           + ", gestures: " + frame.Gestures ().Count);         //手势计数
		Debug.Log ("lastFrame id: " + lastframe.Id
		           + ", lasttimestamp: " + lastframe.Timestamp
		           + ", lasthands: " + lastframe.Hands.Count
		           + ", lastfingers: " + lastframe.Fingers.Count
		           + ", lasttools: " + lastframe.Tools.Count
		           + ", lastgestures: " + lastframe.Gestures ().Count);
	}

OnFrame(hc);//平时不必调用

      Frame frame = hc.GetFrame ();
Frame lastframe = hc.getlastframe ();

      this.currentFrame = hc.GetFrame ();
GestureList gestures = this.currentFrame.Gestures ();

      Vector lefthand = null;
Vector righthand = null;
bool lefthandexist = false;//判断左右手是否在场景中存在
bool righthandexist = false;
foreach (var h in hc.GetFrame().Hands) {
	if (h.IsLeft) {
		lefthandexist=true;
		Debug.Log ("lefthand exist? =" + lefthandexist);
		lefthand = h.PalmPosition;
		//____code____//
		/*
	         此中h即为左手，可按照手的一切操作方式来编码
	          */
	}
	if (h.IsRight) {
		righthandexist=true;
		Debug.Log ("righthandexist? =" + righthandexist);
		righthand=h.PalmPosition;
		foreach (Finger finger in righthand.Fingers) {
			Finger.FingerType type=finger.Type();
         	Debug.Log ("    Finger id: " + finger.Id
			               + ", " + finger.Type().ToString()
			               + ", length: " + finger.Length
			               + "mm, width: " + finger.Width + "mm");
			if(type==Finger.FingerType.TYPE_INDEX)// 手指类型的判断
				Debug.Log("tip position="+finger.TipPosition+
				          "tip direction="+finger.Direction);
		//____code____//
	}
	if(lefthandexist&&righthandexist)
	{
		//____code____//
		//如果左右手同时存在情况下的代码放在如下
	}
}

/*控制台输出debug。log与using system之中  console。writeline用法相同
		 * 代码使用foreach来循环以达到返回所有手部数据的要求因此设计中可以带来更多设计
		 * keytap可用来点选
		 * type circle可用来旋转目标
		 * 挥舞可用来滑动菜单
		 * UI检测方式可用跟踪手的位置  如果：palm_position<e(UI模块范围)&&gesture==keytap  则生成交互
		 *
		 * 在此基础上改变交互规则：
		 *
		 * 以下为可收集数据中的注释 全可在以上对帧的循环下执行
		 * WriteLine ("Frame id: " + frame.Id
                    + ", timestamp: " + frame.Timestamp
                    + ", hands: " + frame.Hands.Count
                    + ", fingers: " + frame.Fingers.Count
                    + ", tools: " + frame.Tools.Count
                    + ", gestures: " + frame.Gestures ().Count);
		 * //pass
		 * WriteLine ("  Hand id: " + hand.Id
						+ ", palm position: " + hand.PalmPosition);
			// Get the hand's normal vector and direction
			Vector normal = hand.PalmNormal;
			Vector direction = hand.Direction;
			// 计算手的角度  翻滚，偏离角
			WriteLine ("  Hand pitch: " + direction.Pitch * 180.0f / (float)Math.PI + " degrees, "
                        + "roll: " + normal.Roll * 180.0f / (float)Math.PI + " degrees, "
                        + "yaw: " + direction.Yaw * 180.0f / (float)Math.PI + " degrees");
			// 获得胳膊的骨骼
            Arm arm = hand.Arm;
			WriteLine ("  Arm direction: " + arm.Direction
                        + ", wrist position: " + arm.WristPosition
                        + ", elbow position: " + arm.ElbowPosition);
			// 获得手指  foreach也可嵌套
			foreach (Finger finger in hand.Fingers) {
				SafeWriteLine ("    Finger id: " + finger.Id
					        + ", " + finger.Type().ToString()
					        + ", length: " + finger.Length
					        + "mm, width: " + finger.Width + "mm");
				// 获得手指的骨骼
				Bone bone;
				foreach (Bone.BoneType boneType in (Bone.BoneType[]) Enum.GetValues(typeof(Bone.BoneType)))
				{
					bone = finger.Bone(boneType);
					SafeWriteLine("      Bone: " + boneType
						        + ", start: " + bone.PrevJoint
						        + ", end: " + bone.NextJoint
						        + ", direction: " + bone.Direction);
				}
			}
		 *
		 *
		 *
		 * ——————————————————————————————————————————————————————————————————
		 * 以下为prefab手势的扩展与详解
		 *
		 * 旋转手势  顺时针与逆时针的判断规则：
		 * case Gesture.GestureType.TYPE_CIRCLE:
				CircleGesture circle = new CircleGesture (gesture);
                // Calculate clock direction using the angle between circle normal and pointable
				String clockwiseness;
				if (circle.Pointable.Direction.AngleTo (circle.Normal) <= Math.PI / 2) {
					//Clockwise if angle is less than 90 degrees
					clockwiseness = "clockwise";
				} else {
					clockwiseness = "counterclockwise";
				}
		 * 计算旋转手势转过的角度：
		 * float sweptAngle = 0;//初始化角度为零
                // 计算从上一帧到这一帧的角度
				if (circle.State != Gesture.GestureState.STATE_START) {
					CircleGesture previousUpdate = new CircleGesture (controller.Frame (1).Gesture (circle.Id));
					sweptAngle = (circle.Progress - previousUpdate.Progress) * 360;
				}
				WriteLine ("  Circle id: " + circle.Id
                               + ", " + circle.State
                               + ", progress: " + circle.Progress
                               + ", radius: " + circle.Radius
                               + ", angle: " + sweptAngle
                               + ", " + clockwiseness);
		 *
		 *
		 *
		 */

public Frame GetFrame() {
  if (enableRecordPlayback && recorder_.state == RecorderState.Playing)
    return recorder_.GetCurrentFrame();
  return leap_controller_.Frame();
}

public Frame getlastframe(int i){return leap_controller_.Frame (i);}

if(Input.GetKey(KeyCode.UpArrow))
{
	Debug.Log ("up");
	//this.cube.transform.Translate(0,0.1f,0,Space.World);
		this.cube.transform.Translate(0f,0.1f,0f);
}

using UnityEngine;
using System.Collections;
using LMWidgets;

protected override void Start()
{
  base.Start();
}
protected override void FixedUpdate()
{
  base.FixedUpdate();
  UpdateGraphics();
}

using UnityEngine;
using System;
using System.Collections;
namespace LMWidgets
{
  public abstract class SliderBase : LeapPhysicsSpring, AnalogInteractionHandler<float>, IDataBoundWidget<SliderBase, float>
  {
    protected DataBinderSlider m_dataBinder;
    // Binary Interaction Handler - Fires when interaction with the widget starts.
    public event EventHandler<LMWidgets.EventArg<float>> StartHandler;
    // Analog Interaction Handler - Fires while widget is being interacted with.
    public event EventHandler<LMWidgets.EventArg<float>> ChangeHandler;
    // Binary Interaction Handler - Fires when interaction with the widget ends.
    public event EventHandler<LMWidgets.EventArg<float>> EndHandler;
    public GameObject upperLimit;
    public GameObject lowerLimit;
    protected float m_localTriggerDistance;

using UnityEngine;
using UnityEngine.UI;
using System.Collections;
public class ButtonDemoGraphics : MonoBehaviour
{
	public void SetActive(bool status)
	{
		Renderer[] renderers = GetComponentsInChildren<Renderer>();
		Text[] texts = GetComponentsInChildren<Text>();
		Image[] GUIimages = GetComponentsInChildren<Image>();
		foreach (Renderer renderer in renderers)
		{
			renderer.enabled = status;
		}
		foreach(Text text in texts){
			text.enabled = status;
		}
		foreach(Image image in GUIimages){
			image.enabled = status;
		}
	}
	public void SetColor(Color color)//这个不用我说了吧
	{
		Renderer[] renderers = GetComponentsInChildren<Renderer>();
		Text[] texts = GetComponentsInChildren<Text>();
		Image[] GUIimages = GetComponentsInChildren<Image>();
		//获取组件  
		foreach (Renderer renderer in renderers)
		{
			renderer.material.color = color;
		}
		foreach (Text text in texts){
			text.color = color;
		}
		foreach(Image image in GUIimages){
			image.color = color;
		}
	}
}

using UnityEngine;
using System.Collections;
using LMWidgets;
public class ButtonDemoToggle : ButtonToggleBase
{
  public ButtonDemoGraphics onGraphics;
  public ButtonDemoGraphics offGraphics;
  public ButtonDemoGraphics midGraphics;
  public ButtonDemoGraphics botGraphics;
  public Color MidGraphicsOnColor = new Color(0.0f, 0.5f, 0.5f, 1.0f);
  public Color BotGraphicsOnColor = new Color(0.0f, 1.0f, 1.0f, 1.0f);
  public Color MidGraphicsOffColor = new Color(0.0f, 0.5f, 0.5f, 0.1f);
  public Color BotGraphicsOffColor = new Color(0.0f, 0.25f, 0.25f, 1.0f);
  public override void ButtonTurnsOn()
  {
    TurnsOnGraphics();
  }
  public override void ButtonTurnsOff()
  {
    TurnsOffGraphics();
  }
  private void TurnsOnGraphics()
  {
    onGraphics.SetActive(true);
    offGraphics.SetActive(false);
	midGraphics.SetColor(MidGraphicsOnColor);
	botGraphics.SetColor(BotGraphicsOnColor);
  }
  private void TurnsOffGraphics()
  {
    onGraphics.SetActive(false);
    offGraphics.SetActive(true);
	midGraphics.SetColor(MidGraphicsOffColor);
	botGraphics.SetColor(BotGraphicsOffColor);
  }
  private void UpdateGraphics()
  {
    Vector3 position = transform.localPosition;
    position.z = Mathf.Min(position.z, m_localTriggerDistance);
    onGraphics.transform.localPosition = position;
    offGraphics.transform.localPosition = position;
    Vector3 bot_position = position;
    bot_position.z = Mathf.Max(bot_position.z, m_localTriggerDistance - m_localCushionThickness);
    botGraphics.transform.localPosition = bot_position;
    Vector3 mid_position = position;
    mid_position.z = (position.z + bot_position.z) / 2.0f;
    midGraphics.transform.localPosition = mid_position;
  }
  protected override void Start()
  {
    base.Start();//
  }
  protected override void FixedUpdate()
  {
    base.FixedUpdate();//
    UpdateGraphics();//
  }
}

protected override void Start() {
     if ( m_dataBinder != null ) {
       setButtonState(m_dataBinder.GetCurrentData(), true); // Initilize widget value
     }
     else {
       setButtonState(false, true);
     }
   }

Hand lefthand=null;
Hand righthand = null;
Hand last_lefthand = null;
Hand last_righthand = null;
bool lefthandexist = false;//判断左右手是否在场景中存在
bool righthandexist = false;
double scale=0f;
double dis=0f;
double last_dis= 0f;
double handdis(Hand a,Hand b)
{
	double c=Math.Sqrt (Math.Pow ((a.PalmPosition.x-b.PalmPosition.x), 2) + Math.Pow ((a.PalmPosition.y-b.PalmPosition.y), 2) + Math.Pow ((a.PalmPosition.z-b.PalmPosition.z), 2));
	return c;
}

//左右手模块_________________________________________________________________________________________________________
		foreach (var h in hc.GetFrame().Hands) {
			if (h.IsLeft) {
				lefthandexist = true;
				lefthand = h;
				Debug.Log ("lefthand exist? =" + lefthandexist);
				Debug.Log ("lefthand position=" + lefthand.PalmPosition);
				Debug.Log ("lefthand squize?=" + squize (lefthand.SphereRadius));
			}
			if (h.IsRight) {
				righthandexist = true;
				righthand = h;
				Debug.Log ("righthandexist? =" + righthandexist);
				Debug.Log ("righthand position=" + righthand.PalmPosition);
				Debug.Log ("righthand squize?=" + squize (righthand.SphereRadius));
			}
		}
			if((lefthandexist)&&(righthandexist))
			{
				if((squize(lefthand.SphereRadius))&&(squize(righthand.SphereRadius)))
				{
					foreach (Hand hand in frame.Hands)//当前帧的手
					{
						foreach(Hand lastframe_hand in lastframe.Hands)
						{
							if(hand.IsLeft){lefthand=hand;}
							if(hand.IsRight){righthand=hand;}
							if(lastframe_hand.IsLeft){last_lefthand=lastframe_hand;}
							if(lastframe_hand.IsRight){last_righthand=lastframe_hand;}
						}
				}
				dis=handdis(lefthand,righthand);
				last_dis=handdis(last_lefthand,last_righthand);
				if(dis>last_dis)
				{Debug.Log("++++++++++");
					this.cube.transform.localScale+=(new Vector3(1f,1f,1f));}
				if(dis<last_dis)
				{Debug.Log("__________");
					this.cube.transform.localScale+=(new Vector3(-1f,-1f,-1f));}
				}
			}

protected virtual void ResetPivots()
   {
     m_pivot = transform.localPosition;
     if (m_target != null)
       m_targetPivot = transform.parent.InverseTransformPoint(m_target.transform.position);
   }

protected virtual void OnTriggerEnter(Collider collider)
   {
   //检测是否是手
     if (m_target == null && IsHand(collider) && State != LeapPhysicsState.Disabled)
     {
       State = LeapPhysicsState.Interacting;
       m_target = collider.gameObject;
       ResetPivots();
     }
   }
   protected virtual void OnTriggerExit(Collider collider)
   {
     if (collider.gameObject == m_target)
     {
       State = LeapPhysicsState.Reflecting;
       m_target = null;
     }
   }

private bool IsHand(Collider collider)
{
  return collider.transform.parent && collider.transform.parent.parent &&       collider.transform.parent.parent.GetComponent<HandModel>();
}

protected virtual void FixedUpdate()
   {
     if (m_target == null && State == LeapPhysicsState.Interacting)
     {
       State = LeapPhysicsState.Reflecting;
     }
     switch (State)
     {
       case LeapPhysicsState.Interacting://交互
         ApplyInteractions();
         break;
       case LeapPhysicsState.Reflecting://反映
         ApplyPhysics();
         break;
       case LeapPhysicsState.Disabled://无
         break;
       default:
         break;
     }
     ApplyConstraints();
   }

public enum LeapPhysicsState
  {
    Interacting, // Responsible for moving the widgets with the fingers
    Reflecting, // Responsible for reflecting widget information and simulating the physics
    Disabled // State in  which the widget is disabled
  }

protected virtual void Awake()
   {
     if (GetComponent<Collider>() == null)
     {
       Debug.LogWarning("This Widget lacks a collider. Will not function as expected.");
     }//碰撞其检测与error/warning输出
   }

protected virtual void ResetPivots()
   {
     m_pivot = transform.localPosition;
     if (m_target != null)
       m_targetPivot = transform.parent.InverseTransformPoint(m_target.transform.position);
   }

protected override void ResetPivots() {
   base.ResetPivots();
   m_contentPivot = ContentTransform.localPosition;
 }

//计算一维弹簧力
 protected float calculate1DSpringForce(float offsetVector) {
  float springForce = offsetVector * SnapSpringForce;
  float dampingForce = m_dampingForce * (m_velocity);
  return springForce - dampingForce;
}

protected float calculateOverrunMagnitude() {
//计算超过量（文本边界超过显示边界的量）
   float overrunDistance = 0.0f;
   // Put all positions in object space.
   Vector3 localContentTop = transform.InverseTransformPoint(ContentTopBound.position);
   Vector3 localContentBottom = transform.InverseTransformPoint(ContentBottomBound.position);
   Vector3 localContainerTop = transform.InverseTransformPoint(ContainerTopBound.position);
   Vector3 localContainerBottom = transform.InverseTransformPoint(ContainerBottomBound.position);
   if (localContentTop.y < localContainerTop.y) {
     overrunDistance = localContainerTop.y - localContentTop.y;
   }
   else if (localContentBottom.y > localContainerBottom.y) {
     overrunDistance = localContainerBottom.y - localContentBottom.y;
   }
   return overrunDistance;
 }

protected override void ApplyInteractions() {
  Vector3 targetInteractorPositionChange = transform.parent.InverseTransformPoint(m_target.transform.position) - m_targetPivot;
  targetInteractorPositionChange *= InteractionScale;
  targetInteractorPositionChange.x = 0.0f;
  targetInteractorPositionChange.z = 0.0f;
  Vector3 contentCurrentPosition = ContentTransform.localPosition;
  Vector3 newContentPosition = m_contentPivot + targetInteractorPositionChange;
  Vector3 velocity = (newContentPosition - contentCurrentPosition) / Time.deltaTime;
  m_velocity = velocity.y;
  ContentTransform.localPosition = newContentPosition;
}

public void SetActive(bool status)
	{
		Renderer[] renderers = GetComponentsInChildren<Renderer>();
		Text[] texts = GetComponentsInChildren<Text>();
		Image[] GUIimages = GetComponentsInChildren<Image>();
		foreach (Renderer renderer in renderers)
		{
			renderer.enabled = status;
		}
		foreach(Text text in texts){
			text.enabled = status;
		}
		foreach(Image image in GUIimages){
			image.enabled = status;
		}
	}

public void SetColor(Color color)
	{
		Renderer[] renderers = GetComponentsInChildren<Renderer>();
		Text[] texts = GetComponentsInChildren<Text>();
		Image[] GUIimages = GetComponentsInChildren<Image>();
		foreach (Renderer renderer in renderers)
		{
			renderer.material.color = color;
		}
		foreach (Text text in texts){
			text.color = color;
		}
		foreach(Image image in GUIimages){
			image.color = color;
		}
	}

private void TurnsOnGraphics()
 {
   onGraphics.SetActive(true);
   offGraphics.SetActive(false);
midGraphics.SetColor(MidGraphicsOnColor);
botGraphics.SetColor(BotGraphicsOnColor);
 }
 private void TurnsOffGraphics()
 {
   onGraphics.SetActive(false);
   offGraphics.SetActive(true);
midGraphics.SetColor(MidGraphicsOffColor);
botGraphics.SetColor(BotGraphicsOffColor);
 }

public override void ButtonTurnsOn()
{
  TurnsOnGraphics();
}
public override void ButtonTurnsOff()
{
  TurnsOffGraphics();
}

public override void ButtonTurnsOff()
{
  TurnsOffGraphics();
  Debug.Break();
}

public void SetActive(bool status)
 {
   Renderer[] renderers = GetComponentsInChildren<Renderer>();
   foreach (Renderer renderer in renderers)
   {
     renderer.enabled = status;
   }
 }

public void SetColor(Color color)
 {
   Renderer[] renderers = GetComponentsInChildren<Renderer>();
   foreach (Renderer renderer in renderers)
   {
     renderer.material.color = color;
   }
 }

protected override void sliderPressed()
{
//按下
  base.sliderPressed();
  PressedGraphics();
}
protected override void sliderReleased()
{
//释放
  base.sliderReleased();
  ReleasedGraphics();
}

private void CheckTrigger()
    {
      if (State == LeapPhysicsState.Interacting) {
      //状态确定
        fireSliderChanged (GetSliderFraction ());
        if (m_dataBinder != null) {
          m_dataBinder.SetCurrentData (GetSliderFraction ());
        }
      }
    }

private void onStateChanged(object sender, EventArg<LeapPhysicsState> arg) {
      if ( arg.CurrentValue == LeapPhysicsState.Interacting ) {
        sliderPressed();//按下
      }
      else if ( arg.CurrentValue == LeapPhysicsState.Reflecting ) {
        sliderReleased();//释放
      }
    }

public enum LeapPhysicsState
 {
   Interacting, //手指等  触发按钮
   Reflecting, //模拟物理特性 从触发被改变回到预置位置
   Disabled // 关闭（正常）状态
 }

private void UpdateGraphics()
  {
    float handleFraction = GetHandleFraction();
    Vector3 topPosition = transform.localPosition;
    topPosition.x = 0f;
    topPosition.y = 0f;
    topPosition.z -= (1.0f - handleFraction) * 0.25f;
    topPosition.z = Mathf.Min(topPosition.z, -0.003f); // -0.003 为保证dots和top永不相交的中间层
    topLayer.transform.localPosition = topPosition;
    Vector3 botPosition = transform.localPosition;
    botPosition.x = 0f;
    topPosition.y = 0f;
    botPosition.z = -0.001f;
    botLayer.transform.localPosition = botPosition;
    midLayer.transform.localPosition = (topPosition + botPosition) / 2.0f;
//___________________________________________________________________
    if (activeBar)
    {
      UpdateActiveBar();//激活
    }
    //______________________________________________________________________
    if (numberOfDots > 0)
    {
      UpdateDots();//根据bot的位置判断
    }
  }

private void UpdateDots()
  {
    for (int i = 0; i < dots.Count; ++i)
    {//dot的数量  根据此位置dot的x坐标 和 top的x轴自身坐标对比判断 来逐个绘制 小于高亮  大于常亮
      if (dots[i].transform.localPosition.x < transform.localPosition.x)
      {
        Renderer[] renderers = dots[i].GetComponentsInChildren<Renderer>();
        foreach (Renderer renderer in renderers)
        {
		  renderer.material.color = DotsOnColor;
          renderer.material.SetFloat("_Gain", 3.0f);//高亮
        }
      }
      else
      {
        Renderer[] renderers = dots[i].GetComponentsInChildren<Renderer>();
        foreach (Renderer renderer in renderers)
        {
          renderer.material.color = DotsOffColor;
          renderer.material.SetFloat("_Gain", 1.0f);//常亮
        }
      }
    }
  }

public void SetWidgetValue(float value) {
     if ( State == LeapPhysicsState.Interacting || State == LeapPhysicsState.Disabled ) { return; } // 使得状态在交互过程中稳定
     SetPositionFromFraction (value);
   }

protected virtual void FixedUpdate()
{
  if (m_target == null && State == LeapPhysicsState.Interacting)
  {
    State = LeapPhysicsState.Reflecting;
  }
  switch (State)
  {
    case LeapPhysicsState.Interacting://交互状态
      ApplyInteractions();
      break;
    case LeapPhysicsState.Reflecting://从交互状态返回正常状态
      ApplyPhysics();
      break;
    case LeapPhysicsState.Disabled://关闭（正常）状态
      break;
    default:
      break;
  }
  ApplyConstraints();
}

 //进入
 void OnTriggerEnter(Collider other) {
 		Text text = other.GetComponentInChildren<Text>();
    if (text == null) { return; }
		text.color = Color.white;
	}
//保持
	void OnTriggerStay(Collider other){
		Text text = other.GetComponentInChildren<Text>();
    if (text == null) { return; }
		text.color = Color.white;
		CurrentHilightValue = text.text;
	}
	//离开
	void OnTriggerExit(Collider other) {
    Text text = other.GetComponentInChildren<Text> ();
    if (text == null) { return; }
    text.color = textColor;
	}

void OnTriggerEnter(Collider other) {
   Text text = other.GetComponentInChildren<Text> ();
   if (text == null) { return; }
   text.enabled = false;//设置隐藏
}
void OnTriggerExit(Collider other) {
   Text text = other.GetComponentInChildren<Text> ();
   if (text == null) { return; }
   text.enabled = true;//设置显示
}

float opacityMod = FadeCurve.Evaluate(referenceDotDirection);//计算不透明度模
float goalOpacity = m_originalLabelOpacity * opacityMod;//目标透明度

  foreach(Text textComponent in m_textLabels) {
  //遍历设定
  Color textColor = textComponent.color;
  textColor.a = goalOpacity;//对文字颜色的Alpha通道进行修改
  textComponent.color = textColor;
}

private void generateAndLayoutLabels() {
     float currentLayoutXAngle = LabelAngleRangeStart;
     for( int i=1; i<=DialLabels.Count; i++ ) {
       Transform labelPrefab = Instantiate(LabelPrefab, DialCenter.transform.position, transform.rotation) as Transform;
       //生成
       labelPrefab.Rotate(currentLayoutXAngle, 0f, 0f);
       LabelAngles.Add (-currentLayoutXAngle);     
       labelPrefab.parent = DialCenter;
       labelPrefab.localScale = new Vector3(1f, 1f, 1f);
       Text labelText = labelPrefab.GetComponentInChildren<Text>();
       labelText.text = DialLabels[i - 1];
       DialLabelAngles.Add(DialLabels[i - 1], -currentLayoutXAngle);
       labelText.transform.localPosition = new Vector3(0f, 0f, -DialRadius);
       currentLayoutXAngle = ((Mathf.Abs(LabelAngleRangeStart) + Mathf.Abs(LabelAngleRangeEnd))/(DialLabels.Count)) * -i;
       //调整
     }
     LabelPrefab.gameObject.SetActive(false); // Turn off the original prefab that was copied.
   }

   void OnTriggerEnter (Collider other)
{
  if (target_ == null && IsHand (other)) {
  //像之前一样确定触发体是手
    target_ = other.gameObject;//旋转角
    pivot_ = transform.InverseTransformPoint (target_.transform.position) - transform.localPosition;//旋转轴心
    if (GetComponent<Rigidbody>().isKinematic == false)
      transform.GetComponent<Rigidbody>().angularVelocity = Vector3.zero;
    interacting_ = true;
    if (dialGraphics)
      dialGraphics.HilightDial ();
  }
}
void OnTriggerExit (Collider other)
{
  if (other.gameObject == target_) {
    EndInteraction ();//结束交互
  }
}

protected virtual void ApplyRotations ()
{
//旋转至目标角度
  Vector3 curr_direction = transform.InverseTransformPoint (target_.transform.position) - transform.localPosition;
  //轴心
  transform.localRotation = Quaternion.FromToRotation (pivot_, curr_direction) * transform.localRotation;
}

void FixedUpdate ()
{
  if (target_ == null && interacting_) {
    // 当交互时手已经被销毁
    EndInteraction ();//结束交互
  }
  if (target_ != null) {  
    ApplyRotations ();//应用旋转
  }
  ApplyConstraints ();//应用约束以保证交互结束后 返回相应位置
}

using UnityEngine;
using System.Collections;
public class EnhanceItem : MonoBehaviour
{
    // 在ScrollViewitem中的索引
    internal int scrollViewItemIndex = 0;
    // 夹角大小
    internal float angla = 0f;
    // 动画时间值
    internal float dValueTime = 0f;
    // 前后项
    internal EnhanceItem front, back;
	/*
	 *
	 *
	 *
	 *
	 *   internal关键字是类型和类型成员的访问修饰符。只有在同一个程序集的文件中，内部类型或者是成员才可以访问。
	 * 这是msdn上对internal的描述。
	 * 类型就是enum（枚举类型），class（类），interface（接口），struct（结构）等类型。
	 * 类型成员如函数，成员变量等。
	 *
	 * 一个完整的.exe或者是.dll文件就是一个程序集，一般伴随着exe程序集产生的还有一个程序集清单
	 * ，.exe.config文件。下面我就用一个例子来说明“internal关键字是类型和类型成员的访问修饰符。
	 * 只有在同一个程序集的文件中，内部类型或者是成员才可以访问”。
	 *
	 *
	 */
	public int flag = 777;//flag
    private Vector3 targetPos = Vector3.one;
    private Vector3 targetScale = Vector3.one;
    private Transform mTrs;
    private UITexture mTexture;
    void Awake()
    {
        mTrs = this.transform;
        mTexture = this.GetComponent<UITexture>();
    }
    void Start()
    {
        UIEventListener.Get(this.gameObject).onClick = OnClickScrollViewItem;
    }
    // 当点击Item，将该item移动到中间位置
    private void OnClickScrollViewItem(GameObject obj)
    {
        EnhancelScrollView.GetInstance().SetHorizontalTargetItemIndex(scrollViewItemIndex);
    }
    /// <summary>
    /// 更新该Item的缩放和位移
    /// </summary>
    public void UpdateScrollViewItems(float xValue, float yValue, float scaleValue)
    {
        targetPos.x = xValue;
        targetPos.y = yValue;
        targetScale.x = targetScale.y = scaleValue;
        mTrs.localPosition = targetPos;
        mTrs.localScale = targetScale;
    }
    public void SetSelectColor(bool isCenter)
    {
        if (mTexture == null)
            mTexture = this.GetComponent<UITexture>();
        if (isCenter)
            mTexture.color = Color.white;
        else
            mTexture.color = Color.gray;
    }
}

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using Leap;
// [ExecuteInEditMode]
public class EnhancelScrollView : MonoBehaviour
{
    // 含有滑动项目的面板
    public GameObject enhanceScrollView;
    // 缩放曲线
    public AnimationCurve scaleCurve;
    // 位移曲线
    public AnimationCurve positionCurve;
    // 动画时间
    public float duration = 0.2f;
    // 宽度
    public float width = 800.0f;
    // y轴坐标固定值(所有的item的y坐标一致)
    public float yPositionValue = 46.0f;
    // 中间显示目标时间线(0显示第一个，0.5显示中间一个)
    public float horizontalTargetValue = 0.0f;
    // 滑动起始力
    public float touchStartPower = 0.5f;
    // 滑动阻力
    public int touchForce = 120;
    // 目标对象列表
    private List<EnhanceItem> scrollViewItems;
    // 目标对象Widget脚本，用于depth排序
    private List<UITexture> textureTargets;
    // 开始X坐标
    private float startXPos = 0f;
    // 当前处于中间的item
	public EnhanceItem centerItem;
   // 当前出移动中，不能进行点击切换
    private bool isInChange = false;   
    // 位置动画的中间位置时间
    private float positionCenterTime = 0.5f;
    // 当前精度小数位
    private int curACC = 4;
    // 横向变量值
    private float horizontalValue = 0.0f;
    // 移动动画参数
    private float originHorizontalValue = 0.0f;
    private float currentDuration = 0.0f;
    private static EnhancelScrollView instance;
    internal static EnhancelScrollView GetInstance()
    {
        return instance;
    }
     //内部类型或成员才是可访问的
	//__________________________________________________________
//	动作识别部分定义
	public HandController hc;
	Hand lefthand=null;
	Hand righthand = null;
	Hand last_lefthand = null;
	Hand last_righthand = null;
	Frame currentFrame = null;//定义当前帧
	bool lefthandexist = false;//判断左右手是否在场景中存在
	bool righthandexist = false;
	float sweptAngle = 0;//初始化角度为零
	int mark=0;//标记  与下面的函数作用
//	0代表不转动，-1代表向左转，1代表向右转
	//____________________________________________________________
	void checkmark(int sign)
	{
		if (sign == 1) {
			SetHorizontalTargetItemIndex(centerItem.front.scrollViewItemIndex);
		}
		if (sign == -1) {
			SetHorizontalTargetItemIndex(centerItem.back.scrollViewItemIndex);
		}
		mark = 0;
	}
	//执行转动的真正操作  检查标记从而确保只执行一次否则一次挥动将转动多次
    void Awake()
    {
        instance = this;
    }
    void Start()
    {
		hc.GetLeapController().EnableGesture(Gesture.GestureType.TYPECIRCLE);
		hc.GetLeapController().EnableGesture(Gesture.GestureType.TYPESWIPE);
		hc.GetLeapController().EnableGesture(Gesture.GestureType.TYPE_SCREEN_TAP);
		hc.GetLeapController ().EnableGesture (Gesture.GestureType.TYPEKEYTAP);
		hc.GetLeapController ().EnableGesture (Gesture.GestureType.TYPEINVALID);
		//开启所有手势  其实在这个脚本中只开启typeswipe就够了
//		____________________________________________
        InitData();//初始化数据
        // 设置第一个为选中状态
        SetHorizontalTargetItemIndex(0);
    }
    /// <summary>
    /// 初始化数据
    /// </summary>
    private void InitData()
    {
        startXPos = -(width / 2);
        scrollViewItems = new List<EnhanceItem>();
        scrollViewItems.AddRange(enhanceScrollView.GetComponentsInChildren<EnhanceItem>());
        if (textureTargets == null)
            textureTargets = new List<UITexture>();
        float anglaDValue = 360 / scrollViewItems.Count;
        int centerIndex = scrollViewItems.Count / 2;
        for (int i = 0; i < scrollViewItems.Count; i++)
        {
            scrollViewItems[i].scrollViewItemIndex = i;
            scrollViewItems[i].angla = anglaDValue * i;
            scrollViewItems[i].dValueTime = GetCurveTimePos(scrollViewItems[i].angla);
            // 构造环形链
            scrollViewItems[i].front = i == 0 ? scrollViewItems[scrollViewItems.Count - 1] : scrollViewItems[i - 1];
            scrollViewItems[i].back = i == (scrollViewItems.Count - 1) ? scrollViewItems[0] : scrollViewItems[i + 1];
            UITexture tmpTexture = scrollViewItems[i].gameObject.GetComponent<UITexture>();
            textureTargets.Add(tmpTexture);
            scrollViewItems[i].SetSelectColor(false);//设为选中状态 调用了enhanceitem中的方法将mtexture中的混合颜色设为白色以显示高亮
        }
    }
	//_____________________________________________________________________________________________
    void Update()
    {
        if (!isInChange)
        {
            touch();
            return;
        }
        currentDuration += Time.deltaTime;
        float percent = currentDuration / duration;
        horizontalValue = Mathf.Lerp(originHorizontalValue, horizontalTargetValue, percent);
        UpdateEnhanceScrollView(horizontalValue);
        SortDepth();
        if (currentDuration > duration)
        {
            centerItem = textureTargets[textureTargets.Count - 1].gameObject.GetComponent<EnhanceItem>();
            centerItem.SetSelectColor(true);
            isInChange = false;
        }
    }
    /// <summary>
    /// 更新水平滚动
    /// </summary>
    /// <param name="fValue"></param>
    private void UpdateEnhanceScrollView(float fValue)
    {
        for (int i = 0; i < scrollViewItems.Count; i++)
        {
            EnhanceItem itemScript = scrollViewItems[i];
            float xValue = GetXPosValue(fValue, itemScript.dValueTime);
            float scaleValue = GetScaleValue(fValue, itemScript.dValueTime);
            itemScript.UpdateScrollViewItems(xValue, yPositionValue, scaleValue);
        }
    }
    //滑动X轴增量位置
    float xMoved;
    private void touch()
    {
        // 记录滑动位置
        if (Input.touchCount == 1 && Input.GetTouch(0).phase == TouchPhase.Moved)
        {
            //获取手指自最后一帧的移动
            float x = Input.GetTouch(0).deltaPosition.x;
            xMoved = x;
        }
        // 滑动结束时判断故事翻页
        if (Input.touchCount == 1 && Input.GetTouch(0).phase == TouchPhase.Ended)
        {
            if (centerItem == null || Mathf.Abs(xMoved) < touchStartPower)
                return;
            int count = (int)(Mathf.Abs(xMoved * scrollViewItems.Count/ touchForce)) + 1;   
            int minHalfCount = Mathf.CeilToInt((float)scrollViewItems.Count / 2) - 1;
            if (count > minHalfCount)
            {
                count = minHalfCount;
            }
            if(xMoved > 0)
            {
                SetHorizontalTargetItemIndex(GetMoveIndex(centerItem, -count));
            }
            else if (xMoved < 0)
            {
                SetHorizontalTargetItemIndex(GetMoveIndex(centerItem, count));
            }
            xMoved = 0;
        }
    }
    /// <summary>
    /// 缩放曲线模拟当前缩放值
    /// </summary>
    private float GetScaleValue(float sliderValue, float added)
    {
        float scaleValue = scaleCurve.Evaluate(positionCenterTime + sliderValue + added);
        return scaleValue;
    }
    /// <summary>
    /// 位置曲线模拟当前x轴位置
    /// </summary>
    private float GetXPosValue(float sliderValue, float added)
    {
        float evaluateValue = startXPos + positionCurve.Evaluate(positionCenterTime + sliderValue + added) * width;
        return evaluateValue;
    }
    /// <summary>
    /// 计算位置动画中的时间点
    /// </summary>
    /// <param name="anga">角度值,360度=1</param>
    /// <returns></returns>
    private float GetCurveTimePos(float anga)
    {
        // 设定0.5为位置中间
        return Round(anga / 360f, curACC);
    }
    // 获取项目A到项目B之间最小的时间差值（圆形角度计算,1=360度）
    private float GetCurveTimeDValue(EnhanceItem itemA, EnhanceItem itemB)
    {
        return Round((Mathf.DeltaAngle(itemA.angla, itemB.angla)) / 360f, curACC);
    }
    private void SortDepth()
    {
        textureTargets.Sort(new CompareDepthMethod());
        for (int i = 0; i < textureTargets.Count; i++)
            textureTargets[i].depth = i;
    }
    /// <summary>
    /// 用于层级对比接口
    /// </summary>
    private class CompareDepthMethod : IComparer<UITexture>
    {
        public int Compare(UITexture left, UITexture right)
        {
            if (left.transform.localScale.x > right.transform.localScale.x)
                return 1;
            else if (left.transform.localScale.x < right.transform.localScale.x)
                return -1;
            else
                return 0;
        }
    }
	//核心滚动函数
    /// <summary>
    /// 设置横向轴参数，根据缩放曲线和位移曲线更新缩放和位置
    /// </summary>
    internal void SetHorizontalTargetItemIndex(int itemIndex)
    {
        if (isInChange)
            return;
        EnhanceItem item = scrollViewItems[itemIndex];//_____________新场景中根据这个来判断
        if (centerItem == item)
            return;
		Debug.Log ("item = " + item.name);
		if (item.name == "Texture01") {
			//Debug.Log("YES");
		}
//		_________________________________________________________________________________________
        float dvalue = centerItem == null ? 0 : GetCurveTimeDValue(centerItem, item);
        // 更改target数值，平滑移动,设负数倒着转
        horizontalTargetValue += -dvalue;
        beginScroll(horizontalValue, horizontalTargetValue);
    }
	void FixedUpdate()
	{
//		___________________________________________________________________________________手势swipe模块
		this.currentFrame = hc.GetFrame ();
		Frame frame = hc.GetFrame ();
		Frame lastframe = hc.getlastframe ();
		GestureList gestures = this.currentFrame.Gestures ();
		Vector swipedirection=null;
		foreach (Gesture g in gestures) {
			if(g.Type==Gesture.GestureType.TYPE_SWIPE)
			{
				SwipeGesture swipe=new SwipeGesture(g);
				swipedirection=swipe.Direction;
				//Debug.Log("direction is "+swipedirection);
			}
		}
		if (swipedirection.x > 0) {//判断手势向左还是向右参数向左则小于0向右则大于0
			Debug.Log("right");		
			mark=1;
		}
		if (swipedirection.x < 0) {
			Debug.Log("left");
			mark=-1;
		}
		checkmark (mark);//检查参数以完成UI的旋转
//		————————————————————————————————————————————————————————————————————————————————————————————————————————————
	}
    /// <summary>
    /// 开始滚动
    /// </summary>
    /// <param name="startTime"></param>
    /// <param name="endTime"></param>
    private void beginScroll(float startTime, float endTime)
    {
        if (isInChange)
            return;
        foreach (EnhanceItem item in scrollViewItems)
        {
            item.SetSelectColor(false);
        }
        originHorizontalValue = Round(startTime, curACC);
        horizontalTargetValue = Round(endTime, curACC);
        currentDuration = 0.0f;
        isInChange = true;
    }
    /// <summary>
    /// 向右选择角色按钮
    /// </summary>
    public void OnBtnRightClick()
    {
        if (isInChange)
            return;
        SetHorizontalTargetItemIndex(centerItem.back.scrollViewItemIndex);
    }
    /// <summary>
    /// 向左选择按钮
    /// </summary>
    public void OnBtnLeftClick()
    {
        if (isInChange)
            return;
        SetHorizontalTargetItemIndex(centerItem.front.scrollViewItemIndex);
    }
    /// <summary>
    /// 获取移动后的项目索引
    /// </summary>
    /// <param name="item">当前项目</param>
    /// <param name="count">移动位数，负数表示倒移</param>
    /// <returns></returns>
    private int GetMoveIndex(EnhanceItem item, int count)
    {
        EnhanceItem curItem = item;
        for (int i = 0; i < Mathf.Abs(count); i++)
        {
            curItem = count > 0 ? curItem.back : curItem.front;
        }
        return curItem.scrollViewItemIndex;
    }
    /// <summary>
    /// 按指定小数位舍入
    /// </summary>
    /// <param name="f"></param>
    /// <param name="acc"></param>
    /// <returns></returns>
    private float Round(float f, int acc)
    {
        float temp = f * Mathf.Pow(10, acc);
        return Mathf.Round(temp) / Mathf.Pow(10, acc);
    }
    /// <summary>
    /// 截取小数
    /// </summary>
    /// <param name="f"></param>
    /// <returns></returns>
    private float CutDecimal(float f) {
        return f - (int)f;
    }
}

scrollViewItems = new List<EnhanceItem>();
scrollViewItems.AddRange(enhanceScrollView.GetComponentsInChildren<EnhanceItem>());

using UnityEngine;
using System.Collections;
using Leap;
public class ray : MonoBehaviour {
	public hand_script2 control_script;//控制脚本定义
	public HandController hc=null;
	public RaycastHit hit;
	public Vector3 handdir;
	public Vector3 handpos;
	//public GameObject cube = null;
	public GameObject highlight=null;
	float hx, hy, hz=0;
	float dx, dy, dz = 0;
	public GameObject particle_light=null;
	float xr,yr,zr;
	private float index=0;
	Hand lefthand=null;
	Hand righthand=null;
	public GameObject color_apply=null;
	Color origin=Color.black;
	public Color apply_color;
//	______________________________________________________________
	bool squize(float radius)//判断手势是否为握持  阀值为35
	{
		if (radius < 37)
			return true;
		else
			return false;
	}
//	---------------------------------------------------------------------------
	private bool IsHand(Collider collider)
	{
		return collider.transform.parent && collider.transform.parent.parent && collider.transform.parent.parent.GetComponent<HandModel>();
	}//判断触发器是否是手
	void Awake()
	{
	}
	// Use this for initialization
	void Start () {
		Debug.Log ("Start");
		//空间两点距离计算：sqrt(pow(x1-x2，2)+pow(y1-y2，2)+pow(z1-z2，2))
		index = hc.transform.localScale.x / 1000;//计算后面的缩放指数
	}
	// Update is called once per frame
	void Update () {
		bool lefthandexit = false;
		bool righthandexit = false;
		//Debug.Log ("Update");
		//Vector3 fwd = new Vector3 (0, 0,10 );
		Frame frame = hc.GetFrame ();
		Frame lastframe = hc.getlastframe ();
	    apply_color = color_apply.gameObject.GetComponent<RGB> ().rgb;//获取color混合界面的颜色值可去掉
		foreach (Hand hand in frame.Hands) {
			if (hand.IsLeft) {
				lefthandexit = true;
				lefthand = hand;
			}
			if (hand.IsRight) {
				righthandexit = true;
				righthand = hand;
				foreach (Finger finger in righthand.Fingers) {
					Finger.FingerType type=finger.Type();
					if (type == Finger.FingerType.TYPE_INDEX) {
						dx = finger.Direction.x;
						dy = finger.Direction.y;
						dz = finger.Direction.z;
						hx = finger.TipPosition.x;
						hy = finger.TipPosition.y;
						hz = finger.TipPosition.z;
					}
                  //获取中指的信息finger_INDEX
				}
				//dx = hand.Direction.x;
				//dy = hand.Direction.y;
				//dz = hand.Direction.z;
				handdir = new Vector3 (dx*index,dy*index,-dz*index);//必须乘指数
				//				----------------------------------------------------------------------
				//hx = hand.PalmPosition.x;
				//hy = hand.PalmPosition.y;
				//hz = hand.PalmPosition.z;
				handpos = new Vector3 (hx*index, hy*index,-hz*index);//同样乘指数
				//				----------------------------------------------------------
				//Debug.Log ("righthand_position is " + handpos + "righthand dir is " + handdir);
				//Debug.Log ("reall date is" + hand.PalmPosition + " /// " + hand.Direction);
				xr = hand.RotationAngle (lastframe, Vector.XAxis);
				yr = hand.RotationAngle (lastframe, Vector.YAxis);
				zr = hand.RotationAngle (lastframe, Vector.ZAxis);
			}
		}
		//cube.transform.Rotate (new Vector3(xr*index,yr*index,-zr*index),Space.World);
        //原先用cube表示手的信息与射线做对照
		/*
		float x = this.transform.rotation.x;
		float y = this.transform.rotation.y;
		float z = this.transform.rotation.z;
		Vector3 rota = new Vector3 (x, y, z);
		Debug.Log ("this.position=" + this.transform.position);
		dx = this.transform.position.x;
		dy = this.transform.position.y;
		dz = this.transform.position.z;
		Vector3 position = new Vector3 (dx,dy+100,dz);
   */
		if (squize(lefthand.SphereRadius) && (!squize (righthand.SphereRadius))) {
		//如果左手握持且右手不握持
		//bool Physics.Raycast(Ray ray, Vector3 direction, RaycastHit out hit, float distance, int layerMask)
		if (Physics.Raycast(handpos,handdir,out hit,10000,1)) {
         //(Physics.Raycast(射出点,射出方向向量,输出触发信息存储点,长度,1))
			particle_light.transform.position =new Vector3(hit.point.x,hit.point.y,hit.point.z-2);//此处为粒子系统  用粒子系统跟随触发点以显示触发位置
				if ((highlight.gameObject.name.ToString() != hit.collider.gameObject.name.ToString()) &&
					origin == Color.black&&
					(!IsHand(hit.collider))&&
					(hit.collider.gameObject.GetComponent<Renderer>()!=null)) {
              //判断是否第一次触发
				Debug.Log ("first");
				highlight = hit.collider.gameObject;
				control_script.main_son = hit.collider.gameObject;
				origin = highlight.gameObject.GetComponent<Renderer> ().material.color;
				highlight.gameObject.GetComponent<Renderer> ().material.color = Color.gray;
				}
				if ((highlight.gameObject.name.ToString () != hit.collider.gameObject.name.ToString ()) &&
					origin != Color.black&&
					(!IsHand(hit.collider))&&
					((hit.collider.gameObject.GetComponent<Renderer>()!=null)))	{
					//判断是否变更触发物体
				Debug.Log ("change");
				control_script.main_son = hit.collider.gameObject;
				highlight.gameObject.GetComponent<Renderer> ().material.color = origin;
				highlight = hit.collider.gameObject;
				origin = highlight.gameObject.GetComponent<Renderer> ().material.color;
				highlight.gameObject.GetComponent<Renderer> ().material.color = Color.gray;
			}
//以上用来交换信息  坐到触发高亮
			/*
			if((highlight.gameObject.name.ToString()==hit.collider.gameObject.name.ToString())&&origin!=Color.black)
			{
				highlight = hit.collider.gameObject;
				highlight.gameObject.GetComponent<Renderer> ().material.color = Color.red;
			}
			*/
			//hit.collider.gameObject.GetComponent<Renderer> ().material.color = Color.red;
			Debug.Log ("OBJ-name is " + hit.collider.gameObject);
			//Debug.Log ("hit point is " + hit.point + " distance = " + hit.distance);
			//Debug.Log ("Success");
			Debug.DrawLine (handpos, hit.point, Color.red);
			//在sence中显示射线并设置为红色
				//Debug.Break ();
		}
		if (lefthandexit==true) {
			Debug.Log ("________________");
			//Debug.Break();
		}
	}
	}
}
	//射线脚本bug汇总：
	/*
	 * 1.发射点以世界坐标为准则：
	 * 如handcontroller的放大倍率为100则数乘index指数为0.1
	 * 2.必须将控制器的位置考虑进去
	 * 3.射线距离尽可能大
	 */