Hallo
Ich möchte in meinem Projekt Licht einfügen, das Licht selbst hab ich schon gemacht, denn bei der Vordefinierten Spere aus dem glu-Paket funktioniert es sehr schön, nur bei meinen Objekten nicht. Ich denke es liegt an den Normalen, nur weiß ich nicht viel darüber(Vielleicht kann jemand ein Tutorial empfehlen), nur dass sie senkrecht auf der allen Flächen eines Objekts stehen, also habe ich ein Testobjekt mit von mir selbst gemachten Normalen erstellt, aber das wurde auch nicht vom Licht beeinflusst.Ich hab im Internet nichts vernünftiges dazu gefunden(Außer Zeug mit Shadern und das ist ja eher optional und Licht ja auch ohne das, oder?).
licht ohne shader = veraltetes opengl.
du solltest shader verwenden. ein super gutes tutorial gibt es hier:
Category: Modern OpenGL Series
(licht beginnt bei tut 6)
normalen einer fläche kannst du mit dem kreuzprodukt bestimmen.
Heißt so viel wie eine Ebene aus den drei Punkten aufstellen und dann
das kreuzprodukt anwenden. ausgeschrieben sieht das so aus:
Danke, aber wie setze ich das jetzt um, das wurde ja mit diesem Shader gemacht, nur hab ich überhaupt keine Erfahrung und zeichne meinen Kram mit VBO’s? Ich hab mir zu Shadern das mal angeguckt, das hat aber nicht wirklich funktioniert und ehrlich gesagt verstehe ich die Funktionsweise dieser Shader noch nicht richtig.
Einerseits verstehe ich die … “Skepsis” dem “neuen” GL gegenüber. Einen Rant darüber hatte ich schon an anderer Stelle abgelassen. Andererseits wirst du bei allem, was du jetzt mit “glLight”, “glPushMatrix” & Co machst, dieses nagende Gefühl im Hinterkopf haben (müssen), dass das das ziemlich für die Tonne ist, weil kein neu geschriebener Code das mehr verwenden sollte. Und NOCH andererseits ist das vielleicht gar nicht so wichtig: Zu wissen (oder eine grobe Vorstellung zu haben) wie das mit den Matrizen und den Lichtern früher funktioniert hat, kann durchaus helfen, nachzuvollziehen, wie es heute ist (und warum es heute so ist).
Abegsehen vom RedBook ( Chapter 5 - OpenGL Programming Guide ) wüßte ich jetzt keine konkrete Empfehlung. Ein paar mehr Infos wären nicht schlecht. Wie hast du die Normalen berechnet? Wie hast du das Objekt transformiert? Wie äußerte sich das “nicht vom Licht beeinflusst werden”? (Alles Schwarz, alles grau, alles wie ohne Licht?). Keine sarkastisch-rethorische Frage: Hattest du die Lichter eingeschaltet?
Die Lichter sind an und funktionieren, da die von LWJGL vordefinierte Sphere auch vom Licht beinflusst wird. Nun ist es so, dass ich keine Normalen berechne, zum testen hab ich ein Quadrat erstellt und die Normalen händisch hinzugefügt: Punkte{(-1, 1, 0), (-1, -1, 0), (1, 1, 0), (1, -1, 0)} zur Normalen (0, 0, 1). Dass das Licht mit dem Quadrat nicht richtig funktioniert erkennt man daran, dass das Quadrat sich zwar heller, bzw. Dunkler macht, wenn man von verschiedenen Punkten aus draufschaut, nur immer die Ganze Fläche, sodass nicht wie in diesem Tutorial ein Lichtpunkt drauf ist, von dem es immer dunkler wird, was doof aussieht. Auch ist darauf kein “Specular-Punkt” zu erkennen. Wenn man zur Lichtquelle schaut, dann ist alles hell, und wenn man von ihr wegschaut alles dunkel, was ja such doof ist, weil das Licht ja trotzdem dorthin scheinen sollte.
Moin,
die Fixed Function Pipeline kann Licht nur per Vertex berechnen. Die dazwischenliegende Fläche wird dann entweder gleichmäßig eingefärbt (glShadeModel(GL_FLAT)) oder linear zwischen den Vertices interpoliert (glShadeModel(GL_SMOOTH)). Bei der Sphere sieht das okay aus, da diese aus sehr vielen Vertices besteht. Ein einfaches Quadrat hat damit aber nicht die Effekte die Du dir vorstellst.
Du kannst das Quadrat aus sehr vielen Dreiecken aufbauen um das Licht zu verbessern (keine gute Idee) oder die Beleuchtung im Shader per Fragment berechnen (sinnvoller).
Gruß
Fancy
Ich will jetzt versuchen es mit Shadern zu machen und habe mich damit auseinandergesetzt, nur bevor ich das Licht draufmache möchte ich zuerst mal eine Textur anzeigen lassen, und da scheitert es.Genauer gesagt kann ich beim besten Willen nicht herausfinden, wie ich Vertices UND Texture-Koordinaten an den Vertex Shader schicken kann(Nur die Vertices funktioniert gut, ein einfarbiges Dings bekomme ich auch hin). Ich habe im Internet dazu nur C++ Beispiele gefunden, die mir nicht weiterhelfen und irgendwelche Beispiele mit verworrenen vom Tutorial-Verfasser erstellten Klassen, die gar nicht funktionieren. Bitte verlinkt ein gutes Beispiel dazu, oder postet den Code direkt (Wie gesagt es geht hier nur darum Tex-Coords und Vertices zu schicken)
Der Code von Norbert Nopper (ehemals auf nopper.tv, jetzt auf GitHub) ist üblicherweise recht übersichtlich und fokussiert auf den jeweiligen Task (EDIT> Und deswegen leicht nach Java zu portieren <EDIT). Vielleicht hilft also schon https://github.com/McNopper/OpenGL/tree/master/Example06 . Für Java müßte ich spontan auch erst Websuchen.
Ein KSKB mit aktuellem LWJGL 3 und ab OpenGL 3.3:
import static org.lwjgl.glfw.Callbacks.errorCallbackPrint;
import static org.lwjgl.glfw.GLFW.GLFW_CONTEXT_VERSION_MAJOR;
import static org.lwjgl.glfw.GLFW.GLFW_CONTEXT_VERSION_MINOR;
import static org.lwjgl.glfw.GLFW.GLFW_KEY_ESCAPE;
import static org.lwjgl.glfw.GLFW.GLFW_OPENGL_CORE_PROFILE;
import static org.lwjgl.glfw.GLFW.GLFW_OPENGL_PROFILE;
import static org.lwjgl.glfw.GLFW.GLFW_RELEASE;
import static org.lwjgl.glfw.GLFW.GLFW_RESIZABLE;
import static org.lwjgl.glfw.GLFW.GLFW_VISIBLE;
import static org.lwjgl.glfw.GLFW.glfwCreateWindow;
import static org.lwjgl.glfw.GLFW.glfwDefaultWindowHints;
import static org.lwjgl.glfw.GLFW.glfwDestroyWindow;
import static org.lwjgl.glfw.GLFW.glfwGetPrimaryMonitor;
import static org.lwjgl.glfw.GLFW.glfwGetVideoMode;
import static org.lwjgl.glfw.GLFW.glfwInit;
import static org.lwjgl.glfw.GLFW.glfwMakeContextCurrent;
import static org.lwjgl.glfw.GLFW.glfwPollEvents;
import static org.lwjgl.glfw.GLFW.glfwSetErrorCallback;
import static org.lwjgl.glfw.GLFW.glfwSetKeyCallback;
import static org.lwjgl.glfw.GLFW.glfwSetWindowPos;
import static org.lwjgl.glfw.GLFW.glfwSetWindowShouldClose;
import static org.lwjgl.glfw.GLFW.glfwShowWindow;
import static org.lwjgl.glfw.GLFW.glfwSwapBuffers;
import static org.lwjgl.glfw.GLFW.glfwSwapInterval;
import static org.lwjgl.glfw.GLFW.glfwTerminate;
import static org.lwjgl.glfw.GLFW.glfwWindowHint;
import static org.lwjgl.glfw.GLFW.glfwWindowShouldClose;
import static org.lwjgl.opengl.GL11.GL_COLOR_BUFFER_BIT;
import static org.lwjgl.opengl.GL11.GL_CULL_FACE;
import static org.lwjgl.opengl.GL11.GL_DEPTH_BUFFER_BIT;
import static org.lwjgl.opengl.GL11.GL_DEPTH_TEST;
import static org.lwjgl.opengl.GL11.GL_FALSE;
import static org.lwjgl.opengl.GL11.GL_FLOAT;
import static org.lwjgl.opengl.GL11.GL_LINEAR;
import static org.lwjgl.opengl.GL11.GL_REPEAT;
import static org.lwjgl.opengl.GL11.GL_RGBA8;
import static org.lwjgl.opengl.GL11.GL_TEXTURE_2D;
import static org.lwjgl.opengl.GL11.GL_TEXTURE_MAG_FILTER;
import static org.lwjgl.opengl.GL11.GL_TEXTURE_MIN_FILTER;
import static org.lwjgl.opengl.GL11.GL_TEXTURE_WRAP_S;
import static org.lwjgl.opengl.GL11.GL_TEXTURE_WRAP_T;
import static org.lwjgl.opengl.GL11.GL_TRIANGLE_STRIP;
import static org.lwjgl.opengl.GL11.GL_TRUE;
import static org.lwjgl.opengl.GL11.GL_UNSIGNED_BYTE;
import static org.lwjgl.opengl.GL11.GL_UNSIGNED_SHORT;
import static org.lwjgl.opengl.GL11.glBindTexture;
import static org.lwjgl.opengl.GL11.glClear;
import static org.lwjgl.opengl.GL11.glDeleteTextures;
import static org.lwjgl.opengl.GL11.glDrawElements;
import static org.lwjgl.opengl.GL11.glEnable;
import static org.lwjgl.opengl.GL11.glGenTextures;
import static org.lwjgl.opengl.GL11.glTexImage2D;
import static org.lwjgl.opengl.GL12.GL_BGRA;
import static org.lwjgl.opengl.GL13.GL_TEXTURE0;
import static org.lwjgl.opengl.GL13.glActiveTexture;
import static org.lwjgl.opengl.GL15.GL_ARRAY_BUFFER;
import static org.lwjgl.opengl.GL15.GL_ELEMENT_ARRAY_BUFFER;
import static org.lwjgl.opengl.GL15.GL_STATIC_DRAW;
import static org.lwjgl.opengl.GL15.glBindBuffer;
import static org.lwjgl.opengl.GL15.glBufferData;
import static org.lwjgl.opengl.GL15.glDeleteBuffers;
import static org.lwjgl.opengl.GL15.glGenBuffers;
import static org.lwjgl.opengl.GL20.GL_COMPILE_STATUS;
import static org.lwjgl.opengl.GL20.GL_FRAGMENT_SHADER;
import static org.lwjgl.opengl.GL20.GL_INFO_LOG_LENGTH;
import static org.lwjgl.opengl.GL20.GL_LINK_STATUS;
import static org.lwjgl.opengl.GL20.GL_VERTEX_SHADER;
import static org.lwjgl.opengl.GL20.glAttachShader;
import static org.lwjgl.opengl.GL20.glCompileShader;
import static org.lwjgl.opengl.GL20.glCreateProgram;
import static org.lwjgl.opengl.GL20.glCreateShader;
import static org.lwjgl.opengl.GL20.glDeleteProgram;
import static org.lwjgl.opengl.GL20.glDeleteShader;
import static org.lwjgl.opengl.GL20.glEnableVertexAttribArray;
import static org.lwjgl.opengl.GL20.glGetProgramInfoLog;
import static org.lwjgl.opengl.GL20.glGetProgrami;
import static org.lwjgl.opengl.GL20.glGetShaderInfoLog;
import static org.lwjgl.opengl.GL20.glGetShaderi;
import static org.lwjgl.opengl.GL20.glGetUniformLocation;
import static org.lwjgl.opengl.GL20.glLinkProgram;
import static org.lwjgl.opengl.GL20.glShaderSource;
import static org.lwjgl.opengl.GL20.glUniform1i;
import static org.lwjgl.opengl.GL20.glUseProgram;
import static org.lwjgl.opengl.GL20.glVertexAttribPointer;
import static org.lwjgl.opengl.GL30.glBindVertexArray;
import static org.lwjgl.opengl.GL30.glDeleteVertexArrays;
import static org.lwjgl.opengl.GL30.glGenVertexArrays;
import static org.lwjgl.opengl.GL33.glBindSampler;
import static org.lwjgl.opengl.GL33.glDeleteSamplers;
import static org.lwjgl.opengl.GL33.glGenSamplers;
import static org.lwjgl.opengl.GL33.glSamplerParameteri;
import static org.lwjgl.system.MemoryUtil.NULL;
import java.awt.geom.AffineTransform;
import java.awt.image.AffineTransformOp;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteBuffer;
import java.nio.FloatBuffer;
import java.nio.ShortBuffer;
import javax.imageio.ImageIO;
import org.lwjgl.BufferUtils;
import org.lwjgl.glfw.GLFWErrorCallback;
import org.lwjgl.glfw.GLFWKeyCallback;
import org.lwjgl.glfw.GLFWvidmode;
import org.lwjgl.opengl.GLContext;
public final class GL33Texture implements Runnable {
private static final int WIDTH = 1200;
private static final int HEIGHT = 800;
private static final int GL_MAJOR_VERSION = 3;
private static final int GL_MINOR_VERSION = 3;
private static final int VERTEX_COORD_LOCATION = 0;
private static final int TEXTURE_COORD_LOCATION = 1;
private static final int TEXTURE_UNIT = 0;
private static final String VERTEX_SHADER = ""
+ "#version 330
"
+ "
"
+ "layout(location = " + VERTEX_COORD_LOCATION + ") in vec3 v;
"
+ "layout(location = " + TEXTURE_COORD_LOCATION + ") in vec2 vt;
"
+ "
"
+ "out vec2 fvt;
"
+ "
"
+ "void main() {
"
+ "
"
+ " fvt = vt;
"
+ " gl_Position = vec4(v.xyz * 0.5, 1);
"
+ "
"
+ "}
";
private static final String FRAGMENT_SHADER = ""
+ "#version 330
"
+ "
"
+ "uniform sampler2D image;
"
+ "
"
+ "in vec2 fvt;
"
+ "
"
+ "out vec4 color;
"
+ "
"
+ "void main() {
"
+ "
"
+ " color = texture2D(image, fvt);
"
+ "
"
+ "}
";
private static final String IMAGE = "net/mschorn/ssccee/resources/images/london-eye.png";
private static final short[] QUAD_IBO = new short[] { 1, 2, 0, 3 };
// x, y, z, s, t
private static final float[] QUAD_VBO = new float[] {
-1.0f, -1.0f, 0.0f, 0.0f, 0.0f,
+1.0f, -1.0f, 0.0f, 1.0f, 0.0f,
+1.0f, +1.0f, 0.0f, 1.0f, 1.0f,
-1.0f, +1.0f, 0.0f, 0.0f, 1.0f,
};
private GLFWErrorCallback errorCallback;
private GLFWKeyCallback keyCallback;
private long window;
private int handleVAO;
private int handleIBO;
private int handleVBO;
private int handleProgram;
private int handleSampler;
private int handleTexture;
public static void main(final String[] args) {
new GL33Texture().run();
}
@Override
public void run() {
try {
initGLFW();
initGL();
loop();
disposeGL();
releaseGLFW();
} finally {
terminateGLFW();
}
}
private void initGLFW() {
errorCallback = errorCallbackPrint(System.err);
glfwSetErrorCallback(errorCallback);
if (glfwInit() != GL_TRUE)
throw new IllegalStateException("Unable to initialize GLFW");
glfwDefaultWindowHints();
glfwWindowHint(GLFW_VISIBLE, GL_FALSE);
glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, GL_MAJOR_VERSION);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, GL_MINOR_VERSION);
window = glfwCreateWindow(WIDTH, HEIGHT, getClass().getName(), NULL, NULL);
if (window == NULL)
throw new RuntimeException("Failed to create the GLFW window");
keyCallback = new GLFWKeyCallback() {
@Override
public void invoke(final long window, final int key, final int scancode, final int action, final int mods) {
if (key == GLFW_KEY_ESCAPE && action == GLFW_RELEASE)
glfwSetWindowShouldClose(window, GL_TRUE);
}
};
glfwSetKeyCallback(window, keyCallback);
final ByteBuffer vidmode = glfwGetVideoMode(glfwGetPrimaryMonitor());
glfwSetWindowPos(window, (GLFWvidmode.width(vidmode) - WIDTH) / 2, (GLFWvidmode.height(vidmode) - HEIGHT) / 2);
glfwMakeContextCurrent(window);
glfwSwapInterval(1);
glfwShowWindow(window);
}
private void initGL() {
GLContext.createFromCurrent();
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
initVAO();
initIBO();
initVBO();
initShader();
initSampler();
initTexture();
}
private void initVAO() {
handleVAO = glGenVertexArrays();
glBindVertexArray(handleVAO);
}
private void initIBO() {
final ShortBuffer buffer = BufferUtils.createShortBuffer(QUAD_IBO.length);
buffer.put(QUAD_IBO);
buffer.flip();
handleIBO = glGenBuffers();
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, handleIBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, buffer, GL_STATIC_DRAW);
}
private void initVBO() {
final FloatBuffer buffer = BufferUtils.createFloatBuffer(QUAD_VBO.length);
buffer.put(QUAD_VBO);
buffer.flip();
handleVBO = glGenBuffers();
glBindBuffer(GL_ARRAY_BUFFER, handleVBO);
glBufferData(GL_ARRAY_BUFFER, buffer, GL_STATIC_DRAW);
glEnableVertexAttribArray(VERTEX_COORD_LOCATION);
glVertexAttribPointer(VERTEX_COORD_LOCATION, 3, GL_FLOAT, false, Float.BYTES * 5, 0);
glEnableVertexAttribArray(TEXTURE_COORD_LOCATION);
glVertexAttribPointer(TEXTURE_COORD_LOCATION, 2, GL_FLOAT, false, Float.BYTES * 5, Float.BYTES * 3);
}
private void initShader() {
final int vs = buildShader(GL_VERTEX_SHADER, VERTEX_SHADER);
final int fs = buildShader(GL_FRAGMENT_SHADER, FRAGMENT_SHADER);
handleProgram = buildProgram(vs, fs);
glDeleteShader(vs);
glDeleteShader(fs);
glUseProgram(handleProgram);
final int uniformImage = glGetUniformLocation(handleProgram, "image");
glUniform1i(uniformImage, TEXTURE_UNIT);
}
private int buildShader(final int type, final String source) {
final int handle = glCreateShader(type);
glShaderSource(handle, source);
glCompileShader(handle);
if (GL_FALSE == glGetShaderi(handle, GL_COMPILE_STATUS)) {
final int length = glGetShaderi(handle, GL_INFO_LOG_LENGTH);
final String log = glGetShaderInfoLog(handle, length);
throw new RuntimeException(log);
}
return handle;
}
private int buildProgram(final int... shaders) {
final int handle = glCreateProgram();
for (final int shader : shaders)
glAttachShader(handle, shader);
glLinkProgram(handle);
if (GL_FALSE == glGetProgrami(handle, GL_LINK_STATUS)) {
final int length = glGetProgrami(handle, GL_INFO_LOG_LENGTH);
final String log = glGetProgramInfoLog(handle, length);
throw new RuntimeException(log);
}
return handle;
}
private void initSampler() {
handleSampler = glGenSamplers();
glSamplerParameteri(handleSampler, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glSamplerParameteri(handleSampler, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glSamplerParameteri(handleSampler, GL_TEXTURE_WRAP_S, GL_REPEAT);
glSamplerParameteri(handleSampler, GL_TEXTURE_WRAP_T, GL_REPEAT);
glBindSampler(TEXTURE_UNIT, handleSampler);
}
private void initTexture() {
BufferedImage image = loadImage();
final int width = image.getWidth();
final int height = image.getHeight();
final int type = GL_RGBA8;
image = flipImage(image);
final int[] pixels = image.getRGB(0, 0, width, height, null, 0, width);
final ByteBuffer buffer = BufferUtils.createByteBuffer(pixels.length * Integer.SIZE / Byte.SIZE);
buffer.asIntBuffer().put(pixels);
buffer.rewind();
handleTexture = glGenTextures();
glActiveTexture(GL_TEXTURE0 + TEXTURE_UNIT);
glBindTexture(GL_TEXTURE_2D, handleTexture);
glTexImage2D(GL_TEXTURE_2D, 0, type, width, height, 0, GL_BGRA, GL_UNSIGNED_BYTE, buffer);
}
private BufferedImage loadImage() {
BufferedImage image;
try (InputStream is = getClass().getClassLoader().getResourceAsStream(IMAGE)) {
if (is == null)
throw new RuntimeException("Image not found!");
image = ImageIO.read(is);
is.close();
} catch (final IOException e) {
throw new RuntimeException(e);
}
return image;
}
private BufferedImage flipImage(final BufferedImage image) {
final AffineTransform tx = AffineTransform.getScaleInstance(1, -1);
tx.translate(0, -image.getHeight());
final AffineTransformOp op = new AffineTransformOp(tx, AffineTransformOp.TYPE_NEAREST_NEIGHBOR);
final BufferedImage result = op.filter(image, null);
return result;
}
private void loop() {
while (glfwWindowShouldClose(window) == GL_FALSE) {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glDrawElements(GL_TRIANGLE_STRIP, QUAD_IBO.length, GL_UNSIGNED_SHORT, 0);
glfwSwapBuffers(window);
glfwPollEvents();
}
}
private void disposeGL() {
glDeleteTextures(handleTexture);
glDeleteSamplers(handleSampler);
glDeleteProgram(handleProgram);
glDeleteBuffers(handleVBO);
glDeleteBuffers(handleIBO);
glDeleteVertexArrays(handleVAO);
}
private void releaseGLFW() {
glfwDestroyWindow(window);
keyCallback.release();
}
private void terminateGLFW() {
glfwTerminate();
errorCallback.release();
}
}
Gruß
Fancy
(ich wollte beim vorigen Post noch den Nachsatz anhängen: “… oder darauf vertrauen, dass Fancy ein KSBK postet”, aber wollte keinen Druck aufbauen :D)
ja das mit fancys kskb’s ist so ne sache… 
einerseits total übersichtlich und gut strukturiert, und 110% fehlerfrei… aber
als anfänger trotzdem nicht unbedingt „greifbar“… oder so…
@Zombiepriester Hast du dir diese tutorials denn mal angeschaut?
nochmal der link: Category: Modern OpenGL Series
Ich habe selber als totaler opengl noob unter anderem damit gelernt, der typ erklärt
ziemlich super und der code ist sowas von einfach nach java zu portieren…
**EDIT (Marco13) : Habe versucht, den Vulkan/Off-Topic-Teil mal hier rauszuschälen. Der Vollständigkeit halber sind die Beiträge hier unverändert, aber die Vulkan-Relevanten Teile nach http://forum.byte-welt.net/java-forum-erste-hilfe-vom-java-welt-kompetenz-zentrum/allgemeine-themen/16437-vulkan-nachfolger-von-opengl.html kopiert
**
Naja OpenGL ist mittlerweile begraben worden und Vulkan steigt auf (was für ein passender Name wenn ich darüber nachdenke) bin gespannt was Fancy über das neue Projekt denkt. Mensch mensch mensch, wieviele alte User ich in diesem Forum wiedertreffe von damals. Da war Fancy immer nur Guest2 oder so ^^
Zur Frage: Fancy’s KSKB ist wie der Name sagt ein schönes “kleines” kompilierbares Beispiel. Kleiner gehts nicht und enthält entsprechend alle essentiellen Dinge die ein OGL Kontext benötigt.
Man sollte sich aber gleichzeitig dazu ein Tutorial durchlesen um genau zu verstehen wieso weshalb warum.
OpenGL und Shader funktionier halt so, dass man in der Shader-Textdatei eine Variable anlegt mit einem bestimmten Namen. Danach muss man nurnoch OGL fragen welchen Namen die Variable intern besitzt, OGL gibt daraufhin eine Nummer zurück, diese speichern und mithilfe dieser Nummer kann man die Variable dann ansprechen und an sie Daten senden… Gott ist OGL kompliziert.
Aber so funktioniert praktisch der Datenaustausch in OGL
- “Gib Name der Variable XY”
- “Aktiviere Variable”
- “Sende Daten”
Ein KSKB ist nun mal kein Tutorial und als Anfänger muss man sich dann halt in das Thema rein-fräsen. Wäre das nicht so, wäre im KSKB auch nichts Neues und damit der Erkenntnisgewinn minimal. 
Vulkan beobachte ich natürlich auch. Und auch wenn es ursprünglich als „Next Generation OpenGL“ entwickelt wurde, scheint es inzwischen mehr eine Low Level Alternative zu OpenGL zu werden. Aber abwarten was passiert, im Moment ist das was bekannt ist alles noch zu sehr vom Marketing geprägt. Hier hat jemand eine schöne Zusammenfassung geschrieben.
Aber einfach wird Vulkan wohl nicht werden. ~600 Zeilen für ein nacktes Dreieck.
@Marco13 : lol
Gruß
Fancy
Dank euch habe ich es jetzt mit der Textur hinbekommenn, nur hab ich gemerkt, dass das noch relativ doof aussieht, da ich die Matrizen noch nicht eingebunden habe, also guck ich das nach und mach das, nur wird das Viereck nicht angezeigt
Der Vertex-Shader:
layout (location = 0) in vec3 in_Position;
layout (location = 1) in vec2 in_TextureCoord;
uniform mat4 projectionMatrix;
uniform mat4 modelViewMatrix;
out vec2 TexCoord;
void main(void) {
gl_Position = modelViewMatrix*projectionMatrix*vec4(in_Position, 1);
TexCoord = in_TextureCoord;
}
und so setzte ich die Matrizen:
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
GLU.gluPerspective(45, (float) Display.getWidth() / (float) Display.getHeight(), 0.1f, 100);
glGetFloat(GL_PROJECTION_MATRIX, projMat );
int locmat1 = GL20.glGetUniformLocation(s.program, "projectionMatrix");
GL20.glUniformMatrix4(locmat1, false, projMat);
int locmat2 = GL20.glGetUniformLocation(s.program, "modelViewMatrix");
GL20.glUniformMatrix4(locmat2, false, viewMatrix);
[ot] @Fancy : Auch ich habe ein Auge auf Vulkan ( jvulkan.org ) aber bisher gibt es (auch in dieser „schönen“ Zusammenfassung) ja praktisch keine Informationen, die über die (schon seeeeh high-leveligen) Slides von https://www.khronos.org/vulkan hinausgehen. Das „interessanteste“ war da noch der Screenshot von dem Debugger, in dem Zumindest ein paar Codezeilen zu sehen waren. Deswegen frage ich mich, wo du die Information mit den 600 Zeilen her hast. (Das klingt schon viel. Das sind ja mindestsens 50 mehr als bei (non-deprecated, core) OpenGL :eek: :o) )
[/ot]
@Zombiepriester : Versuch mal:
gl_Position = projectionMatrix*modelViewMatrix*vec4(in_Position, 1);
Außerdem gibt es glMatrixMode, glLoadIdentity, gluPerspective usw. im aktuellem OpenGL Core nicht mehr. Auch solltest Du im Shader immer die Version angeben (z.B. „#version 330“), der Treiber macht sonnst was er will.
[ot]@Marco13: Interessant Angedacht hab ich so was auch schon (net.nanojl:vk) bin mir aber noch nicht sicher inwieweit ich da wirklich Zeit rein stecke, da meine Wrapper Technik nicht auf Structs optimiert ist und Vulkan sehr struct lastig zu sein scheint.
Die 600 Zeilen hab ich aus diesem Video. Am Anfang stellt jemand von AMD den Aufbau eines Vulkan Programms dar, da sieht man schon ein wenig wie das später funktionieren soll. Am Ende in der Q&A fragt ein Zuschauer nach einem Hallo World und einer der Moderatoren vergleicht dann die 5 Zeilen von früher (glBegin, glVertex, glEnd) mit 600 Zeilen Vulkan. :)[/ot]
Gruß
Fancy
Wenn ich das schreibe ist kein Unterschied und mit dem #version kommt immer ein Syntaxfehler. Das mit dem glMatrixMode mach ich ja nur, damit ich die Matrix mit GLU einstellen und dann mit glGetFloat als Buffer bekommen kann.
#version 330 funktioniert jetzt, ich hatte im Filereader vergessen, Zeilenumbrüche zu setzen, aber die Transformation funktioniert immer noch nicht
Nuja, so im luftleeren Raum, wird wahrscheinlich keiner erahnen warum das bei Dir nicht funktioniert. Bei mir sähe das so aus:
import static org.lwjgl.glfw.Callbacks.errorCallbackPrint;
import static org.lwjgl.glfw.GLFW.GLFW_CONTEXT_VERSION_MAJOR;
import static org.lwjgl.glfw.GLFW.GLFW_CONTEXT_VERSION_MINOR;
import static org.lwjgl.glfw.GLFW.GLFW_KEY_ESCAPE;
import static org.lwjgl.glfw.GLFW.GLFW_OPENGL_CORE_PROFILE;
import static org.lwjgl.glfw.GLFW.GLFW_OPENGL_PROFILE;
import static org.lwjgl.glfw.GLFW.GLFW_RELEASE;
import static org.lwjgl.glfw.GLFW.GLFW_RESIZABLE;
import static org.lwjgl.glfw.GLFW.GLFW_VISIBLE;
import static org.lwjgl.glfw.GLFW.glfwCreateWindow;
import static org.lwjgl.glfw.GLFW.glfwDefaultWindowHints;
import static org.lwjgl.glfw.GLFW.glfwDestroyWindow;
import static org.lwjgl.glfw.GLFW.glfwGetPrimaryMonitor;
import static org.lwjgl.glfw.GLFW.glfwGetVideoMode;
import static org.lwjgl.glfw.GLFW.glfwInit;
import static org.lwjgl.glfw.GLFW.glfwMakeContextCurrent;
import static org.lwjgl.glfw.GLFW.glfwPollEvents;
import static org.lwjgl.glfw.GLFW.glfwSetErrorCallback;
import static org.lwjgl.glfw.GLFW.glfwSetKeyCallback;
import static org.lwjgl.glfw.GLFW.glfwSetWindowPos;
import static org.lwjgl.glfw.GLFW.glfwSetWindowShouldClose;
import static org.lwjgl.glfw.GLFW.glfwShowWindow;
import static org.lwjgl.glfw.GLFW.glfwSwapBuffers;
import static org.lwjgl.glfw.GLFW.glfwSwapInterval;
import static org.lwjgl.glfw.GLFW.glfwTerminate;
import static org.lwjgl.glfw.GLFW.glfwWindowHint;
import static org.lwjgl.glfw.GLFW.glfwWindowShouldClose;
import static org.lwjgl.opengl.GL11.GL_COLOR_BUFFER_BIT;
import static org.lwjgl.opengl.GL11.GL_CULL_FACE;
import static org.lwjgl.opengl.GL11.GL_DEPTH_BUFFER_BIT;
import static org.lwjgl.opengl.GL11.GL_DEPTH_TEST;
import static org.lwjgl.opengl.GL11.GL_FALSE;
import static org.lwjgl.opengl.GL11.GL_FLOAT;
import static org.lwjgl.opengl.GL11.GL_TRIANGLE_STRIP;
import static org.lwjgl.opengl.GL11.GL_TRUE;
import static org.lwjgl.opengl.GL11.GL_UNSIGNED_SHORT;
import static org.lwjgl.opengl.GL11.glClear;
import static org.lwjgl.opengl.GL11.glDrawElements;
import static org.lwjgl.opengl.GL11.glEnable;
import static org.lwjgl.opengl.GL15.GL_ARRAY_BUFFER;
import static org.lwjgl.opengl.GL15.GL_ELEMENT_ARRAY_BUFFER;
import static org.lwjgl.opengl.GL15.GL_STATIC_DRAW;
import static org.lwjgl.opengl.GL15.GL_STREAM_DRAW;
import static org.lwjgl.opengl.GL15.glBindBuffer;
import static org.lwjgl.opengl.GL15.glBufferData;
import static org.lwjgl.opengl.GL15.glBufferSubData;
import static org.lwjgl.opengl.GL15.glDeleteBuffers;
import static org.lwjgl.opengl.GL15.glGenBuffers;
import static org.lwjgl.opengl.GL20.GL_COMPILE_STATUS;
import static org.lwjgl.opengl.GL20.GL_FRAGMENT_SHADER;
import static org.lwjgl.opengl.GL20.GL_INFO_LOG_LENGTH;
import static org.lwjgl.opengl.GL20.GL_LINK_STATUS;
import static org.lwjgl.opengl.GL20.GL_VERTEX_SHADER;
import static org.lwjgl.opengl.GL20.glAttachShader;
import static org.lwjgl.opengl.GL20.glCompileShader;
import static org.lwjgl.opengl.GL20.glCreateProgram;
import static org.lwjgl.opengl.GL20.glCreateShader;
import static org.lwjgl.opengl.GL20.glDeleteProgram;
import static org.lwjgl.opengl.GL20.glDeleteShader;
import static org.lwjgl.opengl.GL20.glEnableVertexAttribArray;
import static org.lwjgl.opengl.GL20.glGetProgramInfoLog;
import static org.lwjgl.opengl.GL20.glGetProgrami;
import static org.lwjgl.opengl.GL20.glGetShaderInfoLog;
import static org.lwjgl.opengl.GL20.glGetShaderi;
import static org.lwjgl.opengl.GL20.glLinkProgram;
import static org.lwjgl.opengl.GL20.glShaderSource;
import static org.lwjgl.opengl.GL20.glUseProgram;
import static org.lwjgl.opengl.GL20.glVertexAttribPointer;
import static org.lwjgl.opengl.GL30.glBindBufferRange;
import static org.lwjgl.opengl.GL30.glBindVertexArray;
import static org.lwjgl.opengl.GL30.glDeleteVertexArrays;
import static org.lwjgl.opengl.GL30.glGenVertexArrays;
import static org.lwjgl.opengl.GL31.GL_UNIFORM_BUFFER;
import static org.lwjgl.opengl.GL31.glGetUniformBlockIndex;
import static org.lwjgl.opengl.GL31.glUniformBlockBinding;
import static org.lwjgl.system.MemoryUtil.NULL;
import java.nio.ByteBuffer;
import java.nio.FloatBuffer;
import java.nio.ShortBuffer;
import org.lwjgl.BufferUtils;
import org.lwjgl.glfw.GLFWErrorCallback;
import org.lwjgl.glfw.GLFWKeyCallback;
import org.lwjgl.glfw.GLFWvidmode;
import org.lwjgl.opengl.GLContext;
public final class GL33Matrices implements Runnable {
private static final int WIDTH = 1200;
private static final int HEIGHT = 800;
private static final int GL_MAJOR_VERSION = 3;
private static final int GL_MINOR_VERSION = 3;
private static final int VERTEX_COORD_LOCATION = 0;
private static final int MVP_UNIFORM_BLOCK_LOCATION = 0;
private static final String VERTEX_SHADER = ""
+ "#version 330
"
+ "
"
+ "layout(std140) uniform MVP {
"
+ " mat4 projection;
"
+ " mat4 modelview;
"
+ "};
"
+ "
"
+ "layout(location = " + VERTEX_COORD_LOCATION + ") in vec4 v;
"
+ "
"
+ "void main() {
"
+ "
"
+ " gl_Position = projection * modelview * v;
"
+ "
"
+ "}
";
private static final String FRAGMENT_SHADER = ""
+ "#version 330
"
+ "
"
+ "out vec4 color;
"
+ "
"
+ "void main() {
"
+ "
"
+ " color = vec4(1, 1, 1, 1);
"
+ "
"
+ "}
";
private static final short[] QUAD_IBO = new short[] { 1, 2, 0, 3 };
// x, y, z
private static final float[] QUAD_VBO = new float[] {
-1.0f, -1.0f, 0.0f,
+1.0f, -1.0f, 0.0f,
+1.0f, +1.0f, 0.0f,
-1.0f, +1.0f, 0.0f,
};
private final FloatBuffer mvpBuffer = BufferUtils.createFloatBuffer(16 + 16);
private GLFWErrorCallback errorCallback;
private GLFWKeyCallback keyCallback;
private long windowHandle;
private int vaoHandle;
private int iboHandle;
private int vboHandle;
private int uboHandle;
private int programHandle;
private float angle;
public static void main(final String[] args) {
new GL33Matrices().run();
}
@Override
public void run() {
try {
initGLFW();
initGL();
loop();
disposeGL();
releaseGLFW();
} finally {
terminateGLFW();
}
}
private void initGLFW() {
errorCallback = errorCallbackPrint(System.err);
glfwSetErrorCallback(errorCallback);
if (glfwInit() != GL_TRUE)
throw new IllegalStateException("Unable to initialize GLFW");
glfwDefaultWindowHints();
glfwWindowHint(GLFW_VISIBLE, GL_FALSE);
glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, GL_MAJOR_VERSION);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, GL_MINOR_VERSION);
windowHandle = glfwCreateWindow(WIDTH, HEIGHT, getClass().getName(), NULL, NULL);
if (windowHandle == NULL)
throw new RuntimeException("Failed to create the GLFW window");
keyCallback = new GLFWKeyCallback() {
@Override
public void invoke(final long window, final int key, final int scancode, final int action, final int mods) {
if (key == GLFW_KEY_ESCAPE && action == GLFW_RELEASE)
glfwSetWindowShouldClose(window, GL_TRUE);
}
};
glfwSetKeyCallback(windowHandle, keyCallback);
final ByteBuffer videoMode = glfwGetVideoMode(glfwGetPrimaryMonitor());
glfwSetWindowPos(windowHandle, (GLFWvidmode.width(videoMode) - WIDTH) / 2, (GLFWvidmode.height(videoMode) - HEIGHT) / 2);
glfwMakeContextCurrent(windowHandle);
glfwSwapInterval(1);
glfwShowWindow(windowHandle);
}
private void initGL() {
GLContext.createFromCurrent();
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
initVAO();
initIBO();
initVBO();
initUBO();
initShader();
}
private void initVAO() {
vaoHandle = glGenVertexArrays();
glBindVertexArray(vaoHandle);
}
private void initIBO() {
final ShortBuffer buffer = BufferUtils.createShortBuffer(QUAD_IBO.length);
buffer.put(QUAD_IBO);
buffer.flip();
iboHandle = glGenBuffers();
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, iboHandle);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, buffer, GL_STATIC_DRAW);
}
private void initVBO() {
final FloatBuffer buffer = BufferUtils.createFloatBuffer(QUAD_VBO.length);
buffer.put(QUAD_VBO);
buffer.flip();
vboHandle = glGenBuffers();
glBindBuffer(GL_ARRAY_BUFFER, vboHandle);
glBufferData(GL_ARRAY_BUFFER, buffer, GL_STATIC_DRAW);
glEnableVertexAttribArray(VERTEX_COORD_LOCATION);
glVertexAttribPointer(VERTEX_COORD_LOCATION, 3, GL_FLOAT, false, Float.BYTES * 3, 0);
}
private void initUBO() {
uboHandle = glGenBuffers();
glBindBuffer(GL_UNIFORM_BUFFER, uboHandle);
glBufferData(GL_UNIFORM_BUFFER, mvpBuffer.capacity() * 4, GL_STREAM_DRAW);
glBindBufferRange(GL_UNIFORM_BUFFER, MVP_UNIFORM_BLOCK_LOCATION, uboHandle, 0, mvpBuffer.capacity() * 4);
}
private void initShader() {
final int vs = buildShader(GL_VERTEX_SHADER, VERTEX_SHADER);
final int fs = buildShader(GL_FRAGMENT_SHADER, FRAGMENT_SHADER);
programHandle = buildProgram(vs, fs);
glDeleteShader(vs);
glDeleteShader(fs);
glUseProgram(programHandle);
final int mvpUniformBlockIndex = glGetUniformBlockIndex(programHandle, "MVP");
glUniformBlockBinding(programHandle, mvpUniformBlockIndex, MVP_UNIFORM_BLOCK_LOCATION);
}
private int buildShader(final int type, final String source) {
final int handle = glCreateShader(type);
glShaderSource(handle, source);
glCompileShader(handle);
if (GL_FALSE == glGetShaderi(handle, GL_COMPILE_STATUS)) {
final int length = glGetShaderi(handle, GL_INFO_LOG_LENGTH);
final String log = glGetShaderInfoLog(handle, length);
throw new RuntimeException(log);
}
return handle;
}
private int buildProgram(final int... shaders) {
final int handle = glCreateProgram();
for (final int shader : shaders)
glAttachShader(handle, shader);
glLinkProgram(handle);
if (GL_FALSE == glGetProgrami(handle, GL_LINK_STATUS)) {
final int length = glGetProgrami(handle, GL_INFO_LOG_LENGTH);
final String log = glGetProgramInfoLog(handle, length);
throw new RuntimeException(log);
}
return handle;
}
private float[] projection(final float fovy, final float aspect, final float zNear, final float zFar) {
final double f = (1.0 / Math.tan(Math.toRadians(fovy / 2.0)));
final float[] m = new float[16];
m[0] = (float) (f / aspect);
m[5] = (float) (f);
m[10] = (zFar + zNear) / (zNear - zFar);
m[11] = (-1);
m[14] = (2 * zFar * zNear) / (zNear - zFar);
m[15] = 0;
return m;
}
private float[] translate(final float x, final float y, final float z) {
final float[] m = new float[16];
for (int i = 0; i < 4; i++)
m[i * 5] = 1.0f;
m[12] = x;
m[13] = y;
m[14] = z;
return m;
}
private float[] rotate(float x, float y, float z, final double angle) {
final float len = (float) Math.sqrt(x * x + y * y + z * z);
final float c = (float) Math.cos(Math.toDegrees(angle));
final float s = (float) Math.sin(Math.toDegrees(angle));
x = x / len;
y = y / len;
z = z / len;
final float[] m = new float[16];
m[0] = x * x * (1 - c) + c;
m[1] = y * x * (1 - c) + z * s;
m[2] = x * z * (1 - c) - y * s;
m[4] = x * y * (1 - c) - z * s;
m[5] = y * y * (1 - c) + c;
m[6] = y * z * (1 - c) + x * s;
m[8] = x * z * (1 - c) + y * s;
m[9] = y * z * (1 - c) - x * s;
m[10] = z * z * (1 - c) + c;
m[15] = 1;
return m;
}
private float[] multiplication(final float[] m, final float[] o) {
final float[] result = new float[16];
result[0] = m[0] * o[0] + m[4] * o[1] + m[8] * o[2] + m[12] * o[3];
result[1] = m[1] * o[0] + m[5] * o[1] + m[9] * o[2] + m[13] * o[3];
result[2] = m[2] * o[0] + m[6] * o[1] + m[10] * o[2] + m[14] * o[3];
result[3] = m[3] * o[0] + m[7] * o[1] + m[11] * o[2] + m[15] * o[3];
result[4] = m[0] * o[4] + m[4] * o[5] + m[8] * o[6] + m[12] * o[7];
result[5] = m[1] * o[4] + m[5] * o[5] + m[9] * o[6] + m[13] * o[7];
result[6] = m[2] * o[4] + m[6] * o[5] + m[10] * o[6] + m[14] * o[7];
result[7] = m[3] * o[4] + m[7] * o[5] + m[11] * o[6] + m[15] * o[7];
result[8] = m[0] * o[8] + m[4] * o[9] + m[8] * o[10] + m[12] * o[11];
result[9] = m[1] * o[8] + m[5] * o[9] + m[9] * o[10] + m[13] * o[11];
result[10] = m[2] * o[8] + m[6] * o[9] + m[10] * o[10] + m[14] * o[11];
result[11] = m[3] * o[8] + m[7] * o[9] + m[11] * o[10] + m[15] * o[11];
result[12] = m[0] * o[12] + m[4] * o[13] + m[8] * o[14] + m[12] * o[15];
result[13] = m[1] * o[12] + m[5] * o[13] + m[9] * o[14] + m[13] * o[15];
result[14] = m[2] * o[12] + m[6] * o[13] + m[10] * o[14] + m[14] * o[15];
result[15] = m[3] * o[12] + m[7] * o[13] + m[11] * o[14] + m[15] * o[15];
return result;
}
private void loop() {
while (glfwWindowShouldClose(windowHandle) == GL_FALSE) {
angle += 0.001f;
final float[] projection = projection(45, (float) WIDTH / (float) HEIGHT, 0.1f, 1000f);
final float[] translate = translate(0, 0, -10);
final float[] rotate = rotate(0, 0, -1, angle);
final float[] modelview = multiplication(translate, rotate);
mvpBuffer.put(projection);
mvpBuffer.put(modelview);
mvpBuffer.rewind();
glBufferSubData(GL_UNIFORM_BUFFER, 0, mvpBuffer);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glDrawElements(GL_TRIANGLE_STRIP, QUAD_IBO.length, GL_UNSIGNED_SHORT, 0);
glfwSwapBuffers(windowHandle);
glfwPollEvents();
}
}
private void disposeGL() {
glDeleteProgram(programHandle);
glDeleteBuffers(uboHandle);
glDeleteBuffers(vboHandle);
glDeleteBuffers(iboHandle);
glDeleteVertexArrays(vaoHandle);
}
private void releaseGLFW() {
glfwDestroyWindow(windowHandle);
keyCallback.release();
}
private void terminateGLFW() {
glfwTerminate();
errorCallback.release();
}
}
Gruß
Fancy
Irgendwie hat das mit dem Matrizen-erzeugen oder übergeben nicht geklappt, denn wenn ich einfach schreibe:
gl_Position = gl_ModelViewProjectionMatrix * vec4(in_Position, 1);
geht es.
gl_ModelViewProjectionMatrix ist wohl von OpenGL was Vordefiniertes, das sich nach den mit MatrixMode und dergleichen eingestellten Matrizen richtet.
*** Edit ***
Ich hab jetzt einen Fragmentshader fürs Licht nach dem Vorbild diese Modern OpenGL Tutorialsgeschrieben, nur braucht man dafür die Modelmatrix, aber das Übergeben eben dieser funktioniert nicht und ich weiß nicht warum.
FragmentShader:
#version 330
uniform sampler2D texture;
uniform mat4 model;
in vec2 TexCoord;
in vec3 out_lightPos;
in vec3 out_lightColor;
in vec3 fragNormal;
in vec3 fragVert;
void main() {
mat3 normalMatrix = transpose(inverse(mat3(model)));
vec3 normal = normalize(normalMatrix * fragNormal);
vec3 fragPosition = vec3(model * vec4(fragVert, 1));
vec3 surfaceToLight = out_lightPos - fragPosition;
float brightness = dot(normal, surfaceToLight) / (length(surfaceToLight) * length(normal));
brightness = clamp(brightness, 0, 1);
vec4 surfaceColor = texture(texture, TexCoord);
vec3 lightSurfaceColor = brightness * out_lightColor * surfaceColor.rgb;
gl_FragColor = vec4(lightSurfaceColor, surfaceColor.a);
}
So erstelle und übergebe ich die Matrix und das Licht Zeug:
s.use();
float[] lichtPos = {0, 0, 1};
float[] lichtFarbe = {1, 1, 1};
int loc1 = GL20.glGetUniformLocation(s.program, "lightPos");
GL20.glUniform3(loc1, Main.putFloatCoords(lichtPos));
int loc2 = GL20.glGetUniformLocation(s.program, "lightColor");
GL20.glUniform3(loc2, Main.putFloatCoords(lichtFarbe));
int loc3 = GL20.glGetUniformLocation(s.program, "model");
FloatBuffer modelView = BufferUtils.createFloatBuffer(16);
glGetFloat(GL_MODELVIEW_MATRIX, modelView);
GL20.glUniformMatrix4(loc3, false, modelView);
Es wird garnichts angezeigt.