0 registered members (),
677
guests, and 5
spiders. |
Key:
Admin,
Global Mod,
Mod
|
|
|
Re: unreal engine 4
[Re: AlbertoT]
#440823
05/03/14 14:25
05/03/14 14:25
|
Joined: Mar 2011
Posts: 3,150 Budapest
sivan
Expert
|
Expert
Joined: Mar 2011
Posts: 3,150
Budapest
|
if interested in some actual code view, the pre-made 3rd person template character class looks like this (nothing sexy, the capital lettered U... thingies are engine macros you have to know, only the first few lines are auto generated when adding a new class via the editor wizard): .h
// Copyright 1998-2014 Epic Games, Inc. All Rights Reserved.
#pragma once
#include "GameFramework/SpringArmComponent.h"
#include "thirdpersontestCharacter.generated.h"
UCLASS(config=Game)
class AthirdpersontestCharacter : public ACharacter
{
GENERATED_UCLASS_BODY()
/** Camera boom positioning the camera behind the character */
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category=Camera)
TSubobjectPtr<class USpringArmComponent> CameraBoom;
/** Follow camera */
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category=Camera)
TSubobjectPtr<class UCameraComponent> FollowCamera;
/** Base turn rate, in deg/sec. Other scaling may affect final turn rate. */
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category=Camera)
float BaseTurnRate;
/** Base look up/down rate, in deg/sec. Other scaling may affect final rate. */
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category=Camera)
float BaseLookUpRate;
protected:
/** Called for forwards/backward input */
void MoveForward(float Value);
/** Called for side to side input */
void MoveRight(float Value);
/**
* Called via input to turn at a given rate.
* @param Rate This is a normalized rate, i.e. 1.0 means 100% of desired turn rate
*/
void TurnAtRate(float Rate);
/**
* Called via input to turn look up/down at a given rate.
* @param Rate This is a normalized rate, i.e. 1.0 means 100% of desired turn rate
*/
void LookUpAtRate(float Rate);
/** Handler for when a touch input begins. */
void TouchStarted(ETouchIndex::Type FingerIndex, FVector Location);
protected:
// APawn interface
virtual void SetupPlayerInputComponent(class UInputComponent* InputComponent) OVERRIDE;
// End of APawn interface
};
.cpp
// Copyright 1998-2014 Epic Games, Inc. All Rights Reserved.
#include "thirdpersontest.h"
#include "thirdpersontestCharacter.h"
//////////////////////////////////////////////////////////////////////////
// AthirdpersontestCharacter
AthirdpersontestCharacter::AthirdpersontestCharacter(const class FPostConstructInitializeProperties& PCIP)
: Super(PCIP)
{
// Set size for collision capsule
CapsuleComponent->InitCapsuleSize(42.f, 96.0f);
// set our turn rates for input
BaseTurnRate = 45.f;
BaseLookUpRate = 45.f;
// Don't rotate when the controller rotates. Let that just affect the camera.
bUseControllerRotationPitch = false;
bUseControllerRotationYaw = false;
bUseControllerRotationRoll = false;
// Configure character movement
CharacterMovement->bOrientRotationToMovement = true; // Character moves in the direction of input...
CharacterMovement->RotationRate = FRotator(0.0f, 540.0f, 0.0f); // ...at this rotation rate
CharacterMovement->JumpZVelocity = 600.f;
CharacterMovement->AirControl = 0.2f;
// Create a camera boom (pulls in towards the player if there is a collision)
CameraBoom = PCIP.CreateDefaultSubobject<USpringArmComponent>(this, TEXT("CameraBoom"));
CameraBoom->AttachTo(RootComponent);
CameraBoom->TargetArmLength = 300.0f; // The camera follows at this distance behind the character
CameraBoom->bUseControllerViewRotation = true; // Rotate the arm based on the controller
// Create a follow camera
FollowCamera = PCIP.CreateDefaultSubobject<UCameraComponent>(this, TEXT("FollowCamera"));
FollowCamera->AttachTo(CameraBoom, USpringArmComponent::SocketName); // Attach the camera to the end of the boom and let the boom adjust to match the controller orientation
FollowCamera->bUseControllerViewRotation = false; // Camera does not rotate relative to arm
// Note: The skeletal mesh and anim blueprint references on the Mesh component (inherited from Character)
// are set in the derived blueprint asset named MyCharacter (to avoid direct content references in C++)
}
//////////////////////////////////////////////////////////////////////////
// Input
void AthirdpersontestCharacter::SetupPlayerInputComponent(class UInputComponent* InputComponent)
{
// Set up gameplay key bindings
check(InputComponent);
InputComponent->BindAction("Jump", IE_Pressed, this, &ACharacter::Jump);
InputComponent->BindAxis("MoveForward", this, &AthirdpersontestCharacter::MoveForward);
InputComponent->BindAxis("MoveRight", this, &AthirdpersontestCharacter::MoveRight);
// We have 2 versions of the rotation bindings to handle different kinds of devices differently
// "turn" handles devices that provide an absolute delta, such as a mouse.
// "turnrate" is for devices that we choose to treat as a rate of change, such as an analog joystick
InputComponent->BindAxis("Turn", this, &APawn::AddControllerYawInput);
InputComponent->BindAxis("TurnRate", this, &AthirdpersontestCharacter::TurnAtRate);
InputComponent->BindAxis("LookUp", this, &APawn::AddControllerPitchInput);
InputComponent->BindAxis("LookUpRate", this, &AthirdpersontestCharacter::LookUpAtRate);
// handle touch devices
InputComponent->BindTouch(EInputEvent::IE_Pressed, this, &AthirdpersontestCharacter::TouchStarted);
}
void AthirdpersontestCharacter::TouchStarted(ETouchIndex::Type FingerIndex, FVector Location)
{
// jump, but only on the first touch
if (FingerIndex == ETouchIndex::Touch1)
{
Jump();
}
}
void AthirdpersontestCharacter::TurnAtRate(float Rate)
{
// calculate delta for this frame from the rate information
AddControllerYawInput(Rate * BaseTurnRate * GetWorld()->GetDeltaSeconds());
}
void AthirdpersontestCharacter::LookUpAtRate(float Rate)
{
// calculate delta for this frame from the rate information
AddControllerPitchInput(Rate * BaseLookUpRate * GetWorld()->GetDeltaSeconds());
}
void AthirdpersontestCharacter::MoveForward(float Value)
{
if ((Controller != NULL) && (Value != 0.0f))
{
// find out which way is forward
const FRotator Rotation = Controller->GetControlRotation();
const FRotator YawRotation(0, Rotation.Yaw, 0);
// get forward vector
const FVector Direction = FRotationMatrix(Rotation).GetUnitAxis(EAxis::X);
AddMovementInput(Direction, Value);
}
}
void AthirdpersontestCharacter::MoveRight(float Value)
{
if ( (Controller != NULL) && (Value != 0.0f) )
{
// find out which way is right
const FRotator Rotation = Controller->GetControlRotation();
const FRotator YawRotation(0, Rotation.Yaw, 0);
// get right vector
const FVector Direction = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::Y);
// add movement in that direction
AddMovementInput(Direction, Value);
}
}
|
|
|
Re: unreal engine 4
[Re: the_clown]
#440832
05/03/14 19:45
05/03/14 19:45
|
Joined: Oct 2006
Posts: 1,245
AlbertoT
Serious User
|
Serious User
Joined: Oct 2006
Posts: 1,245
|
I don't really see the connection between the use of pointers and a component based architecture. suppose you want to move the entity John In 3dgs you attach an "action" to John Action contains the c_move function with the parameter "me" which is a pointer to the entity John In Unity you attach a script to John which contains the function transform.Traslate() The pointer to john is implicit Now suppose that you want to move John only if he is close to Bill In 3dgs you must have a pointer to Bill in John's action In Unity you call the pointer : bill = GameObject.Find("Bill"); in John's script Dont you see any similarity between 3dgs and Unity ? Dont you agree that the following code is much cleaner ? Start() John = new Actor() Bill = new Actor() Update() if( dist = John.position - Bill.position < = ...) john.Translate();
|
|
|
Re: unreal engine 4
[Re: AlbertoT]
#440834
05/03/14 21:10
05/03/14 21:10
|
Joined: Jan 2002
Posts: 4,225 Germany / Essen
Uhrwerk
Expert
|
Expert
Joined: Jan 2002
Posts: 4,225
Germany / Essen
|
ENTITY* john = ent_create(SPHERE_MDL,vector(0,0,0),NULL);
ENTITY* bill = ent_create(SPHERE_MDL,vector(10,0,0),NULL);
if (vec_dist(&(john->x),&(bill->x)) > 100)
bill->x += 10;
You can also create the GameObject.Find function easily in Gamestudio with the help of ent_next. All this has nothind to do with components.
Always learn from history, to be sure you make the same mistakes again...
|
|
|
Re: unreal engine 4
[Re: the_clown]
#440836
05/03/14 23:18
05/03/14 23:18
|
Joined: Oct 2006
Posts: 1,245
AlbertoT
Serious User
|
Serious User
Joined: Oct 2006
Posts: 1,245
|
What if you have not two but 1000 actors, of different kind, weapons, characters, vehicles, whatever. How would your code look then?
Also, actions in 3dgs can hardy be compared to components. Maybe to a script component, but that's only one flavour of components you could have in a real component based architecture. Yes Unity scripts and 3dgs Actions are similar items Unity supplies a complete set of prefabricated components while in 3DGS you must create your own components using lose functions Of course a traditional engine does not come with the class Actor only It supples different kind of classes such as the class Vehicle or the class Camera , the class light or the generic class Object for non animated items such as weapons
|
|
|
Re: unreal engine 4
[Re: Uhrwerk]
#440855
05/04/14 14:08
05/04/14 14:08
|
Joined: Oct 2006
Posts: 1,245
AlbertoT
Serious User
|
Serious User
Joined: Oct 2006
Posts: 1,245
|
ENTITY* john = ent_create(SPHERE_MDL,vector(0,0,0),NULL);
ENTITY* bill = ent_create(SPHERE_MDL,vector(10,0,0),NULL);
if (vec_dist(&(john->x),&(bill->x)) > 100)
bill->x += 10;
You can also create the GameObject.Find function easily in Gamestudio with the help of ent_next. All this has nothind to do with components. Ok but you can not write, for example John.Animate() or bill.LookAt(john) On th contrary the class Actor contains everything you would expect from an actor ( a character ) same as he class Camera or light or terrain etc This makes the code much more intuitive and clean Anyway superku is right a comparison Unity /3dgs is off topic My question was Can anybody describe in few words UE4 architecture ?
|
|
|
|