picrate 0.2.0-java → 0.3.0-java

Sign up to get free protection for your applications and to get access to all the features.
Files changed (38) hide show
  1. checksums.yaml +4 -4
  2. data/README.md +8 -5
  3. data/Rakefile +10 -2
  4. data/docs/_posts/2018-06-26-auto_install_picrate.md +15 -0
  5. data/lib/export.txt +8 -0
  6. data/lib/picrate/app.rb +4 -4
  7. data/lib/picrate/version.rb +1 -1
  8. data/picrate.gemspec +1 -1
  9. data/pom.rb +1 -1
  10. data/pom.xml +1 -1
  11. data/src/main/java/processing/awt/PGraphicsJava2D.java +16 -85
  12. data/src/main/java/processing/awt/PShapeJava2D.java +9 -33
  13. data/src/main/java/processing/awt/PSurfaceAWT.java +76 -169
  14. data/src/main/java/processing/core/PApplet.java +14019 -15963
  15. data/src/main/java/processing/core/PConstants.java +475 -981
  16. data/src/main/java/processing/core/PFont.java +50 -202
  17. data/src/main/java/processing/core/PGraphics.java +7330 -8477
  18. data/src/main/java/processing/core/PImage.java +42 -212
  19. data/src/main/java/processing/core/PMatrix.java +21 -160
  20. data/src/main/java/processing/core/PMatrix2D.java +18 -178
  21. data/src/main/java/processing/core/PMatrix3D.java +48 -324
  22. data/src/main/java/processing/core/PShape.java +294 -1181
  23. data/src/main/java/processing/core/PShapeOBJ.java +16 -91
  24. data/src/main/java/processing/core/PShapeSVG.java +53 -253
  25. data/src/main/java/processing/core/PStyle.java +34 -179
  26. data/src/main/java/processing/core/PSurface.java +13 -94
  27. data/src/main/java/processing/core/PSurfaceNone.java +35 -140
  28. data/src/main/java/processing/core/PVector.java +10 -87
  29. data/src/main/java/processing/event/Event.java +86 -69
  30. data/src/main/java/processing/event/MouseEvent.java +102 -102
  31. data/src/main/java/processing/opengl/PGL.java +23 -16
  32. data/src/main/java/processing/opengl/PGraphicsOpenGL.java +13 -10
  33. data/src/main/java/processing/opengl/PJOGL.java +32 -12
  34. data/src/main/java/processing/opengl/shaders/LightVert-brcm.glsl +154 -0
  35. data/src/main/java/processing/opengl/shaders/LightVert-vc4.glsl +2 -2
  36. data/src/main/java/processing/opengl/shaders/TexLightVert-brcm.glsl +160 -0
  37. data/src/main/java/processing/opengl/shaders/TexLightVert-vc4.glsl +2 -2
  38. metadata +7 -3
@@ -78,16 +78,8 @@ import processing.core.PApplet;
78
78
  * @instanceName sh any variable of type PShape
79
79
  */
80
80
  public class PShape implements PConstants {
81
-
82
- /**
83
- *
84
- */
85
- protected String name;
86
-
87
- /**
88
- *
89
- */
90
- protected Map<String,PShape> nameTable;
81
+ protected String name;
82
+ protected Map<String,PShape> nameTable;
91
83
 
92
84
  // /** Generic, only draws its child objects. */
93
85
  // static public final int GROUP = 0;
@@ -108,53 +100,29 @@ public class PShape implements PConstants {
108
100
  /** ELLIPSE, LINE, QUAD; TRIANGLE_FAN, QUAD_STRIP; etc. */
109
101
  protected int kind;
110
102
 
111
- /**
112
- *
113
- */
114
- protected PMatrix matrix;
103
+ protected PMatrix matrix;
115
104
 
116
- /**
117
- *
118
- */
119
- protected int textureMode;
105
+ protected int textureMode;
120
106
 
121
107
  /** Texture or image data associated with this shape. */
122
108
  protected PImage image;
123
109
 
124
- /**
125
- *
126
- */
127
- public static final String OUTSIDE_BEGIN_END_ERROR =
110
+ public static final String OUTSIDE_BEGIN_END_ERROR =
128
111
  "%1$s can only be called between beginShape() and endShape()";
129
112
 
130
- /**
131
- *
132
- */
133
- public static final String INSIDE_BEGIN_END_ERROR =
113
+ public static final String INSIDE_BEGIN_END_ERROR =
134
114
  "%1$s can only be called outside beginShape() and endShape()";
135
115
 
136
- /**
137
- *
138
- */
139
- public static final String NO_SUCH_VERTEX_ERROR =
116
+ public static final String NO_SUCH_VERTEX_ERROR =
140
117
  "%1$s vertex index does not exist";
141
118
 
142
- /**
143
- *
144
- */
145
- static public final String NO_VERTICES_ERROR =
119
+ static public final String NO_VERTICES_ERROR =
146
120
  "getVertexCount() only works with PATH or GEOMETRY shapes";
147
121
 
148
- /**
149
- *
150
- */
151
- public static final String NOT_A_SIMPLE_VERTEX =
122
+ public static final String NOT_A_SIMPLE_VERTEX =
152
123
  "%1$s can not be called on quadratic or bezier vertices";
153
124
 
154
- /**
155
- *
156
- */
157
- static public final String PER_VERTEX_UNSUPPORTED =
125
+ static public final String PER_VERTEX_UNSUPPORTED =
158
126
  "This renderer does not support %1$s for individual vertices";
159
127
 
160
128
  /**
@@ -182,117 +150,39 @@ public class PShape implements PConstants {
182
150
  */
183
151
  public float height;
184
152
 
185
- /**
186
- *
187
- */
188
- public float depth;
153
+ public float depth;
189
154
 
190
155
  PGraphics g;
191
156
 
192
157
  // set to false if the object is hidden in the layers palette
193
-
194
- /**
195
- *
196
- */
197
158
  protected boolean visible = true;
198
159
 
199
160
  /** Retained shape being created with beginShape/endShape */
200
161
  protected boolean openShape = false;
201
162
 
202
- /**
203
- *
204
- */
205
- protected boolean openContour = false;
206
-
207
- /**
208
- *
209
- */
210
- protected boolean stroke;
211
-
212
- /**
213
- *
214
- */
215
- protected int strokeColor;
216
-
217
- /**
218
- *
219
- */
220
- protected float strokeWeight; // default is 1
221
-
222
- /**
223
- *
224
- */
225
- protected int strokeCap;
226
-
227
- /**
228
- *
229
- */
230
- protected int strokeJoin;
231
-
232
- /**
233
- *
234
- */
235
- protected boolean fill;
236
-
237
- /**
238
- *
239
- */
240
- protected int fillColor;
241
-
242
- /**
243
- *
244
- */
245
- protected boolean tint;
246
-
247
- /**
248
- *
249
- */
250
- protected int tintColor;
251
-
252
- /**
253
- *
254
- */
255
- protected int ambientColor;
256
-
257
- /**
258
- *
259
- */
260
- protected boolean setAmbient;
261
-
262
- /**
263
- *
264
- */
265
- protected int specularColor;
266
-
267
- /**
268
- *
269
- */
270
- protected int emissiveColor;
271
-
272
- /**
273
- *
274
- */
275
- protected float shininess;
276
-
277
- /**
278
- *
279
- */
280
- protected int sphereDetailU,
281
-
282
- /**
283
- *
284
- */
285
- sphereDetailV;
286
-
287
- /**
288
- *
289
- */
290
- protected int rectMode;
291
-
292
- /**
293
- *
294
- */
295
- protected int ellipseMode;
163
+ protected boolean openContour = false;
164
+
165
+ protected boolean stroke;
166
+ protected int strokeColor;
167
+ protected float strokeWeight; // default is 1
168
+ protected int strokeCap;
169
+ protected int strokeJoin;
170
+
171
+ protected boolean fill;
172
+ protected int fillColor;
173
+
174
+ protected boolean tint;
175
+ protected int tintColor;
176
+
177
+ protected int ambientColor;
178
+ protected boolean setAmbient;
179
+ protected int specularColor;
180
+ protected int emissiveColor;
181
+ protected float shininess;
182
+
183
+ protected int sphereDetailU, sphereDetailV;
184
+ protected int rectMode;
185
+ protected int ellipseMode;
296
186
 
297
187
  /** Temporary toggle for whether styles should be honored. */
298
188
  protected boolean style = true;
@@ -300,10 +190,7 @@ public class PShape implements PConstants {
300
190
  /** For primitive shapes in particular, params like x/y/w/h or x1/y1/x2/y2. */
301
191
  protected float[] params;
302
192
 
303
- /**
304
- *
305
- */
306
- protected int vertexCount;
193
+ protected int vertexCount;
307
194
  /**
308
195
  * When drawing POLYGON shapes, the second param is an array of length
309
196
  * VERTEX_FIELD_COUNT. When drawing PATH shapes, the second param has only
@@ -311,85 +198,24 @@ public class PShape implements PConstants {
311
198
  */
312
199
  protected float[][] vertices;
313
200
 
314
- /**
315
- *
316
- */
317
- protected PShape parent;
318
-
319
- /**
320
- *
321
- */
322
- protected int childCount;
323
-
324
- /**
325
- *
326
- */
327
- protected PShape[] children;
201
+ protected PShape parent;
202
+ protected int childCount;
203
+ protected PShape[] children;
328
204
 
329
205
 
330
206
  /** Array of VERTEX, BEZIER_VERTEX, and CURVE_VERTEX calls. */
331
207
  protected int vertexCodeCount;
332
-
333
- /**
334
- *
335
- */
336
- protected int[] vertexCodes;
208
+ protected int[] vertexCodes;
337
209
  /** True if this is a closed path. */
338
210
  protected boolean close;
339
211
 
340
212
  // ........................................................
341
213
 
342
214
  // internal color for setting/calculating
343
-
344
- /**
345
- *
346
- */
347
- protected float calcR,
348
-
349
- /**
350
- *
351
- */
352
- calcG,
353
-
354
- /**
355
- *
356
- */
357
- calcB,
358
-
359
- /**
360
- *
361
- */
362
- calcA;
363
-
364
- /**
365
- *
366
- */
367
- protected int calcRi,
368
-
369
- /**
370
- *
371
- */
372
- calcGi,
373
-
374
- /**
375
- *
376
- */
377
- calcBi,
378
-
379
- /**
380
- *
381
- */
382
- calcAi;
383
-
384
- /**
385
- *
386
- */
387
- protected int calcColor;
388
-
389
- /**
390
- *
391
- */
392
- protected boolean calcAlpha;
215
+ protected float calcR, calcG, calcB, calcA;
216
+ protected int calcRi, calcGi, calcBi, calcAi;
217
+ protected int calcColor;
218
+ protected boolean calcAlpha;
393
219
 
394
220
  /** The current colorMode */
395
221
  public int colorMode; // = RGB;
@@ -415,10 +241,7 @@ public class PShape implements PConstants {
415
241
  /** True if contains 3D data */
416
242
  protected boolean is3D = false;
417
243
 
418
- /**
419
- *
420
- */
421
- protected boolean perVertexStyles = false;
244
+ protected boolean perVertexStyles = false;
422
245
 
423
246
  // should this be called vertices (consistent with PGraphics internals)
424
247
  // or does that hurt flexibility?
@@ -465,7 +288,6 @@ public class PShape implements PConstants {
465
288
 
466
289
 
467
290
  /**
468
- * @param family
469
291
  * @nowebref
470
292
  */
471
293
  public PShape(int family) {
@@ -474,8 +296,6 @@ public class PShape implements PConstants {
474
296
 
475
297
 
476
298
  /**
477
- * @param g
478
- * @param family
479
299
  * @nowebref
480
300
  */
481
301
  public PShape(PGraphics g, int family) {
@@ -537,47 +357,30 @@ public class PShape implements PConstants {
537
357
  }
538
358
  }
539
359
 
540
- /**
541
- *
542
- * @param g
543
- * @param kind
544
- * @param params
545
- */
546
- public PShape(PGraphics g, int kind, float... params) {
360
+
361
+ public PShape(PGraphics g, int kind, float... params) {
547
362
  this(g, PRIMITIVE);
548
363
  setKind(kind);
549
364
  setParams(params);
550
365
  }
551
366
 
552
- /**
553
- *
554
- * @param family
555
- */
556
- public void setFamily(int family) {
367
+
368
+ public void setFamily(int family) {
557
369
  this.family = family;
558
370
  }
559
371
 
560
- /**
561
- *
562
- * @param kind
563
- */
564
- public void setKind(int kind) {
372
+
373
+ public void setKind(int kind) {
565
374
  this.kind = kind;
566
375
  }
567
376
 
568
- /**
569
- *
570
- * @param name
571
- */
572
- public void setName(String name) {
377
+
378
+ public void setName(String name) {
573
379
  this.name = name;
574
380
  }
575
381
 
576
- /**
577
- *
578
- * @return
579
- */
580
- public String getName() {
382
+
383
+ public String getName() {
581
384
  return name;
582
385
  }
583
386
 
@@ -592,7 +395,6 @@ public class PShape implements PConstants {
592
395
  * showing or hiding the shape in the layers palette in Adobe Illustrator.
593
396
  *
594
397
  * ( end auto-generated )
595
- * @return
596
398
  * @webref pshape:method
597
399
  * @usage web_application
598
400
  * @brief Returns a boolean value "true" if the image is set to be visible, "false" if not
@@ -688,7 +490,6 @@ public class PShape implements PConstants {
688
490
 
689
491
  /**
690
492
  * Get the width of the drawing area (not necessarily the shape boundary).
691
- * @return
692
493
  */
693
494
  public float getWidth() {
694
495
  //checkBounds();
@@ -698,7 +499,6 @@ public class PShape implements PConstants {
698
499
 
699
500
  /**
700
501
  * Get the height of the drawing area (not necessarily the shape boundary).
701
- * @return
702
502
  */
703
503
  public float getHeight() {
704
504
  //checkBounds();
@@ -709,7 +509,6 @@ public class PShape implements PConstants {
709
509
  /**
710
510
  * Get the depth of the shape area (not necessarily the shape boundary). Only makes sense for 3D PShape subclasses,
711
511
  * such as PShape3D.
712
- * @return
713
512
  */
714
513
  public float getDepth() {
715
514
  //checkBounds();
@@ -749,7 +548,6 @@ public class PShape implements PConstants {
749
548
 
750
549
  /**
751
550
  * Return true if this shape is 2D. Defaults to true.
752
- * @return
753
551
  */
754
552
  public boolean is2D() {
755
553
  return !is3D;
@@ -758,17 +556,13 @@ public class PShape implements PConstants {
758
556
 
759
557
  /**
760
558
  * Return true if this shape is 3D. Defaults to false.
761
- * @return
762
559
  */
763
560
  public boolean is3D() {
764
561
  return is3D;
765
562
  }
766
563
 
767
- /**
768
- *
769
- * @param val
770
- */
771
- public void set3D(boolean val) {
564
+
565
+ public void set3D(boolean val) {
772
566
  is3D = val;
773
567
  }
774
568
 
@@ -788,11 +582,6 @@ public class PShape implements PConstants {
788
582
 
789
583
  // Drawing methods
790
584
 
791
- /**
792
- *
793
- * @param mode
794
- */
795
-
796
585
  public void textureMode(int mode) {
797
586
  if (!openShape) {
798
587
  PGraphics.showWarning(OUTSIDE_BEGIN_END_ERROR, "textureMode()");
@@ -802,11 +591,7 @@ public class PShape implements PConstants {
802
591
  textureMode = mode;
803
592
  }
804
593
 
805
- /**
806
- *
807
- * @param tex
808
- */
809
- public void texture(PImage tex) {
594
+ public void texture(PImage tex) {
810
595
  if (!openShape) {
811
596
  PGraphics.showWarning(OUTSIDE_BEGIN_END_ERROR, "texture()");
812
597
  return;
@@ -815,10 +600,7 @@ public class PShape implements PConstants {
815
600
  image = tex;
816
601
  }
817
602
 
818
- /**
819
- *
820
- */
821
- public void noTexture() {
603
+ public void noTexture() {
822
604
  if (!openShape) {
823
605
  PGraphics.showWarning(OUTSIDE_BEGIN_END_ERROR, "noTexture()");
824
606
  return;
@@ -829,11 +611,6 @@ public class PShape implements PConstants {
829
611
 
830
612
 
831
613
  // TODO unapproved
832
-
833
- /**
834
- *
835
- * @param solid
836
- */
837
614
  protected void solid(boolean solid) {
838
615
  }
839
616
 
@@ -862,10 +639,8 @@ public class PShape implements PConstants {
862
639
  beginContourImpl();
863
640
  }
864
641
 
865
- /**
866
- *
867
- */
868
- protected void beginContourImpl() {
642
+
643
+ protected void beginContourImpl() {
869
644
  if (vertexCodes == null) {
870
645
  vertexCodes = new int[10];
871
646
  } else if (vertexCodes.length == vertexCodeCount) {
@@ -899,18 +674,12 @@ public class PShape implements PConstants {
899
674
  openContour = false;
900
675
  }
901
676
 
902
- /**
903
- *
904
- */
905
- protected void endContourImpl() {
677
+
678
+ protected void endContourImpl() {
906
679
  }
907
680
 
908
- /**
909
- *
910
- * @param x
911
- * @param y
912
- */
913
- public void vertex(float x, float y) {
681
+
682
+ public void vertex(float x, float y) {
914
683
  if (vertices == null) {
915
684
  vertices = new float[10][2];
916
685
  } else if (vertices.length == vertexCount) {
@@ -933,96 +702,44 @@ public class PShape implements PConstants {
933
702
  }
934
703
  }
935
704
 
936
- /**
937
- *
938
- * @param x
939
- * @param y
940
- * @param u
941
- * @param v
942
- */
943
- public void vertex(float x, float y, float u, float v) {
705
+
706
+ public void vertex(float x, float y, float u, float v) {
944
707
  }
945
708
 
946
- /**
947
- *
948
- * @param x
949
- * @param y
950
- * @param z
951
- */
952
- public void vertex(float x, float y, float z) {
709
+
710
+ public void vertex(float x, float y, float z) {
953
711
  vertex(x, y); // maybe? maybe not?
954
712
  }
955
713
 
956
- /**
957
- *
958
- * @param x
959
- * @param y
960
- * @param z
961
- * @param u
962
- * @param v
963
- */
964
- public void vertex(float x, float y, float z, float u, float v) {
714
+
715
+ public void vertex(float x, float y, float z, float u, float v) {
965
716
  }
966
717
 
967
- /**
968
- *
969
- * @param nx
970
- * @param ny
971
- * @param nz
972
- */
973
- public void normal(float nx, float ny, float nz) {
718
+
719
+ public void normal(float nx, float ny, float nz) {
974
720
  }
975
721
 
976
- /**
977
- *
978
- * @param name
979
- * @param x
980
- * @param y
981
- * @param z
982
- */
983
- public void attribPosition(String name, float x, float y, float z) {
722
+
723
+ public void attribPosition(String name, float x, float y, float z) {
984
724
  }
985
725
 
986
- /**
987
- *
988
- * @param name
989
- * @param nx
990
- * @param ny
991
- * @param nz
992
- */
993
- public void attribNormal(String name, float nx, float ny, float nz) {
726
+ public void attribNormal(String name, float nx, float ny, float nz) {
994
727
  }
995
728
 
996
- /**
997
- *
998
- * @param name
999
- * @param color
1000
- */
1001
- public void attribColor(String name, int color) {
729
+
730
+ public void attribColor(String name, int color) {
1002
731
  }
1003
732
 
1004
- /**
1005
- *
1006
- * @param name
1007
- * @param values
1008
- */
1009
- public void attrib(String name, float... values) {
733
+
734
+ public void attrib(String name, float... values) {
1010
735
  }
1011
736
 
1012
- /**
1013
- *
1014
- * @param name
1015
- * @param values
1016
- */
1017
- public void attrib(String name, int... values) {
737
+
738
+ public void attrib(String name, int... values) {
1018
739
  }
1019
740
 
1020
- /**
1021
- *
1022
- * @param name
1023
- * @param values
1024
- */
1025
- public void attrib(String name, boolean... values) {
741
+
742
+ public void attrib(String name, boolean... values) {
1026
743
  }
1027
744
 
1028
745
 
@@ -1035,11 +752,8 @@ public class PShape implements PConstants {
1035
752
  beginShape(POLYGON);
1036
753
  }
1037
754
 
1038
- /**
1039
- *
1040
- * @param kind
1041
- */
1042
- public void beginShape(int kind) {
755
+
756
+ public void beginShape(int kind) {
1043
757
  this.kind = kind;
1044
758
  openShape = true;
1045
759
  }
@@ -1053,11 +767,8 @@ public class PShape implements PConstants {
1053
767
  endShape(OPEN);
1054
768
  }
1055
769
 
1056
- /**
1057
- *
1058
- * @param mode
1059
- */
1060
- public void endShape(int mode) {
770
+
771
+ public void endShape(int mode) {
1061
772
  if (family == GROUP) {
1062
773
  PGraphics.showWarning("Cannot end GROUP shape");
1063
774
  return;
@@ -1079,11 +790,6 @@ public class PShape implements PConstants {
1079
790
 
1080
791
  // STROKE CAP/JOIN/WEIGHT
1081
792
 
1082
- /**
1083
- *
1084
- * @param weight
1085
- */
1086
-
1087
793
 
1088
794
  public void strokeWeight(float weight) {
1089
795
  if (!openShape) {
@@ -1094,11 +800,7 @@ public class PShape implements PConstants {
1094
800
  strokeWeight = weight;
1095
801
  }
1096
802
 
1097
- /**
1098
- *
1099
- * @param join
1100
- */
1101
- public void strokeJoin(int join) {
803
+ public void strokeJoin(int join) {
1102
804
  if (!openShape) {
1103
805
  PGraphics.showWarning(OUTSIDE_BEGIN_END_ERROR, "strokeJoin()");
1104
806
  return;
@@ -1107,11 +809,7 @@ public class PShape implements PConstants {
1107
809
  strokeJoin = join;
1108
810
  }
1109
811
 
1110
- /**
1111
- *
1112
- * @param cap
1113
- */
1114
- public void strokeCap(int cap) {
812
+ public void strokeCap(int cap) {
1115
813
  if (!openShape) {
1116
814
  PGraphics.showWarning(OUTSIDE_BEGIN_END_ERROR, "strokeCap()");
1117
815
  return;
@@ -1125,10 +823,6 @@ public class PShape implements PConstants {
1125
823
 
1126
824
  // FILL COLOR
1127
825
 
1128
- /**
1129
- *
1130
- */
1131
-
1132
826
 
1133
827
  public void noFill() {
1134
828
  if (!openShape) {
@@ -1144,11 +838,8 @@ public class PShape implements PConstants {
1144
838
  }
1145
839
  }
1146
840
 
1147
- /**
1148
- *
1149
- * @param rgb
1150
- */
1151
- public void fill(int rgb) {
841
+
842
+ public void fill(int rgb) {
1152
843
  if (!openShape) {
1153
844
  PGraphics.showWarning(OUTSIDE_BEGIN_END_ERROR, "fill()");
1154
845
  return;
@@ -1163,12 +854,8 @@ public class PShape implements PConstants {
1163
854
  }
1164
855
  }
1165
856
 
1166
- /**
1167
- *
1168
- * @param rgb
1169
- * @param alpha
1170
- */
1171
- public void fill(int rgb, float alpha) {
857
+
858
+ public void fill(int rgb, float alpha) {
1172
859
  if (!openShape) {
1173
860
  PGraphics.showWarning(OUTSIDE_BEGIN_END_ERROR, "fill()");
1174
861
  return;
@@ -1183,11 +870,8 @@ public class PShape implements PConstants {
1183
870
  }
1184
871
  }
1185
872
 
1186
- /**
1187
- *
1188
- * @param gray
1189
- */
1190
- public void fill(float gray) {
873
+
874
+ public void fill(float gray) {
1191
875
  if (!openShape) {
1192
876
  PGraphics.showWarning(OUTSIDE_BEGIN_END_ERROR, "fill()");
1193
877
  return;
@@ -1202,12 +886,8 @@ public class PShape implements PConstants {
1202
886
  }
1203
887
  }
1204
888
 
1205
- /**
1206
- *
1207
- * @param gray
1208
- * @param alpha
1209
- */
1210
- public void fill(float gray, float alpha) {
889
+
890
+ public void fill(float gray, float alpha) {
1211
891
  if (!openShape) {
1212
892
  PGraphics.showWarning(OUTSIDE_BEGIN_END_ERROR, "fill()");
1213
893
  return;
@@ -1227,13 +907,8 @@ public class PShape implements PConstants {
1227
907
  }
1228
908
  }
1229
909
 
1230
- /**
1231
- *
1232
- * @param x
1233
- * @param y
1234
- * @param z
1235
- */
1236
- public void fill(float x, float y, float z) {
910
+
911
+ public void fill(float x, float y, float z) {
1237
912
  if (!openShape) {
1238
913
  PGraphics.showWarning(OUTSIDE_BEGIN_END_ERROR, "fill()");
1239
914
  return;
@@ -1248,14 +923,8 @@ public class PShape implements PConstants {
1248
923
  }
1249
924
  }
1250
925
 
1251
- /**
1252
- *
1253
- * @param x
1254
- * @param y
1255
- * @param z
1256
- * @param a
1257
- */
1258
- public void fill(float x, float y, float z, float a) {
926
+
927
+ public void fill(float x, float y, float z, float a) {
1259
928
  if (!openShape) {
1260
929
  PGraphics.showWarning(OUTSIDE_BEGIN_END_ERROR, "fill()");
1261
930
  return;
@@ -1275,10 +944,6 @@ public class PShape implements PConstants {
1275
944
 
1276
945
  // STROKE COLOR
1277
946
 
1278
- /**
1279
- *
1280
- */
1281
-
1282
947
 
1283
948
  public void noStroke() {
1284
949
  if (!openShape) {
@@ -1289,11 +954,8 @@ public class PShape implements PConstants {
1289
954
  stroke = false;
1290
955
  }
1291
956
 
1292
- /**
1293
- *
1294
- * @param rgb
1295
- */
1296
- public void stroke(int rgb) {
957
+
958
+ public void stroke(int rgb) {
1297
959
  if (!openShape) {
1298
960
  PGraphics.showWarning(OUTSIDE_BEGIN_END_ERROR, "stroke()");
1299
961
  return;
@@ -1304,12 +966,8 @@ public class PShape implements PConstants {
1304
966
  strokeColor = calcColor;
1305
967
  }
1306
968
 
1307
- /**
1308
- *
1309
- * @param rgb
1310
- * @param alpha
1311
- */
1312
- public void stroke(int rgb, float alpha) {
969
+
970
+ public void stroke(int rgb, float alpha) {
1313
971
  if (!openShape) {
1314
972
  PGraphics.showWarning(OUTSIDE_BEGIN_END_ERROR, "stroke()");
1315
973
  return;
@@ -1320,11 +978,8 @@ public class PShape implements PConstants {
1320
978
  strokeColor = calcColor;
1321
979
  }
1322
980
 
1323
- /**
1324
- *
1325
- * @param gray
1326
- */
1327
- public void stroke(float gray) {
981
+
982
+ public void stroke(float gray) {
1328
983
  if (!openShape) {
1329
984
  PGraphics.showWarning(OUTSIDE_BEGIN_END_ERROR, "stroke()");
1330
985
  return;
@@ -1335,12 +990,8 @@ public class PShape implements PConstants {
1335
990
  strokeColor = calcColor;
1336
991
  }
1337
992
 
1338
- /**
1339
- *
1340
- * @param gray
1341
- * @param alpha
1342
- */
1343
- public void stroke(float gray, float alpha) {
993
+
994
+ public void stroke(float gray, float alpha) {
1344
995
  if (!openShape) {
1345
996
  PGraphics.showWarning(OUTSIDE_BEGIN_END_ERROR, "stroke()");
1346
997
  return;
@@ -1351,13 +1002,8 @@ public class PShape implements PConstants {
1351
1002
  strokeColor = calcColor;
1352
1003
  }
1353
1004
 
1354
- /**
1355
- *
1356
- * @param x
1357
- * @param y
1358
- * @param z
1359
- */
1360
- public void stroke(float x, float y, float z) {
1005
+
1006
+ public void stroke(float x, float y, float z) {
1361
1007
  if (!openShape) {
1362
1008
  PGraphics.showWarning(OUTSIDE_BEGIN_END_ERROR, "stroke()");
1363
1009
  return;
@@ -1368,14 +1014,8 @@ public class PShape implements PConstants {
1368
1014
  strokeColor = calcColor;
1369
1015
  }
1370
1016
 
1371
- /**
1372
- *
1373
- * @param x
1374
- * @param y
1375
- * @param z
1376
- * @param alpha
1377
- */
1378
- public void stroke(float x, float y, float z, float alpha) {
1017
+
1018
+ public void stroke(float x, float y, float z, float alpha) {
1379
1019
  if (!openShape) {
1380
1020
  PGraphics.showWarning(OUTSIDE_BEGIN_END_ERROR, "stroke()");
1381
1021
  return;
@@ -1391,10 +1031,6 @@ public class PShape implements PConstants {
1391
1031
 
1392
1032
  // TINT COLOR
1393
1033
 
1394
- /**
1395
- *
1396
- */
1397
-
1398
1034
 
1399
1035
  public void noTint() {
1400
1036
  if (!openShape) {
@@ -1405,11 +1041,8 @@ public class PShape implements PConstants {
1405
1041
  tint = false;
1406
1042
  }
1407
1043
 
1408
- /**
1409
- *
1410
- * @param rgb
1411
- */
1412
- public void tint(int rgb) {
1044
+
1045
+ public void tint(int rgb) {
1413
1046
  if (!openShape) {
1414
1047
  PGraphics.showWarning(OUTSIDE_BEGIN_END_ERROR, "tint()");
1415
1048
  return;
@@ -1420,12 +1053,8 @@ public class PShape implements PConstants {
1420
1053
  tintColor = calcColor;
1421
1054
  }
1422
1055
 
1423
- /**
1424
- *
1425
- * @param rgb
1426
- * @param alpha
1427
- */
1428
- public void tint(int rgb, float alpha) {
1056
+
1057
+ public void tint(int rgb, float alpha) {
1429
1058
  if (!openShape) {
1430
1059
  PGraphics.showWarning(OUTSIDE_BEGIN_END_ERROR, "tint()");
1431
1060
  return;
@@ -1436,11 +1065,8 @@ public class PShape implements PConstants {
1436
1065
  tintColor = calcColor;
1437
1066
  }
1438
1067
 
1439
- /**
1440
- *
1441
- * @param gray
1442
- */
1443
- public void tint(float gray) {
1068
+
1069
+ public void tint(float gray) {
1444
1070
  if (!openShape) {
1445
1071
  PGraphics.showWarning(OUTSIDE_BEGIN_END_ERROR, "tint()");
1446
1072
  return;
@@ -1451,12 +1077,8 @@ public class PShape implements PConstants {
1451
1077
  tintColor = calcColor;
1452
1078
  }
1453
1079
 
1454
- /**
1455
- *
1456
- * @param gray
1457
- * @param alpha
1458
- */
1459
- public void tint(float gray, float alpha) {
1080
+
1081
+ public void tint(float gray, float alpha) {
1460
1082
  if (!openShape) {
1461
1083
  PGraphics.showWarning(OUTSIDE_BEGIN_END_ERROR, "tint()");
1462
1084
  return;
@@ -1467,13 +1089,8 @@ public class PShape implements PConstants {
1467
1089
  tintColor = calcColor;
1468
1090
  }
1469
1091
 
1470
- /**
1471
- *
1472
- * @param x
1473
- * @param y
1474
- * @param z
1475
- */
1476
- public void tint(float x, float y, float z) {
1092
+
1093
+ public void tint(float x, float y, float z) {
1477
1094
  if (!openShape) {
1478
1095
  PGraphics.showWarning(OUTSIDE_BEGIN_END_ERROR, "tint()");
1479
1096
  return;
@@ -1484,14 +1101,8 @@ public class PShape implements PConstants {
1484
1101
  tintColor = calcColor;
1485
1102
  }
1486
1103
 
1487
- /**
1488
- *
1489
- * @param x
1490
- * @param y
1491
- * @param z
1492
- * @param alpha
1493
- */
1494
- public void tint(float x, float y, float z, float alpha) {
1104
+
1105
+ public void tint(float x, float y, float z, float alpha) {
1495
1106
  if (!openShape) {
1496
1107
  PGraphics.showWarning(OUTSIDE_BEGIN_END_ERROR, "tint()");
1497
1108
  return;
@@ -1507,11 +1118,6 @@ public class PShape implements PConstants {
1507
1118
 
1508
1119
  // Ambient set/update
1509
1120
 
1510
- /**
1511
- *
1512
- * @param rgb
1513
- */
1514
-
1515
1121
  public void ambient(int rgb) {
1516
1122
  if (!openShape) {
1517
1123
  PGraphics.showWarning(OUTSIDE_BEGIN_END_ERROR, "ambient()");
@@ -1523,11 +1129,8 @@ public class PShape implements PConstants {
1523
1129
  ambientColor = calcColor;
1524
1130
  }
1525
1131
 
1526
- /**
1527
- *
1528
- * @param gray
1529
- */
1530
- public void ambient(float gray) {
1132
+
1133
+ public void ambient(float gray) {
1531
1134
  if (!openShape) {
1532
1135
  PGraphics.showWarning(OUTSIDE_BEGIN_END_ERROR, "ambient()");
1533
1136
  return;
@@ -1538,13 +1141,8 @@ public class PShape implements PConstants {
1538
1141
  ambientColor = calcColor;
1539
1142
  }
1540
1143
 
1541
- /**
1542
- *
1543
- * @param x
1544
- * @param y
1545
- * @param z
1546
- */
1547
- public void ambient(float x, float y, float z) {
1144
+
1145
+ public void ambient(float x, float y, float z) {
1548
1146
  if (!openShape) {
1549
1147
  PGraphics.showWarning(OUTSIDE_BEGIN_END_ERROR, "ambient()");
1550
1148
  return;
@@ -1560,11 +1158,6 @@ public class PShape implements PConstants {
1560
1158
 
1561
1159
  // Specular set/update
1562
1160
 
1563
- /**
1564
- *
1565
- * @param rgb
1566
- */
1567
-
1568
1161
  public void specular(int rgb) {
1569
1162
  if (!openShape) {
1570
1163
  PGraphics.showWarning(OUTSIDE_BEGIN_END_ERROR, "specular()");
@@ -1575,11 +1168,8 @@ public class PShape implements PConstants {
1575
1168
  specularColor = calcColor;
1576
1169
  }
1577
1170
 
1578
- /**
1579
- *
1580
- * @param gray
1581
- */
1582
- public void specular(float gray) {
1171
+
1172
+ public void specular(float gray) {
1583
1173
  if (!openShape) {
1584
1174
  PGraphics.showWarning(OUTSIDE_BEGIN_END_ERROR, "specular()");
1585
1175
  return;
@@ -1589,13 +1179,8 @@ public class PShape implements PConstants {
1589
1179
  specularColor = calcColor;
1590
1180
  }
1591
1181
 
1592
- /**
1593
- *
1594
- * @param x
1595
- * @param y
1596
- * @param z
1597
- */
1598
- public void specular(float x, float y, float z) {
1182
+
1183
+ public void specular(float x, float y, float z) {
1599
1184
  if (!openShape) {
1600
1185
  PGraphics.showWarning(OUTSIDE_BEGIN_END_ERROR, "specular()");
1601
1186
  return;
@@ -1610,11 +1195,6 @@ public class PShape implements PConstants {
1610
1195
 
1611
1196
  // Emissive set/update
1612
1197
 
1613
- /**
1614
- *
1615
- * @param rgb
1616
- */
1617
-
1618
1198
  public void emissive(int rgb) {
1619
1199
  if (!openShape) {
1620
1200
  PGraphics.showWarning(OUTSIDE_BEGIN_END_ERROR, "emissive()");
@@ -1625,11 +1205,8 @@ public class PShape implements PConstants {
1625
1205
  emissiveColor = calcColor;
1626
1206
  }
1627
1207
 
1628
- /**
1629
- *
1630
- * @param gray
1631
- */
1632
- public void emissive(float gray) {
1208
+
1209
+ public void emissive(float gray) {
1633
1210
  if (!openShape) {
1634
1211
  PGraphics.showWarning(OUTSIDE_BEGIN_END_ERROR, "emissive()");
1635
1212
  return;
@@ -1639,13 +1216,8 @@ public class PShape implements PConstants {
1639
1216
  emissiveColor = calcColor;
1640
1217
  }
1641
1218
 
1642
- /**
1643
- *
1644
- * @param x
1645
- * @param y
1646
- * @param z
1647
- */
1648
- public void emissive(float x, float y, float z) {
1219
+
1220
+ public void emissive(float x, float y, float z) {
1649
1221
  if (!openShape) {
1650
1222
  PGraphics.showWarning(OUTSIDE_BEGIN_END_ERROR, "emissive()");
1651
1223
  return;
@@ -1660,11 +1232,6 @@ public class PShape implements PConstants {
1660
1232
 
1661
1233
  // Shininess set/update
1662
1234
 
1663
- /**
1664
- *
1665
- * @param shine
1666
- */
1667
-
1668
1235
  public void shininess(float shine) {
1669
1236
  if (!openShape) {
1670
1237
  PGraphics.showWarning(OUTSIDE_BEGIN_END_ERROR, "shininess()");
@@ -1680,23 +1247,12 @@ public class PShape implements PConstants {
1680
1247
 
1681
1248
  // Bezier curves
1682
1249
 
1683
- /**
1684
- *
1685
- * @param detail
1686
- */
1687
- public void bezierDetail(int detail) {
1688
- }
1689
-
1690
- /**
1691
- *
1692
- * @param x2
1693
- * @param y2
1694
- * @param x3
1695
- * @param y3
1696
- * @param x4
1697
- * @param y4
1698
- */
1699
- public void bezierVertex(float x2, float y2,
1250
+
1251
+ public void bezierDetail(int detail) {
1252
+ }
1253
+
1254
+
1255
+ public void bezierVertex(float x2, float y2,
1700
1256
  float x3, float y3,
1701
1257
  float x4, float y4) {
1702
1258
  if (vertices == null) {
@@ -1722,31 +1278,14 @@ public class PShape implements PConstants {
1722
1278
  }
1723
1279
  }
1724
1280
 
1725
- /**
1726
- *
1727
- * @param x2
1728
- * @param y2
1729
- * @param z2
1730
- * @param x3
1731
- * @param y3
1732
- * @param z3
1733
- * @param x4
1734
- * @param y4
1735
- * @param z4
1736
- */
1737
- public void bezierVertex(float x2, float y2, float z2,
1281
+
1282
+ public void bezierVertex(float x2, float y2, float z2,
1738
1283
  float x3, float y3, float z3,
1739
1284
  float x4, float y4, float z4) {
1740
1285
  }
1741
1286
 
1742
- /**
1743
- *
1744
- * @param cx
1745
- * @param cy
1746
- * @param x3
1747
- * @param y3
1748
- */
1749
- public void quadraticVertex(float cx, float cy,
1287
+
1288
+ public void quadraticVertex(float cx, float cy,
1750
1289
  float x3, float y3) {
1751
1290
  if (vertices == null) {
1752
1291
  vertices = new float[10][];
@@ -1770,16 +1309,8 @@ public class PShape implements PConstants {
1770
1309
  }
1771
1310
  }
1772
1311
 
1773
- /**
1774
- *
1775
- * @param cx
1776
- * @param cy
1777
- * @param cz
1778
- * @param x3
1779
- * @param y3
1780
- * @param z3
1781
- */
1782
- public void quadraticVertex(float cx, float cy, float cz,
1312
+
1313
+ public void quadraticVertex(float cx, float cy, float cz,
1783
1314
  float x3, float y3, float z3) {
1784
1315
  }
1785
1316
 
@@ -1790,36 +1321,16 @@ public class PShape implements PConstants {
1790
1321
 
1791
1322
  // Catmull-Rom curves
1792
1323
 
1793
- /**
1794
- *
1795
- * @param detail
1796
- */
1797
-
1798
1324
  public void curveDetail(int detail) {
1799
1325
  }
1800
1326
 
1801
- /**
1802
- *
1803
- * @param tightness
1804
- */
1805
- public void curveTightness(float tightness) {
1327
+ public void curveTightness(float tightness) {
1806
1328
  }
1807
1329
 
1808
- /**
1809
- *
1810
- * @param x
1811
- * @param y
1812
- */
1813
- public void curveVertex(float x, float y) {
1330
+ public void curveVertex(float x, float y) {
1814
1331
  }
1815
1332
 
1816
- /**
1817
- *
1818
- * @param x
1819
- * @param y
1820
- * @param z
1821
- */
1822
- public void curveVertex(float x, float y, float z) {
1333
+ public void curveVertex(float x, float y, float z) {
1823
1334
  }
1824
1335
 
1825
1336
 
@@ -1842,12 +1353,6 @@ public class PShape implements PConstants {
1842
1353
  int shapeModeSaved;
1843
1354
  */
1844
1355
 
1845
- /**
1846
- *
1847
- * @param g
1848
- */
1849
-
1850
-
1851
1356
 
1852
1357
  protected void pre(PGraphics g) {
1853
1358
  if (matrix != null) {
@@ -1875,11 +1380,8 @@ public class PShape implements PConstants {
1875
1380
  }
1876
1381
  }
1877
1382
 
1878
- /**
1879
- *
1880
- * @param g
1881
- */
1882
- protected void styles(PGraphics g) {
1383
+
1384
+ protected void styles(PGraphics g) {
1883
1385
  // should not be necessary because using only the int version of color
1884
1386
  //parent.colorMode(PConstants.RGB, 255);
1885
1387
 
@@ -1900,11 +1402,8 @@ public class PShape implements PConstants {
1900
1402
  }
1901
1403
  }
1902
1404
 
1903
- /**
1904
- *
1905
- * @param g
1906
- */
1907
- protected void post(PGraphics g) {
1405
+
1406
+ protected void post(PGraphics g) {
1908
1407
  // for (int i = 0; i < childCount; i++) {
1909
1408
  // children[i].draw(g);
1910
1409
  // }
@@ -1939,13 +1438,6 @@ public class PShape implements PConstants {
1939
1438
 
1940
1439
 
1941
1440
  // TODO unapproved
1942
-
1943
- /**
1944
- *
1945
- * @param parent
1946
- * @param src
1947
- * @return
1948
- */
1949
1441
  static protected PShape createShape(PApplet parent, PShape src) {
1950
1442
  PShape dest = null;
1951
1443
  if (src.family == GROUP) {
@@ -1967,13 +1459,6 @@ public class PShape implements PConstants {
1967
1459
 
1968
1460
 
1969
1461
  // TODO unapproved
1970
-
1971
- /**
1972
- *
1973
- * @param parent
1974
- * @param src
1975
- * @param dest
1976
- */
1977
1462
  static protected void copyGroup(PApplet parent, PShape src, PShape dest) {
1978
1463
  copyMatrix(src, dest);
1979
1464
  copyStyles(src, dest);
@@ -1986,12 +1471,6 @@ public class PShape implements PConstants {
1986
1471
 
1987
1472
 
1988
1473
  // TODO unapproved
1989
-
1990
- /**
1991
- *
1992
- * @param src
1993
- * @param dest
1994
- */
1995
1474
  static protected void copyPrimitive(PShape src, PShape dest) {
1996
1475
  copyMatrix(src, dest);
1997
1476
  copyStyles(src, dest);
@@ -2000,12 +1479,6 @@ public class PShape implements PConstants {
2000
1479
 
2001
1480
 
2002
1481
  // TODO unapproved
2003
-
2004
- /**
2005
- *
2006
- * @param src
2007
- * @param dest
2008
- */
2009
1482
  static protected void copyGeometry(PShape src, PShape dest) {
2010
1483
  dest.beginShape(src.getKind());
2011
1484
 
@@ -2055,12 +1528,6 @@ public class PShape implements PConstants {
2055
1528
 
2056
1529
 
2057
1530
  // TODO unapproved
2058
-
2059
- /**
2060
- *
2061
- * @param src
2062
- * @param dest
2063
- */
2064
1531
  static protected void copyPath(PShape src, PShape dest) {
2065
1532
  copyMatrix(src, dest);
2066
1533
  copyStyles(src, dest);
@@ -2071,12 +1538,6 @@ public class PShape implements PConstants {
2071
1538
 
2072
1539
 
2073
1540
  // TODO unapproved
2074
-
2075
- /**
2076
- *
2077
- * @param src
2078
- * @param dest
2079
- */
2080
1541
  static protected void copyMatrix(PShape src, PShape dest) {
2081
1542
  if (src.matrix != null) {
2082
1543
  dest.applyMatrix(src.matrix);
@@ -2085,12 +1546,6 @@ public class PShape implements PConstants {
2085
1546
 
2086
1547
 
2087
1548
  // TODO unapproved
2088
-
2089
- /**
2090
- *
2091
- * @param src
2092
- * @param dest
2093
- */
2094
1549
  static protected void copyStyles(PShape src, PShape dest) {
2095
1550
  dest.ellipseMode = src.ellipseMode;
2096
1551
  dest.rectMode = src.rectMode;
@@ -2115,12 +1570,6 @@ public class PShape implements PConstants {
2115
1570
 
2116
1571
 
2117
1572
  // TODO unapproved
2118
-
2119
- /**
2120
- *
2121
- * @param src
2122
- * @param dest
2123
- */
2124
1573
  static protected void copyImage(PShape src, PShape dest) {
2125
1574
  if (src.image != null) {
2126
1575
  dest.texture(src.image);
@@ -2136,7 +1585,6 @@ public class PShape implements PConstants {
2136
1585
  * Called by the following (the shape() command adds the g)
2137
1586
  * PShape s = loadShape("blah.svg");
2138
1587
  * shape(s);
2139
- * @param g
2140
1588
  */
2141
1589
  public void draw(PGraphics g) {
2142
1590
  if (visible) {
@@ -2149,7 +1597,6 @@ public class PShape implements PConstants {
2149
1597
 
2150
1598
  /**
2151
1599
  * Draws the SVG document.
2152
- * @param g
2153
1600
  */
2154
1601
  protected void drawImpl(PGraphics g) {
2155
1602
  if (family == GROUP) {
@@ -2165,21 +1612,15 @@ public class PShape implements PConstants {
2165
1612
  }
2166
1613
  }
2167
1614
 
2168
- /**
2169
- *
2170
- * @param g
2171
- */
2172
- protected void drawGroup(PGraphics g) {
1615
+
1616
+ protected void drawGroup(PGraphics g) {
2173
1617
  for (int i = 0; i < childCount; i++) {
2174
1618
  children[i].draw(g);
2175
1619
  }
2176
1620
  }
2177
1621
 
2178
- /**
2179
- *
2180
- * @param g
2181
- */
2182
- protected void drawPrimitive(PGraphics g) {
1622
+
1623
+ protected void drawPrimitive(PGraphics g) {
2183
1624
  if (kind == POINT) {
2184
1625
  g.point(params[0], params[1]);
2185
1626
 
@@ -2261,11 +1702,8 @@ public class PShape implements PConstants {
2261
1702
  }
2262
1703
  }
2263
1704
 
2264
- /**
2265
- *
2266
- * @param g
2267
- */
2268
- protected void drawGeometry(PGraphics g) {
1705
+
1706
+ protected void drawGeometry(PGraphics g) {
2269
1707
  // get cache object using g.
2270
1708
  g.beginShape(kind);
2271
1709
  if (style) {
@@ -2340,12 +1778,6 @@ public class PShape implements PConstants {
2340
1778
  }
2341
1779
  */
2342
1780
 
2343
- /**
2344
- *
2345
- * @param g
2346
- */
2347
-
2348
-
2349
1781
  protected void drawPath(PGraphics g) {
2350
1782
  // Paths might be empty (go figure)
2351
1783
  // http://dev.processing.org/bugs/show_bug.cgi?id=982
@@ -2450,18 +1882,12 @@ public class PShape implements PConstants {
2450
1882
 
2451
1883
  // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2452
1884
 
2453
- /**
2454
- *
2455
- * @return
2456
- */
2457
-
2458
1885
 
2459
1886
  public PShape getParent() {
2460
1887
  return parent;
2461
1888
  }
2462
1889
 
2463
1890
  /**
2464
- * @return
2465
1891
  * @webref
2466
1892
  * @brief Returns the number of children
2467
1893
  */
@@ -2478,11 +1904,8 @@ public class PShape implements PConstants {
2478
1904
  }
2479
1905
  }
2480
1906
 
2481
- /**
2482
- *
2483
- * @return
2484
- */
2485
- public PShape[] getChildren() {
1907
+
1908
+ public PShape[] getChildren() {
2486
1909
  crop();
2487
1910
  return children;
2488
1911
  }
@@ -2495,7 +1918,6 @@ public class PShape implements PConstants {
2495
1918
  * <b>PShape</b> object, or <b>null</b> is returned if there is an error.
2496
1919
  *
2497
1920
  * ( end auto-generated )
2498
- * @return
2499
1921
  * @webref pshape:method
2500
1922
  * @usage web_application
2501
1923
  * @brief Returns a child element of a shape as a PShape object
@@ -2509,7 +1931,6 @@ public class PShape implements PConstants {
2509
1931
 
2510
1932
  /**
2511
1933
  * @param target the name of the shape to get
2512
- * @return
2513
1934
  */
2514
1935
  public PShape getChild(String target) {
2515
1936
  if (name != null && name.equals(target)) {
@@ -2530,8 +1951,6 @@ public class PShape implements PConstants {
2530
1951
  /**
2531
1952
  * Same as getChild(name), except that it first walks all the way up the
2532
1953
  * hierarchy to the eldest grandparent, so that children can be found anywhere.
2533
- * @param target
2534
- * @return
2535
1954
  */
2536
1955
  public PShape findChild(String target) {
2537
1956
  if (parent == null) {
@@ -2568,7 +1987,6 @@ public class PShape implements PConstants {
2568
1987
 
2569
1988
  // adds child who exactly at position idx in the array of children.
2570
1989
  /**
2571
- * @param who
2572
1990
  * @param idx the layer position in which to insert the new child
2573
1991
  */
2574
1992
  public void addChild(PShape who, int idx) {
@@ -2596,7 +2014,6 @@ public class PShape implements PConstants {
2596
2014
 
2597
2015
  /**
2598
2016
  * Remove the child shape with index idx.
2599
- * @param idx
2600
2017
  */
2601
2018
  public void removeChild(int idx) {
2602
2019
  if (idx < childCount) {
@@ -2617,8 +2034,6 @@ public class PShape implements PConstants {
2617
2034
 
2618
2035
  /**
2619
2036
  * Add a shape to the name lookup table.
2620
- * @param nom
2621
- * @param shape
2622
2037
  */
2623
2038
  public void addName(String nom, PShape shape) {
2624
2039
  if (parent != null) {
@@ -2634,8 +2049,6 @@ public class PShape implements PConstants {
2634
2049
 
2635
2050
  /**
2636
2051
  * Returns the index of child who.
2637
- * @param who
2638
- * @return
2639
2052
  */
2640
2053
  public int getChildIndex(PShape who) {
2641
2054
  for (int i = 0; i < childCount; i++) {
@@ -2646,11 +2059,8 @@ public class PShape implements PConstants {
2646
2059
  return -1;
2647
2060
  }
2648
2061
 
2649
- /**
2650
- *
2651
- * @return
2652
- */
2653
- public PShape getTessellation() {
2062
+
2063
+ public PShape getTessellation() {
2654
2064
  return null;
2655
2065
  }
2656
2066
 
@@ -2658,34 +2068,23 @@ public class PShape implements PConstants {
2658
2068
  // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2659
2069
 
2660
2070
 
2661
- /** The shape type, one of GROUP, PRIMITIVE, PATH, or GEOMETRY.
2662
- * @return */
2071
+ /** The shape type, one of GROUP, PRIMITIVE, PATH, or GEOMETRY. */
2663
2072
  public int getFamily() {
2664
2073
  return family;
2665
2074
  }
2666
2075
 
2667
- /**
2668
- *
2669
- * @return
2670
- */
2671
- public int getKind() {
2076
+
2077
+ public int getKind() {
2672
2078
  return kind;
2673
2079
  }
2674
2080
 
2675
- /**
2676
- *
2677
- * @return
2678
- */
2679
- public float[] getParams() {
2081
+
2082
+ public float[] getParams() {
2680
2083
  return getParams(null);
2681
2084
  }
2682
2085
 
2683
- /**
2684
- *
2685
- * @param target
2686
- * @return
2687
- */
2688
- public float[] getParams(float[] target) {
2086
+
2087
+ public float[] getParams(float[] target) {
2689
2088
  if (target == null || target.length != params.length) {
2690
2089
  target = new float[params.length];
2691
2090
  }
@@ -2693,20 +2092,13 @@ public class PShape implements PConstants {
2693
2092
  return target;
2694
2093
  }
2695
2094
 
2696
- /**
2697
- *
2698
- * @param index
2699
- * @return
2700
- */
2701
- public float getParam(int index) {
2095
+
2096
+ public float getParam(int index) {
2702
2097
  return params[index];
2703
2098
  }
2704
2099
 
2705
- /**
2706
- *
2707
- * @param source
2708
- */
2709
- protected void setParams(float[] source) {
2100
+
2101
+ protected void setParams(float[] source) {
2710
2102
  if (params == null) {
2711
2103
  params = new float[source.length];
2712
2104
  }
@@ -2717,23 +2109,13 @@ public class PShape implements PConstants {
2717
2109
  PApplet.arrayCopy(source, params);
2718
2110
  }
2719
2111
 
2720
- /**
2721
- *
2722
- * @param vcount
2723
- * @param verts
2724
- */
2725
- public void setPath(int vcount, float[][] verts) {
2112
+
2113
+ public void setPath(int vcount, float[][] verts) {
2726
2114
  setPath(vcount, verts, 0, null);
2727
2115
  }
2728
2116
 
2729
- /**
2730
- *
2731
- * @param vcount
2732
- * @param verts
2733
- * @param ccount
2734
- * @param codes
2735
- */
2736
- protected void setPath(int vcount, float[][] verts, int ccount, int[] codes) {
2117
+
2118
+ protected void setPath(int vcount, float[][] verts, int ccount, int[] codes) {
2737
2119
  if (verts == null || verts.length < vcount) return;
2738
2120
  if (0 < ccount && (codes == null || codes.length < ccount)) return;
2739
2121
 
@@ -2752,7 +2134,6 @@ public class PShape implements PConstants {
2752
2134
  }
2753
2135
 
2754
2136
  /**
2755
- * @return
2756
2137
  * @webref pshape:method
2757
2138
  * @brief Returns the total number of vertices as an int
2758
2139
  * @see PShape#getVertex(int)
@@ -2767,7 +2148,6 @@ public class PShape implements PConstants {
2767
2148
 
2768
2149
 
2769
2150
  /**
2770
- * @return
2771
2151
  * @webref pshape:method
2772
2152
  * @brief Returns the vertex at the index position
2773
2153
  * @param index the location of the vertex
@@ -2780,9 +2160,7 @@ public class PShape implements PConstants {
2780
2160
 
2781
2161
 
2782
2162
  /**
2783
- * @param index
2784
2163
  * @param vec PVector to assign the data to
2785
- * @return
2786
2164
  */
2787
2165
  public PVector getVertex(int index, PVector vec) {
2788
2166
  if (vec == null) {
@@ -2799,30 +2177,18 @@ public class PShape implements PConstants {
2799
2177
  return vec;
2800
2178
  }
2801
2179
 
2802
- /**
2803
- *
2804
- * @param index
2805
- * @return
2806
- */
2807
- public float getVertexX(int index) {
2180
+
2181
+ public float getVertexX(int index) {
2808
2182
  return vertices[index][X];
2809
2183
  }
2810
2184
 
2811
- /**
2812
- *
2813
- * @param index
2814
- * @return
2815
- */
2816
- public float getVertexY(int index) {
2185
+
2186
+ public float getVertexY(int index) {
2817
2187
  return vertices[index][Y];
2818
2188
  }
2819
2189
 
2820
- /**
2821
- *
2822
- * @param index
2823
- * @return
2824
- */
2825
- public float getVertexZ(int index) {
2190
+
2191
+ public float getVertexZ(int index) {
2826
2192
  return vertices[index][Z];
2827
2193
  }
2828
2194
 
@@ -2848,10 +2214,7 @@ public class PShape implements PConstants {
2848
2214
 
2849
2215
 
2850
2216
  /**
2851
- * @param index
2852
- * @param x
2853
2217
  * @param z the z value for the vertex
2854
- * @param y
2855
2218
  */
2856
2219
  public void setVertex(int index, float x, float y, float z) {
2857
2220
  if (openShape) {
@@ -2866,7 +2229,6 @@ public class PShape implements PConstants {
2866
2229
 
2867
2230
 
2868
2231
  /**
2869
- * @param index
2870
2232
  * @param vec the PVector to define the x, y, z coordinates
2871
2233
  */
2872
2234
  public void setVertex(int index, PVector vec) {
@@ -2885,22 +2247,13 @@ public class PShape implements PConstants {
2885
2247
  }
2886
2248
  }
2887
2249
 
2888
- /**
2889
- *
2890
- * @param index
2891
- * @return
2892
- */
2893
- public PVector getNormal(int index) {
2250
+
2251
+ public PVector getNormal(int index) {
2894
2252
  return getNormal(index, null);
2895
2253
  }
2896
2254
 
2897
- /**
2898
- *
2899
- * @param index
2900
- * @param vec
2901
- * @return
2902
- */
2903
- public PVector getNormal(int index, PVector vec) {
2255
+
2256
+ public PVector getNormal(int index, PVector vec) {
2904
2257
  if (vec == null) {
2905
2258
  vec = new PVector();
2906
2259
  }
@@ -2910,41 +2263,23 @@ public class PShape implements PConstants {
2910
2263
  return vec;
2911
2264
  }
2912
2265
 
2913
- /**
2914
- *
2915
- * @param index
2916
- * @return
2917
- */
2918
- public float getNormalX(int index) {
2266
+
2267
+ public float getNormalX(int index) {
2919
2268
  return vertices[index][PGraphics.NX];
2920
2269
  }
2921
2270
 
2922
- /**
2923
- *
2924
- * @param index
2925
- * @return
2926
- */
2927
- public float getNormalY(int index) {
2271
+
2272
+ public float getNormalY(int index) {
2928
2273
  return vertices[index][PGraphics.NY];
2929
2274
  }
2930
2275
 
2931
- /**
2932
- *
2933
- * @param index
2934
- * @return
2935
- */
2936
- public float getNormalZ(int index) {
2276
+
2277
+ public float getNormalZ(int index) {
2937
2278
  return vertices[index][PGraphics.NZ];
2938
2279
  }
2939
2280
 
2940
- /**
2941
- *
2942
- * @param index
2943
- * @param nx
2944
- * @param ny
2945
- * @param nz
2946
- */
2947
- public void setNormal(int index, float nx, float ny, float nz) {
2281
+
2282
+ public void setNormal(int index, float nx, float ny, float nz) {
2948
2283
  if (openShape) {
2949
2284
  PGraphics.showWarning(INSIDE_BEGIN_END_ERROR, "setNormal()");
2950
2285
  return;
@@ -2955,58 +2290,31 @@ public class PShape implements PConstants {
2955
2290
  vertices[index][PGraphics.NZ] = nz;
2956
2291
  }
2957
2292
 
2958
- /**
2959
- *
2960
- * @param name
2961
- * @param index
2962
- * @param values
2963
- */
2964
- public void setAttrib(String name, int index, float... values) {
2293
+
2294
+
2295
+ public void setAttrib(String name, int index, float... values) {
2965
2296
  }
2966
2297
 
2967
- /**
2968
- *
2969
- * @param name
2970
- * @param index
2971
- * @param values
2972
- */
2973
- public void setAttrib(String name, int index, int... values) {
2298
+
2299
+ public void setAttrib(String name, int index, int... values) {
2974
2300
  }
2975
2301
 
2976
- /**
2977
- *
2978
- * @param name
2979
- * @param index
2980
- * @param values
2981
- */
2982
- public void setAttrib(String name, int index, boolean... values) {
2302
+
2303
+ public void setAttrib(String name, int index, boolean... values) {
2983
2304
  }
2984
2305
 
2985
- /**
2986
- *
2987
- * @param index
2988
- * @return
2989
- */
2990
- public float getTextureU(int index) {
2306
+
2307
+ public float getTextureU(int index) {
2991
2308
  return vertices[index][PGraphics.U];
2992
2309
  }
2993
2310
 
2994
- /**
2995
- *
2996
- * @param index
2997
- * @return
2998
- */
2999
- public float getTextureV(int index) {
2311
+
2312
+ public float getTextureV(int index) {
3000
2313
  return vertices[index][PGraphics.V];
3001
2314
  }
3002
2315
 
3003
- /**
3004
- *
3005
- * @param index
3006
- * @param u
3007
- * @param v
3008
- */
3009
- public void setTextureUV(int index, float u, float v) {
2316
+
2317
+ public void setTextureUV(int index, float u, float v) {
3010
2318
  if (openShape) {
3011
2319
  PGraphics.showWarning(INSIDE_BEGIN_END_ERROR, "setTextureUV()");
3012
2320
  return;
@@ -3024,11 +2332,8 @@ public class PShape implements PConstants {
3024
2332
  vertices[index][PGraphics.V] = v;
3025
2333
  }
3026
2334
 
3027
- /**
3028
- *
3029
- * @param mode
3030
- */
3031
- public void setTextureMode(int mode) {
2335
+
2336
+ public void setTextureMode(int mode) {
3032
2337
  if (openShape) {
3033
2338
  PGraphics.showWarning(INSIDE_BEGIN_END_ERROR, "setTextureMode()");
3034
2339
  return;
@@ -3037,11 +2342,8 @@ public class PShape implements PConstants {
3037
2342
  textureMode = mode;
3038
2343
  }
3039
2344
 
3040
- /**
3041
- *
3042
- * @param tex
3043
- */
3044
- public void setTexture(PImage tex) {
2345
+
2346
+ public void setTexture(PImage tex) {
3045
2347
  if (openShape) {
3046
2348
  PGraphics.showWarning(INSIDE_BEGIN_END_ERROR, "setTexture()");
3047
2349
  return;
@@ -3050,12 +2352,8 @@ public class PShape implements PConstants {
3050
2352
  image = tex;
3051
2353
  }
3052
2354
 
3053
- /**
3054
- *
3055
- * @param index
3056
- * @return
3057
- */
3058
- public int getFill(int index) {
2355
+
2356
+ public int getFill(int index) {
3059
2357
  // make sure we allocated the vertices array and that vertex exists
3060
2358
  if (vertices == null ||
3061
2359
  index >= vertices.length) {
@@ -3075,7 +2373,6 @@ public class PShape implements PConstants {
3075
2373
  }
3076
2374
 
3077
2375
  /**
3078
- * @param fill
3079
2376
  * @nowebref
3080
2377
  */
3081
2378
  public void setFill(boolean fill) {
@@ -3121,8 +2418,6 @@ public class PShape implements PConstants {
3121
2418
  }
3122
2419
 
3123
2420
  /**
3124
- * @param index
3125
- * @param fill
3126
2421
  * @nowebref
3127
2422
  */
3128
2423
  public void setFill(int index, int fill) {
@@ -3150,12 +2445,8 @@ public class PShape implements PConstants {
3150
2445
  }
3151
2446
  }
3152
2447
 
3153
- /**
3154
- *
3155
- * @param index
3156
- * @return
3157
- */
3158
- public int getTint(int index) {
2448
+
2449
+ public int getTint(int index) {
3159
2450
  // make sure we allocated the vertices array and that vertex exists
3160
2451
  if (vertices == null || index >= vertices.length) {
3161
2452
  PGraphics.showWarning(NO_SUCH_VERTEX_ERROR + " (" + index + ")", "getTint()");
@@ -3173,11 +2464,8 @@ public class PShape implements PConstants {
3173
2464
  }
3174
2465
  }
3175
2466
 
3176
- /**
3177
- *
3178
- * @param tint
3179
- */
3180
- public void setTint(boolean tint) {
2467
+
2468
+ public void setTint(boolean tint) {
3181
2469
  if (openShape) {
3182
2470
  PGraphics.showWarning(INSIDE_BEGIN_END_ERROR, "setTint()");
3183
2471
  return;
@@ -3186,11 +2474,8 @@ public class PShape implements PConstants {
3186
2474
  this.tint = tint;
3187
2475
  }
3188
2476
 
3189
- /**
3190
- *
3191
- * @param fill
3192
- */
3193
- public void setTint(int fill) {
2477
+
2478
+ public void setTint(int fill) {
3194
2479
  if (openShape) {
3195
2480
  PGraphics.showWarning(INSIDE_BEGIN_END_ERROR, "setTint()");
3196
2481
  return;
@@ -3205,12 +2490,8 @@ public class PShape implements PConstants {
3205
2490
  }
3206
2491
  }
3207
2492
 
3208
- /**
3209
- *
3210
- * @param index
3211
- * @param tint
3212
- */
3213
- public void setTint(int index, int tint) {
2493
+
2494
+ public void setTint(int index, int tint) {
3214
2495
  if (openShape) {
3215
2496
  PGraphics.showWarning(INSIDE_BEGIN_END_ERROR, "setTint()");
3216
2497
  return;
@@ -3231,12 +2512,8 @@ public class PShape implements PConstants {
3231
2512
  }
3232
2513
  }
3233
2514
 
3234
- /**
3235
- *
3236
- * @param index
3237
- * @return
3238
- */
3239
- public int getStroke(int index) {
2515
+
2516
+ public int getStroke(int index) {
3240
2517
  // make sure we allocated the vertices array and that vertex exists
3241
2518
  if (vertices == null ||
3242
2519
  index >= vertices.length) {
@@ -3252,7 +2529,6 @@ public class PShape implements PConstants {
3252
2529
  }
3253
2530
 
3254
2531
  /**
3255
- * @param stroke
3256
2532
  * @nowebref
3257
2533
  */
3258
2534
  public void setStroke(boolean stroke) {
@@ -3298,8 +2574,6 @@ public class PShape implements PConstants {
3298
2574
  }
3299
2575
 
3300
2576
  /**
3301
- * @param index
3302
- * @param stroke
3303
2577
  * @nowebref
3304
2578
  */
3305
2579
  public void setStroke(int index, int stroke) {
@@ -3325,12 +2599,8 @@ public class PShape implements PConstants {
3325
2599
  vertices[index][PGraphics.SB] = ((stroke >> 0) & 0xFF) / 255.0f;
3326
2600
  }
3327
2601
 
3328
- /**
3329
- *
3330
- * @param index
3331
- * @return
3332
- */
3333
- public float getStrokeWeight(int index) {
2602
+
2603
+ public float getStrokeWeight(int index) {
3334
2604
  // make sure we allocated the vertices array and that vertex exists
3335
2605
  if (vertices == null || index >= vertices.length) {
3336
2606
  PGraphics.showWarning(NO_SUCH_VERTEX_ERROR + " (" + index + ")", "getStrokeWeight()");
@@ -3340,11 +2610,8 @@ public class PShape implements PConstants {
3340
2610
  return vertices[index][PGraphics.SW];
3341
2611
  }
3342
2612
 
3343
- /**
3344
- *
3345
- * @param weight
3346
- */
3347
- public void setStrokeWeight(float weight) {
2613
+
2614
+ public void setStrokeWeight(float weight) {
3348
2615
  if (openShape) {
3349
2616
  PGraphics.showWarning(INSIDE_BEGIN_END_ERROR, "setStrokeWeight()");
3350
2617
  return;
@@ -3359,12 +2626,8 @@ public class PShape implements PConstants {
3359
2626
  }
3360
2627
  }
3361
2628
 
3362
- /**
3363
- *
3364
- * @param index
3365
- * @param weight
3366
- */
3367
- public void setStrokeWeight(int index, float weight) {
2629
+
2630
+ public void setStrokeWeight(int index, float weight) {
3368
2631
  if (openShape) {
3369
2632
  PGraphics.showWarning(INSIDE_BEGIN_END_ERROR, "setStrokeWeight()");
3370
2633
  return;
@@ -3384,11 +2647,8 @@ public class PShape implements PConstants {
3384
2647
  vertices[index][PGraphics.SW] = weight;
3385
2648
  }
3386
2649
 
3387
- /**
3388
- *
3389
- * @param join
3390
- */
3391
- public void setStrokeJoin(int join) {
2650
+
2651
+ public void setStrokeJoin(int join) {
3392
2652
  if (openShape) {
3393
2653
  PGraphics.showWarning(INSIDE_BEGIN_END_ERROR, "setStrokeJoin()");
3394
2654
  return;
@@ -3397,11 +2657,8 @@ public class PShape implements PConstants {
3397
2657
  strokeJoin = join;
3398
2658
  }
3399
2659
 
3400
- /**
3401
- *
3402
- * @param cap
3403
- */
3404
- public void setStrokeCap(int cap) {
2660
+
2661
+ public void setStrokeCap(int cap) {
3405
2662
  if (openShape) {
3406
2663
  PGraphics.showWarning(INSIDE_BEGIN_END_ERROR, "setStrokeCap()");
3407
2664
  return;
@@ -3410,12 +2667,8 @@ public class PShape implements PConstants {
3410
2667
  strokeCap = cap;
3411
2668
  }
3412
2669
 
3413
- /**
3414
- *
3415
- * @param index
3416
- * @return
3417
- */
3418
- public int getAmbient(int index) {
2670
+
2671
+ public int getAmbient(int index) {
3419
2672
  // make sure we allocated the vertices array and that vertex exists
3420
2673
  if (vertices == null || index >= vertices.length) {
3421
2674
  PGraphics.showWarning(NO_SUCH_VERTEX_ERROR + " (" + index + ")", "getAmbient()");
@@ -3428,11 +2681,8 @@ public class PShape implements PConstants {
3428
2681
  return 0xff000000 | (r << 16) | (g << 8) | b;
3429
2682
  }
3430
2683
 
3431
- /**
3432
- *
3433
- * @param ambient
3434
- */
3435
- public void setAmbient(int ambient) {
2684
+
2685
+ public void setAmbient(int ambient) {
3436
2686
  if (openShape) {
3437
2687
  PGraphics.showWarning(INSIDE_BEGIN_END_ERROR, "setAmbient()");
3438
2688
  return;
@@ -3447,12 +2697,8 @@ public class PShape implements PConstants {
3447
2697
  }
3448
2698
  }
3449
2699
 
3450
- /**
3451
- *
3452
- * @param index
3453
- * @param ambient
3454
- */
3455
- public void setAmbient(int index, int ambient) {
2700
+
2701
+ public void setAmbient(int index, int ambient) {
3456
2702
  if (openShape) {
3457
2703
  PGraphics.showWarning(INSIDE_BEGIN_END_ERROR, "setAmbient()");
3458
2704
  return;
@@ -3469,12 +2715,8 @@ public class PShape implements PConstants {
3469
2715
  vertices[index][PGraphics.AB] = ((ambient >> 0) & 0xFF) / 255.0f;
3470
2716
  }
3471
2717
 
3472
- /**
3473
- *
3474
- * @param index
3475
- * @return
3476
- */
3477
- public int getSpecular(int index) {
2718
+
2719
+ public int getSpecular(int index) {
3478
2720
  // make sure we allocated the vertices array and that vertex exists
3479
2721
  if (vertices == null || index >= vertices.length) {
3480
2722
  PGraphics.showWarning(NO_SUCH_VERTEX_ERROR + " (" + index + ")", "getSpecular()");
@@ -3487,11 +2729,8 @@ public class PShape implements PConstants {
3487
2729
  return 0xff000000 | (r << 16) | (g << 8) | b;
3488
2730
  }
3489
2731
 
3490
- /**
3491
- *
3492
- * @param specular
3493
- */
3494
- public void setSpecular(int specular) {
2732
+
2733
+ public void setSpecular(int specular) {
3495
2734
  if (openShape) {
3496
2735
  PGraphics.showWarning(INSIDE_BEGIN_END_ERROR, "setSpecular()");
3497
2736
  return;
@@ -3506,12 +2745,8 @@ public class PShape implements PConstants {
3506
2745
  }
3507
2746
  }
3508
2747
 
3509
- /**
3510
- *
3511
- * @param index
3512
- * @param specular
3513
- */
3514
- public void setSpecular(int index, int specular) {
2748
+
2749
+ public void setSpecular(int index, int specular) {
3515
2750
  if (openShape) {
3516
2751
  PGraphics.showWarning(INSIDE_BEGIN_END_ERROR, "setSpecular()");
3517
2752
  return;
@@ -3528,12 +2763,8 @@ public class PShape implements PConstants {
3528
2763
  vertices[index][PGraphics.SPB] = ((specular >> 0) & 0xFF) / 255.0f;
3529
2764
  }
3530
2765
 
3531
- /**
3532
- *
3533
- * @param index
3534
- * @return
3535
- */
3536
- public int getEmissive(int index) {
2766
+
2767
+ public int getEmissive(int index) {
3537
2768
  // make sure we allocated the vertices array and that vertex exists
3538
2769
  if (vertices == null || index >= vertices.length) {
3539
2770
  PGraphics.showWarning(NO_SUCH_VERTEX_ERROR + " (" + index + ")", "getEmissive()");
@@ -3546,11 +2777,8 @@ public class PShape implements PConstants {
3546
2777
  return 0xff000000 | (r << 16) | (g << 8) | b;
3547
2778
  }
3548
2779
 
3549
- /**
3550
- *
3551
- * @param emissive
3552
- */
3553
- public void setEmissive(int emissive) {
2780
+
2781
+ public void setEmissive(int emissive) {
3554
2782
  if (openShape) {
3555
2783
  PGraphics.showWarning(INSIDE_BEGIN_END_ERROR, "setEmissive()");
3556
2784
  return;
@@ -3565,12 +2793,8 @@ public class PShape implements PConstants {
3565
2793
  }
3566
2794
  }
3567
2795
 
3568
- /**
3569
- *
3570
- * @param index
3571
- * @param emissive
3572
- */
3573
- public void setEmissive(int index, int emissive) {
2796
+
2797
+ public void setEmissive(int index, int emissive) {
3574
2798
  if (openShape) {
3575
2799
  PGraphics.showWarning(INSIDE_BEGIN_END_ERROR, "setEmissive()");
3576
2800
  return;
@@ -3588,12 +2812,8 @@ public class PShape implements PConstants {
3588
2812
  vertices[index][PGraphics.EB] = ((emissive >> 0) & 0xFF) / 255.0f;
3589
2813
  }
3590
2814
 
3591
- /**
3592
- *
3593
- * @param index
3594
- * @return
3595
- */
3596
- public float getShininess(int index) {
2815
+
2816
+ public float getShininess(int index) {
3597
2817
  // make sure we allocated the vertices array and that vertex exists
3598
2818
  if (vertices == null ||
3599
2819
  index >= vertices.length) {
@@ -3604,11 +2824,8 @@ public class PShape implements PConstants {
3604
2824
  return vertices[index][PGraphics.SHINE];
3605
2825
  }
3606
2826
 
3607
- /**
3608
- *
3609
- * @param shine
3610
- */
3611
- public void setShininess(float shine) {
2827
+
2828
+ public void setShininess(float shine) {
3612
2829
  if (openShape) {
3613
2830
  PGraphics.showWarning(INSIDE_BEGIN_END_ERROR, "setShininess()");
3614
2831
  return;
@@ -3623,12 +2840,8 @@ public class PShape implements PConstants {
3623
2840
  }
3624
2841
  }
3625
2842
 
3626
- /**
3627
- *
3628
- * @param index
3629
- * @param shine
3630
- */
3631
- public void setShininess(int index, float shine) {
2843
+
2844
+ public void setShininess(int index, float shine) {
3632
2845
  if (openShape) {
3633
2846
  PGraphics.showWarning(INSIDE_BEGIN_END_ERROR, "setShininess()");
3634
2847
  return;
@@ -3645,11 +2858,8 @@ public class PShape implements PConstants {
3645
2858
  vertices[index][PGraphics.SHINE] = shine;
3646
2859
  }
3647
2860
 
3648
- /**
3649
- *
3650
- * @return
3651
- */
3652
- public int[] getVertexCodes() {
2861
+
2862
+ public int[] getVertexCodes() {
3653
2863
  if (vertexCodes == null) {
3654
2864
  return null;
3655
2865
  }
@@ -3659,29 +2869,21 @@ public class PShape implements PConstants {
3659
2869
  return vertexCodes;
3660
2870
  }
3661
2871
 
3662
- /**
3663
- *
3664
- * @return
3665
- */
3666
- public int getVertexCodeCount() {
2872
+
2873
+ public int getVertexCodeCount() {
3667
2874
  return vertexCodeCount;
3668
2875
  }
3669
2876
 
3670
2877
 
3671
2878
  /**
3672
2879
  * One of VERTEX, BEZIER_VERTEX, CURVE_VERTEX, or BREAK.
3673
- * @param index
3674
- * @return
3675
2880
  */
3676
2881
  public int getVertexCode(int index) {
3677
2882
  return vertexCodes[index];
3678
2883
  }
3679
2884
 
3680
- /**
3681
- *
3682
- * @return
3683
- */
3684
- public boolean isClosed() {
2885
+
2886
+ public boolean isClosed() {
3685
2887
  return close;
3686
2888
  }
3687
2889
 
@@ -3690,13 +2892,6 @@ public class PShape implements PConstants {
3690
2892
 
3691
2893
 
3692
2894
  // http://www.ecse.rpi.edu/Homepages/wrf/Research/Short_Notes/pnpoly.html
3693
-
3694
- /**
3695
- *
3696
- * @param x
3697
- * @param y
3698
- * @return
3699
- */
3700
2895
  public boolean contains(float x, float y) {
3701
2896
  if (family == PATH) {
3702
2897
  boolean c = false;
@@ -3757,9 +2952,7 @@ public class PShape implements PConstants {
3757
2952
  }
3758
2953
 
3759
2954
  /**
3760
- * @param x
3761
2955
  * @param z forward/back translation
3762
- * @param y
3763
2956
  */
3764
2957
  public void translate(float x, float y, float z) {
3765
2958
  checkMatrix(3);
@@ -3900,10 +3093,6 @@ public class PShape implements PConstants {
3900
3093
  }
3901
3094
 
3902
3095
  /**
3903
- * @param angle
3904
- * @param v0
3905
- * @param v1
3906
- * @param v2
3907
3096
  * @nowebref
3908
3097
  */
3909
3098
  public void rotate(float angle, float v0, float v1, float v2) {
@@ -3951,12 +3140,8 @@ public class PShape implements PConstants {
3951
3140
  matrix.scale(s);
3952
3141
  }
3953
3142
 
3954
- /**
3955
- *
3956
- * @param x
3957
- * @param y
3958
- */
3959
- public void scale(float x, float y) {
3143
+
3144
+ public void scale(float x, float y) {
3960
3145
  checkMatrix(2);
3961
3146
  matrix.scale(x, y);
3962
3147
  }
@@ -3993,11 +3178,8 @@ public class PShape implements PConstants {
3993
3178
  matrix.reset();
3994
3179
  }
3995
3180
 
3996
- /**
3997
- *
3998
- * @param source
3999
- */
4000
- public void applyMatrix(PMatrix source) {
3181
+
3182
+ public void applyMatrix(PMatrix source) {
4001
3183
  if (source instanceof PMatrix2D) {
4002
3184
  applyMatrix((PMatrix2D) source);
4003
3185
  } else if (source instanceof PMatrix3D) {
@@ -4005,64 +3187,32 @@ public class PShape implements PConstants {
4005
3187
  }
4006
3188
  }
4007
3189
 
4008
- /**
4009
- *
4010
- * @param source
4011
- */
4012
- public void applyMatrix(PMatrix2D source) {
3190
+
3191
+ public void applyMatrix(PMatrix2D source) {
4013
3192
  applyMatrix(source.m00, source.m01, 0, source.m02,
4014
3193
  source.m10, source.m11, 0, source.m12,
4015
3194
  0, 0, 1, 0,
4016
3195
  0, 0, 0, 1);
4017
3196
  }
4018
3197
 
4019
- /**
4020
- *
4021
- * @param n00
4022
- * @param n01
4023
- * @param n02
4024
- * @param n10
4025
- * @param n11
4026
- * @param n12
4027
- */
4028
- public void applyMatrix(float n00, float n01, float n02,
3198
+
3199
+ public void applyMatrix(float n00, float n01, float n02,
4029
3200
  float n10, float n11, float n12) {
4030
3201
  checkMatrix(2);
4031
3202
  matrix.apply(n00, n01, n02,
4032
3203
  n10, n11, n12);
4033
3204
  }
4034
3205
 
4035
- /**
4036
- *
4037
- * @param source
4038
- */
4039
- public void applyMatrix(PMatrix3D source) {
3206
+
3207
+ public void applyMatrix(PMatrix3D source) {
4040
3208
  applyMatrix(source.m00, source.m01, source.m02, source.m03,
4041
3209
  source.m10, source.m11, source.m12, source.m13,
4042
3210
  source.m20, source.m21, source.m22, source.m23,
4043
3211
  source.m30, source.m31, source.m32, source.m33);
4044
3212
  }
4045
3213
 
4046
- /**
4047
- *
4048
- * @param n00
4049
- * @param n01
4050
- * @param n02
4051
- * @param n03
4052
- * @param n10
4053
- * @param n11
4054
- * @param n12
4055
- * @param n13
4056
- * @param n20
4057
- * @param n21
4058
- * @param n22
4059
- * @param n23
4060
- * @param n30
4061
- * @param n31
4062
- * @param n32
4063
- * @param n33
4064
- */
4065
- public void applyMatrix(float n00, float n01, float n02, float n03,
3214
+
3215
+ public void applyMatrix(float n00, float n01, float n02, float n03,
4066
3216
  float n10, float n11, float n12, float n13,
4067
3217
  float n20, float n21, float n22, float n23,
4068
3218
  float n30, float n31, float n32, float n33) {
@@ -4080,7 +3230,6 @@ public class PShape implements PConstants {
4080
3230
  /**
4081
3231
  * Make sure that the shape's matrix is 1) not null, and 2) has a matrix
4082
3232
  * that can handle <em>at least</em> the specified number of dimensions.
4083
- * @param dimensions
4084
3233
  */
4085
3234
  protected void checkMatrix(int dimensions) {
4086
3235
  if (matrix == null) {
@@ -4113,7 +3262,6 @@ public class PShape implements PConstants {
4113
3262
 
4114
3263
  /**
4115
3264
  * Set the pivot point for all transformations.
4116
- * @param mode
4117
3265
  */
4118
3266
  // public void pivot(float x, float y) {
4119
3267
  // px = x;
@@ -4129,7 +3277,6 @@ public class PShape implements PConstants {
4129
3277
  }
4130
3278
 
4131
3279
  /**
4132
- * @param mode
4133
3280
  * @param max range for all color elements
4134
3281
  */
4135
3282
  public void colorMode(int mode, float max) {
@@ -4138,7 +3285,6 @@ public class PShape implements PConstants {
4138
3285
 
4139
3286
 
4140
3287
  /**
4141
- * @param mode
4142
3288
  * @param maxX range for the red or hue depending on the current color mode
4143
3289
  * @param maxY range for the green or saturation depending on the current color mode
4144
3290
  * @param maxZ range for the blue or brightness depending on the current color mode
@@ -4148,11 +3294,7 @@ public class PShape implements PConstants {
4148
3294
  }
4149
3295
 
4150
3296
  /**
4151
- * @param mode
4152
3297
  * @param maxA range for the alpha
4153
- * @param maxY
4154
- * @param maxX
4155
- * @param maxZ
4156
3298
  */
4157
3299
  public void colorMode(int mode,
4158
3300
  float maxX, float maxY, float maxZ, float maxA) {
@@ -4174,11 +3316,8 @@ public class PShape implements PConstants {
4174
3316
  (colorModeY == 255) && (colorModeZ == 255);
4175
3317
  }
4176
3318
 
4177
- /**
4178
- *
4179
- * @param rgb
4180
- */
4181
- protected void colorCalc(int rgb) {
3319
+
3320
+ protected void colorCalc(int rgb) {
4182
3321
  if (((rgb & 0xff000000) == 0) && (rgb <= colorModeX)) {
4183
3322
  colorCalc((float) rgb);
4184
3323
 
@@ -4187,12 +3326,8 @@ public class PShape implements PConstants {
4187
3326
  }
4188
3327
  }
4189
3328
 
4190
- /**
4191
- *
4192
- * @param rgb
4193
- * @param alpha
4194
- */
4195
- protected void colorCalc(int rgb, float alpha) {
3329
+
3330
+ protected void colorCalc(int rgb, float alpha) {
4196
3331
  if (((rgb & 0xff000000) == 0) && (rgb <= colorModeX)) { // see above
4197
3332
  colorCalc((float) rgb, alpha);
4198
3333
 
@@ -4201,20 +3336,13 @@ public class PShape implements PConstants {
4201
3336
  }
4202
3337
  }
4203
3338
 
4204
- /**
4205
- *
4206
- * @param gray
4207
- */
4208
- protected void colorCalc(float gray) {
3339
+
3340
+ protected void colorCalc(float gray) {
4209
3341
  colorCalc(gray, colorModeA);
4210
3342
  }
4211
3343
 
4212
- /**
4213
- *
4214
- * @param gray
4215
- * @param alpha
4216
- */
4217
- protected void colorCalc(float gray, float alpha) {
3344
+
3345
+ protected void colorCalc(float gray, float alpha) {
4218
3346
  if (gray > colorModeX) gray = colorModeX;
4219
3347
  if (alpha > colorModeA) alpha = colorModeA;
4220
3348
 
@@ -4232,24 +3360,13 @@ public class PShape implements PConstants {
4232
3360
  calcAlpha = (calcAi != 255);
4233
3361
  }
4234
3362
 
4235
- /**
4236
- *
4237
- * @param x
4238
- * @param y
4239
- * @param z
4240
- */
4241
- protected void colorCalc(float x, float y, float z) {
3363
+
3364
+ protected void colorCalc(float x, float y, float z) {
4242
3365
  colorCalc(x, y, z, colorModeA);
4243
3366
  }
4244
3367
 
4245
- /**
4246
- *
4247
- * @param x
4248
- * @param y
4249
- * @param z
4250
- * @param a
4251
- */
4252
- protected void colorCalc(float x, float y, float z, float a) {
3368
+
3369
+ protected void colorCalc(float x, float y, float z, float a) {
4253
3370
  if (x > colorModeX) x = colorModeX;
4254
3371
  if (y > colorModeY) y = colorModeY;
4255
3372
  if (z > colorModeZ) z = colorModeZ;
@@ -4306,12 +3423,8 @@ public class PShape implements PConstants {
4306
3423
  calcAlpha = (calcAi != 255);
4307
3424
  }
4308
3425
 
4309
- /**
4310
- *
4311
- * @param argb
4312
- * @param alpha
4313
- */
4314
- protected void colorCalcARGB(int argb, float alpha) {
3426
+
3427
+ protected void colorCalcARGB(int argb, float alpha) {
4315
3428
  if (alpha == colorModeA) {
4316
3429
  calcAi = (argb >> 24) & 0xff;
4317
3430
  calcColor = argb;