//!
//! scale currently selected object with joystick input
//! @param scale new scale of object
//!
public void scaleSelectionJoystick(Vector3 scale)
{
if (currentSelection)
{
// lights (scalemode is used for light parameters intensity and range)
SceneObjectLight scl = currentSelection.GetComponent <SceneObjectLight>();
if (scl)
{
// set light intensity
scl.setLightIntensity(scl.getLightIntensity() + (scale.z * 0.5f));
// set gui element
scl.setLightRange(scl.getLightRange() + (scale.y * 0.5f));
if (scale.z == 0.0f)
{
UIAdapter.updateRangeSlider(scl.getLightRange());
}
else if (scale.y == 0.0f)
{
UIAdapter.updateRangeSlider(scl.getLightIntensity());
}
}
// objects
else
{
if (scale.x == 0 && scale.y == 0)
{
axisLocker = new Vector3(0, 0, 1);
}
else if (scale.x == 0 && scale.z == 0)
{
axisLocker = new Vector3(0, 1, 0);
}
else if (scale.y == 0 && scale.z == 0)
{
axisLocker = new Vector3(1, 0, 0);
}
else if (scale.x != 0 && scale.y != 0 && scale.z != 0)
{
axisLocker = new Vector3(1, 1, 1);
scale = Vector3.one * scale.x;
}
if (!currentSelection.transform.parent.transform.GetComponent <Light>())
{
float scaleFactor = (8f * Vector3.Distance(Camera.main.transform.position, currentSelection.position) / VPETSettings.Instance.maxExtend);
currentSelection.transform.localScale += Vector3.Scale(scale / currentSelection.transform.parent.lossyScale.x * scaleFactor / VPETSettings.Instance.controllerSpeed, axisLocker) / 100f;
if (liveMode)
{
serverAdapter.SendObjectUpdate(currentSelection.GetComponent <SceneObject>(), ParameterType.SCALE);
}
}
}
}
}
public void setLightParamAngle(float angle)
{
SceneObjectLight currentLight = (SceneObjectLight)currentSceneObject;
if (currentLight)
{
currentLight.setLightAngle(angle);
}
if (activeMode == Mode.lookThroughLightMode)
{
cameraAdapter.Fov = Mathf.Min(angle, 150f);
}
}
public void show(SceneObjectLight light)
{
currentLight = light;
if (sliderType == SliderType.COLOR)
{
colorWheel.gameObject.SetActive(true);
colorWheel.Value = currentLight.getLightColor();
}
else
{
colorWheel.gameObject.SetActive(false);
}
}
////! function to be called to send a lock signal to server
////! @param obj Transform of GameObject to be locked
////! @param locked should it be locked or unlocked
//public void sendLock(Transform obj, bool locked)
//{
// if (locked) // lock it
// {
// if (currentlyLockedObject != null && currentlyLockedObject != obj && !deactivatePublish) // is another object already locked, release it first
// {
// string msg = "client " + id + "|" + "l" + "|" + vpet.Extensions.getPathString(currentlyLockedObject, scene) + "|" + false;
// SendObjectUpdate<ObjectSenderBasic>(msg);
// // print("Unlock object " + currentlyLockedObject.gameObject.name );
// }
// if (currentlyLockedObject != obj && !deactivatePublish) // lock the object if it is not locked yet
// {
// string msg = "client " + id + "|" + "l" + "|" + vpet.Extensions.getPathString(obj, scene) + "|" + true;
// SendObjectUpdate<ObjectSenderBasic>(msg);
// // print("Lock object " + obj.gameObject.name);
// }
// currentlyLockedObject = obj;
// }
// else // unlock it
// {
// if (currentlyLockedObject != null && !deactivatePublish) // unlock if locked
// {
// string msg = "client " + id + "|" + "l" + "|" + vpet.Extensions.getPathString(obj, scene) + "|" + false;
// SendObjectUpdate<ObjectSenderBasic>(msg);
// // print("Unlock object " + obj.gameObject.name);
// }
// currentlyLockedObject = null;
// }
//} // commented at sync update rewrite
//! function parsing received message and executing change
//! @param message message string received by server
public void parseTransformation(byte[] msg)
{
if (msg[0] != m_id)
{
ParameterType paramType = (ParameterType)msg[1];
int objectID = BitConverter.ToInt32(msg, 2);
SceneObject sceneObject = sceneObjectRefList[objectID];
switch (paramType)
{
case ParameterType.POS:
{
#if !SCENE_HOST
if (!mainController.isTranslating)
#endif
{
sceneObject.transform.localPosition = new Vector3(BitConverter.ToSingle(msg, 6),
BitConverter.ToSingle(msg, 10),
BitConverter.ToSingle(msg, 14));
}
}
break;
case ParameterType.ROT:
{
#if !SCENE_HOST
if (!mainController.isRotating)
#endif
{
sceneObject.transform.localRotation = new Quaternion(BitConverter.ToSingle(msg, 6),
BitConverter.ToSingle(msg, 10),
BitConverter.ToSingle(msg, 14),
BitConverter.ToSingle(msg, 18));
}
}
break;
case ParameterType.SCALE:
{
#if !SCENE_HOST
if (!mainController.isScaling)
#endif
{
sceneObject.transform.localScale = new Vector3(BitConverter.ToSingle(msg, 6),
BitConverter.ToSingle(msg, 10),
BitConverter.ToSingle(msg, 14));
}
}
break;
case ParameterType.LOCK:
{
#if SCENE_HOST
if (!sceneObject.isAnimatedCharacter)
{
#endif
bool locked = BitConverter.ToBoolean(msg, 6);
sceneObject.enableRigidbody(!locked);
sceneObject.locked = locked;
#if !SCENE_HOST
sceneObject.updateLockView();
#endif
#if SCENE_HOST
}
#endif
}
break;
case ParameterType.HIDDENLOCK:
{
#if SCENE_HOST
if (!sceneObject.isAnimatedCharacter)
#endif
{
bool locked = BitConverter.ToBoolean(msg, 6);
sceneObject.enableRigidbody(!locked);
sceneObject.locked = locked;
}
}
break;
case ParameterType.KINEMATIC:
{
sceneObject.globalKinematic = BitConverter.ToBoolean(msg, 6);
}
break;
case ParameterType.FOV:
{
SceneObjectCamera soc = (SceneObjectCamera)sceneObject;
if (soc)
{
soc.fov = BitConverter.ToSingle(msg, 6);
}
}
break;
case ParameterType.ASPECT:
{
SceneObjectCamera soc = (SceneObjectCamera)sceneObject;
if (soc)
{
soc.aspect = BitConverter.ToSingle(msg, 6);
}
}
break;
case ParameterType.FOCUSDIST:
{
SceneObjectCamera soc = (SceneObjectCamera)sceneObject;
if (soc)
{
soc.focDist = BitConverter.ToSingle(msg, 6);
}
}
break;
case ParameterType.FOCUSSIZE:
{
SceneObjectCamera soc = (SceneObjectCamera)sceneObject;
if (soc)
{
soc.focSize = BitConverter.ToSingle(msg, 6);
}
}
break;
case ParameterType.APERTURE:
{
SceneObjectCamera soc = (SceneObjectCamera)sceneObject;
if (soc)
{
soc.aperture = BitConverter.ToSingle(msg, 6);
}
}
break;
case ParameterType.COLOR:
{
SceneObjectLight sol = (SceneObjectLight)sceneObject;
if (sol)
{
sol.transform.GetChild(0).GetComponent <Light>().color = new Color(BitConverter.ToSingle(msg, 6),
BitConverter.ToSingle(msg, 10),
BitConverter.ToSingle(msg, 14));
}
}
break;
case ParameterType.INTENSITY:
{
SceneObjectLight sol = (SceneObjectLight)sceneObject;
if (sol)
{
sol.transform.GetChild(0).GetComponent <Light>().intensity = BitConverter.ToSingle(msg, 6);
}
}
break;
case ParameterType.EXPOSURE:
{
// no exposure for unity lights
// used for katana
}
break;
case ParameterType.RANGE:
{
SceneObjectLight sol = (SceneObjectLight)sceneObject;
if (sol)
{
sol.transform.GetChild(0).GetComponent <Light>().range = BitConverter.ToSingle(msg, 6);
}
}
break;
case ParameterType.ANGLE:
{
SceneObjectLight sol = (SceneObjectLight)sceneObject;
if (sol)
{
sol.transform.GetChild(0).GetComponent <Light>().spotAngle = BitConverter.ToSingle(msg, 6);
}
}
break;
case ParameterType.BONEANIM:
{
Vector3 hipPosition = new Vector3(BitConverter.ToSingle(msg, 6),
BitConverter.ToSingle(msg, 10),
BitConverter.ToSingle(msg, 14));
int offset = 12;
int numBones = Enum.GetNames(typeof(HumanBodyBones)).Length - 1;
Quaternion[] animationState = new Quaternion[numBones];
for (int i = 0; i < numBones; i++)
{
animationState[i] = new Quaternion(BitConverter.ToSingle(msg, offset + 6),
BitConverter.ToSingle(msg, offset + 10),
BitConverter.ToSingle(msg, offset + 14),
BitConverter.ToSingle(msg, offset + 18));
offset += 16;
}
#if !SCENE_HOST
if (!mainController.isTranslating)
#endif
sceneObject.gameObject.GetComponent <CharacterAnimationController>().bodyPosition = hipPosition;
sceneObject.gameObject.GetComponent <CharacterAnimationController>().animationState = animationState;
}
break;
case ParameterType.PING:
{
// only for sync server
}
break;
case ParameterType.RESENDUPDATE:
{
// only for sync server
}
break;
case ParameterType.CHARACTERTARGET:
{
#if SCENE_HOST
NavMeshAgent navMeshAgent = sceneObject.transform.GetComponent <NavMeshAgent>();
if (navMeshAgent)
{
navMeshAgent.destination = new Vector3(BitConverter.ToSingle(msg, 6),
BitConverter.ToSingle(msg, 10),
BitConverter.ToSingle(msg, 14));
}
#endif
}
break;
default:
Debug.Log("Unknown paramType in ServerAdapter:ParseTransformation");
return;
break;
}
#if SCENE_HOST
if (recordUpdates)
{
buildRecordMessage(sceneObject, paramType);
}
#endif
}
}
//!
//! Update is called once per frame
//!
void Update()
{
//compensate gravity vector based on AR scene rotation
if (arMode)
{
Physics.gravity = scene.transform.rotation * new Vector3(0f, -981f, 0f);
}
if (Application.targetFrameRate != 30)
{
Application.targetFrameRate = 30;
}
//position modifiers if neccessary
if (currentSelection)
{
Vector3 modifierScale = getModifierScale();
if (lineRenderer)
{
lineRenderer.widthMultiplier = modifierScale.magnitude / 100f;
}
if (activeMode == Mode.translationMode || activeMode == Mode.animationEditing)
{
//translateModifier.transform.position = currentSelection.position;
translateModifier.transform.position = currentSelection.GetComponent <Collider>().bounds.center;
translateModifier.transform.rotation = currentSelection.rotation;
translateModifier.transform.localScale = modifierScale;
translateModifier.transform.GetChild(9).position = new Vector3(currentSelection.position.x, 0.001f, currentSelection.position.z);
}
else if (activeMode == Mode.rotationMode)
{
rotationModifier.transform.position = currentSelection.position;
//rotationModifier.transform.position = currentSelection.GetComponent<Collider>().bounds.center;
rotationModifier.transform.rotation = currentSelection.rotation;
rotationModifier.transform.localScale = modifierScale;
}
else if (activeMode == Mode.scaleMode)
{
scaleModifier.transform.position = currentSelection.position;
scaleModifier.transform.rotation = currentSelection.rotation;
scaleModifier.transform.localScale = modifierScale;
}
}
//state machine
if (oldState != activeMode || currentSelection != oldSelection)
{
print(oldState.ToString() + " >>>>> " + activeMode);
// TODO: review (and remove) this statement
if (currentSelection == null && !cameraPointMove)
{
activeMode = Mode.idle;
}
if (hasUpdatedProjectionMatrix)
{
UpdateProjectionMatrixSecondaryCameras();
hasUpdatedProjectionMatrix = false;
}
// unlock if active mode is none editing mode
//if (activeMode!=Mode.translationMode && activeMode!=Mode.rotationMode && activeMode != Mode.scaleMode && activeMode != Mode.objectLinkCamera && activeMode != Mode.animationEditing && activeMode != Mode.pointToMoveMode && activeMode != Mode.lightSettingsMode)
if (activeMode != oldState)
{
//serverAdapter.sendLock(currentSelection, false);
}
animationController.deactivate();
if (ui.LayoutUI == layouts.ANIMATION)
{
animationController.activate(currentSelection != oldSelection);
}
//properly disable old mode
switch (oldState)
{
case (Mode.idle):
break;
case (Mode.translationMode):
translateModifier.GetComponent <Modifier>().setVisible(false);
//if ( activeMode != Mode.objectLinkCamera && activeMode != Mode.pointToMoveMode && ui.LayoutUI != layouts.ANIMATION )
// ui.drawSecondaryMenu(layouts.EDIT);
ui.hideRangeSlider();
if (activeMode != Mode.objectLinkCamera && activeMode != Mode.translationMode && activeMode != Mode.pointToMoveMode)
{
ui.hideParameterMenu();
}
break;
case (Mode.rotationMode):
rotationModifier.GetComponent <Modifier>().setVisible(false);
ui.hideRangeSlider();
ui.hideParameterMenu();
break;
case (Mode.scaleMode):
scaleModifier.GetComponent <Modifier>().setVisible(false);
ui.hideRangeSlider();
ui.hideParameterMenu();
break;
case (Mode.objectLinkCamera):
if (currentSelection)
{
if (currentSceneObject.GetType() == typeof(SceneObjectLight))
{
currentSelection.parent = oldParent;
}
else
{
//if (ui.LayoutUI != layouts.ANIMATION)
// currentSceneObject.setKinematic(false);
currentSelection.parent = oldParent;
}
//if (ui.LayoutUI == layouts.ANIMATION)
// animationController.setKeyFrame();
}
//if (activeMode != Mode.objectLinkCamera && activeMode != Mode.translationMode && activeMode != Mode.pointToMoveMode) ui.drawSecondaryMenu(layouts.EDIT);
if (activeMode != Mode.objectLinkCamera && activeMode != Mode.translationMode && activeMode != Mode.pointToMoveMode)
{
ui.hideParameterMenu();
}
break;
case (Mode.pointToMoveMode):
if (activeMode != Mode.objectLinkCamera && activeMode != Mode.translationMode && activeMode != Mode.pointToMoveMode)
{
ui.hideParameterMenu();
}
//if (activeMode != Mode.objectLinkCamera && activeMode != Mode.translationMode && activeMode != Mode.pointToMoveMode) ui.drawSecondaryMenu(layouts.EDIT);
break;
case (Mode.objectMenuMode):
break;
case (Mode.lightMenuMode):
break;
case (Mode.cameraMenuMode):
break;
case (Mode.lightSettingsMode):
ui.hideLightSettingsWidget();
ui.hideRangeSlider();
ui.hideParameterMenu();
break;
case (Mode.lookThroughCamMode):
ui.hideRangeSlider();
Camera.main.fieldOfView = 60;
ui.hideParameterMenu();
ui.resetCenterMenu();
break;
case (Mode.lookThroughLightMode):
ui.hideRangeSlider();
Camera.main.fieldOfView = 60;
ui.hideParameterMenu();
break;
case (Mode.cameraSettingsMode):
ui.hideRangeSlider();
ui.hideParameterMenu();
break;
case (Mode.addMode):
break;
default:
break;
}
//enable new mode
switch (activeMode)
{
case (Mode.idle):
ui.hideCenterMenu();
break;
case (Mode.translationMode):
//serverAdapter.sendLock(currentSelection, true);
translateModifier.GetComponent <Modifier>().setVisible(true);
if (ui.LayoutUI != layouts.ANIMATION)
{
ui.drawSecondaryMenu(layouts.TRANSLATION);
}
ui.resetRangeSlider();
ConnectRangeSlider(currentSceneObject, "TranslateX", 2f * VPETSettings.Instance.sceneScale);
ui.drawParameterMenu(layouts.TRANSLATION);
break;
case (Mode.rotationMode):
//serverAdapter.sendLock(currentSelection, true);
rotationModifier.GetComponent <Modifier>().setVisible(true);
ui.resetRangeSlider();
ConnectRangeSlider(currentSceneObject, "RotateX", 1f);
ui.drawParameterMenu(layouts.TRANSFORM);
break;
case (Mode.scaleMode):
scaleModifier.GetComponent <Modifier>().setVisible(true);
//serverAdapter.sendLock(currentSelection, true);
ui.resetRangeSlider();
ConnectRangeSlider(currentSceneObject, "ScaleX", 0.02f);
ui.drawParameterMenu(layouts.TRANSFORM);
break;
case (Mode.objectLinkCamera):
if (currentSceneObject.GetType() == typeof(SceneObjectLight))
{
oldParent = currentSelection.parent;
currentSelection.parent = Camera.main.transform;
}
else
{
currentSceneObject.setKinematic(true);
oldParent = currentSelection.parent;
currentSelection.parent = Camera.main.transform;
}
ui.hideRangeSlider();
// ui.drawParameterMenu(layouts.TRANSLATION);
//serverAdapter.sendLock(currentSelection, true);
break;
case (Mode.pointToMoveMode):
ui.hideRangeSlider();
// ui.drawParameterMenu(layouts.TRANSLATION);
//serverAdapter.sendLock(currentSelection, true);
break;
case (Mode.objectMenuMode):
if (currentSelection && ui.LayoutUI != layouts.SCOUT)
{
if (ui.LayoutUI == layouts.ANIMATION)
{
ui.drawCenterMenu(layouts.ANIMATION);
ui.drawSecondaryMenu(layouts.ANIMATION);
}
else
{
ui.drawCenterMenu(layouts.OBJECT);
}
}
break;
case (Mode.lightMenuMode):
if (currentSelection && ui.LayoutUI != layouts.SCOUT)
{
if (ui.LayoutUI == layouts.ANIMATION)
{
ui.drawCenterMenu(layouts.ANIMATION);
ui.drawSecondaryMenu(layouts.ANIMATION);
}
else
{
SceneObjectLight solight = (SceneObjectLight)currentSceneObject;
if (currentSelection && solight)
{
solight.hideVisualization(false);
}
if (arMode)
{
ui.drawCenterMenu(layouts.LIGHT_AR);
}
else
{
ui.drawCenterMenu(layouts.LIGHT);
}
}
/*
* if (currentSceneObject.isDirectionalLight)
* ui.drawCenterMenu(layouts.LIGHTDIR);
* else if (currentSceneObject.isPointLight)
* ui.drawCenterMenu(layouts.LIGHTPOINT);
* else if (currentSceneObject.isSpotLight)
* ui.drawCenterMenu(layouts.LIGHTSPOT);
*/
}
break;
case (Mode.cameraMenuMode):
if (currentSelection && ui.LayoutUI != layouts.SCOUT)
{
if (arMode)
{
ui.drawCenterMenu(layouts.CAMERA_AR);
}
else
{
ui.drawCenterMenu(layouts.CAMERA);
}
}
break;
case (Mode.cameraLockedMode):
if (currentSelection && ui.LayoutUI != layouts.SCOUT)
{
ui.drawCenterMenu(layouts.CAMERALOCKED);
}
break;
case (Mode.lightSettingsMode):
SceneObjectLight sol = (SceneObjectLight)currentSceneObject;
if (currentSelection && sol)
{
sol.hideVisualization(true);
}
// ConnectRangeSlider(currentSceneObject, "LightIntensity", 1f);
ConnectRangeSlider(sol.setLightIntensity, sol.getLightIntensity(), 0.1f / VPETSettings.Instance.lightIntensityFactor);
if (sol.isDirectionalLight)
{
ui.drawParameterMenu(layouts.LIGHTDIR);
}
else if (sol.isPointLight)
{
ui.drawParameterMenu(layouts.LIGHTPOINT);
}
else if (sol.isSpotLight)
{
ui.drawParameterMenu(layouts.LIGHTSPOT);
}
else if (sol.isAreaLight)
{
ui.drawParameterMenu(layouts.LIGHTAREA);
}
ui.drawLightSettingsWidget();
//serverAdapter.sendLock(currentSelection, true);
break;
case (Mode.lookThroughLightMode):
SceneObjectLight s = (SceneObjectLight)currentSceneObject;
if (currentSelection && s)
{
s.hideVisualization(true);
}
// ConnectRangeSlider(currentSceneObject, "LightIntensity", 1f);
ConnectRangeSlider(s.setLightIntensity, s.getLightIntensity(), 0.1f / VPETSettings.Instance.lightIntensityFactor);
if (s.isDirectionalLight)
{
ui.drawParameterMenu(layouts.LIGHTDIR);
}
else if (s.isPointLight)
{
ui.drawParameterMenu(layouts.LIGHTPOINT);
}
else if (s.isSpotLight)
{
ui.drawParameterMenu(layouts.LIGHTSPOT);
}
else if (s.isAreaLight)
{
ui.drawParameterMenu(layouts.LIGHTAREA);
}
ui.drawLightSettingsWidget();
//serverAdapter.sendLock(currentSelection, true);
break;
case (Mode.addMode):
break;
default:
break;
}
//renew old state
oldState = activeMode;
oldSelection = currentSelection;
}
}
//!
//! function create the object from mesh data
//! @param node object which holds the data
//! @param parentTransform parent object
//!
public static GameObject CreateLight(SceneNodeLight nodeLight, Transform parentTransform)
{
// Tranform
Vector3 pos = new Vector3(nodeLight.position[0], nodeLight.position[1], nodeLight.position[2]);
Quaternion rot = new Quaternion(nodeLight.rotation[0], nodeLight.rotation[1], nodeLight.rotation[2], nodeLight.rotation[3]);
Vector3 scl = new Vector3(nodeLight.scale[0], nodeLight.scale[1], nodeLight.scale[2]);
// set up object basics
GameObject objMain = new GameObject();
objMain.name = Encoding.ASCII.GetString(nodeLight.name);
//place object
objMain.transform.SetParent(parentTransform, false);
objMain.transform.localPosition = pos;
objMain.transform.localRotation = rot;
objMain.transform.localScale = Vector3.one;
// Add light prefab
GameObject lightUber = Resources.Load <GameObject>("VPET/Prefabs/UberLight");
GameObject _lightUberInstance = GameObject.Instantiate(lightUber);
_lightUberInstance.name = lightUber.name;
lightUber.transform.GetChild(0).gameObject.layer = 8;
Light lightComponent = _lightUberInstance.GetComponent <Light>();
// instert type here!!!
lightComponent.type = nodeLight.lightType;
lightComponent.color = new Color(nodeLight.color[0], nodeLight.color[1], nodeLight.color[2]);
lightComponent.intensity = nodeLight.intensity * VPETSettings.Instance.lightIntensityFactor;
lightComponent.spotAngle = nodeLight.angle;
if (lightComponent.type == LightType.Directional)
{
lightComponent.shadows = LightShadows.Soft;
lightComponent.shadowStrength = 0.8f;
}
else
{
lightComponent.shadows = LightShadows.None;
}
lightComponent.shadowBias = 0f;
lightComponent.shadowNormalBias = 1f;
lightComponent.range = nodeLight.range * VPETSettings.Instance.sceneScale;
Debug.Log("Create Light: " + nodeLight.name + " of type: " + ((LightTypeKatana)(nodeLight.lightType)).ToString() + " Intensity: " + nodeLight.intensity + " Pos: " + pos);
// Add light specific settings
if (nodeLight.lightType == LightType.Directional)
{
}
else if (nodeLight.lightType == LightType.Spot)
{
lightComponent.range *= 2;
//objMain.transform.Rotate(new Vector3(0, 180f, 0), Space.Self);
}
else if (nodeLight.lightType == LightType.Area)
{
// TODO: use are lights when supported in unity
lightComponent.spotAngle = 170;
lightComponent.range *= 4;
}
else
{
Debug.Log("Unknown Light Type in NodeBuilderBasic::CreateLight");
}
// parent
_lightUberInstance.transform.SetParent(objMain.transform, false);
// add scene object for interactivity at the light quad
//if (nodeLight.editable)
//{
SceneObjectLight sco = objMain.AddComponent <SceneObjectLight>();
sco.id = idCount++;
sco.exposure = nodeLight.exposure;
//}
// Rotate 180 around y-axis because lights and cameras have additional eye space coordinate system
//objMain.transform.Rotate(new Vector3(0, 180f, 0), Space.Self);
// TODO: what for ??
objMain.layer = 0;
return(objMain);
}
public override void SendObject(byte cID, SceneObject sceneObject, ParameterType paramType, bool sendParent, Transform parent)
{
if (!sceneObject)
{
return;
}
string dagPath = vpet.Extensions.getPathString(sceneObject.transform, root);
// HACK check missing '/' upstream
dagPath = "/" + dagPath;
//Debug.Log(dagPath);
NodeType nodeType = NodeType.GROUP;
if (sceneObject is SceneObjectLight)
{
nodeType = NodeType.LIGHT;
}
else if (sceneObject is SceneObjectCamera)
{
nodeType = NodeType.CAMERA;
}
if (paramType == ParameterType.POS ||
paramType == ParameterType.ROT ||
paramType == ParameterType.SCALE)
{
if (nodeType == NodeType.LIGHT) // do transform for lights to katana differently
{
Transform obj = sceneObject.transform;
Vector3 pos = obj.localPosition;
Quaternion rot = obj.localRotation;
Vector3 scl = obj.localScale;
Quaternion rotY180 = Quaternion.AngleAxis(180, Vector3.up);
rot = rot * rotY180;
float angle = 0;
Vector3 axis = Vector3.zero;
rot.ToAngleAxis(out angle, out axis);
sendMessageQueue.Add(Encoding.UTF8.GetBytes(String.Format(lightTransRotTemplate,
dagPath,
(-pos.x + " " + pos.y + " " + pos.z),
(angle + " " + axis.x + " " + -axis.y + " " + -axis.z),
(scl.x + " " + scl.y + " " + scl.z))));
}
else if (nodeType == NodeType.CAMERA) // do camera different too --> in fact is the same as for lights??
{
Transform obj = sceneObject.transform;
Vector3 pos = obj.localPosition;
Quaternion rot = obj.localRotation;
Vector3 scl = obj.localScale;
Quaternion rotY180 = Quaternion.AngleAxis(180, Vector3.up);
rot = rot * rotY180;
float angle = 0;
Vector3 axis = Vector3.zero;
rot.ToAngleAxis(out angle, out axis);
sendMessageQueue.Add(Encoding.UTF8.GetBytes(String.Format(camTransRotTemplate,
dagPath,
(-pos.x + " " + pos.y + " " + pos.z),
(angle + " " + axis.x + " " + -axis.y + " " + -axis.z),
(scl.x + " " + scl.y + " " + scl.z))));
}
else
{
Transform obj = sceneObject.transform;
Vector3 pos = obj.localPosition;
Quaternion rot = obj.localRotation;
Vector3 scl = obj.localScale;
float angle = 0;
Vector3 axis = Vector3.zero;
rot.ToAngleAxis(out angle, out axis);
sendMessageQueue.Add(Encoding.UTF8.GetBytes(String.Format(objTemplateQuat,
dagPath,
(-pos.x + " " + pos.y + " " + pos.z),
(angle + " " + axis.x + " " + -axis.y + " " + -axis.z),
(scl.x + " " + scl.y + " " + scl.z))));
}
}
else if (paramType == ParameterType.ANGLE ||
paramType == ParameterType.COLOR ||
paramType == ParameterType.INTENSITY ||
paramType == ParameterType.RANGE ||
paramType == ParameterType.EXPOSURE ||
paramType == ParameterType.FOV)
{
if (nodeType == NodeType.LIGHT)
{
SceneObjectLight sol = (SceneObjectLight)sceneObject;
Light light = sol.SourceLight;
LightTypeKatana lightType = (LightTypeKatana)(light.type);
if (sol.isAreaLight)
{
lightType = LightTypeKatana.rect;
}
sendMessageQueue.Add(Encoding.UTF8.GetBytes(String.Format(lightIntensityColorTemplate,
dagPath,
(lightType).ToString(),
light.color.r + " " + light.color.g + " " + light.color.b,
light.intensity / VPETSettings.Instance.lightIntensityFactor,
sol.exposure,
light.spotAngle)));
}
else if (nodeType == NodeType.CAMERA)
{
SceneObjectCamera sol = (SceneObjectCamera)sceneObject;
sendMessageQueue.Add(Encoding.UTF8.GetBytes(String.Format(camFOVTemplate,
dagPath,
Extensions.vFovToHFov(sol.fov, 16, 9))));
}
}
}
public override void SendObject(byte cID, SceneObject sceneObject, ParameterType paramType, bool sendParent, Transform parent)
{
#if SCENE_HOST
if (sceneObject && paramType != ParameterType.LOCK)
{
if (!sceneObject.selected)
{
sceneObject.unlockTime = 0.5f;
sceneObject.selected = true;
SendObject(cID, sceneObject, ParameterType.LOCK, sendParent, parent);
}
}
#endif
byte[] msg = null;
switch (paramType)
{
case ParameterType.POS:
{
Vector3 locPos;
if (sendParent)
{
locPos = sceneObject.transform.position - parent.position;
}
else
{
locPos = sceneObject.transform.localPosition;
}
msg = new byte[18];
msg[0] = cID;
msg[1] = (byte)paramType;
Buffer.BlockCopy(BitConverter.GetBytes((Int32)sceneObject.id), 0, msg, 2, 4);
Buffer.BlockCopy(BitConverter.GetBytes(locPos.x), 0, msg, 6, 4);
Buffer.BlockCopy(BitConverter.GetBytes(locPos.y), 0, msg, 10, 4);
Buffer.BlockCopy(BitConverter.GetBytes(locPos.z), 0, msg, 14, 4);
}
break;
case ParameterType.ROT:
{
Quaternion locRot;
if (sendParent)
{
locRot = Quaternion.Inverse(parent.rotation) * sceneObject.transform.rotation;
}
else
{
locRot = sceneObject.transform.localRotation;
}
msg = new byte[22];
msg[0] = cID;
msg[1] = (byte)paramType;
Buffer.BlockCopy(BitConverter.GetBytes((Int32)sceneObject.id), 0, msg, 2, 4);
Buffer.BlockCopy(BitConverter.GetBytes(locRot.x), 0, msg, 6, 4);
Buffer.BlockCopy(BitConverter.GetBytes(locRot.y), 0, msg, 10, 4);
Buffer.BlockCopy(BitConverter.GetBytes(locRot.z), 0, msg, 14, 4);
Buffer.BlockCopy(BitConverter.GetBytes(locRot.w), 0, msg, 18, 4);
}
break;
case ParameterType.SCALE:
{
Vector3 locScale = sceneObject.transform.localScale;
msg = new byte[18];
msg[0] = cID;
msg[1] = (byte)paramType;
Buffer.BlockCopy(BitConverter.GetBytes((Int32)sceneObject.id), 0, msg, 2, 4);
Buffer.BlockCopy(BitConverter.GetBytes(locScale.x), 0, msg, 6, 4);
Buffer.BlockCopy(BitConverter.GetBytes(locScale.y), 0, msg, 10, 4);
Buffer.BlockCopy(BitConverter.GetBytes(locScale.z), 0, msg, 14, 4);
}
break;
case ParameterType.LOCK:
{
msg = new byte[7];
msg[0] = cID;
msg[1] = (byte)paramType;
Buffer.BlockCopy(BitConverter.GetBytes((Int32)sceneObject.id), 0, msg, 2, 4);
msg[6] = Convert.ToByte(sceneObject.selected);
}
break;
case ParameterType.HIDDENLOCK:
{
msg = new byte[7];
msg[0] = cID;
msg[1] = (byte)paramType;
Buffer.BlockCopy(BitConverter.GetBytes((Int32)sceneObject.id), 0, msg, 2, 4);
msg[6] = Convert.ToByte(sceneObject.isPhysicsActive || sceneObject.isPlayingAnimation);
}
break;
case ParameterType.KINEMATIC:
{
msg = new byte[7];
msg[0] = cID;
msg[1] = (byte)paramType;
Buffer.BlockCopy(BitConverter.GetBytes((Int32)sceneObject.id), 0, msg, 2, 4);
msg[6] = Convert.ToByte(sceneObject.globalKinematic);
}
break;
case ParameterType.FOV:
{
SceneObjectCamera soc = (SceneObjectCamera)sceneObject;
if (soc)
{
msg = new byte[10];
msg[0] = cID;
msg[1] = (byte)paramType;
Buffer.BlockCopy(BitConverter.GetBytes((Int32)sceneObject.id), 0, msg, 2, 4);
Buffer.BlockCopy(BitConverter.GetBytes(soc.fov), 0, msg, 6, 4);
}
}
break;
case ParameterType.ASPECT:
{
SceneObjectCamera soc = (SceneObjectCamera)sceneObject;
if (soc)
{
msg = new byte[10];
msg[0] = cID;
msg[1] = (byte)paramType;
Buffer.BlockCopy(BitConverter.GetBytes((Int32)sceneObject.id), 0, msg, 2, 4);
Buffer.BlockCopy(BitConverter.GetBytes(soc.aspect), 0, msg, 6, 4);
}
}
break;
case ParameterType.FOCUSDIST:
{
SceneObjectCamera soc = (SceneObjectCamera)sceneObject;
if (soc)
{
msg = new byte[10];
msg[0] = cID;
msg[1] = (byte)paramType;
Buffer.BlockCopy(BitConverter.GetBytes((Int32)sceneObject.id), 0, msg, 2, 4);
Buffer.BlockCopy(BitConverter.GetBytes(soc.focDist), 0, msg, 6, 4);
}
}
break;
case ParameterType.FOCUSSIZE:
{
SceneObjectCamera soc = (SceneObjectCamera)sceneObject;
if (soc)
{
msg = new byte[10];
msg[0] = cID;
msg[1] = (byte)paramType;
Buffer.BlockCopy(BitConverter.GetBytes((Int32)sceneObject.id), 0, msg, 2, 4);
Buffer.BlockCopy(BitConverter.GetBytes(soc.focSize), 0, msg, 6, 4);
}
}
break;
case ParameterType.APERTURE:
{
SceneObjectCamera soc = (SceneObjectCamera)sceneObject;
if (soc)
{
msg = new byte[10];
msg[0] = cID;
msg[1] = (byte)paramType;
Buffer.BlockCopy(BitConverter.GetBytes((Int32)sceneObject.id), 0, msg, 2, 4);
Buffer.BlockCopy(BitConverter.GetBytes(soc.aperture), 0, msg, 6, 4);
}
}
break;
case ParameterType.COLOR:
{
SceneObjectLight sol = (SceneObjectLight)sceneObject;
if (sol)
{
Color color = sol.getLightColor();
msg = new byte[18];
msg[0] = cID;
msg[1] = (byte)paramType;
Buffer.BlockCopy(BitConverter.GetBytes((Int32)sceneObject.id), 0, msg, 2, 4);
Buffer.BlockCopy(BitConverter.GetBytes(color.r), 0, msg, 6, 4);
Buffer.BlockCopy(BitConverter.GetBytes(color.g), 0, msg, 10, 4);
Buffer.BlockCopy(BitConverter.GetBytes(color.b), 0, msg, 14, 4);
}
}
break;
case ParameterType.INTENSITY:
{
SceneObjectLight sol = (SceneObjectLight)sceneObject;
if (sol)
{
msg = new byte[10];
msg[0] = cID;
msg[1] = (byte)paramType;
Buffer.BlockCopy(BitConverter.GetBytes((Int32)sceneObject.id), 0, msg, 2, 4);
Buffer.BlockCopy(BitConverter.GetBytes(sol.getLightIntensity()), 0, msg, 6, 4);
}
}
break;
case ParameterType.EXPOSURE:
{
SceneObjectLight sol = (SceneObjectLight)sceneObject;
if (sol)
{
msg = new byte[10];
msg[0] = cID;
msg[1] = (byte)paramType;
Buffer.BlockCopy(BitConverter.GetBytes((Int32)sceneObject.id), 0, msg, 2, 4);
Buffer.BlockCopy(BitConverter.GetBytes(sol.exposure), 0, msg, 6, 4);
}
}
break;
case ParameterType.RANGE:
{
SceneObjectLight sol = (SceneObjectLight)sceneObject;
if (sol)
{
msg = new byte[10];
msg[0] = cID;
msg[1] = (byte)paramType;
Buffer.BlockCopy(BitConverter.GetBytes((Int32)sceneObject.id), 0, msg, 2, 4);
Buffer.BlockCopy(BitConverter.GetBytes(sol.getLightRange()), 0, msg, 6, 4);
}
}
break;
case ParameterType.ANGLE:
{
SceneObjectLight sol = (SceneObjectLight)sceneObject;
if (sol)
{
msg = new byte[10];
msg[0] = cID;
msg[1] = (byte)paramType;
Buffer.BlockCopy(BitConverter.GetBytes((Int32)sceneObject.id), 0, msg, 2, 4);
Buffer.BlockCopy(BitConverter.GetBytes(sol.getLightAngle()), 0, msg, 6, 4);
}
}
break;
case ParameterType.BONEANIM:
{
Animator animator = sceneObject.gameObject.GetComponent <Animator>();
if (animator)
{
int numHBones = Enum.GetNames(typeof(HumanBodyBones)).Length - 1;
msg = new byte[18 + numHBones * 16];
//TODO: check what needs to be send here to support all character variants
Vector3 locPos = animator.bodyPosition;
msg[0] = cID;
msg[1] = (byte)paramType;
Buffer.BlockCopy(BitConverter.GetBytes((Int32)sceneObject.id), 0, msg, 2, 4);
Buffer.BlockCopy(BitConverter.GetBytes(locPos.x), 0, msg, 6, 4);
Buffer.BlockCopy(BitConverter.GetBytes(locPos.y), 0, msg, 10, 4);
Buffer.BlockCopy(BitConverter.GetBytes(locPos.z), 0, msg, 14, 4);
int offset = 12;
for (int i = 0; i < numHBones; i++)
{
Transform t = animator.GetBoneTransform((HumanBodyBones)i);
if (t)
{
Buffer.BlockCopy(BitConverter.GetBytes(t.localRotation.x), 0, msg, offset + 6, 4);
Buffer.BlockCopy(BitConverter.GetBytes(t.localRotation.y), 0, msg, offset + 10, 4);
Buffer.BlockCopy(BitConverter.GetBytes(t.localRotation.z), 0, msg, offset + 14, 4);
Buffer.BlockCopy(BitConverter.GetBytes(t.localRotation.w), 0, msg, offset + 18, 4);
offset += 16;
}
}
}
}
break;
case ParameterType.PING:
{
msg = new byte[2];
msg[0] = cID;
msg[1] = (byte)paramType;
}
break;
case ParameterType.RESENDUPDATE:
{
msg = new byte[2];
msg[0] = cID;
msg[1] = (byte)paramType;
}
break;
case ParameterType.CHARACTERTARGET:
{
Vector3 targetPos = sceneObject.targetTranslation;
msg = new byte[18];
msg[0] = cID;
msg[1] = (byte)paramType;
Buffer.BlockCopy(BitConverter.GetBytes((Int32)sceneObject.id), 0, msg, 2, 4);
Buffer.BlockCopy(BitConverter.GetBytes(targetPos.x), 0, msg, 6, 4);
Buffer.BlockCopy(BitConverter.GetBytes(targetPos.y), 0, msg, 10, 4);
Buffer.BlockCopy(BitConverter.GetBytes(targetPos.z), 0, msg, 14, 4);
}
break;
default:
{
Debug.Log("Unknown paramType in ObjectSenderBasic:SendObject");
}
break;
}
if (msg != null)
{
sendMessageQueue.Add(msg);
}
}
private void parameterButtonHandle(IMenuButton button, int idx)
{
parameterMenu.reset();
button.Toggled = true;
// if point to move or link to camera mode switch to translation
if (mainController.ActiveMode == MainController.Mode.pointToMoveMode || mainController.ActiveMode == MainController.Mode.objectLinkCamera)
{
mainController.ActiveMode = MainController.Mode.translationMode;
}
rangeSlider.MinValue = float.MinValue;
rangeSlider.MaxValue = float.MaxValue;
SceneObject sco = mainController.getCurrentSelection().GetComponent <SceneObject>();
switch (idx)
{
case 0: // X
if (mainController.ActiveMode == MainController.Mode.translationMode)
{
mainController.ConnectRangeSlider(sco, "TranslateX", 2f * VPETSettings.Instance.controllerSpeed);
}
else if (mainController.ActiveMode == MainController.Mode.scaleMode)
{
mainController.ConnectRangeSlider(sco, "ScaleX", 0.02f);
}
else if (mainController.ActiveMode == MainController.Mode.rotationMode)
{
mainController.ConnectRangeSlider(sco, "RotateX", 1f);
}
else if (mainController.ActiveMode == MainController.Mode.lightSettingsMode || mainController.ActiveMode == MainController.Mode.lookThroughLightMode)
{
SceneObjectLight scl = (SceneObjectLight)sco;
if (scl)
{
lightSettingsWidget.hide();
mainController.ConnectRangeSlider(scl.setLightIntensity, scl.getLightIntensity(), 0.1f / VPETSettings.Instance.lightIntensityFactor);
rangeSlider.MinValue = 0f;
}
}
break;
case 1:
if (mainController.ActiveMode == MainController.Mode.translationMode)
{
mainController.ConnectRangeSlider(sco, "TranslateY", 2f * VPETSettings.Instance.controllerSpeed);
}
else if (mainController.ActiveMode == MainController.Mode.scaleMode)
{
mainController.ConnectRangeSlider(sco, "ScaleY", 0.02f);
}
else if (mainController.ActiveMode == MainController.Mode.rotationMode)
{
mainController.ConnectRangeSlider(sco, "RotateY", 1f);
}
else if (mainController.ActiveMode == MainController.Mode.lightSettingsMode || mainController.ActiveMode == MainController.Mode.lookThroughLightMode)
{
SceneObjectLight scl = (SceneObjectLight)sco;
if (scl)
{
lightSettingsWidget.hide();
mainController.ConnectRangeSlider(scl.setLightRange, scl.getLightRange(), 10f);
rangeSlider.MinValue = 0.1f;
}
}
break;
case 2:
if (mainController.ActiveMode == MainController.Mode.translationMode)
{
mainController.ConnectRangeSlider(sco, "TranslateZ", 2f * VPETSettings.Instance.controllerSpeed);
}
else if (mainController.ActiveMode == MainController.Mode.scaleMode)
{
mainController.ConnectRangeSlider(sco, "ScaleZ", 0.02f);
}
else if (mainController.ActiveMode == MainController.Mode.rotationMode)
{
mainController.ConnectRangeSlider(sco, "RotateZ", 1f);
}
else if (mainController.ActiveMode == MainController.Mode.lightSettingsMode || mainController.ActiveMode == MainController.Mode.lookThroughLightMode)
{
SceneObjectLight scl = (SceneObjectLight)sco;
if (scl)
{
lightSettingsWidget.hide();
mainController.ConnectRangeSlider(mainController.setLightParamAngle, scl.getLightAngle());
rangeSlider.MinValue = 1f;
rangeSlider.MaxValue = 179f;
}
}
break;
case 3:
if (mainController.ActiveMode == MainController.Mode.lightSettingsMode || mainController.ActiveMode == MainController.Mode.lookThroughLightMode)
{
SceneObjectLight scl = (SceneObjectLight)sco;
if (scl)
{
hideRangeSlider();
lightSettingsWidget.SetSliderType(LightSettingsWidget.SliderType.COLOR);
lightSettingsWidget.show(mainController.getCurrentSelection().GetComponent <SceneObjectLight>());
//mainController.buttonLightColorClicked(button.Toggled);
}
}
break;
}
}
