Fork: 0
cory / EPQ-3D-renderer
Browse code
- Added object collections
- Changed demo rendering to cube
- Enabled backface culling
- Fixed frame drops due to lines going offscreen
- Optimised 2d triangle rendering
master V1
1 parent 4106f82 commit bb447dab2c58aed5aff065b830f74c5eb7fa83f9
@cory cory authored on 10 Nov 2022
Patch
Unified Split
Showing 19 changed files
View
out/production/EPQ 3D renderer/App.class
Not supported
View
out/production/EPQ 3D renderer/Face.class
Not supported
View
out/production/EPQ 3D renderer/Line.class
Not supported
View
out/production/EPQ 3D renderer/Object3d.class
Not supported
View
out/production/EPQ 3D renderer/Player.class
Not supported
View
out/production/EPQ 3D renderer/Point3D.class
Not supported
View
out/production/EPQ 3D renderer/PointComp.class
Not supported
View
out/production/EPQ 3D renderer/Screen.class
Not supported
View
out/production/EPQ 3D renderer/Triangle.class
Not supported
View
28
■■■■■
 src/App.java
import javax.swing.*;
 
class App {
 
static ObjectCollection mainCollection;
private static void initWindow() {
// create a window frame and set the title in the toolbar
JFrame window = new JFrame("Testing");
// when we close the window, stop the app
window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
// create the jpanel to draw on.
// this also initializes the game loop
Screen screen = new Screen();
initObjects();
Screen screen = new Screen(mainCollection);
// add the jpanel to the window
window.add(screen);
window.addKeyListener(screen);
window.addMouseListener(screen);
// this is a lot of boilerplate code that you shouldn't be too concerned about.
// just know that when main runs it will call initWindow() once.
SwingUtilities.invokeLater(App::initWindow);
}
 
public static void initObjects(){
mainCollection = new ObjectCollection();
mainCollection.addObject(new Object3d(new PointComp[]{
new PointComp(-10,-10,-10),
new PointComp(-10,-10,10),
new PointComp(-10,10,-10),
new PointComp(-10,10,10),
new PointComp(10,-10,-10),
new PointComp(10,-10,10),
new PointComp(10,10,-10),
new PointComp(10,10,10)
 
}, new int[][]{
{0,2,3,1},
{4,5,7,6},
{0,1,5,4},
{1,3,7,5},
{3,2,6,7},
{2,0,4,6},
}, true));
}
}
View
67
■■■■■
 src/Face.java
import java.awt.image.BufferedImage;
import java.security.cert.TrustAnchor;
import java.util.ArrayList;
 
public class Face {
PointComp[] points;
Vector3D normal;
Triangle[] tris;
 
public void rotate(Matrix camMatrix){
for (PointComp point:
points){
camMatrix.multiplyPoint3to(point.point, point.rotatedPoint);
public void initialise(){
calculateNormal();
separateTris();
}
 
public void invalidate(){
for (Triangle tri:
tris) {
tri.invalidate();
}
}
public void project(int FPDis, int scrX, int scrY){
public int draw(BufferedImage img, BufferedImage debugImg, Matrix camMatrix, double FPDis, int scrX, int scrY){
// check for backface culling has been done previously.
// initialise points
int numberofPixels = 0;
boolean valid = true;
for (PointComp point:
points){
point.rotatedPoint.projectOn(FPDis, scrX, scrY, point.projectedPoint);
points) {
point.setRotatedPoint(camMatrix);
point.setProjectedPoint(FPDis, scrX, scrY);
// skip rendering if any points are behind the camera
if(point.getRotatedPoint().z < 0){
valid = false;
break;
}
}
if(valid){for (Triangle tri:
tris) {
numberofPixels += tri.draw(img);
}}
return numberofPixels;
}
public void separateTris(){
 
Triangle[] newTris = new Triangle[points.length - 2];
for(int i = 0; i< newTris.length; i+=1){
newTris[i] = new Triangle(
points[0].getProjectedPoint(),
points[i+1].getProjectedPoint(),
points[i+2].getProjectedPoint());
}
tris = newTris;
}
public void calculateNormal(){
// too many new variables
Point3D point0 = points[0].point;
View
17
■■■■■
 src/Line.java
* Draws onto a given image
* @param img the image to draw onto
*/
public void draw(BufferedImage img){
 
if (!is_initialised){initialise();}
if (iterator == 'x'){
for (int i = 0; i <= dx; i++){
nextPix();
try {
if(returnVal[0] >= 0 && returnVal[0] < img.getWidth() && returnVal[1] >= 0 && returnVal[1] < img.getHeight()) { // check if drawing in bounds
img.setRGB(returnVal[0], returnVal[1], Color.HSBtoRGB(1, 1, 1));
}
catch (ArrayIndexOutOfBoundsException ignored){
// System.out.println(returnVal[0] + " " + returnVal[1]);
}
 
}
} else {
for (int i = 0; i <= dy; i++){
nextPix();
try {
if(returnVal[0] >= 0 && returnVal[0] < img.getWidth() && returnVal[1] >= 0 && returnVal[1] < img.getHeight()) { // check if drawing in bounds
img.setRGB(returnVal[0], returnVal[1], Color.HSBtoRGB(.5f, 1, 1));
}
catch (ArrayIndexOutOfBoundsException ignored){
// System.out.println(returnVal[0] + " " + returnVal[1]);
}
}
}
is_initialised = false;
/*
debug - draws the start and end of each line in white and green
img.setRGB(realPoint1.intX(), realPoint1.intY(), Color.blue.getRGB());
img.setRGB(realPoint2.intX(), realPoint2.intY(), Color.green.getRGB());
*/
 
is_initialised = false;
}
 
/**
* Performs the initial calculations required to draw the line
View
35
■■■■■
 src/Object3d.java
import java.awt.*;
import java.awt.image.BufferedImage;
 
public class Object3d {
public PointComp[] points;
public int[][] faceList;
public Face[] faces;
public Point3D boundingSphereC;
public double boundingSphereR;
 
public Object3d(PointComp[] _points, int[][] faceList, boolean initialise){
public Object3d(PointComp[] _points, int[][] _faceList, boolean initialise){
points = _points;
faceList = _faceList;
if(initialise){initialise();}
}
public void invalidate(){
for (Face face:
faces) {
face.invalidate();
}
}
public void draw(BufferedImage img, BufferedImage debugimg, Matrix camMatrix, double FPDis, int scrX, int scrY, Point3D playerPos){
int iterator = 0;
for (Face face:
faces) {
// check whether faces are pointing towards or away from the camera
// TODO figure out angle
Vector3D camVec = new Vector3D(
face.points[0].point.x - playerPos.x,
face.points[0].point.y - playerPos.y,
face.points[0].point.z - playerPos.z
);
double ang = face.normal.angleTo(camVec);
//debugimg.getGraphics().drawString(Math.round(Math.toDegrees(ang)) + " angle " + iterator, 10, 20 + 10*iterator);
int numberOfPixels = 0;
if(ang <= Math.PI/2-0.01){
numberOfPixels = face.draw(img, debugimg, camMatrix, FPDis, scrX, scrY);
}
debugimg.getGraphics().drawString(iterator + ": " +numberOfPixels , 10, 20 + 10*iterator);
 
iterator += 1;
}
}
public void initialise(){
// init faces
faces = new Face[faceList.length];
faces[face].points = new PointComp[faceList[face].length];
for (int point = 0; point < faceList[face].length; point += 1){
faces[face].points[point] = points[faceList[face][point]];
}
faces[face].initialise();
}
// init bounding sphere
double distance = 0;
double newDis;
View
65
■■■■■
 src/ObjectCollection.java
import java.awt.*;
import java.awt.image.BufferedImage;
import java.util.ArrayList;
import java.util.Objects;
 
// stores both objects and other object collections
public class ObjectCollection {
public ArrayList<PointComp> points = new ArrayList<PointComp>();
private Object3d collectionObject;
public ArrayList<ObjectCollection> subCollections = new ArrayList<ObjectCollection>();
public ArrayList<Object3d> objects = new ArrayList<Object3d>();
 
public void invalidate(boolean invalidatePoints){
// the first level of object collections should contain all the points for the sub-levels.
// this means that we only need to invalidate them at the top level
if(invalidatePoints){for (PointComp point:
points) {
point.invalidate();
}}
for(ObjectCollection subCollection:
subCollections){
subCollection.invalidate(false);
}
for(Object3d object:
objects){
object.invalidate();
}
}
 
public void draw(BufferedImage img, BufferedImage debugimg, Matrix camMatrix, double FPDis, int scrX, int scrY, Point3D playerPos){
// todo check for frustum culling
for (Object3d object:
objects) {
object.draw(img, debugimg, camMatrix, FPDis, scrX, scrY, playerPos);
}
// todo check for frustum culling
for(ObjectCollection collection:
subCollections){
collection.draw(img, debugimg, camMatrix, FPDis, scrX, scrY, playerPos);
}
}
public void addCollection(int[] pointList){
subCollections.add(new ObjectCollection());
}
// making sure that all the point indices make sense might be a nightmare but ehh
public void addObject(Object3d object){
PointComp[] newpoints = object.points;
objects.add(object);
// add the new object
 
// merge lists
for (PointComp newpoint : newpoints) {
boolean found = false;
// find out if any of the new points already exist in the list
for (PointComp point : points) {
if (newpoint == point) {
found = true;
break;
}
}
if (!found) {
points.add(newpoint);
}
}
}
//
}
View
19
■■■■■
 src/Player.java
protected double Fpdis;
private Point3D position = new Point3D(-30,0,0);
private Point3D rotation = new Point3D(0,Math.PI / 2, 0);
private Point3D direction = new Point3D(0,0,0);
public Vector3D viewVector = new Vector3D(0,0,0);
public double mouseSensitivity = 0.005; // radians per pixel
// called when the player is initialised
public Player() {
Fpdis = Math.tanh(Math.toRadians(FOV)/2d);
{{1, 0, 0, -position.x},
{0, 1, 0, -position.y},
{0, 0, 1, -position.z}}
);
// multiply out camera matrix
camMatrix = xMat.multiply(yMat).multiply(zMat).multiply(traMat);
// multiply out camera matrix for rotation
camMatrix = xMat.multiply(yMat).multiply(zMat);
// calculate view vector
/*Point3D viewPoint = new Point3D(0,0,0);
camMatrix.multiplyPoint3to(new Point3D(0,0,1), viewPoint);
viewVector.x = viewPoint.x;viewVector.y=viewPoint.y;viewVector.z=viewPoint.z;*/
 
// add translation to camMatrix
camMatrix = camMatrix.multiply(traMat);
}
 
// returnValue Functions
public Point3D getPos() {
View
4
■■■■■
 src/Point3D.java
}
public Point2D project(double fpdis, int scrX, int scrY){
return new Point2D(
(int)(((fpdis*y)/z + .5)*scrX),
(int)(((fpdis*x)/z + .5)*scrX)
(int)(((fpdis*x)/z + .5)*scrY)
// multiply by scrX both times such that the projected screen always projects points between -1<x<1.
// this means that there isn't any weird scaling, and the FOV is in terms of horizontal.. ness.
);
}
public void projectOn(double fpdis, int scrX, int scrY, Point2D point){
point.x = (int)(scrX*((fpdis*y)/z + .5));
point.y = (int)(scrY*((fpdis*y)/z + .5));
point.y = (int)(scrX*((fpdis*x)/z + .5));
}
public double[] get(){
return new double[]{x, y, z};
}
View
66
■■■■■
 src/PointComp.java
public class PointComp {
public Point3D point;
public Point3D rotatedPoint;
public Point2D projectedPoint;
public PointComp(){
 
public Point3D point = new Point3D(0,0,0);
private final Point3D rotatedPoint = new Point3D(0,0,0);
private boolean isRotatedPointValid = true;
private final Point2D projectedPoint = new Point2D(0,0);
private boolean isProjectedPointValid = true;
public PointComp(double _x, double _y, double _z){
point.x = _x;
point.y = _y;
point.z = _z;
}
public void invalidate(){
isProjectedPointValid = false; isRotatedPointValid = false;
}
public Point3D getRotatedPoint(){
if(!isRotatedPointValid){
throw new RuntimeException("Rotated point not initialised");
}
return rotatedPoint;
}
public Point2D getProjectedPoint(){
if(!isRotatedPointValid){
throw new RuntimeException("Projected point not initialised");
}
return projectedPoint;
}
public void setRotatedPoint(Matrix camMatrix){
camMatrix.multiplyPoint3to(point, rotatedPoint);
if(!isRotatedPointValid) {
camMatrix.multiplyPoint3to(point, rotatedPoint);
isRotatedPointValid = true;
}
}
public void project(double FPDis, int scrX, int scrY){
rotatedPoint.projectOn(FPDis, scrX, scrY, projectedPoint);
public void setProjectedPoint(double FPDis, int scrX, int scrY){
if(!isProjectedPointValid) {
rotatedPoint.projectOn(FPDis, scrX, scrY, projectedPoint);
isProjectedPointValid = true;
}
}
}
View
26
■■■■■
 src/Screen.java
import javax.swing.*;
 
public class Screen extends JPanel implements ActionListener, KeyListener, MouseListener, MouseMotionListener {
// __working variables__
 
public long lastTime = 0;
// mouse
private boolean captured = false;
private final Point2D mouseRel = new Point2D(0,0);
private Cursor invisibleCursor;
 
public ObjectCollection mainCollection;
 
// testing\
//private Line line = new Line(new Point2D(200, 200),new Point2D(1, 1));
//private Triangle Triangle = new Triangle(new Point2D(200, 200), new Point2D(1, 1), new Point2D(400,200));
 
// keep a reference to the timer object that triggers actionPerformed() in
// case we need access to it in another method
private final Timer timer;
// objects that appear on the game board
private final Player player;
 
public Screen() {
public Screen(ObjectCollection _mainCollection) {
mainCollection = _mainCollection;
 
// set the game board size
setPreferredSize(new Dimension(TILE_SIZE * COLUMNS, TILE_SIZE * ROWS));
// set the game board background color
setBackground(new Color(232, 232, 232));
Toolkit.getDefaultToolkit().sync();
}
private void drawScreen(Graphics g) {
BufferedImage img = new BufferedImage(getWidth(), getHeight(), BufferedImage.TYPE_INT_RGB );
BufferedImage debugimg = new BufferedImage(getWidth(), getHeight(), BufferedImage.TYPE_INT_ARGB);
debugimg.createGraphics();
g.setColor(Color.white);
// line.point2.x = 100*Math.sin(ang) + 200;
// line.point2.y = 100*Math.cos(ang) + 200;
// Triangle.point2.x = 100*Math.sin(ang+3) + 200;
// Triangle.point2.y = 100*Math.cos(ang+3) + 200;
// line.draw(img);
ArrayList<Point3D> newPoints = new ArrayList<Point3D>();
/* ArrayList<Point3D> newPoints = new ArrayList<Point3D>();
for (Point3D point: points) {
Point3D _new = new Point3D(0,0,0);
player.camMatrix.multiplyPoint3to(point, _new);
if(_new.z > .1) {
} catch(NullPointerException ignored){}
 
try{t1.draw(img);}catch (NullPointerException ignored){}
try{t2.draw(img);}catch (NullPointerException ignored){}
ang += 0.02;
ang += 0.02;*/
mainCollection.invalidate(true);
mainCollection.draw(img, debugimg, player.camMatrix, player.Fpdis, getWidth(), getHeight(), player.getPos());
g.drawImage(img, 0, 0, this);
g.drawImage(debugimg, 0, 0, this);
// DEBUG DRAWING
g.drawString(Math.round(1000/(float)(System.currentTimeMillis() - lastTime)) + " fps" , 10, 10);
lastTime = System.currentTimeMillis();
 
}
 
@Override
View
72
■■■■■
 src/Triangle.java
private Point2D min;
private Point2D max;
// progress variables
 
 
public void invalidate() {
is_initialised = false;
}
public Triangle(Point2D _pA, Point2D _pB, Point2D _pC){
point1 = _pA;
point2 = _pB;
point3 = _pC;
}
public void draw(BufferedImage img){
// returns int for debug
public int draw(BufferedImage img){
int numberOfPixels = 0; // debug
long lastMillis;
 
if (!is_initialised){initialise();}
int[] point1 = new int[]{0, 0};
int[] point2 = new int[]{0, 0};
int lastX = 0;
int lastXLong = 0;
int[] point1;
int[] point2;
char currentLine = 'A';
LineLong.initialise();
LineA.initialise();
LineB.initialise();
LineLong.draw(img);
LineA.draw(img);
LineB.draw(img);
for(int x = min.x; x <= max.x; x += 1) {
while(lastXLong == point1[0]) {
 
lastMillis = System.currentTimeMillis();
 
point1 = LineLong.nextPix();
point2 = LineA.nextPix();
for(int x = min.x+1; x <= max.x; x += 1) {
while(x-1 == point1[0]) {
point1 = LineLong.nextPix();
}
while(lastX == point2[0]) {
while(x-1 == point2[0]) {
if (currentLine == 'A') {
try{point2 = LineA.nextPix();}
catch (RuntimeException e){
currentLine = 'B';
else {
point2 = LineB.nextPix();
}
}
lastXLong = point1[0];
lastX = point2[0];
if(point1[1] < point2[1]) {
for (int y = point1[1]; y <= point2[1]; y += 1) {
if(x >= 0 && x < img.getWidth() && y >= 0 && y < img.getHeight()) { // check if drawing in bounds
// cancel drawing if the x value of the triangle is out of bounds
if (x >= img.getWidth()) {break;}
if (x > 0) {
// check which way to loop
// TODO - work out a way of not needing to test for this every time
if (point1[1] < point2[1]) {
for (int y = Math.max(point1[1], 0); y <= Math.min(point2[1], img.getHeight() - 1); y += 1) {
img.setRGB(x, y, Color.HSBtoRGB(.5f, 1, 1));
}
}} else {
for (int y = point2[1]; y <= point1[1]; y += 1) {
if(x >= 0 && x < img.getWidth() && y >= 0 && y < img.getHeight()) { // check if drawing in bounds
} else {
for (int y = Math.max(point2[1], 0); y <= Math.min(point1[1], img.getHeight() - 1); y += 1) {
img.setRGB(x, y, Color.HSBtoRGB(.5f, 1, 1));
}
}}
}
}
}
is_initialised = false;
lastMillis = (System.currentTimeMillis() - lastMillis);
return (int)lastMillis;
}
public void initialise(){
if (point1 == null || point2 == null || point3 == null){
throw new NullPointerException();
}
min = new Point2D(Math.min(point1.x, Math.min(point2.x, point3.x)), Math.min(point1.y, Math.min(point2.y, point3.y)));
max = new Point2D(Math.max(point1.x, Math.max(point2.x, point3.x)), Math.max(point1.y, Math.max(point2.y, point3.y)));
// woo horrible IFs mess.
// if there are no vertical lines, then we need to find which points touch the edges.
// we need to figure out which points touch the edges in order to find which line is the 'full length' edge.
Point2D realPointA;
Point2D realPointB;
Point2D realPointC;
if (point1.x == min.x) { realPointA = point1;