Generate a display of a 3D object

Abstract

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 basic interface and a first interface. The displayed first component is caused to change shape. A second component of the three-dimensional object is generated for display, the second component having at least a basic interface. The second component is translated and oriented so that when the second component is displayed on the display device, the basic interface of the second component cooperates with the first interface of the first component. The second component is displayed on the display device, wherein the basic interface of the second component cooperates with the first interface of the first component.

Description

Technical Field

[0001] The present disclosure relates to methods, apparatus and computer programs for generating a display of a three-dimensional object.

[0002] background

[0003] There are many applications in which three-dimensional objects are generated by computers for display on display devices. This includes, for example, computer games, computer graphics, and animation packages, etc. At present, the generated three-dimensional objects are usually static in the sense that they will not and cannot change or evolve over time. If the three-dimensional object is intended to change or evolve over time, it is common to pre-model each iteration of the three-dimensional object at different times. This actually produces 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 artists or other content creators have to prepare each image separately. As an alternative, computers can be used to model static images of three-dimensional objects at different times through programs, but this often results in objects that are equivalent or at least unnatural in appearance. In either case, this also means that potentially large amounts of data need to be stored and sent to, for example, a graphics processor for display, which then needs to process the large amount of data, which may not always be practical or even feasible.

[0004] Overview

[0005] This summary is provided to introduce a selection of concepts in a simplified form that are further described below in the detailed description. This summary is not intended to identify key features 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 also not limited to implementations that solve any or all of the disadvantages described herein.

[0006] According to a first aspect of the disclosure, there is provided a computer-implemented method of generating a display of a three-dimensional object, the method comprising:

[0007] generating a first component of a three-dimensional object for display, the first component having at least a basic interface and a first interface;

[0008] displaying the first component on a display device;

[0009] causing the displayed first component to change shape;

[0010] generating a second component of the three-dimensional object for display, the second component having at least a basic interface;

[0011] translating and orienting the second component so that the base interface of the second component cooperates with the first interface of the first component when the second component is displayed on the display device; and

[0012] The second component is displayed on the display device, wherein a basic interface of the second component cooperates with the first interface of the first component.

[0013] This enables the first component and the second component to seamlessly join one another, giving the final object formed from the components a smooth appearance.

[0014] The base interface of the second component typically has the same shape as the first interface of the first component. Moreover, in some examples, generating the second component of the three-dimensional object for display includes: setting the size of the second component so that the base interface of the second component is the same size as the first interface of the first component at the time when the second component is displayed. This further helps to ensure a seamless connection between the base interface of the second component and the first interface of the first component. The respective 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, for example, be the same within a tolerance so that a viewer of the display device cannot perceive any subtle differences. Factors related to this will include, for example, the screen resolution of the display device (i.e., the screen resolution of the image sent to the display device).

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

[0016] In one example, the method includes:

[0017] causing the displayed first component to further change shape; and

[0018] causing the displayed second component to change shape;

[0019] The shapes of the first component and the second component are changed so that the basic interface of the second component continues to cooperate with the first interface of the first component.

[0020] In one example, the method includes:

[0021] generating a third component of the three-dimensional object for display, the third component having at least a basic interface;

[0022] The third component is displayed on the display device, and the displayed third component is translated and oriented as needed so that the basic interface of the third component matches the second interface of the first component or the first interface of the second component.

[0023] Other components may be similarly generated and displayed, where the other components cooperate with previously displayed components, optionally in a layered manner.

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

[0025] This provides efficient use of the graphics processor because it reduces the amount of data that must be processed by the graphics processor. It also reduces the amount of data that must be sent to the graphics processor.

[0026] In one example, the data structure includes data defining a shape of a reference component, and the data structure includes difference data defining differences in shapes of components of the object relative to a shape of the reference component at a plurality of different points in time.

[0027] This further provides for efficient use of the graphics processor as it further reduces the amount of data that must be processed by the graphics processor. It also further reduces the amount of data that must be sent to the graphics processor. Different components of the three-dimensional object can be generated for display based on differences in shape from a reference component corresponding to the time at which the component is being displayed on the display device.

[0028] The reference component may be, for example, a global mature component, which is the component when it is at its largest size. In the case of an object that is intended to grow over time when displayed, this corresponds to the time when the component is in its oldest state. On the other hand, in the case of an object that is intended to shrink or reduce in size over time when displayed, this corresponds to the time when the component is in its youngest state. Nevertheless, in general, it is possible to mix, for example, from oldest to youngest or from youngest to oldest, regardless of the reference component.

[0029] In one example, the shape of the reference component is defined by a plurality of vertices, and the difference data includes translation data for each vertex, wherein the translation data for each vertex represents the difference in the position of the vertex in each component of the object relative to the position of the vertex in the reference component at different points in time.

[0030] The translation data may be sent to a graphics processor as a texture along with data defining the shape of the reference component.

[0031] According to a second aspect of the disclosure, there is provided a computer-implemented method of generating a time-varying asset on a computer display, the method comprising:

[0032] accessing a set of rules stored in an electronic memory, wherein the rules define at least a base asset, and evaluating the rules to generate a set of hierarchical commands;

[0033] evaluating hierarchical commands to construct assets for display, wherein the hierarchical commands include 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, wherein the asset type is associated with transformation data, the result of the evaluation being a plurality of time slices of the assets hierarchically arranged in time; and

[0034] The asset for display is visualized by generating temporally successive slices of the asset for display and presenting the asset on a computer display, each slice having transformation data for deforming the slice depending on the age of the slice and subject to any age constraints imposed by the age constraint utility command.

[0035] In one example, the base asset takes the form of a manually designed grid.

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

[0037] In one example, rules are represented as a linear structure of data symbols that define an asset.

[0038] In one example, rules are evaluated according to a parallel rewrite system.

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

[0040] In one example, the utility command is an instruction for one or more of: gravity, custom force, random rotation, clockwise yaw rotation, counterclockwise yaw rotation, end branch, and prevent branch aging.

[0041] In one example, the method includes setting an age via a uniform parameter on a material that manages transformation data, whereby a shader can sample relative deformation data from a texture and reposition vertices of a mesh accordingly.

[0042] According to a third aspect disclosed herein, there is provided a computer system, comprising:

[0043] at least one processor;

[0044] and at least one memory including computer program instructions;

[0045] The at least one memory and the computer program instructions are configured to, together with the at least one processor, cause the computer system to perform a method of generating a display of a three-dimensional object, the method comprising:

[0046] generating a first component of a three-dimensional object for display, the first component having at least a basic interface and a first interface;

[0047] displaying the first component on a display device;

[0048] causing the displayed first component to change shape;

[0049] generating a second component of the three-dimensional object for display, the second component having at least a basic interface;

[0050] translating and orienting the second component so that the base interface of the second component cooperates with the first interface of the first component when the second component is displayed on the display device; and

[0051] The second component is displayed on the display device, wherein a basic interface of the second component cooperates with the first interface of the first component.

[0052] According to a fourth aspect disclosed herein, there is provided a computer system, comprising:

[0053] at least one processor;

[0054] and at least one memory including computer program instructions;

[0055] The at least one memory and the computer program instructions are configured to, with the at least one processor, cause the computer system to perform a method of generating a time-varying asset on a computer display, the method comprising:

[0056] (a) accessing a set of rules stored in an electronic memory, wherein the rules define at least a base asset, and evaluating the rules to generate a set of hierarchical commands;

[0057] (b) evaluating hierarchical commands to construct assets for display, wherein the hierarchical commands include 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, wherein the asset type is associated with transformation data, the result of the evaluation being a plurality of time slices of the assets hierarchically arranged in time; and

[0058] (c) visualizing an asset for display by generating temporally successive slices of the asset for display and presenting the asset on a computer display, each slice having transformation data for deforming the slice depending on the age of the slice and subject to any age constraints imposed by the age constraint utility command.

[0059] According to a fifth aspect of the disclosure, there is provided a computer program, the computer program comprising a set of computer readable instructions, the computer readable instructions, when executed by a computer system, causing the computer system to perform a method of generating a display of a three-dimensional object, the method comprising:

[0060] generating a first component of a three-dimensional object for display, the first component having at least a basic interface and a first interface;

[0061] displaying the first component on a display device;

[0062] causing the displayed first component to change shape;

[0063] generating a second component of the three-dimensional object for display, the second component having at least a basic interface;

[0064] translating and orienting the second component so that the base interface of the second component cooperates with the first interface of the first component when the second component is displayed on the display device; and

[0065] The second component is displayed on the display device, wherein a basic interface of the second component cooperates with the first interface of the first component.

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

[0067] According to a sixth aspect of the disclosure, there is provided a computer program, the 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:

[0068] (a) accessing a set of rules stored in an electronic memory, wherein the rules define at least a base asset, and evaluating the rules to generate a set of hierarchical commands;

[0069] (b) evaluating hierarchical commands to construct assets for display, wherein the hierarchical commands include 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, wherein the asset type is associated with transformation data, the result of the evaluation being a plurality of time slices of the assets hierarchically arranged in time; and

[0070] The asset for display is visualized by generating temporally successive slices of the asset for display and presenting the asset on a computer display, each slice having transformation data for deforming the slice depending on the age of the slice and subject to any age constraints imposed by the age constraint utility command.

[0071] A non-transitory computer-readable storage medium storing a computer program as described above may be provided. BRIEF DESCRIPTION OF THE DRAWINGS

[0073] To assist in understanding the present disclosure and to show how various embodiments may be put into practice, reference is made by way of example to the accompanying drawings, in which:

[0074] Figure 1 schematically illustrates examples of several components of a three-dimensional object at different points in time;

[0075] Figure 2 Schematically shows Figure 1two of the components;

[0076] Figure 3 Schematically shows Figure 2 The vertices of each component;

[0077] Figure 4 Schematically shows the Figure 1 An indication of the increment of the difference in the shape of the individual components;

[0078] Figure 5 Schematically shows the Figure 1 An expression of the increment of the difference in the shapes of all parts;

[0079] Figures 6A to 6D schematically illustrates examples of proliferation and growth of components of an object for display; and

[0080] Fig. 7A and 7B An example of a component and an interface of the component are schematically shown respectively.

[0081] Detailed Description

[0082] In the present disclosure, the terms "programmed creation" and the like may be understood to mean automatically created without any user interaction. The term "stylized" may be understood to mean using a set of rules to define a certain style. For example, in the case of trees, different styles may correspond to different kinds of trees, such as willows or oaks. As another example in the case of a cave or tunnel system, different styles may correspond to different basic types of caves or tunnels, such as, for example, gold mines, glacial caves, karst caves, etc. The terms "layered" or "tree-like structure" and the like may be understood to mean repeating or fractal type geometric structures, including but not limited to trees, cave networks, or a flash of lightning. A hand-crafted mesh asset or component is a reference to a custom geometric structure created by an artist or other content creator that would not have been created programmatically. This could be, for example, the components of a tree house or a more complex tree component.

[0083] The present disclosure describes examples of methods for generating objects for display on a display device, including, inter alia, 4D hierarchical or tree-like structures, although other structures that are not constrained by the traditional L-system (developed by Aristid Lindenmayer in 1968 and discussed further below) may be created from any arbitrary mesh. The problem addressed by the present method is that using custom-made geometry segments and ensuring that the mesh segments fit together as intended without any holes or gaps is a difficult task. For example, it is relatively easy to ensure that procedurally created tubes fit together when creating a tree (see the discussion of the L-system developed by Aristid Lindenmayer below). However, if a more complex object (such as a tree, cave system, or other complex object) needs to be created with more complex custom geometry with an added time component (such as branches growing from the trunk of a tree that evolve over time, cave systems, or lighting effects, etc.), it is not simple to programmatically create such complex shapes and then use them to create a hierarchical or tree-like or branching structure without holes or seams. In one embodiment, the present method programmatically creates a stylized tree-like or other hierarchical structure from a manually authored mesh asset or component. The goal is to enable custom geometry to be utilized in a way that is simpler, procedurally generated, so that they can be rendered realistically as they change over time without noticeable discontinuities.

[0084] The example method can be viewed as being split into three distinct operations that can be computed at runtime, although the method is not limited to operating at runtime, but can be operated in advance "offline." These three distinct operations can be summarized or characterized as 1) generating a structure, 2) creating an entity that conforms to the structure, and 3) updating the entity when necessary.

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

[0086] In the first step of evaluating the rules, any hierarchical object can be generalized into a style. For example, a birch tree can be defined as tall and slender with thin branches; a specific cave system can be defined as a specific type of cave, such as, for example, a gold mine, a glacial cave, a karst cave, etc. Other styles can be provided for other types of trees or other objects or structures that are not trees. The style can be represented by a linear (which may be multidimensional) structure of data symbols that represent, for example, the components of an object and utility commands. A parallel rewrite system is used to evaluate the rules given a number of levels. This will produce a new data structure that defines a hierarchical structure of commands. The parallel rewrite system is an adaptation of Lindenmayer's L system and uses similar principles, but is adapted for use in this method.

[0087] In this regard, the traditional L-system developed by Aristid Lindenmayer in 1968 is a parallel rewrite system developed to model the growth process in plant development. They have been adapted in computer graphics to generate the skeleton of a tree, after which other programmatic systems can automatically create tubes along the skeleton. Using these methods, a tree with a seemingly random but natural appearance can be created programmatically. However, the system is limited by the fact that only tube descriptions can be used. It is relatively easy to ensure that the programmatic tubes fit together when creating an object to be rendered by graphics in a computer device. However, it is not an easy task to expand the L-system for the generation of other geometric structures, which limits the types of graphical shapes that can be rendered. This is particularly challenging when considering the need to model objects at different times.

[0088] The next step 2) evaluates these commands to obtain a hierarchy of commands and processes these to create the final asset or component(s) of the object. In this example, there are two types of commands: asset type and utility type. In this example, the asset type is a reference to a four-dimensional mesh. The reference is also accompanied by relevant materials and transformation data for shading the object (which is typically used by a shader (especially a vertex shader) in a hardware processor (such as a graphics processing unit or GPU) or processing software, etc.). In one example, the transformation data contains a 4D position offset for each branch point on the asset or component of the object, a quaternion for aligning the next component of the object, and other data.

[0089] In one example, the utility type is an instruction for one of the following: gravity, custom force, random rotation, clockwise yaw rotation, counterclockwise yaw rotation, end branch, and prevent branch aging. Other examples include phototropism, where, for example, plants grow towards a light source, wind direction, where components are forced to bend with the wind, etc. These instructions will either modify the rotation of components around a previous branch direction, or impose constraints in the fourth (time) dimension. During each command, assets or components of the object are created and transformed accordingly if necessary. After the system has processed all commands, several assets or components of the object organized in a hierarchical structure in four dimensions are obtained.

[0090] The second operation 2) creates entities that conform to the structure, including generating parts or assets to be joined together to form a display object. This includes visualizing time slices of the final object. For the third operation 3) updating the entity when needed, in one example, while creating the individual assets or parts of the object, materials have been created and assigned to handle the visualization throughout time. These materials sample texture inputs that have been encoded with transformation data. This data is able to deform the mesh and therefore represent the object through its fourth (time) dimension. When using the system to create a growing tree or other structure that changes shape, this data will deform all the vertices of the mesh from its final cylindrical state into thin cylinders, then into cones, and finally into tiny seeds with all vertices collapsed on top of each other.

[0091] By setting an age on the material via a uniform parameter, the graphics processor or processing software's vertex shader samples the relative deformation data from the texture and repositions the vertices accordingly. The material of each component will be assigned an offset in the fourth dimension (here time). This will offset the individual age or local time of each component and provide a seamless blend between components so that the appearance of the final object formed by the components is just one smooth mesh. Now, by setting a constant age or time for the entire final object, and adding these local offsets in the fourth (time) dimension, the result is a singular, conformal final object.

[0092] A description of a specific example of the present disclosure will now be given. An example will be given of generating a display of a three-dimensional object that changes shape, and particularly changes shape over time in the context of a computer game. In this example, generating the display of the three-dimensional object is performed at runtime (i.e., while the computer game is running). However, the present disclosure may be used to generate a display of a three-dimensional object that changes shape over time in advance (i.e., not at runtime). The present disclosure may also be used in other applications, such as, for example, a computer graphics software package.

[0093] The specific example described herein has two main phases. In the first phase, content and related data are generated. In the second phase, a three-dimensional object is generated for display on a display device, and the shape of the displayed three-dimensional object is made to change over time.

[0094] A specific example of a tree about a three-dimensional object described herein will be given. A tree can change shape, and this shape can be used to, for example, represent a tree growing over time. However, the principle described herein can be applied to other three-dimensional objects that change shape or appearance over time or have different shapes or appearances from the beginning. This includes, for example, other vegetation, such as shrubs and plants, leaves, flowers, fruits, etc. Other three-dimensional objects that can be represented include tree houses or other buildings or structures, caves or tunnel systems, lightning, robot-like animated characters or other animated characters, tentacles on organisms, rivers, power lines, etc. In other examples, a three-dimensional object may be the interior of some space, such as the interior of a building or a cave network. In other examples, a three-dimensional object may be a representation of a color or shading effect, which has, for example, an appearance of moving or passing above a specific object in a displayed scene or display scene in a manner of scattering light or dark veins. In addition to or in lieu of a shape or appearance that changes over time to represent, for example, a growing tree, leaves that weather over time, leaves that change from a mature green state to a withered and yellow or red autumn state, or objects that become damaged or corroded over time, the techniques described herein can be used to enable three-dimensional objects, or components of three-dimensional objects, to have an appearance that varies across objects and / or between components from scratch in a computationally efficient manner.

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

[0096] As the first operation in the content creation period of the first stage, at least two parts of the object are created. These can be drawn by, for example, a person using a computer in a manner known per se. These two parts represent snapshots of a part of the object at different times. In some examples, more than two parts of the object can be created. A large number of parts created at this stage will result in a more fluent or seamless representation of an object that changes shape 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 power when the three-dimensional object is being generated for display.

[0097] Figure 1An example of this is illustrated schematically in . This shows eleven components 10 which, in this particular example, represent a section or portion of a tree at eleven different points in time. In other examples, when other objects or structures are modeled, these components represent portions of other objects or structures at different points in time. In still other examples, each component may represent a component of a three-dimensional object having an appearance that varies across the object. One of these components 10 is then used as a reference component when the three-dimensional object is being generated for display. In this example, the reference component is the global mature component, which is the component when it is at its largest size. In the case of an object that is intended to grow over time when displayed, this corresponds to the time when the component is in its oldest state, and is Figure 1 The rightmost component 10 ′ (also shown in Figure 1 In the case of an object that is intended to shrink or decrease in size over time when displayed, this corresponds to the time when the component is in its youngest state. In other examples, a different intermediate component 10 may be used as a reference component.

[0098] As is known per se in computer modeling, each component 10 is defined by a number of vertices 12. Figure 1 In the example of FIG. 1 , as time increases from one component 10 to another, the vertices 12 move away from each other, which indicates that the components grow over time. The movement of the vertices 12 relative to each other defines how the shape of the components 10 evolves over time, and can be used to control the changing shape of a three-dimensional object, as will be discussed further below. It can be noted that in Figure 1 In the leftmost (youngest) component 10, all vertices 12 are collapsed to a single point, as indicated by the dot in the figure. In addition, it may be possible for an artist or other content creator to "manually" create two components (such as the youngest component and the oldest component), and then an automated computer process is used to generate any number of desired intermediate components.

[0099] In principle, the different components 10 can be effectively used to generate three-dimensional objects for display in this format. However, when drawing several objects (such as trees or other objects or structures), this will place high demands on the graphics processor or the like that is generating the display, and may not be feasible for many graphics processors and / or may result in stuttering and an unsmooth growing appearance.

[0100] A more efficient way to handle this is to identify and record the differences in the shape of each component 10 relative to the reference component 10', and send data about these differences to the graphics processor. In one example, for each of the created components 10, the (apparent) movement of each vertex 12 of the component relative to the corresponding vertex 12 in the reference component 10' is identified. By way of example, Figure 2 , which shows a reference component 10 ′ on the left and one of the other components 10 (in this example, Figure 1 The first component 10 after the leftmost (youngest) component 10 in which all vertices 12 are collapsed to a single point). Figure 2 , a specific vertex 14 ′ in the reference component 10 ′ and a corresponding vertex 14 in the other component 10 are indicated.

[0101] For the sake of clarity, Figure 3 Certain vertices 14 ′ in the reference component 10 ′ and corresponding vertices 14 in the other component 10 are shown, while other vertices 12 are omitted. Figure 3 A particular vertex 14' in a reference component 10' is shown to be effectively moved along a vector or "increment" Δ1 to a corresponding vertex 14 in the other component 10. The increment Δ1 has x, y, and z components. In the example shown, a left-handed coordinate system is used, with the z component pointing upwards, such as Figure 3 . For reasons that will become clear, the x, y and z components of the increment Δ1 can be represented as RGB values ​​of the color. That is, the increment Δ1 can be represented as a color pixel p1. It can be noted that pixel information is usually conventionally stored with 8-bit precision, and therefore 256 unique values ​​per channel. In this example, 8-bit precision can be used. However, in this example, 32-bit precision is used in order to better preserve the range and precision of the data.

[0102] This identification of the relative movement of the vertex 12 between the reference component 10 ′ and the further component 10 is repeated for all vertices 12. This results in a corresponding number of increments Δ n , one increment per vertex 12. This results in a corresponding number of colored pixels p n . Color pixel p n The components 10 may then (at least conceptually) be arranged in rows. For the case where each component 10 has fifty vertices and therefore there are fifty increments Δ and therefore fifty color pixels p, this is Figure 4 is schematically illustrated in Figure 4 and 5 Although the individual "color" of pixel p will vary from case to case, and will generally be a unique, different value for each pixel, for purposes of illustration, the shading listed in Table 1 below is used to schematically indicate the colors in this particular example:

[0103]

[0104] Table 1

[0105] This process is performed for each of the other components 10. This results in several sets of increments, which can be represented as rows of colored pixels. For the case where there are eleven components 10 in total, this is Figure 5 is schematically explained. Figure 5 It is shown that the increment for each vertex of each component 10 can be expressed as a pixel p nt A two-dimensional matrix of , where n is the number of vertices 12 (here 50) and t is the number of moments, which corresponds to the total number of components 10 (here 11). It can be noted that the first row at the top is blank, since it represents the reference component 10'.

[0106] The result of this is a reference component 10' (which is defined by the x, y, z position of its vertex 12) and a set of several differences or increments Δ n (one for each component 10), and wherein each set of differences is used to define the relative movement of vertices 12, which together represent (in this example) a segment or part of the tree at different points in time. n In other words, at the end of this initial creation period, there is a three-dimensional mesh (which defines the reference part 10') and a texture, which can be considered as a data structure used to define the relative movement of the vertices 12 in the mesh or reference part 10'. These are then used together to generate a three-dimensional object for display and to cause the generated three-dimensional object to change shape over time, as will be discussed further below.

[0107] As a next stage, at least one interface is defined for each of the components 10. The interface is then used to enable different components 10 to be joined in the displayed object during the generation of the three-dimensional object for display. This joining of different components 10 needs to be presented in a smooth or seamless joining that is invisible to the user. This use of different components 10 joined in the displayed image provides an efficient way to enable the displayed three-dimensional object to change shape over time. In this example, this enables the tree to appear to grow over time by growing larger and optionally adding new branches, twigs, etc. In an example where the three-dimensional object is, for example, a cave or tunnel system, this can be used to show, for example, a cave or other structure that grows over time. This growth can be "organic" in the sense that a cave or other structure, such as a tree, will expand over time to grow larger. This can be used, for example, to explain a cave or tunnel system that becomes deeper as a new tunnel is dug or formed.

[0108] To illustrate how this works in practice during the display of a three-dimensional object, Figures 6A to 6D This example is a simple example for illustration purposes, where each component is a thin branch or a portion of a tree trunk.

[0109] First, during display of the three-dimensional object, a component is caused to be displayed or "proliferated". This first component has its local time set to zero, and therefore since this represents the earliest time in the sequence, the first component is actually point 600, as shown in FIG. Fig. 6A shown.

[0110] Next, the first component is effectively made to grow larger. This is achieved by incrementing the component's local time by one time unit (that is, by setting the component's local time to 1 at this time). (An example of how growth of individual components can be achieved is discussed further below.) Figure 6B As shown, this causes the first component to grow longer and thicker, thereby (in this example) becoming an elongated rod-like component 601. In addition, a new second component is proliferated. At this stage, the local time of the second component is set to zero, and therefore the second component is actually point 620, as shown in FIG. Figure 6B shown.

[0111] Next, the local time of each component is incremented by 1. Figure 6C As shown, the first component has grown longer and thicker (as indicated by 602), and the second component has also grown longer and thicker (as indicated by 621). In addition, a new third component is proliferated, where its local time is set to zero, and thus the third component is actually point 640. This can be illustrated as Fig.6D is repeated as shown, Fig.6D It is shown that the first through third components have grown in size (as indicated by reference numerals 603, 622, 641 respectively) and a new component 660 has been added having a local time set to zero.

[0112] It can be noted that in this example, the same component 60 has been effectively used essentially three times. However, the components 60 are different, at least in that they represent different time slices, i.e., have been offset by different amounts of time, so that they have different local time offsets. (In general, the components 60 will also be different due to having been translated to be located at different locations and also rotated.) At this point in this example, it can be noted that the "time" of the entire object formed by the individual components 60, 62, 64 is 3 time units, while the local times of the individual components 60, 62, 64 are 3, 2, and 1, respectively.

[0113] This explains how each new component is joined with the components that have been previously displayed on the display device. An important aspect of enabling smooth joining of components is the interface where the components join with each other. To this end, when the new component is displayed, the various interfaces on the new component and the components to which it is joined are located in space and oriented relative to each other to provide a smooth, virtually seamless join. To this end, each interface is provided with conversion information or data, which has two main components, namely a translation offset and an orientation offset. The translation offset moves the new component in the local space in the displayed image relative to the previous component to which it is being connected. The orientation offset rotates the new component relative to the previous component. Taken together, this allows the new component to be in the correct position and orientation relative to the previous component, regardless of the actual shape of the various components, because the interfaces of the various components are correctly positioned and oriented relative to each other. Moreover, in order to obtain a "seamless" join and facilitate a smooth transition between the components when growing or otherwise changing shape, in some examples, the interfaces of the various components being connected are arranged to be the same size as each other. However, in other examples, the interfaces of the various components being connected may have different sizes, depending on, for example, 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, fruit or foliage to be added to a branch, etc. The dimensions of the interface in its global mature state may be defined as part of the interface. In an example, the transformation data also contains the normals, tangents, and binormals of the interface, which may later be used by the runtime system to apply gravity and / or other forces or effects.

[0114] These interfaces are discussed further and are now referenced Fig. 7A , Fig. 7A An example of a component 70 is shown, each component having at least a basic interface 72. The basic interface 72 is Figure 7B . The base interface 72 is a polygon with n sides. The polygon can be generally an irregular polygon, although in some examples, the polygon can be a regular polygon that can facilitate the orientation of the components to connect the components. The center O of the polygon is the origin of the base interface 72. Moreover, the base interface 72 can be symmetrical, with a symmetry level that can be generally the same as or different from the number of sides n of the polygon. The reverse normal of the base interface 72 Pointing upward along the z-axis. The tangent line of the basic interface 72 (i.e., a vector tangent to the surface of the base interface 72) originates from the origin O and points directly along the x-axis. In this example, the tangent line Pass through one of the vertices 74 on the boundary of the base interface 72 .

[0115] In this example, component 70 is not a terminal component and therefore has another first interface or main interface 76 in addition to the basic interface 72. In this example, the main interface 76 is a polygon, again, it is usually an irregular polygon, but it can be a regular polygon. The main interface 76 contains a translation offset and an orientation offset. The orientation is calculated as follows. The normal is derived for the main interface 76 and tangent As for the basic interface 72, the tangent Originates from the center of the main interface 76 and points to one of the vertices of the main interface 76. Then, respectively from [0,0,1] to and [1,0,0] to . (As is well known, quaternions provide a mathematical notation for representing the orientation and / or rotation of objects in three dimensions.) For this master interface 76, the quaternion can now orient the normal of the base interface of the next component with its own normal, and can also rotate the next component about its normal so that the tangents are also aligned, all in one calculation. That is, this enables the mating interfaces of adjacent components to be correctly positioned and oriented relative to each other.

[0116] In this example, the component 70 has other interfaces or secondary interfaces 78. This enables other components to be joined to the first component. In this case, as can be seen, the secondary interface 78 faces away from the main body or trunk of the component 70, which enables other components to be added to represent, for example, branches of a tree. However, the other components added can represent other items, such as, for example, components of a tree house or other objects being modeled. Other interfaces can be provided on the component 70. Each interface is defined by a quaternion in the same manner as the primary interface 76.

[0117] Using polygons for the interfaces 72 , 76 , 78 has the advantage that it effectively constrains the rotations that the next component can perform, which means that the rotation of the next component is more predictable and the next component can be aligned with the previous component 70 more easily.

[0118] As a final stage in the first phase of generating content and related data, rules are created or defined, which are then used in the visualization phase to determine the appearance or "style" of the parts of the object, and therefore the object as a whole. 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, architectural structures, etc. Rules are typically generated "by hand" by artists or other content creators. The use of rules when generating three-dimensional objects for display on a display device will be further discussed below. In short, when applied in this example, the application of the rules results in a set or array of symbols, which are then interpreted as commands, which are then evaluated to generate instructions that are then used to generate objects for display, as further discussed below.

[0119] A style defines a set of features of an object to be displayed. Each style has "axioms" and a set of rules. To help understand the styles and axioms and rules, as well as what is created at this stage, a brief overview of the parallel rewrite system will now be given. As mentioned, the parallel rewrite system used in this article's examples and discussed in more detail below can be viewed as an adaptation of Lindenmayer's L system, and uses similar principles specifically adapted to the method.

[0120] L-systems are iterative, parallel rewriting systems using a set of rules and axioms. A discussion of L-systems will be given to illustrate this point. The symbols and other representations discussed here are intended to provide illustrative examples of the technique. In practice, when run on a computer, the detailed implementation may be different, although the basic concepts are the same.

[0121] As a simple example, the axiom could be B, and there could be rules such as:

[0122] A->B Rule 1

[0123] B->F, A rule 2

[0124] During the operation of the parallel rewrite system, a container is first created for the symbols, which will be created when the rules are applied. The axiom (B in this illustrative example) is inserted into the container. The parallel rewrite system is an iterative process, so the subsequent steps will be performed repeatedly. At each iteration, the symbol(s) in the container are checked, and any symbol therein is replaced according to the rules.

[0125] Thus, in this illustrative example of a parallel rewrite system, since the symbol initially in the container was B, it is replaced by F, A according to the second rule. Now, the first rule specifies that A is replaced by B; otherwise, there is no rule for F, so it remains unchanged. This means that at the next iteration, F, A is replaced by f, B. Continuing in the same way, at the next iteration, 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 specified number of iterations, and can be summarized by the following Table 2 (up to five iterations):

[0126] <![CDATA[ Iteration ]]> <![CDATA[ symbol ]]> 0 B(Axiom) 1 F, A 2 F, B 3 F, F, A 4 F, F, B 5 F, F, F, A

[0127] Table 2

[0128] The adaptation of the known L-system as used in this example for parallel rewriting will be discussed in more detail below, but briefly, assume that after several iterations, the resulting symbols are F, F, F, F, F, F, F, F, F, F, A. During the generation of the object for display, the symbol F is interpreted as a "part" or "asset" command, while the symbol A is not recognized as a command and is simply ignored. Thus, this particular array of symbols will cause an object to be constructed for display, wherein the object includes eleven parts stacked on top of each other. (Compared to Fig.6D ) In addition, the use of interfaces on the components and the translation and orientation of the interfaces of the components as discussed above make the connection or joint between the various components appear smooth and seamless.

[0129] As is well known, L-systems are able to handle branching structures, and thus are able to generate images of trees or plants with branches or twigs, etc. Accordingly, the above example is a simple example using a one-dimensional symbol set or array of symbols, but in practice this can be easily extended to a two-dimensional symbol array to accommodate, for example, branches or other more complex or elaborate structures, whether for trees or other objects or structures being modeled.

[0130] As mentioned, rules are usually created or defined "manually" by an artist or content creator so that the final object has a desired style (i.e., a desired appearance), which may be different for different objects that otherwise have the same style. In the example of trees, this means that, for example, several trees of the same type (e.g., oaks or willows, etc.) can be generated, each with a different appearance. As another example in the case of caves, different appearances can be used to represent different types of caves, such as, for example, gold mines, glacial caves, karst caves, etc.

[0131] Application of the rules results in a set or array of symbols, which in turn are interpreted as commands, which in turn are evaluated to generate instructions for subsequent use when the object is being generated for display.There are two main types of commands: component or asset commands and utility commands.

[0132] The component command is symbolized by F in the illustrative example above. This is used to construct a component at its current position in the component hierarchy, as mentioned above and as will be discussed further below.

[0133] Utility commands act as modifiers of the structure, i.e., to modify certain parts of the object being generated for display. When the object is being generated for display, the utility commands are interpreted as instructions for applying some predetermined function at the current point in the hierarchical structure. Again, this will be discussed further below.

[0134] Some examples of utility commands are summarized in Table 3 below, it being understood that this can be extended to other applications:

[0135]

[0136]

[0137] Table 3

[0138] It may be noted that some utility commands permit "weighting" to be specified and applied. In each of these examples herein, the utility command permitting weighting is a command that causes a component of an object to rotate relative to a previous component. As a specific example, gravity may be applied so that the branches of a tree droop downward as the branches extend away from the trunk of the tree, and the amount or degree of droop may be determined by the weighting applied. Weighting may be specified in the rule using, for example, parentheses, e.g., #(0.5) represents a weighting of 50% of the custom force. If no weighting is specified, a default value of 1 may be assumed.

[0139] Utilizing the various different types of symbols that can be generated by the rules, and which are interpreted as commands when the object is being generated for display, complex styles can be created that result in correspondingly complex objects. This facilitates the subsequent programmatic generation of objects that can otherwise have very different appearances from one another. To illustrate the possible complexity of the styles that can be created, and without going into detail about the meaning of the rules and axioms for this example, a style may have a set of rules such as the following:

[0140] R=|(5),E,|(5),E,K,|(5),E,|(-5),E,|(-5),E,|(-5),E

[0141] C=~,|,R,C

[0142] B=~,|(-0.25),#,P,L,O,Y

[0143] M=~,|(-0.75),#,B

[0144] H=M,H

[0145] And the following axioms:

[0146] ~,S,R,B,H,T

[0147] After this first preparatory phase or setup phase, a three-dimensional object is generated for display on a display device, and the shape of the displayed three-dimensional object is caused to change over time in a second phase. This second phase is performed by a computing device operating according to instructions in a computer program. As mentioned, this can be performed at runtime when, for example, a computer game is running on a computing device. In other examples, this can be performed as a separate process on a computing device in each case, such as for generating artwork using a software drawing package, for generating moving images for a movie or film, for post-processing images, etc. Such computing devices have one or more processors, RAM or other working memories and can optionally have persistent storage. The generation of a three-dimensional object can be performed by, for example, a graphics processor, which can be provided by, for example, a graphics card or by an integrated graphics card provided as a part of a central processing unit. The computing device can have an integrated display device, or image data for display can be sent to a separate display device, or image data can be sent to storage for later sending to a display device.

[0148] As mentioned, in one example, the second phase can be viewed as including three distinct operations that can be computed at runtime, but is not limited to being computed at runtime. In this context, runtime means the time when an object is to be rendered to make it visible on a display screen.

[0149] These three operations can be summarized as:

[0150] 1) Generate a unique structure,

[0151] 2) create entities that conform to that structure, and

[0152] 3) Update the entity when necessary

[0153] Regarding the first operation 1) generating a unique structure, in one example, this takes the form of two distinct steps: (i) evaluating rules and (ii) evaluating commands. The purpose of (i) evaluating rules is to generate a two-dimensional hierarchical array of commands using a parallel rewrite system technique. The purpose of (ii) evaluating commands is to generate an optimal buffer of instructions. These instructions contain the minimum necessary information used in the next step, so that no further calculations are required to determine where to place an object, what object to place, rotation, etc. For example, an instruction will inform the system to place a specific piece of geometry (e.g., a component of an object to be displayed) in a specific position and specific orientation in "world space". (This "world space" is a reference frame in which everything in the world that is being modeled on a display device is located in absolute coordinates.) After all of these instructions have been processed, this will result in an object that conforms to the previously defined structure.

[0154] Now discussing 1) (i) evaluating the rules in more detail, when the rules of the style are applied, the system first checks each symbol generated to check whether they are component commands. If the symbol is a component command, the system checks whether the component contains any sub-interfaces. If so, based on the above discussion of interfaces, the system treats these sub-interfaces as branches. A new symbol array is created and instantiated using the predefined "additional command" symbol in the sub-interface. The original symbol array then records the branch by adding a "branch symbol". The branch symbol is a pointer to the newly created symbol array. This can be seen in the example below. Note that in this example, there are multiple symbol arrays, which are indexed as 0, 1,...

[0155] Assume that the first symbol array with index 0 contains symbols F, A. (Again, it is emphasized that this is a simplified example for the purpose of illustrating the example, and the symbol array will generally be more complex in practice.) This can be represented by the following Table 4:

[0156]

[0157] Table 4

[0158] As mentioned above, in this illustrative example, symbol F is interpreted as a "component" command (and symbol A is not recognized as a command and is simply ignored). Accordingly, a check is made to see if the component contains any secondary interfaces. If so, a new symbol array marked with the next index (here index 1) is created.

[0159] Now, for any sub-interface, an additional command is defined. The purpose of this is to serve as a new axiom for new branches in the parallel rewriting system. Without this, the branch would end abruptly without any geometric structure. Assume that the additional command for this sub-interface is represented by the symbol B. This is then set at the axiom for the newly created array (here it has index 1). In addition, the branch symbol is inserted into the original array (here it has index 0). Let the branch symbol be {1}.

[0160] In this example, the result of the rule evaluation can be represented by the following Table 5:

[0161]

[0162] Table 5

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

[0164] This is illustrated by the following example. Here, the rule is:

[0165] A->B Rule 1

[0166] B(0.8)->F,A Rule 2

[0167] The chance of following rule 2 is 80%.

[0168] 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 remain unchanged.

[0169] After 1)(i) evaluating the rules is complete, there is now a set of array symbols. These symbols are then processed to enable 1)(ii) evaluating the commands, thereby generating the instructions required to subsequently generate the objects for display. This is most simply explained by way of example. It will be appreciated that this is again merely an illustrative example, and that actual implementations will actually vary greatly in detail and in the possible complexity of the methods disclosed herein.

[0170] 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 rules. Accordingly, the symbols are checked and any symbols that are not commands are removed.

[0171] For example, suppose the following array of symbols is generated as a result of evaluating a rule:

[0172]

[0173] Table 6

[0174] Here the symbols A and B are recognized as not being commands and are therefore removed, resulting in the following in this example:

[0175]

[0176] Table 7

[0177] Commands can now be evaluated. This is performed by first considering the first symbol array with index 0. The symbols in the content of the first symbol array are processed in order. In this example, the first command F is identified as a component command. Accordingly, an instruction that will be used to construct a component (i.e., instantiate the geometry of F) is generated. Usually, for a component command, component F is instantiated at its current position in the component hierarchy. In this case, since this is the first component being constructed or instantiated, the component will be instantiated at the root or base of the entire object being generated in this example. Moreover, since no other components have been created previously, and it is assumed that the entire object does not have an initial rotation, the component will be instantiated with its geometry facing up in the z direction and without rotation. But it will be appreciated that this can be easily modified if, for example, some rotations are required.

[0178] Referring back to Figure 7, it can be seen that in this example, the first symbol (now considered a command) is followed by {1}, which in this example is a branch command. Therefore, the system knows that component F contains a secondary interface. Accordingly, in this example, the symbol array with the index referenced in the branch command is processed next. In this example, this is the symbol array with index 1 because the branch command {} contains pointer 1.

[0179] In this example, symbol array 1 has a first symbol D (which, in this simple illustrative example, is the only symbol in the array). In this example, this is identified as a component command. Accordingly, instructions are generated that will be used to construct component D (i.e., instantiate the geometry of D). Moreover, because this is a branch, component D will be positioned and rotated as needed so that its primary interface is aligned with the first and only secondary interface of (the first instance of) component F.

[0180] 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), and in particular to the point in symbol array 0 that it previously branched past (at {1}). In this example, the next command in symbol array 0 is ~. In this example, this is a utility command that, in a specific example, is used to generate instructions to apply random rotations. The random rotations are calculated so as to conform to the symmetry level of the main interface of component F. The random rotations are now stored for later use.

[0181] The process then moves to the next command in symbol array 0. In this example, this is S, which is another component command in this example. Accordingly, instructions are generated that cause component S to be generated with the necessary accumulated translations and rotations (including the previously calculated random rotation in this example) so that the basic interface of component S is aligned with the main interface of component F, and so that it also conforms to the style provided for the entire generated object.

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

[0183] The result at this stage is a set of instructions that can then be used to generate objects for display. It can be noted that these instructions are independent of each other and can generally be executed in any order. This is due to the fact that all transformation data is represented in its simplest form and no further operations are required. The data is also related to the world space in which the object is placed. As mentioned, in one example, the transformation data contains a 4D position offset, a quaternion for aligning the next component of the object, and other data for each branch point on the asset or component of the object. All transformations and time offsets inherited by each component are compiled together to create the final transformation and time offset of the component in world space.

[0184] Accordingly, the created instructions can now be used to generate objects for display. In one example, this is done by executing each instruction in order, creating an instance of the geometry or mesh of each component with that particular world space transform and time offset, and assigning instances of the material to the components. Again, this "order" is generally unordered, that is, the instructions can generally be executed in any order.

[0185] In an example, first, a component is instantiated using instructions. As an example, the instructions contain the following information: mesh, material(s), translation, rotation, and time offset.

[0186] In this regard and in short, materials determine the appearance of a part. Depending on or for example, the specific shader used in the graphics processor or processing software, etc., the material defines the gloss or reflective or matte degree of the part, the color and transparency of the part, tiling information, etc. As mentioned, the instructions can generally be executed in any order.

[0187] Instancing itself is a well-known technique used in graphics processing. Accordingly, only the main differences between this example and the standard instancing technique are discussed here.

[0188] In this example, when a material is instantiated on or for a component, a reference to the material is stored. The data for a material is relatively large, and processing the material to create the data is relatively processor intensive. When a new instance of the same material needs to be instantiated, the reference to the material is noticed, and the same material can be instantiated from the stored reference. This avoids having to create and store potentially very large numbers of materials that are actually identical: only one instance of each material needs to be stored. This is particularly useful given that a scene can contain a large number of such objects (which can be trees or other objects as discussed above) and each object can be formed from a large number of components.

[0189] The time offset for each component is read from the instructions by a shader of a graphics processor or processing software, etc. The visualization or appearance of each component can then be adjusted as desired.

[0190] Specifically, in this example, the pre-computed data for each component is decoded by the shader. The pre-computed data for each component is contained in the delta-encoded texture data structure discussed above and is decoded by the shader. Figure 5 The deltas in the texture data structure are decoded and applied as object space offsets for the specific part. An important consideration here is the "time" that should be set for the part so that it is visualized with the correct time and shape (both relative to the other parts that make up the whole object and relative to other objects) and the total game runtime in the case of computer games and the like.

[0191] Regarding time, first, in the case of computer games and the like, there may be a "global time" that represents the time that has passed since the computer game was started (e.g., by a player or other user). If this global time is used for all objects, all objects will appear to be created at the same time and will "grow" or otherwise change shape at the same time. This may be appropriate in some cases and / or for some objects. However, in other cases, it may be appropriate for (at least some) objects to appear to be created at different times and to "grow" or otherwise change shape at different times. Accordingly, the components that make up a particular object may be assigned a global time offset that causes each component and therefore the object to begin growing or otherwise changing shape after the global time offset since the computer game was started. As a simple example to illustrate this point, if an object is to begin growing at 120 seconds after the game starts, all mesh instances for that particular object are instructed to process a global time offset value of 120. That is, in this example, the local time for the particular object as a whole may be calculated by the shader as:

[0192] Local time (object) = (global time - global time offset)

[0193] Equation 1

[0194] Additionally, as discussed above, in one example, each individual component of an object has its own local time offset. This is because each component effectively represents a different time slice, i.e., has been offset by a different amount of time. Accordingly, the local time for a particular component of an object can be calculated by the shader as:

[0195] Local time (component) = (global time - global time offset) - local time offset

[0196] Equation 2

[0197] Following the above, each object will be created / visualized to appear at different times according to the global time offset for different objects, and will further grow or otherwise change shape according to the individual local time offsets of each individual component of the object. In this regard, according to this example, the objects will grow or otherwise change shape at the same rate. In some cases, this may be convenient. However, if it is desired that the objects grow or otherwise change shape at different rates, another scalar variable "growth speed" may be added. In such a case, the local time for a particular component of the object may be calculated by the shader as:

[0198] Local time (component) = ((global time - global time offset) - local time offset) * growth rate

[0199] Equation 3

[0200] Using this method, when an object grows or otherwise changes shape, all necessary information needs to be passed to the instance buffer once and only once for the entire life cycle of the object. In addition to passing the global time from the CPU or other main processor of the computing device as usual, there is no need to communicate with the CPU or other main processor of the computing device and the graphics processor or processing software, etc. to make the object appear to grow or otherwise change shape over time. In the prior art, if the object is to change shape or be updated in other ways, the CPU or other main processor of the computing device must usually communicate with the graphics processor or processing software to send instructions, which must then be processed by the graphics processor. This communication between the CPU and the GPU is usually a slow part of the update process, and is avoided in the examples described herein except that the global time is usually passed from the CPU to the GPU (which is a small amount of data). As a result, the examples described herein enable the shape of the object to be changed smoothly and uninterruptedly, and do not require any selective update of the object.

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

[0202] Although at least some aspects of the embodiments described herein with reference to the accompanying drawings include computer processes executed in a processing system or processor, the invention also extends to computer programs suitable for putting the invention into practice, especially computer programs on or in a carrier. The program may be in the form of non-transient source code, object code, code between source code and object code, such as in a partially compiled form, or in any other non-transient form suitable for implementing the process according to the invention. The carrier may be any entity or device capable of carrying the program. For example, the carrier may generally include a storage medium, such as a solid-state drive (SSD) or other semiconductor-based RAM; a ROM, such as a CD ROM or a semiconductor ROM; a magnetic recording medium, such as a floppy disk or a hard disk; an optical storage device; and the like.

[0203] It will be understood that the processor or processing system or circuitry referred to herein may actually be provided by a single chip or integrated circuit or multiple chips or integrated circuits, optionally provided 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. One or more chips may include circuitry (and possible firmware) for embodying at least one or more of one or more data processors, one or more digital signal processors, baseband circuitry, and radio frequency circuitry, which may be configured to operate in accordance with exemplary embodiments. In this regard, exemplary embodiments may be implemented at least in part by computer software stored in (non-transitory) memory and executable by a processor or by hardware or by a combination of tangibly stored software and hardware (and tangibly stored firmware).

[0204] The examples described herein will be understood as illustrative examples of embodiments of the present invention. The present invention may be applied to modeling, for example, trees, buildings or other structures, caves or tunnel systems, lightning, robot-like animated characters or other animated characters, tentacles on creatures, rivers, power lines, etc. In other examples, the modeled object may be the interior of some space, such as the interior of a building or a cave network. In other examples, the modeled object may be a representation of a color or shadow effect, which has, for example, an appearance of moving or passing over a specific object in a displayed scene or a displayed scene in a manner of scattering light or dark veins. Further embodiments and examples are contemplated. Any feature described with respect to any one of the examples or embodiments may be used alone or in combination with other features. In addition, any feature described with respect to any one of the examples or embodiments may also be used in combination with one or more features of any other example or embodiment in the example or embodiment, or any combination of any other example or embodiment in the example or embodiment. In addition, equivalent forms and modifications not described herein may also be adopted within the scope of the present invention defined by the claims.

Claims

1. A computer-implemented method of generating a display of a three-dimensional object, the method comprising: generating a first component of a three-dimensional object for display, the first component having at least a base interface and a first interface, wherein each component of the object is instantiated by a graphics processor based on a same data structure, the data structure comprising data defining a shape of a reference component, the data structure comprising difference data defining a difference in shape of each component of the object relative to a shape of the reference component at a plurality of different time points, the first component corresponding to the shape of the reference component at a first local time point, wherein the shape of the reference component is defined by a plurality of vertices, and the difference data comprises translation data for each vertex, wherein the translation data for each vertex represents a difference in position of the vertex in each component of the object relative to the position of the vertex in the reference component at the different time points; displaying the first component on a display device; causing the shape of the displayed first component to change to the shape of the reference component at a second local time point; generating a second component of the three-dimensional object for display, the second component having at least a basic interface; translating and orienting the second component so that a base interface of the second component cooperates with a first interface of the first component when the second component is displayed on the display device; as well as The second component is displayed on the display device, wherein a basic interface of the second component cooperates with a first interface of the first component.

2. The method according to claim 1, wherein: Reshaping the displayed first component causes the displayed first component to change shape over time such that the displayed three-dimensional object changes shape over time.

3. The method according to claim 1, comprising: causing the displayed first component to further change shape; as well as causing the displayed second component to change shape; The shapes of the first component and the second component are changed so that the basic interface of the second component continues to cooperate with the first interface of the first component.

4. The method according to claim 3, comprising: generating a third component of the three-dimensional object for display, wherein the third component has at least a basic interface; The third component is displayed on the display device, and the displayed third component is translated and oriented as needed so that the basic interface of the third component cooperates with the second interface of the first component or the first interface of the second component.

5. A computer system comprising: at least one processor; and at least one memory including computer program instructions; The at least one memory and the computer program instructions are configured to, together with the at least one processor, cause the computer system to perform the method of generating a display of a three-dimensional object as claimed in any one of claims 1 to 4.

6. A non-transitory computer-readable storage medium comprising a set of computer-readable instructions stored thereon, which, when executed by a computer system, causes the computer system to perform the method of generating a display of a three-dimensional object as described in any one of claims 1-4.

Images