अवास्तविक इंजन 4 में UObject का विस्तार

सभी को नमस्कार! मेरा नाम अलेक्जेंडर है, मैं 5 साल से अधिक समय से अवास्तविक इंजन के साथ काम कर रहा हूं, और लगभग सभी समय - नेटवर्क परियोजनाओं के साथ।

चूंकि नेटवर्क परियोजनाएं उनके विकास और प्रदर्शन की आवश्यकताओं में भिन्न होती हैं, इसलिए अक्सर सरल वस्तुओं के साथ काम करना आवश्यक होता है, जैसे कि UObject क्लासेस, लेकिन उनकी कार्यक्षमता को शुरू में छोटा कर दिया जाता है, जो एक मजबूत ढांचा तैयार कर सकता है। इस लेख में, मैं अवास्तविक इंजन 4 में UObject बेस क्लास में विभिन्न कार्यों को सक्रिय करने के तरीके के बारे में बात करूंगा।

वास्तव में, मैंने लेख को संदर्भ के रूप में अधिक लिखा। अधिकांश जानकारी दस्तावेज़ीकरण या समुदाय में खोजना बेहद कठिन है, और यहां आप लिंक को जल्दी से खोल सकते हैं और वांछित कोड कॉपी कर सकते हैं। मैंने आपके साथ साझा करने के लिए उसी समय का फैसला किया! लेख उन लोगों के लिए लक्षित है जो पहले से ही UE4 से थोड़ा परिचित हैं। C ++ कोड पर विचार किया जाएगा, हालांकि इसे जानना आवश्यक नहीं है। आप बस निर्देशों का पालन कर सकते हैं यदि आपको किसी चीज के बारे में बात करने की आवश्यकता है। इसके अलावा, सब कुछ कॉपी करना आवश्यक नहीं है, आप आवश्यक गुणों के साथ अनुभाग से कोड पेस्ट कर सकते हैं और इसे काम करना चाहिए।

UObject के बारे में थोड़ा सा

UObject लगभग सब कुछ के लिए आधार वर्ग है जो अवास्तविक इंजन में है 4. आपकी दुनिया में या केवल स्मृति में बनाई गई वस्तुओं का विशाल बहुमत इससे विरासत में मिला है: मंच पर वस्तुएं (एक्टर), घटक (UActorComponent), के साथ काम करने के लिए विभिन्न प्रकार डेटा और अन्य।

कक्षा ही, हालांकि डेरिवेटिव की तुलना में आसान है, एक ही समय में काफी कार्यात्मक है। उदाहरण के लिए, इसमें कई उपयोगी घटनाएं शामिल हैं, जैसे कि संपादक में चर के मूल्यों को बदलना और नेटवर्क के लिए बुनियादी कार्य, जो डिफ़ॉल्ट रूप से सक्रिय नहीं हैं।

इस वर्ग द्वारा बनाई गई वस्तुएं मंच पर नहीं हो सकती हैं और विशेष रूप से स्मृति में मौजूद हैं। उन्हें अभिनेताओं के घटक के रूप में नहीं जोड़ा जा सकता है, हालांकि यह एक प्रकार का घटक हो सकता है यदि आप स्वयं आवश्यक कार्यक्षमता को लागू करते हैं।

अगर एएक्टर पहले से ही मेरी ज़रूरत की हर चीज़ का समर्थन करता है तो मुझे UObject की आवश्यकता क्यों है? सामान्य तौर पर, उपयोग के कई उदाहरण हैं। सबसे आसान सूची आइटम है। मंच पर, कहीं आकाश में, उन्हें स्टोर करना अव्यावहारिक है, इसलिए आप रेंडर लोड किए बिना और अनावश्यक गुणों को बनाए बिना उन्हें मेमोरी में स्टोर कर सकते हैं। तकनीकी तुलना पसंद करने वालों के लिए, एएकर एक किलोबाइट (1016 बाइट्स) लेता है, और एक खाली यूओबजेक्ट केवल 56 बाइट्स है।

एक UObject समस्या क्या है?

सामान्य तौर पर, कोई समस्या नहीं है, या मैं अभी उनके सामने नहीं आया हूं। UObject की घोषणा करने वाले सभी एएक्टर या घटकों में डिफ़ॉल्ट रूप से उपलब्ध विभिन्न विशेषताओं की कमी है। यहाँ वे समस्याएं हैं जो मैंने अपने अभ्यास के लिए पहचानी हैं:

• UObjects को नेटवर्क पर दोहराया नहीं जाता है;
• पहले बिंदु के कारण, हम RPC घटनाओं को ट्रिगर नहीं कर सकते हैं;
• आप ब्लूप्रिंट में दुनिया के लिए एक लिंक की आवश्यकता वाले व्यापक कार्यों का उपयोग नहीं कर सकते हैं;
• उनके पास BeginPlay और Tick जैसी मानक घटनाएं नहीं हैं;
• आप ब्लूप्रिंट में UObjects से AActor तक घटक नहीं जोड़ सकते।

ज्यादातर चीजें आसानी से हल की जा सकती हैं। लेकिन कुछ टिंकर करना होगा।

UObject बनाना

सुविधाओं के साथ अपनी कक्षा का विस्तार करने से पहले, हमें इसे बनाने की आवश्यकता है। आइए संपादक का उपयोग करें ताकि जनरेटर स्वचालित रूप से वह सब कुछ लिख दे जो हेडर (.h) पर काम करने के लिए आवश्यक है।

हम नए बटन पर क्लिक करके और नई C ++ कक्षा का चयन करके सामग्री ब्राउज़र संपादक में एक नई कक्षा बना सकते हैं।



इसके बाद, हमें कक्षा को स्वयं चुनने की आवश्यकता है। यह सामान्य सूची में नहीं हो सकता है, इसलिए, इसे खोलें और UObject चुनें।



अपनी कक्षा को नाम दें और यह चुनें कि यह किस फ़ोल्डर में संग्रहीत किया जाएगा। जब हमने कक्षा बनाई, तो आप स्टूडियो में जा सकते हैं, वहां इसे ढूंढ सकते हैं और सभी आवश्यक कार्यों को एम्बेड करना शुरू कर सकते हैं।

शुरुआती, ध्यान दें कि दो फाइलें बनाई गई हैं: .h और .ccp। .H में, आप चर और कार्यों की घोषणा करेंगे, और .cpp में आप उनके तर्क को परिभाषित करेंगे। अपने प्रोजेक्ट में दोनों फाइलें खोजें। यदि आपने पथ नहीं बदला है, तो उन्हें प्रोजेक्ट / स्रोत / प्रोजेक्ट / में होना चाहिए।

जब तक हम जारी रखते हैं, तब तक कक्षा घोषणा के ऊपर UCLASS () मैक्रो में ब्लूप्रिंट योग्य पैरामीटर लिखें। आपको कुछ इस तरह से मिलना चाहिए:

ज

UCLASS(Blueprintable) class MYPROPJECT_API UMyObject : public UObject { GENERATED_BODY() } 

इसके लिए धन्यवाद, आप ब्लूप्रिंट बना सकते हैं जो इस वस्तु के साथ हमारे द्वारा किए जाने वाले हर चीज़ को विरासत में देगा।

UObject प्रतिकृति

डिफ़ॉल्ट रूप से, UObjects को नेटवर्क पर दोहराया नहीं जाता है। जैसा कि मैंने ऊपर वर्णित किया है, कई प्रतिबंध तब बनाए जाते हैं जब आपको पार्टियों के बीच डेटा या तर्क को सिंक्रनाइज़ करने की आवश्यकता होती है, लेकिन दुनिया में कचरा संग्रहित नहीं करते हैं।

अवास्तविक इंजन 4 में, प्रतिकृति दुनिया की वस्तुओं के कारण ठीक होती है। इसका मतलब है कि बस एक ऑब्जेक्ट को मेमोरी में बनाना और उसकी नकल करना विफल हो जाएगा। किसी भी मामले में, आपको एक स्वामी की आवश्यकता होगी जो सर्वर और क्लाइंट के बीच ऑब्जेक्ट डेटा के हस्तांतरण का प्रबंधन करेगा। उदाहरण के लिए, यदि आपकी वस्तु चरित्र का कौशल है, तो चरित्र को ही मालिक बनना चाहिए। वह नेटवर्क पर सूचना प्रसारित करने के लिए एक कंडक्टर भी होगा।

प्रतिकृति के लिए हमारी वस्तु तैयार करें। हेडर में अब तक हमें केवल एक फ़ंक्शन सेट करने की आवश्यकता है:

ज

 UCLASS(Blueprintable) class MYPROPJECT_API UMyObject : public UObject { GENERATED_BODY() public: virtual bool IsSupportedForNetworking () const override { return true; }; } 

IsSupportedForNetworking () निर्धारित करेगा कि ऑब्जेक्ट नेटवर्क का समर्थन करता है और दोहराया जा सकता है।

हालांकि, सब कुछ इतना सरल नहीं है। जैसा कि मैंने ऊपर लिखा है, आपको एक स्वामी की आवश्यकता है जो ऑब्जेक्ट के हस्तांतरण को नियंत्रित करता है। प्रयोग की शुद्धता के लिए, एक एएक्टर बनाएं जो इसे दोहराएगा। यह ठीक उसी तरह से किया जा सकता है, जैसे UObject, केवल मूल वर्ग, स्वाभाविक रूप से, AActor।

शुरुआती, यदि आपको किसी चरित्र, नियंत्रक या अन्य जगहों पर किसी वस्तु को दोहराने की आवश्यकता है, तो संपादक के माध्यम से उचित आधार वर्ग बनाएं, उसमें आवश्यक तर्क जोड़ें, और पहले से ही ब्लूप्रिंट में इस वर्ग से विरासत में मिला।

अंदर हमें 3 कार्यों की आवश्यकता है: एक कंस्ट्रक्टर, सबोबैक्ट्स की प्रतिकृति के लिए एक फ़ंक्शन, एक फ़ंक्शन जो यह निर्धारित करता है कि इस एएक्टर (चर, वस्तु संदर्भ, आदि) के अंदर क्या दोहराया गया है और वह स्थान जहां हम अपनी वस्तु बनाते हैं।

एक वैरिएबल बनाना न भूलें जिसके द्वारा हमारी वस्तु संग्रहीत की जाएगी:

ज

 class MYPROPJECT_API AMyActor : public AActor { GENERATED_BODY() public: AMyActor(); virtual bool ReplicateSubobjects (class UActorChannel *Channel, class FOutBunch *Bunch, FReplicationFlags *RepFlags) override; void GetLifetimeReplicatedProps (TArray<FLifetimeProperty>& OutLifetimeProps) const override; virtual void BeginPlay (); UPROPERTY(Replicated, BlueprintReadOnly, Category="Object") class UMyObject* MyObject; } 

स्रोत फ़ाइल के अंदर हमें सब कुछ लिखना होगा:

सीपीपी

 //  #include "MyActor.h" #include "Net/UnrealNetwork.h" #include "Engine/World.h" #include "Engine/ActorChannel.h" #include "   UObject/MyObject.h" AMyActor::AMyActor() { //  Actor  . bReplicates = true // . NetCullDistanceSquared = 99999; //  (  ). NetUpdateFrequency = 1.f; } void AMyActor::GetLifetimeReplicatedProps (TArray<FLifetimeProperty>& OutLifetimeProps) { Super::GetLifetimeReplicatedProps(OutLifetimeProps); //       .           . DOREPLIFETIME(AMyActor, MyObject); } bool AMyActor::ReplicateSubobjects(UActorChannel * Channel, FOutBunch * Bunch, FReplicationFlags * RepFlags) { bool WroteSomething = Super::ReplicateSubobjects(Channel, Bunch, RepFlags); //   . if (MyObject ) WroteSomething |= Channel->ReplicateSubobject(MyObject , *Bunch, *RepFlags); return WroteSomething; } AMyActor::BeginPlay() { /*       (  )  .    this.        . ,       ,     . */ if(HasAuthority()) { MyObject = NewObject<UMyObject>(this); //       if(MyObject) UE_LOG(LogTemp, Log, TEXT("%s created"), *MyObject->GetName()); } } 

अब इस अभिनेता के साथ आपकी वस्तु को दोहराया जाएगा। आप टिक पर उसका नाम प्रदर्शित कर सकते हैं, लेकिन पहले से ही क्लाइंट पर। कृपया ध्यान दें कि शुरुआत प्ले पर एक ऑब्जेक्ट क्लाइंट के सामने आने की संभावना नहीं है, इसलिए उस पर लॉग लिखने का कोई मतलब नहीं है।

UObject में चर का प्रतिकृति

ज्यादातर मामलों में, किसी ऑब्जेक्ट को दोहराने के लिए कोई मतलब नहीं है अगर इसमें ऐसी जानकारी नहीं है जो सर्वर और क्लाइंट के बीच भी सिंक्रनाइज़ होगी। चूंकि हमारी वस्तु पहले से ही प्रतिकृति है, इसलिए चर को पार करना मुश्किल नहीं है। यह हमारे अभिनेता के अंदर उसी तरह से किया जाता है:

ज

 UCLASS(Blueprintable) class MYPROPJECT_API UMyObject : public UObject { GENERATED_BODY() public: virtual bool IsSupportedForNetworking () const override { return true; }; void GetLifetimeReplicatedProps (TArray<FLifetimeProperty>& OutLifetimeProps) const override; UPROPERTY(Replicated, BlueprintReadWrite, Category="Object") int MyInteger; //   } 

सीपीपी

 //  #include "MyObject.h" #include "Net/UnrealNetwork.h" UMyObject ::UMyObject () { //  Object  .     . bReplicates = true //       ,     . } void UMyObject ::GetLifetimeReplicatedProps (TArray<FLifetimeProperty>& OutLifetimeProps) { Super::GetLifetimeReplicatedProps(OutLifetimeProps); //   Integer  . DOREPLIFETIME(UMyObject, MyInteger); } } 

एक चर जोड़कर और प्रतिकृति के लिए इसे ध्वजांकित करके, हम इसे दोहरा सकते हैं। सब कुछ सरल है और एएक्टर के समान है।

हालांकि, एक छोटा सा गड्ढा है जो तुरंत दिखाई नहीं देता है, लेकिन भ्रामक हो सकता है। यह विशेष रूप से ध्यान देने योग्य होगा यदि आप C ++ में काम करने के लिए अपना UObject नहीं बना रहे हैं, लेकिन इसे उत्तराधिकार के लिए तैयार कर रहे हैं और ब्लूप्रिंट में काम कर रहे हैं।

लब्बोलुआब यह है कि ब्लूप्रिंट के वारिस में बनाए गए चर को दोहराया नहीं जाएगा। इंजन स्वचालित रूप से उन्हें चिह्नित नहीं करता है और बीपी में सर्वर पर एक पैरामीटर को बदलने से क्लाइंट पर मूल्य में कुछ भी नहीं बदलता है। लेकिन इसके लिए एक इलाज है। बीपी चर की सही प्रतिकृति के लिए, आपको उन्हें पहले से चिह्नित करने की आवश्यकता है। GetLifetimeReplicatedProps () के लिए कुछ पंक्तियाँ जोड़ें:

सीपीपी

 void UMyObject ::GetLifetimeReplicatedProps (TArray<FLifetimeProperty>& OutLifetimeProps) { Super::GetLifetimeReplicatedProps(OutLifetimeProps); //   Integer  . DOREPLIFETIME(UMyObject, MyInteger); //       UBlueprintGeneratedClass* BPClass = Cast<UBlueprintGeneratedClass>(GetClass()); if (BPClass) BPClass->GetLifetimeBlueprintReplicationList(OutLifetimeProps); } 

बाल ब्लूप्रिंट कक्षाओं में चर अब उम्मीद के मुताबिक दोहराए जाएंगे।

UObject में RPC घटनाएँ

RPC (दूरस्थ प्रक्रिया कॉल) ईवेंट विशेष कार्य हैं जिन्हें प्रोजेक्ट के नेटवर्क इंटरैक्शन के दूसरी तरफ कहा जाता है। उनका उपयोग करते हुए, आप सर्वर से अन्य क्लाइंट पर और क्लाइंट से सर्वर पर फ़ंक्शन को कॉल कर सकते हैं। नेटवर्क प्रोजेक्ट लिखते समय बहुत उपयोगी और अक्सर उपयोग किया जाता है।

यदि आप उनसे परिचित नहीं हैं, तो मैं एक लेख पढ़ने की सलाह देता हूं। यह C ++ और ब्लूप्रिंट में उपयोग का वर्णन करता है।

जबकि UObject घटनाओं में अभिनेता या उनके कॉल के साथ घटकों में कोई समस्या नहीं होती है, जहां उन्हें बुलाया गया था, जहां जरूरत पड़ने पर रिमोट कॉल करना असंभव हो जाता है।

घटक कोड (UActorComponent) को देखते हुए, हम कई फ़ंक्शन पा सकते हैं जो आपको नेटवर्क पर कॉल स्थानांतरित करने की अनुमति देते हैं। चूंकि UActorComponent को UObject से विरासत में मिला है, इसलिए हम कोड के आवश्यक अनुभागों को कॉपी कर सकते हैं और अपनी वस्तु में पेस्ट कर सकते हैं ताकि यह काम करे:

ज

 //   #include "Engine/EngineTypes.h" UCLASS(Blueprintable) class MYPROPJECT_API UMyObject : public UObject { GENERATED_BODY() public: virtual bool CallRemoteFunction (UFunction * Function, void * Parms, struct FOutParmRec * OutParms, FFrame * Stack) override; virtual int32 GetFunctionCallspace (UFunction* Function, void* Parameters, FFrame* Stack) override; //   } 

सीपीपी

 //   #include "Engine/NetDriver.h" //       . bool UMyObject::CallRemoteFunction(UFunction * Function, void * Parms, FOutParmRec * OutParms, FFrame * Stack) { if (!GetOuter()) return false; UNetDriver* NetDriver = GetOuter()->GetNetDriver(); if (!NetDriver) return false; NetDriver->ProcessRemoteFunction(GetOuter(), Function, Parms, OutParms, Stack, this); return true; } int32 UMyObject::GetFunctionCallspace(UFunction * Function, void * Parameters, FFrame * Stack) { return (GetOuter() ? GetOuter()->GetFunctionCallspace(Function, Parameters, Stack) : FunctionCallspace::Local); } 

इन कार्यों के साथ, हम RPC घटनाओं को न केवल कोड में, बल्कि ब्लूप्रिंट में भी ट्रिगर करने में सक्षम होंगे।

कृपया ध्यान दें कि क्लाइंट या सर्वर ईवेंट को ट्रिगर करने के लिए, आपको एक स्वामी की आवश्यकता होती है, जिसका स्वामी हमारा खिलाड़ी है। उदाहरण के लिए, ऑब्जेक्ट का स्वामित्व उपयोगकर्ता के चरित्र या उस ऑब्जेक्ट का होता है जिसमें स्वामी प्लेयर का प्लेयर कंट्रोलर होता है।

ब्लूप्रिंट में वैश्विक विशेषताएं

यदि आपने कभी एक ऑब्जेक्ट ब्लोप्रिंट बनाया है, तो आपने देखा होगा कि आप वैश्विक कार्यों को कॉल नहीं कर सकते हैं (स्थैतिक, लेकिन स्पष्टता के लिए हम इसे कहते हैं) जो अन्य वर्गों में उपलब्ध हैं, उदाहरण के लिए, गेटगैमोड ()। ऐसा लगता है कि आप बस ऑब्जेक्ट कक्षाओं में कक्षाएं नहीं कर सकते हैं, जिसके कारण आपको बनाने के दौरान या तो किसी भी लिंक को पास करना होगा, या किसी तरह बिगाड़ना होगा, और कभी-कभी चुनाव पूरी तरह से मंच पर बनने वाले अभिनेता वर्ग पर पड़ता है और हर चीज का समर्थन करता है।

लेकिन C ++ में, निश्चित रूप से, ऐसी समस्याएं नहीं हैं। हालाँकि, गेम डिज़ाइनर, जो सेटिंग्स के साथ खेलता है और विभिन्न छोटी चीज़ों को जोड़ता है, यह नहीं कह सकता है कि आपको विज़ुअल स्टूडियो खोलने की आवश्यकता है, उचित वर्ग ढूंढें और गेम पॉइंट को doSomething () फ़ंक्शन में बदलकर प्राप्त करें। इसलिए, यह जरूरी है कि डिजाइनर ब्लूप्रिंट में प्रवेश कर सकता है और दो क्लिक के साथ वह काम करता है जो उसका काम है। उसका समय और तुम्हारा दोनों बचाओ। हालाँकि, इसके लिए ब्लूप्रिंट का आविष्कार किया गया था।

लब्बोलुआब यह है कि जब आप ब्लूप्रिंट में संदर्भ मेनू में फ़ंक्शन को देखते या कॉल करते हैं, तो उन्हीं वैश्विक कार्यों को जिन्हें दुनिया के संदर्भ की आवश्यकता होती है, अपने ऑब्जेक्ट के अंदर एक फ़ंक्शन को कॉल करने का प्रयास करते हैं जो इसे संदर्भित करता है। और अगर संपादक देखता है कि कोई फ़ंक्शन नहीं है, तो वह समझता है कि वह इसका उपयोग नहीं कर सकता है और इसे सूची में नहीं दिखाता है।



हालांकि, इसके लिए एक इलाज है। यहां तक ​​कि दो।

आइए पहले संपादक में अधिक सुविधाजनक उपयोग के लिए एक विकल्प पर विचार करें। हमें एक फ़ंक्शन को फिर से परिभाषित करना होगा जो दुनिया के लिए एक लिंक देता है और फिर संपादक समझ जाएगा कि खेल में ही यह काम कर सकता है:

ज

 UCLASS(Blueprintable) class MYPROPJECT_API UMyObject : public UObject { GENERATED_BODY() //  GetWorld()    . virtual UWorld* GetWorld() const override; //   } 

सीपीपी

 UWorld* UMyObject::GetWorld() const { //       ,    . if (GIsEditor && !GIsPlayInEditorWorld) return nullptr; else if (GetOuter()) return GetOuter()->GetWorld(); else return nullptr; } 

अब यह परिभाषित किया गया है और संपादक समझ जाएगा कि सामान्य रूप से ऑब्जेक्ट वांछित पॉइंटर प्राप्त करने में सक्षम है (हालांकि यह मान्य नहीं है) और बीपी में वैश्विक कार्यों का उपयोग करें।

कृपया ध्यान दें कि मालिक (GetOuter ()) को भी दुनिया तक पहुंच प्राप्त होनी चाहिए। यह दृश्य में एक विशिष्ट गेटवर्ल्ड (), घटक या अभिनेता वस्तु के साथ एक और UObject हो सकता है।



एक और तरीका है। क्लास को घोषित करते समय UCLASS () मैक्रो में एक लेबल जोड़ने के लिए पर्याप्त है कि BPC में स्थिर कार्यों में WorldContextObject पैरामीटर जोड़ा जाएगा, जिसमें कोई भी वस्तु जो "दुनिया" के लिए एक कंडक्टर के रूप में कार्य करती है और इंजन के वैश्विक कार्यों को खिलाया जाता है। यह विकल्प उन लोगों के लिए उपयुक्त है, जिनके पास परियोजना में एक ही समय में कई दुनिया हो सकती है (उदाहरण के लिए, दर्शक के लिए खेल की दुनिया और दुनिया):

ज

 //   WorldContext      UCLASS(Blueprintable, meta=(ShowWorldContextPin)) class MYPROPJECT_API UMyObject : public UObject { GENERATED_BODY() //   } 

यदि आप BP में खोज में GetGamemode दर्ज करते हैं, तो यह अन्य समान फ़ंक्शन की तरह सूची में दिखाई देगा, और पैरामीटर WorldContextObject होगा, जिसमें आपको अभिनेता के लिंक को पास करना होगा।



वैसे, आप वहां हमारी संपत्ति के मालिक को दर्ज कर सकते हैं। मैं अभिनेता पर एक समारोह बनाने की सलाह देता हूं, यह हमेशा वस्तु के लिए उपयोगी होगा:

ज

 UCLASS(Blueprintable, meta=(ShowWorldContextPin)) class MYPROPJECT_API UMyObject : public UObject { GENERATED_BODY() //      ,     . public: UFUNCTION(BlueprintPure) AActor* GetOwner() const {return Cast<AActor>(GetOuter());}; //   } 

अब आप बस मालिक को प्राप्त करने के लिए हमारे शुद्ध फ़ंक्शन के संयोजन में वैश्विक कार्यों का उपयोग कर सकते हैं।



यदि आप दूसरे संस्करण में भी गेटवर्ल्ड () को पहले संस्करण के रूप में घोषित करते हैं, तो आप WorldContextObject के पैरामीटर में अपने आप को (स्वयं या यह) एक संदर्भ प्रस्तुत कर सकते हैं।

BeginPlay और टिक घटनाओं

एक और समस्या जिसका ब्लूप्रिंट डेवलपर्स सामना कर सकते हैं, वह यह है कि ऑब्जेक्ट क्लास में कोई StartPlay और टिक इवेंट नहीं हैं। बेशक, आप उन्हें खुद बना सकते हैं और दूसरी कक्षा से बुला सकते हैं। लेकिन आपको यह स्वीकार करना होगा कि यह बहुत सुविधाजनक है जब यह सभी बॉक्स से बाहर निकलता है।

शुरुआत प्ले बनाने के तरीके को समझकर करें। हम बीपी में पुनर्लेखन के लिए उपलब्ध एक फ़ंक्शन बना सकते हैं और इसे क्लास के कंस्ट्रक्टर में कॉल कर सकते हैं, लेकिन कई समस्याएं हैं, क्योंकि कंस्ट्रक्टर के समय आपकी ऑब्जेक्ट अभी तक पूरी तरह से इनिशियलाइज़ नहीं हुई है।

सभी वर्गों में, PostInitProperties () फ़ंक्शन है, जो कि अधिकांश मापदंडों के प्रारंभ और विभिन्न आंतरिक प्रणालियों में ऑब्जेक्ट के पंजीकरण के बाद कहा जाता है, उदाहरण के लिए, कचरा कलेक्टर के लिए। इसमें, आप केवल हमारे ईवेंट को कॉल कर सकते हैं, जिसका उपयोग ब्लूप्रिंट में किया जाएगा:

ज

 UCLASS(Blueprintable) class MYPROPJECT_API UMyObject : public UObject { GENERATED_BODY() //      . virtual void PostInitProperties() override; // ,      . UFUNCTION(BlueprintImplementableEvent) void BeginPlay(); //   } 

सीपीपी

 void UMyObject::PostInitProperties() { Super::PostInitProperties(); //   ,   .   BeginPlay    if(GetOuter() && GetOuter()->GetWorld()) BeginPlay(); } 

इसके बजाय यदि (GetOuter () && GetOuter () -> GetWorld ()) आप बस (GetWorld ()) डाल सकते हैं यदि आपने पहले ही इसे फिर से परिभाषित कर लिया है।

सावधान! डिफ़ॉल्ट रूप से, PostInitProperties () को संपादक में भी कहा जाता है।

अब हम अपने BP ऑब्जेक्ट में जा सकते हैं और BeginPlay इवेंट को कॉल कर सकते हैं। ऑब्जेक्ट बनने पर इसे कहा जाएगा।

चलिए इवेंट टिक पर चलते हैं। हमारे लिए कोई सरल कार्य नहीं है। इंजन में टिक ऑब्जेक्ट एक विशेष प्रबंधक को कॉल करता है, जिसके लिए आपको किसी तरह लेने की आवश्यकता होती है। हालांकि, यहां एक बहुत सुविधाजनक चाल है - FTickableGameObject से अतिरिक्त विरासत। यह आपको स्वचालित रूप से आपकी जरूरत की सभी चीजों को करने की अनुमति देगा, और फिर यह केवल आवश्यक कार्यों को लेने के लिए पर्याप्त होगा:

ज

 //   #include "Tickable.h" //   c FTickableGameObject UCLASS(Blueprintable) class MYPROPJECT_API UMyObject : public UObject, public FTickableGameObject { GENERATED_BODY() public: //   virtual void Tick(float DeltaTime) override; virtual bool IsTickable() const override; virtual TStatId GetStatId() const override; protected: //     UFUNCTION(BlueprintImplementableEvent) void EventTick(float DeltaTime); //   } 

सीपीपी

 void UMyObject::Tick(float DeltaTime) { //       . EventTick(DeltaTime); //     . } //     bool UMyObject::IsTickable() const { return true; } TStatId UMyObject::GetStatId() const { return TStatId(); } 

यदि आप अपनी वस्तु से विरासत में प्राप्त करते हैं और बीपी वर्ग बनाते हैं, तो एक EventTick घटना उपलब्ध होगी, जो प्रत्येक फ्रेम के लिए तर्क का कारण बनेगी।

UObjects से घटक जोड़ना

UObject ब्लूप्रिंट में, आप अभिनेताओं के लिए घटकों को स्पॉन नहीं कर सकते। यही समस्या एक्टर कॉमपोन्ट के ब्लूप्रिंट में निहित है। एपिक गेम्स का तर्क बहुत स्पष्ट नहीं है, क्योंकि C ++ में ऐसा किया जा सकता है। इसके अलावा, आप केवल लिंक को निर्दिष्ट करके अभिनेता से दूसरे अभिनेता ऑब्जेक्ट में एक घटक जोड़ सकते हैं। लेकिन ऐसा नहीं किया जा सकता है।

दुर्भाग्य से, मैं इस मद का पता नहीं लगा सका। अगर किसी को यह करने के निर्देश हैं, तो मुझे यहां पोस्ट करने में खुशी होगी।

एकमात्र विकल्प जो मैं इस समय पेश कर सकता हूं, वह है UObject क्लास में एक रैपर बनाना, जो घटकों के सरल जोड़ तक पहुंच प्रदान करता है। इस प्रकार, अभिनेता के लिए घटकों को जोड़ना संभव होगा, लेकिन आपके पास स्पॉन के गतिशील रूप से निर्मित इनपुट पैरामीटर नहीं होंगे। अक्सर, यह उपेक्षित किया जा सकता है।

संपादक के माध्यम से एक उदाहरण स्थापित करना

UE4 में, वस्तुओं के साथ काम करने के लिए एक और सुविधाजनक "सुविधा" है - यह आरंभीकरण के दौरान एक उदाहरण बनाने और संपादक के माध्यम से अपने मापदंडों को बदलने की क्षमता है, जिससे इसके गुणों को सेट किया जा सकता है, केवल सेटिंग्स के लिए एक बाल वर्ग बनाने के बिना। खेल डिजाइनरों के लिए विशेष रूप से उपयोगी है।

मान लीजिए कि आपके पास एक चरित्र के लिए एक संशोधक प्रबंधक है और संशोधक खुद को उन वर्गों द्वारा दर्शाया जाता है जो सुपरइम्पोज़्ड प्रभावों का वर्णन करते हैं। गेम डिज़ाइनर ने एक जोड़ी मॉडिफ़ायर बनाया और प्रबंधक को इंगित किया जो कि उपयोग किए जाते हैं।

एक सामान्य स्थिति में, यह इस तरह दिखेगा:

ज

 class MYPROPJECT_API AMyActor : public AActor { GENERATED_BODY() public: UPROPERTY(EditAnywhere) TSubclassOf<class UMyObject> MyObjectClass; } 

हालाँकि, इसमें एक समस्या है कि यह संशोधक को कॉन्फ़िगर नहीं कर सकता है और आपको अन्य मानों के लिए एक अतिरिक्त वर्ग बनाना होगा। सहमत हैं, सामग्री ब्राउज़र में दर्जनों कक्षाएं होना बहुत सुविधाजनक नहीं है जो केवल मूल्यों में भिन्न हैं। इसे ठीक करना आसान है। आप USTRUCT () के अंदर कुछ फ़ील्ड्स जोड़ सकते हैं, और कंटेनर ऑब्जेक्ट में यह भी इंगित कर सकते हैं कि हमारी ऑब्जेक्ट्स इंस्टेंसेस होंगी, और न केवल गैर-मौजूद ऑब्जेक्ट्स या कक्षाओं के संदर्भ में:

ज

 UCLASS(Blueprintable, DefaultToInstanced, EditInlineNew) //  -        class MYPROPJECT_API UMyObject : public UObject { GENERATED_BODY() UPROPERTY(EditAnywhere) //       uint8 MyValue; // ,    //   } 

यह अकेला पर्याप्त नहीं है, अब यह इंगित करना आवश्यक है कि कक्षा के साथ एक ही चर एक उदाहरण होगा। यह पहले से ही है जहां आप ऑब्जेक्ट को स्टोर करते हैं, उदाहरण के लिए, चरित्र संशोधक प्रबंधक में:

ज

 class MYPROPJECT_API AMyActor : public AActor { GENERATED_BODY() public: UPROPERTY(EditAnywhere, Instanced) //   Instanced    class UMyObject* MyObject; //    } 

कृपया ध्यान दें कि हम ऑब्जेक्ट के संदर्भ का उपयोग करते हैं, और वर्ग के लिए नहीं, क्योंकि उदाहरण के प्रारंभ पर तुरंत बनाया जाएगा। अब हम एक वर्ग का चयन करने और उदाहरण के अंदर मूल्यों को समायोजित करने के लिए संपादक विंडो में जा सकते हैं। यह बहुत अधिक सुविधाजनक और अधिक लचीला है।

जानकारी

अवास्तविक इंजन में एक और दिलचस्प वर्ग है। यह AInfo है। एएकेर से विरासत में मिला एक वर्ग जिसके पास दुनिया में दृश्य प्रतिनिधित्व नहीं है। जानकारी वर्ग का उपयोग करती है जैसे: गेम मोड, गेमस्टेट, प्लेयरस्टैट और अन्य। यही है, कक्षाएं जो एएक्टर से विभिन्न चिप्स का समर्थन करती हैं, उदाहरण के लिए, प्रतिकृति, लेकिन दृश्य पर नहीं रखी जाती हैं।

यदि आपको एक अतिरिक्त, वैश्विक प्रबंधक बनाने की आवश्यकता है जो नेटवर्क और सभी परिणामी अभिनेता वर्गों का समर्थन करे, तो आप इसका उपयोग कर सकते हैं। आपको UObject वर्ग में हेरफेर करने की आवश्यकता नहीं है, जैसा कि ऊपर वर्णित है, उदाहरण के लिए, डेटा को दोहराने के लिए।

हालांकि, यह ध्यान रखें कि यद्यपि ऑब्जेक्ट में कोई निर्देशांक नहीं है, कोई दृश्य घटक नहीं है और यह स्क्रीन पर प्रस्तुत नहीं करता है, यह अभी भी अभिनेता वर्ग का वंशज है, जिसका अर्थ है कि यह माता-पिता के समान भारी है। उचित मात्रा में और सुविधा के लिए उपयोग किया जाता है।

निष्कर्ष

UObject की बहुत बार आवश्यकता होती है, और मैं आपको सलाह देता हूं कि जब भी अभिनेता की आवश्यकता नहीं है, तब इसका उपयोग करें। यह एक दया है कि यह थोड़ा सीमित है, लेकिन यह एक प्लस भी है। कभी-कभी आपको एक कस्टम टेम्पलेट का उपयोग करने की आवश्यकता होने पर टिंकर करना पड़ता है, लेकिन सबसे महत्वपूर्ण बात यह है कि सभी मुख्य प्रतिबंधों को हटाया जा सकता है।

, , UObject, , , .

, , Unreal Engine 4. - , . , - , UObject.