質問編集履歴

13

提示コードを編集

2020/04/10 02:36

投稿

退会済みユーザー
test CHANGED
@@ -1 +1 @@
1
- クォータニオンによる中心点を中心にラジアン度カメラを回転する視点移動を実装したい。
1
+ クォータニオンによる中心点を中心にラジアン度カメラを回転する視点移動を実装したい。原点の算出法など
test CHANGED
@@ -1,8 +1,6 @@
1
- 参考サイトなどを見て計算式をプログラムに落とし込んだが何が原因で以下の症状のようバグがでるのかどうしてもわかりません
1
+ 参考サイトなどを見て計算式をプログラムに落とし込んだが何が原因でカメラが注視点を中心に回転しくれのかわからない”地球を中心に回る月のような月”
2
-
3
- rotate();関数の引数は(座標,ラジアン,中心点,回転軸)ようになっています。
2
+
4
-
5
- "座標"を"中心点"を中心とした"回転軸"に"ラジアン"回転するということを目的としています。
3
+ rotate();関数の引数は(座標,ラジアン,中心点,回転軸)ようになっています。"座標"を"中心点"を中心とした"回転軸"に"ラジアン"回転するということを目的としています。
6
4
 
7
5
 
8
6
 
@@ -56,7 +54,13 @@
56
54
 
57
55
  /*回転 回転する座標、ラジアン、中心、軸*/
58
56
 
57
+
58
+
59
+
60
+
61
+ /*回転する座標、ラジアン、中心、軸*/
62
+
59
- void Game::rotate(Vector *pos,const float ang, const Vector target,const Vector axis)
63
+ void Game::rotate(Vector *pos,const float ang, const Vector targetV,const Vector axis)
60
64
 
61
65
  {
62
66
 
@@ -66,45 +70,41 @@
66
70
 
67
71
 
68
72
 
69
- Quaternion P(0,Vector(pos->x, pos->y, pos->z));//回転させる点
73
+ Quaternion P(0, Vector(pos->x, pos->y, pos->z));//回転させる点
74
+
70
-
75
+ Quaternion P2(0, Vector(pos->x - targetV.x, pos->y - targetV.y, pos->z - targetV.z));//回転させる点
76
+
71
-
77
+ Quaternion PP(0, Vector(targetV.x - pos->x, targetV.y - pos->y, targetV.z - pos->z));//回転させる点
72
-
78
+
73
- MATRIX t = MGetRotX(ang);//回転させる
79
+ Quaternion PP3(0,Vector(targetV.x , targetV.y , targetV.z ));//回転させる
74
-
75
-
76
-
77
- VECTOR v;
80
+
78
-
79
- v.x = -1;
81
+
80
-
81
- v.y = 0;
82
+
82
-
83
- v.z = 0;
84
-
85
-
86
-
87
-
88
-
89
- Quaternion Q(cos(ang / 2), Vector(v.x * sin(ang / 2), v.y * sin(ang / 2), v.z * sin(ang / 2)));
83
+ Quaternion Q(cos(ang / 2), Vector( axis.x * sin(ang / 2), axis.y * sin(ang / 2), axis.z * sin(ang / 2)));
90
-
84
+
91
- Quaternion R(cos(ang / 2), Vector(-v.x * sin(ang / 2) , -v.y * sin(ang / 2), -v.z * sin(ang / 2)));
85
+ Quaternion R(cos(ang / 2), Vector(-axis.x * sin(ang / 2) , -axis.y * sin(ang / 2), -axis.z * sin(ang / 2)));
92
-
93
-
94
-
86
+
87
+
88
+
95
- /*
89
+ Quaternion result = (R * P2) * Q;//順番が大事
90
+
91
+
92
+
93
+ ofs << "pos.x:" << pos->x << std::endl;
94
+
95
+ ofs << "pos.y:" << pos->y << std::endl;
96
+
97
+ ofs << "pos.z:" << pos->z << "\n" << std::endl;
98
+
99
+
96
100
 
97
101
  ofs << "result.x:" << result.v.x << std::endl;
98
102
 
99
103
  ofs << "result.y:" << result.v.y << std::endl;
100
104
 
101
- ofs<< "result.z:" << result.v.z <<"\n\n\n"<< std::endl;
105
+ ofs << "result.z:" << result.v.z << "\n\n\n" << std::endl;
102
-
103
- */
106
+
104
-
105
- Quaternion result = R * P * Q;//順番が大事
107
+
106
-
107
-
108
108
 
109
109
  pos->x = result.v.x;
110
110
 

12

タイトルを再度編集しました。

2020/04/10 02:36

投稿

退会済みユーザー
test CHANGED
@@ -1 +1 @@
1
- クォータニオンによる中心点を中心にラジアン度 カメラ回転を実装したい。
1
+ クォータニオンによる中心点を中心にラジアン度カメラ回転する視点移動を実装したい。
test CHANGED
File without changes

11

文章とタイトルを編集しました。

2020/04/07 04:30

投稿

退会済みユーザー
test CHANGED
@@ -1 +1 @@
1
- クォータニオンによるカメラ回転を実装したい。その時の空間を2Dのように回ってしまう原因とは
1
+ クォータニオンによる中心点を中心にラジアン度 カメラ回転を実装したい。
test CHANGED
@@ -1,8 +1,18 @@
1
1
  参考サイトなどを見て計算式をプログラムに落とし込んだが何が原因で以下の症状のようなバグがでるのかどうしてもわかりません。
2
2
 
3
-
3
+ rotate();関数の引数は(座標,ラジアン,中心点,回転軸)ようになっています。
4
+
4
-
5
+ "座標"を"中心点"を中心とした"回転軸"に"ラジアン"回転するということを目的としています。
6
+
7
+
8
+
9
+
10
+
11
+
12
+
5
- 質問1、X軸回転の関数ですがクォータニオンの計算をしてカメラを回転させたいがクォータニオン同士の掛け算やベクトルの外積、内積の計算が正しいのか?
13
+ 質問1、rotate関数ですがクォータニオンの計算をしてカメラを回転させたいがクォータニオン同士の掛け算や
14
+
15
+ ベクトルの外積、内積の計算が正しいのか、注視点はいいのか?
6
16
 
7
17
 
8
18
 
@@ -10,15 +20,13 @@
10
20
 
11
21
 
12
22
 
13
- 質問3.以下の症状が修正できず、何が悪いのかわからない。
14
-
15
- 症状は 実行時に上下に動かと見事にクォータニオンしてくれますが左右動いたあとrotate();関数が行されてそ
23
+ 質問3、どうればクォータニオンによる中心点を中心にラジアン度 カメラ回転を装できるか知りたい。
16
-
17
- 上下に動かすとその**空間座標?を中心にくるくる回ってしまいます**
24
+
18
-
19
-
20
-
25
+
26
+
27
+
28
+
21
- やりたいこと **周回軌道のようなモン〇ンのカメラのようなカメラ動作をしてほしい。**
29
+ やりたいこと **周回軌道のようなモン〇ンのような3アクションゲームのカメラのようなカメラ動作をしてほしい。**
22
30
 
23
31
 
24
32
 
@@ -44,22 +52,24 @@
44
52
 
45
53
  ```ここに言語を入力
46
54
 
55
+
56
+
47
- /*X軸回転*/
57
+ /*回転 回転する座標、ラジアン、中心、軸*/
48
-
58
+
49
- void Game::rotate_X(float *x,float *y,float *z,const float ang, const float mx,const float my,const float mz)
59
+ void Game::rotate(Vector *pos,const float ang, const Vector target,const Vector axis)
50
-
60
+
51
- {
61
+ {
52
-
53
-
54
-
55
- //Quaternion Prev(0, Vector(*x - mx, *y - my, *z - mz));
56
-
57
-
58
-
59
- Quaternion P(0,Vector(*x, *y, *z));//回転させる点
60
62
 
61
63
 
62
64
 
65
+ //Quaternion Prev(0, Vector(*x - mx, *y - my, *z - mz));
66
+
67
+
68
+
69
+ Quaternion P(0,Vector(pos->x, pos->y, pos->z));//回転させる点
70
+
71
+
72
+
63
73
  MATRIX t = MGetRotX(ang);//回転させる軸
64
74
 
65
75
 
@@ -96,470 +106,528 @@
96
106
 
97
107
 
98
108
 
99
- *x = result.v.x;
109
+ pos->x = result.v.x;
100
-
110
+
101
- *y = result.v.y;
111
+ pos->y = result.v.y;
102
-
112
+
103
- *z = result.v.z;
113
+ pos->z = result.v.z;
104
-
105
-
106
-
107
- }
108
-
109
-
110
-
111
-
112
-
113
-
114
-
115
- /* 一次変換 (x,y)の点を(mx,my)を中心にang角回転する */
116
-
117
- void rotate(float* x, float* y, const float ang, const float mx, const float my)
118
-
119
- {
120
114
 
121
115
 
122
116
 
117
+ }
118
+
119
+
120
+
121
+ void Game::Update()
122
+
123
+ {
124
+
125
+ /*カメラ回転*/
126
+
127
+ if (Input::keyboard(KEY_INPUT_LEFT) > 0)
128
+
129
+ {
130
+
131
+ // rotate(&cameraX, &cameraZ, +ROTATE_SPEED, targetX, targetZ,);
132
+
133
+ }
134
+
135
+ else if (Input::keyboard(KEY_INPUT_RIGHT) > 0)
136
+
137
+ {
138
+
139
+ // rotate(&cameraX, &cameraZ, -ROTATE_SPEED, targetX, targetZ);
140
+
141
+ }
142
+
143
+ else if (Input::keyboard(KEY_INPUT_UP) > 0)
144
+
145
+ {
146
+
147
+ // rotate_X(&cameraX, &cameraY,&cameraZ, -ROTATE_SPEED, targetX, targetY,targetZ);
148
+
149
+ DrawFormatString(100,100,GetColor(255,255,255),"UP");
150
+
151
+
152
+
153
+ }
154
+
155
+ else if (Input::keyboard(KEY_INPUT_DOWN) > 0)
156
+
157
+ {
158
+
159
+ // rotate_X(&cameraX, &cameraY, &cameraZ, +ROTATE_SPEED, targetX, targetY, targetZ);
160
+
161
+ DrawFormatString(100, 100, GetColor(255, 255, 255), "Down");
162
+
163
+
164
+
165
+ }
166
+
167
+ if (Input::keyboard(KEY_INPUT_W) > 0)
168
+
169
+ {
170
+
171
+
172
+
173
+ }
174
+
175
+ else if (Input::keyboard(KEY_INPUT_S) > 0)
176
+
177
+ {
178
+
179
+
180
+
181
+ }
182
+
183
+
184
+
185
+
186
+
187
+ /*色 変更*/
188
+
123
- const float ox = *x - mx, oy = *y - my;
189
+ if(Input::keyboard(KEY_INPUT_SPACE) == 1)
190
+
124
-
191
+ {
192
+
125
- *x = (ox * cos(ang)) + (oy * sin(ang));
193
+ ModeChange = !ModeChange;
194
+
126
-
195
+ }
196
+
197
+ /* false spcカラーを変更*/
198
+
199
+ if (Input::keyboard(KEY_INPUT_Z) > 0 && ModeChange == false)
200
+
201
+ {
202
+
203
+ color_spc.r += -1;
204
+
205
+ color_spc.g += -1;
206
+
207
+ color_spc.b += -1;
208
+
209
+
210
+
211
+ }
212
+
213
+ else if (Input::keyboard(KEY_INPUT_X) > 0 && ModeChange == false)
214
+
215
+ {
216
+
217
+ color_spc.r += 1;
218
+
219
+ color_spc.g += 1;
220
+
221
+ color_spc.b += 1;
222
+
223
+
224
+
225
+ /*true difカラー変更*/
226
+
227
+ }else if (Input::keyboard(KEY_INPUT_Z) > 0 && ModeChange == true)
228
+
229
+ {
230
+
231
+ color_dif.r += -1;
232
+
233
+ color_dif.g += -1;
234
+
235
+ color_dif.b += -1;
236
+
237
+
238
+
239
+ }
240
+
241
+ else if (Input::keyboard(KEY_INPUT_X) > 0 && ModeChange == true)
242
+
243
+ {
244
+
245
+ color_dif.r += 1;
246
+
247
+ color_dif.g += 1;
248
+
249
+ color_dif.b += 1;
250
+
251
+
252
+
253
+ }
254
+
255
+
256
+
127
- *y = (-ox * sin(ang)) + (oy * cos(ang));
257
+ if (Input::keyboard(KEY_INPUT_F1) == 1)
258
+
128
-
259
+ {
260
+
129
-
261
+ TextureMode = !TextureMode;
262
+
130
-
263
+ }
264
+
265
+
266
+
267
+
268
+
269
+
270
+
271
+
272
+
273
+
274
+
275
+
276
+
277
+
278
+
279
+ }
280
+
281
+ ```
282
+
283
+
284
+
285
+ ヘッダー部
286
+
287
+ ```ここに言語を入力
288
+
289
+ #ifndef ___Vector_H
290
+
291
+ #define ___Vector_H
292
+
293
+
294
+
295
+ //template<typename type>
296
+
131
- *x += mx;
297
+ class Vector
298
+
132
-
299
+ {
300
+
133
- *y += my;
301
+ private:
302
+
303
+
304
+
305
+
306
+
307
+
308
+
309
+
310
+
311
+ public:
134
312
 
135
313
 
136
314
 
137
315
 
138
316
 
139
- }
140
-
141
-
142
-
143
-
144
-
145
-
146
-
147
- void Game::Update()
148
-
149
- {
150
-
151
- /*カメラ回転*/
152
-
153
- if (Input::keyboard(KEY_INPUT_LEFT) > 0)
154
-
155
- {
156
-
157
- rotate(&cameraX, &cameraZ, +ROTATE_SPEED, targetX, targetZ);
158
-
159
- }
160
-
161
- else if (Input::keyboard(KEY_INPUT_RIGHT) > 0)
162
-
163
- {
164
-
165
- rotate(&cameraX, &cameraZ, -ROTATE_SPEED, targetX, targetZ);
166
-
167
- }
168
-
169
- else if (Input::keyboard(KEY_INPUT_UP) > 0)
170
-
171
- {
172
-
173
- rotate_X(&cameraX, &cameraY,&cameraZ, -ROTATE_SPEED, targetX, targetY,targetZ);
174
-
175
- DrawFormatString(100,100,GetColor(255,255,255),"UP");
176
-
177
-
178
-
179
- }
180
-
181
- else if (Input::keyboard(KEY_INPUT_DOWN) > 0)
182
-
183
- {
184
-
185
- rotate_X(&cameraX, &cameraY, &cameraZ, +ROTATE_SPEED, targetX, targetY, targetZ);
186
-
187
- DrawFormatString(100, 100, GetColor(255, 255, 255), "Down");
188
-
189
-
190
-
191
- }
192
-
193
- if (Input::keyboard(KEY_INPUT_W) > 0)
194
-
195
- {
196
-
197
-
198
-
199
- }
200
-
201
- else if (Input::keyboard(KEY_INPUT_S) > 0)
202
-
203
- {
204
-
205
-
206
-
207
- }
208
-
209
-
210
-
211
- }
317
+ float x;
318
+
319
+ float y;
320
+
321
+ float z;
322
+
323
+
324
+
325
+ Vector(float xx, float yy, float zz);
326
+
327
+ Vector();
328
+
329
+
330
+
331
+
332
+
333
+
334
+
335
+
336
+
337
+
338
+
339
+ static Vector cross(Vector a, Vector b);//外積
340
+
341
+ static float dot(Vector a, Vector b);//内積
342
+
343
+
344
+
345
+
346
+
347
+ static Vector mul_scalar(float a, Vector v);//スカラーとベクトルの掛け算
348
+
349
+
350
+
351
+
352
+
353
+
354
+
355
+
356
+
357
+
358
+
359
+ Vector operator = (Vector v);
360
+
361
+ Vector operator + (Vector v);
362
+
363
+
364
+
365
+ };
366
+
367
+
368
+
369
+ //template<typename type>
370
+
371
+ class Quaternion
372
+
373
+ {
374
+
375
+ public:
376
+
377
+
378
+
379
+ /*実部*/
380
+
381
+ float a;
382
+
383
+
384
+
385
+ /*虚部*/
386
+
387
+ // Vector<type> v;
388
+
389
+ Vector v;
390
+
391
+
392
+
393
+ Quaternion(float aa, Vector vv);
394
+
395
+ Quaternion();
396
+
397
+
398
+
399
+ Quaternion operator * (Quaternion t);
400
+
401
+
402
+
403
+
404
+
405
+ };
406
+
407
+
408
+
409
+
410
+
411
+
412
+
413
+
414
+
415
+ #endif
416
+
417
+
212
418
 
213
419
  ```
214
420
 
215
421
 
216
422
 
217
- ヘッダ
423
+ スファイル
218
424
 
219
425
  ```ここに言語を入力
220
426
 
221
- #ifndef ___Vector_H
222
-
223
- #define ___Vector_H
224
-
225
-
226
-
227
- //template<typename type>
228
-
229
- class Vector
230
-
231
- {
232
-
233
- private:
234
-
235
-
236
-
237
-
238
-
239
-
240
-
241
-
242
-
243
- public:
244
-
245
-
246
-
247
-
248
-
249
- float x;
250
-
251
- float y;
252
-
253
- float z;
254
-
255
-
256
-
257
- Vector(float xx, float yy, float zz);
258
-
259
- Vector();
260
-
261
-
262
-
263
-
264
-
265
-
266
-
267
-
268
-
269
-
270
-
271
- static Vector cross(Vector a, Vector b);//外積
272
-
273
- static float dot(Vector a, Vector b);//内積
274
-
275
-
276
-
277
-
278
-
279
- static Vector mul_scalar(float a, Vector v);//スカラーとベクトルの掛け算
280
-
281
-
282
-
283
-
284
-
285
-
286
-
287
-
288
-
289
-
290
-
291
- Vector operator = (Vector v);
292
-
293
- Vector operator + (Vector v);
294
-
295
-
296
-
297
- };
298
-
299
-
300
-
301
- //template<typename type>
302
-
303
- class Quaternion
304
-
305
- {
306
-
307
- public:
308
-
309
-
310
-
311
- /*実部*/
312
-
313
- float a;
427
+ #include "Vector.hpp"
428
+
429
+
430
+
431
+
432
+
433
+ /*ベクトル x スカラーの掛け算*/
434
+
435
+ Vector Vector::mul_scalar(float a, Vector v)
436
+
437
+ {
438
+
439
+ return Vector(a * v.x,a * v.y,a * v.z);
440
+
441
+ }
442
+
443
+
444
+
445
+
446
+
447
+ /*外積 ベクトル x ベクトル*/
448
+
449
+ Vector Vector::cross(Vector a,Vector b)
450
+
451
+ {
452
+
453
+ return Vector( (a.y * b.z) - (a.z * b.y),
454
+
455
+ (a.z * b.x) - (a.x * b.z),
456
+
457
+ (a.x * b.y) - (a.y * b.x));
458
+
459
+
460
+
461
+ }
462
+
463
+
464
+
465
+ /*内積*/
466
+
467
+ float Vector::dot(Vector a, Vector b)
468
+
469
+ {
470
+
471
+ return (a.x * b.x) + (a.y * b.y) + (a.z * a.z);
472
+
473
+ }
474
+
475
+
476
+
477
+
478
+
479
+ /*コンストラクタ*/
480
+
481
+ Vector::Vector(float xx,float yy,float zz)
482
+
483
+ {
484
+
485
+ x = xx;
486
+
487
+ y = yy;
488
+
489
+ z = zz;
490
+
491
+ }
492
+
493
+
494
+
495
+
496
+
497
+
498
+
499
+ /*コンストラクタ*/
500
+
501
+ Vector::Vector()
502
+
503
+ {
504
+
505
+ x = 0.0f;
506
+
507
+ y = 0.0f;
508
+
509
+ z = 0.0f;
510
+
511
+ }
512
+
513
+
514
+
515
+
516
+
517
+ /*オペレーター = */
518
+
519
+ Vector Vector::operator = (Vector v)
520
+
521
+ {
522
+
523
+ this->x = v.x;
524
+
525
+ this->y = v.y;
526
+
527
+ this->z = v.z;
528
+
529
+
530
+
531
+ return *this;
532
+
533
+ }
534
+
535
+
536
+
537
+ /*オペレーター + */
538
+
539
+ Vector Vector::operator + (Vector v)
540
+
541
+ {
542
+
543
+ Vector t;
544
+
545
+ t.x = this->x + v.x;
546
+
547
+ t.y = this->y + v.y;
548
+
549
+ t.z = this->z + v.z;
550
+
551
+
552
+
553
+
554
+
555
+ return t;
556
+
557
+ }
558
+
559
+
560
+
561
+
562
+
563
+
564
+
565
+
566
+
567
+ /*コンストラクタ 実部、虚部(Vector) */
568
+
569
+ Quaternion::Quaternion(float aa, Vector vv)
570
+
571
+ {
572
+
573
+ a = aa;//実部
314
574
 
315
575
 
316
576
 
317
577
  /*虚部*/
318
578
 
579
+ v = vv;
580
+
581
+ }
582
+
583
+
584
+
585
+
586
+
319
- // Vector<type> v;
587
+ /*コンストラクタ 引数なし*/
320
-
321
- Vector v;
588
+
322
-
323
-
324
-
325
- Quaternion(float aa, Vector vv);
589
+ Quaternion::Quaternion()
590
+
326
-
591
+ {
592
+
593
+
594
+
595
+ a = 0.0f;//実部
596
+
597
+
598
+
599
+ /*虚部*/
600
+
327
- Quaternion();
601
+ v.x = 0.0f;
602
+
328
-
603
+ v.y = 0.0f;
604
+
329
-
605
+ v.z = 0.0f;
606
+
330
-
607
+ }
608
+
609
+
610
+
611
+ /*クォータニオン同士の掛け算
612
+
613
+
614
+
615
+ A = (a; U)
616
+
617
+ B = (b; V)
618
+
619
+ AB = (ab - U・V; aV + bU + U×V)
620
+
621
+ */
622
+
331
- Quaternion operator * (Quaternion t);
623
+ Quaternion Quaternion::operator * ( Quaternion t )
624
+
332
-
625
+ {
626
+
333
-
627
+ return Quaternion(this->a * t.a - Vector::dot(this->v,t.v),Vector(Vector::mul_scalar(this->a,t.v) + Vector::mul_scalar(t.a,this->v) + Vector::cross(this->v,t.v)));
334
-
335
-
336
-
628
+
337
- };
629
+ }
338
-
339
-
340
-
341
-
342
-
343
-
344
-
345
-
346
-
347
- #endif
348
630
 
349
631
 
350
632
 
351
633
  ```
352
-
353
-
354
-
355
- ソースファイル
356
-
357
- ```ここに言語を入力
358
-
359
- #include "Vector.hpp"
360
-
361
-
362
-
363
-
364
-
365
- /*ベクトル x スカラーの掛け算*/
366
-
367
- Vector Vector::mul_scalar(float a, Vector v)
368
-
369
- {
370
-
371
- return Vector(a * v.x,a * v.y,a * v.z);
372
-
373
- }
374
-
375
-
376
-
377
-
378
-
379
- /*外積 ベクトル x ベクトル*/
380
-
381
- Vector Vector::cross(Vector a,Vector b)
382
-
383
- {
384
-
385
- return Vector( (a.y * b.z) - (a.z * b.y),
386
-
387
- (a.z * b.x) - (a.x * b.z),
388
-
389
- (a.x * b.y) - (a.y * b.x));
390
-
391
-
392
-
393
- }
394
-
395
-
396
-
397
- /*内積*/
398
-
399
- float Vector::dot(Vector a, Vector b)
400
-
401
- {
402
-
403
- return (a.x * b.x) + (a.y * b.y) + (a.z * a.z);
404
-
405
- }
406
-
407
-
408
-
409
-
410
-
411
- /*コンストラクタ*/
412
-
413
- Vector::Vector(float xx,float yy,float zz)
414
-
415
- {
416
-
417
- x = xx;
418
-
419
- y = yy;
420
-
421
- z = zz;
422
-
423
- }
424
-
425
-
426
-
427
-
428
-
429
-
430
-
431
- /*コンストラクタ*/
432
-
433
- Vector::Vector()
434
-
435
- {
436
-
437
- x = 0.0f;
438
-
439
- y = 0.0f;
440
-
441
- z = 0.0f;
442
-
443
- }
444
-
445
-
446
-
447
-
448
-
449
- /*オペレーター = */
450
-
451
- Vector Vector::operator = (Vector v)
452
-
453
- {
454
-
455
- this->x = v.x;
456
-
457
- this->y = v.y;
458
-
459
- this->z = v.z;
460
-
461
-
462
-
463
- return *this;
464
-
465
- }
466
-
467
-
468
-
469
- /*オペレーター + */
470
-
471
- Vector Vector::operator + (Vector v)
472
-
473
- {
474
-
475
- Vector t;
476
-
477
- t.x = this->x + v.x;
478
-
479
- t.y = this->y + v.y;
480
-
481
- t.z = this->z + v.z;
482
-
483
-
484
-
485
-
486
-
487
- return t;
488
-
489
- }
490
-
491
-
492
-
493
-
494
-
495
-
496
-
497
-
498
-
499
- /*コンストラクタ 実部、虚部(Vector) */
500
-
501
- Quaternion::Quaternion(float aa, Vector vv)
502
-
503
- {
504
-
505
- a = aa;//実部
506
-
507
-
508
-
509
- /*虚部*/
510
-
511
- v = vv;
512
-
513
- }
514
-
515
-
516
-
517
-
518
-
519
- /*コンストラクタ 引数なし*/
520
-
521
- Quaternion::Quaternion()
522
-
523
- {
524
-
525
-
526
-
527
- a = 0.0f;//実部
528
-
529
-
530
-
531
- /*虚部*/
532
-
533
- v.x = 0.0f;
534
-
535
- v.y = 0.0f;
536
-
537
- v.z = 0.0f;
538
-
539
- }
540
-
541
-
542
-
543
- /*クォータニオン同士の掛け算
544
-
545
-
546
-
547
- A = (a; U)
548
-
549
- B = (b; V)
550
-
551
- AB = (ab - U・V; aV + bU + U×V)
552
-
553
- */
554
-
555
- Quaternion Quaternion::operator * ( Quaternion t )
556
-
557
- {
558
-
559
- return Quaternion(this->a * t.a - Vector::dot(this->v,t.v),Vector(Vector::mul_scalar(this->a,t.v) + Vector::mul_scalar(t.a,this->v) + Vector::cross(this->v,t.v)));
560
-
561
- }
562
-
563
-
564
-
565
- ```

10

文章とタイトルを編集しました。

2020/04/07 04:26

投稿

退会済みユーザー
test CHANGED
@@ -1 +1 @@
1
- クォータニオンによるカメラ回転を実装したが上手く動作ない原因が知りたい。回転前後で動作が違う
1
+ クォータニオンによるカメラ回転を実装したい。その時の空間を2Dのように回ってまう原因と
test CHANGED
@@ -1,18 +1,24 @@
1
+ 参考サイトなどを見て計算式をプログラムに落とし込んだが何が原因で以下の症状のようなバグがでるのかどうしてもわかりません。
2
+
3
+
4
+
1
- X軸回転の関数ですが Y軸とZ軸数値が上がり下がりますが上手く周回しくれず、あと一歩のところで上手く回転できま
5
+ 質問1、X軸回転の関数ですがクォータニオン計算をしてカメラを回転たいがクォータニオン同士の掛け算やベクトルの外積、内積の計算が正しいのか?
2
-
3
- これは何を間違えたのでしょうか?
6
+
4
-
5
-
6
-
7
+
8
+
7
- 質問ですが"回転軸ベクトル"とは何をすれば算出されるのでしょうか?
9
+ 質問2、"回転軸ベクトル"とは何をすれば算出されるのでしょうか?
10
+
11
+
12
+
8
-
13
+ 質問3.以下の症状が修正できず、何が悪いのかわからない。
9
-
10
14
 
11
15
  症状は 実行時に上下に動かすと見事にクォータニオンしてくれますが左右に動いたあとrotate();関数が実行されてその後
12
16
 
13
- 上下に動かすとその**空間座標?を中心にくるくる回ってしまい**周回軌道のようなモン〇ンのカメラのような動作をしてくれません
17
+ 上下に動かすとその**空間座標?を中心にくるくる回ってしまいます**
18
+
19
+
20
+
14
-
21
+ やりたいこと **周回軌道のようなモン〇ンのカメラのようなカメラ動作をしてほしい。**
15
-
16
22
 
17
23
 
18
24
 
@@ -20,7 +26,7 @@
20
26
 
21
27
  ![イメージ説明](7036df702c017099eb73b3deb642844a.png)
22
28
 
23
- ![イメージ説明](0ea179463c2bbfeebdcaa870c57fcabe.png)
29
+
24
30
 
25
31
 
26
32
 
@@ -44,45 +50,49 @@
44
50
 
45
51
  {
46
52
 
53
+
54
+
55
+ //Quaternion Prev(0, Vector(*x - mx, *y - my, *z - mz));
56
+
57
+
58
+
59
+ Quaternion P(0,Vector(*x, *y, *z));//回転させる点
60
+
47
61
 
48
62
 
49
- // Quaternion Prev(0, Position(*x - mx, *y - my, *z - mz));//回転させる点
50
-
51
- Quaternion P(0,Position(*x, *y, *z));//回転させる点
52
-
53
- //Position v(-5, 0, 0);//回転させる軸
54
-
55
63
  MATRIX t = MGetRotX(ang);//回転させる軸
56
64
 
57
65
 
58
66
 
59
- VECTOR v2;
67
+ VECTOR v;
60
-
61
-
62
-
68
+
63
- v2.x = *x;
69
+ v.x = -1;
64
-
70
+
65
- v2.y = *y;
71
+ v.y = 0;
66
-
72
+
67
- v2.z = *z;
73
+ v.z = 0;
68
-
69
-
70
-
71
- VECTOR v = VTransform(v2,t);
74
+
72
-
73
- //Position v(ang,0,0);//回転させる軸
75
+
74
-
75
-
76
-
76
+
77
+
78
+
77
- Quaternion Q(cos(ang / 2), Position(v.x * sin(ang / 2), v.y * sin(ang / 2), v.z * sin(ang / 2)));
79
+ Quaternion Q(cos(ang / 2), Vector(v.x * sin(ang / 2), v.y * sin(ang / 2), v.z * sin(ang / 2)));
78
-
80
+
79
- Quaternion R(cos(ang / 2), Position(-v.x * sin(ang / 2) , -v.y * sin(ang / 2), -v.z * sin(ang / 2)));
81
+ Quaternion R(cos(ang / 2), Vector(-v.x * sin(ang / 2) , -v.y * sin(ang / 2), -v.z * sin(ang / 2)));
82
+
83
+
84
+
80
-
85
+ /*
81
-
82
-
86
+
83
- Quaternion r = Quaternion::mul(R , Q);
87
+ ofs << "result.x:" << result.v.x << std::endl;
88
+
84
-
89
+ ofs << "result.y:" << result.v.y << std::endl;
90
+
91
+ ofs<< "result.z:" << result.v.z <<"\n\n\n"<< std::endl;
92
+
93
+ */
94
+
85
- Quaternion result = Quaternion::mul(r , P);
95
+ Quaternion result = R * P * Q;//順番が大事
86
96
 
87
97
 
88
98
 
@@ -90,7 +100,9 @@
90
100
 
91
101
  *y = result.v.y;
92
102
 
93
- *z = result.v.z;
103
+ *z = result.v.z;
104
+
105
+
94
106
 
95
107
  }
96
108
 
@@ -206,85 +218,171 @@
206
218
 
207
219
  ```ここに言語を入力
208
220
 
209
- #include "Position.hpp"
210
-
211
-
212
-
213
- /*クォータニオン*/
214
-
215
-
216
-
217
- Quaternion::Quaternion(float aa,Position vv)
218
-
219
- {
220
-
221
- a = aa;
222
-
223
-
224
-
225
- v.x = vv.x;
226
-
227
- v.y = vv.y;
228
-
229
- v.z = vv.z;
230
-
231
- }
232
-
233
-
234
-
235
- Quaternion Quaternion::mul(Quaternion a, Quaternion b)
236
-
237
- {
238
-
239
- return Quaternion(a.a * b.a - Position::dot(a.v,b.v),
240
-
241
- Position::Add(Position::mul(a.a ,b.v) , Position::mul(b.a , a.v) , Position::cross(a.v,b.v)));
242
-
243
- }
244
-
245
-
246
-
247
-
248
-
249
-
250
-
251
-
252
-
253
-
254
-
255
- /*ベクトル x スカラー*/
256
-
257
- Position Position::mul(float a, Position v)
258
-
259
- {
260
-
261
- return Position(a * v.x,a * v.y,a * v.z);
262
-
263
- }
264
-
265
-
266
-
267
- /*ベクトルの足し*/
268
-
269
- Position Position::Add(Position a,Position b,Position c)
270
-
271
- {
272
-
273
- return Position(a.x + b.x + c.x, a.y + b.y + c.y,a.z + b.z + c.z);
274
-
275
-
276
-
277
- }
221
+ #ifndef ___Vector_H
222
+
223
+ #define ___Vector_H
224
+
225
+
226
+
227
+ //template<typename type>
228
+
229
+ class Vector
230
+
231
+ {
232
+
233
+ private:
234
+
235
+
236
+
237
+
238
+
239
+
240
+
241
+
242
+
243
+ public:
244
+
245
+
246
+
247
+
248
+
249
+ float x;
250
+
251
+ float y;
252
+
253
+ float z;
254
+
255
+
256
+
257
+ Vector(float xx, float yy, float zz);
258
+
259
+ Vector();
260
+
261
+
262
+
263
+
264
+
265
+
266
+
267
+
268
+
269
+
270
+
271
+ static Vector cross(Vector a, Vector b);//外積
272
+
273
+ static float dot(Vector a, Vector b);//内積
274
+
275
+
276
+
277
+
278
+
279
+ static Vector mul_scalar(float a, Vector v);//スカラーとベクトルの掛け
280
+
281
+
282
+
283
+
284
+
285
+
286
+
287
+
288
+
289
+
290
+
291
+ Vector operator = (Vector v);
292
+
293
+ Vector operator + (Vector v);
294
+
295
+
296
+
297
+ };
298
+
299
+
300
+
301
+ //template<typename type>
302
+
303
+ class Quaternion
304
+
305
+ {
306
+
307
+ public:
308
+
309
+
310
+
311
+ /*実部*/
312
+
313
+ float a;
314
+
315
+
316
+
317
+ /*虚部*/
318
+
319
+ // Vector<type> v;
320
+
321
+ Vector v;
322
+
323
+
324
+
325
+ Quaternion(float aa, Vector vv);
326
+
327
+ Quaternion();
328
+
329
+
330
+
331
+ Quaternion operator * (Quaternion t);
332
+
333
+
334
+
335
+
336
+
337
+ };
338
+
339
+
340
+
341
+
342
+
343
+
344
+
345
+
346
+
347
+ #endif
348
+
349
+
350
+
351
+ ```
352
+
353
+
354
+
355
+ ソースファイル
356
+
357
+ ```ここに言語を入力
358
+
359
+ #include "Vector.hpp"
360
+
361
+
362
+
363
+
364
+
365
+ /*ベクトル x スカラーの掛け算*/
366
+
367
+ Vector Vector::mul_scalar(float a, Vector v)
368
+
369
+ {
370
+
371
+ return Vector(a * v.x,a * v.y,a * v.z);
372
+
373
+ }
374
+
375
+
278
376
 
279
377
 
280
378
 
281
379
  /*外積 ベクトル x ベクトル*/
282
380
 
283
- Position Position::cross(Position a,Position b)
381
+ Vector Vector::cross(Vector a,Vector b)
284
-
382
+
285
- {
383
+ {
286
-
384
+
287
- return Position( (a.y * b.z) - (a.z * b.y),
385
+ return Vector( (a.y * b.z) - (a.z * b.y),
288
386
 
289
387
  (a.z * b.x) - (a.x * b.z),
290
388
 
@@ -298,7 +396,7 @@
298
396
 
299
397
  /*内積*/
300
398
 
301
- float Position::dot(Position a, Position b)
399
+ float Vector::dot(Vector a, Vector b)
302
400
 
303
401
  {
304
402
 
@@ -308,13 +406,11 @@
308
406
 
309
407
 
310
408
 
409
+
410
+
311
- /*座標系*/
411
+ /*コンストラクタ*/
312
-
313
-
314
-
315
- //template<typename type>
412
+
316
-
317
- Position::Position(float xx,float yy,float zz)
413
+ Vector::Vector(float xx,float yy,float zz)
318
414
 
319
415
  {
320
416
 
@@ -332,9 +428,9 @@
332
428
 
333
429
 
334
430
 
335
- //template<typename type>
431
+ /*コンストラクタ*/
336
-
432
+
337
- Position::Position()
433
+ Vector::Vector()
338
434
 
339
435
  {
340
436
 
@@ -350,126 +446,120 @@
350
446
 
351
447
 
352
448
 
449
+ /*オペレーター = */
450
+
451
+ Vector Vector::operator = (Vector v)
452
+
453
+ {
454
+
455
+ this->x = v.x;
456
+
457
+ this->y = v.y;
458
+
459
+ this->z = v.z;
460
+
461
+
462
+
463
+ return *this;
464
+
465
+ }
466
+
467
+
468
+
469
+ /*オペレーター + */
470
+
471
+ Vector Vector::operator + (Vector v)
472
+
473
+ {
474
+
475
+ Vector t;
476
+
477
+ t.x = this->x + v.x;
478
+
479
+ t.y = this->y + v.y;
480
+
481
+ t.z = this->z + v.z;
482
+
483
+
484
+
485
+
486
+
487
+ return t;
488
+
489
+ }
490
+
491
+
492
+
493
+
494
+
495
+
496
+
497
+
498
+
499
+ /*コンストラクタ 実部、虚部(Vector) */
500
+
501
+ Quaternion::Quaternion(float aa, Vector vv)
502
+
503
+ {
504
+
505
+ a = aa;//実部
506
+
507
+
508
+
509
+ /*虚部*/
510
+
511
+ v = vv;
512
+
513
+ }
514
+
515
+
516
+
517
+
518
+
519
+ /*コンストラクタ 引数なし*/
520
+
521
+ Quaternion::Quaternion()
522
+
523
+ {
524
+
525
+
526
+
527
+ a = 0.0f;//実部
528
+
529
+
530
+
531
+ /*虚部*/
532
+
533
+ v.x = 0.0f;
534
+
535
+ v.y = 0.0f;
536
+
537
+ v.z = 0.0f;
538
+
539
+ }
540
+
541
+
542
+
543
+ /*クォータニオン同士の掛け算
544
+
545
+
546
+
547
+ A = (a; U)
548
+
549
+ B = (b; V)
550
+
551
+ AB = (ab - U・V; aV + bU + U×V)
552
+
553
+ */
554
+
555
+ Quaternion Quaternion::operator * ( Quaternion t )
556
+
557
+ {
558
+
559
+ return Quaternion(this->a * t.a - Vector::dot(this->v,t.v),Vector(Vector::mul_scalar(this->a,t.v) + Vector::mul_scalar(t.a,this->v) + Vector::cross(this->v,t.v)));
560
+
561
+ }
562
+
563
+
564
+
353
565
  ```
354
-
355
-
356
-
357
- ソースファイル
358
-
359
- ```ここに言語を入力
360
-
361
- #ifndef ___POSITION_H
362
-
363
- #define ___POSITION_H
364
-
365
-
366
-
367
- //template<typename type>
368
-
369
- class Position
370
-
371
- {
372
-
373
- private:
374
-
375
-
376
-
377
-
378
-
379
-
380
-
381
-
382
-
383
- public:
384
-
385
- float x;
386
-
387
- float y;
388
-
389
- float z;
390
-
391
-
392
-
393
- Position(float xx, float yy, float zz);
394
-
395
- Position();
396
-
397
-
398
-
399
-
400
-
401
-
402
-
403
-
404
-
405
- static Position cross(Position a, Position b);//外積
406
-
407
- static float dot(Position a, Position b);//内積
408
-
409
-
410
-
411
- static Position mul(float a, Position v);
412
-
413
- static Position Add(Position a, Position b, Position c);
414
-
415
-
416
-
417
-
418
-
419
-
420
-
421
-
422
-
423
-
424
-
425
-
426
-
427
- };
428
-
429
-
430
-
431
- //template<typename type>
432
-
433
- class Quaternion
434
-
435
- {
436
-
437
- public:
438
-
439
-
440
-
441
- /*実部*/
442
-
443
- float a;
444
-
445
-
446
-
447
- /*虚部*/
448
-
449
- // Position<type> v;
450
-
451
- Position v;
452
-
453
-
454
-
455
- Quaternion(float aa, Position vv);
456
-
457
-
458
-
459
- static Quaternion mul(Quaternion a, Quaternion b);//掛け算
460
-
461
-
462
-
463
-
464
-
465
-
466
-
467
- };
468
-
469
-
470
-
471
-
472
-
473
- #endif
474
-
475
- ```

9

文章を再度追加

2020/04/06 11:32

投稿

退会済みユーザー
test CHANGED
File without changes
test CHANGED
@@ -4,6 +4,10 @@
4
4
 
5
5
 
6
6
 
7
+ 質問ですが"回転軸ベクトル"とは何をすれば算出されるのでしょうか?
8
+
9
+
10
+
7
11
  症状は 実行時に上下に動かすと見事にクォータニオンしてくれますが左右に動いたあとrotate();関数が実行されてその後
8
12
 
9
13
  上下に動かすとその**空間座標?を中心にくるくる回ってしまい**周回軌道のようなモン〇ンのカメラのような動作をしてくれません

8

タイトルと文章を編集しました。

2020/04/06 08:27

投稿

退会済みユーザー
test CHANGED
@@ -1 +1 @@
1
- クォータニオンによるカメラ回転を実装したが上手く動作しない原因が知りたい。
1
+ クォータニオンによるカメラ回転を実装したが上手く動作しない原因が知りたい。回転前と後で動作が違う
test CHANGED
@@ -1,8 +1,12 @@
1
1
  X軸回転の関数ですが Y軸とZ軸の数値が上がり下がりしますが上手く周回してくれず、あと一歩のところで上手く回転できません
2
2
 
3
- これは何を間違えたのでしょうか? 提示画像2枚目の左上カメラ座標
3
+ これは何を間違えたのでしょうか?
4
+
5
+
6
+
4
-
7
+ 症状は 実行時に上下に動かすと見事にクォータニオンしてくれますが左右に動いたあとrotate();関数が実行されてその後
8
+
5
- ※Update();でってもやっても一定場所まで近くりそ動作がおかいです。
9
+ 上下に動かすとその**空間座標?を中心にくるくる回ってしまい**周回軌道ようモン〇ンカメラのような動作てくれません
6
10
 
7
11
 
8
12
 
@@ -88,6 +92,42 @@
88
92
 
89
93
 
90
94
 
95
+
96
+
97
+
98
+
99
+ /* 一次変換 (x,y)の点を(mx,my)を中心にang角回転する */
100
+
101
+ void rotate(float* x, float* y, const float ang, const float mx, const float my)
102
+
103
+ {
104
+
105
+
106
+
107
+ const float ox = *x - mx, oy = *y - my;
108
+
109
+ *x = (ox * cos(ang)) + (oy * sin(ang));
110
+
111
+ *y = (-ox * sin(ang)) + (oy * cos(ang));
112
+
113
+
114
+
115
+ *x += mx;
116
+
117
+ *y += my;
118
+
119
+
120
+
121
+
122
+
123
+ }
124
+
125
+
126
+
127
+
128
+
129
+
130
+
91
131
  void Game::Update()
92
132
 
93
133
  {

7

タイトルを編集しました。

2020/04/06 01:39

投稿

退会済みユーザー
test CHANGED
@@ -1 +1 @@
1
- ゲーム数学 クォータニオンによるカメラ回転を実装したが上手く動作しない原因が知りたい。
1
+ クォータニオンによるカメラ回転を実装したが上手く動作しない原因が知りたい。
test CHANGED
File without changes

6

画像と提示コードと文章を再度編集しました。

2020/04/05 10:17

投稿

退会済みユーザー
test CHANGED
@@ -1 +1 @@
1
- ゲーム数学 クォータニオンによるカメラ回転を実装したが上手く動作しない原因が知りたい。
1
+ ゲーム数学 クォータニオンによるカメラ回転を実装したが上手く動作しない原因が知りたい。
test CHANGED
@@ -1,16 +1,20 @@
1
- X軸回転の関数ですが Y軸とZ軸の数値が上がり下がりしますがどんでもない大きさになってまってあと一歩のところで上手く回転できません
1
+ X軸回転の関数ですが Y軸とZ軸の数値が上がり下がりしますが上手く周回してくれず、あと一歩のところで上手く回転できません
2
2
 
3
3
  これは何を間違えたのでしょうか? 提示画像2枚目の左上カメラ座標
4
4
 
5
-
5
+ ※Update();で上、下どってもやっても一定の場所まで近くなりその後動作がおかしいです。
6
-
7
-
8
-
9
-
10
-
6
+
7
+
8
+
9
+
10
+
11
+
12
+
11
- ![イメージ説明](8e016f366f8322640a0b03384251ba06.png)
13
+ ![イメージ説明](7036df702c017099eb73b3deb642844a.png)
12
-
14
+
13
- ![イメージ説明](ac50cc4c1c91a8c673f00546cfc73e19.png)
15
+ ![イメージ説明](0ea179463c2bbfeebdcaa870c57fcabe.png)
16
+
17
+
14
18
 
15
19
  参考サイト1 : http://marupeke296.com/DXG_No10_Quaternion.html
16
20
 
@@ -20,6 +24,10 @@
20
24
 
21
25
 
22
26
 
27
+
28
+
29
+ 以下rotete_x();関数部です。引数にカメラ座標と注視点座標とラジアンを入れて回転させる予定
30
+
23
31
  ```ここに言語を入力
24
32
 
25
33
  /*X軸回転*/
@@ -30,11 +38,31 @@
30
38
 
31
39
 
32
40
 
33
- //Quaternion P(0, Position(*x - mx, *y - my, *z - mz));//回転させる点
41
+ // Quaternion Prev(0, Position(*x - mx, *y - my, *z - mz));//回転させる点
34
42
 
35
43
  Quaternion P(0,Position(*x, *y, *z));//回転させる点
36
44
 
45
+ //Position v(-5, 0, 0);//回転させる軸
46
+
47
+ MATRIX t = MGetRotX(ang);//回転させる軸
48
+
49
+
50
+
51
+ VECTOR v2;
52
+
53
+
54
+
55
+ v2.x = *x;
56
+
57
+ v2.y = *y;
58
+
59
+ v2.z = *z;
60
+
61
+
62
+
63
+ VECTOR v = VTransform(v2,t);
64
+
37
- Position v(ang,0,0);//回転させる軸
65
+ //Position v(ang,0,0);//回転させる軸
38
66
 
39
67
 
40
68
 
@@ -52,9 +80,77 @@
52
80
 
53
81
  *x = result.v.x;
54
82
 
55
- *y = result.v.y;
83
+ *y = result.v.y;
56
-
84
+
57
- *z = result.v.z;
85
+ *z = result.v.z;
86
+
87
+ }
88
+
89
+
90
+
91
+ void Game::Update()
92
+
93
+ {
94
+
95
+ /*カメラ回転*/
96
+
97
+ if (Input::keyboard(KEY_INPUT_LEFT) > 0)
98
+
99
+ {
100
+
101
+ rotate(&cameraX, &cameraZ, +ROTATE_SPEED, targetX, targetZ);
102
+
103
+ }
104
+
105
+ else if (Input::keyboard(KEY_INPUT_RIGHT) > 0)
106
+
107
+ {
108
+
109
+ rotate(&cameraX, &cameraZ, -ROTATE_SPEED, targetX, targetZ);
110
+
111
+ }
112
+
113
+ else if (Input::keyboard(KEY_INPUT_UP) > 0)
114
+
115
+ {
116
+
117
+ rotate_X(&cameraX, &cameraY,&cameraZ, -ROTATE_SPEED, targetX, targetY,targetZ);
118
+
119
+ DrawFormatString(100,100,GetColor(255,255,255),"UP");
120
+
121
+
122
+
123
+ }
124
+
125
+ else if (Input::keyboard(KEY_INPUT_DOWN) > 0)
126
+
127
+ {
128
+
129
+ rotate_X(&cameraX, &cameraY, &cameraZ, +ROTATE_SPEED, targetX, targetY, targetZ);
130
+
131
+ DrawFormatString(100, 100, GetColor(255, 255, 255), "Down");
132
+
133
+
134
+
135
+ }
136
+
137
+ if (Input::keyboard(KEY_INPUT_W) > 0)
138
+
139
+ {
140
+
141
+
142
+
143
+ }
144
+
145
+ else if (Input::keyboard(KEY_INPUT_S) > 0)
146
+
147
+ {
148
+
149
+
150
+
151
+ }
152
+
153
+
58
154
 
59
155
  }
60
156
 
@@ -66,6 +162,158 @@
66
162
 
67
163
  ```ここに言語を入力
68
164
 
165
+ #include "Position.hpp"
166
+
167
+
168
+
169
+ /*クォータニオン*/
170
+
171
+
172
+
173
+ Quaternion::Quaternion(float aa,Position vv)
174
+
175
+ {
176
+
177
+ a = aa;
178
+
179
+
180
+
181
+ v.x = vv.x;
182
+
183
+ v.y = vv.y;
184
+
185
+ v.z = vv.z;
186
+
187
+ }
188
+
189
+
190
+
191
+ Quaternion Quaternion::mul(Quaternion a, Quaternion b)
192
+
193
+ {
194
+
195
+ return Quaternion(a.a * b.a - Position::dot(a.v,b.v),
196
+
197
+ Position::Add(Position::mul(a.a ,b.v) , Position::mul(b.a , a.v) , Position::cross(a.v,b.v)));
198
+
199
+ }
200
+
201
+
202
+
203
+
204
+
205
+
206
+
207
+
208
+
209
+
210
+
211
+ /*ベクトル x スカラー*/
212
+
213
+ Position Position::mul(float a, Position v)
214
+
215
+ {
216
+
217
+ return Position(a * v.x,a * v.y,a * v.z);
218
+
219
+ }
220
+
221
+
222
+
223
+ /*ベクトルの足し算*/
224
+
225
+ Position Position::Add(Position a,Position b,Position c)
226
+
227
+ {
228
+
229
+ return Position(a.x + b.x + c.x, a.y + b.y + c.y,a.z + b.z + c.z);
230
+
231
+
232
+
233
+ }
234
+
235
+
236
+
237
+ /*外積 ベクトル x ベクトル*/
238
+
239
+ Position Position::cross(Position a,Position b)
240
+
241
+ {
242
+
243
+ return Position( (a.y * b.z) - (a.z * b.y),
244
+
245
+ (a.z * b.x) - (a.x * b.z),
246
+
247
+ (a.x * b.y) - (a.y * b.x));
248
+
249
+
250
+
251
+ }
252
+
253
+
254
+
255
+ /*内積*/
256
+
257
+ float Position::dot(Position a, Position b)
258
+
259
+ {
260
+
261
+ return (a.x * b.x) + (a.y * b.y) + (a.z * a.z);
262
+
263
+ }
264
+
265
+
266
+
267
+ /*座標系*/
268
+
269
+
270
+
271
+ //template<typename type>
272
+
273
+ Position::Position(float xx,float yy,float zz)
274
+
275
+ {
276
+
277
+ x = xx;
278
+
279
+ y = yy;
280
+
281
+ z = zz;
282
+
283
+ }
284
+
285
+
286
+
287
+
288
+
289
+
290
+
291
+ //template<typename type>
292
+
293
+ Position::Position()
294
+
295
+ {
296
+
297
+ x = 0.0f;
298
+
299
+ y = 0.0f;
300
+
301
+ z = 0.0f;
302
+
303
+ }
304
+
305
+
306
+
307
+
308
+
309
+ ```
310
+
311
+
312
+
313
+ ソースファイル
314
+
315
+ ```ここに言語を入力
316
+
69
317
  #ifndef ___POSITION_H
70
318
 
71
319
  #define ___POSITION_H
@@ -82,6 +330,12 @@
82
330
 
83
331
 
84
332
 
333
+
334
+
335
+
336
+
337
+
338
+
85
339
  public:
86
340
 
87
341
  float x;
@@ -98,6 +352,12 @@
98
352
 
99
353
 
100
354
 
355
+
356
+
357
+
358
+
359
+
360
+
101
361
  static Position cross(Position a, Position b);//外積
102
362
 
103
363
  static float dot(Position a, Position b);//内積
@@ -110,6 +370,16 @@
110
370
 
111
371
 
112
372
 
373
+
374
+
375
+
376
+
377
+
378
+
379
+
380
+
381
+
382
+
113
383
  };
114
384
 
115
385
 
@@ -154,150 +424,8 @@
154
424
 
155
425
 
156
426
 
427
+
428
+
157
429
  #endif
158
430
 
159
431
  ```
160
-
161
-
162
-
163
- ソースファイル
164
-
165
- ```ここに言語を入力
166
-
167
- #include "Position.hpp"
168
-
169
-
170
-
171
- /*クォータニオン*/
172
-
173
-
174
-
175
- Quaternion::Quaternion(float aa,Position vv)
176
-
177
- {
178
-
179
- a = aa;
180
-
181
-
182
-
183
- v.x = vv.x;
184
-
185
- v.y = vv.y;
186
-
187
- v.z = vv.z;
188
-
189
- }
190
-
191
-
192
-
193
- Quaternion Quaternion::mul(Quaternion a, Quaternion b)
194
-
195
- {
196
-
197
- return Quaternion(a.a + b.a - Position::dot(a.v,b.v), Position::Add(Position::mul(a.a ,b.v) , Position::mul(b.a , a.v) , Position::cross(a.v,b.v)));
198
-
199
- }
200
-
201
-
202
-
203
-
204
-
205
-
206
-
207
-
208
-
209
-
210
-
211
- /*ベクトル x スカラー*/
212
-
213
- Position Position::mul(float a, Position v)
214
-
215
- {
216
-
217
- return Position(a * v.x,a * v.y,a * v.z);
218
-
219
- }
220
-
221
-
222
-
223
- Position Position::Add(Position a,Position b,Position c)
224
-
225
- {
226
-
227
- return Position(a.x + b.x + c.x, a.y + b.y + c.y,a.z + b.z + c.z);
228
-
229
-
230
-
231
- }
232
-
233
-
234
-
235
- /*外積*/
236
-
237
- Position Position::cross(Position a,Position b)
238
-
239
- {
240
-
241
- return Position(a.y * b.y - b.y * a.z,
242
-
243
- (-1) * (a.x * b.z - b.x * a.z),
244
-
245
- a.x * b.y - b.x * a.y);
246
-
247
- }
248
-
249
-
250
-
251
- /*内積*/
252
-
253
- float Position::dot(Position a, Position b)
254
-
255
- {
256
-
257
- return (a.x * b.x) + (a.y * b.y) + (a.z * a.z);
258
-
259
- }
260
-
261
-
262
-
263
- /*座標系*/
264
-
265
-
266
-
267
- //template<typename type>
268
-
269
- Position::Position(float xx,float yy,float zz)
270
-
271
- {
272
-
273
- x = xx;
274
-
275
- y = yy;
276
-
277
- z = zz;
278
-
279
- }
280
-
281
-
282
-
283
-
284
-
285
-
286
-
287
- //template<typename type>
288
-
289
- Position::Position()
290
-
291
- {
292
-
293
- x = 0.0f;
294
-
295
- y = 0.0f;
296
-
297
- z = 0.0f;
298
-
299
- }
300
-
301
-
302
-
303
- ```

5

タイトルと文章を編集しました。

2020/04/05 05:14

投稿

退会済みユーザー
test CHANGED
@@ -1 +1 @@
1
- ゲーム数学 クォータニオン * クォータニオンの計算方法が知りたい。
1
+ ゲーム数学 クォータニオンによるカメラ回転を実装した上手く動作しない原因が知りたい。
test CHANGED
@@ -1,24 +1,16 @@
1
- 質問1、X軸回転のrotate_x();関数部の最後のR * P *Q;部の計算ですがプログラム上ではどう計算すればのでしょうか?
1
+ X軸回転の関数ですが Y軸とZ軸の数値ががり下がりしますがどんもな大きさになってしまってあと一歩ところ上手く回転できません
2
-
3
- 数式では参考サイト1より出ています。
2
+
4
-
5
- 質問、またベクトルxスカラーの計算方法も知りたいです。
3
+ これは何を間違えたのでしょうか? 提示画像枚目の左上座標
6
-
7
-
8
-
9
-
10
-
11
- ※数学ライブラリ関数すらでこないので質問しました。
4
+
12
-
13
-
14
-
15
-
16
-
17
-
18
-
19
-
20
-
5
+
6
+
7
+
8
+
9
+
10
+
21
- ![イメージ説明](43d3313a961c7f604126434b11730cc5.png)
11
+ ![イメージ説明](8e016f366f8322640a0b03384251ba06.png)
12
+
13
+ ![イメージ説明](ac50cc4c1c91a8c673f00546cfc73e19.png)
22
14
 
23
15
  参考サイト1 : http://marupeke296.com/DXG_No10_Quaternion.html
24
16
 
@@ -30,38 +22,282 @@
30
22
 
31
23
  ```ここに言語を入力
32
24
 
33
- #include "DxLib.h"
34
-
35
-
36
-
37
25
  /*X軸回転*/
38
26
 
39
- //カメラ座標、ラジアン、中心座標(画像の正方形ポリゴン)
40
-
41
- void rotate_X(float *x,float *y,float *z,const float ang, const float mx,const float my,const float mz)
27
+ void Game::rotate_X(float *x,float *y,float *z,const float ang, const float mx,const float my,const float mz)
42
-
28
+
43
- {
29
+ {
44
-
45
-
46
-
30
+
31
+
32
+
47
- Quaternion<float> P(0,*x - mx,*y - my,*z - mz);//回転させる点
33
+ //Quaternion P(0, Position(*x - mx, *y - my, *z - mz));//回転させる点
34
+
48
-
35
+ Quaternion P(0,Position(*x, *y, *z));//回転させる点
36
+
49
- Position<float> v(1,0,0);//回転させる軸
37
+ Position v(ang,0,0);//回転させる軸
50
-
51
-
52
-
38
+
39
+
40
+
53
- Quaternion<float> Q(cos(ang / 2), v.x * sin(ang / 2), v.y * sin(ang / 2), v.z * sin(ang / 2));
41
+ Quaternion Q(cos(ang / 2), Position(v.x * sin(ang / 2), v.y * sin(ang / 2), v.z * sin(ang / 2)));
54
-
42
+
55
- Quaternion<float> R(cos(ang / 2),-v.x * sin(ang / 2) , -v.y * sin(ang / 2), -v.z * sin(ang / 2));
43
+ Quaternion R(cos(ang / 2), Position(-v.x * sin(ang / 2) , -v.y * sin(ang / 2), -v.z * sin(ang / 2)));
56
-
57
-
58
-
44
+
45
+
46
+
59
- Quaternion<float> result = R * Q * P;
47
+ Quaternion r = Quaternion::mul(R , Q);
48
+
60
-
49
+ Quaternion result = Quaternion::mul(r , P);
50
+
51
+
52
+
61
-
53
+ *x = result.v.x;
54
+
62
-
55
+ *y = result.v.y;
56
+
57
+ *z = result.v.z;
58
+
63
- }
59
+ }
64
-
65
-
66
60
 
67
61
  ```
62
+
63
+
64
+
65
+ ヘッダー部
66
+
67
+ ```ここに言語を入力
68
+
69
+ #ifndef ___POSITION_H
70
+
71
+ #define ___POSITION_H
72
+
73
+
74
+
75
+ //template<typename type>
76
+
77
+ class Position
78
+
79
+ {
80
+
81
+ private:
82
+
83
+
84
+
85
+ public:
86
+
87
+ float x;
88
+
89
+ float y;
90
+
91
+ float z;
92
+
93
+
94
+
95
+ Position(float xx, float yy, float zz);
96
+
97
+ Position();
98
+
99
+
100
+
101
+ static Position cross(Position a, Position b);//外積
102
+
103
+ static float dot(Position a, Position b);//内積
104
+
105
+
106
+
107
+ static Position mul(float a, Position v);
108
+
109
+ static Position Add(Position a, Position b, Position c);
110
+
111
+
112
+
113
+ };
114
+
115
+
116
+
117
+ //template<typename type>
118
+
119
+ class Quaternion
120
+
121
+ {
122
+
123
+ public:
124
+
125
+
126
+
127
+ /*実部*/
128
+
129
+ float a;
130
+
131
+
132
+
133
+ /*虚部*/
134
+
135
+ // Position<type> v;
136
+
137
+ Position v;
138
+
139
+
140
+
141
+ Quaternion(float aa, Position vv);
142
+
143
+
144
+
145
+ static Quaternion mul(Quaternion a, Quaternion b);//掛け算
146
+
147
+
148
+
149
+
150
+
151
+
152
+
153
+ };
154
+
155
+
156
+
157
+ #endif
158
+
159
+ ```
160
+
161
+
162
+
163
+ ソースファイル
164
+
165
+ ```ここに言語を入力
166
+
167
+ #include "Position.hpp"
168
+
169
+
170
+
171
+ /*クォータニオン*/
172
+
173
+
174
+
175
+ Quaternion::Quaternion(float aa,Position vv)
176
+
177
+ {
178
+
179
+ a = aa;
180
+
181
+
182
+
183
+ v.x = vv.x;
184
+
185
+ v.y = vv.y;
186
+
187
+ v.z = vv.z;
188
+
189
+ }
190
+
191
+
192
+
193
+ Quaternion Quaternion::mul(Quaternion a, Quaternion b)
194
+
195
+ {
196
+
197
+ return Quaternion(a.a + b.a - Position::dot(a.v,b.v), Position::Add(Position::mul(a.a ,b.v) , Position::mul(b.a , a.v) , Position::cross(a.v,b.v)));
198
+
199
+ }
200
+
201
+
202
+
203
+
204
+
205
+
206
+
207
+
208
+
209
+
210
+
211
+ /*ベクトル x スカラー*/
212
+
213
+ Position Position::mul(float a, Position v)
214
+
215
+ {
216
+
217
+ return Position(a * v.x,a * v.y,a * v.z);
218
+
219
+ }
220
+
221
+
222
+
223
+ Position Position::Add(Position a,Position b,Position c)
224
+
225
+ {
226
+
227
+ return Position(a.x + b.x + c.x, a.y + b.y + c.y,a.z + b.z + c.z);
228
+
229
+
230
+
231
+ }
232
+
233
+
234
+
235
+ /*外積*/
236
+
237
+ Position Position::cross(Position a,Position b)
238
+
239
+ {
240
+
241
+ return Position(a.y * b.y - b.y * a.z,
242
+
243
+ (-1) * (a.x * b.z - b.x * a.z),
244
+
245
+ a.x * b.y - b.x * a.y);
246
+
247
+ }
248
+
249
+
250
+
251
+ /*内積*/
252
+
253
+ float Position::dot(Position a, Position b)
254
+
255
+ {
256
+
257
+ return (a.x * b.x) + (a.y * b.y) + (a.z * a.z);
258
+
259
+ }
260
+
261
+
262
+
263
+ /*座標系*/
264
+
265
+
266
+
267
+ //template<typename type>
268
+
269
+ Position::Position(float xx,float yy,float zz)
270
+
271
+ {
272
+
273
+ x = xx;
274
+
275
+ y = yy;
276
+
277
+ z = zz;
278
+
279
+ }
280
+
281
+
282
+
283
+
284
+
285
+
286
+
287
+ //template<typename type>
288
+
289
+ Position::Position()
290
+
291
+ {
292
+
293
+ x = 0.0f;
294
+
295
+ y = 0.0f;
296
+
297
+ z = 0.0f;
298
+
299
+ }
300
+
301
+
302
+
303
+ ```

4

文章を編集しました。

2020/04/04 12:46

投稿

退会済みユーザー
test CHANGED
@@ -1 +1 @@
1
- ゲーム数学と数学の違いが知りたい。クォータニオン 内積と外積
1
+ ゲーム数学 クォータニオン * クォータニオンの計算方法が知りたい。
test CHANGED
@@ -1,30 +1,20 @@
1
- 参考サイト2の3番の数式を使ってある点を中心にカメラをX軸回転させる(上下)のですがクォータニオンを使えばいいと思ったすが
1
+ 質問1、X軸回転のrotate_x();関数部最後のR * P *Q;部の計算ですがプログラム上ではどう計算すればいいのでしょうか?
2
2
 
3
- P = (0; xp, yp, zp)=(0; Vp)動か点なのでカメラ座標を入れる?
3
+ 数式で参考サイト1より出ていま
4
4
 
5
- v = (xv, yv, zv)のコードは1,0,0としてX軸の方向を表せばいい?
6
-
7
-
8
-
9
- Q = (cos(θ/2); xv・sin(θ/2), yv・sin(θ/2), zv・sin(θ/2))
10
-
11
- R = (cos(θ/2); -xv・sin(θ/2), -yv・sin(θ/2), -zv・sin(θ/2))
12
-
13
- 二つの式の ・ はドット積ですが単純な掛け算でしょうか?
5
+ 質問2、またベクトルxスカラー計算方法も知りたいです
14
-
15
-
16
-
17
- 最後の式は掛け算とありますが参考サイト1のクォータニオンの基礎の掛け算でベクトルの内積、外積の計算を調べましたがどうすればいいのでしょうか?Q1 * Q2のサンプルのようにやると結果が一つになってしまうので最後のx,y,zの座標が作れない気がするのですが?
18
-
19
-
20
-
21
- R*P*Q = (0; x, y, z)
22
6
 
23
7
 
24
8
 
25
9
 
26
10
 
27
- そもそも**ある点を中心にカメをX軸回転させる(上下)**処理はれで実現できるのでしょうか?
11
+ ※数学イブラリ関数すらでないので質問ました。
12
+
13
+
14
+
15
+
16
+
17
+
28
18
 
29
19
 
30
20
 

3

文章とタイトルを編集しました。

2020/04/04 11:37

投稿

退会済みユーザー
test CHANGED
@@ -1 +1 @@
1
- 中心点を中心にカメラ回転するクォータニオンを使えばいいのか?
1
+ ゲーム数学と数学の違いが知りたい。クォータニオン 内積と外積
test CHANGED
@@ -1,8 +1,26 @@
1
- 参考サイトの番の数式を使ってある点を中心にカメラをX軸回転させる(上下)なのですがクォータニオンを使えばいいと思ったののですが
1
+ 参考サイト23番の数式を使ってある点を中心にカメラをX軸回転させる(上下)なのですがクォータニオンを使えばいいと思ったののですが
2
2
 
3
- P = (0; xp, yp, zp)=(0; Vp)はしょうか
3
+ P = (0; xp, yp, zp)=(0; Vp)は動かす点なのでカメラ座標を入れる
4
4
 
5
- 二番目のv = (xv, yv, zv)のコードは1,0,0としてX軸の方向を表せばいいと思います。
5
+ v = (xv, yv, zv)のコードは1,0,0としてX軸の方向を表せばいい
6
+
7
+
8
+
9
+ Q = (cos(θ/2); xv・sin(θ/2), yv・sin(θ/2), zv・sin(θ/2))
10
+
11
+ R = (cos(θ/2); -xv・sin(θ/2), -yv・sin(θ/2), -zv・sin(θ/2))
12
+
13
+ この二つの式の ・ はドット積ですが単純な掛け算でしょうか?
14
+
15
+
16
+
17
+ 最後の式は掛け算とありますが参考サイト1のクォータニオンの基礎の掛け算でベクトルの内積、外積の計算を調べましたがどうすればいいのでしょうか?Q1 * Q2のサンプルのようにやると結果が一つになってしまうので最後のx,y,zの座標が作れない気がするのですが?
18
+
19
+
20
+
21
+ R*P*Q = (0; x, y, z)
22
+
23
+
6
24
 
7
25
 
8
26
 
@@ -12,7 +30,13 @@
12
30
 
13
31
  ![イメージ説明](43d3313a961c7f604126434b11730cc5.png)
14
32
 
15
- 参考サイト: http://marupeke296.com/DXG_No10_Quaternion.html
33
+ 参考サイト1 : http://marupeke296.com/DXG_No10_Quaternion.html
34
+
35
+ 参考サイト2 : http://marupeke296.com/COL_Basic_No1_InnerAndOuterProduct.html
36
+
37
+ 参考サイト3 :https://home.hiroshima-u.ac.jp/kyoshida/MathExercise/2015(1stSemester)/exercise1(no03).pdf
38
+
39
+
16
40
 
17
41
  ```ここに言語を入力
18
42
 
@@ -20,383 +44,29 @@
20
44
 
21
45
 
22
46
 
23
- #include "Game.hpp"
47
+ /*X軸回転*/
24
48
 
25
- #include "Input.hpp"
49
+ //カメラ座標、ラジアン、中心座標(画像の正方形ポリゴン)
26
50
 
27
- #include "Frame.hpp"
51
+ void rotate_X(float *x,float *y,float *z,const float ang, const float mx,const float my,const float mz)
28
-
29
-
30
-
31
-
32
-
33
-
34
-
35
- Game::Game()
36
52
 
37
53
  {
38
54
 
39
55
 
40
56
 
57
+ Quaternion<float> P(0,*x - mx,*y - my,*z - mz);//回転させる点
58
+
41
- SetUseLighting(true);
59
+ Position<float> v(1,0,0);//回転させる軸
42
60
 
43
61
 
44
62
 
45
- SetUseZBuffer3D(true);
63
+ Quaternion<float> Q(cos(ang / 2), v.x * sin(ang / 2), v.y * sin(ang / 2), v.z * sin(ang / 2));
46
64
 
47
- SetWriteZBuffer3D(true);
65
+ Quaternion<float> R(cos(ang / 2),-v.x * sin(ang / 2) , -v.y * sin(ang / 2), -v.z * sin(ang / 2));
48
66
 
49
67
 
50
68
 
51
- /*手前*/
52
-
53
- Vertex[0].pos = VGet(-RANGE, RANGE, 10);
54
-
55
- Vertex[0].norm = VGet(0.0f, 0.0f, -1.0f);
56
-
57
- Vertex[0].dif = color_dif;
58
-
59
- Vertex[0].spc = color_spc;
60
-
61
- Vertex[0].u = 0.0f;
62
-
63
- Vertex[0].v = 0.0f;
64
-
65
- Vertex[0].su = 0.0f;
66
-
67
- Vertex[0].sv = 0.0f;
68
-
69
-
70
-
71
- Vertex[1].pos = VGet(RANGE, RANGE, 10);
72
-
73
- Vertex[1].norm = VGet(0.0f, 0.0f, -1.0f);
74
-
75
- Vertex[1].dif = color_dif;
76
-
77
- Vertex[1].spc = color_spc;
78
-
79
- Vertex[1].u = 1.0f;
80
-
81
- Vertex[1].v = 0.0f;
82
-
83
- Vertex[1].su = 0.0f;
84
-
85
- Vertex[1].sv = 0.0f;
86
-
87
-
88
-
89
- Vertex[2].pos = VGet(-RANGE, -RANGE, 10);
69
+ Quaternion<float> result = R * Q * P;
90
-
91
- Vertex[2].norm = VGet(0.0f, 0.0f, -1.0f);
92
-
93
- Vertex[2].dif = color_dif;
94
-
95
- Vertex[2].spc = color_spc;
96
-
97
- Vertex[2].u = 0.0f;
98
-
99
- Vertex[2].v = 1.0f;
100
-
101
- Vertex[2].su = 0.0f;
102
-
103
- Vertex[2].sv = 0.0f;
104
-
105
-
106
-
107
- Vertex[3].pos = VGet(RANGE, -RANGE, 10);
108
-
109
- Vertex[3].norm = VGet(0.0f, 0.0f, -1.0f);
110
-
111
- Vertex[3].dif = color_dif;
112
-
113
- Vertex[3].spc = color_spc;
114
-
115
- Vertex[3].u = 1.0f;
116
-
117
- Vertex[3].v = 1.0f;
118
-
119
- Vertex[3].su = 0.0f;
120
-
121
- Vertex[3].sv = 0.0f;
122
-
123
-
124
-
125
- /*奥*/
126
-
127
- Vertex[4].pos = VGet(-RANGE, RANGE, 10 + RANGE);
128
-
129
- Vertex[4].norm = VGet(0.0f, 0.0f, -1.0f);
130
-
131
- Vertex[4].dif = color_dif;
132
-
133
- Vertex[4].spc = color_spc;
134
-
135
- Vertex[4].u = 0.0f;
136
-
137
- Vertex[4].v = 0.0f;
138
-
139
- Vertex[4].su = 0.0f;
140
-
141
- Vertex[4].sv = 0.0f;
142
-
143
-
144
-
145
- Vertex[5].pos = VGet(RANGE, RANGE, 10 + RANGE);
146
-
147
- Vertex[5].norm = VGet(0.0f, 0.0f, -1.0f);
148
-
149
- Vertex[5].dif = color_dif;
150
-
151
- Vertex[5].spc = color_spc;
152
-
153
- Vertex[5].u = 1.0f;
154
-
155
- Vertex[5].v = 0.0f;
156
-
157
- Vertex[5].su = 0.0f;
158
-
159
- Vertex[5].sv = 0.0f;
160
-
161
-
162
-
163
- Vertex[6].pos = VGet(-RANGE, -RANGE, 10 + RANGE);
164
-
165
- Vertex[6].norm = VGet(0.0f, 0.0f, -1.0f);
166
-
167
- Vertex[6].dif = color_dif;
168
-
169
- Vertex[6].spc = color_spc;
170
-
171
- Vertex[6].u = 0.0f;
172
-
173
- Vertex[6].v = 1.0f;
174
-
175
- Vertex[6].su = 0.0f;
176
-
177
- Vertex[6].sv = 0.0f;
178
-
179
-
180
-
181
- Vertex[7].pos = VGet(RANGE, -RANGE, 10 + RANGE);
182
-
183
- Vertex[7].norm = VGet(0.0f, 0.0f, -1.0f);
184
-
185
- Vertex[7].dif = color_dif;
186
-
187
- Vertex[7].spc = color_spc;
188
-
189
- Vertex[7].u = 1.0f;
190
-
191
- Vertex[7].v = 1.0f;
192
-
193
- Vertex[7].su = 0.0f;
194
-
195
- Vertex[7].sv = 0.0f;
196
-
197
- #define GROUND_Z 200
198
-
199
- #define GROUND_X 200
200
-
201
-
202
-
203
- /*地面 ポリゴン*/
204
-
205
- Ground_Vertex[0].pos = VGet( -RANGE * GROUND_X, -RANGE * 2, RANGE * GROUND_Z);
206
-
207
- Ground_Vertex[0].norm = VGet(0.0f, 0.0f, -1.0f);
208
-
209
- Ground_Vertex[0].dif = color_dif;
210
-
211
- Ground_Vertex[0].spc = color_spc;
212
-
213
- Ground_Vertex[0].u = 0.0f;
214
-
215
- Ground_Vertex[0].v = 0.0f;
216
-
217
-
218
-
219
- Ground_Vertex[1].pos = VGet(RANGE * GROUND_X, -RANGE * 2, RANGE * GROUND_Z);
220
-
221
- Ground_Vertex[1].norm = VGet(0.0f, 0.0f, -1.0f);
222
-
223
- Ground_Vertex[1].dif = color_dif;
224
-
225
- Ground_Vertex[1].spc = color_spc;
226
-
227
- Ground_Vertex[1].u = 1.0f;
228
-
229
- Ground_Vertex[1].v = 0.0f;
230
-
231
-
232
-
233
- Ground_Vertex[2].pos = VGet(-RANGE * GROUND_X, -RANGE * 2, GROUND_Z * -RANGE);
234
-
235
- Ground_Vertex[2].norm = VGet(0.0f, 0.0f, -1.0f);
236
-
237
- Ground_Vertex[2].dif = color_dif;
238
-
239
- Ground_Vertex[2].spc = color_spc;
240
-
241
- Ground_Vertex[2].u = 0.0f;
242
-
243
- Ground_Vertex[2].v = 1.0f;
244
-
245
-
246
-
247
- Ground_Vertex[3].pos = VGet(RANGE * GROUND_X, -RANGE * 2, GROUND_Z * -RANGE);
248
-
249
- Ground_Vertex[3].norm = VGet(0.0f, 0.0f, -1.0f);
250
-
251
- Ground_Vertex[3].dif = color_dif;
252
-
253
- Ground_Vertex[3].spc = color_spc;
254
-
255
- Ground_Vertex[3].u = 1.0f;
256
-
257
- Ground_Vertex[3].v = 1.0f;
258
-
259
-
260
-
261
- /*地面インデックス*/
262
-
263
- Ground_Index[0] = 0;
264
-
265
- Ground_Index[1] = 1;
266
-
267
- Ground_Index[2] = 2;
268
-
269
-
270
-
271
- Ground_Index[3] = 1;
272
-
273
- Ground_Index[4] = 2;
274
-
275
- Ground_Index[5] = 3;
276
-
277
-
278
-
279
-
280
-
281
-
282
-
283
- /*手前*/
284
-
285
- Index[0][0] = 0;
286
-
287
- Index[0][1] = 1;
288
-
289
- Index[0][2] = 2;
290
-
291
-
292
-
293
- Index[0][3] = 1;
294
-
295
- Index[0][4] = 2;
296
-
297
- Index[0][5] = 3;
298
-
299
-
300
-
301
- /*奥*/
302
-
303
- Index[1][0] = 4;
304
-
305
- Index[1][1] = 5;
306
-
307
- Index[1][2] = 6;
308
-
309
-
310
-
311
- Index[1][3] = 6;
312
-
313
- Index[1][4] = 5;
314
-
315
- Index[1][5] = 7;
316
-
317
-
318
-
319
- /*左*/
320
-
321
- Index[2][0] = 0;
322
-
323
- Index[2][1] = 4;
324
-
325
- Index[2][2] = 2;
326
-
327
-
328
-
329
- Index[2][3] = 4;
330
-
331
- Index[2][4] = 2;
332
-
333
- Index[2][5] = 6;
334
-
335
-
336
-
337
-
338
-
339
- /*右*/
340
-
341
- Index[3][0] = 1;
342
-
343
- Index[3][1] = 5;
344
-
345
- Index[3][2] = 7;
346
-
347
-
348
-
349
- Index[3][3] = 1;
350
-
351
- Index[3][4] = 3;
352
-
353
- Index[3][5] = 7;
354
-
355
-
356
-
357
-
358
-
359
-
360
-
361
-
362
-
363
- /*上*/
364
-
365
- Index[4][0] = 0;
366
-
367
- Index[4][1] = 4;
368
-
369
- Index[4][2] = 5;
370
-
371
-
372
-
373
- Index[4][3] = 0;
374
-
375
- Index[4][4] = 1;
376
-
377
- Index[4][5] = 5;
378
-
379
-
380
-
381
-
382
-
383
- /*下*/
384
-
385
- Index[5][0] = 6;
386
-
387
- Index[5][1] = 7;
388
-
389
- Index[5][2] = 2;
390
-
391
-
392
-
393
- Index[5][3] = 3;
394
-
395
- Index[5][4] = 7;
396
-
397
- Index[5][5] = 2;
398
-
399
-
400
70
 
401
71
 
402
72
 
@@ -404,636 +74,4 @@
404
74
 
405
75
 
406
76
 
407
-
408
-
409
- /* (x,y)の点を(mx,my)を中心にang角回転する */
410
-
411
- void rotate(float* x, float* y, const float ang, const float mx, const float my)
412
-
413
- {
414
-
415
-
416
-
417
- const float ox = *x - mx, oy = *y - my;
418
-
419
- *x = (ox * cos(ang)) + (oy * sin(ang));
420
-
421
- *y = (-ox * sin(ang)) + (oy * cos(ang));
422
-
423
-
424
-
425
- *x += mx;
426
-
427
- *y += my;
428
-
429
-
430
-
431
-
432
-
433
- }
434
-
435
-
436
-
437
- /*X軸回転*/
438
-
439
- void rotate_X(float *y,float *z,const float ang,const float my,const float mz)
440
-
441
- {
442
-
443
- const float oy = *y - my;
444
-
445
- const float oz = *z - mz;
446
-
447
-
448
-
449
- *y = (oy * cos(ang)) + (oz * sin(ang));
450
-
451
- *z = (-oy * sin(ang)) + (oz * cos(ang));
452
-
453
-
454
-
455
- *y += my;
456
-
457
- *z += mz;
458
-
459
-
460
-
461
-
462
-
463
- }
464
-
465
-
466
-
467
- void Game::Update()
468
-
469
- {
470
-
471
- /*カメラ回転*/
472
-
473
- if (Input::keyboard(KEY_INPUT_LEFT) > 0)
474
-
475
- {
476
-
477
- rotate(&cameraX, &cameraZ, +ROTATE_SPEED, targetX, targetZ);
478
-
479
- }
480
-
481
- else if (Input::keyboard(KEY_INPUT_RIGHT) > 0)
482
-
483
- {
484
-
485
- rotate(&cameraX, &cameraZ, -ROTATE_SPEED, targetX, targetZ);
486
-
487
- }
488
-
489
- else if (Input::keyboard(KEY_INPUT_UP) > 0)
490
-
491
- {
492
-
493
- rotate_X(&cameraY, &cameraZ, -ROTATE_SPEED, targetY, targetZ);
494
-
495
- }
496
-
497
- else if (Input::keyboard(KEY_INPUT_DOWN) > 0)
498
-
499
- {
500
-
501
- rotate_X(&cameraY, &cameraZ, +ROTATE_SPEED, targetY, targetZ);
502
-
503
- }
504
-
505
- if (Input::keyboard(KEY_INPUT_W) > 0)
506
-
507
- {
508
-
509
-
510
-
511
- }
512
-
513
- else if (Input::keyboard(KEY_INPUT_S) > 0)
514
-
515
- {
516
-
517
-
518
-
519
- }
520
-
521
-
522
-
523
-
524
-
525
- /*色 変更*/
526
-
527
- if(Input::keyboard(KEY_INPUT_SPACE) == 1)
528
-
529
- {
530
-
531
- ModeChange = !ModeChange;
532
-
533
- }
534
-
535
- /* false spcカラーを変更*/
536
-
537
- if (Input::keyboard(KEY_INPUT_Z) > 0 && ModeChange == false)
538
-
539
- {
540
-
541
- color_spc.r += -1;
542
-
543
- color_spc.g += -1;
544
-
545
- color_spc.b += -1;
546
-
547
-
548
-
549
- }
550
-
551
- else if (Input::keyboard(KEY_INPUT_X) > 0 && ModeChange == false)
552
-
553
- {
554
-
555
- color_spc.r += 1;
556
-
557
- color_spc.g += 1;
558
-
559
- color_spc.b += 1;
560
-
561
-
562
-
563
- /*true difカラー変更*/
564
-
565
- }else if (Input::keyboard(KEY_INPUT_Z) > 0 && ModeChange == true)
566
-
567
- {
568
-
569
- color_dif.r += -1;
570
-
571
- color_dif.g += -1;
572
-
573
- color_dif.b += -1;
574
-
575
-
576
-
577
- }
578
-
579
- else if (Input::keyboard(KEY_INPUT_X) > 0 && ModeChange == true)
580
-
581
- {
582
-
583
- color_dif.r += 1;
584
-
585
- color_dif.g += 1;
586
-
587
- color_dif.b += 1;
588
-
589
-
590
-
591
- }
592
-
593
-
594
-
595
- if (Input::keyboard(KEY_INPUT_F1) == 1)
596
-
597
- {
598
-
599
- TextureMode = !TextureMode;
600
-
601
- }
602
-
603
-
604
-
605
-
606
-
607
- const int num = 4;
608
-
609
-
610
-
611
-
612
-
613
-
614
-
615
-
616
-
617
-
618
-
619
- }
620
-
621
- VECTOR v;
622
-
623
-
624
-
625
-
626
-
627
-
628
-
629
- //45,48
630
-
631
-
632
-
633
- void Game::DrawUpdate()
634
-
635
- {
636
-
637
- SetCameraPositionAndTarget_UpVecY(VGet(cameraX, cameraY, cameraZ), VGet(targetX, targetY, targetZ));
638
-
639
-
640
-
641
-
642
-
643
-
644
-
645
- for(int i = 0; i< 8; i++)
646
-
647
- {
648
-
649
- Vertex[i].dif = color_dif;
650
-
651
- Vertex[i].spc = color_spc;
652
-
653
-
654
-
655
- }
656
-
657
-
658
-
659
-
660
-
661
-
662
-
663
- int handle = LoadGraph("assets/resource/texturePos.png",false);
664
-
665
-
666
-
667
- for(int i =0 ;i < 6; i++){
668
-
669
-
670
-
671
- switch( i )
672
-
673
- {
674
-
675
- case 0:
676
-
677
- {
678
-
679
- Vertex[ 0 ].u = 0.0f;
680
-
681
- Vertex[ 0 ].v = 0.0f;
682
-
683
-
684
-
685
- Vertex[ 1 ].u = 1.0f;
686
-
687
- Vertex[ 1 ].v = 0.0f;
688
-
689
-
690
-
691
- Vertex[ 2 ].u = 0.0f;
692
-
693
- Vertex[ 2 ].v = 1.0f;
694
-
695
-
696
-
697
- Vertex[ 3 ].u = 1.0f;
698
-
699
- Vertex[ 3 ].v = 1.0f;
700
-
701
-
702
-
703
- Vertex[ 4 ].u = 1.0f;
704
-
705
- Vertex[ 4 ].v = 1.0f;
706
-
707
-
708
-
709
- Vertex[ 5 ].u = 0.0f;
710
-
711
- Vertex[ 5 ].v = 0.0f;
712
-
713
-
714
-
715
- Vertex[ 6 ].u = 0.0f;
716
-
717
- Vertex[ 6 ].v = 0.0f;
718
-
719
-
720
-
721
- Vertex[ 7 ].u = 0.0f;
722
-
723
- Vertex[ 7 ].v = 0.0f;
724
-
725
- }
726
-
727
- break;
728
-
729
-
730
-
731
-
732
-
733
- case 1:
734
-
735
- {
736
-
737
- Vertex[0].u = 0.0f;
738
-
739
- Vertex[0].v = 0.0f;
740
-
741
-
742
-
743
- Vertex[1].u = 1.0f;
744
-
745
- Vertex[1].v = 0.0f;
746
-
747
-
748
-
749
- Vertex[2].u = 0.0f;
750
-
751
- Vertex[2].v = 1.0f;
752
-
753
-
754
-
755
- Vertex[3].u = 0.0f;
756
-
757
- Vertex[3].v = 0.0f;
758
-
759
-
760
-
761
- Vertex[4].u = 0.0f;
762
-
763
- Vertex[4].v = 0.0f;
764
-
765
-
766
-
767
- Vertex[5].u = 1.0f;
768
-
769
- Vertex[5].v = 0.0f;
770
-
771
-
772
-
773
- Vertex[6].u = 0.0f;
774
-
775
- Vertex[6].v = 1.0f;
776
-
777
-
778
-
779
- Vertex[7].u = 1.0f;
780
-
781
- Vertex[7].v = 1.0f;
782
-
783
-
784
-
785
- }
786
-
787
- break;
788
-
789
-
790
-
791
-
792
-
793
- case 2:
794
-
795
- {
796
-
797
-
798
-
799
- Vertex[0].u = 1.0f;
800
-
801
- Vertex[0].v = 0.0f;
802
-
803
-
804
-
805
- Vertex[1].u = 1.0f;
806
-
807
- Vertex[1].v = 0.0f;
808
-
809
-
810
-
811
- Vertex[2].u = 1.0f;
812
-
813
- Vertex[2].v = 1.0f;
814
-
815
-
816
-
817
- Vertex[3].u = 0.0f;
818
-
819
- Vertex[3].v = 0.0f;
820
-
821
-
822
-
823
-
824
-
825
-
826
-
827
- Vertex[4].u = 0.0f;
828
-
829
- Vertex[4].v = 0.0f;
830
-
831
-
832
-
833
- Vertex[5].u = 0.0f;
834
-
835
- Vertex[5].v = 1.0f;
836
-
837
-
838
-
839
- Vertex[6].u = 0.0f;
840
-
841
- Vertex[6].v = 1.0f;
842
-
843
-
844
-
845
- Vertex[7].u = 1.0f;
846
-
847
- Vertex[7].v = 1.0f;
848
-
849
-
850
-
851
- }
852
-
853
- break;
854
-
855
-
856
-
857
- /*右*/
858
-
859
- case 3:
860
-
861
- {
862
-
863
-
864
-
865
- Vertex[0].u = 1.0f;
866
-
867
- Vertex[0].v = 0.0f;
868
-
869
-
870
-
871
- Vertex[1].u = 0.0f;
872
-
873
- Vertex[1].v = 0.0f;
874
-
875
-
876
-
877
- Vertex[2].u = 1.0f;
878
-
879
- Vertex[2].v = 1.0f;
880
-
881
-
882
-
883
- Vertex[3].u = 0.0f;
884
-
885
- Vertex[3].v = 1.0f;
886
-
887
-
888
-
889
-
890
-
891
-
892
-
893
- Vertex[4].u = 0.0f;
894
-
895
- Vertex[4].v = 0.0f;
896
-
897
-
898
-
899
- Vertex[5].u = 1.0f;
900
-
901
- Vertex[5].v = 0.0f;
902
-
903
-
904
-
905
- Vertex[6].u = 0.0f;
906
-
907
- Vertex[6].v = 1.0f;
908
-
909
-
910
-
911
- Vertex[7].u = 1.0f;
912
-
913
- Vertex[7].v = 1.0f;
914
-
915
-
916
-
917
- }
918
-
919
- break;
920
-
921
-
922
-
923
-
924
-
925
- /*上*/
926
-
927
- case 4:
928
-
929
- {
930
-
931
-
932
-
933
- Vertex[0].u = 0.0f;
934
-
935
- Vertex[0].v = 0.0f;
936
-
937
-
938
-
939
- Vertex[1].u = 0.0f;
940
-
941
- Vertex[1].v = 1.0f;
942
-
943
-
944
-
945
- Vertex[4].u = 1.0f;
946
-
947
- Vertex[4].v = 0.0f;
948
-
949
-
950
-
951
- Vertex[5].u = 1.0f;
952
-
953
- Vertex[5].v = 1.0f;
954
-
955
-
956
-
957
- }
958
-
959
- break;
960
-
961
-
962
-
963
-
964
-
965
- /*下*/
966
-
967
- case 5:
968
-
969
- {
970
-
971
-
972
-
973
- Vertex[2].u = 0.0f;
974
-
975
- Vertex[2].v = 1.0f;
976
-
977
-
978
-
979
- Vertex[3].u = 1.0f;
980
-
981
- Vertex[3].v = 1.0f;
982
-
983
-
984
-
985
- Vertex[6].u = 0.0f;
986
-
987
- Vertex[6].v = 0.0f;
988
-
989
-
990
-
991
- Vertex[7].u = 1.0f;
992
-
993
- Vertex[7].v = 0.0f;
994
-
995
- }
996
-
997
- break;
998
-
999
- }
1000
-
1001
- if(TextureMode == true){
1002
-
1003
- DrawPolygonIndexed3D(Vertex, 8, Index[i], 2, handle, false);
1004
-
1005
- }else{
1006
-
1007
- DrawPolygonIndexed3D(Vertex, 8, Index[i], 2, DX_NONE_GRAPH, false);
1008
-
1009
- }
1010
-
1011
- }
1012
-
1013
-
1014
-
1015
- DrawPolygonIndexed3D(Ground_Vertex,4,Ground_Index,6,handle,false);
1016
-
1017
-
1018
-
1019
- // cameraY += -1;
1020
-
1021
-
1022
-
1023
-
1024
-
1025
- DrawFormatString(0, 0, GetColor(255, 255, 255), "カメラ座標 x: %.2f , y: %.2f , z:%.2f ", cameraX,cameraY,cameraZ);
1026
-
1027
- // DrawFormatString(0, 40, Get color;(255, 255, 255), " test x: %.2f z: %.2f", xx, zz);
1028
-
1029
-
1030
-
1031
-
1032
-
1033
-
1034
-
1035
-
1036
-
1037
- }
1038
-
1039
77
  ```

2

タイトルを文章を編集しました。

2020/04/04 06:29

投稿

退会済みユーザー
test CHANGED
@@ -1 +1 @@
1
- 中心点を中心にカメラ回転する回転式を使っても上手くできな下人が知りた
1
+ 中心点を中心にカメラ回転するクォータニオンを使えばいいのか?
test CHANGED
@@ -1,22 +1,18 @@
1
- カメラX軸回転させて正方形ポリゴンの下の貼ってあるポリゴンを見ようとしたのですが十字キの上押し続けるその場所にぐるぐる回てしまい上手く中心点を中心に回ってくれませんこれは何が原因なのでしょうか? void rotate_X();関数部で
1
+ 参考サイトの②番の数式を使ってある点を中心にカメラX軸回転させる(上下)なのですがクォタニオン使えばいいです
2
-
2
+
3
- 実行た時の座標のままだと正常に回ります。参考サイトのX軸周りの回転一番上の式
3
+ P = (0; xp, yp, zp)=(0; Vp)ははなんの値でょうか?
4
-
5
-
6
-
7
-
8
-
4
+
9
- 参考サイト:http://www.f.waseda.jp/moriya/PUBLIC_HTML/education/classes/infomath6/applet/fractal/coord/
5
+ 二番目のv = (xv, yv, zv)のコードは1,0,0としてX軸の方向を表せばいいと思います。
6
+
7
+
8
+
10
-
9
+ そもそも**ある点を中心にカメラをX軸回転させる(上下)**処理はこれで実現できるのでしょうか?
11
-
12
-
13
-
14
-
10
+
11
+
12
+
15
- ![イメージ説明](15429c92478bb10d229a1250417eb5e2.png)
13
+ ![イメージ説明](43d3313a961c7f604126434b11730cc5.png)
16
-
14
+
17
- ![メージ説明](dc2fec7bf579290f3eccf5ac66deb182.png)
15
+ 参考サト: http://marupeke296.com/DXG_No10_Quaternion.html
18
-
19
-
20
16
 
21
17
  ```ここに言語を入力
22
18
 
@@ -198,6 +194,86 @@
198
194
 
199
195
  Vertex[7].sv = 0.0f;
200
196
 
197
+ #define GROUND_Z 200
198
+
199
+ #define GROUND_X 200
200
+
201
+
202
+
203
+ /*地面 ポリゴン*/
204
+
205
+ Ground_Vertex[0].pos = VGet( -RANGE * GROUND_X, -RANGE * 2, RANGE * GROUND_Z);
206
+
207
+ Ground_Vertex[0].norm = VGet(0.0f, 0.0f, -1.0f);
208
+
209
+ Ground_Vertex[0].dif = color_dif;
210
+
211
+ Ground_Vertex[0].spc = color_spc;
212
+
213
+ Ground_Vertex[0].u = 0.0f;
214
+
215
+ Ground_Vertex[0].v = 0.0f;
216
+
217
+
218
+
219
+ Ground_Vertex[1].pos = VGet(RANGE * GROUND_X, -RANGE * 2, RANGE * GROUND_Z);
220
+
221
+ Ground_Vertex[1].norm = VGet(0.0f, 0.0f, -1.0f);
222
+
223
+ Ground_Vertex[1].dif = color_dif;
224
+
225
+ Ground_Vertex[1].spc = color_spc;
226
+
227
+ Ground_Vertex[1].u = 1.0f;
228
+
229
+ Ground_Vertex[1].v = 0.0f;
230
+
231
+
232
+
233
+ Ground_Vertex[2].pos = VGet(-RANGE * GROUND_X, -RANGE * 2, GROUND_Z * -RANGE);
234
+
235
+ Ground_Vertex[2].norm = VGet(0.0f, 0.0f, -1.0f);
236
+
237
+ Ground_Vertex[2].dif = color_dif;
238
+
239
+ Ground_Vertex[2].spc = color_spc;
240
+
241
+ Ground_Vertex[2].u = 0.0f;
242
+
243
+ Ground_Vertex[2].v = 1.0f;
244
+
245
+
246
+
247
+ Ground_Vertex[3].pos = VGet(RANGE * GROUND_X, -RANGE * 2, GROUND_Z * -RANGE);
248
+
249
+ Ground_Vertex[3].norm = VGet(0.0f, 0.0f, -1.0f);
250
+
251
+ Ground_Vertex[3].dif = color_dif;
252
+
253
+ Ground_Vertex[3].spc = color_spc;
254
+
255
+ Ground_Vertex[3].u = 1.0f;
256
+
257
+ Ground_Vertex[3].v = 1.0f;
258
+
259
+
260
+
261
+ /*地面インデックス*/
262
+
263
+ Ground_Index[0] = 0;
264
+
265
+ Ground_Index[1] = 1;
266
+
267
+ Ground_Index[2] = 2;
268
+
269
+
270
+
271
+ Ground_Index[3] = 1;
272
+
273
+ Ground_Index[4] = 2;
274
+
275
+ Ground_Index[5] = 3;
276
+
201
277
 
202
278
 
203
279
 
@@ -378,7 +454,7 @@
378
454
 
379
455
  *y += my;
380
456
 
381
- *z += mz;
457
+ *z += mz;
382
458
 
383
459
 
384
460
 
@@ -430,7 +506,7 @@
430
506
 
431
507
  {
432
508
 
433
- cameraZ += -4;
509
+
434
510
 
435
511
  }
436
512
 
@@ -438,7 +514,7 @@
438
514
 
439
515
  {
440
516
 
441
- y -= 2;
517
+
442
518
 
443
519
  }
444
520
 
@@ -516,7 +592,13 @@
516
592
 
517
593
 
518
594
 
519
-
595
+ if (Input::keyboard(KEY_INPUT_F1) == 1)
596
+
597
+ {
598
+
599
+ TextureMode = !TextureMode;
600
+
601
+ }
520
602
 
521
603
 
522
604
 
@@ -552,7 +634,7 @@
552
634
 
553
635
  {
554
636
 
555
- SetCameraPositionAndTarget_UpVecY(VGet(cameraX, cameraY, cameraZ), VGet(targetX, targetZ, targetZ));
637
+ SetCameraPositionAndTarget_UpVecY(VGet(cameraX, cameraY, cameraZ), VGet(targetX, targetY, targetZ));
556
638
 
557
639
 
558
640
 
@@ -640,16 +722,6 @@
640
722
 
641
723
  Vertex[ 7 ].v = 0.0f;
642
724
 
643
-
644
-
645
-
646
-
647
-
648
-
649
-
650
-
651
- DrawPolygonIndexed3D(Vertex, 8, Index[i], 2, handle, false);
652
-
653
725
  }
654
726
 
655
727
  break;
@@ -660,19 +732,241 @@
660
732
 
661
733
  case 1:
662
734
 
735
+ {
736
+
737
+ Vertex[0].u = 0.0f;
738
+
739
+ Vertex[0].v = 0.0f;
740
+
741
+
742
+
743
+ Vertex[1].u = 1.0f;
744
+
745
+ Vertex[1].v = 0.0f;
746
+
747
+
748
+
749
+ Vertex[2].u = 0.0f;
750
+
751
+ Vertex[2].v = 1.0f;
752
+
753
+
754
+
755
+ Vertex[3].u = 0.0f;
756
+
757
+ Vertex[3].v = 0.0f;
758
+
759
+
760
+
761
+ Vertex[4].u = 0.0f;
762
+
763
+ Vertex[4].v = 0.0f;
764
+
765
+
766
+
767
+ Vertex[5].u = 1.0f;
768
+
769
+ Vertex[5].v = 0.0f;
770
+
771
+
772
+
773
+ Vertex[6].u = 0.0f;
774
+
775
+ Vertex[6].v = 1.0f;
776
+
777
+
778
+
779
+ Vertex[7].u = 1.0f;
780
+
781
+ Vertex[7].v = 1.0f;
782
+
783
+
784
+
785
+ }
786
+
787
+ break;
788
+
789
+
790
+
791
+
792
+
793
+ case 2:
794
+
663
795
  {
664
796
 
797
+
798
+
799
+ Vertex[0].u = 1.0f;
800
+
801
+ Vertex[0].v = 0.0f;
802
+
803
+
804
+
805
+ Vertex[1].u = 1.0f;
806
+
807
+ Vertex[1].v = 0.0f;
808
+
809
+
810
+
811
+ Vertex[2].u = 1.0f;
812
+
813
+ Vertex[2].v = 1.0f;
814
+
815
+
816
+
817
+ Vertex[3].u = 0.0f;
818
+
819
+ Vertex[3].v = 0.0f;
820
+
821
+
822
+
823
+
824
+
825
+
826
+
827
+ Vertex[4].u = 0.0f;
828
+
829
+ Vertex[4].v = 0.0f;
830
+
831
+
832
+
833
+ Vertex[5].u = 0.0f;
834
+
835
+ Vertex[5].v = 1.0f;
836
+
837
+
838
+
839
+ Vertex[6].u = 0.0f;
840
+
841
+ Vertex[6].v = 1.0f;
842
+
843
+
844
+
845
+ Vertex[7].u = 1.0f;
846
+
847
+ Vertex[7].v = 1.0f;
848
+
849
+
850
+
851
+ }
852
+
853
+ break;
854
+
855
+
856
+
857
+ /*右*/
858
+
859
+ case 3:
860
+
861
+ {
862
+
863
+
864
+
865
+ Vertex[0].u = 1.0f;
866
+
867
+ Vertex[0].v = 0.0f;
868
+
869
+
870
+
871
+ Vertex[1].u = 0.0f;
872
+
873
+ Vertex[1].v = 0.0f;
874
+
875
+
876
+
877
+ Vertex[2].u = 1.0f;
878
+
879
+ Vertex[2].v = 1.0f;
880
+
881
+
882
+
883
+ Vertex[3].u = 0.0f;
884
+
885
+ Vertex[3].v = 1.0f;
886
+
887
+
888
+
889
+
890
+
891
+
892
+
893
+ Vertex[4].u = 0.0f;
894
+
895
+ Vertex[4].v = 0.0f;
896
+
897
+
898
+
899
+ Vertex[5].u = 1.0f;
900
+
901
+ Vertex[5].v = 0.0f;
902
+
903
+
904
+
905
+ Vertex[6].u = 0.0f;
906
+
907
+ Vertex[6].v = 1.0f;
908
+
909
+
910
+
911
+ Vertex[7].u = 1.0f;
912
+
913
+ Vertex[7].v = 1.0f;
914
+
915
+
916
+
917
+ }
918
+
919
+ break;
920
+
921
+
922
+
923
+
924
+
925
+ /*上*/
926
+
927
+ case 4:
928
+
929
+ {
930
+
931
+
932
+
933
+ Vertex[0].u = 0.0f;
934
+
935
+ Vertex[0].v = 0.0f;
936
+
937
+
938
+
939
+ Vertex[1].u = 0.0f;
940
+
941
+ Vertex[1].v = 1.0f;
942
+
665
943
 
666
944
 
667
- Vertex[0].u = 0.0f;
945
+ Vertex[4].u = 1.0f;
668
-
946
+
669
- Vertex[0].v = 0.0f;
947
+ Vertex[4].v = 0.0f;
670
-
671
-
672
-
948
+
949
+
950
+
673
- Vertex[1].u = 1.0f;
951
+ Vertex[5].u = 1.0f;
674
-
952
+
675
- Vertex[1].v = 0.0f;
953
+ Vertex[5].v = 1.0f;
954
+
955
+
956
+
957
+ }
958
+
959
+ break;
960
+
961
+
962
+
963
+
964
+
965
+ /*下*/
966
+
967
+ case 5:
968
+
969
+ {
676
970
 
677
971
 
678
972
 
@@ -682,342 +976,60 @@
682
976
 
683
977
 
684
978
 
685
- Vertex[3].u = 0.0f;
979
+ Vertex[3].u = 1.0f;
686
-
980
+
687
- Vertex[3].v = 0.0f;
981
+ Vertex[3].v = 1.0f;
688
-
689
-
690
-
691
-
692
-
693
-
694
-
695
- Vertex[4].u = 0.0f;
696
-
697
- Vertex[4].v = 0.0f;
698
-
699
-
700
-
701
- Vertex[5].u = 1.0f;
702
-
703
- Vertex[5].v = 0.0f;
704
982
 
705
983
 
706
984
 
707
985
  Vertex[6].u = 0.0f;
708
986
 
709
- Vertex[6].v = 1.0f;
987
+ Vertex[6].v = 0.0f;
710
988
 
711
989
 
712
990
 
713
991
  Vertex[7].u = 1.0f;
714
992
 
715
- Vertex[7].v = 1.0f;
993
+ Vertex[7].v = 0.0f;
716
-
717
-
718
-
719
- DrawPolygonIndexed3D(Vertex, 8, Index[i], 2, handle, false);
720
-
721
-
722
994
 
723
995
  }
724
996
 
725
997
  break;
726
998
 
727
-
728
-
729
-
730
-
731
- case 2:
732
-
733
- {
734
-
735
-
736
-
737
- Vertex[0].u = 1.0f;
738
-
739
- Vertex[0].v = 0.0f;
740
-
741
-
742
-
743
- Vertex[1].u = 1.0f;
744
-
745
- Vertex[1].v = 0.0f;
746
-
747
-
748
-
749
- Vertex[2].u = 1.0f;
750
-
751
- Vertex[2].v = 1.0f;
752
-
753
-
754
-
755
- Vertex[3].u = 0.0f;
756
-
757
- Vertex[3].v = 0.0f;
758
-
759
-
760
-
761
-
762
-
763
-
764
-
765
- Vertex[4].u = 0.0f;
766
-
767
- Vertex[4].v = 0.0f;
768
-
769
-
770
-
771
- Vertex[5].u = 0.0f;
772
-
773
- Vertex[5].v = 1.0f;
774
-
775
-
776
-
777
- Vertex[6].u = 0.0f;
778
-
779
- Vertex[6].v = 1.0f;
780
-
781
-
782
-
783
- Vertex[7].u = 1.0f;
784
-
785
- Vertex[7].v = 1.0f;
786
-
787
-
788
-
789
- DrawPolygonIndexed3D(Vertex, 8, Index[i], 2, handle, false);
790
-
791
-
792
-
793
- }
794
-
795
- break;
796
-
797
-
798
-
799
- /*右*/
800
-
801
- case 3:
802
-
803
- {
804
-
805
-
806
-
807
- Vertex[0].u = 1.0f;
808
-
809
- Vertex[0].v = 0.0f;
810
-
811
-
812
-
813
- Vertex[1].u = 0.0f;
814
-
815
- Vertex[1].v = 0.0f;
816
-
817
-
818
-
819
- Vertex[2].u = 1.0f;
820
-
821
- Vertex[2].v = 1.0f;
822
-
823
-
824
-
825
- Vertex[3].u = 0.0f;
826
-
827
- Vertex[3].v = 1.0f;
828
-
829
-
830
-
831
-
832
-
833
-
834
-
835
- Vertex[4].u = 0.0f;
836
-
837
- Vertex[4].v = 0.0f;
838
-
839
-
840
-
841
- Vertex[5].u = 1.0f;
842
-
843
- Vertex[5].v = 0.0f;
844
-
845
-
846
-
847
- Vertex[6].u = 0.0f;
848
-
849
- Vertex[6].v = 1.0f;
850
-
851
-
852
-
853
- Vertex[7].u = 1.0f;
854
-
855
- Vertex[7].v = 1.0f;
856
-
857
-
858
-
859
- DrawPolygonIndexed3D(Vertex, 8, Index[i], 2, handle, false);
860
-
861
-
862
-
863
- }
864
-
865
- break;
866
-
867
-
868
-
869
-
870
-
871
- /*上*/
872
-
873
- case 4:
874
-
875
- {
876
-
877
-
878
-
879
- Vertex[0].u = 0.0f;
880
-
881
- Vertex[0].v = 0.0f;
882
-
883
-
884
-
885
- Vertex[1].u = 0.0f;
886
-
887
- Vertex[1].v = 1.0f;
888
-
889
-
890
-
891
- Vertex[4].u = 1.0f;
892
-
893
- Vertex[4].v = 0.0f;
894
-
895
-
896
-
897
- Vertex[5].u = 1.0f;
898
-
899
- Vertex[5].v = 1.0f;
900
-
901
-
902
-
903
-
904
-
905
-
906
-
907
- DrawPolygonIndexed3D(Vertex, 8, Index[i], 2, handle, false);
908
-
909
-
910
-
911
- }
912
-
913
- break;
914
-
915
-
916
-
917
-
918
-
919
- /*下*/
920
-
921
- case 5:
922
-
923
- {
924
-
925
-
926
-
927
- Vertex[2].u = 0.0f;
928
-
929
- Vertex[2].v = 1.0f;
930
-
931
-
932
-
933
- Vertex[3].u = 1.0f;
934
-
935
- Vertex[3].v = 1.0f;
936
-
937
-
938
-
939
- Vertex[6].u = 0.0f;
940
-
941
- Vertex[6].v = 0.0f;
942
-
943
-
944
-
945
- Vertex[7].u = 1.0f;
946
-
947
- Vertex[7].v = 0.0f;
948
-
949
-
950
-
951
-
952
-
953
-
954
-
955
- DrawPolygonIndexed3D(Vertex, 8, Index[i], 2, handle, false);
956
-
957
-
958
-
959
- }
960
-
961
- break;
962
-
963
-
964
-
965
-
966
-
967
999
  }
968
1000
 
969
-
1001
+ if(TextureMode == true){
1002
+
970
-
1003
+ DrawPolygonIndexed3D(Vertex, 8, Index[i], 2, handle, false);
1004
+
1005
+ }else{
1006
+
1007
+ DrawPolygonIndexed3D(Vertex, 8, Index[i], 2, DX_NONE_GRAPH, false);
1008
+
971
- }
1009
+ }
1010
+
1011
+ }
1012
+
1013
+
1014
+
1015
+ DrawPolygonIndexed3D(Ground_Vertex,4,Ground_Index,6,handle,false);
1016
+
1017
+
1018
+
1019
+ // cameraY += -1;
1020
+
1021
+
1022
+
1023
+
1024
+
1025
+ DrawFormatString(0, 0, GetColor(255, 255, 255), "カメラ座標 x: %.2f , y: %.2f , z:%.2f ", cameraX,cameraY,cameraZ);
1026
+
1027
+ // DrawFormatString(0, 40, Get color;(255, 255, 255), " test x: %.2f z: %.2f", xx, zz);
972
1028
 
973
1029
 
974
1030
 
975
1031
 
976
1032
 
977
-
978
-
979
-
980
-
981
-
982
-
983
-
984
-
985
- DrawFormatString(0, 0, GetColor(255, 255, 255), "x: %.2f , y: %.2f , z:%.2f ", cameraX,cameraY,cameraZ);
986
-
987
- // DrawFormatString(0, 40, Get color;(255, 255, 255), " test x: %.2f z: %.2f", xx, zz);
988
-
989
-
990
-
991
- if(ModeChange == false){
992
-
993
- DrawFormatString(0, 32 * 5, GetColor(255, 255, 255), "Mode: spc ");
994
-
995
-
996
-
997
- DrawFormatString(0, 32 * 1, GetColor(255, 255, 255), "color_spc.r: %d", color_spc.r);
998
-
999
- DrawFormatString(0, 32 * 2, GetColor(255, 255, 255), "color_spc.g: %d", color_spc.g);
1000
-
1001
- DrawFormatString(0, 32 * 3, GetColor(255, 255, 255), "color_spc.b: %d", color_spc.b);
1002
-
1003
- }else
1004
-
1005
- {
1006
-
1007
- DrawFormatString(0, 32 * 5, GetColor(255, 255, 255), "Mode: dif ");
1008
-
1009
-
1010
-
1011
- DrawFormatString(0, 32 * 1, GetColor(255, 255, 255), "color_dif.r: %d", color_dif.r);
1012
-
1013
- DrawFormatString(0, 32 * 2, GetColor(255, 255, 255), "color_dif.g: %d", color_dif.g);
1014
-
1015
- DrawFormatString(0, 32 * 3, GetColor(255, 255, 255), "color_dif.b: %d", color_dif.b);
1016
-
1017
-
1018
-
1019
- }
1020
-
1021
1033
 
1022
1034
 
1023
1035
 

1

タイトルを編集しました。

2020/04/04 01:38

投稿

退会済みユーザー
test CHANGED
@@ -1 +1 @@
1
- カメラ回転で注視点が悪か,回転悪いのか?,そう見えるだけなのか?知りたい
1
+ 中心点を中心にカメラ回転する回転式を使っても上手くきな下人が知りたい
test CHANGED
File without changes