2016. 2. 22. 05:45

[Unity3D] 간단한 데이터 저장을 위한 PlayerPrefs 클래스 사용법

프로그래밍/Unity3D

PlayerPrefs 클래스는 아주 간단한 방법으로 저장할 정보를입력하면 그걸 자동으로 파일로 저장/불러오기를 해 주는데,

 

Mac OS : ~/Library/Preferences 폴더 안에  unity.[companyname].[product name].plist 라는 이름으로 저장됨

윈도우즈 OS : HKCU\Software\[companyname]\[product name] 레지스트리 안에 저장됨

윈도우즈 웹플레이어 : %APPDATA%\Unity\WebPlayerPrefs안에

Mac 웹플레이어 :~/Library/Preferences/Unity/WebPlayerPrefs

 

이 클래스의 원문 링크는

http://docs.unity3d.com/Documentation/ScriptReference/PlayerPrefs.html

 

사용법

 

 

PlayerPrefs의 인자

 

 voidDeleteAll()                              모든 정보를 삭제한다.

 voidDeleteKey(string key)                  특정 키(정보)를 삭제한다.

 float GetFloat(string key)                     float형 정보를 가져온다.

 float GetFloat(string key, float defaultValue)          float형 정보를 가져오는데, 그 키에 대한 값이  없으면 defaultValue로 가져온다.

 intGetInt(string key)     int형 정보를 가져온다.

 intGetInt(string key, int defaultValue)      GetFloat과 마찬가지

 string GetString(string key)        string형 정보를 가져온다.

 stringGetString(string key, string defaultValue)      GetFloat과 마찬가지

 boolHasKey(string key)  이 key가 존재하는가

 voidSave()       PlayerPrefs 클래스에 있는 모든키와 그 정보를

 저장한다.

 voidSetFloat(string key, float value)        float형 값을 클래스에 저장한다.

 voidSetInt(string key, int value)   int형값을 클래스에 저장한다.

 voidSetString(string key, string value)      string형 값을 클래스에 저장한다.

 

 

 

1. 어떤 int 형의숫자 저장하기

 

PlayerPrefs.SetInt("score",score);

PlayerPrefs.Save();

 

PlayerPrefs.SetInt 함수는 인트형 값을 저장하는 함수인데, 앞의 string은 이 값이 뭔지,즉 변수명이라고 보면 된다. 뒤의 int 값은어떤 값을 저장할건지를 말한다.

이렇게 PlayerPrefs 클래스에 score의 값을 넣었으면 그걸 파일에 넣기 위해(저장) PlayerPrefs.Save()를 호출한다.

 

 

 

2. 어떤 int 형의값 가져오기

 

int temp =PlayerPrefs.GetInt("score");

 

temp에다가 내가PlayerPrefs로 저장한 값 중 score라는 키를 가진 값을 가져와서 temp에 저장한다

저작자표시 비영리 변경금지

'프로그래밍 > Unity3D' 카테고리의 다른 글

[Unity3D] 오브젝트를 특정 축을 기준으로 월드/ 로컬 회전 하기  (0) 2016.02.22
[Unity3D] Unity5에서 마우스가 UI위에 있는지 체크하기.  (0) 2016.02.22
[Unity3D] 코드를 이용하여 기본도형 메시 만들기  (0) 2016.02.22
[Unity3D] 유니티를 이용하여 Gmail 보내기  (0) 2016.02.22
[Unity3D] 유니티 메시를 STL(format)으로 변환하여 저장 하기.  (0) 2016.02.22
Posted by 시리시안
2016. 2. 22. 05:44

[Unity3D] 코드를 이용하여 기본도형 메시 만들기

프로그래밍/Unity3D
C# - Plane
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
// You can change that line to provideanother MeshFilter
MeshFilter filter =gameObject.AddComponent< MeshFilter >();
Mesh mesh = filter.mesh;
mesh.Clear();
 
float length = 1f;
float width = 1f;
int resX = 2; // 2 minimum
int resZ = 2;
 
#region Vertices           
Vector3[] vertices = new Vector3[ resX *resZ ];
for(int z = 0; z < resZ; z++)
{
           //[ -length / 2, length / 2 ]
           floatzPos = ((float)z / (resZ - 1) - .5f) * length;
           for(intx = 0; x < resX; x++)
           {
                     //[ -width / 2, width / 2 ]
                     floatxPos = ((float)x / (resX - 1) - .5f) * width;
                     vertices[x + z * resX ] = new Vector3( xPos, 0f, zPos );
           }
}
#endregion
 
#region Normales
Vector3[] normales = new Vector3[vertices.Length ];
for( int n = 0; n < normales.Length; n++)
           normales[n]= Vector3.up;
#endregion
 
#region UVs                
Vector2[] uvs = new Vector2[vertices.Length ];
for(int v = 0; v < resZ; v++)
{
           for(intu = 0; u < resX; u++)
           {
                     uvs[u + v * resX ] = new Vector2( (float)u / (resX - 1), (float)v / (resZ - 1) );
           }
}
#endregion
 
#region Triangles
int nbFaces = (resX - 1) * (resZ - 1);
int[] triangles = new int[ nbFaces * 6 ];
int t = 0;
for(int face = 0; face < nbFaces; face++)
{
           //Retrieve lower left corner from face ind
           inti = face % (resX - 1) + (face / (resZ - 1) * resX);
 
           triangles[t++]= i + resX;
           triangles[t++]= i + 1;
           triangles[t++]= i;
 
           triangles[t++]= i + resX;
           triangles[t++]= i + resX + 1;
           triangles[t++]= i + 1;
}
#endregion
 
mesh.vertices = vertices;
mesh.normals = normales;
mesh.uv = uvs;
mesh.triangles = triangles;
 
mesh.RecalculateBounds();
mesh.Optimize();
 
C# - Box
// You can change that line to provideanother MeshFilter
MeshFilter filter =gameObject.AddComponent< MeshFilter >();
Mesh mesh = filter.mesh;
mesh.Clear();
 
float length = 1f;
float width = 1f;
float height = 1f;
 
#region Vertices
Vector3 p0 = new Vector3( -length * .5f,    -width * .5f, height * .5f );
Vector3 p1 = new Vector3( length * .5f,     -width * .5f, height * .5f );
Vector3 p2 = new Vector3( length * .5f,     -width * .5f, -height * .5f );
Vector3 p3 = new Vector3( -length * .5f,    -width * .5f, -height * .5f );         
 
Vector3 p4 = new Vector3( -length * .5f,    width * .5f, height * .5f );
Vector3 p5 = new Vector3( length * .5f,     width * .5f, height * .5f );
Vector3 p6 = new Vector3( length * .5f,     width * .5f, -height * .5f );
Vector3 p7 = new Vector3( -length * .5f,    width * .5f, -height * .5f );
 
Vector3[] vertices = new Vector3[]
{
           //Bottom
           p0,p1, p2, p3,
 
           //Left
           p7,p4, p0, p3,
 
           //Front
           p4,p5, p1, p0,
 
           //Back
           p6,p7, p3, p2,
 
           //Right
           p5,p6, p2, p1,
 
           //Top
           p7,p6, p5, p4
};
#endregion
 
#region Normales
Vector3 up        =Vector3.up;
Vector3 down    = Vector3.down;
Vector3 front     = Vector3.forward;
Vector3 back     = Vector3.back;
Vector3 left       = Vector3.left;
Vector3 right     = Vector3.right;
 
Vector3[] normales = new Vector3[]
{
           //Bottom
           down,down, down, down,
 
           //Left
           left,left, left, left,
 
           //Front
           front,front, front, front,
 
           //Back
           back,back, back, back,
 
           //Right
           right,right, right, right,
 
           //Top
           up,up, up, up
};
#endregion      
 
#region UVs
Vector2 _00 = new Vector2( 0f, 0f );
Vector2 _10 = new Vector2( 1f, 0f );
Vector2 _01 = new Vector2( 0f, 1f );
Vector2 _11 = new Vector2( 1f, 1f );
 
Vector2[] uvs = new Vector2[]
{
           //Bottom
           _11,_01, _00, _10,
 
           //Left
           _11,_01, _00, _10,
 
           //Front
           _11,_01, _00, _10,
 
           //Back
           _11,_01, _00, _10,
 
           //Right
           _11,_01, _00, _10,
 
           //Top
           _11,_01, _00, _10,
};
#endregion
 
#region Triangles
int[] triangles = new int[]
{
           //Bottom
           3,1, 0,
           3,2, 1,                       
 
           //Left
           3+ 4 * 1, 1 + 4 * 1, 0 + 4 * 1,
           3+ 4 * 1, 2 + 4 * 1, 1 + 4 * 1,
 
           //Front
           3+ 4 * 2, 1 + 4 * 2, 0 + 4 * 2,
           3+ 4 * 2, 2 + 4 * 2, 1 + 4 * 2,
 
           //Back
           3+ 4 * 3, 1 + 4 * 3, 0 + 4 * 3,
           3+ 4 * 3, 2 + 4 * 3, 1 + 4 * 3,
 
           //Right
           3+ 4 * 4, 1 + 4 * 4, 0 + 4 * 4,
           3+ 4 * 4, 2 + 4 * 4, 1 + 4 * 4,
 
           //Top
           3+ 4 * 5, 1 + 4 * 5, 0 + 4 * 5,
           3+ 4 * 5, 2 + 4 * 5, 1 + 4 * 5,
 
};
#endregion
 
mesh.vertices = vertices;
mesh.normals = normales;
mesh.uv = uvs;
mesh.triangles = triangles;
 
mesh.RecalculateBounds();
mesh.Optimize();
cs



C# - Cone


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
//Note that cylinders (bottomRadius ==topRadius) and pyramids (4 sides, topRadius == 0) are types of cones, and canbe created with this script.
MeshFilter filter =gameObject.AddComponent<MeshFilter>();
Mesh mesh = filter.mesh;
mesh.Clear();
 
float height = 1f;
float bottomRadius = .25f;
float topRadius = .05f;
int nbSides = 18;
int nbHeightSeg = 1; // Not implemented yet
 
int nbVerticesCap = nbSides + 1;
#region Vertices
 
// bottom + top + sides
Vector3[] vertices = newVector3[nbVerticesCap + nbVerticesCap + nbSides * nbHeightSeg * 2 + 2];
int vert = 0;
float _2pi = Mathf.PI * 2f;
 
// Bottom cap
vertices[vert++] = new Vector3(0f, 0f, 0f);
while( vert <= nbSides )
{
           floatrad = (float)vert / nbSides * _2pi;
           vertices[vert]= new Vector3(Mathf.Cos(rad) * bottomRadius, 0f, Mathf.Sin(rad) *bottomRadius);
           vert++;
}
 
// Top cap
vertices[vert++] = new Vector3(0f, height,0f);
while (vert <= nbSides * 2 + 1)
{
           floatrad = (float)(vert - nbSides - 1)  /nbSides * _2pi;
           vertices[vert]= new Vector3(Mathf.Cos(rad) * topRadius, height, Mathf.Sin(rad) * topRadius);
           vert++;
}
 
// Sides
int v = 0;
while (vert <= vertices.Length - 4 )
{
           floatrad = (float)v / nbSides * _2pi;
           vertices[vert]= new Vector3(Mathf.Cos(rad) * topRadius, height, Mathf.Sin(rad) * topRadius);
           vertices[vert+ 1] = new Vector3(Mathf.Cos(rad) * bottomRadius, 0, Mathf.Sin(rad) *bottomRadius);
           vert+=2;
           v++;
}
vertices[vert] = vertices[ nbSides * 2 + 2];
vertices[vert + 1] = vertices[nbSides * 2 +3 ];
#endregion
 
#region Normales
 
// bottom + top + sides
Vector3[] normales = newVector3[vertices.Length];
vert = 0;
 
// Bottom cap
while( vert <= nbSides )
{
           normales[vert++]= Vector3.down;
}
 
// Top cap
while( vert <= nbSides * 2 + 1 )
{
           normales[vert++]= Vector3.up;
}
 
// Sides
v = 0;
while (vert <= vertices.Length - 4 )
{                              
           floatrad = (float)v / nbSides * _2pi;
           floatcos = Mathf.Cos(rad);
           floatsin = Mathf.Sin(rad);
 
           normales[vert]= new Vector3(cos, 0f, sin);
           normales[vert+1]= normales[vert];
 
           vert+=2;
           v++;
}
normales[vert] = normales[ nbSides * 2 + 2];
normales[vert + 1] = normales[nbSides * 2 +3 ];
#endregion
 
#region UVs
Vector2[] uvs = newVector2[vertices.Length];
 
// Bottom cap
int u = 0;
uvs[u++] = new Vector2(0.5f, 0.5f);
while (u <= nbSides)
{
   float rad = (float)u / nbSides * _2pi;
   uvs[u] = new Vector2(Mathf.Cos(rad) * .5f + .5f, Mathf.Sin(rad) * .5f +.5f);
   u++;
}
 
// Top cap
uvs[u++] = new Vector2(0.5f, 0.5f);
while (u <= nbSides * 2 + 1)
{
   float rad = (float)u / nbSides * _2pi;
   uvs[u] = new Vector2(Mathf.Cos(rad) * .5f + .5f, Mathf.Sin(rad) * .5f +.5f);
   u++;
}
 
// Sides
int u_sides = 0;
while (u <= uvs.Length - 4 )
{
   float t = (float)u_sides / nbSides;
   uvs[u] = new Vector3(t, 1f);
   uvs[u + 1] = new Vector3(t, 0f);
    u+= 2;
   u_sides++;
}
uvs[u] = new Vector2(1f, 1f);
uvs[u + 1] = new Vector2(1f, 0f);
#endregion
 
#region Triangles
int nbTriangles = nbSides + nbSides +nbSides*2;
int[] triangles = new int[nbTriangles * 3 +3];
 
// Bottom cap
int tri = 0;
int i = 0;
while (tri < nbSides - 1)
{
           triangles[i ] = 0;
           triangles[i+1 ] = tri + 1;
           triangles[i+2 ] = tri + 2;
           tri++;
           i+= 3;
}
triangles[i] = 0;
triangles[i + 1] = tri + 1;
triangles[i + 2] = 1;
tri++;
i += 3;
 
// Top cap
//tri++;
while (tri < nbSides*2)
{
           triangles[i ] = tri + 2;
           triangles[i+ 1] = tri + 1;
           triangles[i+ 2] = nbVerticesCap;
           tri++;
           i+= 3;
}
 
triangles[i] = nbVerticesCap + 1;
triangles[i + 1] = tri + 1;
triangles[i + 2] = nbVerticesCap;             
tri++;
i += 3;
tri++;
 
// Sides
while( tri <= nbTriangles )
{
           triangles[i ] = tri + 2;
           triangles[i+1 ] = tri + 1;
           triangles[i+2 ] = tri + 0;
           tri++;
           i+= 3;
 
           triangles[i ] = tri + 1;
           triangles[i+1 ] = tri + 2;
           triangles[i+2 ] = tri + 0;
           tri++;
           i+= 3;
}
#endregion
 
mesh.vertices = vertices;
mesh.normals = normales;
mesh.uv = uvs;
mesh.triangles = triangles;
 
mesh.RecalculateBounds();
mesh.Optimize();
cs


C# - Tube

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
MeshFilter filter =gameObject.AddComponent<MeshFilter>();
Mesh mesh = filter.mesh;
mesh.Clear();
 
float height = 1f;
int nbSides = 24;
 
// Outter shell is at radius1 + radius2 /2, inner shell at radius1 - radius2 / 2
float bottomRadius1 = .5f;
float bottomRadius2 = .15f;
float topRadius1 = .5f;
float topRadius2 = .15f;
 
int nbVerticesCap = nbSides * 2 + 2;
int nbVerticesSides = nbSides * 2 + 2;
#region Vertices
 
// bottom + top + sides
Vector3[] vertices = newVector3[nbVerticesCap * 2 + nbVerticesSides * 2];
int vert = 0;
float _2pi = Mathf.PI * 2f;
 
// Bottom cap
int sideCounter = 0;
while( vert < nbVerticesCap )
{
           sideCounter= sideCounter == nbSides ? 0 : sideCounter;
 
           floatr1 = (float)(sideCounter++) / nbSides * _2pi;
           floatcos = Mathf.Cos(r1);
           floatsin = Mathf.Sin(r1);
           vertices[vert]= new Vector3( cos * (bottomRadius1 - bottomRadius2 * .5f), 0f, sin * (bottomRadius1- bottomRadius2 * .5f));
           vertices[vert+1]= new Vector3( cos * (bottomRadius1 + bottomRadius2 * .5f), 0f, sin *(bottomRadius1 + bottomRadius2 * .5f));
           vert+= 2;
}
 
// Top cap
sideCounter = 0;
while( vert < nbVerticesCap * 2 )
{
           sideCounter= sideCounter == nbSides ? 0 : sideCounter;
 
           floatr1 = (float)(sideCounter++) / nbSides * _2pi;
           floatcos = Mathf.Cos(r1);
           floatsin = Mathf.Sin(r1);
           vertices[vert]= new Vector3( cos * (topRadius1 - topRadius2 * .5f), height, sin * (topRadius1- topRadius2 * .5f));
           vertices[vert+1]= new Vector3( cos * (topRadius1 + topRadius2 * .5f), height, sin * (topRadius1+ topRadius2 * .5f));
           vert+= 2;
}
 
// Sides (out)
sideCounter = 0;
while (vert < nbVerticesCap * 2 +nbVerticesSides )
{
           sideCounter= sideCounter == nbSides ? 0 : sideCounter;
 
           floatr1 = (float)(sideCounter++) / nbSides * _2pi;
           floatcos = Mathf.Cos(r1);
           floatsin = Mathf.Sin(r1);
 
           vertices[vert]= new Vector3(cos * (topRadius1 + topRadius2 * .5f), height, sin * (topRadius1+ topRadius2 * .5f));
           vertices[vert+ 1] = new Vector3(cos * (bottomRadius1 + bottomRadius2 * .5f), 0, sin *(bottomRadius1 + bottomRadius2 * .5f));
           vert+=2;
}
 
// Sides (in)
sideCounter = 0;
while (vert < vertices.Length )
{
           sideCounter= sideCounter == nbSides ? 0 : sideCounter;
 
           floatr1 = (float)(sideCounter++) / nbSides * _2pi;
           floatcos = Mathf.Cos(r1);
           floatsin = Mathf.Sin(r1);
 
           vertices[vert]= new Vector3(cos * (topRadius1 - topRadius2 * .5f), height, sin * (topRadius1- topRadius2 * .5f));
           vertices[vert+ 1] = new Vector3(cos * (bottomRadius1 - bottomRadius2 * .5f), 0, sin *(bottomRadius1 - bottomRadius2 * .5f));
           vert+= 2;
}
#endregion
 
#region Normales
 
// bottom + top + sides
Vector3[] normales = newVector3[vertices.Length];
vert = 0;
 
// Bottom cap
while( vert < nbVerticesCap )
{
           normales[vert++]= Vector3.down;
}
 
// Top cap
while( vert < nbVerticesCap * 2 )
{
           normales[vert++]= Vector3.up;
}
 
// Sides (out)
sideCounter = 0;
while (vert < nbVerticesCap * 2 +nbVerticesSides )
{
           sideCounter= sideCounter == nbSides ? 0 : sideCounter;
 
           floatr1 = (float)(sideCounter++) / nbSides * _2pi;
 
           normales[vert]= new Vector3(Mathf.Cos(r1), 0f, Mathf.Sin(r1));
           normales[vert+1]= normales[vert];
           vert+=2;
}
 
// Sides (in)
sideCounter = 0;
while (vert < vertices.Length )
{
           sideCounter= sideCounter == nbSides ? 0 : sideCounter;
 
           floatr1 = (float)(sideCounter++) / nbSides * _2pi;
 
           normales[vert]= -(new Vector3(Mathf.Cos(r1), 0f, Mathf.Sin(r1)));
           normales[vert+1]= normales[vert];
           vert+=2;
}
#endregion
 
#region UVs
Vector2[] uvs = newVector2[vertices.Length];
 
vert = 0;
// Bottom cap
sideCounter = 0;
while( vert < nbVerticesCap )
{
           floatt = (float)(sideCounter++) / nbSides;
           uvs[vert++ ] = new Vector2( 0f, t );
           uvs[vert++ ] = new Vector2( 1f, t );
}
 
// Top cap
sideCounter = 0;
while( vert < nbVerticesCap * 2 )
{
           floatt = (float)(sideCounter++) / nbSides;
           uvs[vert++ ] = new Vector2( 0f, t );
           uvs[vert++ ] = new Vector2( 1f, t );
}
 
// Sides (out)
sideCounter = 0;
while (vert < nbVerticesCap * 2 +nbVerticesSides )
{
           floatt = (float)(sideCounter++) / nbSides;
           uvs[vert++ ] = new Vector2( t, 0f );
           uvs[vert++ ] = new Vector2( t, 1f );
}
 
// Sides (in)
sideCounter = 0;
while (vert < vertices.Length )
{
           floatt = (float)(sideCounter++) / nbSides;
           uvs[vert++ ] = new Vector2( t, 0f );
           uvs[vert++ ] = new Vector2( t, 1f );
}
#endregion
 
#region Triangles
int nbFace = nbSides * 4;
int nbTriangles = nbFace * 2;
int nbIndexes = nbTriangles * 3;
int[] triangles = new int[nbIndexes];
 
// Bottom cap
int i = 0;
sideCounter = 0;
while (sideCounter < nbSides)
{
           intcurrent = sideCounter * 2;
           intnext = sideCounter * 2 + 2;
 
           triangles[i++ ] = next + 1;
           triangles[i++ ] = next;
           triangles[i++ ] = current;
 
           triangles[i++ ] = current + 1;
           triangles[i++ ] = next + 1;
           triangles[i++ ] = current;
 
           sideCounter++;
}
 
// Top cap
while (sideCounter < nbSides * 2)
{
           intcurrent = sideCounter * 2 + 2;
           intnext = sideCounter * 2 + 4;
 
           triangles[i++ ] = current;
           triangles[i++ ] = next;
           triangles[i++ ] = next + 1;
 
           triangles[i++ ] = current;
           triangles[i++ ] = next + 1;
           triangles[i++ ] = current + 1;
 
           sideCounter++;
}
 
// Sides (out)
while( sideCounter < nbSides * 3 )
{
           intcurrent = sideCounter * 2 + 4;
           intnext = sideCounter * 2 + 6;
 
           triangles[i++ ] = current;
           triangles[i++ ] = next;
           triangles[i++ ] = next + 1;
 
           triangles[i++ ] = current;
           triangles[i++ ] = next + 1;
           triangles[i++ ] = current + 1;
 
           sideCounter++;
}
 
 
// Sides (in)
while( sideCounter < nbSides * 4 )
{
           intcurrent = sideCounter * 2 + 6;
           intnext = sideCounter * 2 + 8;
 
           triangles[i++ ] = next + 1;
           triangles[i++ ] = next;
           triangles[i++ ] = current;
 
           triangles[i++ ] = current + 1;
           triangles[i++ ] = next + 1;
           triangles[i++ ] = current;
 
           sideCounter++;
}
#endregion
 
mesh.vertices = vertices;
mesh.normals = normales;
mesh.uv = uvs;
mesh.triangles = triangles;
 
mesh.RecalculateBounds();
mesh.Optimize();
cs


C# - Torus



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
MeshFilter filter =gameObject.AddComponent< MeshFilter >();
Mesh mesh = filter.mesh;
mesh.Clear();
 
float radius1 = 1f;
float radius2 = .3f;
int nbRadSeg = 24;
int nbSides = 18;
 
#region Vertices           
Vector3[] vertices = newVector3[(nbRadSeg+1) * (nbSides+1)];
float _2pi = Mathf.PI * 2f;
for( int seg = 0; seg <= nbRadSeg; seg++)
{
           intcurrSeg = seg  == nbRadSeg ? 0 : seg;
 
           floatt1 = (float)currSeg / nbRadSeg * _2pi;
           Vector3r1 = new Vector3( Mathf.Cos(t1) * radius1, 0f, Mathf.Sin(t1) * radius1 );
 
           for(int side = 0; side <= nbSides; side++ )
           {
                     intcurrSide = side == nbSides ? 0 : side;
 
                     Vector3normale = Vector3.Cross( r1, Vector3.up );
                     floatt2 = (float)currSide / nbSides * _2pi;
                     Vector3r2 = Quaternion.AngleAxis( -t1 * Mathf.Rad2Deg, Vector3.up ) *new Vector3(Mathf.Sin(t2) * radius2, Mathf.Cos(t2) * radius2 );
 
                     vertices[side+ seg * (nbSides+1)] = r1 + r2;
           }
}
#endregion
 
#region Normales                    
Vector3[] normales = newVector3[vertices.Length];
for( int seg = 0; seg <= nbRadSeg; seg++)
{
           intcurrSeg = seg  == nbRadSeg ? 0 : seg;
 
           floatt1 = (float)currSeg / nbRadSeg * _2pi;
           Vector3r1 = new Vector3( Mathf.Cos(t1) * radius1, 0f, Mathf.Sin(t1) * radius1 );
 
           for(int side = 0; side <= nbSides; side++ )
           {
                     normales[side+ seg * (nbSides+1)] = (vertices[side + seg * (nbSides+1)] - r1).normalized;
           }
}
#endregion
 
#region UVs
Vector2[] uvs = newVector2[vertices.Length];
for( int seg = 0; seg <= nbRadSeg; seg++)
           for(int side = 0; side <= nbSides; side++ )
                     uvs[side+ seg * (nbSides+1)] = new Vector2( (float)seg / nbRadSeg, (float)side /nbSides );
#endregion
 
#region Triangles
int nbFaces = vertices.Length;
int nbTriangles = nbFaces * 2;
int nbIndexes = nbTriangles * 3;
int[] triangles = new int[ nbIndexes ];
 
int i = 0;
for( int seg = 0; seg <= nbRadSeg; seg++)
{                              
           for(int side = 0; side <= nbSides - 1; side++ )
           {
                     intcurrent = side + seg * (nbSides+1);
                     intnext = side + (seg < (nbRadSeg) ?(seg+1) * (nbSides+1) : 0);
 
                     if(i < triangles.Length - 6 )
                     {
                                triangles[i++]= current;
                                triangles[i++]= next;
                                triangles[i++]= next+1;
 
                                triangles[i++]= current;
                                triangles[i++]= next+1;
                                triangles[i++]= current+1;
                     }
           }
}
#endregion
 
mesh.vertices = vertices;
mesh.normals = normales;
mesh.uv = uvs;
mesh.triangles = triangles;
 
mesh.RecalculateBounds();
mesh.Optimize();
cs


C# - Sphere

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
//Regular sphere. Source :http://stackoverflow.com/questions/4081898/procedurally-generate-a-sphere-mesh
MeshFilter filter =gameObject.AddComponent< MeshFilter >();
Mesh mesh = filter.mesh;
mesh.Clear();
 
float radius = 1f;
// Longitude |||
int nbLong = 24;
// Latitude ---
int nbLat = 16;
 
#region Vertices
Vector3[] vertices = new Vector3[(nbLong+1)* nbLat + 2];
float _pi = Mathf.PI;
float _2pi = _pi * 2f;
 
vertices[0] = Vector3.up * radius;
for( int lat = 0; lat < nbLat; lat++ )
{
           floata1 = _pi * (float)(lat+1) / (nbLat+1);
           floatsin1 = Mathf.Sin(a1);
           floatcos1 = Mathf.Cos(a1);
 
           for(int lon = 0; lon <= nbLong; lon++ )
           {
                     floata2 = _2pi * (float)(lon == nbLong ? 0 : lon) / nbLong;
                     floatsin2 = Mathf.Sin(a2);
                     floatcos2 = Mathf.Cos(a2);
 
                     vertices[lon + lat * (nbLong + 1) + 1] = new Vector3( sin1 * cos2, cos1, sin1 * sin2 ) *radius;
           }
}
vertices[vertices.Length-1] = Vector3.up *-radius;
#endregion
 
#region Normales                    
Vector3[] normales = newVector3[vertices.Length];
for( int n = 0; n < vertices.Length; n++)
           normales[n]= vertices[n].normalized;
#endregion
 
#region UVs
Vector2[] uvs = newVector2[vertices.Length];
uvs[0] = Vector2.up;
uvs[uvs.Length-1] = Vector2.zero;
for( int lat = 0; lat < nbLat; lat++ )
           for(int lon = 0; lon <= nbLong; lon++ )
                     uvs[lon+ lat * (nbLong + 1) + 1] = new Vector2( (float)lon / nbLong, 1f -(float)(lat+1) / (nbLat+1) );
#endregion
 
#region Triangles
int nbFaces = vertices.Length;
int nbTriangles = nbFaces * 2;
int nbIndexes = nbTriangles * 3;
int[] triangles = new int[ nbIndexes ];
 
//Top Cap
int i = 0;
for( int lon = 0; lon < nbLong; lon++ )
{
           triangles[i++]= lon+2;
           triangles[i++]= lon+1;
           triangles[i++]= 0;
}
 
//Middle
for( int lat = 0; lat < nbLat - 1; lat++)
{
           for(int lon = 0; lon < nbLong; lon++ )
           {
                     intcurrent = lon + lat * (nbLong + 1) + 1;
                     intnext = current + nbLong + 1;
 
                     triangles[i++]= current;
                     triangles[i++]= current + 1;
                     triangles[i++]= next + 1;
 
                     triangles[i++]= current;
                     triangles[i++]= next + 1;
                     triangles[i++]= next;
           }
}
 
//Bottom Cap
for( int lon = 0; lon < nbLong; lon++ )
{
           triangles[i++]= vertices.Length - 1;
           triangles[i++]= vertices.Length - (lon+2) - 1;
           triangles[i++]= vertices.Length - (lon+1) - 1;
}
#endregion
 
mesh.vertices = vertices;
mesh.normals = normales;
mesh.uv = uvs;
mesh.triangles = triangles;
 
mesh.RecalculateBounds();
mesh.Optimize();
cs


C# - IsoSphere


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
//This is a sphere without poles. Source :http://blog.andreaskahler.com/2009/06/creating-icosphere-mesh-in-code.html
//Note : Don't forget to includeSystem.Collections.Generic. And there is no UV yet, not sure how to go about itactually.
private static class IsoSphere
{
   private struct TriangleIndices
    {
       public int v1;
       public int v2;
       public int v3;
 
       public TriangleIndices(int v1, int v2, int v3)
       {
           this.v1 = v1;
           this.v2 = v2;
           this.v3 = v3;
       }
    }
 
   // return index of point in the middle of p1 and p2
   private static int getMiddlePoint(int p1, int p2, refList<Vector3> vertices, ref Dictionary<long, int> cache, floatradius)
    {
       // first check if we have it already
       bool firstIsSmaller = p1 < p2;
       long smallerIndex = firstIsSmaller ? p1 : p2;
       long greaterIndex = firstIsSmaller ? p2 : p1;
       long key = (smallerIndex << 32) + greaterIndex;
 
       int ret;
       if (cache.TryGetValue(key, out ret))
       {
           return ret;
       }
 
       // not in cache, calculate it
       Vector3 point1 = vertices[p1];
       Vector3 point2 = vertices[p2];
       Vector3 middle = new Vector3
                     (
           (point1.x + point2.x) / 2f,
           (point1.y + point2.y) / 2f,
           (point1.z + point2.z) / 2f
                     );
 
       // add vertex makes sure point is on unit sphere
                     inti = vertices.Count;
       vertices.Add( middle.normalized * radius );
 
       // store it, return index
       cache.Add(key, i);
 
       return i;
    }
 
   public static void Create()
    {
       MeshFilter filter = gameObject.AddComponent< MeshFilter >();
       Mesh mesh = filter.mesh;
       mesh.Clear();
 
       List<Vector3> vertList = new List<Vector3>();
       Dictionary<long, int> middlePointIndexCache = new Dictionary<long,int>();
       int index = 0;
 
       int recursionLevel = 3;
       float radius = 1f;
 
       // create 12 vertices of a icosahedron
       float t = (1f + Mathf.Sqrt(5f)) / 2f;
 
       vertList.Add(new Vector3(-1f, t,  0f).normalized * radius);
       vertList.Add(new Vector3( 1f, t,  0f).normalized * radius);
       vertList.Add(new Vector3(-1f, -t, 0f).normalized * radius);
       vertList.Add(new Vector3( 1f, -t, 0f).normalized * radius);
 
       vertList.Add(new Vector3( 0f, -1f, t).normalized * radius);
       vertList.Add(new Vector3( 0f, 1f,  t).normalized * radius);
       vertList.Add(new Vector3( 0f, -1f, -t).normalized * radius);
       vertList.Add(new Vector3( 0f,  1f,-t).normalized * radius);
 
       vertList.Add(new Vector3( t,  0f,-1f).normalized * radius);
       vertList.Add(new Vector3( t, 0f,  1f).normalized * radius);
       vertList.Add(new Vector3(-t,  0f,-1f).normalized * radius);
        vertList.Add(new Vector3(-t,  0f, 1f).normalized * radius);
 
 
       // create 20 triangles of the icosahedron
       List<TriangleIndices> faces = new List<TriangleIndices>();
 
       // 5 faces around point 0
       faces.Add(new TriangleIndices(0, 11, 5));
       faces.Add(new TriangleIndices(0, 5, 1));
       faces.Add(new TriangleIndices(0, 1, 7));
       faces.Add(new TriangleIndices(0, 7, 10));
       faces.Add(new TriangleIndices(0, 10, 11));
 
       // 5 adjacent faces
       faces.Add(new TriangleIndices(1, 5, 9));
       faces.Add(new TriangleIndices(5, 11, 4));
       faces.Add(new TriangleIndices(11, 10, 2));
       faces.Add(new TriangleIndices(10, 7, 6));
       faces.Add(new TriangleIndices(7, 1, 8));
 
        // 5 faces around point 3
       faces.Add(new TriangleIndices(3, 9, 4));
       faces.Add(new TriangleIndices(3, 4, 2));
       faces.Add(new TriangleIndices(3, 2, 6));
       faces.Add(new TriangleIndices(3, 6, 8));
       faces.Add(new TriangleIndices(3, 8, 9));
 
       // 5 adjacent faces
       faces.Add(new TriangleIndices(4, 9, 5));
       faces.Add(new TriangleIndices(2, 4, 11));
       faces.Add(new TriangleIndices(6, 2, 10));
       faces.Add(new TriangleIndices(8, 6, 7));
       faces.Add(new TriangleIndices(9, 8, 1));
 
 
       // refine triangles
       for (int i = 0; i < recursionLevel; i++)
       {
           List<TriangleIndices> faces2 = new List<TriangleIndices>();
           foreach (var tri in faces)
           {
                // replace triangle by 4triangles
                int a = getMiddlePoint(tri.v1,tri.v2, ref vertList, ref middlePointIndexCache, radius);
                int b = getMiddlePoint(tri.v2,tri.v3, ref vertList, ref middlePointIndexCache, radius);
                int c = getMiddlePoint(tri.v3,tri.v1, ref vertList, ref middlePointIndexCache, radius);
 
                faces2.Add(newTriangleIndices(tri.v1, a, c));
                faces2.Add(newTriangleIndices(tri.v2, b, a));
                faces2.Add(newTriangleIndices(tri.v3, c, b));
                faces2.Add(newTriangleIndices(a, b, c));
           }
           faces = faces2;
       }
 
       mesh.vertices = vertList.ToArray();
 
       List< int > triList = new List<int>();
       for( int i = 0; i <faces.Count; i++ )
       {
           triList.Add( faces[i].v1 );
           triList.Add( faces[i].v2 );
           triList.Add( faces[i].v3 );
       }                    
       mesh.triangles = triList.ToArray();
       mesh.uv = new Vector2[ vertices.Length ];
 
       Vector3[] normales = new Vector3[ vertList.Count];
       for( int i = 0; i < normales.Length; i++ )
           normales[i] = vertList[i].normalized;
 
 
       mesh.normals = normales;
 
       mesh.RecalculateBounds();
       mesh.Optimize();
    }
}
cs


저작자표시 비영리 변경금지

'프로그래밍 > Unity3D' 카테고리의 다른 글

[Unity3D] Unity5에서 마우스가 UI위에 있는지 체크하기.  (0) 2016.02.22
[Unity3D] 간단한 데이터 저장을 위한 PlayerPrefs 클래스 사용법  (0) 2016.02.22
[Unity3D] 유니티를 이용하여 Gmail 보내기  (0) 2016.02.22
[Unity3D] 유니티 메시를 STL(format)으로 변환하여 저장 하기.  (0) 2016.02.22
[Unity3D] 카메라를 기준으로 캐릭터의 forward와 Right Vector구하기  (0) 2016.02.22
Posted by 시리시안
2016. 2. 22. 05:40

[Unity3D] 유니티를 이용하여 Gmail 보내기

프로그래밍/Unity3D

간단하게 할수 있습니다.



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
using UnityEngine;
using System.Collections;
using System;
using System.Net;
using System.Net.Mail;
using System.Net.Security;
using System.Security.Cryptography.X509Certificates;
 
public class mono_gmail : MonoBehaviour
{
        void Main ()
        {
            MailMessage mail = new MailMessage();
             
            mail.From = new MailAddress("youraddress@gmail.com");
            mail.To.Add("youraddress@gmail.com");
            mail.Subject = "Test Mail";
            mail.Body = "This is for testing SMTP mail from GMAIL";
            SmtpClient smtpServer = new SmtpClient("smtp.gmail.com");      
            smtpServer.Port = 587;
            smtpServer.Credentials = new System.Net.NetworkCredential("youraddress@gmail.com", "yourpassword") as ICredentialsByHost;
            smtpServer.EnableSsl = true;
            ServicePointManager.ServerCertificateValidationCallback = delegate(object s, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors) 
            {
             return true; 
            };
            smtpServer.Send(mail); 
            Debug.Log("success");   
       }
}
 
 
cs



또한 파일을 첨부해서 보낸다면


1
2
3
4
5
 
                System.Net.Mail.Attachment attachment;  
                attachment = new System.Net.Mail.Attachment("D:\\temp\\file.txt");  
                  
                mail.Attachments.Add(attachment);
cs

위와

위와같은 코드를 추가하면 됩니다.


저작자표시 비영리 변경금지

'프로그래밍 > Unity3D' 카테고리의 다른 글

[Unity3D] 간단한 데이터 저장을 위한 PlayerPrefs 클래스 사용법  (0) 2016.02.22
[Unity3D] 코드를 이용하여 기본도형 메시 만들기  (0) 2016.02.22
[Unity3D] 유니티 메시를 STL(format)으로 변환하여 저장 하기.  (0) 2016.02.22
[Unity3D] 카메라를 기준으로 캐릭터의 forward와 Right Vector구하기  (0) 2016.02.22
[Unity3D] 플랫폼별 각 경로들  (0) 2016.02.22
Posted by 시리시안

티스토리툴바