A three-dimensional rendering engine for multi-source design model integration of offshore oil engineering

Abstract

The application provides a three-dimensional rendering engine for multi-source design model integration of ocean petroleum engineering, relates to the field of computer graphics and three-dimensional visualization technology, and comprises four layers of technical architecture: a cloud rendering layer realizes high-performance graphics processing based on a Vulkan API; a cloud transmission layer is responsible for pixel stream transmission and instruction interaction; an integrated SDK layer encapsulates common interfaces; and an application docking layer realizes business development. A service-side rendering plus pixel stream pushing technical route is adopted, low-delay video transmission is realized through WebRTC, instruction interaction is realized in combination with an MQTT protocol, rendering calculation is concentrated on the service side, and the client only needs to process video stream decoding. The model browsing frame rate of the application is not lower than 20 frames per second, the first preloading time is less than 1 minute, and the system response time after preloading is less than 3 seconds, so that the smooth display problem of large-scale three-dimensional models on ordinary terminal devices is effectively solved, and high-fidelity three-dimensional visualization support is provided for the whole business process of ocean engineering.

Description

Technical Field

[0001] This invention relates to the fields of computer graphics and 3D visualization technology, and in particular to a 3D rendering engine for integrating multi-source design models for marine oil engineering. Background Technology

[0002] The marine engineering industry has an increasingly urgent need for digital and intelligent transformation. The application of traditional 3D visualization technology in the field of marine engineering faces the following technical bottlenecks: 1. Conflict between model size and performance: Large structural models such as jackets and floating structures in marine engineering have a huge amount of data (usually containing millions to hundreds of millions of triangular faces). Traditional WebGL rendering technology is difficult to display smoothly on ordinary terminal devices, resulting in poor user experience and slow interactive response.

[0003] 2. Insufficient cross-platform compatibility: Existing 3D engines mostly rely on specific plugins or clients, and cannot run uniformly on multiple platforms such as Windows, Linux, iOS, Android, HarmonyOS and domestic operating systems, which limits the sharing and collaboration of engineering data.

[0004] 3. Low network transmission efficiency: Traditional 3D model transmission requires sending the complete model data to the client, which requires high network bandwidth and makes it difficult to guarantee a real-time interactive experience in complex network environments.

[0005] 4. System integration difficulties: Existing 3D engines lack standardized API interfaces, making it difficult to seamlessly integrate with marine engineering design, construction, operation and maintenance systems, and thus failing to meet the full-process requirements of digital delivery.

[0006] 5. Balancing rendering quality and performance: While ensuring high-fidelity rendering effects, it is difficult to achieve a stable frame rate of more than 20 frames per second, which affects user experience and engineering decision-making efficiency. Summary of the Invention

[0007] The main technical problem to be solved by this invention is that the existing technology has problems such as poor rendering performance of large-scale 3D models, insufficient cross-platform compatibility, and difficulty in system integration. In order to overcome the above-mentioned defects of the existing technology, a 3D rendering engine for multi-source design model integration in marine oil engineering is provided.

[0008] The technical solution adopted by this invention to solve its technical problem is: A 3D rendering engine for integrating multi-source design models in marine oil engineering, comprising a four-layer technical architecture: The cloud rendering layer, based on the Vulkan API, implements high-performance graphics processing programs and is responsible for the construction, rendering, and interaction of 3D scenes; The cloud transport layer, connected to the cloud rendering layer, is responsible for pixel stream transmission services and instruction interaction between the browser and the 3D engine. An integrated SDK layer, connected to the cloud transmission layer, includes a pixel stream receiving and processing module and an instruction communication processing module, which is used to encapsulate commonly used interfaces; The application interface layer, connected to the integration SDK layer, is used to integrate the SDK through the page and call the interface to complete specific business development. The cloud rendering layer adopts a technical approach that combines server-side rendering with pixel-stream push, concentrating rendering computation on the server side, while the client only needs to receive the video stream; the cloud transmission layer uses WebRTC technology for network image data transmission and implements streaming media services based on SRS; the integrated SDK layer uses the MQTT protocol to realize command interaction between the client and the server.

[0009] Furthermore, in the network image data transmission, image encoding is based on I420 sampling, and video uses H264 encoding.

[0010] Furthermore, the client listens for mouse and keyboard events, calls the JS SDK interface to push operation instructions to the server, and the engine instance parses the instructions and executes the model operations.

[0011] Furthermore, the cloud rendering layer implements rendering through the Vulkan API, supports explicit control of GPU and CPU resources, and the rendering process includes: server-side rendering, sampling the rendering results, converting the sampled data into YUV format and compressing it, then performing H264 encoding, and finally pushing the stream to the client through the SRS streaming media service for subscription, decoding and playback.

[0012] Furthermore, the cloud transmission layer ensures that the latency of instruction interaction between the client and the server is less than 100ms, and the uplink bandwidth of a single node is not less than 30MB / s.

[0013] Furthermore, the performance metrics of the 3D rendering engine are as follows: initial preloading time is less than 1 minute, system response time after preloading is less than 3 seconds, model browsing frame rate is not less than 20 frames / second, and it supports multi-user concurrent access and live streaming mode.

[0014] Furthermore, the integrated SDK layer provides a general API development interface, including model loading, view control, component operation, and measurement annotation functions. It supports the transmission of model ID, progress scale, coordinate position, and viewpoint data parameters, and provides professional function interfaces for camera control, section display, measurement calculation, and annotation.

[0015] Furthermore, the 3D rendering engine supports multiple platforms including Windows, Linux, iOS, Android, HarmonyOS, and Kylin Desktop V10sp1, and is compatible with mainstream browsers. The server-side hardware configuration requirements are: a 16-core CPU with 32GB or more of RAM, 500GB or more of storage, an Nvidia RTX 4080 Super or A6000 or higher graphics card, and a single-node uplink network bandwidth of 30MB / s or more.

[0016] Furthermore, the cloud rendering layer uses Vulkan's parallel command buffering mechanism to optimize the triangle face processing and material rendering process, and utilizes multi-core CPU resources to improve rendering efficiency.

[0017] Furthermore, the application docking layer enables visualization of large jacket and floating facility models, and supports functions including sectioning to view internal structures, measuring component dimensions, data connection to display component attribute information, character roaming to simulate on-site inspection, displaying liquid dynamic effects, and marking to record problem points.

[0018] The beneficial effects of this invention are: 1. Breaking through performance bottlenecks, the cloud rendering architecture moves complex rendering calculations to the server, and the client only needs to handle video stream decoding, significantly reducing the performance requirements of terminal devices and enabling ordinary PCs and mobile devices to smoothly browse large 3D models.

[0019] 2. Enhanced interactive experience: Based on WebRTC's low-latency transmission technology and combined with the MQTT command interaction mechanism, it achieves an interactive experience close to that of local applications, with a model browsing frame rate of over 20 frames per second.

[0020] 3. Enhanced system compatibility, supporting multiple platforms including Windows, Linux, iOS, Android, HarmonyOS, and Kylin Desktop V10sp1, compatible with mainstream browsers, and meeting the access needs of different terminal devices.

[0021] 4. Simplify system integration by providing standardized JS SDK and API interfaces, enabling third-party systems to quickly integrate 3D visualization functions and shorten the development cycle.

[0022] 5. Ensure data security: Model data is stored on the server side, and the client only receives the pixel stream of the rendering result, effectively protecting the security of the original model data and meeting the data confidentiality requirements of the marine engineering industry. Attached Figure Description

[0023] The present invention will be further described below with reference to the accompanying drawings and embodiments.

[0024] Figure 1 This is a diagram illustrating the overall technical architecture of the 3D engine of this invention. Figure 2 This is a flowchart illustrating the overall process architecture of the engine rendering for this invention. Figure 3 This is a data flow diagram of the core module of the present invention; Figure 4 This is a diagram of the engine management function architecture of the present invention; Figure 5 This is an example diagram of 3D scene rendering for the present invention. Detailed Implementation

[0025] The present invention will be further described below with reference to specific embodiments. The illustrative embodiments and descriptions herein are used to explain the present invention, but are not intended to limit the present invention.

[0026] Reference Figures 1-5 As shown, this invention discloses a 3D rendering engine for integrating multi-source design models in marine oil engineering, wherein... Figure 1 This demonstrates the composition and data flow of the cloud rendering layer, cloud transport layer, integration SDK layer, and application interface layer. Figure 2 It demonstrates the complete data flow from server-side rendering to client-side display, including rendering sampling, YUV compression, H264 encoding, SRS streaming, and client-side decoding. Figure 3 It provides a detailed demonstration of the command interaction and video stream transmission process between the client and server, including key nodes such as user input, command encapsulation, network transmission, model loading, rendering engine, and video encoding. Figure 4 The functional modules of the engine management terminal are shown, including lightweight management, engine management, and server resource management. Figure 5 The rendering of large jacket models and floating facility models in the engine is showcased.

[0027] The 3D rendering engine of this invention adopts a four-layer technical architecture, including: Cloud Rendering Layer: A high-performance graphics processing program implemented based on the Vulkan API, responsible for the construction, rendering, and interaction of 3D scenes. This layer adopts a server-side rendering + pixel stream push technology approach, centralizing rendering calculations on the server side, while the client only needs to receive the video stream.

[0028] Cloud Transport Layer: Responsible for pixel stream transmission services and command interaction between the browser and the 3D engine. This layer uses WebRTC technology for network image data transmission, enabling peer-to-peer connections; image encoding is based on I420 (YUV 4:2:2) sampling, video uses H264 encoding, streaming media services are implemented based on SRS, and support multiple protocols such as RTMP, WebRTC, and HLS.

[0029] Integrated SDK Layer: This layer includes pixel stream receiving and processing, command communication processing modules, and encapsulates commonly used interfaces. It enables command interaction between the client and server via the MQTT protocol. The client listens for mouse and keyboard events, calls the JS SDK interface, and the SDK pushes the operation commands to the server via the MQTT protocol. The engine instance parses the commands, executes model operations, and updates the rendering results, achieving a low-latency (<100ms) real-time interactive experience.

[0030] Application Integration Layer: This layer integrates the SDK into the page, allowing users to call APIs to complete specific business logic development.

[0031] Specifically, this includes the following aspects: 1. System environment configuration.

[0032] The 3D rendering engine system of this invention consists of two parts: a server and a client. The specific hardware and software environment requirements are as follows: 1.1 Server-side hardware configuration.

[0033] Operating System: Windows 10 / Server 2016 64-bit and above, or Kylin Desktop Edition V10 sp1; CPU and memory: 16 cores and 32GB or more; Storage: 500GB or more; Graphics card: Nvidia RTX 4080 Super or A6000 or better, with at least 8GB of video memory (16GB recommended). Network bandwidth: Uplink speed of 30MB / s or more per node.

[0034] 1.2 Client hardware configuration.

[0035] Operating system: Windows 10 / Server 2016 or later; CPU: Intel Core i5-9600 or higher; Memory: 4GB or more; Network bandwidth: Download speed of 30MB / s or higher; Storage: 50GB or more.

[0036] 2. Implementation of core modules.

[0037] 2.1. Specific implementation of the cloud rendering layer.

[0038] The rendering engine is developed based on the Vulkan API, achieving high-performance rendering, supporting explicit control of GPU and CPU resources, and reducing driver layer overhead. The main implementation process is as follows: / / Create a Vulkan instance VkInstanceCreateInfo createInfo = {}; createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; / / ...Configure instance parameters... vkCreateInstance(&createInfo, nullptr, &instance); / / Create the rendering pipeline VkGraphicsPipelineCreateInfo pipelineInfo = {}; pipelineInfo.sType=VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; pipelineInfo.stageCount = 2; / / Vertex shader and fragment shader pipelineInfo.pStages = shaderStages; vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &pipelineInfo,nullptr, &pipeline); / / Rendering loop while (!shouldClose) { / / Process user input ProcessInput(); / / Record commands RecordCommandBuffer(); / / Submit command SubmitCommandBuffer(); / / Rendering frames PresentFrame(); } This invention utilizes Vulkan's parallel command buffering mechanism to fully leverage multi-core CPU resources and improve rendering efficiency. Specifically, it optimizes the triangle processing and material rendering workflow for marine engineering models. / / Vertex input state configuration VkPipelineVertexInputStateCreateInfo vertexInputState = vks::initializers::pipelineVertexInputStateCreateInfo(); vertexInputState.vertexBindingDescriptionCount = 1; vertexInputState.pVertexBindingDescriptions=&vertexInputBinding; vertexInputState.vertexAttributeDescriptionCount = static_cast<uint32_t>(vertexInputAttributes.size()); vertexInputState.pVertexAttributeDescriptions=vertexInputAttributes.data(); / / Vertex binding description VkVertexInputBindingDescription vertexInputBinding = vks::initializers::vertexInputBindingDescription( 0, sizeof(Vertex), VK_VERTEX_INPUT_RATE_VERTEX); / / Vertex attribute description std::vector <vkvertexinputattributedescription>vertexInputAttributes ={ vks::initializers::vertexInputAttributeDescription(0, 0, VK_FORMAT_R32G32B32_SFLOAT, offsetof(Vertex, pos)), vks::initializers::vertexInputAttributeDescription(0, 1, VK_FORMAT_R32G32B32_SFLOAT, offsetof(Vertex, normal)), vks::initializers::vertexInputAttributeDescription(0, 2, VK_FORMAT_R32G32_SFLOAT, offsetof(Vertex, uv)), }; 2.2. Cloud Transport Layer Implementation: Streaming media transmission based on WebRTC and SRS.

[0039] The cloud transmission layer enables low-latency interaction, with a client-server command interaction latency of less than 100ms and a single node uplink bandwidth requirement of more than 30MB / s, ensuring high-fidelity rendering quality.

[0040] The rendering process includes: server-side rendering, sampling the rendering results, converting the sampled data to YUV format and compressing it, followed by H264 encoding, and finally pushing the stream to the client via the SRS streaming media service for subscription, decoding, and playback. WebRTC technology is used to achieve low-latency video transmission, combined with H264 encoding and the SRS streaming media server to ensure high-quality video stream push and reception. The server-side acquisition and push process is as follows: / / Server-side rendering result collection void CaptureFrame() { / / Sample from the rendered result vkGetImageSubresourceLayout(device,renderImage,&subresourceLayout, &layout); void* mapped; vkMapMemory(device, renderMemory, 0, VK_WHOLE_SIZE, 0, &mapped); / / Convert to YUV format ConvertRGBAToYUV((uint8_t*)mapped, yuvBuffer, width, height); / / H264 encoding EncodeH264(yuvBuffer, h264Frame); / / Push to SRS SRS_PushStream(h264Frame); vkUnmapMemory(device, renderMemory); } / / Client receiving and decoding void ReceiveAndDecode() { / / Subscribe to video stream from SRS SRS_SubscribeStream(channel); / / Receive H.264 frames ReceiveH264Frame(frame); / / Decoding DecodeH264(frame, yuvBuffer); / / Convert to RGB and display ConvertYUVToRGBA(yuvBuffer, rgbaBuffer, width, height); DisplayOnCanvas(rgbaBuffer); } 2.3. Command Interaction Implementation.

[0041] Implement command interaction between client and server based on MQTT protocol: / / Client-side JS SDK function rotateView(angleX, angleY) { const command = { type: "rotate", params: {x: angleX, y: angleY}, instanceId: currentInstanceId }; / / Send commands via MQTT mqttClient.publish(`engine / command / ${instanceId}`,JSON.stringify(command)); } / / Server-side command processing void HandleCommand(const std::string& payload) { auto command = ParseCommand(payload); if (command.type == "rotate") { / / Update camera parameters camera.Rotate(command.params.x, command.params.y); / / Trigger re-render RequestRender(); } / / Other instruction processing... } 3. Implementation process of main functions.

[0042] 3.1 Model loading and rendering process in the cloud rendering layer.

[0043] 3.1.1. Engine Instance Initialization: Create a rendering context — Initialize Vulkan devices and the swap chain — Configure the rendering pipeline.

[0044] 3.1.2. Model Data Loading: Load lightweight model data from the server — parse the model structure and material information — create vertex buffers and index buffers.

[0045] void MatMeshModel::loadModel(vks::VulkanDevice* device, const std::string& modelPath) { / / Load model data auto modelData = LoadModelData(modelPath); / / Create vertex buffer VK_CHECK_RESULT(device->createBuffer( VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, &vertexBuffer, modelData.vertices.size() * sizeof(Vertex), modelData.vertices.data() )); / / Create an index buffer VK_CHECK_RESULT(device->createBuffer( VK_BUFFER_USAGE_INDEX_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, &indexBuffer, modelData.indices.size() * sizeof(uint32_t), modelData.indices.data() )); / / Create a material buffer createMaterialBuffer(device); } 3.1.3. Rendering loop.

[0046] Clear the frame buffer — bind the rendering pipeline — bind the vertex and index buffers — draw the model — sample and encode the rendering results.

[0047] void RenderLoop() { while (running) { / / Get the next swap chain image uint32_t imageIndex; vkAcquireNextImageKHR(device, swapChain, UINT64_MAX,imageAvailableSemaphore, VK_NULL_HANDLE, &imageIndex); / / Record commands RecordCommandBuffer(imageIndex); / / Submission Queue SubmitQueue(imageIndex); / / Presenting images PresentQueue(imageIndex); / / Sampling and encoding CaptureAndEncodeFrame(); } } 3.2. Implement view control functionality through a cloud rendering layer (server-side) and an integrated SDK layer (client-side call).

[0048] / / Reset view void ResetViewPort() { / / Reset camera position and orientation camera.Reset(); / / Recalculate the projection matrix camera.UpdateProjectionMatrix(); / / Trigger rendering RequestRender(); } / / Model measurement function void MeasureDistance(const glm::vec3& start, const glm::vec3& end) { float distance = glm::distance(start, end); / / Display measurement results on the screen DrawMeasurementResult(start, end, distance); } / / Slicing function void ApplySectionCut(const glm::vec3& planeNormal, float planeOffset){ / / Update cutting plane parameters sectionPlane.normal = planeNormal; sectionPlane.offset = planeOffset; / / Update shader uniform UpdateSectionPlaneUniform(); / / Trigger rendering RequestRender(); } 4. The integrated SDK layer provides a general API development interface, including model loading, view control, component operation, and measurement annotation functions. It supports the transmission of model ID, progress scale, coordinate position, and viewpoint data parameters, and provides professional function interfaces for camera control, section display, measurement calculation, and annotation, which facilitates secondary development and function expansion by users and meets diverse application needs.

[0049] Example of API interface implementation in the integrated SDK layer.

[0050] Provides a standardized JS SDK interface for easy integration with third-party systems: / / Initialize the engine function initEngine(containerId, renderAddr, commandAddr) { / / Create a rendering container const container = document.getElementById(containerId); / / Connect to rendering service const videoStream = new VideoStream(renderAddr); videoStream.play(container); / / Connection command service const commandClient = new CommandClient(commandAddr); return { / / View control method resetView: () => commandClient.send('resetView'), zoomFit: (modelId) => commandClient.send('zoomFit', {modelId}), / / Model operation methods hideElement: (elementId) => commandClient.send('hideElement',{elementId}), showElement: (elementId) => commandClient.send('showElement',{elementId}), / / Measurement function startMeasure: (type) => commandClient.send('startMeasure', {type}), stopMeasure: () => commandClient.send('stopMeasure'), / / Event Listener onModelLoaded: (callback) => commandClient.on('modelLoaded',callback), onCameraChanged: (callback) => commandClient.on('cameraChanged',callback) }; } 5. Practical application scenarios are implemented through the application interface layer.

[0051] 5.1 Visualization of large-scale catheter stents: Load the pipe rack model containing millions of triangular faces; Use the sectioning function to view the internal structure; Use measuring tools to accurately measure the dimensions of the components; Display component attribute information through data linking.

[0052] 5.2 Load the model of floating facilities such as FPSO.

[0053] Implement a character roaming function to simulate on-site inspection; Display dynamic effects of liquids, such as changes in oil tank levels; Use the marking function to record problem points and add annotations.

[0054] The performance metrics of the 3D rendering engine are as follows: initial pre-loading time less than 1 minute, system response time after pre-loading less than 3 seconds, model browsing frame rate no less than 20 frames / second to ensure a smooth interactive experience, support for multi-user concurrent access and live streaming mode to meet the needs of multi-user collaboration, effectively solve the problem of smooth display of large-scale 3D models (millions to hundreds of millions of triangles) on ordinary terminal devices, and provide high-fidelity 3D visualization support for the entire business process of marine engineering. The engine rendering nodes support horizontal expansion and can dynamically adjust resources according to the load.

[0055] The 3D rendering engine supports multiple platforms including Windows, Linux, iOS, Android, HarmonyOS, and Kylin Desktop V10sp1, and is compatible with mainstream browsers. The server-side hardware configuration requirements are: a 16-core CPU with 32GB or more of RAM, 500GB or more of storage, an Nvidia RTX 4080 Super or A6000 or higher graphics card, and a single-node uplink network bandwidth of 30MB / s or more.

[0056] This invention has been successfully applied in actual projects of Offshore Oil Engineering Co., Ltd., verifying its excellent performance in large-scale 3D model rendering, multi-platform compatibility, and system integration, providing strong technical support for the digital transformation of marine engineering.

[0057] The above description is merely a preferred embodiment of the present invention and is not intended to limit the present invention in any way. Any simple modifications, equivalent changes, and alterations made to the above embodiments based on the technical essence of the present invention shall still fall within the scope of the technical solution of the present invention.< / vkvertexinputattributedescription>

Claims

1. A 3D rendering engine for integrating multi-source design models in marine oil engineering, characterized in that, Includes a four-layer technical architecture: The cloud rendering layer, based on the Vulkan API, implements high-performance graphics processing programs and is responsible for the construction, rendering, and interaction of 3D scenes; The cloud transport layer, connected to the cloud rendering layer, is responsible for pixel stream transmission services and instruction interaction between the browser and the 3D engine. An integrated SDK layer, connected to the cloud transmission layer, includes a pixel stream receiving and processing module and an instruction communication processing module, which is used to encapsulate commonly used interfaces; The application interface layer, connected to the integration SDK layer, is used to integrate the SDK through the page and call the interface to complete specific business development. The cloud rendering layer adopts a technical approach that combines server-side rendering with pixel stream push, which centralizes rendering calculations on the server side, and the client only needs to receive the video stream. The cloud transport layer uses WebRTC technology for network image data transmission and implements streaming media services based on SRS; the integrated SDK layer uses the MQTT protocol to enable command interaction between the client and the server.

2. The 3D rendering engine for multi-source design model integration in marine oil engineering according to claim 1, characterized in that, In the network image data transmission, image encoding is based on I420 sampling, and video uses H264 encoding.

3. A 3D rendering engine for integrating multi-source design models in marine oil engineering according to claim 1, characterized in that, The client listens for mouse and keyboard events, calls the JS SDK interface to push operation instructions to the server, and the engine instance parses the instructions and executes the model operations.

4. A 3D rendering engine for integrating multi-source design models in marine oil engineering according to claim 1, characterized in that, The cloud rendering layer implements rendering through the Vulkan API, supports explicit control of GPU and CPU resources, and the rendering process includes: server-side rendering, sampling the rendering results, converting the sampled data into YUV format and compressing it, then encoding it with H264, and finally pushing it to the client for subscription, decoding and playback through the SRS streaming media service.

5. A 3D rendering engine for integrating multi-source design models in marine oil engineering according to claim 1, characterized in that, The cloud transport layer ensures that the latency of command interaction between the client and the server is less than 100ms, and the uplink bandwidth of a single node is not less than 30MB / s.

6. A 3D rendering engine for integrating multi-source design models in marine oil engineering according to claim 1, characterized in that, The performance metrics of the 3D rendering engine are: initial preloading time less than 1 minute, system response time after preloading less than 3 seconds, model browsing frame rate not less than 20 frames / second, and support for multi-user concurrent access and live streaming mode.

7. A 3D rendering engine for integrating multi-source design models in marine oil engineering according to claim 1, characterized in that, The integrated SDK layer provides a general API development interface, including model loading, view control, component operation, and measurement annotation functions. It supports the transmission of model ID, progress scale, coordinate position, and viewpoint data parameters, and provides professional function interfaces for camera control, section display, measurement calculation, and annotation.

8. A 3D rendering engine for integrating multi-source design models in marine oil engineering according to claim 1, characterized in that, The 3D rendering engine supports multiple platforms including Windows, Linux, iOS, Android, HarmonyOS, and Kylin Desktop V10sp1, and is compatible with mainstream browsers. The server-side hardware configuration requirements are: a 16-core CPU with 32GB or more of RAM, 500GB or more of storage, an Nvidia RTX 4080 Super or A6000 or higher graphics card, and a single-node uplink network bandwidth of 30MB / s or more.

9. A 3D rendering engine for integrating multi-source design models in marine oil engineering according to claim 1, characterized in that, The cloud rendering layer uses Vulkan's parallel command buffering mechanism to optimize the triangle face processing and material rendering process, and utilizes multi-core CPU resources to improve rendering efficiency.

10. A 3D rendering engine for integrating multi-source design models in marine oil engineering according to claim 1, characterized in that, The application docking layer enables visualization of large jacket and floating facility models, and supports functions including sectioning to view internal structure, measuring component dimensions, data connection to display component attribute information, character roaming to simulate on-site inspection, displaying liquid dynamic effects, and marking to record problem points.

Images