पोर्टल्स के साथ सोचना: अवास्तविक इंजन 4 में पोर्टल्स बनाना

इस लेख में मैं आपको बताऊंगा कि अवास्तविक इंजन 4 में पोर्टल्स कैसे बनाए जाते हैं। मुझे ऐसा कोई स्रोत नहीं मिला, जो इस तरह की प्रणाली का विस्तार से वर्णन करता हो (पोर्टलों के माध्यम से निगरानी करना और उनके माध्यम से गुजरना), इसलिए मैंने अपना लिखने का फैसला किया।

एक पोर्टल क्या है?

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


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


हालाँकि, केवल अवास्तविक इंजन के नए संस्करणों में मैंने वांछित प्रभाव को प्राप्त करने का प्रबंधन किया:

पोर्टल - वे कैसे काम करते हैं?

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

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


इस छवि में, कैप्चर डिवाइस (UE4 में दृश्य) उस स्थान के सामने स्थित है जो खिलाड़ी के दृष्टिकोण से देखे गए स्थान से मेल खाती है। सब कुछ जो लाइन के बाद दिखाई देता है उसे कैप्चर के द्वारा प्रतिस्थापित किया जा सकता है। चूंकि कैप्चर डिवाइस दरवाजे और अन्य वस्तुओं के बीच स्थित हो सकती है, इसलिए तथाकथित "क्लिपिंग प्लेन" का उपयोग करना महत्वपूर्ण है। पोर्टल के मामले में, हम चाहते हैं कि पोर्टल के सामने दिखाई देने वाली वस्तुओं को मास्क करने के लिए क्लीपिंग प्लेन हो।

संक्षेप में देना। हमें चाहिए:

• खिलाड़ी का स्थान
• पोर्टल एंट्री पॉइंट
• पोर्टल निकास बिंदु
• क्लिपिंग प्लेन के साथ क्लिपिंग डिवाइस

इसे अवास्तविक इंजन में कैसे लागू किया जाए?

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

ध्यान रखें कि ट्यूटोरियल आपको कोड से वर्ण और प्लेयरकंट्रोलर कक्षाओं तक पहुंच की उम्मीद करता है। मेरे मामले में, उन्हें एक्सड्रेचरचर और एक्सड्रेपलेयरकंट्रोलर कहा जाता है।

एक पोर्टल अभिनेता वर्ग बनाना

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

अभिनेता की विस्तृत चर्चा शुरू करने से पहले, मैं कुछ अवधारणाओं की व्याख्या करता हूं जो मैंने पोर्टल प्रणाली का प्रबंधन करने के लिए बनाई थी:

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

इन नियमों का उपयोग करते हुए, मैंने एएक्टर से विरासत में मिली एक नई एक्सडरपार्टल क्लास बनाई, जो एक शुरुआती बिंदु है। यहाँ इसका शीर्षक है:

#pragma once #include "CoreMinimal.h" #include "GameFramework/Actor.h" #include "ExedrePortal.generated.h" UCLASS() class EXEDRE_API AExedrePortal : public AActor { GENERATED_UCLASS_BODY() protected: virtual void BeginPlay() override; public: virtual void Tick(float DeltaTime) override; //Status of the Portal (being visualized by the player or not) UFUNCTION(BlueprintPure, Category="Exedre|Portal") bool IsActive(); UFUNCTION(BlueprintCallable, Category="Exedre|Portal") void SetActive( bool NewActive ); //Render target to use to display the portal UFUNCTION(BlueprintNativeEvent, BlueprintCallable, Category="Exedre|Portal") void ClearRTT(); UFUNCTION(BlueprintNativeEvent, BlueprintCallable, Category="Exedre|Portal") void SetRTT( UTexture* RenderTexture ); UFUNCTION(BlueprintNativeEvent, Category="Exedre|Portal") void ForceTick(); //Target of where the portal is looking UFUNCTION(BlueprintPure, Category="Exedre|Portal") AActor* GetTarget(); UFUNCTION(BlueprintCallable, Category="Exedre|Portal") void SetTarget( AActor* NewTarget ); //Helpers UFUNCTION(BlueprintCallable, Category="Exedre|Portal") bool IsPointInFrontOfPortal( FVector Point, FVector PortalLocation, FVector PortalNormal ); UFUNCTION(BlueprintCallable, Category="Exedre|Portal") bool IsPointCrossingPortal( FVector Point, FVector PortalLocation, FVector PortalNormal ); UFUNCTION(BlueprintCallable, Category="Exedre|Portal") void TeleportActor( AActor* ActorToTeleport ); protected: UPROPERTY(BlueprintReadOnly) USceneComponent* PortalRootComponent; private: bool bIsActive; AActor* Target; //Used for Tracking movement of a point FVector LastPosition; bool LastInFront; }; 

जैसा कि आप देख सकते हैं, यहां वर्णित अधिकांश व्यवहार हैं। अब देखते हैं कि उन्हें शरीर में (.cpp) कैसे संसाधित किया जाता है।

---

यहां का डिजाइनर रूट कंपोनेंट्स तैयार कर रहा है। मैंने दो मूल घटक बनाने का फैसला किया, क्योंकि पोर्टल अभिनेता ग्राफिक प्रभाव और टकराव / मान्यता दोनों को जोड़ देगा। इसलिए मुझे यह निर्धारित करने के लिए एक सरल तरीके की आवश्यकता थी कि ब्लूटूथ विशेषताओं या अन्य चाल की आवश्यकता के बिना खिड़की / पोर्टल विमान कहां है। PortalRootComponent पोर्टल से संबंधित सभी गणनाओं का आधार होगा।

पोर्टल रूट डायनामिक पर सेट है, अगर ब्लूप्रिंट क्लास इसे एनिमेट करता है (उदाहरण के लिए, एक ओपन / क्लोज एनीमेशन का उपयोग करता है)।

 // Sets default values AExedrePortal::AExedrePortal(const FObjectInitializer& ObjectInitializer) : Super(ObjectInitializer) { PrimaryActorTick.bCanEverTick = true; bIsActive = false; RootComponent = CreateDefaultSubobject<USceneComponent>(TEXT("RootComponent")); RootComponent->Mobility = EComponentMobility::Static; PortalRootComponent = CreateDefaultSubobject<USceneComponent>(TEXT("PortalRootComponent")); PortalRootComponent->SetupAttachment( GetRootComponent() ); PortalRootComponent->SetRelativeLocation( FVector(0.0f, 0.0f, 0.0f) ); PortalRootComponent->SetRelativeRotation( FRotator(0.0f, 0.0f, 0.0f) ); PortalRootComponent->Mobility = EComponentMobility::Movable; } 

---

केवल गेट और सेट कार्य हैं, और अधिक कुछ नहीं। हम दूसरी जगह से गतिविधि की स्थिति का प्रबंधन करेंगे।

 bool AExedrePortal::IsActive() { return bIsActive; } void AExedrePortal::SetActive( bool NewActive ) { bIsActive = NewActive; } 

---

खाका घटनाओं, मैं सी ++ वर्ग में कुछ भी नहीं कर रहा हूं।

 void AExedrePortal::ClearRTT_Implementation() { } void AExedrePortal::SetRTT_Implementation( UTexture* RenderTexture ) { } void AExedrePortal::ForceTick_Implementation() { } 

---

लक्ष्य अभिनेता के लिए कार्य प्राप्त करें और सेट करें। इस भाग में और अधिक जटिल कुछ भी नहीं है।

 AActor* AExedrePortal::GetTarget() { return Target; } void AExedrePortal::SetTarget( AActor* NewTarget ) { Target = NewTarget; } 

---

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

 bool AExedrePortal::IsPointInFrontOfPortal( FVector Point, FVector PortalLocation, FVector PortalNormal ) { FPlane PortalPlane = FPlane( PortalLocation, PortalNormal ); float PortalDot = PortalPlane.PlaneDot( Point ); //If < 0 means we are behind the Plane //See : http://api.unrealengine.com/INT/API/Runtime/Core/Math/FPlane/PlaneDot/index.html return ( PortalDot >= 0 ); } 

---

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

फ़ंक्शन पिछले और वर्तमान स्थान के बीच एक दिशा / खंड बनाता है, और फिर जाँचता है कि क्या वे विमान को काटते हैं। यदि ऐसा है, तो हम जांचते हैं कि क्या यह सही दिशा में (आगे से पीछे?) पार करता है।

 bool AExedrePortal::IsPointCrossingPortal( FVector Point, FVector PortalLocation, FVector PortalNormal ) { FVector IntersectionPoint; FPlane PortalPlane = FPlane( PortalLocation, PortalNormal ); float PortalDot = PortalPlane.PlaneDot( Point ); bool IsCrossing = false; bool IsInFront = PortalDot >= 0; bool IsIntersect = FMath::SegmentPlaneIntersection( LastPosition, Point, PortalPlane, IntersectionPoint ); //Did we intersect the portal since last Location ? //If yes, check the direction : crossing forward means we were in front and now at the back //If we crossed backward, ignore it (similar to Prey 2006) if( IsIntersect && !IsInFront && LastInFront ) { IsCrossing = true; } //Store values for Next check LastInFront = IsInFront; LastPosition = Point; return IsCrossing; } 

टेलीपोर्ट एक्टर

पोर्टल अभिनेता का अंतिम भाग जिसे हम देखेंगे वह TeleportActor () फ़ंक्शन है।

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

पोर्टल का चौराहा एक सीधी रेखा में जाने जैसा लगता है, लेकिन वास्तव में कुछ पूरी तरह से अलग होता है। पोर्टल से बाहर निकलने पर, खिलाड़ी बहुत अलग संदर्भ में हो सकता है। पोर्टल से एक उदाहरण पर विचार करें:


जैसा कि आप देख सकते हैं, पोर्टल को पार करते समय, कैमरा अपने आगे वेक्टर (रोटेट्स) के सापेक्ष घूमता है। इसका कारण यह है कि प्रारंभ और अंत बिंदु विभिन्न विमानों के समानांतर हैं:


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

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

 void AExedrePortal::TeleportActor( AActor* ActorToTeleport ) { if( ActorToTeleport == nullptr || Target == nullptr ) { return; } //------------------------------- //Retrieve and save Player Velocity //(from the Movement Component) //------------------------------- FVector SavedVelocity = FVector::ZeroVector; AExedreCharacter* EC = nullptr; if( ActorToTeleport->IsA( AExedreCharacter::StaticClass() ) ) { EC = Cast<AExedreCharacter>( ActorToTeleport ); SavedVelocity = EC->GetCharMovementComponent()->GetCurrentVelocity(); } //------------------------------- //Compute and apply new location //------------------------------- FHitResult HitResult; FVector NewLocation = UTool::ConvertLocationToActorSpace( ActorToTeleport->GetActorLocation(), this, Target ); ActorToTeleport->SetActorLocation( NewLocation, false, &HitResult, ETeleportType::TeleportPhysics ); //------------------------------- //Compute and apply new rotation //------------------------------- FRotator NewRotation = UTool::ConvertRotationToActorSpace( ActorToTeleport->GetActorRotation(), this, Target ); //Apply new rotation ActorToTeleport->SetActorRotation( NewRotation ); //------------------------------- //If we are teleporting a character we need to //update its controller as well and reapply its velocity //------------------------------- if( ActorToTeleport->IsA( AExedreCharacter::StaticClass() ) ) { //Update Controller AExedrePlayerController* EPC = EC->GetPlayerController(); if( EPC != nullptr ) { NewRotation = UTool::ConvertRotationToActorSpace( EPC->GetControlRotation(), this, Target ); EPC->SetControlRotation( NewRotation ); } //Reapply Velocity (Need to reorient direction into local space of Portal) { FVector Dots; Dots.X = FVector::DotProduct( SavedVelocity, GetActorForwardVector() ); Dots.Y = FVector::DotProduct( SavedVelocity, GetActorRightVector() ); Dots.Z = FVector::DotProduct( SavedVelocity, GetActorUpVector() ); FVector NewVelocity = Dots.X * Target->GetActorForwardVector() + Dots.Y * Target->GetActorRightVector() + Dots.Z * Target->GetActorUpVector(); EC->GetCharMovementComponent()->Velocity = NewVelocity; } } //Cleanup Teleport LastPosition = NewLocation; } 

---

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

 FVector ConvertLocationToActorSpace( FVector Location, AActor* Reference, AActor* Target ) { if( Reference == nullptr || Target == nullptr ) { return FVector::ZeroVector; } FVector Direction = Location - Reference->GetActorLocation(); FVector TargetLocation = Target->GetActorLocation(); FVector Dots; Dots.X = FVector::DotProduct( Direction, Reference->GetActorForwardVector() ); Dots.Y = FVector::DotProduct( Direction, Reference->GetActorRightVector() ); Dots.Z = FVector::DotProduct( Direction, Reference->GetActorUpVector() ); FVector NewDirection = Dots.X * Target->GetActorForwardVector() + Dots.Y * Target->GetActorRightVector() + Dots.Z * Target->GetActorUpVector(); return TargetLocation + NewDirection; } 

विभिन्न कोणों को निर्धारित करने के लिए वैक्टर के स्केलर उत्पाद की गणना करके यहां परिवर्तन किया जाता है। दिशा वेक्टर को सामान्यीकृत नहीं किया जाता है, अर्थात, हम फिर से लक्ष्य वैक्टर के द्वारा डॉट्स परिणाम को गुणा कर सकते हैं ताकि लक्ष्य अभिनेता के स्थानीय स्थान पर ठीक उसी दूरी पर स्थिति प्राप्त हो सके।

 FRotator ConvertRotationToActorSpace( FRotator Rotation, AActor* Reference, AActor* Target ) { if( Reference == nullptr || Target == nullptr ) { return FRotator::ZeroRotator; } FTransform SourceTransform = Reference->GetActorTransform(); FTransform TargetTransform = Target->GetActorTransform(); FQuat QuatRotation = FQuat( Rotation ); FQuat LocalQuat = SourceTransform.GetRotation().Inverse() * QuatRotation; FQuat NewWorldQuat = TargetTransform.GetRotation() * LocalQuat; return NewWorldQuat.Rotator(); } 

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

एक पोर्टल मेष बनाना

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

• विमान 1 : मुख्य विमान जिस पर पोर्टल का रेंडर लक्ष्य प्रदर्शित होता है। इस विमान में एक असामान्य व्यवहार है, क्योंकि इसका कार्य खिलाड़ी से थोड़ा धक्का देना है क्योंकि वह कैमरे द्वारा क्लिपिंग से बचने के लिए संपर्क करता है। चूंकि विमान की सीमाएं नहीं चलती हैं, लेकिन केवल इसकी मध्य चोटियां चलती हैं, इससे खिलाड़ी को दृश्य कलाकृतियों के बिना पोर्टल प्रदान करने पर सुपरमिशन करने की अनुमति मिलती है। किनारों पर किनारों के ऊपरी आधे हिस्से में अपना स्वयं का यूवी है, जबकि निचले किनारों में आंतरिक किनारों का अपना यूवी है, जो उन्हें छाया में मुखौटा करना आसान बनाता है।
• विमान 2 : इस विमान का उपयोग केवल मेष के मानक बाउंडिंग बॉक्स का विस्तार करने के लिए किया जाता है। कोने के मानदंड नीचे की ओर निर्देशित होते हैं, इसलिए गैर-प्लानर जमीन पर भी जाली डिफ़ॉल्ट रूप से दिखाई नहीं देगी (क्योंकि रेंडरिंग सामग्री दो तरफा नहीं होगी)।

क्यों इस तरह एक जाल का उपयोग करें?

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

"विमान 2" कार्य जाल के मानक बाउंडिंग बॉक्स का विस्तार करना है। चूँकि "प्लेन 1" सपाट है, एक अक्ष पर बाउंडिंग बॉक्स की मोटाई 0 है, और यदि कैमरा इसके पीछे है, तो इंजन इसे काट देगा (अर्थात यह इसे रेंडर नहीं करेगा)। प्लेन 1 का आकार 128 × 128 है, इसलिए इसे इंजन का उपयोग करके आसानी से बढ़ाया जा सकता है। विमान 2 मंजिल से थोड़ा बड़ा और नीचे (0 से नीचे) है।

मेष का निर्माण करने के बाद, हम बस इसे तृतीय-पक्ष 3D संपादक से निर्यात करते हैं और अवास्तविक में आयात करते हैं। इसका उपयोग अगले चरण में किया जाएगा।

पोर्टल सामग्री बनाना

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



अब इसे खोलें और निम्नलिखित ग्राफ बनाएं:


यहां बताया गया है कि सामग्री कैसे काम करती है:

• FadeColor रंग है जो पोर्टल के माध्यम से दिखाई देगा जब यह बहुत दूर है। इसकी आवश्यकता है क्योंकि हम हमेशा सभी पोर्टल्स को रेंडर नहीं करते हैं, इसलिए हम प्लेयर / कैमरा दूर होने पर रेंडरिंग को अस्पष्ट करते हैं।
• यह पता लगाने के लिए कि खिलाड़ी पोर्टल से कितना दूर है, मैं कैमरा स्थिति और अभिनेता की स्थिति के बीच की दूरी निर्धारित करता हूं। फिर मैं उस अधिकतम मूल्य से दूरी को विभाजित करता हूं जिसके साथ मैं तुलना करना चाहता हूं। उदाहरण के लिए, यदि अधिकतम I सेट 2000 है, और खिलाड़ी से दूरी 1000 है, तो हमें 0.5 मिलता है। यदि खिलाड़ी आगे है, तो मुझे 1 से अधिक मूल्य मिलेगा, इसलिए मैं इसे सीमित करने के लिए संतृप्त नोड्स का उपयोग करता हूं। अगला स्मूथस्टेप नोड आता है, जिसका उपयोग दूरी को ढाल के रूप में और अधिक सटीक रूप से पोर्टल छायांकन को नियंत्रित करने के लिए किया जाता है। उदाहरण के लिए, मैं चाहता हूं कि जब खिलाड़ी करीब हो, छाया पूरी तरह से गायब हो जाए।
• मैं शेडिंग रंग और बनावट को मिश्रित करने के लिए Lerp नोड के लिए अल्फा चैनल मान के रूप में दूरी की गणना का उपयोग करता हूं जो पोर्टल लक्ष्य को प्रस्तुत करेगा।
• अंत में, मैं एक मुखौटा बनाने के लिए यूवी निर्देशांक के वाई घटक को अलग करता हूं जो आपको यह बताता है कि जाल के कौन से कोने को धक्का दिया जाएगा। मुझे इस मास्क को उस प्रतिकर्षण राशि से गुणा करना है जिसकी मुझे आवश्यकता है। मैं एक नकारात्मक मूल्य का उपयोग करता हूं ताकि जब कोने के मानदंड को गुणा से गुणा किया जाए, तो वे विपरीत दिशा में चलते हैं।

यह सब करने के बाद, हमने तैयार-से-उपयोग सामग्री तैयार की।

ब्लूप्रिंट में एक पोर्टल अभिनेता बनाना

आइए पोर्टल अभिनेता से विरासत में एक नया खाका तैयार करें। सामग्री ब्राउज़र पर राइट-क्लिक करें और ब्लूप्रिंट क्लास चुनें:


अब पोर्टल वर्ग का चयन करने के लिए खोज फ़ील्ड में "पोर्टल" दर्ज करें:


यदि यह पहले से खुला न हो तो ब्लूटूथ खोलें। घटकों की सूची में आपको निम्नलिखित पदानुक्रम दिखाई देंगे:


जैसा कि हमने उम्मीद की थी, एक रूट कंपोनेंट और पोर्टल रूट है। आइए PortalRootComponent में एक स्थिर मेष घटक जोड़ें और पिछले चरण में बनाई गई जाली को इसमें लोड करें:

---

हम टकराव बॉक्स भी जोड़ते हैं, जिसका उपयोग यह निर्धारित करने के लिए किया जाएगा कि खिलाड़ी पोर्टल वॉल्यूम के अंदर है:



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

अब ब्लूप्रिंट में सामग्री सेट करते हैं।

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


हमें अपने स्वयं के ईवेंट नोड्स भी जोड़ने होंगे। ईवेंट ग्राफ़ में राइट-क्लिक मेनू खोलने और ईवेंट के नाम खोजने के लिए सबसे अच्छा है:


और यहाँ निम्नलिखित चित्र बनाने के लिए:

• Play Play : यहां हम इसे अभिनेता को लिंक देने के लिए पोर्टल के मूल फ़ंक्शन SetTarget () को कहते हैं, जिसे बाद में SceneCapture के लिए उपयोग किया जाएगा। फिर हम एक नया डायनामिक मटेरियल बनाते हैं और इसे MaterialInstance वैरिएबल का मान असाइन करते हैं। इस नई सामग्री के साथ, हम इसे स्टैटिक मेश कंपोनेंट को सौंप सकते हैं। मैंने सामग्री को एक डमी बनावट भी दिया, लेकिन यह वैकल्पिक है।
• Clear RTT : इस सुविधा का उद्देश्य पोर्टल सामग्री को सौंपे गए रेंडर टारगेट की बनावट को साफ़ करना है। इसे पोर्टल प्रबंधक द्वारा लॉन्च किया गया है।
• सेट RTT : इस फ़ंक्शन का उद्देश्य पोर्टल की रेंडर टारगेट सामग्री को सेट करना है। इसे पोर्टल प्रबंधक द्वारा लॉन्च किया गया है।

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

पोर्टल प्रबंधक

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

• पोर्टल प्रबंधक एक खिलाड़ी है जिसे प्लेयर कंट्रोलर द्वारा बनाया गया है और खेल स्तर के भीतर खिलाड़ी के राज्य और विकास को ट्रैक करने के लिए इसे संलग्न किया गया है।
• टारगेट पोर्टल बनाएँ और नष्ट करें। यह विचार गतिशील रूप से एक रेंडर टारगेट बनावट बनाने का है जो खिलाड़ी के स्क्रीन रिज़ॉल्यूशन से मेल खाता है। इसके अलावा, खेल के दौरान रिज़ॉल्यूशन बदलते समय, प्रबंधक स्वचालित रूप से इसे वांछित आकार में बदल देगा।
• पोर्टल प्रबंधक पोर्टल रेंडर स्तर को ढूंढता है और उन्हें अद्यतन करता है और उन्हें एक टारगेट टारगेट देता है। यह कार्य इस तरह से किया जाता है ताकि स्तर स्ट्रीमिंग के साथ संगतता सुनिश्चित हो सके। जब एक नया अभिनेता दिखाई देता है, तो उसे एक बनावट मिलनी चाहिए। इसके अलावा, यदि रेंडर लक्ष्य बदल जाता है, तो प्रबंधक अपने आप एक नया भी असाइन कर सकता है। इससे सिस्टम का प्रबंधन करना आसान हो जाता है, बजाय प्रत्येक पोर्टल अभिनेता मैन्युअल रूप से प्रबंधक से संपर्क करने के।
• SceneCapture घटक पोर्टल प्रबंधक से जुड़ा हुआ है, इसलिए प्रत्येक पोर्टल के लिए एक प्रति बनाने के लिए नहीं। इसके अलावा, यह आपको हर बार जब हम एक विशिष्ट पोर्टल अभिनेता के स्तर पर स्विच करते हैं, तो इसका पुन: उपयोग करने की अनुमति देता है।
• जब पोर्टल खिलाड़ी को टेलीपोर्ट करने का फैसला करता है, तो वह पोर्टल प्रबंधक को एक अनुरोध भेजता है। स्रोत और गंतव्य दोनों (यदि कोई हो) पोर्टल्स को अपडेट करने के लिए यह आवश्यक है, ताकि संक्रमण बिना जोड़ों के हो सके।
• पोर्टल प्रबंधक को अक्षर टिक () फ़ंक्शन के अंत में अपडेट किया जाता है ताकि खिलाड़ी के कैमरे सहित सब कुछ सही ढंग से अपडेट हो जाए। यह सुनिश्चित करता है कि स्क्रीन पर सब कुछ सिंक्रनाइज़ है और इंजन द्वारा रेंडरिंग के दौरान एक फ्रेम की देरी से बचा जाता है।

आइए एक नजर डालते हैं पोर्टल मैनेजर हेडर पर:

 #pragma once #include "CoreMinimal.h" #include "GameFramework/Actor.h" #include "ExedrePortalManager.generated.h" //Forward declaration class AExedrePlayerController; class AExedrePortal; class UExedreScriptedTexture; UCLASS() class EXEDRE_API AExedrePortalManager : public AActor { GENERATED_UCLASS_BODY() public: AExedrePortalManager(); //Called by a Portal actor when wanting to teleport something UFUNCTION(BlueprintCallable, Category="Portal") void RequestTeleportByPortal( AExedrePortal* Portal, AActor* TargetToTeleport ); //Save a reference to the PlayerControler void SetControllerOwner( AExedrePlayerController* NewOwner ); //Various setup that happens during spawn void Init(); //Manual Tick void Update( float DeltaTime ); //Find all the portals in world and update them //returns the most valid/usable one for the Player AExedrePortal* UpdatePortalsInWorld(); //Update SceneCapture void UpdateCapture( AExedrePortal* Portal ); //Accessor for Debug purpose UTexture* GetPortalTexture(); //Accessor for Debug purpose FTransform GetCameraTransform(); private: //Function to create the Portal render target void GeneratePortalTexture(); UPROPERTY() USceneCaptureComponent2D* SceneCapture; //Custom class, can be replaced by a "UCanvasRenderTarget2D" instead //See : https://api.unrealengine.com/INT/API/Runtime/Engine/Engine/UCanvasRenderTarget2D/index.html UPROPERTY() UExedreScriptedTexture* PortalTexture; UPROPERTY() AExedrePlayerController* ControllerOwner; int32 PreviousScreenSizeX; int32 PreviousScreenSizeY; float UpdateDelay; }; 

---

विवरण में जाने से पहले, मैं दिखाऊंगा कि कैसे एक खिलाड़ी प्लेयर कंट्रोलर क्लास से बनाया गया है, जिसे बिगप्ले () फ़ंक्शन से कहा जाता है:

  FActorSpawnParameters SpawnParams; PortalManager = nullptr; PortalManager = GetWorld()->SpawnActor<AExedrePortalManager>( AExedrePortalManager::StaticClass(), FVector::ZeroVector, FRotator::ZeroRotator, SpawnParams); PortalManager->AttachToActor( this, FAttachmentTransformRules::SnapToTargetIncludingScale); PortalManager->SetControllerOwner( this ); PortalManager->Init(); 

इसलिए, हम एक अभिनेता बनाते हैं, इसे खिलाड़ी के नियंत्रक (यह) से जोड़ते हैं, और फिर लिंक को सहेजते हैं और इनिट () फ़ंक्शन को कॉल करते हैं।

यह भी ध्यान रखना महत्वपूर्ण है कि हम अभिनेता को चरित्र वर्ग से मैन्युअल रूप से अपडेट करते हैं:

 void AExedreCharacter::TickActor( float DeltaTime, enum ELevelTick TickType, FActorTickFunction& ThisTickFunction ) { Super::TickActor( DeltaTime, TickType, ThisTickFunction ); if( UGameplayStatics::GetPlayerController(GetWorld(), 0) != nullptr ) { AExedrePlayerController* EPC = Cast<AExedrePlayerController>( UGameplayStatics::GetPlayerController(GetWorld(), 0) ); EPC->PortalManager->Update( DeltaTime ); } } 

और यहाँ पोर्टल मैनेजर का निर्माण है। ध्यान दें कि टिक अक्षम है, फिर से क्योंकि हम मैन्युअल रूप से खिलाड़ी के माध्यम से पोर्टल प्रबंधक को अपडेट करेंगे।

 AExedrePortalManager::AExedrePortalManager(const FObjectInitializer& ObjectInitializer) : Super(ObjectInitializer) { PrimaryActorTick.bCanEverTick = false; PortalTexture = nullptr; UpdateDelay = 1.1f; PreviousScreenSizeX = 0; PreviousScreenSizeY = 0; } 

---

यहां पोर्टल मैनेजर पाने / सेट करने के कार्य हैं (उसके बाद हम और दिलचस्प चीजों पर आगे बढ़ेंगे):

 void AExedrePortalManager::SetControllerOwner( AExedrePlayerController* NewOwner ) { ControllerOwner = NewOwner; } FTransform AExedrePortalManager::GetCameraTransform() { if( SceneCapture != nullptr ) { return SceneCapture->GetComponentTransform(); } else { return FTransform(); } } UTexture* AExedrePortalManager::GetPortalTexture() { //Portal Texture is a custom component class that embed a UCanvasRenderTraget2D //The GetTexture() simply returns the RenderTarget contained in that class. //IsValidLowLevel() is used here as a way to ensure the Texture has not been destroyed or garbage collected. if( PortalTexture != nullptr && PortalTexture->IsValidLowLevel() ) { return PortalTexture->GetTexture(); } else { return nullptr; } } 

---

जाहिर है, पहली बात के साथ शुरू करने के लिए Init () फ़ंक्शन है।

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

उल्लेख करने के लिए गुण:

• bCaptureEveryFrame = false : हम यह नहीं चाहते हैं कि जब हमें इसकी आवश्यकता न हो, तो हम इसे चालू कर दें। हम इसे मैन्युअल रूप से प्रबंधित करेंगे।
• bEnableClipPlane = true : पोर्टल कैप्चर को सही ढंग से प्रस्तुत करने के लिए एक बहुत महत्वपूर्ण संपत्ति।
• bUseCustomProjectionMatrix = true : यह खिलाड़ी के दृष्टिकोण के आधार पर हमें कैप्चर प्रोजेक्शन को अपने से बदलने की अनुमति देता है।
• कैप्चरसोर्स = ESceneCaptureSource :: SCS_SceneColorSceneDepth : यह मोड थोड़ा महंगा है, लेकिन पर्याप्त मात्रा में जानकारी प्रदान करना आवश्यक है।

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

अंतिम भाग उस फ़ंक्शन को कॉल करता है जो रेंडर टारगेट बनाता है, जिसे हम नीचे देखेंगे।

 void AExedrePortalManager::Init() { //------------------------------------------------ //Create Camera //------------------------------------------------ SceneCapture = NewObject<USceneCaptureComponent2D>(this, USceneCaptureComponent2D::StaticClass(), *FString("PortalSceneCapture")); SceneCapture->AttachToComponent( GetRootComponent(), FAttachmentTransformRules::SnapToTargetIncludingScale ); SceneCapture->RegisterComponent(); SceneCapture->bCaptureEveryFrame = false; SceneCapture->bCaptureOnMovement = false; SceneCapture->LODDistanceFactor = 3; //Force bigger LODs for faster computations SceneCapture->TextureTarget = nullptr; SceneCapture->bEnableClipPlane = true; SceneCapture->bUseCustomProjectionMatrix = true; SceneCapture->CaptureSource = ESceneCaptureSource::SCS_SceneColorSceneDepth; //Setup Post-Process of SceneCapture (optimization : disable Motion Blur, etc) FPostProcessSettings CaptureSettings; CaptureSettings.bOverride_AmbientOcclusionQuality = true; CaptureSettings.bOverride_MotionBlurAmount = true; CaptureSettings.bOverride_SceneFringeIntensity = true; CaptureSettings.bOverride_GrainIntensity = true; CaptureSettings.bOverride_ScreenSpaceReflectionQuality = true; CaptureSettings.AmbientOcclusionQuality = 0.0f; //0=lowest quality..100=maximum quality CaptureSettings.MotionBlurAmount = 0.0f; //0 = disabled CaptureSettings.SceneFringeIntensity = 0.0f; //0 = disabled CaptureSettings.GrainIntensity = 0.0f; //0 = disabled CaptureSettings.ScreenSpaceReflectionQuality = 0.0f; //0 = disabled CaptureSettings.bOverride_ScreenPercentage = true; CaptureSettings.ScreenPercentage = 100.0f; SceneCapture->PostProcessSettings = CaptureSettings; //------------------------------------------------ //Create RTT Buffer //------------------------------------------------ GeneratePortalTexture(); } 

---

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

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

 void AExedrePortalManager::GeneratePortalTexture() { int32 CurrentSizeX = 1920; int32 CurrentSizeY = 1080; if( ControllerOwner != nullptr ) { ControllerOwner->GetViewportSize(CurrentSizeX, CurrentSizeY); } CurrentSizeX = FMath::Clamp( int(CurrentSizeX / 1.7), 128, 1920); //1920 / 1.5 = 1280 CurrentSizeY = FMath::Clamp( int(CurrentSizeY / 1.7), 128, 1080); if( CurrentSizeX == PreviousScreenSizeX && CurrentSizeY == PreviousScreenSizeY ) { return; } PreviousScreenSizeX = CurrentSizeX; PreviousScreenSizeY = CurrentSizeY; //Cleanup existing RTT if( PortalTexture != nullptr && PortalTexture->IsValidLowLevel() ) { PortalTexture->DestroyComponent(); GEngine->ForceGarbageCollection(); } //Create new RTT PortalTexture = nullptr; PortalTexture = NewObject<UExedreScriptedTexture>(this, UExedreScriptedTexture::StaticClass(), *FString("PortalRenderTarget")); PortalTexture->SizeX = CurrentSizeX; PortalTexture->SizeY = CurrentSizeY; //Custom properties of the UExedreScriptedTexture class PortalTexture->Gamma = 1.0f; PortalTexture->WrapModeX = 1; //Clamp PortalTexture->WrapModeY = 1; //Clamp PortalTexture->bDrawWidgets = false; PortalTexture->bGenerateMipMaps = false; PortalTexture->SetClearOnUpdate( false ); //Will be cleared by SceneCapture instead PortalTexture->Format = ERenderTargetFormat::RGBA16; //Needs 16b to get >1 for Emissive PortalTexture->AttachToComponent( GetRootComponent(), FAttachmentTransformRules::SnapToTargetIncludingScale ); PortalTexture->RegisterComponent(); PortalTexture->SetOwner( this ); PortalTexture->Init(); PortalTexture->SetFilterMode( TextureFilter::TF_Bilinear ); } 

जैसा कि ऊपर उल्लेख किया गया है, मैंने अपनी खुद की कक्षा बनाई है, इसलिए यहां निर्धारित गुण सामान्य रेंडर टारगेट के अनुकूल होने चाहिए।

यह समझना महत्वपूर्ण है कि कैप्चर कहां प्रदर्शित किया जाएगा। चूंकि गेम में रेंडर टारगेट प्रदर्शित किया जाएगा, इसका मतलब यह है कि यह पूरे पोस्ट-प्रोसेसिंग से पहले होगा, और इसलिए हमें पर्याप्त जानकारी (ब्लूम बनाने के लिए 1 से ऊपर के मूल्यों को संग्रहीत करने) के साथ दृश्य को प्रस्तुत करना होगा। यही कारण है कि मैंने RGBA16 प्रारूप को चुना (ध्यान दें कि इसका अपना Enum है, आपको इसके बजाय ETextureRenderTargetFormat का उपयोग करना होगा)।

अधिक जानकारी के लिए, निम्न स्रोत देखें:

• UTextureRenderTarget2D
• ETextureRenderTargetFormat
• USceneCaptureComponent2D

---

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

 void AExedrePortalManager::Update( float DeltaTime ) { //----------------------------------- //Generate Portal texture ? //----------------------------------- UpdateDelay += DeltaTime; if( UpdateDelay > 1.0f ) { UpdateDelay = 0.0f; GeneratePortalTexture(); } //----------------------------------- //Find portals in the level and update them //----------------------------------- AExedrePortal* Portal = UpdatePortalsInWorld(); if( Portal != nullptr ) { UpdateCapture( Portal ); } } 

हम वर्तमान दुनिया में मौजूद सभी पोर्टल्स (सभी लोड किए गए स्तरों सहित ) को खोजने और उन्हें अपडेट करने के लिए UpdatePortalsInWorld () को कॉल करते हैं। फ़ंक्शन यह भी निर्धारित करता है कि कौन सा "सक्रिय" है, अर्थात खिलाड़ी को दिखाई। यदि हमें एक सक्रिय पोर्टल मिलता है, तो हम UpdateCapture () कहते हैं , जो SceneCapture घटक को नियंत्रित करता है।

---

यहां बताया गया है कि दुनिया अपडेट UpdatePortalsInWorld () के अंदर कैसे काम करती है :

1. ( )
2. iterator ,
3. , , ClearRTT() , . (, ).
4. , , , , .

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

 AExedrePortal* AExedrePortalManager::UpdatePortalsInWorld() { if( ControllerOwner == nullptr ) { return nullptr; } AExedreCharacter* Character = ControllerOwner->GetCharacter(); //----------------------------------- //Update Portal actors in the world (and active one if nearby) //----------------------------------- AExedrePortal* ActivePortal = nullptr; FVector PlayerLocation = Character->GetActorLocation(); FVector CameraLocation = Character->GetCameraComponent()->GetComponentLocation(); float Distance = 4096.0f; for( TActorIterator<AExedrePortal>ActorItr( GetWorld() ); ActorItr; ++ActorItr ) { AExedrePortal* Portal = *ActorItr; FVector PortalLocation = Portal->GetActorLocation(); FVector PortalNormal = -1 * Portal->GetActorForwardVector(); //Reset Portal Portal->ClearRTT(); Portal->SetActive( false ); //Find the closest Portal when the player is Standing in front of float NewDistance = FMath::Abs( FVector::Dist( PlayerLocation, PortalLocation ) ); if( NewDistance < Distance ) { Distance = NewDistance; ActivePortal = Portal; } } return ActivePortal; } 

---

यह UpdateCapture () फ़ंक्शन पर विचार करने का समय है ।

यह एक अपग्रेड फीचर है जो पोर्टल के दूसरे हिस्से को कैप्चर करता है। टिप्पणियों से सब कुछ स्पष्ट होना चाहिए, लेकिन यहां एक संक्षिप्त विवरण दिया गया है:

1. हमें कैरेक्टर और प्लेयर कंट्रोलर के लिंक मिलते हैं ।
2. हम जांचते हैं कि क्या सब कुछ सही है (पोर्टल, सीनकैप्ट्योर घटक, प्लेयर)।
3. Camera Target .
4. , SceneCapture.
5. SceneCapture Target.
6. , SceneCapure , , .
7. Render Target SceneCapture, .
8. PlayerController.
9. , Capture SceneCapture .

जैसा कि हम देख सकते हैं, किसी खिलाड़ी को टेलीपोर्ट करते समय, SceneCapture के स्वाभाविक और निर्दोष व्यवहार का एक प्रमुख तत्व स्थानीय टारगेट स्पेस में पोर्टल की स्थिति और रोटेशन का सही परिवर्तन है।

ConvertLocationToActorSpace () की परिभाषा के लिए, "टेलीपोर्टिंग एक्टर" देखें।

 void AExedrePortalManager::UpdateCapture( AExedrePortal* Portal ) { if( ControllerOwner == nullptr ) { return; } AExedreCharacter* Character = ControllerOwner->GetCharacter(); //----------------------------------- //Update SceneCapture (discard if there is no active portal) //----------------------------------- if(SceneCapture != nullptr && PortalTexture != nullptr && Portal != nullptr && Character != nullptr ) { UCameraComponent* PlayerCamera = Character->GetCameraComponent(); AActor* Target = Portal->GetTarget(); //Place the SceneCapture to the Target if( Target != nullptr ) { //------------------------------- //Compute new location in the space of the target actor //(which may not be aligned to world) //------------------------------- FVector NewLocation = UTool::ConvertLocationToActorSpace( PlayerCamera->GetComponentLocation(), Portal, Target ); SceneCapture->SetWorldLocation( NewLocation ); //------------------------------- //Compute new Rotation in the space of the //Target location //------------------------------- FTransform CameraTransform = PlayerCamera->GetComponentTransform(); FTransform SourceTransform = Portal->GetActorTransform(); FTransform TargetTransform = Target->GetActorTransform(); FQuat LocalQuat = SourceTransform.GetRotation().Inverse() * CameraTransform.GetRotation(); FQuat NewWorldQuat = TargetTransform.GetRotation() * LocalQuat; //Update SceneCapture rotation SceneCapture->SetWorldRotation( NewWorldQuat ); //------------------------------- //Clip Plane : to ignore objects between the //SceneCapture and the Target of the portal //------------------------------- SceneCapture->ClipPlaneNormal = Target->GetActorForwardVector(); SceneCapture->ClipPlaneBase = Target->GetActorLocation() + (SceneCapture->ClipPlaneNormal * -1.5f); //Offset to avoid visible pixel border } //Switch on the valid Portal Portal->SetActive( true ); //Assign the Render Target Portal->SetRTT( PortalTexture->GetTexture() ); SceneCapture->TextureTarget = PortalTexture->GetTexture(); //Get the Projection Matrix SceneCapture->CustomProjectionMatrix = ControllerOwner->GetCameraProjectionMatrix(); //Say Cheeeeese ! SceneCapture->CaptureScene(); } } 

कार्य GetCameraProjectionMatrix () कक्षा में डिफ़ॉल्ट PlayerController मौजूद नहीं है, मैं इसे अपने आप को जोड़ा। इसे नीचे दिखाया गया है:

 FMatrix AExedrePlayerController::GetCameraProjectionMatrix() { FMatrix ProjectionMatrix; if( GetLocalPlayer() != nullptr ) { FSceneViewProjectionData PlayerProjectionData; GetLocalPlayer()->GetProjectionData( GetLocalPlayer()->ViewportClient->Viewport, EStereoscopicPass::eSSP_FULL, PlayerProjectionData ); ProjectionMatrix = PlayerProjectionData.ProjectionMatrix; } return ProjectionMatrix; } 

---

अंत में, हमें टेलीपोर्ट फ़ंक्शन पर कॉल को लागू करने की आवश्यकता है। पोर्टल प्रबंधक के माध्यम से टेलीपोर्टेशन के आंशिक प्रसंस्करण का कारण यह है कि आवश्यक पोर्टल्स के अद्यतन की गारंटी देना आवश्यक है, क्योंकि केवल प्रबंधक को दृश्य में सभी पोर्टल्स के बारे में जानकारी है।

यदि हमारे पास दो कनेक्टेड पोर्टल्स हैं, तो एक से दूसरे में स्विच करते समय, हमें दोनों को एक टिक में अपडेट करना होगा। अन्यथा, खिलाड़ी टेलीपोर्ट करेगा और पोर्टल के दूसरी तरफ होगा, लेकिन लक्ष्य पोर्टल अगले फ्रेम / माप तक सक्रिय नहीं होगा। यह विमान जाल की ऑफसेट सामग्री के साथ दृश्य अंतराल बनाएगा जिसे हमने ऊपर देखा था।

 void AExedrePortalManager::RequestTeleportByPortal( AExedrePortal* Portal, AActor* TargetToTeleport ) { if( Portal != nullptr && TargetToTeleport != nullptr ) { Portal->TeleportActor( TargetToTeleport ); //----------------------------------- //Force update //----------------------------------- AExedrePortal* FuturePortal = UpdatePortalsInWorld(); if( FuturePortal != nullptr ) { FuturePortal->ForceTick(); //Force update before the player render its view since he just teleported UpdateCapture( FuturePortal ); } } } 

ठीक है, यह है, हम अंत में पोर्टल प्रबंधक के साथ किया है!

खाका खत्म करो

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


यहां बताया गया है कि यह कैसे काम करता है:

• हम सामग्री को अपडेट कर रहे हैं ताकि यह सक्रिय अवस्था में न रहे।
• यदि पोर्टल वर्तमान में निष्क्रिय है , तो शेष उपाय को छोड़ दिया गया है।
• कैमरा स्थान तक पहुंचने के लिए हमें चरित्र वर्ग मिलता है ।
• पहला भाग यह जाँचता है कि कैमरा पोर्टल के टक्कर बॉक्स में है या नहीं। यदि ऐसा है, तो हम पोर्टल जाल को इसकी सामग्री से भर देते हैं ।
• दूसरा भाग टक्कर बॉक्स के अंदर स्थान को फिर से जांचना है। यदि इसे निष्पादित किया जाता है, तो हम एक फ़ंक्शन को कॉल करते हैं जो यह जांचता है कि क्या हम पोर्टल को पार करते हैं ।
• , Portal manager, Teleport .

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

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

 bool IsPointInsideBox( FVector Point, UBoxComponent* Box ) { if( Box != nullptr ) { //From : //https://stackoverflow.com/questions/52673935/check-if-3d-point-inside-a-box/52674010 FVector Center = Box->GetComponentLocation(); FVector Half = Box->GetScaledBoxExtent(); FVector DirectionX = Box->GetForwardVector(); FVector DirectionY = Box->GetRightVector(); FVector DirectionZ = Box->GetUpVector(); FVector Direction = Point - Center; bool IsInside = FMath::Abs( FVector::DotProduct( Direction, DirectionX ) ) <= Half.X && FMath::Abs( FVector::DotProduct( Direction, DirectionY ) ) <= Half.Y && FMath::Abs( FVector::DotProduct( Direction, DirectionZ ) ) <= Half.Z; return IsInside; } else { return false; } } 

 AExedrePortalManager* GetPortalManager( AActor* Context ) { AExedrePortalManager* Manager = nullptr; //Retrieve the World from the Context actor if( Context != nullptr && Context->GetWorld() != nullptr ) { //Find PlayerController AExedrePlayerController* EPC = Cast<AExedrePlayerController>( Context->GetWorld()->GetFirstPlayerController() ); //Retrieve the Portal Manager if( EPC != nullptr && EPC->GetPortalManager() != nullptr ) { Manager = EPC->GetPortalManager(); } } return Manager; } 

---

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


प्रक्रिया टिक फ़ंक्शन के रूप में लगभग उसी समय शुरू होती है, लेकिन हम केवल अनुक्रम के पहले भाग को निष्पादित करते हैं, जो सामग्री को अपडेट करता है।

क्या हम कर रहे हैं?

लगभग।

यदि हम इस रूप में पोर्टल प्रणाली को लागू करते हैं, तो सबसे अधिक संभावना है कि हम निम्नलिखित समस्या का सामना करेंगे:


यहाँ क्या हो रहा है?

इस gif में, गेम की फ्रेम दर समस्या को और अधिक स्पष्ट रूप से दिखाने के लिए 6 FPS तक सीमित है। एक फ्रेम में, क्यूब गायब हो जाता है क्योंकि अवास्तविक इंजन क्लिपिंग सिस्टम इसे अदृश्य मानता है।

ऐसा इसलिए है क्योंकि खोज को वर्तमान फ्रेम में किया जाता है, और फिर अगले में उपयोग किया जाता है। यह एक फ्रेम की देरी पैदा करता है । यह आमतौर पर ऑब्जेक्ट के बाउंडिंग बॉक्स का विस्तार करके हल किया जा सकता है ताकि यह दिखाई देने से पहले पंजीकृत हो। हालांकि, यह यहां काम नहीं करेगा, क्योंकि जब हम पोर्टल को पार करते हैं, तो हम एक जगह से एक पूरी तरह से अलग से टेलीपोर्ट करते हैं।

कतरन प्रणाली को अक्षम करना भी असंभव है, खासकर क्योंकि कई वस्तुओं के स्तर पर यह प्रदर्शन को कम करेगा। इसके अलावा, मैंने अवास्तविक इंजन की कई टीमों की कोशिश की, लेकिन सकारात्मक परिणाम नहीं मिले: सभी मामलों में, एक फ्रेम की देरी बनी रही। सौभाग्य से, अवास्तविक इंजन स्रोत कोड के एक विस्तृत अध्ययन के बाद, मैं एक समाधान खोजने में कामयाब रहा (पथ लंबा था - इसमें एक सप्ताह से अधिक समय लगा)!

सीनकैपचर घटक के साथ, आप खिलाड़ी के कैमरे को बता सकते हैं कि हमने एक छलांग लगाई है- कैमरे की स्थिति दो फ़्रेमों के बीच कूद गई, जिसका अर्थ है कि हम पिछले फ्रेम की जानकारी पर भरोसा नहीं कर सकते हैं। मतिने या सीक्वेंसर का उपयोग करते समय यह व्यवहार देखा जा सकता है, उदाहरण के लिए, जब कैमरे स्विच करते हैं: गति धुंधला या चौरसाई पिछले फ्रेम से जानकारी पर भरोसा नहीं कर सकती है।

ऐसा करने के लिए, हमें दो पहलुओं पर विचार करने की आवश्यकता है:

• LocalPlayer : यह वर्ग विभिन्न जानकारी (उदाहरण के लिए, खिलाड़ी का व्यूपोर्ट) को संसाधित करता है और प्लेयरकंट्रोलर के साथ जुड़ा होता है। यह वह जगह है जहां हम खिलाड़ी के कैमरे की प्रतिपादन प्रक्रिया को प्रभावित कर सकते हैं।
• प्लेयरकंट्रोलर : जब कोई खिलाड़ी टेलीपोर्ट करता है, तो यह क्लास लोकलपेयर तक पहुंचने के लिए धन्यवाद शुरू कर देता है।

इस समाधान का बड़ा फायदा यह है कि इंजन की रेंडरिंग प्रक्रिया में हस्तक्षेप अवास्तविक इंजन के भविष्य के अपडेट में बनाए रखने के लिए न्यूनतम और आसान है।

---

चलिए शुरुआत करते हैं लोकलपेयर से विरासत में मिला एक नया वर्ग बनाने की। नीचे एक शीर्षक है जो दो मुख्य घटकों की पहचान करता है: दृश्य व्यूपोर्ट गणना को फिर से परिभाषित करना और कैमरा gluing के लिए एक नया कार्य।

 #pragma once #include "CoreMinimal.h" #include "Engine/LocalPlayer.h" #include "ExedreLocalPlayer.generated.h" UCLASS() class EXEDRE_API UExedreLocalPlayer : public ULocalPlayer { GENERATED_BODY() UExedreLocalPlayer(); public: FSceneView* CalcSceneView( class FSceneViewFamily* ViewFamily, FVector& OutViewLocation, FRotator& OutViewRotation, FViewport* Viewport, class FViewElementDrawer* ViewDrawer, EStereoscopicPass StereoPass) override; void PerformCameraCut(); private: bool bCameraCut; }; 

यहां बताया गया है कि सब कुछ कैसे लागू किया जाता है:

 #include "Exedre.h" #include "ExedreLocalPlayer.h" UExedreLocalPlayer::UExedreLocalPlayer() { bCameraCut = false; } FSceneView* UExedreLocalPlayer::CalcSceneView( class FSceneViewFamily* ViewFamily, FVector& OutViewLocation, FRotator& OutViewRotation, FViewport* Viewport, class FViewElementDrawer* ViewDrawer, EStereoscopicPass StereoPass) { // ULocalPlayer::CalcSceneView() use a ViewInitOptions to create // a FSceneView which contains a "bCameraCut" variable // See : H:\GitHub\UnrealEngine\Engine\Source\Runtime\Renderer\Private\SceneCaptureRendering.cpp // as well for bCameraCutThisFrame in USceneCaptureComponent2D FSceneView* View = Super::CalcSceneView(ViewFamily, OutViewLocation, OutViewRotation, Viewport, ViewDrawer, StereoPass ); if( bCameraCut ) { View->bCameraCut = true; bCameraCut = false; } return View; } void UExedreLocalPlayer::PerformCameraCut() { bCameraCut = true; } 

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

---

प्लेयर कंट्रोलर साइड पर, परिवर्तन न्यूनतम हैं। आपको LocalPlayer के मूल वर्ग का लिंक संग्रहीत करने के लिए शीर्ष लेख में एक चर जोड़ना होगा:

  UPROPERTY() UExedreLocalPlayer* LocalPlayer; 

तब BeginPlay () फ़ंक्शन में :

  LocalPlayer = Cast<UExedreLocalPlayer>( GetLocalPlayer() ); 

मैंने कट को जल्द लॉन्च करने के लिए एक फंक्शन भी जोड़ा:

 void AExedrePlayerController::PerformCameraCut() { if( LocalPlayer != nullptr ) { LocalPlayer->PerformCameraCut(); } } 

---

अंत में, पोर्टल प्रबंधक फ़ंक्शन RequestTeleportByPortal () में, हम कैमरा कट टेलीपोर्टेशन के दौरान निष्पादित कर सकते हैं:

 void AExedrePortalManager::RequestTeleportByPortal( AExedrePortal* Portal, AActor* TargetToTeleport ) { if( Portal != nullptr && TargetToTeleport != nullptr ) { if( ControllerOwner != nullptr ) { ControllerOwner->PerformCameraCut(); } [...] 

और वह सब है!

कैमरा कट को SceneCapture के अपडेट होने से पहले कॉल किया जाना चाहिए, यही वजह है कि यह फ़ंक्शन की शुरुआत में है।

अंतिम परिणाम

अब हमने पोर्टल्स में सोचना सीख लिया है।

यदि सिस्टम अच्छा काम करता है, तो हमें इन चीजों को बनाने में सक्षम होना चाहिए:


यदि आपको समस्या हो रही है, तो निम्नलिखित जांचें:

• सत्यापित करें कि पोर्टल प्रबंधक ठीक से बनाया और आरंभिक है।
• रेंडर लक्ष्य सही ढंग से बनाया गया है (आप आरंभ करने के लिए सामग्री ब्राउज़र में निर्मित एक का उपयोग कर सकते हैं)।
• पोर्टल सही ढंग से सक्रिय और निष्क्रिय हैं।
• पोर्टल्स में एडिटर में टार्गेट एक्टर सही तरीके से सेट है।

क्यू एंड ए

इस ट्यूटोरियल के बारे में मुझसे पूछे गए सबसे लोकप्रिय सवाल:

क्या इसे ब्लंट पर लागू करना संभव है, और सी ++ के माध्यम से नहीं?

कोड के थोक को दो पहलुओं के अपवाद के साथ, ब्लंट में लागू किया जा सकता है:

• प्रोजेक्शन मैट्रिक्स को प्राप्त करने के लिए उपयोग किया जाने वाला LocalPlayer GetProjectionData () फ़ंक्शन ब्लूप्रिंट में उपलब्ध नहीं है।
• LocalPlayer CalcSceneView () फ़ंक्शन , जो कतरन प्रणाली समस्या को हल करने के लिए महत्वपूर्ण है, ब्लूप्रिंट में उपलब्ध नहीं है।

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

क्या मैं वीआर में इस प्रणाली का उपयोग कर सकता हूं?

हाँ, अधिकांश भाग के लिए। हालांकि, कुछ हिस्सों को अनुकूलित करना होगा, उदाहरण के लिए:

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

मुख्य समस्या प्रदर्शन होगी, क्योंकि पोर्टल के दूसरे पक्ष को दो बार प्रस्तुत करना होगा।

क्या कोई अन्य वस्तु पोर्टल को पार कर सकती है?

मेरे कोड में कोई नहीं है। हालांकि, इसे और सामान्य बनाना इतना मुश्किल नहीं है। ऐसा करने के लिए, पोर्टल को यह जांचने की आवश्यकता है कि क्या वे इसे पार करते हैं या नहीं।

क्या सिस्टम रिकर्सन (पोर्टल के अंदर पोर्टल) का समर्थन करता है?

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

क्या मैं दीवार के पास पोर्टल पार कर सकता हूं?

दुर्भाग्य से, नहीं। हालाँकि, मैं इसे लागू करने के दो तरीके देखता हूं (सैद्धांतिक रूप से):

• खिलाड़ी की टक्करों को अक्षम करें ताकि वह दीवारों से गुजर सके। इसे लागू करना आसान है, लेकिन इससे कई दुष्प्रभाव होंगे।
• गतिशील रूप से एक छेद बनाने के लिए टकराव प्रणाली को हैक करें, जो खिलाड़ी को गुजरने की अनुमति देगा। ऐसा करने के लिए, आपको इंजन की भौतिक प्रणाली को संशोधित करने की आवश्यकता है। हालाँकि, जो मैं जानता हूँ, स्तर लोड करने के बाद, स्थिर भौतिकी को अद्यतन नहीं किया जा सकता है। इसलिए, इस सुविधा का समर्थन करने के लिए बहुत काम की आवश्यकता होगी। यदि आपके पोर्टल्स स्थिर हैं, तो आप संभवतः विभिन्न टकरावों के बीच स्विच करने के लिए स्तर स्ट्रीमिंग का उपयोग करके इस समस्या को हल कर सकते हैं।