KR20080018407A - Computer-readable recording medium for recording of 3d character deformation program - Google Patents

Abstract

A computer-readable recording medium having an animation character-change program providing changing of a three-dimensional animation character is provided to shorten time and efforts considerably required for changing a fabricated animation character. A body changing module(110) uses vertex data storing configuration information of a three-dimensional animation character, and provides a figure change script and a Lua script for changing a figure of the three-dimensional animation character with reference to normal data, texture data, and frame data. A material changing module(120) provides an image morphing function for changing the form of a face of the three-dimensional animation character, provides a material script for adjusting the color of the three-dimensional animation character and a change according to time and space of the color, and provides a blend script for adjusting blending of texture images of the three-dimensional animation character. An operation changing module(130) changes an operation of the three-dimensional animation character based on operation data including rotation change values with respect to each frame and central movement value of the three-dimensional animation character.

Description

Computer-Readable Recording Medium for Recording of 3D Character Deformation Program

1 is a view showing simply the internal structure of the character transformation program according to a preferred embodiment of the present invention,

2 is a view showing a three-dimensional character whose body shape is deformed by the body shape deformation module according to an embodiment of the present invention;

3 is a view showing feature points on a face image according to a preferred embodiment of the present invention;

4 is a view showing a face image generated by the image morphing function of the material deformation module according to an embodiment of the present invention,

5 is a view showing a screen displayed when driving the character transformation program according to a preferred embodiment of the present invention;

6A is a diagram illustrating a screen for setting a skeleton of a character in a character transformation program according to an exemplary embodiment of the present invention;

6B is a diagram illustrating a screen for setting rotation on a skeleton set in a character transformation program according to an exemplary embodiment of the present invention.

<Description of Symbols for Main Parts of Drawings>

100: character transformation program 110: body deformation module

120: material deformation module 130: motion deformation module

The present invention relates to a computer readable recording medium having recorded thereon a character deformation program providing deformation of a three-dimensional character. More specifically, the image morphing function is used to deform the shape of the 3D character by using the vertex data storing the spatial position information of the 3D character, and to control the transformation target image of the 3D character and the corresponding texture coordinates. The present invention relates to a computer-readable recording medium which records a program for deforming a material of a 3D character and deforming the 3D character by using motion data of the 3D character and rotation and movement data of 19 skeletons.

The domestic game industry is expected to grow to 4.9 trillion won in 2005, and to reach 5.6 trillion won in 2006. Since 2002, it has been growing at an annual rate of about 27%, and Korean online games have gained a lot of popularity overseas. With the expansion of the game market and the development of technology, users prefer 3D games to existing 2D games, and online games are becoming an important part of the game industry rather than offline games.

3D games are made up of various components, but among them, the characters are of interest to users and the most resources are put into them. In 2001, one of the domestic online game companies launched an online game using a three-dimensional avatar. Previously, avatars were considered to be characters represented in two dimensions, but now it is natural to see avatars represented as three-dimensional characters online. The direction of the business has changed from the past two-dimensional graphics-based games to the perfect three-dimensional games, and online community services using three-dimensional characters are gradually expanding, in addition to the online games, making the characters nicely and how many characters Whether it is provided, it is a factor that determines the success of online games.

In particular, the community using avatars has to provide items of various avatars, and for this, a lot of manpower is given to character and item production, but the produced characters gradually become far from the interests according to the consumer's eye level and become useless at the end. 3D characters are an important element in online games, because once produced characters are initially popular and profitable, even if they are profitable, they are naturally disregarded by consumers unless they continue to change.

Three-dimensional characters are different from two-dimensional characters, so it costs a lot of money and time to produce one. The important features to consider when creating a character in the game are: The first is to make the 3D characters run as efficiently as possible on a low-specified system rather than to represent them realistically, and the second is to provide characters that are satisfactory to the consumer at minimal cost.

Therefore, a lot of manpower should be administered in order for various characters to come out, but in order to transform a character that has already been produced, it takes much time and effort to produce one character. There was a problem.

In addition, changes in the appearance of the character and various movements are made depending on the manual work of the graphic designer. Therefore, an additional modeling work is required for the expression that the height grows as the character grows or the stomach grows due to overeating. There was a problem of additional input of time and time.

In order to solve this problem, the present invention, by transforming the body shape of the three-dimensional character by using the vertex data that stores the spatial position information of the three-dimensional character, and controls the deformation target image and the corresponding texture coordinates of the three-dimensional character A computer-readable recording medium that records a program that modifies the material of the 3D character by using the image morphing function and uses the motion data of the 3D character and the rotation and movement data of the 19 skeletons to record the program of the 3D character. Its purpose is to provide.

In order to achieve this object, according to the first object of the present invention, in a recording medium on which a program for deforming a three-dimensional character is recorded, the program stores vertex data storing the external form information of the three-dimensional character. A body shape transformation module for providing a body shape transformation script and a lua script for modifying the body shape of the 3D character with reference to normal data, texture data, and skeleton data of the 3D character; Provides image morphing function to transform 3D character's face shape, provides material script to control 3D character's color and color change over time and space, and controls blending between texture images of 3D character A material deformation module for providing a blend script; And a motion deformation module for providing a deformation of the motion of the 3D character based on motion data including a rotation change value and a movement value of the center of each skeleton of the 3D character. A computer readable recording medium having recorded thereon a program is provided.

Hereinafter, exemplary embodiments of the present invention will be described in detail with reference to the accompanying drawings. First of all, in adding reference numerals to the components of each drawing, it should be noted that the same reference numerals are used as much as possible even if displayed on different drawings. In addition, in describing the present invention, when it is determined that the detailed description of the related well-known configuration or function may obscure the gist of the present invention, the detailed description thereof will be omitted.

1 is a diagram schematically showing the internal structure of the character transformation program according to a preferred embodiment of the present invention.

Character deformation program 100 according to a preferred embodiment of the present invention is configured to include a body deformation module 110, a material deformation module 120 and a motion deformation module 130.

In addition, the basic structure of the script of the character transformation program 100 is written in XML (eXtensible Markup Language), and the data structure is written using Lua (LUA) to describe a direct mathematical function.

In the present invention, Lua is an extended programming language designed to support general procedural programming, and supports object-oriented programming, functional programming, and data-centric programming, and is a lightweight and powerful scripting language in combination with a programming language such as C or C ++. Can be used.

In addition, Lua is implemented as a library and is in the form of Clean C, a subset language similar to ANSI C or C ++, and does not have the concept of a main program to serve as an extension language. Or, because it is embedded (included) in the host program, the present invention calls a function that can execute Lua code in a script written in XML to describe the data structure as a direct mathematical function.

The body shape deformation module 110 according to a preferred embodiment of the present invention deforms the body shape of the 3D character by using vertex data that stores the appearance information of the 3D character, and the vertex data includes the 3D character. Vertex coordinate value of is stored.

In addition, when the body shape of the 3D character is deformed, the skin change is linked with the direction of the normal value of the vertex, so the normal data is referred to, and the vertex data is changed in conjunction with the texture image during the deformation of the body shape. Refers to texture data, and when changing the size of a 3D character, it refers to bone data.The vertex coordinate values of the vertex data are (vx, vy, vz), normal data. The normal coordinates are expressed as (nx, ny, nz), the texture coordinates of texture data are (tx, ty, tz), and the skeleton coordinates of skeleton data are expressed as (bx, by, bz).

The script used in the body deformation module 110 is included as a child element in the <deform> element, and functions related to the body deformation script are described in <deformVertex> ... </ deformVertex>.

In addition, the script used in the body deformation module 110 is composed of a function that can transform the vertex data of the general model and a function applied only to the characteristics of the character, and did not limit the vertex keyword to facilitate future expansion.

Body shape modification module 110 is composed of a function body script that modifies the argument value to a function of a predetermined function by using the structural form of XML and Lua script that can be modified by applying a variety of mathematical functions and algorithms .

Function body scripts consist of script functions that describe changes over time in vertex data of a general mesh structure. It is mainly used to move vertex data in the background model, and can be applied to any model in addition to the character.

The wave function, which changes the vertex data value in the form of a wave function, is used to express periodic movements such as movement or vibration caused by the character's breathing, and defines the shape of the wave and the div that controls the size of the wave. func, a base indicating how far the vertex falls from the original, an amp defining the maximum value of the deformation, a phase defining the starting position in terms of the basic shape of the wave, and the number of wave repetitions in one second. It consists of attributes such as freq, and is expressed in the form of "<wave div =“ ”func =“ ”base =“ ”amp =“ ”phase =“ ”freq =“ ”/>”.

The div corresponds to a unit of length of the skeleton and uses a function unit. func is Sin, which represents a sine wave, Triangl, which is a wave that grows in the shape of a mountain, and then becomes smaller at the top.Square that suddenly changes to the maximum and minimum values at regular intervals, Sawtooth and serrated wave, which are serrated waves. It is expressed as a string value expressed as a string such as InverseSawtooth. The base usually indicates the position of the center of the wave, positive for the position above the original surface, and negative for the position below. The amp calculates the absolute value of the positive or negative number set as the maximum change in the wave so that it does not change beyond the magnitude value set in the amp. phase is usually set to zero to start at its original shape.

Unlike the wave function, the move function that moves all the vertices of the character in a given direction is determined by the movement direction (x, y, z), and the size of the vertices actually moved is the value of the x, y, z movement multiplied by the amp value. The size is applied and expressed as "<move x =“ ”y =“ ”z =“ ”func =“ ”base =“ ”amp =“ ”phase =“ ”freq =“ ”/>”.

For example, if move = "10 0 0 sin 0 100 0 5", the maximum value of the actual movement is to move by 10 * 100 in the x-axis direction.

The normal function, which changes only the vertex normal value without moving the vertex, is used to create various effects by affecting various elements of the script, light shading, reflection, environment mapping, etc. that will be used after the normal value is transformed. Without effect, it is expressed in the form "<normal div =" "func =" "base =" "amp =" "freq =" ”/>".

The bulge function, which moves the bulging shape in the axial direction of the column, is used to design the shape of a curved column, which is expressed as "<bulge width =“ ”height =“ ”speed =“ ”/>”. do.

The table function, which describes the deformation part of the mesh as a table and applies the corresponding vertex value to the table one to one, transforms various vertex groups at once. Uses referencing the vertex table value of the previously defined table, properties that directly write the appropriate ratio according to the vertex when applying the table, or ratio specifying the periodic function that changes over time, and vertex indicating the coordinates used in the table. In the form of "<table name =" "use =" "ratio =" value | func base amp phase freq "/>".

For example, when expressing a face's fatness, the vertex coordinates corresponding to the state before and after the face data becomes fat are described in a table, and the fat deformation of the face part is given to an arbitrary character based on the vertex. To get it from the table and apply it.

The specified value of ratio means the ratio from the first vertex coordinate value in the table to the second vertex coordinate value. If the value of ratio is 0, it is the first vertex coordinate value. Value, and set the ratio to 0.5 to apply the intermediate value of the first and second vertex coordinates.

In addition, ratio can be described as a periodic property rather than a specified value between 0 and 1 in order to create an effect such as a character breathing so that the value can change with time. Must be between 0 and 1. For example, when ratio = "sin 0.5 0.5 0 0.5" is described, the breathing motion is expressed as the up and down times of the boat once every two seconds.

The vertex has coordinate values separated by -1 and should have a one-to-one correspondence. The vertex is expressed as either a source corresponding to the source of the table value or a target corresponding to the target of the table value, and "type =" source | target " In the form of ".

Lua script that transforms a character's vertices into various algorithms and mathematical functions, vertex coordinates, normal coordinates, and transformations that transform body shapes that are difficult to transform with only the function body script into a Lua script between <deformVertex> ... </ deformVertex>. Design an algorithm using skeletal coordinates.

In the present invention, when <deformScript> exists in <deformVertex> .... </ deformVertex>, all functions described in <deformScript> .... </ deformScript> are defined to be recognized as Lua scripts.

 <deformVertex> <deformScript name = "doublesize" vptr = "vertex"> <!-Luascript is here-> local temp = {} local nsize = vertex ["size"] for i = 0, nsize -1,4 do temp [i] = vertex [i] * 2 temp [i + 1] = vertex [i + 1] * 2 temp [i + 2] = vertex [i + 2] * 2 temp [i + 3] = vertex [i + 3] end return temp, nsize, 0 <!-Luascript is here-> </ deformScript>

Table 1 shows the algorithm that receives vertex coordinates and doubles them by using Lua script.

For example, specify the vertex data belonging to the skeleton corresponding to the belly of the character's figure, and express the fat bulging with the specified vertex data twice as far outward from the bone position. The written algorithm can be applied.

FIG. 2 is a view showing a character who bulges a boat by applying the lua script of Table 1. FIG.

If the Lua script in Table 1 is applied to the belly of the 3D character as shown in Figure 2A, the body shape is transformed into a 3D character with a bulging belly as shown in Figure 2B.

Implement the parsing part of the elements (deformVertex, deformScript) and attributes (name, wave, move, normal, bulge) used in the body deformation module 110. The class related to the shape transformation is ADSDformAction as the base class, and the basic transformation is performed by the deform function.Inheriting this class, the ADSDeformWave, ADSDeformNormal, ADSDeformBulge, ADSDeformMove, and ADSDeformTable classes are in charge of the function of the script. The base class name for calling and resolving body shape scripts is ADSDeform, and the function for resolving scripts is implemented in loadXML.

Material deformation module 120 according to a preferred embodiment of the present invention to support a two-dimensional image morphing (Morphing) function to control the face of the character, and to directly control elements related to the texture of the character in the function of the XML script do.

3 is a diagram illustrating feature points set in a face texture image according to an exemplary embodiment of the present invention.

In the present invention, as shown in FIG. 3, it is assumed that the face texture is basically expressed as one image in the process of controlling the character face image, and control the eyes, eyebrows, nose, and mouth, which are important elements of the face, with 47 feature points. To make it possible. Also, to make the character's face look naturally different, the script assigns feature points to all face textures to create an intermediate image of the character's transformation based on the location of the feature points.

In addition, in the present invention, the image morphing function supported by the material deformation module 120 applies a two-dimensional image morphing technique using a feature point to generate a middle face when the young face changes from an image of a young face to an older face. Has automatically generated images of middle age according to the transformation of texture images into female faces in their 60s.

In the present invention, the material deformation script includes a texture script indicating a texture of a surface and an image script for controlling deformation of an image.

The material of the character has factors related to the reflection of light, such as a shiny metallic feel, a soft skin feel, a roughness of the stone, etc. The ambient color depicts natural brightness with diffuse reflection, and the diffuse color depicts the basic color of the material. It is divided into reflective colors depicting intense light reflections and divergent colors depicting fluorescent or light bulbs.

Therefore, in the present invention, the function of adjusting the change of time and space of the basic color of the material is put in the material script, and the script function to control the blend function that can control the blending between the basic texture images.

The material function, which controls the elements corresponding to the character's material properties, determines the ambient light sensitivity, even if there is no light, the diffuse color that displays the base color of the material, and the reflectance of the light shining on the character. It contains the properties of emission, which describe the texture of an emitting object, such as specular and bulb, with r for red light, g for green light, and blue light. In the case of ratio, the string value defined in b and input to each attribute is expressed as Ag, Ab, Dr, Dg, Db, Sr, Sg, Sb, Er, Eg and Eb, and each string value is 0 to 1 It is expressed in the form of "<material ambient =" Ar Ag Ab "diffuse =" Dr Dg Db "specular =" Sr Sg Sb "emission =" Er Eg Eb "/>".

The rgbgen function, which changes the base color of the character's material or expresses periodic changes, uses the color specified by the vertex or works in conjunction with the wave function to brighten and express periodic changes.

The type property, which specifies the type of color to be used in the material script, is a periodic function that uses wave for changing colors, identity for setting the material's color as the default, and color values set in the modeling data of the material. In this case, enter the string value of the vertex, and enter the string values such as sin, triangle, square, sawtooth, and inversesawtooth for the wave attribute representing the periodic change of color.

The blendfunc function, which determines how a material is blended between images, enters a blend property that blends the colors of the image. When the type property is specified, the blend property is omitted because the blend according to the type property is used. blendfunc blend = "srcparam destparam" type = "add | filter | blend" /> "

The blend attribute blends the colors of the image by the operation of srcparam and destparam, where srcparam is a value that determines the proportion or type of the original color, and multiplies it by the source color. destparam is a value that determines the proportion or type of the target color. Multiply by

The type attribute of the blend attribute add if the srcparam and destparam values are 1, the filter if the blend attribute replaces the srcparam with the target color and the destparam is set to 0. The blend attribute's srcparam is 0 and the destparam is the original. To set the color, enter blend.

An image script is a script element that changes the coordinates of an image of a material and a texture. Most of the deformation of an image is expressed and a feature point of a face image is specified.

The map function, which defines the path and file name of the texture image, includes a name that describes the file name, including the path to the texture image file, and a type property that indicates the type of image to use. It displays the controlpoint function and displays the location of 47 feature points. The "<map name =" mapname "type =" base | light | env | face "/>" and "<controlpoint> x1 y1, x2 y2, x3 y3 , ..., x47 y47 </ controlpoint> ".

In the type property used in the map function, enter base for normal images, light for images used as lightmaps, env for environment maps, face for face images, and enter face. In this case, 47 two-dimensional coordinates must be input to the controlpoint function to define the image morphing criteria.

The tcmod function, which transforms texture coordinates, scales the texture coordinates up or down by sx and sy values, scrolls the texture coordinates by dx, dy, rotates the texture coordinates by theta, and rotates the texture coordinates with the given function. It is used for one-dimensional linear transformation, including attributes such as strech, and "<tcmod scale =" sx sy "scroll =" dx dy "rotate =" theta "stretch =" func base amp phase freq "transform =" m1. ..m5 "/>"

 <deformShader> <map name = "face20.jpg" type = "face"> <controlpoint> 0.1725 0.675, 0.235 0.7075, 0.3075 0.7175, 0.3725 0.7, 0.43 0.67, 0.235 0.7, 0.3075 0.71, 0.3725 0.695, 0.325 0.585, 0.2025 0.5875 , 0.275 0.6375, 0.3625 0.6375, 0.4175 0.5775, 0.3625 0.5375, 0.28 0.5375, 0.5775 0.6675, 0.6425 0.7025, 0.7075 0.7175, 0.7725 0.7075, 0.8275 0.6775, 0.6425 0.6975, 0.7075 0.71, 0.7725 0.6975, 0.6925 0.585, 0.595 0.5775, 0.6475 0.6375, 0.735 0.6325, 0.7975 0.585, 0.7275 0.5375, 0.655 0.535, 0.505 0.5825, 0.4375 0.3925, 0.5025 0.4, 0.555 0.3875, 0.38 0.285, 0.47 0.305, 0.525 0.305, 0.6175 0.285, 0.4675 0.2775, 0.5 0.265, 0.53 0.2775, 0.44 0.27, 0.5 0.265, 0.56 0.2725, 0.435 0.24, 0.5 0.2275, 0.5725 0.24 </ controlpoint> </ map> <map name = "face60.jpg" type = "face"> <controlpoint> 0.1825 0.68, 0.235 0.7125, 0.3075 0.72, 0.3675 0.715, 0.4225 0.6975, 0.24 0.695, 0.305 0.705, 0.37 0.7, 0.3075 0.5925, 0.205 0.5825, 0.2625 0.6175, 0.3575 0.64, 0.4 0.577 5, 0.35 0.5425, 0.2775 0.5425, 0.5775 0.6925, 0.6375 0.7175, 0.7075 0.72, 0.7725 0.71, 0.8175 0.68, 0.64 0.7, 0.7075 0.7025, 0.7675 0.6925, 0.6925 0.59, 0.6025 0.5775, 0.65 0.6375, 0.7375 0.6175, 0.795 0.58, 0.7275 0.55, 0.6575 0.54, 0.505 0.5825, 0.4375 0.3925, 0.5025 0.4, 0.555 0.3875, 0.3825 0.2725, 0.465 0.3075, 0.53 0.31, 0.615 0.2725, 0.4675 0.2775, 0.5 0.2675, 0.53 0.2775, 0.44 0.27, 0.5 0.2675, 0.56 0.2725, 0.435 0.2375 0.5 0.225, 0.5725 0.24 </ controlpoint> </ map> </ deformShader>

Table 2 shows the script that changes the character's face image. The face that is halfway between the 20's and 60's face images using the face20.jpg file, which is the face image of the 20s, and the face60.jpg file, which is the face image of the 60s. Automatically generate an image. As shown in Figure 4, the image generated by the texture morphing function by the script in Table 2 is shown in Figure 4B, Figure 4A is the original image face20.jpg, Figure 4C is the target image face60.jpg.

In the present invention, all functions for driving the material deformation module 120 are present between <deformShader> and </ deformShader>.

Like the body transformation script, the basic form uses the Document data structure of the TinyXML class and connects the elements and attributes expressed in the material script to the texture and material variables of the character so that they can be rendered at render time.

The motion deformation module 130 according to a preferred embodiment of the present invention deforms the motion of the 3D character based on the motion data including the rotation change value and the center movement value of each skeleton of the 3D character.

The motion data applied to the character is composed of basic skeleton information and basic skeleton information that can know the configuration of the skeleton, the motion capture data of the BVH file is a typical example.

 // skeletal information of skeleton HIERARCHY ROOT Hips {OFFSET 0 -2 0 CHANNELS 6 Xposition Yposition Zposition Zrotation Xrotation Yrotation JOINT LeftHip {OFFSET 9.24534 0 0.0065797 CHANNELS 3 Zrotation Xrotation Yrotation JOINT LeftKnee {OFFSET 0 -39.9265 0 CHANNELS 3 Zrotation JOINT Left {OFFSET 0 -38.6177 0 CHANNELS 3 Zrotation Xrotation Yrotation End Site .............. Middle omitted JOINT Head {OFFSET -0.0493344 11.713 -0.444875 CHANNELS 3 Zrotation Xrotation Yrotation End Site {OFFSET 0.298768 11.7265 0.856213}}}}} // Motion Data MOTION Frames: 165 Frame Time: 0.033333333 0.4223 85.8318 -0.4882 2.4007 2.7725 1.9305 ... (Omitted) 0.3766 85.8723 -0.4500 2.2092 2.6025 1.9741 ...... (Omitted) 0.3594 85.8987 -0.4216 2.0 903 2.4808 2.0241 ... (Omitted) 0.4223 85.8318 -0.4882 2.0403 2.4762 2.0402 ... (Omitted) .... Mid omitted .... 2.3061 85.9629 0.5953 2.0180 1.6200 -0.6675 ..... (Omitted) 2.2931 85.9644 0.6052 1.9909 1.6288 -0.6267 ... (Omitted)

Looking at Table 3, the first part contains the skeleton information of the motion-captured character, and the second part captures the number of captured frames, the number of frames per second of data, and the movement and rotation values of the motion data.

Skeleton information in the header portion of the BVH file includes the structure and length of the skeleton, the type of motion data connected, and the number of data shown below is determined from this header information. In general, all skeletons can have movement and rotation values in six degrees of freedom, but most skeletons have only rotation values except for the skeleton that corresponds to the first route. Based on such information, the actual operation data is placed behind.

The motion data displays the total number of frames and the number of frames to be processed in one second, and then expresses the movement information of all the skeletons in one line. In the case of Table 3, since the entire frame is 165, the motion data is represented by 165 rows, and the first term in each line is interpreted as a one-to-one correspondence in a manner corresponding to the first of the degrees of freedom defined in the header.

The character motion element controlled by the script in the motion transformation module 130 according to a preferred embodiment of the present invention is a rotation change value and a character center movement value of each character skeleton. Motion data of the 3D character by motion capture are 19 rotation values and 1 movement value.

This is generally data about a specific person or character's motion, and in order to apply the motion data to a specific character, the motion data must be corrected or deformed, so the motion deformation module 130 changes the skeleton, and the motion data to fit the changed skeleton. Include <bonemodifier> to change the and <motionmodifier> to change the motion irrespective of the skeleton, so that it exists between <deformMotion> and </ deformMotion>.

The functions used between <bonemodifier> and </ bonemodifier>, which are used to transform data between motions with different skeletons, are the rotate function, which stretches the skeleton while maintaining the motion, and the Stretch function, which changes the length of the skeleton.

The rotate function describes the jointname that sets the name of the joint whose angle is to be changed, and the deformation angle of the joint in degrees in the order of the x-axis, y-axis, and z-axis to apply rotation in the order of x, y, z. Contains attributes of rotatedelta.

The stretch function modifies its behavior to preserve the position of the lowest joint in the subsequent bones when the two or more subsequent bones are deformed together.The jointname property of the stretch function includes the name of the top joint of the joints whose length is to be changed. And enter the change depth. The depth of change indicates the depth of the joint to be changed in length. The default value of the change depth is 1, and when the change depth is set to 0, the distance to the lowest child of the descendants of the joint to be changed is set as the change depth. For example, if two or more joints are deformed together, enter the deformation depth as two or more.

In addition, the stretch function includes a stretchratio property that sets the length change ratio of each joint. The stretchratio property of a function that increases or decreases the length of the joint by the length ratio is the number of change depths of the jointname property and the length ratio of the stretchratio property. Must match, and if the length ratio is 1, the original length is preserved, and if 2, it is twice the original length.

 <bonemodifier> <rotate jointname = "root" rotatedelta = "0 90 0" /> </ bonemodifier>

Table 4 shows the script that rotates the character within the bonemodifier. Motion is applied to the armature, which rotates the entire arm by 90 degrees along the y axis, while maintaining the final motion seen by the user.

The function used between <motionmodifier> and </ motionmodifier>, which transforms a certain section of motion without skeletal deformation due to character characteristics, situational factors, and specific constraints, rotates and transforms the motion in a specific frame. Rotate function to interpolate the motion before and after the frame and translate function to move the root of a specific frame according to the position of a specific joint and interpolate the position value before and after the frame.

The rotate function rotates in order of the jointname that sets the name of the joint whose motion is to be changed, and the targetframe, the x-axis, the y-axis, and the z-axis that indicate the position of the target frame whose motion is to be changed from -1, 0 to the total number of frames. These include attributes such as rotatedelta, which indicates the angle of change of motion to be applied, interpolation that interpolates from the interpolation start frame to the end of the interpolation frame, and rotateabs, which indicates the final angle of the joint.

The default value of the targetframe property is -1, and if it is -1, it means to change for all frames.

In the interpolation attribute, the demper interpolates only the joint, but the endeffector also affects the motion of the lower joint of the target joint.

The rotateabs attribute can be used instead of the rotatedelta attribute. For example, if you don't want to set the target angle for the x-axis, you can write x at the position of the target angle on the x-axis.

The translate function is used to set the name of the joint that is the reference for calculating the positional movement of the root, the targetframe indicating the position of the target frame whose motion is to be changed from -1, 0 to the total number of frames, and the change of the position of the reference joint. It includes attributes such as translatedelta describing the delta, interpolating the positional movement from the start frame of the buffer to the end of the frame through the target frame, and translateabs indicating the position of the joint.

The translatedelta attribute describes the positional change of the reference joint in the form of deltaX deltaY deltaZ, and the translateabs attribute can be used instead of the translatedelta attribute. For example, if you do not want to set the target position with respect to the x position, substitute x.

 <motionmodifier> <rotate jointname = "left_upper_leg" targetframe = "1000" rotatedelta = "-90 0 0" interpolation = "demper 0 2000" /> </ motionmodifier>

Table 5 shows a script that rotates the character's left knee 1000 degrees further 90 degrees along the x-axis. Smooth interpolation between 0 and 2000 frames using a cosine curve.

The present invention utilizes a universal XML grammar parsing module to interpret structural scripts in XML format and uses the TinyXML class to ensure the safety of basic grammar parsers.

The motion transformation script interprets the motion movement and rotation information described in XML and the deformation of the data controlled by Lua script using motion capture data of BVH format as input data.The important class to interpret this is ADSDeformMotion class. In this case, the role of modifying and executing scripts in ADSBoneMotion is the role of modify function.

Driving the character transformation program 100 according to the preferred embodiment of the present invention displays a basic screen as shown in FIG.

In the present invention, the character transformation program 100 receives the data in the VRML format, and the texture image can be called and stored in the JPG, TGA format, and modify the motion by applying the motion capture data of the BVH format to the character.

6A is a diagram illustrating a screen for setting a skeleton of a character in a character transformation program according to an exemplary embodiment of the present invention.

The character transformation program 100 according to the preferred embodiment of the present invention generates model data by loading basic shape information and image information of a three-dimensional character. To modify the behavior of a 3D character, you need to set up the skeleton information.

Therefore, in the present invention, the character deformation program 100 provides a function of setting 19 skeleton information in a 3D character and provides a function of setting 16 finger joints.

6B is a diagram illustrating a screen for setting rotation on a skeleton set in a character transformation program according to an exemplary embodiment of the present invention.

Based on the skeletal information set for the 3D character in FIG. 6A, it is necessary to determine how much the rotation value is applied to the joint for each vertex, which is expressed as a skin specific gravity value. This is because the naturalness of the animation is determined by the skin specific gravity value.

The above description is merely illustrative of the technical idea of the present invention, and those skilled in the art to which the present invention pertains may make various modifications and changes without departing from the essential characteristics of the present invention. Therefore, the embodiments disclosed in the present invention are not intended to limit the technical idea of the present invention but to describe the present invention, and the scope of the technical idea of the present invention is not limited by these embodiments. The scope of protection of the present invention should be interpreted by the following claims, and all technical ideas within the scope equivalent thereto should be construed as being included in the scope of the present invention.

As described above, according to the present invention, by providing a deformation of the existing three-dimensional character produced by using the character transformation program, the character who is alienated from the user is deformed to give a satisfaction to the user using the character, the produced character It has the effect of dramatically reducing the time and effort spent modifying the system.

Claims (4)

In the recording medium recording a program for deforming a three-dimensional character, the program, Body shape modification script for deforming the body shape of the 3D character by using vertex data storing the appearance information of the 3D character and referring to normal data, texture data, and skeleton data of the 3D character Body deformation module for providing a Lua script; It provides an image morphing function for modifying the shape of the face of the three-dimensional character, provides a material script for adjusting the color of the three-dimensional character and the change over time and space of the color, and the texture image of the three-dimensional character A material deformation module for providing a blend script to control mixing between; And Motion deformation module that provides a deformation of the motion of the three-dimensional character based on the motion data including the rotation change value and the movement value of the center of the skeleton of the three-dimensional character And a computer readable recording medium having recorded thereon a program for deforming a three-dimensional character. The method of claim 1, wherein the Lua script, And a mathematical function for deforming the body shape of the 3D character, and inputting the vertex data, the normal data, the texture data, and the skeleton data to the mathematical function. Computer-readable recording medium. The method of claim 2, wherein the material deformation module, 47 feature points are set in the face image of the 3D character, and while the face of the 3D character is deformed based on the feature point, an intermediate image for deforming the 3D character according to the position of the feature point is generated. A computer-readable recording medium having recorded thereon a program for deforming a three-dimensional character. The method of claim 1, wherein the motion modification module, A computer for recording a program for deforming a three-dimensional character, providing a function of setting skeleton information of the three-dimensional character and providing a function of setting a rotation value of the skeleton information set in the three-dimensional character. Readable record carrier.

Images