Hi guys,

I'm trying to start learning about 3D in processing. When initializing a Peasy camera with this simple script:

1. import peasy.test.*;
2. import peasy.org.apache.commons.math.*;
3. import peasy.*;
4. import peasy.org.apache.commons.math.geometry.*;
5. PeasyCam jCam;
6. void setup(){
7.   size(600,600,P3D);
8.  
9.   jCam = new PeasyCam(this, 100);
10.  
11. }
12. void draw(){
13.   background(0);
14.  
15.   stroke(255);
16.   noFill();
17.   box(600);
18.  
19. }

there is the error:

No framebuffer objects available

Does anybody know what is it? Thank you!

Hi guys

Im trying to simulate the behavior of the unicellular organism Slime Mould. This organism looks for sources of food and other slime cells. Each has a domain of vision that depends on a determined angle and depth of vision. If a food source is sensed, it moves towards the food. If no food is seen but other cells, moves towards the geometric center of them. If no food nor cells are seen, it follows the same movement.

My script is not working because I dont know how to script a certain part. Once a cell has found food, how can I make them look for other sources of food? They get stuck and I don't know what else to try, I'm quite desperate.

Any advice is welcome. Thanks in advance!


CLASS SLIME CELL

1. class SlimeCell {
2.   int visionExtend;
3.   int visionAngle;
4.   PVector location;
5.   PVector direction;
6.   SlimeCell [] allCells;
7.   ArrayList neighbors;
8.   Food [] allFood;
9.   ArrayList food;
10.   boolean isOutside;
11.   SlimeCell() {
12.     location = new PVector(random(width), random(height));
13.     direction = new PVector(random(-1, 1), random(-1, 1));
14.     neighbors = new ArrayList();
15.     food = new ArrayList();
16.     isOutside = false;
17.   }
18.   PVector returnLocation() {
19.     return location;
20.   }
21.   void getNeighbors(SlimeCell [] allCells, Food [] allFood) {
22.     visionExtend = 100;
23.     visionAngle = 135;
24.    
25.     if(allFood.length > 0){
26.       for (int i = 0; i < allFood.length; i++) {
27.         PVector a = allFood[i].returnLocation();
28.         float distance1 = dist(location.x, location.y, a.x, a.y);
29.        
30.         PVector foodCellVect = PVector.sub(a, location);
31.         float angle1 = PVector.angleBetween(direction, foodCellVect);
32.  
33.         if ((distance1<=visionExtend) && (distance1>0) && (angle1<visionAngle/2)) {
34.           food.add(allFood[i]);
35.         }
36.       }
37.     }
38.     for (int i = 0; i < allCells.length; i++) {
39.       PVector b = allCells[i].returnLocation();
40.       float distance = dist(location.x, location.y, b.x, b.y);
41.      
42.       PVector cellCellVect = PVector.sub(b, location);
43.       float angle = PVector.angleBetween(direction, cellCellVect);
44.       if ((distance<=visionExtend) && (distance>0) && (angle<visionAngle/2)) {
45.         neighbors.add(allCells[i]);
46.       }
47.     }
48.   }
49.   void getDirection() {
50.    
51.     float threshold = 45;
52.    
53.     if (food.size()==0) {
54.       if (neighbors.size()>0) {
55.         int sumX = 0;
56.         int sumY = 0;
57.         SlimeCell oneNeighbor;
58.         for (int i = 0; i < neighbors.size(); i++) {
59.           oneNeighbor = (SlimeCell) neighbors.get(i);
60.           sumX += oneNeighbor.location.x;
61.           sumY += oneNeighbor.location.y;
62.         }
63.         int xCoord = sumX/(neighbors.size());
64.         int yCoord = sumY/(neighbors.size());
65.         PVector vectorDirection = new PVector(xCoord, yCoord);
66.         direction = PVector.sub(vectorDirection, location);
67.        
68.       }if (neighbors.size()==0){
69.         direction = direction;
70.       }
71.     }if (food.size()>0){
72.      
73.       Food aim = (Food) food.get(0);
74.      
75.       PVector foodLoc = aim.returnLocation();
76.      
77.       float distance = dist(location.x, location.y, foodLoc.x, foodLoc.y);
78.      
79.       if(distance > threshold){
80.         direction = PVector.sub(foodLoc, location);
81.       }if(distance < threshold){
82.         direction = direction;
83.       }
84.     }
85.   }
86.   void mover() {
87.     direction.normalize();
88.     direction.mult(2);
89.     location = PVector.add(location, direction);
90.     if (location.x<0) isOutside = true;
91.     else if (location.x>width) isOutside = true;
92.     else if (location.y<0) isOutside = true;
93.     else if (location.y>height) isOutside = true;
94.     if (isOutside) {
95.       location.x = random(width);
96.       location.y = random(height);
97.       direction.x = random(-1, 1);
98.       direction.y = random(-1, 1);
99.       isOutside = false;
100.     }
101.    
102.   }
103.   void render() {
104.     //COPY LOCATION AND DIRECTION TO DRAW LINE
105.     PVector locationVector = location.get();
106.     PVector directionVector = direction.get();
107.     directionVector.normalize();
108.     directionVector.mult(visionExtend);
109.     PVector lineDir = PVector.add(directionVector, locationVector);
110.    
111.     //RENDER CELL
112.     noStroke();
113.     fill(0);
114.     ellipse(location.x, location.y, 5, 5);
115. /*
116.     //RENDER LINE
117.    
118.     line(location.x, location.y, lineDir.x, lineDir.y);
119.     PVector vectorDirection = PVector.add(location, lineDir);
120. */
121.     //RENDER SENSING SPACE
122.     noFill();
123.     strokeWeight(0.5);
124.     stroke(160);
125.     PVector xAxis = new PVector(1,0);
126.     float dirAxisAngle = PVector.angleBetween(xAxis, direction);
127.     translate(location.x, location.y);
128.     
129.     if(lineDir.y >= location.y){
130.       rotate(1*dirAxisAngle);
131.       arc(0, 0, visionExtend*2, visionExtend*2, radians(-visionAngle/2), radians(visionAngle/2));
132.       rotate(-dirAxisAngle);
133.     }else{
134.       rotate(-1*dirAxisAngle);
135.       arc(0, 0, visionExtend*2, visionExtend*2, radians(-visionAngle/2), radians(visionAngle/2));
136.       rotate(1*dirAxisAngle);
137.     }
138.     translate(-location.x,-location.y);   
139.   }
140. }

CLASS FOOD

1. class Food {
2.   int x;
3.   int y;
4.   int rad;
5.   PVector location;
6.   Food(int x, int y) {
7.     location = new PVector(x, y);
8.   }
9.   PVector returnLocation() {
10.     return location;
11.   }
12.   void render() {
13.     rad = 10;
14.     fill(255, 100, 0);
15.     ellipse(location.x, location.y, rad, rad);
16.   }
17. }

RUN THE SCRIPT

1. int cellNumber;
2. SlimeCell [] cellsList;
3. Food [] foodList;
4. void setup() {
5.   size(1000, 800);
6.   smooth();
7.   //FOOD SOURCES PLACEMENT
8.   foodList = new Food[3];
9.   foodList[0] = new Food(width/4, height/2);
10.   foodList[1] = new Food(width/2, height/4);
11.   foodList[2] = new Food(3*width/4, height/2);
12.   //CELLS CREATION
13.   cellNumber = 100;
14.   cellsList = new SlimeCell [cellNumber];
15.   for (int i = 0; i<cellNumber; i++) {
16.     cellsList[i] = new SlimeCell();
17.   }
18. }
19. void draw() {
20.   background(255);
21.   for (int i = 0; i < foodList.length; i++) {
22.     foodList[i].render();
23.   }
24.   for (int i = 0; i < cellsList.length; i++) {
25.     cellsList[i].getNeighbors(cellsList, foodList);
26.     cellsList[i].getDirection();
27.     cellsList[i].mover();
28.     cellsList[i].render();
29.   }
30. }