I am not sure you are the right people to ask, but I am working my way down the software chain.
I am using the latest version of java3d, compiled on my machine (that has a NVIDIA graphics board) from maven.
On a NVIDIA graphics board everything works just fine. On an Intel or AMD board there are weird rendering artifacts. It seems to be that surfaces suddenly become see through. Walls do not hide what is behind them (in some spots), the ground does not hide what is below it (in some spots). Those spots change as the view point changes. Attached is a set of images to illustrate the problems. The problems.txt file describes the problems in each pair of files.
This problem started (as far as I can tell) when we switched to Java 8.0, although that may be a false correlation. I used to use LWJGL and it had the same problem. I was hoping that converting to the modern java3d would fix it.
In my humble opinion, it has nothing to do with Java 1.8, it looks like an OpenGL problem and as Java3D is based on OpenGL, it's affected too. You probably rely on an unspecified behaviour of Nvidia graphics cards. I advise you to look at the winding of the vertices in the affected models and their respective normals. You can disable the Java2D OpenGL pipeline if you think that it might affect Java3D. There seems to be something really wrong with your normals, I have found some other anomalies. Backface culling is probably enabled in your code.
That all makes sense, except for the part about relying on an unspecified behavior of Nvidia cards. Until recently, this code worked correctly on all graphics cards. I have older compiled versions of the code that still work correctly on all cards. Newer code is all non-3d features. I believe, and I could be wrong, that the only 3d changes are to make the code jogamp-java3d instead of lwjgl (but both behave in the same way) and a locally rolled version of com.jogamp.opengl.util.GLBuffers and com.jogamp.common.nio.Buffers.
I thought I turned back face culling off, but I will double check.
I will compare the old OpenGL code to the current OpenGL code and see if I can find differences. Also, I will look into the vertex winding and normal calculations.
Here are the models as they were imported into the software. Also included are the sketchup original files that were exported to Collada. There is a file used_models.txt which lists the models used. https://mab.to/TBtEylQ2E
Here is a link to the files as they are exported from our software, including the whole site as a Collada model. https://mab.to/U2YWq5gmC
I'm not sure how these links will work, but if they don't let me know.
I have no explanation about why it works with a Nvidia card (on multiple machines BTW). That totally confuses and frustrates me.
All jar files are local, nothing gets copied to the JRE. Actually all referenced jars are copied from the JDK to be local.
When we switched to Java 1.8 we were still using the old unmaintained LWJGL. It had the same problems. I was hoping Java3D would fix those problems. We needed to move to Java3D anyway, so no going back.
After loading each model, I went through all meshes and made sure everything was counter clockwise. I also recalculated the normal for each point. Also, I made sure each mesh and node had culling set to none. None of this made any difference in the drawing problem.
Here is a better link. It includes each model separately. https://mab.to/SyzaOngwn I was able to load the entire site into Sketchup. I have not tried Blender. The original models are in 3D_Models, the site and house models are in Test_Virtual_3d.
The original bin files I gave you had, faces set to no cull and an attempt at normalizing the faces. This caused problems in the working 3d version we have. Mostly the problem was flickering as two faces at the same location were drawn. I have removed both the normalization and forcing all faces to no cull. Here are the same bins.
app_buildings.bin app_ground.bin app_models.bin
I assume links in my older e-mails have expired. Please let me know if you want them recreated.
The remaining problem is that the models draw just fine on a NVidia card. On an Intel/AMD graphics card there are weird artifacts, the surfaces (sometimes) do not obscure things behind/underneath them. The original pictures I sent you of the problem are from unaltered models (the second set). Same models, same code, different graphics board. We have different graphics boards in the office and have not noticed a difference until recently.
What I'm saying in my previous post is that I tried to implement some of your suggestions, but they did not produce useful results. Perhaps the fault is mine in how I implemented them.