mirror of
https://github.com/processing/processing4.git
synced 2026-05-27 18:47:04 +02:00
making a complete mess
This commit is contained in:
benfry
+65
-199
@@ -262,7 +262,15 @@ public class PApplet extends Applet
|
||||
|
||||
|
||||
public void depth() {
|
||||
g = new PGraphics3(DEFAULT_WIDTH, DEFAULT_HEIGHT);
|
||||
if (g.width != 0) {
|
||||
g = new PGraphics3(g.width, g.height);
|
||||
} else {
|
||||
g = new PGraphics3(DEFAULT_WIDTH, DEFAULT_HEIGHT);
|
||||
}
|
||||
// it's ok to call this, because depth() is only getting called
|
||||
// at least inside of setup, so things can be drawn just
|
||||
// fine since it's post-beginFrame.
|
||||
g.defaults();
|
||||
}
|
||||
|
||||
|
||||
@@ -1949,126 +1957,19 @@ public class PApplet extends Applet
|
||||
// IMAGE I/O
|
||||
|
||||
|
||||
/*
|
||||
private Image gimmeImage(URL url, boolean force) {
|
||||
Toolkit tk = Toolkit.getDefaultToolkit();
|
||||
|
||||
URLConnection conn = null;
|
||||
try {
|
||||
//conn = new URLConnection(url);
|
||||
conn = url.openConnection();
|
||||
|
||||
// i don't think this does anything,
|
||||
// but just set the fella for good measure
|
||||
conn.setUseCaches(false);
|
||||
// also had a note from zach about parent.obj.close() on url
|
||||
// but that doesn't seem to be needed anymore...
|
||||
|
||||
// throws an exception if it doesn't exist
|
||||
conn.connect();
|
||||
|
||||
if (!force) {
|
||||
// how do you close the bastard?
|
||||
conn = null;
|
||||
// close connection and just use regular method
|
||||
return tk.getImage(url);
|
||||
}
|
||||
|
||||
// slurp contents of that stream
|
||||
InputStream stream = conn.getInputStream();
|
||||
|
||||
BufferedInputStream bis = new BufferedInputStream(stream);
|
||||
ByteArrayOutputStream out = new ByteArrayOutputStream();
|
||||
|
||||
try {
|
||||
int c = bis.read();
|
||||
while (c != -1) {
|
||||
out.write(c);
|
||||
c = bis.read();
|
||||
}
|
||||
} catch (IOException e) {
|
||||
return null;
|
||||
}
|
||||
bis.close(); // will this help?
|
||||
//byte bytes[] = out.toByteArray();
|
||||
|
||||
// build an image out of it
|
||||
//return tk.createImage(bytes);
|
||||
return tk.createImage(out.toByteArray());
|
||||
|
||||
} catch (Exception e) { // null pointer or i/o ex
|
||||
//System.err.println("error loading image: " + url);
|
||||
return null;
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
public PImage loadImage(String filename) {
|
||||
if (filename.toLowerCase().endsWith(".tga")) {
|
||||
return loadTargaImage(filename);
|
||||
return loadImageTGA(filename);
|
||||
}
|
||||
return loadImage(filename, true);
|
||||
}
|
||||
|
||||
|
||||
// returns null if no image of that name is found
|
||||
public PImage loadImage(String filename, boolean force) {
|
||||
//Image awtimage = null;
|
||||
//String randomizer = "?" + nf((int) (random()*10000), 4);
|
||||
|
||||
/*
|
||||
if (filename.startsWith("http://")) {
|
||||
try {
|
||||
URL url = new URL(filename);
|
||||
awtimage = gimmeImage(url, force);
|
||||
|
||||
} catch (MalformedURLException e) {
|
||||
System.err.println("error loading image from " + filename);
|
||||
e.printStackTrace();
|
||||
return null;
|
||||
}
|
||||
|
||||
} else {
|
||||
//System.out.println(getClass().getName());
|
||||
//System.out.println(getClass().getResource(filename));
|
||||
awtimage = gimmeImage(getClass().getResource(filename), force);
|
||||
if (awtimage == null) {
|
||||
awtimage =
|
||||
gimmeImage(getClass().getResource("data/" + filename), force);
|
||||
}
|
||||
if (awtimage == null) {
|
||||
try {
|
||||
//FileInputStream fis =
|
||||
//new FileInputStream(folder + "data/" + filename);
|
||||
String url = "file:/" + folder + "/data/" + filename;
|
||||
//URL url = new URL("file:/" + folder + "data/" + filename);
|
||||
awtimage = gimmeImage(new URL(url), force);
|
||||
} catch (IOException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
Image awtImage =
|
||||
Toolkit.getDefaultToolkit().createImage(loadBytes(filename));
|
||||
|
||||
/*
|
||||
if (awtimage == null) {
|
||||
System.err.println("could not load image " + filename);
|
||||
return null;
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
Component component = this; //applet;
|
||||
if (component == null) {
|
||||
component = new Frame();
|
||||
((Frame)component).pack();
|
||||
// now we have a peer! yay!
|
||||
}
|
||||
MediaTracker tracker = new MediaTracker(component);
|
||||
*/
|
||||
|
||||
MediaTracker tracker = new MediaTracker(this);
|
||||
tracker.addImage(awtImage, 0);
|
||||
try {
|
||||
@@ -2089,37 +1990,7 @@ public class PApplet extends Applet
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return image;
|
||||
|
||||
/*
|
||||
int jwidth = awtimage.getWidth(null);
|
||||
int jheight = awtimage.getHeight(null);
|
||||
|
||||
int jpixels[] = new int[jwidth*jheight];
|
||||
PixelGrabber pg =
|
||||
new PixelGrabber(awtimage, 0, 0, jwidth, jheight, jpixels, 0, jwidth);
|
||||
try {
|
||||
pg.grabPixels();
|
||||
} catch (InterruptedException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
|
||||
//int format = RGB;
|
||||
if (filename.toLowerCase().endsWith(".gif")) {
|
||||
// if it's a .gif image, test to see if it has transparency
|
||||
for (int i = 0; i < jpixels.length; i++) {
|
||||
// since transparency is often at corners, hopefully this
|
||||
// will find a non-transparent pixel quickly and exit
|
||||
if ((jpixels[i] & 0xff000000) != 0xff000000) {
|
||||
return new PImage(jpixels, jwidth, jheight, ARGB);
|
||||
//format = RGBA;
|
||||
//break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return new PImage(jpixels, jwidth, jheight, RGB);
|
||||
*/
|
||||
}
|
||||
|
||||
|
||||
@@ -2129,44 +2000,44 @@ public class PApplet extends Applet
|
||||
* [fry] this could be optimized to not use loadBytes
|
||||
* which would help out memory situations with large images
|
||||
*/
|
||||
protected PImage loadTargaImage(String filename) {
|
||||
protected PImage loadImageTGA(String filename) {
|
||||
// load image file as byte array
|
||||
byte[] buffer = loadBytes(filename);
|
||||
|
||||
// check if it's a TGA and has 8bits/colour channel
|
||||
if (buffer[2] == 2 && buffer[17] == 8) {
|
||||
// get image dimensions
|
||||
//int w=(b2i(buffer[13])<<8) + b2i(buffer[12]);
|
||||
int w = ((buffer[13] & 0xff) << 8) + (buffer[12] & 0xff);
|
||||
//int h=(b2i(buffer[15])<<8) + b2i(buffer[14]);
|
||||
int h = ((buffer[15] & 0xff) << 8) + (buffer[14] & 0xff);
|
||||
// check if image has alpha
|
||||
boolean hasAlpha=(buffer[16] == 32);
|
||||
// check if it's a TGA and has 8bits/colour channel
|
||||
if (buffer[2] == 2 && buffer[17] == 8) {
|
||||
// get image dimensions
|
||||
//int w=(b2i(buffer[13])<<8) + b2i(buffer[12]);
|
||||
int w = ((buffer[13] & 0xff) << 8) + (buffer[12] & 0xff);
|
||||
//int h=(b2i(buffer[15])<<8) + b2i(buffer[14]);
|
||||
int h = ((buffer[15] & 0xff) << 8) + (buffer[14] & 0xff);
|
||||
// check if image has alpha
|
||||
boolean hasAlpha=(buffer[16] == 32);
|
||||
|
||||
// setup new image object
|
||||
PImage img = new PImage(w,h);
|
||||
img.format = (hasAlpha ? ARGB : RGB);
|
||||
// setup new image object
|
||||
PImage img = new PImage(w,h);
|
||||
img.format = (hasAlpha ? ARGB : RGB);
|
||||
|
||||
// targa's are written upside down, so we need to parse it in reverse
|
||||
int index = (h-1) * w;
|
||||
// actual bitmap data starts at byte 18
|
||||
int offset = 18;
|
||||
// targa's are written upside down, so we need to parse it in reverse
|
||||
int index = (h-1) * w;
|
||||
// actual bitmap data starts at byte 18
|
||||
int offset = 18;
|
||||
|
||||
// read out line by line
|
||||
for (int y = h-1; y >= 0; y--) {
|
||||
for (int x = 0; x < w; x++) {
|
||||
img.pixels[index + x] =
|
||||
(buffer[offset++] & 0xff) |
|
||||
((buffer[offset++] & 0xff) << 8) |
|
||||
((buffer[offset++] & 0xff) << 16) |
|
||||
(hasAlpha ? ((buffer[offset++] & 0xff) << 24) : 0xff000000);
|
||||
}
|
||||
index -= w;
|
||||
}
|
||||
return img;
|
||||
}
|
||||
die("loadImage(): bad targa image format");
|
||||
return null;
|
||||
// read out line by line
|
||||
for (int y = h-1; y >= 0; y--) {
|
||||
for (int x = 0; x < w; x++) {
|
||||
img.pixels[index + x] =
|
||||
(buffer[offset++] & 0xff) |
|
||||
((buffer[offset++] & 0xff) << 8) |
|
||||
((buffer[offset++] & 0xff) << 16) |
|
||||
(hasAlpha ? ((buffer[offset++] & 0xff) << 24) : 0xff000000);
|
||||
}
|
||||
index -= w;
|
||||
}
|
||||
return img;
|
||||
}
|
||||
die("loadImage(): bad targa image format");
|
||||
return null;
|
||||
}
|
||||
|
||||
|
||||
@@ -4510,23 +4381,18 @@ v PApplet.this.stop();
|
||||
}
|
||||
|
||||
|
||||
public void modified() {
|
||||
g.modified();
|
||||
public void updatePixels() {
|
||||
g.updatePixels();
|
||||
}
|
||||
|
||||
|
||||
public void modified(int x, int y) {
|
||||
g.modified(x, y);
|
||||
public void updatePixels(int x1, int y1, int x2, int y2) {
|
||||
g.updatePixels(x1, y1, x2, y2);
|
||||
}
|
||||
|
||||
|
||||
public void modified(int x1, int y1, int x2, int y2) {
|
||||
g.modified(x1, y1, x2, y2);
|
||||
}
|
||||
|
||||
|
||||
public void resetModified() {
|
||||
g.resetModified();
|
||||
public void pixelsUpdated() {
|
||||
g.pixelsUpdated();
|
||||
}
|
||||
|
||||
|
||||
@@ -4778,6 +4644,12 @@ v PApplet.this.stop();
|
||||
}
|
||||
|
||||
|
||||
public void quad(float x1, float y1, float x2, float y2,
|
||||
float x3, float y3, float x4, float y4) {
|
||||
g.quad(x1, y1, x2, y2, x3, y3, x4, y4);
|
||||
}
|
||||
|
||||
|
||||
public void rectMode(int mode) {
|
||||
g.rectMode(mode);
|
||||
}
|
||||
@@ -4788,12 +4660,6 @@ v PApplet.this.stop();
|
||||
}
|
||||
|
||||
|
||||
public void quad(float x1, float y1, float x2, float y2,
|
||||
float x3, float y3, float x4, float y4) {
|
||||
g.quad(x1, y1, x2, y2, x3, y3, x4, y4);
|
||||
}
|
||||
|
||||
|
||||
public void ellipseMode(int mode) {
|
||||
g.ellipseMode(mode);
|
||||
}
|
||||
@@ -5001,11 +4867,6 @@ v PApplet.this.stop();
|
||||
}
|
||||
|
||||
|
||||
public void angleMode(int mode) {
|
||||
g.angleMode(mode);
|
||||
}
|
||||
|
||||
|
||||
public void translate(float tx, float ty) {
|
||||
g.translate(tx, ty);
|
||||
}
|
||||
@@ -5016,6 +4877,16 @@ v PApplet.this.stop();
|
||||
}
|
||||
|
||||
|
||||
public void angleMode(int mode) {
|
||||
g.angleMode(mode);
|
||||
}
|
||||
|
||||
|
||||
public void rotate(float angle) {
|
||||
g.rotate(angle);
|
||||
}
|
||||
|
||||
|
||||
public void rotateX(float angle) {
|
||||
g.rotateX(angle);
|
||||
}
|
||||
@@ -5031,11 +4902,6 @@ v PApplet.this.stop();
|
||||
}
|
||||
|
||||
|
||||
public void rotate(float angle) {
|
||||
g.rotate(angle);
|
||||
}
|
||||
|
||||
|
||||
public void rotate(float angle, float vx, float vy, float vz) {
|
||||
g.rotate(angle, vx, vy, vz);
|
||||
}
|
||||
|
||||
@@ -279,6 +279,7 @@ public class PGraphics extends PImage implements PConstants {
|
||||
resize(iwidth, iheight);
|
||||
|
||||
// init color/stroke/fill
|
||||
// called instead just before setup on first frame
|
||||
//defaults();
|
||||
|
||||
// clear geometry for loading later
|
||||
@@ -744,12 +745,6 @@ public class PGraphics extends PImage implements PConstants {
|
||||
}
|
||||
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////
|
||||
|
||||
// LINE
|
||||
|
||||
|
||||
public void line(float x1, float y1, float x2, float y2) {
|
||||
// TODO
|
||||
}
|
||||
@@ -761,18 +756,18 @@ public class PGraphics extends PImage implements PConstants {
|
||||
}
|
||||
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////
|
||||
|
||||
// TRIANGLE
|
||||
|
||||
|
||||
public void triangle(float x1, float y1, float x2, float y2,
|
||||
float x3, float y3) {
|
||||
// TODO
|
||||
}
|
||||
|
||||
|
||||
public void quad(float x1, float y1, float x2, float y2,
|
||||
float x3, float y3, float x4, float y4) {
|
||||
// TODO
|
||||
}
|
||||
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////
|
||||
|
||||
@@ -809,19 +804,12 @@ public class PGraphics extends PImage implements PConstants {
|
||||
y1 -= vradius;
|
||||
}
|
||||
|
||||
// TODO write rect drawing function
|
||||
draw_rect(x1, y1, x2, y2);
|
||||
}
|
||||
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////
|
||||
|
||||
// QUAD
|
||||
|
||||
|
||||
public void quad(float x1, float y1, float x2, float y2,
|
||||
float x3, float y3, float x4, float y4) {
|
||||
// TODO
|
||||
protected void draw_rect(float x1, float y1, float x2, float y2) {
|
||||
// TODO write rect drawing function
|
||||
}
|
||||
|
||||
|
||||
@@ -857,6 +845,11 @@ public class PGraphics extends PImage implements PConstants {
|
||||
y = b - d/2f;
|
||||
}
|
||||
|
||||
draw_ellipse(x, y, w, h);
|
||||
}
|
||||
|
||||
|
||||
protected void draw_ellipse(float x, float y, float w, float h) {
|
||||
// TODO draw an ellipse
|
||||
}
|
||||
|
||||
@@ -900,7 +893,12 @@ public class PGraphics extends PImage implements PConstants {
|
||||
while (stop < start) stop += TWO_PI;
|
||||
}
|
||||
|
||||
// TODO draw an arc
|
||||
draw_arc(start, stop, x, y, w, h);
|
||||
}
|
||||
|
||||
|
||||
protected void draw_arc(float start, float stop,
|
||||
float x, float y, float w, float h) {
|
||||
}
|
||||
|
||||
|
||||
@@ -1407,7 +1405,7 @@ public class PGraphics extends PImage implements PConstants {
|
||||
textFont.resetLeading();
|
||||
|
||||
} else {
|
||||
System.err.println("Ignoring improperly loaded font in textFont()");
|
||||
throw new RuntimeException("a null PFont was passed to textFont()");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1424,7 +1422,7 @@ public class PGraphics extends PImage implements PConstants {
|
||||
textSize = size;
|
||||
|
||||
} else {
|
||||
System.err.println("First set a font before setting its size.");
|
||||
throw new RuntimeException("use textFont() before textSize()");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1434,7 +1432,7 @@ public class PGraphics extends PImage implements PConstants {
|
||||
textFont.leading(leading);
|
||||
|
||||
} else {
|
||||
System.err.println("First set a font before setting its leading.");
|
||||
throw new RuntimeException("use textFont() before textLeading()");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1444,7 +1442,7 @@ public class PGraphics extends PImage implements PConstants {
|
||||
textFont.align(mode);
|
||||
|
||||
} else {
|
||||
System.err.println("First set a font before setting its mode.");
|
||||
throw new RuntimeException("use textFont() before textMode()");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1454,7 +1452,7 @@ public class PGraphics extends PImage implements PConstants {
|
||||
textFont.space(space);
|
||||
|
||||
} else {
|
||||
System.err.println("First set a font before setting the space.");
|
||||
throw new RuntimeException("use textFont() before textSpace()");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1464,7 +1462,7 @@ public class PGraphics extends PImage implements PConstants {
|
||||
textFont.text(c, x, y, this);
|
||||
|
||||
} else {
|
||||
System.err.println("text(): first set a font before drawing text");
|
||||
throw new RuntimeException("use textFont() before text()");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1479,7 +1477,7 @@ public class PGraphics extends PImage implements PConstants {
|
||||
textFont.text(s, x, y, this);
|
||||
|
||||
} else {
|
||||
System.err.println("text(): first set a font before drawing text");
|
||||
throw new RuntimeException("use textFont() before text()");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1521,7 +1519,7 @@ public class PGraphics extends PImage implements PConstants {
|
||||
textFont.text(s, x1, y1, x2, y2, this);
|
||||
|
||||
} else {
|
||||
System.err.println("text(): first set a font before drawing text");
|
||||
throw new RuntimeException("use textFont() before text()");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1564,11 +1562,6 @@ public class PGraphics extends PImage implements PConstants {
|
||||
// MATRIX TRANSFORMATIONS
|
||||
|
||||
|
||||
public void angleMode(int mode) {
|
||||
angleMode = mode;
|
||||
}
|
||||
|
||||
|
||||
public void translate(float tx, float ty) {
|
||||
m02 += tx*m00 + ty*m01 + m02;
|
||||
m12 += tx*m10 + ty*m11 + m12;
|
||||
@@ -1579,16 +1572,9 @@ public class PGraphics extends PImage implements PConstants {
|
||||
// not supported in 2D
|
||||
}
|
||||
|
||||
public void rotateX(float angle) {
|
||||
// not supported in 2D
|
||||
}
|
||||
|
||||
public void rotateY(float angle) {
|
||||
// not supported in 2D
|
||||
}
|
||||
|
||||
public void rotateZ(float angle) {
|
||||
// not supported in 2D
|
||||
public void angleMode(int mode) {
|
||||
angleMode = mode;
|
||||
}
|
||||
|
||||
|
||||
@@ -1605,6 +1591,19 @@ public class PGraphics extends PImage implements PConstants {
|
||||
}
|
||||
|
||||
|
||||
public void rotateX(float angle) {
|
||||
// not supported in 2D
|
||||
}
|
||||
|
||||
public void rotateY(float angle) {
|
||||
// not supported in 2D
|
||||
}
|
||||
|
||||
public void rotateZ(float angle) {
|
||||
// not supported in 2D
|
||||
}
|
||||
|
||||
|
||||
public void rotate(float angle, float vx, float vy, float vz) {
|
||||
// not supported in 2D
|
||||
}
|
||||
|
||||
@@ -561,20 +561,21 @@ public class PGraphics2 extends PGraphics {
|
||||
if (who.cache == null) {
|
||||
who.cache = new BufferedImage(who.width, who.height,
|
||||
BufferedImage.TYPE_INT_ARGB);
|
||||
who.modified(); // mark the whole thing for update
|
||||
who.updatePixels(); // mark the whole thing for update
|
||||
}
|
||||
|
||||
if (who.modified) {
|
||||
// update the sub-portion of the image as necessary
|
||||
BufferedImage bi = (BufferedImage) who.cache;
|
||||
|
||||
bi.setRGB(who.mx1, who.my1,
|
||||
who.mx2 - who.mx1 + 1,
|
||||
who.my2 - who.my1 + 1,
|
||||
bi.setRGB(who.mx1,
|
||||
who.my1,
|
||||
who.mx2 - who.mx1,
|
||||
who.my2 - who.my1,
|
||||
who.pixels,
|
||||
who.my1*who.width + who.mx1, // offset for copy
|
||||
who.width); // scan size
|
||||
who.resetModified();
|
||||
who.pixelsUpdated();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -843,7 +844,7 @@ public class PGraphics2 extends PGraphics {
|
||||
|
||||
|
||||
public void copy(PImage src, int dx, int dy) {
|
||||
// TODO if this image is not RGB, needs to behave differently
|
||||
// TODO if this image is not ARGB or RGB, needs to behave differently
|
||||
// (if it's gray, need to copy gray pixels)
|
||||
// for alpha, just leave it be.. copy() doesn't composite
|
||||
((BufferedImage) image).setRGB(dx, dy, src.width, src.height,
|
||||
|
||||
+155
-50
@@ -4,7 +4,7 @@
|
||||
PGraphics - main graphics and rendering context
|
||||
Part of the Processing project - http://processing.org
|
||||
|
||||
Copyright (c) 2004- Ben Fry and Casey Reas
|
||||
Copyright (c) 2004-05 Ben Fry and Casey Reas
|
||||
Copyright (c) 2001-04 Massachusetts Institute of Technology
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
@@ -25,11 +25,9 @@
|
||||
|
||||
package processing.core;
|
||||
|
||||
//import java.applet.*;
|
||||
import java.awt.*;
|
||||
//import java.awt.event.*;
|
||||
import java.awt.image.*;
|
||||
//import java.io.*;
|
||||
|
||||
|
||||
public class PGraphics3 extends PGraphics {
|
||||
|
||||
@@ -207,7 +205,7 @@ public class PGraphics3 extends PGraphics {
|
||||
allocate();
|
||||
|
||||
// clear the screen with the old background color
|
||||
background(backgroundColor);
|
||||
//background(backgroundColor);
|
||||
|
||||
// init perspective projection based on new dimensions
|
||||
cameraFOV = 60; // at least for now
|
||||
@@ -246,7 +244,9 @@ public class PGraphics3 extends PGraphics {
|
||||
// because of a java 1.1 bug, pixels must be registered as
|
||||
// opaque before their first run, the memimgsrc will flicker
|
||||
// and run very slowly.
|
||||
for (int i = 0; i < pixelCount; i++) pixels[i] = 0xffffffff;
|
||||
backgroundColor |= 0xff000000; // just for good measure
|
||||
for (int i = 0; i < pixelCount; i++) pixels[i] = backgroundColor;
|
||||
//for (int i = 0; i < pixelCount; i++) pixels[i] = 0xffffffff;
|
||||
|
||||
cm = new DirectColorModel(32, 0x00ff0000, 0x0000ff00, 0x000000ff);;
|
||||
mis = new MemoryImageSource(width, height, pixels, 0, width);
|
||||
@@ -254,7 +254,6 @@ public class PGraphics3 extends PGraphics {
|
||||
mis.setAnimated(true);
|
||||
image = Toolkit.getDefaultToolkit().createImage(mis);
|
||||
|
||||
// TODO don't allocate these until depth() is called
|
||||
zbuffer = new float[pixelCount];
|
||||
stencil = new int[pixelCount];
|
||||
|
||||
@@ -266,6 +265,9 @@ public class PGraphics3 extends PGraphics {
|
||||
public void defaults() {
|
||||
super.defaults();
|
||||
|
||||
cameraMode(PERSPECTIVE);
|
||||
|
||||
//System.out.println("PGraphics3.defaults()");
|
||||
// easiest for beginners
|
||||
textureMode(IMAGE_SPACE);
|
||||
|
||||
@@ -1394,6 +1396,24 @@ public class PGraphics3 extends PGraphics {
|
||||
}
|
||||
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////
|
||||
|
||||
// BASIC SHAPES
|
||||
|
||||
|
||||
public void point(float x, float y) {
|
||||
point(x, y, 0);
|
||||
}
|
||||
|
||||
|
||||
public void point(float x, float y, float z) {
|
||||
beginShape(POINTS);
|
||||
vertex(x, y, z);
|
||||
endShape();
|
||||
}
|
||||
|
||||
/*
|
||||
private void point3(float x, float y, float z, int color) {
|
||||
// need to get scaled version of the stroke
|
||||
float x1 = screenX(x - 0.5f, y - 0.5f, z);
|
||||
@@ -1414,59 +1434,145 @@ public class PGraphics3 extends PGraphics {
|
||||
// these will be
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////
|
||||
|
||||
// SHAPES
|
||||
|
||||
public void point(float x, float y) {
|
||||
point(x, y, 0);
|
||||
}
|
||||
|
||||
public void point(float x, float y, float z) {
|
||||
}
|
||||
|
||||
public void line(float x1, float y1, float x2, float y2) {
|
||||
line(x1, y1, 0, x2, y2, 0);
|
||||
}
|
||||
|
||||
|
||||
public void line(float x1, float y1, float z1,
|
||||
float x2, float y2, float z2) {
|
||||
beginShape(LINES);
|
||||
vertex(x1, y1, z1);
|
||||
vertex(x2, y2, z2);
|
||||
endShape();
|
||||
}
|
||||
|
||||
|
||||
public void triangle(float x1, float y1, float x2, float y2,
|
||||
float x3, float y3) {
|
||||
beginShape(TRIANGLES);
|
||||
vertex(x1, y1);
|
||||
vertex(x2, y2);
|
||||
vertex(x3, y3);
|
||||
endShape();
|
||||
}
|
||||
|
||||
//public void rectMode(int mode)
|
||||
|
||||
public void rect(float x1, float y1, float x2, float y2) {
|
||||
}
|
||||
|
||||
public void quad(float x1, float y1, float x2, float y2,
|
||||
float x3, float y3, float x4, float y4) {
|
||||
beginShape(QUADS);
|
||||
vertex(x1, y1);
|
||||
vertex(x2, y2);
|
||||
vertex(x3, y3);
|
||||
vertex(x4, y4);
|
||||
endShape();
|
||||
}
|
||||
|
||||
public void circle(float x, float y, float radius) {
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////
|
||||
|
||||
// PLACED SHAPES
|
||||
|
||||
|
||||
public void draw_rect(float x1, float y1, float x2, float y2) {
|
||||
quad(x1, y1, x2, y1, x2, y2, x1, y2);
|
||||
}
|
||||
|
||||
public void ellipseMode(int mode) {
|
||||
|
||||
protected void draw_ellipse(float x, float y, float hradius, float vradius) {
|
||||
// adapt accuracy to radii used w/ a minimum of 4 segments [toxi]
|
||||
// now uses current scale factors to determine "real" transformed radius
|
||||
|
||||
//int cAccuracy = (int)(4+Math.sqrt(hradius*abs(m00)+vradius*abs(m11))*2);
|
||||
//int cAccuracy = (int)(4+Math.sqrt(hradius+vradius)*2);
|
||||
|
||||
// notched this up to *3 instead of *2 because things were
|
||||
// looking a little rough, i.e. the calculate->arctangent example [fry]
|
||||
|
||||
// also removed the m00 and m11 because those were causing weirdness
|
||||
// need an actual measure of magnitude in there [fry]
|
||||
|
||||
int cAccuracy = (int)(4+Math.sqrt(hradius+vradius)*3);
|
||||
|
||||
// [toxi031031] adapted to use new lookup tables
|
||||
float inc = (float)SINCOS_LENGTH / cAccuracy;
|
||||
|
||||
float val = 0;
|
||||
beginShape(POLYGON);
|
||||
for (int i = 0; i < cAccuracy; i++) {
|
||||
vertex(x + cosLUT[(int) val] * hradius,
|
||||
y + sinLUT[(int) val] * vradius);
|
||||
val += inc;
|
||||
}
|
||||
endShape();
|
||||
}
|
||||
|
||||
public void ellipse(float x, float y, float hradius, float vradius) {
|
||||
|
||||
/**
|
||||
* Start and stop are in radians, converted by the parent function.
|
||||
* Note that the radians can be greater (or less) than TWO_PI.
|
||||
* This is so that an arc can be drawn that crosses zero mark,
|
||||
* and the user will still collect $200.
|
||||
*/
|
||||
protected void draw_arc(float start, float stop,
|
||||
float x, float y, float w, float h) {
|
||||
float hr = w / 2f;
|
||||
float vr = h / 2f;
|
||||
|
||||
if (fill) {
|
||||
// shut off stroke for a minute
|
||||
boolean savedStroke = stroke;
|
||||
stroke = false;
|
||||
|
||||
int startLUT = (int) (0.5f + (start / TWO_PI) * SINCOS_LENGTH);
|
||||
int stopLUT = (int) (0.5f + (stop / TWO_PI) * SINCOS_LENGTH);
|
||||
|
||||
beginShape(TRIANGLE_FAN);
|
||||
vertex(x, y);
|
||||
int increment = 1; // what's a good algorithm? stopLUT - startLUT;
|
||||
for (int i = startLUT; i < stopLUT; i += increment) {
|
||||
int ii = i % SINCOS_LENGTH;
|
||||
vertex(x + cosLUT[ii] * hr,
|
||||
y + sinLUT[ii] * vr);
|
||||
}
|
||||
// draw last point explicitly for accuracy
|
||||
vertex(x + cosLUT[stopLUT % SINCOS_LENGTH] * hr,
|
||||
y + sinLUT[stopLUT % SINCOS_LENGTH] * vr);
|
||||
endShape();
|
||||
|
||||
stroke = savedStroke;
|
||||
}
|
||||
|
||||
if (stroke) {
|
||||
// Almost identical to above, but this uses a LINE_STRIP
|
||||
// and doesn't include the first (center) vertex.
|
||||
|
||||
boolean savedFill = fill;
|
||||
fill = false;
|
||||
|
||||
int startLUT = (int) (0.5f + (start / TWO_PI) * SINCOS_LENGTH);
|
||||
int stopLUT = (int) (0.5f + (stop / TWO_PI) * SINCOS_LENGTH);
|
||||
|
||||
beginShape(LINE_STRIP);
|
||||
int increment = 1; // what's a good algorithm? stopLUT - startLUT;
|
||||
for (int i = startLUT; i < stopLUT; i += increment) {
|
||||
int ii = i % SINCOS_LENGTH;
|
||||
vertex(x + cosLUT[ii] * hr,
|
||||
y + sinLUT[ii] * vr);
|
||||
}
|
||||
// draw last point explicitly for accuracy
|
||||
vertex(x + cosLUT[stopLUT % SINCOS_LENGTH] * hr,
|
||||
y + sinLUT[stopLUT % SINCOS_LENGTH] * vr);
|
||||
endShape();
|
||||
|
||||
fill = savedFill;
|
||||
}
|
||||
}
|
||||
|
||||
//public void arcMode(int mode)
|
||||
|
||||
public void arc(float start, float stop,
|
||||
float x, float y, float radius) {
|
||||
}
|
||||
|
||||
public void arc(float start, float stop,
|
||||
float x, float y, float hr, float vr) {
|
||||
}
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////
|
||||
@@ -1493,12 +1599,7 @@ public class PGraphics3 extends PGraphics {
|
||||
// 3D BOX
|
||||
|
||||
|
||||
// solid or wire depends on settings for stroke and fill
|
||||
// slices/stacks can be set by an advanced option
|
||||
|
||||
//public void cube(float size) {
|
||||
public void box(float size) {
|
||||
//box(-size/2, -size/2, -size/2, size/2, size/2, size/2);
|
||||
box(size, size, size);
|
||||
}
|
||||
|
||||
@@ -1506,15 +1607,14 @@ public class PGraphics3 extends PGraphics {
|
||||
// OPT this isn't the least bit efficient
|
||||
// because it redraws lines along the vertices
|
||||
// ugly ugly ugly!
|
||||
//public void box(float x1, float y1, float z1,
|
||||
// float x2, float y2, float z2) {
|
||||
public void box(float w, float h, float d) {
|
||||
float x1 = -w/2f; float x2 = w/2f;
|
||||
float y1 = -h/2f; float y2 = h/2f;
|
||||
float z1 = -d/2f; float z2 = d/2f;
|
||||
|
||||
//if (hints[NEW_GRAPHICS]) triangle.setCulling(true);
|
||||
triangle.setCulling(true);
|
||||
if (triangle != null) { // triangle is null in gl
|
||||
triangle.setCulling(true);
|
||||
}
|
||||
|
||||
beginShape(QUADS);
|
||||
|
||||
@@ -1556,8 +1656,9 @@ public class PGraphics3 extends PGraphics {
|
||||
|
||||
endShape();
|
||||
|
||||
//if (hints[NEW_GRAPHICS]) triangle.setCulling(false);
|
||||
triangle.setCulling(false);
|
||||
if (triangle != null) { // triangle is null in gl
|
||||
triangle.setCulling(false);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -1637,8 +1738,9 @@ public class PGraphics3 extends PGraphics {
|
||||
if (x!=0f && y!=0f && z!=0f) translate(x,y,z);
|
||||
scale(r);
|
||||
|
||||
//if (hints[NEW_GRAPHICS]) triangle.setCulling(true);
|
||||
triangle.setCulling(true);
|
||||
if (triangle != null) { // triangle is null in gl
|
||||
triangle.setCulling(true);
|
||||
}
|
||||
|
||||
// 1st ring from south pole
|
||||
beginShape(TRIANGLE_STRIP);
|
||||
@@ -1681,8 +1783,9 @@ public class PGraphics3 extends PGraphics {
|
||||
endShape();
|
||||
pop();
|
||||
|
||||
//if (hints[NEW_GRAPHICS]) triangle.setCulling(false);
|
||||
triangle.setCulling(false);
|
||||
if (triangle != null) { // triangle is null in gl
|
||||
triangle.setCulling(false);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -2236,6 +2339,8 @@ public class PGraphics3 extends PGraphics {
|
||||
* even if noDepth() was called before draw() exited.
|
||||
*/
|
||||
public void clear() {
|
||||
//System.out.println("PGraphics3.clear(" +
|
||||
// PApplet.hex(backgroundColor) + ")");
|
||||
for (int i = 0; i < pixelCount; i++) {
|
||||
pixels[i] = backgroundColor;
|
||||
zbuffer[i] = MAX_FLOAT;
|
||||
|
||||
+134
-42
@@ -4,7 +4,7 @@
|
||||
PImage - storage class for pixel data
|
||||
Part of the Processing project - http://Proce55ing.net
|
||||
|
||||
Copyright (c) 2001-03
|
||||
Copyright (c) 2001-05
|
||||
Ben Fry, Massachusetts Institute of Technology and
|
||||
Casey Reas, Interaction Design Institute Ivrea
|
||||
|
||||
@@ -28,6 +28,7 @@ package processing.core;
|
||||
|
||||
import java.awt.*;
|
||||
import java.awt.image.*;
|
||||
import java.lang.reflect.*;
|
||||
import java.io.*;
|
||||
|
||||
|
||||
@@ -84,6 +85,9 @@ public class PImage implements PConstants, Cloneable {
|
||||
public int imageMode = CORNER;
|
||||
public boolean smooth = false;
|
||||
|
||||
/** native storage for java 1.3 image object */
|
||||
//public Object image;
|
||||
|
||||
/** for subclasses that need to store info about the image */
|
||||
public Object cache;
|
||||
|
||||
@@ -186,10 +190,15 @@ public class PImage implements PConstants, Cloneable {
|
||||
|
||||
|
||||
/**
|
||||
* mode is one of CORNERS, CORNER, CENTER
|
||||
* mode is one of CORNERS or CORNER, because the others are
|
||||
* just too weird for the other functions
|
||||
*/
|
||||
public void imageMode(int mode) {
|
||||
imageMode = mode;
|
||||
if ((imageMode == CORNER) || (imageMode == CORNERS)) {
|
||||
imageMode = mode;
|
||||
} else {
|
||||
throw new RuntimeException("imageMode() only works with CORNER or CORNERS");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -216,41 +225,124 @@ public class PImage implements PConstants, Cloneable {
|
||||
// MARKING IMAGE AS MODIFIED / FOR USE w/ GET/SET
|
||||
|
||||
|
||||
public void modified() {
|
||||
mx1 = 0;
|
||||
my1 = 0;
|
||||
mx2 = width - 1;
|
||||
my2 = height - 1;
|
||||
modified = true;
|
||||
/*
|
||||
public int[] loadPixels() {
|
||||
return getPixels(0, 0, width, height);
|
||||
}
|
||||
*/
|
||||
|
||||
|
||||
/**
|
||||
* Note that when using imageMode(CORNERS),
|
||||
* the x2 and y2 positions are non-inclusive.
|
||||
*/
|
||||
/*
|
||||
public int[] loadPixels(int x1, int y1, int x2, int y2) {
|
||||
if (modified) {
|
||||
// have to set the modified region to include the min/max
|
||||
// of the coordinates coming in.
|
||||
// also, mustn't get the pixels for the section that's
|
||||
// already been marked as modified. gah.
|
||||
// too complicated, just throw an error
|
||||
String msg =
|
||||
"getPixels(x, y, w, h) cannot be used multiple times. " +
|
||||
"Use getPixels() once to get the entire image instead.";
|
||||
throw new RuntimeException(msg);
|
||||
}
|
||||
|
||||
if (imageMode == CORNER) { // x2, y2 are w/h
|
||||
x2 += x1;
|
||||
y2 += y1;
|
||||
}
|
||||
|
||||
if (pixels == null) { // this is a java 1.3 buffered image
|
||||
if (image == null) { // this is just an error
|
||||
throw new RuntimeException("PImage not properly setup for getPixels()");
|
||||
} else {
|
||||
pixels = new int[width*height];
|
||||
}
|
||||
}
|
||||
|
||||
if (image == null) {
|
||||
// this happens when using just the 1.1 library
|
||||
// no need to do anything, since the pixels have already been grabbed
|
||||
|
||||
} else {
|
||||
// copy the contents of the buffered image to pixels[]
|
||||
//((BufferedImage) image).getRGB(x, y, w, h, output.pixels, 0, width);
|
||||
try {
|
||||
//System.out.println("running getrgb...");
|
||||
Class bufferedImageClass =
|
||||
Class.forName("java.awt.image.BufferedImage");
|
||||
// getRGB(int startX, int startY, int w, int h, int[] rgbArray, int offset, int scansize)
|
||||
Method getRgbMethod =
|
||||
bufferedImageClass.getMethod("getRGB", new Class[] {
|
||||
Integer.TYPE, Integer.TYPE, Integer.TYPE, Integer.TYPE,
|
||||
int[].class, Integer.TYPE, Integer.TYPE
|
||||
});
|
||||
getRgbMethod.invoke(image, new Object[] {
|
||||
new Integer(x1), new Integer(y1),
|
||||
new Integer(x2 - x1 + 1), new Integer(y2 - y1 + 1),
|
||||
pixels, new Integer(0), new Integer(width)
|
||||
});
|
||||
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
return pixels; // just to be nice
|
||||
}
|
||||
*/
|
||||
|
||||
|
||||
/**
|
||||
* Mark all pixels as needing update.
|
||||
*/
|
||||
public void updatePixels() {
|
||||
updatePixels(0, 0, width, height);
|
||||
}
|
||||
|
||||
public void modified(int x, int y) {
|
||||
if (x < mx1) mx1 = x;
|
||||
if (x > mx2) mx2 = x;
|
||||
if (y < my1) my1 = y;
|
||||
if (y > my2) my2 = y;
|
||||
modified = true;
|
||||
|
||||
/**
|
||||
* Note that when using imageMode(CORNERS),
|
||||
* the x2 and y2 positions are non-inclusive.
|
||||
*/
|
||||
public void updatePixels(int x1, int y1, int x2, int y2) {
|
||||
//if (!modified) { // could just set directly, but..
|
||||
//}
|
||||
|
||||
if (imageMode == CORNER) { // x2, y2 are w/h
|
||||
x2 += x1;
|
||||
y2 += y1;
|
||||
}
|
||||
|
||||
if (!modified) {
|
||||
mx1 = x1;
|
||||
mx2 = x2;
|
||||
my1 = y1;
|
||||
my2 = y2;
|
||||
modified = true;
|
||||
|
||||
} else {
|
||||
if (x1 < mx1) mx1 = x1;
|
||||
if (x1 > mx2) mx2 = x1;
|
||||
if (y1 < my1) my1 = y1;
|
||||
if (y1 > my2) my2 = y1;
|
||||
|
||||
if (x2 < mx1) mx1 = x2;
|
||||
if (x2 > mx2) mx2 = x2;
|
||||
if (y2 < my1) my1 = y2;
|
||||
if (y2 > my2) my2 = y2;
|
||||
}
|
||||
}
|
||||
|
||||
public void modified(int x1, int y1, int x2, int y2) {
|
||||
if (x1 < mx1) mx1 = x1;
|
||||
if (x1 > mx2) mx2 = x1;
|
||||
if (y1 < my1) my1 = y1;
|
||||
if (y1 > my2) my2 = y1;
|
||||
|
||||
if (x2 < mx1) mx1 = x2;
|
||||
if (x2 > mx2) mx2 = x2;
|
||||
if (y2 < my1) my1 = y2;
|
||||
if (y2 > my2) my2 = y2;
|
||||
|
||||
modified = true;
|
||||
}
|
||||
|
||||
public void resetModified() {
|
||||
mx1 = -Integer.MAX_VALUE;
|
||||
my1 = -Integer.MAX_VALUE;
|
||||
mx2 = Integer.MAX_VALUE;
|
||||
my2 = Integer.MAX_VALUE;
|
||||
public void pixelsUpdated() {
|
||||
//mx1 = Integer.MAX_VALUE;
|
||||
//my1 = Integer.MAX_VALUE;
|
||||
//mx2 = -Integer.MAX_VALUE;
|
||||
//my2 = -Integer.MAX_VALUE;
|
||||
modified = false;
|
||||
}
|
||||
|
||||
|
||||
@@ -283,10 +375,10 @@ public class PImage implements PConstants, Cloneable {
|
||||
w = (w - x);
|
||||
h = (h - x);
|
||||
|
||||
} else if (imageMode == CENTER) {
|
||||
//} else if (imageMode == CENTER) {
|
||||
// w/h are the proper w/h, but x/y need to be moved
|
||||
x -= w/2;
|
||||
y -= h/2;
|
||||
//x -= w/2;
|
||||
//y -= h/2;
|
||||
}
|
||||
|
||||
if (x < 0) x = 0;
|
||||
@@ -506,9 +598,9 @@ public class PImage implements PConstants, Cloneable {
|
||||
sx2 += sx1; sy2 += sy1;
|
||||
dx2 += dx1; dy2 += dy1;
|
||||
|
||||
} else if (imageMode == CENTER) {
|
||||
sx2 /= 2f; sy2 /= 2f;
|
||||
dx2 /= 2f; dy2 /= 2f;
|
||||
//} else if (imageMode == CENTER) {
|
||||
//sx2 /= 2f; sy2 /= 2f;
|
||||
//dx2 /= 2f; dy2 /= 2f;
|
||||
}
|
||||
|
||||
if ((src == this) &&
|
||||
@@ -585,9 +677,9 @@ public class PImage implements PConstants, Cloneable {
|
||||
sx2 += sx1; sy2 += sy1;
|
||||
dx2 += dx1; dy2 += dy1;
|
||||
|
||||
} else if (imageMode == CENTER) {
|
||||
sx2 /= 2f; sy2 /= 2f;
|
||||
dx2 /= 2f; dy2 /= 2f;
|
||||
//} else if (imageMode == CENTER) {
|
||||
//sx2 /= 2f; sy2 /= 2f;
|
||||
//dx2 /= 2f; dy2 /= 2f;
|
||||
}
|
||||
|
||||
if ((src == this) &&
|
||||
|
||||
@@ -140,27 +140,36 @@ public interface PMethods {
|
||||
public void triangle(float x1, float y1, float x2, float y2,
|
||||
float x3, float y3);
|
||||
|
||||
public void quad(float x1, float y1, float x2, float y2,
|
||||
float x3, float y3, float x4, float y4);
|
||||
|
||||
//
|
||||
|
||||
public void rectMode(int mode);
|
||||
|
||||
public void rect(float x1, float y1, float x2, float y2);
|
||||
|
||||
public void quad(float x1, float y1, float x2, float y2,
|
||||
float x3, float y3, float x4, float y4);
|
||||
//protected void draw_rect(float x1, float y1, float x2, float y2);
|
||||
|
||||
//public void circle(float x, float y, float radius);
|
||||
// REMOVED public void circle(float x, float y, float radius);
|
||||
|
||||
public void ellipseMode(int mode);
|
||||
|
||||
public void ellipse(float x, float y, float hradius, float vradius);
|
||||
|
||||
//public void arcMode(int mode);
|
||||
//protected void draw_ellipse(float x, float y, float hradius, float vradius);
|
||||
|
||||
//public void arc(float start, float stop,
|
||||
// float x, float y, float radius);
|
||||
// REMOVED public void arcMode(int mode);
|
||||
|
||||
// REMOVED public void arc(float start, float stop,
|
||||
// float x, float y, float radius);
|
||||
|
||||
public void arc(float start, float stop,
|
||||
float x, float y, float hr, float vr);
|
||||
|
||||
//protected void draw_arc(float start, float stop,
|
||||
// float x, float y, float hr, float vr);
|
||||
|
||||
//
|
||||
|
||||
public void box(float size);
|
||||
@@ -263,20 +272,20 @@ public interface PMethods {
|
||||
|
||||
//
|
||||
|
||||
public void angleMode(int mode);
|
||||
|
||||
public void translate(float tx, float ty);
|
||||
|
||||
public void translate(float tx, float ty, float tz);
|
||||
|
||||
public void angleMode(int mode);
|
||||
|
||||
public void rotate(float angle);
|
||||
|
||||
public void rotateX(float angle);
|
||||
|
||||
public void rotateY(float angle);
|
||||
|
||||
public void rotateZ(float angle);
|
||||
|
||||
public void rotate(float angle);
|
||||
|
||||
public void rotate(float angle, float v0, float v1, float v2);
|
||||
|
||||
public void scale(float s);
|
||||
|
||||
+73
-10
@@ -29,11 +29,71 @@ o saveFrame gets called at the beginning of loop()
|
||||
o or is just a message to save the next frame (problem for anim)
|
||||
X vertices max out at 512.. make it grow
|
||||
X add gzipInput and gzipOutput
|
||||
X light(x, y, z, c1, c2, c3, TYPE)
|
||||
X also BLight with same constructor, and on() and off() fxn
|
||||
|
||||
image stuff
|
||||
o could also do PImage2, which would need a getPixels() before messing w/ it
|
||||
o bad idea, distinction not clear
|
||||
o even in java 1.1, could use regular java.awt.Image and require getPixels()
|
||||
o -> 1.1 wouldn't help anything, because needs pixels to render, oops
|
||||
|
||||
api changes
|
||||
X removed circle.. it's dumb when ellipse() is in there
|
||||
X (it's not like we have square() in the api)
|
||||
X arcMode is gone.. just uses ellipseMode()
|
||||
X save tga and tif methods are static and public
|
||||
X imageMode(CORNER) and CORNERS are the only usable versions
|
||||
|
||||
_ sphere x,y,z,r or box w,h,d.. need to make them consistent
|
||||
|
||||
_ the updatePixels() in PGraphics has to be overridden (from PImage)
|
||||
_ to make itself actually update on-screen
|
||||
_ actually, should be no different than the check_image function
|
||||
_ PGraphics2 and PGraphicsGL will need loadPixels() to be called
|
||||
_ in order to read pixels from the buffer
|
||||
_ loadPixels() and updatePixels() prolly should be shut off in opengl
|
||||
_ make people use get() instead to grab sub-images
|
||||
_ PGraphicsGL.copy() needs to be overridden.. use glDrawBitmap
|
||||
|
||||
o loadImage() needs to handle 1.1 vs 1.3 loading
|
||||
o set image.format to be BUFFERED? no.. just use RGBA always
|
||||
o have a flag to always use the cache, i.e. with BufferedImage
|
||||
o turn that off when someone modifies it (nope, no need to)
|
||||
X PImage.getPixels(), updatePixels(), updatePixels(x, y, w, h),
|
||||
o PImage.setPixels(int another[]);
|
||||
|
||||
readPixels/writePixels?
|
||||
has to happen, since this is so fundamental to gl as well
|
||||
loadImage in 1.3 leaves pixels[] null (not in 1.1)
|
||||
1.3 plus gl is a problem, since conflicting caches
|
||||
gl has no need for a bufferedimage tho
|
||||
so maybe checks to see if the cache is a BufferedImage
|
||||
if it is, calls getPixels to set the int array
|
||||
then replaces cache with glimageache
|
||||
pappletgl loadimage could take care of this instead
|
||||
calls super.loadImage(), if cache != null, proceed..
|
||||
this is prolly a mess
|
||||
PImage.getPixels() and PImage.getPixels(x, y, w, h) ->
|
||||
(the xywh version still allocates the entire array, but only updates those)
|
||||
only needed for java2d
|
||||
not (necessarily) needed when loading images,
|
||||
but definitely needed when setting pixels on PGraphics
|
||||
PImage.updatePixels() and PImage.updatePixels(x, y, w, h)
|
||||
(this is actually just setModified)
|
||||
in opengl, marks all or some as modified
|
||||
so next time it's drawn, the texture is updated PGraphicsGL.image()
|
||||
in java2d, updates the BufferedImage on next draw
|
||||
can't use regular getPixels() on PGraphics, because its image isn't 'cache'
|
||||
also, the cache may be used to draw the whole surface as a gl texture (?)
|
||||
not a problem for the main PGraphics, but for any others created to draw on
|
||||
|
||||
_ imageMode(CENTER) is weird for copy() and updatePixels()
|
||||
_ perhaps copy() and get() ignore imageMode and use xywh or x1y1x2y2?
|
||||
_ or disallow imageMode(CENTER) altogether?
|
||||
|
||||
_ in java 1.3, getPixels() can call getRGB() via reflection
|
||||
_ cache.getClass().getName().equals("BufferedImage")
|
||||
|
||||
_ beginShape()
|
||||
_ don't allow you to draw stroked items unless stroke() is called
|
||||
@@ -50,32 +110,35 @@ _ get regular graphics engine working again
|
||||
_ smooth is no longer working
|
||||
_ ellipses aren't handled
|
||||
|
||||
_ look for size() method to determine default size of applet
|
||||
_ (same as applet exporter function)
|
||||
_ when using core graphics, don't show applet frame until first frame
|
||||
_ (in opengl, open frame early, make sure this isn't inhibited)
|
||||
|
||||
_ default to single byte input from serial port
|
||||
_ and add serial.setBuffer() for message length as alternative
|
||||
_ or serial.setDelimiter() to fire message on delim
|
||||
|
||||
_ move textMode and textSpace back out of PFont
|
||||
_ use die() to fail in font situations
|
||||
_ can't, just use a RuntimeException
|
||||
|
||||
_ die() may need to throw a RuntimeException
|
||||
|
||||
_ light(x, y, z, c1, c2, c3, TYPE)
|
||||
_ also BLight with same constructor, and on() and off() fxn
|
||||
_ make light() functions actually do something in PGraphicsGL
|
||||
_ make lights half do something in PGraphics3 too
|
||||
|
||||
_ bring in materials for opengl as well?
|
||||
_ don't include a class, just make it similar to the light functions
|
||||
|
||||
_ be consistent about getXxx() methods
|
||||
|
||||
//
|
||||
_ on start, mouseX is 0.. how to avoid?
|
||||
_ use firstMouse variable.. figure out naming
|
||||
|
||||
//
|
||||
|
||||
_ basic sample audio playback needed for p5
|
||||
_ make separate java 1.1 and java 1.3 classes
|
||||
|
||||
_ on start, mouseX is 0.. how to avoid?
|
||||
_ use firstMouse variable.. figure out naming
|
||||
_ microphone input for java 1.3
|
||||
_ this may be reason to move sound classes out into a lib?
|
||||
_ or maybe just microphone goes into its own library?
|
||||
|
||||
_ image loading bug is huge
|
||||
_ figure out how to handle cached images, multiple images
|
||||
|
||||
Reference in New Issue
Block a user