Normand Briere
2019-04-22 4a5b9e0b9ecc97203d4089ca0cd0d6df8c76bf1c
CameraPane.java
....@@ -31,8 +31,12 @@
3131
3232 import gleem.linalg.Mat4f;
3333
34
-class CameraPane extends GLCanvas implements Runnable, GLEventListener, ActionListener, MouseWheelListener, MouseMotionListener, MouseListener, KeyListener
34
+class CameraPane extends GLCanvas implements iCameraPane, Runnable, GLEventListener, ActionListener, MouseWheelListener, MouseMotionListener, MouseListener, KeyListener
3535 {
36
+ static cMaterial[] materialstack = new cMaterial[65536];
37
+ static boolean[] selectedstack = new boolean[65536];
38
+ static int materialdepth = 0;
39
+
3640 static boolean DEBUG = false;
3741 static boolean FRUSTUM = false; // still bogus true; // frustum culling
3842
....@@ -42,25 +46,7 @@
4246
4347 static int STEP = 1;
4448
45
- static boolean ONESTEP = false; // do LIVE once
46
-
47
- /**
48
- * @return the LIVE
49
- */
50
- public static boolean isLIVE()
51
- {
52
- return LIVE || ONESTEP;
53
- }
54
-
55
- /**
56
- * @param aLIVE the LIVE to set
57
- */
58
- public static void setLIVE(boolean aLIVE)
59
- {
60
- LIVE = aLIVE;
61
- }
62
-
63
- /*static*/ boolean CULLFACE = false; // true;
49
+ /*static*/ private boolean CULLFACE = false; // true;
6450 /*static*/ boolean NEAREST = false; // true;
6551 /*static*/ boolean WIREFRAME = false; // true;
6652
....@@ -97,10 +83,8 @@
9783
9884 static boolean textureon = true;
9985 static boolean LOCALTRANSFORM = false;
100
-private static boolean LIVE = false;
10186 static boolean FULLSCREEN = false;
10287 static boolean SUPPORT = true;
103
-static boolean CROWD = false;
10488 static boolean INERTIA = true;
10589 static boolean FAST = false;
10690 static boolean SLOWPOSE = false;
....@@ -165,12 +149,39 @@
165149 defaultcaps.setAccumBlueBits(16);
166150 defaultcaps.setAccumAlphaBits(16);
167151 }
168
- static CameraPane theRenderer;
169
-
152
+
170153 void SetAsGLRenderer(boolean b)
171154 {
172155 isRenderer = b;
173
- theRenderer = this;
156
+ Globals.theRenderer = this;
157
+ }
158
+
159
+ CameraPane(Object3D o, Camera cam, boolean withcontext)
160
+ {
161
+ super(defaultcaps, null, withcontext?glcontext:null, null);
162
+
163
+ //System.out.println("AMERICA AREA = " + (9458886 + 9210755 + 8480395 + 2736391 + 1943018 + 1289475 + 1141569 + 1069350 + 911559 + 721229 + 395886 + 377972 + 246700 + 211156 + 173985 + 141133 + 118279 + 112079 + 108523));
164
+ glcontext = getContext();
165
+
166
+ cameras = new Camera[2];
167
+ targetLookAts = new cVector[2];
168
+
169
+ SetCamera(cam);
170
+
171
+ SetLight(new Camera(new cVector(10, 10, -20)));
172
+
173
+ object = o;
174
+
175
+ setBackground(Color.white);
176
+
177
+ addKeyListener(this);
178
+ addMouseListener(this);
179
+ addMouseMotionListener(this);
180
+ addMouseWheelListener(this);
181
+ //System.out.println("addGLEventListener: " + this);
182
+ addGLEventListener(this);
183
+
184
+// pingthread.start(); // may 2013
174185 }
175186
176187 static boolean AntialiasingEnabled()
....@@ -178,12 +189,19 @@
178189 return CURRENTANTIALIAS > 0;
179190 }
180191
181
- void ClearDepth()
192
+ /// INTERFACE
193
+
194
+ public boolean IsBoxMode()
195
+ {
196
+ return BOXMODE;
197
+ }
198
+
199
+ public void ClearDepth()
182200 {
183201 GetGL().glClear(GetGL().GL_DEPTH_BUFFER_BIT);
184202 }
185203
186
- void DepthTest(boolean depthtest)
204
+ public void DepthTest(boolean depthtest)
187205 {
188206 if (depthtest)
189207 GetGL().glDepthFunc(GL.GL_LEQUAL);
....@@ -191,7 +209,7 @@
191209 GetGL().glDepthFunc(GL.GL_ALWAYS);
192210 }
193211
194
- void DepthWrite(boolean depthwrite)
212
+ public void DepthWrite(boolean depthwrite)
195213 {
196214 if (depthwrite)
197215 GetGL().glDepthMask(true);
....@@ -199,12 +217,1265 @@
199217 GetGL().glDepthMask(false);
200218 }
201219
202
- void BackFaceCull(boolean bfc)
220
+ public void BackFaceCull(boolean bfc)
203221 {
204222 if (bfc)
205223 GetGL().glEnable(GetGL().GL_CULL_FACE);
206224 else
207225 GetGL().glDisable(GetGL().GL_CULL_FACE);
226
+ }
227
+
228
+ public boolean BackFaceCullMode()
229
+ {
230
+ return this.CULLFACE;
231
+ }
232
+
233
+ public boolean IsAmbientOcclusionOn()
234
+ {
235
+ return this.ambientOcclusion;
236
+ }
237
+
238
+ public boolean IsDebugSelection()
239
+ {
240
+ return DEBUG_SELECTION;
241
+ }
242
+
243
+ public boolean IsFrozen()
244
+ {
245
+ boolean selectmode = this.DrawMode() == SELECTION || this.IsDebugSelection();
246
+
247
+ return !selectmode && cameracount == 0; // != 0;
248
+ }
249
+
250
+ // Currently in Globals
251
+ public int DrawMode()
252
+ {
253
+ return Globals.DrawMode();
254
+ }
255
+
256
+ public Camera EyeCamera()
257
+ {
258
+ return eyeCamera;
259
+ }
260
+
261
+ public Camera LightCamera()
262
+ {
263
+ return lightCamera;
264
+ }
265
+
266
+ public Camera ManipCamera()
267
+ {
268
+ return manipCamera;
269
+ }
270
+
271
+ public Camera RenderCamera()
272
+ {
273
+ return renderCamera;
274
+ }
275
+
276
+ public Camera[] Cameras()
277
+ {
278
+ return cameras;
279
+ }
280
+
281
+ public void PushMaterial(Object3D obj, boolean selected)
282
+ {
283
+ CameraPane display = this;
284
+ javax.media.opengl.GL gl = display.GetGL();
285
+ cMaterial material = obj.material;
286
+
287
+ if (material != null)
288
+ {
289
+ materialstack[materialdepth] = material;
290
+ selectedstack[materialdepth] = selected;
291
+ cStatic.objectstack[materialdepth++] = obj;
292
+ //System.out.println("material " + material);
293
+ //Applet3D.tracein(this, selected);
294
+ display.vector2buffer = obj.projectedVertices;
295
+ if (obj instanceof Camera)
296
+ {
297
+ display.options1[0] = material.shift;
298
+ //System.out.println("shift " + material.shift);
299
+ display.options1[1] = material.lightarea;
300
+ display.options1[2] = material.shadowbias;
301
+ display.options1[3] = material.aniso;
302
+ display.options1[4] = material.anisoV;
303
+ display.options2[0] = material.opacity;
304
+ display.options2[1] = material.diffuse;
305
+ display.options2[2] = material.factor;
306
+
307
+ cColor.HSBtoRGB(material.color, material.modulation, 1, display.options3);
308
+ display.options4[0] = material.cameralight/0.2f;
309
+ display.options4[1] = material.subsurface;
310
+ display.options4[2] = material.sheen;
311
+
312
+ // if (display.CURRENTANTIALIAS > 0)
313
+ // display.options3[3] /= 4;
314
+
315
+ /*
316
+ System.out.println("Focus = " + display.options1[0]);
317
+ System.out.println("Aperture = " + display.options1[1]);
318
+ System.out.println("ShadowBlur = " + display.options1[2]);
319
+ System.out.println("Antialiasing = " + display.options1[3]);
320
+ System.out.println("Fog = " + display.options2[0]);
321
+ System.out.println("Intensity = " + display.options2[1]);
322
+ System.out.println("Elevation = " + display.options2[2]);
323
+ /**/
324
+ } else
325
+ {
326
+ DrawMaterial(material, selected);
327
+ }
328
+ } else
329
+ {
330
+ if (selected && CameraPane.flash)
331
+ {
332
+ display.modelParams4[1] = 100;
333
+ gl.glProgramEnvParameter4fvARB(gl.GL_FRAGMENT_PROGRAM_ARB, 4, display.modelParams4, 0);
334
+ }
335
+ }
336
+ }
337
+
338
+ public void PushMaterial2(Object3D obj, boolean selected)
339
+ {
340
+ CameraPane display = this;
341
+ cMaterial material = obj.material;
342
+
343
+ if (material != null)
344
+ {
345
+ materialstack[materialdepth] = material;
346
+ selectedstack[materialdepth] = selected;
347
+ cStatic.objectstack[materialdepth++] = obj;
348
+ //System.out.println("material " + material);
349
+ //Applet3D.tracein("selected ", selected);
350
+ display.vector2buffer = obj.projectedVertices;
351
+ display.DrawMaterial(material, selected);
352
+ }
353
+ }
354
+
355
+ public void PopMaterial(Object3D obj, boolean selected)
356
+ {
357
+ CameraPane display = this;
358
+ javax.media.opengl.GL gl = display.GetGL();
359
+ cMaterial material = obj.material;
360
+
361
+ //if (parent != null && parent.GetMaterial() != null)
362
+ // parent.GetMaterial().Draw(display, parent.IsSelected(this));
363
+ if (material != null)
364
+ {
365
+ materialdepth -= 1;
366
+ if (materialdepth > 0)
367
+ {
368
+ display.vector2buffer = cStatic.objectstack[materialdepth - 1].projectedVertices;
369
+ display.DrawMaterial(materialstack[materialdepth - 1], selectedstack[materialdepth - 1]);
370
+ }
371
+ //Applet3D.traceout("selected ", (stackdepth>0)?selectedstack[stackdepth-1]:"???");
372
+ } else if (selected && CameraPane.flash && obj.GetMaterial() != null)
373
+ {
374
+ display.modelParams4[1] = obj.GetMaterial().cameralight;
375
+ gl.glProgramEnvParameter4fvARB(gl.GL_FRAGMENT_PROGRAM_ARB, 4, display.modelParams4, 0);
376
+ }
377
+ }
378
+
379
+ public void PopMaterial2(Object3D obj)
380
+ {
381
+ CameraPane display = this;
382
+ cMaterial material = obj.material;
383
+
384
+ if (material != null)
385
+ {
386
+ materialdepth -= 1;
387
+ if (materialdepth > 0)
388
+ {
389
+ display.vector2buffer = cStatic.objectstack[materialdepth - 1].projectedVertices;
390
+ display.DrawMaterial(materialstack[materialdepth - 1], selectedstack[materialdepth - 1]);
391
+ }
392
+ //Applet3D.traceout("selected ", (stackdepth>0)?selectedstack[stackdepth-1]:"???");
393
+ //else
394
+ //material.Draw(display, false);
395
+ }
396
+ }
397
+
398
+ public void DrawFace(Object3D obj, Vertex pv, Vertex qv, Vertex rv, Face face)
399
+ {
400
+ CameraPane display = this;
401
+
402
+ if (pv.y == -10000 ||
403
+ qv.y == -10000 ||
404
+ rv.y == -10000)
405
+ return;
406
+
407
+// float b = f.nbiterations & 1;
408
+// float g = (f.nbiterations>>1) & 1;
409
+// float r = (f.nbiterations>>2) & 1;
410
+//
411
+// //if (f.weight == 10000)
412
+// //{
413
+// // r = 1; g = b = 0;
414
+// //}
415
+// //else
416
+// //{
417
+// // assert(f.weight < 10000);
418
+// r = g = b = (float)bRep.FaceWeight(f)*100;
419
+// if (r<0)
420
+// assert(r>=0);
421
+// //}
422
+
423
+ javax.media.opengl.GL gl = display.GetGL();
424
+
425
+ boolean selectmode = display.DrawMode() == display.SELECTION || display.IsDebugSelection();
426
+
427
+ //System.out.println("p = " + pv + "; q = " + qv + "; r = " + rv);
428
+ if (!selectmode) // display.drawMode != display.SELECTION) // && display.drawMode != display.SHADOW) // (attributes & FILL) != 0)
429
+ {
430
+ //gl.glBegin(gl.GL_TRIANGLES);
431
+ boolean hasnorm = pv.norm != null; // && (pv.norm.x != 0 || pv.norm.y != 0 || pv.norm.z != 0);
432
+ if (!hasnorm)
433
+ {
434
+ // System.out.println("FUCK!!");
435
+ LA.vecSub(pv/*.pos*/, qv/*.pos*/, obj.v0);
436
+ LA.vecSub(pv/*.pos*/, rv/*.pos*/, obj.v1);
437
+ LA.vecCross(obj.v0, obj.v1, obj.v2);
438
+ LA.vecNormalize(obj.v2);
439
+ gl.glNormal3f((float) obj.v2.x, (float) obj.v2.y, (float) obj.v2.z);
440
+ }
441
+
442
+ // P
443
+ float x = (float)pv.x;
444
+ float y = (float)pv.y;
445
+ float z = (float)pv.z;
446
+
447
+ if (hasnorm)
448
+ {
449
+// if (!pv.norm.normalized())
450
+// assert(pv.norm.normalized());
451
+
452
+ //System.out.println("normalp = " + pv.norm.x + ", " + pv.norm.y + ", " + pv.norm.z);
453
+ float nx = (float)pv.norm.x;
454
+ float ny = (float)pv.norm.y;
455
+ float nz = (float)pv.norm.z;
456
+
457
+ x += nx * obj.NORMALPUSH;
458
+ y += ny * obj.NORMALPUSH;
459
+ z += nz * obj.NORMALPUSH;
460
+
461
+ gl.glNormal3f(nx, ny, nz);
462
+ }
463
+ gl.glColor4f(pv.AO, pv.AO, pv.AO, 1);
464
+ SetColor(obj, pv);
465
+ //gl.glColor4f(r, g, b, 1);
466
+ //gl.glColor4f(pv.boundary, pv.boundary, pv.boundary, 1);
467
+ if (obj.flipV)
468
+ gl.glTexCoord2f((float) pv.s, 1-(float) pv.t);
469
+ else
470
+ gl.glTexCoord2f((float) pv.s, (float) pv.t);
471
+ //System.out.println("vertexp = " + pv.x + ", " + pv.y + ", " + pv.z);
472
+
473
+ gl.glVertex3f(x, y, z);
474
+
475
+ // Q
476
+ x = (float)qv.x;
477
+ y = (float)qv.y;
478
+ z = (float)qv.z;
479
+
480
+// Print(pv);
481
+ if (hasnorm)
482
+ {
483
+// assert(qv.norm.normalized());
484
+ //System.out.println("normalq = " + qv.norm.x + ", " + qv.norm.y + ", " + qv.norm.z);
485
+ float nx = (float)qv.norm.x;
486
+ float ny = (float)qv.norm.y;
487
+ float nz = (float)qv.norm.z;
488
+
489
+ x += nx * obj.NORMALPUSH;
490
+ y += ny * obj.NORMALPUSH;
491
+ z += nz * obj.NORMALPUSH;
492
+
493
+ gl.glNormal3f(nx, ny, nz);
494
+ }
495
+ //System.out.println("vertexq = " + qv.s + ", " + qv.t);
496
+ // boolean locked = false;
497
+ // float eps = 0.1f;
498
+ // boolean wrap = CameraPane.UVWRAP; // true; // UV WRAP TEXTURE ISSUE: true = artifacts, false = nice
499
+
500
+ // int dot = 0; //*/ (int)f.dot;
501
+
502
+ // if ((dot&1) == 0)
503
+ // dot |= (Math.abs(qv.s - pv.s) < eps && Math.abs(qv.t - pv.t) < eps) ? 3 : 1;
504
+
505
+ // if (wrap || (dot&2) != 0) // Math.abs(qv.s - pv.s) < eps && Math.abs(qv.t - pv.t) < eps)
506
+ if (obj.flipV)
507
+ gl.glTexCoord2f((float) qv.s, 1-(float) qv.t);
508
+ else
509
+ gl.glTexCoord2f((float) qv.s, (float) qv.t);
510
+ // else
511
+ // {
512
+ // locked = true;
513
+ // gl.glTexCoord2f((float) pv.s, (float) pv.t);
514
+ // }
515
+ gl.glColor4f(qv.AO, qv.AO, qv.AO, 1);
516
+ SetColor(obj, qv);
517
+
518
+ gl.glVertex3f(x, y, z);
519
+ //gl.glColor4f(r, g, b, 1);
520
+ //gl.glColor4f(qv.boundary, qv.boundary, qv.boundary, 1);
521
+ //System.out.println("vertexq = " + qv.x + ", " + qv.y + ", " + qv.z);
522
+// Print(qv);
523
+
524
+ // R
525
+ x = (float)rv.x;
526
+ y = (float)rv.y;
527
+ z = (float)rv.z;
528
+
529
+ if (hasnorm)
530
+ {
531
+// assert(rv.norm.normalized());
532
+ //System.out.println("normalr = " + rv.norm.x + ", " + rv.norm.y + ", " + rv.norm.z);
533
+ float nx = (float)rv.norm.x;
534
+ float ny = (float)rv.norm.y;
535
+ float nz = (float)rv.norm.z;
536
+
537
+ x += nx * obj.NORMALPUSH;
538
+ y += ny * obj.NORMALPUSH;
539
+ z += nz * obj.NORMALPUSH;
540
+
541
+ gl.glNormal3f(nx, ny, nz);
542
+ }
543
+
544
+ // if ((dot&4) == 0)
545
+ // dot |= (Math.abs(rv.s - pv.s) < eps && Math.abs(rv.t - pv.t) < eps) ? 12 : 4;
546
+
547
+ // if (wrap || !locked && (dot&8) != 0)
548
+ if (obj.flipV)
549
+ gl.glTexCoord2f((float) rv.s, 1-(float) rv.t);
550
+ else
551
+ gl.glTexCoord2f((float) rv.s, (float) rv.t);
552
+ // else
553
+ // gl.glTexCoord2f((float) pv.s, (float) pv.t);
554
+
555
+ // f.dot = dot;
556
+
557
+ gl.glColor4f(rv.AO, rv.AO, rv.AO, 1);
558
+ SetColor(obj, rv);
559
+ //gl.glColor4f(r, g, b, 1);
560
+ //gl.glColor4f(rv.boundary, rv.boundary, rv.boundary, 1);
561
+ //System.out.println("vertexr = " + rv.x + ", " + rv.y + ", " + rv.z);
562
+ gl.glVertex3f(x, y, z);
563
+// Print(rv);
564
+ //gl.glEnd();
565
+ }
566
+ else
567
+ {
568
+ gl.glVertex3f((float) pv.x, (float) pv.y, (float) pv.z);
569
+ gl.glVertex3f((float) qv.x, (float) qv.y, (float) qv.z);
570
+ gl.glVertex3f((float) rv.x, (float) rv.y, (float) rv.z);
571
+
572
+ }
573
+
574
+ if (false) // (attributes & WIREFRAME) != 0)
575
+ {
576
+ gl.glDisable(gl.GL_LIGHTING);
577
+
578
+ gl.glBegin(gl.GL_LINE_LOOP);
579
+ gl.glVertex3d(pv./*pos.*/x, pv./*pos.*/y, pv./*pos.*/z);
580
+ gl.glVertex3d(qv./*pos.*/x, qv./*pos.*/y, qv./*pos.*/z);
581
+ gl.glVertex3d(rv./*pos.*/x, rv./*pos.*/y, rv./*pos.*/z);
582
+ gl.glEnd();
583
+
584
+ gl.glEnable(gl.GL_LIGHTING);
585
+ }
586
+ }
587
+
588
+ /**
589
+ * <code>draw</code> renders a <code>TriMesh</code> object including
590
+ * it's normals, colors, textures and vertices.
591
+ *
592
+ * @see Renderer#draw(TriMesh)
593
+ * @param tris
594
+ * the mesh to render.
595
+ */
596
+ public void DrawParticles(TriMesh geo, Object3D shape, boolean selected, boolean rotate) // TriMesh tris)
597
+ {
598
+ CameraPane display = this;
599
+
600
+ float r = display.modelParams0[0];
601
+ float g = display.modelParams0[1];
602
+ float b = display.modelParams0[2];
603
+ float opacity = display.modelParams5[1];
604
+
605
+ //final GL gl = GLU.getCurrentGL();
606
+ GL gl = display.GetGL(); // getGL();
607
+
608
+ FloatBuffer vertBuf = geo.vertBuf;
609
+
610
+ int v = vertBuf.capacity();
611
+
612
+ int count = 0;
613
+
614
+ boolean cf = gl.glIsEnabled(gl.GL_CULL_FACE);
615
+ gl.glEnable(gl.GL_CULL_FACE);
616
+ // gl.glScalef(1.0f/1024,1.0f/1024,1.0f/1024);
617
+ for (int i=0; i<v/3; i++)
618
+ {
619
+ int index3 = i*3;
620
+
621
+ if (geo.sizeBuf.get(index3+1) == 0)
622
+ continue;
623
+
624
+ count++;
625
+
626
+ int index4 = i*4;
627
+
628
+ float tx = vertBuf.get(index3);
629
+ float ty = vertBuf.get(index3+1);
630
+ float tz = vertBuf.get(index3+2);
631
+
632
+ // if (tx == 0 && ty == 0 && tz == 0)
633
+ // continue;
634
+
635
+ gl.glMatrixMode(gl.GL_TEXTURE);
636
+ gl.glPushMatrix();
637
+
638
+ float[] texmat = geo.texmat;
639
+ texmat[12] = texmat[13] = texmat[14] = i;
640
+
641
+ gl.glMultMatrixf(texmat, 0);
642
+
643
+ gl.glMatrixMode(gl.GL_MODELVIEW);
644
+ gl.glPushMatrix();
645
+
646
+ gl.glTranslatef(tx,ty,tz);
647
+
648
+ if (rotate)
649
+ gl.glRotatef(i, 0, 1, 0);
650
+
651
+ float size = geo.sizeBuf.get(index3) / 100;
652
+ gl.glScalef(size,size,size);
653
+
654
+ float cr = geo.colorBuf.get(index4);
655
+ float cg = geo.colorBuf.get(index4+1);
656
+ float cb = geo.colorBuf.get(index4+2);
657
+ float ca = geo.colorBuf.get(index4+3);
658
+
659
+ display.modelParams0[0] = r * cr;
660
+ display.modelParams0[1] = g * cg;
661
+ display.modelParams0[2] = b * cb;
662
+
663
+ display.modelParams5[1] = opacity * ca;
664
+
665
+ gl.glProgramEnvParameter4fvARB(gl.GL_FRAGMENT_PROGRAM_ARB, 0, display.modelParams0, 0);
666
+ gl.glProgramEnvParameter4fvARB(gl.GL_FRAGMENT_PROGRAM_ARB, 5, display.modelParams5, 0);
667
+
668
+ RandomNode.globalseed = (int)geo.sizeBuf.get(index3+2); // i;
669
+ RandomNode.globalseed2 = RandomNode.globalseed;
670
+
671
+// gl.glColor4f(cr,cg,cb,ca);
672
+ // gl.glScalef(1024/16,1024/16,1024/16);
673
+ shape.Draw/*Node*/(display,null,selected,false); // blocked
674
+ // gl.glScalef(16.0f/1024,16.0f/1024,16.0f/1024);
675
+ //gl.glTranslatef(-tx,-ty,-tz);
676
+ gl.glPopMatrix();
677
+
678
+ gl.glMatrixMode(gl.GL_TEXTURE);
679
+ gl.glPopMatrix();
680
+ }
681
+ // gl.glScalef(1024,1024,1024);
682
+ if (!cf)
683
+ gl.glDisable(gl.GL_CULL_FACE);
684
+
685
+ display.modelParams0[0] = r;
686
+ display.modelParams0[1] = g;
687
+ display.modelParams0[2] = b;
688
+
689
+ display.modelParams5[1] = opacity;
690
+
691
+ gl.glProgramEnvParameter4fvARB(gl.GL_FRAGMENT_PROGRAM_ARB, 0, display.modelParams0, 0);
692
+ gl.glProgramEnvParameter4fvARB(gl.GL_FRAGMENT_PROGRAM_ARB, 5, display.modelParams5, 0);
693
+
694
+ gl.glMatrixMode(gl.GL_MODELVIEW);
695
+
696
+// System.err.println("total = " + v/3 + "; displayed = " + count);
697
+ if (true)
698
+ return;
699
+
700
+//// if (!tris.predraw(this))
701
+//// {
702
+//// return;
703
+//// }
704
+//// if (Debug.stats)
705
+//// {
706
+//// StatCollector.addStat(StatType.STAT_TRIANGLE_COUNT, tris.getTriangleCount());
707
+//// StatCollector.addStat(StatType.STAT_VERTEX_COUNT, tris.getVertexCount());
708
+//// StatCollector.addStat(StatType.STAT_GEOM_COUNT, 1);
709
+//// }
710
+////
711
+//// if (tris.getDisplayListID() != -1)
712
+//// {
713
+//// renderDisplayList(tris);
714
+//// return;
715
+//// }
716
+////
717
+//// if (!generatingDisplayList)
718
+//// {
719
+//// applyStates(tris.states, tris);
720
+//// }
721
+//// if (Debug.stats)
722
+//// {
723
+//// StatCollector.startStat(StatType.STAT_RENDER_TIMER);
724
+//// }
725
+//// boolean transformed = doTransforms(tris);
726
+//
727
+// int glMode = GL.GL_TRIANGLES;
728
+// switch (getMode())
729
+// {
730
+// case Triangles:
731
+// glMode = GL.GL_TRIANGLES;
732
+// break;
733
+// case Strip:
734
+// glMode = GL.GL_TRIANGLE_STRIP;
735
+// break;
736
+// case Fan:
737
+// glMode = GL.GL_TRIANGLE_FAN;
738
+// break;
739
+// }
740
+//
741
+// if (!predrawGeometry(gl))
742
+// {
743
+// // make sure only the necessary indices are sent through on old
744
+// // cards.
745
+// IntBuffer indices = this.getIndexBuffer();
746
+// if (indices == null)
747
+// {
748
+// logger.severe("missing indices on geometry object: " + this.toString());
749
+// } else
750
+// {
751
+// indices.rewind();
752
+// indices.limit(this.getMaxIndex());
753
+//
754
+// gl.glDrawElements(glMode, indices.limit(), GL.GL_UNSIGNED_INT, indices); // TODO Check <count> and assumed <type> of GL_UNSIGNED_INT
755
+//
756
+// indices.clear();
757
+// }
758
+// } else
759
+// {
760
+// gl.glDrawElements(glMode, this.getIndexBuffer().limit(),
761
+// GL.GL_UNSIGNED_INT, 0);
762
+// }
763
+//
764
+//// postdrawGeometry(tris);
765
+//// if (transformed)
766
+//// {
767
+//// undoTransforms(tris);
768
+//// }
769
+////
770
+//// if (Debug.stats)
771
+//// {
772
+//// StatCollector.endStat(StatType.STAT_RENDER_TIMER);
773
+//// }
774
+//// tris.postdraw(this);
775
+ }
776
+
777
+ static Camera localcamera = new Camera();
778
+ static cVector from = new cVector();
779
+ static cVector to = new cVector();
780
+
781
+ public void PrepOcclusion(BoundaryRep br, double[][] transform)
782
+ {
783
+ CameraPane cp = this;
784
+
785
+ Camera keep = cp.RenderCamera();
786
+ cp.renderCamera = localcamera;
787
+
788
+ if (br.trimmed)
789
+ {
790
+ float[] colors = new float[br.positions.length / 3];
791
+
792
+ int i3 = 0;
793
+ for (int i = 0; i < br.positions.length / 3; i++, i3 += 3)
794
+ {
795
+ if (br.normals[i3] == 0 && br.normals[i3+1] == 0 && br.normals[i3+2] == 0)
796
+ continue;
797
+
798
+ from.set(br.positions[i3], br.positions[i3 + 1], br.positions[i3 + 2]);
799
+ to.set(br.positions[i3] + br.normals[i3],
800
+ br.positions[i3 + 1] + br.normals[i3 + 1],
801
+ br.positions[i3 + 2] + br.normals[i3 + 2]);
802
+ LA.xformPos(from, transform, from);
803
+ LA.xformPos(to, transform, to); // RIGID ONLY
804
+ localcamera.setAim(from, to);
805
+
806
+ CameraPane.occlusionbuffer.display();
807
+
808
+ if (CameraPane.DEBUG_OCCLUSION)
809
+ cp.display(); // debug
810
+
811
+ colors[i] = cp.vertexOcclusion.r;
812
+ //colors[i3 + 1] = cp.vertexOcclusion.g;
813
+ //colors[i3 + 2] = cp.vertexOcclusion.b;
814
+
815
+ if ((i % 100) == 0 && i != 0)
816
+ {
817
+ Globals.theRenderer.setCursor(java.awt.Cursor.getPredefinedCursor(java.awt.Cursor.WAIT_CURSOR));
818
+ //System.out.println("Color = " + cp.vertexOcclusion.r + ", " + cp.vertexOcclusion.g + ", " + cp.vertexOcclusion.b + "; " + (int)(100.0*i/(positions.length/3)) + "% done");
819
+ System.out.println((int) (100.0 * i / (br.positions.length / 3)) + "% (" + i + " of " + (br.positions.length / 3) + ")");
820
+ }
821
+ }
822
+
823
+ br.colors = colors;
824
+ }
825
+ else
826
+ {
827
+ for (int i = 0; i < br.VertexCount(); i++)
828
+ {
829
+ Vertex v = br.GetVertex(i);
830
+
831
+ if (v.norm == null || v.norm.x == 0 && v.norm.y == 0 && v.norm.z == 0)
832
+ continue;
833
+
834
+ from.set(v.x, v.y, v.z);
835
+ to.set(v.x+v.norm.x, v.y+v.norm.y, v.z+v.norm.z);
836
+ LA.xformPos(from, transform, from);
837
+ LA.xformPos(to, transform, to); // RIGID ONLY
838
+ localcamera.setAim(from, to);
839
+
840
+ CameraPane.occlusionbuffer.display();
841
+
842
+ if (CameraPane.DEBUG_OCCLUSION)
843
+ cp.display(); // debug
844
+
845
+ v.AO = cp.vertexOcclusion.r;
846
+
847
+ if ((i % 100) == 0 && i != 0)
848
+ {
849
+ Globals.theRenderer.setCursor(java.awt.Cursor.getPredefinedCursor(java.awt.Cursor.WAIT_CURSOR));
850
+ //System.out.println("Color = " + cp.vertexOcclusion.r + ", " + cp.vertexOcclusion.g + ", " + cp.vertexOcclusion.b + "; " + (int)(100.0*i/(positions.length/3)) + "% done");
851
+ System.out.println((int) (100.0 * i / br.VertexCount()) + "% (" + i + " of " + br.VertexCount() + ")");
852
+ }
853
+ }
854
+ }
855
+
856
+ //System.out.println("done.");
857
+
858
+ cp.renderCamera = keep;
859
+ }
860
+
861
+ void DrawPointFLow(PointFlow pointFlow, Object3D /*Composite*/ root, boolean selected, boolean blocked)
862
+ {
863
+ CameraPane display = this;
864
+ pointFlow.CreateHT();
865
+
866
+ float r = display.modelParams0[0];
867
+ float g = display.modelParams0[1];
868
+ float b = display.modelParams0[2];
869
+ float opacity = display.modelParams5[1];
870
+
871
+ //final GL gl = GLU.getCurrentGL();
872
+ GL gl = display.GetGL(); // getGL();
873
+
874
+ int s = pointFlow.points.size();
875
+
876
+ boolean cf = gl.glIsEnabled(gl.GL_CULL_FACE);
877
+ gl.glEnable(gl.GL_CULL_FACE);
878
+
879
+ for (int i=s; --i>=0;)
880
+ //for (int i=0; i<s; i++)
881
+ {
882
+ cVector v = pointFlow.points.get(i);
883
+
884
+ double mindist = Double.MAX_VALUE;
885
+
886
+ double size = pointFlow.minimumSize;
887
+
888
+ double distancenext = 0;
889
+
890
+ if (i > 0)
891
+ {
892
+ cVector w = pointFlow.points.get(i-1);
893
+
894
+ double dist = w.distance(v);
895
+
896
+ distancenext = dist;
897
+
898
+ if (mindist > dist)
899
+ {
900
+ mindist = dist;
901
+ size = mindist*pointFlow.resizefactor;
902
+ }
903
+ }
904
+
905
+ if (i < s-1)
906
+ {
907
+ cVector w = pointFlow.points.get(i+1);
908
+
909
+ double dist = w.distance(v);
910
+
911
+ if (mindist > dist)
912
+ {
913
+ mindist = dist;
914
+ size = mindist*pointFlow.resizefactor;
915
+ }
916
+ }
917
+
918
+ if (size < pointFlow.minimumSize)
919
+ size = pointFlow.minimumSize;
920
+ if (size > pointFlow.maximumSize)
921
+ size = pointFlow.maximumSize;
922
+
923
+ double tx = v.x;
924
+ double ty = v.y;
925
+ double tz = v.z;
926
+
927
+ // if (tx == 0 && ty == 0 && tz == 0)
928
+ // continue;
929
+
930
+ gl.glMatrixMode(gl.GL_TEXTURE);
931
+ gl.glPushMatrix();
932
+ pointFlow.texmat[12] = pointFlow.texmat[13] = pointFlow.texmat[14] = i;
933
+
934
+ gl.glMultMatrixf(pointFlow.texmat, 0);
935
+
936
+ gl.glMatrixMode(gl.GL_MODELVIEW);
937
+ gl.glPushMatrix();
938
+
939
+ gl.glTranslated(tx,ty,tz);
940
+
941
+ gl.glScaled(size,size,size);
942
+
943
+// float cr = colorBuf.get(index4);
944
+// float cg = colorBuf.get(index4+1);
945
+// float cb = colorBuf.get(index4+2);
946
+// float ca = colorBuf.get(index4+3);
947
+//
948
+// display.modelParams0[0] = r * cr;
949
+// display.modelParams0[1] = g * cg;
950
+// display.modelParams0[2] = b * cb;
951
+//
952
+// display.modelParams5[1] = opacity * ca;
953
+//
954
+// gl.glProgramEnvParameter4fvARB(gl.GL_FRAGMENT_PROGRAM_ARB, 0, display.modelParams0, 0);
955
+// gl.glProgramEnvParameter4fvARB(gl.GL_FRAGMENT_PROGRAM_ARB, 5, display.modelParams5, 0);
956
+//
957
+// RandomNode.globalseed = (int)sizeBuf.get(index3+2); // i;
958
+// RandomNode.globalseed2 = RandomNode.globalseed;
959
+//
960
+//// gl.glColor4f(cr,cg,cb,ca);
961
+// // gl.glScalef(1024/16,1024/16,1024/16);
962
+ pointFlow.geo.Draw/*Node*/(display,null,selected, blocked);
963
+
964
+ gl.glPopMatrix();
965
+
966
+ double step = size/4; //
967
+
968
+ if (i == 0 || size == 0 || distancenext > 8*size || distancenext < step)
969
+ continue;
970
+
971
+ int nbsteps = (int)(distancenext/step);
972
+
973
+ step = distancenext/nbsteps;
974
+
975
+ cVector next = pointFlow.points.get(i-1);
976
+
977
+ tmp.set(next);
978
+ tmp.sub(v);
979
+ tmp.normalize();
980
+ tmp.mul(step);
981
+
982
+ // calculate next size
983
+ mindist = Double.MAX_VALUE;
984
+
985
+ double nextsize = pointFlow.minimumSize;
986
+
987
+ if (i > 1)
988
+ {
989
+ cVector w = pointFlow.points.get(i-2);
990
+
991
+ double dist = w.distance(next);
992
+
993
+ if (mindist > dist)
994
+ {
995
+ mindist = dist;
996
+ nextsize = mindist*pointFlow.resizefactor;
997
+ }
998
+ }
999
+
1000
+ double dist = v.distance(next);
1001
+
1002
+ if (mindist > dist)
1003
+ {
1004
+ mindist = dist;
1005
+ nextsize = mindist*pointFlow.resizefactor;
1006
+ }
1007
+
1008
+ if (nextsize < pointFlow.minimumSize)
1009
+ nextsize = pointFlow.minimumSize;
1010
+ if (nextsize > pointFlow.maximumSize)
1011
+ nextsize = pointFlow.maximumSize;
1012
+ //
1013
+
1014
+ double count = 0;
1015
+
1016
+ while (distancenext > 0.000000001) // step
1017
+ {
1018
+ gl.glPushMatrix();
1019
+
1020
+ gl.glTranslated(tx + tmp.x*count, ty + tmp.y*count, tz + tmp.z*count);
1021
+
1022
+ double K = count/nbsteps;
1023
+
1024
+ double intersize = K*nextsize + (1-K)*size;
1025
+
1026
+ gl.glScaled(intersize,intersize,intersize);
1027
+
1028
+ pointFlow.geo.Draw/*Node*/(display,null,selected,blocked);
1029
+
1030
+ count++;
1031
+
1032
+ distancenext -= step;
1033
+
1034
+ gl.glPopMatrix();
1035
+ }
1036
+
1037
+ if (count != nbsteps)
1038
+ assert(count == nbsteps);
1039
+
1040
+ // gl.glScalef(16.0f/1024,16.0f/1024,16.0f/1024);
1041
+ //gl.glTranslatef(-tx,-ty,-tz);
1042
+
1043
+ gl.glMatrixMode(gl.GL_TEXTURE);
1044
+ gl.glPopMatrix();
1045
+ }
1046
+
1047
+ if (!cf)
1048
+ gl.glDisable(gl.GL_CULL_FACE);
1049
+
1050
+// display.modelParams0[0] = r;
1051
+// display.modelParams0[1] = g;
1052
+// display.modelParams0[2] = b;
1053
+//
1054
+// display.modelParams5[1] = opacity;
1055
+//
1056
+// gl.glProgramEnvParameter4fvARB(gl.GL_FRAGMENT_PROGRAM_ARB, 0, display.modelParams0, 0);
1057
+// gl.glProgramEnvParameter4fvARB(gl.GL_FRAGMENT_PROGRAM_ARB, 5, display.modelParams5, 0);
1058
+
1059
+ gl.glMatrixMode(gl.GL_MODELVIEW);
1060
+ }
1061
+
1062
+ /// INTERFACE
1063
+
1064
+ void SetColor(Object3D obj, Vertex p0)
1065
+ {
1066
+ CameraPane display = this;
1067
+ BoundaryRep bRep = obj.bRep;
1068
+
1069
+ if (RENDERPROGRAM == 0)
1070
+ {
1071
+ float r = 0;
1072
+ if (bRep != null)
1073
+ {
1074
+ if (bRep.stripified)
1075
+ {
1076
+ r = 1;
1077
+ }
1078
+ }
1079
+ float g = 0;
1080
+ if (bRep != null)
1081
+ {
1082
+ if (bRep.trimmed)
1083
+ {
1084
+ g = 1;
1085
+ }
1086
+ }
1087
+ float b = 0;
1088
+ if (obj.support != null && obj.link2master)
1089
+ {
1090
+ b = 1;
1091
+ }
1092
+ display.GetGL().glColor3f(r*p0.AO, g*p0.AO, b*p0.AO);
1093
+ return;
1094
+ }
1095
+
1096
+ if (display.DrawMode() != CameraPane.SHADOW)
1097
+ return;
1098
+
1099
+ javax.media.opengl.GL gl = display.GetGL();
1100
+// if (true) return;
1101
+// float ao = p.AO;
1102
+//
1103
+// // if (ao == 0 && !bRep.AOdone) // transient problem!
1104
+// // ao = 1;
1105
+//
1106
+// gl.glColor4f(ao, ao, ao, 1);
1107
+
1108
+// CameraPane.selectedpoint.
1109
+// getAverage(cStatic.point1, true);
1110
+ if (CameraPane.pointflow == null) // !random) // live)
1111
+ {
1112
+ return;
1113
+ }
1114
+
1115
+ cStatic.point1.set(0,0,0);
1116
+ LA.xformPos(cStatic.point1, CameraPane.selectedpoint.toParent, cStatic.point1);
1117
+
1118
+ cStatic.point1.sub(p0);
1119
+
1120
+
1121
+// if (marked && (p0.vertexlinks == null || support == null || support.bRep == null)) // no position delta?
1122
+// {
1123
+// return;
1124
+// }
1125
+
1126
+ //if (true)
1127
+ if (cStatic.point1.dot(cStatic.point1) > 0.000001)
1128
+ {
1129
+ return;
1130
+ }
1131
+
1132
+ float[] colorV = new float[3];
1133
+
1134
+ if (false) // marked)
1135
+ {
1136
+ // debug rigging weights
1137
+ for (int object = 0; object < p0.vertexlinks.length; object++)
1138
+ {
1139
+ float weight = p0.weights[object] / p0.totalweight;
1140
+
1141
+ // if (weight < 0.1)
1142
+ // {
1143
+ // assert(weight == 0);
1144
+ // continue;
1145
+ // }
1146
+
1147
+ if (p0.vertexlinks[object] == -1)
1148
+ continue;
1149
+
1150
+ Vertex q = obj.support.bRep.GetVertex(p0.vertexlinks[object]);
1151
+
1152
+ int color = //1 << object; //
1153
+ //p.vertexlinks.length;
1154
+ obj.support.bRep.supports[p0.closestsupport].links[object];
1155
+ colorV[2] += (color & 1) * weight;
1156
+ colorV[1] += ((color & 2) >> 1) * weight;
1157
+ colorV[0] += ((color & 4) >> 2) * weight;
1158
+ }
1159
+ }
1160
+ else
1161
+ {
1162
+ if (obj.drawingstarted)
1163
+ {
1164
+ // find next point
1165
+ if (bRep.GetVertex(0).faceindices == null)
1166
+ {
1167
+ bRep.InitFaceIndices();
1168
+ }
1169
+
1170
+ double ymin = p0.y;
1171
+
1172
+ Vertex newp = p0;
1173
+
1174
+ for (int fii = 0; fii < p0.faceindices.length; fii++)
1175
+ {
1176
+ int fi = p0.faceindices[fii];
1177
+
1178
+ if (fi == -1)
1179
+ break;
1180
+
1181
+ Face f = bRep.GetFace(fi);
1182
+
1183
+ Vertex p = bRep.GetVertex(f.p);
1184
+ Vertex q = bRep.GetVertex(f.q);
1185
+ Vertex r = bRep.GetVertex(f.r);
1186
+
1187
+ int swap = (int)(Math.random()*3);
1188
+
1189
+// for (int s=swap; --s>=0;)
1190
+// {
1191
+// Vertex t = p;
1192
+// p = q;
1193
+// q = r;
1194
+// r = t;
1195
+// }
1196
+ if (ymin > p.y)
1197
+ {
1198
+ ymin = p.y;
1199
+ newp = p;
1200
+// break;
1201
+ }
1202
+ if (ymin > q.y)
1203
+ {
1204
+ ymin = q.y;
1205
+ newp = q;
1206
+// break;
1207
+ }
1208
+ if (ymin > r.y)
1209
+ {
1210
+ ymin = r.y;
1211
+ newp = r;
1212
+// break;
1213
+ }
1214
+ }
1215
+
1216
+ CameraPane.selectedpoint.toParent[3][0] = newp.x;
1217
+ CameraPane.selectedpoint.toParent[3][1] = newp.y;
1218
+ CameraPane.selectedpoint.toParent[3][2] = newp.z;
1219
+
1220
+ obj.drawingstarted = false;
1221
+
1222
+ // return;
1223
+ }
1224
+
1225
+ if (false) // CameraPane.DRAW
1226
+ {
1227
+ p0.AO = colorV[0] = 2;
1228
+ colorV[1] = 2;
1229
+ colorV[2] = 2;
1230
+ }
1231
+
1232
+ CameraPane.pointflow.add(p0);
1233
+ CameraPane.pointflow.Touch();
1234
+ }
1235
+
1236
+// gl.glColor3f(colorV[0], colorV[1], colorV[2]);
1237
+// gl.glMaterialfv(gl.GL_FRONT, gl.GL_DIFFUSE, colorV, 0);
1238
+// gl.glMaterialfv(gl.GL_BACK, gl.GL_DIFFUSE, colorV, 0);
1239
+ }
1240
+
1241
+ void DrawMaterial(cMaterial material, boolean selected)
1242
+ {
1243
+ CameraPane display = this;
1244
+ //new Exception().printStackTrace();
1245
+
1246
+ if (display.IsFrozen() && !selected || display.IsAmbientOcclusionOn()) // || display.drawMode == display.SHADOW)
1247
+ {
1248
+ return;
1249
+ }
1250
+
1251
+ javax.media.opengl.GL gl = display.GetGL();
1252
+
1253
+ //Color col = Color.getHSBColor(color,modulation,1);
1254
+ //col.getColorComponents(ColorSpace.getInstance(ColorSpace.CS_LINEAR_RGB), CameraPane.modelParams0);
1255
+ if (!material.multiply)
1256
+ {
1257
+ display.color = color;
1258
+ display.saturation = material.modulation;
1259
+ }
1260
+ else
1261
+ {
1262
+ display.color *= color*2;
1263
+ display.saturation *= material.modulation*2;
1264
+ }
1265
+
1266
+ cColor.HSBtoRGB(display.color, display.saturation, 1, display.modelParams0);
1267
+
1268
+ float[] colorV = GrafreeD.colorV;
1269
+
1270
+ /**/
1271
+ if (display.DrawMode() == display.DEFAULT) // && display.RENDERPROGRAM == 0)
1272
+ {
1273
+ colorV[0] = display.modelParams0[0] * material.diffuse;
1274
+ colorV[1] = display.modelParams0[1] * material.diffuse;
1275
+ colorV[2] = display.modelParams0[2] * material.diffuse;
1276
+ colorV[3] = material.opacity;
1277
+
1278
+ gl.glColor4f(colorV[0], colorV[1], colorV[2], material.opacity);
1279
+ //System.out.println("Opacity = " + opacity);
1280
+
1281
+ gl.glMaterialfv(gl.GL_FRONT, gl.GL_DIFFUSE, colorV, 0);
1282
+ //color[0] /= 2; color[1] /= 2; color[2] /= 2;
1283
+ gl.glMaterialfv(gl.GL_BACK, gl.GL_DIFFUSE, colorV, 0);
1284
+
1285
+ float amb = material.ambient;
1286
+ if (amb < material.cameralight)
1287
+ {
1288
+ amb = material.cameralight;
1289
+ }
1290
+ colorV[0] = display.modelParams0[0] * material.diffuse * amb;
1291
+ colorV[1] = display.modelParams0[1] * material.diffuse * amb;
1292
+ colorV[2] = display.modelParams0[2] * material.diffuse * amb;
1293
+ gl.glMaterialfv(gl.GL_FRONT, gl.GL_AMBIENT, colorV, 0);
1294
+ //color[0] /= 2; color[1] /= 2; color[2] /= 2;
1295
+ gl.glMaterialfv(gl.GL_BACK, gl.GL_AMBIENT, colorV, 0);
1296
+
1297
+ /**/
1298
+ colorV[0] = ((1 - material.metalness) + display.modelParams0[0] * material.metalness) * material.specular;
1299
+ colorV[1] = ((1 - material.metalness) + display.modelParams0[1] * material.metalness) * material.specular;
1300
+ colorV[2] = ((1 - material.metalness) + display.modelParams0[2] * material.metalness) * material.specular;
1301
+ gl.glMaterialfv(gl.GL_FRONT, gl.GL_SPECULAR, colorV, 0);
1302
+ //color[0] /= 2; color[1] /= 2; color[2] /= 2;
1303
+ gl.glMaterialfv(gl.GL_BACK, gl.GL_SPECULAR, colorV, 0);
1304
+ colorV[0] = 10 / material.shininess; // 1/0.005f;
1305
+ //System.out.println("shininess = " + colorV[0]);
1306
+ if (colorV[0] > 128)
1307
+ {
1308
+ colorV[0] = 128;
1309
+ }
1310
+ gl.glMaterialfv(gl.GL_FRONT, gl.GL_SHININESS, colorV, 0);
1311
+ gl.glMaterialfv(gl.GL_BACK, gl.GL_SHININESS, colorV, 0);
1312
+ /**/
1313
+ }
1314
+ /**/
1315
+
1316
+ //selected = false;
1317
+ selected = selected && display.flash;
1318
+
1319
+ //display.modelParams0[0] = 0; // pigment.r;
1320
+ //display.modelParams0[1] = 0; // pigment.g;
1321
+ //display.modelParams0[2] = 0; // pigment.b;
1322
+ if (!material.multiply)
1323
+ {
1324
+ display.modelParams0[3] = material.metalness;
1325
+ display.modelParams1[0] = material.diffuse;
1326
+ display.modelParams1[1] = material.specular;
1327
+ display.modelParams1[2] = 1 / material.shininess;
1328
+ display.modelParams1[3] = material.shift;
1329
+ display.modelParams2[0] = material.ambient;
1330
+ display.modelParams2[1] = material.lightarea;
1331
+ //System.out.println("light area = " + lightarea);
1332
+ display.modelParams2[2] = 1 / material.factor; // diffuseness
1333
+ display.modelParams2[3] = material.velvet;
1334
+ display.modelParams3[0] = material.sheen;
1335
+ display.modelParams3[1] = material.subsurface;
1336
+ display.modelParams3[2] = material.bump; // backlit
1337
+ display.modelParams3[3] = material.aniso;
1338
+ display.modelParams4[0] = material.anisoV;
1339
+ display.modelParams4[1] = selected ? 100 : material.cameralight;
1340
+ //System.out.println("selected = " + selected);
1341
+ display.modelParams4[2] = material.diffuseness;
1342
+ display.modelParams4[3] = material.shadow;
1343
+ display.modelParams5[0] = material.texture;
1344
+ display.modelParams5[1] = material.opacity;
1345
+ display.modelParams5[2] = material.fakedepth;
1346
+ display.modelParams5[3] = CameraPane.SHADOWCULLFACE ? 0f : (material.shadowbias - 0.005f) / 10;
1347
+ }
1348
+ else
1349
+ {
1350
+ display.modelParams0[3] *= material.metalness*2;
1351
+ display.modelParams1[0] *= material.diffuse*2;
1352
+ display.modelParams1[1] *= material.specular*2;
1353
+ display.modelParams1[2] *= material.shininess*2;
1354
+ display.modelParams1[3] *= material.shift*2;
1355
+ display.modelParams2[0] *= material.ambient*2;
1356
+ display.modelParams2[1] *= material.lightarea*2;
1357
+ display.modelParams2[2] *= material.factor*2;
1358
+ display.modelParams2[3] *= material.velvet*2;
1359
+ display.modelParams3[0] *= material.sheen*2;
1360
+ display.modelParams3[1] *= material.subsurface*2;
1361
+ display.modelParams3[2] *= material.bump*2;
1362
+ display.modelParams3[3] *= material.aniso*2;
1363
+ display.modelParams4[0] *= material.anisoV*2;
1364
+ display.modelParams4[1] *= material.cameralight*2;
1365
+ //System.out.println("selected = " + selected);
1366
+ display.modelParams4[2] *= material.diffuseness*2;
1367
+ display.modelParams4[3] *= material.shadow*2;
1368
+ display.modelParams5[0] *= material.texture*2;
1369
+ display.modelParams5[1] *= material.opacity*2;
1370
+ display.modelParams5[2] *= material.fakedepth*2;
1371
+ display.modelParams5[3] *= material.shadowbias*2;
1372
+ }
1373
+
1374
+ display.modelParams6[0] = 0;
1375
+ display.modelParams6[1] = 0;
1376
+ display.modelParams6[2] = 0;
1377
+ display.modelParams6[3] = 0;
1378
+
1379
+ display.modelParams7[0] = 0;
1380
+ display.modelParams7[1] = 1000;
1381
+ display.modelParams7[2] = 0;
1382
+ display.modelParams7[3] = 0;
1383
+
1384
+ display.modelParams6[0] = 100; // criss de bug de bump
1385
+
1386
+ Object3D.cVector2[] extparams = display.vector2buffer;
1387
+ if (extparams != null && extparams.length > 0 && extparams[0] != null)
1388
+ {
1389
+ display.modelParams6[0] = extparams[0].x / 1000.0f; // bump
1390
+ display.modelParams6[1] = extparams[0].y / 1000.0f; // noise
1391
+ if (extparams.length > 1)
1392
+ {
1393
+ display.modelParams6[2] = extparams[1].x / 1000.0f; // borderfade
1394
+ display.modelParams6[3] = extparams[1].y / 1000.0f; // (float)Math.exp(-extparams[1].y / 1000.0f); // fog punchthrough
1395
+ if (extparams.length > 2)
1396
+ {
1397
+ display.modelParams7[0] = extparams[2].x / 1000.0f; // noise power
1398
+ float x = extparams[2].y / 1000.0f;
1399
+ //if (x == 0)
1400
+ // x = 1f;
1401
+ display.modelParams7[1] = 1 / x / x / x / x / x / x / x / x / x / x / x / x / x; // (float)Math.pow(-Math.log((extparams[2].y+0.00) / 1000.0f), 1); // opacity power
1402
+ if (extparams[2].y > 0)
1403
+ {
1404
+ //System.out.println("extparams[1].y = " + extparams[1].y);
1405
+ //System.out.println("extparams[2].y = " + extparams[2].y);
1406
+ //System.out.println("opacity power = " + display.modelParams7[1]);
1407
+ }
1408
+ }
1409
+ }
1410
+ }
1411
+
1412
+ //if (display.modelParams6[2] != 0)
1413
+ /*
1414
+ System.out.println("modelParams0[0] = " + display.modelParams0[0]);
1415
+ System.out.println("modelParams0[1] = " + display.modelParams0[1]);
1416
+ System.out.println("modelParams0[2] = " + display.modelParams0[2]);
1417
+ System.out.println("modelParams0[3] = " + display.modelParams0[3]);
1418
+ System.out.println("modelParams1[0] = " + display.modelParams1[0]);
1419
+ System.out.println("modelParams1[1] = " + display.modelParams1[1]);
1420
+ System.out.println("modelParams1[2] = " + display.modelParams1[2]);
1421
+ System.out.println("modelParams1[3] = " + display.modelParams1[3]);
1422
+ System.out.println("modelParams2[0] = " + display.modelParams2[0]);
1423
+ System.out.println("modelParams2[1] = " + display.modelParams2[1]);
1424
+ System.out.println("modelParams2[2] = " + display.modelParams2[2]);
1425
+ System.out.println("modelParams2[3] = " + display.modelParams2[3]);
1426
+ System.out.println("modelParams3[0] = " + display.modelParams3[0]);
1427
+ System.out.println("modelParams3[1] = " + display.modelParams3[1]);
1428
+ System.out.println("modelParams3[2] = " + display.modelParams3[2]);
1429
+ System.out.println("modelParams3[3] = " + display.modelParams3[3]);
1430
+ System.out.println("modelParams4[0] = " + display.modelParams4[0]);
1431
+ System.out.println("modelParams4[1] = " + display.modelParams4[1]);
1432
+ System.out.println("modelParams4[2] = " + display.modelParams4[2]);
1433
+ System.out.println("modelParams4[3] = " + display.modelParams4[3]);
1434
+ System.out.println("modelParams5[0] = " + display.modelParams5[0]);
1435
+ System.out.println("modelParams5[1] = " + display.modelParams5[1]);
1436
+ System.out.println("modelParams5[2] = " + display.modelParams5[2]);
1437
+ System.out.println("modelParams5[3] = " + display.modelParams5[3]);
1438
+ System.out.println("modelParams6[0] = " + display.modelParams6[0]);
1439
+ System.out.println("modelParams6[1] = " + display.modelParams6[1]);
1440
+ System.out.println("modelParams6[2] = " + display.modelParams6[2]);
1441
+ System.out.println("modelParams6[3] = " + display.modelParams6[3]);
1442
+ System.out.println("modelParams7[0] = " + display.modelParams7[0]);
1443
+ System.out.println("modelParams7[1] = " + display.modelParams7[1]);
1444
+ System.out.println("modelParams7[2] = " + display.modelParams7[2]);
1445
+ System.out.println("modelParams7[3] = " + display.modelParams7[3]);
1446
+ /**/
1447
+ //assert (display.modelParams6[2] == 0);
1448
+
1449
+ //System.out.println("noise power = " + display.modelParams7[0]);
1450
+ //System.out.println("shadowbias = " + shadowbias);
1451
+
1452
+ gl.glProgramEnvParameter4fvARB(gl.GL_FRAGMENT_PROGRAM_ARB, 0, display.modelParams0, 0);
1453
+ gl.glProgramEnvParameter4fvARB(gl.GL_FRAGMENT_PROGRAM_ARB, 1, display.modelParams1, 0);
1454
+ gl.glProgramEnvParameter4fvARB(gl.GL_FRAGMENT_PROGRAM_ARB, 2, display.modelParams2, 0);
1455
+ gl.glProgramEnvParameter4fvARB(gl.GL_FRAGMENT_PROGRAM_ARB, 3, display.modelParams3, 0);
1456
+ gl.glProgramEnvParameter4fvARB(gl.GL_FRAGMENT_PROGRAM_ARB, 4, display.modelParams4, 0);
1457
+ gl.glProgramEnvParameter4fvARB(gl.GL_FRAGMENT_PROGRAM_ARB, 5, display.modelParams5, 0);
1458
+ gl.glProgramEnvParameter4fvARB(gl.GL_FRAGMENT_PROGRAM_ARB, 6, display.modelParams6, 0);
1459
+ gl.glProgramEnvParameter4fvARB(gl.GL_FRAGMENT_PROGRAM_ARB, 7, display.modelParams7, 0);
1460
+
1461
+ int mode = display.FP_SHADER;
1462
+
1463
+ if (material.aniso != material.anisoV || material.aniso > 0.002)
1464
+ {
1465
+ mode |= display.FP_ANISO;
1466
+ }
1467
+
1468
+ display.EnableProgram(mode);
1469
+
1470
+ //System.out.println("opacity power = " + display.modelParams7[1]);
1471
+
1472
+ if (!material.multiply)
1473
+ {
1474
+ if (Globals.drawMode == CameraPane.SHADOW)
1475
+ gl.glDepthMask(material.opacity >= 0.9 && display.modelParams7[1] > 0.1);
1476
+ else
1477
+ gl.glDepthMask(material.opacity >= 0.99);
1478
+ }
2081479 }
2091480
2101481 int matrixdepth = 0; // 10000; // CONFLICT WITH cMESH... WARNING WARNING WARNING WARNING WARNING WARNING !!!!!!!!!!!! 0;
....@@ -225,7 +1496,7 @@
2251496 currentGL.glMultMatrixd(model, 0);
2261497 }
2271498
228
- void PushMatrix(double[][] matrix, int count)
1499
+ public void PushMatrix(double[][] matrix, int count) // INTERFACE
2291500 {
2301501 matrixdepth++;
2311502 // GrafreeD.tracein(matrix);
....@@ -270,7 +1541,7 @@
2701541
2711542 double[][] tmpmat = new double[4][4];
2721543
273
- void PopMatrix(double[][] inverse)
1544
+ public void PopMatrix(double[][] inverse) // INTERFACE
2741545 {
2751546 --matrixdepth;
2761547
....@@ -310,7 +1581,7 @@
3101581 PushTextureMatrix(matrix, 1);
3111582 }
3121583
313
- void PushTextureMatrix(double[][] matrix, int count)
1584
+ public void PushTextureMatrix(double[][] matrix, int count) // INTERFACE
3141585 {
3151586 currentGL.glActiveTexture(GetGL().GL_TEXTURE0);
3161587
....@@ -324,7 +1595,7 @@
3241595 currentGL.glMatrixMode(GetGL().GL_MODELVIEW);
3251596 }
3261597
327
- void PopTextureMatrix(double[][] inverse)
1598
+ public void PopTextureMatrix(double[][] inverse) // INTERFACE
3281599 {
3291600 currentGL.glActiveTexture(GetGL().GL_TEXTURE0);
3301601 currentGL.glMatrixMode(GetGL().GL_TEXTURE);
....@@ -351,15 +1622,15 @@
3511622
3521623 static int camerachangeframe;
3531624
354
- boolean SetCamera(Camera cam)
1625
+ public boolean SetCamera(Camera cam)
3551626 {
3561627 // may 2014 if (cam == cameras[0] || cam == cameras[1])
3571628 // return false;
3581629
359
- if (REFUSEMODE && isLIVE() && camerachangeframe != 0 && camerachangeframe != framecount)
1630
+ if (REFUSEMODE && Globals.isLIVE() && camerachangeframe != 0 && camerachangeframe != Globals.framecount)
3601631 {
3611632 // check for last change
362
- if (framecount < camerachangeframe + 400) // 120 == 1 second
1633
+ if (Globals.framecount < camerachangeframe + 400) // 120 == 1 second
3631634 {
3641635 // refuse the camera change
3651636 System.err.println("Camera " + cam + " REFUSED");
....@@ -367,7 +1638,7 @@
3671638 }
3681639 }
3691640
370
- camerachangeframe = framecount;
1641
+ camerachangeframe = Globals.framecount;
3711642
3721643 cam.hAspect = -1; // Read only
3731644
....@@ -398,7 +1669,7 @@
3981669 {
3991670 //System.err.println("Oeil on");
4001671 TRACK = true;
401
-// JUNE 2014 if (TRACK && trackedobject != null && drawMode == SHADOW) // && !lightMode)
1672
+// JUNE 2014 if (TRACK && trackedobject != null && DrawMode() == SHADOW) // && !lightMode)
4021673 // object.editWindow.ScreenFit(trackedobject);
4031674 //pingthread.StepToTarget(true);
4041675 }
....@@ -407,7 +1678,7 @@
4071678 {
4081679 //System.err.println("Oeil on");
4091680 OEIL = true;
410
- if ((TRACK || SHADOWTRACK) && trackedobject != null && drawMode == SHADOW) // && !lightMode)
1681
+ if ((TRACK || SHADOWTRACK) && trackedobject != null && DrawMode() == SHADOW) // && !lightMode)
4111682 object.editWindow.ScreenFit(trackedobject, SHADOWTRACK && !TRACK);
4121683 //pingthread.StepToTarget(true);
4131684 }
....@@ -471,39 +1742,12 @@
4711742 {
4721743 frozen ^= true;
4731744 // Weird...
474
- lighttouched = true;
1745
+ Globals.lighttouched = true;
4751746 }
4761747
4771748 void ToggleDL()
4781749 {
4791750 mainDL ^= true;
480
- }
481
-
482
- void ToggleTexture()
483
- {
484
- textureon ^= true;
485
- }
486
-
487
- void ToggleLive()
488
- {
489
- setLIVE(isLIVE() ^ true);
490
-
491
- System.err.println("LIVE = " + isLIVE());
492
-
493
- if (!isLIVE()) // save sound
494
- GrafreeD.savesound = true; // wav.save();
495
- // else
496
- repaint(); // start loop // may 2013
497
- }
498
-
499
- void ToggleSupport()
500
- {
501
- SUPPORT ^= true;
502
- }
503
-
504
- void ToggleAbort()
505
- {
506
- ABORTMODE ^= true;
5071751 }
5081752
5091753 void ToggleFullScreen()
....@@ -513,12 +1757,7 @@
5131757
5141758 void ToggleCrowd()
5151759 {
516
- CROWD ^= true;
517
- }
518
-
519
- void ToggleInertia()
520
- {
521
- INERTIA ^= true;
1760
+ Globals.CROWD ^= true;
5221761 }
5231762
5241763 void ToggleLocal()
....@@ -526,62 +1765,84 @@
5261765 LOCALTRANSFORM ^= true;
5271766 }
5281767
529
- void ToggleFast()
1768
+ public void ToggleTexture()
1769
+ {
1770
+ textureon ^= true;
1771
+ }
1772
+
1773
+ public void ToggleLive()
1774
+ {
1775
+ Globals.setLIVE(Globals.isLIVE() ^ true);
1776
+
1777
+ System.err.println("LIVE = " + Globals.isLIVE());
1778
+
1779
+ if (!Globals.isLIVE()) // save sound
1780
+ GrafreeD.savesound = true; // wav.save();
1781
+ // else
1782
+ repaint(); // start loop // may 2013
1783
+ }
1784
+
1785
+ public void ToggleSupport()
1786
+ {
1787
+ SUPPORT ^= true;
1788
+ }
1789
+
1790
+ public void ToggleAbort()
1791
+ {
1792
+ ABORTMODE ^= true;
1793
+ }
1794
+
1795
+ public void ToggleInertia()
1796
+ {
1797
+ INERTIA ^= true;
1798
+ }
1799
+
1800
+ public void ToggleFast()
5301801 {
5311802 FAST ^= true;
5321803 }
5331804
534
- void ToggleSlowPose()
1805
+ public void ToggleSlowPose()
5351806 {
5361807 SLOWPOSE ^= true;
5371808 }
5381809
539
- void ToggleFootContact()
540
- {
541
- FOOTCONTACT ^= true;
542
- }
543
-
544
- void ToggleBoxMode()
1810
+ public void ToggleBoxMode()
5451811 {
5461812 BOXMODE ^= true;
5471813 }
5481814
549
- void ToggleSmoothFocus()
1815
+ public void ToggleSmoothFocus()
5501816 {
5511817 SMOOTHFOCUS ^= true;
5521818 }
5531819
554
- void ToggleImageFlip()
1820
+ public void ToggleImageFlip()
5551821 {
5561822 IMAGEFLIP ^= true;
5571823 }
5581824
559
- void ToggleSpeakerMocap()
1825
+ public void ToggleSpeakerMocap()
5601826 {
5611827 SPEAKERMOCAP ^= true;
5621828 }
5631829
564
- void ToggleSpeakerCamera()
1830
+ public void ToggleSpeakerCamera()
5651831 {
5661832 SPEAKERCAMERA ^= true;
5671833 }
5681834
569
- void ToggleSpeakerFocus()
1835
+ public void ToggleSpeakerFocus()
5701836 {
5711837 SPEAKERFOCUS ^= true;
5721838 }
5731839
574
- void ToggleDebug()
575
- {
576
- DEBUG ^= true;
577
- }
578
-
579
- void ToggleFrustum()
1840
+ public void ToggleFrustum()
5801841 {
5811842 FRUSTUM ^= true;
5821843 }
5831844
584
- void ToggleTrack()
1845
+ public void ToggleTrack()
5851846 {
5861847 TRACK ^= true;
5871848 if (TRACK)
....@@ -600,25 +1861,35 @@
6001861 repaint();
6011862 }
6021863
603
- void ToggleTrackOnce()
1864
+ public void ToggleTrackOnce()
6041865 {
6051866 TRACKONCE ^= true;
6061867 }
6071868
608
- void ToggleShadowTrack()
1869
+ public void ToggleShadowTrack()
6091870 {
6101871 SHADOWTRACK ^= true;
6111872 repaint();
6121873 }
6131874
614
- void ToggleOeil()
1875
+ public void ToggleOeil()
6151876 {
6161877 OEIL ^= true;
6171878 }
6181879
619
- void ToggleOeilOnce()
1880
+ public void ToggleOeilOnce()
6201881 {
6211882 OEILONCE ^= true;
1883
+ }
1884
+
1885
+ void ToggleFootContact()
1886
+ {
1887
+ FOOTCONTACT ^= true;
1888
+ }
1889
+
1890
+ void ToggleDebug()
1891
+ {
1892
+ DEBUG ^= true;
6221893 }
6231894
6241895 void ToggleLookAt()
....@@ -672,34 +1943,6 @@
6721943 //assert (cam.hAspect == 0);
6731944 cam.hAspect = 0;
6741945 lightCamera = cam;
675
- }
676
-
677
- CameraPane(Object3D o, Camera cam, boolean withcontext)
678
- {
679
- super(defaultcaps, null, withcontext?glcontext:null, null);
680
-
681
- //System.out.println("AMERICA AREA = " + (9458886 + 9210755 + 8480395 + 2736391 + 1943018 + 1289475 + 1141569 + 1069350 + 911559 + 721229 + 395886 + 377972 + 246700 + 211156 + 173985 + 141133 + 118279 + 112079 + 108523));
682
- glcontext = getContext();
683
-
684
- cameras = new Camera[2];
685
- targetLookAts = new cVector[2];
686
-
687
- SetCamera(cam);
688
-
689
- SetLight(new Camera(new cVector(10, 10, -20)));
690
-
691
- object = o;
692
-
693
- setBackground(Color.white);
694
-
695
- addKeyListener(this);
696
- addMouseListener(this);
697
- addMouseMotionListener(this);
698
- addMouseWheelListener(this);
699
- //System.out.println("addGLEventListener: " + this);
700
- addGLEventListener(this);
701
-
702
-// pingthread.start(); // may 2013
7031946 }
7041947
7051948 private static void ApplyTransform(GL gl, Mat4f xform)
....@@ -759,7 +2002,7 @@
7592002
7602003 GL currentGL;
7612004
762
- GL GetGL()
2005
+ public GL GetGL() // INTERFACE
7632006 {
7642007 return currentGL;
7652008 }
....@@ -6271,7 +7514,7 @@
62717514 return null;
62727515 }
62737516
6274
- void ReleaseTextures(cTexture tex)
7517
+ public void ReleaseTextures(cTexture tex) // INTERFACE
62757518 {
62767519 if (/*tex == null ||*/ ambientOcclusion ) // || !textureon)
62777520 {
....@@ -6309,7 +7552,7 @@
63097552
63107553 void ReleaseTexture(String tex, boolean bump)
63117554 {
6312
- if (// drawMode != 0 || /*tex == null ||*/
7555
+ if (// DrawMode() != 0 || /*tex == null ||*/
63137556 ambientOcclusion ) // || !textureon)
63147557 {
63157558 return;
....@@ -6410,9 +7653,9 @@
64107653 }
64117654 }
64127655
6413
- /*boolean*/ void BindTextures(cTexture tex, int resolution)
7656
+ /*boolean*/ public void BindTextures(cTexture tex, int resolution) // INTERFACE
64147657 {
6415
- if (// drawMode != 0 || /*tex == null ||*/
7658
+ if (// DrawMode() != 0 || /*tex == null ||*/
64167659 ambientOcclusion ) // || !textureon)
64177660 {
64187661 return; // false;
....@@ -6708,7 +7951,7 @@
67087951 return texture!=null?texture.texture:null;
67097952 }
67107953
6711
- com.sun.opengl.util.texture.TextureData GetTextureData(String tex, boolean bump, int resolution)
7954
+ public com.sun.opengl.util.texture.TextureData GetTextureData(String tex, boolean bump, int resolution)
67127955 {
67137956 CacheTexture texture = GetCacheTexture(tex, bump, resolution);
67147957
....@@ -7312,9 +8555,9 @@
73128555 static boolean occlusionInitialized = false;
73138556 boolean selection = false;
73148557 boolean pointselection = false;
7315
- /*static*/ boolean lighttouched = true;
8558
+ ///*static*/ boolean lighttouched = true;
73168559 boolean deselect;
7317
- boolean ambientOcclusion = false;
8560
+ private boolean ambientOcclusion = false;
73188561 static boolean flash = false;
73198562 /*static*/ boolean wait = false;
73208563 boolean displaydone = false; // after repaint() calls
....@@ -7444,6 +8687,8 @@
74448687 //gl.glFrustum(-0.5*scale, 0.5*scale, -0.5*scale, 0.5*scale, 1, 100);
74458688 //glu.gluPerspective(lightshaper_fovy, 1, lightshaper_zNear, lightshaper_zFar);
74468689 double scale = lightCamera.SCALE / lightCamera.Distance();
8690
+// PATCH FILLE AUX JEANS
8691
+ //scale *= lightCamera.shaper_fovy / 25;
74478692 gl.glScaled(2 * scale, 2 * scale, -scale);
74488693 gl.glTranslated(0, 0, lightCamera.DECAL);
74498694
....@@ -7601,8 +8846,6 @@
76018846
76028847 boolean restartframe = false;
76038848
7604
- static int framecount = 0; // general-purpose global count
7605
-
76068849 void displayAntiAliased(javax.media.opengl.GL gl)
76078850 {
76088851 //gl.glGetIntegerv(gl.GL_ACCUM_RED_BITS, viewport, 0);
....@@ -7633,7 +8876,7 @@
76338876 gl.glClear(gl.GL_ACCUM_BUFFER_BIT);
76348877 for (jitter = 0; jitter < ACSIZE; jitter++) //, GrafreeD.wav.cursor += LIVE ? 735 : 0)
76358878 {
7636
- framecount++;
8879
+ Globals.framecount++;
76378880
76388881 if (CameraPane.tickcount > 0)
76398882 CameraPane.tickcount--;
....@@ -7671,7 +8914,7 @@
76718914
76728915 gl.glLightfv(gl.GL_LIGHT0, gl.GL_POSITION, pos, 0);
76738916 */
7674
- lighttouched = true;
8917
+ Globals.lighttouched = true;
76758918 //System.err.println(" shadowbuffer: " + jitter);
76768919 shadowbuffer.display();
76778920
....@@ -8618,13 +9861,6 @@
86189861 }
86199862 }
86209863
8621
- boolean IsFrozen()
8622
- {
8623
- boolean selectmode = drawMode == SELECTION || CameraPane.DEBUG_SELECTION;
8624
-
8625
- return !selectmode && cameracount == 0; // != 0;
8626
- }
8627
-
86289864 boolean niceon = false;
86299865 javax.swing.Timer AAtimer = new javax.swing.Timer(750, this);
86309866 boolean currentlydrawing = false;
....@@ -8642,8 +9878,8 @@
86429878 }
86439879 // if (DEBUG_SELECTION)
86449880 // {
8645
-// if (drawMode != SELECTION)
8646
-// drawMode = SELECTION;
9881
+// if (DrawMode() != SELECTION)
9882
+// DrawMode() = SELECTION;
86479883 // }
86489884
86499885 if (!isRenderer)
....@@ -8699,9 +9935,9 @@
86999935
87009936 //ANTIALIAS = 0;
87019937
8702
- if (drawMode == DEFAULT) // && CURRENTANTIALIAS > 0)
9938
+ if (DrawMode() == DEFAULT) // && CURRENTANTIALIAS > 0)
87039939 {
8704
- if (niceon || isLIVE())
9940
+ if (niceon || Globals.isLIVE())
87059941 {
87069942 //if(active == 0)
87079943 // antialiaser = null;
....@@ -8726,7 +9962,7 @@
87269962 assert eyeCamera.shaper_zFar == 1E5f; // 500.0f;
87279963 */
87289964
8729
- if (drawMode == DEFAULT)
9965
+ if (DrawMode() == DEFAULT)
87309966 {
87319967 currentlydrawing = true;
87329968 }
....@@ -8757,12 +9993,12 @@
87579993
87589994 // if(Applet3D.clipboard != null)
87599995 // System.out.println("Clipboard = " + Applet3D.clipboard); //.get(0).parent);
8760
-//drawMode = SELECTION;
9996
+//DrawMode() = SELECTION;
87619997 indexcount = 0;
87629998
8763
- if (drawMode == OCCLUSION)
9999
+ if (DrawMode() == OCCLUSION)
876410000 {
8765
- drawMode = DEFAULT;
10001
+ Globals.drawMode = DEFAULT; // WARNING
876610002 ambientOcclusion = true;
876710003 setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
876810004 Object3D theobject = object;
....@@ -8781,19 +10017,19 @@
878110017 ambientOcclusion = false;
878210018 }
878310019
8784
- if (lighttouched && drawMode == DEFAULT && !lightMode) // && !FROZEN)
10020
+ if (Globals.lighttouched && DrawMode() == DEFAULT && !lightMode) // && !FROZEN)
878510021 {
878610022 //if (RENDERSHADOW) // ?
878710023 if (!IsFrozen())
878810024 {
878910025 // dec 2012
8790
- if (!ambientOcclusion && !(!flash && !lightMode && drawMode == DEFAULT && ANTIALIAS > 0))
10026
+ if (!ambientOcclusion && !(!flash && !lightMode && DrawMode() == DEFAULT && ANTIALIAS > 0))
879110027 {
8792
- framecount++;
10028
+ Globals.framecount++;
879310029 shadowbuffer.display();
879410030 }
879510031 }
8796
- lighttouched = false; // ??
10032
+ Globals.lighttouched = false; // ??
879710033 //drawing = true;
879810034 //lighttouched = true;
879910035 }
....@@ -8814,9 +10050,9 @@
881410050 //eyeCamera.shaper_fovy = 1;
881510051 }
881610052
8817
- if ((RENDERPROGRAM != 0 || ambientOcclusion || spherical) && drawMode == DEFAULT) // SELECTION)
10053
+ if ((RENDERPROGRAM != 0 || ambientOcclusion || spherical) && DrawMode() == DEFAULT) // SELECTION)
881810054 {
8819
- //System.out.println("drawMode = " + drawMode);
10055
+ //System.out.println("DrawMode() = " + DrawMode());
882010056 vertexMode |= VP_PASS;
882110057 //vertexMode |= VP_PROJECTION;
882210058 if (!ambientOcclusion)
....@@ -8876,7 +10112,7 @@
887610112 Camera cam = renderCamera; // lightMode?lightCamera:eyeCamera;
887710113 //Camera lightcam = new Camera(light0);
887810114
8879
- if (drawMode == SHADOW)
10115
+ if (DrawMode() == SHADOW)
888010116 {
888110117 /*
888210118 gl.glMatrixMode(GL.GL_MODELVIEW);
....@@ -8966,7 +10202,7 @@
896610202 gl.glClear(gl.GL_DEPTH_BUFFER_BIT);
896710203 } else
896810204 {
8969
- if (drawMode != DEFAULT)
10205
+ if (DrawMode() != DEFAULT)
897010206 {
897110207 gl.glClearColor(1, 1, 1, 0);
897210208 } // 1);
....@@ -9031,7 +10267,7 @@
903110267
903210268 fast &= !ambientOcclusion;
903310269
9034
- if (drawMode == DEFAULT)
10270
+ if (DrawMode() == DEFAULT)
903510271 {
903610272 //gl.glEnable(gl.GL_ALPHA_TEST);
903710273 //gl.glActiveTexture(GL.GL_TEXTURE0);
....@@ -9092,6 +10328,8 @@
909210328 //gl.glFrustum(-0.5*scale, 0.5*scale, -0.5*scale, 0.5*scale, 1, 100);
909310329 //glu.gluPerspective(lightshaper_fovy, 1, lightshaper_zNear, lightshaper_zFar);
909410330 double scale = lightCamera.SCALE / lightCamera.Distance();
10331
+// PATCH FILLE AUX JEANS
10332
+ //scale *= lightCamera.shaper_fovy / 25;
909510333 gl.glScaled(2 * scale, 2 * scale, -scale);
909610334 gl.glTranslated(0, 0, lightCamera.DECAL);
909710335
....@@ -9227,10 +10465,12 @@
922710465 gl.glMatrixMode(gl.GL_PROJECTION);
922810466 gl.glLoadIdentity();
922910467
9230
- if (drawMode == SHADOW || cam == lightCamera) // || (vertexMode&VP_PROJECTION) != 0)
10468
+ if (DrawMode() == SHADOW || cam == lightCamera) // || (vertexMode&VP_PROJECTION) != 0)
923110469 {
923210470 //glu.gluPerspective(lightshaper_fovy, 1, lightshaper_zNear, lightshaper_zFar);
923310471 double scale = lightCamera.SCALE / lightCamera.Distance();
10472
+// PATCH FILLE AUX JEANS
10473
+ //scale *= lightCamera.shaper_fovy / 25;
923410474 gl.glScaled(2 * scale, 2 * scale, -scale);
923510475 gl.glTranslated(0, 0, lightCamera.DECAL);
923610476 //System.out.println("DECAL = " + LIGHTDECAL + "; SCALE = " + LIGHTSCALE);
....@@ -9283,7 +10523,7 @@
928310523 //gl.glPushMatrix();
928410524 gl.glLoadIdentity();
928510525
9286
- if (!ambientOcclusion) // drawMode != OCCLUSION)
10526
+ if (!ambientOcclusion) // DrawMode() != OCCLUSION)
928710527 {
928810528 //LA.xformPos(light0, lightCamera.fromScreen, light);
928910529 LA.xformDir(dirlight, lightCamera.fromScreen, lightposition);
....@@ -9370,7 +10610,7 @@
937010610 }
937110611
937210612 /**/
9373
- if (true) // drawMode == SELECTION) // != DEFAULT)
10613
+ if (true) // DrawMode() == SELECTION) // != DEFAULT)
937410614 gl.glDisable(gl.GL_LIGHTING);
937510615 else
937610616 gl.glEnable(gl.GL_LIGHTING);
....@@ -9388,7 +10628,7 @@
938810628
938910629 lightslot = 64;
939010630
9391
- if (!frozen && !ambientOcclusion && isRenderer && drawMode == DEFAULT)
10631
+ if (!frozen && !ambientOcclusion && isRenderer && DrawMode() == DEFAULT)
939210632 {
939310633 DrawLights(object);
939410634 }
....@@ -9399,7 +10639,7 @@
939910639 fragmentMode |= (lightslot - 64) << 2; // 1; // first bit is available for aniso
940010640 //System.out.println("fragmentMode = " + fragmentMode);
940110641
9402
- if (drawMode == DEFAULT || drawMode == SELECTION || DEBUG_SELECTION)
10642
+ if (DrawMode() == DEFAULT || DrawMode() == SELECTION || IsDebugSelection())
940310643 {
940410644 /*
940510645 if (CULLFACE || (ambientOcclusion && OCCLUSION_CULLING))
....@@ -9432,7 +10672,7 @@
943210672 }
943310673 }
943410674
9435
- if (drawMode == DEFAULT)
10675
+ if (DrawMode() == DEFAULT)
943610676 {
943710677 if (WIREFRAME && !ambientOcclusion)
943810678 {
....@@ -9450,7 +10690,7 @@
945010690 gl.glDisable(GL.GL_FRAGMENT_PROGRAM_ARB);
945110691 gl.glDisable(GL.GL_VERTEX_PROGRAM_ARB);
945210692
9453
- if (!fast/*RENDERPROGRAM != 0*/ && (drawMode == DEFAULT || drawMode == SHADOW)) // && !WIREFRAME) //
10693
+ if (!fast/*RENDERPROGRAM != 0*/ && (DrawMode() == DEFAULT || DrawMode() == SHADOW)) // && !WIREFRAME) //
945410694 {
945510695 if (vertexMode != 0) // && !fast)
945610696 {
....@@ -9470,7 +10710,7 @@
947010710 }
947110711 }
947210712
9473
- if (false) // fast && !IsFreezed() && drawMode != SELECTION && !ambientOcclusion)
10713
+ if (false) // fast && !IsFreezed() && DrawMode() != SELECTION && !ambientOcclusion)
947410714 {
947510715 //gl.glDepthFunc(GL.GL_LEQUAL);
947610716 //gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT);
....@@ -9498,7 +10738,7 @@
949810738 //gl.glDepthMask(false);
949910739 }
950010740
9501
- if (false) // drawMode == SHADOW)
10741
+ if (false) // DrawMode() == SHADOW)
950210742 {
950310743 //SetColumnMajorData(cameraInverseTransform, view_1);
950410744 //System.out.println("light = " + cameraInverseTransform);
....@@ -9512,16 +10752,16 @@
951210752 //System.out.println("object = " + object);
951310753 if (!frozen && !imageLocked)
951410754 {
9515
- if (!flash && !lightMode && drawMode == DEFAULT && ANTIALIAS > 0)
10755
+ if (!flash && !lightMode && DrawMode() == DEFAULT && ANTIALIAS > 0)
951610756 {
951710757 displayAntiAliased(gl);
951810758 } else
951910759 {
952010760 programcount = 0;
9521
- int keepmode = drawMode;
10761
+ int keepmode = DrawMode();
952210762 // if (DEBUG_SELECTION)
952310763 // {
9524
-// drawMode = SELECTION;
10764
+// DrawMode() = SELECTION;
952510765 // }
952610766 // for point selection
952710767 // gl.glGetDoublev(gl.GL_MODELVIEW_MATRIX, tempmat, 0);
....@@ -9531,10 +10771,10 @@
953110771 DrawObject(gl);
953210772
953310773 // jan 2013 System.err.println("RESET ABORT (display)");
9534
- // if (drawMode == DEFAULT)
10774
+ // if (DrawMode() == DEFAULT)
953510775 // ABORTED = false;
953610776 fullreset = false;
9537
- drawMode = keepmode;
10777
+ Globals.drawMode = keepmode; // WARNING
953810778 //System.out.println("PROGRAM SWITCH " + programcount);
953910779 }
954010780 }
....@@ -9542,11 +10782,11 @@
954210782 gl.glDisable(GL.GL_VERTEX_PROGRAM_ARB);
954310783 gl.glDisable(GL.GL_FRAGMENT_PROGRAM_ARB);
954410784
9545
- if (drawMode == DEFAULT)
10785
+ if (DrawMode() == DEFAULT)
954610786 {
954710787 ReleaseTexture(NOISE_TEXTURE, false);
954810788 }
9549
- //if (drawMode == DEFAULT)
10789
+ //if (DrawMode() == DEFAULT)
955010790 {
955110791
955210792 gl.glActiveTexture(GL.GL_TEXTURE1);
....@@ -9558,7 +10798,7 @@
955810798 //else
955910799 //gl.glDisable(gl.GL_TEXTURE_2D);
956010800 //gl.glPopMatrix();
9561
- if (imageCompleted && ANTIALIAS > 0 && drawMode == DEFAULT && cam != lightCamera && !ambientOcclusion)
10801
+ if (imageCompleted && ANTIALIAS > 0 && DrawMode() == DEFAULT && cam != lightCamera && !ambientOcclusion)
956210802 {
956310803 //new Exception().printStackTrace();
956410804 //System.out.println("Draw image " + width + ", " + height);
....@@ -9600,7 +10840,7 @@
960010840 //gl.glFlush();
960110841 }
960210842
9603
- if (flash && drawMode == DEFAULT)
10843
+ if (flash && DrawMode() == DEFAULT)
960410844 {
960510845 flash = false;
960610846 wait = true;
....@@ -9608,9 +10848,9 @@
960810848 }
960910849
961010850 //drawing = false;
9611
- //if(drawMode == DEFAULT)
10851
+ //if(DrawMode() == DEFAULT)
961210852 // niceon = false;
9613
- if (drawMode == DEFAULT)
10853
+ if (DrawMode() == DEFAULT)
961410854 {
961510855 currentlydrawing = false;
961610856 }
....@@ -9630,7 +10870,7 @@
963010870 repaint();
963110871 }
963210872
9633
- if (isLIVE() && drawMode == DEFAULT) // may 2013
10873
+ if (Globals.isLIVE() && DrawMode() == DEFAULT) // may 2013
963410874 repaint();
963510875
963610876 displaydone = true;
....@@ -9667,7 +10907,7 @@
966710907 if (GrafreeD.RENDERME > 0)
966810908 GrafreeD.RENDERME--; // mechante magouille
966910909
9670
- ONESTEP = false;
10910
+ Globals.ONESTEP = false;
967110911 }
967210912
967310913 static boolean zoomonce = false;
....@@ -9675,11 +10915,11 @@
967510915 void DrawObject(GL gl, boolean draw)
967610916 {
967710917 //System.out.println("DRAW OBJECT " + mouseDown);
9678
-// drawMode = SELECTION;
10918
+// DrawMode() = SELECTION;
967910919 //GL gl = getGL();
968010920 if ((TRACK || SHADOWTRACK) || zoomonce)
968110921 {
9682
- if ((TRACK || SHADOWTRACK) && trackedobject != null && drawMode == SHADOW) // && !lightMode)
10922
+ if ((TRACK || SHADOWTRACK) && trackedobject != null && DrawMode() == SHADOW) // && !lightMode)
968310923 object.editWindow.ScreenFit(trackedobject, SHADOWTRACK && !TRACK);
968410924 pingthread.StepToTarget(true); // true);
968510925 // zoomonce = false;
....@@ -9700,9 +10940,9 @@
970010940 callist = gl.glGenLists(1);
970110941 }
970210942
9703
- boolean selectmode = drawMode == SELECTION || CameraPane.DEBUG_SELECTION;
10943
+ boolean selectmode = DrawMode() == SELECTION || IsDebugSelection();
970410944
9705
- boolean active = !selectmode; // drawMode != SELECTION; // mouseDown;
10945
+ boolean active = !selectmode; // DrawMode() != SELECTION; // mouseDown;
970610946
970710947 if (!mainDL || !active || touched)
970810948 {
....@@ -9729,7 +10969,7 @@
972910969 PushMatrix(ClickInfo.matbuffer);
973010970 }
973110971
9732
- if (drawMode == 0)
10972
+ if (DrawMode() == 0)
973310973 {
973410974 // System.out.println("CLEAR +++++++++++++++ +++++++++++++++ +++++++++++++++ +++++++++++++++");
973510975
....@@ -9743,7 +10983,7 @@
974310983 // DRAW
974410984 object.draw(this, /*(Composite)*/ object, false, false);
974510985
9746
- if (drawMode == DEFAULT)
10986
+ if (DrawMode() == DEFAULT)
974710987 {
974810988 if (DEBUG)
974910989 {
....@@ -9754,40 +10994,40 @@
975410994 selectedpoint.radius = radius;
975510995 selectedpoint.recalculate();
975610996 selectedpoint.material = new cMaterial();
9757
- selectedpoint.material.color = 0.15f;
10997
+ selectedpoint.material.color = 0.15f; // Yellow
975810998 selectedpoint.material.modulation = 0.75f;
975910999
9760
- debugpoint.radius = radius;
9761
- debugpoint.recalculate();
9762
- debugpoint.material = new cMaterial();
9763
- debugpoint.material.color = 0.25f;
9764
- debugpoint.material.modulation = 0.75f;
11000
+ debugpointG.radius = radius;
11001
+ debugpointG.recalculate();
11002
+ debugpointG.material = new cMaterial();
11003
+ debugpointG.material.color = 0.25f; // Green
11004
+ debugpointG.material.modulation = 0.75f;
976511005
9766
- debugpoint2.radius = radius;
9767
- debugpoint2.recalculate();
9768
- debugpoint2.material = new cMaterial();
9769
- debugpoint2.material.color = 0.75f;
9770
- debugpoint2.material.modulation = 0.75f;
11006
+ debugpointP.radius = radius;
11007
+ debugpointP.recalculate();
11008
+ debugpointP.material = new cMaterial();
11009
+ debugpointP.material.color = 0.75f; // Purple
11010
+ debugpointP.material.modulation = 0.75f;
977111011
9772
- debugpoint3.radius = radius;
9773
- debugpoint3.recalculate();
9774
- debugpoint3.material = new cMaterial();
9775
- debugpoint3.material.color = 0.5f;
9776
- debugpoint3.material.modulation = 0.75f;
11012
+ debugpointC.radius = radius;
11013
+ debugpointC.recalculate();
11014
+ debugpointC.material = new cMaterial();
11015
+ debugpointC.material.color = 0.5f; // Cyan
11016
+ debugpointC.material.modulation = 0.75f;
977711017
9778
- debugpoint4.radius = radius;
9779
- debugpoint4.recalculate();
9780
- debugpoint4.material = new cMaterial();
9781
- debugpoint4.material.color = 0f;
9782
- debugpoint4.material.modulation = 0.75f;
11018
+ debugpointR.radius = radius;
11019
+ debugpointR.recalculate();
11020
+ debugpointR.material = new cMaterial();
11021
+ debugpointR.material.color = 0f; // Red
11022
+ debugpointR.material.modulation = 0.75f;
978311023
978411024 InitPoints(radius);
978511025 }
978611026 selectedpoint.draw(this, /*(Composite)*/ null, false, false);
9787
- debugpoint.draw(this, /*(Composite)*/ null, false,false);
9788
- debugpoint2.draw(this, /*(Composite)*/ null, false,false);
9789
- debugpoint3.draw(this, /*(Composite)*/ null, false,false);
9790
- debugpoint4.draw(this, /*(Composite)*/ null, false,false);
11027
+ debugpointG.draw(this, /*(Composite)*/ null, false,false);
11028
+ debugpointP.draw(this, /*(Composite)*/ null, false,false);
11029
+ debugpointC.draw(this, /*(Composite)*/ null, false,false);
11030
+ debugpointR.draw(this, /*(Composite)*/ null, false,false);
979111031 // DrawPoints(this);
979211032 }
979311033
....@@ -9795,7 +11035,7 @@
979511035 }
979611036 // GrafreeD.traceoff();
979711037 //System.out.println(stackdepth);
9798
- if (drawMode == 0)
11038
+ if (DrawMode() == 0)
979911039 {
980011040 ReleaseTextures(DEFAULT_TEXTURES);
980111041
....@@ -9820,17 +11060,19 @@
982011060
982111061 checker = null;
982211062
9823
- if (!ambientOcclusion && !IsFrozen() && drawMode == DEFAULT)
11063
+ if (!ambientOcclusion && !IsFrozen() && DrawMode() == DEFAULT)
982411064 FindChecker(object);
982511065
9826
- if (checker != null && drawMode == DEFAULT)
11066
+ if (checker != null && DrawMode() == DEFAULT)
982711067 {
9828
- // BindTexture(IMMORTAL_TEXTURE);
11068
+ //BindTexture(IMMORTAL_TEXTURE);
11069
+ BindTextures(checker.GetTextures(), checker.texres);
982911070 // NEAREST
983011071 GetGL().glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_NEAREST); // GL.GL_LINEAR);
983111072 DrawChecker(gl);
983211073 //checker.Draw(this, null, false);
983311074 // ReleaseTexture(IMMORTAL_TEXTURE);
11075
+ ReleaseTextures(checker.GetTextures());
983411076 }
983511077
983611078 if (object.parent != null)
....@@ -9843,7 +11085,7 @@
984311085 //gl.glDisable(GL.GL_VERTEX_PROGRAM_ARB);
984411086 //gl.glDisable(GL.GL_FRAGMENT_PROGRAM_ARB);
984511087
9846
- if (DISPLAYTEXT && drawMode == DEFAULT)
11088
+ if (DISPLAYTEXT && DrawMode() == DEFAULT)
984711089 {
984811090 // Draw it once, then use the raster
984911091 Balloon(gl, balloon.createGraphics());
....@@ -9899,9 +11141,9 @@
989911141 int[] xs = new int[3];
990011142 int[] ys = new int[3];
990111143
9902
- void DrawString(Object3D obj) // String string)
11144
+ public void DrawString(Object3D obj) // String string) // INTERFACE
990311145 {
9904
- if (!DISPLAYTEXT || drawMode != DEFAULT)
11146
+ if (!DISPLAYTEXT || DrawMode() != DEFAULT)
990511147 {
990611148 return;
990711149 }
....@@ -10388,6 +11630,7 @@
1038811630 "PARAM lodbias = { 10,10,10,10 };" + // 20, -2, -20, 1.0 };" +
1038911631 "PARAM infinity = { 100000000, 100000000, 100000000, 1.0 };" +
1039011632 "PARAM one2048th = { 0.00048828125, 0.00048828125, 0.00048828125, 1.0 };" +
11633
+ "PARAM ninetenth = { 0.9, 0.9, 0.9, 1.0 };" +
1039111634 "PARAM almostone = { 0.999, 0.999, 0.999, 1.0 };" +
1039211635 "PARAM c256 = { 256, 256, 256, 1.0 };" +
1039311636 "PARAM c256i = { 0.00390625, 0.00390625, 0.00390625, 1.0 };" +
....@@ -11302,6 +12545,7 @@
1130212545 String Shadow(String depth, String shadow)
1130312546 {
1130412547 return "MAX temp.x, ndotl.x, one64th.x;" +
12548
+ "MIN temp.x, temp.x, ninetenth.x;" +
1130512549 /**/
1130612550 // Sine
1130712551 "MUL temp.y, temp.x, temp.x;" +
....@@ -11926,9 +13170,10 @@
1192613170 return;
1192713171 }
1192813172
13173
+ boolean capsLocked = Toolkit.getDefaultToolkit().getLockingKeyState(KeyEvent.VK_CAPS_LOCK);
1192913174
1193013175 // TIMER
11931
- if (!wheeltimer.isRunning() && e.getModifiersEx() == 0) // VR
13176
+ if (!wheeltimer.isRunning() && e.getModifiersEx() == 0 && !capsLocked) // VR
1193213177 {
1193313178 keepboxmode = BOXMODE;
1193413179 keepsupport = SUPPORT;
....@@ -12057,7 +13302,7 @@
1205713302 // ObjEditor.tweenManager.update(1f / 60f);
1205813303
1205913304 // fev 2014???
12060
- if ((TRACK || SHADOWTRACK) && trackedobject != null) // && drawMode == SHADOW) // && !lightMode)
13305
+ if ((TRACK || SHADOWTRACK) && trackedobject != null) // && DrawMode() == SHADOW) // && !lightMode)
1206113306 object.editWindow.ScreenFit(trackedobject, SHADOWTRACK && !TRACK);
1206213307 pingthread.StepToTarget(true); // true);
1206313308 }
....@@ -12169,6 +13414,11 @@
1216913414 cVector tmp = new cVector();
1217013415 cVector tmp2 = new cVector();
1217113416 boolean isMoving;
13417
+
13418
+ public cVector TargetLookAt()
13419
+ {
13420
+ return targetLookAt;
13421
+ }
1217213422
1217313423 class PingThread extends Thread
1217413424 {
....@@ -12308,7 +13558,7 @@
1230813558 //System.out.println("---------------- ---------- Paint " + tmp.length2());
1230913559 if (lightMode)
1231013560 {
12311
- lighttouched = true;
13561
+ Globals.lighttouched = true;
1231213562 }
1231313563
1231413564 if (OEILONCE && OEIL)
....@@ -12366,7 +13616,7 @@
1236613616 mouseDown = false;
1236713617 if (lightMode)
1236813618 {
12369
- lighttouched = true;
13619
+ Globals.lighttouched = true;
1237013620 }
1237113621 repaint();
1237213622 alreadypainted = true;
....@@ -12374,7 +13624,7 @@
1237413624 isMoving = false;
1237513625 } //??
1237613626
12377
- if (isLIVE() && !alreadypainted)
13627
+ if (Globals.isLIVE() && !alreadypainted)
1237813628 {
1237913629 // FOR DEBUG BREAKPOINT USING PAUSE: while (true)
1238013630 repaint();
....@@ -12386,7 +13636,7 @@
1238613636 {
1238713637 if (lightMode)
1238813638 {
12389
- lighttouched = true;
13639
+ Globals.lighttouched = true;
1239013640 }
1239113641 drag(X, (mouseMode != 0) ? Y : anchorY, MODIFIERS);
1239213642 }
....@@ -12629,6 +13879,7 @@
1262913879 {
1263013880 manipCamera.Translate(dx, dy, getWidth());
1263113881 }
13882
+ else
1263213883 if ((mouseMode & ZOOM) == 0 && (mouseMode & VR) != 0)
1263313884 {
1263413885 manipCamera.RotateInterest(dx, dy);
....@@ -12639,7 +13890,7 @@
1263913890
1264013891 if (manipCamera == lightCamera)
1264113892 {
12642
- lighttouched = true;
13893
+ Globals.lighttouched = true;
1264313894 }
1264413895 /*
1264513896 switch (mode)
....@@ -12862,7 +14113,7 @@
1286214113 }
1286314114 if ((modifiers & CTRLCLICK) == CTRLCLICK)
1286414115 {
12865
- mouseMode |= SELECT; // BACKFORTH;
14116
+ mouseMode |= SELECT;
1286614117 }
1286714118 if ((modifiers & COMMAND) == COMMAND)
1286814119 {
....@@ -12900,7 +14151,7 @@
1290014151 SetMouseMode(modifiers);
1290114152 }
1290214153
12903
- theRenderer.keyPressed(key);
14154
+ Globals.theRenderer.keyPressed(key);
1290414155 }
1290514156
1290614157 int kompactbit = 4; // power bit
....@@ -12912,7 +14163,7 @@
1291214163 float SATPOW = 1; // 2; // 0.5f;
1291314164 float BRIPOW = 1; // 0.5f; // 0.5f;
1291414165
12915
- void keyPressed(int key)
14166
+ public void keyPressed(int key)
1291614167 {
1291714168 if (key >= '0' && key <= '5')
1291814169 clampbit = (key-'0');
....@@ -13027,7 +14278,7 @@
1302714278 case 'B':
1302814279 BRISMOOTH ^= true;
1302914280 SHADOWCULLFACE ^= true;
13030
- lighttouched = true;
14281
+ Globals.lighttouched = true;
1303114282 repaint();
1303214283 break;
1303314284 case 'b':
....@@ -13127,7 +14378,7 @@
1312714378 repaint();
1312814379 break;
1312914380 case 'O':
13130
- drawMode = OCCLUSION;
14381
+ Globals.drawMode = OCCLUSION; // WARNING
1313114382 repaint();
1313214383 break;
1313314384 case 'o':
....@@ -13218,7 +14469,7 @@
1321814469 break;
1321914470 case ' ':
1322014471 lightMode ^= true;
13221
- lighttouched = true;
14472
+ Globals.lighttouched = true;
1322214473 manipCamera = renderCamera = lightMode ? lightCamera : eyeCamera;
1322314474 targetLookAt.set(manipCamera.lookAt);
1322414475 repaint();
....@@ -13230,11 +14481,11 @@
1323014481 repaint();
1323114482 break;
1323214483 case 'Z':
13233
- RESIZETEXTURE ^= true;
13234
- break;
14484
+ //RESIZETEXTURE ^= true;
14485
+ //break;
1323514486 case 'z':
1323614487 RENDERSHADOW ^= true;
13237
- lighttouched = true;
14488
+ Globals.lighttouched = true;
1323814489 repaint();
1323914490 break;
1324014491 //case UP:
....@@ -13349,6 +14600,7 @@
1334914600 }
1335014601 //System.out.println("shaper_fovy = " + manipCamera.shaper_fovy);
1335114602 }
14603
+
1335214604 static double OCCLUSIONBOOST = 1; // 0.5;
1335314605
1335414606 void keyReleased(int key, int modifiers)
....@@ -13360,7 +14612,7 @@
1336014612 }
1336114613 }
1336214614
13363
- protected void processKeyEvent(KeyEvent e)
14615
+ public void processKeyEvent(KeyEvent e)
1336414616 {
1336514617 switch (e.getID())
1336614618 {
....@@ -13836,6 +15088,7 @@
1383615088 //if (g != gr) g.drawImage(img, 0, 0, width, height, null);
1383715089 }
1383815090
15091
+ // To avoid clear.
1383915092 public void update(Graphics g)
1384015093 {
1384115094 paint(g);
....@@ -14438,7 +15691,7 @@
1443815691 gl.glPushAttrib(GL.GL_ALL_ATTRIB_BITS);
1443915692 gl.glPushMatrix();
1444015693 gl.glLoadIdentity();
14441
- PushMatrix(checker.toParent);
15694
+ //PushMatrix(checker.toParent);
1444215695
1444315696 gl.glMatrixMode(GL.GL_TEXTURE);
1444415697 gl.glPushMatrix();
....@@ -14461,8 +15714,8 @@
1446115714
1446215715 gl.glNormal3f(0.0f, 0.0f, 1.0f);
1446315716
14464
- float step = 0.1666f; //0.25f;
14465
- float stepv = step * 1652 / 998;
15717
+ float step = 2; // 0.1666f; //0.25f;
15718
+ float stepv = 2; // step * 1652 / 998;
1446615719
1446715720 int i0 = 0;
1446815721 /*
....@@ -14498,20 +15751,21 @@
1449815751 /**/
1449915752 //checker.GetMaterial().opacity = 1.1f;
1450015753 ////checker.GetMaterial().ambient = 0.99f;
14501
- Object3D.materialstack[Object3D.materialdepth] = checker.material;
14502
- Object3D.selectedstack[Object3D.materialdepth] = false;
14503
- cStatic.objectstack[Object3D.materialdepth++] = checker;
15754
+ materialstack[materialdepth] = checker.material;
15755
+ selectedstack[materialdepth] = false;
15756
+ cStatic.objectstack[materialdepth++] = checker;
1450415757 //System.out.println("material " + material);
1450515758 //Applet3D.tracein(this, selected);
1450615759 vector2buffer = checker.projectedVertices;
1450715760
14508
- checker.GetMaterial().Draw(this, false); // true);
15761
+ //checker.GetMaterial().Draw(this, false); // true);
15762
+ DrawMaterial(checker.GetMaterial(), false); // true);
1450915763
14510
- Object3D.materialdepth -= 1;
14511
- if (Object3D.materialdepth > 0)
15764
+ materialdepth -= 1;
15765
+ if (materialdepth > 0)
1451215766 {
14513
- vector2buffer = cStatic.objectstack[Object3D.materialdepth - 1].projectedVertices;
14514
- Object3D.materialstack[Object3D.materialdepth - 1].Draw(this, Object3D.selectedstack[Object3D.materialdepth - 1]);
15767
+ vector2buffer = cStatic.objectstack[materialdepth - 1].projectedVertices;
15768
+ DrawMaterial(materialstack[materialdepth - 1], selectedstack[materialdepth - 1]);
1451515769 }
1451615770 //checker.GetMaterial().opacity = 1f;
1451715771 ////checker.GetMaterial().ambient = 1f;
....@@ -14532,15 +15786,27 @@
1453215786
1453315787 //float u = (i+1)/2;
1453415788 //float v = (j+1)/2;
14535
- gl.glTexCoord2f((i + 1) / 2, (j + 1) / 2); // (1,0) // (i+1+step)/2,(j+1)/2);
15789
+ if (checker.flipV)
15790
+ gl.glTexCoord2f((i + 1) / 2, 1 - (j + 1) / 2);
15791
+ else
15792
+ gl.glTexCoord2f((i + 1) / 2, (j + 1) / 2); // (1,0) // (i+1+step)/2,(j+1)/2);
1453615793 gl.glVertex3f(i, j, -0.5f);
1453715794
15795
+ if (checker.flipV)
15796
+ gl.glTexCoord2f((i + 1 + step) / 2, 1 - (j + 1) / 2); // (1,1) // (i+1+step)/2,(j+1+step)/2);
15797
+ else
1453815798 gl.glTexCoord2f((i + 1 + step) / 2, (j + 1) / 2); // (1,1) // (i+1+step)/2,(j+1+step)/2);
1453915799 gl.glVertex3f(i + step, j, -0.5f);
1454015800
15801
+ if (checker.flipV)
15802
+ gl.glTexCoord2f((i + 1 + step) / 2, 1 - (j + 1 + stepv) / 2); // (0,1) //(i+1)/2,(j+1+step)/2);
15803
+ else
1454115804 gl.glTexCoord2f((i + 1 + step) / 2, (j + 1 + stepv) / 2); // (0,1) //(i+1)/2,(j+1+step)/2);
1454215805 gl.glVertex3f(i + step, j + stepv, -0.5f);
1454315806
15807
+ if (checker.flipV)
15808
+ gl.glTexCoord2f((i + 1) / 2, 1 - (j + 1 + stepv) / 2); // (0,0) //(i+1)/2,(j+1)/2);
15809
+ else
1454415810 gl.glTexCoord2f((i + 1) / 2, (j + 1 + stepv) / 2); // (0,0) //(i+1)/2,(j+1)/2);
1454515811 gl.glVertex3f(i, j + stepv, -0.5f);
1454615812 }
....@@ -14552,7 +15818,7 @@
1455215818 gl.glMatrixMode(GL.GL_PROJECTION);
1455315819 gl.glPopMatrix();
1455415820 gl.glMatrixMode(GL.GL_MODELVIEW);
14555
- PopMatrix(null); // checker.toParent); // null);
15821
+ //PopMatrix(null); // checker.toParent); // null);
1455615822 gl.glPopMatrix();
1455715823 PopTextureMatrix(checker.toParent);
1455815824 gl.glMatrixMode(GL.GL_TEXTURE);
....@@ -14665,14 +15931,14 @@
1466515931
1466615932 //int tmp = selection_view;
1466715933 //selection_view = -1;
14668
- int temp = drawMode;
14669
- drawMode = SELECTION;
15934
+ int temp = DrawMode();
15935
+ Globals.drawMode = SELECTION; // WARNING
1467015936 indexcount = 0;
1467115937 parent.display(drawable);
1467215938 //selection_view = tmp;
1467315939 //if (temp == SELECTION)
1467415940 // temp = DEFAULT; // patch for selection debug
14675
- drawMode = temp;
15941
+ Globals.drawMode = temp; // WARNING
1467615942
1467715943 //gl.glBindTexture(GL.GL_TEXTURE_2D, selection_view);
1467815944
....@@ -14945,14 +16211,14 @@
1494516211 //gl.glColorMask(false, false, false, false);
1494616212
1494716213 //render_scene_from_light_view(gl, drawable, 0, 0);
14948
- if (RENDERSHADOW && lighttouched && !movingcamera) // && !parent.IsFreezed())
16214
+ if (RENDERSHADOW && Globals.lighttouched && !movingcamera) // && !parent.IsFreezed())
1494916215 {
1495016216 gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
1495116217
14952
- int temp = drawMode;
14953
- drawMode = SHADOW;
16218
+ int temp = DrawMode();
16219
+ Globals.drawMode = SHADOW; // WARNING
1495416220 parent.display(drawable);
14955
- drawMode = temp;
16221
+ Globals.drawMode = temp; // WARNING
1495616222 }
1495716223
1495816224 gl.glCullFace(gl.GL_BACK);
....@@ -15005,7 +16271,6 @@
1500516271
1500616272 class AntialiasBuffer implements GLEventListener
1500716273 {
15008
-
1500916274 CameraPane parent = null;
1501016275
1501116276 AntialiasBuffer(CameraPane p)
....@@ -15115,13 +16380,19 @@
1511516380 gl.glFlush();
1511616381
1511716382 /**/
15118
- gl.glReadPixels(0, 0, OCCLUSION_SIZE, OCCLUSION_SIZE, GL.GL_BGRA, GL.GL_UNSIGNED_INT_8_8_8_8_REV, occlusionsizebuffer);
16383
+ gl.glReadPixels(0, 0, OCCLUSION_SIZE, OCCLUSION_SIZE, GL.GL_DEPTH_COMPONENT, GL.GL_FLOAT, occlusionsizebuffer);
1511916384
15120
- int[] pixels = occlusionsizebuffer.array();
16385
+ float[] pixels = occlusionsizebuffer.array();
1512116386
1512216387 double r = 0, g = 0, b = 0;
1512316388
1512416389 double count = 0;
16390
+
16391
+ gl.glGetDoublev(gl.GL_PROJECTION_MATRIX, tempmat2, 0);
16392
+
16393
+ float mindepth = 1;
16394
+
16395
+ double FACTOR = 1;
1512516396
1512616397 for (int i = 0; i < pixels.length; i++)
1512716398 {
....@@ -15206,7 +16477,7 @@
1520616477
1520716478 double scale = ray.z; // 1; // cos
1520816479
15209
- int p = pixels[newindex];
16480
+ float depth = pixels[newindex];
1521016481
1521116482 /*
1521216483 int newindex2 = (x + 1) * OCCLUSION_SIZE + y;
....@@ -15230,10 +16501,23 @@
1523016501 scale = (1 - modu) * modv;
1523116502 */
1523216503
15233
- r += ((p >> 16) & 0xFF) * scale / 255;
15234
- g += ((p >> 8) & 0xFF) * scale / 255;
15235
- b += (p & 0xFF) * scale / 255;
16504
+ //r += ((p >> 16) & 0xFF) * scale / 255;
16505
+ //g += ((p >> 8) & 0xFF) * scale / 255;
16506
+ //b += (p & 0xFF) * scale / 255;
16507
+
16508
+ if (mindepth > depth)
16509
+ {
16510
+ mindepth = depth;
16511
+ }
1523616512
16513
+ double z_eye = tempmat2[3*4 + 2] / (depth * -2.0 + 1.0 - tempmat2[2*4 + 2]);
16514
+
16515
+ double factor = 1 - Math.exp(-z_eye * z_eye / FACTOR);
16516
+
16517
+ r += factor * scale;
16518
+ g += factor * scale;
16519
+ b += factor * scale;
16520
+
1523716521 count += scale;
1523816522 }
1523916523
....@@ -15331,12 +16615,6 @@
1533116615 GLUT glut = new GLUT();
1533216616
1533316617
15334
- static final public int DEFAULT = 0;
15335
- static final public int SELECTION = 1;
15336
- static final public int SHADOW = 2;
15337
- static final public int OCCLUSION = 3;
15338
- static
15339
- public int drawMode = DEFAULT;
1534016618 public boolean spherical = false;
1534116619 static boolean DEBUG_OCCLUSION = false;
1534216620 static boolean DEBUG_SELECTION = false;
....@@ -15351,10 +16629,10 @@
1535116629 //double[] selectedpoint = new double[3];
1535216630 static Superellipsoid selectedpoint = new Superellipsoid();
1535316631 static Sphere previousselectedpoint = null;
15354
- static Sphere debugpoint = new Sphere();
15355
- static Sphere debugpoint2 = new Sphere();
15356
- static Sphere debugpoint3 = new Sphere();
15357
- static Sphere debugpoint4 = new Sphere();
16632
+ static Sphere debugpointG = new Sphere();
16633
+ static Sphere debugpointP = new Sphere();
16634
+ static Sphere debugpointC = new Sphere();
16635
+ static Sphere debugpointR = new Sphere();
1535816636
1535916637 static Sphere debugpoints[] = new Sphere[8];
1536016638
....@@ -15385,7 +16663,7 @@
1538516663 }
1538616664 }
1538716665
15388
- static void DrawPoints(CameraPane cpane)
16666
+ static void DrawPoints(iCameraPane cpane)
1538916667 {
1539016668 for (int i=0; i<8; i++) // first and last are red
1539116669 {
....@@ -15407,7 +16685,8 @@
1540716685 static IntBuffer texturesizebuffer = IntBuffer.allocate(TEX_SIZE * TEX_SIZE);
1540816686 static IntBuffer selectsizebuffer = IntBuffer.allocate(SELECT_SIZE * SELECT_SIZE);
1540916687 static java.nio.FloatBuffer pointselectsizebuffer = java.nio.FloatBuffer.allocate(SELECT_SIZE * SELECT_SIZE);
15410
- static IntBuffer occlusionsizebuffer = IntBuffer.allocate(OCCLUSION_SIZE * OCCLUSION_SIZE);
16688
+ //static IntBuffer occlusionsizebuffer = IntBuffer.allocate(OCCLUSION_SIZE * OCCLUSION_SIZE);
16689
+ static java.nio.FloatBuffer occlusionsizebuffer = java.nio.FloatBuffer.allocate(OCCLUSION_SIZE * OCCLUSION_SIZE);
1541116690 static BufferedImage bufimage = new BufferedImage(TEX_SIZE, TEX_SIZE, BufferedImage.TYPE_INT_RGB);
1541216691 static BufferedImage textest = new cBufferedImage(1, 1, BufferedImage.TYPE_INT_ARGB);
1541316692 static java.util.Vector<BufferedImage> billboards = new java.util.Vector<BufferedImage>();