Scene construction method, scene rendering method, device and computing equipment

Abstract

The embodiments of the present application provide a scene building method, a scene rendering method, an apparatus and a computing device, and relate to the field of computer application technology. Among them, a scene building framework is provided; the scene building framework includes at least one component; the component is used to be attached to a label to realize the corresponding scene function; based on the construction requirements of the target scene, the components and configuration parameters required to build the target scene are determined; based on the corresponding labels of the components required for the target scene and the configuration parameters, a target file is constructed; an association relationship between the target file and a page file constructed based on the page building framework is established; the page building framework is used to parse the target file into an executable file, so that the client can execute the executable file to realize the rendering and display of the target scene. The technical solution provided by the embodiments of the present application simplifies the scene building process and reduces development costs.

Description

Technical Field

[0001] The embodiments of the present application relate to the field of computer application technology, and in particular to a scene building method, a scene rendering method, an apparatus and a computing device. Background Art

[0002] In order to enrich the interface display content and improve the user experience, presenting the display content of 3D (three-dimensional) scenes in the front-end interface has become a major goal of front-end development.

[0003] In order to present a 3D scene in the interface, it is necessary to build the 3D scene in advance, that is, to write a 3D scene program file to be executed on the front end. At present, 3D scene building is usually implemented based on WebGL (Web Graphics Library). The front end installs a WebGL rendering engine, uses the WebGL native API (Application Programming Interface) to write a 3D scene program file, and executes the 3D scene program file through the front-end WebGL rendering engine, that is, the 3D scene can be rendered and displayed on the page.

[0004] However, using WebGL's native API to build 3D scene program files requires front-end developers to master relevant knowledge of WebGL, and the code writing is complex and the amount of code is large, which makes scene construction more complicated. Summary of the invention

[0005] The embodiments of the present application provide a scene construction method, a scene rendering method, an apparatus and a computing device to solve the technical problem of complex scene construction in the prior art.

[0006] In a first aspect, an embodiment of the present application provides a scene construction method, comprising:

[0007] Providing a scene building framework; wherein the scene building framework includes at least one component; the component is used to be attached to a label to realize a corresponding scene function;

[0008] Based on the requirements of the target scene, determine the components and configuration parameters required to build the target scene;

[0009] Building a target file based on the labels corresponding to the components required by the target scenario and the configuration parameters;

[0010] Establishing an association relationship between the target file and a page file constructed based on a page building framework;

[0011] The page building framework is used to parse the target file into an executable file, so that the client can execute the executable file to realize the rendering and display of the target scene.

[0012] In a second aspect, an embodiment of the present application provides a scene rendering method, comprising:

[0013] Utilizing the page building framework, parsing the target file associated with the page file to obtain an executable file; wherein the target file includes tags corresponding to the components required to build the target scene, and the tags provide configuration parameters corresponding to the target scene;

[0014] The executable file is executed, and the scene building framework is called to run the components required for the target scene to render and display the target scene.

[0015] In a third aspect, an embodiment of the present application provides a scene building device, comprising:

[0016] A component providing module is used to provide a scene building framework; wherein the scene building framework includes at least one component; the component is used to be attached to a label to realize a corresponding scene function;

[0017] A file construction module, used to determine the components and configuration parameters required to build the target scene based on the construction requirements of the target scene; and to construct the target file based on the labels corresponding to the components required by the target scene and the configuration parameters;

[0018] A relationship building module, used to establish an association relationship between the target file and a page file built based on a page building framework;

[0019] The page building framework is used to parse the target file into an executable file, so that the client can execute the executable file to realize the rendering and display of the target scene.

[0020] In a fourth aspect, an embodiment of the present application provides a scene rendering device, including:

[0021] A file compilation module is used to use the page building framework to parse the target file associated with the page file to obtain an executable file; wherein the target file includes tags corresponding to the components required to build the target scene, and the tags provide configuration parameters corresponding to the target scene;

[0022] The scene rendering module is used to execute the executable file, call the scene building framework to run the components required for the target scene, and render to obtain the target scene.

[0023] In a fifth aspect, an embodiment of the present application provides a client that integrates a page building framework and a scene building framework that relies on the page building framework;

[0024] The page building framework is used to parse the target file associated with the page file to obtain an executable file; wherein the target file includes tags corresponding to the components required to build the target scene, and the tags provide configuration parameters corresponding to the target scene;

[0025] The scene building framework is called when executing the executable file to run the components required for the target scene and realize the rendering display of the target scene.

[0026] In a sixth aspect, an embodiment of the present application provides a scene building framework, including:

[0027] Page docking device, used to establish association relationship with page files;

[0028] The rendering engine is used to provide a running environment for scene construction and load components in the component library at runtime;

[0029] A component library, wherein the component library includes at least one general component and component attributes, wherein the general component is used to be attached to a tag, and the tag provides configuration parameters corresponding to a corresponding scenario.

[0030] including a processing component and a storage component;

[0031] The storage component stores one or more computer instructions; the one or more computer instructions are used to be called and executed by the processing component;

[0032] The processing component is used to:

[0033] Providing a scene building framework; wherein the scene building framework includes at least one component; the component is used to be attached to a label to realize a corresponding scene function;

[0034] Based on the requirements of the target scene, determine the components and configuration parameters required to build the target scene;

[0035] Building a target file based on the labels corresponding to the components required by the target scenario and the configuration parameters;

[0036] Establishing an association relationship between the target file and a page file constructed based on a page building framework;

[0037] The page building framework is used to parse the target file into an executable file, so that the client can execute the executable file to realize the rendering and display of the target scene.

[0038] In an eighth aspect, an embodiment of the present application provides a computing device, including a processing component and a storage component;

[0039] The storage component stores one or more computer instructions; the one or more computer instructions are used to be called and executed by the processing component;

[0040] The processing component is used to:

[0041] Utilizing the page building framework, parsing the target file associated with the page file to obtain an executable file; wherein the target file includes tags corresponding to the components required to build the target scene, and the tags provide configuration parameters corresponding to the target scene;

[0042] The executable file is executed, and the scene building framework is called to run the components required for the target scene to render and display the target scene.

[0043] In an embodiment of the present application, a scene building framework is provided, in which at least one component can be predefined in the scene building framework, and the component can be attached to a label to realize the corresponding scene function. For the target scene that needs to be built, based on the building requirements of the target scene, the components and configuration parameters required for the target scene can be determined, so that the target file can be constructed based on the corresponding labels of the components required for the target scene and the configuration parameters; an association relationship between the target file and the page file built based on the page building framework is established; wherein the page building framework supports label parsing, so that the target file can be parsed into an executable file using the page building framework, so that the client can execute the executable file to realize the rendering display of the target scene. The embodiment of the present application simplifies the scene building process, reduces development costs and maintenance costs, reduces the amount of code, and reduces the probability of code coupling.

[0044] These and other aspects of the present application will become more clearly understood in the description of the following embodiments. BRIEF DESCRIPTION OF THE DRAWINGS

[0045] In order to more clearly illustrate the embodiments of the present application or the technical solutions in the prior art, a brief introduction will be given below to the drawings required for use in the embodiments or the description of the prior art. Obviously, the drawings described below are some embodiments of the present application. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying any creative work.

[0046] Figure 1 A flow chart of an embodiment of a scene building method provided by the present application is shown;

[0047] Figure 2a to Figure 2d Schematic diagrams of scenarios in actual applications of the embodiments of the present application are respectively shown;

[0048] Figure 3 A scene construction demonstration diagram of an embodiment of the present application in a practical application is shown;

[0049] Figure 4 A flow chart of an embodiment of a scene rendering method provided by the present application is shown;

[0050] Figure 5 A schematic diagram showing the structure of an embodiment of a scene building device provided by the present application is shown;

[0051] Figure 6 A schematic diagram showing the structure of an embodiment of a scene rendering device provided by the present application is shown;

[0052] Figure 7 A schematic diagram showing a structure of an embodiment of a scene building framework provided by the present application is shown;

[0053] Figure 8 A schematic diagram showing the structure of an embodiment of a computing device provided by the present application is shown;

[0054] Fig. 9 A structural schematic diagram of another embodiment of a computing device provided by the present application is shown. DETAILED DESCRIPTION

[0055] In order to enable those skilled in the art to better understand the solution of the present application, the technical solution in the embodiments of the present application will be clearly and completely described below in conjunction with the drawings in the embodiments of the present application.

[0056] In some of the processes described in the specification and claims of this application and the above-mentioned figures, multiple operations that appear in a specific order are included, but it should be clearly understood that these operations may not be executed in the order in which they appear in this article or executed in parallel. The serial numbers of the operations, such as 101, 102, etc., are only used to distinguish between different operations, and the serial numbers themselves do not represent any execution order. In addition, these processes may include more or fewer operations, and these operations may be executed in sequence or in parallel. It should be noted that the descriptions of "first", "second", etc. in this article are used to distinguish different messages, devices, modules, etc., do not represent the order of precedence, and do not limit the "first" and "second" to different types.

[0057] The technical solution of the embodiment of the present application is mainly used to realize the construction and rendering of the front-end 3D (three-dimensional) scene, so as to present the 3D display content on the page.

[0058] At present, 3D scene construction is usually implemented based on WebGL (Web Graphics Library). The 3D scene program file is written using the WebGL native API (Application Programming Interface), and the WebGL rendering engine is installed on the front end. The 3D scene program file is executed by the front-end WebGL rendering engine, and the 3D scene can be rendered and displayed on the page. However, using the WebGL native API to write a 3D scene program requires the front-end developer to master the relevant knowledge of WebGL, and the development cost is high. The implementation of each node in the scene and the implementation of each function require new code logic. If the scene is complex, the amount of code will increase uncontrollably, the maintenance cost is high, and the code is very easy to couple. In short, the current 3D scene construction is very complex, the process is cumbersome, and the development cost is high, the maintenance cost is high, and the code is also very easy to couple.

[0059] In order to simplify the scene building process, the inventor found through a series of studies that componentization has become a popular trend, and there are some common code logics in different scene building, such as the need to create a new rendering engine, a new scene, a new camera, etc. in different scene building, as well as some entities commonly used in different scene building, such as lights, geometric bodies, etc. If some common code logic can be extracted and componentized, the components can be directly referenced when building the scene without creating new code. And there are many page building frameworks for front-end page building at present. If it can be integrated with these page building frameworks, then there is no need for front-end developers to master a lot of knowledge. Whether the technology stack of the page building framework can be used to achieve scene building. Based on this research idea, the inventor proposed the technical solution of the present application. In the embodiment of the present application, a scene building framework is provided, and the scene building framework includes at least one component; the component is used to be attached to a label to provide a corresponding scene function; for the components and configuration parameters required for the target scene to be built, a target file is constructed based on the corresponding labels and the configuration parameters of the components required for the target scene; an association relationship between the target file and the page file built based on the page building framework is established; wherein the page building framework supports tag parsing, so that the target file can be parsed into an executable file using the page building framework to call the components required to run the target scene in the scene building framework to realize the rendering display of the target scene. In the embodiment of the present application, the code logic for realizing the scene function is componentized, so there is no need to write a large amount of code, and the scene is built using the tag syntax of the markup language, which has a simple and clear structure, so the scene building can be further simplified, and it only needs to be integrated with the page building framework that supports tag parsing, that is, the target file of the page building framework can be parsed into a file that can be executed by the client, so that the client can realize the scene rendering display by executing the executable file, and the embodiment of the present application simplifies the scene building process, reduces the development cost and maintenance cost, reduces the amount of code, and reduces the probability of code coupling.

[0060] The following will be combined with the drawings in the embodiments of the present application to clearly and completely describe the technical solutions in the embodiments of the present application. Obviously, the described embodiments are only part of the embodiments of the present application, not all of the embodiments. Based on the embodiments in the present application, all other embodiments obtained by those skilled in the art without creative work are within the scope of protection of this application.

[0061] Figure 1 A flowchart of an embodiment of a scene building method provided in an embodiment of the present application, the method may include the following steps:

[0062] 101: Provide a framework for scene building.

[0063] The scene building framework may include at least one component; the component may realize the corresponding scene function and may be attached to a tag for reference. The scene building framework may pre-define components for realizing different scene functions.

[0064] Among them, components refer to the encapsulation of data and methods, which can be reused. It is equivalent to encapsulating some codes that can be reused in scene construction. Components can provide some common configurations in the scene construction process.

[0065] Among them, as a possible implementation method, the scene building framework may include at least general components, and the general components may include rendering engines, scene components, camera components, and other components that realize essential scene functions. The rendering engine provides a rendering engine function, which is used to declare the basic configuration of the target scene, such as scene identification, scene size, etc., and render the target scene into the page, provide a running environment for scene building, and load other components at runtime; the scene component provides a scene definition function, which is used to declare a scene in the rendering engine; the camera component provides a camera function, which is used to observe the target scene formed by the construction. The camera realizes the function of the human eye, and only the part illuminated by the camera can be seen. If there is no camera, the scene picture will be a black mass, so the camera component is used to crop the scene and determine the content drawn on the screen.

[0066] In addition, the scene building framework can also include entity components, which can realize the entities that constitute the target scene. Entities can refer to objects that can be observed in the target scene. In many scenes, there are also some commonly used entities, such as lights, geometric bodies, etc. Therefore, entity components can include light components, geometric body components, head-up components, particle emitter components, prefab components, etc.

[0067] In addition, the scene building framework may also include a model component, which provides a model loading function and can introduce external models for scene building. The external model may be, for example, a point, line, surface, or other model with a specific shape. After the model is loaded through the model component, an entity in the target scene can also be formed.

[0068] In addition, the scene framework may also include auxiliary components, which are used to provide auxiliary functions for the entire scene or a node in the scene. The auxiliary components may include, for example, collision box components, material creation components, event monitoring components, shadow components, camera surround components, etc.

[0069] In addition, the scene building framework may also include base class components. The base class components have an inheritance function. When building a target scene, in addition to directly using the components provided in the scene building framework, additional components may be defined by inheriting the base class components. The newly added components may also be attached to the tags and referenced. Therefore, as another embodiment, the method may further include:

[0070] Utilize the base class components in the scene building framework and define new components according to the required scene functions.

[0071] Among them, the newly added component can directly inherit the original functions of the base class component, or add new required scene functions, or use the new required scene functions to cover the original functions of the base class component, etc.

[0072] The newly added component may be, for example, an entity component, that is, by inheriting a base class component, a new entity component required in the current target scene may be defined.

[0073] As another possible implementation, at least one component in the scene building framework may include a panoramic component. If the target scene is a panoramic scene, the component required for the target scene is the panoramic component. The target file can be constructed by attaching the panoramic component to a tag and setting the component attribute value. The nodes in the panoramic scene are pre-defined in the panoramic component, and the panoramic component can be quickly configured. The rendering and display of the panoramic scene can be achieved by simply referencing the panoramic component through a tag. The component properties of the panoramic component may include a picture link. By setting the component attribute value, that is, the specific picture link, a panoramic picture can be introduced. As shown in the following code:

[0074] <Panorama scenePicUrl="xx.jpg">

[0075] ;

[0076] Panorama indicates the component name of the panoramic component, "xx.jpg" is the image link, and scenePicUrl is the component property that needs to be set for the panoramic component. Attach the component to the tag, that is, introduce the component with the start tag "<>" and the end tag, and the component can be tagged. Among them, the panoramic image indexed by the image link can be a panoramic picture to achieve 360-degree display.

[0077] In addition, the scene building framework may also include a loading component to set the target scene to be gradually displayed during the loading process, and may also include a calibration component to set calibration content in the target scene.

[0078] The panoramic component can be used to quickly configure the target scene. The functions of the above-mentioned general components are pre-configured in the panoramic component, so there is no need to use general components or other physical components.

[0079] Of course, the scene building framework may include all components involved in the above two possible implementation methods.

[0080] Since the scene building framework of the present application needs to be used in conjunction with the page building framework, which is usually implemented in JavaScript, the code encapsulated in the component can be implemented in JavaScript.

[0081] 102: Based on the construction requirements of the target scene, determine the components and configuration parameters required to build the target scene.

[0082] Among them, the component has component attributes, and the configuration parameter may refer to the component attribute value, etc.

[0083] 103: Build a target file based on the labels corresponding to the components required by the target scenario and the configuration parameters.

[0084] Optionally, the target file may be constructed by attaching the components required for the target scenario to tags and setting the configuration parameters.

[0085] The target file is implemented using a markup language, and attaching the components required for the target scene to a tag may refer to using the markup language to introduce the components required for the target scene in the form of a tag, and the constructed target file is also a scene program file.

[0086] Based on the construction requirements of the target scene, it can be determined which components and component properties need to be referenced. The target scene can specifically refer to a 3D scene.

[0087] The markup language may be specifically JSX, which is a JavaScript syntax extension that looks like XML. It is a format that combines JavaScript and XML (Extensible Markup Language), and can be used in page building frameworks such as React.

[0088] In a markup language, an object can be introduced in the form of a tag, that is, an object is introduced using angle brackets and attached to a tag to achieve labeling. In an embodiment of the present application, a component is introduced in the form of a tag and the component is labeled to form a basic element. The basic element composed of each tag also forms a node in the target scene.

[0089] The following example is a possible code constructed in the target file:

[0090]

[0091] Among them, "FEngine" is the component name of the rendering engine, "FScene" is the component name of the scene component, and "FCamera" is the component name of the camera component; Id (identification), width (width), height (height) are the component properties of the rendering engine, "r3-demo" "400", "400" are configuration parameters, that is, component attribute values; position (position) and clearParam (color) are component attributes that need to be set for the scene component. Attach the component to the tag, that is, introduce the component with the start tag "<>" and the end tag, label the component, and form a node. The above code can be used to render and display a 400px (pixel) * 400px canvas element on the page, and the colors are 0.0, 0.4, 0.4, 1.0, which is the background color of the target scene, see Figure 2a Schematic diagram of .

[0092] 104: Establishing an association relationship between the target file and a page file constructed based on a page building framework.

[0093] Since the scene building framework needs to be integrated with the page building framework, after obtaining the target file, an association relationship can be established with the page file built based on the page building framework. Among them, the page file is used to render and form a page, which defines the interface view in the page, such as a two-dimensional view, etc., and the target file is rendered and displayed in the page, that is, a three-dimensional view.

[0094] The page building framework is used to parse the target file into an executable file, so that the client can execute the executable file to realize the rendering and display of the target scene.

[0095] That is, by establishing an association relationship, the target file can be compiled into an executable file using the page building framework, so that the client can execute it conveniently and then use the scene building framework to achieve the rendering and display of the target scene.

[0096] The page building framework may be a framework that supports parsing of tag languages ​​corresponding to tags, such as React, Vue (a progressive framework for building user interfaces), etc. As mentioned above, the markup language may be JSX, which is used in React to replace conventional JavaScript, and using JSX to write target files may be simpler and faster.

[0097] In this embodiment, by componentizing the code logic that implements the scene function, there is no need to write a large amount of code, and the scene is built using tag syntax, the structure is simple and clear, so the scene building can be further simplified. It only needs to be integrated with a page building framework that supports tag parsing, that is, the page building framework can be used to compile the target file into an executable file that can be executed by the client, so that the client can execute the executable file to realize scene rendering and display. The embodiment of the present application simplifies the scene building process, reduces development costs and maintenance costs, reduces the amount of code, and reduces the probability of code coupling.

[0098] From the above description, it can be seen that the components defined in the scene building framework may include general components, base class components, model components, entity components and auxiliary components; if only general components are introduced, only the background color of the target scene can be drawn, and no objects exist yet, so it is also necessary to add entity elements to the target scene.

[0099] Therefore, in some embodiments, the use of a markup language to introduce components required for building a target scene in the form of tags, and setting component properties based on the building requirements of the target scene may include:

[0100] Attach the common components required by the target scenario to the tag and set component attribute values;

[0101] In the tag of the general component, the corresponding tags of the base class component, the entity component or the model component required by the target scene are inserted and the component attribute values ​​are set to build the entity of the target scene.

[0102] That is, markup language can be used to introduce common components required for building the target scene in the form of tags and set component properties; in the tag of the common component, the required base class component, the required entity component or the required model component can be inserted in the form of tags and the component properties can be set accordingly to build the entity that forms the target scene.

[0103] The following code is an example of introducing model components to implement entity construction:

[0104]

[0105] Among them, "EmptyModel" is the model component, modelUrl is the component property of the model component, which is used to enter the link address of the model https: / / XXXXXXXXX, such as Figure 2b As shown in Figure 2a In the scene diagram with only background color, the entity 201 formed by model construction is introduced by model components, forming a scene diagram.

[0106] In addition, there may also be a subordinate relationship between entities in the target scene, that is, a parent-child relationship. Therefore, in some embodiments, the method may also include:

[0107] If any entity has a parent-child relationship, insert the child entity label into the label of any entity.

[0108] The arbitrary entity is the parent node, and the sub-entity formed by the inserted sub-entity tag is the child node.

[0109] The construction of entities can be realized by using base class components, entity components or model components. The base class components can be used to build empty entities. In some parent-child relationships, the parent node can be an empty entity.

[0110] Wherein, as an optional manner, if any entity has a parent-child relationship, inserting a child node label into the label of any entity includes:

[0111] If any entity has a parent-child relationship, a child entity constructed based on any base class component, any entity component or any model component is inserted in the tag of the arbitrary entity in the form of a tag.

[0112] That is, sub-entities can also be built through base class components, entity components or model components.

[0113] The following code is an example of introducing a parent-child relationship through an entity component:

[0114]

[0115] Among them, "Cube" represents a physical component used to build a cube, and "Sphere" represents a physical component used to build a sphere. According to the above example, the sphere is the child node of the cube, and the operation of the parent node cube will also affect the child node sphere. Figure 2c as well as Figure 2d In the scene diagram shown in , the cube 202 constructed according to the above code is the parent node, and the sphere 203 is the child node of the cube 202. When the cube 202 is operated, such as moving, the sphere will also perform the corresponding moving operation. It should be noted that Figure 2d The dashed lines in the figure are not entities included in the scene diagram, but are only used to illustrate that the entity sends movement.

[0116] As can be seen from the above code, the markup language itself defines the parent-child relationship, so the parent-child relationship can be easily introduced through the markup language. Inserting another tag element in a tag element indicates that the tag element and the other tag element are in a parent-child relationship. The use of markup language reduces the amount of code, and there is no need to write redundant code such as declaring the parent node first, then declaring the child node, and then pointing the child node to the parent node.

[0117] As another optional manner, if the nodes have a parent-child relationship, inserting a child node label into the label of the node may include:

[0118] If any entity has a parent-child relationship, inserting a child entity tag into the tag of the any entity includes:

[0119] If any entity has a parent-child relationship, the child entity file is defined using the markup language;

[0120] In the tag of the arbitrary entity, the sub-entity file is introduced in the form of a tag.

[0121] That is, the sub-entity file can be declared in advance, so that the sub-entity file can be directly inserted in the tag of any entity in the form of a tag.

[0122] The following code example is a predefined sub-entity file:

[0123]

[0124] This code example defines a child entity called "MyThing".

[0125] Inserting it into the tag of any entity can be done as follows:

[0126]

[0127]

[0128] Furthermore, in some embodiments, the method may further include:

[0129] Insert the corresponding label of the required auxiliary component into the label of any node to add auxiliary functions to the arbitrary node.

[0130] Auxiliary components can add auxiliary functions to any node. These auxiliary functions may include, for example, adding materials to an entity, adding collision boxes to an entity, etc. Auxiliary components are function implementation components used to add a function to the entire target scene or any entity.

[0131] In addition, when building a target scene, there will be some control requirements for the nodes in the target scene, and there may be multiple control requirements for multiple nodes. If the control logic is written separately for each node, the amount of code will increase, and code coupling problems are prone to occur. Therefore, the inventors thought of using the ECS (Entity-Controller-System) model to solve the code coupling problem.

[0132] In some embodiments, constructing a target file based on the component corresponding labels and the configuration parameters required by the target scenario may include:

[0133] Attaching components required for the target scene to tags and setting component attribute values ​​to build nodes in the target scene;

[0134] Define the controller that implements the target control function;

[0135] Add the controller to the tag of any node that needs to implement the target control function.

[0136] Among them, attaching the components required for the target scene to the tag may refer to using a markup language to introduce the components required for building the target scene in the form of a tag.

[0137] The controller is the controller in the ECS mode. The arbitrary node is the Entity in the ECS mode, and the arbitrary node is obtained by labeling any component. The labeled rendering engine is the System in the ECS mode.

[0138] Optionally, the arbitrary node may refer to the entire target scene or any entity in the target scene.

[0139] By defining a controller that implements the target control function, the controller can be added to the tag of any node to implement the target control function for the arbitrary node. Since any node is obtained by labeling components, it can be specifically added to any component tag except the rendering engine.

[0140] The controller may be added to the label of any node that needs to implement the target control function by means of component attributes.

[0141] The following code example defines a controller named "myController" that can move left and right:

[0142]

[0143] You can add this controller as a component property to any node label, such as the node label formed by labeling the model component in the example above:

[0144]

[0145] In some embodiments, establishing an association relationship between the target file and the page file built based on the page building framework may include:

[0146] The target file is embedded in a page file built based on a page building framework.

[0147] There are many ways to embed the target file in the page file, such as directly embedding it in the page file, such as embedding it in the body part of the page text. Of course, the target file can be an independent file, and the page file introduces the target file in the form of an external link, for example, the target file can be pointed to in the body part of the page file.

[0148] Since the scene building framework is used in conjunction with the page building framework, in order to more conveniently realize the scene when rendering the target scene, in some embodiments, the method may further include:

[0149] Establishing a dependency relationship between the components in the target file and the life cycle of the page building framework;

[0150] The dependency relationship is used to execute a node creation task, a node update task or a node deletion task in the target scenario in different life cycle stages of executing the page file.

[0151] The different life cycle phases include a component creation phase, a component update phase, and a component deletion phase of the page file.

[0152] Therefore, the node creation task in the target scene may be executed in the component creation phase; the node update task may be executed in the component update phase; and the node deletion task may be executed in the component deletion phase.

[0153] When the page building framework is React, the node creation task can be executed in the ComponentWillMount event in the component creation phase, including general logic, such as binding name, initializing the object's position, size, rotation angle, binding collision box, etc. Different component types have their own customized logic. For example, for the light component, the light-related characteristics will be bound at this time, and the parameters passed by the developer will be configured. The model loading component will load the model file through the modelUrl parameter, and add it to the scene after parsing;

[0154] It can be that in the ComponentDidUpdate event in the component update phase, the node update task is executed. For example, when the value of the external position variable is modified, the position update of the node in the target scene is automatically promoted.

[0155] It can be that in the ComponentWillMount event in the component deletion phase, the node deletion task is executed to uninstall a node from the target scene. For example, some fired bullets will disappear after a period of time, which will frequently trigger this logic.

[0156] In an actual application, the page building framework can be React, which is a JavaScript library for building user interfaces. React has high performance and its own code logic is relatively simple. It can be programmed using the markup language JSX instead of conventional JavaScript. Accordingly, the present application provides a scene building framework that relies on the page building framework. The scene building framework can provide a component library, which includes components that implement different scene functions. Here, the components can be some general code logic for building 3D scenes. Thus, the page building framework can be responsible for ordinary interface views in the page, such as some 2D views, buttons or input boxes in the building page, etc., and the 3D view in the page is realized through the scene building framework to build a 3D scene.

[0157] like Figure 3 In FIG. 1 , a scene construction demonstration diagram is shown. Figure 3 It can be seen that for a page 301, a common interface view 302 can be realized by a page building framework, such as React. A 3D view 303 can be realized by building a 3D scene through a scene building framework. When building a 3D scene, a markup language supported by the page building framework can be used for building, such as JSX supported by React. First, a rendering engine 304 is introduced in the form of a tag, and a scene component 305 is introduced in the form of a tag in the engine component 304 tag. A camera component 306, as well as tags such as an entity component, a model component 307 or a base class component can be inserted into the scene component tag to build entities in the target scene. Figure 3 Taking the model component 307 as an example, for the model component 307, a sub-node tag can also be inserted into the model component tag, and the sub-node tag can be formed based on the entity component 308. In addition, in the tag of any node, such as in the scene component tag or the model component tag, a controller 309 can also be added, and the definition of the controller 309 can be implemented using an auxiliary component 310 or some auxiliary functions 311.

[0158] Among them, multiple scene component tags can be introduced into a rendering engine tag to establish multiple 3D scenes. For example, in some game applications, scene images of multiple game levels can be achieved by adding multiple scene component tags in a rendering engine tag.

[0159] based on Figure 1The target file constructed can be executed on the client to achieve the rendering and display of the target scene. Figure 4 As shown, it is a flowchart of an embodiment of a scene rendering method provided by an embodiment of the present application, and the method may include the following steps:

[0160] 401: Use the page to build a framework, parse the target file associated with the page file, and obtain the executable file.

[0161] The target file includes tags corresponding to components required to build the target scene, and the tags provide configuration parameters corresponding to the target scene.

[0162] The target file is associated with a page file constructed based on the page building framework.

[0163] The construction method of this target file can be found in detail Figure 1 The illustrated embodiments will not be described in detail here.

[0164] 402: Execute the executable file, call the scene building framework to run the components required by the target scene to render and obtain the target scene.

[0165] The page can be rendered by calling the page building framework to execute the page file.

[0166] A page building framework and a scene building framework can be pre-installed in the client, so that the page building framework is called when the client executes the page file. The page building framework can be used to parse the target file associated with the page file and compile to obtain an executable file. The client can execute the executable file to call the scene building framework to provide the components required for the target scene, thereby rendering and displaying the target scene in the page.

[0167] In this embodiment, by componentizing the code logic that implements the scene function, there is no need to write a large amount of code, and the scene is built using tag syntax, the structure is simple and clear, so the scene building can be further simplified. It only needs to be integrated with a page building framework that supports tag parsing, that is, the page building framework can be used to parse the target file into an executable file that can be executed by the client, so that the client can execute the executable file to realize scene rendering and display. The embodiment of the present application simplifies the scene building process, reduces development costs and maintenance costs, reduces the amount of code, and reduces the probability of code coupling.

[0168] In some embodiments, calling the scene building framework to run the components required by the target scene to render and obtain the target scene may include:

[0169] Executing the executable file to call the scene building framework to monitor and execute the life cycle generated by the page file;

[0170] Based on the components required for the target scene provided by the scene building framework, in different life cycle stages, the scene building framework is called to execute node creation tasks, node update tasks or node deletion tasks to achieve rendering and display of the target scene.

[0171] In some embodiments, executing a node creation task, a node update task, or a node deletion task in different life cycle stages to achieve rendering and display of the target scene may include:

[0172] In the component creation phase in the page file, executing the node creation task in the target scene;

[0173] In the component update phase in the page file, executing the node update task in the target scene;

[0174] In the component deletion phase in the page file, a node deletion task in the target scene is performed.

[0175] Among them, when the page building framework is React, it can be in the ComponentWillMount event in the component creation phase to execute node creation tasks, including general logic, such as binding name, initializing the position, size, rotation angle of the object, binding collision box, etc. According to different component types, there are customized logic. For example, for the light component, the light-related characteristics will be bound at this time, and the parameters passed by the developer will be configured. The model loading component will load the model file through the modelUrl parameter, parse it and add it to the scene; it can be in the ComponentDidUpdate event in the component update phase to execute node update tasks, such as when the external position variable value is modified, it will automatically promote the position update of the node in the target scene; it can be in the ComponentWillMount event in the component deletion phase to execute node deletion tasks and uninstall a node from the target scene. For example, some fired bullets will disappear after a period of time, which will frequently trigger this logic.

[0176] In practical applications, the technical solutions of the embodiments of the present application can realize the creation of 3D scenes in different usage scenarios, such as large electronic data screens for displaying chart data, games, industrial brains for displaying factory data, and fitting effect rendering, etc.

[0177] Among them, for the use scenarios that need to display chart data, such as electronic data screens and industrial brains, you can create a new component for displaying charts through the base class component mentioned above, attach the corresponding controller through the new component, and dynamically create a 3D chart entity according to the data passed in the new component. This can be achieved by inserting the new component into the scene component tag in the form of a tag.

[0178] For the fitting effect rendering scene, you can pre-build human body components in the scene building framework or create human body entities through base class components. For use scenarios such as games, you can choose appropriate components based on the building requirements to build game scenes.

[0179] Figure 5 A schematic diagram of a structure of an embodiment of a page building device provided in an embodiment of the present application, the device may include:

[0180] The component providing module 501 is used to provide a scene building framework; wherein the scene building framework includes at least one component; the component is used to be attached to a label to realize a corresponding scene function;

[0181] The file construction module 502 is used to determine the components and configuration parameters required to build the target scene based on the construction requirements of the target scene; and to construct the target file based on the labels corresponding to the components required by the target scene and the configuration parameters;

[0182] A relationship building module 503 is used to establish an association relationship between the target file and the page file constructed based on the page building framework;

[0183] The page building framework is used to parse the target file into an executable file, so that the client can execute the executable file to realize the rendering and display of the target scene.

[0184] In some embodiments, the file construction model is specifically used to attach components required for the target scene to tags and set component attribute values ​​to build nodes in the target scene; define a controller that implements a target control function; and add the controller to the tag of any node that needs to implement the target control function.

[0185] In some embodiments, at least one component in the scene building framework may include a general component, a base class component, a model component, an entity component, and an auxiliary component;

[0186] The file construction module can be specifically used to attach the common components required for the target scene to a label and set component attribute values; in the label of the common component, insert the corresponding tags of the required base class components, required entity components or required model components and set the component attributes accordingly to build the entities that form the target scene; if any entity has a parent-child relationship, insert the child entity tag in the label of the any entity.

[0187] In addition, the file construction model is also used to insert a corresponding label of a required auxiliary component into the label of any node to add auxiliary functions to the arbitrary node.

[0188] In some embodiments, if any entity has a parent-child relationship, the file construction module inserts a child node tag into the tag of any entity, including:

[0189] If any entity has a parent-child relationship, a child entity constructed based on any base class component, any entity component or any model component is inserted in the tag of the arbitrary entity in the form of a tag.

[0190] In some embodiments, if any entity has a parent-child relationship, the file construction module inserts a child node tag into the tag of any entity, including:

[0191] If any entity has a parent-child relationship, use the markup language to define the child entity file;

[0192] In the tag of the arbitrary entity, the sub-entity file is introduced in the form of a tag.

[0193] In some embodiments, the relationship building module may be specifically used to embed the target file in a page file built based on a page building framework.

[0194] In some embodiments, the apparatus may further include:

[0195] A dependency building module, used to build a dependency relationship between the target file and the life cycle of the page building framework;

[0196] The dependency relationship is used to execute a node creation task, a node update task or a node deletion task in the target scenario in different life cycle stages of executing the page file.

[0197] In an actual application, the page building framework may be React, and the markup language may be JSX.

[0198] Figure 5 The scene building device can execute Figure 1The implementation principle and technical effect of the scene building method described in the illustrated embodiment will not be described in detail. The specific manner in which each module and unit performs operations in the scene building device in the above embodiment has been described in detail in the embodiment of the method, and will not be described in detail here.

[0199] Figure 6 A schematic diagram of a structure of an embodiment of a scene rendering device provided in an embodiment of the present application, the device can be configured as a client, the client can refer to a browser, etc., the device may include:

[0200] The file compiling module 601 is used to parse the target file associated with the page file using the page building framework to obtain an executable file; wherein the target file includes tags corresponding to the components required to build the target scene, and the tags provide configuration parameters corresponding to the target scene;

[0201] The scene rendering module 602 is used to execute the executable file, call the scene building framework to run the components required for the target scene, and render and display the target scene in the page.

[0202] In some embodiments, the scene rendering module can be specifically used to execute the executable file to call the scene building framework to listen to and execute the life cycle generated by the page file; based on the components required for the target scene provided by the scene building framework, in different life cycle stages, the scene building framework is called to execute node creation tasks, node update tasks or node deletion tasks to achieve rendering and display of the target scene.

[0203] In some embodiments, the scene rendering module executes a node creation task, a node update task or a node deletion task in different life cycle stages to achieve rendering and display of the target scene, including: executing a node creation task in the target scene in the component creation stage in the page file; executing a node update task in the target scene in the component update stage in the page file; and executing a node deletion task in the target scene in the component deletion stage in the page text.

[0204] Figure 6 The scene rendering device can execute Figure 4 The implementation principle and technical effect of the scene rendering method described in the illustrated embodiment will not be described in detail. The specific manner in which each module and unit performs operations in the scene rendering device in the above embodiment has been described in detail in the embodiment of the method, and will not be described in detail here.

[0205] In addition, the embodiment of the present application further provides a client, which integrates a page building framework and a scene building framework dependent on the page building framework;

[0206] The page building framework is used to parse the target file associated with the page file to obtain an executable file; wherein the target file includes tags corresponding to the components required to build the target scene, and the tags provide configuration parameters corresponding to the target scene;

[0207] The scene building framework is called when executing the executable text to run the components required by the target scene and realize the rendering display of the target scene.

[0208] In addition, the present application embodiment also provides a scene building framework, such as Figure 7 As described in, the scene building framework may include:

[0209] The page docking device 701 is used to establish an association relationship with a page file; the page file is formed based on the page building framework;

[0210] The rendering engine 702 is used to provide a running environment for scene construction and load components in the component library at runtime;

[0211] A component library 702, wherein the component library includes at least one general component and component attributes, wherein the general component is used to be attached to a tag, and the tag is used to provide configuration parameters of a corresponding scenario.

[0212] The rendering engine may also be stored in the component library as a general component. The configuration parameter set by the tag may specifically be a component attribute value corresponding to the component attribute.

[0213] In some embodiments, the scene building framework may also include:

[0214] A model library, wherein the model library includes at least one model;

[0215] The component library also includes a model component for introducing the model in the model library.

[0216] In some embodiments, the at least one common component may include:

[0217] A scene component, used to declare a scene in the rendering engine;

[0218] The camera component is used to clip the scene and determine what is drawn on the screen.

[0219] In some embodiments, the component library may also include entity components, auxiliary components, base class components, etc., which may be described above for details.

[0220] In one possible design, Figure 5 The scene building device of the embodiment shown can be implemented as a computing device, such as Figure 8 As shown, the computing device may include a storage component 801 and a processing component 802;

[0221] The storage component 801 stores one or more computer instructions, wherein the one or more computer instructions are called and executed by the processing component 802 .

[0222] The processing component 802 is used to:

[0223] Providing a scene building framework; wherein the scene building framework includes at least one component; the component is used to be attached to a label to realize a corresponding scene function;

[0224] Based on the requirements of the target scene, determine the components and configuration parameters required to build the target scene;

[0225] Building a target file based on the labels corresponding to the components required by the target scenario and the configuration parameters;

[0226] Establishing an association relationship between the target file and a page file constructed based on a page building framework;

[0227] The page building framework is used to parse the target file into an executable file, so that the client can execute the executable file to realize the rendering and display of the target scene.

[0228] The processing component 802 may include one or more processors to execute computer instructions to complete all or part of the steps in the above method. Of course, the processing component may also be implemented by one or more application-specific integrated circuits (ASICs), digital signal processors (DSPs), digital signal processing devices (DSPDs), programmable logic devices (PLDs), field programmable gate arrays (FPGAs), controllers, microcontrollers, microprocessors or other electronic components to perform the above method.

[0229] The storage component 801 is configured to store various types of data to support operations in the computing device. The storage component can be implemented by any type of volatile or non-volatile storage device or a combination thereof, such as static random access memory (SRAM), electrically erasable programmable read-only memory (EEPROM), erasable programmable read-only memory (EPROM), programmable read-only memory (PROM), read-only memory (ROM), magnetic memory, flash memory, magnetic disk or optical disk.

[0230] Of course, a computing device may also include other components, such as input / output interfaces, communication components, etc.

[0231] The input / output interface provides an interface between the processing component and the peripheral interface module, which may be an output device, an input device, etc.

[0232] The communication component is configured to facilitate, among other things, wired or wireless communications between the computing device and other devices.

[0233] The present application also provides a computer-readable storage medium storing a computer program, wherein the computer program can achieve the above-mentioned Figure 1 The scene building method of the illustrated embodiment.

[0234] In one possible design, Figure 6 The scene rendering device of the embodiment shown can be implemented as a computing device, such as Fig. 9 As shown, the computing device may include a storage component 901 and a processing component 902;

[0235] The storage component 901 stores one or more computer instructions, wherein the one or more computer instructions are called and executed by the processing component 902 .

[0236] The processing component 902 is used to:

[0237] Utilizing the page building framework, parsing the target file associated with the page file to obtain an executable file; wherein the target file includes tags corresponding to the components required to build the target scene, and the tags provide configuration parameters corresponding to the target scene;

[0238] The executable file is executed, and the scene building framework is called to run the components required for the target scene to render and display the target scene.

[0239] The processing component 902 may include one or more processors to execute computer instructions to complete all or part of the steps in the above method. Of course, the processing component may also be implemented by one or more application-specific integrated circuits (ASICs), digital signal processors (DSPs), digital signal processing devices (DSPDs), programmable logic devices (PLDs), field programmable gate arrays (FPGAs), controllers, microcontrollers, microprocessors or other electronic components to perform the above method.

[0240] The storage component 901 is configured to store various types of data to support operations in the computing device. The storage component can be implemented by any type of volatile or non-volatile storage device or a combination thereof, such as static random access memory (SRAM), electrically erasable programmable read-only memory (EEPROM), erasable programmable read-only memory (EPROM), programmable read-only memory (PROM), read-only memory (ROM), magnetic memory, flash memory, magnetic disk or optical disk.

[0241] Of course, a computing device may also include other components, such as input / output interfaces, communication components, etc.

[0242] The input / output interface provides an interface between the processing component and the peripheral interface module, which may be an output device, an input device, etc.

[0243] The communication component is configured to facilitate, among other things, wired or wireless communications between the computing device and other devices.

[0244] The present application also provides a computer-readable storage medium storing a computer program, wherein the computer program can achieve the above-mentioned Figure 4 The scene rendering method of the illustrated embodiment.

[0245] Those skilled in the art can clearly understand that, for the convenience and brevity of description, the specific working processes of the systems, devices and units described above can refer to the corresponding processes in the aforementioned method embodiments and will not be repeated here.

[0246] The device embodiments described above are merely illustrative, wherein the units described as separate components may or may not be physically separated, and the components displayed as units may or may not be physical units, that is, they may be located in one place, or they may be distributed on multiple network units. Some or all of the modules may be selected according to actual needs to achieve the purpose of the scheme of this embodiment. Ordinary technicians in this field can understand and implement it without paying creative labor.

[0247] Through the description of the above implementation methods, those skilled in the art can clearly understand that each implementation method can be implemented by means of software plus a necessary general hardware platform, and of course, it can also be implemented by hardware. Based on this understanding, the above technical solution is essentially or the part that contributes to the prior art can be embodied in the form of a software product, and the computer software product can be stored in a computer-readable storage medium, such as ROM / RAM, a disk, an optical disk, etc., including a number of instructions for a computer device (which can be a personal computer, a server, or a network device, etc.) to execute the methods described in each embodiment or some parts of the embodiments.

[0248] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present application, rather than to limit it. Although the present application has been described in detail with reference to the aforementioned embodiments, those skilled in the art should understand that they can still modify the technical solutions described in the aforementioned embodiments, or make equivalent replacements for some of the technical features therein. However, these modifications or replacements do not deviate the essence of the corresponding technical solutions from the spirit and scope of the technical solutions of the embodiments of the present application.

Claims

1. A scene building method, characterized in that: include: Providing a scene building framework; wherein the scene building framework includes at least one component; the component is used to be attached to a label to realize a corresponding scene function; Based on the requirements of the target scene, determine the components and configuration parameters required to build the target scene; Based on the labels corresponding to the components required by the target scenario and the configuration parameters, a target file is constructed, wherein the target file is constructed by attaching the components required by the target scenario to the labels and setting the configuration parameters; the target file is implemented using a markup language, and the components required by the target scenario are introduced in the form of labels using the markup language; the components required by the target scenario are introduced in the form of labels, and the basic elements formed constitute the nodes in the target scenario; Establishing an association relationship between the target file and a page file constructed based on a page building framework; The page building framework is used to parse the target file into an executable file, so that the client can execute the executable file to realize the rendering and display of the target scene.

2. The method according to claim 1, characterized in that The constructing of the target file based on the component corresponding labels and the configuration parameters required by the target scenario includes: Attaching components required for the target scene to tags and setting component attribute values ​​to build nodes in the target scene; Define the controller that implements the target control function; Add the controller to the tag of any node that needs to implement the target control function.

3. The method according to claim 1, characterized in that The components in the scene building framework include general components, base class components, model components, entity components and auxiliary components; The constructing of the target file based on the component corresponding labels and the configuration parameters required by the target scenario includes: Attach the common components required by the target scenario to the tag and set component attribute values; In the tag of the general component, insert the corresponding tag of the base class component, the entity component or the model component required by the target scene and set the component attribute value to build the entity of the target scene; If any entity has a parent-child relationship, the child entity tag is inserted into the tag of the arbitrary entity.

4. The method according to claim 3, characterized in that Also includes: Insert the corresponding label of the required auxiliary component into the label of any node to add auxiliary functions to the arbitrary node.

5. The method according to claim 3, characterized in that: If any entity has a parent-child relationship, inserting a child entity tag into the tag of the any entity includes: If any entity has a parent-child relationship, a child entity constructed based on any base class component, any entity component or any model component is inserted in the tag of the arbitrary entity in the form of a tag.

6. The method according to claim 3, characterized in that If any entity has a parent-child relationship, inserting a child entity tag into the tag of the any entity includes: If any entity has a parent-child relationship, use the markup language to define the child entity file; In the tag of the arbitrary entity, the sub-entity file is introduced in the form of a tag.

7. The method according to claim 1, characterized in that The establishing of the association relationship between the target file and the page file built based on the page building framework includes: The target file is embedded in a page file built based on a page building framework.

8. The method according to claim 1, characterized in that Also includes: Establishing a dependency relationship between the target file and the life cycle of the page building framework; The dependency relationship is used to execute a node creation task, a node update task or a node deletion task in the target scenario in different life cycle stages of executing the page file.

9. The method according to claim 1, characterized in that: The page building framework is React, and the tags are referenced using JSX.

10. A scene rendering method, characterized in that: include: The target file associated with the page file is parsed by using a page building framework to obtain an executable file, wherein the target file is constructed by attaching components required for a target scenario to tags and setting configuration parameters; the target file is implemented by using a markup language, and the components required for the target scenario are introduced in the form of tags using the markup language; the components required for the target scenario are introduced in the form of tags, and the formed basic elements constitute nodes in the target scenario; wherein the target file includes tags corresponding to the components required for building the target scenario, and the tags provide configuration parameters corresponding to the target scenario; The executable file is executed, and the scene building framework is called to run the components required for the target scene to render and display the target scene.

11. The method according to claim 10, characterized in that The target file is associated with a page file constructed based on the page building framework; The calling of the scene building framework to run the components required by the target scene to render and obtain the target scene includes: Execute the executable file, call the scene building framework to monitor and execute the life cycle generated by the page file; Based on the components required for the target scene provided by the scene building framework, in different life cycle stages, the scene building framework is called to execute node creation tasks, node update tasks or node deletion tasks to achieve rendering and display of the target scene.

12. The method according to claim 11, characterized in that In different life cycle stages, executing a node creation task, a node update task or a node deletion task to achieve rendering and display of the target scene includes: In the component creation phase in the page file, executing the node creation task in the target scene; In the component update phase in the page file, executing the node update task in the target scene; In the component deletion phase in the page text, a node deletion task in the target scene is performed.

13. A scene building device, characterized in that: include: A component providing module is used to provide a scene building framework; wherein the scene building framework includes at least one component; the component is used to be attached to a label to realize a corresponding scene function; A file construction module is used to determine the components and configuration parameters required for building the target scene based on the construction requirements of the target scene; construct a target file based on the corresponding tags of the components required for the target scene and the configuration parameters, wherein the target file is constructed by attaching the components required for the target scene to the tags and setting the configuration parameters; the target file is implemented using a markup language, and the components required for the target scene are introduced in the form of tags using the markup language; the components required for the target scene are introduced in the form of tags, and the basic elements formed constitute the nodes in the target scene; A relationship building module, used to establish an association relationship between the target file and a page file built based on a page building framework; The page building framework is used to parse the target file into an executable file, so that the client can execute the executable file to realize the rendering and display of the target scene.

14. A scene rendering device, characterized in that: include: A file compilation module is used to use the page building framework to parse the target file associated with the page file to obtain an executable file, wherein the target file is constructed by attaching components required for the target scene to tags and setting configuration parameters; the target file is implemented using a markup language, and the components required for the target scene are introduced in the form of tags using the markup language; the components required for the target scene are introduced in the form of tags, and the basic elements formed constitute the nodes in the target scene; wherein the target file includes tags corresponding to the components required for building the target scene, and the tags provide configuration parameters corresponding to the target scene; The scene rendering module is used to execute the executable file, call the scene building framework to run the components required for the target scene, and render to obtain the target scene.

15. A client, characterized in that: An integrated page building framework and a scene building framework that depends on the page building framework; The page building framework is used to parse the target file associated with the page file to obtain an executable file, wherein the target file is constructed by attaching components required for the target scene to tags and setting configuration parameters; the target file is implemented using a markup language, and the components required for the target scene are introduced in the form of tags using the markup language; the components required for the target scene are introduced in the form of tags, and the basic elements formed constitute the nodes in the target scene; wherein the target file includes tags corresponding to the components required for building the target scene, and the tags provide configuration parameters corresponding to the target scene; The scene building framework is called when executing the executable file to run the components required for the target scene and realize the rendering display of the target scene.

16. A scene building framework, characterized in that: include: A page docking device is used to establish an association relationship with a page file, wherein the association relationship includes an association relationship between a target file and a page file constructed based on a page building framework, wherein the target file is constructed by attaching components required for a target scene to a tag and setting configuration parameters; the target file is implemented using a markup language, and the components required for the target scene are introduced in the form of tags using the markup language; the components required for the target scene are introduced in the form of tags, and the basic elements formed constitute nodes in the target scene; The rendering engine is used to provide a running environment for scene construction and load components in the component library at runtime; A component library, wherein the component library includes at least one general component and component attributes, wherein the general component is used to be attached to a tag, and the tag provides configuration parameters corresponding to a corresponding scenario.

17. The scene building framework according to claim 16, characterized in that: Also includes: A model library, wherein the model library includes at least one model; The component library also includes a model component for introducing the model in the model library.

18. The scene building framework according to claim 16, characterized in that: The at least one common component comprises: A scene component, used to declare a scene in the rendering engine; The camera component is used to clip the scene and determine what is drawn on the screen.

19. A computing device, characterized in that including a processing component and a storage component; The storage component stores one or more computer instructions; the one or more computer instructions are used to be called and executed by the processing component; The processing component is used to: Providing a scene building framework; wherein the scene building framework includes at least one component; the component is used to be attached to a label to realize a corresponding scene function; Based on the requirements of the target scene, determine the components and configuration parameters required to build the target scene; Based on the labels corresponding to the components required by the target scenario and the configuration parameters, a target file is constructed, wherein the target file is constructed by attaching the components required by the target scenario to the labels and setting the configuration parameters; the target file is implemented using a markup language, and the components required by the target scenario are introduced in the form of labels using the markup language; the components required by the target scenario are introduced in the form of labels, and the basic elements formed constitute the nodes in the target scenario; Establishing an association relationship between the target file and a page file constructed based on a page building framework; The page building framework is used to parse the target file into an executable file, so that the client can execute the executable file to realize the rendering and display of the target scene.

20. A computing device, characterized in that including a processing component and a storage component; The storage component stores one or more computer instructions; the one or more computer instructions are used to be called and executed by the processing component; The processing component is used to: The target file associated with the page file is parsed by using a page building framework to obtain an executable file, wherein the target file is constructed by attaching components required for a target scenario to tags and setting configuration parameters; the target file is implemented by using a markup language, and the components required for the target scenario are introduced in the form of tags using the markup language; the components required for the target scenario are introduced in the form of tags, and the formed basic elements constitute nodes in the target scenario; wherein the target file includes tags corresponding to the components required for building the target scenario, and the tags provide the configuration parameters corresponding to the target scenario; The executable file is executed, and the scene building framework is called to run the components required for the target scene to render and display the target scene.

Images