--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Renderer/Application/Chain.h	Mon Oct 12 09:39:35 2009 +0900
@@ -0,0 +1,25 @@
+#include "Application.h"
+
+typedef struct {
+    double x, y, next_x, next_y;
+    double vx, vy, next_vx, next_vy;
+    double angle[3];
+    int can_move;
+    SceneGraphPtr parent;
+    int id;
+    int parent_id;
+} *ChainPropertyPtr, ChainProperty;
+
+
+class Chain : public Application {
+public:
+    Chain(){}
+
+    SceneGraphPtr scenegraph_factory(void *p, int size);
+    SceneGraphPtr scenegraph_connector(void *p, int size, SceneGraphPtr s, SceneGraphPtr sg_available_list);
+	void init(TaskManager *manager, int w, int h);
+    void init_chain_vars(ChainPropertyPtr cv);
+    void chain_move(TaskManager *manager, SceneGraphPtr sg, int w, int h);
+    void chain_collision(SceneGraphPtr sg, int w, int h, SceneGraphPtr osg);
+
+};

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Renderer/Application/back_action.cc	Mon Oct 12 09:39:35 2009 +0900
@@ -0,0 +1,24 @@
+#include <iostream>
+#include "SceneGraphRoot.h"
+#include "SGList.h"
+#include "ball_action.h"
+using namespace std;
+
+void
+back_move(SceneGraphPtr node, int w, int h)
+{
+    Pad *pad = sgroot->getController();
+
+    if (pad->triangle.isPush()) {
+	SceneGraphPtr ball = sgroot->createSceneGraph(Ball);
+	ball->xyz[0] = -100;
+	ball->set_move_collision(ball_move, ball_coll);
+	node->addChild(ball);
+    }
+}
+
+void
+back_coll(SceneGraphPtr node, int w, int h, SceneGraphPtr tree)
+{
+    
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Renderer/Application/back_action.h	Mon Oct 12 09:39:35 2009 +0900
@@ -0,0 +1,2 @@
+void back_move(SceneGraphPtr, int, int);
+void back_coll(SceneGraphPtr, int, int, SceneGraphPtr);

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Renderer/Application/ball_action.cc	Mon Oct 12 09:39:35 2009 +0900
@@ -0,0 +1,16 @@
+#include <iostream>
+#include "SceneGraphRoot.h"
+#include "SGList.h"
+using namespace std;
+
+void
+ball_move(SceneGraphPtr node, int w, int h)
+{
+    node->xyz[0] += 4;
+}
+
+void
+ball_coll(SceneGraphPtr node, int w, int h, SceneGraphPtr tree)
+{
+    if (node->xyz[0] > 600) node->remove();
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Renderer/Application/ball_action.h	Mon Oct 12 09:39:35 2009 +0900
@@ -0,0 +1,2 @@
+void ball_move(SceneGraphPtr, int, int);
+void ball_coll(SceneGraphPtr, int, int, SceneGraphPtr);

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Renderer/Application/ball_bound.cc	Mon Oct 12 09:39:35 2009 +0900
@@ -0,0 +1,128 @@
+#include <math.h>
+#include <stdlib.h>
+#include "SceneGraphRoot.h"
+#include "SGList.h"
+
+// prototype
+static void ball_move(SceneGraphPtr node, int screen_w, int screen_h);
+static void ball_collision(SceneGraphPtr node, int screen_w, int screen_h, SceneGraphPtr tree);
+static void ball_collision_idle(SceneGraphPtr, int w, int h, SceneGraphPtr tree);
+
+
+static float vy = 0.0f; // y 方向速度
+static float dt = 1.0/1.0f; // frame rate 
+
+static float e = -0.8f;  // 反発係数
+static float g = 9.8f;  // 重力加速度
+//static float v0 = 0.0f; // 初速は 0
+
+static float h0; // 初期高さ
+static float ball_radius = 100.0f;
+
+static float speed = 10.0f;
+
+static void
+ball_move_idle2(SceneGraphPtr node, int screen_w, int screen_h)
+{
+    Pad *pad = sgroot->getController();
+
+    if (pad->circle.isHold()) {
+		if (pad->left.isHold()) {
+			node->xyz[0] -= speed;
+			if(node->xyz[0] < ball_radius)
+				node->xyz[0] = ball_radius;
+		} else if (pad->right.isHold()) {
+			node->xyz[0] += speed;
+			if(node->xyz[0] > screen_w  - ball_radius)
+				node->xyz[0] = screen_w - ball_radius;
+		}
+
+		if (pad->up.isHold()) {
+			node->xyz[1] -= speed;
+		} else if (pad->down.isHold()) {
+			node->xyz[1] += speed;
+            if(node->xyz[1] > screen_h - ball_radius)
+				node->xyz[1] = screen_h - ball_radius;
+		}
+    } else {
+		node->set_move_collision(ball_move, ball_collision);
+    }
+}
+
+static int time = 0;
+
+static void
+ball_move_idle(SceneGraphPtr node, int screen_w, int screen_h)
+{
+    Pad *pad = sgroot->getController();
+
+    if (pad->circle.isPush()) {
+		node->set_move_collision(ball_move_idle2, ball_collision_idle);
+		time = 0;
+    }
+
+    time++;
+
+    if (time > 90) {
+		float w = (float)random();
+      
+		w = fmodf(w, screen_w - ball_radius*2);
+		node->xyz[0] = w + ball_radius;
+		node->xyz[1] = h0;
+		node->set_move_collision(ball_move, ball_collision);
+		time = 0;
+    }
+}
+
+static void
+ball_move(SceneGraphPtr node, int screen_w, int screen_h)
+{
+    vy += g * dt;
+    node->xyz[1] += vy * dt;
+    //    node->xyz[0] += 10.0f;
+}
+
+static void
+ball_collision_idle(SceneGraphPtr, int w, int h, SceneGraphPtr tree)
+{
+}
+
+static void
+ball_collision(SceneGraphPtr node, int screen_w, int screen_h,
+			   SceneGraphPtr tree)
+{
+    if (node->xyz[1] > screen_h - ball_radius) {
+		node->xyz[1] = screen_h - ball_radius;
+
+		vy *= e;
+		if (vy > -g && vy < 0) {
+			vy = 0.0;
+			node->set_move_collision(ball_move_idle, ball_collision_idle);
+		}
+    }
+}
+
+
+void
+ball_bound_init(TaskManager *manager, int screen_w, int screen_h)
+{
+    SceneGraphPtr ball;
+
+    // 固定した値で srandom すると、毎回同じ、random() 列が生成される
+    // random な値が欲しいなら、man random に方法が書いてあります。
+    srandom(100);
+
+    sgroot->createFromXMLfile(manager, "xml_file/Ball.xml");
+    ball = sgroot->createSceneGraph(Ball);
+    ball->set_move_collision(ball_move, ball_collision);
+
+    h0 = screen_h/2;
+    h0 = -1000;
+
+    ball->xyz[0] = screen_w/2;
+    //ball->xyz[0] = 0.0f;
+    ball->xyz[1] = h0;
+    ball->xyz[2] = 30.0f;
+
+    sgroot->setSceneData(ball);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Renderer/Application/boss1_action.cc	Mon Oct 12 09:39:35 2009 +0900
@@ -0,0 +1,269 @@
+#include "SGList.h"
+#include "boss1_action.h"
+
+/*
+static void
+null_move(SceneGraphPtr node, int screen_w, int screen_h)
+{
+}
+*/
+
+static void
+null_collision(SceneGraphPtr node, int screen_w, int screen_h,
+	       SceneGraphPtr tree)
+{
+}
+
+
+static void
+boss1_move_right(SceneGraphPtr node, int screen_w, int screen_h) {
+  node->xyz[0] += node->stack_xyz[0];
+  if(node->xyz[0] > (screen_w - boss_radius_x)) {
+    node->set_move_collision(boss1_move_left, null_collision);
+  }
+}
+
+//ボスが左に移動する動作
+static void
+boss1_move_left(SceneGraphPtr node, int screen_w, int screen_h) {
+  node->xyz[0] -= node->stack_xyz[0];
+  if(node->xyz[0] < boss_radius_x) {
+    node->set_move_collision(boss1_move_right, null_collision);
+  }
+}
+
+//ボスが戦闘位置へ戻る時の動作
+/*
+static void
+boss1_move_return(SceneGraphPtr node, int screen_w, int screen_h)
+{
+  node->xyz[1] -= node->stack_xyz[1];
+  node->xyz[2] -= node->stack_xyz[2];
+
+  if((node->xyz[2] = 0)) {
+    node->stack_xyz[0] = 1.0;
+    node->set_move_collision(boss1_move_left, null_collision);
+  }
+}
+*/
+
+//ボス登場時の動き
+/*
+static void
+boss1_first_move(SceneGraphPtr node, int screen_w, int screen_h)
+{
+  node->xyz[1] += node->stack_xyz[1];
+  if(node->xyz[1] > screen_h) {
+    float time = first_boss1_depth / node->stack_xyz[2];
+    node->stack_xyz[1] = (screen_h - boss_radius_y) / time;
+    node->stack_xyz[2] = return_boss1_depth_speed;
+    node->set_move_collision(boss1_move_return, null_collision);
+  }
+}
+*/
+
+static void
+player_move(SceneGraphPtr node, int screen_w, int screen_h)
+{
+  Pad *pad = sgroot->getController();
+  
+  if (pad->left.isPush()
+      || pad->left.isHold()) {
+#if 0
+    SceneGraphPtr player_left;
+    player_left =  sgroot->createSceneGraph(PLAYER_L);
+    player_left->set_move_collision(player_move_left, null_collision);
+    player_left->xyz[0] = node->xyz[0];
+    player_left->xyz[1] = node->xyz[1];
+    node->addChild(player_left);
+    node->flag_drawable = 1;
+#endif
+    node->xyz[0] -= player_speed;
+    
+    if (node->xyz[0] - player_radius< 0) {
+      node->xyz[0] = player_radius;
+    }
+  }
+  
+  
+  if (pad->right.isPush()
+      || pad->right.isHold()) {
+    node->xyz[0] += player_speed;
+    
+    if (node->xyz[0] + player_radius > screen_w) {
+      node->xyz[0] = screen_w - player_radius;
+    }
+  }
+  
+  if (pad->up.isPush()
+      || pad->up.isHold()) {
+    node->xyz[1] -= player_speed;
+    
+    if (node->xyz[1] - player_radius < 0) {
+      node->xyz[1] = player_radius;
+    }
+  }
+  
+  if (pad->down.isPush()
+      || pad->down.isHold()) {
+    node->xyz[1] += player_speed;
+    
+    if (node->xyz[1] + player_radius > screen_h) {
+      node->xyz[1] = screen_h - player_radius;
+    }
+  }
+  
+  if (pad->circle.isPush()) {
+    SceneGraphPtr shot = sgroot->createSceneGraph(P_SHOT1);
+    shot->set_move_collision(shot_move, shot_collision);
+    shot->xyz[0] = node->xyz[0];
+    shot->xyz[1] = node->xyz[1] - player_radius;
+    node->addBrother(shot);
+  }    
+}
+
+static void
+player_collision(SceneGraphPtr node, int screen_w, int screen_h,
+		 SceneGraphPtr tree)
+{
+  //自機とボスのx,y座標での距離と2点間の距離
+  static float x_distant, y_distant, distance;
+  //ボスの四角形の四隅の座標
+  //  static float boss_low_x, boss_low_y, boss_high_x, boss_high_y;
+  
+  SceneGraphIteratorPtr it = sgroot->getIterator(tree);
+  
+  
+  for (; it->hasNext(BOSS1);) {
+    it->next(BOSS1);
+    SceneGraphPtr enemy = it->get();
+    
+    //各変数の初期化
+    x_distant = node->xyz[0] - enemy->xyz[0];
+    y_distant = node->xyz[1] - enemy->xyz[1];
+    
+    //hypotfで2点間の距離を求める
+    distance = hypotf(x_distant, y_distant);
+    
+    /*四角形と円のcollision
+    if( (fabs( node->xyz[1] - ( boss_low_y )))
+    */
+    
+    //円同士のcollision
+    if(distance < (player_radius + boss_radius_y)) {
+      printf("!!!CAUTION!!!\n");
+    }
+  }
+}
+
+static void
+shot_move(SceneGraphPtr node, int screen_w, int screen_h)
+{
+  node->xyz[1] -= shot_speed;
+  
+  // 描画領域から抜けたら削除
+  if (node->xyz[1] < 0) {
+    node->remove();
+  }
+}
+
+static void
+shot_collision(SceneGraphPtr node, int screen_2, int screen_h,
+	       SceneGraphPtr tree)
+{
+  //自機とボスのx,y座標での距離と2点間の距離
+  static float x_distant, y_distant, distance;
+  //ボスの四角形の四隅の座標
+  //  static float boss_low_x, boss_low_y, boss_high_x, boss_high_y;
+  
+  SceneGraphIteratorPtr it = sgroot->getIterator(tree);
+  
+  
+  for (; it->hasNext(BOSS1);) {
+    it->next(BOSS1);
+    SceneGraphPtr enemy = it->get();
+    
+    x_distant = node->xyz[0] - enemy->xyz[0];
+    y_distant = node->xyz[1] - enemy->xyz[1];
+    
+    //hypotfで2点間の距離を求める
+    distance = hypotf(x_distant, y_distant);
+    
+    //円同士のcollision
+    if(distance <  boss_radius_y) {
+      SceneGraphPtr blast = sgroot->createSceneGraph(BLAST1);
+      
+      blast->set_move_collision(blast_move, null_collision);
+      blast->xyz[0] = node->xyz[0];
+      blast->xyz[1] = node->xyz[1];
+      node->addBrother(blast);
+      node->remove();
+    }
+  }
+}
+
+static void
+blast_move(SceneGraphPtr node, int screen_w, int screen_h)
+{
+  if(node->sgid > BLAST8) {
+    SceneGraphPtr blast = sgroot->createSceneGraph(node->sgid - 1);
+    blast->set_move_collision(blast_move, null_collision);
+    blast->xyz[0] = node->xyz[0];
+    blast->xyz[1] = node->xyz[1];
+    node->addBrother(blast);
+  }
+  
+  if (node->sgid == BLAST8) {
+    node->flag_drawable = 1;
+  }
+  
+  if((node->frame > 1)) {
+    node->remove();
+  }
+  node->frame += 1;
+}
+  
+void
+boss1_init(TaskManager *manager, int screen_w, int screen_h)
+{
+  SceneGraphPtr root;
+  SceneGraphPtr player;
+  SceneGraphPtr boss1;
+  SceneGraphPtr left_parts;
+  SceneGraphPtr right_parts;
+
+  sgroot->createFromXMLfile(manager, "xml_file/boss1.xml");
+  sgroot->createFromXMLfile(manager, "xml_file/player1.xml");
+  sgroot->createFromXMLfile(manager, "xml_file/p_shot.xml");
+  sgroot->createFromXMLfile(manager, "xml_file/blast.xml");
+  
+  //rootとなるSceneGraphを生成
+  root = sgroot->createSceneGraph();
+  
+  //自機の初期化
+  player = sgroot->createSceneGraph(PLAYER);
+  player->xyz[0] = screen_w/2;
+  player->xyz[1] = screen_h - player_radius;
+  root->addChild(player);
+
+  //ボスの初期化
+  boss1 = sgroot->createSceneGraph(BOSS1);
+  boss1->xyz[0] = screen_w/2;
+  boss1->xyz[1] = boss_radius_y;
+  //  boss1->xyz[2] = first_boss1_depth;
+  boss1->stack_xyz[0] = first_boss1_speed;
+  root->addChild(boss1);
+
+  //ボスの左右パーツを追加
+  left_parts = sgroot->createSceneGraph(BOSS1_L);
+  boss1->addChild(left_parts);
+  right_parts = sgroot->createSceneGraph(BOSS1_R);
+  boss1->addChild(right_parts);
+
+  //各機体の動きと当たり判定をセット
+  player->set_move_collision(player_move, player_collision);  
+  boss1->set_move_collision(boss1_move_left, null_collision);
+  
+  //仕上げ
+  sgroot->setSceneData(root);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Renderer/Application/boss1_action.h	Mon Oct 12 09:39:35 2009 +0900
@@ -0,0 +1,66 @@
+#ifndef BOSS1_ACCTION_H
+#define BOSS1_ACCTION_H
+
+#include <math.h>
+#include "SceneGraphRoot.h"
+#include "SGList.h"
+
+static const float player_speed = 10.0f;
+static const float player_radius = 42.0f;
+
+static const float boss_radius_x = 65.4f;
+static const float boss_radius_y = 130.8f;
+static const float first_boss1_speed = 10.0;
+static const float first_boss1_depth = 500.0;
+static const float return_boss1_depth_speed = 10.0;
+
+static const float shot_speed = 30.0f;
+static const float shot_radius = 42.4f;
+
+
+/*
+static void
+null_move(SceneGraphPtr node, int screen_w, int screen_h);
+*/
+
+static void
+null_collision(SceneGraphPtr node, int screen_w, int screen_h,
+		SceneGraphPtr tree);
+
+static void
+boss1_move_right(SceneGraphPtr node, int screen_w, int screen_h);
+
+static void
+boss1_move_left(SceneGraphPtr node, int screen_w, int screen_h);
+
+/*
+static void
+boss1_move_return(SceneGraphPtr node, int screen_w, int screen_h);
+*/
+
+/*
+static void
+boss1_first_move(SceneGraphPtr node, int screen_w, int screen_h);
+*/
+
+static void
+player_move(SceneGraphPtr node,int screen_2, int screen_h);
+
+/*
+static void
+player_move_left(SceneGraphPtr node,int screen_2, int screen_h);
+*/
+
+static void
+player_collision(SceneGraphPtr node, int screen_w, int screen_h,
+		SceneGraphPtr tree);
+static void
+shot_move(SceneGraphPtr node, int screen_w, int screen_h);
+
+static void
+shot_collision(SceneGraphPtr node, int screen_2, int screen_h,
+	       SceneGraphPtr tree);
+static void
+blast_move(SceneGraphPtr node, int screen_w, int screen_h);
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Renderer/Application/bullet_action.cc	Mon Oct 12 09:39:35 2009 +0900
@@ -0,0 +1,65 @@
+#include <math.h>
+#include "SceneGraphRoot.h"
+#include "SGList.h"
+#include "hit_judge.h"
+#define PI M_PI
+
+int i = 0;
+
+void
+bullet_init(SceneGraphPtr bullet, SceneGraphPtr player)
+{
+    bullet->xyz[0] = player->xyz[0];
+    bullet->xyz[1] = player->xyz[1];
+    bullet->xyz[2] = player->xyz[2];
+
+    bullet->angle[0] = player->angle[0];
+    bullet->angle[1] = player->angle[1];
+    bullet->angle[2] = player->angle[2];
+}
+
+void 
+bluebullet_move(SceneGraphPtr node, int screen_w, int screen_h)
+{  
+    double a = (node->angle[2]+90)*PI/180;
+    double b = (node->angle[0]+90)*PI/180;
+      
+    double y = sin(a);
+    double x = cos(a);
+    double z = -cos(b);
+    
+    node->xyz[0] += x * 5;//x軸方向
+    node->xyz[1] += y * 5;//y軸方向
+    node->xyz[2] += z * 5;//z軸方向  
+}
+
+void
+bullet_collision(SceneGraphPtr node, int screen_w, int screen_h, SceneGraphPtr tree)
+{
+    SceneGraphIteratorPtr it = sgroot->getIterator(tree);
+    //static int damage = 0;
+
+    for (; it->hasNext(E_PLANE);) {
+	it->next(E_PLANE);
+	SceneGraphPtr enemy = it->get();
+
+	int judge = square_judge(node, enemy);
+	if(judge == HIT)
+	{
+	    //node->set_move_collision(null_move, bullet_collision);
+	    //E_PLANE->set_move_collision(null_move, enemy_collision);
+	  enemy->remove();
+	    node->remove();
+	    //printf("hit!!!\n");
+	    //bullet_delete(node, scene_graph);
+	}
+    }
+
+    if(node->xyz[1] > 100)
+    {
+	node->remove();
+	//scene_graph->delete_object(node, node->next,node->prev);
+	//i -= 1;
+	//printf("bullet_delete:残り弾数＝%d\n",i);
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Renderer/Application/bullet_action.h	Mon Oct 12 09:39:35 2009 +0900
@@ -0,0 +1,8 @@
+#ifndef BULLET_ACTION_H
+#define BULLET_ACTION_H
+
+void bullet_init(SceneGraphPtr scene_graph, SceneGraphPtr node);
+void bluebullet_move(SceneGraphPtr node, int screen_w, int screen_h);
+void bullet_collision(SceneGraphPtr node, int screen_w, int screen_h ,SceneGraphPtr tree);
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Renderer/Application/camera_action.cc	Mon Oct 12 09:39:35 2009 +0900
@@ -0,0 +1,58 @@
+#include "SceneGraphRoot.h"
+#include "SGList.h"
+#include "camera_action.h"
+
+#define MOVE_SPEED 0.10
+
+void
+camera_init(SceneGraphPtr node, int screen_w, int screen_h)
+{
+    node->xyz[0] = screen_w/2;
+    node->xyz[1] = screen_h/2 + 50;
+    node->xyz[2] = 0;
+    node->angle[0] = 120;
+}
+
+void
+c_move(SceneGraphPtr node, int screen_w, int screen_h)
+{
+    Pad *pad = sgroot->getController();
+
+    if(pad->right.isHold())
+    {
+	if(node->xyz[0]>screen_w/2 - 50)
+	{
+          node->xyz[0]-=MOVE_SPEED;
+        }
+    }
+
+    if(pad->left.isHold())
+    {
+      if(node->xyz[0]<screen_w/2 + 50)
+        {
+          node->xyz[0]+=MOVE_SPEED;
+        }
+    }
+
+  if(pad->down.isHold())
+    {
+      if(node->xyz[2]>-25)
+        {
+          node->xyz[2]-=MOVE_SPEED;
+        }
+    }
+
+  if(pad->up.isHold())
+  {
+      if(node->xyz[2]<25)
+      {
+          node->xyz[2]+=MOVE_SPEED;
+      }
+  }
+
+}
+
+void
+camera_collision(SceneGraphPtr node, int screen_w, int screen_h,SceneGraphPtr tree)
+{
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Renderer/Application/camera_action.h	Mon Oct 12 09:39:35 2009 +0900
@@ -0,0 +1,3 @@
+void camera_init(SceneGraphPtr node, int screen_w, int screen_h);
+void c_movet(SceneGraphPtr node, int screen_w, int screen_h);
+void camera_collision(SceneGraphPtr node, int screen_w, int screen_h, SceneGraphPtr tree);

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Renderer/Application/chain.cc	Mon Oct 12 09:39:35 2009 +0900
@@ -0,0 +1,163 @@
+#include <iostream>
+#include <math.h>
+#include "SceneGraphRoot.h"
+#include "SceneGraph.h"
+#include "SGList.h"
+#include "TaskManager.h"
+#include "Func.h"
+#include "Chain.h"
+#define FALSE 0
+#define TRUE !FALSE
+#define CHAIN_LEN 50
+
+static double chain_width = 10;
+
+
+/* SceneGraph の property */
+ChainPropertyPtr properties[2];
+ChainPropertyPtr property;
+
+
+//void createSceneGraphFromProperty(ChainPropertyPtr p) ;
+void createSceneGraphFromProperty(void* p) ;
+
+void
+Chain::init_chain_vars(ChainPropertyPtr cv) {
+    cv->x = 0, cv->y = 0, cv->next_x = 0, cv->next_y = 0;
+    cv->vx = 0, cv->vy = 0, cv->next_vx = 0, cv->next_vy = 0;
+    cv->can_move = TRUE;
+}
+
+void
+set_vector(ChainPropertyPtr p, SceneGraphPtr sg) {
+    sg->xyz[0] = p->next_x;
+    sg->xyz[1] = p->next_y;
+    sg->xyz[2] = 0.0f;
+    sg->angle[0] = p->angle[0];
+    sg->angle[1] = p->angle[1];
+    sg->angle[2] = p->angle[2];
+}
+
+#if 0
+static void
+chain_move_ope(SceneGraphPtr node, int screen_w, int screen_h)
+{
+    Pad *pad = sgroot->getController();
+
+    if (pad->circle.isHold()) {
+        property[CHAIN_LEN-1].can_move = FALSE;
+        if (pad->left.isHold()) {
+            property[CHAIN_LEN-1].x += -5.0;
+        } else if (pad->right.isHold()) {
+            property[CHAIN_LEN-1].x += 5.0;
+        }
+
+        if (pad->up.isHold()) {
+            property[CHAIN_LEN-1].y += -5.0;
+        } else if (pad->down.isHold()) {
+            property[CHAIN_LEN-1].y += 5.0;
+        }
+    } else {
+        property[CHAIN_LEN-1].can_move = TRUE;
+    }
+}
+#endif
+
+void
+Chain::chain_move(TaskManager *manager, SceneGraphPtr sg, int w, int h)
+{
+    int id = sg->id;
+    //ChainPropertyPtr p = (ChainPropertyPtr)sg->propertyptr;
+    HTaskPtr chain_cal;
+    ChainPropertyPtr output;
+
+    // SceneGraph の切り替えもここでやる
+    if (property == properties[0]) {
+      property = properties[1];
+      output   = properties[0];
+    }else{
+      property = properties[0];
+      output   = properties[1];
+    }
+    chain_cal = manager->create_task(CHAINCAL_TASK);
+    chain_cal->add_inData(property, sizeof(ChainProperty)*CHAIN_LEN);
+    chain_cal->add_param(id);
+    chain_cal->add_outData(output, sizeof(ChainProperty)*CHAIN_LEN);
+    chain_cal->set_post(createSceneGraphFromProperty, (void*)id);
+    chain_cal->spawn();
+
+}
+
+void
+Chain::chain_collision(SceneGraphPtr sg, int w, int h, SceneGraphPtr osg)
+{
+
+}
+
+void 
+createSceneGraphFromProperty(void* p)
+{
+    ChainPropertyPtr chain_p = (ChainPropertyPtr)p;
+    SceneGraphPtr chain_copy = sgroot->createSceneGraph(CHAIN);
+    chain_copy->propertyptr = (void*)chain_p;
+    chain_copy->property_size = sizeof(ChainProperty);
+    set_vector(chain_p, chain_copy);
+    chain_p->parent->addChild(chain_copy);
+}
+
+void
+Chain::init(TaskManager *manager, int w, int h)
+{
+    SceneGraphPtr root_chain, chain;
+    ChainPropertyPtr rcv;
+	ChainProperty r;
+    HTaskPtr chain_init;
+
+	rcv = &r;    
+    
+    sgroot->createFromXMLfile(manager, "xml_file/chain.xml");
+
+    /* SPE に送る property の配列の領域確保 */
+    properties[0] = (ChainPropertyPtr)manager->allocate(sizeof(ChainProperty)*CHAIN_LEN);
+    properties[1] = (ChainPropertyPtr)manager->allocate(sizeof(ChainProperty)*CHAIN_LEN);
+    property = properties[0];
+
+    root_chain = sgroot->createSceneGraph(CHAIN);
+    // set_move_collision()ではだめ
+//    root_chain->set_move_collision(chain_move_ope, chain_collision);
+	init_chain_vars(rcv);
+    rcv->next_x = w / 2;
+    rcv->next_y = 0.0;
+    rcv->angle[0] = 0;
+    rcv->angle[1] = 0;
+    rcv->angle[2] = 0;
+
+    set_vector(rcv, root_chain);
+
+    for(int i = 0; i < CHAIN_LEN; i++) {
+        chain = sgroot->createSceneGraph(CHAIN);
+        property[i].id = i;
+        init_chain_vars(&property[i]);
+        property[i].x = 0;
+        property[i].y = chain_width * i;
+        set_vector(&property[i], chain);
+        property->angle[1] = -90 * (i % 2);
+        //chain->set_move_collision(chain_move, chain_collision);
+		chain->propertyptr = &property[i];
+		chain->property_size = sizeof(ChainProperty);
+        root_chain->addChild(chain);
+		property[i].parent = root_chain;
+    }
+    property[0].can_move = FALSE;
+
+    // property を SPU の共有領域へコピーする
+    chain_init = manager->create_task(CHAININIT_TASK);
+    chain_init->add_inData(property, sizeof(ChainProperty)*CHAIN_LEN);
+    chain_init->add_param(CHAIN_LEN);
+    chain_init->set_cpu(SPE_0);
+    chain_init->set_post(createSceneGraphFromProperty, (void*)property);
+    chain_init->spawn();
+
+    sgroot->setSceneData(root_chain);
+}
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Renderer/Application/chain_old.cc	Mon Oct 12 09:39:35 2009 +0900
@@ -0,0 +1,159 @@
+#include <iostream>
+#include <math.h>
+#include "SceneGraphRoot.h"
+#include "SGList.h"
+#include "SceneGraph.h"
+#include "TaskManager.h"
+#include "Func.h"
+
+
+#define FALSE 0
+#define TRUE !FALSE
+#define CHAIN_LEN 50
+
+static double m = 100.0;
+static double k = 7000.0;
+static double g = 9.8;
+static double dt = 0.003;
+static double chain_width = 10;
+static double safe = 0.995;
+
+typedef struct {
+    double x, y, next_x, next_y;
+    double vx, vy, next_vx, next_vy;
+    int can_move;
+} CHAIN_VARS;
+
+CHAIN_VARS cv[CHAIN_LEN];
+
+void
+init_chainold_vars(CHAIN_VARS *cv) {
+    cv->x = 0, cv->y = 0, cv->next_x = 0, cv->next_y = 0;
+    cv->vx = 0, cv->vy = 0, cv->next_vx = 0, cv->next_vy = 0;
+    cv->can_move = TRUE;
+}
+
+void
+set_old_vector(CHAIN_VARS *cv, SceneGraphPtr sg) {
+    sg->xyz[0] = (float)cv->next_x;
+    sg->xyz[1] = (float)cv->next_y;
+    sg->xyz[2] = 0.0f;
+}
+
+
+static void
+chain_old_move_ope(SceneGraphPtr node, int screen_w, int screen_h)
+{
+    Pad *pad = sgroot->getController();
+
+    if (pad->start.isHold()) {
+        cv[CHAIN_LEN-1].can_move = FALSE;
+        if (pad->left.isHold()) {
+            cv[CHAIN_LEN-1].x += -5.0;
+        } else if (pad->right.isHold()) {
+            cv[CHAIN_LEN-1].x += 5.0;
+        }
+
+        if (pad->up.isHold()) {
+            cv[CHAIN_LEN-1].y += -5.0;
+        } else if (pad->down.isHold()) {
+            cv[CHAIN_LEN-1].y += 5.0;
+        }
+    } else {
+        cv[CHAIN_LEN-1].can_move = TRUE;
+    }
+}
+
+void
+chain_old_move(SceneGraphPtr sg, int w, int h)
+{
+    int id = sg->id;
+    if(id == 0) {
+        for(int cnt = 0; cnt < 600; cnt++) {
+            for(int i = 0; i < CHAIN_LEN; i++) {
+                if(cv[i].can_move) {
+                    double dx = cv[i-1].x - cv[i].x;
+                    double dy = cv[i-1].y - cv[i].y;
+                    double l = sqrt(dx * dx + dy * dy);
+                    double a = k * (l - chain_width) / m;
+                    double ax = a * dx / l;
+                    double ay = a * dy / l;
+                    if(i < CHAIN_LEN - 1) {
+                        dx = cv[i+1].x - cv[i].x;
+                        dy = cv[i+1].y - cv[i].y;
+                        l = sqrt(dx * dx + dy * dy);
+                        a = k * (l - chain_width) / m;
+                        ax += a * dx / l;
+                        ay += a * dy / l;
+                    }
+                    ay += g;
+                    cv[i].vx *= safe;
+                    cv[i].vy *= safe;
+                    cv[i].next_vx = cv[i].vx + ax * dt;
+                    cv[i].next_vy = cv[i].vy + ay * dt;
+                    cv[i].next_x = cv[i].x + cv[i].vx * dt;
+                    cv[i].next_y = cv[i].y + cv[i].vy * dt;
+                } else {
+                    cv[i].next_x = cv[i].x;
+                    cv[i].next_y = cv[i].y;
+                }
+            }
+            for(int i = 0; i < CHAIN_LEN; i++) {
+                cv[i].vx = cv[i].next_vx;
+                cv[i].vy = cv[i].next_vy;
+                cv[i].x = cv[i].next_x;
+                cv[i].y = cv[i].next_y;
+            }
+        }
+        //    cout << id << ", " << sg->xyz[1] << endl;
+    }
+    set_old_vector(&cv[id], sg);
+    int p, n;
+    p = n = id;
+    if(p != 0) {
+        p--;
+    }
+    if(n != CHAIN_LEN - 1) {
+        n++;
+    }
+    sg->angle[2-(id%2)*2]
+        = 90 + atan((cv[p].next_y - cv[n].next_y) / (cv[p].next_x - cv[n].next_x)) * 180 / M_PI;
+}
+
+void
+chain_old_collision(SceneGraphPtr sg, int w, int h, SceneGraphPtr osg)
+{
+
+}
+
+void
+chain_old_init(TaskManager *manager, int w, int h)
+{
+    SceneGraphPtr root_old_chain, chain;
+    CHAIN_VARS rcv;
+
+    sgroot->createFromXMLfile(manager,"xml_file/chain.xml");
+
+    root_old_chain = sgroot->createSceneGraph(CHAIN);
+    root_old_chain->set_move_collision(chain_old_move_ope, chain_old_collision);
+    init_chainold_vars(&rcv);
+    rcv.next_x = w / 2;
+    rcv.next_y = 0.0;
+    set_old_vector(&rcv, root_old_chain);
+
+    for(int i = 0; i < CHAIN_LEN; i++) {
+        chain = sgroot->createSceneGraph(CHAIN);
+        chain->id = i;
+        init_chainold_vars(&cv[i]);
+        cv[i].x = 0;
+        cv[i].y = chain_width * i;
+        set_old_vector(&cv[i], chain);
+        chain->angle[1] = -90 * (i % 2);
+        chain->set_move_collision(chain_old_move, chain_old_collision);
+
+        root_old_chain->addChild(chain);
+    }
+    cv[0].can_move = FALSE;
+
+    sgroot->setSceneData(root_old_chain);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Renderer/Application/cube.cc	Mon Oct 12 09:39:35 2009 +0900
@@ -0,0 +1,174 @@
+#include <math.h>
+#include "SceneGraphRoot.h"
+#include "vacuum.h"
+#include "SGList.h"
+#define SELECT 2
+
+void
+cube_collision(SceneGraphPtr node, int screen_w, int screen_h,
+               SceneGraphPtr tree)
+{
+    if (node->frame > 120) {
+      cube_split(node,tree);
+    }
+}
+
+void
+cube_move_left(SceneGraphPtr node, int screen_w, int screen_h)
+{
+    node->xyz[0] -= node->stack_xyz[0];
+    node->xyz[1] += node->stack_xyz[1];
+
+    if (node->xyz[0] < 0) {
+        node->set_move_collision(cube_move_right, cube_collision);
+    }
+
+    if (node->xyz[1] < 0 || node->xyz[1] > screen_h) {
+        node->stack_xyz[1] = -node->stack_xyz[1];
+    }
+}
+
+void
+cube_rotate(SceneGraphPtr node, int w, int h)
+{
+    node->angle[0] += 2.0f;
+    node->angle[1] += 2.0f;
+    node->angle[2] += 2.0f;
+}
+
+void
+cube_move_right(SceneGraphPtr node, int screen_w, int screen_h)
+{
+    node->xyz[0] += node->stack_xyz[0];
+    node->xyz[1] += node->stack_xyz[1];
+
+    if (node->xyz[0] > screen_w) {
+        node->set_move_collision(cube_move_left, cube_collision);
+    }
+
+    if (node->xyz[1] < 0 || node->xyz[1] > screen_h) {
+        node->stack_xyz[1] = -node->stack_xyz[1];
+    }
+
+}
+
+
+void
+cube_split(SceneGraphPtr root,SceneGraphPtr tree)
+{
+
+  SceneGraphPtr p;
+  //  SceneGraphPtr common_move = sgroot->createSceneGraph();
+  //  SceneGraphPtr root_common_move = root->parent;
+
+  if(random()%SELECT) {
+    p = sgroot->createSceneGraph(REDCUBE);
+  }
+  else {
+    p = sgroot->createSceneGraph(ENEMY);
+  }
+
+    root->set_move_collision(cube_move_right, cube_collision);
+    p->set_move_collision(cube_move_left, cube_collision);
+
+    root->frame = 0;
+    p->frame = 0;
+
+    p->xyz[0] = root->xyz[0] + 2;
+    p->xyz[1] = root->xyz[1];
+    p->xyz[2] = root->xyz[2];
+
+    p->stack_xyz[0] = 2.0f;
+    p->stack_xyz[1] = random()%3-1;
+    p->stack_xyz[2] = 0.0f;
+
+    root->xyz[0] -= 2;
+    root->stack_xyz[0] = 2.0f;
+    root->stack_xyz[1] = random()%3-1;
+
+    //common_move->addChild(p);
+    root->addBrother(p);
+
+}
+
+
+void
+collision_red(SceneGraphIteratorPtr it,SceneGraphPtr node)
+{
+  float dx, dy,ddx,ddy, r;
+  float q = 0;
+
+  for (; it->hasNext(REDCUBE);) {
+
+    it->next(REDCUBE);
+    SceneGraphPtr mcube = it->get();
+    dx = node->xyz[0] - mcube->xyz[0];
+    dy = node->xyz[1] - mcube->xyz[1];
+
+    ddx = dx*dx;
+    ddy = dy*dy;
+
+    if(sqrt(ddx) < 10 && sqrt(ddy) < 10) {
+      mcube->remove();
+      continue;
+    }
+    r = sqrt(ddx + ddy);
+    if (r >= 1) q = 200/r;
+    if (dx == 0) {
+      if(mcube->xyz[1] > node->xyz[1]) {
+        mcube->stack_xyz[1] -= q;
+      } else if(mcube->xyz[1] < node->xyz[1]) {
+        mcube->stack_xyz[1] += q;
+      }
+    } else {
+      if(mcube->xyz[0] > node->xyz[0]) {
+        mcube->xyz[0] -= q*cos(atan(dy/dx));
+        mcube->xyz[1] -= q*sin(atan(dy/dx));
+      } else if(mcube->xyz[0] < node->xyz[0]) {
+        mcube->xyz[0] += q*cos(atan(dy/dx));
+        mcube->xyz[1] += q*sin(atan(dy/dx));
+      }
+    }
+  }
+}
+
+void
+collision_purple(SceneGraphIteratorPtr it,SceneGraphPtr node,int w,int h)
+{
+  float dx, dy,ddx,ddy, r;
+  float q = 0;
+
+  for (; it->hasNext(ENEMY);) {
+    it->next(ENEMY);
+    SceneGraphPtr mcube = it->get();
+
+    dx = node->xyz[0] - mcube->xyz[0];
+    dy = node->xyz[1] - mcube->xyz[1];
+    ddx = dx*dx;
+    ddy = dy*dy;
+
+    if(sqrt(ddx) < 10 && sqrt(ddy) < 10) {
+      gameover_scene(w,h,mcube);
+      node->remove();
+      break;
+    }
+    r = sqrt(ddx + ddy);
+    if (r >= 1) q = 200/r;
+    if (dx == 0) {
+      if(mcube->xyz[1] > node->xyz[1]) {
+        mcube->stack_xyz[1] -= q;
+      } else if(mcube->xyz[1] < node->xyz[1]) {
+        mcube->stack_xyz[1] += q;
+      }
+    } else {
+
+      if(mcube->xyz[0] > node->xyz[0]) {
+        mcube->xyz[0] -= q*cos(atan(dy/dx));
+        mcube->xyz[1] -= q*sin(atan(dy/dx));
+      } else if(mcube->xyz[0] < node->xyz[0]) {
+        mcube->xyz[0] += q*cos(atan(dy/dx));
+        mcube->xyz[1] += q*sin(atan(dy/dx));
+      }
+    }
+  }
+}