Файл:Banner wiki transparent(mini).png

2011-06-16T16:11:43Z

Sodiet:

Обсуждение файла:Banner wiki transparent.png

2011-06-16T16:10:46Z

Sodiet: Новая страница: «Уменьшенная версия баннера(размер: 500*63) Файл:Banner_wiki_transparent(mini).png »

Уменьшенная версия баннера(размер: 500*63)

[[Файл:Banner_wiki_transparent(mini).png ]]

Создание новой сущности

2011-06-16T11:07:08Z

Sodiet: Новая страница: «<!-- Please enter the information about your article for each section after the equal sign. The information will be translated into a formatted page upon b...»

[[Категория:Lua]]
{{Статья
|автор=ins
|переводчик=Sodiet
|сложность=Средняя
|совместимости=All
|требования=Текстовый редактор
|добавлена=03/08/08
|обновлена=16/06/11
}}



}}
= Creating a new entity =
In this document we will go through creating a new entity (in Lua), with support for flowgraphs.
I’ll be using MyMod and MyEntity to identify our mod and the new entity. You can of course change this to whatever you like.

== Lua compiler ==
It is handy to have a lua compiler to check for syntax errors in your script files. Also, the 'Reload Script' button in the Sandbox Editor uses this.
[[Image:Lua_entity_tutorial_reloadscript.jpg]]

You can get the lua compiler [http://www.crymod.com/attachment.php?attachmentid=7970 here].

Extract LuaCompiler.exe to <crysis folder>/bin32/ or <crysis folder>/bin64/

== Setting up an entity ==
Now, let's get started. First of all we’re going to create a mod folder. Browse to your Crysis folder and create a Mods folder. In that folder create a MyMod folder.
Next, let’s create a shortcut in that folder so we can launch the editor with our mod loaded. We have to add –MOD MyMod to the shortcut so the editor knows what mod to load. It could be something like this:

{{SimpleBox|"C:\Program Files\Electronic Arts\Crytek\Crysis\Bin32\Editor.exe" -MOD MyMod}}

After that, we need to let the engine know we have a new entity which needs to be loaded. We will need to create a new folder in our mod-directory: Game, and in there another new dir: entities. In that folder create a new file called MyEntity.ent.

Now let’s edit our created MyEntity.ent in a text-editor of your choice. This is the content that needs to be in the file:

{{SimpleBox| <nowiki><Entity Name="MyEntity" Script="Scripts/Entities/MyMod/MyEntity.lua" /></nowiki>}}

Let’s look at that a bit closer. It’s just a simple xml file with the name in it, and the location to a .lua file. We will create that scriptfile in the next chapter. Let’s get to the scripting part.

== The entity script (basics) ==
Now that we have the entity setup, we need to create the lua file for it. The lua file will contain the code and the properties of our entity. If you look at our MyEntity.ent file you can see the path Scripts/Entities/MyMod/MyEntity.lua. We need to create this file, as it doesn’t exist yet.

{{Warning
|Because Sandbox doesn’t like editing and reloading entities from our mod-folder, we will develop our entity inside the default Crysis/Game/ folder. Once our entity is ready, we can move it to our Mod folder.
}}

Let’s create a new file in Crysis/Game/Scripts/Entities/MyMod/ (create directories if needed). The file name should be MyEntity.lua, which is specified in our MyEntity.ent file. Now that we have our new file, open it in a text editor. I will now go step by step and analyze the code we have to type. If you want, you can copy and paste the whole file at the end of this tutorial.

{{Lua_Code|notable=1|
<source lang="lua">
MyEntity = {
Properties = {
fMessageDuration = 10.0,
sMessage = "Use me",
bDoesNothing = 0,
object_MyModel = "Editor/Objects/objective.cgf",
Colors = {
clrColor = {x=1, y=0, z=0 },
},
},
Editor = { Icon= "Target.bmp", },
};
</source>
}}

Let’s analyze that code a bit. First we define our entity with

{{SimpleBox|<nowiki>MyEntity = { … }</nowiki> }}

Next we set up our Properties. Everything in here will be properties you can adjust in the Sandbox editor, like in the picture on the right, which are the properties of the Tornado entity.
Our properties are:

{| style="border: 1px solid black; background-color: #3F3F3F"
|-
| fMessageDuration
| The time a message will be shown when we use our entity.
|-
| sMessage
| The actual message to show.
|-
| bDoesNothing
| This actually does nothing
|-
| object_MyModel
| The model that our entity has
|-
| clrColor
| The color of our message
|}

A few things to note: our variables have prefixes like f,s,b,clr,object_ . They are there for a reason. It lets Sandbox know what kind of variable it is. That way we can’t put in text in our MessageDuration, we get a Open file dialog for our models, etc… . Here’s a small list with the most common prefixes:
{| style="border: 1px solid black; background-color: #3F3F3F"
|-
|b
|boolean
|-
|s
|string
|-
|f
|float
|-
|object_
|model(with file open dialog)
|-
|clr
|Color (with colorpick dialog)
|}

Also note that our clrColor is in another table in the Properties table. This way we will have a subcategory in Sandbox. After our Properties come the Editor properties. Here we set the Icon which sandbox will use.

{{SimpleBox|<nowiki> Editor = { Icon= "Target.bmp", }, </nowiki>}}

After that you can also set up some private variables which you can use in the scripts. But for this tutorial we won’t need those.

We can already take a peek in the editor, and I suggest you do so. That way we can check if our files are in the right place, and if the editor loads our file.

So browse to our mod folder we created and launch the editor via the shortcut to sandbox.
No need to load a map, in the rollup bar select Entity and there we should find our entity listed, nicely found in a map called MyMod.

If that isn’t the case, something is wrong. Make sure you did everything right, launched the editor with our shortcut, made the .ent file, made the .lua file.

If you double click our entity you should see our properties we defined in the lua file:

[[Image:Lua_entity_tutorial_properties.jpg]]

Here you can also see what the prefixes have done. Also note that everything is sorted alphabetically, without prefixes.

Now, our entity has some properties, but it doesn’t do anything. You can even try to set a model, it won’t show up. So let’s code that in first. (No need to close the Editor now, we can keep it open for quick debugging) Open the MyEntity.lua script again and add

{{Lua_Code|notable=1|
<source lang="lua">
function MyEntity:OnInit()
self:OnReset();
end
</source>
}}

The OnInit function gets called when our entity gets initialized, typically when loading the map. We call a function called OnReset(), which we will now make.

{{Lua_Code|notable=1|
<source lang="lua">
function MyEntity:OnReset()
if (self.Properties.object_MyModel ~= "") then
self:LoadObject(0, self.Properties.object_MyModel);
end
end
</source>
}}

There’s a bit more to explain now. The function gets called on its own when we jump into the editor. (We also call it from OnInit here, which is pretty common)

This first checks if the model is not an empty string. After that it loads the model. Save your file now.
Let’s get back to the editor. Open a map if you didn’t do so yet. Place the MyEntity entity on it. You should see a model now. If not, reload the entity script via the Reload Script button.

Now try changing the model again. It doesn’t seem to work. We need to add some more code for that.

{{Lua_Code|notable=1|
<source lang="lua">
function MyEntity:OnPropertyChange()
self:OnReset();
end
</source>
}}

OnPropertyChange() gets called whenever we change a property in the editor. Because of that, we need to reload the model. So we call OnReset again which will load the new model.

Let’s take a look at what we have by now. An entity which has a model, we can change that model, but that’s about it. It doesn’t do anything. Let’s make it so we can use our entity.

{{Lua_Code|notable=1|
<source lang="lua">
function MyEntity:IsUsable(user)
return 2;
end

function MyEntity:GetUsableMessage(idx)
return self.Properties.sMessage;
end
</source>
}}

The first function IsUsable() returns 2. This makes it so that we can use our entity. The second function defines what message we will get when we want to use the entity. We return the message we set in our properties. Now our entity will be useable, but it still won’t do anything. For that, we need, you guessed it, more code.

{{Lua_Code|notable=1|
<source lang="lua">
function MyEntity:OnUsed(user, idx)
CryAction.Persistant2DText(
string.format("Used> %s", self.Properties.sMessage),
2,
self.Properties.Colors.clrColor,
"OnUsed",
self.Properties.fMessageDuration
);
end
</source>
}}

What this does is print a message to our screen. The message is “Used: OurMessage”, OurMessage gets replaced with the message specified in the properties.

Second argument is the size of our message, currently set to 2.

Next argument is the color, we also get it from the properties.

4th argument is the name of the message 5th and last argument is the duration of our message, in seconds.

We can try that out now, jump back to the editor, click the reload script button and jump ingame. Run up to our entity and press ‘f’. You should see the message specified in the properties. Try changing some of the values in the properties panel and jump ingame to see the results.

This is what you should have by now:
{{Lua_Code|notable=1|
<source lang="lua">
MyEntity = {
Properties = {
fMessageDuration = 10.0,
sMessage = “Use me”,
bDoesNothing = 0,
object_MyModel = "Editor/Objects/objective.cgf",
Colors = {
clrColor = {x=1, y=0, z=0 },
},
},
Editor = { Icon= "Target.bmp", },
};

function MyEntity:OnInit()
self:OnReset();
end

function MyEntity:OnReset()
if (self.Properties.object_MyModel ~= "") then
self:LoadObject(0, self.Properties.object_MyModel);
end
end

function MyEntity:OnPropertyChange()
self:OnReset();
end

function MyEntity:IsUsable(user)
return 2;
end

function MyEntity:GetUsableMessage(idx)
return self.Properties.sMessage;
end

function MyEntity:OnUsed(user, idx)
CryAction.Persistant2DText(
string.format("Used> %s", self.Properties.sMessage),
2,
self.Properties.Colors.clrColor,
"OnUsed",
self.Properties.fMessageDuration
);
end
</source>
}}

== Extending our entity ==
We have a basic entity now, let’s add some more interesting/advanced stuff. We will base this on the entity we just made. First, let’s make our model physicalized. We will make a new function for this called PhysicalizeThis, and call it in the OnReset function.

{{Lua_Code|notable=1|
<source lang="lua">
function MyEntity:OnReset()
if (self.Properties.object_MyModel ~= "") then
self:LoadObject(0, self.Properties.object_MyModel);
end
self:PhysicalizeThis(); -- This is the new line
end

function MyEntity:PhysicalizeThis()
local Physics = {
bRigidBody=1,
bRigidBodyActive = 0,
bRigidBodyAfterDeath =1,
bResting = 1,
Density = -1,
Mass = 5,
};
EntityCommon.PhysicalizeRigid( self, 0, Physics, 1 );
end
</source>
}}

In the PhysicalizeThis function we define Physics which contains some vars you should recognize from the editor. Then we pass them along EntityCommon.PhysicalizeRigid(). And now our model is physicalized, it’s that simple.

We can jump in the editor and knock over our entity now. One of the last things we will do now is clone our entity when we press it. Lets’ get coding. We need to add code when we use our entity, so let’ go there and call a new function.

{{Lua_Code|notable=1|
<source lang="lua">
function MyEntity:OnUsed(user, idx)
CryAction.Persistant2DText(
string.format("Used> %s", self.Properties.sMessage),
2,
self.Properties.Colors.clrColor,
"OnUsed",
self.Properties.fMessageDuration
);
self:Clone(); -- This is the new line
end

function MyEntity:Clone()
local clone = { class = "MyEntity", };
clone.properties = self.Properties;

local ent = System.SpawnEntity(clone);
local pos = self:GetPos();

pos.x = pos.x + 1;
ent:SetPos(pos);
end
</source>
}}

This clones our entity. First we set the class to MyEntity, which will spawn our entity with the default values. We want the settings of our main entity though, so we copy the properties of our self. Then we spawn the entity, get the position of our main entity and increase the x value by 1. This will make it so we can actually see if it’s cloned or not. After that, we set the position again to our new position.

And done, we got our cloning function. You can test it out in the editor.

== Adding flowgraph support ==
For this particular entity it’s a bit stupid, but it’s the idea that counts. All the flowgraph info goes into FlowEvents. We have to define that, so let’s do that now.

{{Lua_Code|notable=1|
<source lang="lua">
MyEntity.FlowEvents = {
Inputs = {
Clone = { MyEntity.Event_Clone, "bool" },
Message = { MyEntity.Event_Message, "string" },
},
Outputs = { Used = "bool", },
}
</source>
}}

When we look at it for a second, it doesn’t seem that hard. We have the inputs and the outputs part. In the Inputs part we got a Clone and a Message. In the output we have a Used which will get called when we used our entity.

But what’s the stuff after Clone = and Message = ? MyEntity.Event_Clone and MyEntity.Event_Message, where does that come from? You’re right, it comes out of nowhere, so we need to declare some functions.

{{Lua_Code|notable=1|
<source lang="lua">
function MyEntity:Event_Clone(sender)
self:Clone();
end

function MyEntity:Event_Message(sender, msg)
self.Properties.sMessage = msg;
end
</source>
}}

Event_Clone just calls our Clone function we made earlier. With Event_Message we can change our property sMessage from the flowgraph. That covers our Inputs, but how are the outputs handled? We need to add some code that triggers that event, and it’s actually quite simple:

{{Lua_Code|notable=1|
<source lang="lua">
function MyEntity:OnUsed(user, idx)
CryAction.Persistant2DText(
string.format("Used> %s", self.Properties.sMessage),
2,
self.Properties.Colors.clrColor,
"OnUsed",
self.Properties.fMessageDuration
);
self:Clone();
self:ActivateOutput( "Used" ,true ); -- This is the new line
end
</source>
}}

We just set that Used value we defined earlier in the output Flowevents and set it to true.

That was it, our flowgraph should work now. Let’s give it a little test. Go to the editor and reload your entity, then click on the Create button under Flowgraph. Give it some name and then we got a blank flowgraph. Now rightclick and select ‘Add Graph Default Entity’. We have the entity on our flowgraph now.

Let’s give it a little test:

[[Image:Lua_entity_tutorial_flowgraph_sample.jpg]]

And now once we use our entity, we will see a “Flowgraph is here” message. Note that it this will only show on the original entity. So that sums it up, we have a custom entity which doesn’t do anything spectacular, with flowgraph support.

== Full code ==

{{Lua_Code|notable=1|
<source lang="lua">
MyEntity = {
Properties = {
fMessageDuration = 10.0,
sMessage = "Use me",
bDoesNothing = 0,
object_MyModel = "Editor/Objects/objective.cgf",
Colors = {
clrColor = {x=1, y=0, z=0 },
},
},
Editor = { Icon= "Target.bmp", },
};

function MyEntity:OnInit()
self:OnReset();
end

function MyEntity:OnReset()
if (self.Properties.object_MyModel ~= "") then
self:LoadObject(0, self.Properties.object_MyModel);
end
self:PhysicalizeThis();
end

function MyEntity:OnPropertyChange()
self:OnReset();
end

function MyEntity:IsUsable(user)
return 2;
end

function MyEntity:GetUsableMessage(idx)
return self.Properties.sMessage;
end

function MyEntity:OnUsed(user, idx)
CryAction.Persistant2DText(
string.format("Used> %s", self.Properties.sMessage),
2,
self.Properties.Colors.clrColor,
"OnUsed",
self.Properties.fMessageDuration
);
self:Clone();
end

function MyEntity:PhysicalizeThis()
local Physics = {
bRigidBody=1,
bRigidBodyActive = 0,
bRigidBodyAfterDeath =1,
bResting = 1,
Density = -1,
Mass = 5,
};
EntityCommon.PhysicalizeRigid( self, 0, Physics, 1 );
end

function MyEntity:Clone()
local clone = { class = "MyEntity", };
clone.properties = self.Properties;

local ent = System.SpawnEntity(clone);
local pos = self:GetPos();

pos.x = pos.x + 1;
ent:SetPos(pos);
end

function MyEntity:Event_Clone(sender)
self:Clone();
end

function MyEntity:Event_Message(sender, msg)
self.Properties.sMessage = msg;
end

MyEntity.FlowEvents = {
Inputs = {
Clone = { MyEntity.Event_Clone, "bool" },
Message = { MyEntity.Event_Message, "string" },
},
Outputs = { Used = "bool", },
}
</source>
}}
[[Category:Lua]]

2011-06-11T09:46:07Z

Sodiet:

{{В_процессе_перевода}}

== Персонаж первого лица==

=== Обзор ===
Данный документ рассказывает о создании комплектов оружия, если быть точнее, предоставляет пример оружия, основную анимацию и объясняет процесс экспорта в движок.
Другие пакеты будут рассмотрены после появления экспотеров для них
=== Характеристики оружия===
==== Настройки геометрии====

[[Image:FirstPersonCharacters_image001.jpg]]

На данном изображении вы видите пример меша пары рук, обычно использующийся для создания вооружения персонадам от первого лица

Локальные трансформации этого меша должны быть нулевыми по всем осям. А центр ("pivot") располагаться в центре всемирных координат(Position 0,0,0; Rotation 0,0,0)

{{Примечание|Меш/Геометрия должны быть всегда в центре всемирных координат без вращения}} 

==== Иерархия рук ====

Ниже иерархия будет использоваться для изменения геометрии рук. Заметьте, что основани, являющееся верхней костью в иерархии, также расположено во всемирном центре и не имеют примененного вращения.

[[Image:Sandbox_FirstPersonCharacters_image002.jpg]]

Три красные кости в предплечьях являются хелперами запястья и используются для деформации запястий. Они имеют простое выражение, которое соединяет кости рук во время вращения по оси X

{{Примечание|Как раз сейчас удобно перевести позицию и вращение всех элементов иерархии в значение 0. Таким образом вы будете иметь функцию возврата назад.}} 

[[Image:Sandbox_FirstPersonCharacters_image003.jpg]]

Полностью вся иерархия рук в схематичном виде

[[Image:Sandbox_FirstPersonCharacters_image004.jpg]]

Хелперы запястий должны быть скрыты после после применения оператора границы, чтобы они не были случайно анимированы. Это заставило бы прикладные выражения становиться неэффективными.

Необязательно сохранять точно такую же иерархию структуры, использующуюся здесь. Also changing the way the wrists are solved is possible.

==== Вес геометрии====

{{Примечание|Обычно применяется модифицируя и уничтожая в стеке модификаторов для того, чтобы вы могли применить модификатор границ. Это удаляет неважные и ненужные для геометрии образования, которые в будущем могут стать причиной проблем.}

[[Image:Sandbox_FirstPersonCharacters_image005.jpg]]

Оператор, примененный в 3Ds MAX, не имеет значения. Вы можете использовать или Physique, или Skin при создании веса геометрии. Оба поддерживаются движком

{{Примечание|title=Информация|Когда вершины одновременно влияют на более, чем две кости, вес на одной из них, влияющее меньше всего. будет удален и восстановлен после того, как в зоне влияния останутся две кости:}}

В нашем примере Skin используется для веса костей рук. Модификатор имеет значение 0, но кроме этого есть еще и значение стандартной позиции, настроенной ранее. Это значение стандартно в движке и помогает в процессе отладки.

Только кости, необходимые для деформации меша в настройках путей, добавлены в лист костей модификатора
Only bones which are necessary to deform the mesh in a proper way were added to the bone list in the modifier.

[[Image:Sandbox_FirstPersonCharacters_image006.jpg]]

{{Примечание|title=Информация|Кости в иерархии, имеющие отрицательное значение в начале своих имен, будут игнорироваться экспортером. Это оставляет размер экспортируемого персонажа малым. В данном пункте они были в иерархии слева для создания легкой связки выделения, когда используется физический модификатор. }}

==== Экспорт персонажа====

Когда вы закончили настройку веса персонада, вы готовы к экспорту рук в движок.
Если плагин установлен в директорию 3Ds MAX, то будет виден на командной панели во вкладке утилиты. Выделите вашу геометрию рук и нажмите "Add selected" в секции "Object Export", если она не была автоматически добавлена. В секции "Bone Export" это автоматически должно добавить самый верхний узел иерархии, путей в этом случае

[[Image:Sandbox_FirstPersonCharacters_image007.jpg]] 

Set the Drop-down-list in the “Object Export” section under “Export To” to “Character (*.chr), and click the “Export Nodes” button. This exports a compiled version of your object to the same folder your max-file has been saved to. If you want to specify a different name for your character (which is usually generated from the name of the max-file) you can specify one by activating the option below the “Export To” drop down list. Exporting is only possible to the same folder that the max-file resides in, or to a sub-folder from that one.

Now you can open the Character Editor under “view” in the editor…

[[Image:Sandbox_FirstPersonCharacters_image008.jpg]]

…and load your character.

[[Image:Sandbox_FirstPersonCharacters_image009.jpg]]

The big green arrow shows you the “forward direction” in the engine, which all characters should be facing to (Y+).

=== 1st Person Weapon===

==== The Weapon Geometry====

Now that the arms model is ready, we can prepare a weapon to use with it. Here you can see a basic weapon model, with some elements highlighted in red.

[[Image:Sandbox_FirstPersonCharacters_image010.jpg]]

'''Tip:''' 
To make the weighting process more convenient, you can move away the parts which are meant to be animated later and should get their own bones, by a known amount of units or its multiples. Later after you applied your weighting modifier you can easily move them back to their original position by animating the bones they have been weighted to, the same amount you moved them apart from the main model earlier.

For the geometry the same rules apply like have been pointed out in the arms section.
No translations should be applied to the geometry, and before applying the weighting modifier do a reset-x-form, and collapse it in the modifier stack, to get rid of unwanted transforms. The pivot should be aligned to the world coordinate center, and the model should point in the positive y-direction.

==== The Weapon Hierarchy====

The same transformation rules should be kept for the bones you create for the weapon hierarchy, or at least to some of them which serve a specific purpose.
In 3ds max it doesn’t matter if bones or helpers (dummies) are used to define a hierarchy. The exporter treats them both as bones when they are exported.

[[Image:Sandbox_FirstPersonCharacters_image011.jpg]]

All those names can be changed code wise of course; the names here are for demonstration purposes.

Weapon Term: used to attach the muzzle-flash effects to.
Shells: used to attach the particle effect for the shells to.
Collision: used for determining the position of impact when used as a melee weapon.
Various attachment helpers, which are used to control the position of weapon parts. (attachment_top; attachment_side; attachment_bottom; etc)

Helpers or bones which don’t influence elements or parts of the weapon geometry, won’t need to be added to the deform modifier. Make sure they are added to the hierarchy before exporting the character, or they won’t be accessible by the engine.

'''Note:''' 
Before a deforming modifier is applied, merge in the arms character from its source max-file, and parent the highest node from the weapon rig under the root bone of the arms character.

[[Image:fixed_FirstPersonCharacters_image012.jpg]]

'''Hint:''' 
When using the Physique modifier chose the highest node in the hierarchy with which you want to deform your mesh upon initialisation.

==== Exporting the Weapon====

After weighting is done, you can export your character to the engine. For this select the mesh of your weapon, go to the Cryengine rollout in the utilities pane of the command panel and add it to the node section. Switch to “Character” under “Export to...” and click the “Export Nodes” button. This exports your character into the same folder as the max file and inherits the name of your max file. You can also specify the name manually using the custom file name option.

In order to view your character in the Character Editor with the mesh skinned to the bones, you have to add them as a “skin attachment” by setting the choice to “skin” in the attachments properties, selecting the arms object, and then creating a “new” attachment. After you hit “Apply” the character is attached to the bones, and becomes visible in the editor.

[[Image:FirstPersonCharacters_image013.jpg]]

=== Animations for 1st Person Characters===

==== Preliminary tasks====

In order to have the Resource compiler handling the 1st person weapons correctly you have to create an entry in the animations.cba file. In this file all information concerning your character is stored, i.e. compression ratio of animations, the path to the character etc.
Here is a sample entry which has all the required settings for a 1st person weapon. For a detailed description of these parameters, see the reference document on the CBA file parameters. (LINK)
If this entry is missing the exporter won’t export animations, because it needs to know the location of the character-file.

==== Exporting Animations====

In 3ds max you have two different ways of exporting animations for your character. The easiest way is to set the time range in the timeline to the exact frames of the start and end positions of the animation you want to export.
It’s always a good idea to have all animations start and end in a default pose, so that blending in the engine works in a smooth way.

'''Tip:''' 
You can also create a free camera at the world coordinate center which is looking in the direction of the positive y-axis. When you set its FOV (field of view) to the same value you use in-game, it becomes an accurate representation of what your animation will look like from the players view.
You can also use “link constraints” on the camera to a helper called “camera_helper”, which is parented to the “root-bone” of the arms character, and later activate the camera control parameter for specific animations to let them be controlled by this helper. Mind, that the start and end frame of the animation for the camera should always start and end at the world coordinate centre to prevent unwanted “jumps” in your animation in the engine, between animations which have this helper activated and those which haven’t.

Once you set your time range, you can move on to the exporter. Make sure the right object is added in the node section of the objects pane. This should automatically add the root of your character in the “Bone Export” list. If not, do so manually.
Hit the “Export Bones” button, enter the desired name of the animation and save it to the folder you entered earlier in the animations.cba file.

To preview your animation in the Character Editor, you have to create one more file which tells the engine which animations are available for this character (a “cal-file”).
Below is the cal-file for the example weapon.
It has the path of the animations folder in it, and the names of the animations, and their binary counterparts, like they would be called “on disk”.

Scar_fp.cal

#filepath = Animations1st_personSCAR_fp

select_01 = select_01.caf
fire_bullets_right_01 = fire_bullets_right_01.caf
idle_right_01 = idle_right_01.caf
reload_01 = reload_01.caf

zoom_in_ironsight_01 = zoom_in_ironsight_01.caf
fire_bullets_right_ironsight_01 = fire_bullets_right_ironsight_01.caf
idle_right_ironsight_01 = idle_right_ironsight_01.caf
zoom_out_ironsight_01 = zoom_out_ironsight_01.caf

//layers control placement of attachments

silencer_on_layer_01 = silencer_on_layer_01.caf
reflex_on_layer_01 = reflex_on_layer_01.caf
scope_on_layer_01 = scope_on_layer_01.caf

The file needs to be saved to the same folder the character is saved to, and has to have the same name, except for the file extension, which is “.cal”.
The file path which points to the animations folder is relative to your games root folder.
Once you entered all available animations into the cal-file, and exported them from 3ds max, they will show up in the “Available Animations”-list in the character editor.

[[Image:FirstPersonCharacters_image014.gif]]

The second option to export animations is to use the “Sub Ranges” dialog, in the “Timing” pane of the Cryengine exporter. You can add animations into the list, by highlighting the “new range” entry and typing the name of your animation. Make sure the start and end times are entered correctly. Check if the root of your character is still showing up in the bone list. When you activate the “Export file per range” in the “sub ranges” area, after hitting the “Export Bones” button, the exporter will ask for a location, and will export any of the entered animations from the “sub ranges” – list.

[[Image:FixFirstPersonCharacters_image015.jpg]]

==== Layered Animations====

Sometimes you might only want to change specific parts of an animation which is used on a hierarchy. One example might be a different pose for the fingers for the right hand, when you want to reuse it for another type of weapon. This is one use for layered animations, which could be activated by code, and overwrite the existing animations on certain parts of your hierarchy.

Layers are also used to control placement of attachments on weapons. In this case the silencer and the magazine are solved as attachments.

To export layered animations you have to make sure that the bone list only contains the highest node of the parts that should be influenced.

Also for these kinds of layers you might only use a static pose. To achieve this activate “manual range” in the timing pane of the exporter and set the start and end frame to be the same time.

[[Image:Sandbox_FirstPersonCharacters_image016.jpg]]

After the animation is exported and added to the cal-file, you can test it in the Character Editor.

To add an attachment to your character, you have to create a new one in the attachments pane of the Character Editor.

[[Image:Sandbox_FirstPersonCharacters_image017.jpg]]

In the attachment properties select Bone Attachment and select the bone you want the object to be attached to from the drop down list. (silencer_attach, in this case).
After you have selected the correct object from the objects browser, you can create the new attachment and click “apply” to load it into the editor. It should show up at the default position of the bone you selected when you created the attachment.

To test the layer, you can activate a primary animation on the base character (i.e. an “idle” animation) by selecting one from the “available animations” list. Then switch to one of the “secondary” animation slots in the character animation pane, and select the layer animation in the list. The parts of the animation which were triggered from the “primary” animation on this bone should be overwritten, by the new layered animation.

[[Image:Sandbox_FirstPersonCharacters_image018.jpg]]

[[Category:Official:Asset Creation:Basics]]

Участник:Sodiet

2011-06-07T09:57:12Z

Sodiet: Новая страница: «{{Шаблон:Стаж|23|2|2011|dmy=1}}»

Персонажи от первого лица

{{В_процессе_перевода}}

== Breakable Objects==
Breakable objects consist of separate pieces which are held together by joints. 
The single parts can be separately disjointed, by applying physical force (bullets, player interaction, explosions) bigger than the joint limits. 
In general, Breakable objects are placed in Sandbox as brushes 
A perfect example for a breakable objects would be a road sign, a wooden fence, or a wooden shag.

==== Table of Content====

=== Sample File===

Sample File: [http://wiki.crymod.com/images/5/5b/Breakable_example.max Breakable-Example]

=== General Setup in 3d applications===
* The objects must have several nodes in max, each with its own physics.
* Nodes are held together with joints (each joint can connect only 2 parts).
* Naming convention for Joints: $joint01, $joint02,...
* Joints are represented in the 3d application with helper objects (dummies, Nulls..). They need to intersect with the physics proxy of 1 or max. two geometry objects.
* The Z-orientation of the joint pivot should normally point upward (see Debug section)
* Alternatively, one can explicitly specify part names in the joint name using this format: $joint1_part1_part2. This can be useful at complicated junctions where geometrical intersections can find more than 2 parts
* When a joint object intersects only with one node, a joint between the object and the world is created.
* The size of the dummy object does _not_ have any effect on the strength.
* It is, however, used to re-attach joints to broken parts if some geometries also have procedural breaking on (namely: when a part breaks procedurally, all joints that are attached to it are checked for intersections with the newly formed pieces, and are re-attached to them if needed)
* The strength of the joints and the mass of the separate are defined in the node properties (different name in every 3d application; in 3ds: objects Properties)
* Specific joint limits are relative to the joint's normal, represented by the helper node's *z* axis. For joints that specify part names explicitly, care must be taken that the normal points into the 1st parts (otherwise push and pull limits will switch meanings)
* Turn OFF "Merge All Nodes" on export
* Objects can be placed as brush or geom. Entity

* example for dummy placement
[[Image:PrebrokenObject dummyplacement.jpg]]

* Example for joint properties
[[Image:PrebrokenObject objectproperties.jpg]]

Each time an external force (from collisions with other objects, or bullet hits) is applied to the object, the system calculates internal forces needed to hold the object parts together, and if some forces breach the threshold, the corresponding joints are removed. Then part connectivities via remaining joints are recomputed and isolated islands are moved to new entities.

==== Node Properties====
The nodes need properties attached (depending on software) to work correctly in the engine.

*entity (render geometry property) 
If the render geometry properties include "entity", the object will not fade out after being disconnected from the main object. 

*box (render geometry property) 
If the render geometry properties include "box", the engine will use a simple box (based on the bounding box of the object's physics proxy) as the collision geometry. This helps speeding up physics calculation. 

*mass=VALUE (render geometry property) 
Mass defines the weight of an object based on real world physics 
mass=0 sets the object to "unmovable". This is used on the basement of a house for example or the sign pole which should not be movable and always stay in the original position. When used in brushes and Geom Entities, this is the final part's mass. When used in regular Entities, all parts masses are scaled so that their total mass gives the mass specified in the entity properties.
*CAUTION* You must either define this value or density to ensure the simulation is working correctly.

*density=VALUE
The engine automatically calculates the mass for an object based on the density and the bounding box of an object.
Can be used alternatively to mass.

*limit=VALUE (Joint object property) 
limit is a general value for several different kind of forces applied to the joint. It contains a combination of the values below. 
CAUTION This value needs to be defined, otherwise the simulation will not work correctly.
Crysis Example values: 100 - 500 can be broken by a bullet; 10000 can be broken by the impact of a driving vehicle or a big explosion.

The following values are optional and are used to fine tune the "limit" settings. 
*bend=VALUE (Joint object property) 
maximum torque around an axis perpendicular to the normal.

*twist=VALUE (Joint object property) 
maximum torque around the normal

*pull=VALUE (Joint object property) 
maximum force applied to the joint’s 1st object against the joint normal (the parts are "pulled together" as a reaction to external forces pulling them apart)

*push=VALUE (Joint object property) 
maximum force applied to the joint's 1st object (i.e. the one whose name is listed first in the joint's name, or if the names were not specified, the object the joint's z axis points towards) along the joint normal; joint normal is the joint's z axis, so for this value to actually be "push apart" (as a reaction to external forces pressing the parts together), this axis must be directed inside the 1st object

*shift=VALU (Joint object property) 
maximum force in the direction perpendicular to normal

Addition: joints also support non-fully-rigid (non-6dof) constraints. A full rigid constraint will become a dynamic constraint if its either bend and twist limit gets broken and the joint has a non-0 "constrant_limit" property. 

Broken "bends" will become "socket" constraints, and "twists" will become hinges. The newly created dynamic constraint will inherit pull and shift limits from the joint. The constraint’s frame will be that of the joint’s helper in max. In order to preserve the meaning of "twisting", however, the axes will be swapped (z of the joint's helper will become the constraint's x - since both represent the "twising" axis, x will become y, and y wil become z). Thus, for hinges, z asis of the helper should be directed along the desired hinge direction. For socket's, z axis should be the axis the attached part "bends around". 

Here is the list of related properties: 
*constraint_limit=VALUE (Joint object property) 
Force limit for the newly created constraint, is checked when the constraint hits a rotation limit and is being pushed further

*constraint_minang=VALUE (Joint object property) 
*constraint_maxang=VALUE (Joint object property) 
Rotation limits for the constraint (the interpretation is the same as in standalone constraints). The default is no limits

*constraint_damping=VALUE (Joint object property) 
Angular damping (default 0)

*constraint_collides=VALUE (Joint object property) 
Whether the constraint parts will ignore collisions with each other (default 1)

For example, to quickly create an unbreakable hinge constraint, one should put this into the joint’s properties: 
twist = 0 (the constraint will created at the first activation, regardless of force) 
constraint_limit = 1E20 (just something big enough) 
Note that the general "limit = xx" is not required, since we want the limits other than twist to remain unbreakable. 
Also note that the nodes that have dynamic constraints between them should always be physicalized as entities (not particles).

==== Dissolving into particlespieces====
Jointed Objects can be set up to break in smaller pieces when being detached from the joint. i.e. a wooden sheet breaks into several planks.
The object properties must contain the information about the pieces used. i.e. "pieces=$blah1", "pieces=$rock1".
Several objects can share the same name, but it is also possible to set up the pieces with different names, i.e. "pieces=$blah1,$blah2".
Pieces need to be linked to the object they should replace later on. 
NOTE: make sure the names of the objects you want to use as pieces are in lower case only i.e. $debris or $piece1. Debris would not work.

WARNING Be aware that the search function in the code also returns nodes with only partially matching strings. If you have problems with pieces spawning out of nowhere or existing nodes being cloned for no reason, look into the name strings and change them to avoid this issue.

 
If you don't specify anything in the piece properties, they will be spawned as particles, which means they will have no collision and will disappear after a few seconds. If you want the pieces to behave like actual physicalized objects, you have to add "entity" into their properties box.
 

* Sample setup
[[Image:PrebrokenObject pieces thumb.jpg]]

Practical examples of how pieces can be used:

- Optimization: If you create a dummy object with a nodraw material (like a simple cube) and spawn it as a piece, the jointed object will simply disappear once the joint breaks - it will be replaced by an invisible object. This can be helpful since the piece that is broken off will not fall down and interact with the remaining pieces, potentially causing problems, and it is also beneficial performance-wise. Once the original object is seperated from its joint, no further physics calculations will be necessary.

- Adding dynamic detail: Pieces replace their original object once this object is "broken off" (seperated from it's joint), so you can take the original object and cut it up into smaller pieces. An example of this is the huts in crysis, most roof panels have two sub-pieces that spawn once the panel breaks off. This results in more detailed breaking and smaller debris. Don't forget to add "entity" and a realistic mass to the piece properties, and make sure the piece is physicalized, or else the pieces will fall through the ground and/or disappear after a few seconds. (in case they are only small "fluff" pieces, this might actually be intended)

- Adding static detail: You can also spawn small debris pieces, that, instead of falling down, stay where they appear (for example steel cables sticking out of a concrete wall). To do this, you have to add the following lines to the properties of the piece:

entity
 
mass=0
 
density=0
 

Entity because you want the object to stay where it is once it is spawned, and because you want it to be physicalized. The object needs to be physicalized (i.e. contain polygons with a physicalized material) in order for this to work.
Mass and density need to be 0 to assign the objects infinite mass, which results in the object staying where it spawns and not reacting to force. If it wasn't 0, it would fall down upon spawning.

==== Level of detail settings====
LodCreation per object can easily be added by naming them $lod1; $lod2, $lod3... and linking them to the relevant subobjects. In order to make differentiation easier, a postfix can be added; i.e. "$lod1_wooden plank"

==== Occlusion Proxy====
An OcclusionProxy can be added by naming it $occlusion and linking it to the relevant jointed object; like a big sheet of metal on a metal fence or a wooden wall on a hut. Occlusion proxy is allowed to have open edges and need to be as low as possible (something around 2-10 polys).

==== Instancing within breakable objects====
[[AssetCreation_InstancingObjects]] Instancing objects] is used to optimize render time by reducing drawcalls and memory consumption.
The engine automatically detects identical geometry elements within the exported objects. 
There is no special setup needed to take advantage of this feature. UVs and relative point position to the pivot need to be identical in objects in order to qualify them for instancing.

==== Linking Objects to simplify export====
Linked objects don�t need to be exported, just the Root node needs to be added to the exporter list. All child nodes will automatically be exported. The name and pivot will be derived from the root joint. 

* Example of linking objects and joints for simpler export
[[Image:PrebrokenObject NamingAndHierarchy.jpg]]

=== Setup in Sandbox===

Add the object as a brush or a Geom. Entity. In case of a brush, the engine will detext automatically that the object is breakable.
For multiplayer where breaking objects has a massive impact on the data transfer, breakability is automatically disabled (might change later)

=== Debugging===
* p_debug_joints 1 shows the default debug mode for joints (see picture below); p_draw_helpers needs to be activated
* CAUTION Never scale a joint If you need a new size, create a new joint. the scaling value will be passed on to the engine and causes wrong results in the simulation.
* The "spikes" on the joint objects show the orientation. For limits to properly reflect their names (i.e. pull, twist, etc), the spikes must be directed along the "natural" joints axes. However, it's also possible to keep them always pointing up, for consistency.
* The blue colored numbers show the mass of the single pieces. Note the "0.00kg" this is the mass of the top node - in this case a dummy.
* Joints linked to the world are displayed red.
* When a force is applied to a joint, the direction is shown (in this case shift and bend), together with the strength and the limit of the particular joint. Green text represents an impact with an impulse much lower then the joint limit. Yellow represents values closer to the joint limit. Red represents values which were higher than the limit - in this case the joint is broken.
* NOTE: the debug mode is handy to see how the impulse of weapons react with the breakable object. set the general limit first and then fine tune the specific limits by setting them explicitly for shift, bend...

* Example of debug display
[[Image:PrebrokenObject sign example thumb.jpg]]

[[Category:Official:Asset_Creation:Basics]]