protected UnityAvatarData toAvatar(GameObject gameObject, UnityScene unityScene)
{
var avatarData = unityScene.getAvatarData(unityScene);
Renderer[] renderers = gameObject.GetComponentsInChildren <Renderer>();
List <UnityMeshData> list = null;
foreach (var renderer in renderers)
{
var meshdata = toMeshData(renderer, unityScene);
if (null != meshdata)
{
if (false == avatarData.mesh.ContainsKey(meshdata.node))
{
list = new List <UnityMeshData>();
avatarData.mesh.Add(meshdata.node, list);
}
else
{
list = avatarData.mesh[meshdata.node];
}
list.Add(meshdata);
}
}
return(avatarData);
}
protected UnityNodeData toNodes(GameObject obj, UnityScene unityScene, string modelPath)
{
UnityNodeData nodeData = Export.GameObjectToUnityNodeData(obj);
Transform transform = obj.transform;
for (int i = 0; i < transform.childCount; i++)
{
var child = transform.GetChild(i);
var gameObject = child.gameObject;
// var path = AssetDatabase.GetAssetPath(PrefabUtility.GetCorrespondingObjectFromSource(child.gameObject));
if (null == gameObject.GetComponent <Animation>())
{
var childNodeData = toNodes(child.gameObject, unityScene, modelPath);
if (null != childNodeData)
{
nodeData.children.Add(childNodeData);
childNodeData.parent = nodeData;
}
}
else
{
//todo Child Mesh
}
}
return(nodeData);
}
public UnityAvatarData getAvatarData(UnityScene unityScene, string refName = null)
{
UnityAvatarRenderer renderer = getAvatarRenderer();
UnityAvatarData avatar = null;
if (null == refName)
{
refName = renderer.avatar;
}
if (null == refName)
{
return(null);
}
if (unityScene.avatarObj.ContainsKey(refName))
{
avatar = unityScene.avatarObj[refName];
}
else
{
avatar = new UnityAvatarData();
unityScene.avatarObj.Add(refName, avatar);
}
renderer.avatar = refName;
return(avatar);
}
public Presenter(GameSettings gameSettings, Resources resources, Screens screens, Camera camera)
{
var unityScene = new UnityScene(resources);
_model = new ClientModel(gameSettings, unityScene, resources);
_view = new ClientView(resources, _model, unityScene, screens, camera);
}
/// <summary>
/// Check if lifetime expired. If yes then dispatch an event.
/// </summary>
private void CheckIfExpired()
{
if (_expireStopwatch.Elapsed.Seconds >= LIFE_TIME_SECONDS)
{
UnityScene.GetController <EventController>().Dispatch <SpecialFeedExpiredEvent>(new EventArgs());
}
}
public static void ExportUnitScene(UnityScene unitScene)
{
//write avatar
//step1 write mesh
foreach (var item in unitScene.avatarObj)
{
var avatar = item.Value;
TFile file = new TFile(Export.config.outdir).ResolvePath(avatar.refName + ".km");
file.WriteAMF(avatar);
}
//write animation
foreach (var item in unitScene.animationDataObj)
{
var path = item.Key.Replace("assets/", "");
var clip = item.Value;
TFile file = new TFile(Export.config.outdir).ResolvePath(path);
file.WriteAMF(clip);
}
foreach (var item in unitScene.materialObj)
{
string key = item.Key;
string value = TFile.Join(Export.config.outdir, item.Value);
var file = TFile.AppliationRoot.ResolvePath(key);
file.CopyTo(value);
}
}
protected UnityVertexData parserSkeleton(SkinnedMeshRenderer renderer, UnityScene scene)
{
var bones = renderer.bones;
var mesh = renderer.sharedMesh;
var poses = mesh.bindposes;
nameIndex = 0;
UnityVertexData data = new UnityVertexData();
data.vertex = Export.boneWeightToBytes(mesh.boneWeights);
data.data32PerVertex = 8;
var dict = skeletonRoot2Dict(scene.getAvatarData(scene).root);
for (int i = 0; i < bones.Length; i++)
{
var bone = bones[i];
if (dict.ContainsKey(bone.name))
{
var node = dict[bone.name];
node.inv = Export.Matrix4x4ToBytes(poses[i]);
node.index = i;
}
}
// getUsedSkeleton(mesh.boneWeights);
return(data);
}
static void ApplyNewCamera(UnityScene unityScene)
{
var cameraWithModernSettings = new GameObject().AddComponent <Camera>().SetSettings(new ModernSettingsForUnityCamera());
Camera.current.enabled = false;
Camera.SetupCurrent(cameraWithModernSettings);
}
static void ApplyUnityLightingToScene(UnityScene unityScene)
{
GameObject.Find(unityScene.ModernSceneryObject).ForThisObjectAndItsChildren(UnityEngine.Object.Destroy);
UnityEngine.Object.FindObjectsOfType <Light>().ForTheseObjects(UnityEngine.Object.Destroy);
SceneManager.LoadScene(unityScene.SceneNameWithUnityLighting, LoadSceneMode.Additive);
UnityUtil.ResetUnityLighting(unityScene.SkyMaterialObject);
}
/// <summary>
/// Instantiate new part of tail and attaches it to snake tail parts.
/// </summary>
public void GrowSnake()
{
var resourceData = UnityScene.GetResourceManager().resourceData as Snake2DResourceData;
GameObject newSnakeTile = MonoBehaviour.Instantiate(resourceData.PREFAB_SNAKE_TILE);
newSnakeTile.transform.position = head.transform.position;
tailParts.Insert(0, newSnakeTile);
}
public override void OnEnter()
{
_scene = Context.Scene;
_gameLogic = new GameLogic(Context.Settings, _scene);
_world = _gameLogic.CreateNewWorld(_worldId);
_gameLogic.Init(_world);
_startTime = Time.realtimeSinceStartup;
}
public override object parser(GameObject _object, Component component, UnityScene element)
{
// base.writeData
return(true);
}
static bool CanApplyModernGfx(UnityScene unityScene)
{
return(unityScene != null &&
UnityUtil.GetSceneByName(unityScene.SceneNameWithUnityLighting) != null &&
GameObject.Find(unityScene.SunObject) != null &&
GameObject.Find(unityScene.ModernSceneryObject) != null &&
GameObject.Find(unityScene.SkyMaterialObject) != null &&
GameObject.Find(unityScene.PostProcessingObject) != null);
}
public void EnterScene(string sceneId, object param)
{
if (null != mCurScene)
{
mCurScene.OnWillExited();
}
mNextScene = new UnityScene(sceneId);
mNextScene.OnWillEntered();
UnityEngine.SceneManagement.SceneManager.LoadScene(sceneId.ToString(), UnityEngine.SceneManagement.LoadSceneMode.Single);
}
/// <summary>
/// Called once after constructor
/// </summary>
public void OnStart()
{
_snakeController.OnStart();
_cameraController.OnStart();
foodSpawningController.OnStart();
IEventController e = UnityScene.GetController <EventController>();
foodSpawningController.Subscribe(e);
}
public static void ExportGameObject(GameObject obj, UnityScene unitScene = null)
{
if (null == unitScene)
{
unitScene = new UnityScene();
}
Serialize(obj, unitScene);
ExportUnitScene(unitScene);
}
// ================================ AREA PORTALS =================================
/// <summary>
/// Registers a new area portal to the area manager. Only the scenes of registered portals can be loaded/unloaded additively.
/// </summary>
public void RegisterAreaPortal(UnityScene subScene)
{
if (!GetIsActive || subScene == null || String.IsNullOrWhiteSpace(subScene.SceneName))
{
return;
}
subScenes.Add(subScene);
DebugManager.LogFormat(nameof(AreaManager), nameof(RegisterAreaPortal), subScene.SceneName); //DEBUG
}
/// <summary>
/// Additively unloads a scene on the client who left the area portal.
/// </summary>
public void UnloadScenesAdditive(NetworkIdentity ni, UnityScene scene)
{
if (!GetIsActive || ni == null)
{
return;
}
NetworkServer.SendToClientOfPlayer(ni, new SceneMessage {
sceneName = scene.SceneName, sceneOperation = SceneOperation.UnloadAdditive
});
}
public ClientModel(GameSettings gameSettings, UnityScene scene, Resources resources)
{
Settings = gameSettings;
Scene = scene;
Resources = resources;
PlayerProfileStorage = new PlayerProfileStorage();
CurrentState = new InitModelState();
CurrentState.Context = this;
CurrentState.OnEnter();
}
static void ApplyModernGfx(ShipRefs ship, UnityScene unityScene)
{
using (var p = new TimerUtil())
{
ApplyUnityLightingToScene(unityScene);
ApplyStandardShaderToScenery(unityScene);
ApplyStandardShaderToShip(ship);
ApplyDynamicShadows(ship);
ApplyNewCamera(unityScene);
}
}
public ClientView(Resources resources, ClientModel appModel, UnityScene scene, Screens screens, Camera camera)
{
Resources = resources;
AppModel = appModel;
Scene = scene;
Camera = camera;
Screens = screens;
CurrentState = new MainMenuViewState();
CurrentState.Context = this;
CurrentState.OnEnter();
}
/// <summary>
/// Subscribes events and init parts and moveController.
/// </summary>
public void OnStart()
{
_moveController.OnStart();
_parts.OnStart();
IEventController e = UnityScene.GetController <EventController>();
_moveController.Subscribe(e);
_snakeEatingSystem.Subscribe(e);
_snakeGrowingSystem.Subscribe(e);
_snakeCollisionController.Subscribe(e);
}
void OnSceneLoaded(UnityEngine.SceneManagement.Scene scene, UnityEngine.SceneManagement.LoadSceneMode loadMode)
{
if (null != mCurScene)
{
mCurScene.OnExited();
}
if (null != mNextScene)
{
mNextScene.OnEntered();
}
mCurScene = mNextScene;
mNextScene = null;
}
/// <summary>
/// Tries to apply modern Unity graphics to the current BallsiticNG track scene.
/// </summary>
/// <param name="ship">A BallisticNG ShipRef object</param>
/// <param name="unityScene">An object specifying certain GameObject names in your Unity scene</param>
/// <returns>False if the unityScene argument is invalid, otherwise true.</returns>
public static async Task <bool> TryApplyModernGfx(ShipRefs ship, UnityScene unityScene)
{
if (CanApplyModernGfx(unityScene))
{
ApplyModernGfx(ship, unityScene);
return(true);
}
else
{
await LogUtil.Log("Cant apply modern graphics (is your unityScene parameter correct?)");
return(false);
}
}
public override object parser(GameObject _object, Component component, UnityScene unityScene)
{
UnityVertexData skeletonData = null;
SkinnedMeshRenderer renderer = component as SkinnedMeshRenderer;
skeletonData = parserSkeleton(renderer, unityScene);
UnityMeshData meshData = base.parser(_object, component, unityScene) as UnityMeshData;
meshData.skeleton = skeletonData;
return(meshData);
}
public static UnityScene ExportScene(Scene scene)
{
UnityScene unitScene = new UnityScene();
var list = scene.GetRootGameObjects();
foreach (var obj in list)
{
UnityPerfabData data = Serialize(obj, unitScene);
if (null != data)
{
unitScene.perfabDatas.Add(data);
}
}
return(unitScene);
}
public override object parser(GameObject _object, Component component, UnityScene unityScene)
{
Animator animator = component as Animator;
string path = AssetDatabase.GetAssetPath(animator.avatar);
if ("" == path)
{
return(null);
}
UnityAvatarData avataData = null;
UnityAvatarRenderer avatar = unityScene.getAvatarRenderer();
if (true == unityScene.avatarObj.ContainsKey(path))
{
avataData = unityScene.avatarObj[path];
}
else
{
avataData = unityScene.getAvatarData(unityScene, path);
//step1 : parser Nodes
avataData.root = toNodes(_object, unityScene, path);
//step2 : parser meshs
toAvatar(_object, unityScene);
avataData.refName = getRefName(path);
unityScene.avatarObj[path] = avataData;
}
avatar.avatar = avataData.refName;
//step3 : parser animation
if (animator.runtimeAnimatorController)
{
avataData.animator = avatar.animator = toAnimator(_object, animator.runtimeAnimatorController as AnimatorController, unityScene);
}
return(avatar);
}
/// <summary>
/// Unregisters a new area portal to the area manager. Only the scenes of registered portals can be loaded/unloaded additively.
/// </summary>
public void UnRegisterAreaPortal(UnityScene subScene)
{
if (!GetIsActive || subScene == null || String.IsNullOrWhiteSpace(subScene.SceneName))
{
return;
}
for (int i = 0; i < subScenes.Count; i++)
{
if (subScenes[i] == null || String.IsNullOrWhiteSpace(subScenes[i].SceneName))
{
continue;
}
if (subScenes[i].SceneName == subScene.SceneName)
{
subScenes.RemoveAt(i);
DebugManager.LogFormat(nameof(AreaManager), nameof(UnRegisterAreaPortal), subScene.SceneName); //DEBUG
}
}
}
//===================================================================================================
// export material
//===================================================================================================
public static MaterialData ExportMaterial(Material material, UnityScene unitScene = null)
{
var path = AssetDatabase.GetAssetPath(material.mainTexture);
// var dependencies=AssetDatabase.GetDependencies(path);
// File file = new File(path);
// File.Copy(path,outPath+"diff.png",true);
MaterialData data = new MaterialData();
data.depthMask = true;
data.passCompareMode = 0x0203; //LEQUAL
data.srcFactor = 0x0302; //SRC_ALPHA
data.dstFactor = 0x0303; //ONE_MINUS_SRC_ALPHA
data.cull = 0; //NONE
data.diffTex = new TextureData();
data.diffTex.mipmap = true;
data.diffTex.repeat = 0x2901; //REPEAT
data.diffTex.mag = 0x2601; //LINEAR
data.diffTex.mix = 0x2702; //NEAREST_MIPMAP_LINEAR
if ("" != path)
{
data.diffTex.url = path.ToLower().Replace("assets/", "");
if (null != unitScene)
{
// unitScene
if (false == unitScene.materialObj.ContainsKey(path))
{
unitScene.materialObj.Add(path, data.diffTex.url);
}
}
}
return(data);
}
/// <summary>
/// Factory method. Instantiates normal food prefab.
/// </summary>
protected override GameObject MakeGameObject()
{
var resourceData = UnityScene.GetResourceManager().resourceData as Snake2DResourceData;
return(MonoBehaviour.Instantiate(resourceData.PREFAB_NORMAL_FEED));
}
