Generation and display of three-dimensional objects

Abstract

To solve a problem of a conventional technology.SOLUTION: A first component of a three-dimensional object is generated for display and displayed on a display device. The first component has at least a base interface and a first interface. The first displayed component is caused to change the shape. A second component of the three-dimensional object is generated for display, and has at least a base interface. The second component is translated and oriented such that the base interface of the second component is compatible with the first interface of the first component when the second component is displayed on the display device. The second component is displayed on the display device in a state in which the first interface of the first component aligns with the base interface of the second component.SELECTED DRAWING: Figure 1

Description

Technical Field

[0001] The present disclosure relates to a method, an apparatus, and a computer program for generating a display of a three-dimensional object (3D object).

Background Art

[0002] There are many applications in which a three-dimensional object is computer-generated for display on a display device. This includes, for example, computer games, computer drawings, animation packages, and the like. Currently, the three-dimensional objects generated are usually static in the sense that they do not or cannot change or evolve over time. If it is intended for the three-dimensional object to change or evolve over time, currently it is common to pre-model each iteration of the three-dimensional object at different times. In practice, this involves generating a set of static images of the three-dimensional object at different times, which are then displayed in sequence. However, this is time-consuming because an artist or other content creator has to prepare each image individually. Alternatively, a computer can be used to procedurally model static images of the three-dimensional object at different times, but this tends to result in objects that look identical or at least unnatural. In any case, it means that potentially large amounts of data need to be stored and sent, for example, to a graphics processor for display, and then the graphics processor has to process the large amounts of data, which may not always be practical or even feasible.

Summary of the Invention

[0003] This summary is provided to introduce, in a simplified form, a selection of concepts that are further described below in the detailed description of the invention. This summary is not intended to identify key or essential features of the claimed subject matter, nor is it intended to be used to limit the scope of the claimed subject matter. The claimed subject matter is not limited to implementations that solve any or all of the disadvantages described herein.

[0004] According to a first aspect disclosed herein, there is provided a computer-implemented method for generating a display of a three-dimensional object, the method comprising: generating a first component of the three-dimensional object for display, the first component having at least a base interface and a first interface; displaying the first component on a display device; causing the first component displayed to change shape; generating a second component of the three-dimensional object for display, the second component having at least a base interface; translating and orienting the second component such that, when the second component is displayed on the display device, the base interface of the second component is compatible (fits) with the first interface of the first component; displaying the second component on the display device with the base interface of the second component compatible with the first interface of the first component.

[0005] This enables the first and second components to be seamlessly joined, resulting in a smooth appearance for the final object formed from the parts.

[0006] The base interface of the second component typically has the same shape as the first interface of the first component. Additionally, in some examples, generating the second component of a three-dimensional object for display includes setting the size of the second component such that when the second component is displayed, the base interface of the second component is the same size as the first interface of the first component. This further helps ensure that there is a seamless junction between the base interface of the second component and the first interface of the first component. The sizes of the base interface of the second component and the first interface of the first component do not have to be exactly the same, and may be the same within a tolerance such that any slight difference is not perceptible to a viewer of the display device. Factors relevant to this include, for example, the screen resolution of the display device (i.e., the image sent to the display device).

[0007] In one example, causing the first component being displayed to change shape causes the first component being displayed to change shape over time such that the three-dimensional object being displayed changes shape over time.

[0008] In one example, the method further causes the first component being displayed to change shape, and causes the second component being displayed to change shape, and includes changing the shapes of the first component and the second component is done such that the base interface of the second component continues to match the first interface of the first component.

[0009] In one example, the method includes generating a third component of a three-dimensional object for display, the third component having at least a base interface, and displaying the third component on a display device, the third component being displayed being translated and oriented as necessary such that the base interface of the third component matches the second interface of the first component or the first interface of the second component.

[0010] Additional parts may similarly be generated and displayed, and additional parts may optionally be fitted to previously displayed parts in a hierarchical manner.

[0011] In one example, each part of an object is instantiated by a graphics processor based on the same data structure.

[0012] This results in an efficient use of the graphics processor, as it reduces the amount of data that has to be processed by the graphics processor. It also reduces the amount of data that has to be sent to the graphics processor.

[0013] In one example, the data structure includes data defining the shape of a reference part, and the data structure includes difference data defining the difference in shape of the parts of the object at a number of different points in time with respect to the shape of the reference part.

[0014] This further provides for an efficient use of the graphics processor, as it further reduces the amount of data that has to be processed by the graphics processor. It also further reduces the amount of data that has to be sent to the graphics processor. The different parts of a 3D object can be generated for display based on the difference in shape from the corresponding reference part when that part is being displayed on a display device.

[0015] The reference component may be, for example, a generally mature component, and a generally mature component is the component when it is at its maximum size. In the case of an object intended to grow over time when displayed, this corresponds to when the component is in its oldest state. On the other hand, in the case of an object intended to shrink or decrease over time when displayed, this corresponds to when the component is in its youngest state. Nevertheless, generally, for example, regardless of the reference component, it is possible to mix from the oldest to the youngest or from the youngest to the oldest.

[0016] In one example, the shape of the reference component is defined by a plurality of vertices, the difference data includes translational data for each vertex, and the translational data for each vertex represents the difference in position of the vertices of each component of the object at different times with respect to the position of the vertices of the reference component.

[0017] The translational data may be sent to the graphics processor as a texture together with the data defining the shape of the reference component.

[0018] According to a second aspect disclosed herein, a computer-implemented method for generating a time-varying asset on a computer display is provided, the method comprising accessing a set of rules stored in an electronic memory device, the rules defining at least a base asset, accessing, and evaluating the rules to generate a set of hierarchical commands, and Evaluating hierarchical commands to build assets for presentation, where the hierarchical commands include at least an asset command that defines an asset type and a utility command, the utility command is at least one of a rotation command and an age constraint, the asset type is associated with transformation data, and the result of the evaluation is a number of slices over time of assets hierarchically arranged in time, the evaluating, Visualizing assets for presentation by generating successive slices of the assets over time for presentation and presenting the assets on a computer display, where each slice has transformation data for transforming the slice according to its age and any age constraints applied by an age constraint utility command, the visualizing,

[0019] In one example, the basic asset is in the form of a mesh designed manually.

[0020] In one example, at least one of accessing, evaluating, and visualizing is computed at runtime to render the assets on a computer display in a time-varying manner.

[0021] In one example, the rules are represented as a linear structure of data symbols that define the assets.

[0022] In one example, the rules are evaluated according to a parallel rewriting system.

[0023] In one example, the conversion data includes, for each branch point on the 4D position offset and the asset, a quaternion for aligning the next asset, and the fourth component of the 4D position offset offsets the age of each asset relative to the adjacent asset.

[0024] In one example, the utility command is one or more of gravity, custom force, random force, clockwise yaw rotation, counterclockwise yaw rotation, end branch, and branch aging prevention.

[0025] In one example, the method includes setting an age for a material that manages conversion data via uniform parameters such that a shader can sample relative deformation data from a texture and, correspondingly, relocate vertices of a mesh.

[0026] According to a third aspect disclosed herein, a computer system is provided, the computer system comprising at least one processor, and at least one memory including computer program instructions, wherein the at least one memory and the computer program instructions are configured to cause the computer system, using the at least one processor, to execute a method of generating a display of a three-dimensional object, the method comprising generating, for display, a first part of the three-dimensional object, the first part having at least a base interface and a first interface; displaying the first part on a display device; changing the shape of the first part being displayed; generating, for display, a second part of the three-dimensional object, the second part having at least a base interface; When the second component is displayed on the display device, translating and orienting the second component so that the base interface of the second component is compatible with the first interface of the first component, displaying the second component on the display device with the base interface of the second component being compatible with the first interface of the first component.

[0027] According to a fourth aspect disclosed herein, a computer system is provided, the computer system comprising: at least one processor; at least one memory including computer program instructions, the at least one memory and the computer program instructions being configured to cause the at least one processor to execute a method of generating a time-varying asset on a computer display, the method comprising: (a) accessing a set of rules stored in an electronic storage device, the rules defining at least a basic asset, and evaluating the rules to generate a set of hierarchical commands; (b) evaluating the hierarchical commands to construct an asset for display, the hierarchical commands including at least an asset command defining an asset type and a utility command, the utility command being at least one of a rotation command and an age constraint, the asset type being associated with conversion data, and the result of the evaluating being a number of slices over time of the asset hierarchically arranged in time; (c) visualizing the asset for display by generating successive slices of the asset over time for display and presenting the asset on a computer display, each slice having conversion data for transforming the slice according to its age and any age constraints applied by the age constraint utility command.

[0028] According to a fifth aspect disclosed herein, there is provided a computer program including a set of computer-readable instructions that, when executed by a computer system, cause the computer system to execute a method for generating a display of a three-dimensional object. The method includes: generating a first part of the three-dimensional object for display, the first part having at least a base interface and a first interface; displaying the first part on a display device; causing the first part being displayed to change shape; generating a second part of the three-dimensional object for display, the second part having at least a base interface; when the second part is displayed on the display device, translating and orienting the second part so that the base interface of the second part conforms to the first interface of the first part; displaying the second part on the display device with the base interface of the second part conforming to the first interface of the first part.

[0029] As described above, a non-transitory computer-readable storage medium storing the computer program may be provided.

[0030] According to a sixth aspect disclosed herein, there is provided a computer program including a set of computer-readable instructions that, when executed by a computer system, cause the computer system to generate a time-varying asset on a computer display. The method includes: (a) accessing a set of rules stored in an electronic storage device, the rules defining at least a basic asset, and evaluating the rules to generate a set of hierarchical commands; (b) Evaluating hierarchical commands to construct an asset for display, the hierarchical commands including at least an asset command that defines an asset type and a utility command, the utility command being at least one of a rotation command and an age constraint, the asset type being associated with conversion data, and the result of the evaluation being a number of slices over time of the hierarchically arranged assets in time, the evaluating, (c) Visualizing the asset for display by generating sequential slices of the asset over time and presenting the asset on a computer display, each slice having conversion data for transforming the slice according to its age and any age constraints applied by the age constraint utility command, the visualizing,

[0031] A non-transitory computer-readable storage medium storing a computer program as described above may be provided.

[0032] For the purpose of assisting in the understanding of the present disclosure and showing how embodiments may be implemented, the accompanying drawings are provided as an example.

Brief Description of the Drawings

[0033]

Fig. 1

[0034]

Fig. 2

[0035]

Fig. 3

[0036]

Fig. 4

[0037]

Fig. 5

[0038]

Fig. 6A

Fig. 6B

Fig. 6C

Fig. 6D

[0039]

Fig. 7A

Fig. 7B

Mode for Carrying Out the Invention

[0040] In this disclosure, the term "procedurally create" or equivalent terms can be understood to mean automatically creating without user interaction (user interaction). The term "styled" can be understood to mean defining a certain style using a set of rules. For example, in the case of trees, different styles may correspond to different species of trees, such as willow trees or oak trees. As another example, in the case of caves or tunnel systems, different styles may correspond to different basic types of caves or tunnels, such as gold mines, glacier caves, solution caves, etc. The terms "hierarchical" or "tree-like structure" or equivalent expressions can be understood to indicate iterative or fractal types of geometric shapes, including but not limited to trees, cave networks, or lightning bolts. Handmade mesh assets (mesh materials) or parts are references to custom geometric shapes created by artists or other content creators that would otherwise not be created procedurally. This may be, for example, part of a treehouse or more complex tree parts.

[0041] This disclosure describes an example of a method for generating objects for display on a display device that can create other structures from any arbitrary mesh without being subject to the limitations of conventional L-systems (developed in 1968 by Aristid Lindenmayer and further discussed below), including in particular 4D hierarchical or tree structures. The problem solved by this method is that it is a difficult task to use custom-made geometric shape partitions and to ensure that the mesh partitions fit together without any holes or gaps as intended. For example, when creating a tree, it is relatively easy to ensure that procedurally created tubes fit together (see the discussion of L-systems developed by Aristid Lindenmayer below). However, if it is necessary to create more complex objects, such as a tree, a cave system, or other complex objects with additional elements of time, such as branches growing from the trunk of a tree, a cave system, or lighting effects that develop over time, it is not easy to create this complex shape procedurally and then use it to create a hierarchical or tree or branching structure without holes or seams. In one embodiment, the method procedurally creates a styled tree structure or other hierarchical structure from handcrafted mesh assets or parts. The goal is to enable custom geometric shapes to be utilized in a simpler, procedurally generated structure method so that they can be realistically rendered without obvious discontinuities as they change over time.

[0042] The exemplary method can be considered to be divided into three distinct operations that can be calculated at runtime, although the method is not restricted to operating at runtime and may be made to operate "offline" beforehand. These three distinct operations may be summarized or characterized as 1) generation of a structure, 2) creation of entities that conform to the structure, and 3) updating the entities when required.

[0043] The generation of a unique structure in one example takes the form of two distinct steps, namely, evaluating a series of rules to generate a series of commands, and evaluating those commands to construct the assets or parts that make up the final object.

[0044] In the first step of evaluating the rules, any hierarchical object can be generalized to a style. For example, a silver-white tree can be defined as tall, slender, and having thin branches, and a particular cave system can be defined as a particular type of cave, such as a gold mine, a glacier cave, a solution cave, etc. Other styles may be provided for other types of trees, or other objects or structures that are not trees. This style can be represented, for example, by a linear structure of data tokens (which may be multi-dimensional) that represent utility commands and parts of the object. The rules are evaluated using a parallel rewrite system with many levels. This generates a new data structure that defines a hierarchy of commands. This parallel rewrite system is an adaptation of the Lindenmayer's L-system and is adapted for use in this method but uses similar principles.

[0045] In this regard, the conventional L-system developed in 1968 by Aristid Lindenmayer is a parallel rewriting system developed to model the growth process in plant development. They are adapted to computer graphics to generate the skeletons of trees, after which other procedural systems can automatically create tubes along the skeletons. Using these methods, trees with a seemingly random but natural appearance can be procedurally created. However, this system is limited by the fact that it can only use descriptions of tubes. When creating objects that are graphically drawn within a computer device, it is relatively easy to ensure that procedural tubes fit together. However, extending the L-system for the generation of other geometric shapes is not a trivial problem, and it limits the types of graphic shapes that can be drawn. It is particularly difficult when considering the need to model objects at different times.

[0046] 2) The next step of evaluating those commands is to take the hierarchy of commands and process them to create the final asset(s) or part(s) of the object. In this example, there are two types of commands, namely, asset type and utility type. In this example, the asset type is a reference to a 4D mesh. This reference is used by a shader, particularly a vertex shader, (typically in a hardware processor such as a graphics processing unit or GPU, or in processing software or the equivalent) and also involves related materials for shading the object and transformation data. In one example, the transformation data includes a 4D position offset, a quaternion for aligning the next part of the object, and other data for each branching point on the asset or part of the object.

[0047] In one example, the utility type is one of the instructions of gravity, custom force, random rotation, clockwise yaw rotation, counterclockwise yaw rotation, end branching, and branching aging prevention. Other examples include, for example, phototropism in which a plant grows towards a light source, wind direction in which a part is forced to bend with the wind, and the like. These instructions modify the component rotation about the previous branching direction or apply constraints to the fourth (time) dimension. In each command, if necessary, the assets or components of the object are created and transformed accordingly. After the system processes all the commands, a number of assets or components of the object organized in a four-dimensional hierarchical structure are obtained.

[0048] The creation of entities compliant with the second operation 2) configuration involves generating parts and assets that are joined together to form a display object. This includes visualizing slices of the final object over time. For the third operation 3) 3) updating the entity as needed, in one example, while creating the individual assets or components of the object, materials are created and assigned to process the visuals over time. These materials sample texture inputs encoded with transform data. This data can deform the mesh and thus represent the object through its fourth dimension (time). When using this system to create a growing tree or other structure that changes shape, this data deforms all the vertices of the mesh from its final cylindrical state to a thin cylinder (cylinder), then to a conical shape, and finally to a small seed where all the vertices overlap and bend.

[0049] By setting the age of the material using uniform parameters, the vertex shader of the graphics processor or processing software samples relative deformation data from the texture and relocates the vertices accordingly. The material of each component is assigned an offset in a fourth dimension, here time. This offsets (cancels out) the individual ages or local times of each component and provides a seamless join between components so that the appearance of the final object formed from the components is simply a single smooth mesh. Here, by setting a constant age or time across the entire final object and adding these local offsets in the fourth (time) dimension, the result is a single consistent final object.

[0050] Here, a specific example of the present disclosure is provided. This example is provided with respect to generating a display of a three-dimensional object that changes shape, particularly as time elapses in the context of a computer game. In this example, the generation of the display of the three-dimensional object is performed at runtime, i.e., when the computer game is running. However, the present disclosure may be used to generate in advance (i.e., not at runtime) a display of a three-dimensional object that changes shape as time elapses. The present disclosure may be used in other applications, such as, for example, a computer graphics software package.

[0051] The specific example described herein has two main stages. In the first stage, content and related data are generated. In the second stage, a three-dimensional object is generated for display on a display device, and the shape of the three-dimensional object to be displayed is changed as time elapses.

[0052] The specific examples described in this specification are given with respect to the three-dimensional object being a tree. The tree can change its shape, which may be used, for example, to represent a tree growing over time. However, the principles described in this specification may be applied to other three-dimensional objects that change shape or appearance over time or have different shapes or appearances from the start. This includes, for example, other vegetation such as shrubs and plants, leaves, flowers, fruits, etc. Other three-dimensional objects that may be represented include a treehouse or other building or structure, a cave or tunnel system, a lightning bolt, a robotic or other animated character, a tentacle of a living being, a river, an electric wire, etc. In other examples, the three-dimensional object may be inside some space, such as inside a building or a cave network. In other examples, the three-dimensional object may be a representation of a color or shading effect having an appearance that moves over or through specific objects within a scene that is displayed in a pattern such as a diffusing light or darkness trend. In addition to or instead of a shape or appearance that changes over time, for example, to represent a growing tree, leaves that weather over time, leaves that move from a mature green state to a withered yellow or red autumn state, or an object that is damaged or eroded over time, etc., the techniques described in this specification can be used to give a three-dimensional object or a part of a three-dimensional object different appearances computationally efficiently, from the start across the object and / or between parts.

[0053] In any case, since the three-dimensional object changes over time or due to some other parameter, this may be considered a four-dimensional model.

[0054] As a first operation in the first stage content creation phase, at least two parts of an object are created. These may be drawn by a human using a computer, for example, in a manner known per se. The two parts represent snapshots of a portion of the object at different times. In some examples, more than two parts of the object may be created. A larger number of parts created at this stage results in a more fluid or seamless representation of the object that changes over time. On the other hand, a smaller number of parts created at this stage requires less time at this stage and also requires lower data storage capacity and lower processing capacity when a three-dimensional object is being generated for display.

[0055] One example of this is illustrated schematically in FIG. 1. This shows 11 parts 10, and in this specific example, the parts 10 represent cross-sections or portions of a tree at 11 different points in time. In other examples, when modeling other objects or structures, such parts represent portions of other objects or structures at different points in time. In still other examples, the parts may represent parts of a three-dimensional object having different appearances across the object. One of these parts 10 is then used as a reference part when a three-dimensional object is being generated for display. In this example, the reference part is a fully mature part, which is the part when it is at its maximum size. In the case of an object intended to grow over time when displayed, this corresponds to the part 10' that is in the rightmost part of FIG. 1 (also shown in the topmost part of FIG. 1) when the part is in its oldest state. In the case of an object intended to shrink or decrease over time when displayed, this corresponds to the part when it is in its youngest state. In other examples, different intermediate parts 10 may be used as the reference part.

[0056] As is known in computer modeling itself, each component 10 is defined by a number of vertices 12. In the example of FIG. 1, as time progresses from one component 10 to another, the vertices 12 move away from each other, which represents a component that grows over time. The movement of the vertices 12 relative to each other defines how the shape of the component 10 develops over time and can be used to control the changing shape of a three-dimensional object, as will be discussed further below. In the leftmost (youngest) component 10 of FIG. 1, it may be noted that all of the vertices 12 are collapsed to a single point, as indicated by the dots in the figure. Additionally, an artist or other content creator may "by hand" create two components, such as the youngest and oldest components, and then use an automated computer process to generate any number of desired intermediate components.

[0057] In principle, different components 10 can be effectively used in this format for the generation of three-dimensional objects for display. However, when depicting a large number of objects, such as trees or other objects or structures, this places high demands on the graphics processor or equivalent that is generating the display and may not be executable on many graphics processors and / or may result in a jerky and non-smooth appearance of growth.

[0058] A more efficient way to process this is to identify and record the shape differences of each part 10 with respect to the reference part 10', and send the data regarding those differences to a graphics processor. In one example, for each of the created parts 10, the (apparent) movement of each vertex 12 of the part with respect to the corresponding vertex 12 in the reference part 10' is identified. Referring to FIG. 2 as an example, this shows the reference part 10' on the left side and one of the other parts 10 (in this example, the first part 10 following the leftmost (youngest) part 10 of FIG. 1 where all vertices 12 are folded into a single point) on the right side. FIG. 2 shows a specific vertex 14' of the reference part 10' and the corresponding vertex 14 of the other part 10.

[0059] For clarity, FIG. 3 shows a specific vertex 14' of the reference part 10' and the corresponding vertex 14 of the other part 10, with the other vertices 12 omitted. FIG. 3 shows that a specific vertex 14' of the reference part 10' effectively moves along a vector or "delta" Δ 1 to the corresponding vertex 14 of the other part 10. Delta Δ1 has x, y, and z components. In the illustrated example, as shown in FIG. 3, a left-handed coordinate system where the z component points upward is used. For reasons that will become apparent, the x, y, z components of delta Δ 1 may be represented as the RGB values of a color. That is, delta Δ 1 may be represented as a colored pixel p 1 It may be noted that pixel information is often conventionally stored with 8-bit precision, and thus 256 unique values per channel. In this example, 8-bit precision may be used. However, in this example, 32-bit precision is used to better maintain the range and accuracy of the data.

[0060] This identification of the relative movement of vertex 12 between the reference part 10' and the other part 10 is repeated for all of vertex 12. This results in one delta Δ n for each vertex 12, one by one. Correspondingly, this results in the corresponding number of colored pixels p n Next, the colored pixel p nmay be arranged (at least conceptually) in rows. This is schematically shown in FIG. 4 for the case where each component 10 has 50 vertices, and thus there are 50 deltas Δ, and thus 50 colored pixels p. In FIGS. 4 and 5, the individual “colors” of the pixels p vary from case to case and are typically different unique values for each pixel, but for illustrative purposes, the shading shown in Table 1 below is used to schematically represent the colors in this particular example.

Table 0001

[0061] This process is performed for each of the other components 10. This results in a set of a large number of deltas, which may be represented as rows of colored pixels. This is schematically illustrated in FIG. 5 for the case where there are a total of 11 components 10. FIG. 5 shows that the deltas for each vertex for each component 10 may be represented as a two-dimensional matrix of pixels p nt where n is the number of vertices 12 (here 50) and t is the number of time instants corresponding to the total number of components 10 (here 11). It may be noted that the first topmost row is blank. This is because it represents the reference component 10’.

[0062] This result is the reference component 10’ defined by the x, y, z locations of its vertices 12 and a set of a large number of differences or deltas Δ n one for each of the other components 10, where each set of differences is used to define the relative movement of the vertices 12 that represents (in this example) the compartments or parts of the tree at different points in time taken together. In this example, the deltas Δ nThe set is represented as a texture. In other words, at the end of this initial creation phase, there is a 3D mesh, which may be considered to be the reference part 10' and a texture that is a data structure used to define the relative movement of the reference part 10' or the vertices 12 within the mesh. Together, these are used to continue to generate a 3D object for display and to vary the shape of the generated 3D object over time, as will be discussed further below.

[0063] As a next step, at least one interface is defined for each of the parts 10. The interface 10 is used during the generation of the 3D object for display to enable the different parts 10 to be joined within the object being displayed. This joining of the different parts 10 needs to present a smooth or seamless join that is not visible to the user. This use of the different parts 10 joined within the image being displayed provides an efficient way to enable the 3D object being displayed to vary its shape over time. In this example, this enables a tree to appear to grow over time by growing larger and optionally adding new branches, twigs, etc. In an example where the 3D object is a cave or tunnel system, this can be used, for example, to show a cave or other structure that grows over time. This growth may be "organic" in the sense that, like a tree, a cave or other structure grows larger over time. This can be used, for example, to illustrate that a cave or tunnel system gets deeper as they are dug or new tunnels are formed, etc.

[0064] During the display of the three-dimensional object, reference is made to FIGS. 6A-6D to illustrate how this actually works. This example is a simple example for illustrative purposes, and each part is a part of a tree trunk or a thin branch.

[0065] First, during the display of a 3D object, a part is displayed or "spawned". This first part has its local time set to zero, and thus, since this represents the earliest time in the sequence, the first part is, in effect, the point 60 as shown in FIG. 6A 0 which is the case.

[0066] Next, the first part is effectively grown larger. This is achieved by incrementing the local time of the part by one unit of time, i.e., by setting the local time for the part to 1 at this point. (Examples of how the growth of individual parts is achieved are discussed further below). As shown in FIG. 6B, this causes the first part to grow longer and thicker into, in this example, an elongated stick-like part 60 1 In addition, a second new part is spawned. At this stage, the local time of the second part is set to zero, and thus, the second part is, in effect, the point 62 as shown in FIG. 6B 0 which is the case.

[0067] Next, the local time for each part is incremented by 1. As shown in FIG. 6C, the first part has grown longer and thicker as indicated by 60 2 and the second part has likewise grown longer and thicker as indicated by 62 1 In addition, a third new part is spawned with its local time set to zero, and thus, the third part is, in effect, the point 64 0 which is the case. This can be repeated as shown in FIG. 6D, which shows that the sizes of the first through third parts have grown as indicated by reference numerals 60 3 62 2 64 1 respectively, and that a new part 66 0 with its local time set to zero has been added.

[0068] In this example, it should be noted that basically the same component 60 is effectively used three times. However, the components 60 are different. This is because, at least, they represent different slices of time, i.e., they are offset by different amounts in time such that they have different local time offsets. (Generally, the components 60 are also translated to be located at different positions and rotated, so they are different). At this point, in this example, it may be noted that the "time" for the entire object formed from the individual components 60, 62, 64 is 3 unit times, while the local times for the individual components 60, 62, 64 are 3, 2, and 1 respectively.

[0069] This illustrates how each new component joins with the components that were previously displayed on the display device. An important aspect enabling smooth joining of components is the interface where the components join with each other. For this purpose, when a new component is displayed, each interface on the new component and the component to which it is joined are positioned and oriented relative to each other within the space so as to provide a smooth and substantially seamless join. For this purpose, transformation information or data having two main components, namely a translational offset and an orientation offset, is provided for each interface. The translational offset moves the new component within the local space in the image displayed relative to the previous component to which it is connected. The orientation offset rotates the new component relative to the previous component. Collectively, this enables the new component to be in the correct position and orientation relative to the previous component, regardless of the actual shape of each component. This is because the interfaces of each component are correctly positioned and oriented relative to each other. Moreover, in order to obtain a "seamless" join and to facilitate a smooth transition between components when growing or changing shape in some other way, the interfaces of the connected components are arranged to be the same size as each other in some instances. However, in other instances, the interfaces of each connected component may be of different sizes, depending, for example, on the desired effect or appearance. For example, it may be desirable to add a component that intersects a previous component. As a specific example in the case of a tree, this enables, for example, fruits or leaves to be added to branches and the like. The size of the interface in the overall mature state may be defined as part of the interface. In one example, the transformation data also includes the normal, tangent, and binormal of the interface, which may be used later in the runtime system to apply gravity and / or other forces or effects.

[0070] Referring to FIG. 7A, which further discusses the interface and shows an example of component 70, each component has at least a base interface 72. The base interface 72 is more clearly shown in FIG. 7B. The base interface 72 is an n-sided polygon. The polygon may generally be an irregular polygon, but in some examples, the polygon may be a regular polygon that can facilitate the orientation of the components for connection. The center O of the polygon is the origin of the base interface 72. Moreover, the base interface 72 may be symmetric and generally may have an order of symmetry that is the same as or different from the number n of sides of the polygon. The normal to the base interface 72 (Outer 0001) TIFF0007687786000002.tif12119 points upward along the z-axis. The tangent to the base interface 72 (Outer 0002) TIFF0007687786000003.tif11119 (i.e., the vector that is the tangent to the surface of the base interface 72) originates from the origin O and is directed directly along the x-axis. The tangent (Outer 0003) TIFF0007687786000004.tif12119 passes through one of the vertices 74 on the boundary of the base interface 72 in this example.

[0071] In this example, component 70 is not a terminal portion and thus, in addition to the base interface 72, has another interface, a first interface, or a primary interface 76. In this example, the primary interface 76 is a polygon, and the polygon may also generally be an irregular polygon but may be a regular polygon. The primary interface 76 includes a translational offset and an orientation offset. This orientation is calculated as follows. The normal (Outer 0004) TIFF0007687786000005.tif10119 and the tangent (Outer 0005) TIFF0007687786000006.tif10119 are derived for the primary interface 76. With respect to the base interface 72, the tangent (Outer 0006) TIFF0007687786000007.tif10119 is derived from the center of the primary interface 76 and points to one of the vertices of the primary interface 76. Next, quaternion rotations are respectively from [0,0,1] to (Outer 0007) TIFF0007687786000008.tif10119 and from [1,0,0] to (Outer 0008) TIFF0007687786000009.tif12119 are compiled from two combined rotations. (As is known in itself, quaternions provide a mathematical notation for representing the orientation and / or rotation of an object in three dimensions). For this primary interface 76, the quaternion can now orient the normal of the next part with respect to the base interface of the next part using its own normal, and can also rotate the next part around its normal so that the tangents are aligned in one calculation. That is, this enables the mating interfaces of adjacent parts to be correctly positioned and oriented with respect to each other.

[0072] In this example, the part 70 has a further interface 78 or secondary interface 78. This enables a further part to be joined to the first part. In this case, as can be seen from the drawing, the secondary interface 78 faces away from the body or trunk of the part 70, which enables a further part to be added, for example, to represent a branch of a tree. However, the further part added may represent other items, such as a house on a modeled tree or components of other objects. Further interfaces may be provided on the part 70. Each interface is defined by a quaternion in the same way as the primary interface 76.

[0073] The use of polygons for the interfaces 72, 76, 78 has the advantage of effectively restricting the rotations that the next part can perform, which means that the rotation of the next part is more predictable and the next part can be more easily aligned with the previous part 70.

[0074] As a final phase of the first stage of generating content and related data, rules are created or defined and then they are used in a visualization stage to determine the parts of an object and thus typically the appearance or "style" of the whole object. In this example, the style represents different species or types of trees. In other examples, the style can represent different types of other objects or structures to be displayed, such as different types of lightning, lighting effects, cave networks, building structures, etc. Rules are typically generated "by hand" by an artist or other content creator. The use of rules when a 3D object is generated for display on a display device is further discussed below. However, briefly, when applied in this example, the application of the rules results in a set or array of symbols which are then interpreted as commands and the commands are then evaluated to generate instructions that are subsequently used to generate the object for display, as further discussed below.

[0075] A style defines a set of characteristics of the object to be displayed. Each style has an "axiom" and a series of rules. To help understand styles, axioms, rules, and what is created at this stage, an overview of a parallel rewrite system is given. As mentioned above, the parallel rewrite system used in the examples of this specification and discussed in more detail below may be considered an application of Lindenmayer's L-system and uses similar principles that have been specifically adapted for use in this method.

[0076] An L-system is an iterative parallel rewrite system that uses a series of rules and an axiom. To illustrate this, a discussion of the L-system is given. The symbols and other representations discussed in this specification are given to provide an exemplary example of this technique. In practice, the detailed implementation may be somewhat different when executed on a computer, but the basic concept is the same.

[0077] As a simple example, the axiom may be B, and there are the following rules.

Number

[0078] During the operation of the parallel rewriting system, first, a container for the symbols created when the rules are applied is created. The axiom (B in this exemplary example) is inserted into the container. The parallel rewriting system is an iterative process, and thus, subsequent steps are executed repeatedly. With each iteration, the symbol(s) in the container are inspected, and any symbol present is replaced according to the rules.

[0079] Therefore, in this exemplary example of the parallel rewriting system, initially the symbol in the container is B, so this is replaced by F, A according to the second rule. Here, the first rule stipulates replacing A with B, and in addition, there is no rule for F, so it remains unchanged. This means that in the next iteration, F, A is replaced by f, B. Repeating in the same way, in the next interaction, F remains unchanged and B is replaced by F, A. Thus, the symbols in the container are now F, F, A. This continues for a specific number of iterations and can be summarized by Table 2 below (for 5 iterations).

Table 0002

[0080] The adaptation of a known L-system for parallel rewriting as used in this example is discussed in more detail below, but briefly, after a number of iterations, it is assumed that the resulting symbols are F, F, F, F, F, F, F, F, F, F, F, A. During the generation of objects for display, the symbol F is interpreted as a "part" or "asset" command, whereas the symbol A is not recognized as a command and is simply ignored. Thus, this particular array of symbols causes the objects to be constructed for a display consisting of 11 parts stacked on top of each other. (Compare with the example shown in FIG. 6D having four parts). Further, as discussed above, the use of interfaces on the parts, as well as the translation and orientation of the interfaces of the parts, allows the connections or junctions between the various parts to appear smooth and seamless.

[0081] As is known, L-systems can handle branching structures so as to be able to generate images of trees or plants having branches or twigs, etc. Correspondingly, the above example is a simple example using a one-dimensional set or array of symbols, which can actually be easily extended to a two-dimensional array of symbols so as to adapt to branching or other more complex or more refined structures, for example, for trees or for other objects or structures being modeled.

[0082] As described above, since the rules are typically created or defined "by hand" by an artist or content creator, the final objects can have the desired style, i.e., the desired appearance that can be different for different objects having the same style nevertheless. In the example of trees, this means that, for example, a number of the same type of trees (e.g., oak or willow, etc.) each having a different appearance can be generated. As another example, in the case of caves, for example, different appearances may be used to represent different types of caves, such as gold mines, glacier caves, solution caves, etc.

[0083] The application of the rules results in a set or array of symbols that are, when an object is being generated for display, ultimately evaluated to generate instructions for subsequent use and thus interpreted as commands. There are two main types of commands, namely, component or asset commands, and utility commands.

[0084] In the above exemplary example, the component command was symbolized as F. This is used, as described above and further discussed below, to construct the component at its current position in the component hierarchy.

[0085] Utility commands act as structure modifiers, i.e., they modify some part of the object that is being generated for display. When an object is being generated for display, the utility commands are interpreted as instructions to apply some predefined function at the current point in the hierarchy. Again, this is further discussed below.

[0086] Some examples of utility commands are summarized in Table 3 below, it being understood that these may be extended for other uses.

Table 0003

[0087] Some of the utility commands allow for an application with a specified "weighting". In each of these examples herein, the utility command that allows for weighting is a command that rotates a part of an object relative to a previous part. As a specific example, when a branch extends away from the trunk of a tree, gravity may be applied so that the tree branch hangs downward, and the amount or degree of the hanging may be determined by the applied weighting. The weighting may be specified in a rule, for example, at #(0.5) for a parameter, for example, a 50% weighting of a custom force. If no weighting is specified, a default value (initial setting value) of 1 may be assumed.

[0088] Complex styles can be created and corresponding complex objects can be brought about using various types of symbols that can be generated by rules and that are interpreted as commands when an object is being generated for display. This facilitates the subsequent procedural generation of objects that can nevertheless have very different appearances from one another. Without touching on the details of the meaning of the rules and axioms of this example in order to illustrate the possible complexity of the styles that can be created, the style may have a set of rules such as the following,

Number

Number

[0089] Following this first preliminary or setup stage, a three-dimensional object is generated for display on a display device, and the shape of the three-dimensional object to be displayed is changed over time in a second stage. This second stage is executed by a computing device operating according to instructions in a computer program. As described above, this may be executed at runtime, for example, when a computer game is running on a computing device. In other examples, this may be executed as a separate process, on a computing device in each case, for generating an artistic work using a software drawing package, for generating a film or movie video, for post-processing an image, etc. Such a computing device has one or more processors, RAM or other working memory, and optionally a persistent storage device. The generation of the three-dimensional object may be executed, for example, by a graphics processor provided by a graphics card or by integrated graphics provided as part of a central processing unit. The computing device may have an integrated display device, or may send image data for display to a separate display device, or may send image data to a storage device for later transmission to a display device.

[0090] As described above, in one example, the second stage can be considered to include three separate operations that can be calculated at runtime but are not restricted to being calculated at runtime. In this context, runtime means the time when the object is rendered (drawn) so as to be visible on the display screen.

[0091] The three operations may be summarized as follows. 1) Generation of a unique structure, 2) Creation of an entity that conforms to the structure, and 3) Updating the entity when required.

[0092] First, regarding the generation of a unique structure, in one example, this takes the form of two separate steps, namely, (i) rule evaluation, and (ii) command evaluation. (i) The purpose of evaluating the rules is to generate a two-dimensional hierarchical array of commands using parallel rewrite system techniques. (ii) The purpose of evaluating the commands is to generate an optimal buffer for the instructions. These instructions contain the minimum necessary information to be used in the next step so that no further calculations are required to determine where to place the objects, which objects to place, rotation, etc. For example, the instructions notify the system to place a specific geometric shape (e.g., a part of the object to be displayed) at a specific location in the "world space" and in a specific orientation. (The "world space" is a reference system in which everything in the world modeled on the display device is placed within absolute coordinates.) After all these instructions are processed, this results in an object that conforms to the previously defined structure.

[0093] Next, discussing the rule evaluation in more detail, when the style rules are applied, the system first examines each of the symbols to be generated to determine whether they are component commands. If the symbol is a component command, the system checks whether the component contains any secondary interfaces. If so, along the lines of the above discussion of the interfaces, the system treats these secondary interfaces as branches. A new symbol array is created and instantiated with the "additional command" symbols predefined for the secondary interfaces. Next, the original symbol array annotates this branch by adding a "branching symbol". This branching symbol is a pointer to the newly created symbol array. This is understood by the following example. It should be noted that in this example, there are multiple symbol arrays indexed as 0, 1,....

[0094] The first symbol array with index 0 contains the symbols F, A. (Here too, this is a simplified example for illustrative purposes, and it is emphasized that usually the symbol array is actually more complex). This can be represented by Table 4 below.

Table 0004

[0095] As described above, in this exemplary example, the symbol F is interpreted as a "component" command. (And the symbol A is not recognized as a command and is simply ignored). Thus, it is confirmed whether the component includes any secondary interface. If yes, a new symbol is created and labeled with the next index, here index 1.

[0096] Here, for any secondary interface, an additional command is defined. This purpose serves as a new axiom for the new branch in the parallel rewrite system. Without this, the branch would suddenly end and have no geometric shape. Assume that the additional command for this secondary interface is represented by the symbol B. This is then set in the axiom of the newly created array (here having index 1). Further, a branch symbol is inserted into the original array (here having index 0). Let the branch symbol be {1}.

[0097] In this example, the result of this rule evaluation can be represented by Table 5 below.

Table 0005

[0098] As an option in the rule evaluation process, an element of chance can be introduced. That is, the possibility or probability that a symbol will be replaced according to the rule can be specified as part of the rule. Otherwise, if no possibility is specified, the symbol will always be replaced according to the rule. The advantage of this is that even if the object is generated procedurally, the object generated for display will have a random appearance to at least the extent specified by the rule. This further helps to generate multiple objects for display whose appearances are not all identical.

[0099] This is illustrated by the following example, where the rule is as follows: [Number] Here, the possibility of following Rule 2 is 80%.

[0100] In this example, this means that there is an 80% chance that symbol B will be replaced by F, A, and a 20% chance that symbol B will not be changed.

[0101] 1) i) After the evaluation of the rule is completed, there is now a set of array symbols. Next, these symbols are processed to enable the evaluation of 1) (ii) the command, thereby generating the instructions that will continue to be required to generate the object for display. This is most easily explained by way of an example. Again, this is just an illustrative example, and it will be understood that the actual implementation will vary greatly with respect to both the details and complexity that are possible with the methods disclosed herein.

[0102] In this example, the symbols are first processed to remove all symbols that are not commands. In this regard, it will be recalled that some symbols are only used during the process of evaluating the rule. Thus, the symbols are inspected and any symbol that is not a command is removed.

[0103] For example, assume that the following symbol array is generated as a result of rule evaluation.

Table 0006

[0104] Here, the symbols A and B are recognized as not being commands, and thus are removed, resulting in the following in this example.

Table 0007

[0105] Now the commands can be evaluated. This is done by first considering the first symbol array having index 0. The symbols within the content of the first symbol array are processed in order. In this example, the first command F is recognized as a part command. Thus, commands are generated to continue to be used to build the part, i.e., to instantiate the geometric shape of F. Generally for a part command, part F is instantiated at its current position in the part hierarchy. In this case, since this is the first part being built or instantiated, the part is instantiated at the root or base of the overall object being generated in this example. Moreover, assuming that no other parts have been created previously and that the overall object has no initial rotation, the part is instantiated with its geometric shape facing upward in the z direction and having no rotation. However, it will be understood that if some rotation is required, for example, this can be easily modified.

[0106] Referring back to Table 7, in this example, following the first symbol (now treated as a command) is {1}, which in this example is known to be a branching command. Thus, the system knows that component F includes one secondary interface. Thus, in this example, the symbol array having the index referenced by the branching command is then processed. In this example, this is the symbol array having index 1. This is because this branching command {} includes pointer 1.

[0107] Symbol array 1 of this example has a first symbol D (the only symbol in this array in this simple illustrative example). This is recognized as a component command in this example. Thus, commands are generated to configure component D, i.e., to instantiate the geometric shape of component D. Moreover, since this is a branch, component D is positioned and rotated as necessary so that its base interface aligns with the first and only secondary interface of component F (the first instance).

[0108] In this example, since there are no more commands in symbol array 1, the process returns to the previous symbol array, here symbol array 0, specifically to the point in symbol array 0 where symbol array 0 previously branched (at {1}). In this example, the next command in symbol array 0 is ~. In this example, this is a utility command used to generate a command to apply a random rotation in a particular example. The random rotation is calculated to match the symmetry order of the primary interface of component F. The random rotation is stored at this point for later use.

[0109] Next, the process moves to the next command in symbol array 0. In this example, this is S, which in this example is another part command. Thus, commands are generated such that part S is generated with the required cumulative translation and rotation (including the random rotation calculated previously in this example), so that the base interface of part S aligns with the primary interface of part F and, thereon, it also matches the style provided for the overall generated object.

[0110] This process continues in a similar fashion through the remaining symbols in the symbol array until all symbols in all of the symbol arrays have been processed. In this example, this includes F{2}, which is another instance of part F.

[0111] The result at this stage is then a set of instructions that can be used to generate an object for display. It may be noted that these instructions are independent of each other and generally can be executed in any order. This is because all of the transformation data is represented in its simplest form and requires no further computation. This data also relates to the world space in which the object is to be placed. As described above, in one example, the transformation data includes a 4D position offset, a quaternion for aligning the next part of the object, and other data for each branch point on the asset or part of the object. All of the transformations and time offsets inherited by each part are compiled together to create the final transformation and time offset of the part in world space.

[0112] Thus, the object can now be generated for display using the generated instructions. In one example, this proceeds by executing each instruction in a sequence, generating an instance of the geometric shape or mesh of each part with its specific world space transformation and time offset, and assigning an instance of the material to the part. It is again noted that this "sequence" is generally unordered, i.e., the instructions can generally be executed in any order.

[0113] In one example, first, a component is instantiated using an instruction. As an example, the instruction includes the following information, namely, a mesh, (a plurality of) materials, translation, rotation, and a time offset.

[0114] In this regard, put simply, the material determines the appearance of the component. For example, depending on the particular shader used in a graphics processor or processing software or the like, the material defines how shiny, reflective, or matte the component is, the color or transparency of the component, tiling information, etc. As described above, the instructions can generally be executed in any order.

[0115] The instantiation itself is a well-known technique used in graphics processing. Therefore, only the main differences of this example with respect to standard instantiation techniques are discussed herein.

[0116] In this example, when a certain material is instantiated onto or for a certain component, a reference to that material is stored. The data for the material is relatively large, and moreover, processing the material to create the data is relatively processor-intensive. When a new instance of the same material needs to be instantiated, a reference to that material is noted, and the same material can be instantiated from the reference where it is stored. This effectively avoids having to create and store potentially a very large number of identical materials, and only one instance per material needs to be stored. This is particularly useful if the scene can contain a large number of such objects (which may be trees or other objects as discussed above), and each object may be formed from a large number of components.

[0117] The time offset for each component is read from the instruction by a shader of the graphics processor or processing software or the like. The visualization or appearance of the component can be adjusted as needed.

[0118] Specifically, in this example, the pre - calculated data for each component is decoded by the shader. The pre - calculated data for each component is included in the delta - encoded texture data structure, which was discussed above and is schematically shown in FIG. 5 as an example. The deltas in this texture data structure are decoded and applied as object - space offsets for specific components. The important consideration here is the "time" that should be set for that component so that the component is visualized in the correct time and shape relative to other components that make up the overall object, as well as relative to other objects, and in the case of a computer game or the like, relative to the total execution time of the game.

[0119] Regarding time, first, in the case of a computer game or the like, there may be a "global time" that represents the elapsed time since the computer game was started (e.g., by a player or other user). If this global time were used for all objects, all objects would appear to be created simultaneously and either "grow" or otherwise change shape simultaneously. This may be suitable in some cases or for some objects. However, in other cases, it may be desirable for objects (at least some of them) to be created at different times and to appear to "grow" or otherwise change shape at different times. Therefore, a global - time offset may be assigned to the components that make up a specific object, which causes that component, and thus that object, to start growing or otherwise change shape after the elapse of that global - time offset since the start of the computer game. As a simple example to illustrate this, if an object starts growing 120 seconds after the start of the game, all mesh instances for that specific object are instructed to have a global - time offset value of 120. That is, in this example, the local time for the entire specific object may be calculated by the shader as follows.

Number

[0120] In addition, as discussed above, in one example, each individual part of an object has its own local time offset. This is because the parts substantially represent different time slices, i.e., they are offset by different amounts of time. Thus, the local time of a particular part of an object may be calculated by a shader as follows.

Number

[0121] Subsequent to the above, the object is created / visualized to appear at different times according to the global time offset for different objects, and further grows or otherwise changes shape according to the individual local time offsets of the individual parts of the object. In this regard, in this example, the object grows or otherwise changes shape at the same rate. This may be desirable in some cases. However, if it is desirable for the object to grow or otherwise change shape at different rates, an additional scalar variable "grow speed" may be added. In such a case, the local time for a particular part of the object may be calculated by a shader as follows.

Number

[0122] If this method is used, all of the necessary information need only be passed to the instance buffer once across the object's life cycle when the object grows or otherwise changes shape. Other than the passage of global time from the CPU or other main processor of a normal computing device, there is no need for further communication from the CPU or other main processor of the computing device to the graphics processor or processing software or the like, simply to make the object appear to grow or otherwise change shape over time. In the prior art, if an object changes shape or is otherwise updated, typically the CPU or other main processor of the computing device has to communicate with the graphics processor or processing software to send commands, which then have to be processed by the graphics processor. This communication between the CPU and GPU is usually the slow part of the update process and is avoided in the examples described herein, except for the normal passage of global time from the CPU to the GPU which is a small amount of data. As a result, the examples described herein allow for a smooth and uninterrupted change in the shape of the object and do not require any selective updates of the object.

[0123] Reference is now made to a data storage device for storing data. This may be provided by a single device or by multiple devices. Suitable devices include, for example, hard disks and non-volatile semiconductor memories (e.g., solid state drives or SSDs).

[0124] Referring to the drawings, at least some aspects of the embodiments described herein include computer processes executed by a processing system or a processor. However, the present invention also extends to a computer program adapted to implement the present invention, particularly a computer program on or in a carrier. The program may be in the form of object code such as non-temporary source code, object code, intermediate source code in the code, and partially compiled form, or any other non-temporary form suitable for use in implementing a process according to the present invention. The carrier may be any entity or device capable of supporting the program. For example, the carrier may include a storage medium such as a solid state drive (SSD) or other semiconductor-based RAM, ROM, such as a CD-ROM or semiconductor ROM, a magnetic recording medium, such as a floppy disk or hard disk, a common optical memory device, and the like.

[0125] It will be understood that the processor or processing system or circuit configuration referred to herein may actually be provided, optionally, by a single chip or integrated circuit or a plurality of chips or integrated circuits, such as a chipset, an application specific integrated circuit (ASIC), a field programmable gate array (FPGA), a digital signal processor (DSP), a graphics processing unit (GPU), etc., depending on the specific application. The chip or plurality of chips may include a circuit configuration (and optionally firmware) for embodying at least one or more of a data processor or processor, a digital signal processor, a baseband circuit configuration, and a radio frequency circuit configuration that can be configured to operate according to an exemplary embodiment. In this regard, the exemplary embodiments may be implemented, at least in part, by computer software stored in a (non-temporary) memory and executable by a processor, or by hardware, or by a combination of software stored tangibly and hardware (and firmware stored tangibly).

[0126] The examples described in this specification should be understood as illustrative examples of embodiments of the present invention. The present invention may be applied to models, such as trees, buildings or other structures, caves or tunnel systems, lightning, robots or other animated characters, tentacles of living things, rivers, electric wires, etc. In other examples, the object to be modeled may be inside some space, such as inside a building or a cave network. In other examples, the object to be modeled may be, for example, a representation of a color or shading effect having an appearance that moves over or through a displayed scene or a particular object within a display scene in a pattern of diffusing light or darkness trends. Further embodiments and examples are envisioned. Any configuration described in relation to any one example or embodiment may be used alone or in combination with other configurations. Additionally, any configuration described in relation to any one example or embodiment may be used in combination with one or more configurations of any other example or combination or any combination of any other examples or embodiments. Furthermore, equivalents and modifications not described in this specification may also be utilized within the scope of the invention as defined in the claims.

Claims

1. 1. A computer-implemented method for generating a time-varying asset for a computer display, comprising: The method includes accessing a set of rules stored in an electronic storage device and evaluating the rules to generate a set of hierarchical commands, the rules defining at least a basic asset; The method includes evaluating the hierarchy commands to structure assets for display, the hierarchy commands including at least asset commands defining an asset type and utility commands, the utility commands being at least one of rotation commands and age constraints, the asset types being associated with transformation data, and a result of evaluating the hierarchy commands is a number of slices through time of the assets arranged hierarchically in time; The method includes visualizing the asset for display by generating successive slices of the asset in time for display and presenting the asset on a computer display, each slice having transformation data for transforming the slice depending on its age and according to any age constraints applied by an age constraint utility command. method.

2. 2. The method of claim 1 , wherein at least one of the accessing, evaluating the rules, evaluating the hierarchical commands, and visualizing is calculated at run-time to render the assets in a time-varying manner on the computer display.

3. 1. A computer program comprising a set of computer readable instructions which, when executed by a computer system, causes the computer system to perform a method for generating a time-varying asset on a computer display, the method comprising: The method includes accessing a set of rules stored in an electronic storage device and evaluating the rules to generate a set of hierarchical commands, the rules defining at least a basic asset; The method includes evaluating the hierarchy commands to structure assets for display, the hierarchy commands including at least asset commands defining an asset type and utility commands, the utility commands being at least one of rotation commands and age constraints, the asset types being associated with transformation data, and a result of evaluating the hierarchy commands is a number of slices through time of the assets arranged hierarchically in time; The method includes visualizing the asset for display by generating successive slices of the asset in time for display and presenting the asset on a computer display, each slice having transformation data for transforming the slice depending on its age and according to any age constraints applied by an age constraint utility command. Computer program.

4. The method of claim 1 or claim 2, wherein the rules are represented as a linear structure of data symbols that define an asset.

5. The method of claim 1 , 2 or 4 , wherein the rules are evaluated according to a parallel rewrite system.

6. 6. The method of claim 1, claim 2, claim 4, or claim 5, wherein the transformation data includes a 4D position offset, for each branch point on the asset, a quaternion to align the next asset, and a fourth component of the 4D position offset offsets each asset by age relative to adjacent assets.

7. The method of any one of claims 1, 2, or 4-6, wherein the utility command is one or more of the following commands: gravity, custom force, random force, clockwise yaw rotation, counterclockwise yaw rotation, terminal branch, and branch aging prevention.

8. A method according to any one of claims 1, 2 or 4 to 7, comprising setting an age for the material that manages the transformation data via a uniform parameter so that a shader can sample relative transformation data from a texture and reposition the vertices of the mesh accordingly.

Images