[JAVA2D] Texturing a trapezoid (fake 3d engine)

Newbie & Debugging Questions
#1 

				double top1 =    Math.round(this.tempy + (this.newCamera.camz - this.z * 9.0D) * this.scale1);
				double top2 =    Math.round(this.tempy + (this.newCamera.camz - this.z * 9.0D) * this.scale2);
				double bottom1 = Math.round(this.tempy + (this.newCamera.camz - this.z * 9.0D) * this.scale3);
				double bottom2 = Math.round(this.tempy + (this.newCamera.camz - this.z * 9.0D) * this.scale4);
				
				if (
						(point1 > view_width && point2 > view_width && point3 > view_width && point4 > view_width) ||
						(top1 > view_height && top2 > view_height && bottom1 > view_height && bottom2 > view_height) ||
						(top1 <= 0 && top2 <= 0 && bottom1 <= 0 && bottom2 <= 0) ||
						(point1 <= 0 && point2 <= 0 && point3 <= 0 && point4 <= 0)
						){
						return;
				}

				double length = point_distance(point1, top1, point2, top2);
				double dist1 = point_distance(point1, top1, point3, bottom1);
				double dist2 = point_distance(point2, top2, point4, bottom2);
				double direction1 = point_direction(point1, top1, point3, bottom1);
				double direction2 = point_direction(point2, top2, point4, bottom2);
				if (Math.abs(direction2 - direction1) > 180) {
					if (direction2 < direction1) {
						direction2 = 360;
					}else{
						direction1 = 360;
					}

				}
				double repeat = (int) Math.ceil(length / 3.5D); //quality of the texturing
				if (repeat <= 8)
					repeat = 8; //need at least 1 draw call per image!
				if (repeat > 32)
					repeat = 32;
				
				int cellwidth = (int) Math.ceil(  length/repeat  ); //width of each image part of the floor
				Graphics2D g2d = (Graphics2D)g;
				double number = point2 - point1;
				double changex = number / repeat;
				double changey = (top2 - top1) / repeat;
				double changedir = (direction2 - direction1) / repeat;
				double changedist = (dist2 - dist1) / repeat;
				double cellwidthintex = sprite_height/repeat;
				for (int ii = 1; ii <= repeat+1; ii++) { //amount of draw calls per image (the more, the better quality)
					int i = ii;
					if (x >= newCamera.getX()) {
						i = (int) (repeat + 2 - ii);
					}
					double dx = point1 + (changex * i);
					double dy = top1 + (changey * i);
					double rx = dx;// - (cellwidth);
					double ry = dy;
					double dir = direction1 + (changedir * i);

					draw_set_rotation(g2d, dir, rx, ry);
					double dist = dist1 + (changedist * i);

					int sy1 = (int) (cellwidthintex * (i - 1));
					int sx1 = 0;
					int sy2 = (int) (sy1 + cellwidthintex);
					int sx2 = this.sprite_width;
					g.drawImage(this.sprite_index, (int)dx, (int)dy, (int)dx + (int)dist, (int)dy + (int)cellwidth + 1, sx1, sy1, sx2, sy2, null);

					draw_set_removerot(g2d, dir, rx, ry);
				}

What the above code does, can be slightly explained from this picture:

If you need me to explain anything else, please ask :slight_smile:

#2

Any help would be greatly appreciated!

#3

My advice would be to render in scanline (horizontal) order. Much simpler.

#4

The camera can turn, there would be no difference.

#5

I’m not understanding. The camera does whatever it does and you still render in scanline order.

#6

This really is a twisted and inefficient way of doing texture mapping. As Roquen said, you should consider to move to a scanline based approach instead. In addition, you can’t take perspective into account when doing it this way.