Att göra en grundläggande 3D-motor i Java (1 / 5 steg)

Steg 1: Den nationella klassen

Det första som måste göras är en huvudklass. Huvudklass hanterar visar bilder till användaren, uppmanar andra klasser för att räkna om vad ska visas till spelaren och uppdatera positionen för kameran.

För den här klassen kommer att importen vara:

import java.awt.Color;
import java.awt.Graphics;
import java.awt.image.BufferStrategy;
import java.awt.image.BufferedImage;
import java.awt.image.DataBufferInt;
import java.util.ArrayList;
import javax.swing.JFrame;

Klassen och dess variabler kommer att se ut så här:

allmän klass spelet sträcker sig JFrame genomför Runnable {
privata statisk sista långa serialVersionUID = 1L;
Public int mapWidth = 15.
Public int mapHeight = 15.
privat tråd tråd;
privata boolean kör;
privat BufferedImage bild;
Public int [] pixlar.
offentliga statisk int [] [] karta =
{
{1,1,1,1,1,1,1,1,2,2,2,2,2,2,2},
{1,0,0,0,0,0,0,0,2,0,0,0,0,0,2},
{1,0,3,3,3,3,3,0,0,0,0,0,0,0,2},
{1,0,3,0,0,0,3,0,2,0,0,0,0,0,2},
{1,0,3,0,0,0,3,0,2,2,2,0,2,2,2},
{1,0,3,0,0,0,3,0,2,0,0,0,0,0,2},
{1,0,3,3,0,3,3,0,2,0,0,0,0,0,2},
{1,0,0,0,0,0,0,0,2,0,0,0,0,0,2},
{1,1,1,1,1,1,1,1,4,4,4,0,4,4,4},
{1,0,0,0,0,0,1,4,0,0,0,0,0,0,4},
{1,0,0,0,0,0,1,4,0,0,0,0,0,0,4},
{1,0,0,2,0,0,1,4,0,3,3,3,3,0,4},
{1,0,0,0,0,0,1,4,0,3,3,3,3,0,4},
{1,0,0,0,0,0,0,0,0,0,0,0,0,0,4},
{1,1,1,1,1,1,1,4,4,4,4,4,4,4,4}
};

Observera att kartan kan konfigureras om till vad du vill, vad jag har här är bara ett urval. Siffrorna på kartan representerar vilken typ av vägg kommer att vara på den positionen. En 0 representerar tomt utrymme medan andra nummer representerar en fast vägg och den struktur som går med det. BufferedImage är vad som visas för användaren, och pixlar är en matris med alla pixlar i bilden. Övriga variabler brukar verkligen visas igen, de används bara för att få grafik och program fungerar.

Konstruktören kommer att se ut så här nu:

offentliga Game() {
tråden = nya Thread(this);
bild = nya BufferedImage (640, 480, BufferedImage.TYPE_INT_RGB);
pixlar = ((DataBufferInt)image.getRaster().getDataBuffer()).getData();
setSize (640, 480);
setResizable(false);
setTitle ("3D-motor");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBackground(Color.black);
setLocationRelativeTo(null);
setVisible(true);
Start();
}

Merparten av detta är bara initiering av variablerna som klass och ramen. Koden efter "pixlar =" ansluter pixlar och bild så att helst datavärdena i pixlar ändras motsvarande ändringar visas på bilden när den visas för användaren.

Start och stopp är enkel och används för att se till att programmet säkert börjar och slutar.

privata synkroniseras void start() {
kör = sant;
Thread.start();
}
offentliga synkroniseras void stop() {
köra = false;
försök {
Thread.Join();
} fånga (InterruptedException e) {
e.printStackTrace();
}
}

De sista två metoder som måste vara i klassen spel är render och köra metoder. Metoden render ut så här:

public void render() {
BufferStrategy bs = getBufferStrategy();
IF(BS == null) {
createBufferStrategy(3);
hemkomst.
}
Graphics g = bs.getDrawGraphics();
g.drawImage (bild, 0, 0, image.getWidth(), image.getHeight(), null);
BS.show();
}

En buffert strategi används vid rendering så att uppdateringar är smidigare. Sammantaget hjälper använder en buffert strategi bara spelet utseendet bättre när du kör. För att faktiskt dra bilden till skärmen ett graphics-objekt hämtas från strategin som buffert och används för att rita vår image.

Kör metoden är mycket viktigt eftersom det hanterar hur ofta olika delar av programmet uppdateras. För att göra detta använder vissa kod att hålla reda på när 1/60 av en andra har passerat, och när den har skärmen och kameran är uppdaterade. Detta förbättrar hur smidigt programmet körs. Kör metoden ser ut så här:

public void run() {
lång lastTime = System.nanoTime();
slutliga dubbel ns = 1000000000.0 / 60.0;//60 gånger per sekund
dubbla delta = 0;
requestFocus();
While(Running) {
länge nu = System.nanoTime();
delta = delta + ((now-lastTime) / ns);
lastTime = nu;
medan (delta > = 1) //Make säker uppdatering sker endast 60 gånger per sekund
{
hanterar all logik begränsad tid

delta--;
}
Render (), //displays till dess att skärmen obegränsad
}
}

När alla dessa metoder, konstruktörer och variabler är sedan är det enda kvar för att göra i klassen spelet just nu att lägga till en huvudsakliga metod. Den huvudsakliga metoden är mycket lätt allt du behöver göra är:

offentliga statisk void main (String [] args) {
Spel spel = nya Game();
}

Och nu huvudklass görs för tillfället! Om du kör programmet bör nu en svart skärm dyka upp.