why the second method call crashes java?

Question

I'm making a java 3d project with lwjgl.

Java crashes when calling Sphere.getVertices() method. But when I try to detect a collision between two cubes, I see a black screen with no components, but java doesn't crash.

log

#
# A fatal error has been detected by the Java Runtime Environment:
#
#  EXCEPTION_ACCESS_VIOLATION (0xc0000005) at pc=0x00007ffbbedaa293, pid=2500, tid=1752
#
# JRE version: OpenJDK Runtime Environment Temurin-17.0.7+7 (17.0.7+7) (build 17.0.7+7)
# Java VM: OpenJDK 64-Bit Server VM Temurin-17.0.7+7 (17.0.7+7, mixed mode, sharing, tiered, compressed oops, compressed class ptrs, g1 gc, windows-amd64)
# Problematic frame:
# C  [lwjgl_opengl.dll+0xa293]
#
# No core dump will be written. Minidumps are not enabled by default on client versions of Windows
#
# If you would like to submit a bug report, please visit:
#   https://github.com/adoptium/adoptium-support/issues
# The crash happened outside the Java Virtual Machine in native code.
# See problematic frame for where to report the bug.
#

---------------  S U M M A R Y ------------

Command Line: -XX:+ShowCodeDetailsInExceptionMessages Main

Host: Intel(R) Core(TM) i5-8265U CPU @ 1.60GHz, 8 cores, 7G,  Windows 10 , 64 bit Build 19041 (10.0.19041.3155)
Time: Tue Aug 22 12:57:53 2023 RTZ 2 (s 10 , 64 bit Build 19041 (10.0.19041.3155) elapsed time: 0.495254 seconds (0d 0h 0m 0s)

---------------  T H R E A D  ---------------

Current thread (0x000001bc95c0e1a0):  JavaThread "main" [_thread_in_native, id=1752, stack(0x000000481f200000,0x000000481f300000)]

Stack: [0x000000481f200000,0x000000481f300000],  sp=0x000000481f2ff4c8,  free space=1021k
Native frames: (J=compiled Java code, j=interpreted, Vv=VM code, C=native code)
C  [lwjgl_opengl.dll+0xa293]

Java frames: (J=compiled Java code, j=interpreted, Vv=VM code)
j  org.lwjgl.opengl.GL11.glColor3f(FFF)V+0
j  Models.Sphere$1.<init>(LModels/Sphere;)V+21
j  Models.Sphere.getVertices()Ljava/util/ArrayList;+5
j  Engine.Component.checkColision(LEngine/Component;)Z+21
j  Main.main([Ljava/lang/String;)V+86
v  ~StubRoutines::call_stub

siginfo: EXCEPTION_ACCESS_VIOLATION (0xc0000005), reading address 0x00000000000000b0


Register to memory mapping:

RIP=0x00007ffbbedaa293 lwjgl_opengl.dll
RAX=0x000001bcb84a83e0 points into unknown readable memory: 0x0000000000000000 | 00 00 00 00 00 00 00 00
RBX={method} {0x000001bcb4704b78} 'glColor3f' '(FFF)V' in 'org/lwjgl/opengl/GL11'
RCX=0x0 is NULL
RDX=0x000000481f2ff560 is pointing into the stack for thread: 0x000001bc95c0e1a0
RSP=0x000000481f2ff4c8 is pointing into the stack for thread: 0x000001bc95c0e1a0
RBP=0x000000481f2ff550 is pointing into the stack for thread: 0x000001bc95c0e1a0
RSI=0x000001bcb4007c98 is pointing into metadata
RDI=0x0000000000009c1a is an unknown value
R8 =0x0000000000000002 is an unknown value
R9 =0x0000000000000002 is an unknown value
R10=0x000001bca4c3d5f2 is at code_begin+946 in an Interpreter codelet
method entry point (kind = native)  [0x000001bca4c3d240, 0x000001bca4c3dbc0]  2432 bytes
R11=0x00000000894524c0 is an oop: java.lang.Class 
{0x00000000894524c0} - klass: 'java/lang/Class']

Component.java code:

import java.util.ArrayList;
import java.util.List;

import org.joml.Matrix4f;
import org.joml.Vector3f;


public abstract class Component {
    private Vector3f pos = new Vector3f(0, 0, 0);
    private Vector3f rotate = new Vector3f(0, 0, 0);
    private Vector3f scale = new Vector3f(1, 1, 1);

    public boolean checkColision(Component component) {
        ArrayList<Vector3f> transformedVertices = transformVertices(getVertices(), pos, rotate, scale);
        ArrayList<Vector3f> componentTransformedVertices = transformVertices(component.getVertices(), component.getPos(), component.getRotate(), component.getScale()); //The problem is probably here.


        Vector3f max = new Vector3f(Float.MIN_VALUE, Float.MIN_VALUE, Float.MIN_VALUE);
        Vector3f min = new Vector3f(Float.MAX_VALUE, Float.MAX_VALUE, Float.MAX_VALUE);

        for(Vector3f vertex : transformedVertices) {
            if(vertex.x > max.x) max.x = vertex.x;
            if(vertex.y > max.y) max.y = vertex.y;
            if(vertex.z > max.z) max.z = vertex.z;

            if(vertex.x < min.x) min.x = vertex.x;
            if(vertex.y < min.y) min.y = vertex.y;
            if(vertex.z < min.z) min.z = vertex.z;
        }

        Vector3f componentMax = new Vector3f(Float.MIN_VALUE, Float.MIN_VALUE, Float.MIN_VALUE);
        Vector3f componentMin = new Vector3f(Float.MAX_VALUE, Float.MAX_VALUE, Float.MAX_VALUE);

        for(Vector3f vertex : componentTransformedVertices) {
            if(vertex.x > componentMax.x) componentMax.x = vertex.x;
            if(vertex.y > componentMax.y) componentMax.y = vertex.y;
            if(vertex.z > componentMax.z) componentMax.z = vertex.z;

            if(vertex.x < componentMin.x) componentMin.x = vertex.x;
            if(vertex.y < componentMin.y) componentMin.y = vertex.y;
            if(vertex.z < componentMin.z) componentMin.z = vertex.z;
        }

        if (max.x <= componentMin.x || min.x >= componentMax.x) return false;
        if (max.y <= componentMin.y || min.y >= componentMax.y) return false;
        if (max.z <= componentMin.z || min.z >= componentMax.z) return false;
        return true;
    }

//some getters and setters.

    public abstract ArrayList<Vector3f> getVertices(); //returns an arraylist of object vertex coordinates for collision detection.

    private synchronized static ArrayList<Vector3f> transformVertices(ArrayList<Vector3f> vertices, Vector3f position, Vector3f rotation, Vector3f scale) {
        ArrayList<Vector3f> transformedVertices = new ArrayList<>();
        Matrix4f transformationMatrix = new Matrix4f()
            .translate(position)
            .rotateX((float) Math.toRadians(rotation.x))
            .rotateY((float) Math.toRadians(rotation.y))
            .rotateZ((float) Math.toRadians(rotation.z))
            .scale(scale);

        for (Vector3f vertex : vertices) {
            Vector3f transformedVertex = new Vector3f(vertex);
            transformedVertex.mulPosition(transformationMatrix);
            transformedVertices.add(transformedVertex);
        }

        return transformedVertices;
    }
}

Sphere.java code:

package Models;

import Engine.Component;
import org.lwjgl.opengl.GL11;

import static org.lwjgl.opengl.GL11.*;

import java.util.ArrayList;

import org.joml.Vector3f;

public class Sphere extends Component {
    public float radius = 1.0f;
    public int gradation = 100;
    public final float PI = (float) Math.PI;
    @Override
    public void draw() {
        float x, y, z, alpha, beta;
        for (alpha = 0.0f; alpha < Math.PI; alpha += PI / gradation) {
            glBegin(GL_TRIANGLE_STRIP);
            GL11.glColor3f(0.7f, 0.7f, 0.7f);
            for (beta = 0.0f; beta < 2.01f * Math.PI; beta += PI / gradation) {
                x = (float) (radius * Math.cos(beta) * Math.sin(alpha));
                y = (float) (radius * Math.sin(beta) * Math.sin(alpha));
                z = (float) (radius * Math.cos(alpha));
                glTexCoord2f(beta / (2.0f * PI), alpha / PI);
                glVertex3f(x, y, z);
                x = (float) (radius * Math.cos(beta) * Math.sin(alpha + PI / gradation));
                y = (float) (radius * Math.sin(beta) * Math.sin(alpha + PI / gradation));
                z = (float) (radius * Math.cos(alpha + PI / gradation));
                glTexCoord2f(beta / (2.0f * PI), alpha / PI + 1.0f / gradation);
                glVertex3f(x, y, z);
            }
            glEnd();
        }
    }
    @Override
    public ArrayList<Vector3f> getVertices() {
        return new ArrayList<Vector3f>() {{
            float x, y, z, alpha, beta;
            for (alpha = 0.0f; alpha < Math.PI; alpha += PI / gradation) {
                GL11.glColor3f(0.7f, 0.7f, 0.7f);
                for (beta = 0.0f; beta < 2.01f * Math.PI; beta += PI / gradation) {
                    x = (float) (radius * Math.cos(beta) * Math.sin(alpha));
                    y = (float) (radius * Math.sin(beta) * Math.sin(alpha));
                    z = (float) (radius * Math.cos(alpha));
                    glTexCoord2f(beta / (2.0f * PI), alpha / PI);
                    add(new Vector3f(x, y, z));
                    x = (float) (radius * Math.cos(beta) * Math.sin(alpha + PI / gradation));
                    y = (float) (radius * Math.sin(beta) * Math.sin(alpha + PI / gradation));
                    z = (float) (radius * Math.cos(alpha + PI / gradation));
                    glTexCoord2f(beta / (2.0f * PI), alpha / PI + 1.0f / gradation);
                    add(new Vector3f(x, y, z));
                }
            }
        }};
    }
}

Cube.java code:

package Models;

import Engine.Component;

import java.util.ArrayList;

import org.joml.Vector3f;
import org.lwjgl.opengl.GL11;

public class Cube extends Component {
    public float size = 1.0f;
    @Override
    public void draw() {
        GL11.glBegin(GL11.GL_QUADS);
        GL11.glColor3f(0.7f, 0.7f, 0.7f);

        GL11.glVertex3f(-size, size, -size);
        GL11.glVertex3f(size, size, -size);
        GL11.glVertex3f(size, size, size);
        GL11.glVertex3f(-size, size, size);

        GL11.glVertex3f(-size, -size, -size);
        GL11.glVertex3f(-size, -size, size);
        GL11.glVertex3f(size, -size, size);
        GL11.glVertex3f(size, -size, -size);

        GL11.glVertex3f(-size, -size, size);
        GL11.glVertex3f(-size, size, size);
        GL11.glVertex3f(size, size, size);
        GL11.glVertex3f(size, -size, size);

        GL11.glVertex3f(-size, -size, -size);
        GL11.glVertex3f(size, -size, -size);
        GL11.glVertex3f(size, size, -size);
        GL11.glVertex3f(-size, size, -size);

        GL11.glVertex3f(-size, -size, -size);
        GL11.glVertex3f(-size, -size, size);
        GL11.glVertex3f(-size, size, size);
        GL11.glVertex3f(-size, size, -size);

        GL11.glVertex3f(size, -size, -size);
        GL11.glVertex3f(size, size, -size);
        GL11.glVertex3f(size, size, size);
        GL11.glVertex3f(size, -size, size);

        GL11.glEnd();
    }

    @Override
    public ArrayList<Vector3f> getVertices() {
        return new ArrayList<Vector3f>() {{
            add(new Vector3f(-size, size, -size));
            add(new Vector3f(size, size, -size));
            add(new Vector3f(size, size, size));
            add(new Vector3f(-size, size, size));
            add(new Vector3f(-size, -size, -size));
            add(new Vector3f(-size, -size, size));
            add(new Vector3f(size, -size, size));
            add(new Vector3f(size, -size, -size));
            add(new Vector3f(-size, -size, size));
            add(new Vector3f(-size, size, size));
            add(new Vector3f(size, size, size));
            add(new Vector3f(size, -size, size));
            add(new Vector3f(-size, -size, -size));
            add(new Vector3f(size, -size, -size));
            add(new Vector3f(size, size, -size));
            add(new Vector3f(-size, size, -size));
            add(new Vector3f(-size, -size, -size));
            add(new Vector3f(-size, -size, size));
            add(new Vector3f(-size, size, size));
            add(new Vector3f(-size, size, -size));
            add(new Vector3f(size, -size, -size));
            add(new Vector3f(size, size, -size));
            add(new Vector3f(size, size, size));
            add(new Vector3f(size, -size, size));
        }};
    }
}

Instead of crashing, I would like to have a method that returns true when object boundaries are crossed.

Answer 1

Doing a collision you are probably in a different opengl state/context. Calling openGL functions in the wrong state/context at the wrong time could be the cause of the crash.

The main issue is that your Sphere.GetVertices() function uses glTexCoord2f and glColor3f while it's not clear what context you are in. You can only call those from the thread the GLContext was created in, you should also only call them during actual draw contexts (i.e. between glBegin and glEnd).

Removing glColor3f and glTexCoord2f from GetVertices() will likely fix the issue, especially since you don't need them there to begin with, as you aren't drawing those vertices at that time.