unit Unit1;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants,
  System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, rtti, Vcl.Themes,
  Vcl.Styles;

type
  TForm1 = class(TForm)
    procedure FormCreate(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
var
  rtti: TRttiContext;
  c2: TClass;
  c1: TRttiType;
  m: TRttiMethod;
  p: TRttiParameter;
  fileSkin: string;
  Args: TArray<TValue>;
begin
  c1 := rtti.GetType(TStyleManager);
  c2 := c1.handle.TypeData.ClassType;

  fileSkin := 'CharcoalDarkSlate.vsf';
  for m in c1.GetMethods do
  begin
    if (m.Name = 'SetStyle') and
      (m.GetParameters[0].ParamType.TypeKind = tkPointer) then
    begin
      SetLength(Args, 1);
      Args[0] := TStyleManager.LoadFromFile(fileSkin);
      //  Args[0] := TRttiPointerType(TStyleManager.LoadFromFile(fileSkin));
      m.Invoke(c2, Args);

      // Работает прямой вызов
      // TStyleManager.SetStyle(PPointer(Args[0].GetReferenceToRawData)^);
    end;
  end;
end;

end.

function TValue.Cast(ATypeInfo: PTypeInfo; const EmptyAsAnyType: Boolean): TValue;
begin
  if not TryCast(ATypeInfo, Result, EmptyAsAnyType) then
    raise EInvalidCast.CreateRes(@SInvalidCast);
end;

procedure TForm1.FormCreate(Sender: TObject);
  function MethodInvoke(c2: TClass; m: TRttiMethod;
    Args: TArray<TValue>): TValue;
  var
    ResultType: PTypeInfo;
    Max, Min: Integer;
    v: TValue;
  begin
    SetLength(Args, Length(Args) + 1);

    Max := High(Args);

    for Min := 0 to High(Args) - 1 do
    begin
      v := Args[Min];
      Args[Min] := Args[Max];
      Args[Max] := v;
      Dec(Max);
    end;

    Args[0] := c2;

    if m.ReturnType <> nil then
      ResultType := m.ReturnType.Handle
    else
      ResultType := nil;

    Result := System.rtti.Invoke(m.CodeAddress, Args, m.CallingConvention,
      ResultType);
  end;

var
  rtti: TRttiContext;
  c2: TClass;
  c1: TRttiType;
  m: TRttiMethod;
  p: TRttiParameter;
  fileSkin: string;
  Args: TArray<TValue>;
begin
  c1 := rtti.GetType(TStyleManager);
  c2 := c1.Handle.TypeData.ClassType;

  fileSkin := 'CharcoalDarkSlate.vsf';
  for m in c1.GetMethods do
  begin
    if (m.Name = 'SetStyle') and
      (m.GetParameters[0].ParamType.TypeKind = tkPointer) then
    begin
      SetLength(Args, 1);
      Args[0] := TStyleManager.LoadFromFile(fileSkin);

      MethodInvoke(c2, m, Args);
    end;
  end;
end;

function MethodInvoke(c2: pointer; m: TRttiMethod;
  Args: TArray<TValue>): TValue;
type
  PPVtable = ^PVtable;
  PVtable = ^TVtable;
  TVtable = array [0 .. MaxInt div sizeof(pointer) - 1] of pointer;
var
  ResultType: PTypeInfo;
  Max, Min: integer;
  v: TValue;
  plus, lARGS: integer;
  alloc: Boolean;
  cls: TClass;
  obj: TObject;
  code: pointer;
  GetParameters: TArray<TRttiParameter>;
  P: TRttiParameter;
begin
  if m.IsConstructor then
    plus := 2
  else
    plus := 1;

  SetLength(Args, length(Args) + plus);

  Max := High(Args);

  GetParameters := m.GetParameters;
  lARGS := length(GetParameters);

  for Min := 0 to High(Args) - 1 do
  begin
    v := Args[Min];
    if (Min < lARGS) and v.IsEmpty then
    begin
      P := GetParameters[Min];
      if P.ParamType.Handle <> nil then
      begin
        TValue.Make(nil, P.ParamType.Handle, v);
      end;
    end;
    Args[Min] := Args[Max];
    Args[Max] := v;
    Dec(Max);
  end;

  if m.IsConstructor then
  begin
    cls := nil;
    alloc := TValue(c2).TryAsType<TClass>(cls);
    if alloc then
      obj := nil
    else
    begin
      obj := TValue(c2).AsObject;
      if obj <> nil then
        cls := obj.ClassType
      else
        cls := nil;
    end;
    if alloc then
      Args[0] := cls
    else
      Args[0] := obj;

    Args[1] := alloc;

    case m.DispatchKind of
      dkVtable:
        code := PVtable(cls)^[m.VirtualIndex];
      dkDynamic:
        code := GetDynaMethod(cls, m.VirtualIndex);
    else
      code := m.CodeAddress;
    end;
  end
  else
  begin
    Args[0] := c2;
    code := m.CodeAddress;
  end;
  if m.ReturnType <> nil then
    ResultType := m.ReturnType.Handle
  else
    ResultType := nil;

  if m.IsConstructor then
    result := System.rtti.Invoke(code, Args, m.CallingConvention, cls.ClassInfo,
      m.IsStatic, True)
  else
    result := System.rtti.Invoke(code, Args, m.CallingConvention, ResultType);
end;

function MethodInvoke(Instance: pointer; m: TRttiMethod;
  Args: TArray<TValue>): TValue;
type
  PPVtable = ^PVtable;
  PVtable = ^TVtable;
  TVtable = array [0 .. MaxInt div sizeof(pointer) - 1] of pointer;
  procedure PushSelfFirst(CC: TCallConv; var argList: TArray<TValue>;
    var Index: integer; const value: TValue); inline;
  begin
{$IFDEF CPUX86}
    if CC = ccPascal then
      exit;
{$ENDIF CPUX86}
    argList[Index] := value;
    inc(Index);
  end;

  procedure PushSelfLast(CC: TCallConv; var argList: TArray<TValue>;
    var Index: integer; const value: TValue); inline;
  begin
{$IFDEF CPUX86}
    if CC <> ccPascal then
      exit;
    argList[Index] := value;
{$ELSE !CPUX86}
{$ENDIF CPUX86}
  end;

var
  code: pointer;
  argCount: integer;
  parList: TArray<TRttiParameter>;
  i, CurrArg: integer;
  cls: TClass;
  obj: TObject;
  alloc: Boolean;
  plus, lARGS, gg, Min, Max: integer;
  P: TRttiParameter;
  v: TValue;
begin
  with m do
  begin
    argCount := length(Args);
    gg := argCount;
    if IsConstructor or IsDestructor then
      inc(argCount);
    if not IsStatic then
      inc(argCount);

    SetLength(Args, argCount);

    lARGS := length(GetParameters);

    Max := argCount - 1;

    for Min := 0 to gg - 1 do
    begin
      v := Args[Min];
      if (Min < lARGS) and v.IsEmpty then
      begin
        P := GetParameters[Min];
        if P.ParamType.Handle <> nil then
        begin
          TValue.Make(nil, P.ParamType.Handle, v);
        end;
      end;
      Args[Min] := Args[Max];
      Args[Max] := v;
      Dec(Max);
    end;

    CurrArg := 0;
    cls := nil;

    alloc := True; // avoid warning
    obj := nil; // avoid warning

    if not IsStatic then
    begin
      // Two jobs: handle special methods like ctor/dtor, and
      // extract metaclass so that vtable lookups can occur.
      if IsConstructor then
      begin
        alloc := TValue(Instance).TryAsType<TClass>(cls);
        // flag: should allocate
        if alloc then
          obj := nil // not used
        else
        begin
          obj := TValue(Instance).AsObject;
          if obj <> nil then
            cls := obj.ClassType
          else
            cls := nil;
        end;
        if alloc then
          PushSelfFirst(CallingConvention, Args, CurrArg, cls)
        else
          PushSelfFirst(CallingConvention, Args, CurrArg, obj);
        Args[CurrArg] := alloc;
        inc(CurrArg);
      end
      else if IsDestructor then
      begin
        cls := TValue(Instance).AsObject.ClassType;
        PushSelfFirst(CallingConvention, Args, CurrArg, Instance);
        Args[CurrArg] := True;
        inc(CurrArg);
      end
      else if IsClassMethod then
      begin
        cls := TValue(Instance).AsClass;
        PushSelfFirst(CallingConvention, Args, CurrArg, Instance);
      end
      else
      begin
        PushSelfFirst(CallingConvention, Args, CurrArg, Instance);
      end;

    end;

    if IsStatic then
      code := CodeAddress
    else
      case DispatchKind of
        dkVtable:
          code := PVtable(cls)^[VirtualIndex];
        dkDynamic:
          code := GetDynaMethod(cls, VirtualIndex);
      else
        code := CodeAddress;
      end;

    if not IsStatic then
    begin
      if IsConstructor then
      begin
        if alloc then
          PushSelfLast(CallingConvention, Args, CurrArg, cls)
        else
          PushSelfLast(CallingConvention, Args, CurrArg, obj);
      end
      else
        PushSelfLast(CallingConvention, Args, CurrArg, Instance);
    end;

    if ReturnType <> nil then
      result := System.rtti.Invoke(code, Args, CallingConvention,
        ReturnType.Handle, IsStatic)
    else if IsConstructor then
      result := System.rtti.Invoke(code, Args, CallingConvention, cls.ClassInfo,
        IsStatic, True)
    else
      result := System.rtti.Invoke(code, Args, CallingConvention, nil);
  end;
end;