void _createRenderOnTopCamera()
{
//Create None DepthTest Camera, which is clear the depth buffer ,and render mesh on screen top.
GameObject camObj = new GameObject(VRCamera.name + "_RenderOnTop +" + _UnityRenderOnTopCamOrder);
camObj.transform.parent = null;
Vive.Plugin.SR.ViveSR_HMDCameraShifter shifter = camObj.AddComponent <Vive.Plugin.SR.ViveSR_HMDCameraShifter>();
GameObject eyeObj = new GameObject("eye");
eyeObj.transform.parent = camObj.transform;
eyeObj.transform.localPosition = Vector3.zero;
eyeObj.transform.localRotation = Quaternion.identity;
_UnityRenderOnTopCamera = eyeObj.AddComponent <Camera>();
_UnityRenderOnTopCamera.CopyFrom(VRCamera);
_UnityRenderOnTopCamera.cullingMask = (1 << UnityRenderOnTopLayer | 1 << UnityRenderOnTopNoShadowLayer);
_UnityRenderOnTopCamera.clearFlags = CameraClearFlags.Depth;
_UnityRenderOnTopCamera.depth = VRCamera.depth + _UnityRenderOnTopCamOrder;
//shifter.TargetCamera = _UnityRenderOnTopCamera;
bool setTargetCam = MyReflection.SetMemberVariable(shifter, "TargetCamera", _UnityRenderOnTopCamera);
if (!setTargetCam)
{
Debug.LogError("shifter.TargetCamera set fail..._UnityRenderOnTopCamera");
}
#if ADVANCE_RENDER
VRCamera.cullingMask = MyHelpLayer.RemoveMaskLayer(VRCamera.cullingMask, UnityRenderOnTopLayer);
VRCamera.cullingMask = MyHelpLayer.RemoveMaskLayer(VRCamera.cullingMask, UnityRenderOnTopNoShadowLayer);
#else
//We render AR top model on both camera(VRCamera&UnityRenderOnTopCamera), to produce shadow on VRCamera,
//and render on top layer to prevent culled by scanned mesh.
//So, we don't remove VRCamera's UnityRenderOnTop Layer
#endif
}
public void InitRenderSystem()
{
//Get realworld camera image
DualCameraL.clearFlags = CameraClearFlags.SolidColor;
DualCameraL.backgroundColor = Color.clear;
_dualCameraLRT = DualCameraL.gameObject.AddComponent <CopyCameraImage>();
_dualCameraLRT.rtRefreshCallback = LDualCamRTRefreshCallback;
DualCameraR.clearFlags = CameraClearFlags.SolidColor;
DualCameraR.backgroundColor = Color.clear;
_dualCameraRRT = DualCameraR.gameObject.AddComponent <CopyCameraImage>();
_dualCameraRRT.rtRefreshCallback = RDualCamRTRefreshCallback;
//Create None DepthTest Camera, which is clear the depth buffer ,and render mesh on screen top.
_createRenderOnTopCamera();
#if ADVANCE_RENDER
advanceRender.InitRenderSystem(_dualCameraLRT, _dualCameraRRT);
#endif
foreach (Transform t in unityrenderWithDepthObject)
{
MyHelpLayer.SetSceneLayer(t, ARRender.UnityRenderWithDepthLayer);
}
foreach (Transform t in unityrenderWithDepthNoShadowObject)
{
MyHelpLayer.SetSceneLayer(t, ARRender.UnityRenderWithDepthNoShadowLayer);
}
}
public void RecoverUnityrenderWithDepthLayer()
{
foreach (Transform t in unityrenderWithDepthObject)
{
MyHelpLayer.SetSceneLayer(t, UnityRenderWithDepthLayer);
}
}
public void SetUnityrenderWithDepthToTopLayer()
{
foreach (Transform t in unityrenderWithDepthObject)
{
MyHelpLayer.SetSceneLayer(t, UnityRenderOnTopLayer);
}
}
public void AddUnityrenderWithDepth(Transform t)
{
if (unityrenderWithDepthObject.IndexOf(t) < 0)
{
unityrenderWithDepthObject.Add(t);
MyHelpLayer.SetSceneLayer(t, UnityRenderWithDepthLayer);
}
}
IEnumerator _closeRenderAlphaWall()
{
yield return(new WaitForSeconds(4));
for (int a = 0; a < selectedWallRoot.transform.childCount; a++)
{
Transform child = selectedWallRoot.transform.GetChild(a);
ARRender.Instance.RemoveUnityrenderWithDepth(child);
MyHelpLayer.SetSceneLayer(child, ARRender.MRReconstructObjectLayer);
}
}
public void StartGarageSetting()
{
VivePoseTracker tracker = LiftMachine.GetComponent <VivePoseTracker>();
if (tracker.isPoseValid)
{
LiftMachine.position = tracker.transform.position;
}
//else if (recontructFloor != null && recontructFloor.transform.childCount > 0)
// LiftMachinePosition = recontructFloor.transform.GetChild(0).position;
else
{
LiftMachine.position = Vector3.zero;
}
if (ARRender.ADVANCE_RENDER)
{
//We only set PaintObject to render shadow to save shadow render performance
MyHelpLayer.ReplaceSceneLayer(LiftMachine, LayerMask.NameToLayer("Default"), ARRender.UnityRenderOnTopLayer);
MyHelpLayer.ReplaceSceneLayer(LiftMachine, LayerMask.NameToLayer("PaintObject"), ARRender.UnityRenderOnTopLayer);
}
else
{
MyHelpLayer.SetSceneLayer(LiftMachine, ARRender.UnityRenderOnTopLayer);
}
FixedWorldPosCover[] fwpcs = LiftMachine.GetComponentsInChildren <FixedWorldPosCover>();
foreach (FixedWorldPosCover fwpc in fwpcs)
{
fwpc.UpdateWorldMatrix();
// fwpc.GetComponent<Renderer>().sharedMaterial.SetTexture("_LeftEyeTexture", dualCameraLRT.GetRT());
// fwpc.GetComponent<Renderer>().sharedMaterial.SetTexture("_RightEyeTexture", dualCameraRRT.GetRT());
fwpc.GetComponent <Renderer>().sharedMaterial.SetFloat("_Transparent", 1);
}
Renderer[] renders = LiftMachine.GetComponentsInChildren <Renderer>(true);
foreach (Renderer r in renders)
{
r.enabled = true;
}
}
void RenderSystemUpdate()
{
if (deferredLightMap != null)
{
deferredLightMap.ClearAllLights();
foreach (GameObject lightObj in PointLightObjList)
{
if (!lightObj.activeSelf)
{
continue;
}
{
Light[] lights = lightObj.GetComponentsInChildren <Light>();
foreach (Light l in lights)
{
deferredLightMap.AddPointLight(l);
}
}
ParticleLights[] particleLights = lightObj.GetComponentsInChildren <ParticleLights>();
foreach (ParticleLights pl in particleLights)
{
if (pl.particleLightNode == null || !pl.particleLightNode.activeSelf)
{
continue;
}
Light[] lights = pl.particleLightNode.GetComponentsInChildren <Light>();
foreach (Light l in lights)
{
deferredLightMap.AddPointLight(l);
}
}
}
foreach (GameObject lightObj in SpotLightObjList)
{
if (!lightObj.activeInHierarchy)
{
continue;
}
Light[] lights = lightObj.GetComponentsInChildren <Light>();
foreach (Light l in lights)
{
deferredLightMap.AddSpotLight(l);
}
}
}
//Alpha blend object render with depth
if (_UnityRenderWithDepthCamera == null)
{
GameObject camObj = new GameObject(ARRender.Instance.VRCamera.name + "_WithDetpth +" + _UnityRenderWithDepthCamOrder);
camObj.transform.parent = null;
Vive.Plugin.SR.ViveSR_HMDCameraShifter shifter = camObj.AddComponent <Vive.Plugin.SR.ViveSR_HMDCameraShifter>();
GameObject eyeObj = new GameObject("eye");
eyeObj.transform.parent = camObj.transform;
eyeObj.transform.localPosition = Vector3.zero;
eyeObj.transform.localRotation = Quaternion.identity;
_UnityRenderWithDepthCamera = eyeObj.AddComponent <Camera>();
_UnityRenderWithDepthCamera.CopyFrom(ARRender.Instance.VRCamera);
_UnityRenderWithDepthCamera.cullingMask = 1 << ARRender.UnityRenderWithDepthLayer | 1 << ARRender.UnityRenderWithDepthNoShadowLayer;
_UnityRenderWithDepthCamera.clearFlags = CameraClearFlags.Nothing;
_UnityRenderWithDepthCamera.depth = ARRender.Instance.VRCamera.depth + _UnityRenderWithDepthCamOrder;
ARRender.Instance.VRCamera.cullingMask =
MyHelpLayer.RemoveMaskLayer(ARRender.Instance.VRCamera.cullingMask, ARRender.UnityRenderWithDepthLayer);
ARRender.Instance.VRCamera.cullingMask =
MyHelpLayer.RemoveMaskLayer(ARRender.Instance.VRCamera.cullingMask, ARRender.UnityRenderWithDepthNoShadowLayer);
//shifter.TargetCamera = _UnityRenderWithDepthCamera;
bool setTargetCam = MyReflection.SetMemberVariable(shifter, "TargetCamera", _UnityRenderWithDepthCamera);
if (!setTargetCam)
{
Debug.LogError("shifter.TargetCamera set fail..._UnityRenderWithDepthCamera");
}
}
}
public void InitRenderSystem(CopyCameraImage _dualCameraLRT, CopyCameraImage _dualCameraRRT)
{
//Set reconstruct mesh to ScanLiveMeshLayer if exist
Material reconMeshMat = new Material(Shader.Find("Unlit/Color"));
reconMeshMat.color = Color.white * 0.5f;
MeshRenderer[] reconMeshes = SRWorkControl.Instance.GetReconstructStaticMeshes();
if (reconMeshes != null)
{
foreach (MeshRenderer r in reconMeshes)
{
r.gameObject.layer = ScanLiveMeshLayer;
r.gameObject.GetComponent <MeshRenderer>().sharedMaterial = reconMeshMat;
r.GetComponent <MeshFilter>().mesh.RecalculateNormals();//must RecalculateNormals since original normal is wrong
}
}
//-------------------------------------------------------------------------------------------------
//Add culling processor
//-------------------------------------------------------------------------------------------------
_renderLivemeshDepthN = ARRender.Instance.VRCamera.gameObject.AddComponent <CameraRenderRT>();
_renderLivemeshDepthN.RTType = CameraRenderRT.RTTYPE.FLOAT4;
_renderLivemeshDepthN.RenderShader = ScanLiveMeshShaderDepthNormal;
_renderLivemeshDepthN.cullMask = 1 << ScanLiveMeshLayer;
_renderLivemeshDepthN.clearColor = Color.white;
_renderLivemeshDepthN.blurHMaterial = new Material(blurHMaterial);
_renderLivemeshDepthN.blurVMaterial = new Material(blurVMaterial);
_renderLivemeshDepthN.BlurFactor = 3f;// 2.7f;//0 turn off blur
_renderLivemeshDepthN.Init();
//VRCamera.cullingMask = VRCamera.cullingMask & ~(1 << ScanLiveMeshLayer);//Not render 'LiveMesh' in vr camera
ARRender.Instance.VRCamera.cullingMask = MyHelpLayer.RemoveMaskLayer(ARRender.Instance.VRCamera.cullingMask, ScanLiveMeshLayer);
ARRender.Instance.VRCamera.clearFlags = CameraClearFlags.Color;
ARRender.Instance.VRCamera.backgroundColor = new Color(0, 0, 0, 0);
//Add dilation for later pass 'DownSample' not sample outter edge's black color.
Dilation dilation = ARRender.Instance.VRCamera.gameObject.AddComponent <Dilation>();
dilation.dilateCount = 2;
dilation.dilateMaskShader = dilateMaskShader;
dilation.genBinaryMaskShader = genBinaryMaskShader;
dilation.refineGBufferShader = refineGBufferShader;
//Add down sample for matching the low resolution see through camera.
RTDownSample downsample = _createCameraFilter <RTDownSample>() as RTDownSample;
downsample.DownScale = 3;
//Render block pattern for simulate noise for matching low resolution see through camera.
CamFilterDrawBlocks drawblocks = _createCameraFilter <CamFilterDrawBlocks>() as CamFilterDrawBlocks;
drawblocks.Fade = 0.003f;
CopyCameraDepthColor vrdepth = ARRender.Instance.VRCamera.gameObject.AddComponent <CopyCameraDepthColor>();
vrdepth.CopyCameraDepthColorMaterial = CopyCameraDepthColorMaterial;
#if USE_MERGE_DEPTH
MergeDepth mergeDepth = ARRender.Instance.VRCamera.gameObject.AddComponent <MergeDepth>();
mergeDepth.cameraRenderRT = _renderLivemeshDepthN.RT;
mergeDepth.mergeDepthMat = MergeDepthMat;
mergeDepth.copyCameraColorDepth = vrdepth;
#endif
SoftEdgeWeight softEdgeWeight = ARRender.Instance.VRCamera.gameObject.AddComponent <SoftEdgeWeight>();
softEdgeWeight.renderDepth = _renderLivemeshDepthN;
softEdgeWeight.SoftEdgeWeightMaterial = softEdgeWeightMaterial;
softEdgeWeight.factor = 2f;
RenderWithARDepth renderWithARDepth = ARRender.Instance.VRCamera.gameObject.AddComponent <RenderWithARDepth>();
renderWithARDepth.RenderWithARDepthMaterial = RenderWithARDepthMaterial;
renderWithARDepth.MRDepthNormal = _renderLivemeshDepthN.RT;
renderWithARDepth.VRCamera = vrdepth;
renderWithARDepth.softCullLength = 0.0001f;
renderWithARDepth.glowAmount = 0.018f;
renderWithARDepth.coefAmount = 0.062f;
renderWithARDepth.seeThroughL = _dualCameraLRT;
renderWithARDepth.seeThroughR = _dualCameraRRT;
renderWithARDepth.softEdgeWeight = softEdgeWeight;
renderWithARDepth.CullingBaise = 0.000017f;//1.7e-05
//-------------------------------------------------------------------------------------------------
//Add shadow processor
//-------------------------------------------------------------------------------------------------
ARRender.Instance.shadowCastDirLight.transform.position = ARRender.Instance.VRCamera.transform.position;
ShadowRecieve shadowRecieve = ARRender.Instance.VRCamera.gameObject.AddComponent <ShadowRecieve>();
shadowRecieve.ScreenMapScale = 0.5f;
shadowRecieve.shadowLight = ARRender.Instance.shadowCastDirLight;
shadowRecieve.screenShadowBlit = screenShadowBlit;
// shadowRecieve.blurMaterial = shadowBlur;
shadowRecieve.blurHMaterial = new Material(blurHMaterial);
shadowRecieve.blurVMaterial = new Material(blurVMaterial);
shadowRecieve.BlurFactor = 3;
shadowRecieve.ShadowFactor = 10;
shadowRecieve.VRDepthColor = vrdepth;//set VR scene depth for screen shadow culling (no need recieve mesh's depth)
shadowRecieve.cameraDepthN = _renderLivemeshDepthN.RT;
//shadowRecieve.recieveShadowLayer = (1 << ScanLiveMeshLayer);
GameObject shadowCastCameraObj = Instantiate(shadowCastCameraPrefab);
shadowCastCameraObj.transform.parent = ARRender.Instance.shadowCastDirLight.transform;
ShadowCastCamera shadowCastCamera = shadowCastCameraObj.GetComponent <ShadowCastCamera>();
shadowCastCamera.GetComponent <Camera>().orthographicSize = 4; //4 is enough
shadowCastCamera.shadowMapSize = 400;
//cast shadow for default layer
shadowCastCamera.shadowRenderMask = shadowCastMask;
//shadowRecieve.shadowColor = Color.white * 50f / 255f;
shadowRecieve.bais = 0;
shadowRecieve.shadowBlitBais = 0;
//-------------------------------------------------------------------------------------------------
//Add point light processor
//-------------------------------------------------------------------------------------------------
deferredLightMap = ARRender.Instance.VRCamera.gameObject.AddComponent <DeferredLightMap>();
deferredLightMap.DeferredPointLightMapMaterial = DeferredPointLightMapMaterial;
deferredLightMap.DeferredSpotLightMapMaterial = DeferredSpotLightMapMaterial;
deferredLightMap.BlitLightMapMaterial = BlitLightMapMaterial;
deferredLightMap.LightMapFactor = 0.2f;
//deferredLightMap.mergeDepth = mergeDepth;
deferredLightMap.cameraRenderDepthNormal = _renderLivemeshDepthN.RT; //not use merge depth, since game objects use unity lighting.
deferredLightMap.TurnOffUnityLight = false; //Dont' turn off unity light, because current time my deferred lighting is not concern normal, and I need unity lighting to render object.
//-------------------------------------------------------------------------------------------------
//write Depth Camera and render alpha object
//-------------------------------------------------------------------------------------------------
GameObject writeDepthCameraRoot = new GameObject(ARRender.Instance.VRCamera.name + "_writeDepth +" + _writeDepthCamLOrder);
writeDepthCameraRoot.transform.parent = null;
Vive.Plugin.SR.ViveSR_HMDCameraShifter shifter = writeDepthCameraRoot.AddComponent <Vive.Plugin.SR.ViveSR_HMDCameraShifter>();
writeDepthCameraRoot.transform.position = Vector3.zero;
writeDepthCameraRoot.transform.rotation = Quaternion.identity;
GameObject writeDepthCameraObj = Instantiate(writeDepthCameraPrefab);
writeDepthCameraObj.transform.parent = writeDepthCameraRoot.transform;
writeDepthCameraObj.transform.localPosition = Vector3.zero;
writeDepthCameraObj.transform.localRotation = Quaternion.identity;
_writeDepthCamera = writeDepthCameraObj.GetComponent <Camera>();
_writeDepthCamera.depth = ARRender.Instance.VRCamera.depth + _writeDepthCamLOrder;
_writeDepthCamera.name = _writeDepthCamera.name + " +" + _writeDepthCamLOrder;
_writeDepth = _writeDepthCamera.GetComponent <WriteDepthPerspective>();
_writeDepth.mainCam = ARRender.Instance.VRCamera;
_writeDepth.addShiftR = 0.00145f; //0.00807f;
_writeDepth.addShiftUP = -0.00005f;; // -0.0001f;
_writeDepth.Init(0);
//_writeDepth.IsRenderRightEye = null;
//shifter.TargetCamera = _writeDepthCamera;
bool setTargetCam = MyReflection.SetMemberVariable(shifter, "TargetCamera", _writeDepthCamera);
if (!setTargetCam)
{
Debug.LogError("shifter.TargetCamera set fail..._writeDepthCamera");
}
#if USE_MERGE_DEPTH
_writeDepth.mergeDepth = mergeDepth;
#else
_writeDepth.cameraDepth = renderLiveMeshDepthN.RT;
#endif
ARRender.Instance.shadowCastDirLight.shadowBias = 0.02f;
}
public static GameObject SetPivotInMeshCenter(Transform tran, Mesh mesh,
Transform parentNode, Material colliderMaterial, string name, Vector3 normal, Vector3 position)
{
//Duplicate my wall
GameObject wall = new GameObject(name);// current.colliderMesh.name + " : " + current.area);
wall.isStatic = true;
wall.transform.parent = parentNode;
//Set pivot in mesh center
// Transform tran = current.colliderMesh.transform;
// Mesh mesh = current.colliderMesh.sharedMesh;
/*Vector3[] newVert = new Vector3[mesh.vertices.Length];
* for (int b = 0; b < mesh.vertices.Length; b++)
* {
* newVert[b] = tran.TransformPoint(mesh.vertices[b]) - current.meshCenter;//move pos in world space
* newVert[b] = tran.InverseTransformPoint(newVert[b]);//set vertex to local space
* }*/
Matrix4x4 origMatrix = tran.localToWorldMatrix;
wall.transform.position = position;// current.meshCenter;
wall.transform.rotation = (normal == Vector3.zero) ? Quaternion.identity : Quaternion.LookRotation(normal /*current.avgNormalWorld*/, Vector3.up);
wall.transform.localScale = Vector3.one;
Matrix4x4 newMatrix = wall.transform.localToWorldMatrix;
Matrix4x4 offsetMat = Matrix4x4.Inverse(origMatrix) * newMatrix;
Vector3[] newVert = new Vector3[mesh.vertices.Length];
for (int b = 0; b < mesh.vertices.Length; b++)
{
newVert[b] = offsetMat.inverse.MultiplyPoint(mesh.vertices[b]);
}
////Set normal for collider
//Vector3[] newVertNormal = new Vector3[newVert.Length];
//for (int b = 0; b < mesh.triangles.Length; b++)
//{
// newVertNormal[mesh.triangles[b]] += current.triNormal[b % 3];
// newVertNormal[mesh.triangles[b]] *= 0.5f;
// newVertNormal[mesh.triangles[b]].Normalize();
//}
Mesh newM = new Mesh();
newM.name = mesh.name;
newM.vertices = newVert;
// newM.normals = newVertNormal;//The supplied array needs to be the same size as the Mesh.vertices array.
newM.uv = null;
newM.SetTriangles(mesh.triangles, 0);
newM.RecalculateNormals();
MeshFilter newMF = wall.AddComponent <MeshFilter>();
newMF.sharedMesh = newM;
//MeshCollider newMC = wall.AddComponent<MeshCollider>();
//newMC.convex = true;
//newMC.gameObject.isStatic = true;
if (colliderMaterial != null)
{
MeshRenderer newMR = wall.AddComponent <MeshRenderer>();
newMR.material = colliderMaterial;
}
wall.layer = ARRender.MRReconstructObjectLayer;
ARRender.Instance.VRCamera.cullingMask = MyHelpLayer.RemoveMaskLayer(ARRender.Instance.VRCamera.cullingMask, ARRender.MRReconstructObjectLayer);
return(wall);
}
public void AutoPickFloor()
{
List <MeshSizeData> meshSizeDataList;
List <MeshCollider> ignoreList;
_getPlanesByMaxArea(reconstructConvexCollidersHorizontal, out meshSizeDataList, out ignoreList);
//if (recontructTable != null)
// Destroy(recontructTable);
//recontructTable = new GameObject("RecontructTable");
if (recontructFloor != null)
{
Destroy(recontructFloor);
}
recontructFloor = new GameObject("RecontructFloor");
if (floorPlaneObj != null)
{
Destroy(floorPlaneObj);
}
if (floorPlaneObjCollider != null)
{
Destroy(floorPlaneObjCollider);
}
//Get the lowest is the floor and y must -0.5~0.5
MeshSizeData lowestMesh = null;
float lowestD = 9999f;
for (int a = 0; a < meshSizeDataList.Count; a++)
{
if (a >= 3)
{
break;
}
MeshSizeData current = meshSizeDataList[a];
if (current.meshCenterWorld.y < lowestD)
{
//if (-0.6f < current.meshCenterWorld.y && current.meshCenterWorld.y < 0.6f)
{
lowestD = current.meshCenterWorld.y;
lowestMesh = current;
}
}
}
if (lowestMesh != null)
{
GameObject floorConvexObj = SetPivotInMeshCenter(
lowestMesh.colliderMesh.transform,
lowestMesh.colliderMesh.sharedMesh,
recontructFloor.transform,
null,
lowestMesh.colliderMesh.name + "_convex : " + lowestMesh.area,
lowestMesh.avgNormalWorld,
lowestMesh.meshCenterWorld);
meshSizeDataList.Remove(lowestMesh);
//Add floor quad for shadow rendering
foreach (MeshCollider mc in reconstructQuadCollidersHorizontal)
{
string namesQuad = mc.name.Remove(0, mc.name.IndexOf('_') + 1);
string namesConvex = lowestMesh.colliderMesh.name.Remove(0, lowestMesh.colliderMesh.name.IndexOf('_') + 1);
if (namesQuad == namesConvex)
{
//Vector3[] planeTriNormal;
//Vector3 AVGNormalWorld = -_getAVGNormalLocal(mc.sharedMesh, mc.transform, out planeTriNormal);
Vector3 center = mc.transform.TransformPoint(_getMeshCenter(mc.sharedMesh));
//GameObject floorPlaneObj = SetPivotInMeshCenter(mc.transform, mc.sharedMesh,
// floorConvexObj.transform, floorColliderMaterial,
// lowestMesh.colliderMesh.name + "_quadFloor",
// AVGNormalWorld, center);
floorPlaneObj = GameObject.CreatePrimitive(PrimitiveType.Plane);
floorPlaneObj.name = lowestMesh.colliderMesh.name + "_quadFloor";
floorPlaneObj.transform.parent = floorConvexObj.transform;
floorPlaneObj.transform.position = center;
floorPlaneObj.transform.rotation = Quaternion.identity;
floorPlaneObj.transform.localScale = Vector3.one * 2;
//SRWork 0.7.5.0 use scan mesh collider
floorPlaneObj.isStatic = true;
floorPlaneObj.layer = AdvanceRender.ScanLiveMeshLayer;
if (ARRender.ADVANCE_RENDER)
{
//In advance render floorPlaneObj is for render, so, we clone a new one for collision
floorPlaneObjCollider = GameObject.Instantiate(floorPlaneObj);
floorPlaneObjCollider.layer = AdvanceRender.MRCollisionFloorLayer;
floorPlaneObjCollider.transform.position = floorPlaneObj.transform.position;
floorPlaneObjCollider.transform.rotation = floorPlaneObj.transform.rotation;
ARRender.Instance.VRCamera.cullingMask = MyHelpLayer.RemoveMaskLayer(ARRender.Instance.VRCamera.cullingMask, AdvanceRender.MRCollisionFloorLayer);
}
else
{
floorPlaneObj.GetComponent <MeshRenderer>().sharedMaterial = new Material(Shader.Find("ViveSR/MeshCuller, Shadowed, Stencil"));
//floorPlaneObj.GetComponent<MeshRenderer>().enabled = false;
}
break;
}
}
//SRWork0.7.5.0 ConvexColliders default is turn off
//turn off the original convex mesh's collider
//foreach (MeshCollider mc in reconstructConvexCollidersHorizontal)
//{
// string namesA = mc.name.Remove(0, mc.name.IndexOf('_') + 1);
// string namesB = lowestMesh.colliderMesh.name.Remove(0, lowestMesh.colliderMesh.name.IndexOf('_') + 1);
// //namesA = namesA.Remove(0, namesA.IndexOf('_'));//srwork 0.7 without '_' again
// //namesB = namesB.Remove(0, namesB.IndexOf('_'));
// if (namesA == namesB)
// {
// mc.transform.gameObject.SetActive(false);
// }
//}
}
else
{
Debug.LogWarning("[reconstructPickFloor] there are no reconstruct floor picked...");
}
/*
* //Get the highest is the table
* MeshSizeData highestMesh = null;
* float highestD = -9999f;
* for (int a = 0; a < meshSizeDataList.Count; a++)
* {
* if (a >= 10)
* break;
* MeshSizeData current = meshSizeDataList[a];
* if (current.meshCenterWorld.y > highestD &&
* current.meshCenterWorld.y < VRCamera.transform.position.y//must not higher then player's head
* )
* {
* highestD = current.meshCenterWorld.y;
* highestMesh = current;
* }
* }
* if (highestMesh != null)
* {
* SetPivotInMeshCenter(highestMesh.colliderMesh.transform, highestMesh.colliderMesh.sharedMesh,
* recontructTable.transform, tableColliderMaterial,
* highestMesh.colliderMesh.name + "_convex : " + highestMesh.area,
* highestMesh.avgNormalWorld,
* highestMesh.meshCenterWorld);
* meshSizeDataList.Remove(highestMesh);
* }
* else
* Debug.LogWarning("[reconstructPickFloor] there are no reconstruct table picked...");
*/
}
public void UpdateState()
{
if (manager.PadTouchL)
{
robotController.TurnLeft();
}
else if (manager.PadTouchR)
{
robotController.TurnRight();
}
if (manager.PadKeyUp)
{
robotController.Stop();
}
if (manager.PadPressL && manager.PadIsFirstPress ||
manager.PadPressR && manager.PadIsFirstPress)
{
robotController.SwitchDiscoLight();
}
if (robotController.GetDiscoLightRoot().gameObject.activeSelf)
{
MyHelpLayer.SetSceneLayer(robotController.GetDiscoLightRoot(), ARRender.UnityRenderWithDepthNoShadowLayer);
}
if (manager.PadPressUpward)
{
//robotController.MoveForwrad();
robotController.stallHigh += Time.deltaTime * 0.9f;
robotController.stallHigh = Mathf.Clamp(robotController.stallHigh, 0.5f, 10);
}
else if (manager.PadPressDownward)
{
//robotController.MoveBack();
robotController.stallHigh -= Time.deltaTime * 0.9f;
robotController.stallHigh = Mathf.Clamp(robotController.stallHigh, 0.5f, 10);
}
float triggerRatio = ViveInput.GetTriggerValue(HandRole.RightHand);
if (triggerRatio > 0)
{
if (robotController != null)
{
robotController.MoveForwrad(triggerRatio);
}
//Debug.Log("tvalue : " + tvalue);
}
if (GameManager.Instance.ViveIsGrip())
{
manager.SwitchState(GameStateManager.GameState.GARAGE);
}
//Recover to idle state
if (ViveInput.GetPressUp(HandRole.RightHand, ControllerButton.Trigger) ||
triggerRatio < 0.01f)
{
robotController.Stop();
}
}
public void RecoverFishToDefaultLayer()
{
MyHelpLayer.ReplaceSceneLayer(fishAI.transform, ARRender.UnityRenderOnTopNoShadowLayer, LayerMask.NameToLayer("Default"));
MyHelpLayer.ReplaceSceneLayer(fishAI.transform, ARRender.UnityRenderOnTopLayer, LayerMask.NameToLayer("PaintObject"));
ARRender.Instance.RecoverUnityrenderWithDepthLayer();
}
public void SetFishToRenderTop()
{
MyHelpLayer.ReplaceSceneLayer(fishAI.transform, LayerMask.NameToLayer("Default"), ARRender.UnityRenderOnTopNoShadowLayer);
MyHelpLayer.ReplaceSceneLayer(fishAI.transform, LayerMask.NameToLayer("PaintObject"), ARRender.UnityRenderOnTopLayer);
ARRender.Instance.SetUnityrenderWithDepthToTopLayer();
}
public void StartPaintBallWallGame()
{
//if (PaintBallWallGameSizePlaneOrigScale == null)
// PaintBallWallGameSizePlaneOrigScale = PaintBallWallGameSizePlane.lossyScale.z;
float origW = measureSizeQuad.transform.lossyScale.x; //2.8f;// original W, H is 2.8 , 1.6
origW = origW * 3f / 7f; // 3x2 block size of 7x4 size
Vector3 newNearPoint, newFarPoint;
//PaintBallWallGameObj.SetActive(true);
Debug.LogWarning("[StartPaintBallWallGame]");
float localScale = 1;
Transform fishHidingWall = fishAI.fishHidingWall;
if (fishHidingWall == null)
{
fishHidingWall = ReconstructManager.Instance.selectedWallRoot.transform.GetChild(0);
}
//float areaQuadMax, areaQuadMin;
//Mesh quadMesh = fishHidingWall.GetChild(0).GetComponent<MeshFilter>().sharedMesh;
Mesh quadMesh = fishHidingWall.GetComponent <MeshFilter>().sharedMesh;
Transform quadTransform = fishHidingWall;//.GetChild(0);
float destW = 0;
if (fishHidingWall != null)
{
PaintBallWallGameLocation.position = fishHidingWall.position;
//PaintBallWallGameLocation.rotation = fishHidingWall.rotation;
PaintBallWallGameLocation.LookAt(
fishHidingWall.position + GetFaceToPlayerNormal(fishHidingWall.position, fishHidingWall.forward),
Vector3.up);
//Fit quad align with height
//Because the game quad is W:(10m*0.7), H:(10m*0.4), so fit the height with quadMesh's height
/*areaQuadMax = -9999;
* areaQuadMin = 9999f;
* foreach (Vector3 vec in quadMesh.vertices)
* {
* //Z is the width
* Vector3 vecWorld = fishHidingWall.TransformPoint(vec);
* if (vecWorld.z > areaQuadMax)
* areaQuadMax = vecWorld.z;
* if (vecWorld.z < areaQuadMin)
* areaQuadMin = vecWorld.z;
* }*/
List <Vector3> widthList = new List <Vector3>();
for (int a = 0; a < quadMesh.vertices.Length; a++)// ( in quadMesh.vertices)
{
Vector3 vec = quadMesh.vertices[a];
vec = quadTransform.TransformPoint(vec);
vec.y = 0;
widthList.Add(vec);
}
MyHelpMesh.GetLongestLineFromVertices(widthList, null, out newNearPoint, out newFarPoint);
destW = (newNearPoint - newFarPoint).magnitude;
localScale = destW / origW; //Z is the width
//Furthermore consider the area ratio
float areaQuad = ReconstructManager.GetMeshArea(quadMesh);
float areaConvex = ReconstructManager.GetMeshArea(fishHidingWall.GetComponent <MeshFilter>().sharedMesh);
localScale *= areaConvex / areaQuad;
}
trackerOfMRWall.position = PaintBallWallGameLocation.position + PaintBallWallGameLocation.forward * 0.01f;
Vector3 lookForward = PaintBallWallGameLocation.forward;
lookForward.y = 0;
trackerOfMRWall.LookAt(PaintBallWallGameLocation.position + lookForward.normalized, Vector3.up);
localScale = Mathf.Clamp(localScale * 0.8f, 0.1f, 1.2f);//limit the max size
trackerOfMRWall.localScale = Vector3.one * localScale;
//Get the top offset to align with top edge
//areaQuadMax = -9999;
//areaQuadMin = 9999f;
//foreach (Vector3 vec in quadMesh.vertices)
//{
// //X is the height
// Vector3 vecWorld = quadTransform.TransformPoint(vec);
// if (vecWorld.y > areaQuadMax)
// areaQuadMax = vecWorld.y;
// if (vecWorld.y < areaQuadMin)
// areaQuadMin = vecWorld.y;
//}
List <Vector3> heightList = new List <Vector3>();
for (int a = 0; a < quadMesh.vertices.Length; a++)// ( in quadMesh.vertices)
{
Vector3 vec = quadMesh.vertices[a];
vec = quadTransform.TransformPoint(vec);
vec.x = 0;
vec.z = 0;
heightList.Add(vec);
}
//float destH = areaQuadMax - areaQuadMin;
MyHelpMesh.GetLongestLineFromVertices(heightList, null, out newNearPoint, out newFarPoint);
float destH = (newNearPoint - newFarPoint).magnitude;
float origH = measureSizeQuad.transform.lossyScale.y; //1.6f * localScale;// original W, H is 2.8 , 1.6
origH = origH * 2f / 4f; // 3x2 block size of 7x4 size
float offsetH = (destH - origH) * 0.5f;
//float ratio = destH / destW;
trackerOfMRWall.position = new Vector3(trackerOfMRWall.position.x, trackerOfMRWall.position.y + offsetH * 0.6f, trackerOfMRWall.position.z);
//set health position
Vector3 dir = PaintBallWallGameLocation.position - ARRender.Instance.VRCamera.transform.position;
dir.y = 0;
dir.Normalize();
// float length = dir.magnitude;
trackerOfHealth.position = ARRender.Instance.VRCamera.transform.position + dir * 1f;
trackerOfHealth.LookAt(ARRender.Instance.VRCamera.transform, Vector3.up);
ARRender.Instance.AddUnityrenderWithDepth(trackerOfHealth);
if (ARRender.ADVANCE_RENDER)
{
//We only set PaintObject to render shadow to save shadow render performance
MyHelpLayer.ReplaceSceneLayer(trackerOfMRWall, LayerMask.NameToLayer("Default"), ARRender.UnityRenderOnTopNoShadowLayer);
MyHelpLayer.ReplaceSceneLayer(trackerOfMRWall, LayerMask.NameToLayer("PaintObject"), ARRender.UnityRenderOnTopLayer);
}
else
{
MyHelpLayer.SetSceneLayer(trackerOfMRWall, ARRender.UnityRenderOnTopLayer);
}
paintBallStateManger.SetState((int)PaintBallStateManager.PaintBallStateEnum.WAIT_USER_TRIGGER);
MRWallManager.instance.ResetMRWall();
//Set directional light
ARRender.Instance.SetDirectionalLight(fishHidingWall);
}