C++RAW

#include "UnityPrefix.h"
#include "Runtime/Mono/MonoBehaviour.h"
#include "Runtime/Mono/MonoScript.h"

#include "Runtime/Scripting/ScriptingManager.h"
#include "Runtime/Scripting/ScriptingUtility.h"
#include "Runtime/Scripting/ScriptingExportUtility.h"

#include "Runtime/Graphics/Transform.h"
#include "Runtime/Animation/AvatarBuilder.h"
#include "Runtime/Animation/Avatar.h"
#include "Runtime/Scripting/Scripting.h"

using namespace Unity;

CSRAW

using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Collections;

namespace UnityEngine
{

STRUCT SkeletonBone
	CSRAW public string		name;

	CSRAW public Vector3	position;
	CSRAW public Quaternion rotation;
	CSRAW public Vector3	scale;	
	CSRAW public int		transformModified;
END

C++RAW

struct MonoSkeletonBone {
	ScriptingStringPtr name;
	Vector3f	position;
	Quaternionf rotation;
	Vector3f	scale;
	int			transformModified;
};

void SkeletonBoneToMono (const SkeletonBone &src, MonoSkeletonBone &dest) {
	dest.name = scripting_string_new(src.m_Name);
	dest.position = src.m_Position;
	dest.rotation = src.m_Rotation;
	dest.scale = src.m_Scale;
	dest.transformModified = src.m_TransformModified ? 1 : 0;
}

void SkeletonBoneFromMono (const MonoSkeletonBone &src, SkeletonBone &dest) {
	dest.m_Name = scripting_cpp_string_for(src.name);
	dest.m_Position = src.position;
	dest.m_Rotation = src.rotation;
	dest.m_Scale = src.scale;
	dest.m_TransformModified = src.transformModified != 0;
}

STRUCT HumanLimit
	CSRAW
	
	Vector3	m_Min;
	Vector3	m_Max;
	Vector3	m_Center;
	float	m_AxisLength;
	int		m_UseDefaultValues;

	public bool		useDefaultValues { get { return m_UseDefaultValues != 0; } set { m_UseDefaultValues = value ? 1 : 0; } }
	public Vector3	min { get { return m_Min; } set { m_Min = value; } }
	public Vector3	max { get { return m_Max; } set { m_Max = value; } }
	public Vector3	center { get { return m_Center; } set { m_Center = value; } }
	public float	axisLength { get { return m_AxisLength; } set { m_AxisLength = value; } }
END
	
C++RAW

struct MonoHumanLimit {
	
	Vector3f	m_Min;
	Vector3f	m_Max;
	Vector3f	m_Center;
	float		m_AxisLength;
	int			m_UseDefaultValues;
};

void HumanLimitToMono (const SkeletonBoneLimit &src, MonoHumanLimit &dest) {
	dest.m_UseDefaultValues = src.m_Modified ? 0 : 1;
	dest.m_Min = src.m_Min;
	dest.m_Max = src.m_Max;
	dest.m_Center = src.m_Value;
	dest.m_AxisLength = src.m_Length;
}

void HumanLimitFromMono (const MonoHumanLimit &src, SkeletonBoneLimit &dest) {
	dest.m_Modified = src.m_UseDefaultValues == 1 ? false : true;
	dest.m_Min = src.m_Min;
	dest.m_Max = src.m_Max;
	dest.m_Value = src.m_Center;
	dest.m_Length = src.m_AxisLength;
}

STRUCT HumanBone
	CSRAW
	string				m_BoneName;
	string				m_HumanName;
	public HumanLimit	limit;

	public string	boneName { get { return m_BoneName; } set { m_BoneName = value; } }
	public string	humanName { get { return m_HumanName; } set { m_HumanName = value; } }
END
	
C++RAW

struct MonoHumanBone {
	ScriptingStringPtr	m_BoneName;
	ScriptingStringPtr	m_HumanName;
	MonoHumanLimit		m_Limit;
};

void HumanBoneToMono (const HumanBone &src, MonoHumanBone &dest) 
{
	dest.m_BoneName = scripting_string_new(src.m_BoneName);
	dest.m_HumanName = scripting_string_new(src.m_HumanName);
	HumanLimitToMono(src.m_Limit, dest.m_Limit);
}

void HumanBoneFromMono (const MonoHumanBone &src, HumanBone &dest) 
{
	dest.m_BoneName = scripting_cpp_string_for(src.m_BoneName);
	dest.m_HumanName = scripting_cpp_string_for(src.m_HumanName);
	HumanLimitFromMono(src.m_Limit, dest.m_Limit);
}

STRUCT HumanDescription
	CSRAW
	public HumanBone[]		human;
	public SkeletonBone[]	skeleton;

	float			m_ArmTwist;
	float			m_ForeArmTwist;
	float			m_UpperLegTwist;
	float			m_LegTwist;
	float			m_ArmStretch;
	float			m_LegStretch;
	float			m_FeetSpacing;

	public float	upperArmTwist { get { return m_ArmTwist; } set { m_ArmTwist = value;} 	}
	public float	lowerArmTwist { get { return m_ForeArmTwist; } set { m_ForeArmTwist = value;} 	}
	public float	upperLegTwist { get { return m_UpperLegTwist; } set { m_UpperLegTwist = value;} 	}
	public float	lowerLegTwist { get { return m_LegTwist; } set { m_LegTwist = value;} 	}
	public float	armStretch { get { return m_ArmStretch; } set { m_ArmStretch = value;} 	}
	public float	legStretch { get { return m_LegStretch; } set { m_LegStretch = value;} 	}
	public float	feetSpacing { get { return m_FeetSpacing; } set { m_FeetSpacing = value;} 	}
END
		
C++RAW

struct MonoHumanDescription {
	ScriptingArrayPtr	m_Human;
	ScriptingArrayPtr	m_Skeleton;

	float				m_ArmTwist;
	float				m_ForeArmTwist;
	float				m_UpperLegTwist;
	float				m_LegTwist;
	float				m_ArmStretch;
	float				m_LegStretch;
	float				m_FeetSpacing;
};


void HumanDescriptionToMono (const HumanDescription &src, MonoHumanDescription &dest) 
{
	if (src.m_Skeleton.size() <= 0)
		dest.m_Skeleton = CreateEmptyStructArray(MONO_COMMON.skeletonBone);
	else
		dest.m_Skeleton = CreateScriptingArray(&src.m_Skeleton[0], src.m_Skeleton.size(), MONO_COMMON.skeletonBone);

	if (src.m_Human.size() <= 0)
		dest.m_Human = CreateEmptyStructArray(MONO_COMMON.humanBone);
	else
		dest.m_Human = CreateScriptingArray(&src.m_Human[0], src.m_Human.size(), MONO_COMMON.humanBone);	

	dest.m_ArmTwist = src.m_ArmTwist;
	dest.m_ForeArmTwist = src.m_ForeArmTwist;

	dest.m_UpperLegTwist = src.m_UpperLegTwist;
	dest.m_LegTwist = src.m_LegTwist;
	dest.m_ArmStretch = src.m_ArmStretch;
	dest.m_LegStretch = src.m_LegStretch;
	dest.m_FeetSpacing = src.m_FeetSpacing;
}

void HumanDescriptionFromMono (const MonoHumanDescription &src, HumanDescription &dest) 
{
	ScriptingStructArrayToVector<SkeletonBone, MonoSkeletonBone>(src.m_Skeleton, dest.m_Skeleton, SkeletonBoneFromMono);
	ScriptingStructArrayToVector<HumanBone, MonoHumanBone>(src.m_Human, dest.m_Human, HumanBoneFromMono);

	dest.m_ArmTwist = src.m_ArmTwist;
	dest.m_ForeArmTwist = src.m_ForeArmTwist;

	dest.m_UpperLegTwist = src.m_UpperLegTwist;
	dest.m_LegTwist = src.m_LegTwist;
	dest.m_ArmStretch = src.m_ArmStretch;
	dest.m_LegStretch = src.m_LegStretch;
	dest.m_FeetSpacing = src.m_FeetSpacing;
}

CLASS AvatarBuilder
	CUSTOM static Avatar BuildHumanAvatar(GameObject go, HumanDescription monoHumanDescription) {
		Avatar* avatar = NEW_OBJECT(Avatar);
		avatar->Reset();	

		HumanDescription humanDescription;
		HumanDescriptionFromMono(monoHumanDescription, humanDescription);

		AvatarBuilder::Options options;
		options.avatarType = kHumanoid;
		options.useMask = true;

		std::string error = AvatarBuilder::BuildAvatar(*avatar, *go, false, humanDescription, options);
		if(!error.empty())
			ErrorString(error);

		avatar->AwakeFromLoad(kInstantiateOrCreateFromCodeAwakeFromLoad);

		return Scripting::ScriptingWrapperFor(avatar);
	}

	CUSTOM static Avatar BuildGenericAvatar(GameObject go, string rootMotionTransformName) {
		Avatar* avatar = NEW_OBJECT(Avatar);
		avatar->Reset();	

		HumanDescription humanDescription;
		humanDescription.m_RootMotionBoneName = rootMotionTransformName.AsUTF8().c_str();
		std::string error = AvatarBuilder::BuildAvatar(*avatar, *go, false, humanDescription);
		if(!error.empty())
			ErrorString(error);

		avatar->AwakeFromLoad(kInstantiateOrCreateFromCodeAwakeFromLoad);

		return Scripting::ScriptingWrapperFor(avatar);
	}	
END

CSRAW }