javaScript features (ECMAScript6)

Class

define

class Queue {
    _queue;      
  constructor(contents = []) {
    this._queue = [...contents];
  }
  pop() {
    const value = this._queue[0];
    this._queue.splice(0, 1);
    return value;
  }

extends

class PeekableQueue extends Queue {
  peek() {
    return this._queue[0];
  }

class Account extends Foo {
  constructor(balance) {
    this.balance = balance;
  }

  history(done) {
    someLongTask((err, data) => {
      // Do something with data
      done(null, data);
    });
  }

  deposit(amount) {
    this.balance += amount;
    return this.balance;
  }
}

// Currently, you can only declare functions in a class
Account.types = ['checking', 'savings'];

get,set

class Account {
  constructor() {
    this.balance = 0;
  }

  get underBudget() {
    return this.balance >= 0;
  }

  get overBudget() {
    return this.balance < 0;
  }
}

const myAccount = Account();
myAccount.balance = 100;
console.log(myAccount.underBudget); // true

Iterable Class

可建立iterable class，並且可用generator建立iterator。

class MyIterable {
  constructor(items) {
    this.items = items;
  }

  *[Symbol.iterator]() {
    for (let item of this.items) {
      yield `Hello, ${item}`;
    }
  }
}

const test = new MyIterable([1, 2, 3, 4, 5]);

for (let item of test) {
  console.log(item); // => Hello, 1...
}

Map

let map = new Map(arr);

for (let key of map.keys()) {
  console.log(key);
}

for (let value of map.values()) {
  console.log(value);
}

for (let item of map.entries()) {
  console.log(item[0], item[1]
}

Module

基本定義與引用

用ES6 export，就用import；不要用require

一個文件中不要export與default export一起用

不要在import中使用*，確保module中有一個default export

//定義模組 module.js

var privateVar = "privateVar";  
//不能被外部引用的成員
export var publicVar = "and this one is public";   
//export出去，可被外部引用的成員

export function getVar() {
   return privateVar;
};

//引用模組 use.js
import { getVar, publicVar } from 'mymodule'; 
//import getVar及publicVar兩個成員
console.log(getVar());

//一次引用這個模組的所有可引用成員
X import 'mm' from 'mymodule';
X import 'mymodule' as mm;
//或是這樣
import * as 'mm' from 'mymodule';  //不建議使用*
import abc =require('mymodule');

//不一定都有implement
import defaultMember from "module-name";
import * as name from "module-name";
import { member } from "module-name";
import { member as alias } from "module-name";
import { member1 , member2 } from "module-name";
import { member1 , member2 as alias2 , [...] } from "module-name";
import defaultMember, { member [ , [...] ] } from "module-name";
import defaultMember, * as name from "module-name";
import "module-name";

console.log(mm.gerVar());

default export(無命名export) (文件中只有一個成員)

//------ myFunc.js ------
export default function () { ... };

//------ main1.js ------
import myFunc from 'myFunc';
myFunc();

//------ MyClass.js ------
export default class { ... };
 
//------ main2.js ------
import MyClass from 'MyClass';
let inst = new MyClass();

一個文件中同時有export(一般export)與default export(無命名export)

//------ underscore.js ------
export default function (obj) {
    ...
};

export function each(obj, iterator, context) {
    ...
}
export { each as forEach };

//------ main.js ------
import _, { each } from 'underscore';
...

default export就是another named export

//以下兩者相同
import { default as foo } from 'lib';
import foo from 'lib';

//以下兩個模組export相同
//------ module1.js ------
export default 123;

//------ module2.js ------
const D = 123;
export { D as default };

commonJS的module

//------ underscore.js ------
var _ = function (obj) {
    ...
};
var each = _.each = _.forEach =
    function (obj, iterator, context) {
        ...
    };
module.exports = _;
 

//------ main.js ------
var _ = require('underscore');
var each = _.each;
...

//------ lib.js ------
var sqrt = Math.sqrt;
function square(x) {
    return x * x;
}
function diag(x, y) {
    return sqrt(square(x) + square(y));
}
module.exports = {
    sqrt: sqrt,
    square: square,
    diag: diag,
};
 
//------ main.js ------
var square = require('lib').square;
var diag = require('lib').diag;
console.log(square(11)); // 121
console.log(diag(4, 3)); // 5

頂點及索引

Vertex and Index

頂點 ->索引
v0 -> 0
v1 -> 1
v2 -> 2
v3 -> 3

index決定三角形構成方式
[0,1,2,2,3,0]
v0->v1->v2
v2->v3->v0
決定了兩個三角形構成，
也就是決定了兩個面

頂點代表多重意義，基本上是多種屬性的重疊
一般封裝的方式有兩種：

struct Vertex {
  Vector3 Position;
  Vector3 Normal;
  Vector3 Color;
}

Vector3[] Vertices;
Vector3[] normals;
Vector3[] colors;

Vertex Buffer

存放vertices的區域，稱為vertex buffer
在DX/OpenGL中，我們需要
1 申請vertex buffer
2 綁定buffer
3 上傳vertex資料
4 一個模型對應一個buffer

在unity中， 這些已經被封裝了

Gluint vertexbuffer;
glGenBuffer(1,&vertexbuffer);
glBindBuffer(GL_ARRAY_BUFFER,vertexbuffer);
glBufferData(GL_ARRAY_BUFFER,sizeof(g_vertex_buffer_data),g_vertex_buffer_data,GL_STATIC_DRAM);

Index Buffer

存放index資料的暫存區，稱為index buffer

不同的向量方向，構成的三角形不同

[0,1,2]構成 v0->v1, v1->v2兩個向量
[2,1,0]構成v2->v1，v1->v2兩個向量
兩者的法向量不同，所以是不同三角形

 三角形的正面及背面

Dx以情況A為正向，依據左手系統，法向量朝我方。

OpenGL以情況B為正向，依據右手系統，法向量朝我方。

索引的意義

1 每三個索引，決定一個三角形(面數)
2 索引順序不同，構成三角形不同
3 DX預設順時針為正向，OpenGL預設逆時針為正向
4 索引會決定三角形的正面、背面
5 索引可表示重複使用的頂點，可減少記憶體使用
6 索引是簡單整數，有些設備一個物件只支援65535個索引=21845個三角形

Unity物件頂點數限制65000個，也是從此而來。

物件頂點數超過65535個，可進行頂點資料及索引拆分，分成兩份資料。

7 合併緩衝區

用索引決定渲染

渲染整個模型，索引從0到最後
渲染某部分，更改索引起始位置及結束位置

合併緩衝區

就是把兩個物件的頂點緩衝區及索引緩衝區合併，當成一個物件處理。

假設三個物件的vertexBuffer及indexBuffer：
v0   v1  v2 => 0,1,2
m0 m1 m2 => 0,1,2
n0  n1   n2 => 0,1,2

合併後
[v0,v1,v2,m0,m1,m2,n0,n1,n2]
[0,1,2,(0+3),(1+3),(2+3),(0+6),(1+6),(2+6)]

0+3=4，表示是vertex的第四個=m0
1+4=5，表示是vertex的第五個=m2

這就是unity draw call batching的原理
合併緩衝區在物件是靜態時，效果最好，
如果非static卻一直合併緩衝區，就適得其反。
所以unity draw call batching 有分dynamic及static，
確保物件是static才使用static方法。

顏色

顏色表示法

假設使用向量表示顏色，最小值為0，最大值為1。
三原色可表示為：

r=(1,0,0)
g=(0,1,0)
b=(0,0,1)

8位元表示法，最小值為0，最大值為255
r=(255,0,0)
g=(0,255,0)
b=(0,0,255)

[0,1]對應到[0,255]，只要每個分量除255即可。

顏色運算

加法

r+g=(1,0,0)+(0,1,0)=(1,1,0)

減法

(1,1,0)-(0,1,0)=(1,0,0)

數乘

0.5*(1,1,1)=(0.5,0.5,0.5)

分量乘法

(r0,r1,r2)*(g0,g1,g2)=(r0*g0,r1*g1,r2*g2)

分量乘法應用
假設c0=(1,1,1) 太陽光
c1=(0.5,0.25,0.5)  材質反射率

c0*c1=(0.5,0.25,0.5)
就是太陽光照射材質後，反射出來的光

向量點積、向量叉積對顏色無意義

顏色分量要限縮在0-1之間，超過這個範圍就無意義

射線 平面

射線

定義

定義射線需要起點，方向，長度
起點p0
方向=單位向量u
長度=t

向量相加為所形成平行四邊形的對角線
得到射線p(t)=p0+tu

Unity Raycast API

public static bool Raycast(Vector3 origin, Vector3 direction, float maxDistance)
其實就和射線定義相同(起點，方向，長度)

平面

定義

p為平面上任意點，n為平面法向量，p1為法向量交於平面的點

p-p1向量=p-p1 假設為(ax,ay,az)
n假設為 (bx,by,bz)
p-p1與n垂直
向量點積公式 (a長)*(b長)*Cos(90)=0
向量點積算法(ax*bx+ay*by+cz*bz)
得到n.(p-p1)=0

射線與平面相交

射線
p=p0+tu

平面
n.(p-p1)=0

把射線p帶入平面

n.(p0+tu - p1)=0

n.p0+n.tu-n.p1=0

n.tu=n.p1-n.p0

t=n.p1-n.p0/n.u

這裡 (.)是點積

若t>=0，射線與平面相交，且交點為p0+tu
若t<0，兩不相交

矩陣

矩陣運算

矩陣相加   對應元素相加

矩陣相減   對應元素相減

矩陣相乘   每個元素就是兩個矩陣的行與列點積。所以兩個矩陣的行與列維度要相同。

矩陣數乘   每個元素乘上一個數

矩陣相等   對應的每個元素相等

矩陣相乘

條件

假設A矩陣*B矩陣
則A行向量的元素個數=B列向量元素個數
(大陸橫為行，直為列)
否則無法相乘


A=[1- 5 -4]
     [3   2  1]

B=[2  1  0 ]
     [0  -2  1]
     [-1  2   3]

AB=[(-1,5,-4).(2,0,-1)   (-1,5,-4).(1,-2,2)   (-1,5,-4).(0,1,3)]
        [(3,2,1).(2,0,1)       (3,2,1).(1,-1,2)      (3,2,1)(0,1,3)]

行.列  (點積)

矩陣乘法不滿足交換率

A*B != B*A

矩陣乘法滿足結合率

A(B+C)=AB+AB
(AB)C=A(BC)

矩陣除法

矩陣運算沒有除法

向量矩陣

行向量矩陣
A=[1 3 3]

列向量矩陣
B= [2]
      [2]
      [3]

向量-矩陣乘法

OpenGL 左乘方式--矩陣在左，向量在右    記憶法(O在左)
DirectX    右乘方式--矩陣在右，向量在左    記憶法(X在右)

因為矩陣乘法不反足交換率，所以在左在右結果不同。

轉置矩陣(Transpose)

把一個矩陣的行和列互換。mxn的轉置矩陣就是nxm。
原矩陣的行向量＝轉置矩陣的列向量

A=[1  1  1 ]
     [2  2   2]

C=A.transpose
[1 2]
[1 2]
[1 2]


B=[a b c d]

D=B.transpose
[a]
[b]
[c]
[d]

A*B=(D*C).transpose

範例
A,B兩向量
C=A.transpose
D=B.transpose

A*B    ↘︎  C*D    =>  A*B=D*C      兩個剛好交錯
B*A   ↗︎   D*C    =>  B*A=C*D

矩陣乘以向量

1 矩陣維度與向量元素個數不需相同

2 矩陣*向量  =>變成向量

3 矩陣*向量=向量*矩陣轉置(要自己計算)

向量 X=(1,2,3,4);

A=[1  1  1 1]
     [2  2   2 2]
     [3  3  3  3]
     [4  4  4  4]

A*X=(1111.(1234)  2222.(1234)  3333.(1234)   4444.(1234))

A.transpose=
[1 2 3 4]
[1 2 3 4]
[1 2 3 4]
[1 2 3 4]

X*A.transpose
((1234)(1111)   (1234)(2222)  (1234)(3333)  (1234)(4444))

 Unity中矩陣乘以向量

可以直接矩陣*向量

不能向量*矩陣  (要自己計算)

矩陣A

向量V

A*V  =>ok

V*A  =>error

單位矩陣

1 是正方形矩陣

2 中心左上右下斜對角線(back slash)的元素都是1

3 其他元素都是0

4 任何矩陣*單位矩陣，結果不變

5 單位矩陣就是矩陣中的數字1(跟單位向量相同)

[1  0   0]
[0  1   0]
[0  0   1]

逆矩陣(Inverse)

1 矩陣運算沒有除法

2 只有正方形矩陣才能夠逆運算

3 一個nxn的矩陣的逆矩陣，仍然是nxn的矩陣

4 不是所有的矩陣都有逆矩陣，有逆矩陣的矩陣稱為可逆

5 如果有可逆矩陣，這個逆矩陣一定是唯一的

6 將一個矩陣與他的逆矩陣相乘，結果一定為單位矩陣

有矩陣A,B,C，且A=B*C，且D為C的逆矩陣
A=BC
AD=BDC (DC=1)
AD=B

範例

有一點a
一矩陣b
d=b的逆矩陣
轉換後的點c = a*b

cd=a*b*d  (bd=1)
cd=a

可找到原始的a點

常用來把點從局部空間轉換到世界空間，
或從世界空間轉換回局部空間。

矩陣計算平移

1 點的位移向量，使用DirectX要寫在矩陣第四行的前三個，
   因為如果寫在前三行，那會被x,y,z乘到
   只能寫在第四行的前三個，經過計算後就分別被x,y,z加

   使用OpenGL則分別寫在前三行的最後一元素

    directX與openGL可使用矩陣轉置來切換

2 矩陣的每個位置數字都有意義，都是經過設計的

3 因為3x3不夠用，所以擴充為4x4，自己新增w

4 當w=0，(x,y,z,0) 就是用來描述向量 =>可得到原始向量

5 當w=1，(x,y,z,1) 就是用來描述點    =>可算出位移後的點


DirectX計算(右乘，矩陣在右，向量在左)

A=[x,y,z,w] 行向量

M= 單位矩陣
       1  0  0  0
       0  1  0  0
       0  0  1  0
       0  0  0  1

A*M=

x*1+y*0+z*0+w*0=x
x*0+y*1+z*0+w*0=y
x*0+y*0+z*1+w*0=z
x*0+y*0+z*0+w*1=w

假設位移向量B=(tx,ty,tz)，則A位移後的點為(x+tx,y+ty,z+tz)
tx,ty,tz寫在矩陣最下行靠左

m=
1  0   0   0
0  1   0   0
0   0  1   0
tx  ty tz  1

A*m=[x,y,z,w] *m=

x*1+y*0+z*0+w*tx=x+wtx
x*0+y*1+z*0+w*ty=y+wty
x*0+y*0+z*1+w*tz=z+wtz
x*0+y*0+z*0+w*1=w

當w=1，結果就是 x+tx,y+ty,z+tz,1
因為w是我們自己擴充的，所以可設為1

所以經由以上算法，點A的位移，利用矩陣運算可得到結果。
矩陣每個位置的數字都有固定意義，都事先設定好的。


OpenGL計算(左乘，矩陣在左，向量在右 =Unity的系統 )

A=[x,y,z,w] 行向量

M= 單位矩陣
       1  0  0  0
       0  1  0  0
       0  0  1  0
       0  0  0  1

M*A=

x*1+y*0+z*0+w*0=x
x*0+y*1+z*0+w*0=y
x*0+y*0+z*1+w*0=z
x*0+y*0+z*0+w*1=w

假設位移向量B=(tx,ty,tz)，則A位移後的點為(x+tx,y+ty,z+tz)
tx,ty,tz寫在矩陣前三行最末位

m=
1  0   0   tx
0  1   0   ty
0   0  1   tz
0  0  0    1

m*A=m*[x,y,z,w] =

1*x+0*y+0*z+w*tx=x+wtx
0*x+1*y+0*z+w*ty=y+wty
0*x+0*y+1*z+w*tz=z+wtz
0*x+0*y+0*z+w*1=w

當w=1，結果就是 x+tx,y+ty,z+tz,1
因為w是我們自己擴充的，所以可設為1

矩陣計算縮放

1 縮放就是倍數的關係，所以(x,y,z)要能分別乘以縮放的數字

2 因此只能放在斜對角線的元素位置上

sx 0  0  0
0  sy 0  0
0  0  sz 0
0  0  0  0

假設x放大2，y所小0.5，z放大3，那就是

2     0  0  0
0  0.5  0  0
0     0  3  0
0     0  0  0

範例

矩陣A=
[1 0  0      0]
[0  2  0     0]
[0  0  0.5  0]
[0  0  0     1]

向量V=[x,y,z,w]

v*A=
x*1+y*0+z*0+w*0=x
x*0+y*2+z*0+w*0=2y
x*0+y*0+z*0.5+w*0=0.5z
x*0+y*0+z*0+w*0=w

=[x,2y,0.5z,0]
＝x不變，y放大2，z縮小0.5

矩陣計算旋轉

1 旋轉要考慮軸

2 旋轉要考率角度(非弧度)


假設延n軸旋轉 n=(x,y,z)
轉 a角度
c=cos(a)
s=sin(a)

矩陣為：

c+(1-c)*x*x        (1-c)*x*y+s*z      (1-c)*x*z-s*y      0
(1-c)*x*y-s*z       c+(1-c)*y*y       (1-c)*y*z+s*x     0
(1-c)*x*z+s*y     (1-c)*y*z-s*x       c+(1-c)*z*z        0
0                           0                            0                          1

範例

假設延x軸旋轉 (1,0,0)

1   0             0             0
0  cos(a)   sin(a)      0
0  -sin(a)    cos(a)    0
0  0             0              1

矩陣組合

1 如果一次要計算三個矩陣(平移矩陣，縮放矩陣，旋轉矩陣)，太消耗資源

2 利用矩陣乘法分配律，可以把三個矩陣先相乘，在跟向量相乘，可以少算2/3次

3 同時三個矩陣組成一個，也方便處理

4 組合方式是三個矩陣相乘

向量

向量的意義

向量是同時具有大小和方向的物理量

勢能：在某方向上施加一定的作用力

位移：在某方向上移動的一度距離

速度：速率和方向

用來表示方向

遊戲中角色方向

多邊形面對的方向

光線的方向

反射光的方向

向量幾何意義

兩個向量可以：
確定一個三角形
確定一個平行四邊形
確定一個平面

向量運算

向量相加  對應的元素相加
向量相減  對應的元素相減
向量數乘  每個元素乘上一個數
向量叉積  就是第三個同時垂直原向量的向量。不含自己，前減後，↘︎↙︎↘︎ 。|A||B|Sin(a)
向量點積  對應元素相乘，加起來。變成一個數。|A||B|Cos(a)
向量相等  方向相同，大小相等就是兩個相等向量

向量計算

向量計算一定是把向量頭部移到原點

也就是假設向量從原點出發

向量加法

定義

兩個同維度(2D和2D或3D和3D)的向量相加，
就是兩個向量的對應分量相加。
x+x
y+y
z+z

u=(ux,uy,uz)
v=(vx,vy,vz)
u+v=(ux+vx,uy+vy,uz+vz)

幾何意義

A=(xa,yz)
B=(xb,yb)
C=(xc,yc)

AB=(xb-xa,yb-ya)
BC=(xc-xb,yc-yb)
AC=(xc-xa,yc-ya)

AB+BC=(xb-xa+xc-xb,yb-ya+yc-yb)=(xc-xa,yc-ya)=AC
頭尾相連的兩個向量相加，結果從頭到尾的那個向量

AC就是平行四邊形的對角線
是兩向量行成的夾角內的對角線
因此兩個向量相加可以確定一個平行四邊形

AC也是兩向量頭尾相連的三角形的第三邊
所以可以求第三邊的長度及方向

平行四邊形面積= 底*高
所以向量可以算出平行四邊形面積

三角形面積=平行四邊形面積/2


結論

向量加法就是：兩項量移動成頭尾相連，所形成的第三邊。

因為向量有相等性，可以平移，
所以任何兩個向量，一定可以平移成頭尾相連。

向量減法

定義

兩個同維度(2D和2D或3D和3D)的向量相減，
就是兩個向量的對應分量相減。
x-x
y-y
z-z

u=(ux,uy,uz)
v=(vx,vy,vz)
u-v=(ux-vx,uy-vy,uz-vz)

幾何意義

AB=(xb-xa,yb-ya)
AC=(xc-xa,yc-ya)
BC=(xc-xb,yc-yb)


AB-AC=(xb-xa-xc+xa,yb-ya-yc+ya)=(xb-xc,yb-yc)=CB

CB是兩向量形成的平行四邊形的對角線(非兩向量形成的夾角內的對角線)
所以也可確定一個平行四邊形

CB是兩向量尾部相連形成的三角形的第三邊
CB可以求第三邊的長度及方向

結論

向量減法就是：兩向量移動成起點相連形成的第三邊
方向指向被減向量。(減號前方的是被減數)

向量減法就是向量加法加上負向量，
所以用向量加法來思考即可。

向量叉積 

向量叉積 Cross Product
向量外積 Outer Product
向量積Vector Product

A,B兩向量叉積(A X B) 會得到一個垂直於這兩個向量的第三個向量
B,A兩向量叉積(B X A) 會得到一個垂直於這兩個向量的第三個向量，但與A X B 方向相反

A ∧ B = - A ∧ B 
各自算出的結果是兩個方向相反，大小相同向量
就是反交換律

寫作

×（有時也被寫成∧，避免和字母x混淆）

公式

A X B =|A||B|Sin𝛳
θ表示和之間的角度（0°≤θ≤180°），它位於這兩個矢量所定義的平面上
是一個與、所構成的平面垂直的單位矢量。
https://zh.wikipedia.org/wiki/%E5%90%91%E9%87%8F%E7%A7%AF

直接算法

A=(ax,ay,az)
B=(bx,by,bz)

A x B=(ay*bz - az*by) =x          記憶法 ↘︎  不含自己    前減後
            (az*bx - ax*bz) =y                       ↙︎
            (ax*by - ay*bx) =z                      ↘︎

幾何意義

叉積可得到垂直於AB平面的法向量。

向量點積

向量點積 Dot Product
向量內積 Inner Product
標向量 Scalar Product

 兩向量計算點積會得到一個純量，不帶方向只有大小

寫作

. 

公式

A.B=|A||B|cos𝛳

𝛳是AB間的最小夾角。即0<= 𝛳<=180
兩個向量必須共起點
當A,B都是單位向量時，A.B=1*1*cos𝛳=cos𝛳 , => -1<=cos𝛳<=1
cos𝛳一定大於等於-1，小於等於1

直接算法

A=(ax,ay,az)
B= (bx,by,bz)

A.B =ax*bx+ay*by+az*bz  =>只有大小  記憶法：分量相乘，加起來

AB都是單位向量，可推斷出角度

就可直接得到cos𝛳的值
若cos𝛳的值是已知的，那就可以知道角度是多少
ABcos𝛳=0.95 ，𝛳=18
因為cos(18)=0.95

幾何意義

無，但有一些性質

利用cos𝛳可得到一些性質
cos𝛳 0度=1
cos𝛳 90度=0
cos𝛳 180度=-1

所以 A.B=0  =>cos𝛳=0  => 𝛳 =90度 => A,B垂直
所以 A.B>0  =>cos𝛳>0  => 𝛳 <90度 =>A,B夾角小於90度
所以 A.B<0  =>cos𝛳<0  => 𝛳 >90度 =>A,B夾角大於90度

平面法線跟光的角度越小，光越強
平面法線跟光的角度越大，光越弱
正好符合cos，所以可以用cos(𝛳)來計算光的強弱
光最後的顏色=光的顏色*cos(𝛳)

向量大小(長度)

向量長度符號
||U||=√a² +b²

單位向量符號
U戴帽子∧

都是從勾股定理，商高定理(畢氏定理)來的
Pythagorean theorem

平面上的直角三角形的兩條直角邊的長度平方和等於斜邊長平方
勾長 直邊
股長 底邊
弦長 斜邊

來源：
根據「周髀算經」記載，
商高對周公說 將一根直尺折成一個直角，
兩端連結成一個直角三角形，
如果勾是 3，股是 4， 那麼弦就是 5。

2D distance

√(a²   + b²)
根號(a²+b²)

3D distance

√(x²+y²+z²)
根號(x²+y²+z²)

空間中的兩個點距離
A(ax,ay,az)
B(bx,by,bz)
√((ax-bx)²+(ay-by)²+(az-bz)²)
 根號((ax-bx)²+(ay-by)²+(az-bz)²)

a 是利用兩次勾股定理算出

b 或是利用向量平移，把其中一個點移到原點，
然後另一個點扣掉平移量之後，跟原點計算距離

c 其實就是向量減法的幾何意義

單位向量驗證
把長度/長度
√(x²+y²+z²)/向量長=1/1=1

C# Coroutine

Unity Coroutine

使用的地方

必須在MonoBehaviour或繼承MonoBehaviour的class中使用

不可使用的地方

yield不可在Update
不可在FixedUpdate中使用

啟動Coroutine

StartCoroutine(string methodName)
StartCoroutine(IEnumeratorroutine)

停止Coroutine

StopCoroutine(string methodName)
StopAllCoroutines()