Thanks for the BP->C++ Converter, it's awesome!

John_Alcatraz · February 25, 2016, 4:10pm

I can’t find any code in the <Project Path>\Intermediate\WindowsNoEditor\NativizedAssets\Source\ that was mentioned, and I don’t see much reason to spend time on searching for where the code is since its not supposed to be ever looked at. You don’t need that code

anonymous_user_21a58d97 · February 25, 2016, 5:08pm

@kaziu

If you are responsible for this and it does not blow my project up when i use it for the first time, i am buying dinner,supper and all the drinks you can possibly have!

Whooohoooo!!

Shirk · February 25, 2016, 9:54pm

I tried getting this to work, but the packaging fails on every 4.11 project, even just the templates.

John_Alcatraz · February 26, 2016, 12:06am

Do you have VS2015 installed?

Slavq · February 26, 2016, 12:57am

Wow! That’s just Epic.

Send positive energy to dev team to help finishing this converter

Shirk · February 26, 2016, 12:58am

I have Visual Studio Community 2015 installed. I have only installed it though, I haven’t touched it for anything else.

SaxonRah · February 28, 2016, 7:25pm

I will be posting soon about the BP 2 C++ converter. I will post everything i did.

Edit here we go.

Picture album of the converted blueprint and screenshots of what the blueprint does.

[Album] imgur.com

&stc=1

HeightSplineBPActor__pf.H:


#pragma once
#include "Blueprint/BlueprintSupport.h"


#include "Runtime/Engine/Classes/GameFramework/Actor.h"
class USplineComponent;
#include "HeightSpline_BPActor__pf.generated.h"
UCLASS(Blueprintable, BlueprintType, meta=(ReplaceConverted="/Game/BP2Cpp/HeightSpline_BPActor.HeightSpline_BPActor_C", OverrideNativeName="HeightSpline_BPActor_C"))
class AHeightSpline_BPActor_C__pf : public AActor
{
public:
    GENERATED_BODY()
    UPROPERTY(BlueprintReadWrite, NonTransactional, meta=(Category="Default", OverrideNativeName="SplineRoad"))
    USplineComponent* bpv__SplineRoad__pf;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, meta=(DisplayName="Number Of Circle Points", Category="Default", OverrideNativeName="NumberOfCirclePoints"))
    int32 bpv__NumberOfCirclePoints__pf;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, meta=(DisplayName="Circle Diameter", Category="Default", OverrideNativeName="CircleDiameter"))
    float bpv__CircleDiameter__pf;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, meta=(DisplayName="Start Angle", Category="Default", UIMax="360", ClampMax="360", UIMin="0", ClampMin="0", OverrideNativeName="StartAngle"))
    float bpv__StartAngle__pf;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, meta=(DisplayName="Trace Length", Category="Default", OverrideNativeName="TraceLength"))
    float bpv__TraceLength__pf;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, meta=(DisplayName="B Closed Loop", Category="Default", OverrideNativeName="bClosedLoop"))
    bool bpv__bClosedLoop__pf;
    AHeightSpline_BPActor_C__pf(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get());
    virtual void PostLoadSubobjects(FObjectInstancingGraph* OuterInstanceGraph) override;
    static void __StaticDependenciesAssets(TArray<FBlueprintDependencyData>& AssetsToLoad);
    UFUNCTION(BlueprintCallable, meta=(BlueprintInternalUseOnly="true", DisplayName="Construction Script", ToolTip="Construction script, the place to spawn components and do other setup.@note Name used in CreateBlueprint function@param       Location        The location.@param       Rotation        The rotation.", Category, CppFromBpEvent, OverrideNativeName="UserConstructionScript"))
    void bpf__UserConstructionScript__pf();
    UFUNCTION(BlueprintCallable, meta=(Category, OverrideNativeName="CreateSplinePoints"))
    virtual void bpf__CreateSplinePoints__pf();
public:
};

HeightSplineBPActor__pf.CPP:



#include "HeightSpline_BPActor__pf.h"
#include "GeneratedCodeHelpers.h"
#include "Runtime/Engine/Classes/Components/SplineComponent.h"
#include "Runtime/Engine/Classes/Engine/SCS_Node.h"
#include "Runtime/Engine/Classes/Components/SceneComponent.h"
#include "Runtime/Engine/Classes/Engine/SimpleConstructionScript.h"
#include "Runtime/CoreUObject/Classes/Object.h"
#include "Runtime/Engine/Classes/Components/ActorComponent.h"
#include "Runtime/Engine/Classes/GameFramework/PlayerController.h"
#include "Runtime/InputCore/Classes/InputCoreTypes.h"
#include "Runtime/Engine/Classes/GameFramework/Pawn.h"
#include "Runtime/Engine/Classes/GameFramework/Controller.h"
#include "Runtime/Engine/Classes/Components/PrimitiveComponent.h"
#include "Runtime/Engine/Classes/Components/ChildActorComponent.h"
#include "Runtime/Engine/Classes/Engine/EngineTypes.h"
#include "Runtime/Engine/Classes/Materials/MaterialInterface.h"
#include "Runtime/Engine/Classes/Materials/MaterialInstanceDynamic.h"
#include "Runtime/Engine/Classes/GameFramework/DamageType.h"
#include "Runtime/Engine/Classes/Engine/EngineBaseTypes.h"
#include "Runtime/Engine/Classes/Components/InputComponent.h"
#include "Runtime/Engine/Classes/Matinee/MatineeActor.h"
#include "Runtime/Engine/Classes/Kismet/KismetMathLibrary.h"
#include "Runtime/Engine/Classes/Kismet/KismetSystemLibrary.h"
#include "Runtime/Engine/Classes/Kismet/GameplayStatics.h"
#include "Runtime/Engine/Classes/PhysicalMaterials/PhysicalMaterial.h"
#include "Runtime/Engine/Classes/Engine/BlueprintGeneratedClass.h"
AHeightSpline_BPActor_C__pf::AHeightSpline_BPActor_C__pf(const FObjectInitializer& ObjectInitializer) : Super(ObjectInitializer)
{
    if(HasAnyFlags(RF_ClassDefaultObject) && (AHeightSpline_BPActor_C__pf::StaticClass() == GetClass()))
    {
        ensure(0 == CastChecked<UDynamicClass>(GetClass())->MiscConvertedSubobjects.Num());
        ensure(0 == CastChecked<UDynamicClass>(GetClass())->ReferencedConvertedFields.Num());
        ensure(0 == CastChecked<UDynamicClass>(GetClass())->UsedAssets.Num());
        ensure(0 == CastChecked<UDynamicClass>(GetClass())->DynamicBindingObjects.Num());
        ensure(0 == CastChecked<UDynamicClass>(GetClass())->ComponentTemplates.Num());
        ensure(0 == CastChecked<UDynamicClass>(GetClass())->Timelines.Num());
        ensure(nullptr == CastChecked<UDynamicClass>(GetClass())->AnimClassImplementation);
    }
    {
        
        bpv__SplineRoad__pf = CreateDefaultSubobject<USplineComponent>(TEXT("SplineRoad"));
        RootComponent = bpv__SplineRoad__pf;
        bpv__SplineRoad__pf->CreationMethod = EComponentCreationMethod::Native;
        bpv__SplineRoad__pf->SplineInfo.LoopKeyOffset = 1.000000f;
        bpv__SplineRoad__pf->SplineRotInfo.LoopKeyOffset = 1.000000f;
        bpv__SplineRoad__pf->SplineScaleInfo.LoopKeyOffset = 1.000000f;
        bpv__SplineRoad__pf->BodyInstance.MassInKg = 0.000000f;
        bpv__NumberOfCirclePoints__pf = 12;
        bpv__CircleDiameter__pf = 2400.000000f;
        bpv__StartAngle__pf = 0.000000f;
        bpv__TraceLength__pf = 1000.000000f;
        bpv__bClosedLoop__pf = false;
    }
}
void AHeightSpline_BPActor_C__pf::PostLoadSubobjects(FObjectInstancingGraph* OuterInstanceGraph)
{
    Super::PostLoadSubobjects(OuterInstanceGraph);
    if(ensure(bpv__SplineRoad__pf))
    {
        bpv__SplineRoad__pf->CreationMethod = EComponentCreationMethod::Native;
    }
}
void AHeightSpline_BPActor_C__pf::__StaticDependenciesAssets(TArray<FBlueprintDependencyData>& AssetsToLoad)
{
}
struct FRegisterHelper__AHeightSpline_BPActor_C__pf
{
    FRegisterHelper__AHeightSpline_BPActor_C__pf()
    {
        FConvertedBlueprintsDependencies::Get().RegisterClass(TEXT("/Game/BP2Cpp/HeightSpline_BPActor"), &AHeightSpline_BPActor_C__pf::__StaticDependenciesAssets);
    }
    static FRegisterHelper__AHeightSpline_BPActor_C__pf Instance;
};
FRegisterHelper__AHeightSpline_BPActor_C__pf FRegisterHelper__AHeightSpline_BPActor_C__pf::Instance;
void AHeightSpline_BPActor_C__pf::bpf__UserConstructionScript__pf()
{
    // K2Node_FunctionEntry_0
    // K2Node_VariableGet_420
    // K2Node_VariableGet_413
    // K2Node_CallFunction_8929
    if(IsValid(bpv__SplineRoad__pf))
    {
        bpv__SplineRoad__pf->SetClosedLoop(bpv__bClosedLoop__pf);
    }
    // K2Node_CallFunction_2499
    bpf__CreateSplinePoints__pf();
    return;
}
void AHeightSpline_BPActor_C__pf::bpf__CreateSplinePoints__pf()
{
    int32 bpv__Temp_int_Variable__pf{};
    int32 bpv__CallFunc_Add_IntInt_ReturnValue__pf{};
    float bpv__CallFunc_Conv_IntToFloat_ReturnValue__pf{};
    float bpv__CallFunc_Multiply_IntFloat_ReturnValue__pf{};
    float bpv__CallFunc_Divide_FloatFloat_ReturnValue__pf{};
    float bpv__CallFunc_Divide_FloatFloat_ReturnValue2__pf{};
    float bpv__CallFunc_Add_FloatFloat_ReturnValue__pf{};
    float bpv__CallFunc_Sin_ReturnValue__pf{};
    float bpv__CallFunc_BreakVector_X__pf{};
    float bpv__CallFunc_BreakVector_Y__pf{};
    float bpv__CallFunc_BreakVector_Z__pf{};
    float bpv__CallFunc_Multiply_FloatFloat_ReturnValue__pf{};
    float bpv__CallFunc_Cos_ReturnValue__pf{};
    float bpv__CallFunc_Add_FloatFloat_ReturnValue2__pf{};
    float bpv__CallFunc_Multiply_FloatFloat_ReturnValue2__pf{};
    float bpv__CallFunc_BreakVector_X2__pf{};
    float bpv__CallFunc_BreakVector_Y2__pf{};
    float bpv__CallFunc_BreakVector_Z2__pf{};
    float bpv__CallFunc_Multiply_IntFloat_ReturnValue2__pf{};
    float bpv__CallFunc_Add_FloatFloat_ReturnValue3__pf{};
    float bpv__CallFunc_GetPI_ReturnValue__pf{};
    FVector bpv__CallFunc_MakeVector_ReturnValue__pf{};
    float bpv__CallFunc_Multiply_FloatFloat_ReturnValue3__pf{};
    TArray<AActor*> bpv__Temp_object_Variable__pf{};
    bool bpv__CallFunc_LessEqual_IntInt_ReturnValue__pf{};
    float bpv__CallFunc_Multiply_IntFloat_ReturnValue3__pf{};
    FVector bpv__CallFunc_MakeVector_ReturnValue2__pf{};
    FHitResult bpv__CallFunc_LineTraceSingle_NEW_OutHit__pf{};
    bool bpv__CallFunc_LineTraceSingle_NEW_ReturnValue__pf{};
    FVector bpv__CallFunc_K2_GetComponentLocation_ReturnValue__pf{};
    bool bpv__CallFunc_BreakHitResult_bBlockingHit__pf{};
    bool bpv__CallFunc_BreakHitResult_bInitialOverlap__pf{};
    float bpv__CallFunc_BreakHitResult_Time__pf{};
    FVector bpv__CallFunc_BreakHitResult_Location__pf{};
    FVector bpv__CallFunc_BreakHitResult_ImpactPoint__pf{};
    FVector bpv__CallFunc_BreakHitResult_Normal__pf{};
    FVector bpv__CallFunc_BreakHitResult_ImpactNormal__pf{};
    UPhysicalMaterial* bpv__CallFunc_BreakHitResult_PhysMat__pf{};
    AActor* bpv__CallFunc_BreakHitResult_HitActor__pf{};
    UPrimitiveComponent* bpv__CallFunc_BreakHitResult_HitComponent__pf{};
    FName bpv__CallFunc_BreakHitResult_HitBoneName__pf{};
    int32 bpv__CallFunc_BreakHitResult_HitItem__pf{};
    FVector bpv__CallFunc_BreakHitResult_TraceStart__pf{};
    FVector bpv__CallFunc_BreakHitResult_TraceEnd__pf{};
    int32 bpv__Local_PointIteration__pf{};
    float bpv__Local_Radius__pf{};
    FVector bpv__Local_Origin__pf{};
    float bpv__Local_Theta__pf{};
    float bpv__Local_Tau__pf{};
    TArray< int32, TInlineAllocator<8> > StateStack;


    int32 CurrentState = 0;
    do
    {
        switch( CurrentState )
        {
        case 0:
            {
                // K2Node_FunctionEntry_4
            }
        case 1:
            {
                // K2Node_VariableSet_256
                bpv__Local_Origin__pf = FVector(0.000000,0.000000,0.000000);
            }
        case 2:
            {
                // K2Node_VariableGet_256
                // K2Node_CallFunction_2423
                if(IsValid(bpv__SplineRoad__pf))
                {
                    bpv__SplineRoad__pf->ClearSplinePoints();
                }
            }
        case 3:
            {
                // K2Node_VariableGet_256
                // K2Node_CallFunction_2456
                if(IsValid(bpv__SplineRoad__pf))
                {
                    bpv__CallFunc_K2_GetComponentLocation_ReturnValue__pf = bpv__SplineRoad__pf->K2_GetComponentLocation();
                }
                // K2Node_VariableSet_63
                bpv__Local_Origin__pf = bpv__CallFunc_K2_GetComponentLocation_ReturnValue__pf;
            }
        case 4:
            {
                // K2Node_CallFunction_2428
                bpv__CallFunc_GetPI_ReturnValue__pf = UKismetMathLibrary::GetPI();
                // K2Node_CommutativeAssociativeBinaryOperator_23
                bpv__CallFunc_Multiply_FloatFloat_ReturnValue3__pf = UKismetMathLibrary::Multiply_FloatFloat(bpv__CallFunc_GetPI_ReturnValue__pf, 2.000000);
                // K2Node_VariableSet_20
                bpv__Local_Tau__pf = bpv__CallFunc_Multiply_FloatFloat_ReturnValue3__pf;
            }
        case 5:
            {
                // K2Node_VariableGet_524
                // K2Node_CallFunction_3301
                bpv__CallFunc_Divide_FloatFloat_ReturnValue__pf = FCustomThunkTemplates::Divide_FloatFloat(bpv__CircleDiameter__pf, 2.000000);
                // K2Node_VariableSet_22
                bpv__Local_Radius__pf = bpv__CallFunc_Divide_FloatFloat_ReturnValue__pf;
            }
        case 6:
            {
                // K2Node_TemporaryVariable_285
                // K2Node_AssignmentStatement_235
                bpv__Temp_int_Variable__pf = 1;
            }
        case 7:
            {
                // K2Node_TemporaryVariable_285
                // K2Node_VariableGet_100
                // K2Node_CallFunction_8955
                bpv__CallFunc_LessEqual_IntInt_ReturnValue__pf = UKismetMathLibrary::LessEqual_IntInt(bpv__Temp_int_Variable__pf, bpv__NumberOfCirclePoints__pf);
                // K2Node_IfThenElse_104
                if (!bpv__CallFunc_LessEqual_IntInt_ReturnValue__pf)
                {
                    CurrentState = (StateStack.Num() > 0) ? StateStack.Pop(/*bAllowShrinking=*/ false) : -1;
                    break;
                }
            }
        case 8:
            {
                // K2Node_ExecutionSequence_94
                StateStack.Push(9);
                CurrentState = 11;
                break;
            }
        case 9:
            {
            }
        case 10:
            {
                // K2Node_TemporaryVariable_285
                // K2Node_CallFunction_8954
                bpv__CallFunc_Add_IntInt_ReturnValue__pf = UKismetMathLibrary::Add_IntInt(bpv__Temp_int_Variable__pf, 1);
                // K2Node_AssignmentStatement_234
                bpv__Temp_int_Variable__pf = bpv__CallFunc_Add_IntInt_ReturnValue__pf;
                CurrentState = 7;
                break;
            }
        case 11:
            {
                // K2Node_TemporaryVariable_285
                // K2Node_VariableSet_46
                bpv__Local_PointIteration__pf = bpv__Temp_int_Variable__pf;
            }
        case 12:
            {
                // K2Node_VariableGet_412
                // K2Node_VariableGet_365
                // K2Node_VariableGet_383
                // K2Node_VariableGet_382
                // K2Node_CallFunction_8671
                bpv__CallFunc_Conv_IntToFloat_ReturnValue__pf = UKismetMathLibrary::Conv_IntToFloat(bpv__NumberOfCirclePoints__pf);
                // K2Node_VariableGet_385
                // K2Node_VariableGet_381
                // K2Node_CallFunction_8669
                bpv__CallFunc_Multiply_IntFloat_ReturnValue__pf = UKismetMathLibrary::Multiply_IntFloat(bpv__Local_PointIteration__pf, bpv__Local_Tau__pf);
                // K2Node_CallFunction_8670
                bpv__CallFunc_Divide_FloatFloat_ReturnValue2__pf = FCustomThunkTemplates::Divide_FloatFloat(bpv__CallFunc_Multiply_IntFloat_ReturnValue__pf, bpv__CallFunc_Conv_IntToFloat_ReturnValue__pf);
                // K2Node_CommutativeAssociativeBinaryOperator_91
                bpv__CallFunc_Add_FloatFloat_ReturnValue__pf = UKismetMathLibrary::Add_FloatFloat(bpv__CallFunc_Divide_FloatFloat_ReturnValue2__pf, bpv__StartAngle__pf);
                // K2Node_VariableGet_113
                // K2Node_CallFunction_3095
                bpv__CallFunc_Sin_ReturnValue__pf = UKismetMathLibrary::Sin(bpv__CallFunc_Add_FloatFloat_ReturnValue__pf);
                // K2Node_CallFunction_8957
                UKismetMathLibrary::BreakVector(bpv__Local_Origin__pf, /*out*/ bpv__CallFunc_BreakVector_X__pf, /*out*/ bpv__CallFunc_BreakVector_Y__pf, /*out*/ bpv__CallFunc_BreakVector_Z__pf);
                // K2Node_CommutativeAssociativeBinaryOperator_89
                bpv__CallFunc_Multiply_FloatFloat_ReturnValue__pf = UKismetMathLibrary::Multiply_FloatFloat(bpv__Local_Radius__pf, bpv__CallFunc_Sin_ReturnValue__pf);
                // K2Node_CallFunction_3094
                bpv__CallFunc_Cos_ReturnValue__pf = UKismetMathLibrary::Cos(bpv__CallFunc_Add_FloatFloat_ReturnValue__pf);
                // K2Node_CommutativeAssociativeBinaryOperator_21
                bpv__CallFunc_Add_FloatFloat_ReturnValue2__pf = UKismetMathLibrary::Add_FloatFloat(bpv__CallFunc_BreakVector_Y__pf, bpv__CallFunc_Multiply_FloatFloat_ReturnValue__pf);
                // K2Node_CommutativeAssociativeBinaryOperator_92
                bpv__CallFunc_Multiply_FloatFloat_ReturnValue2__pf = UKismetMathLibrary::Multiply_FloatFloat(bpv__Local_Radius__pf, bpv__CallFunc_Cos_ReturnValue__pf);
                // K2Node_VariableGet_122
                // K2Node_VariableGet_233
                // K2Node_CallFunction_8956
                UKismetMathLibrary::BreakVector(bpv__Local_Origin__pf, /*out*/ bpv__CallFunc_BreakVector_X2__pf, /*out*/ bpv__CallFunc_BreakVector_Y2__pf, /*out*/ bpv__CallFunc_BreakVector_Z2__pf);
                // K2Node_CallFunction_2983
                bpv__CallFunc_Multiply_IntFloat_ReturnValue2__pf = UKismetMathLibrary::Multiply_IntFloat(100, bpv__TraceLength__pf);
                // K2Node_CommutativeAssociativeBinaryOperator_22
                bpv__CallFunc_Add_FloatFloat_ReturnValue3__pf = UKismetMathLibrary::Add_FloatFloat(bpv__CallFunc_BreakVector_X2__pf, bpv__CallFunc_Multiply_FloatFloat_ReturnValue2__pf);
                // K2Node_CallFunction_2681
                bpv__CallFunc_MakeVector_ReturnValue__pf = UKismetMathLibrary::MakeVector(bpv__CallFunc_Add_FloatFloat_ReturnValue3__pf, bpv__CallFunc_Add_FloatFloat_ReturnValue2__pf, bpv__CallFunc_Multiply_IntFloat_ReturnValue2__pf);
                // K2Node_TemporaryVariable_286
                // K2Node_VariableGet_47
                // K2Node_CallFunction_2714
                bpv__CallFunc_Multiply_IntFloat_ReturnValue3__pf = UKismetMathLibrary::Multiply_IntFloat(-100, bpv__TraceLength__pf);
                // K2Node_CallFunction_2680
                bpv__CallFunc_MakeVector_ReturnValue2__pf = UKismetMathLibrary::MakeVector(bpv__CallFunc_Add_FloatFloat_ReturnValue3__pf, bpv__CallFunc_Add_FloatFloat_ReturnValue2__pf, bpv__CallFunc_Multiply_IntFloat_ReturnValue3__pf);
                // K2Node_CallFunction_2429
                bpv__CallFunc_LineTraceSingle_NEW_ReturnValue__pf = UKismetSystemLibrary::LineTraceSingle_NEW(this, bpv__CallFunc_MakeVector_ReturnValue__pf, bpv__CallFunc_MakeVector_ReturnValue2__pf, ETraceTypeQuery::TraceTypeQuery1, false, /*out*/ TArrayCaster<AActor>(bpv__Temp_object_Variable__pf).Get<AActor>(), EDrawDebugTrace::None, /*out*/ bpv__CallFunc_LineTraceSingle_NEW_OutHit__pf, true);
            }
        case 13:
            {
                // K2Node_VariableGet_455
                // K2Node_CallFunction_2441
                UGameplayStatics::BreakHitResult(/*out*/ bpv__CallFunc_LineTraceSingle_NEW_OutHit__pf, /*out*/ bpv__CallFunc_BreakHitResult_bBlockingHit__pf, /*out*/ bpv__CallFunc_BreakHitResult_bInitialOverlap__pf, /*out*/ bpv__CallFunc_BreakHitResult_Time__pf, /*out*/ bpv__CallFunc_BreakHitResult_Location__pf, /*out*/ bpv__CallFunc_BreakHitResult_ImpactPoint__pf, /*out*/ bpv__CallFunc_BreakHitResult_Normal__pf, /*out*/ bpv__CallFunc_BreakHitResult_ImpactNormal__pf, /*out*/ bpv__CallFunc_BreakHitResult_PhysMat__pf, /*out*/ bpv__CallFunc_BreakHitResult_HitActor__pf, /*out*/ bpv__CallFunc_BreakHitResult_HitComponent__pf, /*out*/ bpv__CallFunc_BreakHitResult_HitBoneName__pf, /*out*/ bpv__CallFunc_BreakHitResult_HitItem__pf, /*out*/ bpv__CallFunc_BreakHitResult_TraceStart__pf, /*out*/ bpv__CallFunc_BreakHitResult_TraceEnd__pf);
                // K2Node_CallFunction_3154
                if(IsValid(bpv__SplineRoad__pf))
                {
                    bpv__SplineRoad__pf->AddSplinePoint(/*out*/ bpv__CallFunc_BreakHitResult_Location__pf, ESplineCoordinateSpace::World);
                }
                CurrentState = (StateStack.Num() > 0) ? StateStack.Pop(/*bAllowShrinking=*/ false) : -1;
                break;
            }
        default:
            check(false); // Invalid state
            break;
        }
    } while( CurrentState != -1 );
    return;
}

John_Alcatraz · February 28, 2016, 10:22pm

Just noticed that data tables don’t seem to work at all when using the BP->C++ converter, that’s actually quite annoying. Not even in master branch.

ryan20fun · March 2, 2016, 2:33pm

Looks like a quick automatic syntax formatting and find and replace would make it “far” more readable.

DamirH · March 2, 2016, 10:50pm

It being readable isn’t the point though.

SaxonRah · March 3, 2016, 2:40am

Yeah, honestly, its not as bad as one might think, i’ve seen worse written by people. but really i think, correct me if i am wrong, but the point of this is to have a “quickfix” if something is really slow in bp, right? not to have a bp to c++ tool to convert into human like code.

what i do not understand, if we convert a bp to c++ we get semi-non-readable c++ code, that’s fine, but after it converts it to c++ does it use this c++ instead of the bp implementation? and if it does use the c++ code instead, why can you not make a bp based on said converted c++ class. (just curious. i assume its due to the state machine nature of bp)

ryan20fun · March 3, 2016, 9:52am

I would probably use this to quickly get some C++ code of some of my BP’s to clean up.
I think it would be quicker to use it as a initial conversion tool to save you time looking up the BP->C++ function mapping.

I would think that it uses the C++ version instead, But it could be some kind of hybrid solution.

UE4Hobbyist · March 3, 2016, 2:41pm

Can this be used in the editor? More performance in the packaged game is great, but more performance in the editor opens new design possibilities. For example I have made custom A* pathfinding in blueprints and while bearable its not as fast as I would want it to be. Maybe I can take those generated c++ classes and add them in my project as a c++ actor?

Achilleon · March 3, 2016, 2:58pm

No. The whole purpose of this is so that your blueprints act faster in game. It’s not there to write what you suppose to as C++.

teak421 · March 3, 2016, 7:41pm

Think there will still be a place for native C++ code for readability. Blueprints can get messy…

teak

Achilleon · March 3, 2016, 9:11pm

C++ will never be replaced or forgotten because there is a converter now. Many people still prefers only C++ solutions. And some stuff just cant be exposed visually, and probably shouldn’t. Just my opinion.

teak421 · March 4, 2016, 12:46am

Agreed! That project of your’s is neat… Need to check it out more! Just saw your opening screenshots! Marketplace or release to the community?

teak

joeGraf · March 23, 2016, 6:29pm

That’s not a practical test of the system since you shouldn’t do that in C++ either. My job often involves me taking a look at people’s projects for optimization help and the very first item I check is how many ticking actors they have.

Steve_T · March 23, 2016, 7:18pm

Wow this is awesome!!

motorsep · March 23, 2016, 7:38pm

So, how does it work? Do we just check the option in the project settings and upon deployment UE4 will do what’s needed to be done or do we have to go out of out way and compile converted BPs manually using VS2015 ?

Btw, is VS2013 supported ?