home *** CD-ROM | disk | FTP | other *** search
/ DOS/V Power Report 1997 March / VPR9703A.ISO / VPR_DATA / DOGA / SOURCES / MEDIT.LZH / DISPLAY.CPP < prev    next >
C/C++ Source or Header  |  1996-07-12  |  56KB  |  1,926 lines
  1. /*  Project medit
  2.     Project Team DoGA
  3.     Copyright (c) 1995. All Rights Reserved.
  4.  
  5.     サブシステム:    medit.apx Application
  6.     ファイル:        display.cpp
  7.     作成者:          Taka2
  8.  
  9.  
  10.     概要
  11.     ====
  12.     TWinDisplay (TWindow) のインプリメンテーション用のソースファイル
  13. */
  14.  
  15. #include <owl\owlpch.h>
  16. #pragma hdrstop
  17.  
  18. #include <owl\statusba.h>
  19. #include <owl\textgadg.h>
  20. #include "display.h"
  21. #include "anim.h"
  22. #include "motion.h"
  23. #include "bezier.h"
  24. #include "status.h"
  25. #include "syscolor.h"
  26. #include "mecha.h"
  27.  
  28. #include "log.h"
  29.  
  30. static const int minimumcube = 1, minimummarker = 4;
  31.  
  32. double bezierrate[17][4] = {
  33.     {4096.0 / 4096.0,    0.0 / 4096.0,    0.0 / 4096.0,    0.0 / 4096.0},
  34.     {3375.0 / 4096.0,  675.0 / 4096.0,   45.0 / 4096.0,    1.0 / 4096.0},
  35.     {2744.0 / 4096.0, 1176.0 / 4096.0,  168.0 / 4096.0,    8.0 / 4096.0},
  36.     {2197.0 / 4096.0, 1521.0 / 4096.0,  351.0 / 4096.0,   27.0 / 4096.0},
  37.     {1728.0 / 4096.0, 1728.0 / 4096.0,  576.0 / 4096.0,   64.0 / 4096.0},
  38.     {1331.0 / 4096.0, 1815.0 / 4096.0,  825.0 / 4096.0,  125.0 / 4096.0},
  39.     {1000.0 / 4096.0, 1800.0 / 4096.0, 1080.0 / 4096.0,  216.0 / 4096.0},
  40.     { 729.0 / 4096.0, 1701.0 / 4096.0, 1323.0 / 4096.0,  343.0 / 4096.0},
  41.     { 512.0 / 4096.0, 1536.0 / 4096.0, 1536.0 / 4096.0,  512.0 / 4096.0},
  42.     { 343.0 / 4096.0, 1323.0 / 4096.0, 1701.0 / 4096.0,  729.0 / 4096.0},
  43.     { 216.0 / 4096.0, 1080.0 / 4096.0, 1800.0 / 4096.0, 1000.0 / 4096.0},
  44.     { 125.0 / 4096.0,  825.0 / 4096.0, 1815.0 / 4096.0, 1331.0 / 4096.0},
  45.     {  64.0 / 4096.0,  576.0 / 4096.0, 1728.0 / 4096.0, 1728.0 / 4096.0},
  46.     {  27.0 / 4096.0,  351.0 / 4096.0, 1521.0 / 4096.0, 2197.0 / 4096.0},
  47.     {   8.0 / 4096.0,  168.0 / 4096.0, 1176.0 / 4096.0, 2744.0 / 4096.0},
  48.     {   1.0 / 4096.0,   45.0 / 4096.0,  675.0 / 4096.0, 3375.0 / 4096.0},
  49.     {   0.0 / 4096.0,    0.0 / 4096.0,    0.0 / 4096.0, 4096.0 / 4096.0},
  50. };
  51.  
  52. //
  53. // このアプリケーションで処理するすべてのメッセージ／コマンドの
  54. // 応答テーブルを作成する
  55. //
  56. DEFINE_RESPONSE_TABLE1(TWinDisplay, TWindow)
  57. //{{TWinDisplayRSP_TBL_BEGIN}}
  58.     EV_WM_LBUTTONDOWN,
  59.     EV_WM_MOUSEMOVE,
  60.     EV_WM_LBUTTONUP,
  61.     EV_WM_RBUTTONDOWN,
  62. //{{TWinDisplayRSP_TBL_END}}
  63. END_RESPONSE_TABLE;
  64.  
  65.  
  66. //{{TWinDisplay Implementation}}
  67.  
  68.  
  69. TWinDisplay::TWinDisplay(TWindow* parent, AnimationData *d, SelectType sel, int x, int y, int w, int h):
  70.     TWindow(parent, 0, 0)
  71. {
  72.     SetBkgndColor(TColor::LtGray);
  73.  
  74.     anim = d;
  75.     type = sel;
  76.     convmatrix = Matrix(1);
  77.  
  78.     markers = 0;
  79.  
  80.     if (sel == SelXY) {
  81.     } else if (sel == SelZX) {
  82.         convmatrix.v[1] = Vector(0.0, 0.0, -1.0);
  83.         convmatrix.v[2] = Vector(0.0, 1.0,  0.0);
  84.     } else if (sel == SelYZ) {
  85.         convmatrix.v[0] = Vector(0.0, 0.0, 1.0);
  86.         convmatrix.v[1] = Vector(1.0, 0.0, 0.0);
  87.         convmatrix.v[2] = Vector(0.0, 1.0, 0.0);
  88.     } else {
  89.  
  90.     }
  91.     Attr.X = x;
  92.     Attr.Y = y;
  93.     Attr.W = w;
  94.     Attr.H = h;
  95. }
  96.  
  97.  
  98. TWinDisplay::~TWinDisplay ()
  99. {
  100.     Destroy();
  101.  
  102.     // INSERT>> デストラクタ用のコードはここに
  103.  
  104. }
  105.  
  106.  
  107. static void getpoint(Matrix& mat, TPoint& pc, TPoint& vx, TPoint& vy, TPoint& vz, int& zx, int& zy, int& zz)
  108. {
  109.     vx = TPoint(int(mat.v[0].x),-int(mat.v[0].y));
  110.     vy = TPoint(int(mat.v[1].x),-int(mat.v[1].y));
  111.     vz = TPoint(int(mat.v[2].x),-int(mat.v[2].y));
  112.     pc = TPoint(int(mat.v[3].x),-int(mat.v[3].y));
  113.     zx = int(mat.v[0].z);
  114.     zy = int(mat.v[1].z);
  115.     zz = int(mat.v[2].z);
  116. }
  117.  
  118. static void draw5line(TDC& dc, TPoint& center, TPoint& offset, TPoint& p1, TPoint& p2)
  119. {
  120.     dc.MoveTo(center+offset+p1-p2);
  121.     dc.LineTo(center-offset+p1-p2);
  122.     dc.LineTo(center-offset-p1+p2);
  123.     dc.LineTo(center+offset-p1+p2);
  124.     dc.LineTo(center+offset+p1-p2);
  125.     dc.MoveTo(center+offset+p1+p2);
  126.     dc.LineTo(center-offset+p1+p2);
  127.  
  128. //    dc.SelectObject(TPen(cBackGround,1,PS_DOT));
  129. //    dc.MoveTo(center+offset+p1); dc.LineTo(center-offset+p1);
  130. //    dc.MoveTo(center+offset+p2); dc.LineTo(center-offset+p2);
  131. //    dc.MoveTo(center+p1-p2); dc.LineTo(center-p1+p2);
  132. }
  133.  
  134. static void draw4line(TDC& dc, TPoint& center, TPoint& p1, TPoint& p2)
  135. {
  136.     dc.MoveTo(center+p1+p2);
  137.     dc.LineTo(center+p1-p2);
  138.     dc.LineTo(center-p1-p2);
  139.     dc.LineTo(center-p1+p2);
  140.     dc.LineTo(center+p1+p2);
  141.  
  142. //    dc.SelectObject(TPen(cBackGround,1,PS_DOT));
  143. //    dc.MoveTo(center+p1); dc.LineTo(center-p1);
  144. //    dc.MoveTo(center+p2); dc.LineTo(center-p2);
  145. }
  146.  
  147. static void draw9line(TDC& dc, TPoint& pc, TPoint& p1, TPoint& p2, TPoint& p3)
  148. {
  149.     dc.MoveTo(pc+p1+p2+p3);
  150.     dc.LineTo(pc+p1+p2-p3);
  151.     dc.LineTo(pc+p1-p2-p3);
  152.     dc.LineTo(pc+p1-p2+p3);
  153.     dc.LineTo(pc-p1-p2+p3);
  154.     dc.LineTo(pc-p1+p2+p3);
  155.     dc.LineTo(pc-p1+p2-p3);
  156.     dc.LineTo(pc+p1+p2-p3);
  157.     dc.MoveTo(pc-p1+p2+p3);
  158.     dc.LineTo(pc+p1+p2+p3);
  159.     dc.LineTo(pc+p1-p2+p3);
  160.  
  161. //    dc.SelectObject(TPen(cBackGround,1,PS_DOT));
  162. //    dc.MoveTo(pc+p1-p2); dc.LineTo(pc+p1+p2); dc.LineTo(pc-p1+p2);
  163. //    dc.MoveTo(pc+p2-p3); dc.LineTo(pc+p2+p3); dc.LineTo(pc-p2+p3);
  164. //    dc.MoveTo(pc+p3-p1); dc.LineTo(pc+p3+p1); dc.LineTo(pc-p3+p1);
  165. }
  166.  
  167. void TWinDisplay::Set4Marker(SelectType type, TPoint& pc, TPoint& p1, TPoint& p2)
  168. {
  169.     SelectType t1, t2;
  170.     if (type == SelXY) {
  171.         t1 = SelX;
  172.         t2 = SelY;
  173.     } else if (type == SelYZ) {
  174.         t1 = SelY;
  175.         t2 = SelZ;
  176.     } else {
  177.         t1 = SelZ;
  178.         t2 = SelX;
  179.     }
  180.     markerpoint[markers]  = pc + p1;        markertype[markers++] = SelScale | t1;
  181.     markerpoint[markers]  = pc - p1;        markertype[markers++] = SelScale | t1;
  182.     markerpoint[markers]  = pc + p2;        markertype[markers++] = SelScale | t2;
  183.     markerpoint[markers]  = pc - p2;        markertype[markers++] = SelScale | t2;
  184.     markerpoint[markers]  = pc + p1 + p2;    markertype[markers++] = SelRot | type;
  185.     markerpoint[markers]  = pc + p1 - p2;    markertype[markers++] = SelRot | type;
  186.     markerpoint[markers]  = pc - p1 + p2;    markertype[markers++] = SelRot | type;
  187.     markerpoint[markers]  = pc - p1 - p2;    markertype[markers++] = SelRot | type;
  188. }
  189.  
  190. void TWinDisplay::Set5Marker(SelectType t3, SelectType /*t1*/, SelectType t2, TPoint& pc, TPoint& p3, TPoint& /*p1*/, TPoint& p2)
  191. {
  192.     markerpoint[markers]  = pc + p2;             markertype[markers++] = SelScale | t2;
  193.     markerpoint[markers]  = pc + p3;             markertype[markers++] = SelScale | t3;
  194.     markerpoint[markers]  = pc - p3;            markertype[markers++] = SelScale | t3;
  195.     markerpoint[markers]  = pc + p2 + p3;       markertype[markers++] = SelRot | t2 | t3;
  196.     markerpoint[markers]  = pc + p2 - p3;       markertype[markers++] = SelRot | t2 | t3;
  197. }
  198.  
  199.  
  200. void TWinDisplay::Set9Marker(SelectType t, TPoint& pc, TPoint& /*p1*/, TPoint& p2, TPoint& p3)
  201. {
  202.     SelectType /*t1, */t2, t3;
  203.     if (t == SelX) {
  204. //        t1 = SelX;
  205.         t2 = SelY;
  206.         t3 = SelZ;
  207.     } else if (t == SelY) {
  208. //        t1 = SelY;
  209.         t2 = SelZ;
  210.         t3 = SelX;
  211.     } else {
  212. //        t1 = SelZ;
  213.         t2 = SelX;
  214.         t3 = SelY;
  215.     }
  216.     markerpoint[markers]  = pc      + p2;         markertype[markers++] = SelScale | t2;
  217.     markerpoint[markers]  = pc      + p3;        markertype[markers++] = SelScale | t3;
  218.     markerpoint[markers]  = pc      + p2 + p3;     markertype[markers++] = SelRot | t2 | t3;
  219.     markerpoint[markers]  = pc      + p2 - p3;     markertype[markers++] = SelRot | t2 | t3;
  220.     markerpoint[markers]  = pc      - p2 + p3;     markertype[markers++] = SelRot | t2 | t3;
  221. }
  222.  
  223. void TWinDisplay::DrawMarker(TDC& dc)
  224. {
  225.     for (int i = markers-1; i > 0; --i) {
  226.         switch (markertype[i] & SelMode) {
  227.         case SelMove: case SelTarget:
  228.             dc.SelectObject(TPen(cMarkerMove));
  229.             dc.SelectObject(TBrush(cMarkerMove));
  230.             break;
  231.         case SelRot:
  232.             dc.SelectObject(TPen(cMarkerRot));
  233.             dc.SelectObject(TBrush(cMarkerRot));
  234.             break;
  235.         case SelScale:
  236.             dc.SelectObject(TPen(cMarkerScale));
  237.             dc.SelectObject(TBrush(cMarkerScale));
  238.             break;
  239.         }
  240.         dc.Rectangle(    markerpoint[i].x - markersize,
  241.                         markerpoint[i].y - markersize,
  242.                         markerpoint[i].x + markersize,
  243.                         markerpoint[i].y + markersize);
  244.     }
  245. }
  246.  
  247. void TWinDisplay::ShowCube(Matrix& m, int flag, SelectType t)
  248. {
  249.  
  250.     Matrix mat;
  251.     mat = convmatrix * m;
  252.     TClientDC dc(*this);
  253.  
  254.     dc.SetROP2(R2_NOTXORPEN);
  255.     dc.SelectObject(TPen(cBackGround));
  256.     dc.SetBkMode(TRANSPARENT);
  257.  
  258.     TPoint pc, vx, vy, vz;
  259.     int zx, zy, zz;
  260.     getpoint(mat, pc, vx, vy, vz, zx, zy, zz);
  261.  
  262.     pc.x += Attr.W/2;
  263.     pc.y += Attr.H/2;
  264.  
  265.     if (zx < 0) vx = -vx;
  266.     if (zy < 0) vy = -vy;
  267.     if (zz < 0) vz = -vz;
  268.  
  269.     if (-minimumcube <= zx && zx <= minimumcube) {
  270.         if (-minimumcube <= zy && zy <= minimumcube) {
  271.             draw4line(dc, pc, vx, vy);
  272.         } else if (-minimumcube <= zz && zz <= minimumcube) {
  273.             draw4line(dc, pc, vz, vx);
  274.         } else {
  275.             draw5line(dc, pc, vx, vy, vz);
  276.         }
  277.     } else if (-minimumcube <= zy && zy <= minimumcube) {
  278.         if (-minimumcube <= zz && zz <= minimumcube) {
  279.             draw4line(dc, pc, vy, vz);
  280.         } else {
  281.             draw5line(dc, pc, vy, vz, vx);
  282.         }
  283.     } else if (-minimumcube <= zz && zz <= minimumcube) {
  284.         draw5line(dc, pc, vz, vx, vy);
  285.     } else {
  286.         draw9line(dc, pc, vx, vy, vz);
  287.     }
  288.     if (flag) {
  289.         markers = 0;
  290.         markerpoint[markers]  = pc;
  291.         markertype[markers++] = SelMove;
  292.         if (anim->select->motiondata == NULL) {
  293.             markerpoint[markers]  = pc;
  294.             markertype[markers++] = SelMove;
  295.         }
  296.  
  297.         if (-minimummarker <= zx && zx <= minimummarker) {
  298.             if (-minimummarker <= zy && zy <= minimummarker) {
  299.                 Set4Marker(SelXY, pc, vx, vy);
  300.             } else if (-minimummarker <= zz && zz <= minimummarker) {
  301.                 Set4Marker(SelZX, pc, vz, vx);
  302.             } else {
  303.                 if (t & SelZ) {
  304.                     Set5Marker(SelX, SelZ, SelY, pc, vx, vz, vy);
  305.                 } else {
  306.                     Set5Marker(SelX, SelY, SelZ, pc, vx, vy, vz);
  307.                 }
  308.             }
  309.         } else if (-minimummarker <= zy && zy <= minimummarker) {
  310.             if (-minimummarker <= zz && zz <= minimummarker) {
  311.                 Set4Marker(SelYZ, pc, vy, vz);
  312.             } else {
  313.                 if (t & SelZ) {
  314.                     Set5Marker(SelY, SelZ, SelX, pc, vy, vz, vx);
  315.                 } else {
  316.                     Set5Marker(SelY, SelX, SelZ, pc, vy, vx, vz);
  317.                 }
  318.             }
  319.         } else if (-minimummarker <= zz && zz <= minimummarker) {
  320.             if (t & SelY) {
  321.                 Set5Marker(SelZ, SelY, SelX, pc, vz, vy, vx);
  322.             } else {
  323.                 Set5Marker(SelZ, SelX, SelY, pc, vz, vx, vy);
  324.             }
  325.         } else {
  326.             if (t & SelX) {
  327.                 Set9Marker(SelX, pc, vx, vy, vz);
  328.             } else if (t & SelY) {
  329.                 Set9Marker(SelY, pc, vy, vz, vx);
  330.             } else {
  331.                 Set9Marker(SelZ, pc, vz, vx, vy);
  332.             }
  333.         }
  334.         dc.SetROP2(R2_COPYPEN);
  335.         DrawMarker(dc);
  336.     }
  337. }
  338.  
  339. void TWinDisplay::ShowCamera(Matrix& m, int flag)
  340. {
  341.     Matrix mat;
  342.     mat = convmatrix * m;
  343.     TClientDC dc(*this);
  344.  
  345.     dc.SetROP2(R2_XORPEN);
  346.     dc.SetBkMode(TRANSPARENT);
  347.  
  348.     TPoint pc, vx, vy, vz;
  349.     int zx, zy, zz;
  350.     getpoint(mat, pc, vx, vy, vz, zx, zy, zz);
  351.  
  352.     pc.x += Attr.W/2;
  353.     pc.y += Attr.H/2;
  354.  
  355.     dc.SelectObject(TPen(cWireCameraSelect, 1, PS_DOT));
  356.     dc.MoveTo(pc);    dc.LineTo(pc+vx);
  357.     dc.SelectObject(TPen(cWireCameraSelect));
  358.     if (vy.x == 0 && vy.y == 0) {
  359.         dc.MoveTo(pc);    dc.LineTo(pc+vx+vz);
  360.         dc.MoveTo(pc);    dc.LineTo(pc+vx-vz);
  361.     } else if (vz.x == 0 && vz.y == 0) {
  362.         dc.MoveTo(pc);    dc.LineTo(pc+vx+vy);
  363.         dc.MoveTo(pc);    dc.LineTo(pc+vx-vy);
  364.     } else {
  365.         dc.MoveTo(pc);    dc.LineTo(pc+vx+vy+vz);
  366.         dc.MoveTo(pc);    dc.LineTo(pc+vx+vy-vz);
  367.         dc.MoveTo(pc);    dc.LineTo(pc+vx-vy+vz);
  368.         dc.MoveTo(pc);    dc.LineTo(pc+vx-vy-vz);
  369.     }
  370.     if (flag) {
  371.         dc.SetROP2(R2_COPYPEN);
  372.         markers = 0;
  373.         markerpoint[markers] = pc;
  374.         markertype[markers++] = SelMove;
  375.         if (anim->camera->motiondata == NULL) {
  376.             markerpoint[markers] = pc;
  377.             markertype[markers++] = SelMove;
  378.             markerpoint[markers] = pc+vx;
  379.             markertype[markers++] = SelTarget;
  380.         }
  381.         DrawMarker(dc);
  382.     }
  383. }
  384.  
  385. void TWinDisplay::ShowLight(Vector& vec, int /*flag*/)
  386. {
  387.     TClientDC dc(*this);
  388.  
  389.     dc.SetROP2(R2_NOTXORPEN);
  390.     dc.SelectObject(TPen(cBackGround));
  391.  
  392.     Vector v = convmatrix * vec;
  393.  
  394.     TPoint pc(Attr.W/2      , Attr.H/2);
  395.     TPoint vl(Attr.W/2 - v.x, Attr.H/2 + v.y);
  396.     dc.MoveTo(pc);
  397.     dc.LineTo(vl);
  398.  
  399.     double l = v.length();
  400.     if (l > 1.0) {
  401.         v *= ((double)(markersize*8) /l);
  402.         TPoint v1(-v.x + 0.5 * v.y, v.y + 0.5 * v.x);
  403.         TPoint v2(-v.x - 0.5 * v.y, v.y - 0.5 * v.x);
  404.         dc.MoveTo(pc+v1);
  405.         dc.LineTo(pc);
  406.         dc.LineTo(pc+v2);
  407.         dc.SelectObject(TPen(cMarkerLight));
  408.         dc.SelectObject(TBrush(cMarkerLight));
  409.         dc.SetROP2(R2_XORPEN);
  410.     }
  411.     markers = 0;
  412.     markerpoint[markers] = vl;
  413.     markertype[markers++] = SelTarget;
  414.     dc.Rectangle(    markerpoint[0].x - markersize,
  415.                     markerpoint[0].y - markersize,
  416.                     markerpoint[0].x + markersize,
  417.                     markerpoint[0].y + markersize);
  418. }
  419.  
  420. int TWinDisplay::GetPositionDistance(Motion *motion, TPoint &point)
  421. {
  422.     int cx, cy;
  423.  
  424.     cx = Attr.W / 2;
  425.     cy = Attr.H / 2;
  426.  
  427.     Matrix m = anim->GetMatrix(motion);
  428.     TPoint p;
  429.     if (type == SelXY) {
  430.         p.x = cx + m.v[3].x;
  431.         p.y = cy - m.v[3].y;
  432.     } else if (type == SelYZ) {
  433.         p.x = cx + m.v[3].y;
  434.         p.y = cy - m.v[3].z;
  435.     } else if (type == SelZX) {
  436.         p.x = cx + m.v[3].x;
  437.         p.y = cy - m.v[3].z;
  438.     }
  439.     int distance;
  440.     if (p.x < point.x) {
  441.         distance = point.x - p.x;
  442.     } else {
  443.         distance = p.x - point.x;
  444.     }
  445.     if (p.y < point.y) {
  446.         distance += point.y - p.y;
  447.     } else {
  448.         distance += p.y - point.y;
  449.     }
  450.     return distance;
  451. }
  452.  
  453. void TWinDisplay::DisplayCursorObject(UINT /*modKeys*/, TPoint& point)
  454. {
  455.     Motion *m;
  456.     for (m = anim->motion; m != NULL; m = m->next) {
  457.         if (GetPositionDistance(m, point) < markersize*2) {
  458.             break;
  459.         }
  460.     }
  461.     if (m == NULL && GetPositionDistance(anim->camera, point) < markersize*2) {
  462.         m = anim->camera;
  463.     }
  464.     if (m == NULL && GetPositionDistance(anim->camera->target, point) < markersize*2) {
  465.         m = anim->camera->target;
  466.     }
  467.     anim->Status->DisplayStatusTemp(m);
  468. }
  469.  
  470.  
  471.  
  472. void TWinDisplay::DrawBezier(Bezier *bezier)
  473. {
  474.     Matrix m = GetMatrix();
  475.  
  476.     TClientDC dc(*this);
  477. //    dc.SetROP2(R2_NOTXORPEN);
  478. //    dc.SelectObject(TPen(cBackGround));
  479.     dc.SetROP2(R2_XORPEN);
  480.     dc.SelectObject(TPen(cWireLocusSelect));
  481.     dc.SetBkMode(TRANSPARENT);
  482.  
  483.     Vector v0 = m * bezier->point[0];
  484.     Vector v1 = m * bezier->point[1];
  485.     Vector v2 = m * bezier->point[2];
  486.     Vector v3 = m * bezier->point[3];
  487.     dc.MoveTo(v0.x, v0.y);
  488.     for (int i = 1; i < 16; ++i) {
  489.         double vx = v0.x * bezierrate[i][0] + v1.x * bezierrate[i][1] + v2.x * bezierrate[i][2] + v3.x * bezierrate[i][3];
  490.         double vy = v0.y * bezierrate[i][0] + v1.y * bezierrate[i][1] + v2.y * bezierrate[i][2] + v3.y * bezierrate[i][3];
  491.         dc.LineTo(vx, vy);
  492.     }
  493.     dc.LineTo(v3.x, v3.y);
  494.     Vector v01 = m * ((3.0 / 2.0) * bezier->point[0] - (1.0/2.0) * bezier->point[1]);
  495.     Vector v32 = m * ((3.0 / 2.0) * bezier->point[3] - (1.0/2.0) * bezier->point[2]);
  496.  
  497.     dc.SelectObject(TPen(cWireBezierSelect,1,PS_DOT));
  498.     dc.MoveTo(v0.x,  v0.y);
  499.     dc.LineTo(v01.x, v01.y);
  500.     dc.MoveTo(v3.x,  v3.y);
  501.     dc.LineTo(v32.x, v32.y);
  502.  
  503. }
  504.  
  505. static int distance(TPoint& p1, TPoint& p2)
  506. {
  507.     int dist;
  508.     TPoint p = p1 - p2;
  509.     if (p.x < 0) {
  510.         dist = -p.x;
  511.     } else {
  512.         dist = p.x;
  513.     }
  514.     if (p.y < 0) {
  515.         dist += -p.y;
  516.     } else {
  517.         dist += p.y;
  518.     }
  519.     return dist;
  520. }
  521.  
  522. void TWinDisplay::OpCubeBegin(UINT /*modKeys*/, TPoint& point)
  523. {
  524.     if (anim->select == NULL
  525.      || (anim->select->motiondata == NULL
  526.          && (anim->selectframe <  anim->select->beginframe || anim->select->endframe < anim->selectframe))
  527.      || (anim->select->motiondata != NULL
  528.          && (anim->selectframe != anim->select->beginframe && anim->selectframe != anim->select->endframe))) {
  529.         return;
  530.     }
  531.     for (int i = 1; i < markers; ++i) {
  532.         if (distance(anim->drag_point, markerpoint[i]) < markersize * 2) {
  533.             break;
  534.         }
  535.     }
  536.     if (i == markers) {
  537.         return;
  538.     }
  539.     double rx, ry, len;
  540.     Matrix m;
  541.     Vector v;
  542.     anim->selectstatus = markertype[i];
  543.     anim->GetCubeMatrix(anim->select, anim->drag_move, anim->drag_rot, anim->drag_scale);
  544.     anim->drag_mat = anim->drag_move * anim->drag_rot * anim->drag_scale;
  545.     switch (markertype[i] & SelMode) {
  546.     case SelRot:
  547. //        anim->statusbar->SetText("向き設定中");
  548.         m = convmatrix * anim->drag_rot;
  549.         rx = anim->drag_px[0] = (double)(point.x - markerpoint[0].x);
  550.         ry = anim->drag_px[1] = (double)(point.y - markerpoint[0].y);
  551.         switch (markertype[i] & SelXYZ) {
  552.         case SelYZ: v = m.v[0]; break;
  553.         case SelZX: v = m.v[1]; break;
  554.         case SelXY: v = m.v[2]; break;
  555.         }
  556.         if (v.z > 0.0) {
  557.             anim->drag_py[0] =  anim->drag_px[1];
  558.             anim->drag_py[1] = -anim->drag_px[0];
  559.         } else {
  560.             anim->drag_py[0] = -anim->drag_px[1];
  561.             anim->drag_py[1] =  anim->drag_px[0];
  562.         }
  563.         anim->drag_point = markerpoint[0];
  564.         len = rx*rx+ry*ry;
  565.         if (len > 0.0) {
  566.             anim->drag_rx = rx / len * deg(90.0);
  567.             anim->drag_ry = ry / len * deg(90.0);
  568.         } else {
  569.             anim->drag_rx = anim->drag_ry = 0;
  570.         }
  571.         break;
  572.     case SelScale:
  573. //        anim->statusbar->SetText("大きさ設定中");
  574.         anim->drag_point = markerpoint[0];
  575.         rx = double(point.x - markerpoint[0].x);
  576.         ry = double(point.y - markerpoint[0].y);
  577.         len = rx * rx + ry * ry;
  578.         if (len > minimumdouble) {
  579.             anim->drag_rx = rx / len;
  580.             anim->drag_ry = ry / len;
  581.         } else {
  582.             anim->drag_rx = anim->drag_ry = 0;
  583.         }
  584.         break;
  585.     }
  586.     if (type == SelXY) {
  587.         v.x =  double(point.x - anim->drag_point.x);
  588.         v.y = -double(point.y - anim->drag_point.y);
  589.         v.z = 0.0;
  590.     } else if (type == SelYZ) {
  591.         v.x = 0.0;
  592.         v.y=  double(point.x - anim->drag_point.x);
  593.         v.z = -double(point.y - anim->drag_point.y);
  594.     } else {
  595.         v.x =  double(point.x - anim->drag_point.x);
  596.         v.y = 0.0;
  597.         v.z = -double(point.y - anim->drag_point.y);
  598.     }
  599. }
  600.  
  601. static void SelectOne(Vector& v)
  602. {
  603.     double px, py, pz;
  604.     if ((px = v.x) < 0.0) px = -px;
  605.     if ((py = v.y) < 0.0) py = -py;
  606.     if ((pz = v.z) < 0.0) pz = -pz;
  607.     if (px > py && px > pz) {
  608.         v.y = v.z = 0.0;
  609.     } else if (py > pz) {
  610.         v.x = v.z = 0.0;
  611.     } else {
  612.         v.x = v.y = 0.0;
  613.     }
  614. }
  615.  
  616. static void engrid(Vector& v, int grid)
  617. {
  618.     if (v.x > 0) {
  619.         v.x =  (double)( ((long)( v.x) + grid/2) / grid) * (double) grid;
  620.     } else {
  621.         v.x = -(double)( ((long)(-v.x) + grid/2) / grid) * (double) grid;
  622.     }
  623.     if (v.y > 0) {
  624.         v.y =  (double)( ((long)( v.y) + grid/2) / grid) * (double) grid;
  625.     } else {
  626.         v.y = -(double)( ((long)(-v.y) + grid/2) / grid) * (double) grid;
  627.     }
  628.     if (v.z > 0) {
  629.         v.z =  (double)( ((long)( v.z) + grid/2) / grid) * (double) grid;
  630.     } else {
  631.         v.z = -(double)( ((long)(-v.z) + grid/2) / grid) * (double) grid;
  632.     }
  633. }
  634.  
  635. static void limit(Vector& v)
  636. {
  637.     if (v.x >  limitdim) v.x =  limitdim;
  638.     if (v.x < -limitdim) v.x = -limitdim;
  639.     if (v.y >  limitdim) v.y =  limitdim;
  640.     if (v.y < -limitdim) v.y = -limitdim;
  641.     if (v.z >  limitdim) v.z =  limitdim;
  642.     if (v.z < -limitdim) v.z = -limitdim;
  643. }
  644.  
  645. void TWinDisplay::OpCubeDrag(UINT modKeys, TPoint& point, Vector& v)
  646. {
  647.     Matrix nmat;
  648.     Vector tmpvec;
  649.     Vector l;
  650.     double r;
  651.     double px, py;
  652.     switch (anim->selectstatus & SelMode) {
  653.     case SelMove:
  654.         if (modKeys & MK_SHIFT) {
  655.             SelectOne(v);
  656.         }
  657.         tmpvec = anim->select->position + (1.0/anim->displayscale)*v;
  658.         limit(tmpvec);
  659.         if (((modKeys & MK_CONTROL) != 0) ^ (anim->gridflag != FALSE)) {
  660.             engrid(tmpvec, anim->gridspacing);
  661.         }
  662.         if (anim->select == anim->camera) {
  663.             Vector v0 = anim->camera->target->position - anim->camera->position;
  664.             double l0 = v0.length(), s;
  665.             if (l0 > minimumdouble) {
  666.                 s = (anim->camera->target->position - tmpvec).length() / l0;
  667.             } else {
  668.                 s = 0.0;
  669.             }
  670.             nmat = (anim->camera->target->position - tmpvec) ^ Vector(0,0,1);
  671.             nmat = anim->drag_move.move(tmpvec-anim->select->position)
  672.                  * nmat * anim->drag_scale.scale(s);
  673.         } else {
  674.             nmat = anim->drag_move.move(tmpvec-anim->select->position)
  675.                  * anim->drag_rot * anim->drag_scale;
  676.         }
  677.         anim->Status->DisplayPosition(tmpvec);
  678.         anim->ShowCube(anim->drag_mat, nmat);
  679.         anim->drag_mat = nmat;
  680.         break;
  681.     case SelTarget: {
  682.         if (modKeys & MK_SHIFT) {
  683.             SelectOne(v);
  684.         }
  685.         tmpvec = anim->camera->target->position + (1.0/anim->displayscale) * v;
  686.         limit(tmpvec);
  687.         if (((modKeys & MK_CONTROL) != 0) ^ (anim->gridflag != FALSE)) {
  688.             engrid(tmpvec, anim->gridspacing);
  689.         }
  690.         Vector v0 = anim->camera->target->position - anim->camera->position;
  691.         double l0 = v0.length(), s;
  692.         if (l0 > minimumdouble) {
  693.             s = (tmpvec - anim->camera->position).length() / l0;
  694.         } else {
  695.             s = 0.0;
  696.         }
  697.         nmat = (tmpvec - anim->camera->position) ^ Vector(0.0, 0.0, 1.0);
  698.         nmat = anim->drag_move * nmat * anim->drag_scale.scale(s);
  699.         anim->Status->DisplayTarget(tmpvec);
  700.         anim->ShowCube(anim->drag_mat, nmat);
  701.         anim->drag_mat = nmat;
  702.         break;
  703.         }
  704.     case SelRot:
  705.         r = anim->drag_rx * (point.x - anim->drag_point.x)
  706.           + anim->drag_ry * (point.y - anim->drag_point.y);
  707.         px = anim->drag_px[0] * (point.x - anim->drag_point.x)
  708.            + anim->drag_px[1] * (point.y - anim->drag_point.y);
  709.         py = anim->drag_py[0] * (point.x - anim->drag_point.x)
  710.            + anim->drag_py[1] * (point.y - anim->drag_point.y);
  711.         if (-minimumdouble < px && px < minimumdouble
  712.          && -minimumdouble < py && py < minimumdouble) {
  713.             nmat = anim->drag_rot;
  714.         } else {
  715.             switch (anim->selectstatus & SelXYZ) {
  716.             case SelXY:
  717.                 nmat = anim->drag_rot.rotz(atan2(py, px));
  718.                 break;
  719.             case SelYZ:
  720.                 nmat = anim->drag_rot.rotx(atan2(py, px));
  721.                 break;
  722.             case SelZX:
  723.                 nmat = anim->drag_rot.roty(atan2(py, px));
  724.                 break;
  725.             }
  726.         }
  727.         tmpvec = nmat.GetRotation();
  728.         if (((modKeys & MK_CONTROL) != 0) ^ (anim->gridflag != FALSE)) {
  729.             tmpvec *= rad(1.0);
  730.             engrid(tmpvec, anim->rotspacing);
  731.             tmpvec *= deg(1.0);
  732.             nmat = Matrix::m_rot(tmpvec);
  733.         }
  734.  
  735.         nmat = anim->drag_move * nmat * anim->drag_scale;
  736.         anim->Status->DisplayRotation(tmpvec);
  737.         anim->ShowCube(anim->drag_mat, nmat);
  738.         anim->drag_mat = nmat;
  739.         break;
  740.     case SelScale:
  741.         r = anim->drag_rx * (double)(point.x - anim->drag_point.x)
  742.           + anim->drag_ry * (double)(point.y - anim->drag_point.y);
  743.         tmpvec = anim->select->scale;
  744.         nmat = Matrix(1);
  745.         if (modKeys & MK_SHIFT) {
  746.             nmat.v[0].x = nmat.v[1].y = nmat.v[2].z = r;
  747.             tmpvec *= r;
  748.         } else {
  749.             if (anim->selectstatus & SelX) { nmat.v[0].x = r; tmpvec.x *= r;}
  750.             if (anim->selectstatus & SelY) { nmat.v[1].y = r; tmpvec.y *= r;}
  751.             if (anim->selectstatus & SelZ) { nmat.v[2].z = r; tmpvec.z *= r;}
  752.         }
  753.         if (((modKeys & MK_CONTROL) != 0) ^ (anim->gridflag != FALSE)) {
  754.             Vector org = tmpvec;
  755.             tmpvec *= scalespacingfactor;
  756.             engrid(tmpvec, anim->scalespacing);
  757.             tmpvec *= (1.0/scalespacingfactor);
  758.             if (org.x < -minimumdouble || minimumdouble < org.x) nmat.v[0].x *= tmpvec.x / org.x;
  759.             if (org.y , -minimumdouble || minimumdouble < org.y) nmat.v[1].y *= tmpvec.y / org.y;
  760.             if (org.z < -minimumdouble || minimumdouble < org.z) nmat.v[2].z *= tmpvec.z / org.z;
  761.         }
  762.         nmat = anim->drag_move * anim->drag_rot * anim->drag_scale * nmat;
  763.         anim->ShowCube(anim->drag_mat, nmat);
  764.         anim->drag_mat = nmat;
  765.         anim->Status->DisplayScale(tmpvec);
  766.         break;
  767.     }
  768. }
  769.  
  770. void TWinDisplay::OpCubeEnd(UINT modKeys, TPoint& point, Vector& v)
  771. {
  772.     Vector tmpvec;
  773.     Motion *s = anim->select;
  774.     switch (anim->selectstatus & SelMode) {
  775.     case SelMode:
  776.         break;
  777.     case SelMove:
  778.         if (modKeys & MK_SHIFT) {
  779.             SelectOne(v);
  780.         }
  781.         tmpvec = anim->select->position;
  782.         anim->select->position += (1.0/anim->displayscale) * v;
  783.         limit(anim->select->position);
  784.         if (((modKeys & MK_CONTROL) != 0) ^ (anim->gridflag != FALSE)) {
  785.             engrid(anim->select->position, anim->gridspacing);
  786.         }
  787.         if (tmpvec != anim->select->position) {
  788.             if (anim->select == anim->camera) {
  789.                 anim->camera->GetPosition(anim->selectframe);
  790.                 anim->CalcPoints(anim->select);
  791.                 anim->CalcViewAll();
  792.             } else {
  793.                 anim->CalcPoints(anim->select);
  794.             }
  795.             anim->editflag++;
  796.             anim->Redraw();
  797.         }
  798.         break;
  799.     case SelTarget:
  800.         if (modKeys & MK_SHIFT) {
  801.             SelectOne(v);
  802.         }
  803.         tmpvec = anim->camera->target->position + (1.0 / anim->displayscale) * v;
  804.         limit(tmpvec);
  805.         if (((modKeys & MK_CONTROL) != 0) ^ (anim->gridflag != FALSE)) {
  806.             engrid(tmpvec, anim->gridspacing);
  807.         }
  808.         if (tmpvec != anim->camera->target->position) {
  809.             anim->camera->target->position = tmpvec;
  810.             anim->camera->GetPosition(anim->selectframe);
  811.             anim->CalcPoints(anim->camera);
  812.             anim->CalcViewAll();
  813.             anim->editflag++;
  814.             anim->Redraw();
  815.         }
  816.         break;
  817.     case SelRot: {
  818.             double px, py;
  819.             Matrix nmat;
  820.             px = anim->drag_px[0] * (point.x - anim->drag_point.x)
  821.                + anim->drag_px[1] * (point.y - anim->drag_point.y);
  822.             py = anim->drag_py[0] * (point.x - anim->drag_point.x)
  823.                + anim->drag_py[1] * (point.y - anim->drag_point.y);
  824.             if (-minimumdouble < px && px < minimumdouble
  825.              && -minimumdouble < py && py < minimumdouble) {
  826.                 nmat = anim->drag_rot;
  827.             } else {
  828.                 switch (anim->selectstatus & SelXYZ) {
  829.                 case SelXY:
  830.                     nmat = anim->drag_rot.rotz(atan2(py, px));
  831.                     break;
  832.                 case SelYZ:
  833.                     nmat = anim->drag_rot.rotx(atan2(py, px));
  834.                     break;
  835.                 case SelZX:
  836.                     nmat = anim->drag_rot.roty(atan2(py, px));
  837.                     break;
  838.                 }
  839.             }
  840.             Vector tmprot = s->rotation;
  841.             s->rotation = nmat.GetRotation();
  842.             if (((modKeys & MK_CONTROL) != 0) ^ (anim->gridflag != FALSE)) {
  843.                 Vector tmpvec = rad(1.0) * s->rotation;
  844.                 engrid(tmpvec, anim->rotspacing);
  845.                 s->rotation = deg(1.0) * tmpvec;
  846.             }
  847.             if (tmprot != s->rotation) {
  848.                 if (s->motiondata != NULL) {
  849.                     if (anim->selectframe == anim->select->beginframe) {
  850.                         s->motiondata->rotation[0] = s->rotation;
  851.                     } else {
  852.                         s->motiondata->rotation[1] = s->rotation;
  853.                         if (s->motiondata->dirtype == DirForward) {
  854.                             s->motiondata->dirtype = DirLinear;
  855.                         }
  856.                     }
  857.                 }
  858.                 anim->CalcPoints(anim->select);
  859.                 anim->editflag++;
  860.                 anim->Redraw();
  861.             } else {
  862.                 anim->Status->DisplayStatus(FALSE);
  863.             }
  864.         }
  865.         break;
  866.     case SelScale: {
  867.             double r;
  868.             r = anim->drag_rx * (point.x - anim->drag_point.x)
  869.               + anim->drag_ry * (point.y - anim->drag_point.y);
  870.             Vector tmpvec = s->scale;
  871.             if (modKeys & MK_SHIFT) {
  872.                 tmpvec *= r;
  873.             } else {
  874.                 if (anim->selectstatus & SelX) tmpvec.x *= r;
  875.                 if (anim->selectstatus & SelY) tmpvec.y *= r;
  876.                 if (anim->selectstatus & SelZ) tmpvec.z *= r;
  877.             }
  878.             int redrawflag;
  879.             redrawflag = s->scale != tmpvec;
  880.             if (tmpvec.x >  10000.0) { tmpvec.x =  10000.0; redrawflag = TRUE; }
  881.             if (tmpvec.y >  10000.0) { tmpvec.y =  10000.0; redrawflag = TRUE; }
  882.             if (tmpvec.z >  10000.0) { tmpvec.z =  10000.0; redrawflag = TRUE; }
  883.             if (tmpvec.x < -10000.0) { tmpvec.x = -10000.0; redrawflag = TRUE; }
  884.             if (tmpvec.y < -10000.0) { tmpvec.y = -10000.0; redrawflag = TRUE; }
  885.             if (tmpvec.z < -10000.0) { tmpvec.z = -10000.0; redrawflag = TRUE; }
  886.             if (((modKeys & MK_CONTROL) != 0) ^ (anim->gridflag != FALSE)) {
  887.                 tmpvec *= scalespacingfactor;
  888.                 engrid(tmpvec, anim->scalespacing);
  889.                 tmpvec *= (1.0/scalespacingfactor);
  890.             }
  891.             if ((-minimumdouble < tmpvec.x && tmpvec.x < minimumdouble)
  892.              || (-minimumdouble < tmpvec.y && tmpvec.y < minimumdouble)
  893.              || (-minimumdouble < tmpvec.z && tmpvec.z < minimumdouble)) {
  894.                 Matrix nmat = anim->drag_move * anim->drag_rot * anim->drag_scale;
  895.                 anim->ShowCube(anim->drag_mat, nmat);
  896.                 anim->Status->DisplayScale(s->scale);
  897.             } else if (redrawflag) {
  898.                 s->scale = tmpvec;
  899.                 if (s->motiondata != NULL) {
  900.                     if (anim->selectframe == anim->select->beginframe) {
  901.                         s->motiondata->scale[0] = s->scale;
  902.                     } else {
  903.                         s->motiondata->scale[1] = s->scale;
  904. //                        if (s->motiondata->dirtype == DirForward) {
  905. //                            s->motiondata->dirtype = DirLinear;
  906. //                        }
  907.                     }
  908.                 }
  909.                 anim->CalcPoints(anim->select);
  910.                 anim->Redraw();
  911.                 anim->editflag++;
  912.             } else {
  913.                 anim->Status->DisplayStatus(FALSE);
  914.             }
  915.         }
  916.         break;
  917.     }
  918. }
  919.  
  920. void TWinDisplay::OpBezierBegin(UINT modKeys, TPoint& point)
  921. {
  922.     int i;
  923.     if (anim->select == NULL || anim->select->motiondata == NULL) {
  924.         return;
  925.     }
  926.     Matrix m = GetMatrix();
  927.  
  928.     Bezier *bezier = anim->select->motiondata->bezier;
  929.     Vector v;
  930. // 選択フレームが制御点の場合には、その点を優先的に選択可能
  931.     if (anim->selectframe == anim->select->beginframe) {
  932.         v = m * bezier->point[0];
  933.         if (distance(TPoint(v.x, v.y), point) < markersize*2) {
  934.             anim->drag_count = 0;
  935.             anim->org_point = bezier->point[0];
  936.             anim->selectstatus = SelCube;
  937.             if ((modKeys & MK_SHIFT) != 0) {
  938.                 anim->drag_count = 1;
  939.                 anim->selectstatus = SelBezier;
  940.             }
  941.         }
  942.     } else if (anim->selectframe == anim->select->endframe) {
  943.         v = m * bezier->point[3];
  944.         if (distance(TPoint(v.x, v.y), point) < markersize*2) {
  945.             anim->drag_count = 3;
  946.             anim->org_point = bezier->point[3];
  947.             anim->selectstatus = SelCube;
  948.             if ((modKeys & MK_SHIFT) != 0) {
  949.                 anim->drag_count = 2;
  950.                 anim->selectstatus = SelBezier;
  951.             }
  952.         }
  953.     }
  954. // 残りの制御点の中から探す
  955.     if (anim->selectstatus == SelMode) {
  956.         int selno[4];
  957.         Vector ov[4];
  958.         ov[0] = bezier->point[0];
  959.         ov[1] = ((3.0 / 2.0) * bezier->point[0] - (1.0/2.0) * bezier->point[1]);
  960.         ov[2] = ((3.0 / 2.0) * bezier->point[3] - (1.0/2.0) * bezier->point[2]);
  961.         ov[3] = bezier->point[3];
  962.  
  963.         if ((modKeys & MK_SHIFT) != 0) {
  964.             selno[0] = 1; selno[1] = 2; selno[2] = 0; selno[3] = 3;
  965.         } else {
  966.             selno[0] = 0; selno[1] = 3; selno[2] = 1; selno[3] = 2;
  967.         }
  968.         for (i = 0; i < 4; ++i) {
  969.             Vector v = m * ov[selno[i]];
  970.             if (distance(TPoint(v.x, v.y), point) < markersize*2) {
  971.                 anim->selectstatus = SelBezier;
  972.                 anim->drag_count = selno[i];
  973.                 anim->org_point = ov[selno[i]];
  974.                 break;
  975.             }
  976.         }
  977.     }
  978.     if (anim->selectstatus == SelCube) {
  979.         if (anim->select == anim->camera->target) {
  980.             anim->GetCubeMatrix(anim->camera, anim->drag_move, anim->drag_rot, anim->drag_scale);
  981.         } else {
  982.             anim->GetCubeMatrix(anim->select, anim->drag_move, anim->drag_rot, anim->drag_scale);
  983.         }
  984.         anim->drag_mat = anim->drag_move * anim->drag_rot * anim->drag_scale;
  985.     }
  986.     if (anim->selectstatus != SelMode) {
  987.         if (anim->select->motiondata != NULL && anim->select->motiondata->dirtype == DirForward) {
  988.             anim->org_vector = anim->select->motiondata->bezier->GetVector(0.0);
  989.         }
  990.         if (anim->drag_count % 3 == 0) {
  991. //            anim->statusbar->SetText("位置設定中");
  992.         } else {
  993. //            anim->statusbar->SetText("進行方向設定中");
  994.         }
  995.     } else if (anim->select == anim->camera) {
  996.         anim->select = anim->camera->target;
  997.         OpBezierBegin(modKeys, point);
  998.         if (anim->selectstatus == SelMode) {
  999.             anim->select = anim->camera;
  1000.         }
  1001.     }
  1002. }
  1003.  
  1004. void TWinDisplay::OpBezierDrag(UINT modKeys, TPoint& /*point*/, Vector& v)
  1005. {
  1006.     Bezier *bezier = anim->select->motiondata->bezier;
  1007.     double diff = (1.0 / anim->displayscale) * markersize * 3;
  1008.  
  1009.     anim->DrawBezier(bezier);
  1010.  
  1011.     if (modKeys & MK_SHIFT) {
  1012.         SelectOne(v);
  1013.     }
  1014.  
  1015.     Vector tmpvec = anim->org_point + (1.0 / anim->displayscale) * v;
  1016.  
  1017.     if (anim->drag_count== 1
  1018.      && bezier->point[0].x-diff < tmpvec.x && tmpvec.x < bezier->point[0].x+diff
  1019.      && bezier->point[0].y-diff < tmpvec.y && tmpvec.y < bezier->point[0].y+diff
  1020.      && bezier->point[0].z-diff < tmpvec.z && tmpvec.z < bezier->point[0].z+diff) {
  1021.         tmpvec = bezier->point[0];
  1022.     } else if (anim->drag_count== 2
  1023.      && bezier->point[3].x-diff < tmpvec.x && tmpvec.x < bezier->point[3].x+diff
  1024.      && bezier->point[3].y-diff < tmpvec.y && tmpvec.y < bezier->point[3].y+diff
  1025.      && bezier->point[3].z-diff < tmpvec.z && tmpvec.z < bezier->point[3].z+diff) {
  1026.         tmpvec = bezier->point[3];
  1027.     } else {
  1028.         limit(tmpvec);
  1029.         if (((modKeys & MK_CONTROL) != 0) ^ (anim->gridflag != FALSE)) {
  1030.             Vector ovec = tmpvec;
  1031.             engrid(tmpvec, anim->gridspacing);
  1032.             if (type == SelXY) {
  1033.                 tmpvec.z = ovec.z;
  1034.             } else if (type == SelYZ) {
  1035.                 tmpvec.x = ovec.x;
  1036.             } else {
  1037.                 tmpvec.y = ovec.y;
  1038.             }
  1039.         }
  1040.     }
  1041.     if (anim->drag_count == 1) {
  1042.         Vector mvec = 3.0 * bezier->point[0] - 2.0 * tmpvec;
  1043.         bezier->MovePoint(1, mvec, BCsame);
  1044.     } else if (anim->drag_count == 2) {
  1045.         Vector mvec = 3.0 * bezier->point[3] - 2.0 * tmpvec;
  1046.         bezier->MovePoint(2, mvec, BCsame);
  1047.     } else {
  1048.         bezier->MovePoint(anim->drag_count, tmpvec, BCsame);
  1049.     }
  1050.     if (anim->selectstatus == SelCube && anim->select == anim->camera) {
  1051.         Matrix nmat;
  1052.         Vector v0 = anim->camera->target->position - anim->camera->position;
  1053.         double l0 = v0.length(), s;
  1054.         if (l0 > minimumdouble) {
  1055.             s = (anim->camera->target->position - tmpvec).length() / l0;
  1056.         } else {
  1057.             s = 0.0;
  1058.         }
  1059.         nmat = (anim->camera->target->position - tmpvec) ^ Vector(0,0,1);
  1060.         nmat = anim->drag_move.move(tmpvec-anim->camera->position)
  1061.              * nmat * anim->drag_scale.scale(s);
  1062.         anim->ShowCube(anim->drag_mat, nmat);
  1063.         anim->drag_mat = nmat;
  1064.     } else if (anim->selectstatus == SelCube && anim->select == anim->camera->target) {
  1065.         Matrix nmat;
  1066.         Vector v0 = anim->camera->target->position - anim->camera->position;
  1067.         double l0 = v0.length(), s;
  1068.         if (l0 > minimumdouble) {
  1069.             s = (tmpvec - anim->camera->position).length() / l0;
  1070.         } else {
  1071.             s = 0.0;
  1072.         }
  1073.         nmat = (tmpvec - anim->camera->position) ^ Vector(0.0, 0.0, 1.0);
  1074.         nmat = anim->drag_move * nmat * anim->drag_scale.scale(s);
  1075.         anim->ShowCube(anim->drag_mat, nmat);
  1076.         anim->drag_mat = nmat;
  1077.     } else if (anim->selectstatus == SelCube) {
  1078.         Matrix nmat = Matrix::m_move(anim->displayoffset).scale(anim->displayscale).move(tmpvec)
  1079.                             * anim->drag_rot * anim->drag_scale;
  1080.         anim->ShowCube(anim->drag_mat, nmat);
  1081.         anim->drag_mat = nmat;
  1082.     }
  1083.     if (anim->select == anim->camera->target) {
  1084.         anim->Status->DisplayTarget(tmpvec);
  1085.     } else {
  1086.         anim->Status->DisplayPosition(tmpvec);
  1087.     }
  1088.  
  1089.     anim->DrawBezier(bezier);
  1090. }
  1091.  
  1092. void TWinDisplay::OpBezierEnd(UINT modKeys, TPoint& /*point*/, Vector& v)
  1093. {
  1094.     Bezier *bezier = anim->select->motiondata->bezier;
  1095.  
  1096.     Vector tmpvec = anim->org_point + (1.0 / anim->displayscale) * v;
  1097.     limit(tmpvec);
  1098.     if (((modKeys & MK_CONTROL) != 0) ^ (anim->gridflag != FALSE)) {
  1099.         Vector ovec = tmpvec;
  1100.         engrid(tmpvec, anim->gridspacing);
  1101.         if (type == SelXY) {
  1102.             tmpvec.z = ovec.z;
  1103.         } else if (type == SelYZ) {
  1104.             tmpvec.x = ovec.x;
  1105.         } else {
  1106.             tmpvec.y = ovec.y;
  1107.         }
  1108.  
  1109.     }
  1110.  
  1111.     if (anim->org_point != tmpvec) {
  1112.         if (anim->select->motiondata->dirtype == DirForward) {
  1113.             Vector& v1 = anim->org_vector;
  1114.             Vector v2 = bezier->GetVector(0.0);
  1115.             if (v1 != v2) {
  1116.                 anim->select->motiondata->SetAnyAxis(v1, v2);
  1117.             }
  1118. #if 0
  1119.             if (anim->drag_count == 1
  1120.              || (anim->drag_count > 1 && bezier->point[0] == bezier->point[1])) {
  1121. //                Vector v1 = bezier->point[0] - anim->org_point;
  1122. //                Vector v2 = bezier->point[0] - tmpvec;
  1123.                 anim->select->motiondata->SetAnyAxis(v1, v2);
  1124.             }
  1125. #endif
  1126.         }
  1127.         if (anim->select == anim->camera || anim->select == anim->camera->target) {
  1128.             anim->camera->GetPosition(anim->selectframe);
  1129.             anim->CalcPoints(anim->camera);
  1130.             anim->CalcViewAll();
  1131.         } else {
  1132.             anim->select->GetPosition(anim->selectframe);
  1133.             anim->CalcPoints(anim->select);
  1134.         }
  1135.         anim->editflag++;
  1136.         anim->Redraw();
  1137.     } else {
  1138.         anim->Status->DisplayStatus(FALSE);
  1139.     }
  1140.     if (anim->select == anim->camera->target) {
  1141.         anim->select = anim->camera;
  1142.     }
  1143. }
  1144.  
  1145. void TWinDisplay::OpZoomBegin(UINT /*modKeys*/, TPoint& point)
  1146. {
  1147.     Vector v;
  1148.     if (type == SelXY) {
  1149.         v.x =  double(point.x - Attr.W/2);
  1150.         v.y = -double(point.y - Attr.H/2);
  1151.         v.z = 0.0;
  1152.     } else if (type == SelYZ) {
  1153.         v.x = 0.0;
  1154.         v.y=  double(point.x - Attr.W/2);
  1155.         v.z = -double(point.y - Attr.H/2);
  1156.     } else {
  1157.         v.x =  double(point.x - Attr.W/2);
  1158.         v.y = 0.0;
  1159.         v.z = -double(point.y - Attr.H/2);
  1160.     }
  1161.     anim->displayoffset -= v;
  1162.     anim->displayscale *= 4;
  1163.     anim->displayoffset *= 4;
  1164.     anim->SetScrollLimit(TRUE);
  1165.  
  1166.     anim->zoomflag = TRUE;
  1167.     anim->opstat = OpDefault;
  1168.     anim->CalcPointsAll();
  1169.     anim->Redraw(SelXYZ);
  1170.     anim->Status->Redraw();
  1171. }
  1172.  
  1173. void TWinDisplay::OpLightBegin(UINT /*modKeys*/, TPoint& point)
  1174. {
  1175.     if (distance(markerpoint[0], point) < markersize*2) {
  1176.         anim->drag_point = point;
  1177.         anim->selectstatus = SelTarget;
  1178.         anim->org_vector = anim->org_point;
  1179.         SetCapture();
  1180.     }
  1181. }
  1182.  
  1183. void TWinDisplay::OpLightDrag(UINT /*modKeys*/, TPoint& /*point*/, Vector& v)
  1184. {
  1185.     Vector tmpvec = anim->org_point - v;
  1186.     anim->ShowLight(anim->org_vector, tmpvec);
  1187.     anim->org_vector = tmpvec;
  1188.     double l = tmpvec.length();
  1189.     if (l > minimumdouble) {
  1190.         tmpvec *= (100.0/l);
  1191.     }
  1192.     anim->Status->DisplayPosition(tmpvec);
  1193. }
  1194.  
  1195. void TWinDisplay::OpLightEnd(UINT /*modKeys*/, TPoint& /*point*/, Vector& /*v*/)
  1196. {
  1197.     anim->org_point = anim->org_vector;
  1198.     anim->editflag++;
  1199.     ReleaseCapture();
  1200. }
  1201.  
  1202. void TWinDisplay::OpSelectMotion(UINT /*modKeys*/, TPoint& point, Vector& /*v*/)
  1203. {
  1204.     Matrix mat = GetMatrix();
  1205.  
  1206.     const int maxSelObj=128;
  1207.     const int maxSelDist=markersize*10;
  1208.     Motion *sel[maxSelObj];
  1209.     int pnt[maxSelObj];
  1210.     int dis[maxSelObj];
  1211.     int d, i, count = 0;
  1212.     Motion *m;
  1213.     if ((m = anim->motion) == NULL) {
  1214.         m = anim->camera;
  1215.     }
  1216.     for (;;) {
  1217.         if (m->motiondata == NULL
  1218.          || (m->beginframe < anim->selectframe && anim->selectframe < m->endframe)) {
  1219.             Vector v = mat * m->position;
  1220.             if ((d = distance(TPoint(v.x, v.y), point)) < maxSelDist) {
  1221.                 if (count < maxSelObj || dis[count-1] > d) {
  1222.                     if (count < maxSelObj) {
  1223.                         count++;
  1224.                     }
  1225.                     for (i = count-1; i > 0; --i) {
  1226.                         if (dis[i-1] < d) {
  1227.                             break;
  1228.                         }
  1229.                         dis[i] = dis[i-1];
  1230.                         sel[i] = sel[i-1];
  1231.                         pnt[i] = pnt[i-1];
  1232.                     }
  1233.                     dis[i] = d;
  1234.                     if (m == anim->camera->target && anim->camera->motiondata == NULL) {
  1235.                         sel[i] = anim->camera;
  1236.                     } else {
  1237.                         sel[i] = m;
  1238.                     }
  1239.                     pnt[i] = -1;
  1240.                 }
  1241.             }
  1242.         }
  1243.         if (m->motiondata != NULL) {
  1244.             for (int n = 0; n <2; ++n) {
  1245.                 Vector v = mat * m->motiondata->bezier->point[n*3];
  1246.                 if ((d = distance(TPoint(v.x, v.y), point)) < maxSelDist) {
  1247.                     if (count < maxSelObj || dis[count-1] > d) {
  1248.                         if (count < maxSelObj) {
  1249.                             count++;
  1250.                         }
  1251.                         for (i = count-1; i > 0; --i) {
  1252.                             if (dis[i-1] < d) {
  1253.                                 break;
  1254.                             }
  1255.                             dis[i] = dis[i-1];
  1256.                             sel[i] = sel[i-1];
  1257.                             pnt[i] = pnt[i-1];
  1258.                         }
  1259.                         dis[i] = d;
  1260.                         sel[i] = m;
  1261.                         pnt[i] = n;
  1262.                     }
  1263.                 }
  1264.             }
  1265.         }
  1266.         if (m == anim->camera->target) {
  1267.             break;
  1268.         } else if (m == anim->camera) {
  1269.             m = anim->camera->target;
  1270.         } else if (m->next == NULL) {
  1271.             m = anim->camera;
  1272.         } else {
  1273.             m = m->next;
  1274.         }
  1275.     }
  1276.     Motion *selm = NULL;
  1277.     int selp = -1;
  1278.     if (count > 0) {
  1279.         if (anim->select == NULL) {
  1280.             selm = sel[0];
  1281.             selp = pnt[0];
  1282.         } else {
  1283.             for (i = 0; i < count-1; ++i) {
  1284.                 if (sel[i] == anim->select
  1285.                  && (pnt[i] < 0
  1286.                   || (pnt[i] == 0 && anim->selectframe == sel[i]->beginframe)
  1287.                   || (pnt[i] == 1 && anim->selectframe == sel[i]->endframe))) {
  1288.                     selm = sel[i+1];
  1289.                     selp = pnt[i+1];
  1290.                     break;
  1291.                 }
  1292.             }
  1293.             if (i == count-1) {
  1294.                 selm = sel[0];
  1295.                 selp = pnt[0];
  1296.             }
  1297.         }
  1298.     }
  1299.     if (selm == anim->camera->target && anim->camera->motiondata == NULL) {
  1300.         selm = anim->camera;
  1301.     }
  1302.  
  1303.     if (selm != NULL) {
  1304.         anim->SelectMotion(selm);
  1305.         if (selm->motiondata == NULL) {
  1306.             if (anim->selectframe < selm->beginframe) {
  1307.                 anim->SelectFrame(selm->beginframe);
  1308.             } else if (anim->selectframe > selm->endframe) {
  1309.                 anim->SelectFrame(selm->endframe);
  1310.             }
  1311.         } else {
  1312.             if (selp == 0) {
  1313.                 anim->SelectFrame(selm->beginframe);
  1314.             } else if (selp == 1) {
  1315.                 anim->SelectFrame(selm->endframe);
  1316.             }
  1317.         }
  1318.         anim->Redraw();
  1319.     }
  1320.  
  1321. }
  1322.  
  1323. void TWinDisplay::OpSelectMotionAndDrag(UINT /*modKeys*/, TPoint& point, Vector& /*v*/)
  1324. {
  1325.     if (anim->select != NULL) {
  1326.         return;
  1327.     }
  1328.     Matrix mat = GetMatrix();
  1329.  
  1330.     int seld = markersize*2, d;
  1331.     Motion *selm = NULL;
  1332.     for (Motion *m = anim->motion; m != NULL;m = m->next) {
  1333.         Vector v = mat * m->position;
  1334.         if ((d = distance(TPoint(v.x, v.y), point)) < seld) {
  1335.             seld = d;
  1336.             selm = m;
  1337.         }
  1338.     }
  1339.     m = anim->camera; {
  1340.         Vector v = mat * m->position;
  1341.         if ((d = distance(TPoint(v.x, v.y), point)) < seld) {
  1342.             seld = d;
  1343.             selm = m;
  1344.         }
  1345.     }
  1346.     m = anim->camera->target; {
  1347.         Vector v = mat * m->position;
  1348.         if ((d = distance(TPoint(v.x, v.y), point)) < seld) {
  1349.             seld = d;
  1350.             selm = m;
  1351.         }
  1352.     }
  1353.     if (selm != NULL) {
  1354.         if (selm->motiondata == NULL) {
  1355.             if (selm == anim->camera->target) {
  1356.                 anim->SelectMotion(anim->camera);
  1357.                 anim->selectstatus = SelTarget;
  1358.             } else {
  1359.                 anim->SelectMotion(selm);
  1360.                 anim->selectstatus = SelMove;
  1361.             }
  1362.             anim->GetCubeMatrix(anim->select, anim->drag_move, anim->drag_rot, anim->drag_scale);
  1363.             anim->Redraw();
  1364.             anim->drag_mat = anim->drag_move * anim->drag_rot * anim->drag_scale;
  1365. #if 0
  1366.             anim->SelectMotion(selm);
  1367.             anim->selectstatus = SelMove;
  1368.             if (selm == anim->camera->target) {
  1369.                 anim->SelectMotion(anim->camera);
  1370.                 anim->selectstatus = SelTarget;
  1371.                 anim->GetCubeMatrix(anim->camera, anim->drag_move, anim->drag_rot, anim->drag_scale);
  1372.             } else {
  1373.                 anim->GetCubeMatrix(anim->select, anim->drag_move, anim->drag_rot, anim->drag_scale);
  1374.             }
  1375.             anim->Redraw();
  1376.             anim->drag_mat = anim->drag_move * anim->drag_rot * anim->drag_scale;
  1377. #endif
  1378.         } else if (selm->beginframe == anim->selectframe || selm->endframe == anim->selectframe) {
  1379.             anim->SelectMotion(selm);
  1380.             anim->Redraw();
  1381.             anim->selectstatus = SelCube;
  1382.             anim->drag_count = (selm->beginframe == anim->selectframe) ? 0 : 3;
  1383.             anim->org_point = selm->position;
  1384.             if (anim->select == anim->camera->target) {
  1385.                 anim->GetCubeMatrix(anim->camera, anim->drag_move, anim->drag_rot, anim->drag_scale);
  1386.             } else {
  1387.                 anim->GetCubeMatrix(anim->select, anim->drag_move, anim->drag_rot, anim->drag_scale);
  1388.             }
  1389.             anim->drag_mat = anim->drag_move * anim->drag_rot * anim->drag_scale;
  1390.         } else {
  1391.             anim->SelectMotion(selm);
  1392.             anim->selectstatus = SelNone;
  1393.             anim->Redraw();
  1394.         }
  1395.     }
  1396. }
  1397.  
  1398.  
  1399. void TWinDisplay::EvLButtonDown (UINT modKeys, TPoint& point)
  1400. {
  1401.     TWindow::EvLButtonDown(modKeys, point);
  1402.  
  1403.     // INSERT>> 追加コードはここに
  1404.  
  1405.     switch(anim->opstat) {
  1406.     case OpDefault:
  1407.         anim->selectstatus = SelMode;
  1408.         anim->drag_point = point;
  1409.         break;
  1410.     case OpSelZoom:
  1411.         OpZoomBegin(modKeys, point);
  1412.         break;
  1413.     case OpLight:
  1414.         OpLightBegin(modKeys, point);
  1415.         break;
  1416.     case OpPlay:
  1417.         anim->OpModeDefault();
  1418.         break;
  1419.     }
  1420.     anim->drag_point = point;
  1421. }
  1422.  
  1423. void TWinDisplay::EvMouseMove (UINT modKeys, TPoint& point)
  1424. {
  1425.     TWindow::EvMouseMove(modKeys, point);
  1426.  
  1427.     // INSERT>> 追加コードはここに
  1428.  
  1429.     if (anim->selectstatus == SelNone) {
  1430.         if (anim->opstat != OpLight && anim->select == NULL) {
  1431.            DisplayCursorObject(modKeys, point);
  1432.         }
  1433.         return;
  1434.     }
  1435.     Vector v;
  1436.     if (type == SelXY) {
  1437.         v.x =  double(point.x - anim->drag_point.x);
  1438.         v.y = -double(point.y - anim->drag_point.y);
  1439.         v.z = 0.0;
  1440.     } else if (type == SelYZ) {
  1441.         v.x = 0.0;
  1442.         v.y=  double(point.x - anim->drag_point.x);
  1443.         v.z = -double(point.y - anim->drag_point.y);
  1444.     } else {
  1445.         v.x =  double(point.x - anim->drag_point.x);
  1446.         v.y = 0.0;
  1447.         v.z = -double(point.y - anim->drag_point.y);
  1448.     }
  1449.  
  1450.     switch(anim->opstat) {
  1451.     case OpDefault:
  1452.         if (anim->selectstatus == SelMode) {
  1453.             if (anim->select != NULL) {
  1454.                 OpCubeBegin(modKeys, point);
  1455.                 if (anim->selectstatus == SelMode) {
  1456.                     OpBezierBegin(modKeys, point);
  1457.                 }
  1458.             } else {
  1459.                 OpSelectMotionAndDrag(modKeys, point, v);
  1460.             }
  1461.             if (anim->selectstatus == SelMode) {
  1462.                 anim->selectstatus = SelNone;
  1463.             } else {
  1464.                 SetCapture();
  1465.             }
  1466.         }
  1467.         if (anim->selectstatus == SelBezier || anim->selectstatus == SelCube) {
  1468.             OpBezierDrag(modKeys, point, v);
  1469.         } else {
  1470.             OpCubeDrag(modKeys, point, v);
  1471.         }
  1472.         break;
  1473.     case OpSelZoom:
  1474.         break;
  1475.     case OpLight:
  1476.         OpLightDrag(modKeys, point, v);
  1477.         break;
  1478.     }
  1479. }
  1480.  
  1481. void TWinDisplay::EvLButtonUp (UINT modKeys, TPoint& point)
  1482. {
  1483.     TWindow::EvLButtonUp(modKeys, point);
  1484.  
  1485.     // INSERT>> 追加コードはここに
  1486.  
  1487.     ReleaseCapture();
  1488.     if (anim->selectstatus == SelNone) {
  1489.         return;
  1490.     }
  1491.     Vector v;
  1492.     if (type == SelXY) {
  1493.         v.x =  double(point.x - anim->drag_point.x);
  1494.         v.y = -double(point.y - anim->drag_point.y);
  1495.         v.z = 0.0;
  1496.     } else if (type == SelYZ) {
  1497.         v.x = 0.0;
  1498.         v.y=  double(point.x - anim->drag_point.x);
  1499.         v.z = -double(point.y - anim->drag_point.y);
  1500.     } else {
  1501.         v.x =  double(point.x - anim->drag_point.x);
  1502.         v.y = 0.0;
  1503.         v.z = -double(point.y - anim->drag_point.y);
  1504.     }
  1505.  
  1506.     switch(anim->opstat) {
  1507.     case OpDefault:
  1508.         if (anim->selectstatus == SelMode) {
  1509.             OpSelectMotion(modKeys, point, v);
  1510.         } else if (anim->selectstatus == SelBezier || anim->selectstatus == SelCube) {
  1511.             OpBezierEnd(modKeys, point, v);
  1512.         } else {
  1513.             OpCubeEnd(modKeys, point, v);
  1514.         }
  1515.         break;
  1516.     case OpLight:
  1517.         OpLightEnd(modKeys, point, v);
  1518.     }
  1519.     anim->selectstatus = SelNone;
  1520. }
  1521.  
  1522. void TWinDisplay::EvRButtonDown (UINT modKeys, TPoint& point)
  1523. {
  1524.     TWindow::EvRButtonDown(modKeys, point);
  1525.  
  1526.     // INSERT>> 追加コードはここに
  1527.  
  1528.     switch(anim->opstat) {
  1529.     case OpDefault:
  1530.         if (anim->selectstatus != SelNone) {
  1531.             if (anim->selectstatus == SelCube || anim->selectstatus == SelBezier) {
  1532.                 if (anim->select->motiondata != NULL) {
  1533.                     anim->select->motiondata->bezier->point[anim->drag_count] = anim->org_point;
  1534.                 }
  1535.             }
  1536.             anim->selectstatus = SelNone;
  1537.             anim->Redraw();
  1538.         } else if (anim->select != NULL) {
  1539.             anim->SelectMotion(NULL);
  1540.             anim->Redraw();
  1541.         }
  1542.         break;
  1543.     case OpSelZoom:
  1544.     case OpLight:
  1545.         anim->OpModeDefault();
  1546.         break;
  1547.     }
  1548.     ReleaseCapture();
  1549. }
  1550.  
  1551. void TWinDisplay::Paint (TDC& dc, BOOL erase, TRect& rect)
  1552. {
  1553.     TWindow::Paint(dc, erase, rect);
  1554.  
  1555.     // INSERT>> 追加のコードはここに
  1556.     SelectType t;
  1557.     if (type == SelYZ) {
  1558.         t = SelX;
  1559.     } else if (type == SelZX) {
  1560.         t = SelY;
  1561.     } else {
  1562.         t = SelZ;
  1563.     }
  1564.     anim->Redraw(t);
  1565. }
  1566.  
  1567. void TWinDisplay::Redraw(void)
  1568. {
  1569. #if 0
  1570.     TClientDC dc(*this);
  1571. #else
  1572.     TClientDC cdc(*this);
  1573.     TMemoryDC dc(cdc);
  1574.     TBitmap bitmap(cdc, Attr.W, Attr.H);
  1575.     dc.SelectObject(bitmap);
  1576. #endif
  1577.     dc.SelectObject(TPen(cBackGround));
  1578.     dc.SelectObject(TBrush(cBackGround));
  1579.     dc.Rectangle(dc.GetClipBox());
  1580.  
  1581.     ShowMesh(dc);
  1582.     dc.SetBkColor(cBackGround);
  1583.     dc.SetTextColor(TColor::White);
  1584.     switch (type) {
  1585.     case SelXY:
  1586.         dc.TextOut(0,0,"上");
  1587.         break;
  1588.     case SelYZ:
  1589.         dc.TextOut(0,0,"前");
  1590.         break;
  1591.     case SelZX:
  1592.         dc.TextOut(0,0,"横");
  1593.         break;
  1594.     }
  1595.  
  1596.     for (Motion *mot = anim->motion; mot != NULL; mot = mot->next) {
  1597.         if (mot != anim->select) {
  1598.             ShowMotion(dc, mot);
  1599.             ShowBezier(dc, mot, FALSE);
  1600.         }
  1601.     }
  1602.     if ((anim->select != anim->camera && anim->select != anim->camera->target)
  1603.      || (anim->camera->motiondata != NULL && anim->selectframe != BEGIN && anim->selectframe != anim->maxframe)) {
  1604.         ShowMotion(dc, anim->camera);
  1605.     }
  1606.     if (anim->select == NULL) {
  1607.         ShowBezier(dc, anim->camera->target, FALSE);
  1608.         ShowBezier(dc, anim->camera, FALSE);
  1609.         if (anim->opstat == OpDefault) {
  1610.             dc.SetROP2(R2_COPYPEN);
  1611.             dc.SelectObject(TPen(cMarker));
  1612.             dc.SelectObject(TBrush(cMarker));
  1613.             for (Motion *mot = anim->motion; mot != NULL; mot = mot->next) {
  1614.                 if (mot != anim->select) {
  1615.                     ShowMarker(dc, mot);
  1616.                 }
  1617.             }
  1618.             ShowMarker(dc, anim->camera);
  1619.             ShowMarker(dc, anim->camera->target);
  1620.         }
  1621.     } else if (anim->select == anim->camera) {
  1622.         ShowBezier(dc, anim->camera->target, FALSE);
  1623.         ShowBezier(dc, anim->camera, TRUE);
  1624.     } else if (anim->select == anim->camera->target) {
  1625.         ShowBezier(dc, anim->camera, FALSE);
  1626.         ShowBezier(dc, anim->camera->target, TRUE);
  1627.     } else {
  1628.         ShowBezier(dc, anim->camera, FALSE);
  1629.         ShowBezier(dc, anim->camera->target, FALSE);
  1630.         ShowMotion(dc, anim->select);
  1631.         ShowBezier(dc, anim->select, TRUE);
  1632.     }
  1633.  
  1634.     cdc.BitBlt(0,0,Attr.W, Attr.H, dc, 0, 0, SRCCOPY);
  1635. }
  1636.  
  1637. void TWinDisplay::ShowMotion(TDC& dc, Motion *mot)
  1638. {
  1639.     if (anim->selectframe < mot->beginframe || mot->endframe < anim->selectframe) {
  1640. //     || mot == anim->camera->target
  1641. //     || ((mot == anim->sele&& anim->camera->motioindata != NULL || )) {
  1642.         return;
  1643.     }
  1644.     int cx = Attr.W/2, cy = Attr.H/2;
  1645.  
  1646.     Matrix m = anim->GetMatrix(mot);
  1647.     dc.SetROP2(R2_COPYPEN);
  1648.     if (mot == anim->select || (mot == anim->camera && anim->select == anim->camera->target)) {
  1649.         dc.SelectObject(TPen(cWireSelect));
  1650.     } else if (mot == anim->camera) {
  1651.         if (anim->select != NULL || anim->opstat == OpLight) {
  1652.             dc.SelectObject(TPen(cWireCameraNoSelect));
  1653.         } else {
  1654.             dc.SelectObject(TPen(cWireCamera));
  1655.         }
  1656.     } else {
  1657.         if (anim->select != NULL || anim->opstat == OpLight) {
  1658.             dc.SelectObject(TPen(cWireNoSelect));
  1659.         } else {
  1660.             dc.SelectObject(TPen(cWireNormal));
  1661.         }
  1662.     }
  1663.     int *ppx, *ppy;
  1664.     switch(type) {
  1665.     case SelYZ:
  1666.         ppx = mot->point_y;
  1667.         ppy = mot->point_z;
  1668.         break;
  1669.     case SelZX:
  1670.         ppx = mot->point_x;
  1671.         ppy = mot->point_z;
  1672.         break;
  1673.     case SelXY:
  1674.         ppx = mot->point_x;
  1675.         ppy = mot->point_y;
  1676.         break;
  1677.     }
  1678.     int begin, end = -1;
  1679.     if (mot->boxflag == FALSE) {
  1680.         int lno = 0;
  1681.  
  1682.         if (mot == anim->camera) {
  1683.             begin = mot->line_1[0];
  1684.             end = mot->line_2[0];
  1685.             if (anim->select != NULL || anim->opstat == OpLight) {
  1686.                 dc.SelectObject(TPen(cWireCameraNoSelect,1,PS_DOT));
  1687.                 dc.MoveTo(cx + ppx[begin], cy - ppy[begin]);
  1688.                 dc.LineTo(cx + ppx[end],   cy - ppy[end]);
  1689.                 dc.SelectObject(TPen(cWireCameraNoSelect));
  1690.             } else {
  1691.                 dc.SelectObject(TPen(cWireCamera,1,PS_DOT));
  1692.                 dc.MoveTo(cx + ppx[begin], cy - ppy[begin]);
  1693.                 dc.LineTo(cx + ppx[end],   cy - ppy[end]);
  1694.                 dc.SelectObject(TPen(cWireCamera));
  1695.             }
  1696.             lno++;
  1697.         }
  1698.  
  1699.         for (; lno < mot->lines; ++lno) {
  1700.             if ((begin = mot->line_1[lno]) != end) {
  1701.                 dc.MoveTo(cx + ppx[begin], cy - ppy[begin]);
  1702.             }
  1703.             end = mot->line_2[lno];
  1704.             dc.LineTo(cx + ppx[end],   cy - ppy[end]);
  1705.         }
  1706.     } else if (mot->motiondata == NULL) {
  1707.         dc.MoveTo(cx+ppx[0], cy-ppy[0]);
  1708.         dc.LineTo(cx+ppx[1], cy-ppy[1]);
  1709.         dc.LineTo(cx+ppx[2], cy-ppy[2]);
  1710.         dc.LineTo(cx+ppx[3], cy-ppy[3]);
  1711.         dc.LineTo(cx+ppx[0], cy-ppy[0]);
  1712.         dc.LineTo(cx+ppx[4], cy-ppy[4]);
  1713.         dc.LineTo(cx+ppx[5], cy-ppy[5]);
  1714.         dc.LineTo(cx+ppx[6], cy-ppy[6]);
  1715.         dc.LineTo(cx+ppx[7], cy-ppy[7]);
  1716.         dc.LineTo(cx+ppx[4], cy-ppy[4]);
  1717.         dc.MoveTo(cx+ppx[1], cy-ppy[1]);
  1718.         dc.LineTo(cx+ppx[5], cy-ppy[5]);
  1719.         dc.MoveTo(cx+ppx[2], cy-ppy[2]);
  1720.         dc.LineTo(cx+ppx[6], cy-ppy[6]);
  1721.         dc.MoveTo(cx+ppx[3], cy-ppy[3]);
  1722.         dc.LineTo(cx+ppx[7], cy-ppy[7]);
  1723.     } else {
  1724.         dc.MoveTo(cx+ppx[0], cy-ppy[0]);
  1725.         dc.LineTo(cx+ppx[1], cy-ppy[1]);
  1726.         dc.LineTo(cx+ppx[2], cy-ppy[2]);
  1727.         dc.LineTo(cx+ppx[0], cy-ppy[0]);
  1728.         dc.LineTo(cx+ppx[3], cy-ppy[3]);
  1729.         dc.LineTo(cx+ppx[4], cy-ppy[4]);
  1730.     }
  1731. }
  1732.  
  1733. void TWinDisplay::ShowBezier(TDC& dc, Motion *mot, int flag)
  1734. {
  1735.     if (mot->motiondata == NULL) {
  1736.         return;
  1737.     }
  1738.     Bezier *bez = mot->motiondata->bezier;
  1739.     Matrix m = GetMatrix();
  1740.  
  1741.     if (flag == FALSE) {
  1742.         dc.SetROP2(R2_COPYPEN);
  1743.         if (anim->select == NULL) {
  1744.             dc.SelectObject(TPen(cWireLocus));
  1745.         } else {
  1746.             dc.SelectObject(TPen(cWireLocusNoSelect,1,PS_DOT));
  1747.         }
  1748.     } else {
  1749.         dc.SetROP2(R2_XORPEN);
  1750.         dc.SelectObject(TPen(cWireLocusSelect));
  1751. //        dc.SelectObject(TPen(cBackGround));
  1752.     }
  1753. #if 0
  1754.     Vector *p = bez->point;
  1755.     Vector v = m * p[0];
  1756.     double v0x = v.x, v0y = v.y;
  1757.     dc.MoveTo(v0x, v0y);
  1758.     for (int j = 0; j < bez->points; ++j) {
  1759.         double v1x, v1y, v2x, v2y, v3x, v3y;
  1760.         v = m * p[1]; v1x = v.x; v1y = v.y;
  1761.         v = m * p[2]; v2x = v.x; v2y = v.y;
  1762.         v = m * p[3]; v3x = v.x; v3y = v.y;
  1763.         for (int i = 1; i < 16; ++i) {
  1764.             double vx = v0x * bezierrate[i][0] + v1x * bezierrate[i][1] + v2x * bezierrate[i][2] + v3x * bezierrate[i][3];
  1765.             double vy = v0y * bezierrate[i][0] + v1y * bezierrate[i][1] + v2y * bezierrate[i][2] + v3y * bezierrate[i][3];
  1766.             dc.LineTo(vx, vy);
  1767.         }
  1768.         dc.LineTo(v3x, v3y);
  1769.         v0x = v3x;
  1770.         v0y = v3y;
  1771.         p += 3;
  1772.     }
  1773. #else
  1774.     {
  1775.     Vector v0 = m * bez->point[0];
  1776.     Vector v1 = m * bez->point[1];
  1777.     Vector v2 = m * bez->point[2];
  1778.     Vector v3 = m * bez->point[3];
  1779.     dc.MoveTo(v0.x, v0.y);
  1780.     for (int i = 1; i < 16; ++i) {
  1781.         double vx = v0.x * bezierrate[i][0] + v1.x * bezierrate[i][1] + v2.x * bezierrate[i][2] + v3.x * bezierrate[i][3];
  1782.         double vy = v0.y * bezierrate[i][0] + v1.y * bezierrate[i][1] + v2.y * bezierrate[i][2] + v3.y * bezierrate[i][3];
  1783.         dc.LineTo(vx, vy);
  1784.     }
  1785.     dc.LineTo(v3.x, v3.y);
  1786.     }
  1787. #endif
  1788.  
  1789.     if (flag == FALSE) {
  1790.         return;
  1791.     }
  1792.  
  1793.     Vector v0 = m * bez->point[0];
  1794.     Vector v3 = m * bez->point[3];
  1795.     Vector v1 = m * ((3.0 / 2.0) * bez->point[0] - (1.0/2.0) * bez->point[1]);
  1796.     Vector v2 = m * ((3.0 / 2.0) * bez->point[3] - (1.0/2.0) * bez->point[2]);
  1797.  
  1798.     Vector v0v = m * bez->GetVector(0.0) - m.v[3];
  1799.     v0v.z = 0.0;
  1800.     Vector v3v = m * bez->GetVector(1.0) - m.v[3];
  1801.     v3v.z = 0.0;
  1802.  
  1803.     dc.SelectObject(TPen(cWireBezierSelect,1,PS_DOT));
  1804.     dc.MoveTo(v0.x, v0.y); dc.LineTo(v1.x, v1.y);
  1805.     dc.MoveTo(v3.x, v3.y); dc.LineTo(v2.x, v2.y);
  1806.  
  1807.     dc.SetROP2(R2_COPYPEN);
  1808.     dc.SelectObject(TPen(cMarkerSelect));
  1809.     dc.SelectObject(TBrush(cMarkerSelect));
  1810.     if (v1.x != v0.x || v1.y != v0.y) {
  1811.         dc.Rectangle(v1.x-markersize, v1.y-markersize,
  1812.                      v1.x+markersize, v1.y+markersize);
  1813.     }
  1814.     if (v2.x != v3.x || v2.y != v3.y) {
  1815.         dc.Rectangle(v2.x-markersize, v2.y-markersize,
  1816.                      v2.x+markersize, v2.y+markersize);
  1817.     }
  1818.  
  1819.     dc.SelectObject(TPen(cMarker));
  1820.     dc.SelectObject(TBrush(cMarker));
  1821.     double l;
  1822.     if ((l = v0v.length()) > minimumdouble) {
  1823.         v0v *= (markersize*1.5/l);
  1824.         TPoint p[3];
  1825.         p[0] = TPoint(v0.x +       v0v.x              , v0.y +       v0v.y);
  1826.         p[1] = TPoint(v0.x - 0.5 * v0v.x - 0.8 * v0v.y, v0.y - 0.5 * v0v.y + 0.8 * v0v.x);
  1827.         p[2] = TPoint(v0.x - 0.5 * v0v.x + 0.8 * v0v.y, v0.y - 0.5 * v0v.y - 0.8 * v0v.x);
  1828.         dc.Polygon(p, 3);
  1829.     } else {
  1830.         dc.Rectangle(v0.x-markersize, v0.y-markersize,
  1831.                      v0.x+markersize, v0.y+markersize);
  1832.     }
  1833.     if ((l = v3v.length()) > minimumdouble) {
  1834.         v3v *= (markersize*1.5/l);
  1835.         TPoint p[3];
  1836.         p[0] = TPoint(v3.x +       v3v.x              , v3.y +       v3v.y);
  1837.         p[1] = TPoint(v3.x - 0.5 * v3v.x - 0.8 * v3v.y, v3.y - 0.5 * v3v.y + 0.8 * v3v.x);
  1838.         p[2] = TPoint(v3.x - 0.5 * v3v.x + 0.8 * v3v.y, v3.y - 0.5 * v3v.y - 0.8 * v3v.x);
  1839.         dc.Polygon(p, 3);
  1840.     } else {
  1841.         dc.Rectangle(v3.x-markersize, v3.y-markersize,
  1842.                      v3.x+markersize, v3.y+markersize);
  1843.     }
  1844. }
  1845.  
  1846. void TWinDisplay::ShowMarker(TDC& dc, Motion *mot)
  1847. {
  1848.     Matrix m = GetMatrix();
  1849.     Vector v;
  1850.     v = m * mot->position;
  1851.     dc.Rectangle(v.x-markersize, v.y-markersize,
  1852.                  v.x+markersize, v.y+markersize);
  1853. }
  1854.  
  1855. void TWinDisplay::ShowMesh(TDC& dc)
  1856. {
  1857.     if (anim->meshflag == FALSE) {
  1858.         return;
  1859.     }
  1860.     Vector v = convmatrix * anim->displayoffset;
  1861.     double bx = - (1.0 / anim->displayscale) * (v.x + Attr.W / 2);
  1862.     double by = - (1.0 / anim->displayscale) * (v.y + Attr.H / 2);
  1863.     int cx = (1.0 / anim->displayscale) * (double)Attr.W / (double)anim->meshspacing+1;
  1864.     int cy = (1.0 / anim->displayscale) * (double)Attr.H / (double)anim->meshspacing+1;
  1865.  
  1866.     dc.SetROP2(R2_COPYPEN);
  1867.     dc.SelectObject(TPen(cGrid));
  1868.     dc.SelectObject(TPen(cGrid,1,PS_DOT));
  1869.     dc.SetBkMode(TRANSPARENT);
  1870.     int i;
  1871.  
  1872.     if (bx < 0) {
  1873.         bx = -((long)(-bx/anim->meshspacing)  ) * anim->meshspacing;
  1874.     } else {
  1875.         bx =  ((long)( bx/anim->meshspacing)+1) * anim->meshspacing;
  1876.     }
  1877.     for (i = 0; i < cx; ++i) {
  1878.         int x = bx * anim->displayscale + v.x + Attr.W / 2;
  1879.         if (-anim->meshspacing/2 < bx && bx < anim->meshspacing/2) {
  1880.             dc.SelectObject(TPen(cGridZero));
  1881.             dc.MoveTo(x,0);
  1882.             dc.LineTo(x,Attr.H);
  1883.             dc.SelectObject(TPen(cGrid,1,PS_DOT));
  1884. //            dc.SelectObject(TPen(cGrid));
  1885.         } else {
  1886.             dc.MoveTo(x,0);
  1887.             dc.LineTo(x,Attr.H);
  1888.         }
  1889.         bx += anim->meshspacing;
  1890.     }
  1891.     if (by < 0) {
  1892.         by = -((long)(-by/anim->meshspacing)  ) * anim->meshspacing;
  1893.     } else {
  1894.         by =  ((long)( by/anim->meshspacing)+1) * anim->meshspacing;
  1895.     }
  1896.     for (i = 0; i < cy; ++i) {
  1897.         int y = -by * anim->displayscale - v.y + Attr.H / 2;
  1898.         if (-anim->meshspacing/2 < by && by     < anim->meshspacing/2) {
  1899.             dc.SelectObject(TPen(cGridZero));
  1900.             dc.MoveTo(0,y);
  1901.             dc.LineTo(Attr.W,y);
  1902.             dc.SelectObject(TPen(cGrid,1,PS_DOT));
  1903. //            dc.SelectObject(TPen(cGrid));
  1904.         } else {
  1905.             dc.MoveTo(0,y);
  1906.             dc.LineTo(Attr.W,y);
  1907.         }
  1908.         by += anim->meshspacing;
  1909.     }
  1910.  
  1911. }
  1912.  
  1913. Matrix TWinDisplay::GetMatrix(void)
  1914. {
  1915.     return    Matrix::m_move(Vector(Attr.W/2, Attr.H/2, 0)).scale(Vector(1,-1,1))
  1916.          * convmatrix.move(anim->displayoffset).scale(anim->displayscale);
  1917. }
  1918.  
  1919. Matrix TWinDisplay::GetInvMatrix(void)
  1920. {
  1921.     return (Matrix::m_scale(1.0/anim->displayscale).move(-anim->displayoffset) * convmatrix.inv())
  1922.         .scale(Vector(1, -1, 1)).move(Vector(-Attr.W/2, -Attr.H/2, 0));
  1923. }
  1924.  
  1925.  
  1926.