Blender 2.48 released with real-time Bullet soft bodies

ความสามารถที่ว่านี้ของ Blender อยู่ในตัว Game Engine ครับ ลองดู video ประกอบจาก youtube





ความสามารถของ Blender เกี่ยวกับการทำเกมส์นั้นมีเยอะ ลองศึกษาดูครับ

http://www.bulletphysics.com/

PyOgre Beginner Tutorial 2 – Part 2 Cameras&ViewPort

Creating the Camera
การสร้างกล้องเราจะสร้างแทนที่ default method ใน  ExampleApplication ที่ใช้สร้างกล้อง
โดยหาฟังก์ชั่นสมาชิก _createCamera สิ่งแรกที่ต้องทำ เราจะใช้  SceneManager สร้างกล้องขึ้น เพิ่มโค้ดตามนี้

self.camera =  self.sceneManager.createCamera ('PlayerCam')

นี่จะเป็นการสร้างกล้องโดยมีชื่อว่า "PlayerCam" จำไว้ว่าคุณสามารถที่จะใช้  getCamera ฟังก์ชั่นของ  SceneManager เพื่อเข้าถึงกล้องผ่านชื่อ ถ้าคุณตัดสินใจไม่เอาตัวชี้มาอ้างถึงมัน
สิ่งที่เราจะทำต่อไป ทำการตั้งค่าตำแหน่งและทิศการหันในกับ Camera ที่เราสร้างขึ้น โดยจะให้กล้องวางอยู่ห่างจากจุด กำเนิด และหันหน้าเข้าจุดกำเนิด

self.camera.position = (0, 10, 500)
self.camera.lookAt((0, 0, 0))

สำหรับ lookAt function เป็นฟังก์ชั่นที่เราจะใช้ในการบังคับให้ Camera หันหน้าไปในทิศทางที่เราต้องการ โดยที่เราไม่ต้องเข้าไปยุ่งกับการหมุนกล้อง หันกล้อง ทำให้เราสามารถที่จะตั้งค่าการหันกล้องไปในทิศทางที่เราต้องการง่ายมากขึ้น ในขั้นสุดท้าย ทำการตั้งค่าระยะใกล้ ในการแสดงภาพของกล้อง ที่มองออกไป(near clipping distance)

self.camera.nearClipDistance = 5

เรายังสามารถที่จะ ทำการตั้งค่าระยะไกล ในการแสดงภาพของกล้อง ที่มองออกไป(far clipping distance) ได้โดยใช้คุณสมบัติที่เรียกว่า "farClipDistance"

Viewports

Ogre Viewports
เมื่อคุณเริ่มมีการ ใช้กล้องหลายตัว เนื้อหาสำคัญเกี่ยวกับ  Viewport class นั้นจะเริ่มมีประโยชน์สำหรับคุณมากขึ้น หัวข้อที่เริ่มเกิดขึ้นขนาดนี้เพราะว่า มันเป็นสิ่งสำคัญสำหรับคุณที่ จะต้องเข้าใจว่า Ogre ตัดสินใจว่ากล้องอันไหนที่จะต้อง ทำการเรนเดอร์ภาพจากกล้องนั้นให้ปรากฎบนหน้าจอ และมันมีความเป็นไปได้สำหรับ Ogre ที่จะมี  SceneManagers หลายตัวในเวลาเดียวกัน ดังนั้นจึงสามารถที่จะแบ่งหน้าจอให้แสดงผลจากหลายกล้องได้ แต่ต้องเรียนรู้ในระดับที่สูงกว่านี้
ในการทำความเข้าใจเกี่ยวกับการ เรนเดอร์ภาพของ Ogre ซึ่งประกอบไปด้วยส่วนที่สำคัญ  Camera,  SceneManager, และ RenderWindow
RenderWindow มันคือหน้าต่างพื้นฐานที่ใช้ในการแสดงทุกสิ่งให้ปรากฏบนจอ
SceneManager ใช้สร้าง Camera เพื่อแสดง Scene

ในการที่จะเรนเดอร์ภาพจาก Camera ตัวไหนคุณต้องบอก  RenderWindow  ตามธรรมดาที่ใช้ใน Ogre คุณควรจะสร้าง Camera เพียงตัวเดียว และทำการเซต Camera ให้ใช้  RenderWindow และมี Viewport เดียว ซึ่งเราจะได้ศึกษาต่อไปนี้ และยังมีการตั้งค่าภาพพื้นหลังให้กับ Scene อีกด้วย


Creating the Viewport
เพิ่มโค้ดในส่วนของ TutorialApplication._createViewports เพิ่ม Viewport

viewport = self.renderWindow.addViewport (self.camera)

ตั้งค่าสีพื้นหลังเป็นสีดำ

viewport.backGroundColor = (0, 0, 0)

และสิ่งสำคัญคือการตั้งค่า อัตราส่วนการแสดงผลของ Viewport ซึ่งค่าโดยมาตรฐานแล้วคือแสดงเต็มจอ

self.camera.aspectRatio = float (viewport.actualWidth) / float (viewport.actualHeight)

และนี้ก็คือการใช้ Class Viewport อย่างง่ายๆ

PyOgre Beginner Tutorial 2 – Part 1 Cameras

From Ogre Wiki แก้ไข 22/10/2551

Cameras

Introduction
ในบทนี้จะได้เรียนรู้เกี่ยวกับ แนวความคิดเกี่ยวกับ Light objects และการสร้างเงาใน Ogre และครอบคลุมถึงพื้นฐานของ Cameras
ทำความเข้าใจกับบทนี้ คุณควรเขียนเพิ่มโค้ดช้าๆ และดูผลลัพธ์ที่ได้เป็นระยะ

Getting Started
หลังจากที่ได้เริ่มต้นกับโค้ดเริ่มต้นมาแล้ว จากนี้เราจะเพิ่ม methods อีกสองอันเข้าใน  TutorialApplication class ได้แก่ _createViewport และ _createCamera ซึ่งฟั่งก์ชั่นทั้งสองได้ถูกกำหนดไว้แล้วใน class หลัก  SampleFramework.Application แต่ในบทนี้เราจะมาดูว่า  Cameras และ  Viewports ซึ่งมีอยู่ในเวลานี้ถูกสร้างและใช้ยังไง
เริ่มสร้างไฟล์ "basic_2.py" เพิ่มโค้ดตามนี้

import ogre.renderer.OGRE as ogre
import SampleFramework as sf

class TutorialApplication (sf.Application):

def _createScene (self):
pass

def _createCamera (self):
pass

def _createViewports (self):
pass 

if __name__ == '__main__':
ta = TutorialApplication ()
ta.go ()

เราสามารถที่จะให้เมาส์ หรือกดปุ่ม WASD เพื่อที่จะเคลื่อนฉาก(Scene)ในแนวระนาบได้ และสามารถที่จะออกจากโปรแกรมโดยกดปุ่ม ESC



Ogre Cameras
กล้อง (Camera) คือ สิ่งที่เราใช้ในการมองเข้าไปในฉาก(Scene)เพื่อแสดงสิ่งที่เราได้ทำการสร้าง ขึ้นในฉาก กล้องเป็นวัตถุพิเศษที่มีการทำงานบางอย่างคล้าย SceneNode มันมีคุณสมบัติ "positon" และ yaw function, roll function, pitch function คุณสามารถที่จะนำมันผูกติด SceneNode ใดก็ได้เหมือนที่อธิบายผ่านมากล้อง มีตำแหน่งที่สัมพันธ์กับโหนดหลักที่ผูกติดอยู่ สำหรับการเคลื่อนที่และหมุน คุณสามารถคิดว่ากล้อง นั้นเหมือน SceneNode
สิ่งหนึ่งเกี่ยวกับกล้องใน Ogre เราไม่สามารถกล้องสองอันเพื่อมองไปในฉากพร้อมกันและ เปิดใช้(enabling) หรือ ปิดใช้(disabling) กล้องในส่วนของScene ที่ต้องการแสดงได้ แต่สามารถที่จะทำให้เกิดผลแบบนี้ได้โดยใช้ วิธีอื่นแทน โดยการสร้าง SceneNode ที่ให้เป็น "camera holders" และตั้งค่าจุดที่ต้องการมองให้กล้อง ที่ต้องการมองในตำแหน่งต่างๆ ดูวิธีการนี้ได้ใน

Basic Tutorial 4.

List of Free Numerical Analysis Software

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

http://www.ann.jussieu.fr/~lehyaric/freesoft/free.htm

PyOgre Beginner Tutorial 1 - Part 6

SceneNodes more in Depth

Class SceneNode เป็น Class ที่มีความซับซ้อนมาก มีหลายอย่างที่เราสามารถที่จะทำกับ SceneNode ได้ ดังนั้นเราจะกล่าวถึงเพียงในส่วนที่มีการใช้เป็นประโยชน์มากที่สุดและบ่อย
คุณสมบัติ ‘position’ สามารถใช้ในการตั้งค่าหรือขอค่า ตำแหน่งของ SceneNode (สัมพันธ์กับ SceneNode ที่เป็นหลัก) คุณสามารถที่จะเคลื่อน วัตถุสัมพันธ์กับตำแหน่งปัจจุบัน โดยใช้ translate method
                SceneNodes ไม่เพียงจัดการแค่ตำแหน่ง แต่สามารถจะจัดการทั้ง การขยาย (scale) วัถตุโดยใช้ฟังก์ชั่น scaleBy และการหมุน (rotation) ของวัตถุ สามารถที่จะทำโดยใช้ฟังก์ชั่น yaw, roll, และ pitch เมื่อเราต้องการให้ค่าที่เราได้ทำการเปลี่ยนแปลงไปนั้นกลับมาเป็นเหมือนเดิม เราก็ให้ฟังก์ชั่น resetOrientation และเรายังสามารถที่จะใช้คุณสมบัติ ‘orientation’ ในการที่จะดูค่า หรือเซตค่าได้เหมือนกัน
                เราได้เห็นการให้งานฟังก์ชั่น attachObject จากโค้ดโปรแกรมที่ผ่านมาแล้ว ยังมีอีกหลายฟังก์ชั่นและหลายคุณสมบัติที่จะช่วยให้เราสามารถที่จะจัดการ กับวัตถุที่ถูกผูกติดไว้กับ SceneNode เช่นคุณสมบัติ numAttachedObjects ฟังก์ชั่น getAttachedObject (มีหลายเวอร์ชั่น สำหรับฟังก์ชั่นนี้), detachObject(มีหลายเวอร์ชั่นเหมือนกัน), detachAllObjects ซึ่งทั้งหมดสามารถช่วยจัดการ SceneNodes ได้เป็นอย่างดี


                เมื่อเรารู้ว่าการเปลี่ยนแปลงตำแหน่ง การเคลื่อนย้าย มีความสัมพันธ์ กับตัวโหนดหลัก (parent) ของ SceneNode  เราจึงสามารถที่จะทำให้ SceneNode สองอันเคลื่อนย้ายไปด้วยกันโดยง่ายตามโค้ดนี้

ent1 = sceneManager.createEntity('Robot','robot.mesh')
node1 = sceneManager.getRootSceneNode().createChildSceneNode('RobotNode')
node1.attachObject (ent1) 

ent2 = sceneManager.createEntity ('Robot2','robot.mesh')
node2 = sceneManager.getRootSceneNode().createChildSceneNode('RobotNode2',(50,0,0))
node2.attachObject (ent2)

ถ้าเราเป็นโค้ดจากเดิม

node2 = sceneManager.getRootSceneNode().createChildSceneNode('RobotNode2',(50,0,0))

ไปเป็น

node2 = node1.createChildSceneNode('RobotNode2',(50,0,0))

ดังนั้นแล้วเราได้ทำให้ RobotNode2 เป็นโหนดลูกของ RobotNode เมื่อมีการเคลื่อนย้าย node1 ก็จะย้าย node2 ตามไปด้วย แต่การเคลื่อนย้าย node2 ไม่มีผลใดๆกับ node1 ตัวอย่างโค้ดถ้าเคลื่อนย้าย RobotNode2 อย่างเดียว:

node2.translate((0,50,0))

ตัวอย่างโค้ดถ้าเคลื่อนย้าย RobotNode แล้ว RobotNode2 จะย้ายตาม:

node1.translate((0,50,0))

ถ้ามีปัญหากับสิ่งที่กล่าวมานี้ให้ลองไล่เริ่มที่ root SceneNode ลงไปเริ่มจาก

ถ้าเราให้ node1 เริ่มที่ (0,0,0) และย้ายไปที่ (25,0,0) ตำแหน่งใหม่ของ node1 จะกลายเป็น (25,0,0)

ถ้าเราให้ node2 เริ่มที่ (50,0,0) และย้ายไปที่ (10,0,10) ตำแหน่งใหม่ของ node2 จะกลายเป็น (60,0,10)

แต่สิ่งที่เกิดขึ้นจริงคือ เริ่มที่ root SceneNode ซึ่งตำแหน่งของมันจะมีค่า (0,0,0) ตลอด แล้วเราให้

node1 มีตำแหน่งคือ (root+node1)(0,0,0)+(25,0,0) = (25,0,0)

ขณะนี้ node2 เป็นโหนดลูกของ node1 ดังนั้นตำแหน่งของมันจะเป็น

 node2 มีตำแหน่งคือ (root+node1+node2)(0,0,0)+(25,0,0)+(60,0,10) = (85,0,0)

นี้เป็นเพียงตัวอย่างที่อธิบายความสัมพันธ์ที่เกี่ยวของตำแหน่งโหนดหลัก และโหนดลูก

ท้ายสุดของ PyOgre Beginner Tutorial 1  นี้จำไว้ว่าเราสามารถเข้าถึงทั้ง SceneNodes และ Entities โดยการเรียกชื่อผ่านฟังก์ชั่น getSceneNode และ getEntity ของ SceneManager ดังนั้นไม่ต้องเก็บตัวชี้ (pointer) กับทุกๆ SceneNode ควรใช้เฉพาะที่ต้องใช้พอ

PyOgre Beginner Tutorial 1 - Part 5

Vectors and ColourValue

ถ้าคุณจิตนาการจะเห็นว่า ภายใน Class จะมีการใช้ Ogre เป็นจำนวนมาก ซึ่งสองอย่างจากทั้งหลายเหล่านั้นก็คือ Vector3 และ ColourValue คุณสามารถทำให้มันง่ายขึ้น เมื่อคุณต้องการใช้ 
Vector3  และ ColourValue คุณสามารถใช้ tuple แทน เช่น Vector3(50,0,0) และ ColourValue(1,1,1) แทนเป็น (50,0,0) และ (1,1,1)แทน ดังโค้ดต่อไปนี้

sceneManager = self.sceneManager

sceneManager.ambientLight = (1, 1, 1)

ent1 = sceneManager.createEntity('Robot', 'robot.mesh')
node1 = sceneManager.rootSceneNode.createChildSceneNode('RobotNode')
node1.attachObject(ent1)

ent2 = sceneManager.createEntity('Robot2', 'robot.mesh')
node2 = sceneManager.rootSceneNode.createChildSceneNode('RobotNode2', (50, 0, 0))
node2.attachObject(ent2)

   
Entities more in Depth

    Entity class เป็น class ที่มีเนื้อหาที่กว้าง เราไม่สามารถที่จะพูดถึงการใช้งานเกี่ยวกับมันได้หมดในขนาดนี้ ต้องศึกษาเอง แต่จะยกตัวอย่างฟังก์ชั่นบางอย่างที่ให้เป็นประโยชน์ได้มาก 2-3 อัน
     คุณสมบัติที่หนึ่ง  “visible” คุณสามารถที่จะตั้งให้ Entity สามารถมองเห็นได้หรือไม่ โดยการตั้งให้มันเป็น True หรือ False แทนการที่จะ ลบและสร้าง Entity ใหม่ในแต่ละครั้งซึ่งจะทำให้ต้องมีการ สร้างโหลดทุกครั้งทำให้ไม่เสียเวลาในการ โหลดใน Memory ทุกครั้ง
     คุณสมบัติ  “name”  จะส่งค่าชื่อของตัว Entity กลับ (ค่าอ่านได้อย่างเดียว เราไม่สามารถเปลี่ยนชื่อได้หลังจากสร้างมันขึ้นมาแล้ว)
 คุณสมบัติ  “parentSceneNode” ส่งค่า SceneNode,entity ที่ผูกติดกลับมัน

PyOgre Beginner Tutorial 1 - Part 4

Coordinates and Vectors
    ก่อนที่เราจะไปไกลกว่านี้ เราจะต้องพูดถึงเรี่ยวกับ screen coordinates and Ogre Vector objects สำหรับ Ogre นั้นก็เหมือนกับ กราฟฟิกเอนจิ้นทั่วๆไป คือ ให้แกน X เป็นแนวนอน Z แกนแนวลึก และ แกน Y เป็นแนวตั้ง เมื่อคุณมองจอคอมพิวเตอร์ขณะนี้ แกน X จะเริ่มจาก ซ้ายไปขวาของจอ โดยด้านขวาจะเป็นทิศทางบวก แกน  Y จะเริ่มจากล่างขึ้นบนของจอ โดยด้านบนจะเป็นทิศทางบวก  แกน Z จะมีทิศเข้าสู่จอและออกจากจอ โดยทิศทางบวกจะเริ่มจากทางนอกจอเข้าสู่จอ
    ถ้าให้ตัวหุ่นยนต์ Robot ในฉากหันหน้าไปตามทิศแกน X ในทิศบวกซึ่งเป็นคุณสมบัติของ Mesh เองที่มันสร้างถูกออกแบบไว้แล้ว Ogre ไม่สามารถที่จะรู้ได้ว่า Model ของคุณนั้นมีทิศหันไปทางไหน ดังนั้นแต่ละตัวที่ถูกโหลดขึ้นมา จะมีการหันทิศทางการหันแตกต่างกันออกไป
    Ogre ใช้ Vector class เป็นตัวแทนของตำแหน่งและทิศทาง (ไม่ใช่ Point class ) ซึ่งการกำหนด Vector จะมีอยู่ 2(Vector2), 3(Vector3), และ 4 (Vector4) มิติ โดยมากแล้ว Vector3 นั้นจะถูกใช้มากกว่า ถ้าคุณไม่คุ้นเคยกับ Vectors ก็ควรจะศึกษาเพิ่มเกี่ยวกับมัน ก่อนที่คุณจะทำอะไรที่ยากขึ้นกับ Ogre เพราะคณิตศาสตร์ของ Vectors จะใช้ประโยชน์ได้ เมื่อคุณทำงานกับโปรแกรมที่ซับซ้อนมากขึ้น



Adding another Object
    เมื่อเข้าใจเกี่ยวระบบตำแหน่งแล้ว เราจะกลับมาในส่วนของโค้ด ที่เขียนมาแล้ว ซึ่งโค้ดเราไม่มีการให้ค่าตำแหน่งที่เราต้องการให้ Robot เราแสดงบนจอภาพ แต่ฟังก์ชั่นใน Orge มีค่า Default ให้กับมันแล้ว สำหรับตัวอย่าง เช่น SceneNode.createChildSceneNode ฟังก์ชั่นสมาชิกใน Ogre มีพารามิเตอร์สามตัวประกอบด้วย ชื่อของ SceneNode  ตำแหน่งของ SceneNode ทิศทางการหัน SceneNode  ตำแหน่งนั้นถ้าคุณสังเกต จะเห็นว่ามันเป็นตำแหน่ง (0,0,0) ถ้าเราจะให้ค่าตำแหน่งเริ่มบางตำแหน่งแทนค่าเดิม

ent2 = sceneManager.createEntity('Robot2', 'robot.mesh')
node2 = sceneManager.rootSceneNode.createChildSceneNode('RobotNode2', ogre.Vector3(50, 0, 0))
node2.attachObject(ent2)

จากโค้ดจะคล้ายของเดิมแต่ได้มีการเพิ่มบางอย่างลงไป ขั้นแรก ตั้งชื่อ Entity และ SceneNode เป็นชื่อที่ต่างไปจากเดิม ขั้นสองเราให้ค่าตำแหน่งเริ่มต้น เปลี่ยนไปโดยให้ค่า X เป็น 50 จาก root SceneNode (จำไว้ว่า ทุกตำแหน่งของ SceneNode ทั้งหมดจะสัมพันธ์กับตัวหลัก ) เมื่อทำการทดสอบโค้ดเราจะ เห็น Robot สองตัวอยู่ข้างกัน

DirectX 9 Download

ปัญหาที่พบในบางครั้งเมื่อเราจะติดตั้งเกมส์ หรือ Game Engine เพื่อพัฒนาเกมส์ มักจะเจอ Error ที่เกี่ยวข้องกับเวอร์ชั่นของ DirectX ที่ใช้ปัจจุบัน หลายคนที่ไม่รู้ บอกว่า "ก็ DirectX ที่ลงกับ windows XP ก็เวอร์ชั่นใหม่แล้วนิ" คำพูดนี้มันก็ใช่นะแต่ รู้ไหมว่าเจ้า DirectX 9c ที่ลงบน Windows XP นั้นมีการอัพเดตเสริมความสามารถใหม่ตลอด และจะปล่อยเวอร์ชั่นที่ใหม่สุดออกเรื่อย ดังนั้นถ้าเกมส์หรือโปรแกรมที่ใช้งานอ้างอิง DirectX ที่เป็นเวอร์ชั่นใหม่ๆ เขียนขึ้นมาก็จะเกิดปัญหาสำหรับคนที่ยังใช้ DirectX เวอร์ชั่นเก่าอยู่ ดังนั้นมาอัพเดต DirectX กันเถอะครับ

DownLoad DirctX 9.0c

DirectX 9.0c (Nov 08)  <------เวอร์ชั่นใหม่ล่าสุดในขณะที่เขียนโพสนี้

Old Versions
DirectX 9.0c (Aug 08)
DirectX 9.0c (Jun 08)
DirectX 9.0c (Mar 08)
DirectX 9.0c (Nov 07)
DirectX 9.0c (Aug 07)
DirectX 9.0c (Jun 07)
DirectX 9.0c (Apr 07)
DirectX 9.0c (Feb 07)
DirectX 9.0c (Dec 06)
DirectX 9.0c (Oct 06)
DirectX 9.0c (Aug 06)
DirectX 9.0c (Jun 06)
DirectX 9.0c (Apr 06)
DirectX 9.0c (Feb 06)
DirectX 9.0c (Dec 05)
DirectX 9.0c (Oct 05)
DirectX 9.0c (Aug 05)
DirectX 9.0c

PyOgre Beginner Tutorial 1 - Part 3

 Your first Ogre application

                   กลับสู่โค้ดโปรแกรมที่ได้เขียนไว้แล้วในPyOgre Beginner Tutorial 1 - Part 1 โดยจะปรับปรุงเพิ่มโค้ดในส่วน ของฟังก์ชั่น _createScene โดยสิ่งแรกที่จะทำคือการเซต ambient light สำหรับ Scene เพื่อที่จะทำให้เราสามารถมองเห็นใน Scene ได้ว่าเรากำลังทำอะไรอยู่ โดยจะทำการเรียกฟังก์ชั่น setAmbientLight และทำการตั้งค่าสีของแสงตามที่เราต้องการ โดยให้จำไว้ว่า ค่าที่จะใส่นั้นจะเรียง red, green, blue   และมีค่าในช่วงระหว่าง 0-1

sceneManager = self.sceneManager
sceneManager.ambientLight = ogre.ColourValue(1, 1, 1)

 ขั้นต่อไปเราจะทำการสร้าง Entity ที่จะให้ปรากฏบนจอ เราทำโดยการเรียก 

ent1 = sceneManager.createEntity('Robot', 'robot.mesh')

 คำบางคำถามเกิดขึ้น ก่อนอื่น self.sceneManager มาจากไหนและเราเรียก createEntity ด้วยอะไร self.sceneManager นั้นเป็นตัวแปร ที่มีส่วนของ SceneManager object ปัจจุบัน (ถูกประกาศไว้ใน SampleFramework.Application )

ค่าพารามิเตอร์ตัวแรกสำหรับแมทอด createEntity ก็คือชื่อของ Entity ที่ต้องการสร้างขึ้น ตามด้วยชื่อโมเดล

 เราสามารถทำให้สร้างสิ่งที่สร้าง เกิดปรากฏบนจอได้ เราต้องสร้าง SceneNode เพื่อนำมันมาผูกติดโดยเหตุนี้ทุกๆ SceneManager จึงมีหนึ่ง root SceneNode เป็นตัวหลัก เราสามารถสร้าง node ย่อยผูกต่อโดย

node1  =  sceneManager.rootSceneNode.createChildSceneNode('RobotNode')

 ในส่วนของโค้ดนี้เราได้เรียก method createChildSceneNode ของ root SceneNode ค่าที่ผ่านสู่ createChildSceneNode คือชื่อของ SceneNode ที่เราสร้าง คล้ายในส่วนของ Entity class และ SceneNode ไม่สามารถมีชื่อเดียวกันได้

ขั้นสุดท้ายเราต้องทำการผูก Entity เข้ากับ SceneNode ดังนั้น Robot จึงมีตำแหน่งที่จะเรนเดอร์ที่

node1.attachObject(ent1)

 โค้ดที่ได้จากของเดิมจะเป็น

import ogre.renderer.OGRE as ogre
import SampleFramework as sf
class TutorialApplication(sf.Application):
def _createScene(self):
sceneManager = self.sceneManager
sceneManager.ambientLight = ogre.ColourValue(1, 1, 1)
ent1 = sceneManager.createEntity('Robot','robot.mesh')
node1  =  sceneManager.rootSceneNode.createChildSceneNode('RobotNode')
node1.attachObject(ent1)

if __name__ == '__main__':
ta = TutorialApplication()
ta.go()

และเมื่อทำการทดสอบ Run โค้ดที่สร้างคุณจะเห็นตัวหุ่นยนต์ปรากฏอยู่บนหน้าจอ

หมายเหตุ โค้ดโปรแกรมที่เขียนทดสอบต้องบันทึกใน C:\PythonOgre\demos\ogre เพื่อการอ้างอิงค่าคอนฟิกของโปรแกรมเดิมและโมเดล 3d ที่เรียกใช้ทดสอบโปรแกรม

PyOgre Beginner Tutorial 1 - Part 2

Ogre Engine ทำงานได้อย่างไร

เราเริ่มต้นด้วย SceneManagers ซึ่งเป็นการนำเราเข้าสู่การควบคุมและใช้งาน MovableObjects และ SceneNodes มีสาม classes ที่เป็นพื้นฐานสำคัญในการสร้าง Ogre applications

1. SceneManager Basics

                   ทุกอย่างที่ปรากฏในหน้าจอถูกจัดการด้วย SceneManager เมื่อคุณทำการวาง objects เข้าไปใน Scene ตัว SceneManager คือ class ที่จะคอยติดตาม ตำแหน่งของพวกมัน เช่นเมื่อคุณสร้าง Cameras เพื่อจะมองเข้าไปใน Scene SceneManager คอยติดตาม ตำแหน่งของพวกมัน ไม่ว่าคุณจะสร้าง planes, billboards, lights หรืออื่นๆก็เช่นเดียวกัน

                มี SceneManager อยู่หลายประเภท

                1 Selecting a Scene Manager

                2 Octree Scene Manager

                3 Terrain Scene Manager

                4 Nature Scene Manager (ogreaddons)

                5 Paging Scene Manager (ogreaddons)

                6 BSP Scene Manager

                7 DotSceneOctree SceneManager (ogreaddons)

               

2.MovableObject Basics

                MovableObject    คือทุกสิ่งที่สามารถวางลงไปใน Scene และทำให้เคลื่อนที่ได้ ซึ่งโดยที่จริงแล้วมี object ประเภทเดียวที่สามารถเรนเดอร์ให้เห็นใน Scene ได้ซึ่งเรียกว่า 3D mesh เช่น หุ่นยนต์ ปลา หรือ พื้นดินที่ตัวละครคุณสามารถที่เดิน ล้วนเป็น Entity สำหรับ Lights, Billboards, Particles, Cameras,อื่นๆ ไม่เป็น Entity แต่ก็เป็น MovableObjects

                 สิ่งหนึ่งที่ต้องจดจำเกี่ยวกับ Ogre คือมันแยกการเรนเดอร์ objects จากตำแหน่งและทิศการ หัน หมายความว่าคุณไม่สามารถที่จะวาง สิ่งที่มีอยู่ลง Scene โดยตรง คุณต้องผูกติด Entity เข้ากับ SceneNode ซึ่งมันจะเก็บข้อมูลเกี่ยวกับตำแหน่งและทิศการหันไว้นั้นเอง

                *Entity =สิ่งที่มีจริงมองเห็นได้

  

3.SceneNode Basics

                SceneNode   จะเป็นตัวเก็บข้อมูลเกี่ยวกับตำแหน่งและทิศการหันไว้สำหรับ Entity ที่ผูกติดกลับตัวของมันไว้ทั้งหมด เมื่อคุณสร้างวัตถุที่จะแสดง มันจะไม่มีการเรนเดอร์ให้เห็นในบนจอ จนกระทั่งคุณจะผูกติดมันกับ SceneNode ถึงจะมีการเรนเดอร์ให้เห็นบนหน้าจอ

                SceneNode สามารถมีจำนวนวัตถุที่ผูกติดกับมันเท่าไหร่ก็ได้ เช่น ต้องสร้างตัวละคร

บนหน้าจอและต้องการสร้างแสงรอบๆตัวละคร สิ่งที่ต้องทำเป็นอย่างแรกคือ สร้าง SceneNode มาอันหนึ่ง สร้าง ตัวละครผูกกับ SceneNode จากนั้นก็สร้าง Light object ผูกกับ SceneNode สำหรับ SceneNode นั้นเราสามารถที่จะผูกติดกับ SceneNode อันอื่นได้ ซึ่งจะทำให้เกิดลำดับขั้นของ SceneNodes

                   หนึ่งเนื้อหาสำคัญที่ต้องจดจำไว้เกี่ยวกับ SceneNodes ตำแหน่งของ SceneNode  จะสัมพันธ์กับ SceneNode ที่เป็นต้นที่มันผูกติดด้วยเสมอ และแต่ละ SceneManager จะประกอบด้วยจุดต่อรวม หลักหนึ่งอันที่สามารถที่จะให้ SceneNodes อื่นผูกติด

PyOgre Beginner Tutorial 1 - Part 1

PyOgre Beginner Tutorial 1

From Ogre Wiki แก้ไข 22/10/2551

เริ่มต้น Base Code ทำการ import สิ่งที่ต้องการใช้งานซึ่งก็คือ OGRE และ SampleFramework เพื่อใช้ในการสืบทอดสร้างโปรแกรมของเราเอง สามารถที่จะดูคลาสและเมทอด ภายใน SampleFramework ได้โดยเปิดดูไฟล์ SampleFramework.py สำหรับโครงสร้างโค้ดพื้นฐาน นี้สามารถนำไปเพิ่มเติมส่วนต่างๆ ได้อีก เมื่อศึกษาให้ลึกมากขึ้น 

import ogre.renderer.OGRE as ogre
import SampleFramework as sf 
class TutorialApplication(sf.Application): 
def _createScene(self):
pass 
if __name__ == '__main__':
ta = TutorialApplication()
ta.go()

 เมื่อรันสคริป เราสามารถที่จะให้เมาส์ หรือกดปุ่ม WASD เพื่อที่จะเคลื่อนฉากในแนวระนาบได้ แต่ในตอนนี้เราจะไม่เห็นสิ่งที่เกิดขึ้นเพราะ ไม่มีการสร้างอะไรในฉาก เราจึงเห็นแต่จอภาพดำสนิท สามารถที่จะออกจากโปรแกรมโดยกดปุ่ม ESC

หมายเหตุ โค้ดโปรแกรมที่เขียนทดสอบต้องบันทึกใน C:\PythonOgre\demos\ogre เพื่อการอ้างอิงค่าคอนฟิกของโปรแกรมเดิมและโมเดล 3d ที่เรียกใช้ทดสอบโปรแกรม

การติดตั้ง PyOgre Game Engine

 การติดตั้ง PyOgre Game Engine

1. ดาวโหลด Python 2.5 หรือเวอร์ชั่นสูงกว่า download
2. ดาวโหลด PyOgre Game Engine
3. อัพเดด directX ให้เป็นเวอร์ชั่นปรับปรุงใหม่ล่าสุด
   

ลิงค์ตัวช่วย

• Python-Ogre Wiki
• การเขียนภาษา Python ภาษาไทย

สามารถค้นหา ข้อมูลอื่นได้โดยผ่านทาง Google นะครับ

SmoothTeddy

SmoothTeddy เป็นโปรแกรมที่ผมเองเห็นมานานมากละ น่าใช้ดีด้วยเป็นโปรเจคเล็กๆ ที่ใช้งานได้ในระดับหนึ่ง ในการสร้างโมเดลสามมิติ พร้อมทั้งระบายสีโมเดลแบบเรียลไทม์ได้ด้วย เป็นอีกโปรแกรมที่เด็กๆสามารถเล่นได้การใช้งานจำเป็นจะต้องทำการติดตั้ง java runtime ด้วย ดาวโหลดตามลิงค์ครับ

DownLoad Teddy    ตัวทำโมเดลบันทึกเป็น .obj

DownLoad Chameleon ตัวใส่สีสันให้โมเดล (texture painting) บันทึกไฟล์เป็น .bmp

DownLoad Smooth Teddy ตัวทำโมเดลและใส่สีสันแบบทูอินวัน บันทึกเป็นไฟล์ .asg ใช้ใน Alice โปรเจค

Download java runtime

* หมายเหตุในตัวรัน(ไฟล์ .bat)ของ Teddy และ Chameleon เนื่องจากเป็นเวอร์ชั่นเก่า คำสั่งรันก็เลยเก่าให้แก้คำสั่งด้านในไฟล์ .bat โดยใช้ notepad จาก jview เป็น java แล้วถึงจะรันได้

ผลงานที่ได้ทำ ตัวการ์ตูนสร้างจาก Teddy ใส่สีสันใน Chemeleon จากนั้น import เข้า Blender 3d เพื่อเรนเดอร์

ตารางผลการทดสอบ CPU แรงเร็วและก็แพง

ถ้าเราจะพูดถึงเรื่องราวของ CPU อันเป็นหัวใจสำคัญอย่างหนึ่งในการขับเคลื่อนระบบคอมพิวเตอร์ ไม่ว่าจะเป็นเครื่อง PC หรือ Notebook สิ่งหนึ่งที่ทุกคนอยากได้จาก CPU ก็คือความเร็วแรง ประหยัดพลังงาน และราคาถูก แต่ในความจริงแล้วนั้นยิ่งแรง ก็แพงด้วย มาลองดูกันว่า CPU ค่ายไหนเร็วได้สุดๆ ตามลิงค์ด้านล่างครับ

Hight End CPU's


Mid Range CPU's

Low End CPU's

AMD Stream SDK will support DirectX 11 and OpenCL

เป็นข่าวดีอีกครั้งสำหรับผู้ใช้งานกราฟฟิคการ์ด ของ ATI (AMD) เกี่ยวกับการนำเอากราฟฟิคการ์ดไปประมวลผลงานทั่วไป GPGPU ที่ไม่ใช่เฉพาะงานสามมิติที่คุ้นเคย จากที่ใครหลายคนเคยได้ลองใช้ตัวพัฒนาตัวเดิมที่เขียนโดยใช้ Brook+ สำหรับตัวผมที่ได้ลองคิดว่ามันมีเครื่องมือ ต่างๆ รวมถึงบทความสอนเขียนน้อยมาก ถ้าเทียบกับ CUDA จากค่ายสีเขียวคู่แข่ง NVIDIA แต่หลังจากนี้ไปก็คงจะได้เห็นมาตรการเขียนโปรแกรมบน กราฟฟิคการ์ด ของ ATI เป็นที่เป็นมาตรฐานขึ้นเพราะ OpenCL นี้เกิดจากการร่วมมือของหลายค่ายยักษ์ใหญ่ในวงการคอมพิวเตอร์ที่ต้องการสร้างมาตรฐานการเขียนโปรแกรมแบบ GPGPU สำหรับหัวหอกแกนนำงานนี้ก็คือ Apple นั้นเอง หวังว่างานนี้คงไปได้สวย ติดตามข้อมูลข่าวสารได้ตามลิงค์ครับ

greeks3d