Unity AssetBundle-based course resource increment downloading method and system

Abstract

The invention relates to the technical field of computer software, in particular to a course resource increment downloading method and system based on Unity AssetBundle, and the method comprises the steps: constructing, analyzing and referencing dependency through a resource packet topology to generate AssetBundle with a version identifier; the increment configuration file manages and associates a course ID and an AssetBundle path and marks a necessary / increment resource type; a scene triggers and downloads a response course selection layer / chapter entering layer / experiment interaction layer behavior, a necessary resource bundle is forcibly updated, and an incremental resource bundle is triggered by a user as required by providing UGUI interface elements; according to block difference updating, a resource packet is divided into 512 KB blocks to verify differences, and only server-side identification blocks are downloaded; the resource isolated storage creates a sandbox directory and generates a disk hard link. The hierarchical loading efficiency is substantially improved, the incremental transmission flow is declined, the multi-course conflict is thoroughly eradicated, and the storage reuse rate is multiplied in magnitude.

Description

Technical Field

[0001] This invention relates to the field of computer software technology, specifically to a method and system for incremental downloading of course resources based on Unity AssetBundle. Background Technology

[0002] With the rapid development of mobile internet and online education, interactive course software developed based on the Unity engine is becoming increasingly popular in computer software. This type of software usually contains a large number of multimedia resources, such as models, textures, audio, video, and scenes. These resources are packaged and managed through Unity's AssetBundle technology to facilitate resource loading and updates.

[0003] In existing technologies, when software needs to be updated or users switch to different courses, it is often necessary to download the complete resource package or download all possible incremental resources indiscriminately. This leads to storage management defects, such as forced full downloads when switching courses, indiscriminate updates of incremental resources, and slow response in weak network environments. It also results in high storage consumption, redundant resources occupying storage space, conflicts between multiple course AssetBundles, and unreused duplicate resources. Furthermore, the update mechanism is flawed, with dependencies not explicitly recorded, single-file updates requiring full rebuilding, and the lack of a block-based differential update mechanism.

[0004] Therefore, in order to achieve incremental updates on demand and significantly improve resource loading efficiency and storage utilization, a method and system for incremental downloading course resources based on Unity AssetBundle is proposed. Summary of the Invention

[0005] The purpose of this invention is to provide a method and system for incremental downloading course resources based on Unity AssetBundle, which solves the problems of storage management defects, excessive storage consumption, and defects in the update mechanism.

[0006] To achieve the above objectives, the present invention provides the following technical solution: a method for incremental downloading of course resources based on Unity AssetBundle, comprising the following steps: Resource package topology construction: parse the reference dependencies between course resource files, and generate an AssetBundle resource package with version identifier through Unity's BuildPipeline.BuildAssetBundle; Incremental configuration file management: Maintain associated course IDs and AssetBundle paths and mark required / incremental type course resource configuration files, as well as global version configuration files; Scene-triggered download: In response to user selection of courses or entry into chapters, a differentiated download strategy is executed; Required resource pack; forced download when the version is outdated; Incremental resource packages provide UGUI interface elements for users to trigger downloads on demand; Block-based difference update: Download the difference blocks through the block hash verification mechanism; Resource isolation storage: Create version sandbox directories for different courses to avoid AssetBundle conflicts.

[0007] Furthermore, the construction of the AssetBundle resource package includes: Resource files with a reference frequency of >5 times per course will be automatically merged into the same AssetBundle package; Generate an XML-formatted AssetBundle dependency index file, recording cross-package reference paths.

[0008] Furthermore, the scenario-triggered download includes: The course selection layer responds to course selection behavior and downloads the core course scenario package; The chapter entry layer responds to chapter entry behavior and loads the chapter-specific resource package; The experiment interaction layer responds to the click behavior of the experiment button and asynchronously downloads the experiment toolkit.

[0009] Furthermore, the incremental configuration file management is implemented through the Unity editor: Drag and drop the AssetBundle resource package to the course ID configuration area in the UGUI interface; Generate course configuration files containing AssetBundle paths in real time.

[0010] Furthermore, the block difference update includes: Divide the AssetBundle resource package into 512KB blocks; Use Unity's Hash128 structure to generate block hash values; Only download the difference blocks identified by the server and reassemble the AssetBundle.

[0011] Furthermore, the resource isolation storage includes: Create a version directory in Application.persistentDataPath / CourseID / ; Create hard links to disk for AssetBundle files with the same content using Unity's System.IOAPI.

[0012] Furthermore, when executing the chapter entry layer: Perform version validity checks on the resource packages specific to the aforementioned chapters; When a local version is detected to be lagging behind, a block difference update is automatically triggered. After the update is complete, load the latest resource package using AssetBundle.LoadFromFile.

[0013] Furthermore, the generation of the XML format AssetBundle depends on the execution of the index file: When an update to a single resource file in the course resources is detected; The direct associated AssetBundle resource bundles that need to be rebuilt are determined by the cross-package reference relationships recorded in the dependency index file. Only rebuild the directly associated AssetBundle resource bundle; Update the version identifier information in the dependency index file.

[0014] This invention also discloses a system for incremental downloading of course resources based on Unity AssetBundle, the system comprising: AssetBundle Builder: Calls Unity's BuildPipeline.BuildAssetBundle to generate an asset bundle with dependency indexes; Course Configurator: Generates a UGUI drag-and-drop interface, allowing users to associate resource packages with course IDs through the interface; Incremental Downloader: Performs chunked differential updates via UnityWebRequest, determining the download strategy based on the course configurator's configuration file; Sandbox Manager: Isolates AssetBundle storage paths based on course IDs, receives resource files transmitted by incremental downloaders, and stores them in isolated paths.

[0015] Compared with the prior art, the beneficial effects of the present invention are as follows: 1. By resolving the dependency relationships between course resource files through resource package topology construction, version-identified AssetBundle resource packages are generated. In addition, incremental configuration files are used to manage and maintain the association between course IDs and AssetBundle paths, and to mark required resource packages and incremental resource package types. A global version configuration file is established to record the latest resource status. This collaborative mechanism enables the course selection layer to accurately download the core scenario package of the course when responding to the course selection behavior, the chapter entry layer to load the chapter-specific resource package on demand when responding to the chapter entry behavior, and the experiment interaction layer to asynchronously download the experiment tool package when responding to the experiment button click behavior, thus achieving a fundamental optimization of resource loading efficiency.

[0016] 2. When the scenario triggers a differentiated download strategy, essential resource packages are forcibly downloaded when their versions are outdated. Incremental resource packages are available for users to trigger downloads on demand through UGUI interface elements. This process is coupled with a block-based differential update mechanism that divides the AssetBundle resource package into 512KB blocks. The block hash value is generated using Unity's Hash128 structure. Only the differential blocks identified by the server are downloaded and the AssetBundle is reassembled. This closed-loop technology significantly reduces network transmission consumption while ensuring that the block-based differential update is automatically triggered when the chapter enters the layer. After the update is completed, the latest resource package is seamlessly loaded through AssetBundle.LoadFromFile.

[0017] 3. Resource isolation storage is implemented in the Application.persistentDataPath / CourseID / Creation Version Sandbox directory. Hard links to AssetBundles with the same content are generated on disk through Unity's System.IO API, completely eliminating the risk of conflicts between multiple course AssetBundles. This mechanism forms a complete closed loop with the incremental configuration file management implemented in the Unity editor's UGUI interface. When the user drags and drops AssetBundle resource packages to the course ID configuration area in the UGUI interface, a course configuration file containing the AssetBundle path is generated in real time. This visual configuration process works in conjunction with resource isolation storage.

[0018] 4. When an update to a single resource file in the course resources is detected, the directly associated AssetBundle resource package that needs to be rebuilt is determined by the cross-package reference path recorded in the AssetBundle dependency index file. Only the associated package is rebuilt and the version identification information in the dependency index file is updated. This precise update mechanism is dynamically linked with the version sandbox directory established by the resource isolation storage. During the block differential update process, the integrity of the AssetBundle storage path isolated by the course ID is maintained, so as to completely resolve storage conflicts and achieve a substantial leap in update efficiency. Attached Figure Description

[0019] Figure 1 This is a flowchart of the system architecture of the present invention; Figure 2 This is a schematic diagram illustrating the construction of the resource package of the present invention; Figure 3 This is a flowchart of the hierarchical triggering mechanism of the present invention. Detailed Implementation

[0020] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0021] Please see Figures 1 to 3 This invention provides a technical solution: a method for incremental downloading of course resources based on Unity AssetBundle, comprising the following steps: Resource package topology construction: parse the reference dependencies between course resource files, and generate an AssetBundle resource package with version identifier through Unity's BuildPipeline.BuildAssetBundle; Incremental configuration file management: Maintain associated course IDs and AssetBundle paths and mark required / incremental type course resource configuration files, as well as global version configuration files; Scene-triggered download: In response to user selection of courses or entry into chapters, a differentiated download strategy is executed; Required resource pack; forced download when the version is outdated; Incremental resource packages provide UGUI interface elements for users to trigger downloads on demand; Block-based difference update: Download the difference blocks through the block hash verification mechanism; Resource isolation storage: Create version sandbox directories for different courses to avoid AssetBundle conflicts; The system resolves the dependencies between course resource files by constructing a resource package topology, generating version-identified AssetBundle resource packages. Incremental configuration files manage and maintain the association between course IDs and AssetBundle paths, marking them as required / incremental types. Scene-triggered download responses respond to three levels of user behavior. Block-based differential updates divide 512KB blocks and verify them. Resource isolation storage creates a course ID sandbox directory, resolving the defects of full downloads, storage conflicts, and inefficient updates, thereby reducing course switching latency and doubling device storage space utilization.

[0022] AssetBundle resource package building includes: Resource files with a reference frequency of >5 times per course will be automatically merged into the same AssetBundle package; Generate an XML-formatted AssetBundle dependency index file to record cross-package reference paths; Execution to generate XML format AssetBundle dependency index files: When an update to a single resource file in the course resources is detected; By using the cross-package reference relationships recorded in the dependency index file, the directly associated AssetBundle resource bundles that need to be rebuilt can be determined. Only rebuild the directly associated AssetBundle resource bundle; Update the version identification information in the dependency index file; Resources cited more than 5 times per course are merged and packaged to generate an XML-formatted AssetBundle dependency index file. When a single file update is detected, the dependency index locates the directly related packages that need to be rebuilt and updates the version identifier. This overcomes the defect that a single file update requires a full package rebuild, reduces the scope of resource package rebuilding, and improves the reuse rate of high-frequency resources.

[0023] Scene-triggered downloads include: The course selection layer responds to course selection behavior and downloads the core course scenario package; The chapter entry layer responds to chapter entry behavior and loads the chapter-specific resource package; The experiment interaction layer responds to the click behavior of experiment buttons and asynchronously downloads the experiment toolkit; The scenario-triggered download responds to chapter entry behavior at the chapter entry layer, performs version validity checks, and automatically triggers block difference updates if the local version is outdated. After the update is completed, the resource package is loaded via AssetBundle.LoadFromFile, which solves the problem of resource loading delay when switching chapters and eliminates the defect of learning process interruption caused by the update process.

[0024] Incremental configuration file management generates a UGUI drag-and-drop interface through the Unity editor. Users drag and drop AssetBundles to the course ID configuration area, and a course configuration file containing the AssetBundle path is generated in real time. This solves the problem of high complexity in resource configuration and greatly improves the efficiency of course management.

[0025] Chunk-based differential update divides the AssetBundle resource package into 512KB blocks, uses Unity's Hash128 structure to generate block hash values, and only downloads the differential blocks identified by the server and reassembles the AssetBundle, solving the defect of 200% over-limit update traffic and reducing download time in weak network environments.

[0026] Resource isolation is achieved by storing the version in the Application.persistentDataPath / CourseID / directory. For AssetBundle files with the same content, hard links to disk are generated through the System.IO API, which eliminates the problem of version conflicts between multiple courses' AssetBundles and reduces the disk space usage of the same resources.

[0027] This invention also discloses a system for incremental downloading of course resources based on Unity AssetBundle, the system comprising: AssetBundle Builder: Calls Unity's BuildPipeline.BuildAssetBundle to generate an asset bundle with dependency indexes; Course Configurator: Generates a UGUI drag-and-drop interface, allowing users to associate resource packages with course IDs through the interface; Incremental Downloader: Performs chunked differential updates via UnityWebRequest, determining the download strategy based on the course configurator's configuration file; Sandbox Manager: Isolates AssetBundle storage paths based on course IDs, receives resource files transmitted by incremental downloaders, and stores them in isolated paths; Eliminate resource dependency black box, overcome the defects of full download, eradicate multi-course conflicts and support precise single file updates.

[0028] Example 1: The Entire Process of Course Resource Allocation When developers configure resource packages for high school physics courses, they need to establish a mapping relationship between required resource packages and incremental resource packages. 1.1 Resource Pack Topology Construction: Open the resource editing interface in the Unity editor; Call BuildPipeline.BuildAssetBundle to generate an AssetBundle resource package with version identifier; Resource files with a reference frequency of >5 times per course will be automatically merged and packaged. 1.2 Incremental Configuration File Management: The course configurator generates a UGUI drag-and-drop interface; Drag the Electromagnetism Demonstration Animation AssetBundle to the High School Physics Course ID Configuration Area; The system generates course configuration files containing AssetBundle paths in real time; 1.3 Mark resource type: Add the path to the Newton's Laws demo package to the required resource package configuration file; The system automatically marks the corresponding resource package group as MustUpdate; 1.4 Version file generation: Output the global resource version configuration file; Records the latest version information for all AssetBundle resource packages; Implement UGUI drag-and-drop configuration functionality to establish a resource foundation for scene-triggered downloads.

[0029] Example 2: Implementation of Course Switching Scenarios When a user switches from a chemistry course to a high school physics course, the system performs layered resource loading. 2.1 Course Selection Layer Response: The user clicks on the high school physics course card; Read the course configuration file and the global resource version configuration file; Compare with local resource status log files; 2.2 Required resource package processing: The Newton's Laws demo package is outdated. The incremental downloader downloads updates via UnityWebRequest; Execute the block-based difference update strategy; 2.3 Incremental resource package triggering: Display a list of downloadable incremental resources on the course details page; Users can select to download the electromagnetism animation package through UGUI interface elements; 2.4 Resource-isolated storage execution: The sandbox manager creates a version directory based on the course ID; Create hard links to the same AssetBundle; Implement a course selection layer trigger mechanism to achieve resource isolation and storage.

[0030] Example 3: Implementation of Chapter Learning Scenarios When a user enters the optics chapter of a high school physics course, the system loads exclusive resources. 3.1 Chapter Entry Layer Response: The user clicks on the entry point for the Optics chapter; The system checks the version status of the chapter-specific resource pack; 3.2 Execution of Block Difference Update: The resource pack is divided into 512KB blocks; Use the Hash128 structure to generate block hash values; Download only the difference blocks identified by the server; 3.3 Seamless resource loading: After the update is complete, call AssetBundle.LoadFromFile; Directly load chapter-specific scene resources; 3.4 Dependency Index Update: When an update to a single resource file is detected; Locate the associated packages using the AssetBundle dependency index file; Only rebuild directly associated resource packages; Achieve chapter entry layer response and precise update mechanism.

[0031] Example 4: Implementation of Experimental Operation Scenario Users click the microscope button in the virtual laboratory to trigger the download of the experimental toolkit; 4.1 Experimental Interaction Layer Response: The user clicks the microscope operation button; The system checks the local status of the incremental resource package; 4.2 Asynchronous download execution: The incremental downloader divides resource packets into 512KB blocks; Silently download the difference blocks in the background; Download progress is displayed in real time on the UGUI interface; 4.3 Real-time resource loading: The microscope model will be automatically loaded after the download is complete; Update the local resource status log file; 4.4 Storage and reuse mechanism: The sandbox manager recognizes identical AssetBundles; Generate hard links to disks using the System.IO API; Implement optimizations for experimental interaction layer response and storage.

[0032] Example 5: Full System Implementation The high school physics curriculum version has been updated; the terminal executes the complete update process. 5.1. Running the AssetBundle builder: Call BuildPipeline.BuildAssetBundle; Generate a new resource package with an XML dependency index; After the dependency index file is updated, the global version configuration file will synchronously refresh the resource package version number; 5.2 Course Configurator Update: Adjust the quantum mechanics package path in the UGUI interface; Generate an updated course configuration file; 5.3 Incremental Downloader Operation: The software detects version differences when the user starts the software. Perform chunked difference updates using UnityWebRequest; 5.4 Sandbox Manager Deployment: Create a new version catalog based on the course ID; Create hard links to unmodified resources; 5.5 Resource Loading Verification: Users can directly access the updated courses; All experimental resources loaded normally; Enables collaborative work of system components and completes a closed loop of end-to-end resource management.

[0033] It should also be noted that the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such process, method, article, or apparatus. Unless otherwise specified, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or apparatus that includes that element.

[0034] Although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art can still modify the technical solutions described in the foregoing embodiments or make equivalent substitutions for some of the technical features. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the protection scope of the present invention.

Claims

1. A method for incremental downloading of course resources based on Unity AssetBundle, characterized in that, Includes the following steps: Resource package topology construction: parse the reference dependencies between course resource files, and generate an AssetBundle resource package with version identifier through Unity's BuildPipeline.BuildAssetBundle; Incremental configuration file management: Maintain associated course IDs and AssetBundle paths and mark required / incremental type course resource configuration files, as well as global version configuration files; Scene-triggered download: In response to user selection of courses or entry into chapters, a differentiated download strategy is executed; Required resource pack; forced download when the version is outdated; Incremental resource packages provide UGUI interface elements for users to trigger downloads on demand; Block-based difference update: Download the difference blocks through the block hash verification mechanism; Resource isolation storage: Create version sandbox directories for different courses to avoid AssetBundle conflicts.

2. The incremental download method for course resources based on Unity AssetBundle according to claim 1, characterized in that, The AssetBundle resource package construction includes: Resource files with a reference frequency of >5 times per course will be automatically merged into the same AssetBundle package; Generate an XML-formatted AssetBundle dependency index file, recording cross-package reference paths.

3. The incremental download method for course resources based on Unity AssetBundle according to claim 1, characterized in that, The scenario-triggered download includes: The course selection layer responds to course selection behavior and downloads the core course scenario package; The chapter entry layer responds to chapter entry behavior and loads the chapter-specific resource package; The experiment interaction layer responds to the click behavior of the experiment button and asynchronously downloads the experiment toolkit.

4. The incremental download method for course resources based on Unity AssetBundle according to claim 1, characterized in that, The incremental configuration file management is implemented through the Unity editor: Drag and drop the AssetBundle resource package to the course ID configuration area in the UGUI interface; Generate course configuration files containing AssetBundle paths in real time.

5. The incremental download method for course resources based on Unity AssetBundle according to claim 1, characterized in that, The block difference update includes: Divide the AssetBundle resource package into 512KB blocks; Use Unity's Hash128 structure to generate block hash values; Only download the difference blocks identified by the server and reassemble the AssetBundle.

6. The incremental download method for course resources based on Unity AssetBundle according to claim 1, characterized in that, The resource isolation storage includes: Create a version directory in Application.persistentDataPath / CourseID / ; Create hard links to disk for AssetBundle files with the same content using Unity's System.IOAPI.

7. The incremental download method for course resources based on Unity AssetBundle according to claim 3, characterized in that, When executing the entry layer of the aforementioned chapter: Perform version validity checks on the resource packages specific to the aforementioned chapters; When a local version is detected to be lagging behind, a block difference update is automatically triggered. After the update is complete, load the latest resource package using AssetBundle.LoadFromFile.

8. The incremental download method for course resources based on Unity AssetBundle according to claim 2, characterized in that, The generation of XML format AssetBundles depends on the execution of the index file: When an update to a single resource file in the course resources is detected; The direct associated AssetBundle resource bundles that need to be rebuilt are determined by the cross-package reference relationships recorded in the dependency index file. Only rebuild the directly associated AssetBundle resource bundle; Update the version identifier information in the dependency index file.

9. A system for incremental downloading of course resources based on Unity AssetBundle according to any one of claims 1-8, characterized in that, The system includes: AssetBundle Builder: Calls Unity's BuildPipeline.BuildAssetBundle to generate an asset bundle with dependency indexes; Course Configurator: Generates a UGUI drag-and-drop interface, allowing users to associate resource packages with course IDs through the interface; Incremental Downloader: Performs chunked differential updates via UnityWebRequest, determining the download strategy based on the course configurator's configuration file; Sandbox Manager: Isolates AssetBundle storage paths based on course IDs, receives resource files transmitted by incremental downloaders, and stores them in isolated paths.

Images