Algemeen Folder Objecten

Deze topic introduceert de specifieke bestanden die een add-on vormen, en de tools die je gebruikt om die bestanden te maken. "Add-on" is een generieke term die verwijst naar aanvullende (aangepaste) inhoud zoals objecten, voertuigen, gebouwen en mensen die aan de VBS-simulator zijn toegevoegd.

De volgende flowchart geeft een idee van wat er in een .pbo / .cbo / .paa gaat, dit zijn de bestandstypen die nodig zijn om je add-on in VBS te krijgen.

Bestandstypen

Om inhoud aan VBS toe te voegen, heb je een 3D-model met texturen nodig, en configuratiebestanden om de functie en het gedrag van het model voor de simulatorengine te definiëren. De bestandstypen die bij dit proces betrokken zijn, worden vermeld in de volgende tabellen:

3D Model Bestanden

De volgende bestandstypen zijn vereist voor je 3D-model (asset).

Configuratiebestanden

De volgende bestandstypen bevatten alle vereiste configuratie voor je asset.

Bestanden gemaakt door Addon Packer

De volgende versleutelde bestandstypen worden gemaakt door Addon Packer.

Overzicht van een folder structuur

Config.Cpp:

Voorbeeld van een sample structure:

//always include the defines common to all configs at the top of the file

#include "\vbs2\basic_defines.hpp"

//--------------------------------------------------------------------

//always change this to be the path (without drive) to the directory you are working in!

#define **CurrentDir** \vbs2\customer\structures\bia_sample_structure

class CfgPatches // Super class declaration, this is an addon.

{

class bia_sample_structure // Define the class name with the same name as the addon folder.

{

units[] = {};

weapons[] = {};

requiredVersion = 0.10;

requiredAddons[] = {vbs2_Structures};

modules[] =

{

vbs_xx_techdemo_module

};

};

};

//--------------------------------------------------------------------

class CfgVehicleClasses // Super class declaration, tell simulation we are creating categories for the listing of objects in the editor.

{

class bia_sample_structures // User defined class name for this category, which is referenced by "vehicleClass" later in the config.

{

displayname = "BIA Sample Structures"; // Display name for this category that shows up in editor.

};

};

//--------------------------------------------------------------------

class VBS2_Ruins_Generic; // Declares a class that already exists in VBS2 and will be used below for Destruction Effects.

class CfgVehicles // Super class declaration, tells the simulation we are configuring objects/vehicles/people.

{

//large watertower

class vbs2_House; // Declare an existing base class to be inherited from.

class Land_bia_watertank : vbs2_House // The class name for structures starts with "Land_" and then the model name. This is required for the class to work with Visitor placed objects.

{

scope = public; // Makes this class available in the simulator.

DisplayName = "Sample water tank"; // Displayed name of model in the editor.

vehicleClass = bia_sample_structures; // Name of editor class this object resides in, created in CfgVehicleClasses

model = **CurrentDir**\bia_watertank; // Replace last part with the name of your .p3d model.

armor = 750; // Global strength value of the object, how much damaged can be inflicted before destruction. Is also influenced by the size of the model.

destrType = DestructBuilding; // What happens when this structure is destroyed; see bottom of config for options.

class DestructionEffects: VBS2_Ruins_Generic {}; // Implements the smoke effect associated with the building being destroyed and replaces your model with a generic "destroyed" building model.

};

//wall section

class vbs2_wall; // State an existing base class to be inherited from.

class Land_bia_wall : vbs2_wall // The class name for structures starts with "Land_" and then the model name. This is required for the class to work with Visitor placed objects.

{

scope = public;

DisplayName = "Sample wall segment";

vehicleClass = bia_sample_structures;

model = **CurrentDir**\bia_wall;

};

};

//--------------------------------------------------------------------

/*

Possible values for destrType:

DestructNo - no visual destruction effect

DestructBuilding - object sinks into the ground and ruins remain; class destructioneffects must also be configured

DestructEngine - object explodes

DestructTree - object falls over; pivoting around the Z axis

DestructTent - object folds inwards on itself

*/

Uitleg gebruik config.cpp:

Component Configuratie

Componentconfiguraties bepalen de attributen en het gedrag van componenten voor het Universal Component System (UCS). Nieuwe componentklassen worden gedefinieerd in de config.cpp.

Het onderstaande voorbeeld toont een generieke component voor een object:

C++

// Standaard definities bovenaan de file includen.
#include "\vbs2\basic_defines.hpp"
#include "\VBS2\weapons\weapons_defines.hpp" // Superklasse definities includen.

// Definieer het pad naar de huidige directory.
#define \__CurrentDir_\_ \vbs2\customer\components\my_components_folder

class CfgPatches
{
	class vbs2_customer_components_my_components_folder
	{
		// Altijd leeg
		units[]          = {};
		weapons[]        = {};
		// Vereiste versie
		requiredVersion  = 0.10;
		// Vereiste addons (optioneel)
		requiredAddons[] = {};
	};
};

class CfgComponents
{
	class Existing_Component;
	class My_Component : Existing_Component
	{
		// Publieke scope
		scope           = public;
		// Weergavenaam in de game
		displayName     = "My Ammo";
		// Pad naar het model
		model           = model_path;
		// Categorie waarin de component geplaatst kan worden
		SlotInterface[] = {category_label};
	};
};

Component Includes en Definities

Om een nieuwe componentklasse te declareren, gebruik je minimaal de volgende #includes en #defines bovenaan je config.cpp:

• #include "\vbs2\basic_defines.hpp": Bevat basisdefinities voor alle configuraties.
• #include "\vbs2\weapons\weapons_defines.hpp": Definities en macro's voor de superklasse van je component.
• #define \__CurrentDir_\_ \vbs2\customer\weapons\my_components_folder: Definieert de directory waar de huidige configuratie is opgeslagen.

Component Klasse Declaratie

Declareer vervolgens je componentklasse binnen de superklasse CfgPatches:

C++

class CfgPatches
{
	class vbs2_customer_components_my_component_folder // Pad naar je addon folder
	{
		units[]          = {}; // Altijd leeg
		weapons[]        = {}; // Altijd leeg
		requiredVersion  = 0.10; // Vereiste versie
		requiredAddons[] = {}; // Vereiste addons (optioneel)
	};
};

Component Klasse Definitie

Na de CfgPatches configuratie, definieer je je nieuwe componentklasse binnen de superklasse CfgComponents. Je nieuwe klasse moet erven van een bestaande componentklasse:

C++

class CfgComponents
{
	class Existing_Component;
	class My_Component : Existing_Component // Erft van Existing_Component
	{
		scope           = public;
		displayName     = "My Component"; // Weergavenaam
		model           = model_path;
		SlotInterface[] = {category_label}; // Categorie waarin de component geplaatst kan worden
		class Modifiers
		{
			// Parameters om waardes van de basisobjecten te overschrijven.
		};
	};
};

Volg deze stappen:

1. Declareer de bestaande klasse waarvan je wilt erven.
2. Declareer je nieuwe componentklasse, gevolgd door een dubbele punt (:) en de erfklasse (vb. Existing_Component).
3. Stel waarden in voor de parameters in je nieuwe componentklasse om je specifieke component te definiëren.
4. Raadpleeg "Component Parameters" voor een lijst van beschikbare parameters.

Klassen Erfenis

Erfenis in modelconfiguratie is complex en omvat het gebruik van een breed scala aan basisklassen. Voor een beter begrip van hoe erfenis werkt, is het raadzaam de hiërarchische structuur rechtstreeks te bestuderen in de VBS Configuration Browser.

Subklassen

Gebruik de volgende subklassen binnen de componentklasse om specifiek gedrag voor je nieuwe componentklasse te definiëren:

• Class Animations: Definieert animaties voor je component, zoals hoe deze vast te houden.
• Class Canvases: Containerklasse voor "canvases" (oppervlakken) van UCS-componenten.
• Class CfgDecals: Rootklasse voor het configureren van decals op de canvases van UCS-componenten.
• Class Lasers: Activeert laser- of zaklampfunctionaliteit.
• Class Muzzles: Definieert de eigenschappen van elke vuur kamer van het wapen.
• Class MuzzleEffects: Definieert de eigenschappen van een loop, zoals richting en geluidseffecten van de munitie.
• Class Optics: Activeert optiekfunctionaliteit voor de component.

Object Subklassen

Gebruik de volgende subklassen binnen de basisobjectconfiguratie om componentbevestigingslocaties en standaardcomponenten te definiëren:

• Class LinkedComponents: Definieert de specifieke componenten die standaard aan het object moeten worden bevestigd.
• Class Slots: Definieert de bevestigingspunten op een object en welke componentcategorieën ze ondersteunen.

De VBS model.cfg bestand

Voorbeeld model.cfg:

class CfgModels

{

class vbs2_house;

class bia_watertank : vbs2_house {}; //place your .p3d model name (without extension) in place of bia_watertank

};

Gebruik van het model.cfg bestand

De VBS simulatie-engine gebruikt een techniek genaamd skeletanimatie (Forward Kinematic Animation) om 3D-modellen te animeren. Er wordt een reeks "botten" geconstrueerd en er wordt een reeks transformaties (bewegingen en posities) gedefinieerd. Deze definitie wordt verwerkt door het model.cfg configuratiebestand. Tenzij uw model volledig statisch is, moet er een model.cfg-bestand aanwezig zijn in de directory van uw project.

Het model.cfg-bestand wordt verwerkt tijdens het binariseren en vertelt Addon Packer wat de verschillende secties van het model zijn, welk skelet het gebruikt en hoe het wordt geanimeerd. Deze informatie wordt tijdens het binarisatieproces in het model "ingebakken".

De volgende superklassen worden gebruikt in het model.cfg-bestand:

Het hoofdmodel.cfg-bestand (te vinden in P:\vbs2\model.cfg) in uw VBS Developer Suite lijkt vrij klein te zijn. Dit komt doordat het is verdeeld over afzonderlijke bestanden:

C++

class VBS2_Vehicle: Default
{
	isDiscrete=1;
	skeletonBones[]=
	{
	};
};

#define CfgSkeletons
#include "data\cfg\model_cfg\helicopters_model_cfg.hpp"
#include "data\cfg\model_cfg\planes_model_cfg.hpp"
#include "data\cfg\model_cfg\static_model_cfg.hpp"
#include "data\cfg\model_cfg\tracked_model_cfg.hpp"
#include "data\cfg\model_cfg\water_model_cfg.hpp"
#include "data\cfg\model_cfg\wheeled_model_cfg.hpp"
#include "data\cfg\model_cfg\weapons_model_cfg.hpp"
#include "data\cfg\model_cfg\people_model_cfg.hpp"
#include "data\cfg\model_cfg\structures_model_cfg.hpp"
undef CfgSkeletons

Alle vermelde model.cfg-bestanden erven van de Default-klasse die bovenaan de code wordt genoemd (zie Klassen en Erfenis).

Klasse CfgSkeletons

Alle bewegende modellen vereisen een skelet dat bestaat uit individuele botten, dit omvat levenloze objecten zoals voertuigen, maar ook mensen en dieren. Skeletten worden geconfigureerd in de klasse CfgSkeletons, die zich binnen de klasse Default bevindt. Klasse CfgSkeletons vertelt de engine welke botten te animeren en definieert de bottenhiërarchie. Elke modelklasse binnen klasse CfgSkeletons moet de volgende verplichte parameters hebben:

Bottenhiërarchie

Wanneer een kindbot erft van (of is gekoppeld aan) een ouderbot, is de transformatie van het kindbot een combinatie van de transformatie van het kindbot en het ouderbot. Dit wordt "hiërarchie" genoemd (zie Klassen en Erfenis). Het principe is hetzelfde bij menselijke skeletten. Bijvoorbeeld, botten in je handen maken deel uit van botten in je armen. Als je je armen beweegt, bewegen je handen ook. Klasse CfgSkeletons vertelt de engine in feite welk bot aan welk bot is bevestigd.

Bij het maken van modellen moet u onthouden dat wanneer één deel animeert, de verbonden delen ook moeten animeren. Bijvoorbeeld, als een wiel van een auto wordt geanimeerd, moeten de aangesloten vering en het stuurwiel ook animeren. Dus om iets te animeren, moet je een bot hebben gedefinieerd voor die specifieke animatie. Je kunt zoveel botten hebben als je wilt voor een model, er is geen limiet.

Het volgende model.cfg-voorbeeld is voor het hoofdkanon op de koepel van een tank. De koepel draait en de elevatieboog van het kanon draait ook mee, dus de configuratie weerspiegelt dit:

C++

class CfgSkeletons
{
	class vbs2Tracked8Skeleton; // Basis skeletklasse
	class bia_T72_base_Skeleton : vbs2Tracked8Skeleton //Nieuwe skeletklasse die erft van basisklasse
	{
		isDiscrete      = 1;
		skeletonInherit = "vbs2Tracked8Skeleton";
		skeletonBones[] =
		{
			"hatch_driver","",
			"main_trav","",// Beweging van main_trav is niet gekoppeld aan andere botten
			"main_elev","main_trav",// Beweging van main_elev is gekoppeld aan main_trav
			"cmdr_trav","main_trav",
			"cmdr_elev","cmdr_trav",
			"cmdr_light_elev","cmdr_trav",
			"hatch_commander","cmdr_trav",
			"loader_trav","main_trav",
			"loader_elev","loader_trav",
			"hatch_gunner","main_trav"
		};
	};
};

Het koepelbot is gedefinieerd als "main_trav". Het kanonbot is gedefinieerd als "main_elev". De koepel is niet aan andere botten gekoppeld zoals de configuratie aangeeft: "main_trav","". Het kanon kan op en neer bewegen, maar moet ook draaien als de koepel draait, vandaar de entry: "main_elev","main_trav" die het kanonbot koppelt aan het koepelbot.

Het is ook mogelijk om meerdere schakels aan elkaar te rijgen, bijvoorbeeld "cmdr_light_elev" is gekoppeld aan "cmdr_trav" die is gekoppeld aan "main_trav". De beweging voor elk bot wordt meestal gedefinieerd in een specifieke animatiesubklasse binnen Klasse Animaties.

TIPS

• Zorg ervoor dat de regels bij het schrijven van code ingesprongen zijn. Dit maakt de code beter leesbaar. Sommige skeletten kunnen tientallen regels code hebben die moeilijk te lezen zijn als ze als een vast verticaal blok zijn gerangschikt. Zie Opmaak voor meer informatie.

CfgModels

CfgModels is de belangrijkste klasse in de model.cfg-configuratiebestanden voor animaties. Het brengt alle onderdelen en attributen samen en past ze toe op een specifiek model. Onderdelen van het model worden in deze klasse gedefinieerd en skeletten en botten worden gekoppeld aan hun animaties.

Elke klasse binnen klasse CfgModels heeft klasse Animaties. Hier worden de animatieparameters gedefinieerd. Indien gewenst kunnen animaties worden overgenomen van een bovenliggende klasse. De modelklasse gebruikt de volgende parameters:

Namen van CfgModels-klassen

De standaardlaagklassenamen binnen klasse CfgModels moeten overeenkomen met de naam van het .p3d-model waarop ze worden toegepast. Wanneer een .p3d wordt gebinarizeerd, worden CfgModels-klassen gekoppeld aan de .p3d-naam om te bepalen welke attributen in het gebinarizeerde bestand moeten worden "ingebakken".

Vb. Als uw .p3d-model "xyz_tanklarge.p3d" heet, moet de klassenaam in klasse CfgModels "class xyz_tanklarge" zijn.

Modelsecties

Modelsecties (zie de tabellen in Model.cfg-configuratie) worden gebruikt om zaken zoals schakelbare texturen aan een model toe te voegen, en worden geplaatst in de parameterarray sections[] binnen klasse CfgModels. De structuur van de array is vergelijkbaar met die van skeletonBones[] in klasse CfgSkeletons in die zin dat het gebruik maakt van overerving (zie Bottenhiërarchie).

De modelsecties die worden vermeld in de array sections[] zijn delen van het model die speciale effecten rechtstreeks van de engine krijgen. Ze zijn meestal constant voor elk voertuig. Bijvoorbeeld, licht-sprites worden verborgen wanneer de bestuurder de lichten van een voertuig uitschakelt. Mondschotflitsen moeten in de engine worden gemodelleerd en de juiste naamselectie krijgen voor mondschotflitsen. Ze worden door de engine altijd verborgen behalve wanneer het betreffende wapen wordt afgevuurd. Ook zaken als wonden, eenheidslogo's en verborgen selecties zijn opgenomen.

Lijsten met standaardsecties voor voertuigen in VBS zijn te vinden in het model.cfg-bestand op: P:\vbs2\model.cfg

Verschillende soorten voertuigen kunnen extra secties hebben die specifiek zijn voor hun type.

Vb. Rupsvoertuigen voegen "track_1" en "track_2" toe. Kijk in de meegeleverde bestanden waarnaar wordt verwezen in het primaire model.cfg voor meer informatie: P:\vbs2\data\cfg\model.cfg

Animaties

Animaties zijn ingebed in de standaard subklassen in klasse CfgModels. Elk bot in het gedefinieerde skelet krijgt een animatie, of erft er een van een bovenliggende klasse. Zie Inleiding tot animaties voor meer informatie en een voorbeeldconfiguratie.

Object development

Algemene workflow1 (Zonder Substance painter):

• High Poly Model/Low poly model (Blender - LOD Maker)
• Build UV Low Poly Model(Blender - ZenUV)
• Make Materials (Blender - Substance Alchemist/Sampler)
• Apply Materials (Blender)
• Bake textures (Blender - Simple Bake)
• Apply textures - PBR Shader (Blender - Node Wrangler)
• Create other LOD's (Blender - LOD Maker)
• Apply textures if needed (Blender)
• Export Model as FBX (blender - Better FBX)
• Transform Model (Model importer)
• Create icon (Blender);
  • 256X256 72 Dpi       
• Config model (Notepad++, Configuration manager
• Pack Addon (Addon Packer)

Algemene workflow2:

• High Poly Model/Low poly model (Blender – LOD Maker)
• Import in Substance Painter (UV-Map prepare)
• Make Materials (Substance Alchemist/Substance Sampler)
• Bake textures (Substance Painter)
• Create other LOD’s (Blender-LOD Maker)
• Apply textures if needed (Blender)
• Export Model as FBX (blender – Better FBX)
• Transform Model (Model importer)
• Create icon (Blender)
• Config model (Notepad++ Notepad++, Configuration manager)
• Pack Addon (Addon Packer)

Verdere informatie gerelateerd aan VBS:

Polycount VBS: (less is more)

• Hardlimit: 20000
• Softlimit: 10000
• LOD Res1: 3000
• LOD Res2: 1500
• LOD Res3: 800

LOD (Level of detail):

• Shadow: Res2 or Res3
  • Smouth Edges
• Geometrie: Box containing Res0 – closed geometrie convex hull
  • bisim_mass propertie = gewicht in kg
• ViewGeometrie:
• Opmerkingen:
  • Triangulate (ctrl+T) - Voor elke LOD
  • Closed geometrie - Voor elke LOD
  • Smouth Edges (waar nodig - ShadowLOD)