Difference between Game Engine vs Physics Engine vs Geometric modeling kernel - c++

Question

"The rendering engine generates animated 3D graphics by any of a number of methods (rasterization, ray-tracing etc.).
Instead of being programmed and compiled to be executed on the CPU or GPU directly, most often rendering engines are built upon one or multiple rendering application programming interfaces (APIs), such as Direct3D, OpenGL, or Vulkan which provide a software abstraction of the graphics processing unit (GPU). Low-level libraries such as DirectX, Simple DirectMedia Layer (SDL), and OpenGL are also commonly used in games as they provide hardware-independent access to other computer hardware such as input devices (mouse, keyboard, and joystick), network cards, and sound cards." - Game Engine
"UNISURF was a pioneering surface CAD/CAM system, designed to assist with car body design and tooling. It was developed by French engineer Pierre Bézier for Renault in 1968, and entered full use at the company in 1975.[1][2] By 1999, around 1,500 Renault employees made use of UNISURF for car design and manufacture." Advent of CAD/CAM Systems
"A geometric modeling kernel is a 3D solid modeling software component used in computer-aided design packages" Geometric Modeling Kernel
I am struggling to understand an underlying architecture of a geometric modeling kernels compared to the game engines and physics engines.
Questions:
Am I understand it correctly, that the geometric modeling kernels, are actually the low-level APIs, more specifically, a kernel loadable extensions, used specifically to handle the rendering of a geometric operations, like creating a boundary representation of an objects on the screen?
How are the geometric modeling kernels differ from the OpenGL-derived APIs? Are they also written in C++, or an older languages, since, I believe, they have appeared earlier?
Am I understand correctly, that the geometric modeling kernels, like ACIS, Parasolid are continuing to use it's own, proprietary, low-level modules, instead of OpenCL/OpenGL, or they are kind of mixed?
What is the architecture of the physics engine, in terms of an APIs. Is it using the OpenGL or other derived low-level graphics APIs? Let's say, Havoc, is it relying on other low-level API, say Direct3D?

Answer 1

Geometric modeling kernel is a modeling kernel, it allows constructing or modifying geometry and has nothing to do with displaying this geometry on the screen. It also differs from model sculpturing applications, because the latter ones are used by artists, while modeling kernels are used by engineers, and hence, has very different inputs, even when constructing visually similar model.
Modern modeling kernels are usually accompanied by 3D renderer for displaying models. But this functionality is usually put into dedicated components within the framework. Platforms have only limited set of hardware accelerated graphics libraries like OpenGL, Vulkan and Direct3D, so that 3D graphics engine coming with modeling kernel usually relies on one of lower-level libraries. Historically, OpenGL was used by majority of industrial applications (in contrast to Games), but this might be not the same today.
The language in which modeling kernel is written might differ, but I believe the most are written in C++. As modeling kernels were started to be written in older days, they might inherit some intermediate languages, like CDL in OCCT (remnants have been removed since OCCT 7.0.0) or code originating from other languages (like from FORTRAN, popular in the past) - the modeling kernels most likely don't use these languages, but it might be figured out from source code, that C++ code of some algorithms was converted from FORTRAN at some step (but of course, you cannot check this point with proprietary kernels).
If you take a look onto components structure of Open CASCADE Technology, an open source solid modeling kernel, you will find that Visualization component implements interactive services for displaying models using OpenGL or other low-level graphic library, but OCCT-based application does not have to use it, and may consider displaying shapes using other libraries.
In attempt to generalize:
Graphics engine implements services for rendering existing geometry and implemented on top of low-level APIs like OpenGL. This includes implementation of shading/material model (Phong, PBR metallic-roughness), Camera definition and a bunch of other tools, not coming with low-level APIs.
Geometric modeling kernel implements data structures (like Boundary Representation or CSG), complex math for model construction by engineers (including primitives, fillets, Boolean operations) on exact geometry represented by B-Splines and similar (in contrast to artists-orientated tools which usually works on polygonal geometry). The framework may provide other tools, including graphics engine, but they usually separated from geometry kernel. Graphics engines usually do not work directly with B-Spline geometry, so that Geometry modeling kernel has to generate triangulation for rendering the geomery.
Physics engine implements only services related to physics simulation. Physics engine includes collision detection module. The project may also contains samples using some graphics library, but the kernel should not depend on any.
Game engine combines Graphics engine, Physics engine, Audio engine, and usually also provides some scripting language and other tools for simplifying game development.