การสร้าง instance ใน flash

เราสามารถสร้างclassใน action script file (.as)เพื่อเป็นtemplate ในการสร้าง instanceหรือ object ในการควบคุม movie clipได้ โดยเราสามารถ map movieclip ให้เข้ากับ class ต่างๆได้ เช่น หากเราสร้าง movieclip
เครื่องบินขึ้นมา เราก็สร้าง class plane{} ซึ่งเป็น class สำหรับ movie clip ดังกล่าวได้ วิธีการสร้างทำได้ดังนี้
1.สร้าง file(.as)โดยไปที่ New action scipt file

2.แล้วสร้าง classขึ้นในไำฟล์ชื่อ plane.as










3.สร้าง ไฟล์ flash.fla ไปที่ New flash Document


4.ลองสร้าง movie clip เล่นๆ เช่น วาดรูปเครื่องบิน จากนั้น convert to symbol เพื่อแปลงภาพ ให้เป็นsymbol เลือก เป็น Movieclip แล้วกำหนด instance name เป็น plane_mc

5.เมื่อเราได้movieclip plane ดังกล่าวแล้ว ให้ไปที่ window -> library เพื่อใช้ library เลือก export for action scipt
คลิ๊กซ้าย ตรงบริิิเวณดังรูปแล้วเลือก linkage พิมพ์ชื่อ class As.2 ที่เราสร้างไว้ใน .as file














6.ไปที่ Action panel จากนั้นเราสามารถอ้างอิงคลาสดังกล่าว
เช่น trace(plane_mc.test); ผลลัพธ์จะปรากฏใน window-> output

กลับมาแว้ว

โอ้ย แย่แล้ว!!หายไปหลายวันเลย มัวนั่งทำ introflash อยู่ วันนี้มาต่อกันเลยดีกว่า
ได้พอนั่งเล่น flash กับ action script บ้าง วันนี้เลยจะพูดถึงพื้นฐานของaction scriptใน การควบคุม flash
โดยหลักๆแล้วรูปแบบการเขียนมี 2 แบบ ก็คือ
- แบบที่ใช้ script ควบคุมวัตถุต่างๆภายในตัว object เอง ซึ่งเราจะเขียน scriptฝังไปในตัววัตถุเลยเราก็ไม่จำเป็นที่จะต้อง ระบุตัววัตถุดังกล่าว ใน หน้าต่าง action ได้เลย
ตัวอย่าง

on(press){
this.play();
}
ข้อเสียคือ เวลาแก้ทีหาให้วุ่นเลย ยิ่งหากเราสร้าง งานที่ซับซ้อนเมื่อไหร่ ก็เจ้งนะสิ
ข้อดี คือ ไม่ต้องเขียนอ้างอิงอะไรมาก

- แบบที่ใช้ script ควบคุมจากภายนอก เช่น เราเขียน script เพื่อ อ้างอิง วัตถุต่างผ่านทางชื่อที่เราตั้งให้กับ object ซึ่งเหมือนการสร้าง instance ของวัตถุนั้นแล้ว เราจึงใช้ method ผ่านทาง instance นั้นได้
เช่น circle.play(); //ตั้งชื่อ instance เป็น circle

_root.circle.onPress=function(){
this.play();
}
ข้อสังเกตนิดนึง symbol แบบ graphic จะไม่มีให้ใส่ชื่อ ของ instance เราจึงไม่สามารถอ้างอิงได้

เรามาดูในเรื่องของขอบเขตการประกาศตัวแปร เป็นเรื่องที่สำคัญทีเดียวเนื่องจาก flash ช่วยเราให้สามารถสร้้าง vector graphic และการสร้างงาน animation บน timeline ได้ง่ายดังนั้น เราจำเป็นต้องรู้ว่า ณ timeline นี้ตัวแปรที่เปรียบเสมือนใช้แทนค่าอะไรก็แล้วแต่ มีผลต่อวัตถุนั้นหรือไม่ หรือ ตัวแปรนั้นตายไปแล้วหรือยัง มาดูกันดีกว่า ว่ามีอะไรบ้าง

1.ระดับ local ->ตัวแปร ประกาศใช้ใน function โดยจะขึ้นต้นด้วย var
หากมีการประกาศ var ตามด้วยตัวแปร ไปแล้ว เมื่อมีการอ้่างอิงตัวแปรที่มีชื่อนั้นเหมือนกัน(แต่ไม่มี var) คือ จะ เป็นตัวเดียวกัน

2.ระดับ timeline
กล่าวคือ เราประกาศตัวแปร ณ ที่ใด ใน frame บน timeline ก็จะสามารถอ้างอิงตัวแปรดังกล่าวได้ตั้งแต่
เฟรมที่ประกาศ เป็นต้นไป ไป ถึง ....ใน time

3.ระดับ Global -> เรียกใช้ได้ทั้งโปรแกรม
ตัวอย่าง _global.my_var=100;

เพิ่ม เติมนิดหน่อยเกี่ยวกับการอ้างอิงในการจัดการ movie clip
หากเรามีการสร้าง movie clip ไว้ซ้อนๆ เราอ้างอิงมันได้เหมือนกับการอ้างอิงไดเรกทอรี เช่น
โดยที่ movie clip หลัก ก่อนที่จะมีการสร้าง movie clipอื่น ๆ จะเป็น _root (movie clip )โดยที่การอ้างอิง
มีด้วยกัน 2 แบบ คือ
1. แบบAbsolute -> เริ่มจาก _root ไปเรื่อยๆจนถึงที่ต้องการ รับรองถ้าพิมพ์ถูก ไล่บำดับถูก หาเจอแน่นอน
2.แบบ Relative -> อ้างอิงกับmovie clip ที่ทำการฝังcode เอาไว้

Reference counted object:: 5 Rules

Reference counted object ->จะจัดหาขอบเขตของการแก้ปัญหาของobjในการจองหน่วยความจำบน heap(ด้วยคำสั่ง new) คำถามต่อมาก็คือเราจะลบมันหรือเคลียร์ หน่วยความจำตรงนั้นอย่างไร ซึ่งสามารถทำได้โดยการให้มี ตัวนับอ้างอิงให้แก่ obj กล่าวคือจะมีการนับเพิ่มขึ้นเมื่อมีการใช้งาน obj นั้นจากภายนอก และจะลดลงเมื่อใช้ เสร็จ เมื่อมีการใช้ครั้งสุดท้าย reference count จะเป็น 0 แล้วobj นั้นก็จะถูกลบไป
แต่การใช้งาน Reference counted object ก็มีข้อที่ควรระวังอยู่เหมือนกัน เนื่องจากเป็นการทำงา่นแบบอัตโนมัติจึงมีกฏในการใช้งานดังนี้ เพื่อให้การทำงานเป็นไปอย่างถูกต้องตามที่ควรจะเป็น
ref_ptr nptr =new osg::Node;
ซึ่งจะต่างจากการประกาศแบบนี้
osg::Node *nptr =new osg::Node; //จะไม่มีการนับการอ้างอิง


Rule Of Thumb #1
Always use ref_ptr<> to point to classes that are derived from Referenced.
กฏข้อนี้จะเป็นการใช้งานร่วมกันระหว่าง ref_ptr กับ standard pointer(*)
กล่าวคือ หากมีการโยนตัวชี้(node*) ไปให้ ref_ptr ชี้ต่อ จะทำให้จากเิดิมที่สร้าง (node*)แล้วทำการ deleteเองซึ่งไม่มีการ นับการอ้างอิง ไปยัง ref_ptr ที่มีการอ้างอิงซึ่งหาก เกิด นับแล้วเป็น 0 ขึ้นมา มีกา่รrelease หน่วยความจำขึ้นมา ก็...ซวย
Node *n=new Node();
ref_ptr ptr= n;
ปล.ในscope เดียวกัน อาจไม่เกิดปัญหา แต่ถ้าโยนข้าม scope เกิดปัญหาถ้าไม่มีการดักไว้ก่อน



Rule Of Thumb #2
Never return the address ref_ptr<> points to in the return value of a function. Return the ref_ptr<> itself.
ไม่ให้มีการรีเทิร์นค่าของที่อยู่ ที่ref_ptr ชี้อยู่ แต่ให้ return pointer จากฟังก์ชันหนึ่งไปยังอีก ref_ptr หนึ่งแทน เนื่องมีการ returm ค่าที่ref_ptr.get();จะมีการนับการอ้างอิง ทำให้เมื่อ return ตัวแปรref_ptr ของตัวส่งไม่เป็น0 จึงไม่ถูกลบ

Rule Of Thumb #3
Never use ref() or unref(), (or release(), or unref_nodelete()) unless you really, really, (really) know what you are doing. ค่อนข้างตรงตัวใช้ ref(),ฯลฯ เมื่อเรามั่นใจและรู้ว่ากำลังทำอะไร เนื่องจากการใช้ ref_ptr ในการจัดการแบบอัตโนมัติทำให้มีบางกรณีืั้ที่ไม่ตรงกับความหมายหรือค่าที่ควรจะเป็นจึงต้องมีการใช้การนับด้วยการใช้ฟังก์ชัน ref()หรือ unref() เองบ้างซึ่งควรระวังในการใช้งานด้วย

Rule Of Thumb #4
When subclassing from Referenced (directly or indirectly), always protect the destructor so the object cannot be allocated on the stack.
เมื่อมีการทำ subclass จาก Referenced โดยทางตรงหรืออ้อม จะมีการป้องกันการลบด้วย destructor
และไม่ให้มีการ ref_ptr แก่obj ที่จองหน่วยความจำบน stackgเช่น สร้างclass A(){};แล้วมีการส่ง&ของobjที่เป็น A a; แล้วส่งไปให้ฟังก์ชันที่ีมีการรับด้วยref_ptr

Rule Of Thumb #5
Exception to Rule Of Thumb #1
If circular referencing is possible, it is necessary to carefully use simple pointers when it is known that the the object will be referenced by another ref_ptr in the current scope.
ในบางกรณีหากการอ้างอิงการนับของเราไม่้ได้0หรือไม่มีการrelease memory ทั้งที่ควรจะทำ เราสามารถแหกกฎข้อ 1 ได้โดยการใช้ pointer ธรรมดาในการอ้างอิงแทนที่จะใช้ ref_ptr

Type Casting::C++

Type casting คือการแปลงจาก การกระทำของ typeไปยัง type อีกชนิดหนึ่งซึ่งมีหลายวิธีในการ Cast

Implicit conversion -> เราไม่ต้องกำหนด operation ในการ cast ใดๆ ทั้งสิ้น แต่จะเปลี่ยนโดยอัตโนมัติเมื่อค่าได้ ถูก คัดลอกไปในtypeที่เข้ากันได้ ซึ่งมีมาตรฐานในการแปลงซึ่งจะมีผลต่อพวก datatype พื้นฐานหรือ พวกการแปลงpointer ซึ่งอาจทำให้ค่าอาจสูญหายเช่น ทศนิยมขึ่นอยู่กับ การ implement ของ type พื้นฐาน

Explicit conversion ->เป็นการ แปลง type ที่มีการตีความของค่าที่ีแตกต่าง มี2แบบคือ
-แบบ c-like cast
b = (int)a;
-แบบ functional
b=int(a);

เนื่องจากการ conversion ระหว่าง class อาจทำได้อย่างถูก syntax แต่ิอาจจะไม่ compatible กันก็อาจทำให้ผลลัพธ์ไม่เป็นไปตามที่ต้องการได้ จึงได้มีการควบคุมการcasting ดังนี้

- dynamic_cast ::
อันนี้จะใช้กับ pointer และ reference ไปยัง object เท่านั้น เอาไว้ cast คลาสไปยัง base class
ซึ่งหากมีการ casting โดยไม่เป็นไปตาม derived to base จะฟ้องระหว่าง compile นอกจากว่า เป็น polimorphic กัน(มีการ overriding +inheritance + ใช้ตัวชี้แม่ ไปยังหน่วยความจำตัวลูก)


-static_cast :: สำหรับ static cast นี้ สามารถใช้ในการ conversion ระหว่าง pointer ได้โดยไม่จำเป็นที่จะต้องเป็นแบบ derived to base แต่มันไม่ค่อยปลอดภัยในการตรวจสอบ ซึ่งขึ้นอยู่กับดุลยพินิจของ programmer เอง สามารถใช้ในการ conversion ระหว่าง ตัวแปรแบบพื้นฐานที่เป็นแบบ implicit มากกว่า
และยังไม่มีการตรวจสอบในขณะรันไทม์ ด้่วย เช่น

double d=3.14159265; int i = static_cast<int>(d);

-reinterpret_cast ::ใช้ในการแปลงจาก ทุก pointer typeไปยัง pointer type อื่นที่ำไม่มีึความสัมพันธ์กับ
class ซึ่งผลลัพธ์จาการ cast จะเป็น binary value จากหนึ่ง pointer ไปยัง อีก pointer หนึ่งซึ่งจะขึ้นอยู่กับ
platform นั้นไม่สามารถ เคลื่อนย้ายไประบบอื่นได้

-const_cast ::ใช้สำหรับcast จาก const ไปยังที่ที่คาดหวังว่าจะต้องเป็น non- const

เราสามารถใช้ type_id ซึ่งอยู่ในในการตรวจสอบtype ได้ เช่น
class A{};

A *a=new A();
typeid(a).name();

การใช้ตัวชี้ฟังก์ชัน

พอดีไปติดเรื่องการใช้ตัวชี้ฟังก์ชัน(Function Pointer) ซึ่งคิดว่ามันเป็นข้อดีอีกอย่างหนึ่งของ C++มาดูกัน

int test1(int a,int b){
return a+b;
}

ใน main
------------------------------
int (*func_test)(int,int); // ประกาศตัวชี้ฟังก์ชัน

func_test=test1; //ให้ตัวชี้ไปชี้ที่หน่วยความจำที่เก็บฟังก์ชันนั้นหรือ func_test=&test1

cout<<(*func_test)(10,20); //เรีัยกใช้ ฟังก์ชันผ่าน ตัวชี้

ซึ่งการทำเช่นนี้จะช่วยให้่เราสามารถส่งผ่านฟังก์ชันไปเป็นพารามิเตอร์ให้กับฟังก์ชันโดยใช้ตัวชี้ได้

ตัวอย่างเช่น

int test(int a , intb){
return a+b;
}

int dosomething( int (*func_test)(int,int) , int a,int b){
return (*func_test)(a,b);
}

cout<test,10,20);

สิ่งที่น่าสนใจคือการส่ง test ผ่าน ฟังก์ชัน dosomething() เนื่องจากเมื่อโปรแกรมถูกเรียกให้ทำงาน ระบบปฏิบัติการจะมีการจัดสรรหน่วยความจำให้กับตัวแปร ,ฟังก์ชัน ,object, ... ดังนั้น ถ้าเราประกา่ศ function test ก็จะมีการจองหน่วยความจำให้กับฟังก์ชัน test ดังนั้น
ถ้าจะให้ไม่งงก็สามารถเรียกแบบนี้ก็ได้
cout<test,10,20); เป็นการส่งตน.หน่วยความจำไปให้ตัวชี้ เราก็สามารถใช้ตัวชี้เรียกใช้ฟังก์ชันดังกล่าวได้

โดยปกติแล้ว การเรียกใช้งานฟังก์ชันจะถูกเรียกใช้ในตอน คอมไพล์ไทม์ ซึ่งเป็นการกำหนด ว่าฟังก์ชันนี้ถูกเรียกใช้ตอนใด อย่างตายตัว ซึ่งใน c++สามารถเรียกใช้ฟังก์ชันในขณะรันไทม์ได้ ซึ่งเรียกว่า callback function

ตัวแปรแบบอ้างอิง (Reference Variable)

เคยสงสัยอยู่เหมือนกันว่า เวลาตอนส่งฟังก์ชันแบบ pass by reference ทำไมต้องมี & เช่น

void test (int &x){
x+=10;
}

int a=20;
test(a)


เนื่องจาก c++ มีการกำหนดรูปแบบ ตัวแปรแบบอ้างอิง(reference variable)
กล่าวคือ
int a=10;
int &b=a;
การกำหนดรูปแบบ ตัวแปรอ้างอิงนี้ จะกระทำเมื่อตัวแปรนั้นถูกนิยามมาแล้ว(ชื่อก็บอกอยู่ว่าอ้างอิง) ในการกำหนดค่าเริ่มต้น จึงไม่สามารถให้ค่าคงที่หรือ expression ได้โดยตรง
ผลลัพธ์ที่ได้คือ
นั่นคือ aและ b อ้างอิงหน่วยความจำตำแหน่งเดียวกัน ซึ่งเมื่อเราส่งตัวแปรแบบpass by reference แล้วเมื่อเรามีการ เพิ่มค่า xอีก10 ในฟังก์ชันtest ค่าของ a ก็จะเปลี่ยนด้วยแล้วไม่มีการ copyตัวแปรเหมือน pass by value

เราสามารถส่งค่ากลับ ด้วยการอ้างอิงได้ด้วย
เช่น
int & max(int &a,int &b){
return (a>b)? a:b ; //ไม่สามารถreturnเป็น a+10ได้ เนื่องจากเป็นexpression
}
int c=20;
int d=10;
max(c,d)=30;
จะได้ว่า ผลลัพธ์ที่ส่งกลับมาจากการเรียก ฟังก์ชันmax คือ ค่าที่มากที่สุดของa,b +1โดยค่าจะถูกเก็บในตัวที่
มากนั่นคือc=30

อีกอย่างหนึ่งก็คือการส่งค่าไปยังฟังก์ชันผ่านตัวชี้เช่น
void test3(int *x){
(*a)++;
}
int a=10;
test(&a)
การใช้ตัวชี้เพื่อรับค่าำพารามิเตอร์นั้นจะเป็นการใช้ตัวชี้ ชี้ไปยังหน่วยความจำในตำแหน่งเดียวกับ a ดังนั้นการใช้ (*x)++ ค่าของ aก็จะเปลี่ยนตามด้วย

หน่วยความจำกับการใช้งาน

วันนี้จะมาำำพูดถึงเรื่ิอง pointer ใน c++ กับการ จองหน่วยความจำ พอดีได้อ่านpdfมาแล้วคิดว่าโอ
ซึ่งจะเป็นเรื่อง หน่วยความจำกับการใช้งาน ใน window ซึ่งโดยปกติแล้ว เราสามารถจองหน่วยความจำจากที่ระบบปฏิบัติ จัดสรร มาใช้งานในการเขียนโปรแกรมได้ ซึ่งถ้าเป็นใน วินโดวส์จะมีหน่วยความจำเสมือนอีก
ดังนั้นเราจึงมีหน่วยความจำว่าง= หน่วยความจำทางกายภาพ + หน่วยความจำเสมือน

เมื่อโปรแกรมถูกสั่งให้ทำงาน ระบบปฏิบัติการจะจองหน่วยความจำให้กับโปรแกรมนั้นๆ
โดยเมื่อมีการเรียกใช้งา่นโปรแกรม ตัวแปรต่างๆจะถูกเก็บไว้ที่ สแตก ส่วนหน่วยความจำที่เราขอจากระบบปฏิบัติการจะมีการเก็บข้มูลไว้ที่ ฮีพซึ่งเป็นส่วนของหน่วยความจำที่เหลือว่างอยู่
เมื่อจบการทำงานของฟังก์ชัน ข้อมูลในสแตกจะนำมาใช้อีกไม่ได้ โดยอาจถูกลบทิ้งไป หรืออาศัยการเลื่อนตัวชี้สแตก ดังนั้นตัวแปรโลคอลจึงตายไปพร้อมกับฟังก์ชัน

Keyframe+Graph Editor +ตัวอย่าง

ภาำำำพโครงร่างการเิดินของPonygon

ตัวอย่างการเดินของม้าในจังหวะต่างๆเดี๋ยวเราจะมาทาม
animation ง่ายๆกัน

วิธีการใส่สกิน(skin)ให้ยึดกับกระดูก

-สร้าง bone ให้กับ ตัวโมเดล
-เลือก skin(หรือตัว model) กับ boneที่เป็น root ของbone ทั้งหมด จาก Hypergraph ::Hierarchy

-ไปที่เมนู skin ->bind skin ->smooth bind


















ปล.ต้องเลือกที่ dropdown ที่ Animation ก่อนจึงจะมีเมนู skin ปรากฎ

Basic Animation in MAYA

เกี่ยวกับการทำ animation ในmaya หลักๆ มีด้วยกัน 5เทคนิค

1.ใช้KeyFrame และ Graph editor -> เขยื้อน keyframe (ณ เวลาืที่ต่างกัน ภาพไม่เหมือนกัน)

2. Set Driven Key ->ประมาณว่า จะมี 2 เหตุการณ์ (driver กับ driven)ที่ขึ้นต่อ กัน เช่นเมื่อมี คนเดินมา ประตูจะเปิด

3. Path Animation -> เคลื่อนที่ตาม เส้น Pathที่วาดไว้

4.Nonlinear animation with Trax -> สร้างclip การเคลื่อนที่ เช่นสร้างคนเดินด้วยท่าที่ต่างกัน 5ก้าว แล้ว เล่น clip ที่สร้างไว้ ต่อไปอีก

5.Inverse kinematics ->เคลื่อนที่ขึ้นอยู่กับจุดหมุนเช่นถ้าเรายึดกระดูกที่ข้อมือกับกระดูกที่หัวไหล่แล้วเคลื่อนที่ข้อศอกก็จะงอเป็นต้น

Model :: PONYTA

วันนี้มีโมเดล pegasusมาอวด เนื่องจากเห็นแบบมันสวยดี ก็เลยลองวางโครงโมเดลเอง ตั้งชื่อ ให้มันมา ponyta มาจากชื่อโปเกมอนม้าไฟ... ลองดูเลยแต่ตรงปีกยังไม่ค่อยเนียนเท่าไหร่ ยังไม่ได้ใส่ texture + กระดูก...แค่นี้ก่อนแล้วกัน นอนดีกว่า ง่วงและ

basic:: open scene graph(ต่อ)

วันนี้มาupdate กันต่อกับ open scene graph มาตอนดึกหน่ิอย เพราะตอนกลางวันไม่ค่อยมีเวลาว่างเท่าไหร่
ก็จะมาพูดกันเรื่อง พื้นฐานที่ควรรู้

กราฟิกไปป์ไลน์
-vertex shader เปลี่ยนพิกัดของ vertexต่างๆให้อยู่ในระบบพิกัดของกล้อง คำนวณสีและแสงตกกระทบแต่ละเวอร์เท็กซ์
-Rasterizer เปลี่ยนข้อมูลทางเรขาคณิต(vertex)เป็นข้อมูลของรูป
แฟรกเมนต์ = จุดบนรูป + ข้อมูลอื่นๆ (ความลืก, สี, ฯลฯ)
เฉลี่ยข้อมูลของเวอร์เท็กซ์ไปบนแฟรกเมนต์ต่างๆ
-fragment shader คำนวณสีของแต่ละพิกเซลบนจอ อ่านข้อมูลสีมาจากเท็กซ์เจอร์

วิธีติดตั้ง open scene graph บน Mac OSX

ในการลง Open scence graph ใน Mac OSX 10.5 (Leopard) นั้น ส่งที่ต้องทำคือ การ install Xcode Developer Tools from Appleก่อน
ดาวน์โหลดได้จากที่นี่
1. Xcode Developer Tools (get 3.0 or newer)
2. OpenSceneGraph 2.8.0 Installer for Mac OS X 10.5 (Leopard)
วิธีการ install
- Run ตัว OSG installer
-เปิด Xcode และไปที่ File -> New Project... ให้เลือก OSG Application ใน
Mac OS X - Application
-กดปุ่ม Build and Go เมื่อลงสำเร็จได้ดังรูป

basic:: open scene graph

วันนีั้้มาพูดถึงเรื่อง open scene graph กันบ้างได้พอไปศึกษามาบ้าง แล้ว แต่ความรู้ยังต่ำต้อยอยู่ ลองดูก็แล้วกัน

มาเริ่มกันก่อนว่า scene graph คืออะไร scene graph เป็น Tree Structure (Directed Acyclic Graph => เป็นกราฟระบุทิศทางที่ไม่เกิดวัฏจักร ถ้าเอาชื่อเต็มยศก็คือ กราฟอวัฏจักร ระบุทิศทาง) ซึ่งนำมาใช้เป็นหลักในการจัดการเกี่ยวกับองค์ประกอบทางกราฟิก ดังนั้นจึงมีคุณสมบัติที่สำคัญอย่างหนึ่งซึ่งก็คือ เกิด Herarchical Structure ซึ่งก็คือการสืบทอดเป็นลำดับขั้น ของวัตถุ ดังนั้นเมื่อมีการกระทำที่ตัวของ root แล้วก็จะมีผลกับต้วchild ของ root นั้น ด้วย

open scence graph เป็น opensource ที่ใช้ concept ของ Scence graph ในการที่เป็นเครื่องมือในการพัฒนา กราฟิก aplication ในระดับสูงโดยใช้สร้าง simulation ทางวิทยาศาสตร์ , game ,ฯลฯ


เนื่องจาก OSG ถุกเขียนเป็น Standard C++ และ openGL โดยเราสามารถใช้ประโยชน์ จาก STL(Standard Template Library และ Design Pattern ในการพัฒนาได้)
อีกทั้งยัง Cross-platform โดยจะสนับสนุนทุก plateform ที่มี openGL และ C++ เช่น Windows, MacOSX, BSD, Linux, Solaris ฯลฯ

3D database loaders ประกอบไปด้วย

• OpenFIight (.flt)
• TerraPage(.txp) including multi-threaded paging support
• LightWave(.lwo), Alias Wavefront (.obj)
• Carbon Graphics GEO (.geo)
• 3D Studio MAX (.3ds)
• Peformer (.pfb)
• Quake Character Models (.md2)
• Direct X (.x)
• Inventor Ascii 2.0 (.iv)
• VRML 1.0 (.wrl)
• Designer Workshop (.dw)
• AC3D (.ac)
• .osg Native OSG ASCII format.
• .osg Native OSG banary Format

ส่วนภาพก็จะเป็นพวก

• .rgb
• .gif,
• .jpg
• .png
• .tiff
• .pic
• .bmp
• .dds
• .tga
• quicktime (under OSX).
• Fonts (via the freetype plugin)

วิธีการแปลงไฟล์ MAYA (.mb)ไปเป็น (.flt)

เนื่องจาก open scene graph หากเราอ่านไฟล์ โมเดลที่เป็น .flt เราสามารถ กำหนดชื่อใน maya ใน herarchy ให้กับnode แล้วเขียนโปรแกรมด้วย open scene graph ในการcontroll node นั้นโดยการอ้างอิงชื่อนั้นได้ เช่น หากเราสร้างโมเดล มังกร ขึ้นมาอันนึงแล้ว สร้าง bone ให้กับ modelนั้น เราสามารถใช้ open scene graph ในการบังคับ joint ให้ หมุนหรือ เคลื่อนที่ได้ แต่จะไว้พูดถึงทีหลัง แต่มาดูวิธีการแปลงไฟล์ MAYA(.mb)ไปเป็น .flt ก่อนแล้วกัน ซึ่งไฟล์(.flt)นั้น จะมีการบันทึกเกี่ยวกับชื่อของโหนด ที่เราสร้างจาก maya ไว้ด้วย
มาลองดูกันเลยแล้วกัน
เริ่มจาก
-ไปที่ window ->Settings/Preferences > Plug-in Manager



จะมีหน้าต่าง ขึ้นมาให้ ติ๊กที่ fltTranslator.mll แล้วกด Refresh

-เลือกโมเดลที่ต้องการ export แล้วไปที่ File-> export selection > []

เลือก File type: เป็น OpenFlight

-กด Export Selection แล้ว save

วิธีการ Setup Character บน MAYA

เริ่มจากการสร้าง skeleton บน Maya ทำดังนี้
1.ไปที่ skeleton ->Joint tool เพื่อสร้างกระดูกจำลอง

(ในครั้งต่อไปสามารถใช้ joint tool ได้จาก toolbar)

<> Miror joint เพื่อสร้างmirror จากต้นแบบ)









3.ไปที่ window >Hypergraph : Herarchy จะแสดง หน้าต่าง เกี่ยวกับ ลำดับขั้นในการเชื่อมต่อข้อต่อ


โดย ถ้าเราสร้างข้อต่อใดก่อนข้อต่อนั้นจะเป็น root ของข้อต่อชิ้นต่อไปที่เราสร้าง ดังนั้น ถ้าเราสร้าง คน ส่วนที่เป็น root ควรที่จะเป็น joint ช่วงกลางลำตัว เนื่องจาก ถ้าเราหมุนเอว ช่วงบนของเราจะหมุนด้วย แต่ถ้าหมุนหัว เอวไม่ได้หมุนด้วย...

เราสามารถเคลื่อนย้ายHerarchy ( องคา่พยบ ) ส่วนของข้อต่อได้โดย drag mouseกลางที่ส่วนของ jointที่เป็น child ไปยัง joint ที่เป็น root.... ให้นึกถึงลำดับdirectory ไฟล์ ถ้าเรา ลบ folder แล้ว sub folder ใน folder นั้น ก็จะถูกลบด้วย เป็นต้น

เราสามารถเปลี่ยนชื่อ ของ joint ได้โดยคลิ๊กขวา แล้ว rename

4. การหมุน bone ที่เราสร้างขึ้น ทำได้ดังนี้
-ให้เลือก skeleton >IK Handle Tool

จะมี icon ปรา่กฏบน tool bar ดังรูป

คลิ๊กเพื่อเลือกข้อต่อหลักที่ใช้ในการหมุนโดยคลิ๊กที่ joint แล้วกดshift แล้วคลิ๊กอีกอัน จากนั้น ใช้ move transform เคลื่อนย้ายข้อต่อ 2 อันดังกล่าว

5.ทำการ smooth binding skin เพื่อ ยึด skinให้เข้ากับ skeleton ของเรา

-ทำการเลือก joint ที่เป็น root ของทั้งหมด
-กดshiftแล้ว เลือกskin (Modelที่เราสร้างนั่นเอง)
-ไปที่ skin ->bind skin >smooth bind
-ลองขยับ skeleton ดูว่า skinเคลื่อนที่ตามหรือป่าว







note :เนื่องจาก model ที่เราสร้างขึ้นอาจจะไปบังการเคลื่อนที่ของกระดูกเวลาเราต้องการหมุนกระัดูก เราสามารถ hide modelของเราก่อนได้โดย
-เลือกโมเดลของเรา
- ไปที่ Display -> hide >hide selection
*หากต้องการ show ให้ไปที่ Display -> show > All ก็ได้

**ในการทำงานบางที อาจเกิด ทำ พวกหน้าต่างที่ใช้ในการทำเช่น animation frame line ฯลฯหายไปสามารถเรีัยกกลับมาได้โดยไปที่ Display ->UI elements ->show All UI Elements ได้

การดู shading ใน view port ของมุมมองให้ไปที่ shading ->แล้วเลือกดู

ตัวอย่าง shade

วิธี convert file MAYA (.mb) to OSG

เริ่มจากการ download สิ่ง ต่อไปนี้
1.OpenSceneGraph-2.2.0
2.program Autodesk Maya (ในที่นี้ใช้2010)

วิธีก็คือ

1. เปิด Maya ขึ้นมา แล้วไปที่ window > Setting \Preferences >Plugin Manager




















2. เลือก (ติ๊กถูกที่ load ,Autoload )ของ objExport.mll แล้วกด refresh


3. ทดลองสร้าง model cube ซักอันนึง (create Polygon Primitive >Cube )แล้ววาด ลงworkspace จากนั้น เลือก model นั้นซะ

4.กด Export selection แล้ว save ไว้(c:\test.obj)

5.extract file openscene graph (c:\OpenSceneGraph-2.2.0\bin ซึ่งในนี้จะมีไฟล์ osgconv.exe)

6.เปิด command line แล้วเข้าไป ใน c:\OpenSceneGraph-2.2.0\binด้วยคำสั่ง
cd c:\OpenSceneGraph-2.2.0\bin

7.จากนั้น พิมพ์ osgconv.exe path_of_flie.obj เช่น osgconv.exe c:\test.obj

8.ทดสอบการ convert พิมพ์ฺ osgViewer converted.osg ซึ่ง converted.osg จะเป็นชื่อไฟล์ที่ทำการconvert เรียบร้อยแล้วอยู่ใน c:\OpenSceneGraph-2.2.0\bin สามารถ rename ได้



ถ้าิอ่านแล้วงง สามารถดู วีดีโอ ได้ที่ http://www.youtube.com/watch?v=TnvdcKhz4oA

มาต่อกันอีกดีกว่า ได้ลองไปทามโมเดล โดยใช้polygon มา เป็นรูปมังกรแต่ได้ออกมาเป็นมังกือ ลองดูตัวอย่างภาพ
ก็ได้เรียนรู้เกี่ยวกับ tool ที่ใช้ในการสร้างมาเล็กน้อยเช่น split polygon ,merge vertex , miror,cut face,combine,smooth
เป็นต้น ส่วนการทำโมเดลให้ดูได้จาก เว็บนี้ มาดูกันเลยดีกว่า

ตอนนี้เริ่มเบื่อๆเปลี่ยนโหมดมาเล่นบ้าง กำลังจะลองหัด เล่น maya อยู่ก็เลยอยากจะเขียนเกี่ยวกับสิ่งที่ได้ลองเล่นแล้วกันนะ เริ่มจาก basic maya เกี่ยวกับ tools และ shortcut key และtechnique ต่างๆก็แล้วกัน(maya 2010)หน้าตาโปรแกรมก็ประมาณเนี่ยแหละ
ไม่รุเหมือนกันว่ามีอะไรเพิ่มมาจากเวอร์ชันเดิมบ้าง...เพราะมาถึงก็เล่นอันนี้่เลย ก่อนหน้านี้ก็เคยเล่น 3dsmax(ไปได้แค่สร้าง modeling ขี้เกิยจซะก่อน) และก็ blender(อันนี้ใช้เรียนทาม basic modelเป็นห้องของฉัน)

เอาหละเริ่มกันเลยดีกว่า พอดีอ่าน tutorial ไปด้วยทามไปด้วย

-เวลา่เปิด ก็ไปที่ File -> New scene เวลา save ก็ Save Scene As.. ธรรมดา ได้นามสกุล .mb (maya

binary file)
สร้าง primitive object ทำยังไง
ไปที่ create มี4 โหมดให้เลือกแต่ที่ใช้กันคือ
-แบบ Polygon (เกิดจากเส้นเชื่อมกันสามารถแก้ไขพวก vertex ,face,line ได้)กับ
-แบบ NURBS (เป็นวัตถุที่สร้างจากเส้นโค้งจะsmooth กว่า)

ซึ่งเราสามารถเปลีั่ยนระหว่างสองอย่างนี้ได้เป็นอาจจะไำม่เป็นไปตามที่เราต้องการก็ได้

สำหรับ primitive object ที่สร้่างได้ก็มี พวก cube , torus , sphere ,cylinder,ฯลฯ

ให้ไปที่ create->NURBS Primitives >Cube [] //เมื่อเราต้องการสร้างลูกบาศก์จาก NURBS








เมื่อกดแล้วจะมีปุ่มให้ปรับคุณสมบัติก่อนสร้างวัตถุเมื่อปรับค่าเสร็จแล้วก็click + drag mouse สร้าง วัตถุได้เลย





















เครื่องมือพื้นฐานของ Maya ในการ Transforms

-> Translate เคลื่อนย้ายวัตถุ

-> Rotate หมุนวัตถุ

-> Scale ย่อขยายขนาด


อย่าลืมเลือกวัตถุก่อนหละ

เลือกวัตถุ (selection tool)

หากต้องการ copy วัตถุ ให้ทามดังนี้
-ไปที่ี edit-> duplicate ก็จะำได้วัตถุ copy นั้นอยู่ตำแหน่งเดิม ให้แล้วใช้ เครื่องมือ translate ย้ายตัวที่ duplicate ออกจากตำแหน่งเดิม
-อีกวิธีหนึ่ง ไปที่ edit ->duplicate special จะมี option ให้เลือกสำหรับตั้งค่าเกี่ยวกับ วัตถุcopy ว่า จะให้ไปอยู่ไหน ,หมุนเท่าใด ,เป็นกี่เท่าของของเดิม,ฯลฯ




เกี่ยวกับการมอง
-กด space bar เพื่อให้มีการแสดงโหมดในการมอง 4แบบ คือ top,front ,side ,perspective
-สามารถเลือกมุมการมองได้จากส่วนนี้

Channel Box

มีไว้สำหรับให้เราแก้ไขวัตถุเกี่ยวกับการ transform (translate-rotate-scale )หลังจากที่ไ้ด้สร้างวัตถุนั้นขึ้นมาแล้ว

short cut key เกี่ยวกับการหมุนมุมมอง
- super+กดmouseซ้ายค้างแล้วหมุึน
-super + ปุ่มกลางmouse

วิธีติดตั้ง artoolkit and vrml บน Mac?

กว่าจะใช้งาน artoolkit บน Mac ได้ หืดขึ้นคอ ไม่ใช่ลงยากอะไรนะ แต่มันหาไฟล์ที่จะลงโคตรยากเลย
เริ่มกันเลยสิ่งที่ต้องใช้ก็คือ
1. ARToolKit-2.72.1
2.openvrml-0.16.3-bin-macosx
3.libARvrml.a (*ตัวนี้แหละหายาก ตอนแรกหาเจอดันทำหาย)
เอา video ไปดูเอาเองแล้วกันมันยาวทำตามในนี้เลย รับรองได้ชัวร์