Mercurial > hg > Game > Games

comparison Orchestland/Assets/LeapMotion/DemoResources/Scripts/StemMesh.cs @ 3:0030a1b971fb default tip

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
merge
author Yuta ANSE <e135745@ie.u-ryukyu.ac.jp>
date Fri, 17 Jul 2015 23:23:43 +0900
parents f7675884f2a1
children
comparison
equal deleted inserted replaced
2:fdab88fc2cb9 3:0030a1b971fb
1 /******************************************************************************\
2 * Copyright (C) Leap Motion, Inc. 2011-2014. *
3 * Leap Motion proprietary. Licensed under Apache 2.0 *
4 * Available at http://www.apache.org/licenses/LICENSE-2.0.html *
5 \******************************************************************************/
6
7 using UnityEngine;
8 using System.Collections;
9
10 public class StemMesh : MonoBehaviour {
11
12 const int TRIANGLE_INDICES_PER_QUAD = 6;
13 const int VERTICES_PER_QUAD = 4;
14
15 public Collider[] segments;
16 public int sides = 4;
17 public AnimationCurve stemCurve;
18 public float growthProgress = 0.0f;
19 public float stumpDiminishTime = 2.0f;
20
21 private Vector3[] vertices_;
22 private bool[] broken;
23 private float stump_width_ = 1.0f;
24 private bool is_diminishing_ = false;
25
26 void Start () {
27 broken = new bool[segments.Length];
28 for (int i = 0; i < broken.Length; ++i)
29 broken[i] = false;
30
31 MeshFilter filter = GetComponent<MeshFilter>();
32 filter.mesh = new Mesh();
33 InitMesh();
34 filter.mesh.RecalculateBounds();
35 filter.mesh.RecalculateNormals();
36 }
37
38 void Update () {
39 UpdateMesh();
40 MeshFilter filter = GetComponent<MeshFilter>();
41
42 filter.mesh.MarkDynamic();
43 filter.mesh.vertices = vertices_;
44 filter.mesh.RecalculateBounds();
45 filter.mesh.RecalculateNormals();
46 }
47
48 public bool IsBroken() {
49 if (broken == null)
50 return false;
51
52 for (int i = 0; i < broken.Length; ++i) {
53 if (broken[i])
54 return true;
55 }
56 return false;
57 }
58
59 public bool IsStumpClear() {
60 return stump_width_ == 0.0f;
61 }
62
63 public void RemoveStump() {
64 is_diminishing_ = true;
65 }
66
67 private void InitMesh() {
68 Mesh mesh = GetComponent<MeshFilter>().mesh;
69
70 int num_vertices = sides * segments.Length;
71 vertices_ = new Vector3[num_vertices];
72 Vector2[] uv = new Vector2[num_vertices];
73
74 int[] triangles = new int[TRIANGLE_INDICES_PER_QUAD * (num_vertices - sides)];
75
76 for (int v = 0; v < num_vertices; ++v) {
77 vertices_[v] = new Vector3(0, 0, 0);
78 uv[v] = new Vector3(0, 0, 0);
79 }
80
81 int vertex_index = 0;
82 for (int seg = 0; seg < segments.Length - 1; ++seg) {
83 if (segments[seg + 1].GetComponent<HingeJoint>() == null) {
84 for (int i = 0; i < sides * TRIANGLE_INDICES_PER_QUAD; ++i)
85 triangles[vertex_index++] = 0;
86 }
87 else {
88 for (int side = 0; side < sides; ++side) {
89 int next_side = (side + 1) % sides;
90 triangles[vertex_index++] = sides * seg + side;
91 triangles[vertex_index++] = sides * seg + next_side;
92 triangles[vertex_index++] = sides * (seg + 1) + next_side;
93
94 triangles[vertex_index++] = sides * seg + side;
95 triangles[vertex_index++] = sides * (seg + 1) + next_side;
96 triangles[vertex_index++] = sides * (seg + 1) + side;
97 }
98 }
99 }
100
101 mesh.vertices = vertices_;
102 mesh.uv = uv;
103 mesh.triangles = triangles;
104 }
105
106 protected void Separate(int index) {
107 for (int i = 0; i < index; ++i)
108 segments[i] = null;
109 }
110
111 private void Break(int index) {
112 for (int i = index; i < segments.Length; ++i) {
113 segments[i] = null;
114 }
115 }
116
117 private void KillStump() {
118 for (int i = 0; i < broken.Length && !broken[i]; ++i)
119 segments[i].GetComponent<Collider>().enabled = false;
120 }
121
122 private void UpdateMesh() {
123 if (is_diminishing_ && stump_width_ != 0.0f) {
124 stump_width_ -= Time.deltaTime / stumpDiminishTime;
125 stump_width_ = Mathf.Clamp(stump_width_, 0.0f, 1.0f);
126 if (stump_width_ == 0.0f)
127 KillStump();
128 }
129
130 for (int i = 0; i < segments.Length; ++i) {
131 if (!broken[i] && segments[i].GetComponent<HingeJoint>() == null) {
132 InitMesh();
133 broken[i] = true;
134 }
135 }
136
137 int vertex_index = 0;
138 float angle = 360.0f / sides;
139
140 bool is_stump = true;
141 for (int i = 0; i < segments.Length; ++i) {
142 float phase = (1.0f * i) / (segments.Length - 1);
143 float width = Mathf.Clamp(segments.Length * growthProgress - i, 0.0f, 1.0f);
144
145 is_stump = is_stump && !broken[i];
146 if (is_stump)
147 width *= stump_width_;
148
149 Vector3 offset = new Vector3(width * stemCurve.Evaluate(phase), 0, 0);
150
151 for (int side = 0; side < sides; ++side) {
152 vertices_[vertex_index++] =
153 transform.InverseTransformPoint(segments[i].transform.TransformPoint(offset));
154 offset = Quaternion.AngleAxis(angle, Vector3.up) * offset;
155 }
156 }
157 }
158 }